From b89ceede596827d4dd234e4a74e0f4979d6bfee1 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 16:24:00 +0200 Subject: [PATCH 01/34] docs: add plan for ingesting PL conference proceedings Captures the gap surfaced by Hutchins POPL 2010 (paper never on arxiv) and proposes a DBLP + OpenAlex pipeline covering POPL, PLDI, ICFP, OOPSLA, ESOP, ECOOP, CC, and Haskell Symposium. Also sketches a SourcePoller registry so PL ingest folds into a single `oversight sync` command rather than a per-source CLI. Co-Authored-By: Claude Opus 4.7 (1M context) --- docs/pl-conferences-plan.md | 190 ++++++++++++++++++++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 docs/pl-conferences-plan.md diff --git a/docs/pl-conferences-plan.md b/docs/pl-conferences-plan.md new file mode 100644 index 0000000..3b5d342 --- /dev/null +++ b/docs/pl-conferences-plan.md @@ -0,0 +1,190 @@ +# Plan: ingest PL conference proceedings + +## Motivation + +The arxiv-CS harvester misses any paper that was never deposited on arxiv. +`Pure Subtype Systems` (Hutchins, POPL 2010) is the canonical example: the +paper is foundational PL work but exists only in the ACM Digital Library and +the author's PhD thesis. arxiv-only ingest will never see it. + +A measurable chunk of the PL community publishes only in proceedings, so +filling that gap requires a second ingestion path that scrapes +proceedings directly. arxiv preprints already cover ~9.7k cs.PL papers in +the database; the goal here is to add the ~10–15k papers that exist only +behind ACM/Springer/LIPIcs DOIs. + +## Conferences in scope + +### Tier 1 — SIGPLAN flagship (PACMPL since 2017) + +| Venue | Full name | Years | Volume | +|---|---|---|---| +| POPL | Principles of Programming Languages | 1973– | ~3,000 papers | +| PLDI | Programming Language Design & Implementation | 1979– | ~2,800 | +| ICFP | International Conference on Functional Programming | 1996– | ~1,200 | +| OOPSLA | Object-Oriented Programming, Systems, Languages, Apps (SPLASH) | 1986– | ~2,500 | + +### Tier 2 — also clearly PL + +| Venue | Full name | Years | Volume | +|---|---|---|---| +| ESOP | European Symposium on Programming (ETAPS) | 1986– | ~1,200 | +| ECOOP | European Conference on OO Programming (LIPIcs ≥2018) | 1987– | ~1,000 | +| CC | Compiler Construction (ACM, co-located with CGO) | 1986– | ~900 | +| Haskell Symposium | (co-located with ICFP) | 2007– | ~250 | + +## Data sources + +Both free, no auth, no realistic rate limits: + +1. **DBLP** — canonical, exhaustive paper list per venue/year. + Per-volume JSON endpoint: `https://dblp.org/db/conf/popl/popl2024.json`. + Provides title, authors, DOIs, year. **No abstracts.** + +2. **OpenAlex** — abstracts, affiliations, references, citations. + DOI lookup: `https://api.openalex.org/works/https://doi.org/`. + Returns abstract as inverted index (reconstruct in client). + ~100k req/day per identified email — well above what we need. + +### Fallbacks for missing abstracts + +OpenAlex coverage of these venues is essentially 100%, but pre-2017 ACM +papers occasionally have empty abstracts in Crossref. In order: + +1. **Semantic Scholar API** — `https://api.semanticscholar.org/graph/v1/paper/DOI:?fields=abstract,authors,year`. Filled in for ~all PL papers, including pre-2017. +2. **ACM Digital Library scrape** — landing page metadata is open even when full text is paywalled. Last resort; brittle. +3. **Skip** — log and move on. A title-only record is worse than no record because it pollutes search results without semantic signal. + +## JSON output format + +Reuse the existing `scraped` shape consumed by `Paper.from_scraped_json` +(`src/oversight/Paper.py:111`). Minimal required fields: + +```json +{ + "paper_id": "10.1145/1706299.1706334", + "title": "Pure Subtype Systems", + "abstract": "We present a new approach to type theory called pure subtype systems...", + "date": "2010-01-17", + "link": "https://dl.acm.org/doi/10.1145/1706299.1706334", + "conference_name": "POPL", + "authors": [ + { "first_name": "DeLesley", "last_name": "Hutchins", "institution": "MZA Associates" } + ] +} +``` + +`paper_id` should be the DOI when available — it's globally unique and +stable. Use `--` only when no DOI exists. + +## New components + +### 1. `PLConferenceHarvester.py` + +Modeled on `OpenReviewHarvester.py`. Responsibilities: + +- Take `(venue, year)` pairs. +- Fetch DBLP TOC for that volume. +- For each entry: fetch OpenAlex by DOI, fall back to Semantic Scholar, fall back to ACM scrape, fall back to skip-with-log. +- Emit one JSON file per (venue, year) at `data/pl_conferences//.json`. + +### 2. Source registry + unified sync + +The current sync surface has grown organically: +`make oversight/sync` runs only arxiv, and conference ingestion is manual. +Replace this with a registry of source-pollers and a single `oversight sync` +command. (The user pushed back on per-source commands — this addresses it.) + +```python +# Sketch +SOURCES = { + "arxiv": ArxivPoller(), # daily incremental, OAI-PMH cs:cs + "ml": MLConfPoller(), # OpenReview venues (NeurIPS/ICLR/ICML/MLSys) + "systems": SystemsConfPoller(), # OSDI/SOSP/ASPLOS/EuroSys/ATC/NSDI/VLDB + "pl": PLConfPoller(), # POPL/PLDI/ICFP/OOPSLA/ESOP/ECOOP/CC/Haskell +} +``` + +CLI surface: + +| Command | Effect | +|---|---| +| `oversight sync` | All sources, incremental (only fetch what's newer than newest DB row per source). | +| `oversight sync --sources pl,ml` | Restrict to a subset. | +| `oversight sync --sources pl --backfill` | Ignore newest-date watermark; re-fetch entire venue history. One-shot bootstrap. | +| `oversight sync --dry-run` | Print what would be fetched/inserted. | + +Each poller implements: + +```python +class SourcePoller(Protocol): + name: str + def latest_in_db(self, db: PaperDatabase) -> date: ... + def fetch_since(self, since: date) -> Iterator[Paper]: ... + def fetch_all(self) -> Iterator[Paper]: ... # for --backfill +``` + +This integrates PL ingestion into the same daily cron as arxiv. The +incremental case for PL is "did a new POPL/PLDI/ICFP/OOPSLA volume drop +since the last run?" — typically `false`, so the marginal cost of +including it in the daily sync is one DBLP HEAD request per venue. + +### 3. Embedding pass + +No change required. `PaperDatabase.get_unembedded_conference_papers()` +already picks up any paper with `source != 'arxiv'` and a NULL embedding, +so PL papers will be embedded automatically on the next sync. + +## Implementation phases + +### Phase 1 — vertical slice (1–2 hrs) + +- [ ] `PLConferenceHarvester` hardcoded to POPL 2024 only. +- [ ] DBLP fetch → OpenAlex fetch → emit JSON. +- [ ] Manual `oversight consume data/pl_conferences/popl/2024.json --format scraped`. +- [ ] Verify search surfaces a known POPL 2024 paper. +- [ ] Verify the embedding pass runs over the new rows. + +Acceptance: `oversight search "separation logic" --sources POPL` returns +sensible results. + +### Phase 2 — back-catalogue (one-shot) + +- [ ] Expand to all Tier 1 + Tier 2 venues, all years DBLP has. +- [ ] Run `oversight sync --sources pl --backfill`. +- [ ] Embed everything (~10–15k new papers; budget for embedding API cost). +- [ ] Spot-check Hutchins POPL 2010 lands in the DB. + +### Phase 3 — sync refactor + +- [ ] Introduce `SourcePoller` protocol. +- [ ] Migrate arxiv, ML conferences, systems conferences, PL conferences into pollers. +- [ ] Single `oversight sync` command replaces `oversight/sync` makefile target. +- [ ] Cron runs `oversight sync` daily. + +## Scope estimate + +| Tier | Conferences | Total papers | Embedding cost (approx) | +|---|---|---:|---| +| 1 | POPL, PLDI, ICFP, OOPSLA | ~9,500 | low | +| 2 | ESOP, ECOOP, CC, Haskell | ~3,400 | low | + +Storage impact: at ~16 KB/paper average (current ratio), full Tier 1+2 +adds ~210 MB. Negligible against current 15 GB. + +## Risks and edge cases + +- **Pre-2017 ACM papers without abstracts in Crossref** — handled by + Semantic Scholar fallback. +- **DBLP TOC URL pattern changes** — fragile; pin to current scheme and + add a smoke test that fetches POPL 2024 on every CI run. +- **DOI collisions across venues** — shouldn't happen for proceedings, + but enforce uniqueness on `paper_id` (already a unique constraint). +- **Workshops co-located with main conferences** (PEPM with POPL, + TyDe with ICFP) — DBLP lists these as separate volumes. Decision: ignore + for now, revisit if users notice the gap. +- **Joint papers in arxiv + proceedings** — same paper, two `paper_id`s + (arxiv ID and DOI). Defer dedup until after Phase 2 lands. Once every + venue is in the database we can query actual title/author overlap and + quantify the duplication, then choose a dedup strategy with real + numbers rather than guesses. Don't pre-optimize before we have data. From c5b95e942c751af043cee044f4cd059715b47897 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 16:34:23 +0200 Subject: [PATCH 02/34] feat: add DBLP and OpenAlex clients for PL conference ingest Introduces PLConferenceHarvester, a per-(venue, year) ingester that pulls a volume's table of contents from DBLP (search API, since the per-volume JSON endpoint 404s for PACMPL) and enriches each entry via OpenAlex, with Semantic Scholar as the abstract fallback. Emits papers in the same "scraped" JSON shape the existing consume path reads, so no PaperRepository changes are needed. Hardcoded to ("popl", 2024) for the Phase 1 vertical slice; the constructor is already (venue, year) so Phase 2 can drive the full back-catalogue. Also gitignores the local API response cache directory. Co-Authored-By: Claude Opus 4.7 (1M context) --- .gitignore | 3 + src/oversight/PLConferenceHarvester.py | 464 +++++++++++++++++++++++++ 2 files changed, 467 insertions(+) create mode 100644 src/oversight/PLConferenceHarvester.py diff --git a/.gitignore b/.gitignore index 22ea41c..7a037ec 100644 --- a/.gitignore +++ b/.gitignore @@ -35,3 +35,6 @@ logs_runtime/ # Scraping src/superscraper/tools/.cache/ + +# Local API response cache (PL harvester etc.) +.cache/ diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py new file mode 100644 index 0000000..2c9d116 --- /dev/null +++ b/src/oversight/PLConferenceHarvester.py @@ -0,0 +1,464 @@ +"""Harvester for programming-languages conference proceedings. + +Fetches a venue/year volume from DBLP, looks up abstracts and author +affiliations from OpenAlex (with a Semantic Scholar fallback), and emits +papers in the ``scraped`` JSON shape consumed by +:meth:`oversight.Paper.Paper.from_scraped_json`. + +Currently hardcoded to ``("popl", 2024)`` — the (venue, year) constructor +parameters are present so Phase 2 can drive the full back-catalogue without +touching the implementation. See ``docs/pl-conferences-plan.md``. +""" + +from __future__ import annotations + +import json +import logging +import time +from pathlib import Path +from typing import Any, Iterable + +import requests + +logger = logging.getLogger(__name__) + + +# DBLP returns ``Proc. ACM Program. Lang.`` (PACMPL) for POPL/PLDI/ICFP/OOPSLA +# from 2017 onwards. ``number`` discriminates the issue (e.g. "POPL"). +_PACMPL_ISSUES = { + "popl": "POPL", + "pldi": "PLDI", + "icfp": "ICFP", + "oopsla": "OOPSLA", +} + +# Friendly conference label written into the ``conference_name`` field of the +# emitted JSON (and ultimately the ``source`` column in the database). +_CONFERENCE_LABEL = { + "popl": "POPL", + "pldi": "PLDI", + "icfp": "ICFP", + "oopsla": "OOPSLA", +} + +_USER_AGENT = "oversight/0.1 (https://github.com/charlielidbury/oversight)" +_OPENALEX_MAILTO = "charlie.lidbury@icloud.com" + + +class PLConferenceHarvester: + """Harvest a single (venue, year) volume into a ``scraped``-format JSON file. + + Parameters + ---------- + venue: + Lowercase venue slug, e.g. ``"popl"``. + year: + Four-digit year of the volume. + output_dir: + Directory under which ``/.json`` will be written. + cache_dir: + Optional directory for caching OpenAlex / Semantic Scholar responses + across reruns. Created on demand. Use a path inside ``.cache/`` so it + stays out of git. + request_delay_s: + Polite delay between external API requests. + """ + + def __init__( + self, + venue: str, + year: int, + output_dir: str | Path = "data/pl_conferences", + cache_dir: str | Path | None = None, + request_delay_s: float = 0.1, + ) -> None: + venue = venue.lower() + if venue not in _PACMPL_ISSUES: + raise ValueError( + f"Unsupported venue {venue!r}. Phase 1 only supports POPL; " + "Phase 2 will add the rest." + ) + if venue != "popl" or year != 2024: + # Soft guard rather than hard error so future phases just need to + # remove this branch. + logger.warning( + "PLConferenceHarvester is currently exercised only for POPL 2024;" + " (%s, %s) may surface unhandled edge cases.", + venue, + year, + ) + + self.venue = venue + self.year = year + self.output_dir = Path(output_dir) + self.cache_dir = Path(cache_dir) if cache_dir else None + self.request_delay_s = request_delay_s + + self._session = requests.Session() + self._session.headers.update({"User-Agent": _USER_AGENT}) + + # ------------------------------------------------------------------ + # Top-level entry point + # ------------------------------------------------------------------ + + def harvest(self) -> Path: + """Run the full pipeline. Returns the path to the JSON file written.""" + dblp_entries = list(self._fetch_dblp_entries()) + logger.info( + "DBLP listed %d entries for %s %s", + len(dblp_entries), + self.venue.upper(), + self.year, + ) + + papers: list[dict[str, Any]] = [] + skipped_no_doi: list[str] = [] + skipped_no_abstract: list[str] = [] + + for entry in dblp_entries: + title = (entry.get("title") or "").rstrip(".") + doi = entry.get("doi") + if not doi: + skipped_no_doi.append(title) + logger.warning("Skipping %r: no DOI in DBLP entry", title) + continue + + paper = self._build_paper(entry, doi) + if paper is None: + skipped_no_abstract.append(title) + continue + papers.append(paper) + + logger.info( + "Built %d papers (skipped %d with no DOI, %d with no abstract)", + len(papers), + len(skipped_no_doi), + len(skipped_no_abstract), + ) + + out_path = self.output_dir / self.venue / f"{self.year}.json" + out_path.parent.mkdir(parents=True, exist_ok=True) + with open(out_path, "w", encoding="utf-8") as f: + json.dump(papers, f, ensure_ascii=False, indent=2) + logger.info("Wrote %s (%d papers)", out_path, len(papers)) + return out_path + + # ------------------------------------------------------------------ + # DBLP + # ------------------------------------------------------------------ + + def _fetch_dblp_entries(self) -> Iterable[dict[str, Any]]: + """Yield raw DBLP ``info`` dicts for the configured venue+year. + + We use the search API (``/search/publ/api``) constrained to the + relevant table-of-contents BHT. The per-volume ``.json`` endpoint + documented in the dblp wiki returns 404 for the current PACMPL + volumes, so the search API is the reliable path. + """ + bht = self._dblp_toc_bht() + # Query: facet on the TOC, plus the issue token (e.g. "POPL") to + # restrict to the right PACMPL number when the TOC covers multiple. + issue_token = _PACMPL_ISSUES[self.venue] + query = f"toc:{bht}: {issue_token}" + + url = "https://dblp.org/search/publ/api" + params = { + "q": query, + "format": "json", + "h": 1000, # well above the ~100 papers/year ceiling + "f": 0, + } + resp = self._session.get(url, params=params, timeout=30) + resp.raise_for_status() + payload = resp.json() + hits = payload.get("result", {}).get("hits", {}) + total = int(hits.get("@total", 0)) + sent = int(hits.get("@sent", 0)) + if total > sent: + raise RuntimeError( + f"DBLP returned {sent}/{total} hits — bump 'h' parameter." + ) + + for hit in hits.get("hit", []): + info = hit.get("info", {}) + # Defensive filtering: keep only PACMPL articles for the right + # issue. The search query already constrains this, but if the + # query is loosened later the data must stay clean. + if info.get("number") != issue_token: + continue + if str(info.get("year")) != str(self.year): + continue + if info.get("type") and info["type"] != "Journal Articles": + # Editor-only "Proceedings" records etc. None observed for + # PACMPL, but keep the guard for non-PACMPL venues. + continue + yield info + + def _dblp_toc_bht(self) -> str: + """Return the DBLP TOC BHT identifier for ``(venue, year)``.""" + # PACMPL volume number = year - 2016 (vol 1 = 2017). + if self.venue in _PACMPL_ISSUES: + volume = self.year - 2016 + if volume < 1: + raise ValueError( + f"PACMPL coverage starts in 2017; cannot fetch {self.venue} {self.year}" + ) + return f"db/journals/pacmpl/pacmpl{volume}.bht" + raise ValueError(f"Unsupported venue {self.venue!r}") + + # ------------------------------------------------------------------ + # Paper assembly + # ------------------------------------------------------------------ + + def _build_paper(self, entry: dict[str, Any], doi: str) -> dict[str, Any] | None: + """Combine a DBLP entry with OpenAlex (or Semantic Scholar fallback). + + Returns ``None`` if no abstract can be obtained, in which case the + caller skips the paper. + """ + title = (entry.get("title") or "").rstrip(".") + + oa = self._fetch_openalex(doi) + abstract: str | None = None + publication_date: str | None = None + oa_authors: list[dict[str, str]] = [] + + if oa is not None: + ai = oa.get("abstract_inverted_index") + if ai: + abstract = _reconstruct_abstract(ai) + publication_date = oa.get("publication_date") + oa_authors = _openalex_authors(oa) + + if not abstract: + ss = self._fetch_semantic_scholar(doi) + if ss is not None: + abstract = (ss.get("abstract") or "").strip() or None + + if not abstract: + logger.warning( + "Skipping DOI %s (%r): no abstract in OpenAlex or Semantic Scholar", + doi, + title, + ) + return None + + # Authors: prefer OpenAlex (has institutions). Fall back to DBLP + # author list (no affiliations) so we never lose author names. + if oa_authors: + authors = oa_authors + else: + authors = _dblp_authors(entry) + + date = publication_date or self._fallback_date() + link = f"https://dl.acm.org/doi/{doi}" + + return { + "paper_id": doi, + "title": title, + "abstract": abstract, + "date": date, + "link": link, + "conference_name": _CONFERENCE_LABEL[self.venue], + "authors": authors, + # Provenance — keeps the JSON debuggable without bloating it. + "dblp_key": entry.get("key"), + "venue": self.venue, + "year": self.year, + } + + def _fallback_date(self) -> str: + # Conference dates differ by venue, but the volume publication date + # captured by OpenAlex is what we really want. This is only used + # when both abstract sources also fail to provide a date — which + # currently never happens for PACMPL. Use Jan-1 of the volume year + # as a stable default. + return f"{self.year}-01-01" + + # ------------------------------------------------------------------ + # OpenAlex + # ------------------------------------------------------------------ + + def _fetch_openalex(self, doi: str) -> dict[str, Any] | None: + cache_key = f"openalex/{_safe_filename(doi)}.json" + cached = self._cache_load(cache_key) + if cached is not None: + return cached or None # falsy {} stored as "miss" + + url = f"https://api.openalex.org/works/https://doi.org/{doi}" + params = {"mailto": _OPENALEX_MAILTO} + try: + resp = self._session.get(url, params=params, timeout=30) + except requests.RequestException as exc: + logger.warning("OpenAlex request failed for %s: %s", doi, exc) + return None + time.sleep(self.request_delay_s) + if resp.status_code == 404: + self._cache_store(cache_key, {}) + return None + if resp.status_code != 200: + logger.warning( + "OpenAlex returned %s for %s (%s)", + resp.status_code, + doi, + resp.text[:200], + ) + return None + data = resp.json() + self._cache_store(cache_key, data) + return data + + # ------------------------------------------------------------------ + # Semantic Scholar + # ------------------------------------------------------------------ + + def _fetch_semantic_scholar(self, doi: str) -> dict[str, Any] | None: + cache_key = f"semantic_scholar/{_safe_filename(doi)}.json" + cached = self._cache_load(cache_key) + if cached is not None: + return cached or None + + url = f"https://api.semanticscholar.org/graph/v1/paper/DOI:{doi}" + params = {"fields": "abstract,authors,year"} + try: + resp = self._session.get(url, params=params, timeout=30) + except requests.RequestException as exc: + logger.warning("Semantic Scholar request failed for %s: %s", doi, exc) + return None + time.sleep(self.request_delay_s) + if resp.status_code == 404: + self._cache_store(cache_key, {}) + return None + if resp.status_code == 429: + # Rate limited — wait briefly and retry once. + time.sleep(2.0) + resp = self._session.get(url, params=params, timeout=30) + if resp.status_code != 200: + logger.warning( + "Semantic Scholar returned %s for %s (%s)", + resp.status_code, + doi, + resp.text[:200], + ) + return None + data = resp.json() + self._cache_store(cache_key, data) + return data + + # ------------------------------------------------------------------ + # Cache helpers + # ------------------------------------------------------------------ + + def _cache_load(self, key: str) -> dict[str, Any] | None: + if self.cache_dir is None: + return None + path = self.cache_dir / key + if not path.exists(): + return None + try: + with open(path, "r", encoding="utf-8") as f: + return json.load(f) + except (json.JSONDecodeError, OSError): + return None + + def _cache_store(self, key: str, value: dict[str, Any]) -> None: + if self.cache_dir is None: + return + path = self.cache_dir / key + path.parent.mkdir(parents=True, exist_ok=True) + tmp = path.with_suffix(path.suffix + ".tmp") + with open(tmp, "w", encoding="utf-8") as f: + json.dump(value, f, ensure_ascii=False) + tmp.replace(path) + + +# ---------------------------------------------------------------------- +# Pure helpers (testable without network) +# ---------------------------------------------------------------------- + + +def _reconstruct_abstract(inverted_index: dict[str, list[int]]) -> str: + """Reconstruct an OpenAlex abstract from its inverted-index form.""" + positions: list[tuple[int, str]] = [] + for word, locs in inverted_index.items(): + for loc in locs: + positions.append((loc, word)) + positions.sort(key=lambda p: p[0]) + return " ".join(word for _, word in positions) + + +def _openalex_authors(work: dict[str, Any]) -> list[dict[str, str]]: + out: list[dict[str, str]] = [] + for authorship in work.get("authorships", []) or []: + author = authorship.get("author") or {} + display_name = (author.get("display_name") or "").strip() + if not display_name: + continue + first, last = _split_name(display_name) + institutions = authorship.get("institutions") or [] + institution_name = "" + if institutions: + institution_name = (institutions[0].get("display_name") or "").strip() + out.append( + { + "first_name": first, + "last_name": last, + "institution": institution_name, + } + ) + return out + + +def _dblp_authors(entry: dict[str, Any]) -> list[dict[str, str]]: + """Extract authors from a DBLP search-API ``info`` dict.""" + raw = (entry.get("authors") or {}).get("author") + if raw is None: + return [] + if isinstance(raw, dict): + # Single-author papers come back as a dict, not a list. + raw = [raw] + out: list[dict[str, str]] = [] + for author in raw: + text = (author.get("text") or "").strip() + # DBLP disambiguates name collisions with " 0001" etc — strip those. + text = _strip_dblp_disambiguator(text) + if not text: + continue + first, last = _split_name(text) + out.append({"first_name": first, "last_name": last, "institution": ""}) + return out + + +def _split_name(name: str) -> tuple[str, str]: + parts = name.split() + if len(parts) == 0: + return "", "" + if len(parts) == 1: + return parts[0], "" + return " ".join(parts[:-1]), parts[-1] + + +def _strip_dblp_disambiguator(name: str) -> str: + parts = name.rsplit(" ", 1) + if len(parts) == 2 and parts[1].isdigit() and len(parts[1]) == 4: + return parts[0] + return name + + +def _safe_filename(s: str) -> str: + return s.replace("/", "_").replace(":", "_") + + +# ---------------------------------------------------------------------- +# CLI +# ---------------------------------------------------------------------- + +if __name__ == "__main__": + logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s") + harvester = PLConferenceHarvester( + venue="popl", + year=2024, + output_dir="data/pl_conferences", + cache_dir=".cache/pl_conferences", + ) + harvester.harvest() From 490c2b4b4fec9e968fb82a79597d12f4a98ff9f0 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 16:34:34 +0200 Subject: [PATCH 03/34] feat: harvest POPL 2024 proceedings into data/pl_conferences/ All 93 PACMPL volume 8 issue POPL papers, produced by running \`python -m oversight.PLConferenceHarvester\`. Every paper has a DOI, a real abstract from OpenAlex, and a 2024-01-02 publication date; no DBLP entries had to be skipped. Following the convention in data/systems_conferences/ and data/vldb/, the file is committed to the repo so the consume path is reproducible without re-hitting external APIs. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/popl/2024.json | 2841 ++++++++++++++++++++++++++++ 1 file changed, 2841 insertions(+) create mode 100644 data/pl_conferences/popl/2024.json diff --git a/data/pl_conferences/popl/2024.json b/data/pl_conferences/popl/2024.json new file mode 100644 index 0000000..5a83a21 --- /dev/null +++ b/data/pl_conferences/popl/2024.json @@ -0,0 +1,2841 @@ +[ + { + "paper_id": "10.1145/3632928", + "title": "Flan: An Expressive and Efficient Datalog Compiler for Program Analysis", + "abstract": "Datalog has gained prominence in program analysis due to its expressiveness and ease of use. Its generic fixpoint resolution algorithm over relational domains simplifies the expression of many complex analyses. The performance and scalability issues of early Datalog approaches have been addressed by tools such as Soufflé through specialized code generation. Still, while pure Datalog is expressive enough to support a wide range of analyses, there is a growing need for extensions to accommodate increasingly complex analyses This has led to the development of various extensions, such as Flix, Datafun, and Formulog, which enhance Datalog with features like arbitrary lattices and SMT constraints. Most of these extensions recognize the need for full interoperability between Datalog and a full-fledged programming language, a functionality that high-performance systems like Soufflé lack. Specifically, in most cases, they construct languages from scratch with first-class Datalog support, allowing greater flexibility. However, this flexibility often comes at the cost of performance due to the conflicting requirements of prioritizing modularity and abstraction over efficiency. Consequently, achieving both flexibility and compilation to highly-performant specialized code poses a significant challenge. In this work, we reconcile the competing demands of expressiveness and performance with Flan, a Datalog compiler fully embedded in Scala that leverages multi-stage programming to generate specialized code for enhanced performance. Our approach combines the flexibility of Flix with Soufflé’s performance, offering seamless integration with the host language that enables the addition of powerful extensions while generating specialized code for the entire computation. Flan’s simple operator interface allows the addition of an extensive set of features, including arbitrary aggregates, user-defined functions, and lattices, with multiple execution strategies such as binary and multi-way joins, supported by different indexing structures like specialized trees and hash tables, with minimal effort. We evaluate our system on a variety of benchmarks and compare it to established Datalog engines. Our results demonstrate competitive performance and speedups in the range of to compared to state-of-the-art systems for workloads of practical importance.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632928", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Supun", + "last_name": "Abeysinghe", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Anxhelo", + "last_name": "Xhebraj", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/AbeysingheXR24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632903", + "title": "Probabilistic Programming Interfaces for Random Graphs: Markov Categories, Graphons, and Nominal Sets", + "abstract": "We study semantic models of probabilistic programming languages over graphs, and establish a connection to graphons from graph theory and combinatorics. We show that every well-behaved equational theory for our graph probabilistic programming language corresponds to a graphon, and conversely, every graphon arises in this way. We provide three constructions for showing that every graphon arises from an equational theory. The first is an abstract construction, using Markov categories and monoidal indeterminates. The second and third are more concrete. The second is in terms of traditional measure theoretic probability, which covers ‘black-and-white’ graphons. The third is in terms of probability monads on the nominal sets of Gabbay and Pitts. Specifically, we use a variation of nominal sets induced by the theory of graphs, which covers Erdős-Rényi graphons. In this way, we build new models of graph probabilistic programming from graphons.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632903", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nathanael", + "last_name": "Ackerman", + "institution": "Harvard University Press" + }, + { + "first_name": "Cameron E.", + "last_name": "Freer", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Younesse", + "last_name": "Kaddar", + "institution": "University of Oxford" + }, + { + "first_name": "Jacek", + "last_name": "Karwowski", + "institution": "University of Oxford" + }, + { + "first_name": "Sean", + "last_name": "Moss", + "institution": "University of Birmingham" + }, + { + "first_name": "Daniel", + "last_name": "Roy", + "institution": "University of Toronto" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/AckermanFKKMRSY24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632920", + "title": "Internal Parametricity, without an Interval", + "abstract": "Parametricity is a property of the syntax of type theory implying, e.g., that there is only one function having the type of the polymorphic identity function. Parametricity is usually proven externally, and does not hold internally. Internalising it is difficult because once there is a term witnessing parametricity, it also has to be parametric itself and this results in the appearance of higher dimensional cubes. In previous theories with internal parametricity, either an explicit syntax for higher cubes is present or the theory is extended with a new sort for the interval. In this paper we present a type theory with internal parametricity which is a simple extension of Martin-Löf type theory: there are a few new type formers, term formers and equations. Geometry is not explicit in this syntax, but emergent: the new operations and equations only refer to objects up to dimension 3. We show that this theory is modelled by presheaves over the BCH cube category. Fibrancy conditions are not needed because we use span-based rather than relational parametricity. We define a gluing model for this theory implying that external parametricity and canonicity hold. The theory can be seen as a special case of a new kind of modal type theory, and it is the simplest setting in which the computational properties of higher observational type theory can be demonstrated.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632920", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thorsten", + "last_name": "Altenkirch", + "institution": "University of Nottingham" + }, + { + "first_name": "Yorgo", + "last_name": "Chamoun", + "institution": "École Polytechnique" + }, + { + "first_name": "Ambrus", + "last_name": "Kaposi", + "institution": "Eötvös Loránd University" + }, + { + "first_name": "Michael", + "last_name": "Shulman", + "institution": "University of San Diego" + } + ], + "dblp_key": "journals/pacmpl/AltenkirchCKS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632916", + "title": "Securing Verified IO Programs Against Unverified Code in F", + "abstract": "We introduce SCIO ⋆ , a formally secure compilation framework for statically verified programs performing input-output (IO). The source language is an F ⋆ subset in which a verified program interacts with its IO-performing context via a higher-order interface that includes refinement types as well as pre- and post-conditions about past IO events. The target language is a smaller F ⋆ subset in which the compiled program is linked with an adversarial context that has an interface without refinement types, pre-conditions, or concrete post-conditions. To bridge this interface gap and make compilation and linking secure we propose a formally verified combination of higher-order contracts and reference monitoring for recording and controlling IO operations. Compilation uses contracts to convert the logical assumptions the program makes about the context into dynamic checks on each context-program boundary crossing. These boundary checks can depend on information about past IO events stored in the state of the monitor. But these checks cannot stop the adversarial target context before it performs dangerous IO operations. Therefore linking in SCIO ⋆ additionally forces the context to perform all IO actions via a secure IO library, which uses reference monitoring to dynamically enforce an access control policy before each IO operation. We prove in F ⋆ that SCIO ⋆ soundly enforces a global trace property for the compiled verified program linked with the untrusted context. Moreover, we prove in F ⋆ that SCIO ⋆ satisfies by construction Robust Relational Hyperproperty Preservation, a very strong secure compilation criterion. Finally, we illustrate SCIO ⋆ at work on a simple web server example.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632916", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cezar-Constantin", + "last_name": "Andrici", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Ştefan", + "last_name": "Ciobâcă", + "institution": "Alexandru Ioan Cuza University" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "CryptoExperts (France)" + }, + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Exequiel", + "last_name": "Rivas", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "Centre Inria de Saclay" + } + ], + "dblp_key": "journals/pacmpl/AndriciCHMRTW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632915", + "title": "Predictive Monitoring against Pattern Regular Languages", + "abstract": "While current bug detection techniques for concurrent software focus on unearthing low-level issues such as data races or deadlocks, they often fall short of discovering more intricate temporal behaviours that can arise even in the absence of such low-level issues. In this paper, we focus on the problem of dynamically analysing concurrent software against high-level temporal specifications such as LTL. Existing techniques for runtime monitoring against such specifications are primarily designed for sequential software and remain inadequate in the presence of concurrency — violations may be observed only in intricate thread interleavings, requiring many re-runs of the underlying software in conjunction with the analysis. Towards this, we study the problem of predictive runtime monitoring , inspired by the analogous problem of predictive data race detection studied extensively recently. The predictive runtime monitoring question asks, given an execution σ , if it can be soundly reordered to expose violations of a specification. In general, this problem may become easily intractable when either the specifications or the notion of reorderings used is complex. In this paper, we focus on specifications that are given in regular languages. Our notion of reorderings is trace equivalence , where an execution is considered a reordering of another if it can be obtained from the latter by successively commuting adjacent independent actions. We first show that, even in this simplistic setting, the problem of predictive monitoring admits a super-linear lower bound of O ( n α ) , where n is the number of events in the execution, and α is a parameter describing the degree of commutativity, and typically corresponds to the number of threads in the execution. As a result, predictive runtime monitoring even in this setting is unlikely to be efficiently solvable, unlike in the non-predictive setting where the problem can be checked using a deterministic finite automaton (and thus, a constant-space streaming linear-time algorithm). Towards this, we identify a sub-class of regular languages, called pattern languages (and their extension generalized pattern languages ). Pattern languages can naturally express specific ordering of some number of (labelled) events, and have been inspired by popular empirical hypotheses underlying many concurrency bug detection approaches such as the “small bug depth” hypothesis. More importantly, we show that for pattern (and generalized pattern) languages, the predictive monitoring problem can be solved using a constant-space streaming linear-time algorithm. We implement and evaluate our algorithm PatternTrack on benchmarks from the literature and show that it is effective in monitoring large-scale applications.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632915", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhendong", + "last_name": "Ang", + "institution": "National University of Singapore" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/AngM24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632895", + "title": "Disentanglement with Futures, State, and Interaction", + "abstract": "Recent work has proposed a memory property for parallel programs, called disentanglement, and showed that it is pervasive in a variety of programs, written in different languages, ranging from C/C++ to Parallel ML, and showed that it can be exploited to improve the performance of parallel functional programs. All existing work on disentanglement, however, considers the “fork/join” model for parallelism and does not apply to “futures”, the more powerful approach to parallelism. This is not surprising: fork/join parallel programs exhibit a reasonably strict dependency structure (e.g., series-parallel DAGs), which disentanglement exploits. In contrast, with futures, parallel computations become first-class values of the language, and thus can be created, and passed between functions calls or stored in memory, just like other ordinary values, resulting in complex dependency structures, especially in the presence of mutable state. For example, parallel programs with futures can have deadlocks, which is impossible with fork-join parallelism. In this paper, we are interested in the theoretical question of whether disentanglement may be extended beyond fork/join parallelism, and specifically to futures. We consider a functional language with futures, Input/Output (I/O), and mutable state (references) and show that a broad range of programs written in this language are disentangled. We start by formalizing disentanglement for futures and proving that purely functional programs written in this language are disentangled. We then generalize this result in three directions. First, we consider state (effects) and prove that stateful programs are disentangled if they are race free. Second, we show that race freedom is sufficient but not a necessary condition and non-deterministic programs, e.g. those that use atomic read-modify-operations and some non-deterministic combinators, may also be disentangled. Third, we prove that disentangled task-parallel programs written with futures are free of deadlocks, which arise due to interactions between state and the rich dependencies that can be expressed with futures. Taken together, these results show that disentanglement generalizes to parallel programs with futures and, thus, the benefits of disentanglement may go well beyond fork-join parallelism.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632895", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jatin", + "last_name": "Arora", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/AroraMA24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632918", + "title": "Polynomial Time and Dependent Types", + "abstract": "We combine dependent types with linear type systems that soundly and completely capture polynomial time computation. We explore two systems for capturing polynomial time: one system that disallows construction of iterable data, and one, based on the LFPL system of Martin Hofmann, that controls construction via a payment method. Both of these are extended to full dependent types via Quantitative Type Theory, allowing for arbitrary computation in types alongside guaranteed polynomial time computation in terms. We prove the soundness of the systems using a realisability technique due to Dal Lago and Hofmann. Our long-term goal is to combine the extensional reasoning of type theory with intensional reasoning about the resources intrinsically consumed by programs. This paper is a step along this path, which we hope will lead both to practical systems for reasoning about programs’ resource usage, and to theoretical use as a form of synthetic computational complexity theory .", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632918", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Atkey", + "institution": "University of Strathclyde" + } + ], + "dblp_key": "journals/pacmpl/Atkey24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632891", + "title": "Validation of Modern JSON Schema: Formalization and Complexity", + "abstract": "JSON Schema is the de-facto standard schema language for JSON data. The language went through many minor revisions, but the most recent versions of the language, starting from Draft 2019-09, added two novel features, dynamic references and annotation-dependent validation , that change the evaluation model. Modern JSON Schema is the name used to indicate all versions from Draft 2019-09, which are characterized by these new features, while Classical JSON Schema is used to indicate the previous versions. These new “modern” features make the schema language quite difficult to understand and have generated many discussions about the correct interpretation of their official specifications; for this reason, we undertook the task of their formalization. During this process, we also analyzed the complexity of data validation in Modern JSON Schema, with the idea of confirming the polynomial complexity of Classical JSON Schema validation, and we were surprised to discover a completely different truth: data validation, which is expected to be an extremely efficient process, acquires, with Modern JSON Schema features, a PSPACE complexity. In this paper, we give the first formal description of Modern JSON Schema, which we have discussed with the community of JSON Schema tool developers, and which we consider a central contribution of this work. We then prove that its data validation problem is PSPACE-complete. We prove that the origin of the problem lies in the Draft 2020-12 version of dynamic references, and not in annotation-dependent validation. We study the schema and data complexities, showing that the problem is PSPACE-complete with respect to the schema size even with a fixed instance but is in P when the schema is fixed and only the instance size is allowed to vary. Finally, we run experiments that show that there are families of schemas where the difference in asymptotic complexity between dynamic and static references is extremely visible, even with small schemas.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632891", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lyes", + "last_name": "Attouche", + "institution": "Université Paris Dauphine-PSL" + }, + { + "first_name": "Mohamed-Amine", + "last_name": "Baazizi", + "institution": "Sorbonne Université" + }, + { + "first_name": "Dario", + "last_name": "Colazzo", + "institution": "Université Paris Dauphine-PSL" + }, + { + "first_name": "Giorgio", + "last_name": "Ghelli", + "institution": "University of Pisa" + }, + { + "first_name": "Carlo", + "last_name": "Sartiani", + "institution": "University of Basilicata" + }, + { + "first_name": "Stefanie", + "last_name": "Scherzinger", + "institution": "University of Passau" + } + ], + "dblp_key": "journals/pacmpl/AttoucheBCGSS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3633279", + "title": "Reachability in Continuous Pushdown VASS", + "abstract": "Pushdown Vector Addition Systems with States (PVASS) consist of finitely many control states, a pushdown stack, and a set of counters that can be incremented and decremented, but not tested for zero. Whether the reachability problem is decidable for PVASS is a long-standing open problem. We consider continuous PVASS , which are PVASS with a continuous semantics. This means, the counter values are rational numbers and whenever a vector is added to the current counter values, this vector is first scaled with an arbitrarily chosen rational factor between zero and one. We show that reachability in continuous PVASS is NEXPTIME -complete. Our result is unusually robust: Reachability can be decided in NEXPTIME even if all numbers are specified in binary. On the other hand, NEXPTIME -hardness already holds for coverability, in fixed dimension, for bounded stack, and even if all numbers are specified in unary.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3633279", + "conference_name": "POPL", + "authors": [ + { + "first_name": "A. R.", + "last_name": "Balasubramanian", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ramanathan S.", + "last_name": "Thinniyam", + "institution": "Uppsala University" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/BalasubramanianMTZ24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632935", + "title": "Programmatic Strategy Synthesis: Resolving Nondeterminism in Probabilistic Programs", + "abstract": "We consider imperative programs that involve both randomization and pure nondeterminism. The central question is how to find a strategy resolving the pure nondeterminism such that the so-obtained determinized program satisfies a given quantitative specification, i.e., bounds on expected outcomes such as the expected final value of a program variable or the probability to terminate in a given set of states. We show how memoryless and deterministic (MD) strategies can be obtained in a semi-automatic fashion using deductive verification techniques. For loop-free programs, the MD strategies resulting from our weakest preconditionstyle framework are correct by construction. This extends to loopy programs, provided the loops are equipped with suitable loop invariants - just like in program verification. We show how our technique relates to the well-studied problem of obtaining strategies in countably infinite Markov decision processes with reachabilityreward objectives. Finally, we apply our technique to several case studies.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632935", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Tom Jannik", + "last_name": "Biskup", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Tobias", + "last_name": "Winkler", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/BatzBKW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632843", + "title": "Ramsey Quantifiers in Linear Arithmetics", + "abstract": "We study Satisfiability Modulo Theories (SMT) enriched with the so-called Ramsey quantifiers, which assert the existence of cliques (complete graphs) in the graph induced by some formulas. The extended framework is known to have applications in proving program termination (in particular, whether a transitive binary predicate is well-founded), and monadic decomposability of SMT formulas. Our main result is a new algorithm for eliminating Ramsey quantifiers from three common SMT theories: Linear Integer Arithmetic (LIA), Linear Real Arithmetic (LRA), and Linear Integer Real Arithmetic (LIRA). In particular, if we work only with existentially quantified formulas, then our algorithm runs in polynomial time and produces a formula of linear size. One immediate consequence is that checking well-foundedness of a given formula in the aforementioned theory defining a transitive predicate can be straightforwardly handled by highly optimized SMT-solvers. We show also how this provides a uniform semi-algorithm for verifying termination and liveness with completeness guarantee (in fact, with an optimal computational complexity) for several well-known classes of infinite-state systems, which include succinct timed systems, one-counter systems, and monotonic counter systems. Another immediate consequence is a solution to an open problem on checking monadic decomposability of a given relation in quantifier-free fragments of LRA and LIRA, which is an important problem in automated reasoning and constraint databases. Our result immediately implies decidability of this problem with an optimal complexity (coNP-complete) and enables exploitation of SMT-solvers. It also provides a termination guarantee for the generic monadic decomposition algorithm of Veanes et al. for LIA, LRA, and LIRA. We report encouraging experimental results on a prototype implementation of our algorithms on micro-benchmarks.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632843", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pascal", + "last_name": "Bergsträßer", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Moses", + "last_name": "Ganardi", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/BergstrasserGLZ24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632887", + "title": "Polyregular Functions on Unordered Trees of Bounded Height", + "abstract": "We consider injective first-order interpretations that input and output trees of bounded height. The corresponding functions have polynomial output size, since a first-order interpretation can use a k -tuple of input nodes to represent a single output node. We prove that the equivalence problem for such functions is decidable, i.e. given two such interpretations, one can decide whether, for every input tree, the two output trees are isomorphic. We also give a calculus of typed functions and combinators which derives exactly injective first-order interpretations for unordered trees of bounded height. The calculus is based on a type system, where the type constructors are products, coproducts and a monad of multisets. Thanks to our results about tree-to-tree interpretations, the equivalence problem is decidable for this calculus. As an application, we show that the equivalence problem is decidable for first-order interpretations between classes of graphs that have bounded tree-depth. In all cases studied in this paper, first-order logic and mso have the same expressive power, and hence all results apply also to mso interpretations.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632887", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mikołaj", + "last_name": "Bojańczyk", + "institution": "University of Warsaw" + }, + { + "first_name": "Bartek", + "last_name": "Klin", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/BojanczykK24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632912", + "title": "Mechanizing Refinement Types", + "abstract": "Practical checkers based on refinement types use the combination of implicit semantic subtyping and parametric polymorphism to simplify the specification and automate the verification of sophisticated properties of programs. However, a formal metatheoretic accounting of the soundness of refinement type systems using this combination has proved elusive. We present λ R F , a core refinement calculus that combines semantic subtyping and parametric polymorphism. We develop a metatheory for this calculus and prove soundness of the type system. Finally, we give two mechanizations of our metatheory. First, we introduce data propositions , a novel feature that enables encoding derivation trees for inductively defined judgments as refined data types, and use them to show that L iquid H askell ’s refinement types can be used for mechanization. Second, we mechanize our results in C oq , which comes with stronger soundness guarantees than L iquid H askell , thereby laying the foundations for mechanizing the metatheory of L iquid H askell .", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632912", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael H.", + "last_name": "Borkowski", + "institution": "University of California San Diego" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/BorkowskiVJ24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632874", + "title": "Implementation and Synthesis of Math Library Functions", + "abstract": "Achieving speed and accuracy for math library functions like exp , sin , and log is difficult. This is because low-level implementation languages like C do not help math library developers catch mathematical errors, build implementations incrementally, or separate high-level and low-level decision making. This ultimately puts development of such functions out of reach for all but the most experienced experts. To address this, we introduce MegaLibm, a domain-specific language for implementing, testing, and tuning math library implementations. MegaLibm is safe, modular, and tunable. Implementations in MegaLibm can automatically detect mathematical mistakes like sign flips via semantic wellformedness checks, and components like range reductions can be implemented in a modular, composable way, simplifying implementations. Once the high-level algorithm is done, tuning parameters like working precisions and evaluation schemes can be adjusted through orthogonal tuning parameters to achieve the desired speed and accuracy. MegaLibm also enables math library developers to work interactively, compiling, testing, and tuning their implementations and invoking tools like Sollya and type-directed synthesis to complete components and synthesize entire implementations. MegaLibm can express 8 state-of-the-art math library implementations with comparable speed and accuracy to the original C code, and can synthesize 5 variations and 3 from-scratch implementations with minimal guidance.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632874", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ian", + "last_name": "Briggs", + "institution": "University of Utah" + }, + { + "first_name": "Yash", + "last_name": "Lad", + "institution": "University of Utah" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/BriggsLP24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632876", + "title": "On Learning Polynomial Recursive Programs", + "abstract": "We introduce the class of P-finite automata. These are a generalisation of weighted automata, in which the weights of transitions can depend polynomially on the length of the input word. P-finite automata can also be viewed as simple tail-recursive programs in which the arguments of recursive calls can non-linearly refer to a variable that counts the number of recursive calls. The nomenclature is motivated by the fact that over a unary alphabet P-finite automata compute so-called P-finite sequences, that is, sequences that satisfy a linear recurrence with polynomial coefficients. Our main result shows that P-finite automata can be learned in polynomial time in Angluin’s MAT exact learning model. This generalises the classical results that deterministic finite automata and weighted automata over a field are respectively polynomial-time learnable in the MAT model.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632876", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alex", + "last_name": "Buna-Marginean", + "institution": "University of Oxford" + }, + { + "first_name": "Vincent", + "last_name": "Cheval", + "institution": "University of Oxford" + }, + { + "first_name": "Mahsa", + "last_name": "Shirmohammadi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "James", + "last_name": "Worrell", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/BunaMargineanCSW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632897", + "title": "Monotonicity and the Precision of Program Analysis", + "abstract": "It is widely known that the precision of a program analyzer is closely related to intensional program properties, namely, properties concerning how the program is written. This explains, for instance, the interest in code obfuscation techniques, namely, tools explicitly designed to degrade the results of program analysis by operating syntactic program transformations. Less is known about a possible relation between what the program extensionally computes, namely, its input-output relation, and the precision of a program analyzer. In this paper we explore this potential connection in an effort to isolate program fragments that can be precisely analyzed by abstract interpretation, namely, programs for which there exists a complete abstract interpretation. In the field of static inference of numeric invariants, this happens for programs, or parts of programs, that manifest a monotone (either non-decreasing or non-increasing) behavior. We first formalize the notion of program monotonicity with respect to a given input and a set of numerical variables of interest. A sound proof system is then introduced with judgments specifying whether a program is monotone relatively to a set of variables and a set of inputs. The interest in monotonicity is justified because we prove that the family of monotone programs admits a complete abstract interpretation over a specific class of non-trivial numerical abstractions and inputs. This class includes all non-relational abstract domains that refine interval analysis (i.e., at least as precise as the intervals abstraction) and that satisfy a topological convexity hypothesis.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632897", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Campion", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Mila Dalla", + "last_name": "Preda", + "institution": "University of Verona" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Arizona" + }, + { + "first_name": "Caterina", + "last_name": "Urban", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/CampionPGU24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632931", + "title": "Type-Based Gradual Typing Performance Optimization", + "abstract": "Gradual typing has emerged as a popular design point in programming languages, attracting significant interests from both academia and industry. Programmers in gradually typed languages are free to utilize static and dynamic typing as needed. To make such languages sound, runtime checks mediate the boundary of typed and untyped code. Unfortunately, such checks can incur significant runtime overhead on programs that heavily mix static and dynamic typing. To combat this overhead without necessitating changes to the underlying implementations of languages, we present discriminative typing . Discriminative typing works by optimistically inferring types for functions and implementing an optimized version of the function based on this type. To preserve safety it also implements an un-optimized version of the function based purely on the provided annotations. With two versions of each function in hand, discriminative typing translates programs so that the optimized functions are called as frequently as possible while also preserving program behaviors. We have implemented discriminative typing in Reticulated Python and have evaluated its performance compared to guarded Reticulated Python. Our results show that discriminative typing improves the performance across 95% of tested programs, when compared to Reticulated, and achieves more than 4× speedup in more than 56% of these programs. We also compare its performance against a previous optimization approach and find that discriminative typing improved performance across 93% of tested programs, with 30% of these programs receiving speedups between 4 to 25 times. Finally, our evaluation shows that discriminative typing remarkably reduces the overhead of gradual typing on many mixed type configurations of programs. In addition, we have implemented discriminative typing in Grift and evaluated its performance. Our evaluation demonstrations that DT significantly improves performance of Grift.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632931", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John Peter", + "last_name": "Campora", + "institution": "" + }, + { + "first_name": "Mohammad Wahiduzzaman", + "last_name": "Khan", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + } + ], + "dblp_key": "journals/pacmpl/CamporaKC24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632861", + "title": "With a Few Square Roots, Quantum Computing Is as Easy as Pi", + "abstract": "Rig groupoids provide a semantic model of Π , a universal classical reversible programming language over finite types. We prove that extending rig groupoids with just two maps and three equations about them results in a model of quantum computing that is computationally universal and equationally sound and complete for a variety of gate sets. The first map corresponds to an 8th root of the identity morphism on the unit 1. The second map corresponds to a square root of the symmetry on 1 + 1 . As square roots are generally not unique and can sometimes even be trivial, the maps are constrained to satisfy a nondegeneracy axiom, which we relate to the Euler decomposition of the Hadamard gate. The semantic construction is turned into an extension of Π , called Π , that is a computationally universal quantum programming language equipped with an equational theory that is sound and complete with respect to the Clifford gate set, the standard gate set of Clifford+T restricted to ≤ 2 qubits, and the computationally universal Gaussian Clifford+T gate set.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632861", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jacques", + "last_name": "Carette", + "institution": "McMaster University" + }, + { + "first_name": "Chris", + "last_name": "Heunen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Robin", + "last_name": "Kaarsgaard", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "journals/pacmpl/CaretteHKS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632882", + "title": "Polymorphic Type Inference for Dynamic Languages", + "abstract": "We present a type system that combines, in a controlled way, first-order polymorphism with intersection types, union types, and subtyping, and prove its safety. We then define a type reconstruction algorithm that is sound and terminating. This yields a system in which unannotated functions are given polymorphic types (thanks to Hindley-Milner) that can express the overloaded behavior of the functions they type (thanks to the intersection introduction rule) and that are deduced by applying advanced techniques of type narrowing (thanks to the union elimination rule). This makes the system a prime candidate to type dynamic languages.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632882", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Mickaël", + "last_name": "Laurent", + "institution": "Université Paris Cité" + }, + { + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Université Paris-Saclay" + } + ], + "dblp_key": "journals/pacmpl/CastagnaLN24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632885", + "title": "Quantum Bisimilarity via Barbs and Contexts: Curbing the Power of Non-deterministic Observers", + "abstract": "Past years have seen the development of a few proposals for quantum extensions of process calculi. The rationale is clear: with the development of quantum communication protocols, there is a need to abstract and focus on the basic features of quantum concurrent systems, like CCS and CSP have done for their classical counterparts. So far, though, no accepted standard has emerged, neither for the syntax nor for the behavioural semantics. Indeed, the various proposals do not agree on what should be the observational properties of quantum values, and as a matter of fact, the soundness of such properties has never been validated against the prescriptions of quantum theory. To this aim, we introduce a new calculus, Linear Quantum CCS (lqCCS), and investigate the features of behavioural equivalences based on barbs and contexts. Our calculus can be thought of as an asynchronous, linear version of qCCS, which is in turn based on value-passing CCS. The combination of linearity and asynchronous communication fits well with the properties of quantum systems (e.g. the no-cloning theorem), since it ensures that each qubit is sent exactly once, precisely specifying which qubits of a process interact with the context. We exploit contexts to examine how bisimilarities relate to quantum theory. We show that the observational power of general contexts is incompatible with quantum theory: roughly, they can perform non-deterministic moves depending on quantum values without measuring (hence perturbing) them. Therefore, we refine the operational semantics in order to prevent contexts from performing unfeasible non-deterministic choices. This induces a coarser bisimilarity that better fits the quantum setting: ( i ) it lifts the indistinguishability of quantum states to the distributions of processes and, despite the additional constraints, ( i i ) it preserves the expressiveness of non-deterministic choices based on classical information. To the best of our knowledge, our semantics is the first one that satisfies the two properties above.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632885", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lorenzo", + "last_name": "Ceragioli", + "institution": "IMT School for Advanced Studies Lucca" + }, + { + "first_name": "Fabio", + "last_name": "Gadducci", + "institution": "University of Pisa" + }, + { + "first_name": "Giuseppe", + "last_name": "Lomurno", + "institution": "University of Pisa" + }, + { + "first_name": "Gabriele", + "last_name": "Tedeschi", + "institution": "University of Pisa" + } + ], + "dblp_key": "journals/pacmpl/CeragioliGLT24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632908", + "title": "How Hard Is Weak-Memory Testing?", + "abstract": "Weak-memory models are standard formal specifications of concurrency across hardware, programming languages, and distributed systems. A fundamental computational problem is consistency testing : is the observed execution of a concurrent program in alignment with the specification of the underlying system? The problem has been studied extensively across Sequential Consistency (SC) and weak memory, and proven to be N P -complete when some aspect of the input (e.g., number of threads/memory locations) is unbounded. This unboundedness has left a natural question open: are there efficient parameterized algorithms for testing? The main contribution of this paper is a deep hardness result for consistency testing under many popular weak-memory models: the problem remains N P -complete even in its bounded setting, where candidate executions contain a bounded number of threads, memory locations, and values. This hardness spreads across several Release-Acquire variants of C11, a popular variant of its Relaxed fragment, popular Causal Consistency models, and the POWER architecture. To our knowledge, this is the first result that fully exposes the hardness of weak-memory testing and proves that the problem admits no parameterization under standard input parameters. It also yields a computational separation of these models from SC, x86-TSO, PSO, and Relaxed, for which bounded consistency testing is either known (for SC), or shown here (for the rest), to be in polynomial time.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632908", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Delft University of Technology" + }, + { + "first_name": "Shankara Narayanan", + "last_name": "Krishna", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/ChakrabortyKMP24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632893", + "title": "Unboxed Data Constructors: Or, How cpp Decides a Halting Problem", + "abstract": "We propose a new language feature for ML-family languages, the ability to selectively unbox certain data constructors, so that their runtime representation gets compiled away to just the identity on their argument. Unboxing must be statically rejected when it could introduce confusion, that is, distinct values with the same representation. We discuss the use-case of big numbers, where unboxing allows to write code that is both efficient and safe, replacing either a safe but slow version or a fast but unsafe version. We explain the static analysis necessary to reject incorrect unboxing requests. We present our prototype implementation of this feature for the OCaml programming language, discuss several design choices and the interaction with advanced features such as Guarded Algebraic Datatypes. Our static analysis requires expanding type definitions in type expressions, which is not necessarily normalizing in presence of recursive type definitions. In other words, we must decide normalization of terms in the first-order λ -calculus with recursion. We provide an algorithm to detect non-termination on-the-fly during reduction, with proofs of correctness and completeness. Our algorithm turns out to be closely related to the normalization strategy for macro expansion in the cpp preprocessor.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632893", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Chataing", + "institution": "École Normale Supérieure - PSL" + }, + { + "first_name": "Stephen", + "last_name": "Dolan", + "institution": "" + }, + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/ChataingDSY24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632902", + "title": "A Formalization of Core Why3 in Coq", + "abstract": "Intermediate verification languages like Why3 and Boogie have made it much easier to build program verifiers, transforming the process into a logic compilation problem rather than a proof automation one. Why3 in particular implements a rich logic for program specification with polymorphism, algebraic data types, recursive functions and predicates, and inductive predicates; it translates this logic to over a dozen solvers and proof assistants. Accordingly, it serves as a backend for many tools, including Frama-C, EasyCrypt, and GNATProve for Ada SPARK. But how can we be sure that these tools are correct? The alternate foundational approach, taken by tools like VST and CakeML, provides strong guarantees by implementing the entire toolchain in a proof assistant, but these tools are harder to build and cannot directly take advantage of SMT solver automation. As a first step toward enabling automated tools with similar foundational guarantees, we give a formal semantics in Coq for the logic fragment of Why3. We show that our semantics are useful by giving a correct-by-construction natural deduction proof system for this logic, using this proof system to verify parts of Why3’s standard library, and proving sound two of Why3’s transformations used to convert terms and formulas into the simpler logics supported by the backend solvers.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632902", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Cohen", + "institution": "Princeton University" + }, + { + "first_name": "Philip", + "last_name": "Johnson-Freyd", + "institution": "Sandia National Laboratories California" + } + ], + "dblp_key": "journals/pacmpl/CohenJ24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632888", + "title": "The Complex(ity) Landscape of Checking Infinite Descent", + "abstract": "Cyclic proof systems, in which induction is managed implicitly, are a promising approach to automatic verification. The soundness of cyclic proof graphs is ensured by checking them against a trace-based Infinite Descent property. Although the problem of checking Infinite Descent is known to be PSPACE-complete, this leaves much room for variation in practice. Indeed, a number of different approaches are employed across the various cyclic proof systems described in the literature. In this paper, we study criteria for Infinite Descent in an abstract, logic-independent setting. We look at criteria based on Büchi automata encodings and relational abstractions, and determine their parameterized time complexities in terms of natural dimensions of cyclic proofs: the numbers of vertices of the proof-tree graphs, and the vertex width —an upper bound on the number of components (e.g., formulas) of a sequent that can be simultaneously tracked for descent. We identify novel algorithms that improve upon the parameterised complexity of the existing algorithms. We implement the studied criteria and compare their performance on various benchmarks.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632888", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Liron", + "last_name": "Cohen", + "institution": "Ben-Gurion University of the Negev" + }, + { + "first_name": "Adham", + "last_name": "Jabarin", + "institution": "Ben-Gurion University of the Negev" + }, + { + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "University of Sheffield" + }, + { + "first_name": "Reuben N. S.", + "last_name": "Rowe", + "institution": "Royal Holloway University of London" + } + ], + "dblp_key": "journals/pacmpl/CohenJPR24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632849", + "title": "Calculational Design of [In]Correctness Transformational Program Logics by Abstract Interpretation", + "abstract": "We study transformational program logics for correctness and incorrectness that we extend to explicitly handle both termination and nontermination. We show that the logics are abstract interpretations of the right image transformer for a natural relational semantics covering both finite and infinite executions. This understanding of logics as abstractions of a semantics facilitates their comparisons through their respective abstractions of the semantics (rather that the much more difficult comparison through their formal proof systems). More importantly, the formalization provides a calculational method for constructively designing the sound and complete formal proof system by abstraction of the semantics. As an example, we extend Hoare logic to cover all possible behaviors of nondeterministic programs and design a new precondition (in)correctness logic.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632849", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/Cousot24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632865", + "title": "A Core Calculus for Documents: Or, Lambda: The Ultimate Document", + "abstract": "Passive documents and active programs now widely comingle. Document languages include Turing-complete programming elements, and programming languages include sophisticated document notations. However, there are no formal foundations that model these languages. This matters because the interaction between document and program can be subtle and error-prone. In this paper we describe several such problems, then taxonomize and formalize document languages as levels of a document calculus. We employ the calculus as a foundation for implementing complex features such as reactivity, as well as for proving theorems about the boundary of content and computation. We intend for the document calculus to provide a theoretical basis for new document languages, and to assist designers in cleaning up the unsavory corners of existing languages.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632865", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Will", + "last_name": "Crichton", + "institution": "Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "journals/pacmpl/CrichtonK24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632867", + "title": "Solvable Polynomial Ideals: The Ideal Reflection for Program Analysis", + "abstract": "This paper presents a program analysis method that generates program summaries involving polynomial arithmetic. Our approach builds on prior techniques that use solvable polynomial maps for summarizing loops. These techniques are able to generate all polynomial invariants for a restricted class of programs, but cannot be applied to programs outside of this class—for instance, programs with nested loops, conditional branching, unstructured control flow, etc. There currently lacks approaches to apply these prior methods to the case of general programs. This paper bridges that gap. Instead of restricting the kinds of programs we can handle, our method abstracts every loop into a model that can be solved with prior techniques, bringing to bear prior work on solvable polynomial maps to general programs. While no method can generate all polynomial invariants for arbitrary programs, our method establishes its merit through a monotonicty result. We have implemented our techniques, and tested them on a suite of benchmarks from the literature. Our experiments indicate our techniques show promise on challenging verification tasks requiring non-linear reasoning.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632867", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Cyphert", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/CyphertK24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632932", + "title": "Parametric Subtyping for Structural Parametric Polymorphism", + "abstract": "We study the interaction of structural subtyping with parametric polymorphism and recursively defined type constructors. Although structural subtyping is undecidable in this setting, we describe a notion of parametricity for type constructors and then exploit it to define parametric subtyping , a conceptually simple, decidable, and expressive fragment of structural subtyping that strictly generalizes rigid subtyping . We present and prove correct an effective saturation-based decision procedure for parametric subtyping, demonstrating its applicability using a variety of examples. We also provide an implementation of this decision procedure as an artifact.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632932", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Henry", + "last_name": "DeYoung", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Andreia", + "last_name": "Mordido", + "institution": "University of Lisbon" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ankush", + "last_name": "Das", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/DeYoungMPD24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632901", + "title": "A Case for Synthesis of Recursive Quantum Unitary Programs", + "abstract": "Quantum programs are notoriously difficult to code and verify due to unintuitive quantum knowledge associated with quantum programming. Automated tools relieving the tedium and errors associated with low-level quantum details would hence be highly desirable. In this paper, we initiate the study of program synthesis for quantum unitary programs that recursively define a family of unitary circuits for different input sizes, which are widely used in existing quantum programming languages. Specifically, we present QSynth, the first quantum program synthesis framework, including a new inductive quantum programming language, its specification, a sound logic for reasoning, and an encoding of the reasoning procedure into SMT instances. By leveraging existing SMT solvers, QSynth successfully synthesizes 10 quantum unitary programs including quantum arithmetic programs, quantum eigenvalue inversion, quantum teleportation and Quantum Fourier Transformation, which can be readily transpiled to executable programs on major quantum platforms, e.g., Q#, IBM Qiskit, and AWS Braket.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632901", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Haowei", + "last_name": "Deng", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Runzhou", + "last_name": "Tao", + "institution": "Columbia University" + }, + { + "first_name": "Yuxiang", + "last_name": "Peng", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/DengTPW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632913", + "title": "Enhanced Enumeration Techniques for Syntax-Guided Synthesis of Bit-Vector Manipulations", + "abstract": "Syntax-guided synthesis has been a prevalent theme in various computer-aided programming systems. However, the domain of bit-vector synthesis poses several unique challenges that have not yet been sufficiently addressed and resolved. In this paper, we propose a novel synthesis approach that incorporates a distinct enumeration strategy based on various factors. Technically, this approach weighs in subexpression recurrence by term-graph-based enumeration, avoids useless candidates by example-guided filtration, prioritizes valuable components identified by large language models. This approach also incorporates a bottom-up deduction step to enhance the enumeration algorithm by considering subproblems that contribute to the deductive resolution. We implement all the enhanced enumeration techniques in our S y G u S solver D ryad S ynth , which outperforms state-of-the-art solvers in terms of the number of solved problems, execution time, and solution size. Notably, D ryad S ynth successfully solved 31 synthesis problems for the first time, including 5 renowned Hacker’s Delight problems.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632913", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuantian", + "last_name": "Ding", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/DingQ24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632875", + "title": "An Infinite Needle in a Finite Haystack: Finding Infinite Counter-Models in Deductive Verification", + "abstract": "First-order logic, and quantifiers in particular, are widely used in deductive verification of programs and systems. Quantifiers are essential for describing systems with unbounded domains, but prove difficult for automated solvers. Significant effort has been dedicated to finding quantifier instantiations that establish unsatisfiability of quantified formulas, thus ensuring validity of a system’s verification conditions. However, in many cases the formulas are satisfiable—this is often the case in intermediate steps of the verification process, e.g., when an invariant is not yet inductive. For such cases, existing tools are limited to finding finite models as counterexamples. Yet, some quantified formulas are satisfiable but only have infinite models, which current solvers are unable to find. Such infinite counter-models are especially typical when first-order logic is used to approximate the natural numbers, the integers, or other inductive definitions such as linked lists, which is common in deductive verification. The inability of solvers to find infinite models makes them diverge in these cases, providing little feedback to the user as they try to make progress in their verification attempts. In this paper, we tackle the problem of finding such infinite models, specifically, finite representations thereof that can be presented to the user of a deductive verification tool. These models give insight into the verification failure, and allow the user to identify and fix bugs in the modeling of the system and its properties. Our approach consists of three parts. First, we introduce symbolic structures as a way to represent certain infinite models, and show they admit an efficient model checking procedure. Second, we describe an effective model finding procedure that symbolically explores a given (possibly infinite) family of symbolic structures in search of an infinite model for a given formula. Finally, we identify a new decidable fragment of first-order logic that extends and subsumes the many-sorted variant of EPR, where satisfiable formulas always have a model representable by a symbolic structure within a known family, making our model finding procedure a decision procedure for that fragment. We evaluate our approach on examples from the domains of distributed consensus protocols and of heapmanipulating programs (specifically, linked lists). Our implementation quickly finds infinite counter-models that demonstrate the source of verification failures in a simple way, while state-of-the-art SMT solvers and theorem provers such as Z3, cvc5, and Vampire diverge or return “unknown”.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632875", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neta", + "last_name": "Elad", + "institution": "Tel Aviv University" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/EladPS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632921", + "title": "Explicit Effects and Effect Constraints in ReML", + "abstract": "An important aspect of building robust systems that execute on dedicated hardware and perhaps in constrained environments is to control and manage the effects performed by program code. We present ReML, a higher-order statically-typed functional language, which allows programmers to be explicit about the effects performed by program code and in particular effects related to memory management Allowing programmers to be explicit about effects, the regions in which values reside, and the constraints under which code execute, makes programs robust to changes in the program source code and to compiler updates, including compiler optimisations. ReML is integrated with a polymorphic inference system that builds on top of region-inference, as it is implemented in the MLKit, a Standard ML compiler that uses region-based memory management as its primary memory management scheme.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632921", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/Elsman24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632926", + "title": "Higher Order Bayesian Networks, Exactly", + "abstract": "Bayesian networks are graphical first-order probabilistic models that allow for a compact representation of large probability distributions, and for efficient inference, both exact and approximate. We introduce a higher-order programming language—in the idealized form of a λ -calculus—which we prove sound and complete w.r.t. Bayesian networks: each Bayesian network can be encoded as a term, and conversely each (possibly higher-order and recursive) program of ground type compiles into a Bayesian network. The language allows for the specification of recursive probability models and hierarchical structures. Moreover, we provide a compositional and cost-aware semantics which is based on factors, the standard mathematical tool used in Bayesian inference. Our results rely on advanced techniques rooted into linear logic, intersection types, rewriting theory, and Girard’s geometry of interaction, which are here combined in a novel way.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632926", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Claudia", + "last_name": "Faggian", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Daniele", + "last_name": "Pautasso", + "institution": "University of Turin" + }, + { + "first_name": "Gabriele", + "last_name": "Vanoni", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/FaggianPV24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632925", + "title": "Commutativity Simplifies Proofs of Parameterized Programs", + "abstract": "Commutativity has proven to be a powerful tool in reasoning about concurrent programs. Recent work has shown that a commutativity-based reduction of a program may admit simpler proofs than the program itself. The framework of lexicographical program reductions was introduced to formalize a broad class of reductions which accommodate sequential (thread-local) reasoning as well as synchronous programs. Approaches based on this framework, however, were fundamentally limited to program models with a fixed/bounded number of threads. In this paper, we show that it is possible to define an effective parametric family of program reductions that can be used to find simple proofs for parameterized programs , i.e., for programs with an unbounded number of threads. We show that reductions are indeed useful for the simplification of proofs for parameterized programs, in a sense that can be made precise: A reduction of a parameterized program may admit a proof which uses fewer or less sophisticated ghost variables. The reduction may therefore be within reach of an automated verification technique, even when the original parameterized program is not. As our first technical contribution, we introduce a notion of reductions for parameterized programs such that the reduction R of a parameterized program P is again a parameterized program (the thread template of R is obtained by source-to-source transformation of the thread template of P ). Consequently, existing techniques for the verification of parameterized programs can be directly applied to R instead of P . Our second technical contribution is that we define an appropriate family of pairwise preference orders which can be effectively used as a parameter to produce different lexicographical reductions. To determine whether this theoretical foundation amounts to a usable solution in practice, we have implemented the approach, based on a recently proposed framework for parameterized program verification. The results of our preliminary experiments on a representative set of examples are encouraging.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632925", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Dominik", + "last_name": "Klumpp", + "institution": "University of Freiburg" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + } + ], + "dblp_key": "journals/pacmpl/FarzanKP24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632873", + "title": "Coarser Equivalences for Causal Concurrency", + "abstract": "Trace theory (formulated by Mazurkiewicz in 1987) is a principled framework for defining equivalence relations for concurrent program runs based on a commutativity relation over the set of atomic steps taken by individual program threads. Its simplicity, elegance, and algorithmic efficiency makes it useful in many different contexts including program verification and testing. It is well-understood that the larger the equivalence classes are, the more benefits they would bring to the algorithms and applications that use them. In this paper, we study relaxations of trace equivalence with the goal of maintaining its algorithmic advantages. We first prove that the largest appropriate relaxation of trace equivalence, an equivalence relation that preserves the order of steps taken by each thread and what write operation each read operation observes, does not yield efficient algorithms. Specifically, we prove a linear space lower bound for the problem of checking, in a streaming setting, if two arbitrary steps of a concurrent program run are causally concurrent (i.e. they can be reordered in an equivalent run) or causally ordered (i.e. they always appear in the same order in all equivalent runs). The same problem can be decided in constant space for trace equivalence. Next, we propose a new commutativity-based notion of equivalence called grain equivalence that is strictly more relaxed than trace equivalence, and yet yields a constant space algorithm for the same problem. This notion of equivalence uses commutativity of grains , which are sequences of atomic steps, in addition to the standard commutativity from trace theory. We study the two distinct cases when the grains are contiguous subwords of the input program run and when they are not, formulate the precise definition of causal concurrency in each case, and show that they can be decided in constant space , despite being strict relaxations of the notion of causal concurrency based on trace equivalence.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632873", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/FarzanM24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632919", + "title": "Generating Well-Typed Terms That Are Not "Useless"", + "abstract": "Random generation of well-typed terms lies at the core of effective random testing of compilers for functional languages. Existing techniques have had success following a top-down type-oriented approach to generation that makes choices locally, which suffers from an inherent limitation: the type of an expression is often generated independently from the expression itself. Such generation frequently yields functions with argument types that cannot be used to produce a result in a meaningful way, leaving those arguments unused. Such “use-less” functions can hinder both performance, as the argument generation code is dead but still needs to be compiled, and effectiveness, as a lot of interesting optimizations are tested less frequently. In this paper, we introduce a novel algorithm that is significantly more effective at generating functions that use their arguments. We formalize both the “local” and the “nonlocal” algorithms as step-relations in an extension of the simply-typed lambda calculus with type and arguments holes, showing how delaying the generation of types for subexpressions by allowing nonlocal generation steps leads to “useful” functions. We implement our algorithm demonstrating that it’s much closer to real programs in terms of argument usage rate, and we replicate a case study from the literature that finds bugs in the strictness analyzer of GHC, with our approach finding bugs four times faster than the current state-of-the-art local approach.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632919", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J. Ray", + "last_name": "Frank", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Benjamin", + "last_name": "Quiring", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/FrankQL24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632854", + "title": "Modular Denotational Semantics for Effects with Guarded Interaction Trees", + "abstract": "We present guarded interaction trees — a structure and a fully formalized framework for representing higherorder computations with higher-order effects in Coq, inspired by domain theory and the recently proposed interaction trees. We also present an accompanying separation logic for reasoning about guarded interaction trees. To demonstrate that guarded interaction trees provide a convenient domain for interpreting higher-order languages with effects, we define an interpretation of a PCF-like language with effects and show that this interpretation is sound and computationally adequate; we prove the latter using a logical relation defined using the separation logic. Guarded interaction trees also allow us to combine different effects and reason about them modularly. To illustrate this point, we give a modular proof of type soundness of cross-language interactions for safe interoperability of different higher-order languages with different effects. All results in the paper are formalized in Coq using the Iris logic over guarded type theory.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632854", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dan", + "last_name": "Frumin", + "institution": "University of Groningen" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/FruminTB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632922", + "title": "Indexed Types for a Statically Safe WebAssembly", + "abstract": "We present Wasm-precheck, a superset of WebAssembly (Wasm) that uses indexed types to express and check simple constraints over program values. This additional static reasoning enables safely removing dynamic safety checks from Wasm, such as memory bounds checks. We implement Wasm-precheck as an extension of the Wasmtime compiler and runtime, evaluate the run-time and compile-time performance of Wasm-precheck vs Wasm configurations with explicit dynamic checks, and find an average run-time performance gain of 1.71 x faster in the widely used PolyBenchC benchmark suite, for a small overhead in binary size ( 7.18 % larger) and type-checking time (1.4% slower). We also prove type and memory safety of Wasm-precheck, prove Wasm safely embeds into Wasm-precheck ensuring backwards compatibility, prove Wasm-precheck type-erases to Wasm, and discuss design and implementation trade-offs.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632922", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Adam T.", + "last_name": "Geller", + "institution": "University of British Columbia" + }, + { + "first_name": "J. Ray", + "last_name": "Frank", + "institution": "University of British Columbia" + }, + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/GellerFB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632868", + "title": "Asynchronous Probabilistic Couplings in Higher-Order Separation Logic", + "abstract": "Probabilistic couplings are the foundation for many probabilistic relational program logics and arise when relating random sampling statements across two programs. In relational program logics, this manifests as dedicated coupling rules that, e.g ., say we may reason as if two sampling statements return the same value. However, this approach fundamentally requires aligning or “synchronizing” the sampling statements of the two programs which is not always possible. In this paper, we develop Clutch, a higher-order probabilistic relational separation logic that addresses this issue by supporting asynchronous probabilistic couplings. We use Clutch to develop a logical step-indexed logical relation to reason about contextual refinement and equivalence of higher-order programs written in a rich language with a probabilistic choice operator, higher-order local state, and impredicative polymorphism. Finally, we demonstrate our approach on a number of case studies. All the results that appear in the paper have been formalized in the Coq proof assistant using the Coquelicot library and the Iris separation logic framework.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632868", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "Aarhus University" + }, + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Philipp G.", + "last_name": "Haselwarter", + "institution": "Aarhus University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/GregersenAHTB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632852", + "title": "Decalf: A Directed, Effectful Cost-Aware Logical Framework", + "abstract": "We present decalf , a d irected, e ffectful c ost- a ware l ogical f ramework for studying quantitative aspects of functional programs with effects. Like calf , the language is based on a formal phase distinction between the extension and the intension of a program, its pure behavior as distinct from its cost measured by an effectful step-counting primitive. The type theory ensures that the behavior is unaffected by the cost accounting. Unlike calf , the present language takes account of effects , such as probabilistic choice and mutable state. This extension requires a reformulation of calf ’s approach to cost accounting: rather than rely on a “separable” notion of cost, here a cost bound is simply another program . To make this formal, we equip every type with an intrinsic preorder, relaxing the precise cost accounting intrinsic to a program to a looser but nevertheless informative estimate. For example, the cost bound of a probabilistic program is itself a probabilistic program that specifies the distribution of costs. This approach serves as a streamlined alternative to the standard method of isolating a cost recurrence and readily extends to higher-order, effectful programs. The development proceeds by first introducing the decalf type system, which is based on an intrinsic ordering among terms that restricts in the extensional phase to extensional equality, but in the intensional phase reflects an approximation of the cost of a program of interest. This formulation is then applied to a number of illustrative examples, including pure and effectful sorting algorithms, simple probabilistic programs, and higher-order functions. Finally, we justify decalf via a model in the topos of augmented simplicial sets.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632852", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harrison", + "last_name": "Grodin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yue", + "last_name": "Niu", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Sterling", + "institution": "University of Cambridge" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/GrodinNSH24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632881", + "title": "Orthologic with Axioms", + "abstract": "We study the proof theory and algorithms for orthologic, a logical system based on ortholattices, which have shown practical relevance in simplification and normalization of verification conditions. Ortholattices weaken Boolean algebras while having polynomial-time equivalence checking that is sound with respect to Boolean algebra semantics. We generalize ortholattice reasoning and obtain an algorithm for proving a larger class of classically valid formulas. As the key result, we analyze a proof system for orthologic augmented with axioms. An important feature of the system is that it limits the number of formulas in a sequent to at most two, which makes the extension with axioms non-trivial. We show a generalized form of cut elimination for this system, which implies a sub-formula property. From there we derive a cubic-time algorithm for provability from axioms, or equivalently, for validity in finitely presented ortholattices. We further show that propositional resolution of width 5 proves all formulas provable in orthologic with axioms. We show that orthologic system subsumes resolution of width 2 and arbitrarily wide unit resolution and is complete for reasoning about generalizations of propositional Horn clauses. Moving beyond ground axioms, we introduce effectively propositional orthologic (by analogy with EPR for classical logic), presenting its semantics as well as a sound and complete proof system. Our proof system implies the decidability of effectively propositional orthologic, as well as its fixed-parameter tractability for a bounded maximal number of variables in each axiom. As a special case, we obtain a generalization of Datalog with negation and disjunction.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632881", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon", + "last_name": "Guilloud", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/GuilloudK24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632844", + "title": "Deciding Asynchronous Hyperproperties for Recursive Programs", + "abstract": "We introduce a novel logic for asynchronous hyperproperties with a new mechanism to identify relevant positions on traces. While the new logic is more expressive than a related logic presented recently by Bozzelli et al., we obtain the same complexity of the model checking problem for finite state models. Beyond this, we study the model checking problem of our logic for pushdown models. We argue that the combination of asynchronicity and a non-regular model class studied in this paper constitutes the first suitable approach for hyperproperty model checking against recursive programs.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632844", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jens Oliver", + "last_name": "Gutsfeld", + "institution": "University of Münster" + }, + { + "first_name": "Markus", + "last_name": "Müller-Olm", + "institution": "University of Münster" + }, + { + "first_name": "Christoph", + "last_name": "Ohrem", + "institution": "University of Münster" + } + ], + "dblp_key": "journals/pacmpl/GutsfeldMO24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632907", + "title": "Parikh's Theorem Made Symbolic", + "abstract": "Parikh’s Theorem is a fundamental result in automata theory with numerous applications in computer science. These include software verification (e.g. infinite-state verification, string constraints, and theory of arrays), verification of cryptographic protocols (e.g. using Horn clauses modulo equational theories) and database querying (e.g. evaluating path-queries in graph databases), among others. Parikh’s Theorem states that the letter-counting abstraction of a language recognized by finite automata or context-free grammars is definable in Linear Integer Arithmetic (a.k.a. Presburger Arithmetic). In fact, there is a linear-time algorithm computing existential Presburger formulas capturing such abstractions, which enables an efficient analysis via SMT-solvers. Unfortunately, real-world applications typically require large alphabets (e.g. Unicode, containing a million of characters) — which are well-known to be not amenable to explicit treatment of the alphabets — or even worse infinite alphabets. Symbolic automata have proven in the last decade to be an effective algorithmic framework for handling large finite or even infinite alphabets. A symbolic automaton employs an effective boolean algebra, which offers a symbolic representation of character sets (i.e. in terms of predicates) and often lends itself to an exponentially more succinct representation of a language. Instead of letter-counting, Parikh’s Theorem for symbolic automata amounts to counting the number of times different predicates are satisfied by an input sequence. Unfortunately, naively applying Parikh’s Theorem from classical automata theory to symbolic automata yields existential Presburger formulas of exponential size. In this paper, we provide a new construction for Parikh’s Theorem for symbolic automata and grammars, which avoids this exponential blowup: our algorithm computes an existential formula in polynomial-time over (quantifier-free) Presburger and the base theory. In fact, our algorithm extends to the model of parametric symbolic grammars, which are one of the most expressive models of languages over infinite alphabets. We have implemented our algorithm and show it can be used to solve string constraints that are difficult to solve by existing solvers.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632907", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Artur", + "last_name": "Jeż", + "institution": "University of Wrocław" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Kaiserslautern" + } + ], + "dblp_key": "journals/pacmpl/HagueJL24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632863", + "title": "An Axiomatic Basis for Computer Programming on the Relaxed Arm-A Architecture: The AxSL Logic", + "abstract": "Very relaxed concurrency memory models, like those of the Arm-A, RISC-V, and IBM Power hardware architectures, underpin much of computing but break a fundamental intuition about programs, namely that syntactic program order and the reads-from relation always both induce order in the execution. Instead, out-of-order execution is allowed except where prevented by certain pairwise dependencies, barriers, or other synchronisation. This means that there is no notion of the 'current' state of the program, making it challenging to design (and prove sound) syntax-directed, modular reasoning methods like Hoare logics, as usable resources cannot implicitly flow from one program point to the next. We present AxSL, a separation logic for the relaxed memory model of Arm-A, that captures the fine-grained reasoning underpinning the low-overhead synchronisation mechanisms used by high-performance systems code. In particular, AxSL allows transferring arbitrary resources using relaxed reads and writes when they induce inter-thread ordering. We mechanise AxSL in the Iris separation logic framework, illustrate it on key examples, and prove it sound with respect to the axiomatic memory model of Arm-A. Our approach is largely generic in the axiomatic model and in the instruction-set semantics, offering a potential way forward for compositional reasoning for other similar models, and for the combination of production concurrency models and full-scale ISAs.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632863", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Angus", + "last_name": "Hammond", + "institution": "University of Cambridge" + }, + { + "first_name": "Zongyuan", + "last_name": "Liu", + "institution": "Aarhus University" + }, + { + "first_name": "Thibaut", + "last_name": "Pérami", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/HammondLPSBP24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632899", + "title": "Solving Infinite-State Games via Acceleration", + "abstract": "Two-player graph games have found numerous applications, most notably in the synthesis of reactive systems from temporal specifications, but also in verification. The relevance of infinite-state systems in these areas has lead to significant attention towards developing techniques for solving infinite-state games. We propose novel symbolic semi-algorithms for solving infinite-state games with temporal winning conditions. The novelty of our approach lies in the introduction of an acceleration technique that enhances fixpoint-based game-solving methods and helps to avoid divergence. Classical fixpoint-based algorithms, when applied to infinite-state games, are bound to diverge in many cases, since they iteratively compute the set of states from which one player has a winning strategy. Our proposed approach can lead to convergence in cases where existing algorithms require an infinite number of iterations. This is achieved by acceleration: computing an infinite set of states from which a simpler sub-strategy can be iterated an unbounded number of times in order to win the game. Ours is the first method for solving infinite-state games to employ acceleration. Thanks to this, it is able to outperform state-of-the-art techniques on a range of benchmarks, as evidenced by our evaluation of a prototype implementation.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632899", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philippe", + "last_name": "Heim", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Rayna", + "last_name": "Dimitrova", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "journals/pacmpl/HeimD24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632869", + "title": "Quotient Haskell: Lightweight Quotient Types for All", + "abstract": "Subtypes and quotient types are dual type abstractions. However, while subtypes are widely used both explicitly and implicitly, quotient types have not seen much practical use outside of proof assistants. A key difficulty to wider adoption of quotient types lies in the significant burden of proof-obligations that arises from their use. In this article, we address this issue by introducing a class of quotient types for which the proof-obligations are decidable by an SMT solver. We demonstrate this idea in practice by presenting Quotient Haskell , an extension of Liquid Haskell with support for quotient types.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632869", + "conference_name": "POPL", + "authors": [ + { + "first_name": "B", + "last_name": "Hewer", + "institution": "University of Nottingham" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/HewerH24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632864", + "title": "Regular Abstractions for Array Systems", + "abstract": "Verifying safety and liveness over array systems is a highly challenging problem. Array systems naturally capture parameterized systems such as distributed protocols with an unbounded number of processes. Such distributed protocols often exploit process IDs during their computation, resulting in array systems whose element values range over an infinite domain. In this paper, we develop a novel framework for proving safety and liveness over array systems. The crux of the framework is to overapproximate an array system as a string rewriting system (i.e. over a finite alphabet) by means of a new predicate abstraction that exploits the so-called indexed predicates. This allows us to tap into powerful verification methods for string rewriting systems that have been heavily developed in the last two decades or so (e.g. regular model checking). We demonstrate how our method yields simple, automatically verifiable proofs of safety and liveness properties for challenging examples, including Dijkstra’s self-stabilizing protocol and the Chang-Roberts leader election protocol.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632864", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chih-Duo", + "last_name": "Hong", + "institution": "National Chengchi University" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Kaiserslautern" + } + ], + "dblp_key": "journals/pacmpl/HongL24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632889", + "title": "Deadlock-Free Separation Logic: Linearity Yields Progress for Dependent Higher-Order Message Passing", + "abstract": "We introduce a linear concurrent separation logic, called LinearActris , designed to guarantee deadlock and leak freedom for message-passing concurrency. LinearActris combines the strengths of session types and concurrent separation logic, allowing for the verification of challenging higher-order programs with mutable state through dependent protocols. The key challenge is to prove the adequacy theorem of LinearActris, which says that the logic indeed gives deadlock and leak freedom “for free” from linearity. We prove this theorem by defining a step-indexed model of separation logic, based on connectivity graphs . To demonstrate the expressive power of LinearActris, we prove soundness of a higher-order (GV-style) session type system using the technique of logical relations. All our results and examples have been mechanized in Coq.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632889", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", + "institution": "Aarhus University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/JacobsHK24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632924", + "title": "A Universal, Sound, and Complete Forward Reasoning Technique for Machine-Verified Proofs of Linearizability", + "abstract": "We introduce simple, universal , sound , and complete proof methods for producing machine-verifiable proofs of linearizability and strong linearizability. Universality means that our method works for any object type; soundness means that an algorithm can be proved correct by our method only if it is linearizable (resp. strong linearizable); and completeness means that any linearizable (resp. strong linearizable) implementation can be proved so using our method. We demonstrate the simplicity and power of our method by producing proofs of linearizability for the Herlihy-Wing queue and Jayanti's single-scanner snapshot, as well as a proof of strong linearizability of the Jayanti-Tarjan union-find object. All three of these proofs are machine-verified by TLAPS (the TLA+ Proof System).", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632924", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Prasad", + "last_name": "Jayanti", + "institution": "Dartmouth College" + }, + { + "first_name": "Siddhartha", + "last_name": "Jayanti", + "institution": "Google (United States)" + }, + { + "first_name": "Uğur", + "last_name": "Yavuz", + "institution": "" + }, + { + "first_name": "Lizzie", + "last_name": "Hernandez", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/JayantiJYH24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3633280", + "title": "Answer Refinement Modification: Refinement Type System for Algebraic Effects and Handlers", + "abstract": "Algebraic effects and handlers are a mechanism to structure programs with computational effects in a modular way. They are recently gaining popularity and being adopted in practical languages, such as OCaml. Meanwhile, there has been substantial progress in program verification via refinement type systems . While a variety of refinement type systems have been proposed, thus far there has not been a satisfactory refinement type system for algebraic effects and handlers. In this paper, we fill the void by proposing a novel refinement type system for languages with algebraic effects and handlers. The expressivity and usefulness of algebraic effects and handlers come from their ability to manipulate delimited continuations , but delimited continuations also complicate programs' control flow and make their verification harder. To address the complexity, we introduce a novel concept that we call answer refinement modification (ARM for short), which allows the refinement type system to precisely track what effects occur and in what order when a program is executed, and reflect such information as modifications to the refinements in the types of delimited continuations. We formalize our type system that supports ARM (as well as answer type modification, or ATM) and prove its soundness. Additionally, as a proof of concept, we have extended the refinement type system to a subset of OCaml 5 which comes with a built-in support for effect handlers, implemented a type checking and inference algorithm for the extension, and evaluated it on a number of benchmark programs that use algebraic effects and handlers. The evaluation demonstrates that ARM is conceptually simple and practically useful. Finally, a natural alternative to directly reasoning about a program with delimited continuations is to apply a continuation passing style (CPS) transformation that transforms the program to a pure program without delimited continuations. We investigate this alternative in the paper, and show that the approach is indeed possible by proposing a novel CPS transformation for algebraic effects and handlers that enjoys bidirectional (refinement-)type-preservation. We show that there are pros and cons with this approach, namely, while one can use an existing refinement type checking and inference algorithm that can only (directly) handle pure programs, there are issues such as needing type annotations in source programs and making the inferred types less informative to a user.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3633280", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fuga", + "last_name": "Kawamata", + "institution": "Waseda University" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" + }, + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Waseda University" + } + ], + "dblp_key": "journals/pacmpl/KawamataUST24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632898", + "title": "Algebraic Effects Meet Hoare Logic in Cubical Agda", + "abstract": "This paper presents a novel formalisation of algebraic effects with equations in Cubical Agda. Unlike previous work in the literature that employed setoids to deal with equations, the library presented here uses quotient types to faithfully encode the type of terms quotiented by laws. Apart from tools for equational reasoning, the library also provides an effect-generic Hoare logic for algebraic effects, which enables reasoning about effectful programs in terms of their pre- and post-conditions. A particularly novel aspect is that equational reasoning and Hoare-style reasoning are related by an elimination principle of Hoare logic.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632898", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Donnacha Oisín", + "last_name": "Kidney", + "institution": "Imperial College London" + }, + { + "first_name": "Zhixuan", + "last_name": "Yang", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/KidneyYW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632900", + "title": "Guided Equality Saturation", + "abstract": "Rewriting is a principled term transformation technique with uses across theorem proving and compilation. In theorem proving, each rewrite is a proof step; in compilation, rewrites optimize a program term. While developing rewrite sequences manually is possible, this process does not scale to larger rewrite sequences. Automated rewriting techniques, like greedy simplification or equality saturation, work well without requiring human input. Yet, they do not scale to large search spaces, limiting the complexity of tasks where automated rewriting is effective, and meaning that just a small increase in term size or rewrite length may result in failure. This paper proposes a semi-automatic rewriting technique as a means to scale rewriting by allowing human insight at key decision points. Specifically, we propose guided equality saturation that embraces human guidance when fully automated equality saturation does not scale. The rewriting is split into two simpler automatic equality saturation steps: from the original term to a human-provided intermediate guide , and from the guide to the target. Complex rewriting tasks may require multiple guides, resulting in a sequence of equality saturation steps. A guide can be a complete term, or a sketch containing undefined elements that are instantiated by the equality saturation search. Such sketches may be far more concise than complete terms. We demonstrate the generality and effectiveness of guided equality saturation using two case studies. First, we integrate guided equality saturation in the Lean 4 proof assistant. Proofs are written in the style of textbook proof sketches, as a series of calculations omitting details and skipping steps. These proofs conclude in less than a second instead of minutes when compared to unguided equality saturation, and can find complex proofs that previously had to be done manually. Second, in the compiler of the RISE array language, where unguided equality saturation fails to perform optimizations within an hour and using 60 GB of memory, guided equality saturation performs the same optimizations with at most 3 guides, within seconds using less than 1 GB memory.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632900", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Kœhler", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Andrés", + "last_name": "Goens", + "institution": "Amsterdam University of the Arts" + }, + { + "first_name": "Siddharth", + "last_name": "Bhat", + "institution": "Edinburgh College" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Cambridge" + }, + { + "first_name": "Phil", + "last_name": "Trinder", + "institution": "University of Glasgow" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "Edinburgh College" + } + ], + "dblp_key": "journals/pacmpl/KoehlerGBGTS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632884", + "title": "On-the-Fly Static Analysis via Dynamic Bidirected Dyck Reachability", + "abstract": "Dyck reachability is a principled, graph-based formulation of a plethora of static analyses. Bidirected graphs are used for capturing dataflow through mutable heap data, and are usual formalisms of demand-driven points-to and alias analyses. The best (offline) algorithm runs in O ( m + n · α ( n ) ) time, where n is the number of nodes and m is the number of edges in the flow graph, which becomes O ( n 2 ) in the worst case. In the everyday practice of program analysis, the analyzed code is subject to continuous change, with source code being added and removed. On-the-fly static analysis under such continuous updates gives rise to dynamic Dyck reachability , where reachability queries run on a dynamically changing graph, following program updates. Naturally, executing the offline algorithm in this online setting is inadequate, as the time required to process a single update is prohibitively large. In this work we develop a novel dynamic algorithm for bidirected Dyck reachability that has O ( n · α ( n ) ) worst-case performance per update, thus beating the O ( n 2 ) bound, and is also optimal in certain settings. We also implement our algorithm and evaluate its performance on on-the-fly data-dependence and alias analyses, and compare it with two best known alternatives, namely (i) the optimal offline algorithm, and (ii) a fully dynamic Datalog solver. Our experiments show that our dynamic algorithm is consistently, and by far, the top performing algorithm, exhibiting speedups in the order of 1000X. The running time of each update is almost always unnoticeable to the human eye, making it ideal for the on-the-fly analysis setting.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632884", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shankara Narayanan", + "last_name": "Krishna", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "A. K.", + "last_name": "Lal", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + }, + { + "first_name": "Omkar", + "last_name": "Tuppe", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "journals/pacmpl/KrishnaLPT24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632929", + "title": "On Model-Checking Higher-Order Effectful Programs", + "abstract": "Model-checking is one of the most powerful techniques for verifying systems and programs, which since the pioneering results by Knapik et al., Ong, and Kobayashi, is known to be applicable to functional programs with higher-order types against properties expressed by formulas of monadic second-order logic. What happens when the program in question, in addition to higher-order functions, also exhibits algebraic effects such as probabilistic choice or global store? The results in the literature range from those, mostly positive, about nondeterministic effects, to those about probabilistic effects, in the presence of which even mere reachability becomes undecidable. This work takes a fresh and general look at the problem, first of all showing that there is an elegant and natural way of viewing higher-order programs producing algebraic effects as ordinary higher-order recursion schemes. We then move on to consider effect handlers, showing that in their presence the model checking problem is bound to be undecidable in the general case, while it stays decidable when handlers have a simple syntactic form, still sufficient to capture so-called generic effects . Along the way, we hint at how a general specification language could look like, this way justifying some of the results in the literature, and deriving new ones.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632929", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Alexis", + "last_name": "Ghyselen", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/LagoG24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632894", + "title": "Efficient Bottom-Up Synthesis for Programs with Local Variables", + "abstract": "We propose a new synthesis algorithm that can efficiently search programs with local variables (e.g., those introduced by lambdas). Prior bottom-up synthesis algorithms are not able to evaluate programs with free local variables , and therefore cannot effectively reduce the search space of such programs (e.g., using standard observational equivalence reduction techniques), making synthesis slow. Our algorithm can reduce the space of programs with local variables. The key idea, dubbed lifted interpretation , is to lift up the program interpretation process, from evaluating one program at a time to simultaneously evaluating all programs from a grammar. Lifted interpretation provides a mechanism to systematically enumerate all binding contexts for local variables, thereby enabling us to evaluate and reduce the space of programs with local variables. Our ideas are instantiated in the domain of web automation. The resulting tool, Arborist , can automate a significantly broader range of challenging tasks more efficiently than state-of-the-art techniques including WebRobot and Helena.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632894", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xiang", + "last_name": "Li", + "institution": "University of Michigan" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhou", + "institution": "University of Michigan" + }, + { + "first_name": "Rui", + "last_name": "Dong", + "institution": "University of Michigan" + }, + { + "first_name": "Yihong", + "last_name": "Zhang", + "institution": "University of Washington" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/LiZDZW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632886", + "title": "Internalizing Indistinguishability with Dependent Types", + "abstract": "In type systems with dependency tracking, programmers can assign an ordered set of levels to computations and prevent information flow from high-level computations to the low-level ones. The key notion in such systems is indistinguishability : a definition of program equivalence that takes into account the parts of the program that an observer may depend on. In this paper, we investigate the use of dependency tracking in the context of dependently-typed languages. We present the Dependent Calculus of Indistinguishability (DCOI), a system that adopts indistinguishability as the definition of equality used by the type checker. DCOI also internalizes that relation as an observer-indexed propositional equality type, so that programmers may reason about indistinguishability within the language. Our design generalizes and extends prior systems that combine dependency tracking with dependent types and is the first to support conversion and propositional equality at arbitrary observer levels. We have proven type soundness and noninterference theorems for DCOI and have developed a prototype implementation of its type checker.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632886", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yiyun", + "last_name": "Liu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jonathan", + "last_name": "Chan", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jessica", + "last_name": "Shi", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LiuCSW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632917", + "title": "ReLU Hull Approximation", + "abstract": "Convex hulls are commonly used to tackle the non-linearity of activation functions in the verification of neural networks. Computing the exact convex hull is a costly task though. In this work, we propose a fast and precise approach to over-approximating the convex hull of the ReLU function (referred to as the ReLU hull ), one of the most used activation functions. Our key insight is to formulate a convex polytope that “wraps” the ReLU hull, by reusing the linear pieces of the ReLU function as the lower faces and constructing upper faces that are adjacent to the lower faces. The upper faces can be efficiently constructed based on the edges and vertices of the lower faces, given that an n -dimensional (or simply n d hereafter) hyperplane can be determined by an ( n - 1 ) d hyperplane and a point outside of it. We implement our approach as WraLU , and evaluate its performance in terms of precision, efficiency, constraint complexity, and scalability. WraLU outperforms existing advanced methods by generating fewer constraints to achieve tighter approximation in less time. It exhibits versatility by effectively addressing arbitrary input polytopes and higher-dimensional cases, which are beyond the capabilities of existing methods. We integrate WraLU into PRIMA, a state-of-the-art neural network verifier, and apply it to verify large-scale ReLU-based neural networks. Our experimental results demonstrate that WraLU achieves a high efficiency without compromising precision. It reduces the number of constraints that need to be solved by the linear programming solver by up to half, while delivering comparable or even superior results compared to the state-of-the-art verifiers.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632917", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhongkui", + "last_name": "Ma", + "institution": "The University of Queensland" + }, + { + "first_name": "Jiaying", + "last_name": "Li", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Guangdong", + "last_name": "Bai", + "institution": "The University of Queensland" + } + ], + "dblp_key": "journals/pacmpl/MaLB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632879", + "title": "Positive Almost-Sure Termination: Complexity and Proof Rules", + "abstract": "We study the recursion-theoretic complexity of Positive Almost-Sure Termination (PAST) in an imperative programming language with rational variables, bounded nondeterministic choice, and discrete probabilistic choice. A program terminates positive almost-surely if, for every scheduler, the program terminates almost-surely and the expected runtime to termination is finite. We show that PAST for our language is complete for the (lightface) co-analytic sets ( Π 1 1 -complete). This is in contrast to the related notions of Almost-Sure Termination (AST) and Bounded Termination (BAST), both of which are arithmetical ( Π 2 0 - and Σ 2 0 -complete respectively). Our upper bound implies an effective procedure to reduce reasoning about probabilistic termination to non-probabilistic fair termination in a model with bounded nondeterminism, and to simple program termination in models with unbounded nondeterminism. Our lower bound shows the opposite: for every program with unbounded nondeterministic choice, there is an effectively computable probabilistic program with bounded choice such that the original program is terminating if, and only if, the transformed program is PAST. We show that every program has an effectively computable normal form, in which each probabilistic choice either continues or terminates execution immediately, each with probability 1 / 2 . For normal form programs, we provide a sound and complete proof rule for PAST. Our proof rule uses transfinite ordinals. We show that reasoning about PAST requires transfinite ordinals up to ω 1 CK ; thus, existing techniques for probabilistic termination based on ranking supermartingales that map program states to reals do not suffice to reason about PAST.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632879", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "V. R.", + "last_name": "Sathiyanarayana", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/MajumdarS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632934", + "title": "Efficient Matching of Regular Expressions with Lookaround Assertions", + "abstract": "Regular expressions have been extended with lookaround assertions, which are subdivided into lookahead and lookbehind assertions. These constructs are used to refine when a match for a pattern occurs in the input text based on the surrounding context. Current implementation techniques for lookaround involve backtracking search, which can give rise to running time that is super-linear in the length of input text. In this paper, we first consider a formal mathematical semantics for lookaround, which complements the commonly used operational understanding of lookaround in terms of a backtracking implementation. Our formal semantics allows us to establish several equational properties for simplifying lookaround assertions. Additionally, we propose a new algorithm for matching regular expressions with lookaround that has time complexity O m ⋅ n , where m is the size of the regular expression and n is the length of the input text. The algorithm works by evaluating lookaround assertions in a bottom-up manner. Our algorithm makes use of a new notion of nondeterministic finite automata (NFAs), which we call oracle-NFAs. These automata are augmented with epsilon-transitions that are guarded by oracle queries that provide the truth values of lookaround assertions at every position in the text. We provide an implementation of our algorithm that incorporates three performance optimizations for reducing the work performed and memory used. We present an experimental comparison against PCRE and Java’s regex library, which are state-of-the-art regex engines that support lookaround assertions. Our experimental results show that, in contrast to PCRE and Java, our implementation does not suffer from super-linear running time and is several times faster.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632934", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + }, + { + "first_name": "Agnishom", + "last_name": "Chattopadhyay", + "institution": "Rice University" + } + ], + "dblp_key": "journals/pacmpl/MamourasC24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632848", + "title": "An Iris Instance for Verifying CompCert C Programs", + "abstract": "Iris is a generic separation logic framework that has been instantiated to reason about a wide range of programming languages and language features. Most Iris instances are defined on simple core calculi, but by connecting Iris to new or existing formal semantics for practical languages, we can also use it to reason about real programs. In this paper we develop an Iris instance based on CompCert, the verified C compiler, allowing us to prove correctness of C programs under the same semantics we use to compile and run them. We take inspiration from the Verified Software Toolchain (VST), a prior separation logic for CompCert C, and reimplement the program logic of VST in Iris. Unlike most Iris instances, this involves both a new model of resources for CompCert memories, and a new definition of weakest preconditions/Hoare triples, as the Iris defaults for both of these cannot be applied to CompCert as is. Ultimately, we obtain a complete program logic for CompCert C within Iris, and we reconstruct enough of VST’s top-level automation to prove correctness of simple C programs.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632848", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William", + "last_name": "Mansky", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Ke", + "last_name": "Du", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "journals/pacmpl/ManskyD24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632858", + "title": "Optimal Program Synthesis via Abstract Interpretation", + "abstract": "We consider the problem of synthesizing programs with numerical constants that optimize a quantitative objective, such as accuracy, over a set of input-output examples. We propose a general framework for optimal synthesis of such programs in a given domain specific language (DSL), with provable optimality guarantees. Our framework enumerates programs in a general search graph, where nodes represent subsets of concrete programs. To improve scalability, it uses A * search in conjunction with a search heuristic based on abstract interpretation; intuitively, this heuristic establishes upper bounds on the value of subtrees in the search graph, enabling the synthesizer to identify and prune subtrees that are provably suboptimal. In addition, we propose a natural strategy for constructing abstract transformers for monotonic semantics, which is a common property for components in DSLs for data classification. Finally, we implement our approach in the context of two such existing DSLs, demonstrating that our algorithm is more scalable than existing optimal synthesizers.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632858", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Mell", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/MellZB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632853", + "title": "DisLog: A Separation Logic for Disentanglement", + "abstract": "Disentanglement is a run-time property of parallel programs that facilitates task-local reasoning about the memory footprint of parallel tasks. In particular, it ensures that a task does not access any memory locations allocated by another concurrently executing task. Disentanglement can be exploited, for example, to implement a high-performance parallel memory manager, such as in the MPL (MaPLe) compiler for Parallel ML. Prior research on disentanglement has focused on the design of optimizations, either trusting the programmer to provide a disentangled program or relying on runtime instrumentation for detecting and managing entanglement. This paper provides the first static approach to verify that a program is disentangled: it contributes DisLog, a concurrent separation logic for disentanglement. DisLog enriches concurrent separation logic with the notions necessary for reasoning about the fork-join structure of parallel programs, allowing the verification that memory accesses are effectively disentangled. A large class of programs, including race-free programs, exhibit memory access patterns that are disentangled \"by construction\". To reason about these patterns, the paper distills from DisLog an almost standard concurrent separation logic, called DisLog+. In this high-level logic, no specific reasoning about memory accesses is needed: functional correctness proofs entail disentanglement. The paper illustrates the use of DisLog and DisLog+ on a range of case studies, including two different implementations of parallel deduplication via concurrent hashing. All our results are mechanized in the Coq proof assistant using Iris.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632853", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexandre", + "last_name": "Moine", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/MoineWB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632930", + "title": "Effectful Software Contracts", + "abstract": "Software contracts empower programmers to describe functional properties of components. When it comes to constraining effects, though, the literature offers only one-off solutions for various effects. It lacks a universal principle. This paper presents the design of an effectful contract system in the context of effect handlers. A key metatheorem shows that contracts cannot unduly interfere with a program’s execution. An implementation of this design, along with an evaluation of its generality, demonstrates that the theory can guide practice.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632930", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cameron", + "last_name": "Moy", + "institution": "Northeastern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/MoyDF24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632872", + "title": "Strong Invariants Are Hard: On the Hardness of Strongest Polynomial Invariants for (Probabilistic) Programs", + "abstract": "We show that computing the strongest polynomial invariant for single-path loops with polynomial assignments is at least as hard as the Skolem problem, a famous problem whose decidability has been open for almost a century. While the strongest polynomial invariants are computable for affine loops , for polynomial loops the problem remained wide open. As an intermediate result of independent interest, we prove that reachability for discrete polynomial dynamical systems is Skolem -hard as well. Furthermore, we generalize the notion of invariant ideals and introduce moment invariant ideals for probabilistic programs. With this tool, we further show that the strongest polynomial moment invariant is (i) uncomputable, for probabilistic loops with branching statements, and (ii) Skolem -hard to compute for polynomial probabilistic loops without branching statements. Finally, we identify a class of probabilistic loops for which the strongest polynomial moment invariant is computable and provide an algorithm for it.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632872", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julian", + "last_name": "Müllner", + "institution": "TU Wien" + }, + { + "first_name": "Marcel", + "last_name": "Moosbrugger", + "institution": "TU Wien" + }, + { + "first_name": "Laura", + "last_name": "Kovács", + "institution": "TU Wien" + } + ], + "dblp_key": "journals/pacmpl/MullnerMK24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632850", + "title": "Internal and Observational Parametricity for Cubical Agda", + "abstract": "Two approaches exist to incorporate parametricity into proof assistants based on dependent type theory. On the one hand, parametricity translations conveniently compute parametricity statements and their proofs solely based on individual well-typed polymorphic programs. But they do not offer internal parametricity: formal proofs that any polymorphic program of a certain type satisfies its parametricity statement. On the other hand, internally parametric type theories augment plain type theory with additional primitives out of which internal parametricity can be derived. But those type theories lack mature proof assistant implementations and deriving parametricity in them involves low-level intractable proofs. In this paper, we contribute Agda --bridges: the first practical internally parametric proof assistant. We provide the first mechanized proofs of crucial theorems for internal parametricity, like the relativity theorem. We identify a high-level sufficient condition for proving internal parametricity which we call the structure relatedness principle (SRP) by analogy with the structure identity principle (SIP) of HoTT/UF. We state and prove a general parametricity theorem for types that satisfy the SRP. Our parametricity theorem lets us obtain one-liner proofs of standard internal free theorems. We observe that the SRP is harder to prove than the SIP and provide in Agda --bridges a shallowly embedded type theory to compose types that satisfy the SRP. This type theory is an observational type theory of logical relations and our parametricity theorem ought to be one of its inference rules.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632850", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Antoine Van", + "last_name": "Muylder", + "institution": "KU Leuven" + }, + { + "first_name": "Andreas", + "last_name": "Nuyts", + "institution": "KU Leuven" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/MuylderND24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632870", + "title": "Semantic Code Refactoring for Abstract Data Types", + "abstract": "Modifications to the data representation of an abstract data type (ADT) can require significant semantic refactoring of the code. Motivated by this observation, this paper presents a new method to automate semantic code refactoring tasks. Our method takes as input the original ADT implementation, a new data representation, and a so-called relational representation invariant (relating the old and new data representations), and automatically generates a new ADT implementation that is semantically equivalent to the original version. Our method is based on counterexample-guided inductive synthesis (CEGIS) but leverages three key ideas that allow it to handle real-world refactoring tasks. First, our approach reduces the underlying relational synthesis problem to a set of (simpler) programming-by-example problems, one for each method in the ADT. Second, it leverages symbolic reasoning techniques, based on logical abduction, to deduce code snippets that should occur in the refactored version. Finally, it utilizes a notion of partial equivalence to make inductive synthesis much more effective in this setting. We have implemented the proposed approach in a new tool called Revamp for automatically refactoring Java classes and evaluated it on 30 Java class mined from Github. Our evaluation shows that Revamp can correctly refactor the entire ADT in 97% of the cases and that it can successfully re-implement 144 out of the 146 methods that require modifications.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632870", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "Simon Fraser University" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/PailoorWD24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632890", + "title": "When Subtyping Constraints Liberate: A Novel Type Inference Approach for First-Class Polymorphism", + "abstract": "Type inference in the presence of first-class or “ impredicative ” second-order polymorphism à la System F has been an active research area for several decades, with original works dating back to the end of the 80s. Yet, until now many basic problems remain open, such as how to type check expressions like ( λ x . ( x 123 , x True ) ) id reliably. We show that a type inference approach based on multi-bounded polymorphism , a form of implicit polymorphic subtyping with multiple lower and upper bounds, can help us resolve most of these problems in a uniquely simple and regular way. We define F ≤ , a declarative type system derived from the existing theory of implicit coercions by Cretin and Rémy (LICS 2014), and we introduce SuperF, a novel algorithm to infer polymorphic multi-bounded F ≤ types while checking user type annotations written in the syntax of System F. We use a recursion-avoiding heuristic to guarantee termination of type inference at the cost of rejecting some valid programs, which thankfully rarely triggers in practice. We show that SuperF is vastly more powerful than all first-class-polymorphic type inference systems proposed so far, significantly advancing the state of the art in type inference for general-purpose programming languages.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632890", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Aleksander", + "last_name": "Boruch-Gruszecki", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Andong", + "last_name": "Fan", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Chun Yin", + "last_name": "Chau", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ParreauxBFC24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632860", + "title": "Programming-by-Demonstration for Long-Horizon Robot Tasks", + "abstract": "The goal of programmatic Learning from Demonstration (LfD) is to learn a policy in a programming language that can be used to control a robot’s behavior from a set of user demonstrations. This paper presents a new programmatic LfD algorithm that targets long-horizon robot tasks which require synthesizing programs with complex control flow structures, including nested loops with multiple conditionals. Our proposed method first learns a program sketch that captures the target program’s control flow and then completes this sketch using an LLM-guided search procedure that incorporates a novel technique for proving unrealizability of programming-by-demonstration problems. We have implemented our approach in a new tool called prolex and present the results of a comprehensive experimental evaluation on 120 benchmarks involving complex tasks and environments. We show that, given a 120 second time limit, prolex can find a program consistent with the demonstrations in 80% of the cases. Furthermore, for 81% of the tasks for which a solution is returned, prolex is able to find the ground truth program with just one demonstration. In comparison, CVC5, a syntaxguided synthesis tool, is only able to solve 25% of the cases even when given the ground truth program sketch , and an LLM-based approach, GPT-Synth, is unable to solve any of the tasks due to the environment complexity.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632860", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Noah", + "last_name": "Patton", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kia", + "last_name": "Rahmani", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Meghana", + "last_name": "Missula", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Joydeep", + "last_name": "Biswas", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/PattonRMBD24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632923", + "title": "SimuQ: A Framework for Programming Quantum Hamiltonian Simulation with Analog Compilation", + "abstract": "Quantum Hamiltonian simulation, which simulates the evolution of quantum systems and probes quantum phenomena, is one of the most promising applications of quantum computing. Recent experimental results suggest that Hamiltonian-oriented analog quantum simulation would be advantageous over circuit-oriented digital quantum simulation in the Noisy Intermediate-Scale Quantum (NISQ) machine era. However, programming analog quantum simulators is much more challenging due to the lack of a unified interface between hardware and software. In this paper, we design and implement SimuQ, the first framework for quantum Hamiltonian simulation that supports Hamiltonian programming and pulse-level compilation to heterogeneous analog quantum simulators. Specifically, in SimuQ, front-end users specify the target quantum system with Hamiltonian Modeling Language, and the Hamiltonian-level programmability of analog quantum simulators is specified through a new abstraction called the abstract analog instruction set (AAIS) and programmed in AAIS Specification Language by hardware providers. Through a solver-based compilation, SimuQ generates executable pulse schedules for real devices to simulate the evolution of desired quantum systems, which is demonstrated on superconducting (IBM), neutral-atom (QuEra), and trapped-ion (IonQ) quantum devices. Moreover, we demonstrate the advantages of exposing the Hamiltonian-level programmability of devices with native operations or interaction-based gates and establish a small benchmark of quantum simulation to evaluate SimuQ’s compiler with the above analog quantum simulators.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632923", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuxiang", + "last_name": "Peng", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jacob", + "last_name": "Young", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Pengyu", + "last_name": "Liu", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/PengYLW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632857", + "title": "Nominal Recursors as Epi-Recursors", + "abstract": "We study nominal recursors from the literature on syntax with bindings and compare them with respect to expressiveness. The term “nominal” refers to the fact that these recursors operate on a syntax representation where the names of bound variables appear explicitly, as in nominal logic. We argue that nominal recursors can be viewed as epi-recursors , a concept that captures abstractly the distinction between the constructors on which one actually recurses, and other operators and properties that further underpin recursion. We develop an abstract framework for comparing epi-recursors and instantiate it to the existing nominal recursors, and also to several recursors obtained from them by cross-pollination. The resulted expressiveness hierarchies depend on how strictly we perform this comparison, and bring insight into the relative merits of different axiomatizations of syntax. We also apply our methodology to produce an expressiveness hierarchy of nominal corecursors , which are principles for defining functions targeting infinitary non-well-founded terms (which underlie λ -calculus semantics concepts such as Böhm trees). Our results are validated with the Isabelle/HOL theorem prover.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632857", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "University of Sheffield" + } + ], + "dblp_key": "journals/pacmpl/Popescu24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632892", + "title": "Thunks and Debits in Separation Logic with Time Credits", + "abstract": "A thunk is a mutable data structure that offers a simple memoization service: it stores either a suspended computation or the result of this computation. Okasaki [1999] presents many data structures that exploit thunks to achieve good amortized time complexity. He analyzes their complexity by associating a debit with every thunk. A debit can be paid off in several increments; a thunk whose debit has been fully paid off can be forced. Quite strikingly, a debit is associated also with future thunks, which do not yet exist in memory. Some of the debit of a faraway future thunk can be transferred to a nearer future thunk. We present a complete machine-checked reconstruction of Okasaki’s reasoning rules in Iris $ , a rich separation logic with time credits. We demonstrate the applicability of the rules by verifying a few operations on streams as well as several of Okasaki’s data structures, namely the physicist’s queue, implicit queues, and the banker’s queue.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632892", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Armaël", + "last_name": "Guéneau", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Glen", + "last_name": "Mével", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/PottierGJM24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3633211", + "title": "Shoggoth: A Formal Foundation for Strategic Rewriting", + "abstract": "Rewriting is a versatile and powerful technique used in many domains. Strategic rewriting allows programmers to control the application of rewrite rules by composing individual rewrite rules into complex rewrite strategies. These strategies are semantically complex, as they may be nondeterministic, they may raise errors that trigger backtracking, and they may not terminate. Given such semantic complexity, it is necessary to establish a formal understanding of rewrite strategies and to enable reasoning about them in order to answer questions like: How do we know that a rewrite strategy terminates? How do we know that a rewrite strategy does not fail because we compose two incompatible rewrites? How do we know that a desired property holds after applying a rewrite strategy? In this paper, we introduce Shoggoth: a formal foundation for understanding, analysing and reasoning about strategic rewriting that is capable of answering these questions. We provide a denotational semantics of System S, a core language for strategic rewriting, and prove its equivalence to our big-step operational semantics, which extends existing work by explicitly accounting for divergence. We further define a location-based weakest precondition calculus to enable formal reasoning about rewriting strategies, and we prove this calculus sound with respect to the denotational semantics. We show how this calculus can be used in practice to reason about properties of rewriting strategies, including termination, that they are well-composed, and that desired postconditions hold. The semantics and calculus are formalised in Isabelle/HOL and all proofs are mechanised.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3633211", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xueying", + "last_name": "Qin", + "institution": "University of Edinburgh" + }, + { + "first_name": "Liam", + "last_name": "O’Connor", + "institution": "University of Edinburgh" + }, + { + "first_name": "Rob van", + "last_name": "Glabbeek", + "institution": "UNSW Sydney" + }, + { + "first_name": "Peter", + "last_name": "Höfner", + "institution": "Australian National University" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "Technische Universität Berlin" + } + ], + "dblp_key": "journals/pacmpl/QinOGHKS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632906", + "title": "Decision and Complexity of Dolev-Yao Hyperproperties", + "abstract": "The formal analysis of cryptographic protocols traditionally focuses on trace and equivalence properties, for which decision procedures in the symbolic (or Dolev-Yao, or DY) model are known. However, many relevant security properties are expressed as DY hyperproperties that involve quantifications over both execution paths and attacker computations (which are constrained by the attacker’s knowledge in the underlying model of computation). DY hyperproperties generalise hyperproperties, for which many decision procedures exist, to the setting of DY models. Unfortunately, the subtle interactions between both forms of quantifications have been an obstacle to lifting decision procedures from hyperproperties to DY hyperproperties. The central contribution of the paper is the first procedure for deciding DY hyperproperties, in the usual setting where the number of protocol sessions is bounded and where the equational theory modelling cryptography is subterm-convergent. We prove that our decision procedure can decide the validity of any hyperproperty in which quantifications over messages are guarded and quantifications over attacker computations are limited to expressing the attacker’s knowledge. We also establish the complexity of the decision problem for several important fragments of the hyperlogic. Further, we illustrate the techniques and scope of our contributions through examples of related hyperproperties.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632906", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Itsaka", + "last_name": "Rakotonirina", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Clara", + "last_name": "Schneidewind", + "institution": "Max Planck Institute for Security and Privacy" + } + ], + "dblp_key": "journals/pacmpl/RakotonirinaBS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632909", + "title": "Ill-Typed Programs Don't Evaluate", + "abstract": "We introduce two-sided type systems, which are sequent calculi for typing formulas. Two-sided type systems allow for hypothetical reasoning over the typing of compound program expressions, and the refutation of typing formulas. By incorporating a type of all values, these type systems support more refined notions of well-typing and ill-typing, guaranteeing both that well-typed programs don’t go wrong and that ill-typed programs don’t evaluate - that is, reach a value. This makes two-sided type systems suitable for incorrectness reasoning in higher-order program verification, which we illustrate through an application to precise data-flow typing in a language with constructors and pattern matching. Finally, we investigate the internalisation of the meta-level negation in the system as a complement operator on types. This motivates an alternative semantics for the typing judgement, which guarantees that ill-typed programs don’t evaluate, but in which well-typed programs may yet go wrong.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632909", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Bristol" + }, + { + "first_name": "Charlie", + "last_name": "Walpole", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/RamsayW24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632905", + "title": "Inference of Probabilistic Programs with Moment-Matching Gaussian Mixtures", + "abstract": "Computing the posterior distribution of a probabilistic program is a hard task for which no one-fit-for-all solution exists. We propose Gaussian Semantics, which approximates the exact probabilistic semantics of a bounded program by means of Gaussian mixtures. It is parametrized by a map that associates each program location with the moment order to be matched in the approximation. We provide two main contributions. The first is a universal approximation theorem stating that, under mild conditions, Gaussian Semantics can approximate the exact semantics arbitrarily closely. The second is an approximation that matches up to second-order moments analytically in face of the generally difficult problem of matching moments of Gaussian mixtures with arbitrary moment order. We test our second-order Gaussian approximation (SOGA) on a number of case studies from the literature. We show that it can provide accurate estimates in models not supported by other approximation methods or when exact symbolic techniques fail because of complex expressions or non-simplified integrals. On two notable classes of problems, namely collaborative filtering and programs involving mixtures of continuous and discrete distributions, we show that SOGA significantly outperforms alternative techniques in terms of accuracy and computational time.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632905", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Francesca", + "last_name": "Randone", + "institution": "IMT School for Advanced Studies Lucca" + }, + { + "first_name": "Luca", + "last_name": "Bortolussi", + "institution": "University of Trieste" + }, + { + "first_name": "Emilio", + "last_name": "Incerto", + "institution": "IMT School for Advanced Studies Lucca" + }, + { + "first_name": "Mirco", + "last_name": "Tribastone", + "institution": "IMT School for Advanced Studies Lucca" + } + ], + "dblp_key": "journals/pacmpl/RandoneBIT24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632859", + "title": "Pipelines and Beyond: Graph Types for ADTs with Futures", + "abstract": "Parallel programs are frequently modeled as dependency or cost graphs, which can be used to detect various bugs, or simply to visualize the parallel structure of the code. However, such graphs reflect just one particular execution and are typically constructed in a post-hoc manner. Graph types , which were introduced recently to mitigate this problem, can be assigned statically to a program by a type system and compactly represent the family of all graphs that could result from the program. Unfortunately, prior work is restricted in its treatment of futures , an increasingly common and especially dynamic form of parallelism. In short, each instance of a future must be statically paired with a vertex name. Previously, this led to the restriction that futures could not be placed in collections or be used to construct data structures. Doing so is not a niche exercise: such structures form the basis of numerous algorithms that use forms of pipelining to achieve performance not attainable without futures. All but the most limited of these examples are out of reach of prior graph type systems. In this paper, we propose a graph type system that allows for almost arbitrary combinations of futures and recursive data types. We do so by indexing datatypes with a type-level vertex structure , a codata structure that supplies unique vertex names to the futures in a data structure. We prove the soundness of the system in a parallel core calculus annotated with vertex structures and associated operations. Although the calculus is annotated, this is merely for convenience in defining the type system. We prove that it is possible to annotate arbitrary recursive types with vertex structures, and show using a prototype inference engine that these annotations can be inferred from OCaml-like source code for several complex parallel algorithms.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632859", + "conference_name": "POPL", + "authors": [ + { + "first_name": "F.", + "last_name": "Rinaldi", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "june", + "last_name": "wunder", + "institution": "" + }, + { + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Illinois Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/RinaldiwAM24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632933", + "title": "Inference of Robust Reachability Constraints", + "abstract": "Characterization of bugs and attack vectors is in many practical scenarios as important as their finding. Recently, Girol et al. have introduced the concept of robust reachability , which ensures a perfect reproducibility of the reported violations by distinguishing inputs that are under the control of the attacker ( controlled inputs ) from those that are not ( uncontrolled inputs ), and proposed first automated analysis for it. While it is a step toward distinguishing severe bugs from benign ones, it fails for example to describe violations that are mostly reproducible, i.e., when triggering conditions are likely to happen, meaning that they happen for all uncontrolled inputs but a few corner cases. To address this issue, we propose to leverage theory-agnostic abduction techniques to generate constraints on the uncontrolled program inputs that ensure that a target property is robustly satisfied . Our proposal comes with an extension of robust reachability that is generic on the type of trace property and on the technology used to verify the properties. We show that our approach is complete w.r.t. its inference language , and we additionally discuss strategies for the efficient exploration of the inference space. We demonstrate the feasibility of the method and its practical ability to refine the notion of robust reachability with an implementation that uses robust reachability oracles to generate constraints on standard benchmarks from software verification and security analysis. We illustrate the use of our implementation to a vulnerability characterization problem in the context of fault injection attacks. Our method overcomes a major limitation of the initial proposal of robust reachability, without complicating its definition. From a practical view, this is a step toward new verification tools that are able to characterize program violations through high-level feedback.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632933", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yanis", + "last_name": "Sellami", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Guillaume", + "last_name": "Girol", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Frédéric", + "last_name": "Recoules", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Damien", + "last_name": "Couroussé", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Sébastien", + "last_name": "Bardin", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + } + ], + "dblp_key": "journals/pacmpl/SellamiGRCB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632866", + "title": "The Essence of Generalized Algebraic Data Types", + "abstract": "This paper considers direct encodings of generalized algebraic data types (GADTs) in a minimal suitable lambda-calculus. To this end, we develop an extension of System F ω with recursive types and internalized type equalities with injective constant type constructors. We show how GADTs and associated pattern-matching constructs can be directly expressed in the calculus, thus showing that it may be treated as a highly idealized modern functional programming language. We prove that the internalized type equalities in conjunction with injectivity rules increase the expressive power of the calculus by establishing a non-macro-expressibility result in F ω , and prove the system type-sound via a syntactic argument. Finally, we build two relational models of our calculus: a simple, unary model that illustrates a novel, two-stage interpretation technique, necessary to account for the equational constraints; and a more sophisticated, binary model that relaxes the construction to allow, for the first time, formal reasoning about data-abstraction in a calculus equipped with GADTs.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632866", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "Heriot-Watt University" + }, + { + "first_name": "Sergei", + "last_name": "Stepanenko", + "institution": "Aarhus University" + }, + { + "first_name": "Jonathan", + "last_name": "Sterling", + "institution": "University of Cambridge" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/SieczkowskiSSB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632878", + "title": "Efficient CHAD", + "abstract": "We show how the basic Combinatory Homomorphic Automatic Differentiation (CHAD) algorithm can be optimised, using well-known methods, to yield a simple, composable, and generally applicable reverse-mode automatic differentiation (AD) technique that has the correct computational complexity that we would expect of reverse-mode AD. Specifically, we show that the standard optimisations of sparse vectors and state-passing style code (as well as defunctionalisation/closure conversion, for higher-order languages) give us a purely functional algorithm that is most of the way to the correct complexity, with (functional) mutable updates taking care of the final log-factors. We provide an Agda formalisation of our complexity proof. Finally, we discuss how the techniques apply to differentiating parallel functional array programs: the key observations are 1) that all required mutability is (commutative, associative) accumulation, which lets us preserve task-parallelism and 2) that we can write down data-parallel derivatives for most data-parallel array primitives.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632878", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tom", + "last_name": "Smeding", + "institution": "Utrecht University" + }, + { + "first_name": "Matthijs", + "last_name": "Vákár", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/pacmpl/SmedingV24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632904", + "title": "API-Driven Program Synthesis for Testing Static Typing Implementations", + "abstract": "We introduce a novel approach for testing static typing implementations based on the concept of API-driven program synthesis . The idea is to synthesize type-intensive but small and well-typed programs by leveraging and combining application programming interfaces (APIs) derived from existing software libraries. Our primary insight is backed up by real-world evidence: a significant number of compiler typing bugs are caused by small test cases that employ APIs from the standard library of the language under test. This is attributed to the inherent complexity of the majority of these APIs, which often exercise a wide range of sophisticated type-related features. The main contribution of our approach is the ability to produce small client programs with increased feature coverage, without bearing the burden of generating the corresponding well-formed API definitions from scratch. To validate diverse aspects of static typing procedures (i.e., soundness, precision of type inference), we also enrich our API-driven approach with fault-injection and semantics-preserving modes, along with their corresponding test oracles. We evaluate our implemented tool, thalia , on testing the static typing implementations of the compilers for three popular languages, namely, Scala, Kotlin, and Groovy. thalia has uncovered 84 typing bugs (77 confirmed and 22 fixed), most of which are triggered by test cases featuring APIs that rely on parametric polymorphism, overloading, and higher-order functions. Our comparison with state-of-the-art shows that thalia yields test programs with distinct characteristics, offering additional and complementary benefits.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632904", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thodoris", + "last_name": "Sotiropoulos", + "institution": "ETH Zurich" + }, + { + "first_name": "Stefanos", + "last_name": "Chaliasos", + "institution": "Imperial College London" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/SotiropoulosCS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632871", + "title": "EasyBC: A Cryptography-Specific Language for Security Analysis of Block Ciphers against Differential Cryptanalysis", + "abstract": "Differential cryptanalysis is a powerful algorithmic-level attack, playing a central role in evaluating the security of symmetric cryptographic primitives. In general, the resistance against differential cryptanalysis can be characterized by the maximum expected differential characteristic probability. In this paper, we present generic and extensible approaches based on mixed integer linear programming (MILP) to bound such probability. We design a high-level cryptography-specific language EasyBc tailored for block ciphers and provide various rigorous procedures as differential denotational semantics, to automate the generation of MILP from block ciphers written in EasyBc . We implement an open-sourced tool that provides support for fully automated resistance evaluation of block ciphers against differential cryptanalysis. The tool is extensively evaluated on 23 real-life cryptographic primitives including all the 10 finalists of the NIST lightweight cryptography standardization process. The experiments confirm the expressivity of EasyBc and show that the tool can effectively prove the resistance against differential cryptanalysis for all block ciphers under consideration. EasyBc makes resistance evaluation against differential cryptanalysis easily accessible to cryptographers.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632871", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pu", + "last_name": "Sun", + "institution": "ShanghaiTech University" + }, + { + "first_name": "Fu", + "last_name": "Song", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Yuqi", + "last_name": "Chen", + "institution": "ShanghaiTech University" + }, + { + "first_name": "Taolue", + "last_name": "Chen", + "institution": "Birkbeck, University of London" + } + ], + "dblp_key": "journals/pacmpl/SunSCC24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632896", + "title": "Soundly Handling Linearity", + "abstract": "We propose a novel approach to soundly combining linear types with multi-shot effect handlers. Linear type systems statically ensure that resources such as file handles and communication channels are used exactly once. Effect handlers provide a rich modular programming abstraction for implementing features ranging from exceptions to concurrency to backtracking. Whereas conventional linear type systems bake in the assumption that continuations are invoked exactly once, effect handlers allow continuations to be discarded (e.g. for exceptions) or invoked more than once (e.g. for backtracking). This mismatch leads to soundness bugs in existing systems such as the programming language Links , which combines linearity (for session types) with effect handlers. We introduce control-flow linearity as a means to ensure that continuations are used in accordance with the linearity of any resources they capture, ruling out such soundness bugs. We formalise the notion of control-flow linearity in a System F-style core calculus F eff ∘ equipped with linear types, an effect type system, and effect handlers. We define a linearity-aware semantics in order to formally prove that F eff ∘ preserves the integrity of linear values in the sense that no linear value is discarded or duplicated. In order to show that control-flow linearity can be made practical, we adapt Links based on the design of F eff ∘ , in doing so fixing a long-standing soundness bug. Finally, to better expose the potential of control-flow linearity, we define an ML-style core calculus Q eff ∘ , based on qualified types, which requires no programmer provided annotations, and instead relies entirely on type inference to infer control-flow linearity. Both linearity and effects are captured by qualified types. Q eff ∘ overcomes a number of practical limitations of F eff ∘ , supporting abstraction over linearity, linearity dependencies between type variables, and a much more fine-grained notion of control-flow linearity.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632896", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wenhao", + "last_name": "Tang", + "institution": "University of Edinburgh" + }, + { + "first_name": "Daniel", + "last_name": "Hillerström", + "institution": "" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Iowa" + } + ], + "dblp_key": "journals/pacmpl/TangHLM24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632862", + "title": "The Logical Essence of Well-Bracketed Control Flow", + "abstract": "A program is said to be well-bracketed if every called function must return before its caller can resume execution. This is often the case. Well-bracketedness has been captured semantically as a condition on strategies in fully abstract games models and multiple prior works have studied well-bracketedness by showing correctness/security properties of programs where such properties depend on the well-bracketed nature of control flow. The latter category of prior works have all used involved relational models with explicit state-transition systems capturing the relevant parts of the control flow of the program. In this paper we present the first Hoare-style program logic based on separation logic for reasoning about well-bracketedness and use it to show correctness of well-bracketed programs both directly and also through defining unary and binary logical relations models based on this program logic. All results presented in this paper are formalized on top of the Iris framework and mechanized in the Coq proof assistant.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632862", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Armaël", + "last_name": "Guéneau", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/TimanyGB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632851", + "title": "Trillium: Higher-Order Concurrent and Distributed Separation Logic for Intensional Refinement", + "abstract": "Expressive state-of-the-art separation logics rely on step-indexing to model semantically complex features and to support modular reasoning about imperative higher-order concurrent and distributed programs. Stepindexing comes, however, with an inherent cost: it restricts the adequacy theorem of program logics to a fairly simple class of safety properties. In this paper, we explore if and how intensional refinement is a viable methodology for strengthening higher-order concurrent (and distributed) separation logic to prove non-trivial safety and liveness properties. Specifically, we introduce Trillium, a language-agnostic separation logic framework for showing intensional refinement relations between traces of a program and a model. We instantiate Trillium with a concurrent language and develop Fairis, a concurrent separation logic, that we use to show liveness properties of concurrent programs under fair scheduling assumptions through a fair liveness-preserving refinement of a model. We also instantiate Trillium with a distributed language and obtain an extension of Aneris, a distributed separation logic, which we use to show refinement relations between distributed systems and TLA + models.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632851", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "Aarhus University" + }, + { + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", + "institution": "Aarhus University" + }, + { + "first_name": "Léon", + "last_name": "Gondelman", + "institution": "Aarhus University" + }, + { + "first_name": "Abel", + "last_name": "Nieto", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/TimanyGSHGNB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632855", + "title": "Enriched Presheaf Model of Quantum FPC", + "abstract": "Selinger gave a superoperator model of a first-order quantum programming language and proved that it is fully definable and hence fully abstract. This paper proposes an extension of the superoperator model to higher-order programs based on modules over superoperators or, equivalently, enriched presheaves over the category of superoperators. The enriched presheaf category can be easily proved to be a model of intuitionistic linear logic with cofree exponential, from which one can cave out a model of classical linear logic by a kind of bi-orthogonality construction. Although the structures of an enriched presheaf category are usually rather complex, a morphism in the classical model can be expressed simply as a matrix of completely positive maps. The model inherits many desirable properties from the superoperator model. A conceptually interesting property is that our model has only a state whose “total probability” is bounded by 1, i.e. does not have a state where true and false each occur with probability 2 / 3 . Another convenient property inherited from the superoperator model is a ω CPO-enrichment. Remarkably, our model has a sufficient structure to interpret arbitrary recursive types by the standard domain theoretic technique. We introduce Quantum FPC , a quantum λ -calculus with recursive types, and prove that our model is a fully abstract model of Quantum FPC.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632855", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + }, + { + "first_name": "Kazuyuki", + "last_name": "Asada", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/TsukadaA24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632856", + "title": "Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic Programs", + "abstract": "Fueled by the success of Rust, many programming languages are adding substructural features to their type systems. The promise of tracking properties such as lifetimes and sharing is tremendous, not just for low-level memory management, but also for controlling higher-level resources and capabilities. But so are the difficulties in adapting successful techniques from Rust to higher-level languages, where they need to interact with other advanced features, especially various flavors of functional and type-level abstraction. What would it take to bring full-fidelity reasoning about lifetimes and sharing to mainstream languages? Reachability types are a recent proposal that has shown promise in scaling to higher-order but monomorphic settings, tracking aliasing and separation on top of a substrate inspired by separation logic. However, naive extensions on top of the prior reachability type system λ * with type polymorphism and/or precise reachability polymorphism are unsound, making λ * unsuitable for adoption in real languages. Combining reachability and type polymorphism that is precise, sound, and parametric remains an open challenge. This paper presents a rethinking of the design of reachability tracking and proposes new polymorphic reachability type systems. We introduce a new freshness qualifier to indicate variables whose reachability sets may grow during evaluation steps. The new system tracks variables reachable in a single step and computes transitive closures only when necessary, thus preserving chains of reachability over known variables that can be refined using substitution. These ideas yield the simply-typed λ ◆ -calculus with precise lightweight, i.e. , quantifier-free, reachability polymorphism, and the F < : ◆ -calculus with bounded parametric polymorphism over types and reachability qualifiers, paving the way for making true tracking of lifetimes and sharing practical for mainstream languages. We prove type soundness and the preservation of separation property in Coq. We discuss various applications ( e.g. , safe capability programming), possible effect system extensions, and compare our system with Scala’s capture types.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632856", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Songlin", + "last_name": "Jia", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yuyan", + "last_name": "Bao", + "institution": "Augusta University" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WeiBJBR24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632880", + "title": "Automatic Parallelism Management", + "abstract": "On any modern computer architecture today, parallelism comes with a modest cost, born from the creation and management of threads or tasks. Today, programmers battle this cost by manually optimizing/tuning their codes to minimize the cost of parallelism without harming its benefit, performance. This is a difficult battle: programmers must reason about architectural constant factors hidden behind layers of software abstractions, including thread schedulers and memory managers, and their impact on performance, also at scale. In languages that support higher-order functions, the battle hardens: higher order functions can make it difficult, if not impossible, to reason about the cost and benefits of parallelism. Motivated by these challenges and the numerous advantages of high-level languages, we believe that it has become essential to manage parallelism automatically so as to minimize its cost and maximize its benefit. This is a challenging problem, even when considered on a case-by-case, application-specific basis. But if a solution were possible, then it could combine the many correctness benefits of high-level languages with performance by managing parallelism without the programmer effort needed to ensure performance. This paper proposes techniques for such automatic management of parallelism by combining static (compilation) and run-time techniques. Specifically, we consider the Parallel ML language with task parallelism, and describe a compiler pipeline that embeds “potential parallelism” directly into the call-stack and avoids the cost of task creation by default. We then pair this compilation pipeline with a run-time system that dynamically converts potential parallelism into actual parallel tasks. Together, the compiler and run-time system guarantee that the cost of parallelism remains low without losing its benefit. We prove that our techniques have no asymptotic impact on the work and span of parallel programs and thus preserve their asymptotic properties. We implement the proposed techniques by extending the MPL compiler for Parallel ML and show that it can eliminate the burden of manual optimization while delivering good practical performance.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632880", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/WestrickFRA24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632877", + "title": "Mostly Automated Verification of Liveness Properties for Distributed Protocols with Ranking Functions", + "abstract": "Distributed protocols have long been formulated in terms of their safety and liveness properties. Much recent work has focused on automatically verifying the safety properties of distributed protocols, but doing so for liveness properties has remained a challenging, unsolved problem. We present LVR, the first framework that can mostly automatically verify liveness properties for distributed protocols. Our key insight is that most liveness properties for distributed protocols can be reduced to a set of safety properties with the help of ranking functions. Such ranking functions for practical distributed protocols have certain properties that make them straightforward to synthesize, contrary to conventional wisdom. We prove that verifying a liveness property can then be reduced to a simpler problem of verifying a set of safety properties, namely that the ranking function is strictly decreasing and nonnegative for any protocol state transition, and there is no deadlock. LVR automatically synthesizes ranking functions by formulating a parameterized function of integer protocol variables, statically analyzing the lower and upper bounds of the variables as well as how much they can change on each state transition, then feeding the constraints to an SMT solver to determine the coefficients of the ranking function. It then uses an off-the-shelf verification tool to find inductive invariants to verify safety properties for both ranking functions and deadlock freedom. We show that LVR can mostly automatically verify the liveness properties of several distributed protocols, including various versions of Paxos, with limited user guidance.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632877", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jianan", + "last_name": "Yao", + "institution": "Columbia University" + }, + { + "first_name": "Runzhou", + "last_name": "Tao", + "institution": "Columbia University" + }, + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Columbia University" + }, + { + "first_name": "Jason", + "last_name": "Nieh", + "institution": "Columbia University" + } + ], + "dblp_key": "journals/pacmpl/YaoTGN24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632914", + "title": "Fully Composable and Adequate Verified Compilation with Direct Refinements between Open Modules", + "abstract": "Verified compilation of open modules (i.e., modules whose functionality depends on other modules) provides a foundation for end-to-end verification of modular programs ubiquitous in contemporary software. However, despite intensive investigation in this topic for decades, the proposed approaches are still difficult to use in practice as they rely on assumptions about the internal working of compilers which make it difficult for external users to apply the verification results. We propose an approach to verified compositional compilation without such assumptions in the setting of verifying compilation of heterogeneous modules written in first-order languages supporting global memory and pointers. Our approach is based on the memory model of CompCert and a new discovery that a Kripke relation with a notion of memory protection can serve as a uniform and composable semantic interface for the compiler passes. By absorbing the rely-guarantee conditions on memory evolution for all compiler passes into this Kripke Memory Relation and by piggybacking requirements on compiler optimizations onto it, we get compositional correctness theorems for realistic optimizing compilers as refinements that directly relate native semantics of open modules and that are ignorant of intermediate compilation processes. Such direct refinements support all the compositionality and adequacy properties essential for verified compilation of open modules. We have applied this approach to the full compilation chain of CompCert with its Clight source language and demonstrated that our compiler correctness theorem is open to composition and intuitive to use with reduced verification complexity through end-to-end verification of non-trivial heterogeneous modules that may freely invoke each other (e.g., mutually recursively).", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632914", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ling", + "last_name": "Zhang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Yuting", + "last_name": "Wang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "WU", + "last_name": "Jin-hua", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/ZhangWWKS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632883", + "title": "Fusing Direct Manipulations into Functional Programs", + "abstract": "Bidirectional live programming systems (BLP) enable developers to modify a program by directly manipulating the program output, so that the updated program can produce the manipulated output. One state-of-the-art approach to BLP systems is operation-based, which captures the developer's intention of program modifications by taking how the developer manipulates the output into account. The program modifications are usually hard coded for each direct manipulation in these BLP systems, which are difficult to extend. Moreover, to reflect the manipulations to the source program, these BLP systems trace the modified output to appropriate code fragments and perform corresponding code transformations. Accordingly, they require direct manipulation users be aware of the source code and how it is changed, making “direct” manipulation (on output) be “indirect”. In this paper, we resolve this problem by presenting a novel operation-based framework for bidirectional live programming, which can automatically fuse direct manipulations into the source code, thus supporting code-insensitive direct manipulations. Firstly, we design a simple but expressive delta language DM capable of expressing common direct manipulations for output values. Secondly, we present a fusion algorithm that propagates direct manipulations into the source functional programs and applies them to the constants whenever possible; otherwise, the algorithm embeds manipulations into the “proper positions” of programs. We prove the correctness of the fusion algorithm that the updated program executes to get the manipulated output. To demonstrate the expressiveness of DM and the effectiveness of our fusion algorithm, we have implemented FuseDM, a prototype SVG editor that supports GUI-based operations for direct manipulation, and successfully designed 14 benchmark examples starting from blank code using FuseDM.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632883", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xing", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Ruifeng", + "last_name": "Xie", + "institution": "Peking University" + }, + { + "first_name": "Guanchen", + "last_name": "Guo", + "institution": "Peking University" + }, + { + "first_name": "Xiao", + "last_name": "He", + "institution": "University of Science and Technology Beijing" + }, + { + "first_name": "Tao", + "last_name": "Zan", + "institution": "Longyan University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/ZhangXGHZH24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632910", + "title": "Total Type Error Localization and Recovery with Holes", + "abstract": "Type systems typically only define the conditions under which an expression is well-typed, leaving ill-typed expressions formally meaningless. This approach is insufficient as the basis for language servers driving modern programming environments, which are expected to recover from simultaneously localized errors and continue to provide a variety of downstream semantic services. This paper addresses this problem, contributing the first comprehensive formal account of total type error localization and recovery: the marked lambda calculus. In particular, we define a gradual type system for expressions with marked errors, which operate as non-empty holes, together with a total procedure for marking arbitrary unmarked expressions. We mechanize the metatheory of the marked lambda calculus in Agda and implement it, scaled up, as the new basis for Hazel, a full-scale live functional programming environment with, uniquely, no meaningless editor states. The marked lambda calculus is bidirectionally typed, so localization decisions are systematically predictable based on a local flow of typing information. Constraint-based type inference can bring more distant information to bear in discovering inconsistencies but this notoriously complicates error localization. We approach this problem by deploying constraint solving as a type-hole-filling layer atop this gradual bidirectionally typed core. Errors arising from inconsistent unification constraints are localized exclusively to type and expression holes, i.e., the system identifies unfillable holes using a system of traced provenances, rather than localized in an ad hoc manner to particular expressions. The user can then interactively shift these errors to particular downstream expressions by selecting from suggested partially consistent type hole fillings, which returns control back to the bidirectional system. We implement this type hole inference system in Hazel.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632910", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eric", + "last_name": "Zhao", + "institution": "University of Michigan" + }, + { + "first_name": "Raef", + "last_name": "Maroof", + "institution": "University of Michigan" + }, + { + "first_name": "A Ambedkar", + "last_name": "Dukkipati", + "institution": "University of Michigan" + }, + { + "first_name": "Andrew", + "last_name": "Blinn", + "institution": "University of Michigan" + }, + { + "first_name": "Zhiyi", + "last_name": "Pan", + "institution": "University of Michigan" + }, + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/ZhaoMDBPO24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632911", + "title": "VST-A: A Foundationally Sound Annotation Verifier", + "abstract": "Program verifiers for imperative languages such as C may be annotation-based , in which assertions and invariants are put into source files and then checked, or tactic-based, where proof scripts separate from programs are interactively developed in a proof assistant such as Coq. Annotation verifiers have been more automated and convenient, but some interactive verifiers have richer assertion languages and formal proofs of soundness. We present VST-A, an annotation verifier that uses the rich assertion language of VST, leverages the formal soundness proof of VST, but allows users to describe functional correctness proofs intuitively by inserting assertions. VST-A analyzes control flow graphs, decomposes every C function into control flow paths between assertions, and reduces program verification problems into corresponding straightline Hoare triples . Compared to existing foundational program verification tools like VST and Iris, in VST-A such decompositions and reductions can nonstructural, which makes VST-A more flexible to use. VST-A’s decomposition and reduction is defined in Coq, proved sound in Coq, and computed call-by-value in Coq. The soundness proof for reduction is totally logical, independent of the complicated semantic model (and soundness proof) of VST’s Hoare triple. Because of the rich assertion language, not all reduced proof goals can be automatically checked, but the system allows users to prove residual proof goals using the full power of the Coq proof assistant.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632911", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Litao", + "last_name": "Zhou", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Jianxing", + "last_name": "Qin", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Qinshi", + "last_name": "Wang", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "Qinxiang", + "last_name": "Cao", + "institution": "Shanghai Jiao Tong University" + } + ], + "dblp_key": "journals/pacmpl/ZhouQWAC24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632927", + "title": "Sound Gradual Verification with Symbolic Execution", + "abstract": "Gradual verification, which supports explicitly partial specifications and verifies them with a combination of static and dynamic checks, makes verification more incremental and provides earlier feedback to developers. While an abstract, weakest precondition-based approach to gradual verification was previously proven sound, the approach did not provide sufficient guidance for implementation and optimization of the required run-time checks. More recently, gradual verification was implemented using symbolic execution techniques, but the soundness of the approach (as with related static checkers based on implicit dynamic frames) was an open question. This paper puts practical gradual verification on a sound footing with a formalization of symbolic execution, optimized run-time check generation, and run time execution. We prove our approach is sound; our proof also covers a core subset of the Viper tool, for which we are aware of no previous soundness result. Our formalization enabled us to find a soundness bug in an implemented gradual verification tool and describe the fix necessary to make it sound.", + "date": "2024-01-02", + "link": "https://dl.acm.org/doi/10.1145/3632927", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Conrad", + "last_name": "Zimmerman", + "institution": "Brown University" + }, + { + "first_name": "Jenna", + "last_name": "DiVincenzo", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/ZimmermanDA24", + "venue": "popl", + "year": 2024 + } +] \ No newline at end of file From 00b9c4d4d7c4e833e6f18cc1b52d0717a0fed826 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 16:53:37 +0200 Subject: [PATCH 04/34] refactor: generalize PLConferenceHarvester for arbitrary venue/year MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Drives off a small VENUES registry and discovers per-venue (year, TOC) pairs from DBLP's index.xml — no per-venue branching. Handles the two DBLP TOC schemes (PACMPL journal vs conf//) data-driven. Also fixes parsing edge cases surfaced while expanding past POPL 2024: -

headings with embedded tags (CC@ETAPS ...) now match via DOTALL non-greedy. - 2-digit-year proceedings keys (conf/popl/77 etc) are recognised in addition to 4-digit ones, recovering POPL 1974/1977/1979/1981/1982. The CLI now iterates every venue × every DBLP-indexed year by default, caches DBLP search-API responses and OpenAlex/SS replies under .cache/pl_conferences/, supports --year/--year-min/--year-max scoping, and a --skip-existing-doi switch that pre-loads non-arxiv DOIs from the DB so we don't waste OpenAlex lookups. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 714 ++++++++++++++++++++----- 1 file changed, 592 insertions(+), 122 deletions(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index 2c9d116..ca4eb03 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -1,67 +1,359 @@ """Harvester for programming-languages conference proceedings. -Fetches a venue/year volume from DBLP, looks up abstracts and author -affiliations from OpenAlex (with a Semantic Scholar fallback), and emits -papers in the ``scraped`` JSON shape consumed by -:meth:`oversight.Paper.Paper.from_scraped_json`. - -Currently hardcoded to ``("popl", 2024)`` — the (venue, year) constructor -parameters are present so Phase 2 can drive the full back-catalogue without -touching the implementation. See ``docs/pl-conferences-plan.md``. +For a ``(venue, year)`` pair this fetches the DBLP table-of-contents, +looks up abstracts and author affiliations from OpenAlex (with a Semantic +Scholar fallback), and emits papers in the ``scraped`` JSON shape consumed +by :meth:`oversight.Paper.Paper.from_scraped_json`. + +Two TOC schemes coexist on DBLP: + +1. **PACMPL journal articles** — POPL/PLDI/ICFP/OOPSLA from the year SIGPLAN + moved them onto PACMPL onwards. The TOC lives at + ``db/journals/pacmpl/pacmpl.bht`` where ``vol = year - 2016``; + each volume bundles multiple venues, discriminated by the ``number`` + field (``"POPL"``, ``"PLDI"``, ``"ICFP"``, ``"OOPSLA"``, + ``"OOPSLA1"``/``"OOPSLA2"`` once OOPSLA split into Spring + Fall in 2022). + +2. **Conference proceedings** — everything else (pre-PACMPL POPL/PLDI/ICFP/ + OOPSLA, plus all years of ESOP/ECOOP/CC/Haskell). The TOC lives at + ``db/conf//.bht`` (or ``-1.bht``, + ``-2.bht`` when proceedings are split across volumes, e.g. ESOP). + +DBLP's ``db/conf//index.xml`` enumerates every issue/proceedings +that exists for a venue, including which scheme each year uses. The +:class:`PLVenueIndex` class parses that file; the harvester then iterates +the ``(year, [TOC entries])`` it returns. + +See ``docs/pl-conferences-plan.md``. """ from __future__ import annotations import json import logging +import re import time +import xml.etree.ElementTree as ET +from collections.abc import Callable +from dataclasses import dataclass, field from pathlib import Path -from typing import Any, Iterable +from typing import Any, Iterable, Iterator, Sequence import requests logger = logging.getLogger(__name__) -# DBLP returns ``Proc. ACM Program. Lang.`` (PACMPL) for POPL/PLDI/ICFP/OOPSLA -# from 2017 onwards. ``number`` discriminates the issue (e.g. "POPL"). -_PACMPL_ISSUES = { - "popl": "POPL", - "pldi": "PLDI", - "icfp": "ICFP", - "oopsla": "OOPSLA", -} +# ---------------------------------------------------------------------- +# Venue registry +# ---------------------------------------------------------------------- + -# Friendly conference label written into the ``conference_name`` field of the -# emitted JSON (and ultimately the ``source`` column in the database). -_CONFERENCE_LABEL = { - "popl": "POPL", - "pldi": "PLDI", - "icfp": "ICFP", - "oopsla": "OOPSLA", +@dataclass(frozen=True) +class VenueSpec: + """Static facts about a venue: how to find it on DBLP, how to label it.""" + + slug: str # lowercase, matches DBLP path component + label: str # human label written into ``conference_name`` / DB ``source`` + pacmpl_numbers: frozenset[str] = field(default_factory=frozenset) + """PACMPL ``number`` values that map to this venue. Empty for non-PACMPL + venues. POPL/PLDI/ICFP use ``{label}``; OOPSLA additionally accepts + ``OOPSLA1`` / ``OOPSLA2`` for the post-2022 split.""" + + +VENUES: dict[str, VenueSpec] = { + spec.slug: spec + for spec in [ + # Tier 1 — SIGPLAN flagship (PACMPL since 2017/2018/2023 depending on venue) + VenueSpec("popl", "POPL", frozenset({"POPL"})), + VenueSpec("pldi", "PLDI", frozenset({"PLDI"})), + VenueSpec("icfp", "ICFP", frozenset({"ICFP"})), + VenueSpec("oopsla", "OOPSLA", frozenset({"OOPSLA", "OOPSLA1", "OOPSLA2"})), + # Tier 2 — also clearly PL, conf-only + VenueSpec("esop", "ESOP"), + VenueSpec("ecoop", "ECOOP"), + VenueSpec("cc", "CC"), + VenueSpec("haskell", "Haskell"), + ] } + +# ---------------------------------------------------------------------- +# DBLP TOC discovery +# ---------------------------------------------------------------------- + + +@dataclass(frozen=True) +class TOCEntry: + """One DBLP table-of-contents pointing at a list of papers. + + A single ``(venue, year)`` may resolve to multiple TOC entries: + PACMPL OOPSLA 2022+ has Spring + Fall (``OOPSLA1``/``OOPSLA2``) in one + journal volume; conf-style ESOP 2024 has two parts under separate BHT + files. + """ + + bht: str + """DBLP TOC identifier, e.g. ``db/conf/popl/popl2010.bht`` or + ``db/journals/pacmpl/pacmpl1.bht``.""" + + pacmpl_number: str | None + """When the TOC bundles multiple venues (PACMPL), the ``number`` + discriminator (e.g. ``"POPL"``); ``None`` for single-venue conf TOCs.""" + + +class PLVenueIndex: + """Loads DBLP's ``db/conf//index.xml`` and yields ``(year, [TOCEntry])``. + + The XML is unfortunately not strict (it embeds raw HTML headings like + ``

``), so we parse it as text rather than as an XML tree. Two + relevant productions per year: + + - ```` + — denotes PACMPL coverage (post-2017). + - `` ... db/conf/popl/popl2010.html ... `` + — denotes a conf-style proceedings. + + We filter out workshops co-located with the main conference (PLMW@POPL, + PEPM@POPL, TyDe@ICFP, etc.) by requiring the proceedings ``key`` to + match ``conf//YYYY(-N)?$`` — workshops use suffixes like + ``2015plmw``. + """ + + _USER_AGENT = "oversight/0.1 (https://github.com/charlielidbury/oversight)" + + def __init__( + self, + venue: VenueSpec, + cache_dir: Path | None = None, + request_delay_s: float = 0.5, + ) -> None: + self.venue = venue + self.cache_dir = cache_dir + self.request_delay_s = request_delay_s + self._session = requests.Session() + self._session.headers.update({"User-Agent": self._USER_AGENT}) + self._raw_xml: str | None = None + + # ------------------------------------------------------------------ + + def discover(self) -> list[tuple[int, list[TOCEntry]]]: + """Return ``[(year, [TOCEntry, ...]), ...]`` newest-first.""" + xml_text = self._load_xml() + return list(_parse_index_xml(xml_text, self.venue)) + + # ------------------------------------------------------------------ + + def _load_xml(self) -> str: + if self._raw_xml is not None: + return self._raw_xml + cached = self._cache_path() + if cached is not None and cached.exists(): + self._raw_xml = cached.read_text(encoding="utf-8") + return self._raw_xml + + url = f"https://dblp.org/db/conf/{self.venue.slug}/index.xml" + logger.info("Fetching DBLP venue index %s", url) + resp = _request_with_retries(self._session, url, timeout=30) + resp.raise_for_status() + time.sleep(self.request_delay_s) + + text = resp.text + if cached is not None: + cached.parent.mkdir(parents=True, exist_ok=True) + cached.write_text(text, encoding="utf-8") + self._raw_xml = text + return text + + def _cache_path(self) -> Path | None: + if self.cache_dir is None: + return None + return self.cache_dir / "dblp_index" / f"{self.venue.slug}.xml" + + +# Header like "

37th POPL 2010: Madrid, Spain

", or with nested tags +# such as "

10th CC@ETAPS 2001: Genova, Italy

". +# Non-greedy ``.*?`` plus DOTALL lets nested tags through; the year is +# extracted from the inner text downstream. +_H2_YEAR_RE = re.compile(r"

(.*?)

", re.IGNORECASE | re.DOTALL) +_YEAR_FROM_HEADING_RE = re.compile(r"\b(19|20)\d{2}\b") +# Issue: (self-closing with optional space) +_ISSUE_RE = re.compile( + r"]+?)/?>", + re.IGNORECASE | re.DOTALL, +) +# Proceedings opening tag +_PROCEEDINGS_KEY_RE = re.compile( + r'([^<]+)", re.IGNORECASE) + + +def _parse_index_xml( + xml_text: str, venue: VenueSpec +) -> Iterator[tuple[int, list[TOCEntry]]]: + """Yield ``(year, [TOCEntry])`` for every year listed in the venue index. + + Pure function — no IO — so it stays trivially testable. + """ + # Split the document into ``

`` blocks. Each block runs from one + # ``

`` to the next. + headings = list(_H2_YEAR_RE.finditer(xml_text)) + # Sentinel end position + headings_with_ends: list[tuple[re.Match[str], int]] = [] + for i, m in enumerate(headings): + end = headings[i + 1].start() if i + 1 < len(headings) else len(xml_text) + headings_with_ends.append((m, end)) + + seen_years: set[int] = set() + for match, end in headings_with_ends: + heading_text = match.group(1) + year_match = _YEAR_FROM_HEADING_RE.search(heading_text) + if year_match is None: + continue + year = int(year_match.group(0)) + if year in seen_years: + continue + seen_years.add(year) + + block = xml_text[match.end() : end] + entries = list(_extract_toc_entries(block, venue, year)) + if entries: + yield (year, entries) + + +def _extract_toc_entries(block: str, venue: VenueSpec, year: int) -> Iterator[TOCEntry]: + """Pull out ```` and ```` from one year's block.""" + # PACMPL issues + if venue.pacmpl_numbers: + for m in _ISSUE_RE.finditer(block): + attrs = _parse_xml_attrs(m.group(1)) + href = attrs.get("href", "") + if not href.startswith("db/journals/pacmpl/"): + continue + number = attrs.get("nr", "") + if number not in venue.pacmpl_numbers: + continue + bht = href.replace(".html", ".bht").rstrip("/") + yield TOCEntry(bht=bht, pacmpl_number=number) + + # Conf-style proceedings. Walk every in the block; pick + # only those whose key matches ``conf//YYYY(-N)?$``. DBLP also + # uses 2-digit-year keys for some early proceedings (e.g. + # ``conf/popl/77`` for POPL 1977), so accept those too. + yy = f"{year % 100:02d}" + expected_pattern = re.compile( + rf"^conf/{re.escape(venue.slug)}/(?:{year}|{yy})(?:-\d+)?$" + ) + for m in _PROCEEDINGS_KEY_RE.finditer(block): + key = m.group(1) + if not expected_pattern.match(key): + continue + # Find the matching ... within this proceedings element. + # Search for the closing after this opening tag and + # restrict the URL search to the slice between them. + proc_start = m.start() + proc_end_match = re.search(r"", block[proc_start:], re.IGNORECASE) + if proc_end_match is None: + continue + proc_block = block[proc_start : proc_start + proc_end_match.end()] + url_match = _URL_RE.search(proc_block) + if url_match is None: + continue + url = url_match.group(1).strip() + bht = url.replace(".html", ".bht") + yield TOCEntry(bht=bht, pacmpl_number=None) + + +def _parse_xml_attrs(attr_str: str) -> dict[str, str]: + """Parse `key="value"` pairs out of an XML attribute substring.""" + return { + m.group(1): m.group(2) for m in re.finditer(r'(\w[\w-]*)="([^"]*)"', attr_str) + } + + +# ---------------------------------------------------------------------- +# Harvester +# ---------------------------------------------------------------------- + + _USER_AGENT = "oversight/0.1 (https://github.com/charlielidbury/oversight)" _OPENALEX_MAILTO = "charlie.lidbury@icloud.com" +def _request_with_retries( + session: requests.Session, + url: str, + *, + params: dict[str, Any] | None = None, + timeout: int = 30, + max_attempts: int = 4, +) -> requests.Response: + """GET with exponential backoff on transient errors (429/503/connection).""" + attempt = 0 + backoff = 2.0 + while True: + attempt += 1 + try: + resp = session.get(url, params=params, timeout=timeout) + except requests.RequestException as exc: + if attempt >= max_attempts: + raise + logger.warning( + "Request to %s failed (%s); retry %d/%d in %.1fs", + url, + exc, + attempt, + max_attempts, + backoff, + ) + time.sleep(backoff) + backoff *= 2 + continue + if resp.status_code in (429, 502, 503, 504) and attempt < max_attempts: + retry_after = resp.headers.get("Retry-After") + wait = float(retry_after) if retry_after else backoff + logger.warning( + "Request to %s returned %s; retry %d/%d in %.1fs", + url, + resp.status_code, + attempt, + max_attempts, + wait, + ) + time.sleep(wait) + backoff *= 2 + continue + return resp + + class PLConferenceHarvester: - """Harvest a single (venue, year) volume into a ``scraped``-format JSON file. + """Harvest a single ``(venue, year)`` into a ``scraped``-format JSON file. Parameters ---------- venue: - Lowercase venue slug, e.g. ``"popl"``. + Lowercase venue slug from :data:`VENUES`. year: Four-digit year of the volume. output_dir: Directory under which ``/.json`` will be written. cache_dir: - Optional directory for caching OpenAlex / Semantic Scholar responses - across reruns. Created on demand. Use a path inside ``.cache/`` so it - stays out of git. + Optional directory for caching DBLP / OpenAlex / Semantic Scholar + responses across reruns. Created on demand. Use a path inside + ``.cache/`` so it stays out of git. request_delay_s: Polite delay between external API requests. + skip_existing_doi: + If provided, a callable returning ``True`` for DOIs already present + in the database. Skipping these short-circuits OpenAlex lookups. + toc_entries: + Pre-resolved DBLP TOC entries for this ``(venue, year)``. When + provided, the harvester skips the per-venue index discovery step + (useful when driving many years from a single :class:`PLVenueIndex` + load). """ def __init__( @@ -71,28 +363,23 @@ def __init__( output_dir: str | Path = "data/pl_conferences", cache_dir: str | Path | None = None, request_delay_s: float = 0.1, + skip_existing_doi: Callable[[str], bool] | None = None, + toc_entries: Sequence[TOCEntry] | None = None, ) -> None: venue = venue.lower() - if venue not in _PACMPL_ISSUES: + if venue not in VENUES: raise ValueError( - f"Unsupported venue {venue!r}. Phase 1 only supports POPL; " - "Phase 2 will add the rest." - ) - if venue != "popl" or year != 2024: - # Soft guard rather than hard error so future phases just need to - # remove this branch. - logger.warning( - "PLConferenceHarvester is currently exercised only for POPL 2024;" - " (%s, %s) may surface unhandled edge cases.", - venue, - year, + f"Unsupported venue {venue!r}. Known venues: {sorted(VENUES.keys())}" ) + self.venue_spec = VENUES[venue] self.venue = venue self.year = year self.output_dir = Path(output_dir) self.cache_dir = Path(cache_dir) if cache_dir else None self.request_delay_s = request_delay_s + self.skip_existing_doi = skip_existing_doi + self._toc_entries = list(toc_entries) if toc_entries is not None else None self._session = requests.Session() self._session.headers.update({"User-Agent": _USER_AGENT}) @@ -101,26 +388,43 @@ def __init__( # Top-level entry point # ------------------------------------------------------------------ - def harvest(self) -> Path: - """Run the full pipeline. Returns the path to the JSON file written.""" - dblp_entries = list(self._fetch_dblp_entries()) + def harvest(self) -> Path | None: + """Run the full pipeline. Returns the path to the JSON written, or + ``None`` if no papers were emitted (e.g. DBLP listed nothing).""" + toc_entries = self._resolve_toc_entries() + if not toc_entries: + logger.warning( + "No DBLP TOC entries found for %s %s; skipping.", + self.venue_spec.label, + self.year, + ) + return None + + dblp_entries = list(self._fetch_dblp_entries(toc_entries)) logger.info( - "DBLP listed %d entries for %s %s", + "DBLP listed %d entries for %s %s (across %d TOC%s)", len(dblp_entries), - self.venue.upper(), + self.venue_spec.label, self.year, + len(toc_entries), + "s" if len(toc_entries) != 1 else "", ) papers: list[dict[str, Any]] = [] skipped_no_doi: list[str] = [] skipped_no_abstract: list[str] = [] + skipped_already_in_db = 0 for entry in dblp_entries: title = (entry.get("title") or "").rstrip(".") doi = entry.get("doi") if not doi: skipped_no_doi.append(title) - logger.warning("Skipping %r: no DOI in DBLP entry", title) + logger.debug("Skipping %r: no DOI in DBLP entry", title) + continue + + if self.skip_existing_doi is not None and self.skip_existing_doi(doi): + skipped_already_in_db += 1 continue paper = self._build_paper(entry, doi) @@ -130,81 +434,120 @@ def harvest(self) -> Path: papers.append(paper) logger.info( - "Built %d papers (skipped %d with no DOI, %d with no abstract)", + "Built %d papers (%d in DB; %d no-DOI; %d no-abstract)", len(papers), + skipped_already_in_db, len(skipped_no_doi), len(skipped_no_abstract), ) out_path = self.output_dir / self.venue / f"{self.year}.json" out_path.parent.mkdir(parents=True, exist_ok=True) + if not papers: + # Don't write an empty file — if every DOI is already in DB we + # have nothing to consume; an existing JSON from a previous run + # should remain for reproducibility. + if not out_path.exists(): + logger.info( + "No new papers for %s %s; nothing to write.", + self.venue_spec.label, + self.year, + ) + return None + return out_path with open(out_path, "w", encoding="utf-8") as f: json.dump(papers, f, ensure_ascii=False, indent=2) logger.info("Wrote %s (%d papers)", out_path, len(papers)) return out_path # ------------------------------------------------------------------ - # DBLP + # TOC resolution # ------------------------------------------------------------------ - def _fetch_dblp_entries(self) -> Iterable[dict[str, Any]]: - """Yield raw DBLP ``info`` dicts for the configured venue+year. + def _resolve_toc_entries(self) -> list[TOCEntry]: + if self._toc_entries is not None: + return self._toc_entries + index = PLVenueIndex( + self.venue_spec, + cache_dir=self.cache_dir, + request_delay_s=self.request_delay_s, + ) + for year, entries in index.discover(): + if year == self.year: + self._toc_entries = entries + return entries + self._toc_entries = [] + return [] + + # ------------------------------------------------------------------ + # DBLP search-API: list papers in a TOC + # ------------------------------------------------------------------ + + def _fetch_dblp_entries( + self, toc_entries: Sequence[TOCEntry] + ) -> Iterable[dict[str, Any]]: + seen_keys: set[str] = set() + for toc in toc_entries: + for info in self._fetch_dblp_toc_papers(toc): + key = info.get("key") or info.get("doi") + if key in seen_keys: + continue + if key: + seen_keys.add(key) + yield info + + def _fetch_dblp_toc_papers(self, toc: TOCEntry) -> Iterator[dict[str, Any]]: + """Yield raw DBLP ``info`` dicts for a single TOC entry.""" + cache_key = self._dblp_toc_cache_key(toc) + cached = self._cache_load(cache_key) + if cached is not None: + payload = cached + else: + # Query the search API faceted on the TOC. Add the PACMPL + # ``number`` token (e.g. "POPL") to disambiguate when the same + # TOC bundles several venues. + query_terms = [f"toc:{toc.bht}:"] + if toc.pacmpl_number is not None: + query_terms.append(toc.pacmpl_number) + url = "https://dblp.org/search/publ/api" + params = { + "q": " ".join(query_terms), + "format": "json", + "h": 1000, + "f": 0, + } + resp = _request_with_retries(self._session, url, params=params, timeout=30) + resp.raise_for_status() + time.sleep(self.request_delay_s) + payload = resp.json() + self._cache_store(cache_key, payload) - We use the search API (``/search/publ/api``) constrained to the - relevant table-of-contents BHT. The per-volume ``.json`` endpoint - documented in the dblp wiki returns 404 for the current PACMPL - volumes, so the search API is the reliable path. - """ - bht = self._dblp_toc_bht() - # Query: facet on the TOC, plus the issue token (e.g. "POPL") to - # restrict to the right PACMPL number when the TOC covers multiple. - issue_token = _PACMPL_ISSUES[self.venue] - query = f"toc:{bht}: {issue_token}" - - url = "https://dblp.org/search/publ/api" - params = { - "q": query, - "format": "json", - "h": 1000, # well above the ~100 papers/year ceiling - "f": 0, - } - resp = self._session.get(url, params=params, timeout=30) - resp.raise_for_status() - payload = resp.json() hits = payload.get("result", {}).get("hits", {}) total = int(hits.get("@total", 0)) sent = int(hits.get("@sent", 0)) if total > sent: raise RuntimeError( - f"DBLP returned {sent}/{total} hits — bump 'h' parameter." + f"DBLP returned {sent}/{total} hits for {toc.bht} — bump 'h' parameter." ) for hit in hits.get("hit", []): info = hit.get("info", {}) - # Defensive filtering: keep only PACMPL articles for the right - # issue. The search query already constrains this, but if the - # query is loosened later the data must stay clean. - if info.get("number") != issue_token: - continue - if str(info.get("year")) != str(self.year): - continue - if info.get("type") and info["type"] != "Journal Articles": - # Editor-only "Proceedings" records etc. None observed for - # PACMPL, but keep the guard for non-PACMPL venues. - continue + # Defensive filter: PACMPL TOCs cover multiple venues, so the + # query already restricts by ``number``; verify anyway. + if toc.pacmpl_number is not None: + if info.get("number") != toc.pacmpl_number: + continue + else: + # Conf-style TOCs sometimes include the editor record as a + # ``Editorship`` hit; drop those. + if info.get("type") == "Editorship": + continue yield info - def _dblp_toc_bht(self) -> str: - """Return the DBLP TOC BHT identifier for ``(venue, year)``.""" - # PACMPL volume number = year - 2016 (vol 1 = 2017). - if self.venue in _PACMPL_ISSUES: - volume = self.year - 2016 - if volume < 1: - raise ValueError( - f"PACMPL coverage starts in 2017; cannot fetch {self.venue} {self.year}" - ) - return f"db/journals/pacmpl/pacmpl{volume}.bht" - raise ValueError(f"Unsupported venue {self.venue!r}") + def _dblp_toc_cache_key(self, toc: TOCEntry) -> str: + bht_safe = _safe_filename(toc.bht) + suffix = toc.pacmpl_number or "main" + return f"dblp_toc/{bht_safe}.{suffix}.json" # ------------------------------------------------------------------ # Paper assembly @@ -213,8 +556,7 @@ def _dblp_toc_bht(self) -> str: def _build_paper(self, entry: dict[str, Any], doi: str) -> dict[str, Any] | None: """Combine a DBLP entry with OpenAlex (or Semantic Scholar fallback). - Returns ``None`` if no abstract can be obtained, in which case the - caller skips the paper. + Returns ``None`` if no abstract can be obtained. """ title = (entry.get("title") or "").rstrip(".") @@ -243,15 +585,13 @@ def _build_paper(self, entry: dict[str, Any], doi: str) -> dict[str, Any] | None ) return None - # Authors: prefer OpenAlex (has institutions). Fall back to DBLP - # author list (no affiliations) so we never lose author names. if oa_authors: authors = oa_authors else: authors = _dblp_authors(entry) date = publication_date or self._fallback_date() - link = f"https://dl.acm.org/doi/{doi}" + link = _doi_link(doi) return { "paper_id": doi, @@ -259,20 +599,17 @@ def _build_paper(self, entry: dict[str, Any], doi: str) -> dict[str, Any] | None "abstract": abstract, "date": date, "link": link, - "conference_name": _CONFERENCE_LABEL[self.venue], + "conference_name": self.venue_spec.label, "authors": authors, - # Provenance — keeps the JSON debuggable without bloating it. "dblp_key": entry.get("key"), "venue": self.venue, "year": self.year, } def _fallback_date(self) -> str: - # Conference dates differ by venue, but the volume publication date - # captured by OpenAlex is what we really want. This is only used - # when both abstract sources also fail to provide a date — which - # currently never happens for PACMPL. Use Jan-1 of the volume year - # as a stable default. + # When OpenAlex doesn't tell us the publication date, default to + # Jan-1 of the volume year — stable, sortable, and within the right + # year for downstream date filters. return f"{self.year}-01-01" # ------------------------------------------------------------------ @@ -288,7 +625,7 @@ def _fetch_openalex(self, doi: str) -> dict[str, Any] | None: url = f"https://api.openalex.org/works/https://doi.org/{doi}" params = {"mailto": _OPENALEX_MAILTO} try: - resp = self._session.get(url, params=params, timeout=30) + resp = _request_with_retries(self._session, url, params=params, timeout=30) except requests.RequestException as exc: logger.warning("OpenAlex request failed for %s: %s", doi, exc) return None @@ -321,7 +658,7 @@ def _fetch_semantic_scholar(self, doi: str) -> dict[str, Any] | None: url = f"https://api.semanticscholar.org/graph/v1/paper/DOI:{doi}" params = {"fields": "abstract,authors,year"} try: - resp = self._session.get(url, params=params, timeout=30) + resp = _request_with_retries(self._session, url, params=params, timeout=30) except requests.RequestException as exc: logger.warning("Semantic Scholar request failed for %s: %s", doi, exc) return None @@ -329,10 +666,6 @@ def _fetch_semantic_scholar(self, doi: str) -> dict[str, Any] | None: if resp.status_code == 404: self._cache_store(cache_key, {}) return None - if resp.status_code == 429: - # Rate limited — wait briefly and retry once. - time.sleep(2.0) - resp = self._session.get(url, params=params, timeout=30) if resp.status_code != 200: logger.warning( "Semantic Scholar returned %s for %s (%s)", @@ -415,12 +748,10 @@ def _dblp_authors(entry: dict[str, Any]) -> list[dict[str, str]]: if raw is None: return [] if isinstance(raw, dict): - # Single-author papers come back as a dict, not a list. raw = [raw] out: list[dict[str, str]] = [] for author in raw: text = (author.get("text") or "").strip() - # DBLP disambiguates name collisions with " 0001" etc — strip those. text = _strip_dblp_disambiguator(text) if not text: continue @@ -449,16 +780,155 @@ def _safe_filename(s: str) -> str: return s.replace("/", "_").replace(":", "_") +def _doi_link(doi: str) -> str: + """Return a public landing-page URL for the DOI. + + ACM, Springer, LIPIcs, and others all resolve through ``doi.org``; + keeping the redirect there is more durable than guessing publishers. + """ + return f"https://doi.org/{doi}" + + +# Re-export so external callers don't need to know the parsing details. +__all__ = [ + "VENUES", + "VenueSpec", + "TOCEntry", + "PLVenueIndex", + "PLConferenceHarvester", +] + + +# Suppress "imported but unused" for stdlib ET — kept available for tests +# that may want to validate the index XML if DBLP changes its schema. +_ = ET + + # ---------------------------------------------------------------------- # CLI # ---------------------------------------------------------------------- -if __name__ == "__main__": + +def _main() -> None: + import argparse + + parser = argparse.ArgumentParser( + description="Harvest a PL conference proceedings into the scraped JSON shape." + ) + parser.add_argument( + "venues", + nargs="*", + help=( + "Venue slugs to harvest. Default: all known venues " + f"({', '.join(sorted(VENUES))})." + ), + ) + parser.add_argument( + "--year", + type=int, + help="Single year to harvest. Default: every year DBLP indexes.", + ) + parser.add_argument( + "--year-min", + type=int, + default=None, + help="Minimum year (inclusive). Ignored when --year is set.", + ) + parser.add_argument( + "--year-max", + type=int, + default=None, + help="Maximum year (inclusive). Ignored when --year is set.", + ) + parser.add_argument( + "--output-dir", + default="data/pl_conferences", + ) + parser.add_argument( + "--cache-dir", + default=".cache/pl_conferences", + ) + parser.add_argument( + "--skip-existing-doi", + action="store_true", + help="Skip DOIs already present in the oversight database.", + ) + parser.add_argument( + "--request-delay", + type=float, + default=0.1, + ) + args = parser.parse_args() + logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s") - harvester = PLConferenceHarvester( - venue="popl", - year=2024, - output_dir="data/pl_conferences", - cache_dir=".cache/pl_conferences", + + venues = [v.lower() for v in args.venues] if args.venues else list(VENUES) + for v in venues: + if v not in VENUES: + parser.error(f"Unknown venue {v!r}; known: {sorted(VENUES)}") + + skip_doi: Callable[[str], bool] | None = None + if args.skip_existing_doi: + skip_doi = _make_db_doi_skipper() + + for venue in venues: + spec = VENUES[venue] + index = PLVenueIndex( + spec, + cache_dir=Path(args.cache_dir), + request_delay_s=args.request_delay, + ) + year_to_entries = dict(index.discover()) + years = sorted(year_to_entries.keys()) + if args.year is not None: + years = [args.year] if args.year in year_to_entries else [] + else: + if args.year_min is not None: + years = [y for y in years if y >= args.year_min] + if args.year_max is not None: + years = [y for y in years if y <= args.year_max] + logger.info( + "Venue %s: %d years to harvest (%s)", + spec.label, + len(years), + ", ".join(str(y) for y in years) + if len(years) <= 10 + else f"{years[0]}–{years[-1]}", + ) + for year in years: + harvester = PLConferenceHarvester( + venue=venue, + year=year, + output_dir=args.output_dir, + cache_dir=args.cache_dir, + request_delay_s=args.request_delay, + skip_existing_doi=skip_doi, + toc_entries=year_to_entries[year], + ) + try: + harvester.harvest() + except Exception: # noqa: BLE001 + logger.exception( + "Failed to harvest %s %s; continuing", spec.label, year + ) + + +def _make_db_doi_skipper() -> Callable[[str], bool]: + """Return a function that returns True for DOIs already in the DB.""" + from .PaperDatabase import PaperDatabase + + db = PaperDatabase() + db.__enter__() + cursor = db._get_con().cursor() + cursor.execute( + "SELECT paper_id FROM paper WHERE source != 'arxiv' AND paper_id LIKE '10.%'" ) - harvester.harvest() + existing: set[str] = {row[0] for row in cursor.fetchall()} + cursor.close() + db.__exit__(None, None, None) + logger.info("Loaded %d existing non-arxiv DOIs from DB", len(existing)) + return lambda doi: doi in existing + + +if __name__ == "__main__": + _main() From 824f6eb38288f88d1e18bc81628775ade8e56c23 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:00:06 +0200 Subject: [PATCH 05/34] feat: parallelize PLConferenceHarvester for bulk ingest Run per-paper OpenAlex/Semantic-Scholar lookups across a thread pool (default 16 workers) and process years concurrently from the CLI driver (default 4 workers). Each worker uses a thread-local requests Session. Drops the per-call sleep (request_delay_s default 0.0) since bounded concurrency plus the existing exponential-backoff retry path is enough to stay polite. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 110 +++++++++++++++++++++---- 1 file changed, 96 insertions(+), 14 deletions(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index ca4eb03..bc67f54 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -32,9 +32,11 @@ import json import logging import re +import threading import time import xml.etree.ElementTree as ET from collections.abc import Callable +from concurrent.futures import ThreadPoolExecutor, as_completed from dataclasses import dataclass, field from pathlib import Path from typing import Any, Iterable, Iterator, Sequence @@ -362,9 +364,10 @@ def __init__( year: int, output_dir: str | Path = "data/pl_conferences", cache_dir: str | Path | None = None, - request_delay_s: float = 0.1, + request_delay_s: float = 0.0, skip_existing_doi: Callable[[str], bool] | None = None, toc_entries: Sequence[TOCEntry] | None = None, + max_workers: int = 16, ) -> None: venue = venue.lower() if venue not in VENUES: @@ -380,9 +383,15 @@ def __init__( self.request_delay_s = request_delay_s self.skip_existing_doi = skip_existing_doi self._toc_entries = list(toc_entries) if toc_entries is not None else None + self.max_workers = max_workers + # Sessions are not thread-safe for concurrent reads/writes of the + # same connection pool entry; use a thread-local store so each + # worker has its own. The "main" session is used for serial work + # (DBLP TOC discovery and fetch). self._session = requests.Session() self._session.headers.update({"User-Agent": _USER_AGENT}) + self._tls = threading.local() # ------------------------------------------------------------------ # Top-level entry point @@ -415,6 +424,9 @@ def harvest(self) -> Path | None: skipped_no_abstract: list[str] = [] skipped_already_in_db = 0 + # Pre-filter: drop entries with no DOI or already in DB before we + # spend any HTTP budget on them. + actionable: list[tuple[dict[str, Any], str]] = [] for entry in dblp_entries: title = (entry.get("title") or "").rstrip(".") doi = entry.get("doi") @@ -422,16 +434,36 @@ def harvest(self) -> Path | None: skipped_no_doi.append(title) logger.debug("Skipping %r: no DOI in DBLP entry", title) continue - if self.skip_existing_doi is not None and self.skip_existing_doi(doi): skipped_already_in_db += 1 continue - - paper = self._build_paper(entry, doi) - if paper is None: - skipped_no_abstract.append(title) - continue - papers.append(paper) + actionable.append((entry, doi)) + + # Per-paper fetch is the dominant cost — fan out across workers. + if actionable: + workers = max(1, min(self.max_workers, len(actionable))) + with ThreadPoolExecutor(max_workers=workers) as pool: + futures = { + pool.submit(self._build_paper, entry, doi): (entry, doi) + for entry, doi in actionable + } + for fut in as_completed(futures): + entry, doi = futures[fut] + title = (entry.get("title") or "").rstrip(".") + try: + paper = fut.result() + except Exception: # noqa: BLE001 + logger.exception( + "Failed to build paper for DOI %s (%r); skipping", + doi, + title, + ) + skipped_no_abstract.append(title) + continue + if paper is None: + skipped_no_abstract.append(title) + continue + papers.append(paper) logger.info( "Built %d papers (%d in DB; %d no-DOI; %d no-abstract)", @@ -625,11 +657,14 @@ def _fetch_openalex(self, doi: str) -> dict[str, Any] | None: url = f"https://api.openalex.org/works/https://doi.org/{doi}" params = {"mailto": _OPENALEX_MAILTO} try: - resp = _request_with_retries(self._session, url, params=params, timeout=30) + resp = _request_with_retries( + self._thread_session(), url, params=params, timeout=30 + ) except requests.RequestException as exc: logger.warning("OpenAlex request failed for %s: %s", doi, exc) return None - time.sleep(self.request_delay_s) + if self.request_delay_s: + time.sleep(self.request_delay_s) if resp.status_code == 404: self._cache_store(cache_key, {}) return None @@ -658,11 +693,14 @@ def _fetch_semantic_scholar(self, doi: str) -> dict[str, Any] | None: url = f"https://api.semanticscholar.org/graph/v1/paper/DOI:{doi}" params = {"fields": "abstract,authors,year"} try: - resp = _request_with_retries(self._session, url, params=params, timeout=30) + resp = _request_with_retries( + self._thread_session(), url, params=params, timeout=30 + ) except requests.RequestException as exc: logger.warning("Semantic Scholar request failed for %s: %s", doi, exc) return None - time.sleep(self.request_delay_s) + if self.request_delay_s: + time.sleep(self.request_delay_s) if resp.status_code == 404: self._cache_store(cache_key, {}) return None @@ -678,6 +716,24 @@ def _fetch_semantic_scholar(self, doi: str) -> dict[str, Any] | None: self._cache_store(cache_key, data) return data + # ------------------------------------------------------------------ + # Thread-local HTTP session + # ------------------------------------------------------------------ + + def _thread_session(self) -> requests.Session: + """Return a per-thread :class:`requests.Session`. + + :class:`requests.Session` is not safe for fully concurrent use of + the same instance (the urllib3 connection pool can race), so each + worker thread gets its own. + """ + sess = getattr(self._tls, "session", None) + if sess is None: + sess = requests.Session() + sess.headers.update({"User-Agent": _USER_AGENT}) + self._tls.session = sess + return sess + # ------------------------------------------------------------------ # Cache helpers # ------------------------------------------------------------------ @@ -856,7 +912,19 @@ def _main() -> None: parser.add_argument( "--request-delay", type=float, - default=0.1, + default=0.0, + ) + parser.add_argument( + "--max-workers", + type=int, + default=16, + help="Worker threads per (venue, year) for OpenAlex/SS fetches.", + ) + parser.add_argument( + "--year-workers", + type=int, + default=4, + help="Years to process concurrently per venue.", ) args = parser.parse_args() @@ -895,7 +963,8 @@ def _main() -> None: if len(years) <= 10 else f"{years[0]}–{years[-1]}", ) - for year in years: + + def _harvest_year(year: int) -> None: harvester = PLConferenceHarvester( venue=venue, year=year, @@ -904,6 +973,7 @@ def _main() -> None: request_delay_s=args.request_delay, skip_existing_doi=skip_doi, toc_entries=year_to_entries[year], + max_workers=args.max_workers, ) try: harvester.harvest() @@ -912,6 +982,18 @@ def _main() -> None: "Failed to harvest %s %s; continuing", spec.label, year ) + if args.year_workers <= 1 or len(years) <= 1: + for year in years: + _harvest_year(year) + else: + workers = max(1, min(args.year_workers, len(years))) + with ThreadPoolExecutor(max_workers=workers) as pool: + futs = [pool.submit(_harvest_year, y) for y in years] + for f in as_completed(futs): + # Surface any unexpected exception (each call already + # catches its own; this is just for hard runtime errors). + f.result() + def _make_db_doi_skipper() -> Callable[[str], bool]: """Return a function that returns True for DOIs already in the DB.""" From a3d040ef6139807b3149d0e3760aa0fe806935e0 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:11:16 +0200 Subject: [PATCH 06/34] feat: ingest POPL back-catalogue (1973-2026) Harvested via PLConferenceHarvester into data/pl_conferences/popl/. DBLP has no proceedings for POPL 1974, so the year file is absent. 2024 was already present from the Phase 1 vertical slice; this commit overwrites it with the same content from a fresh run. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/popl/1973.json | 432 +++++ data/pl_conferences/popl/1975.json | 463 +++++ data/pl_conferences/popl/1976.json | 437 +++++ data/pl_conferences/popl/1977.json | 481 +++++ data/pl_conferences/popl/1978.json | 575 ++++++ data/pl_conferences/popl/1979.json | 583 ++++++ data/pl_conferences/popl/1980.json | 547 ++++++ data/pl_conferences/popl/1981.json | 506 +++++ data/pl_conferences/popl/1982.json | 798 ++++++++ data/pl_conferences/popl/1983.json | 596 ++++++ data/pl_conferences/popl/1984.json | 655 +++++++ data/pl_conferences/popl/1985.json | 702 +++++++ data/pl_conferences/popl/1986.json | 692 +++++++ data/pl_conferences/popl/1987.json | 661 +++++++ data/pl_conferences/popl/1988.json | 613 ++++++ data/pl_conferences/popl/1989.json | 692 +++++++ data/pl_conferences/popl/1990.json | 695 +++++++ data/pl_conferences/popl/1991.json | 712 +++++++ data/pl_conferences/popl/1992.json | 629 ++++++ data/pl_conferences/popl/1993.json | 996 ++++++++++ data/pl_conferences/popl/1994.json | 904 +++++++++ data/pl_conferences/popl/1995.json | 847 ++++++++ data/pl_conferences/popl/1996.json | 794 ++++++++ data/pl_conferences/popl/1997.json | 793 ++++++++ data/pl_conferences/popl/1998.json | 778 ++++++++ data/pl_conferences/popl/1999.json | 597 ++++++ data/pl_conferences/popl/2000.json | 745 ++++++++ data/pl_conferences/popl/2001.json | 565 ++++++ data/pl_conferences/popl/2002.json | 754 ++++++++ data/pl_conferences/popl/2003.json | 622 ++++++ data/pl_conferences/popl/2004.json | 671 +++++++ data/pl_conferences/popl/2005.json | 840 ++++++++ data/pl_conferences/popl/2006.json | 940 +++++++++ data/pl_conferences/popl/2007.json | 869 +++++++++ data/pl_conferences/popl/2008.json | 951 +++++++++ data/pl_conferences/popl/2009.json | 1024 ++++++++++ data/pl_conferences/popl/2010.json | 1165 +++++++++++ data/pl_conferences/popl/2011.json | 1440 ++++++++++++++ data/pl_conferences/popl/2012.json | 1351 +++++++++++++ data/pl_conferences/popl/2013.json | 1333 +++++++++++++ data/pl_conferences/popl/2014.json | 1672 ++++++++++++++++ data/pl_conferences/popl/2015.json | 1587 +++++++++++++++ data/pl_conferences/popl/2016.json | 1868 ++++++++++++++++++ data/pl_conferences/popl/2017.json | 1890 ++++++++++++++++++ data/pl_conferences/popl/2018.json | 2075 ++++++++++++++++++++ data/pl_conferences/popl/2019.json | 2348 +++++++++++++++++++++++ data/pl_conferences/popl/2020.json | 2136 +++++++++++++++++++++ data/pl_conferences/popl/2021.json | 1890 ++++++++++++++++++ data/pl_conferences/popl/2022.json | 2027 ++++++++++++++++++++ data/pl_conferences/popl/2023.json | 2334 ++++++++++++++++++++++ data/pl_conferences/popl/2024.json | 2862 +++++++++++++-------------- data/pl_conferences/popl/2025.json | 2494 ++++++++++++++++++++++++ data/pl_conferences/popl/2026.json | 2868 ++++++++++++++++++++++++++++ 53 files changed, 57068 insertions(+), 1431 deletions(-) create mode 100644 data/pl_conferences/popl/1973.json create mode 100644 data/pl_conferences/popl/1975.json create mode 100644 data/pl_conferences/popl/1976.json create mode 100644 data/pl_conferences/popl/1977.json create mode 100644 data/pl_conferences/popl/1978.json create mode 100644 data/pl_conferences/popl/1979.json create mode 100644 data/pl_conferences/popl/1980.json create mode 100644 data/pl_conferences/popl/1981.json create mode 100644 data/pl_conferences/popl/1982.json create mode 100644 data/pl_conferences/popl/1983.json create mode 100644 data/pl_conferences/popl/1984.json create mode 100644 data/pl_conferences/popl/1985.json create mode 100644 data/pl_conferences/popl/1986.json create mode 100644 data/pl_conferences/popl/1987.json create mode 100644 data/pl_conferences/popl/1988.json create mode 100644 data/pl_conferences/popl/1989.json create mode 100644 data/pl_conferences/popl/1990.json create mode 100644 data/pl_conferences/popl/1991.json create mode 100644 data/pl_conferences/popl/1992.json create mode 100644 data/pl_conferences/popl/1993.json create mode 100644 data/pl_conferences/popl/1994.json create mode 100644 data/pl_conferences/popl/1995.json create mode 100644 data/pl_conferences/popl/1996.json create mode 100644 data/pl_conferences/popl/1997.json create mode 100644 data/pl_conferences/popl/1998.json create mode 100644 data/pl_conferences/popl/1999.json create mode 100644 data/pl_conferences/popl/2000.json create mode 100644 data/pl_conferences/popl/2001.json create mode 100644 data/pl_conferences/popl/2002.json create mode 100644 data/pl_conferences/popl/2003.json create mode 100644 data/pl_conferences/popl/2004.json create mode 100644 data/pl_conferences/popl/2005.json create mode 100644 data/pl_conferences/popl/2006.json create mode 100644 data/pl_conferences/popl/2007.json create mode 100644 data/pl_conferences/popl/2008.json create mode 100644 data/pl_conferences/popl/2009.json create mode 100644 data/pl_conferences/popl/2010.json create mode 100644 data/pl_conferences/popl/2011.json create mode 100644 data/pl_conferences/popl/2012.json create mode 100644 data/pl_conferences/popl/2013.json create mode 100644 data/pl_conferences/popl/2014.json create mode 100644 data/pl_conferences/popl/2015.json create mode 100644 data/pl_conferences/popl/2016.json create mode 100644 data/pl_conferences/popl/2017.json create mode 100644 data/pl_conferences/popl/2018.json create mode 100644 data/pl_conferences/popl/2019.json create mode 100644 data/pl_conferences/popl/2020.json create mode 100644 data/pl_conferences/popl/2021.json create mode 100644 data/pl_conferences/popl/2022.json create mode 100644 data/pl_conferences/popl/2023.json create mode 100644 data/pl_conferences/popl/2025.json create mode 100644 data/pl_conferences/popl/2026.json diff --git a/data/pl_conferences/popl/1973.json b/data/pl_conferences/popl/1973.json new file mode 100644 index 0000000..bc25c99 --- /dev/null +++ b/data/pl_conferences/popl/1973.json @@ -0,0 +1,432 @@ +[ + { + "paper_id": "10.1145/512927.512941", + "title": "Advice on Structuring Compilers and Proving Them Correct", + "abstract": "The purpose of this paper is to advise an approach (and to support that advice by discussion of an example) towards achieving a goal first announced by John McCarthy: that compilers for higher-level programming languages should be made completely trustworthy by proving their correctness. The author believes that the compiler-correctness problem can be made much less general and better-structured than the unrestricted program-correctness problem; to do so will of course entail restricting what a compiler may be.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512941", + "conference_name": "POPL", + "authors": [ + { + "first_name": "F. Lockwood", + "last_name": "Morris", + "institution": "Syracuse University" + } + ], + "dblp_key": "conf/popl/Morris73a", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512946", + "title": "Analysis of a Simple Algorithm for Global Flow Problems", + "abstract": "There is an ordering of the nodes of a flow graph G which topologically sorts the dominance relation and can be found in 0(edges) steps. This ordering is the reverse of the order in which a node is last visited while growing any depth-first spanning tree of G. Moreover, if G is reducible, then this ordering topologically sorts the dag of G. Thus, for a reducible flow graph (rfg) there is a simple algorithm to compute the dominators of each node in 0(edges) bit vector steps.The main result of this paper relates two parameters of an rfg. If G is reducible, d is the largest number of back edges found in any cycle-free path in G, and k is the length of the interval derived sequence of G, then k≥d. From this result it follows that there is a very simple bit propagation algorithm (indeed, the obvious one) which also uses the above ordering, and is at least as good as the interval algorithm for solving all known global data flow problems such as available expressions and live variables.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512946", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew S.", + "last_name": "Hecht", + "institution": "Princeton University" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/HechtU73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512932", + "title": "Practical Syntactic Error Recovery", + "abstract": "A substantial portion of any programmer's time is spent in debugging. One of the major services of any compiler ought to be to provide as much information as possible about compile-time errors in order to minimize the time required for debugging. A good error detection and recovery scheme should maximize the number of errors detected but minimize the number of times it reports an error when there is none. These spurious error detections and their associated error messages are usually engendered by an inappropriate recovery action.In this paper we describe a recovery scheme for syntax errors which provides high quality recovery with good diagnostic information at relatively low cost. In addition, implementation of the recovery scheme can be automated - that is, the recovery routine can be created by a parser-generator. Therefore, the compiler designer need not be burdened with the difficulties of error recovery and the programming effort necessary to design and debug a myriad of ad hoc recovery routines.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512932", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Steven P.", + "last_name": "Rhodes", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/GrahamR73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512929", + "title": "Strict Deterministic Versus LR(0) Parsing", + "abstract": "Recently strict deterministic grammars and languages have been introduced [9,10,11]. This family of languages is quite fundamental in the study of the mathematical properties of deterministic languages and in dealing with some classical families of grammars such as LR(k) and bounded right context grammars [7,8,14]. These grammars are closely related to LR(0) grammars [1,12,13,14], in fact each strict deterministic grammar is also LR(0). In the present paper, we consider the question of how to parse strict deterministic grammars. We introduce part of a more general theory called \"characteristic LR(k) parsing\". This actually produces parsers which are tuned to the characteristics of a particular family of grammars. We apply the theory to the family of strict deterministic grammars and we get parsers which are as fast as canonical LR(k) parsers but are substantially smaller. They are not necessarily minimal but we postpone any discussion of minimality to the sequel.The techniques used in the present discussion are quite general [5]. For instance, the study in [3] is similar in spirit to our technique. The optimization techniques for LR(k) parsers in [2] do not work in the case k = 0 without modification. After modifying those methods for k = 0, it can be shown that our parsers cannot be produced by those techniques. This fact has its positive aspect in that our parsers may be smaller and its negative aspect in that error detection may be delayed.The present paper is divided into the present introduction and three sections. In the remainder of this introduction, some basic definitions of strict deterministic and LR(k) parsing are given. We have tried to follow [1] as much as possible in order to minimize the amount of new material to be absorbed. The order of the results is the order needed to prove that the characteristic parser works. In Section III, we apply the theory of Section II to strict deterministic parsing. A simple example shows that the new parsers can be unboundedly smaller than the canonical LR(0) parser.The present paper is meant to be an extended abstract and no proofs are included.The rest of the introduction is concerned with notational conventions for the technical concepts needed.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512929", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew M.", + "last_name": "Geller", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Michael A.", + "last_name": "Harrison", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/GellerH73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512940", + "title": "Mode Modules as Representations of Domains", + "abstract": "High level programming languages tend to free a programmer from concern about the underlying machine structure and permit him to talk about his problem domain in more direct terms. Thus, he may imagine that objects such as real numbers, character strings, and linear arrays really exist in the machine as atomic entities and he need not understand the details of how they are actually represented in the machine. Of course what distinguishes various kinds of objects are the operations that may be performed on them, so when talking about the domain of real numbers, we should include the basic arithmetic operations and constants, and for strings, operations such as length, concatenation and indexing.Unfortunately, existing languages do not permit a programmer to ignore completely questions of representation, for if his problem domain does not happen to be included already in the repertoire of domains supported by the language, the programmer must figure out a representation himself and remember it throughout his programming effort. For example, a FORTRAN programmer may know that it is not meaningful to multiply two integers that happen to represent insurance policy numbers, but he has no way of informing the compiler of this fact.Many extensible languages do provide a wide range of data types including structured types, enabling a programmer to choose a more natural representation of his external objects, but the structured data types reflect only the structure of the data, not its meaning. They still provide only one natural representation for both integers and dates, mass and speed, or planar vectors in cartesian or polar coordinates.Many domains that arise in practice have a great deal of similarity between them which one must employ in his programs. For example, the domain of length 3 vectors and the domain of length 4 vectors have the \"same\" rule of addition, that is, add componentwise, and it would be onerous to have to repeat this information for each new length vector. Thus, one needs both the ability to define brand new domains and also a method for expressing relations among them.We present here some mechanisms, collectively called Aleph-1, which allow the expansion of a programming language's repertoire of internal domains. Many of the ideas embodied in Aleph-1 have been described previously in the literature, and we acknowledge their influence on our thinking, in particular the work of Balzer [1] and Reynolds [5] suggesting the utility of separating out the abstract behavior of an object from its representation, the languages Pascal [10] and Simula-67 [3] which associate functions with data types and types with alternate representations, modular generic functions in Basel [2], Standish's wide variety of structured data [6], and the systematic (though not extensible) treatment of coercion in Algol-68 [8]. Our domain mechanisms bear certain strong similarities to those developed by Morris for the purposes of protection [4].", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512940", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alice E.", + "last_name": "Fischer", + "institution": "Boston Sports & Shoulder Center" + }, + { + "first_name": "Michael J.", + "last_name": "Fischer", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/FischerF73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512934", + "title": "Programming Language Semantics and Closed Applicative Languages", + "abstract": "This paper proposes axioms to define a sequence of language-classes; the most general is that of \"programming language\", the most restricted has some simple and attractive properties. Here \"language\" is used in its traditional sense as referring to a set of interpreted expressions. We are concerned with the syntax of an expression only to the degree needed to relate its structure to its \"meaning\". A clear distinction is drawn between a \"language\" and the many possible \"realizations\" of that language.This introduction comprises a survey and opinionated discussion of the contents of the paper, therefore the reader who wishes to get on with the technical exposition can skip to the next section.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512934", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Backus", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/Backus73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512948", + "title": "Large Scale File Processing - Pogol", + "abstract": "Article Free Access Share on Large scale file processing: POGOL Author: Gloria J. Lambert Dept. of Defense Dept. of DefenseView Profile Authors Info & Claims POPL '73: Proceedings of the 1st annual ACM SIGACT-SIGPLAN symposium on Principles of programming languagesOctober 1973Pages 226–234https://doi.org/10.1145/512927.512948Published:01 October 1973Publication History 0citation377DownloadsMetricsTotal Citations0Total Downloads377Last 12 Months60Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512948", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gloria J.", + "last_name": "Lambert", + "institution": "" + } + ], + "dblp_key": "conf/popl/Lambert73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512949", + "title": "On the Decision Problems of Program Schemas with Commutative and Invertable Functions", + "abstract": "We consider partially interpreted monadic schemas in which some functions are specified to commute, or some function is specified to be invertible. The decision problems considered are those of halting, divergence, equivalence, inclusion and isomorphism. It is shown that with either commutativity or invertibility alone, all these decision problems are solvable, whereas with both commutativity and invertibility, all become unsolvable. These results are also related to the decision problems for finite automata on multi-dimensional infinite tapes.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512949", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ashok K.", + "last_name": "Chandra", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Chandra73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512928", + "title": "Deterministic Parsing of Ambiguous Grammars", + "abstract": "We consider methods of describing the syntax of programming languages in ways that are more flexible and natural than conventional BNF descriptions. These methods involve the use of ambiguous context-free grammars together with rules to resolve syntactic ambiguities. We show how efficient LL and LR parsers can be constructed directly from certain classes of these specifications.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512928", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alfred V.", + "last_name": "Aho", + "institution": "" + }, + { + "first_name": "S. C.", + "last_name": "Johnson", + "institution": "" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/AhoJU73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512945", + "title": "A Unified Approach to Global Program Optimization", + "abstract": "A technique is presented for global analysis of program structure in order to perform compile time optimization of object code generated for expressions. The global expression optimization presented includes constant propagation, common subexpression elimination, elimination of redundant register load operations, and live expression analysis. A general purpose program flow analysis algorithm is developed which depends upon the existence of an \"optimizing function.\" The algorithm is defined formally using a directed graph model of program flow structure, and is shown to be correct. Several optimizing functions are defined which, when used in conjunction with the flow analysis algorithm, provide the various forms of code optimization. The flow analysis algorithm is sufficiently general that additional functions can easily be defined for other forms of global code optimization.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512945", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gary A.", + "last_name": "Kildall", + "institution": "Naval Postgraduate School" + } + ], + "dblp_key": "conf/popl/Kildall73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512935", + "title": "On the Definitional Method of Standard PL/1", + "abstract": "In order to define the semantics of PL/I in a form which is both precise and readable, a method of definition has been developed which employs an abstract machine operating on tree-structured data. The classes of trees involved are defined by formal grammars, while the algorithms governing the behaviour of the machine are expressed semi-formally in prose. This algorithmic metalanguage is itself intended to have largely intuitive semantics, but these are made more precise by an indication of how they could be supported at a lower level of detail within the abstract machine.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512935", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Beech", + "institution": "IBM (United Kingdom)" + } + ], + "dblp_key": "conf/popl/Beech73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512942", + "title": "Actor Induction and Meta-Evaluation", + "abstract": "The PLANNER project is continuing research in natural and effective means for embedding knowledge in procedures. In the course of this work we have succeeded in unifying the formalism around one fundamental concept: the ACTOR. Intuitively, an ACTOR is an active agent which plays a role on cue according to a script. We use the ACTOR metaphor to emphasize the inseparability of control and data flow in our model. Data structures, functions, semaphores, monitors, ports, descriptions, Quillian nets, logical formulae, numbers, identifiers, demons, processes, contexts, and data bases can all be shown to be special cases of actors. All of the above are objects with certain useful modes of behavior. Our formalism shows how all of these modes of behavior can be defined in terms of one kind of behavior: sending messages to actors. An actor is always invoked uniformly in exactly the same way regardless of whether it behaves as a recursive function, data structure, or process.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512942", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Carl", + "last_name": "Hewitt", + "institution": "" + }, + { + "first_name": "Peter", + "last_name": "Bishop", + "institution": "" + }, + { + "first_name": "Irene", + "last_name": "Greif", + "institution": "" + }, + { + "first_name": "Brian Cantwell", + "last_name": "Smith", + "institution": "" + }, + { + "first_name": "Todd", + "last_name": "Matson", + "institution": "" + }, + { + "first_name": "Richard de", + "last_name": "Steiger", + "institution": "" + } + ], + "dblp_key": "conf/popl/HewittBGSMS73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512944", + "title": "Procedure Linkage Optimization", + "abstract": "This paper discusses the desirability of procedure linkage optimization and sketches a general theory of interpretive semantics which is motivated by technical problems in specifying and validating program transformations that optimize procedure linkages. One particular transformation is treated in detail.Recursive ALGOL 60 procedures sometimes pass parameters by name in such a way that the general thunk mechanism is unnecessary and inefficient. We present an optimization which detects this kind of call-by-name and implements it thunklessly. We prove that the transformation preserves semantics and we discuss the effect on running time and memory management.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512944", + "conference_name": "POPL", + "authors": [ + { + "first_name": "A.", + "last_name": "Maggiolo‐Schettini", + "institution": "" + }, + { + "first_name": "Barry K.", + "last_name": "Rosen", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "H. Raymond", + "last_name": "Strong", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Maggiolo-SchettiniRS73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512931", + "title": "Top Down Operator Precedence", + "abstract": "Article Free Access Share on Top down operator precedence Author: Vaughan R. Pratt Massachusetts Institute of Technology Massachusetts Institute of TechnologyView Profile Authors Info & Claims POPL '73: Proceedings of the 1st annual ACM SIGACT-SIGPLAN symposium on Principles of programming languagesOctober 1973 Pages 41–51https://doi.org/10.1145/512927.512931Online:01 October 1973Publication History 25citation3,168DownloadsMetricsTotal Citations25Total Downloads3,168Last 12 Months170Last 6 weeks70 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512931", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vaughan", + "last_name": "Pratt", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Pratt73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512930", + "title": "Labelled Precedence Parsing", + "abstract": "Precendece techniques have been widely used in the past in the construction of parsers. However, the restrictions imposed by them on the grammars were hard to meet. Thus, alteration of the rules of the grammar was necessary in order to make them acceptable to the parser. We have shown that, by keeping track of the possible set of rules that could be applied at any one time, one can enlarge the class of grammars considered. The possible set of rules to be considered is obtained directly from the information given by a labelled set of precedence relations. Thus, the parsers are easily obtained. Compared to the precedence parsers, this new method gives a considerable increase in the class of parsable grammars, as well as an improvement in error detection. An interesting consequence of this approach is a new decomposition technique for LR parsers.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512930", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mario", + "last_name": "Schkolnick", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Schkolnick73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512943", + "title": "Reasoning About Programs", + "abstract": "This paper describes a theorem prover that embodies knowledge about programming constructs, such as numbers, arrays, lists, and expressions. The program can reason about these concepts and is used as part of a program verification system that uses the Floyd-Naur explication of program semantics. It is implemented in the QA4 language; the QA4 system allows many bits of strategic knowledge, each expressed as a small program, to be coordinated so that a program stands forward when it is relevant to the problem at hand. The language allows clear, concise representation of this sort of knowledge. The QA4 system also has special facilities for dealing with commutative functions, ordering relations, and equivalence relations; these features are heavily used in this deductive system. The program interrogates the user and asks his advice in the course of a proof. Verifications have been found for Hoare's FIND program, a real-number division algorithm, and some sort programs, as well as for many simpler algorithms. Additional theorems have been proved about a pattern matcher and a version of Robinson's unification algorithm.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512943", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard", + "last_name": "Waldinger", + "institution": "Menlo School" + }, + { + "first_name": "Karl", + "last_name": "Levitt", + "institution": "Menlo School" + } + ], + "dblp_key": "conf/popl/WaldingerL73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512947", + "title": "Transitions in Extendible Arrays", + "abstract": "Arrays are among the best understood and most widely used data structures. Yet even now, there are no satisfactory techniques for handling algorithms involving extendible arrays (where, e.g., rows and/or columns can be added dynamically). In this paper, the problem of allocating storage for extendible arrays is examined in the light of our earlier work on data graphs and addressing schemes. A formal analog of the assertion that simplicity of array extension precludes simplicity of transition (marching along rows/columns) is proved.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512947", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arnold L.", + "last_name": "Rosenberg", + "institution": "" + } + ], + "dblp_key": "conf/popl/Rosenberg73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512936", + "title": "Mathematical Semantics of Snobol 4", + "abstract": "This paper analyzes the semantics of the programming language SNOBOL4, following the mathematical approach proposed by D. Scott and C. Strachey. The study aims at clarifying a rather unusual semantic structure, and at demonstrating that the mathematical approach can provide a natural and usable formal specification of a practical programming language.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512936", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R. D.", + "last_name": "Tennent", + "institution": "Queen's University" + } + ], + "dblp_key": "conf/popl/Tennent73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512938", + "title": "Types are Not Sets", + "abstract": "The title is not a statement of fact, of course, but an opinion about how language designers should think about types. There has been a natural tendency to look to mathematics for a consistent, precise notion of what types are. The point of view there is extensional: a type is a subset of the universe of values. While this approach may have served its purpose quite adequately in mathematics, defining programming language types in this way ignores some vital ideas. Some interesting developments following the extensional approach are the ALGOL-68 type system [vW], Scott's theory [S], and Reynolds' system [R]. While each of these lend valuable insight to programming languages, I feel they miss an important aspect of types.Rather than worry about what types are I shall focus on the role of type checking. Type checking seems to serve two distinct purposes: authentication and secrecy. Both are useful when a programmer undertakes to implement a class of abstract objects to be used by many other programmers. He usually proceeds by choosing a representation for the objects in terms of other objects and then writes the required operations to manipulate them.", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512938", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James H.", + "last_name": "Morris", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/Morris73", + "venue": "popl", + "year": 1973 + }, + { + "paper_id": "10.1145/512927.512933", + "title": "A Parallel Approach to Compilation", + "abstract": "Article Free Access Share on A parallel approach to compilation Author: Mary Zosel Lawrence Livermore Laboratory Lawrence Livermore LaboratoryView Profile Authors Info & Claims POPL '73: Proceedings of the 1st annual ACM SIGACT-SIGPLAN symposium on Principles of programming languagesOctober 1973 Pages 59–70https://doi.org/10.1145/512927.512933Online:01 October 1973Publication History 11citation237DownloadsMetricsTotal Citations11Total Downloads237Last 12 Months5Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1973-01-01", + "link": "https://doi.org/10.1145/512927.512933", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mary", + "last_name": "Zosel", + "institution": "Laboratory for Research on Enterprise and Decisions" + } + ], + "dblp_key": "conf/popl/Zosel73", + "venue": "popl", + "year": 1973 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1975.json b/data/pl_conferences/popl/1975.json new file mode 100644 index 0000000..82c4316 --- /dev/null +++ b/data/pl_conferences/popl/1975.json @@ -0,0 +1,463 @@ +[ + { + "paper_id": "10.1145/512976.512993", + "title": "An Assertion Language for Data Structures", + "abstract": "In this paper we wish to consider the problem of proving assertions about programs that construct and alter arbitrarily complex data structures. In recent years several papers have been written on the subject of proving assertions about such programs; however, the class of data structures considered has generally been a proper sub-class of the class of all data structures, such as the classes of linear lists or trees. [Burstall 1972] discusses the problem of what he calls Distinct Non-repeating Lists and Distinct Non-repeating Trees. [Kowaltowski 1973] extends Burstall's approach. His approach is likewise basically tree-oriented but is applicable to more general data structures. [Laventhal 1974] restricts his attention to 'simple singly-linked lists', noting the problem of providing 'a complete framework for correctness proofs' if one attempts to handle very general data structures. [Morris 1972] discusses the question of designing a programming language for general data structures in order to facilitate verification of programs written in such a language. [Standish 1973] provides a set of axioms for the class of data structures in which, for instance, two data structures are equal iff they are component-wise equal.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512993", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Cook", + "institution": "University of Toronto" + }, + { + "first_name": "Derek C.", + "last_name": "Oppen", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/popl/CookO75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512991", + "title": "Programming Languages, Natural Languages, and Mathematics", + "abstract": "Some social aspects of programming are illuminated through analogies with similar aspects of mathematics and natural languages. The split between pure and applied mathematics is found similarly in programming. The development of natural languages toward flexionless, word-order based language types speaks for programming language design based on general, abstract constructs. By analogy with incidents of the history of artificial, auxiliary languages it is suggested that Fortran and Cobol will remain dominant for a long time to come. The most promising avenues for further work of wide influence is seen to be high quality program literature (i.e. programs) of general utility and studies of questions related to program style.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512991", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Naur", + "institution": "" + } + ], + "dblp_key": "conf/popl/Naur75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512988", + "title": "Even Simple Programs are Hard to Analyze", + "abstract": "It has long been known that most questions of interest about the behavior of programs are recursively undecidable. These questions include whether a program will halt, whether two programs are equivalent, whether one is an optimized form of another, and so on. On the other hand, it is possible to make some or all of these questions decidable by suitably restricting the computational ability of the programming language under consideration. The Loop language of Meyer and Ritchie [MR], for example, has a decidable halting problem, but undecidable equivalence. Restricting the computational ability still further, virtually all of these questions are decidable for finite automata and generalized sequential machines (except that Griffiths [Gri] has shown equivalence undecidable for nondeterministic gsms).A natural question to ask is how hard it is to solve these problems for programming languages for which they are decidable, and it is with this area that we are concerned in this paper. In particular we describe a programming language modeled on current higher-level languages which has exactly the computational power of deterministic finite state transducers with final states, and analyze the space and time required to decide various questions of programming interest about the language. We find that questions about halting, equivalence, and optimization are already intractable for this very simple language. We also study extensions to the language such as simple arithmetic capabilities, arrays, and recursive subroutines with both call-by-value and call-by-name parameter passing mechanisms, some of which extend the capabilities of the language and/or increase the complexity of its decidable problems. In one case, that of recursion with call-by-name, the previously decidable questions are seen to become undecidable.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512988", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neil D.", + "last_name": "Jones", + "institution": "University of Kansas" + }, + { + "first_name": "Steven S.", + "last_name": "Muchnick", + "institution": "University of Kansas" + } + ], + "dblp_key": "conf/popl/JonesM75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512979", + "title": "A Fast and Usually Linear Algorithm for Global Flow Analysis", + "abstract": "A new algorithm for global flow analysis on reducible graphs is presented. The algorithm is shown to treat a very general class of function spaces. For a graph of e edges, the algorithm has a worst case time bound of 0(e log2e) function operations. In programming terms, the number of operations is shown to be proportional to e + the number of exit nodes from program loops. Consequently a restriction to one-entry one-exit control structures guarantees linearity. It is shown that by relaxing these time bounds, a yet wider class of function spaces can be handled.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512979", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mark N.", + "last_name": "Wegman", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/GrahamW75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512977", + "title": "Application of Lattice Algebra to Loop Optimization", + "abstract": "Article Free Access Share on Application of lattice algebra to loop optimization Authors: Amelia Fong Princeton University, Princeton N. J. Princeton University, Princeton N. J.View Profile , John Kam Princeton University, Princeton N. J. Princeton University, Princeton N. J.View Profile , Jeffrey Ullman Princeton University, Princeton N. J. Princeton University, Princeton N. J.View Profile Authors Info & Claims POPL '75: Proceedings of the 2nd ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1975 Pages 1–9https://doi.org/10.1145/512976.512977Online:01 January 1975Publication History 13citation241DownloadsMetricsTotal Citations13Total Downloads241Last 12 Months8Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512977", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amelia C.", + "last_name": "Fong", + "institution": "Princeton University" + }, + { + "first_name": "John B.", + "last_name": "Kam", + "institution": "Princeton University" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/FongKU75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512986", + "title": "A Semantic Model for Parallel Systems with Scheduling", + "abstract": "This paper presents a semantic model for parallel systems with a scheduling mechanism that is useful for expressing and proving a wider range of properties than semantic models that do not consider scheduling.We formally describe a number of properties related to scheduling and deadlock, including \"Fairness\" and \"Fullness\", and show that schedulers with these properties behave in desirable ways.Lastly, we prove and conjecture some proof rules for scheduled systems and outline briefly the relation of this work to modelling protection in parallel systems.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512986", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ellis S.", + "last_name": "Cohen", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Cohen75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512990", + "title": "On the Complexity of LR(k) Testing", + "abstract": "In this paper we derive upper bounds on the complexity of LR(k) testing both when k is considered to be a fixed integer and also when k is considered to be a parameter of the problem. In the latter case, we show that the lower bounds on the running time of such algorithms depend very strongly on the representation chosen for k. Thus LR(k) testing is NP-complete when k is expressed in unary and complete for nondeterministic exponential time when k is expressed in binary.These results carry over to many other parameterized classes of grammars, such as the LL(k), strong LL(k), SLR(k), LC(k), strong LC(k), BRC(l,k), BC(l,k) and extended precedence (l,k) grammars.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512990", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harry B.", + "last_name": "Hunt", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas G.", + "last_name": "Szymanski", + "institution": "Princeton University" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/HuntSU75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512983", + "title": "Correctness-Preserving Program Transformations", + "abstract": "This paper extends the predicate calculus formalization of the partial correctness properties of programs (Ki, Go) to include the preservation of correctness under program transformations. The general notion of \"program transformations which preserve properties\" is fundamental to the theory of programming and programming languages. In the context of proofs of program correctness, transformations which preserve correctness can be used to improve less efficient, but easier to prove, programs. The basic argument in the use of correctness-preserving program transformations (hereafter CPTs) is:Assume that G is a program (with attached assertions) which has been proved correct with respect to some input-output relation Ain-Aout. Now suppose that S is some part of G, e.g. an expression, assertion, statement, etc., which is to be replaced by some other such part S' to produce the program G'. The goal is to prove that G' is also correct with respect to Ain-Aout and therefore the replacement preserves overall program correctness. Moreover, if the replacement has only a local effect, e.g. the body of a loop, then the proof of correctness-preservation should be restricted to that part of the program affected by the replacement.Section 2 reviews the current paradigm for proving program correctness. An example in section 3 illustrates CPTs in a sequence of improvements on a correct and simple, but inefficient, initial program. In section 4, the formalization of partial correctness properties of programs is recast as a semantic language definition using Knuth's semantic method (Kn1). This formalization is then used in section 5 to describe the mechanics of performing CPTs. In section 6, several questions about the formalization of sections 4 and 5 are discussed and a generalization is proposed. Finally, section 7 returns to a concrete example and suggests that the most effective use of CPTs is by identification of schematic forms. Related work is mentioned in section 8.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512983", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Susan L.", + "last_name": "Gerhart", + "institution": "Duke University" + } + ], + "dblp_key": "conf/popl/Gerhart75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512998", + "title": "An Algebra of Relations for Machine Computation", + "abstract": "This paper extends the relational algebra of data bases, presented by Codd [4] and others, in four areas. The first is the use of selector names to remove order dependencies from the columns of a relation. This use of selector names enables us to define a more general class of operations, which include the normal relational operations of union, equi-join etc., as special cases. Thirdly we introduce relations represented algorithmically as well as by a stored set of tuples. Such computed relations cannot always be effectively realised as a finite set of tuples. Finally we consider relational expressions as algorithmic representations of relations and characterize their effectiveness.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512998", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick A. V.", + "last_name": "Hall", + "institution": "Durham University" + }, + { + "first_name": "Peter B.", + "last_name": "Hitchcock", + "institution": "Durham University" + }, + { + "first_name": "Stephen", + "last_name": "Todd", + "institution": "IBM (United Kingdom)" + } + ], + "dblp_key": "conf/popl/HallHT75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512981", + "title": "Automatic Data Structure Choice in a Language of Very High Level", + "abstract": "SETL is a set-theoretically oriented language of very high level whose repertoire of semantic objects includes finite sets, ordered n-tuples, and sets of ordered n-tuples useable as mappings. This paper sets forth techniques for the logical analysis and optimization of SETL programs. The techniques described allow relations of inclusion and membership to be established, the domains and ranges of (tabulated) mappings to be estimated from above and below, and the singlevaluedness of (tabulated) mappings to be proved. Once facts of this kind have been established, automatic choice of data structures becomes possible. The methods employed are based upon, and extend, known techniques of data-flow analysis.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512981", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J. T.", + "last_name": "Schwartz", + "institution": "New York University" + } + ], + "dblp_key": "conf/popl/Schwartz75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512997", + "title": "Structured Exception Handling", + "abstract": "In this paper, we define what exception conditions are, discuss the requirements exception handling language features must satisfy, survey and analyze existing approaches to exception handling, and propose some new language features for dealing with exceptions in an orderly and reliable way. Our objective is not solely to put forward a language proposal. It is also to analyze exception handling issues and principles in detail. The proposed language features serve to highlight exception handling issues by showing how deficiencies in current approaches could be remedied in a coherent and orderly way.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512997", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John B.", + "last_name": "Goodenough", + "institution": "SofTech (Italy)" + } + ], + "dblp_key": "conf/popl/Goodenough75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512978", + "title": "Node Listings Applied to Data Flow Analysis", + "abstract": "A new approach to global program data flow analysis which constructs a for the control flow graph is discussed and a simple algorithm which uses a node listing to determine the live variables in a program is presented. This algorithm combined with a fast node listing constructor due to Aho and Ullman has produced an 0(n log n) algorithm for live analysis. The utility of the node-listing method is demonstrated by an examination of the class of graphs for which short listings exist. This class is quite similar to the class of graphs for understandable programs.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512978", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/Kennedy75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512989", + "title": "On the Complexity of the Circularity Test for Attribute Grammars", + "abstract": "It is shown that both the upper and the lower bounds on the time complexity of the circularity test for Knuth's attribute grammars are exponential functions of the size of the grammar description. This result implies the \"intractability\" of the circularity test in the sense that the implementation of a general algorithm is not feasible. Another significance of this result is that this is one of the first problems actually arising in practice which has been proven to be of exponential time complexity.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512989", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mehdi", + "last_name": "Jazayeri", + "institution": "" + }, + { + "first_name": "William F.", + "last_name": "Ogden", + "institution": "Case Western Reserve University" + }, + { + "first_name": "William C.", + "last_name": "Rounds", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/popl/JazayeriOR75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512984", + "title": "Actor Semantics of Planner-73", + "abstract": "Work on PLANNER-73 and actors has led to the development of a basis for semantics of programming languages. Its value in describing programs with side-effects, parallelism, and synchronization is discussed. Formal definitions are written and explained for sequences, cells, and a simple synchronization primitive. In addition there is discussion of the implications of actor semantics for the controversy over elimination of side-effects.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512984", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Irene", + "last_name": "Greif", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Carl", + "last_name": "Hewitt", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/GreifH75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512995", + "title": "Program Schemas with Concurrency: Execution Time and Hangups", + "abstract": "A class of program schemas with concurrency is defined as a natural extension of the standard notion of sequential flow-chart-like schemas. The question is considered as to whether such a program schema may reach a premature termination (or \"hangup\") for some interpretation. It is shown that in general this question is undecidable; however, it is shown to be decidable for the class of free program schemas. And an algorithm for testing this property is presented with an upper time bound that grows linearly with the size of the schema.Several structural properties are shown to be equivalent to the hangup-free conditon for free schemas. And we give a method for computing the expected execution time of a program schema if the expected frequencies of choices at the branch points are known.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512995", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bruce P.", + "last_name": "Lester", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/Lester75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512994", + "title": "An Algebraic Model for String Patterns", + "abstract": "Article Free Access Share on An algebraic model for string patterns Author: Glenn F. Stewart I.P. Sharp Associates Limited, Toronto, Ontario, Canada I.P. Sharp Associates Limited, Toronto, Ontario, CanadaView Profile Authors Info & Claims POPL '75: Proceedings of the 2nd ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1975 Pages 167–184https://doi.org/10.1145/512976.512994Published:01 January 1975Publication History 8citation252DownloadsMetricsTotal Citations8Total Downloads252Last 12 Months11Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512994", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Glenn F.", + "last_name": "Stewart", + "institution": "Golder Associates (Canada)" + } + ], + "dblp_key": "conf/popl/Stewart75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512982", + "title": "A Mathematical Approach to Language Design", + "abstract": "A framework for validating surface properties of programming language constructs, composed of proof rules (akin to those of Hoare) and supporting hypotheses, is constructed using the mathematical semantics of Scott and Strachey. The following approach to language design is then considered: the constructs of a language should have surface properties which 1) need few hypotheses other than assumed surface properties; and 2) have proofs consisting, as far as possible, of trivial fixpoint and structural inductions.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512982", + "conference_name": "POPL", + "authors": [ + { + "first_name": "George T.", + "last_name": "Ligler", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/Ligler75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512999", + "title": "Computer Assisted Application Definition", + "abstract": "This paper describes a system being developed to bridge the gap between an application program and a user inexperienced in the ways of computers. The user explores the characteristics of the available programs by a natural language dialogue with the system. The dialogue is supported by a knowledge base covering both the program semantics and the application domain. This paper addresses the problems of representation and inference involved in this approach and describes our solution for them.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512999", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Mikelsons", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Mikelsons75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512992", + "title": "Modes, Values, and Expressions", + "abstract": "NO ABSTRACT SUPPLIED", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512992", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marvin", + "last_name": "Solomon", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Solomon75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512985", + "title": "Reduction: A New Method of Proving Properties of Systems of Processes", + "abstract": "When proving that a system of processes has a given property it is often convenient to assume that a routine is uninterruptible, i.e. that the routine cannot be interleaved with the rest of the system. Here sufficient conditions are obtained to show that the assumption that a routine is uninterruptible can be relaxed and still preserve basic properties such as halting and determinacy. Thus correctness proofs of a system of processes can often be greatly simplified. This technique - called reduction - is viewed as the replacement of an interruptible routine by an uninterruptible one.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512985", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard J.", + "last_name": "Lipton", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/Lipton75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512987", + "title": "A Description of Path Expressions by Petri Nets", + "abstract": "Petri nets are used to define a path and process notation which is more general in its ability to express synchronization than previous path notations. The Petri net classes corresponding to the path notation prove to be interesting in their own right and have demonstrable properties such as liveness and safeness.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512987", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Lauer", + "institution": "Newcastle University" + }, + { + "first_name": "Roy H.", + "last_name": "Campbell", + "institution": "Newcastle University" + } + ], + "dblp_key": "conf/popl/LauerC75", + "venue": "popl", + "year": 1975 + }, + { + "paper_id": "10.1145/512976.512996", + "title": "New Control Structures to Aid Gotolessness", + "abstract": "This paper contains a suggestion for a calculus for constructing 'flowchartable' algorithms. The calculus is a generalization of an Algol-like calculus, and hence maintains some discipline over the algorithms constructible with it.The essence of the great 'go to' debate seems to be that the use of the 'go to' device allows the construction of 'spaghetti-like' algorithms which are difficult to control intellectually, and hence that only more restrictive, special-purpose control structures (which are presumably well thought out) should be used. Another way of saying this, perhaps, is that the 'go to' device is the most primitive (and hence most general) possible control structure, and though implementations of any control structure will ultimately have to be done using it, a programmer should no more be content using a 'go to' than if he were forced to use bit strings for data types. He should be demanding higher-level control structures. To some extent, of course, he has them; but, in discussing the 'go to' debate, the conclusion arrived at by Knuth (1), for instance, is that more powerful control structures than are freely available at present are needed to enable programmers to express their algorithms. He mentions a suggestion by Zahn (2) for strengthening the set of available control structures, but shows that he still needs to resort to the dreaded 'go to' device. (He confesses a sinful urge to jump into the middle of Zahn's loops.) The implication is that even with Zahn's suggestions there is a need for more control structures. We concur with this view, and present here a suggestion for making more such structures available. We invite discussion as to whether the results are profitable for programming language design.The lack of well-developed control structures is manifested, incidentally, not only in the dearth of 'public' control structures (i.e. made freely available to all users), but also in the lack of facilities for creating 'private' ones (analogously to the notion of 'subroutines' or user-defined data types). These deficiencies are not all that surprising since control structures are, in a sense, devices at a third level of sophistication: data (being the first level) is acted upon by programs (being the second level) to produce other data; and programs are acted upon by control structures to produce other programs. But the time has perhaps come to pay some more attention to control structures.", + "date": "1975-01-01", + "link": "https://doi.org/10.1145/512976.512996", + "conference_name": "POPL", + "authors": [ + { + "first_name": "DOMINIC", + "last_name": "SYMES", + "institution": "Queen's University" + } + ], + "dblp_key": "conf/popl/Symes75", + "venue": "popl", + "year": 1975 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1976.json b/data/pl_conferences/popl/1976.json new file mode 100644 index 0000000..d8c7885 --- /dev/null +++ b/data/pl_conferences/popl/1976.json @@ -0,0 +1,437 @@ +[ + { + "paper_id": "10.1145/800168.811544", + "title": "Induction Variables in Very High Level Languages", + "abstract": "We explore the notion of an induction variable in the context of a set-theoretic programming langugage. An appropriate definition, we believe, involves both the necessity that changes in the variable around a loop be easily computable and that they be small. We attempt to justify these requirements and show why they are independent assumptions. Next the question of what operators on sets play the role of +, − and * for arithmetic languages is explored, and several theorems allowing us recursively to detect induction variables in a loop are given. It is shown that most of the usual set operations do fit nicely into the theory and help form induction variables. The reason most variables fail to be induction variables concerns the structure of control flow, more than it does the operators applied.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811544", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amelia C.", + "last_name": "Fong", + "institution": "Princeton University" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "" + } + ], + "dblp_key": "conf/popl/FongU76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811550", + "title": "Primitive Recursive Program Transformations", + "abstract": "We describe how to transform certain flowchart programs into equivalent explicit primitive recursive programs. The input/output correctness conditions for the transformed programs are more amenable to proof than the verification conditions for the corresponding flowchart programs. In particular, the transformed correctness conditions can often be verified automatically by the theorem prover developed by Boyer and Moore [1].", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811550", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R. S.", + "last_name": "Boyer", + "institution": "" + }, + { + "first_name": "J. S.", + "last_name": "Moore", + "institution": "" + }, + { + "first_name": "Robert E.", + "last_name": "Shostak", + "institution": "" + } + ], + "dblp_key": "conf/popl/BoyerMS76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811543", + "title": "A Lazy Evaluator", + "abstract": "A different way to execute pure LISP programs is presented. It delays the evaluation of parameters and list structures without ever having to perform more evaluation steps than the usual method. Although the central idea can be found in earlier work this paper is of interest since it treats a rather well-known language and works out an algorithm which avoids full substitution. A partial correctness proof using Scott-Strachey semantics is sketched in a later section.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811543", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Henderson", + "institution": "Newcastle University" + }, + { + "first_name": "James H.", + "last_name": "Morris", + "institution": "Newcastle University" + } + ], + "dblp_key": "conf/popl/HendersonM76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811537", + "title": "Code Generation for Expressions with Common Subexpressions", + "abstract": "Easy as the task may seem, many compilers generate rather inefficient code. Some of the difficulty of generating good code may arise from the lack of realistic models for programming language and machine semantics. In this paper we show that the computational complexity of generating efficient code in realistic situations may also be a major cause of difficulty in the design of good compilers.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811537", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alfred V.", + "last_name": "Aho", + "institution": "" + }, + { + "first_name": "S. C.", + "last_name": "Johnson", + "institution": "" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "" + } + ], + "dblp_key": "conf/popl/AhoJU76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811535", + "title": "The Influence of Productions on Derivations and Parsing", + "abstract": "The concept of grammar forms [4,5] provides evidence that there seems to be no way to base the definitions of many grammar types used in parsing and compiling solely on the concept of productions.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811535", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benton", + "last_name": "Leong", + "institution": "" + }, + { + "first_name": "Detlef", + "last_name": "Wotschke", + "institution": "" + } + ], + "dblp_key": "conf/popl/LeongW76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811546", + "title": "On Directly Constructing LR(k) Parsers Without Chain Reductions", + "abstract": "A chain production is a production of the form A→M where A is a nonterminal and M is either a terminal or nonterminal. Pager in [Pag5] has presented an algorithm which removes all chain reductions from LR(1) parsers after they have been constructed.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811546", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wilf R.", + "last_name": "LaLonde", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/popl/LaLonde76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811553", + "title": "Verifying Formal Specifications of Synchronous Processes", + "abstract": "SYNVER is an automatic programming system for the synthesis of solutions to problems of synchronization among concurrent processes from specifications written in a high level assertion language (SAL). The correctness of the solutions constructed by SYNVER follows from the soundness of the synthesizer itself and from a verification phase which is applied to the specifications. This verification phase is the main topic of this paper. To provide context for the verification the paper includes a discussion of synchronization problems and a brief overview of both the SYNVER system and the SAL specification language. A formal definition of the correctness of a SAL specification is then presented along with algorithms which may be used to determine if a given specification is correct.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811553", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patricia P.", + "last_name": "Griffiths", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Charles J.", + "last_name": "Prenner", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/GriffithsP76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811536", + "title": "A Complexity Theory of Grammar Problems", + "abstract": "The close relationship between programming language syntax, context-free grammars (abbreviated cfgs), parsing, and compiling is well-known and is extensively discussed in [1]. Unfortunately, many of the problems about programming languages, one might wish to solve, are equivalent to undecidable grammar problems. Two especially important such problems are", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811536", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harry B.", + "last_name": "Hunt", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/Hunt76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811545", + "title": "An Algorithm for Structuring Programs", + "abstract": "Structured programming emphasizes programming language constructs such as while loops, until loops, and if then else statements. Properly used, these constructs make occurrences of loops and branching of control obvious. They are preferable to goto statements, which tend to obscure the flow of control [DDH,DIJ]. This paper describes an algorithm which transforms a flowgraph into a program written using repeat (do forever) and if then else statements. The goal of the algorithm is to produce readable programs, rather than to avoid the use of goto statements entirely. goto statements are generated when there is no better way to describe the flow of control.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811545", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brenda S.", + "last_name": "Baker", + "institution": "" + } + ], + "dblp_key": "conf/popl/Baker76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811542", + "title": "Binding Time Optimization in Programming Languages: Some Thoughts Toward the Design of an Ideal Language", + "abstract": "A new approach to the design of a programming language and its processor is proposed and some of the techniques necessary to realize the design are investigated. The language would have a precisely specified syntax and semantics, with both designed to provide the programmer maximal expressive power and to be as easily understood as possible. The semantics would be based on extremely late binding times, which provide great power to the programmer and are consistent with ease of understanding of the execution process. It would be the responsibility of the processor to implement each program in the most efficient manner consistent with its being correctly executed. Implications of this design philosophy and some of the techniques to be used are discussed in greater detail, focusing particularly on data types and storage allocation.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811542", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neil D.", + "last_name": "Jones", + "institution": "" + }, + { + "first_name": "Steven S.", + "last_name": "Muchnick", + "institution": "" + } + ], + "dblp_key": "conf/popl/JonesM76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811554", + "title": "Test Data as an Aid in Proving Program Correctness", + "abstract": "Proofs of program correctness tend to be long and tedious whereas testing, though useful in detecting errors, usually does not guarantee correctness. This paper introduces a technique whereby test data can be used in proving program correctness. In addition to simplifying certification of correctness, this method simplifies the process of providing specifications for a program. The applicability of this technique to procedures, recursive programs, and modular programs is demonstrated.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811554", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew M.", + "last_name": "Geller", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/popl/Geller76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811552", + "title": "Procedure Referencing Environments in SL5", + "abstract": "SL5 is a programming language developed for experimental work in generalized pattern matching and high-level data structuring and access mechanisms. This paper describes the procedure mechanism and the conventions for the interpretation of identifiers in SL5. Procedure invocation in SL5 is decomposed into the separate source-language operations of context creation, argument binding and procedure activation, and allows SL5 procedures to be used as recursive functions or coroutines. This decomposition has led to rules for scoping and for the interpretation of identifiers that are different from those found in other programming languages. Several examples of SL5 procedures are given, including a scanner based on the coroutine model of pattern matching.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811552", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dianne E.", + "last_name": "Britton", + "institution": "" + }, + { + "first_name": "Frederick C.", + "last_name": "Druseiks", + "institution": "" + }, + { + "first_name": "Ralph E.", + "last_name": "Griswold", + "institution": "" + }, + { + "first_name": "David R.", + "last_name": "Hanson", + "institution": "" + }, + { + "first_name": "Richard A.", + "last_name": "Holmes", + "institution": "" + } + ], + "dblp_key": "conf/popl/BrittonDGHH76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811547", + "title": "PLAN2D - Syntactic Analysis of Precedence Graph Grammars", + "abstract": "The syntactical analysis of pictures derived by a context-free graph-grammar is a rather complicated algorithm. Analogously to the development for Chomsky-grammars ten years ago we define the precedence-graph-grammars as a subclass of the context-free graph-grammars allowing for easier parsing algorithms. By table-lookup we can decide locally if an edge or a node is part of a handle and if it isn't in which direction to proceed to reach one.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811547", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Reinhold", + "last_name": "Franck", + "institution": "" + } + ], + "dblp_key": "conf/popl/Franck76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811551", + "title": "Mathematical Semantics and Data Flow Programming", + "abstract": "A Data Flow program [1,2] is a flow-chart like network of operators which compute concurrently, dependent only on the availability of the data which flow along the paths. Each operator has only a local effect, transforming input data to output data. Although operators may exhibit memory and thus not be functional from an input to an output, all operators are functions from input sequences to output sequences. This plus the strong locality of effect allows mathematization of semantics more readily than traditional programming languages which are burdened with omnipresent storage and occasional GOTO's. This paper proves the semantic behavior of some elementary Data Flow programs and proves that certain optimization transformations preserve other behaviors.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811551", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul R.", + "last_name": "Kosinski", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Kosinski76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811539", + "title": "Automatic Design of Data Processing Systems", + "abstract": "An automated business data processing system designer is described. Attention is centered on the I/O aspects of such systems and the development of optimizing design heuristics.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811539", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gregory R.", + "last_name": "Ruth", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Ruth76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811548", + "title": "Program Improvement by Source to Source Transformation", + "abstract": "We treat a program as an object of manipulation, determine items of program constancy, and simplify the program based on the constancy. Some motivation for program manipulation is presented, along with two examples of “higher level optimization” written in an Algol-like language. A collection of program transformations and a model of the compilation process in terms of source-to-source transformations are presented. Finally a description of the application of these ideas to an existing programming language is given.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811548", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David B.", + "last_name": "Loveman", + "institution": "" + } + ], + "dblp_key": "conf/popl/Loveman76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811538", + "title": "Automatic Generation of Efficient Evaluators for Attribute Grammars", + "abstract": "The translation process may be divided into a syntactic phase and a semantic phase. Context-free grammars can be used to describe the set of syntactically correct source texts in a formal yet intuitively appealing way, and many techniques are now known for automatically constructing parsers from given CF grammars. Knuth's attribute grammars offer the prospect of similarly automating the implementation of the semantic phase.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811538", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + }, + { + "first_name": "Scott K.", + "last_name": "Warren", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/KennedyW76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811540", + "title": "Techniques for the Automatic Selection of Data Structures", + "abstract": "We are all aware of the development of increasingly sophisticated, elaborate, and expensive computer programs, particularly in the fields of artificial intelligence, data base management, and intelligent systems. The need for techniques to deal with such complexity has renewed interest in programming language research. Recent work on structured programming, intelligent compilers, automatic program generation and verification, and high-level optimization has resulted.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811540", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James Richard", + "last_name": "Low", + "institution": "University of Rochester" + }, + { + "first_name": "Paul", + "last_name": "Rovner", + "institution": "" + } + ], + "dblp_key": "conf/popl/LowR76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811549", + "title": "Goal-Directed Program Transformation", + "abstract": "Program development often proceeds by transforming simple, clear programs into complex, involuted, but more efficient ones. This paper examines ways this process can be rendered more systematic. We show how analysis of program performance, partial evaluation of functions, and abstraction of recursive function definitions from recurring subgoals can be combined to yield many global transformations in a methodical fashion. Examples are drawn from compiler optimization, list processing, very high level languages, and APL execution.", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811549", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ben", + "last_name": "Wegbreit", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/Wegbreit76", + "venue": "popl", + "year": 1976 + }, + { + "paper_id": "10.1145/800168.811541", + "title": "A Methodology for Lisp Program Construction from Examples", + "abstract": "This paper reports on a system, THESYS, that synthesizes LISP recursive programs from examples of what they do. There has been recent interest in this form of program specification[1,4,8]. The theory of such inductive systems has been investigated by Blum and Blum[2], Kugel[5] and Summers[10]. In this paper we describe the practical results of an investigation into the problem of program synthesis from examples. The methodology to be presented is based on a firm theoretical foundation which may provide a basis for generalizing the results to other kinds of program synthesis systems. The various theoretical models for computation and data that comprise the theory are not described in detail in this paper but may be found in [10].", + "date": "1976-01-01", + "link": "https://doi.org/10.1145/800168.811541", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Phillip D.", + "last_name": "Summers", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/Summers76", + "venue": "popl", + "year": 1976 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1977.json b/data/pl_conferences/popl/1977.json new file mode 100644 index 0000000..dd65c3d --- /dev/null +++ b/data/pl_conferences/popl/1977.json @@ -0,0 +1,481 @@ +[ + { + "paper_id": "10.1145/512950.512962", + "title": "An Interprocedural Data Flow Analysis Algorithm", + "abstract": "A new interprocedural data flow analysis algorithm is presented and analyzed. The algorithm associates with each procedure in a program information about which variables may be modified, which may be used, and which are possibly preserved by a call on the procedure, and all of it subcalls. The algorithm is sufficiently powerful to be used on recursive programs and to deal with the sharing of variables which arises through reference parameters. The algorithm is unique in that it can compute all of this information in a single pass, not requiring a prepass to compute calling relationships or sharing patterns. A lower bound for the computational complexity of gathering interprocedural data flow information is derived and the algorithm is shown to be asymptotically optimal. The algorithm has been implemented and it is practical for use even on quite large programs.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512962", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeffrey M.", + "last_name": "Barth", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/Barth77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512960", + "title": "An Efficient Insertion-Only Error-Corrector for LL(1) Parsers", + "abstract": "An LL(1)-based error-corrector which operates by insertion-only is studied. The corrector is able to correct and parse any input string. It is efficient (linear in space and time requirements) and chooses least-cost insertions (as defined by the user) in correcting syntax errors. Moreover, the error-corrector can be generated automatically from the grammar and a table of terminal symbol insertion costs. The class of LL(1) grammars correctable by this method contains (with minor modifications) grammars used to specify most common programming languages. Preliminary results suggest that this method can be used to advantage in LL(1)-driven compilers.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512960", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Charles N.", + "last_name": "Fischer", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "D. R.", + "last_name": "Milton", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Scott", + "last_name": "Quiring", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/FischerMQ77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512970", + "title": "Social Processes and Proofs of Theorems and Programs", + "abstract": "Article Free Access Share on Social processes and proofs of theorems and programs Authors: Richard A. DeMillo Georgia Institute of Technology Georgia Institute of TechnologyView Profile , Richard J. Lipton Yale University Yale UniversityView Profile , Alan J. Perlis Yale University Yale UniversityView Profile Authors Info & Claims POPL '77: Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1977 Pages 206–214https://doi.org/10.1145/512950.512970Online:01 January 1977Publication History 22citation680DownloadsMetricsTotal Citations22Total Downloads680Last 12 Months16Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512970", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard A.", + "last_name": "DeMillo", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Richard J.", + "last_name": "Lipton", + "institution": "Yale University" + }, + { + "first_name": "Alan J.", + "last_name": "Perlis", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/DeMilloLP77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512967", + "title": "Elimination of Single Productions from LR Parsers in Conjunction with the Use of Default Reductions", + "abstract": "One of the most attractive techniques in optimizing LR parsers is to eliminate reductions by semantically insignificant productions of the form A → X (single productions), where X is a nonterminal or a terminal; such a modification can lead to substantial savings in both space and time. Therefore, much effort has been devoted to the development of methods for eliminating reductions by single productions from LR parsers (Aho and Ullman [1973a,1973b], Anderson, Eve and Horning[1973], Pager[1973a,1974], Demers[1974,1975], Backhouse [1976], Joliat[1976], Koskimies[1976], LaLonde [1976], Soisalon-Soininen[1976]).", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512967", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eljas", + "last_name": "Soisalon-Soininen", + "institution": "University of Helsinki" + } + ], + "dblp_key": "conf/popl/Soisalon-Soininen77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512959", + "title": "On the Covering of Left Recursive Grammars", + "abstract": "In this paper we show that some prevailing ideas on the elimination of left recursion in a context-free grammar are not valid. An algorithm and a proof are given to show that every proper context-free grammar is covered by a non-left-recursive grammar.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512959", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anton", + "last_name": "Nijholt", + "institution": "" + } + ], + "dblp_key": "conf/popl/Nijholt77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512956", + "title": "Generalized Common Subexpressions in Very High Level Languages", + "abstract": "We propose a new optimization technique applicable to set-oriented languages, which we shall call general common subexpression elimination. It involves the computation of the IAVAIL(n) function for all nodes n in a flow graph, where IAVAIL(n) is the set of expressions such that along every path leading to n, there will be found a computation of the expression followed by only incidental assignments (i.e. A = A ∪ {x} or A = A - {x}) to its operands and that the number of such assignments is bounded, independent of the path taken. We shall try to justify our definitions and demonstrate the usefulness of this technique by several examples. We shall show that this optimization problem does not fit into the semilattice-theoretic model for global program optimization [Ki, KU, GW], and that the standard iterative algorithm for such problems does not work in this case. We then give several theorems which allow the problem to be solved for reducible flow graphs. The formulae given in the theorems are in such a form that an efficient algorithm can be found by adapting an algorithm given in [U]. The resulting algorithm takes 0(e log e) steps of an extended type, where bit vector operations are regarded as one step, and e is the number of edges of the flow graph. It takes 0(n log n) extended steps for a program flow graph of n nodes.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512956", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amelia C.", + "last_name": "Fong", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/popl/Fong77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512971", + "title": "Minimal and Optimal Computations of Recursive Programs", + "abstract": "Procedure call mechanisms have mainly been studied in the framework of recursive programs without assignments, for the simplicity of their operational and denotational semantics (See Scott [16], Nivat [14], Vuillemin [17]).", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512971", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gérard", + "last_name": "Berry", + "institution": "École Nationale Supérieure des Mines de Paris" + }, + { + "first_name": "Jean-Jacques", + "last_name": "Lévy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/BerryL77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512969", + "title": "Structuring", + "abstract": "Structuring can be defined independently of what is being structured, and can be applied profitably to more than one domain. Using one mechanism to structure both values and assignments, we obtain equivalents for a variety of data and control structures. Structuring assignments is preferable to structuring control: the former is more conducive to a mathematical style of programming while the latter is more conducive to tracing.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512969", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eric C. R.", + "last_name": "Hehner", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/popl/Hehner77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512974", + "title": "The Equivalence Problem for Program Schemata with Nonintersecting Loops", + "abstract": "In his thesis Paterson proved that equivalence is decidable for program schemata such that every instruction falls on at most one loop and only monadic function signs appear. Here we remove the restriction on function signs. The problem reduces to that of showing that the numerical exponents which satisfy certain word equations over a semigroup of acyclic directed graphs may be characterized by sentences of Presburger arithmetic; these exponents correspond to loop coefficients of the program schemata. The central construction is a finite automaton whose memory is a window of bounded size on an acyclic directed graph corresponding to a solution to such a word equation.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512974", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harry R.", + "last_name": "Lewis", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/Lewis77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512954", + "title": "A New Strategy for Code Generation - The General Purpose Optimizing Compiler", + "abstract": "This paper presents a systematic approach to the problem of generating good code with a compiler that is easy to construct. A compiler structure is proposed which relies on interprocedural data flow analysis, global optimization, and an intermediate language schema to simplify the task of writing the code generating portions of a compiler without sacrificing code quality. This structure is contrasted with a more conventional structure to explore the reasons why the new structure solves several problems inherent in the conventional structure. Further advantages which accrue from the new structure are also presented.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512954", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William", + "last_name": "Harrison", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Harrison77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512966", + "title": "Generalized Left Corner Parsing", + "abstract": "Brosgol [Br] formalizes the notion that parsing methods can be classified by the positions at which production rules are recognized. In an LL parser, each rule is recognized at the left end, before the rule's yield has been read; in an LR parser, a rule is recognized at its right end, after its yield has been read; and in an LC parser a rule is recognized after the yield of its \"left corner\" has been read. We generalize on these techniques by allowing the user to specify arbitrarily for each production rule the position at which that rule is to be recognized. The resulting GLC or generalized left corner technique includes the LR, LL, LC, and ELC methods as special cases. It also allows for less conventional parsing strategies, such as grammar splitting [K] with certain component grammars parsed top-down and the others parsed bottom-up, as suggested in [AU].This paper is organized as follows. In Section 2 we give some necessary background and notation. Section 3 defines GLC parsing. A canonical GLC(k) parsing technique can be defined analogous to the LR(k) technique. However, the resulting parsers tend to be unacceptably large. We therefore restrict our attention to the SGLC(k), or simple generalized left corner parsing technique, which is analogous to the SLR(k) technique of DeRemer [D]. We give an algorithm for the construction of SGLC(k) parsing tables and prove that the resulting parser is correct.In Section 4 we develop some potentially useful properties of SGLC(1) parsers. We show that there is a well-defined leftmost position at which each production rule can be recognized, and that a minimal left corner parser can be constructed which recognizes each rule as early as possible. We derive a simple expression relating the size (number of states) of an SGLC(1) parser to the size of the corresponding SLR(1) parser. If G is not left-recursive, then the minimal left-corner parser is the smallest parser for G in this class, while the SLR(1) parser is the largest.In Section 5 we extend the techniques 5 of [HSU] to give an O(n2) algorithm to test whether a grammar with no left recursion is SGLC(1), and if so to compute its minimal left corners.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512966", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Demers77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512952", + "title": "Programming Language Constructs for Which it is Impossible to Obtain "Good" Hoare-Like Axiom Systems", + "abstract": "Hoare-like deduction systems for establishing partial correctness of programs may fail to be complete because of (a) incompleteness of the assertion language relative to the underlying interpretation or (b) inability of the assertion language to express the invariants of loops. S. Cook has shown that if there is a complete proof system for the assertion language (e.g. all true statements of the assertion language) and if the assertion language satisfies a certain natural expressibility condition, then sound and complete axiom systems for a fairly large subset of Algol may be devised. We exhibit programming language constructs for which it is impossible to obtain sound and complete sets of Hoare-like axioms even in this special sense of Cook's. These constructs include (i) recursive procedures with procedure parameters in a programming language which uses static scope of identifiers and (ii) coroutines in a language which allows parameterless recursive procedures. Modifications of these constructs for which it is possible to obtain sound and complete systems of axioms are also discussed.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512952", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Edmund", + "last_name": "Clarke", + "institution": "Duke University" + } + ], + "dblp_key": "conf/popl/Clarke77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512953", + "title": "Code Generation for Machines with Multiregister Operations", + "abstract": "Previous work on optimal code generation has usually assumed that the underlying machine has identical registers and that all operands fit in a single register or memory location. This paper considers the more realistic problem of generating optimal code for expressions involving single and double length operands, using several models of register-pair machines permitting both single and double word instructions. With register-pair machines a new phenomenom arises that is not present in optimal code generation for single register machines: In an optimal evaluation of an expression it may be necessary to oscillate back and forth between evaluating subexpressions of the expression.A linear-time optimal code generation algorithm is derived for a register-pair machine in which all registers are interchangeable. The algorithm is based on showing that for this model there is an optimal evaluation sequence with limited oscillation between the sub-trees dominated by the children of a given node. For other machine models including the familiar even-odd register-pair machine, optimal evaluation sequences can always require unlimited oscillation.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512953", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alfred V.", + "last_name": "Aho", + "institution": "" + }, + { + "first_name": "S. C.", + "last_name": "Johnson", + "institution": "" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/AhoJU77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512972", + "title": "Threshold Evaluation and the Semantics of Call by Value, Assignment and Generic Procedures", + "abstract": "We use the concept of evaluation up to a given threshold of information to generalize the semantics of call by value and assignment to non-discrete domains, and to define a formal semantics for generic procedures. We then prove the correctness of McCarthy's transformation of iterative programs into recursive ones provided the same threshold is used for assignment and parameter passing.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512972", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bernard", + "last_name": "Lang", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Lang77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512973", + "title": "Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints", + "abstract": "A program denotes computations in some universe of objects. Abstract interpretation of programs consists in using that denotation to describe computations in another universe of abstract objects, so that the results of abstract execution give some information on the actual computations. An intuitive example (which we borrow from Sintzoff [72]) is the rule of signs. The text -1515 * 17 may be understood to denote computations on the abstract universe {(+), (-), (±)} where the semantics of arithmetic operators is defined by the rule of signs. The abstract execution -1515 * 17 → -(+) * (+) → (-) * (+) → (-), proves that -1515 * 17 is a negative number. Abstract interpretation is concerned by a particular underlying structure of the usual universe of computations (the sign, in our example). It gives a summary of some facets of the actual executions of a program. In general this summary is simple to obtain but inaccurate (e.g. -1515 + 17 → -(+) + (+) → (-) + (+) → (±)). Despite its fundamentally incomplete results abstract interpretation allows the programmer or the compiler to answer questions which do not need full knowledge of program executions or which tolerate an imprecise answer, (e.g. partial correctness proofs of programs ignoring the termination problems, type checking, program optimizations which are not carried in the absence of certainty about their feasibility, …).", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512973", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "" + } + ], + "dblp_key": "conf/popl/CousotC77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512965", + "title": "Parallel Program Correctness Through Refinement", + "abstract": "We develop a theory for the correctness of asynchronous parallel programs. A program is considered correct if its behavior is in some sense similar to that of an abstract version of the program. We discuss various criteria for this similarity. We then concentrate on one of them and develop a technique for showing that a parallel program is correct with respect to this criterion.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512965", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas W.", + "last_name": "Doeppner", + "institution": "Brown University" + } + ], + "dblp_key": "conf/popl/Doeppner77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512951", + "title": "A Complete and Consistent Hoare Semantics for a Simple Programming Language", + "abstract": "Article A complete and consistent hoare axiomatics for a simple programming language Share on Authors: J. Cherniavsky SUNY at Stony Brook, N.Y. SUNY at Stony Brook, N.Y.View Profile , S. Kamin SUNY at Stony Brook, N.Y. SUNY at Stony Brook, N.Y.View Profile Authors Info & Claims POPL '77: Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1977 Pages 1–9https://doi.org/10.1145/512950.512951Online:01 January 1977Publication History 3citation179DownloadsMetricsTotal Citations3Total Downloads179Last 12 Months21Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512951", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John C.", + "last_name": "Cherniavsky", + "institution": "Stony Brook School" + }, + { + "first_name": "Samuel", + "last_name": "Kamin", + "institution": "Stony Brook School" + } + ], + "dblp_key": "conf/popl/CherniavskyK77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512975", + "title": "Parallelism and Synchronization in Actor Systems", + "abstract": "This paper presents a mechanism for the arbitration of parallel requests to shared resources. This mechanism is the serialize, which may be described as a kind of protection mechanism, in that it prevents improper orders of access to a protected resource. The mechanism is a generalization and improvement of the monitor mechanism of Brinch-Hansen and Hoare.Serializers attempt to systematize and abstract desirable structural features of synchronization control structure into a coherent language construct. They represent an improvement in the modularity of synchronization over monitors in several respects. Monitors synchronize requests by providing a pair of operations for each request type [examples are STARTREAD/ENDREAD and STARTWRITE/ENDWRITE for the readers-writers problems]. Such a pair of operations must be used in a certain order for the synchronization to work properly, yet nothing in the monitors construct enforces this use. Serializers incorporate this structural aspect of synchronization in a unified mechanism to guarantee proper check-in and check-out. In scheduling access to a protected resource, it is often desired to wait in a queue for a certain condition before it continues execution. Monitors require that a process waiting in a queue will remain dormant forever, unless another process explicitly signals to the dormant process that it should continue. Serializers improve the modularity of synchronization by providing that the condition for resuming execution must be explicitly stated when a process enters a queue making it it unnecessary for processes to signal other processes. Each process determines for itself the conditions required for its further execution.The behavior of a serializer is defined using the actor message-passing model of computation. Different versions of the \"readers-writers\" problems are used to illustrate how the structure of a serializer corresponds in a natural way to the structure of the arbitration problem to be solved. The correspondence makes it easier to synthesize a scheduler from behavioral specifications and to verify that an implementation satisfies its specifications.No claim is made for the \"completeness\" of the serializer mechanism, beyond showing that semaphores can be implemented using serializers. Further, no \"complete\" solution is proposed to the \"no-starvation\" specification which requires that a resource reply to each request which it receives. Rather, it is shown for some simple examples that serializers represent a step toward better structuring of parallel access to shared resources, and that proofs that starvation is impossible for these examples are easier with serializers than with some of the currently existing mechanisms for controlling parallel access to resources.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512975", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Russell R.", + "last_name": "Atkinson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Carl", + "last_name": "Hewitt", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/HewittA77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512958", + "title": "Applications of Graph Grammar for Program Control Flow Analysis", + "abstract": "A standard approach to the analysis of program structure for the purpose of code optimization is to construct the \"control flow graph\" which models the possible execution paths through the program. Various graph algorithms can be applied to the control flow graph to produce data flow information, possible optimizations, etc. [A1,A2,AC,AU2,AU3,CS,HU1,HU2.HU3,Ke1,Ke2,Ke3,Ke4,Sc,U]. Studies of the form of typical control flow graphs indicate that such graphs tend to fall into a restricted subclass of general graphs. For example, empirical investigations have shown that the vast majority of program graphs have no multiple-entry loops [AC,HU2,HU3,Kn1].The recent work on \"structured programming\" has suggested that \"good\" programs fall into an even more restricted subclass. In fact, purists recommend that all programs be synthesized from three basic control structures: sequential statements, if-then-else statements, and single-entry single-exit loops [Di,Wi].Formal language theory [HoU] has given us a practical way to specify the set of strings which comprise a given language: via a grammar. It is then a natural idea to extend grammars from the strings to graphs in hopes of getting the same power of expression. Several researchers have used this approach [FKZ,J2,Ro].In this paper we study the applicability of a grammatical approach to describing the set of control flow graphs which arise from \"good\" programs in the sense proposed by many programming practitioners. The resulting flow graph language contains all those programs constructed according to the purists' rules and also admits programs with multiple-exit loops if such loops are constructed sensibly. The grammar we use is the \"semi-structured flow graph\" grammar GSSFG which was studied originally in [FKZ]. There are several appealing properties of this grammar; perhaps the most important, from the point-of-view of a compiler-writer, is the existence of a linear-time parsing algorithm which leads directly to a linear-time data flow analysis method [FKZ].In the present work we summarize the results from [FKZ] and address several new questions. First, how often do programs written by people with no knowledge of the SSFG rules fall into the language defined by GSSFG? In other words, is the language a natural one for programming? Second, once a program has been parsed according to GSSFG do benefits other than fast data flow analysis accrue?The paper is organized into three main sections. Section II introduces GSSFG and the parsing algorithm from [FKZ]. Section III is devoted to an empirical study conducted by the authors in an attempt to answer the question of naturalness, described above. Section IV discusses several applications of the graph parse in a \"graph attribute grammar\" framework. The summary at the end of the paper includes suggestions for further investigation.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512958", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + }, + { + "first_name": "Linda", + "last_name": "Zucconi", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/KennedyZ77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512961", + "title": "Symbolic Evaluation and the Global Value Graph", + "abstract": "This paper is concerned with difficult global flow problems which require the symbolic evaluation of programs. We use, as is common in global flow analysis, a model in which the expressions computed are specified, but the flow of control is indicated only by a directed graph whose nodes are blocks of assignment statements. We show that if such a program model is interpreted in the domain of integer arithmetic then many natural global flow problems are unsolvable. We then develop a direct (non-iterative) method for finding general symbolic values for program expressions. Our method gives results similar to an iterative method due to Kildall and a direct method due to Fong, Kam, and Ullman. By means of a structure called the global value graph which compactly represents both symbolic values and the flow of these values through the program, we are able to obtain results that are as strong as either of these algorithms at a lower time cost, while retaining applicability to all flow graphs.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512961", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John H.", + "last_name": "Reif", + "institution": "Harvard University Press" + }, + { + "first_name": "Harry R.", + "last_name": "Lewis", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/ReifL77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512968", + "title": "The Competence/Performance Dichotomy in Programming", + "abstract": "We consider the problem of automating some of the duties of programmers. We take as our point of departure the claim that data management has been automated to the point where the programmer concerned only about the correctness (as opposed to the efficiency) of his program need not involve himself in any aspect of the storage allocation problem. We focus on what we feel is a sensible next step, the problem of automating aspects of control. To accomplish this we propose a definition of control based on a fact/heuristic dichotomy, a variation of Chomsky's competence/performance dichotomy. The dichotomy formalizes an idea originating with McCarthy and developed by Green, Hewitt, McDermott, Sussman, Hayes, Kowalski and others. It allows one to operate arbitrarily on the control component of a program without affecting the program's correctness, which is entirely the responsibility of the fact component. The immediate objectives of our research are to learn how to program keeping fact and control separate, and to identify those aspects of control amenable to automation.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512968", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vaughan", + "last_name": "Pratt", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Pratt77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512963", + "title": "Implementation of an Array Bound Checker", + "abstract": "This paper describes a system which checks correctness of array accesses automatically without any inductive assertions or human interaction. For each array access in the program a condition that the subscript is greater than or equal to the lower bound and a condition that the subscript is smaller than or equal to the upper bound are checked and the results indicating within the bound, out of bound, or undetermined are produced. It can check ordinary programs at about fifty lines per ten seconds, and it shows linear time complexity behavior.It has been long discussed whether program verification will ever become practical. The main argument against program verification is that it is very hard for a programmer to write assertions about programs. Even if he can supply enough assertions, he must have some knowledge about logic in order to prove the lemmas (or verification conditions) obtained from the verifier.However, there are some assertions about programs which must always be true no matter what the programs do; and yet which cannot be checked for all cases. These assertions include: integer values do not overflow, array subscripts are within range, pointers do not fall off NIL, cells are not reclaimed if they are still pointed to, uninitialized variables are not used.Since these conditions cannot be completely checked, many compilers produce dynamic checking code so that if the condition fails, then the program terminates with proper diagnostics. These dynamic checking code sometimes take up much computation time. It is better to have some checking so that unexpected overwriting of data will not occur, but it is still very awkward that the computation stops because of error. Moreover, these errors can be traced back to some other errors in the program. If we can find out whether these conditions will be met or not before actually running the program, we can benefit both by being able to generate efficient code and by being able to produce more reliable programs by careful examination of errors in the programs. Similar techniques can be used to detect semantically equivalent subexpressions or redundant statements to do more elaborate code movement optimization.The system we have constructed runs fast enough to be used as a preprocessor of a compiler. The system first creates logical assertions immediately before array elements such that these assertions must be true whenever the control passes the assertion in order for the access to be valid. These assertions are proved using similar techniques as inductive assertion methods. If an array element lies inside a loop or after a loop a loop invariant is synthesized. A theorem prover was created which has the decision capabilities for a subset of arithmetic formulas. We can use this prover to prove some valid formulas, but we can also use it to generalize nonvalid formulas so that we can hypothesize more general loop invariants.Theoretical considerations on automatic synthesis of loop invariants have been taken into account and a complete formula for loop invariants was obtained. We reduced the problem of loop invariant synthesis to the computation of this formula. This new approach of the synthesis of loop invariant will probably give more firmer basis for the automatic generation of loop invariants in general purpose verifiers.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512963", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norihisa", + "last_name": "Suzuki", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kiyoshi", + "last_name": "Ishihata", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/SuzukiI77", + "venue": "popl", + "year": 1977 + }, + { + "paper_id": "10.1145/512950.512955", + "title": "Applications of High-Level Control Flow", + "abstract": "Control flow relations in a high level language program can be represented by a hierarchy of small graphs that combines nesting relations among statements in an ALGOL-like syntax with relevant perturbations caused by goto or leave statements. Applications of the new style of representation include denotational semantics, data flow analysis, source level compiler diagnostics, and program proving.", + "date": "1977-01-01", + "link": "https://doi.org/10.1145/512950.512955", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Barry K.", + "last_name": "Rosen", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Rosen77", + "venue": "popl", + "year": 1977 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1978.json b/data/pl_conferences/popl/1978.json new file mode 100644 index 0000000..53e345e --- /dev/null +++ b/data/pl_conferences/popl/1978.json @@ -0,0 +1,575 @@ +[ + { + "paper_id": "10.1145/512760.512779", + "title": "Almost Control-Free (Indeterministic) Parallel Computation on Permit Schemes", + "abstract": "The parallelity means \"simultaneous performance or execution\" and it may concern either computer units of different sorts (e.g. a memory and a processor), or computer units of the same sort (e.g. several processors).The computers Illiac 4 and Burroughs Scientific Processor (BSP) (announced recently) have several arithmetic processors. They are designed for large-scale computations with a special sort of numeric data structures, i.e. with large matrices (arrays). Their parallelity concerns naturally and essentially the definitions of matrix operations.According to [Br] the software techniques for exploiting the parallelism of the BSP consists of a \"vectorization\" of an usual serial program. There are 16 processors in the BSP which are heavily dependent each on the other, because at each instant by each of these processors just one and the same operation may be performed. Therefore a synchronization of all processors is assumed, which is the most important difference from the concept of parallel program scheme of [KM], which allows to speak about a sequence of particular steps, each of which is represented by execution of particular statements in parallel.In this paper a parallel computer with m ≥ 1 processors is assumed, which is also synchronized [Cu 1], but the processors are fully independent each on the other, i.e. on different processors different operations may be performed at each instant. Further, the parallelity concerns arbitrary simple data and arbitrary operations in all generality (and not only matrices). Thus the inherent parallelity of any serial program should be discovered and used for speeding up the duration of computation at most m times, while the memory space requirements remain unchanged.In [Cu 2] parallel flow diagrams were introduced and further the following \"parallelization \" (i.e. a \"computation\" of a parallel execution sequence of steps) of a serial program, was discussed in two parts: 1) newly permitted statements are determined by a permitter, and then 2) a subset of m (or less) statements is selected from the set of all permitted (and not yet selected) statements by a selector. The selected statements are executed in parallel on m processors, etc. until all permitted statements are selected (and executed), and the computation terminates. The permitter and the selector should replace the statement counter of serial programs or flow diagrams, by which is determined which statement should be executed as the next one. It is nuclear whether a suitable hardware technology can be designed to perform as a permitter and selector require.The linearity of programs is connected with serial computers (having just one processor, thus m = 1) essentially, and therefore in the following flow diagrams (or program schemes) will be used instead, because they allow a natural and transparent modification to permit diagrams and schemes, which represent a new sort of computing prescription (not necessarily deterministic algorithms) being a generalization of well-known binary trees, by which usual arithmetic expressions are represented.It is well known that there is no inherent reason for performing an operation from the numerator of a fraction sooner than an operation from the denominator. This arbitrariness of the order conceals an intrinsic parallelism of any expression which contains an n-ary operation with n ≥ 2 (which corresponds to the fact that the value of such operation does not depend on the order in which the values of its n arguments were achieved). This obvious fact is less clear when algorithms instead of operations are considered.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512779", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karel", + "last_name": "Čulík", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/Culik78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512778", + "title": "Verification and Design Aspects of "True" Concurrency", + "abstract": "Most abstract models of a set of parallel processes define a computation of the model to be a sequence. It is either a sequence of actions taken by the system [Lip] or a sequence of states of the system existing between actions [Kel, Lau, Ash]. Parallelsim is represented only by the fact that following a given action or state, the \"next\" action or state is not necessarily unique. That is, parallesim is represented by nondeterminism. A. W. Holt has called this representation approach \"serializable concurrency\" as opposed to \"true concurrency\" [Hol]. He, among others, has questioned the appropriateness of implying a total ordering between events that are only known to be partially ordered.In this paper, a definition of an algebraic model of a set of concurrently-executing sequential processes is presented. The \"computations\" of this model are directed acyclic graphs. The nodes of each computation graph represent computer operations and the edges represent the partial ordering of operations with respect to time.Examples demonstrate that these directed acyclic graphs aid in focusing a programmer/verifier's attention on the most important features of a computation. The model suggests the following verification paradigm: since systems often execute a certain sequence of actions to achieve a certain goal, verification procedures should identify these sequences, whether or not each is performed within a single process.A key notion in the abstract model is the treatment of synchronization mechanisms as full-fledged processes. A programming language syntax called \"path programs\" which is suggested by this notion is presented. Path programs are a generalization of the path expressions of Campbell and Habermann [CamHab]. The programming notation is based on the assumption that a processor can be dedicated to each shared data structure in the system. The duty of this processor is to control the synchronization of operations on the data structure.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512778", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Mizell", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/popl/Mizell78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512762", + "title": "The Smalltalk-76 Programming System", + "abstract": "This paper describes a programming system based on the metaphor of communicating objects. Experience with a running system shows that this model provides flexibility, modularity and compactness. A compiled representation for the language is presented, along with an interpreter suitable for microcoding. The object-oriented model provides naturally efficient addressing; a corresponding virtual memory is described which offers dense utilization of resident space.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512762", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel H. H.", + "last_name": "Ingalls", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/Ingalls78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512761", + "title": "Compilation and Delayed Evaluation in APL", + "abstract": "Most existing APL implementations are interpretive in nature, that is, each time an APL statement is encountered it is executed by a body of code that is perfectly general, i.e. capable of evaluating any APL expression, and is in no way tailored to the statement on hand. This costly generality is said to be justified because APL variables are typeless and thus can vary arbitrarily in type, shape, and size during the execution of a program. What this argument overlooks is that the operational semantics of an APL statement are not modified by the varying storage requirements of its variables.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512761", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leo J.", + "last_name": "Guibas", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Douglas K.", + "last_name": "Wyatt", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/GuibasW78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512772", + "title": "Automating Proofs of the Absence of Common Runtime Errors", + "abstract": "The Runcheck Verifier is a working system for proving the absence of common runtime errors. The language accepted is Pascal without variant records, side effects in functions, shared variable parameters to procedures, or functional arguments. The errors checked are: 1) accessing a variable that has not been assigned a value, 2) array subscripting out of range, 3) subrange type error, 4) dereferencing a NIL pointer, 5) arithmetic overflow, and 6) division by zero.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512772", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steven M.", + "last_name": "German", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/German78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512773", + "title": "A Metalanguage for Interactive Proof in LCF", + "abstract": "Article Free Access Share on A Metalanguage for interactive proof in LCF Authors: M. Gordon University of Edinburgh University of EdinburghView Profile , R. Milner University of Edinburgh University of EdinburghView Profile , L. Morris Syracuse University Syracuse UniversityView Profile , M. Newey Australian National University Australian National UniversityView Profile , C. Wadsworth University of Edinburgh University of EdinburghView Profile Authors Info & Claims POPL '78: Proceedings of the 5th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1978Pages 119–130https://doi.org/10.1145/512760.512773Published:01 January 1978Publication History 55citation684DownloadsMetricsTotal Citations55Total Downloads684Last 12 Months96Last 6 weeks5 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512773", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mike", + "last_name": "Gordon", + "institution": "University of Edinburgh" + }, + { + "first_name": "R.", + "last_name": "Milner", + "institution": "University of Edinburgh" + }, + { + "first_name": "L.", + "last_name": "Morris", + "institution": "Syracuse University" + }, + { + "first_name": "M.", + "last_name": "Newey", + "institution": "Australian National University" + }, + { + "first_name": "Christopher P.", + "last_name": "Wadsworth", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/GordonMMNW78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512768", + "title": "A General Scheme for the Automatic Inference of Variable Types", + "abstract": "We present the best known algorithm for the determination of run-time types in a programming language requiring no type declarations. We demonstrate that it is superior to other published algorithms and that it is the best possible algorithm from among all those that use the same set of primitive operators.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512768", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marc", + "last_name": "Kaplan", + "institution": "Princeton University" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/KaplanU78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512782", + "title": "Nondeterminism in Logics of Programs", + "abstract": "We investigate the principles underlying reasoning about nondeterministic programs, and present a logic to support this kind of reasoning. Our logic, an extension of dynamic logic ([22] and [12]), subsumes most existing first-order logics of nondeterministic programs, including that developed by Dijkstra based on the concept of weakest precondition. A significant feature is the strict separation between the two kinds of nonterminating computations: infinite computations and failures. The logic has a Tarskian truth-value semanics, an essential prerequisite to establishing completeness of axiomatizations of the logic. We give an axiomatization for flowchart (regular) programs that is complete relative to arithmetic in the sense of Cook. Having a satisfactory tool at hand, we turn to the clarification of the concept of the total correctness of nondeterministic programs, providing in passing, a critical evaluation of the widely used \"predicate transformer\" approach to the definition of programming constructs, initiated by Dijkstra [5]. Our axiom system supplies a complete axiomatization of wp.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512782", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Harel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vaughan", + "last_name": "Pratt", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/HarelP78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512781", + "title": "A Partial Evaluator, Its Use for Compiling Iterative Statements in Lisp", + "abstract": "A partial evaluation program for LISP is described, and an application where it has been used. The partial evaluator performs a number of other, related operations such as opening of functions and certain optimizations on programs. The application is based on the fact that we can generate from an interpreter and a partial evaluator the same object code as a corresponding compiler should do. The paper will first formally describe the relationship between an interpreter and a compiler through partial evaluation. The partial evaluator system is then briefly described and finally an experiment is shown where an interpreter for the iterative statement in INTERLISP is partially evaluated.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512781", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anders", + "last_name": "Haraldsson", + "institution": "Linköping University" + } + ], + "dblp_key": "conf/popl/Haraldsson78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512764", + "title": "Data Types as Values: Polymorphism, Type-Checking, Encapsulation", + "abstract": "This paper describes a novel approach to the treatment of data types in programming languages, which allows a simple interpretation of \"polymorphic\" or \"generic\" procedures, makes a simple set of type-checking rules semantically justifiable and provides a straightforward treatment of encapsulation.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512764", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Cornell University" + }, + { + "first_name": "James", + "last_name": "Donahue", + "institution": "Cornell University" + }, + { + "first_name": "Glenn S.", + "last_name": "Skinner", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/DemersDS78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512785", + "title": "A New Method for Compiler Code Generation", + "abstract": "An algorithm is given to translate a relatively low-level intermediate representation of a program into assembly code or machine code for a target computer. The algorithm is table driven. A construction algorithm is used to produce the table from a functional description of the target machine. The method produces high quality code for many commercially available computers. By replacing the table, it is possible to retarget a compiler for another kind of computer. In addition techniques are given to prove the correctness of the translator.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512785", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R. Steven", + "last_name": "Glanville", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/GlanvilleG78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512763", + "title": "Clauses: Scope Structures and Defined Functions in Lucid", + "abstract": "In this paper we describe how Lucid can be extended to allow user-defined functions and scope conventions, i.e. conventions for limiting the range or scope of the validity of definitions. This is done using new constructs called clauses which are similar in form to the blocks and procedure declarations of Algol-like languages, but are nevertheless strictly non-imperative, because a clause is actually a compound assertion, i.e. an assertion formed, as a program is, by combining a collection of assertions.Each type of clause (there are four) has a straightforward mathematical semantics together with its own characteristic \"manipulation rules\" for general program massage. In addition, the informal operational view of (some) Lucid programs (described in a previous paper) can be extended to give an (incomplete) operational understanding of the effect of the clauses. In this framework a \"compute\" clause defines a block; a \"mapping\" clause defines a conventional (pointwise) function; a \"produce\" clause defines a block with persistent memory (or an anonymous 'process' or 'actor'); and a \"function\" clause defines a sort of procedure with own variables (or a general kind of coroutine).", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512763", + "conference_name": "POPL", + "authors": [ + { + "first_name": "E. A.", + "last_name": "Ashcroft", + "institution": "University of Waterloo" + }, + { + "first_name": "William W.", + "last_name": "Wadge", + "institution": "University of Warwick" + } + ], + "dblp_key": "conf/popl/AshcroftW78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512774", + "title": "Unrestricted Procedure Calls in Hoare's Logic", + "abstract": "This paper presents a new version of Hoare's logic including generalized procedure call and assignment rules which correctly handle aliased variables. Formal justifications are given for the new rules.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512774", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Cornell University" + }, + { + "first_name": "Derek C.", + "last_name": "Oppen", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/CartwrightO78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512770", + "title": "Automatic Discovery of Linear Restraints Among Variables of a Program", + "abstract": "The model of abstract interpretation of programs developed by Cousot and Cousot [2nd ISOP, 1976], Cousot and Cousot [POPL 1977] and Cousot [PhD thesis 1978] is applied to the static determination of linear equality or inequality invariant relations among numerical variables of programs.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512770", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "" + }, + { + "first_name": "Nicolas", + "last_name": "Halbwachs", + "institution": "Laboratoire d'Informatique de Grenoble" + } + ], + "dblp_key": "conf/popl/CousotH78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512776", + "title": "Reasoning about Recursively Defined Data Structures", + "abstract": "A decision algorithm is given for the quantifier-free theory of recursively defined data structures which, for a conjunction of length n, decides its satisfiability in time linear in n. The first-order theory of recursively defined data structures, in particular the first-order theory of LISP list structure (the theory of CONS, CAR, CDR), is shown to be decidable but not elementary recursive.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512776", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Derek C.", + "last_name": "Oppen", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Oppen78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512787", + "title": "Local Constraints in the Syntax and Semantics of Programming Languages", + "abstract": "The method of local constraints attempts to describe context-free languages in an apparently context-sensitive form which helps to retain the intuitive insights about the grammatical structure. This form of description, while apparently context-sensitive is, in fact, context-free and allows a program derivation structure to be represented as a tree with additional constraints, thus allowing for the possibility of a correctness proof in the form of Knuthian semantics. A part of ALGOL 60 syntax has been restated as a grammar with local constraints. It is also shown that parsing of grammars with local constraints can be carried out by a suitable extension of Early's algorithm. Finally, the relationship of local constraints to the semantics of programs is discussed in Section 4 by considering some program transformations.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512787", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aravind K.", + "last_name": "Joshi", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Leon S.", + "last_name": "Levy", + "institution": "University of Delaware" + }, + { + "first_name": "Kang", + "last_name": "Yueh", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/JoshiLY78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512777", + "title": "Off-Line and On-Line Algorithms for Deducing Equalities", + "abstract": "The classical common subexpression problem in program optimization is the detection of identical subexpressions. Suppose we have some extra information and are given pairs of expressions ei1=ei2 which must have the same value, and expressions fj1≠fj2 which must have different values. We ask if as a result, h1=h2, or h1≠h2. This has been called the uniform word problem for finitely presented algebras, and has application in theorem-proving and code optimization. We show that such questions can be answered in O(nlogn) time, where n is the number of nodes in a graph representation of all relevant expressions. A linear time algorithm for detecting common subexpressions is derived. Algorithms which process equalities, inequalities and deductions on-line are discussed.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512777", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter J.", + "last_name": "Downey", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Hanan", + "last_name": "Samet", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Ravi", + "last_name": "Sethi", + "institution": "" + } + ], + "dblp_key": "conf/popl/DowneySS78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512769", + "title": "Symbolic Programming Analysis in Almost Linear Time", + "abstract": "A global flow model is assumed; as usual, the flow of control is represented by a digraph called the control flow graph. The objective of our program analysis is the construction of a mapping (a cover) from program text expressions to symbolic expressions for their value holding over all executions of the program. The particular cover constructed by our methods is in general weaker than the covers obtainable by the methods of [Ki, FKU, R1], but our method has the advantage of being very efficient; requiring O(ℓ + aα(a)) extended bit vector operations (a logical operation or a shift to the first nonzero bit) on all control flow graphs (whether reducible or not), where a is the number of edges of the control flow graph, ℓ is the length of the text of the program, and α is Tarjan's function (an extremely slowly growing function).", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512769", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John H.", + "last_name": "Reif", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/popl/Reif78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512783", + "title": "A Straightforward Denotational Semantics for Non-Determinant Data Flow Programs", + "abstract": "Data flow programming languages are especially amenable to mathematization of their semantics in the denotational style of Scott and Strachey. However, many real world programming problems, such as operating systems and data base inquiry systems, require a programming language capable of non-determinacy because of the non-determinate behavior of their physical environment. To date, there has been no satisfactory denotational semantics of programming languages with non-determinacy. This paper presents a straightforward denotational treatment of non-determinate data flow programs as functions from sets of tagged sequences to sets of tagged sequences. A simple complete partial order on such sets exists, in which the data flow primitives are continuous functions, so that any data flow program computes a well defined function.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512783", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul R.", + "last_name": "Kosinski", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Kosinki78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512771", + "title": "A Portable Compiler: Theory and Practice", + "abstract": "A compiler for the C language has recently been constructed which is now compiling C for about half a dozen machines. The compiler was influenced in various ways by recent theoretical developments. This paper gives an overview of the compiler structure and algorithms, emphasizing those areas where theory was helpful, and discussing the approaches taken where theory was lacking.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512771", + "conference_name": "POPL", + "authors": [ + { + "first_name": "S. C.", + "last_name": "Johnson", + "institution": "" + } + ], + "dblp_key": "conf/popl/Johnson78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512775", + "title": "A Simplifier Based on Efficient Decision Algorithms", + "abstract": "We describe a simplifier for use in program manipulation and verification. The simplifier finds a normal form for any expression over the language consisting of individual variables, the usual boolean connectives, the conditional function cond (denoting if-then-else), the integers (numerals), the arithmetic functions and predicates +, - and ≤, the LISP constants, functions and predicates nil, car, cdr, cons and atom, the functions store and select for storing into and selecting from arrays, and uninterpreted function symbols. Individual variables range over the union of the rationals, the set of arrays, the LISP s-expressions and the booleans true and false. The constant, function and predicate symbols take their natural interpretations.The simplifier is complete; that is, it simplifies every valid formula to true. Thus it is also a decision procedure for the quantifier-free theory of rationals, arrays and s-expressions under the above functions and predicates.The organization of the simplifier is based on a method for combining decision algorithms for several theories into a single decision algorithm for a larger theory containing the original theories. More precisely, given a set S of functions and predicates over a fixed domain, a satisfiability program for S is a program which determines the satisfiability of conjunctions of literals (signed atomic formulas) whose predicates and function signs are in S. We give a general procedure for combining satisfiability programs for sets S and T into a single satisfiability program for S ∪ T, given certain conditions on S and T. We show how a satisfiability program for a set S can be used to write a complete simplifier for expressions containing functions and predicates of S as well as uninterpreted function symbols.The simplifier described in this paper is currently used in the Stanford Pascal Verifier.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512775", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Greg", + "last_name": "Nelson", + "institution": "Stanford University" + }, + { + "first_name": "Derek C.", + "last_name": "Oppen", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/NelsonO78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512780", + "title": "Complexity of Expressions Allowing Concurrency", + "abstract": "We study some consequences of the formal language approach to modelling software system behavior for the case of asynchronous, concurrent subsystems. We use the formal language shuffle operation to give an \"algebraic\" definition of semantics for a simple (structured) concurrent programming language and prove that the use of this operation is necessary. Having established this necessity, we investigate other types of behavioral expressions which use the operation and show that the analysis problem for these expressions is either undecidable or intractable. The results provide some limitations, for example, on the path expression method of system behavior analysis. Our lower bound proofs involve the use of synchronization symbols, which seem to be a formal language analogue of semaphores.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512780", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William F.", + "last_name": "Ogden", + "institution": "Case Western Reserve University" + }, + { + "first_name": "William E.", + "last_name": "Riddle", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "W. C.", + "last_name": "Round", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/popl/OgdenRR78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512786", + "title": "A Forward Move Algorithm for LR Error Recovery", + "abstract": "A move algorithm, and some of its formal properties, is presented for use in a practical syntactic error scheme for LR parsers. The algorithm finds fragment (comparable to a valid prefix) just to the right of a point of error detection. For expositional purposes the algorithm is presented as parsing arbitrarily far beyond the point of error detection in a parallel mode, as long as all parses agree on the read or reduce action to be taken at each parse step. In practice the forward move is achieved serially by adding recovery states to the LR machine. Based on the formal properties of the forward move we propose an error algorithm that uses the accumulated right context. The performance of the algorithm is illustrated in a specific case and discussed in general.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512786", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas J.", + "last_name": "Pennello", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Frank", + "last_name": "DeRemer", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/popl/PennelloD78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512767", + "title": "Monoids for Rapid Data Flow Analysis", + "abstract": "The earliest data flow analysis research dealt with concrete problems (such as detection of available expressions) and with low level representations of control flow (with one large graph, each of whose nodes represents a basic block). Several recent papers have introduced an abstract approach, dealing with any problem expressible in terms of a semilattice L and a monoid M of isotone maps from L to L, under various algebraic constraints. Examples include [CC77; GW76; KU76; Ki73; Ta75; Ta76; We75]. Several other recent papers have introduced a high level representation with many small graphs, each of which represents a small portion of the control flow information in a program. The hierarchy of small graphs is explicit in [Ro77a; Ro77b] and implicit in papers that deal with syntax directed analysis of programs written within the confines of classical structured programming [DDH72, Sec. 1.7]. Examples include [TK76; ZB74]. The abstract papers have retained the low level representations while the high level papers have retained the concrete problems of the earliest work. This paper studies abstract conditions on L and M that lead to rapid data flow analysis, with emphasis on high level representations. Unlike some analysis methods oriented toward structured programming [TK76; Wu75; ZB74], our method retains the ability to cope with arbitrary escape and jump statements while it exploits the control flow information implicit in the parse tree.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512767", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Barry K.", + "last_name": "Rosen", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Rosen78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512766", + "title": "Syntactic Control of Interference", + "abstract": "In programming languages which permit both assignment and procedures, distinct identifiers can represent data structures which share storage or procedures with interfering side effects. In addition to being a direct source of programming errors, this phenomenon, which we call interference can impact type structure and parallelism. We show how to eliminate these difficulties by imposing syntactic restrictions, without prohibiting the kind of constructive interference which occurs with higher-order procedures or SIMULA classes. The basic idea is to prohibit interference between identifiers, but to permit interference among components of collections named by single identifiers.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512766", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Reynolds", + "institution": "Syracuse University" + } + ], + "dblp_key": "conf/popl/Reynolds78", + "venue": "popl", + "year": 1978 + }, + { + "paper_id": "10.1145/512760.512765", + "title": "Type Definitions with Parameters", + "abstract": "It has long been known that recursively defined types in a highly typed language such as Algol 68 or Pascal may be tested for structural equivalence by the same algorithm that compares finite automata [5,11]. Several authors (for example, [3,8,9,16]) have proposed that classes of types be simultaneously defined by the use of parameterized type definitions, such asType list(x) = record val:x; next:↑list(x) end .This paper shows that unless the use of such parameterized definitions is restricted, new (unparameterized) types may be defined which more closely resemble deterministic context-free languages. In fact, the equivalence problem for such types becomes as hard as the (currently unsolved) deterministic pushdown automaton equivalence problem. Several restrictions on type definitions are considered which allow known equivalence algorithms to be applied.", + "date": "1978-01-01", + "link": "https://doi.org/10.1145/512760.512765", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marvin", + "last_name": "Solomon", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/Solomon78", + "venue": "popl", + "year": 1978 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1979.json b/data/pl_conferences/popl/1979.json new file mode 100644 index 0000000..b6ad12f --- /dev/null +++ b/data/pl_conferences/popl/1979.json @@ -0,0 +1,583 @@ +[ + { + "paper_id": "10.1145/567752.567777", + "title": "Data Flow Analysis of Communicating Processes", + "abstract": "Data flow analysis is a technique essential to the compile-time optimization of computer programs, wherein facts relevant to program optimizations are discovered by the global propagation of facts obvious locally.This paper extends flow analysis techniques developed for sequential programs to the analysis of communicating, concurrent processes.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567777", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John H.", + "last_name": "Reif", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/popl/Reif79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567760", + "title": "Recursion in Logics of Programs", + "abstract": "The problem of reasoning about recursive programs is considered. Utilizing a simple analogy between iterative and recursive programs viewed as unfinite unions of finite terms, we carry out an investigation analogous to that carried out recently for iterative programs. The main results are the arithmetical completeness of axiom systems for (1) context-free dynamic logic and (2) its extension for dealing with infinite computations. Having the power of expression of these logics in mind, these results can be seen to supply (as corollaries) complete proof methods for the various kinds of correctness of recursive programs.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567760", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Harel", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Harel79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567766", + "title": "Characterization and Elimination of Redundancy in Recursive Programs", + "abstract": "Many well-known functions are computed by interpretations of the recursion schemaprocedure f(x) ;if p(x)then return a(x)else return b(x,f(c1(x)),…,f(cn(x)))Some of these interpretations define redundant computations because they lead to multiple calls on f with identical argument values. The existence and nature of the redundancy depend on properties of the functions ci. We explore four sets of assumptions about these functions. We analyze directed acyclic graphs formed by merging the nodes of the computation tree for f(x) which are known to be equal for each set of assumptions. In each case there is a transformed program which computes f(x) without redundancy, provided that certain additional assumptions about p, a, and the ci are satisfied. The transformed programs avoid redundancy by saving exactly those intermediate results which will be needed again later in the computation. These programs are all valueless recursive procedures which leave intermediate and final results in specified global locations; in each case recursion can be eliminated without use of a stack. We compare the storage requirements of the transformed programs, discuss the applicability of these transformations to an automatic program improvement system, and present a general criterion for establishing the existence of redundancy.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567766", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norman", + "last_name": "Cohen", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/Cohen79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567757", + "title": "Principles of Proving Programs Correct in Gypsy", + "abstract": "Concurrency in Gypsy is based on a unique, formal approach to specifying and proving systems of concurrent processes. The specification and proof methods are designed so that proofs of individual processes are totally independent, even when operating concurrently. These methods can be applied both to terminating and non-terminating processes, and the proof methods are well suited to automated verification aids. The basic principles of these methods and their interaction with the design of Gypsy are described.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567757", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Donald I.", + "last_name": "Good", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "R. M.", + "last_name": "Cohen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "James", + "last_name": "Keeton-Williams", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/GoodC79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567753", + "title": "A Compact, Machine-Independent Peephole Optimizer", + "abstract": "Object code optimizers pay dividends but are usually ad hoc and machine-dependent. They would be easier to understand if, instead of performing many ad hoc optimizations, they performed a few general optimizations that give the same effect. They would be easier to implement if they were machine-independent and parametrized by symbolic machine descriptions. This paper describes such a compact, machine-independent peephole optimizer.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567753", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/Fraser79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567758", + "title": "The Evolution of List-Copying Algorithms", + "abstract": "How can one organize the understanding of complex algorithms? People have been thinking about this issue at least since Euclid first tried to explain his innovative greatest common divisor algorithm to his colleagues, but for current research into verifying state-of-the-art programs, some precise answers to the question are needed. Over the past decade the various verification methods which have been introduced (inductive assertions, structural induction, least-fixedpoint semantics, etc.) have established many basic principles of program verification (which we define as: establishing that a program text satisfies a given pair of input-output specifications). However, it is no coincidence that most published examples of the application of these methods have dealt with \"toy programs\" of carefully considered simplicity.Experience indicates that these \"first generation\" principles, with which one can easily verify a three-line greatest common divisor algorithm, do not directly enable one to verify a 10,000 line operating system (or even a 50 line list-processing algorithm) in complete detail. To verify complex programs, additional techniques of organization, analysis and manipulation are required. (That a similar situation exists in the writing of large, correct programs has long been recognized -- structured programming being one solution.)This paper examines the usefulness of correctness-preserving program transformations (see [6]) in structuring fairly complex correctness proofs. Using our approach one starts with a simple, high-level (or \"abstract\") algorithm which can be easily verified, then successively refines it by implementing the abstractions of the initial algorithm to obtain various final, detailed algorithms. In Section 2 we introduce the technique by deriving the Deutsch-Schorr-Waite list-marking algorithm [14]. Our main example is the more complex problem of verifying bounded-workspace list-copying algorithms: Section 3 defines the issues, Section 4 presents the key intermediate algorithm in detail and Section 5 considers three of the most complex (published) implementations of list-copying, one of which is discussed in detail. In Section 6 we make some general remarks on program verification and the relevance of our results to the (larger) field of program correctness; Section 7 mentions some related work.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567758", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stanley Chun-Wei", + "last_name": "Lee", + "institution": "University of California, Berkeley" + }, + { + "first_name": "W.P.", + "last_name": "deRoever", + "institution": "Utrecht University" + }, + { + "first_name": "Susan L.", + "last_name": "Gerhart", + "institution": "Marina Del Rey Hospital" + } + ], + "dblp_key": "conf/popl/LeeGR79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567772", + "title": "Synthesis of Resource Invariants for Concurrent Programs", + "abstract": "Owicki and Gries have developed a proof system for conditional critical regions. In their system logically related variables accessed by more than one process are grouped together as resources, and processes are allowed access to a resource only in a critical region for that resource. Proofs of synchronization properties are constructed by devising predicates called resource invariants which describe relationships among the variables of a resource when no process is in a critical region for the resource. In constructing proofs using the system of Owicki and Gries, the programmer is required to supply the resource invariants.We show that convexity plays a key role in the derivation of strong resource invariants. We also develop methods for automatically synthesizing resource invariants. Specifically, we characterize the resource invariants of a concurrent program as least fixpoints of a functional which can be obtained from the text of the program. By using this fixpoint characterization and a widening operator which exploits our observation on the importance of convexity, good approximations may be obtained for the resource invariants of many concurrent programs.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567772", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Edmund M.", + "last_name": "Clarke", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/Clarke79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567764", + "title": "Automatic Generation of Near-Optimal Translators for Noncircular Attribute Grammars", + "abstract": "Attribute grammars are an extension of context-free grammars devised by Knuth as a formalism for specifying the semantics of a context-free language along with the syntax of the language. The syntactic phase of the translation process has been extensively studied and many techniques are available for automatically generating efficient parsers for context-free grammars. Attribute grammars offer the prospect of similarly automating the implementation of the semantic phase. In this paper we present a general method of constructing, for any non-circular attribute grammar, a deterministic translator which will perform the semantic evaluation of each syntax tree of the grammar in time linear with the size of the tree. Each tree is traversed in a manner particularly suited to the shape of the tree, yielding a near optimal evaluation order for that tree. Basically, the translator consists of a finite set of \"Local Control Automata\", one for each production; these are ordinary finite-state acyclic automata augmented with some special features, which are used to regulate the evaluation process of each syntax tree. With each node in the tree there will be associated the Local Control Automaton of the production applying at the node. At any given time during the translation process all Local Control Automata are inactive, except for the one associated with the currently processed node, which is responsible for directing the next steps taken by the translator until control is finally passed to a neighbour node, reactivating its Local Control Automaton. The Local Control Automata of neighbour nodes communicate with each other.The construction of the translator is custom tailored to each individual attribute grammar. The dependencies among the attributes occurring in the semantic rules are analysed to produce a near-optimal evaluation strategy for that grammar. This strategy ensures that during the evaluation process, each time the translator enters some subtree of the syntax tree, at least one new attribute evaluation will occur at each node visited. It is this property which distinguishes the method presented here from previously known methods of generating translators for unrestricted attribute grammars, and which causes the translators to be near-optimal.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567764", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rina", + "last_name": "Cohen", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eli", + "last_name": "Harry", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/CohenH79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567759", + "title": "First Order Programming Logic", + "abstract": "First Order Programming Logic is a simple, yet powerful formal system for reasoning about recursive programs. In its simplest form, it has one major limitation: it cannot establish any property of the least fixed point of a recursive program which is false for some other fixed point. To rectify this weakness, we present two intuitively distinct approaches to strengthening First Order Programming Logic and prove that either extension makes the logic relatively complete. In the process, we prove that the two approaches are formally equivalent. The relative completeness of the extended logic is significant because it suggests it can establish all \"ordinary\" properties (obviously we cannot escape the Godelian incompleteness inherent in any programming logic) of recursive programs including those which compute partial functions.The second contribution of this paper is to establish that First Order Programming Logic is applicable to iterative programs as well. In particular, we show that the intermittent assertions method--an informal proof method for iterative programs which has not been formalized--is conveniently formalized simply as sugared First Order Programming Logic applied to the recursive translations of iterative programs.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567759", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Cornell University" + }, + { + "first_name": "John", + "last_name": "McCarthy", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/CartwrightM79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567754", + "title": "A PL/CV Precis", + "abstract": "PL/CV is a new formal system which mixes commands and assertions. It includes axioms and rules for a theory of programming over integers and characters. Since arguments in the theory can be checked by the PL/CV Proof Checker, the system offers an approach to mechanical program verification. The Proof Checker is efficient enough for classroom use. Early experience with PL/CV indicates that it nicely supports formal verification of elementary arguments. Continued work should enable the formalization of non-elementary reasoning as well.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567754", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert L.", + "last_name": "Constable", + "institution": "Cornell University" + }, + { + "first_name": "Scott D.", + "last_name": "Johnson", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/ConstableJ79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567763", + "title": "The Universality of Data Retrieval Languages", + "abstract": "We consider the question of how powerful a relational query language should be and state two principles that we feel any query language should satisfy. We show that although relational algebra and relational calculus satisfy these principles, there are certain queries involving least fixed points that cannot be expressed by these languages, yet that also satisfy the principles. We then consider various extensions of relational algebra to enable it to answer such queries. Finally, we discuss our extensions to relational algebra in terms of a new programming language oriented model for queries.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567763", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alfred V.", + "last_name": "Aho", + "institution": "" + }, + { + "first_name": "Jeffrey D.", + "last_name": "Ullman", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/AhoU79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567767", + "title": "The Functional Power of Parameter Passage Mechanisms", + "abstract": "Article Free Access Share on The functional power of parameter passage mechanism Author: Adrienne Critcher Baylor University, Waco, Texas Baylor University, Waco, TexasView Profile Authors Info & Claims POPL '79: Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1979 Pages 158–168https://doi.org/10.1145/567752.567767Online:01 January 1979Publication History 2citation201DownloadsMetricsTotal Citations2Total Downloads201Last 12 Months5Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567767", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Adrienne", + "last_name": "Critcher", + "institution": "Baylor University" + } + ], + "dblp_key": "conf/popl/Critcher79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567776", + "title": "Flow Analysis and Optimization of Lisp-Like Structures", + "abstract": "In [12] the authors introduced the concept of binding time optimization and presented a series of data flow analytic methods for determining some of the binding time characteristics of programs. In this paper we extend that work by providing methods for determining the class of shapes which an unbounded data object may assume during execution of a LISP-like program, and describe a number of uses to which that information may be put to improve storage allocation in compilers and interpreters for advanced programming languages.We are concerned chiefly with finding, for each program point and variable a finite description of a set of graphs which includes all the shapes of values the variable could assume at that point during the execution of a program. If this set is small or regular in structure, this information can be used to optimize the program's execution, mainly by use of more efficient storage allocation schemes.In the first part we show how to construct from a program without selective updating a tree grammar whose nonterminals generate the desired sets of graphs; in this case they will all be trees. The tree grammars are of a more general form than is usually studied [8, 19], so we show that they may be converted to the usual form. The resulting tree grammar could naturally be viewed as a recursive type definition [11] of the values the variables may assume. Further, standard algorithms may be employed to test for infiniteness, emptiness or linearity of the tree structure.In the second part selective updating is allowed, so an alternate semantics is introduced which more closely resembles traditional LISP implementations, and which is equivalent to the tree model for programs without selective updating. In this model data objects are directed graphs. We devise a finite approximation method which provides enough information to detect cell sharing and cyclic structures whenever they can possibly occur. This information can be used to recognize when the use of garbage collection or of reference counts may be avoided.The work reported in the second part of this paper extends that of Schwartz [17] and Cousot and Cousot [7]. They have developed methods for determining whether the values of two or more variables share cells, while we provide information on the detailed structure of what is shared. The ability to detect cycles is also new. It also extends the work of Kaplan [13], who distinguishes only binary relations among the variables of a program, does not handle cycles, and does not distinguish selectors (so that his analysis applies to nodes representing sets rather than ordered tuples).", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567776", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neil D.", + "last_name": "Jones", + "institution": "University of Kansas" + }, + { + "first_name": "Steven S.", + "last_name": "Muchnick", + "institution": "University of Kansas" + } + ], + "dblp_key": "conf/popl/JonesM79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567778", + "title": "Systematic Design of Program Analysis Frameworks", + "abstract": "Semantic analysis of programs is essential in optimizing compilers and program verification systems. It encompasses data flow analysis, data type determination, generation of approximate invariant assertions, etc.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567778", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "Laboratoire d'Informatique de Grenoble" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "Laboratoire d'Informatique de Grenoble" + } + ], + "dblp_key": "conf/popl/CousotC79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567769", + "title": "Specifying Programming Language Semantics", + "abstract": "Hoare and Lauer [1974] have advocated using a variety of styles of programming language definitions to fit the variety of users from implementers to program verifiers. They consider the question of whether different definitions and specifications determine the same language by showing that the definitions are what they call \"consistent\". However, their treatment skirts the question of whether their definitions can each be taken to specify the language adequately. Although, as we will show, any one of the kinds of semantics they discuss -- operational, relational, deductive -- can be used to specify meaning uniquely, Hoare and Lauer do not make the case in their paper. In fact, both their relational and deductive definitions are satisfied by several different semantics, only one of which is desired.Thus, the main point of this paper is to clarify the characteristics of a proper specification of language semantics and to formulate alternative specifications each of which is equally good as the language definition. We basically agree with Hoare and Lauer that several specifications can and should be given, but are disturbed by confusions about such specifications, some of which are illustrated in their paper. In particular we refer to confusions between the mathematical object which is designated to be the meaning of a program and methods for specifying that object; the similar confusion between predicate and expression; between consistency and equivalence of two definitions; between completeness of a theory and its having a unique model. While these issues are familiar in mathematical logic, we take this opportunity to survey them in the context of programming language semantics.This paper can be read without prior familiarity with Hoare and Lauer's paper. The authors plan another paper extending this work which will include a more comprehensive bibliography.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567769", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Irene", + "last_name": "Greif", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/GreifM79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567762", + "title": "The Logic of a Relational Data Manipulation Language", + "abstract": "A logic for a relational data manipulation language is defined by augmenting a known logic of programs with rules for two new statements: the relational assignment, which assign a relational expression to a relation, and the random tuple selection, which extracts an arbitrary tuple from a relation. The usual operations on relations-retrieve, insert, delete, update-are then defined as special cases of the relational assignment, and the for-each construct scanning a relation tuple by tuple is introduced with the help of the random tuple selection.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567762", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco A.", + "last_name": "Casanova", + "institution": "Harvard University" + }, + { + "first_name": "Philip A.", + "last_name": "Bernstein", + "institution": "Harvard University" + } + ], + "dblp_key": "conf/popl/CasanovaB79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567774", + "title": "Predicate Path Expressions", + "abstract": "Path expressions are a tool for synchronization of concurrent processes. They are an integral part of the data abstraction mechanism in a programming language, and specify synchronization entirely in terms of the allowable sequences of operations on an object of the abstract data type. This paper describes an attempt to push the path expression synchronization construct along three dimensions - specification, verification, and implementation - into a useful theoretical and practical tool. We define Predicate Path Expressions (PPEs), which allow for a more convenient specification of many synchronization problems. The predicate is a powerful extension to path expressions that increases their expressiveness. We formally define the semantics of PPEs by a transformation to a corresponding nondeterministic program, thus allowing the use of known verification techniques for nondeterministic programs to be used for proving properties of the PPE and the data abstraction of which it is a part. We also describe our existing implementation, in Algol 68, of a data abstraction mechanism that incorporates PPEs.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567774", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sten F.", + "last_name": "Andler", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Andler79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567755", + "title": "Automatic Improvement of Programs in Very High Level Languages", + "abstract": "In this paper we study the profitability of applying the \"reduction in strength\" technique to programs in set-theoretic languages, focusing on the high level constructs involving set-formers. We define recursively two classes of expressions we shall call inductively computable set-formers and inductively computable predicates which can be evaluated with an order of magnitude improvement of the asymptotic running time as compared to the straightforward evaluation. The quantity developed for this comparison can be used to derive further results when additional information is known. For programs written in very high level languages, which often consist mostly of \"nested\" iterative constructs, this technique amounts to altering the \"algorithm\" used to compute the program by replacing it with an asymptotically faster algorithm.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567755", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amelia C.", + "last_name": "Fong", + "institution": "University of Guelph" + } + ], + "dblp_key": "conf/popl/Fong79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567756", + "title": "An Efficient Way to Find Side Effects of Procedure Calls and Aliases of Variables", + "abstract": "Article Free Access Share on An efficient way to find the side effects of procedure calls and the aliases of variables Author: John P. Banning Stanford Linear Accelerator Center, Stanford, California and Amdahl Corporation, Sunnyvale, California Stanford Linear Accelerator Center, Stanford, California and Amdahl Corporation, Sunnyvale, CaliforniaView Profile Authors Info & Claims POPL '79: Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1979 Pages 29–41https://doi.org/10.1145/567752.567756Online:01 January 1979Publication History 161citation871DownloadsMetricsTotal Citations161Total Downloads871Last 12 Months15Last 6 weeks5 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567756", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Banning", + "institution": "SLAC National Accelerator Laboratory" + } + ], + "dblp_key": "conf/popl/Banning79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567770", + "title": "Decisions for "Type" in APL", + "abstract": "The meaning of \"type\" in an APL extended to contain nested arrays is discussed. It is shown that \"type\" is closely related to the variety of empty arrays of the same shape and to the possible fill values needed in the \"expand\" and \"take\" functions. Choices for fill functions are systematically presented. They are classified according to the possibility of maintaining important identities involving level-manipulating functions in the case of empty arguments, to their effect on other design choices still to be made (the restriction to homogeneous arrays and the definition of the nature of basic data), and to their ability to express \"type\" in a natural way.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567770", + "conference_name": "POPL", + "authors": [ + { + "first_name": "W. E.", + "last_name": "Gull", + "institution": "Queen's University" + }, + { + "first_name": "Michael", + "last_name": "Jenkins", + "institution": "Queen's University" + } + ], + "dblp_key": "conf/popl/GullJ79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567775", + "title": "Type Checking in an Imperfect World", + "abstract": "We present an algorithn for the determination of run-time types which functions in the presence of errors, and show that it provides more information than that obtained using a previously published algorithm.In Section 1 we define the problem and state the requirements for a practically useful type prediction algorithm. In Section 2 we introduce a model programing language and in Section 3 define type inference rules for that language. Section 4 presents a type prediction algorithm and Section 5 describes how to apply the results to solve the problems stated in Section 1. Section 6 presents an example of our procedure and demonstrates how previous work does not satisfy all requirements.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567775", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Terrence C.", + "last_name": "Miller", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/popl/Miller79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567765", + "title": "Space-Time Tradeoffs for Linear Recursion", + "abstract": "A linear recursive procedure is one in which a procedural call can activate at most one other procedural call. When linear recursion cannot be replaced by iteration, it is usually implemented with a stack of size proportional to the depth of recursion. In this paper we analyze implementations of linear recursion which permit large reductions in storage space at the expense of a small increase in computation time. For example, if the depth of recursion is n, storage space can be reduced to √n at the cost of a constant factor increase in running time. The problem is treated by abstracting linear recursion into the pebbling of a simple graph and for this abstraction we exhibit the optimal space-time tradeoffs.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567765", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sowmitri", + "last_name": "Swamy", + "institution": "University of Illinois System" + }, + { + "first_name": "John E.", + "last_name": "Savage", + "institution": "Brown University" + } + ], + "dblp_key": "conf/popl/SavageS79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567761", + "title": "Process Logic", + "abstract": "We discuss problems arising in reasoning about on-going processes, using the modal constructs after, throughout, during, and preserves. Earlier work established decidability of the theory whose language included only the first two of these, along with program connectives | , ; and *. Here we give a complete Gentzen-type axiomatizations for useful combinations of the other modalities. We also indicate how such Gentzen-type axiomatizations lead to deterministic exponential time upper bounds on the complexity of decision procedures for these languages. It remains an open problem how to completely axiomatize the combination of modalities during and preserves.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567761", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vaughan", + "last_name": "Pratt", + "institution": "" + } + ], + "dblp_key": "conf/popl/Pratt79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567771", + "title": "Automatic Data Structure Selection in SETL", + "abstract": "SETL is a very high level programming language supporting set theoretical syntax and semantics. It allows algorithms to be programmed rapidly and succinctly without requiring data structure declarations to be supplied, though such declarations can be manually specified later, without recoding the program, to improve the efficiency of program execution. We describe a new technique for automatic selection of appropriate data representations during compile-time for undeclared, or partially declared programs,and present an efficient data structure selection algorithm, whose complexity is comparable with those of the fastest known general data-flow algorithms of Tarjan [TA2] and Reif [RE].", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567771", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Edmond", + "last_name": "Schonberg", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Jacob T.", + "last_name": "Schwartz", + "institution": "Courant Institute of Mathematical Sciences" + }, + { + "first_name": "Micha", + "last_name": "Sharir", + "institution": "Courant Institute of Mathematical Sciences" + } + ], + "dblp_key": "conf/popl/SchonbergSS79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567779", + "title": "Certifying Information Flow Properties of Programs: An Axiomatic Approach", + "abstract": "Interesting program properties other than functional correctness can be addressed and proved using axiomatic logic. An information flow logic that defines the flow semantics of a parallel programming language is presented. Proofs in this logic can be used to certify programs with respect to information security policies. The flow logic can also be combined with correctness logics to form an even more powerful deductive system.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567779", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard P.", + "last_name": "Reitman", + "institution": "Syracuse University" + }, + { + "first_name": "Gregory R.", + "last_name": "Andrews", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/ReitmanA79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567768", + "title": "Interpreter Generation Using Tree Pattern Matching", + "abstract": "Equations provide a rich, intuitively understandable notation for describing nonprocedural computing languages such as LISP and Lucid. In this paper, we present techniques for automatically generating interpreters from equations, analagous to well-known techniques for generating parsers from context-free grammars. The interpreters so generated are exactly faithful to the simple traditional mathematical meaning of the equations-no lattice-theoretic or fixpoint ideas are needed to explain the correspondence. The main technical problem involved is the extension of efficient practical string matching algorithms to trees. We present some new efficient table-driven matching techniques for a large class of trees, and point out unsolved problems in extending this class. We believe that the techniques of this paper form the beginnings of a useful discipline of interpreting, comparable to the existing discipline of parsing.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567768", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christoph M.", + "last_name": "Hoffmann", + "institution": "" + }, + { + "first_name": "Michael J.", + "last_name": "O’Donnell", + "institution": "" + } + ], + "dblp_key": "conf/popl/HoffmanO79", + "venue": "popl", + "year": 1979 + }, + { + "paper_id": "10.1145/567752.567773", + "title": "String Pattern Matching in Polynomial Time", + "abstract": "There is a wide range of applications for string processing and SNOBOL4 (Griswold, et al. [1971]) has come to be the most widely implemented and accepted language for such applications. No doubt one of the principle reasons for this acceptance is the data structure around which the language is organized, the string pattern. This structure together with the associated pattern matching process provide great flexibility. Nevertheless it has been widely recognized in informal terms that the pattern matching process is often grossly inefficient (Ripley & Griswold [1975], Dewar & McCann [1977]) and that the pattern structure is notoriously difficult to explain and use (Ripley & Griswold [1975], Stewart [1975]). Each of these areas of difficulty relates to such things as two modes of operation (quick-full scan), problems with left-recursion, heuristics in the scan, etc. Some difficulties are inherent with string patterns but many are not; we feel the developments described here help to clarify this situation.In section 2 we describe the formal model upon which we base this work. This allows the careful analysis of the variety of sets of strings which may be specified by the patterns which we admit and deduction to be made concerning the possibility/impossibility of algorithms of interest. With SNOBOL4 it has been the case that the careful definition of the meaning of a pattern is in terms of the actions taken by the pattern matching algorithm. This has led to the incorporation of idiosyncrasies of a particular algorithm into the understanding of the pattern structure. This seems akin to using a compiler as the definition of a programming language and we believe it is important to future progress to have other alternatives.In section 3 we point out that the worst-case execution time of the usual SNOBOL pattern matching algorithm is exponential in the length of the subject string, even on some quite simple patterns. We then present an algorithm whose worst-case time is polynomial and that operates on patterns which include a true set complement operator. As side benefits we find that the algorithm is not multi-modal and correctly handles the null string as an alternative and left-recursion.In order to conserve space we will assume throughout this paper that the reader is familiar with the idea of a string pattern in the sense that it is described in Griswold et al. [1971]. Also it is probably necessary that the reader have some general knowledge of the formal languages area.", + "date": "1979-01-01", + "link": "https://doi.org/10.1145/567752.567773", + "conference_name": "POPL", + "authors": [ + { + "first_name": "K. C.", + "last_name": "Liu", + "institution": "University of Wisconsin–Milwaukee" + }, + { + "first_name": "A. C.", + "last_name": "Fleck", + "institution": "University of Iowa" + } + ], + "dblp_key": "conf/popl/LiuF79", + "venue": "popl", + "year": 1979 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1980.json b/data/pl_conferences/popl/1980.json new file mode 100644 index 0000000..2bd6f88 --- /dev/null +++ b/data/pl_conferences/popl/1980.json @@ -0,0 +1,547 @@ +[ + { + "paper_id": "10.1145/567446.567467", + "title": "Efficient Algorithms for Structural Similarity of Grammars", + "abstract": "Efficient algorithms are presented for several grammar problems relevant to compiler construction. These problems include(i) testing, for a reduced context-free grammar G and an LL(k), uniquely invertible, or BRC(m,n) grammar H, if G is structurally contained by H, and(ii) testing, for a reduced context-free grammar G and a structurally unambiguous grammar H, if G is Reynolds covered by H or if there is an on to homomorphisem from G to H.Related complexity results are presented for several problems for the regular grammars, program schemes, and monadic program schemes.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567467", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harry B.", + "last_name": "Hunt", + "institution": "University at Albany, State University of New York" + }, + { + "first_name": "Daniel J.", + "last_name": "Rosenkrantz", + "institution": "University at Albany, State University of New York" + } + ], + "dblp_key": "conf/popl/HuntR80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567450", + "title": "Experience with an Applicative String Processing Language", + "abstract": "Experience using and implementing the language Poplar is described. The major conclusions are: Applicative programming can be made more natural through the use of built-in iterative operators and post-fix notation. Clever evaluation strategies, such as lazy evaluation, can make applicative programming more computationally efficient. Pattern matching can be performed in an applicative framework. Many problems remain.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567450", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James H.", + "last_name": "Morris", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Eric E.", + "last_name": "Schmidt", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/MorrisSW80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567451", + "title": "An Overview of the Summer Programming Language", + "abstract": "The language SUMMER is intended for the solution of problems in text processing and string manipulation. The language consists of a small kernel which supports success-directed evaluation, control structures, recovery caches and a data abstraction mechanism. It is shown how this kernel can be extended to support simultaneous pattern matching in arbitrary domains.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567451", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul", + "last_name": "Klint", + "institution": "" + } + ], + "dblp_key": "conf/popl/Klint80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567452", + "title": "Analysis of Simple Programs Over Different Sets of Primitives", + "abstract": "It is well known that most questions of interest about the behavior of programs--such as equivalence, halting, optimization, and other problems--are undecidable. On the other hand, it is possible to make some or all of these questions decidable by introducing appropriate restrictions on the programming language under consideration. And once such restrictions are made, the next step is to ask how hard it is to solve these problems for programming languages for which they are decidable.This analysis of programming languages has been undertaken by others, in particular by Jones and Muchnick [4], who choose to restrict their programs to operate over finite memory. Our approach starts from the language of loop-programs, as defined by Meyer and Ritchie [1], in which we in fact allow more general arithmetical operations. Unlike Jones and Muchnick, we do not place any restriction on memory here; instead, we (primarily) restrict our attention to loop-programs without nested loops.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567452", + "conference_name": "POPL", + "authors": [ + { + "first_name": "A. J.", + "last_name": "Kfoury", + "institution": "Boston University" + } + ], + "dblp_key": "conf/popl/Kfoury80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567470", + "title": "An Indeterminate Constructor for Applicative Programming", + "abstract": "This paper proposes the encapsulization and control of contending parallel processes within data structures. The advantage of embedding the contention within data is that the contention, itself, thereby becomes an object which can be handled by the program at a level above the actions of the processes themselves. This means that an indeterminate behavior, never precisely specified by the programmer or by the input, may be shared in the same way that an argument to a function is shared by every use of the corresponding parameter, an ability which is of particular importance to applicative-style programming.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567470", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "David S.", + "last_name": "Wise", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/FriedmanW80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567469", + "title": ""Type-Completeness" as a Language Design Principle", + "abstract": "In his recent Turing Lecture, John Backus delivered a trenchant argument for the proposition that \"programming languages are in trouble.\" Backus claims this to be inevitable: the development of Algol-like languages must lead to this sorry state because it begins from faulty assumptions.A less radical interpretation of the difficulties of language design is that we still do not understand the fundamental principles that should guide our design efforts; the machines we use may limit our results, but our ignorance has far greater effect. As evidence to support this position, we can cite the difficulties of building successors to Algol 60 and Pascal. Both languages have been acclaimed as well-designed, but it has proved extremely difficult to capture just what they \"got right.\" Thus, Hoare has claimed that \"Algol 60 was not only a great improvement on its predecessors, but also on nearly all of its successors.\" [73a] The recent Ada design suggests that the same fate may befall Pascal.In this paper, we expand on an idea of Landin [66] to develop an important principle of programming languages: type-completeness. We argue that application of this principle is an effective tool in understanding problems of programming language design. In particular, type-completeness1. allows us to point out many of the flaws and inconsistencies in existing languages (so we can know what mistakes not to repeat) and2. provides a framework for the design of languages (or language families) that have wide variation in their changeable parts.Below, we present the principle of type-completeness and its ramifications for language design. We then discuss some common examples of incompleteness found in existing Algol-like languages. And we end by presenting the type structure of the type-complete programming language Russell, which has been designed by the authors. As we show, the flexibility provided in Russell by the combination of a small, rich type structure and type-completeness belie Backus's assertion of inherent weakness of vonNeumann languages.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567469", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Cornell University" + }, + { + "first_name": "James", + "last_name": "Donahue", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/DemersD80a", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567468", + "title": "Theoretical and Emperical Studies on Using Program Mutation to Test the Functional Correctness of Programs", + "abstract": "In testing for program correctness, the standard approaches [11,13,21,22,23,24,34] have centered on finding data D, a finite subset of all possible inputs to program P, such that", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567468", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Timothy A.", + "last_name": "Budd", + "institution": "Yale University" + }, + { + "first_name": "Richard A.", + "last_name": "DeMillo", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Richard J.", + "last_name": "Lipton", + "institution": "Berkeley College" + }, + { + "first_name": "Frederick", + "last_name": "Sayward", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/BuddDLS80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567453", + "title": "Synchronous Schemes and Their Decision Problems", + "abstract": "A class of schemes called synchronous schemes is defined. A synchronous scheme can have several variables, but all the active ones are required to keep a synchronized rate of computation as measured by the height of their respective Herbrand values. A \"reset\" statement, which causes all the variables to restart a new computation, is admitted. It is shown that equivalence, convergence, and other properties are decidable for schemes in this class. The class of synchronous schemes contains, as special cases, the known decidable classes of Ianov schemes, one-variable schemes with resets, and progressive schemes.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567453", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zohar", + "last_name": "Manna", + "institution": "Stanford University" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/MannaP80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567466", + "title": "Axiomatic Definitions of Programming Languages: A Theoretical Assessment", + "abstract": "A precise definition is given of how partial correctness or termination assertions serve to specify the semantics of classes of program schemes. Assertions involving only formulas of first order predicate calculus are proved capable of specifying program scheme semantics, and effective axiom systems for deriving such assertions are described. Such axiomatic specifications are possible despite the limited expressive power of predicate calculus.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567466", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "" + }, + { + "first_name": "Joseph Y.", + "last_name": "Halpern", + "institution": "" + } + ], + "dblp_key": "conf/popl/MeyerH80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567463", + "title": ""Sometime" is Sometimes "Not Never" - On the Temporal Logic of Programs", + "abstract": "Pnueli [15] has recently introduced the idea of using temporal logic [18] as the logical basis for proving correctness properties of concurrent programs. This has permitted an elegant unifying formulation of previous proof methods. In this paper, we attempt to clarify the logical foundations of the application of temporal logic to concurrent programs. In doing so, we will also clarify the relation between concurrency and nondeterminism, and identify some problems for further research.In this paper, we consider logics containing the temporal operators \"henceforth\" (or \"always\") and \"eventually\" (or \"sometime\"). We define the semantics of such a temporal logic in terms of an underlying model that abstracts the fundamental concepts common to almost all the models of computation which have been used. We are concerned mainly with the semantics of temporal logic, and will not discuss in any detail the actual rules for deducing theorems.We will describe two different temporal logics for reasoning about a computational model. The same formulas appear in both logics, but they are interpreted differently. The two interpretations correspond to two different ways of viewing time: as a continually branching set of possibilities, or as a single linear sequence of actual events. The temporal concepts of \"sometime\" and \"not never\" (\"not always not\") are equivalent in the theory of linear time, but not in the theory of branching time -- hence, our title. We will argue that the logic of linear time is better for reasoning about concurrent programs, and the logic of branching time is better for reasoning about nondeterministic programs.The logic of linear time was used by Pnueli in [15], while the logic of branching time seems to be the one used by most computer scientists for reasoning about temporal concepts. We have found this to cause some confusion among our colleagues, so one of our goals has been to clarify the formal foundations of Pnueli's work.The following section gives an intuitive discussion of temporal logic, and Section 3 formally defines the semantics of the two temporal logics. In Section 4, we prove that the two temporal logics are not equivalent, and discuss their differences. Section 5 discusses the problems of validity and completeness for the temporal logics. In Section 6, we show that there are some important properties of the computational model that cannot be expressed with the temporal operators \"henceforth\" and \"eventually\", and define more general operators.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567463", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leslie", + "last_name": "Lamport", + "institution": "SRI International" + } + ], + "dblp_key": "conf/popl/Lamport80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567460", + "title": "Expressiveness of the Operation Set of a Data Abstraction", + "abstract": "In a strongly typed system supporting user defined data abstractions, the designer of a data abstraction ought to be careful in choosing the operations for the abstraction. If the operation set chosen is not expressive enough, it might be impossible or inconvenient to implement certain useful functions on the values of the data abstraction. In this paper, we characterize the expressive power of the operation set by defining two properties for data abstractions - expressive completeness and expressive richness. The operation set of an expressively complete data abstraction is adequate enough to implement all computable functions on its values. An expressively rich data abstraction is expressively complete with an operation set that is rich enough to conveniently extract from a value, all relevant information required to reconstruct the value from scratch. Practical applications of the properties of expressiveness introduced are also discussed.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567460", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Deepak", + "last_name": "Kapur", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Srivas", + "last_name": "Mandayam", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/KapurM80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567462", + "title": "On the Temporal Analysis of Fairness", + "abstract": "The use of the temporal logic formalism for program reasoning is reviewed. Several aspects of responsiveness and fairness are analyzed, leading to the need for an additional temporal operator: the 'until' operator -U. Some general questions involving the 'until' operator are then discussed. It is shown that with the addition of this operator the temporal language becomes expressively complete. Then, two deductive systems DX and DUX are proved to be complete for the languages without and with the new operator respectively.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567462", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dov M.", + "last_name": "Gabbay", + "institution": "Bar-Ilan University" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Tel Aviv University" + }, + { + "first_name": "Saharon", + "last_name": "Shelah", + "institution": "Hebrew University of Jerusalem" + }, + { + "first_name": "Jonathan", + "last_name": "Stavi", + "institution": "Bar-Ilan University" + } + ], + "dblp_key": "conf/popl/GabbayPSS80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567471", + "title": "Formal Specification as a Design Tool", + "abstract": "The formulation and analysis of a design specification is almost always of more utility than the verification of the consistency of a program with its specification. Good specification tools can assist in this process, but have generally not been proposed and evaluated in this light. In this paper we outline a specification language combining algebraic axioms and predicate transformers, present part of a non-trivial example (the specification of a high-level interface to a display), and finally discuss the analysis of this specification.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567471", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John V.", + "last_name": "Guttag", + "institution": "" + }, + { + "first_name": "J. J.", + "last_name": "Horning", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/GuttagH80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567448", + "title": "Data Types, Parameters, and Type Checking", + "abstract": "In statically typed programming languages, each variable and expression in a program is assigned a unique \"type\" and the program is checked to ensure that the arguments in each application are \"type-compatible\" with the corresponding parameters. The rules by which this \"type-checking\" is performed must be carefully considered for modern languages that allow the programmer to define his own data types and allow parameterized types or types as parameters. (Such languages include Alphard [Wulf78], CLU [Liskov77], Euclid [Lampson77] and Russell [Demers79].) These features increase the expressive power of the languages, but also increase the difficulty of type-checking them.In this paper, we describe a treatment of type-checking that makes it possible to do completely static checking with a general parameterization mechanism allowing parameterized types, types as parameters, and even a disciplined form of self-application. Our method defines a calculus of \"signatures,\" where signatures are similar to the \"program types\" of [Reynolds78]. Each identifier and expression is given a signature, and applications are type-correct when argument and parameter signatures are equivalent under a simple set of signature transformation rules. Below we present the signature calculus of Russell; we also present a semantic justification of this calculus and specify the language constraints necessary for us to justify our purely static approach to type-checking.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567448", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Cornell University" + }, + { + "first_name": "James E.", + "last_name": "Donahue", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/DemersD80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567454", + "title": "Qualified Data Flow Problems", + "abstract": "It is known that not all paths are possible in the run time control flow of many programs. It is also known that data flow analysis cannot restrict attention to exactly those paths that are possible. It is therefore usual for analytic methods to consider all paths. Sharper information can be obtained by considering a recursive set of paths that is large enough to include all possible paths but small enough to exclude many of the impossible ones. This paper presents a simple uniform methodology for sharpening data flow information by considering certain recursive path sets of practical importance. Associated with each control flow arc there is a relation on a finite set Q. The paths that qualify to be considered are (essentially) those for which the composition of the relations encountered is nonempty. For example, Q might be the set of all assignments of values to each of several bit variables used by a program to remember some facts about the past and branch accordingly in the future. Given any data flow problem together with qualifying relations on Q associated with the control flow arcs, we construct a new problem. Considering all paths in the new problem is equivalent to considering only qualifying paths in the old one. Preliminary experiments (with a small set of real programs) indicate that qualified analysis is feasible and substantially more informative than ordinary analysis. The methodology also has a beneficial feedback effect on the delicate task of passing from programs to meaningful data flow analysis problems. Even when all paths qualify, unusually sharp information can be obtained by passing from programs to problems in ways suggested by our theorems.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567454", + "conference_name": "POPL", + "authors": [ + { + "first_name": "L. Howard", + "last_name": "Holley", + "institution": "Cambridge Scientific (United States)" + }, + { + "first_name": "Barry K.", + "last_name": "Rosen", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/HolleyR80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567464", + "title": "Propositional Logics of Programs: Systems, Models, and Complexity", + "abstract": "We indicate below the various results in this paper and the sections where these results are fully described. δ1 is introductory).(δ2). The partial correctness assertion (PCA) A{α}B is expressed in PDL in the form A → [α]B. We shall consider the question of when a given finite set of PCAs implies another and give optimal complexity bounds. We also give other results of an algebraic nature.(δ3). DPDL is less well understood than PDL since the filtration technique of F-L that applies to the latter falls for the former. We point out a translation from PDL to DPDL which leads to a lower bound for the latter.(δ4). What do models of PDL look like? We show the existence of canonical and universal models and show how an infinite model can be related to its F-L factors.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567464", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rohit", + "last_name": "Parikh", + "institution": "Boston University" + } + ], + "dblp_key": "conf/popl/Parikh80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567447", + "title": "Analysis of Pointer Rotation", + "abstract": "Pointer manipulation is one of the trickiest operations in programming and is a major source of programming errors. A great deal of research effort has been dedicated to making programs with pointers more reliable. In this paper we will present pointer operations which reduce conceptual difficulties when writing pointer programs, and increase reliability of programs. We will analyze theoretically as well as empirically why these operations are more convenient. Finally, we will define the safety of rotations, and show that it is decidable to check whether the rotation is safe and also show that it is a good measure of the correctness of programs. (That is, if the rotation is safe it is highly probable that the program is correct, and if it is unsafe it is highly probable that the program is incorrect.)Probably the most successful effort to eliminate difficulties associated with pointer manipulation is the invention of abstract data types and the use of implementation modules. Pointers are often used to implement complex data structures, which in turn represent abstract data types. We can textually localize relevant pointer manipulations using abstract data types. Thus, we can easily check correctness of pointer programs. This approach is successful when the structure of abstract data types is simple, or efficiency is not seriously required. However, programs like garbage collection, list marking and copying, and balanced tree manipulations have not been well specified by abstract types.The approach taken in this paper is complementary to abstract data types, and makes programs like list marking and copying more reliable and easy to write. The idea behind this approach is to introduce higher-level pointer manipulation primitives instead of pointer assignments. Since most pointer assignments do not appear isolated, we can group several assignments together and replace them by one of these new primitives. We also show some theoretical evidence why these operations are nicer.Two primitives are introduced in this paper. One is the n-way pointer rotation, which is defined as being equivalent to the following procedure:Rotate: procedure(var x1, x2, … , xn:T) = begin var w:T; w:=x1; x1:=x2; … ;xn:=w endwhere all the locations of arguments x1, x2, … , xn are distinct. The other operation is n-way pointer slide, which is as powerful as pointer assignment yet keeps the elegance of rotation.Section 2 of this paper reviews previous work related to this subject. We give definitions of pointer operations analyzed in this paper in section 3. Using these operations, Deutsch-Schorr-Waite algorithm is rewritten in section 4. In section 5 we analyze pointer rotations extensively and obtain several properties which are not attainable by ordinary pointer assignments. In section 6 we define the safety of pointer rotation when applied to linear list and trees. Then, we extend this definition to arbitrary pointer data structures and show a decision procedure to check safety. In section 7 we show two examples, list marking and list copying programs written using rotations and slides. We examine how we can directly code the algorithms using these operations and safety checking algorithms are useful.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567447", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norihisa", + "last_name": "Suzuki", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/Suzuki80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567449", + "title": "A High-Level Approach to Computer Document Formatting", + "abstract": "The very best document-formatting system is a good secretary. He can be given scrawled handwritten text in no particular format, and without further instruction produce a flawless finished document. Nevertheless, we believe that document formatting should be done by computers, because so much of it is the tedium that computers handle so well. Existing computer document formatting programs have met with some success; indeed, most computer systems offer some sort of text formatting capability. These programs are often difficult to use, and are almost invariably tied to a particular kind of printing device.The document-formatting language Scribe was designed to provide a simple, portable language in which document formatting could be specified; the Scribe compiler was written to process that language into finished documents. In following sections we describe the design goals, the implementation, and report on experience with the completed system.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567449", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brian K.", + "last_name": "Reid", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Reid80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567456", + "title": "Prime Subprogram Parsing of a Program", + "abstract": "A parsing method based on the triconnected decomposition of a biconnected graph is presented. The parsing algorithm runs in linear time and handles a large class of flow graphs. The applications of this algorithm to flow analysis and to the automatic structuring of programs are discussed.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567456", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert E.", + "last_name": "Tarjan", + "institution": "Stanford University" + }, + { + "first_name": "Jacobo", + "last_name": "Valdes", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/Tarjan80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567459", + "title": "Final Data Tye Specifications: A New Data Type Specification Method", + "abstract": "A new specification method for data types is presented, which is distinguished by the semantic objects it specifies. In particular, only final data types [GGM,W] are specifiable. A final data type is one in which no two elements are \"input-output equivalent\". It is argued that the mathematical properties of final data types characterize abstractness on the semantic level.Examples are given to show that final data type specifications are easy to construct and use.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567459", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Samuel", + "last_name": "Kamin", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Kamin80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567465", + "title": "A Dynamic Logic of Multiprocessing with Incomplete Information", + "abstract": "A crucial property of distributed multiprocessing systems is the lack of complete information by any given process about the states of other processes. The contribution of this paper is a fundamental modal logic, MPL, for multiprocessing with incomplete information. (Section 1.5 gives an informal introduction to MPL; the formal definitions are in Section 2.)By way of this logic, we develop a solid (practical and theoretical) correspondence between distributed multiprocessing and multiplayer games of incomplete information.Fischer and Ladner, [1979] have shown a logspace reduction from the outcome problem for two person games of perfect information to satisfiability of formulas in their propositional dynamic logic (PDL). We provide in Section 3 a log-space reduction from the outcome problem for multiplayer games of incomplete information to satisfiability of formulas in our logic MPL. Although in general satisfiability in out logic is undecidable, the satisfiability problem of formulae with hierarchical visibility structure is shown decidable (using the methods for solving hierarchical games developed in Reif [1979] and Peterson and Reif [1979], and also the model theoretic techniques of Fischer and Ladner [1979] and Pratt [1979b]).At a more practical level, we argue that the game-like semantics of our logic provides a robust paradigm in which to view distributed multiprocessing problems. We apply our logic to describe total correctness properties of multi-process programs with shared variables as well as communicating processes with \"handshake\"-type message passing.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567465", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John H.", + "last_name": "Reif", + "institution": "Harvard University Press" + }, + { + "first_name": "Gary L.", + "last_name": "Peterson", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/popl/ReifP80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567458", + "title": "A Case Study in Specifying the Semantics of a Programming Language", + "abstract": "On and off over the period of about a year I have worked on a semantic specification for the C programming language My objective was to construct a readable and precise specification of C, aimed at compiler writers, maintainers, and language pundits. This paper is a report on the project.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567458", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ravi", + "last_name": "Sethi", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/Sethi80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567461", + "title": "On Proving Inductive Properties of Abstract Data Types", + "abstract": "The equational axioms of an algebraic specification of a data type (such as finite sequences) often can be formed into a convergent set of rewrite rules; i.e. such that all sequences of rewrites are finite and uniquely terminating. If one adds a rewrite rule corresponding to a data type property whose proof requires induction (such as associativity of sequence concatenation), convergence may be destroyed, but often can be restored by using the Knuth-Bendix algorithm to generate additional rules. A convergent set of rules thus obtained can be used as a decision procedure for the equational theory for the axioms plus the property added. This fact, combined with a \"full specification\" property of axiomatizations, leads to a new method of proof of inductive properties--not requiring the explicit invocation of an inductive rule of inference.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567461", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David R.", + "last_name": "Musser", + "institution": "" + } + ], + "dblp_key": "conf/popl/Musser80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567457", + "title": "On Specifying Verifiers", + "abstract": "The goal of automatic program verification is to prove programs correct formally. We argue that the existing notions of formal proof are too syntactic and as such too intimately bound up with details of low-level computation. We propose a more semantic notion of formal proof which nevertheless pays due respect to the problem of effectiveness in proof checking. Such a notion supplies a more practical basis for the specification of verifiers than do extant approaches. In particular the problem of constructing verifiers according to our approach is reduced entirely to routine development and implementation of decision methods, while permitting shorter proofs and yet remaining easy to develop proofs with.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567457", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vaughan", + "last_name": "Pratt", + "institution": "" + } + ], + "dblp_key": "conf/popl/Pratt80", + "venue": "popl", + "year": 1980 + }, + { + "paper_id": "10.1145/567446.567455", + "title": "Interprocedural Data Flow Analysis in the Presence of Pointers, Procedure Variables and Label Variables", + "abstract": "Interprocedural data flow analysis is complicated by the use of procedure and label variables in programs and by the presence of aliasing among variables. In this paper we present an algorithm for computing possible values for procedure and label variables, thus providing a call graph and a control flow graph. The algorithm also computes the possible aliasing relationships in the program being analyzed.We assume that control flow information is not available to the algorithm; hence, this type of analysis may be termed \"flow-free analysis.\" Given this assumption, we demonstrate the correctness of the algorithm, in the sense that the information it produces is conservative, and show that it is as precise as possible in certain cases. We also show that the problem of determining possible values for procedure variables is P-space hard. This fact indicates that any algorithm which is precise in all cases must also run very slowly for some programs.", + "date": "1980-01-01", + "link": "https://doi.org/10.1145/567446.567455", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William E.", + "last_name": "Weihl", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Weihl80", + "venue": "popl", + "year": 1980 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1981.json b/data/pl_conferences/popl/1981.json new file mode 100644 index 0000000..7ee73ad --- /dev/null +++ b/data/pl_conferences/popl/1981.json @@ -0,0 +1,506 @@ +[ + { + "paper_id": "10.1145/567532.567546", + "title": "Formal Program Testing", + "abstract": "This paper proposes a practical alternative to program verification -- called formal program testing -- with similar, but less ambitious goals. Like a program verifier, a formal testing system takes a program annotated with formal specifications as input, generates the corresponding verification conditions, and passes them through a simplifier. After the simplification step, however, a formal testing system simply evaluates the verification conditions on a representative set of test data instead of trying to prove them. Formal testing provides strong evidence that a program is correct, but does not guarantee it. The strength of the evidence depends on the adequacy of the test data.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567546", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/Cartwright81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567548", + "title": "Axiomatic Definitions of Programming Languages, II", + "abstract": "Sufficient conditions are given for partial correctness assertions to determine the input-output semantics of quite general classes of programming languages. This determination cannot be unique unless states which are indistinguishable by predicates in the assertions are identified. Even when indistinguishable states are identified, partial correctness assertions may not suffice to determine program semantics.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567548", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph Y.", + "last_name": "Halpern", + "institution": "Harvard University Press" + }, + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/HalpernM81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567534", + "title": "Paths: An Abstract Alternative to Pointers", + "abstract": "This paper introduces the path, a new programming language construct designed to supplant the use of pointers to access and destructively update recursive data structures. In contrast to the complex semantics and proof rules for pointers, the semantics and proof rules for paths are simple and abstract. In fact, they are easily formalized within a first-order theory of recursive data objects analogous to first-order number theory. We present a number of sample programs, including implementations of queues and binary trees, utilizing the new construct and prove that they are correct.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567534", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Rice University" + }, + { + "first_name": "Robert", + "last_name": "Hood", + "institution": "Cornell University" + }, + { + "first_name": "Philip", + "last_name": "Matthews", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/popl/CartwrightHM81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567543", + "title": "A Program Development Tool", + "abstract": "In this paper we describe how we have combined a number of tools (most of which understand a particular programming language) into a single system to aid in the reading, writing, and running of programs. We discuss the efficacy and the structure of our system. For the last two years the system has been used to build itself; it currently consists of 500 kilobytes of machine code (25,000 lines of LISP/370 code) and approximately one hundred commands with large numbers of options. We will describe some of the experience we have gained in evolving this system. We first indicate the system components which users have found most important; some of the tools described here are new in the literature. Second, we emphasize how these tools form a synergistic union, and we illustrate this point with a number of examples. Third, we illustrate the use of various system commands in the development of a simple program. Fourth, we discuss the implementation of the system components and indicate how some of them have been generalized.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567543", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cyril N.", + "last_name": "Alberga", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Allen L.", + "last_name": "Brown", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "George B.", + "last_name": "Leeman", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Martin", + "last_name": "Mikelsons", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Mark N.", + "last_name": "Wegman", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/AlbergaBLMW81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567544", + "title": "Incremental Evaluation for Attribute Grammars with Application to Syntax-Directed Editors", + "abstract": "A syntax-directed editor is a tool for structured program development. Such an editor can enforce syntactic correctness incrementally by restricting editing operations to legitimate modifications of the program's context-free derivation tree. However, not all language features can be described by the context-free formalism. To build editors that enforce non-context-free correctness, a more powerful specification technique is needed. In this paper we discuss the advantages of attribute grammars as a specification technique for a syntax-directed editing system. We also present an efficient algorithm for incrementally evaluating attributes as a program tree is derived.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567544", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Cornell University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "Cornell University" + }, + { + "first_name": "Tim", + "last_name": "Teitelbaum", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/DemersRT81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567556", + "title": "A Precise Interprocedural Data Flow Algorithm", + "abstract": "Data flow analysis is well understood at the intra-procedural level and efficient algorithms are available. When inter-procedural mechanisms such as recursion, procedure nesting, and pass-by-reference aliasing are introduced, the data flow problems become much more difficult. The avail, live, and must-summary data flow problems are shown to be NP-complete in the presence of aliasing. However, an algorithm is presented with O(SET*EDGE) time performance where EDGE is the size of the program's flow graph and SET is a possible exponential number which reflects the number of aliasing patterns of the program. It is argued that in practice SET is small and on the order of the number of variables of the program.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567556", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eugene M.", + "last_name": "Myers", + "institution": "" + } + ], + "dblp_key": "conf/popl/Myers81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567533", + "title": "Carrier Arrays: An Idiom-Preserving Extension to APL", + "abstract": "The idiomatic APL programming style is limited by the constraints of a rectangular, homogeneous array as a data structure. Non-scalar data is difficult to represent and manipulate, and the non-scalar APL functions have no uniform extension to higher rank arrays. The carrier array is an extension to APL which addresses these limitations while preserving the economical APL style. A carrier array is a ragged array with an associated partition which allows functions to be applied to subarrays in parallel. The primitive functions are given base definitions on scalars and vectors, and they are extended to higher rank arrays by uniform application mechanisms. Carrier arrays also allow the last dimensions of an array to be treated as a single datum; the primitive functions are given extended definitions on scalars and vectors of this non-scalar data.This paper defines the carrier array and gives the accompanying changes to the definitions of the APL primitive functions. Examples of programming with carrier arrays are presented, and implementation issues are discussed.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567533", + "conference_name": "POPL", + "authors": [ + { + "first_name": "P. Geoffrey", + "last_name": "Lowney", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/Lowney81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567537", + "title": "Programming Primitives for Database Languages", + "abstract": "This paper examines a number of programming primitives in query languages for relational databases. The basic framework is a language based on relational algebra, whose variables take relations as values. The primitives considered are (i) looping, (ii) counters, (iii) generic (or unranked) variables, (iv) equality, (v) bounded looping (which corresponds to counting the number of tuples in a relation), and (vi) isomorphism class (which corresponds to knowing the isomorphism class of the data base). A comparison diagram is given relating all combinations of these six primitives, and several of the resulting classes of queries are characterized by their complexity or algebraic properties. It is shown, for example, that equality cannot be simulated using all the other primitives, that generic variables (with loops) cannot be simulated with only ranked variables and all the other primitives, and that with bounded loops one can determine the isomorphism class of the database when generic variables are allowed, but not otherwise.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567537", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ashok K.", + "last_name": "Chandra", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/Chandra81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567554", + "title": "Program Optimization and Exception Handling", + "abstract": "Optimization of programs that may contain exception handling facilities requires new techniques. Program optimizations that do not account for exception handling facilities may incorrectly transform a procedure that can raise an exception, producing different results from the unoptimized version. Restricted exception handling mechanisms that allow optimization are discussed. Data flow equations for determining the effects of exception handling are presented.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567554", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John L.", + "last_name": "Hennessy", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Hennessy81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567549", + "title": "Program Verification Based on Denotational Semantics", + "abstract": "A theory of partial correctness proofs is formulated in Scott's logic computable junctions. This theory allows mechanical construction of verification condition solely on the basis of a denotational language definition. Extensionally these conditions, the resulting proofs, and the required program augmentation are similar to those of Hoare style proofs; conventional input, output, and invariant assertions in a first order assertion language are required. The theory applies to almost any sequential language defined by a continuation semantics; for example, there are no restrictions on aliasing or side-effects. Aspects of static semantics,such as type and declaration constraints, which are expressed in the denotational definition are validated as part of the verification condition generation process.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567549", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wolfgang", + "last_name": "Polak", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Polak81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567542", + "title": "Position Paper on Optimizing Compilers", + "abstract": "No abstract available.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567542", + "conference_name": "POPL", + "authors": [ + { + "first_name": "S. C.", + "last_name": "Johnson", + "institution": "" + } + ], + "dblp_key": "conf/popl/Johnson81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567551", + "title": "The Temporal Logic of Branching Time", + "abstract": "A temporal language and system are presented which are based on branching time structure. By the introduction of symmetrically dual sets of temporal operators, it is possible to discuss properties which hold either along one path or along all paths. Consequently it is possible to express in this system all the properties that were previously expressible in linear time or branching time systems. We present an exponential decision procedure for satisfiability in the language based on tableaux methods, and a complete deduction system. As associated temporal semantics is illustrated for both structured and graph representation of programs.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567551", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mordechai", + "last_name": "Ben‐Ari", + "institution": "Tel Aviv University" + }, + { + "first_name": "Zohar", + "last_name": "Manna", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/Ben-AriMP81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567538", + "title": "Paging as a "Language Processing" Task", + "abstract": "This paper examines \"language processing\" approach to paging where the of the programming language compiler or interpreter is responsible for generating the necessary control code for the page management of a program. We explore this idea for APL and describe an approach to incorporating in a program the necessary paging functions. The semantics of APL computation are examined to observe how paging operations can be incorporated into the computation. We discuss a model of data access in APL that exhibits storage use for both scalar and page references. A data structure that encodes the logical use of data from an array is introduced. We find that ordering computations efficiently and computing paging needs can be determined by simple transformations on this structure. This analysis leads us to an efficient method for paging an APL computation. Our approach builds on previous studies for efficiently executing APL.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567538", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Condry", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/Condry81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567555", + "title": "Dependence Graphs and Compiler Optimizations", + "abstract": "Dependence graphs can be used as a vehicle for formulating and implementing compiler optimizations. This paper defines such graphs and discusses two kinds of transformations. The first are simple rewriting transformations that remove dependence arcs. The second are abstraction transformations that deal more globally with a dependence graph. These transformations have been implemented and applied to several different types of high-speed architectures.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567555", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David J.", + "last_name": "Kuck", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Robert H.", + "last_name": "Kuhn", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Bruce", + "last_name": "Leasure", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Michael", + "last_name": "Wolfe", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/KuckKPLW81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567541", + "title": "Position Paper on Optimizing Compilers", + "abstract": "No abstract available.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567541", + "conference_name": "POPL", + "authors": [ + { + "first_name": "W. H.", + "last_name": "Harisson", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Harrison81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567539", + "title": "Making the World Safe for Garbage Collection", + "abstract": "This paper describes the formal specifications of garbage collection in the programming language Cedar Mesa. They were developed as part of the process of identifying a safe subset of Mesa for which garbage collection was possible. The purpose of the specifications was to provide a precise definition of safety, along with criteria for checking the safety of proposed language features. Thus the specifications had to characterize the \"invisibility\" of the collector, as well as describe the services it provides. A beneficial effect of the specification effort was that the process of constructing the specifications led to a number of discoveries that improved the quality of the language.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567539", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Susan", + "last_name": "Owicki", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Owicki81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567547", + "title": "On the Advantages of Free Choice: A Symmetric and Fully Distributed Solution to the Dining Philosophers Problem", + "abstract": "It is shown that distributed systems of probabilistic processors are essentially more powerful than distributed systems of deterministic processors, i.e., there are certain useful behaviors that can be realized only by the former. This is demonstrated on the dining philosophers problem. It is shown that, under certain natural hypotheses, there is no way the philosophers can be programmed (in a deterministic fashion) so as to guarantee the absence of deadlock (general starvation). On the other hand, if the philosophers are given some freedom of choice one may program them to guarantee that every hungry philosopher will eat (with probability one) under any circumstances (even an adversary scheduling). The solution proposed here is fully distributed and does not involve any central memory or any process with which every philosopher can communicate.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567547", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Lehmann", + "institution": "Hebrew University of Jerusalem" + }, + { + "first_name": "Michael O.", + "last_name": "Rabin", + "institution": "Hebrew University of Jerusalem" + } + ], + "dblp_key": "conf/popl/LehmannR81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567535", + "title": "Modeling of Problem Domains for Driving Program Development Systems", + "abstract": "Article Free Access Share on Modeling of problem domains for driving program development systems Authors: J. Ramanathan The Ohio State University, Columbus, Ohio The Ohio State University, Columbus, OhioView Profile , C. J. Shubra The Ohio State University, Columbus, Ohio The Ohio State University, Columbus, OhioView Profile Authors Info & Claims POPL '81: Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1981 Pages 28–40https://doi.org/10.1145/567532.567535Online:26 January 1981Publication History 1citation183DownloadsMetricsTotal Citations1Total Downloads183Last 12 Months2Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567535", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jay", + "last_name": "Ramanathan", + "institution": "The Ohio State University" + }, + { + "first_name": "Charles John", + "last_name": "Shubra", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/popl/RamanathanS81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567545", + "title": "Linear Cost is Sometimes Quadratic", + "abstract": "In analysis of programs and many other kinds of computation, algorithms are commonly written to have an input P and an output Q, where both P and Q are large and complicated objects. For example, P might be a routing problem and Q might be a solution to P. Although documented and discussed in this exhaustive style, algorithms are sometimes intended for use in contexts with two departures from the one-time analysis of an entire new input. First, the current value of P is the result of a small change to a previous value of P. We want to update the results of the previous analysis without redoing all of the work. Second, accurate information is only wanted in some designated portion of the large output Q. Possibly inaccurate information may appear elsewhere in Q. We want the analysis to be demand-driven: accurate where accuracy is demanded, but not burdened by the cost of providing much more than is demanded. This paper studies demand-driven algorithms capable of updating without extensive reanalysls. Such algorithms are called incremental, in contrast with the one-time analysis of an entire new input contemplated by exhaustive algorithms. In some cases, it is shown that an exhaustive algorithm can be easily recast in an efficient incremental style. Other algorithms for the same problem may be much less amenable to incremental use. It is shown that traditional exhaustive computational complexity bounds are poor predictors of incremental performance. The main examples are taken from global data flow analysis.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567545", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Barry K.", + "last_name": "Rosen", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Rosen81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567553", + "title": "Inferring Types in Smalltalk", + "abstract": "Smalltalk is an object-oriented language designed and implemented by the Learning Research (Group of the Xerox Palo Alto Research Center [2, 5, 14]. Some features of this language are: abstract data classes, information inheritance by a superclass-subclass mechanism, message passing semantics, extremely late binding no type declarations, and automatic storage management. Experience has shown that large complex systems can be written in Smalltalk in quite a short period of time; it is also used to teach programming to children quite effectively. Object-oriented languages like Smalltalk have begun to be accepted as friendly languages for novice programmers on personal computers.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567553", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norihisa", + "last_name": "Suzuki", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/Suzuki81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567550", + "title": "Program Logic Without Binding is Decidable", + "abstract": "When the \"binding mechanisms\" of assignment, quantification, and procedure definition are removed from a conventional first order total correctness logic of programs, the remaining logical system is decidable in time approximately one exponential in the length of the input. This system is maximal in the sense that the presence of any one of the three binding mechanisms would make it undecidable. Such a decision procedure can play a central role in the construction of program verifiers based on decision methods.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567550", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vaughan", + "last_name": "Pratt", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Pratt81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567552", + "title": "Verification of Attribute Grammars", + "abstract": "Verification of attribute grammar is discussed. As is widely recognized, attribute grammar of Knuth [8] is a very convenient device to describe semantics of programming languages, especially in automating compiler construction. Many efforts have been made to obtain efficient evaluators for attribute grammar [1,3,4,5,7,10] so that efficient compilers may be produced from the semantic specifications written in the attribute grammar.There is another important problem about the semantic specifications. This is how to verify the correctness of the specification and is essential in ascertaining the correctness of produced compilers. In contrast with the evaluation problem, this has not been studied well and only a few partial results have been reported up to now [2,9].In this paper we propose a verification procedure for proving the correctness of attribute grammar, which is applicable to the wide class of attribute grammars called absolutely noncircular ones [7]. Our method can be extended to accept any noncircular attribute grammar since it is shown that any noncircular attribute grammar is transformed into an equivalent absolutely noncircular one [5].Our verification procedure utilizes dependency relations among attributes and verification is performed by induction based on this order relation, according to which attributes are evaluated. This procedure consists of (1) assigning assertions to relevant pairs of a nonterminal symbol and a parallelly evaluable subset of its attributes, (2) generating a set of verification conditions for each production rule with the aid of dependency graph of the rule and (3) proving the verification conditions. Of course, verification is performed production-rule-wise.Our method can accept attribute grammars which contain both synthesized and inherited attributes and handle them in a well-formed way. This contrasts to the previous works where only the synthesized case is considered [2] or there seems no general and formal descriptions about how to verify general attribute grammars [9].In this paper we first give necessary definitions and notations for attribute grammar and then propose a verification procedure to prove its correctness. After giving some examples of verification, we establish consistency and completeness of our procedure.", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567552", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Takuya", + "last_name": "Katayama", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Yutaka", + "last_name": "Hoshino", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "conf/popl/KatayamaH81", + "venue": "popl", + "year": 1981 + }, + { + "paper_id": "10.1145/567532.567536", + "title": "Program Improvement by Internal Specialization", + "abstract": "We investigate the specialization of programs by means of program transformation techniques. There are two goals of this investigation: the construction of program synthesis tools, and a better understanding of the development of algorithms.By extending an ordinary language of recursion equations to include a generalized procedure construct (the expression procedure), our ability to manipulate programs in that language is greatly enhanced. The expression procedure provides a means of expressing information not just about the properties of individual program elements, but also about the way they relate to each other.A set of four operations for transforming programs in this extended language is presented. These operations, unlike the transformation rules of Burstall and Darlington and of Manna and Waldinger, preserve the strong equivalence of programs.This set of operations forms the basis of a general-purpose specialization technique for recursive programs. The practical value of this technique has been demonstrated in the systematic development of many programs, including several context-free parsing algorithms. We outline here the development of Earley's algorithm by specialization.This paper is an informal exposition of part of the results of the author's Ph.D. thesis [Scherlis80].", + "date": "1981-01-01", + "link": "https://doi.org/10.1145/567532.567536", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William L.", + "last_name": "Scherlis", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Scherlis81", + "venue": "popl", + "year": 1981 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1982.json b/data/pl_conferences/popl/1982.json new file mode 100644 index 0000000..ac61dd1 --- /dev/null +++ b/data/pl_conferences/popl/1982.json @@ -0,0 +1,798 @@ +[ + { + "paper_id": "10.1145/582153.582181", + "title": "Partial Evaluation as a Means for Inferencing Data Structures in an Applicative Language: A Theory and Implementation in the Case of Prolog", + "abstract": "An operational semantics of the Prolog programming language is introduced. Meta-IV is used to specify the semantics. One purpose of the work is to provide a specification of an implementation of a Prolog interpreter. Another one is an application of this specification to a formal description of program optimization techniques based on the principle of partial evaluation.Transformations which account for pruning, forward data structure propagation and opening (which also provides backward data structure propagation) are formally introduced and proved to preserve meaning of programs. The so defined transformations provide means to inference data structures in an applicative language. The theoretical investigation is then shortly related to research in rule-based systems and logic.An efficient well-integrated partial evaluation system is available in Qlog --- a Lisp programming environment for Prolog.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582181", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jan", + "last_name": "Komorowski", + "institution": "Linköping University" + } + ], + "dblp_key": "conf/popl/Komorowski82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582178", + "title": "A Semantics-Directed Compiler Generator", + "abstract": "Article Free Access Share on A semantics-directed compiler generator Author: Lawrence Paulson Stanford University and Computer Laboratory, University of Cambridge, U. K. Stanford University and Computer Laboratory, University of Cambridge, U. K.View Profile Authors Info & Claims POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1982 Pages 224–233https://doi.org/10.1145/582153.582178Online:25 January 1982Publication History 54citation699DownloadsMetricsTotal Citations54Total Downloads699Last 12 Months13Last 6 weeks7 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582178", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lawrence C.", + "last_name": "Paulson", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/Paulson82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582186", + "title": "On Effective Axiomatizations of Hoare Logics", + "abstract": "For a wide class of programming languages P and expressive interpretations I, we show that there exist sound and relatively complete Hoare-like logics for both partial correctness and termination assertions. In fact, under mild assumptions on P and I, we show that the assertions true for P in I are uniformly decidable in the theory of I (Th(I)) iff the halting problem for P is decidable for finite interpretations. Moreover termination assertions are uniformly r.e. in Th(I) even if the halting problem for P is not decidable for finite interpretations. Since total correctness assertions coincide with termination assertions for deterministic programming languages, this last result unexpectedly suggests that the class of languages with good axiom systems for total correctness may be wider than for partial correctness.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582186", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Edmund", + "last_name": "Clarke", + "institution": "Harvard University" + }, + { + "first_name": "Steven M.", + "last_name": "German", + "institution": "Stanford University" + }, + { + "first_name": "Joseph Y.", + "last_name": "Halpern", + "institution": "Harvard University" + } + ], + "dblp_key": "conf/popl/ClarkeGH82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582155", + "title": "Guardians and Actions: Linguistic Support for Robust, Distributed Programs", + "abstract": "This paper presents an overview of an integrated programming language and system designed to support the construction and maintenance of distributed programs: programs in which modules reside and execute at communicating, but geographically distinct, nodes. The language is intended to support a class of applications in which the manipulation and preservation of long-lived, on-line, distributed data is important. The language addresses the writing of robust programs that survive hardware failures without loss of distributed information and that provide highly concurrent access to that information while preserving its consistency. Several new linguistic constructs are provided; among them are atomic actions, and modules called guardians that survive node failures.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582155", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Robert W.", + "last_name": "Scheifler", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/LiskovS82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582174", + "title": "Non-Syntactic Attribute Flow in Language Based Editors", + "abstract": "Article Free Access Share on Non-syntactic attribute flow in language based editors Authors: Gregory F. Johnson University of Wisconsin-Madison University of Wisconsin-MadisonView Profile , Charles N. Fischer University of Wisconsin-Madison University of Wisconsin-MadisonView Profile Authors Info & Claims POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1982Pages 185–195https://doi.org/10.1145/582153.582174Published:25 January 1982Publication History 18citation113DownloadsMetricsTotal Citations18Total Downloads113Last 12 Months12Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582174", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gregory F.", + "last_name": "Johnson", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Charles N.", + "last_name": "Fischer", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/JohnsonF82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582187", + "title": "Modular Verification of Concurrent Programs", + "abstract": "Verifying concurrent systems can be difficult because of the complex interactions possible between system components. In this paper, we propose a technique to simplify the task: modular composition of sequential proofs. We model a parallel program as a set of modules that interact by procedure calls. The properties of each module are proved using a sequential-program verification technique. If the modules satisfy a set of constraints presented in this paper, we may compose the modules into a system and the properties of the modules into properties of the system. The constraints ensure that the specifications are robust for each module where they are defined or used, in the sense that they are unaffected by current actions of other modules. A specification can be guaranteed robust for module m by restricting it to local variables of m, or by using monotonic predicates, which once true remain true forever. Our technique can be used to prove safety and liveness properties of parallel programs---the liveness properties are specified using temporal logic.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582187", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brent", + "last_name": "Hailpern", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Susan", + "last_name": "Owicki", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/HailpernO82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582190", + "title": "On the Expressive Power of Query Languages for Relational Databases", + "abstract": "The query languages used in relational database systems are a special class of programming languages. The majority, based on first-order logic, lend themselves to analysis using formal methods. First, we provide a definition of relational query languages and their expressive power. We prove some general results and show that only a proper subset of first-order logic formulas may be used as a practical query language. We characterize this subset in both semantic and syntactic terms. We then analyze the expressive power of several real query languages, including languages based on the relational calculus, languages with set operators and aggregate functions, and procedural query languages.Since the partial ordering \"is more expressive than\" determines a lattice among relational query languages, the results of the paper may be viewed as determining some of the structure of this lattice. We conclude with some applications of the results to the optimization problem for query processing.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582190", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eric C.", + "last_name": "Cooper", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/Cooper82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582185", + "title": "Algorithmic Program Diagnosis", + "abstract": "The notion of program correctness with respect to an interpretation is defined for a class of programming languages. Under this definition, if a program terminates with an incorrect output then it contains an incorrect procedure. Algorithms for detecting incorrect procedures are developed. These algorithms formalize what experienced programmers may know already.A logic program implementation of these algorithms is described. Its performance suggests that the algorithms can be the backbone of debugging aids that go far beyond what is offered by current programming environments.Applications of algorithmic debugging to automatic program construction are explored.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582185", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ehud", + "last_name": "Shapiro", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/Shapiro82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582164", + "title": "Experience with an Attribute Grammar-Based Compiler", + "abstract": "Experience writing a production compiler based on an attribute grammar is related. The compiler is Intel Corporation's Pascal-86 compiler which runs on a microcomputer-based system. An attribute grammar was written describing semantic analysis, storage allocation and translation to intermediate code. Attribute evaluation is done in two alternating passes [J] and the program tree is kept in intermediate files on disk. Various techniques for optimizing the evaluator were tried. Their success is reported and compared with other ideas from the literature.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582164", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rodney", + "last_name": "Farrow", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/popl/Farrow82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582160", + "title": "Programming Aspects of VLSI", + "abstract": "Two components of a VLSI design environment being built at Princeton are described. The general theme of this effort is to make the design of VLSI circuits as similar to programming as possible. A conscious attempt is being made to apply experience in the design of large software systems to the creation of an appropriate environment for VLSI circuits. The two components described are a procedural language to specify circuit layouts and a switch-level circuit simulator for layout produced with this language. They have been chosen for presentation because many issues in their design are very similar to the issues that arise in the design of programming languages and software environments.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582160", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard J.", + "last_name": "Lipton", + "institution": "Princeton University" + }, + { + "first_name": "Robert", + "last_name": "Sedgewick", + "institution": "Brown University" + }, + { + "first_name": "Jacobo", + "last_name": "Valdes", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/LiptonSV82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582154", + "title": "Termination of Probabilistic Concurrent Programs", + "abstract": "The asynchronous execution behavior of several concurrent processes, which may use randomization, is studied. Viewing each process as a discrete Markov chain over the set of common execution states, we give necessary and sufficient conditions for the processes to converge almost surely to a given set of goal states, under any fair, but otherwise arbitrary schedule, provided that the state space is finite. (These conditions can be checked mechanically.) An interesting feature of the proof method is that it depends only on the topology of the transitions and not on the actual values of the probabilities. We also show that in our model synchronization protocols that use randomization are in certain cases no more powerful than deterministic protocols. This is demonstrated by (a) Proving lower bounds on the size of a shared variable necessary to ensure mutual exlusion and lockout-free behavior of the protocol; and (b) Showing that no fully symmetric 'randomized' protocol can ensure mutual exclusion and freedom from lockout.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582154", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sergiu", + "last_name": "Hart", + "institution": "Tel Aviv University" + }, + { + "first_name": "Micha", + "last_name": "Sharir", + "institution": "Tel Aviv University" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/popl/HartSP82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582184", + "title": "Semantics and Correctness of a Query Language Translation", + "abstract": "This paper proves the correctness of a translation from HISEL, a relational database query language, to HI, a hierarchical query language.The four components of Morris' [7] program are established. Appropriate semantics for the two languages are defined. A translation function is defined and an L-attributed grammar capturing the translation function is exhibited. The transformation of database trees into database relations is specified.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582184", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Emden R.", + "last_name": "Gansner", + "institution": "" + }, + { + "first_name": "J.R.", + "last_name": "Horgan", + "institution": "" + }, + { + "first_name": "Chandra M. R.", + "last_name": "Kintala", + "institution": "" + }, + { + "first_name": "Denny", + "last_name": "Moore", + "institution": "" + }, + { + "first_name": "P.", + "last_name": "Surko", + "institution": "" + } + ], + "dblp_key": "conf/popl/GansnerHKMS82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582167", + "title": "Eliminating Redundant Object Code", + "abstract": "Compilers usually eliminate common subexpressions in intermediate code, not object code. This reduces machine-dependence but misses the machine-dependent common subexpressions introduced by the last phases of code expansion. This paper describes a machine-independent procedure for eliminating machine-specific common subexpressions. It also identifies dead variables, defines windows for a companion peephole optimizer, and forms the basis of a retargetable register allocator. Its techniques for handling machine-specific data should generalize to other optimizations as well.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582167", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jack W.", + "last_name": "Davidson", + "institution": "University of Arizona" + }, + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/DavidsonF82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582175", + "title": "Building Friendly Parsers", + "abstract": "An essential part of any interactive programming development system is an incremental parser capable of error recovery. This paper presents a general incremental parser for LR(1) grammars allowing several/any form of modifications in the input program. The parser is suplemented with error recovery routines using an error automaton. Errors can be corrected automatically by recovery routines, or by the user at his request.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582175", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fahimeh", + "last_name": "Jalili", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jean", + "last_name": "Gallier", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/JaliliG82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582182", + "title": "A Logic for Expressions with Side-Effects", + "abstract": "This paper presents a simple programming logic LES, which is particularly well suited for reasoning about so-called expression languages, i.e. languages that incorporate imperative features into expressions rather than distinguishing between expressions and statements. An axiomatization of a simple programming language is presented using this formalism. It is shown that this axiomatization is relatively complete, roughly in the sense of [Coo 76].", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582182", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Boehm82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582162", + "title": "Automatic Generation of Machine Specific Code Optimizers", + "abstract": "Article Free Access Share on Automatic generation of machine specific code optimizers Author: Robert Giegerich Institut für Informatik Technische Universität München West Germany Institut für Informatik Technische Universität München West GermanyView Profile Authors Info & Claims POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1982 Pages 75–81https://doi.org/10.1145/582153.582162Online:25 January 1982Publication History 6citation236DownloadsMetricsTotal Citations6Total Downloads236Last 12 Months10Last 6 weeks5 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582162", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Giegerich", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/popl/Giegerich82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582158", + "title": "Extended Naming Conventions for Communicating Processes", + "abstract": "We present two extensions of Communicating Sequential Processes [HO78]: computed communication targets and unspecified communication targets, as well as corresponding extensions to the system of cooperating proofs [AFR80] for verifying distributed programs. These extensions are important for the natural expressibility of many distributed programs. Examples of the use of these extensions are discussed and verified.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582158", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nissim", + "last_name": "Francez", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/Francez82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582156", + "title": "Specification and Synthesis of Communicating Processes using an Extended Temporal Logic", + "abstract": "We apply an Extended Propositional Temporal Logic (EPTL) to the specification and synthesis of the synchronization part of communicating processes. To specify a process, we give an EPTL formula that describes its sequence of communications. The synthesis is done by constructing a model of the given specifications using a tableau-like satisfiability algorithm for the extended temporal logic. This model can then be interpreted as a program.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582156", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Wolper", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Wolper82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582163", + "title": "Optimal Code for Control Structures", + "abstract": "Article Free Access Share on Optimal code for control structures Authors: M. V. S. Ramanath University of Western Ontario, London, Ontario, Canada University of Western Ontario, London, Ontario, CanadaView Profile , Marvin Solomon Universiy of Wisconsin, Madison, Wisconsin Universiy of Wisconsin, Madison, WisconsinView Profile Authors Info & Claims POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1982 Pages 82–94https://doi.org/10.1145/582153.582163Online:25 January 1982Publication History 0citation207DownloadsMetricsTotal Citations0Total Downloads207Last 12 Months5Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582163", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Maya", + "last_name": "Ramanath", + "institution": "Western University" + }, + { + "first_name": "Marvin", + "last_name": "Solomon", + "institution": "University of Wisconsin System" + } + ], + "dblp_key": "conf/popl/RamanathS82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582177", + "title": "On the Composition of Processes", + "abstract": "We describe a model of net-connected processes that amounts to a reformulation of a model derived by Brock and Ackerman from the Kahn-McQueen model of processes as relations on streams of data. The reformulation leads directly to a straightforward definition of process composition. Our notion of processes and their composition constitutes a natural generalization of the notion of functions and their composition. We apply this definition of process composition to the development of an algebra of processes, which we propose as supplying a formal semantics for a language whose domain of discourse includes nets of interconnected processes. This in turn leads us to logics of such nets, about which we raise three open and fundamental problems: existence of a finite basis for the operations of the language, finite axiomatizability of the equational theory, and decidability of this theory. A natural generalization of the model deals with the time complexity of computations.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582177", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vaughan", + "last_name": "Pratt", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Pratt82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582191", + "title": "On the Ability of Structures to Store and Access Information", + "abstract": "Article On the ability of structures to store and access information Share on Author: Adrienne Critcher The University of Iowa, Iowa City, Iowa The University of Iowa, Iowa City, IowaView Profile Authors Info & Claims POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1982 Pages 366–378https://doi.org/10.1145/582153.582191Online:25 January 1982Publication History 1citation177DownloadsMetricsTotal Citations1Total Downloads177Last 12 Months2Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582191", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Adrienne", + "last_name": "Critcher", + "institution": "University of Iowa" + } + ], + "dblp_key": "conf/popl/Critcher82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582161", + "title": "A Flexible Approach to Interprocedural Data Flow Analysis and Programs with Recursive Data Structures", + "abstract": "A new approach to data flow analysis of procedural programs and programs with recursive data structures is described. The method depends on simulation of the interpreter for the subject programming language using a retrieval function to approximate a program's data structures.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582161", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neil D.", + "last_name": "Jones", + "institution": "Aarhus University" + }, + { + "first_name": "Steven S.", + "last_name": "Muchnick", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/popl/JonesM82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582165", + "title": "Description-Driven Code Generation using Attribute Grammars", + "abstract": "The instruction-set of a target architecture is represented as a set of attribute-grammar productions. A code generator is obtained automatically for any compiler using attributed parsing techniques. A compiler built on this model can automatically perform most popular machine-dependent optimizations, including peephole optimizations. The code generator is also easily retargetable to different machine architectures.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582165", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mahadevan", + "last_name": "Ganapathi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Charles N.", + "last_name": "Fischer", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/GanapathiF82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582176", + "title": "Principal Type-Schemes for Functional Programs", + "abstract": "the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of its publication and date appear, and notice is given", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582176", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luı́s", + "last_name": "Damas", + "institution": "University of Edinburgh" + }, + { + "first_name": "Robin", + "last_name": "Milner", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/DamasM82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582166", + "title": "Code Generation and Reorganization in the Presence of Pipeline Constraints", + "abstract": "Pipeline interlocks are used in a pipelined architecture to prevent the execution of a machine instruction before its operands are available. An alternative to this complex piece of hardware is to rearrange the instructions at compile-time to avoid pipeline interlocks. This problem, called code reorganization, is studied. The basic problem of reorganization of machine level instructions at compile-time is shown to be NP-complete. A heuristic algorithm is proposed and its properties and effectiveness are explored. The impact of code reorganization techniques on the rest of a compiler system are discussed.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582166", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John L.", + "last_name": "Hennessy", + "institution": "Stanford University" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/HennessyG82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582159", + "title": "Unbounded Speed Variability in Distributed Communication Systems", + "abstract": "This paper concerns the fundamental problem of synchronizing communication between distributed processes whose speeds (steps per real time unit) vary dynamically. Communication must be established in matching pairs, which are mutually willing to communicate. We show how to implement a distributed local scheduler to find these pairs. The only means of synchronization are boolean \"flag\" variables, each of which can be written by only one process and read by at most one other process.No global bounds in the speeds of processes are assumed. Processes with speed zero are considered dead. However, when their speed is nonzero then they execute their programs correctly. Dead processes do not harm our algorithms' performance with respect to pairs of other running processes. When the rate of change of the ratio of speeds of neighbour processes (i.e., relative acceleration) is bounded, then any two of these processes will establish communication within a constant number of steps of the slowest process with high likelihood. Thus our implementation has the property of achieving relative real time response. We can use our techniques to solve other problems such as resource allocation and implementation of parallel languages such as CSP and ADA. Note that we do not have any probability assumptions about the system behavior, although our algorithms use the technique of probabilistic choice.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582159", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John H.", + "last_name": "Reif", + "institution": "Harvard University Press" + }, + { + "first_name": "Paul G.", + "last_name": "Spirakis", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/ReifS82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582168", + "title": "A Type Declaration and Inference System for Smalltalk", + "abstract": "An experimental system for declaring and inferring type in Smalltalk is described. (In the current Smalltalk language, the programmer supplies no type declarations.) The system provides the benefits of type declaration in regard to compile-time checking and documentation, while still retaining Smalltalk's flexibility. A type hierarchy, which is integrated with the existing Smalltalk class hierarchy, allows one type to inherit the traits of another type. A type may also have parameters, which are in turn other types.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582168", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Borning", + "institution": "University of Washington" + }, + { + "first_name": "Daniel H. H.", + "last_name": "Ingalls", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/BorningI82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582170", + "title": "Unified Dialogue Management in the Carousel System", + "abstract": "The paper describes the design for a software environment which unifies the dialogue management support of a number of existing software tools, such as command-language handlers, operating-system shells, transition diagram interpreters, and forms management systems. The unification is accomplished without undue complexity: the resulting design is clean and inspectable.A key notion in the design is the use of three orthogonal abstraction hierarchies, for interaction contexts, for interactive operations (roughly = commands), and for data types. These orthogonal hierarchies are used for obtaining multi-dimensional inheritance, i.e. mappings of several arguments, which may be stored in the system's data repository, and which inherit their values along the hierarchies represented in the arguments. Mappings with multi-dimensional inheritance are used in the invocation mechanism, i.e. for selecting the appropriate procedure to be executed in various situations. Currently used programming languages and software tools only use single-dimensional inheritance.A working implementation called the CAROUSEL system, is available.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582170", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Erik", + "last_name": "Sandewall", + "institution": "Linköping University" + } + ], + "dblp_key": "conf/popl/Sandewall82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582172", + "title": "Optimal-Time Incremental Semantic Analysis for Syntax-Directed Editors", + "abstract": "Attribute grammars permit the specification of static semantics in an applicative and modular fashion, and thus are a good basis for syntax-directed editors. Such editors represent programs as attributed trees, which are modified by operations such as subtree pruning and grafting. After each modification, a subset of attributes, AFFECTED, requires new values. Membership in AFFECTED is not known a priori; this paper presents an algorithm that identifies attributes in AFFECTED and computes their new values. The algorithm is time-optimal, its cost is proportional to the size of AFFECTED.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582172", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Reps82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582171", + "title": "Maple: a Programming Language, Operating System", + "abstract": "Maple is a statically typed language system, with very general generic facilities. It incorporates its own programming environment and provides parallel processing with a new method of process synchronization. The synchronization is the direct outgrowth of its data abstraction facility.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582171", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul J.", + "last_name": "Voda", + "institution": "University of Alberta" + } + ], + "dblp_key": "conf/popl/Voda82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582157", + "title": "Messages as Active Agents", + "abstract": "Network algorithms are usually stated from the viewpoint of the network nodes, but they can often be stated more clearly from the viewpoint of an active message, a process that intentionally moves from node to node. This paper gives some examples of this notion, and then discusses a means of implementing it. This implementation applied in both directions also demonstrates the logical equivalence of the two viewpoints.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582157", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David W.", + "last_name": "Wall", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/Wall82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582188", + "title": "Axiomatic Definability and Completeness for Recursive Programs", + "abstract": "The termination assertion pq means that whenever the formula p is true, there is an execution of the possibly nondeterministic program S which terminates in a state in which q is true. Termination assertions are more tractable technically than the partial correctness assertions usually treated in the literature. Termination assertions are studied for a programming language which includes local variable declarations, calls to undeclared global procedures, and nondeterministic recursive procedures with call-by-address and call-by-value parameters. By allowing formulas p and q to place conditions on global procedures, we provide a method for reasoning about programs with calls to global procedures based on hypotheses about procedure input-output behavior. The set of first-order termination assertions valid over all interpretations is completely axiomatizable without reference to the theory of any interpretation. Although uninterpreted assertions have limited expressive power, the set of valid termination assertions defines the semantics of recursive programs in the sense of Meyer and Halpern [10]. Thus the axiomatization constitutes an axiomatic definition of the semantics of recursive programs.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582188", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/MeyerM82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582169", + "title": "Lithe: A Language Combining a Flexible Syntax, Classes", + "abstract": "Article Free Access Share on Lithe: a language combining a flexible syntax and classes Author: David Sandberg University of Washington, Seattle, WA University of Washington, Seattle, WAView Profile Authors Info & Claims POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1982Pages 142–145https://doi.org/10.1145/582153.582169Published:25 January 1982Publication History 11citation369DownloadsMetricsTotal Citations11Total Downloads369Last 12 Months34Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582169", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Sandberg", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/Sandberg82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582173", + "title": "Practical Error Recovery in LR Parsing", + "abstract": "An automatic syntax error handling technique applicable to LR parsing is presented and analyzed. The technique includes a \"phrase-level\" error recovery strategy augmented with certain additional features such as \"local correction\". Attention has also been paid to diagnostic aspects, i.e. the automatic generation of error message texts. The technique has been implemented in the compiler writing system HLP (Helsinki Language Processor), and some promising experimental results have been obtained by testing the technique with erroneous student-written Algol and Pascal programs.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582173", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Seppo", + "last_name": "Sippu", + "institution": "University of Helsinki" + }, + { + "first_name": "Eljas", + "last_name": "Soisalon-Soininen", + "institution": "University of Helsinki" + } + ], + "dblp_key": "conf/popl/SippiS82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582189", + "title": "Is the Interesting Part of Process Logic Uninteresting - A Translation from PL to PDL", + "abstract": "With the (necessary) condition that atomic programs in PL be binary, we present an algorithm for the translation of a PL formula X into a PDL program τ (X) such that a finite path satisfies X iff it belongs to τ (X). This reduction has two immediate corollaries: 1) validity in this PL can be tested by testing validity of formulas in PDL; 2) all finite-path program properties expressible in this PL are expressible in PDL.The translation, however, seems to be of non-elementary time complexity. The significance of the result to the search for natural and powerful logics of programs is discussed.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582189", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R. W.", + "last_name": "Sherman", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "David", + "last_name": "Harel", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/popl/ShermanPH82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582183", + "title": "An Axiomatic Treatment of Exception Handling", + "abstract": "Article Free Access Share on An axiomatic treatment of exception handling Author: Shaula Yemini New York University New York UniversityView Profile Authors Info & Claims POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1982Pages 281–288https://doi.org/10.1145/582153.582183Published:25 January 1982Publication History 1citation276DownloadsMetricsTotal Citations1Total Downloads276Last 12 Months15Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582183", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shaula", + "last_name": "Yemini", + "institution": "New York University" + } + ], + "dblp_key": "conf/popl/Yemeni82", + "venue": "popl", + "year": 1982 + }, + { + "paper_id": "10.1145/582153.582179", + "title": "Semantics-Directed Machine Architecture", + "abstract": "We show how to analyze the denotational semantics for a programming language to obtain a compiler and a suitable target machine for the language. We do this by rewriting the equations using suitable combinators. The machine operates by simulating the reduction sequences for the combinator terms. The reduction sequences pass through certain standard forms, which become an architecture for the machine, and the combinators become machine instructions. Despite the abstract nature of its development, the machine greatly resembles a conventional one. The method is illustrated by a simple expression language with procedures and input-output.", + "date": "1982-01-01", + "link": "https://doi.org/10.1145/582153.582179", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/Wand82", + "venue": "popl", + "year": 1982 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1983.json b/data/pl_conferences/popl/1983.json new file mode 100644 index 0000000..dd2b3f9 --- /dev/null +++ b/data/pl_conferences/popl/1983.json @@ -0,0 +1,596 @@ +[ + { + "paper_id": "10.1145/567067.567081", + "title": ""Sometimes" and "Not Never" Revisited: On Branching Versus Linear Time", + "abstract": "Temporal logic ([PR57], [PR67]) provides a formalism for describing the occurrence of events in time which is suitable for reasoning about concurrent programs (cf. [PN77]). In defining temporal logic, there are two possible views regarding the underlying nature of time. One is that time is linear: at each moment there is only one possible future. The other is that time has a branching, tree-like nature: at each moment, time may split into alternate courses representing different possible futures. Depending upon which view is chosen, we classify (cf. [RU71]) a system of temporal logic as either a linear time logic in which the semantics of the time structure is linear, or a system of branching time logic based on the semantics corresponding to a branching time structure. The modalities of a temporal logic system usually reflect the semantics regarding the nature of time. Thus,in a logic of linear time, temporal operators are provided for describing events along a single time path (cf. [GPSS80]). In contract, in a logic of branching time the operators reflect the branching nature of time by allowing quantification over possible futures cf. [AB80],[EC80]).", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567081", + "conference_name": "POPL", + "authors": [ + { + "first_name": "E. Allen", + "last_name": "Emerson", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Joseph Y.", + "last_name": "Halpern", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/EmersonH83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567068", + "title": "Five Paradigm Shifts in Language Design and their Realization in Viron, a Dataflow Programming Environment", + "abstract": "We describe five paradigm shifts in programming language design, some old and some relatively new, namely Effect to Entity, Serial to Parallel, Partition Types to Predicate Types, Computable to Definable, and Syntactic Consistency to Semantic Consistency. We argue for the adoption of each. We exhibit a programming language, Viron, that capitalizes on these shifts.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567068", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vaughan", + "last_name": "Pratt", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Pratt83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567072", + "title": "Reasoning About Nonatomic Operations", + "abstract": "A method is presented that permits assertional reasoning about a concurrent program even though the atomicity of the elementary operations is left unspecified. It is based upon a generalization of the dynamic logic operator [α]. The method is illustrated by verifying the mutual exclusion property for a two-process version of the bakery algorithm.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567072", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leslie", + "last_name": "Lamport", + "institution": "SRI International" + } + ], + "dblp_key": "conf/popl/Lamport83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567070", + "title": "Code Generation for Silicon", + "abstract": "Compiler writers facea bleak future---soon everyone will be using Ada on the Nebula Architecture and there will be no further need for our services. Luckily, it appears to be possible to recycle compiler writers by encouraging them to build circuit design tools (Silicon Compilers). Many of the standard techniques used in compilers can be immediately applied in circuit design, especially for LSI circuits. In part, this paper attempts to serve as a tutorial, casting some of the problems of designing in nMOS with the Mead-Conway design rules into the vocabulary of the compiler writer. The paper also discusses experience with a Silicon compiler that has fabricated over two dozen different designs.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567070", + "conference_name": "POPL", + "authors": [ + { + "first_name": "S. C.", + "last_name": "Johnson", + "institution": "" + } + ], + "dblp_key": "conf/popl/Johnson83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567085", + "title": "Conversion of Control Dependence to Data Dependence", + "abstract": "Program analysis methods, especially those which support automatic vectorization, are based on the concept of interstatement dependence where a dependence holds between two statements when one of the statements computes values needed by the other. Powerful program transformation systems that convert sequential programs to a form more suitable for vector or parallel machines have been developed using this concept [AllK 82, KKLW 80].The dependence analysis in these systems is based on data dependence. In the presence of complex control flow, data dependence is not sufficient to transform programs because of the introduction of control dependences. A control dependence exists between two statements when the execution of one statement can prevent the execution of the other. Control dependences do not fit conveniently into dependence-based program translators.One solution is to convert all control dependences to data dependences by eliminating goto statements and introducing logical variables to control the execution of statements in the program. In this scheme, action statements are converted to IF statements. The variables in the conditional expression of an IF statement can be viewed as inputs to the statement being controlled. The result is that control dependences between statements become explicit data dependences expressed through the definitions and uses of the controlling logical variables.This paper presents a method for systematically converting control dependences to data dependences in this fashion. The algorithms presented here have been implemented in PFC, an experimental vectorizer written at Rice University.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567085", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John R.", + "last_name": "Allen", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + }, + { + "first_name": "Carrie", + "last_name": "Porterfield", + "institution": "Rice University" + }, + { + "first_name": "Joe", + "last_name": "Warren", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/AllenKPW83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567071", + "title": "Derivation of Efficient DAG Marking Algorithms", + "abstract": "The best known linear-time list marking algorithms also require a linear amount of workspace. Algorithms working in bounded workspace have been obtained only by allowing quadratic execution time or by restricting the list structures to trees. We improve on this here by deriving a new linear-time, bounded workspace marking algorithm that works for dags. The algorithm is derived using correctness-preserving program transformations, which prove the correctness of the algorithm. Our derivation of the marking algorithm provides an example where this method has actually been used to derive a new, more efficient algorithm, rather than just to establish the correctness of a previously known algorithm.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567071", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R. J. R.", + "last_name": "Back", + "institution": "University of Helsinki" + }, + { + "first_name": "Heikki", + "last_name": "Mannila", + "institution": "University of Helsinki" + }, + { + "first_name": "Kari‐Jouko", + "last_name": "Räihä", + "institution": "University of Helsinki" + } + ], + "dblp_key": "conf/popl/BackMR83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567073", + "title": "Verifying Reachability Invariants of Linked Structures", + "abstract": "The paper introduces a reachability predicate for linear lists, develops the elementary axiomatic theory of the predicate, and illustrates its application to program verification with a formal proof of correctness for a short program that traverses and splices linear lists.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567073", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Greg", + "last_name": "Nelson", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/Nelson83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567090", + "title": "Practical Use of a Polymorphic Applicative Language", + "abstract": "Assembling a large system from its component elements is not a simple task. An adequate notation for specifying this task must reflect the system structure, accommodate many configurations of the system and many versions as it develops, and be a suitable input to the many tools that support software development. The language described here applies the ideas of λ-abstraction, hierarchical naming and type-checking to this problem. Some preliminary experience with its use is also given.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567090", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Butler", + "last_name": "Lampson", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Eric E.", + "last_name": "Schmidt", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/LampsonS83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567089", + "title": "A Program Form Based on Data Dependency in Predicate Regions", + "abstract": "A new program representation is presented which permits certain optimizations to be performed at less expense than with other forms. This paper describes code motion, common subexpression elimination and induction variable detection. Scalar propagation and constant folding are sketched here, but detailed elsewhere. The powerful code motion strategy allows entire regions of the program to be moved. The representation described may be used as a compiler intermediate form or simply as a model for program analysis. It has great potential for use in translation for parallel machines.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567089", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeanne", + "last_name": "Ferrante", + "institution": "IBM (United States)" + }, + { + "first_name": "Karl J.", + "last_name": "Ottenstein", + "institution": "Michigan Technological University" + } + ], + "dblp_key": "conf/popl/FerranteO83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567087", + "title": "Compilation of Data-Driven Programs for Synchronous Execution", + "abstract": "We present algorithms that convert a class of parallel programs, called loop programs, from data-driven mode to synchronous mode. Such algorithms enable programmers to use a high-level, data-driven programming language without forfeiting the efficiency of a synchronous machine. We characterize loop programs for which conversion is possible in terms of sets of balancing equations and we present two conversion algorithms.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567087", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Janice E.", + "last_name": "Cuny", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Lawrence", + "last_name": "Snyder", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/CunyS83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567069", + "title": "Uncovering Principles of Novice Programming", + "abstract": "It is widely known that programming, even at a simple level, is a difficult activity to learn. Why is this so? Are novice difficulties really inherent in programming or are they related, to the nature of the programming tools currently given to novices? To answer this question we have used novice Pascal computer programs collected from their terminal sessions, controlled clinical studies focusing on specific aspects of novice programming techniques, and video-taped interviews of novice programming [Bonar, 1982]. In each we focused on bugs and buggy programs. Bugs and errors illuminate what a novice is actually thinking -- providing us a window on the difficulties as they are experienced by the novice.In previous reports we presented evidence that current programming languages do not accurately reflect the cognitive strategies used by novice programmers [Soloway et al, 1981]. Instead, we have found that novice programmers possess knowledge about and experience with step-by-step specifications in natural language. This knowledge and experience gives them powerful intuitions for using a programming language. Programming languages, however, are, not designed to appeal to these intuitions. On a semantic and pragmatic level, there are incompatibilities between the way, natural and programming languages are used. Many novice programming bugs can be directly traced to an inappropriate use of natural language specification style or strategy.As an example of these incompatibility bugs consider the \"while demon\" bug. Novices with this bug assume that the actions in the body of the while loop are continuously monitored for the exit condition to become true. This interpretation is consistent with the English language usage of the word while: e.g.\"while the highway is two lanes, continue, north\". In an earlier written study [Soloway et al, 1981] found that 34% of the students in an introductory programming course thought the test in a Pascal while loop was performed, as a demon. Furthermore, a later interview study showed that novices could even describe the implementation mechanism for such a demon:\"… everytime I [the variable tested in the while condition] is assigned a new value, the machine needs to check that value …\"In this report we describe our use of video-taped interview studies for understanding how novices use a programming system. Interviews provide valuable information not available through statistical analysis of written studies. Written studies allow us to manipulate specific factors and guage the results to performance or style. Furthermore, we can have statistical confidence in those results. An interview study, on the other hand, allows us to examine the source of performance or style differences uncovered. Interviews give us an \"execution trace\" while written studies give us the final output. We use both kinds of studies, depending on the kind of information needed.We have interviewed seventeen novice programmers. Four were interviewed regularly for the first 8-10 weeks of their introductory programming course. For these regular subjects we have about 15 hours of interviews tracing their learning and maturation through the course.In this report we show an example natural language specification and discuss strategies used in that specification. We then discuss two examples of novice programming difficulties stemming from an inappropriate use of natural language specification strategies. These examples are illustrated with video tape transcripts. We conclude with a brief discussion of the implications of this work.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567069", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeffrey", + "last_name": "Bonar", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Elliot", + "last_name": "Soloway", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/BonarS83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567078", + "title": "Computer Experiments with the Reve Term Rewriting System Generator", + "abstract": "A term rewriting system generator called REVE is described. REVE builds confluent and uniformly terminating term rewriting systems from sets of equations. Particular emphasis is placed on mechanization of termination proof. Indeed, REVE is one of the few such systems which can actually be called automatic because termination is fully integrated into the algorithms. REVE uses an incremental termination method based on recursive decomposition ordering which constructs the termination proof step by step from the presentation of the set of equations and which requires little knowledge of termination methods from the user. All examples from this paper are taken from abstract data type specifications.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567078", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Lescanne", + "institution": "Centre de Recherche en Informatique" + } + ], + "dblp_key": "conf/popl/Lescanne83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567094", + "title": "Abstraction Mechanisms in the Beta Programming Language", + "abstract": "The BETA programming language is developed as part of the BETA project. The purpose of this project is to develop concepts, constructs and tools in the field of programming and programming languages. BETA has been developed from 1975 on and the various stages of the language are documented in [BETA a].", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567094", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bent Bruun", + "last_name": "Kristensen", + "institution": "Aalborg University" + }, + { + "first_name": "Ole Lehrmann", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Birger", + "last_name": "Møller-Pedersen", + "institution": "Norwegian Computing Center" + }, + { + "first_name": "Kristen", + "last_name": "Nygaard", + "institution": "Norwegian Computing Center" + } + ], + "dblp_key": "conf/popl/KristensenMMN83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567080", + "title": "Automatic Verification of Finite State Concurrent Systems Using Temporal Logic Specifications: A Practical Approach", + "abstract": "We give an efficient procedure for verifying that a finite state concurrent system meets a specification expressed in a (propositional) branching-time temporal logic. Our algorithm has complexity linear in both the size of the specification and the size of the global transition graph for the concurrent system. We also show how the logic and our algorithm can be modified to handle fairness. We argue that this technique can provide a practical alternative to manual proof construction or use of a mechanical theorem prover for verifying many finite state concurrent systems.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567080", + "conference_name": "POPL", + "authors": [ + { + "first_name": "E. M.", + "last_name": "Clarke", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "E. Allen", + "last_name": "Emerson", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "A. Prasad", + "last_name": "Sistla", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/ClarkeES83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567083", + "title": "Structural Semantics for Polymorphic Data Types", + "abstract": "The semantic modeling of data types has been the subject ofincreased interest over the last few years, enhanced by thedevelopment of applicative languages such as Edinburgh's ML andHOPE, by the need for flexible highly structured languages thatwould nonetheless be amenable to verification, and by ongoinginquiries on polymorphism in programming languages. In particular,there has been a growing interest in generic type structures suchas the Reynolds-Girard discipline of full polymorphism, furtherextended by McCracken [McC] and MacQueen and Sethi [MS], and inuser-defined and recursively-defined types.Our aim here is to model semantically the notion of type so asto encompass full polymorphism, but in a very controlled way whichon the one hand allows the modeling to remain simple, and on theother hand conveys as much of the notion of type as seems feasiblyrelevant to programming languages.Our leading idea is that a type is a structural condition ondata objects rather than a collection of objects which satisfiescertain closure properties. Roughly, we argue that such structuralconditions are fully conveyed by syntactic expressions, not inisolation of course, but within a syntax-oriented typediscipline. In other words, we treat types as discrete objects,which merely code the ways data objects are allowed to interact (asin applying functional object a to object b). Once atype discipline is set to delineate a set of type expressions, andonce the meaning of the type-constructs is imposed on the ways thedata objects relate, the meaning of each type expression isconveyed by the expression itself (reduced to a canonical form ifnecessary). This conception of types permits a strikingly simplemodeling of the use of types as arguments of data objects, a usecentral to Reynolds' polymorphic type system [Rey].The use of types as genuine arguments of procedures is notdevoid of practical interest. E.g., one may wish to treat objectsof type o generically, except for an initial choice dependingon the principal type-constructor of o, that is, according towhether o is an atomic type, a functional type, a cartesianproduct, etc.A particular situation where such choices may be useful is wherea procedure has a formal parameter intended to range over some datastructure (trees of sequences of objects of type t, say), adata structure that has a number of accepted representations byformal data types. It seems desirable to permit the definition of apolymorphic procedure that would accept as valid a number of suchformal representations, branching on them internally. This kind offacility would elevate the polymorphism of a procedure from thelevel of uses with in a single program, to the level oftransportability from one set of data structure specifications toanother.This kind of use of types as arguments is compatible withReynold's discipline of type abstraction, but not with thequantificational discipline of [MS] (cf.[Lei83], §4.2). Whilethe two disciplines, as uninterpreted and unexpanded calculi, arecombinatorially isomorphic the difference between their intendedsemantics becomes apparent when primitive functions over types(such as discriminators over main type-constructor) areconsidered.The examples we have given of uses of types as arguments arefairly restricted in nature: all that is used of a type is itssyntactically representable structure. This is not merely anempirical observation on our limited perception at present time. Ina typed discipline of programming each object carries its type(explicitly or not), and all types of denotable objects arethemselves denotable. It follows that any question that one may askabout the type of a denotable object reduces to a question abouttype-expression(s) denoting that type. The issue of semanticallymodeling Reynold's rich discipline of type abstraction is thereforereduced, from a pragmatic point of view, to a modeling in whichquestions about types are all expressible as questions about typeexpressions.Existing approaches to the semantic modeling of data types are,in one form or another, conceptual continuations of thedenotational semantics approach to data objects. McCracken [McC],following [Sco], defines types as retracts of the universal domain.In Shamir and Wadge [SW], Milner [Mil] and MacQueen and Sethi [MS]types are modeled as some kind of ideal, where an ideal is asubset of the object-domain that satisfies certain closureconditions. In both approaches types are being defined via theproperties that they must satisfy, as sets of objects, so as tobecome compatible with their use. (This may be compared with thealgebraic approach to types, where each particular type isdefined via its algebraic properties rather than its intendedconception).Our modeling of types too is grafted on top of a denotationalsemantics for the object language, However,it has a life of itsown, and can be explained in isolation, or combined with forinstance, an operational semantics for the object language. Thepoint we are trying to make is that the semantics of types haslittle to do with the issues of self-application and continuitywhich motivate denotational semantics. Rather than amalgamateobjects and types, as in [SW] (where types as sets of objects aretreated on an equal footing with objects as sets ofapproximations), we separate the two radically.We make no claim, of course, that our approach should supplantthe modeling of types as retracts or as ideals. Rather, we believethat the semantics we propose is related to types-as-ideals in muchthe same way as operational semantics is related to denotationalsemantics: it is closer to programming practice, permits a smallerset of objects, and is sensitive to the choice of formal framework(which for us is the type discipline). We therefore feel that thetwo approaches should shed light on each other and, in combination,enhance our understanding of complex data-types and and theirproper use.In particular, we believe that even putting down the definitionsand proving basic existence theorems provides some insight aboutthe design and use of data types. For one, our modeling of typessuggests a feasible controlled use of types as arguments of dataobjects. For another, it points to directions in setting very richtype disciplines evolving naturally from a structural-computationalview of types. For instance, it may be useful and feasible toconsider types built as certain recursive sets of other types.Following preliminaries in sections 1 and 2 we define in section3 what is a model of the pure polymorphic lambda calculus.A termmodel is constructed in §4,in §5 we show how to constructa non-extensional model through the solution of a domain equation,and in §6 we construct an extensional model through such asolution. The latter construction involves breaking the circularityin the conditions underlying polymorphic typing, by a method akinto Girard's in the proof theory of higher order logic [Gir].We plan to extend this work in two directions. One is thetreatment of more general type disciplines, of the kinds defined byMcCracken [McC] and further studied by MacQueen and Sethi [MS]. Thecrucial issue here is that, in contrast to Reynold's discipline,distinct type expressions may denote the same type. However, eachtype expression has a normal form, which may be viewed as itsvalue (this view has been advocated in greater generality by PerMartin-Lof [Mar], on somewhat more philosophical grounds). A seconddirection, incorporating aspects of the first, is the treatment ofrecursively defined data types in a polymorphic context, andpossibly more general notions of types.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567083", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniël", + "last_name": "Leivant", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Leivant83a", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567095", + "title": "Locality in Software Systems", + "abstract": "This paper proposes a technique for what we call localization of power in computer systems, which can be viewed as a generalization of such linguistic disciplines as scope rules, strong typing and data-abstraction. Although the proposed technique is conceptually based on the theory of protection, it is presented as a rather simple extension of the package construct of the Ada language. This technique is expected to be beneficial for software engineering in several ways. In particular:• It facilitates reasoning about large scale systems, by allowing one to ignore most of the details of the system when reasoning about specific aspects of it.• It provides us with a generalization of the conventional concept of data-abstraction, by allowing the formation of several different abstractions for the same type of objects, and by supporting \"interactions\" between the abstractions of different types.• It allows us to provide parts of a system with a certain ability to control the activity of the rest of it.• It supports a broad spectrum of policies for the design and management of large scale, evolving systems.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567095", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Naftaly H.", + "last_name": "Minsky", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/popl/Minsky83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567077", + "title": "Polymorphic Type Inference", + "abstract": "The benefits of strong typing to disciplined programming, to compile-time error detection and to program verification are well known. Strong typing is especially natural for functional (applicative) languages, in which function application is the central construct, and type matching is therefore a principal program correctness check. In practice, however, assigning a type to each and every expression in a functional program can be prohibitively cumbersome. As expressions are compounded, the task of assigning a type to each expression and subexpression becomes practically impossible, even more so because the type-expressions themselves grow longer. It becomes imperative therefore to design friendly programming environments that permit the user type-free programming, but that generate fully typed programs in which the types of all expressions are inferred by the system from the program. For interactive functional programming environments of the kind implemented for the Edinburgh functional programming language ML, a type-inference system is an invaluable tool for on-line parse-time error detection and debugging.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567077", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniël", + "last_name": "Leivant", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Leivant83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567079", + "title": "Precise Typing of Abstract Data Type Specifications", + "abstract": "There are two important notions of types being used in programming languages today. In the concept called types, types are algebras; the semantics of programs is described in terms of operations in these algebras. Another notion of found in most of the typed programming languages in actual use regards types as sets of objects; the elements of types are the objects manipulated by the operators of a programming language. I shall be careful to use abstract when I mean the algebraic notion, and data or simply type to mean the set-based concept.This paper presents a formal theory of types as an approximation to the exact semantics of a language, following the lead of Milner [Mil78]. The semantics is based upon multi-sorted algebras [ADJ73, 76, 77, 78] and is applied to a language consisting of equational specifications that define an type. The principal results of the paper are to characterize a class of typings as uniform approximations to an exact semantics, to extend Milner's theory of types to include types formed by coproduct construction, and to explicate typing as an (approximate) semantics for an equational theory.In developing a formal theory of types as multi-sorted algebras, the word is used to designate names used to distinguish various sets of objects that may constitute the domains of operators. Sorts are thus analogous to types in programming languages. However, the sort signatures given to operators of types do not themselves constitute a very richly descriptive language. Sort names can be formed into sequences, corresponding to product construction in an object domain, but the theory (multi-sorted Σ-algebras) does not seem to allow alternation sequences of sorts, corresponding to coproduct construction in an object domain. If this were possible, then sort signatures could actually fulfill the role of types. We shall see that alternation sequences in signatures arise naturally as a consequence of the semantics given to an equational theory.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567079", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard B.", + "last_name": "Kieburtz", + "institution": "Oregon Social Learning Center" + } + ], + "dblp_key": "conf/popl/Kieburtz83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567075", + "title": "Making Variables Abstract: An Equational Theory for Russell", + "abstract": "One of the fundamental notions of programming, and thus of programming languages, is the variable. Recently, the variable has come under attack. The proponents of \"functional programming\" have argued that variables are at the root of all our problems in programming. They claim that we must rid our languages of all manifestations of the \"vonNeumann bottleneck\" and learn to live in the changeless world of functional combinators.While we may not, believe all the claims of the functional programming advocates, there is evidence that the treatment of variables in most programming languages leaves much to be desired. In this paper we discuss how to make variables \"abstract\", i.e., how to introduce the notion of variable in to a language so that variables have reasonable mathematical properties. This paper includes:--- a discussion of language design principles that allow a more mathematical treatment of variables in programming language, and--- a description of an equational logic for the programming language Russell [Boehm80]. Although this logic follows much of the development of abstract data types (cf. [Guttag78]), it is novel in its treatment of a language in which expressions not only produce values but also can have effects. We discuss the over all structure of the logic and present in detail the rules particularly relevant to the semantics of variables. A complete presentation of the logic appears in [Demers82], and the rule numbers in this paper agree with the numbers used there.In the next section, we discuss the underlying language principles needed to make an equational specification of variables possible. In the sections that follow, we present a logic that does so for Russell.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567075", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Cornell University" + }, + { + "first_name": "James", + "last_name": "Donahue", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/DemersD83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567082", + "title": "How to Cook a Temporal Proof System for Your Pet Language", + "abstract": "An abstract temporal proof system is presented whose program-dependent part has a high-level interface with the programming language actually studied. Given a new language, it is sufficient to deline the interface notions of atomic transitions, justice, and fairness in order to obtain a full temporal proof system for this language. This construction is particularly useful for the analysis of concurrent systems. We illustrate the construction on the shared-variable model and on CSP. The generic proof system is shown to be relatively complete with respect to pure first-order temporal logic.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567082", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zohar", + "last_name": "Manna", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/popl/MannaP83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567076", + "title": "Transformational Programming - Applications to Algorithms and Systems", + "abstract": "Ten years ago Cheatham and Wegbreit [4] proposed a transformational program development methodology based on notions of top-down stepwise program refinement first expressed by Dijkstra [10] and Wirth [45]. A schema describing the process of this methodology is given in fig. 1. To develop a program by transformation, we first specify the program in as high a level of abstraction and as great a degree of clarity as our programming language admits. This high level problem statement program P is proved correct semimechanically according to some standard approach (see Flovd and Hoare [15, 21]), Next, using an interactive system equipped with a library of encoded transformations, each of which maps a correct program into another equivalent program, we select and apply transformations one at a time to successive versions of the program until we obtain a concrete, low level, effecient implementation version P'. The goals of transformational programming are to reduce programming labor, improve program reliability, and upgrade program performance. In order for labor to be reduced, the effort required to obtain P, prove it correct, and derive P' by transformation should be less than the effort required to code P from scratch, and also to debug it. Program reliability will be improved if P can be certified correct, and if each transformation preserves program meaning. Finally, program performance will be upgraded if transformations are directed towards increased efficiency.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567076", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Paige", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/popl/Paige83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567086", + "title": "Loops in Combinator-Based Compilers", + "abstract": "In our paper [Wand 82a], we introduced a paradigm for compilation based on combinators. A program from a source language is translated (via a semantic definition) to trees of combinators; the tree is simplified (via associative and distributive laws) to a linear, assembly-language-like format: the compiler writer's virtual machine operates by simulating a reduction sequence of the simplified tree. The correctness of these transformations follows from general results about the λ-calculus. The code produced by such n generator is always tree-like. In this paper, the method is extended to produce target code with explicit loops. This is done by re-introducing variables into the terms of the target language in a restricted way, along with a structured binding operator.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567086", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/Wand83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567074", + "title": "Practical Program Verification: Automatic Program Proving for Real-Time Embedded Software", + "abstract": "Despite the attractiveness of the concept, attempts to date to use proof of correctness techniques on production software have been generally unsuccessful. The obstacles encountered are not fundamental. We have implemented a proof of correctness system to be used for improving the realiability of certain small, real-time programs. It appears that many of the problems of past systems can be avoided.This work is supported by the Long Range Research Program of the Ford Motor Company, Dearborn, Michigan.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567074", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Nagle", + "institution": "" + }, + { + "first_name": "Scott C.", + "last_name": "Johnson", + "institution": "" + } + ], + "dblp_key": "conf/popl/NagleJ83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567093", + "title": "Mechanisms for Compile-Time Enforcement of Security", + "abstract": "This paper discusses features of a secure systems programming language designed and implemented at IBM's Watson Research Lab. Two features of the language design were instrumental in permitting security to be enforced with minimum run-time cost: (1) Language constructs (e.g. pointer variables) which could result in aliasing were removed from the programmer's direct control and replaced by higher level primitive types; and (2) traditional strong type checking was enhanced with typestate checking, a new mechanism in which the compiler guarantees that for all execution paths, the sequence of operations on each variable obeys a finite state grammar associated with that variable's type. Examples are given to illustrate the application of these mechanisms.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567093", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert E.", + "last_name": "Strom", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Strom83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567088", + "title": "Summarizing Graphs by Regular Expressions", + "abstract": "This paper shows how to rapidly determine the path relationships between k different elements of a graph (of the type primarily resulting from programs) in time proportional to k log k. Given the path relations between elements u,v, and w, it is easy to answer questions like \"is there a path from u to w?\" and \"is there a path from u to w which does not go through v?\" (The elements can be either nodes or edges.)This algorithm can be used in a wide variety of contexts. For example, in order to prove that whenever control reaches a point p, the last assignment of a value to a variable, v, has always been of the form v := c, where c is a certain constant, it is only necessary to know the path relations between the point p and all assignments to that variable.Ordinarily one is interested in the possible points, where a variable was assigned its current value (definition points), and at the points at which that value is used. Previously, all flow analysis algorithms would compute the definition points of all variables at all nodes in the graph, despite the fact that any given node may use only one of those variables.This algorithm may also be a generally useful graph algorithm. It can compute transitive closure more rapidly than the standard algorithm using the current best matrix multiplication algorithm on the kinds of graphs resulting from programs. The algorithm proceeds by preprocessing the graph, creating tables that can be used later to rapidly determine flow relationships between any sections of the program. In addition, small changes to the graph need only result in small changes to the tables. The algorithm is therefore suitable for incremental analysis.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567088", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark N.", + "last_name": "Wegman", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Wegman83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567084", + "title": "Incremental Data Flow Analysis", + "abstract": "In this paper we present ACINCF and ACINCB, incremental update algorithms for forward and backward data flow problems, which are based on a linear equations model of Allen/Cocke interval analysis [Allen 77, Ryder 82a]. We have studied their performance on a robust structured programming language L. Given a set of localized program changes in a program in L, we can identify a priori the nodes in its flow graph whose corresponding data flow equations will be affected by the changes. We can characterize these affected nodes by their corresponding program structures and their relation to the original change sites.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567084", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/popl/Ryder83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567092", + "title": "Incremental Polymorphic Type Checking in B", + "abstract": "The programming language B has been designed for personal computing. In B, variables need not be declared, nor formal parameters specified. Nevertheless, B is strongly typed. All type requirements can be checked statically. To signal type violations on the spot during editing, the computations can be organized so that local the source text require a modest amount of recomputation.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567092", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lambert", + "last_name": "Meertens", + "institution": "" + } + ], + "dblp_key": "conf/popl/Meertens83", + "venue": "popl", + "year": 1983 + }, + { + "paper_id": "10.1145/567067.567091", + "title": "On the Unification of Data and Program Abstraction in Ada", + "abstract": "Ada is rich in the variety of its abstraction mechanisms. It has both a data abstraction mechanism (packages with private data types) that supports a functional programming style and a program abstraction mechanism (generic program units) that supports an object-oriented program style. Tradeoffs between data and program abstraction are examined and it is pointed out that Ada discourages program abstraction because program units are not first-class objects. It is shown how program units could be made into first-class objects by introducing closures as values for functions and records with function components as values for packages. Further unification by allowing types to be first-class objects conflicts with the requirement of compile-time type invariance. The relaxation of this requirement in a manner that preserves type consistency is examined and leads to a notion of value for types as tuples of operations. It is suggested in the conclusion that our understanding of abstraction for object-oriented languages and of other language design, implementation, and environment issues will have progressed sufficiently by 1985 to warrant the design of a successor to Ada by the late 1980s.", + "date": "1983-01-01", + "link": "https://doi.org/10.1145/567067.567091", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Wegner", + "institution": "Brown University" + } + ], + "dblp_key": "conf/popl/Wegner83", + "venue": "popl", + "year": 1983 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1984.json b/data/pl_conferences/popl/1984.json new file mode 100644 index 0000000..5321bbf --- /dev/null +++ b/data/pl_conferences/popl/1984.json @@ -0,0 +1,655 @@ +[ + { + "paper_id": "10.1145/800017.800526", + "title": "The Global Storage Needs of a Subcomputation", + "abstract": "A defining characteristic of “functional” specifications is the absence of assignments: updates of tables and data structures are expressed by giving the relationship between the new and old values. An obvious implementation allocates separate space for new and old values and may consume a lot of storage. However, even when updates of attributes like symbol tables are expressed functionally, we would like to avoid making copies of the symbol table during attribute evaluation. In other words, if possible, the implementation should have a single global copy of the table that is updated using assignments. Since the value of the global copy changes during computation, the order of evaluation has to be chosen carefully. In this paper, we partition attributes into classes, the problem being to determine if there exists an evaluation order that allows each class to share a global storage area. The solution extends to handle symbol tables for block structured languages.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800526", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean-Claude", + "last_name": "Raoult", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Ravi", + "last_name": "Sethi", + "institution": "" + } + ], + "dblp_key": "conf/popl/RaoultS84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800529", + "title": "Coercion and Type Inference", + "abstract": "A simple semantic model of automatic coercion is proposed. This model is used to explain four rules for inferring polymorphic types and providing automatic coercions between types. With the addition of a fifth rule, the rules become semantically complete but the set of types associated with an expression may be undecidable. An efficient type checking algorithm based on the first four rules is presented. The algorithm is guaranteed to find a type whenever a type can be deduced using the four inference rules. The type checking algorithm may be modified so that calls to type conversion functions are inserted at compile time.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800529", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "" + } + ], + "dblp_key": "conf/popl/Mitchell84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800536", + "title": "The Semantics of Local Storage, or What Makes the Free-List Free?", + "abstract": "Denotational semantics for an ALGOL-like language with finite-mode procedures, blocks with local storage, and sharing (aliasing) is given by translating programs into an appropriately typed l-calculus. Procedures are entirely explained at a purely functional level - independent of the interpretation of program constructs - by continuous models for l-calculus. However, the usual (cpo) models are not adequate to model local storage allocation for blocks because storage overflow presents an apparent discontinuity. New domains of store models are offered to solve this problem.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800536", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph Y.", + "last_name": "Halpern", + "institution": "" + }, + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "" + }, + { + "first_name": "B. A.", + "last_name": "Trakhtenbrot", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/HalpernMT84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800538", + "title": "A Good Hoare Axiom System for an Algol-like Language", + "abstract": "Clarke has shown that it is impossible to obtain a relatively complete axiomatization of a block-structured programming language if it has features such as static scope, recursive procedure calls with procedure parameters, and global variables, provided that we take first-order logic as the underlying assertion language [Cl]. We show that if we take a more powerful assertion language, and hence a more powerful notion of expressiveness, such a complete axiomatization is possible. The crucial point is that we need to be able to express weakest preconditions of commands with free procedure parameters. The axioms presented here are natural and reflect the syntax of the programming language. Such an axiom system provides a tool for understanding how to reason about languages with powerful control features.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800538", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph Y.", + "last_name": "Halpern", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/Halpern84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800531", + "title": "Direct Implementation of Compiler Specifications or the Pascal P-code Compiler Revisited", + "abstract": "We have developed a complete formal specification of the translation semantics of the Pascal P-compiler. The specification is written as a semantic grammar (a variant of extended attribute grammars), and has been extensively tested and debugged with the aid of Lawrence Paulson's experimental semantics processor. The translation semantics models the operational aspects of compilation in detail. It is one-pass, embodying static semantic checking, address assignment, code generation, and a certain amount of code improvement. Our paper describes the development history of the project, compares the new compiler with the existing P-compiler, and discusses our positive experience with semantic grammars and Paulson's system.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800531", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Don", + "last_name": "Milos", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Uwe F.", + "last_name": "Pleban", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "George J.", + "last_name": "Loegel", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/popl/MilosPL84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800523", + "title": "A Combinator-Based Compiler for a Functional Language", + "abstract": "Article Free Access Share on A combinator-based compiler for a functional language Authors: Paul Hudak Yale University, Department of Computer Science Yale University, Department of Computer ScienceView Profile , David Kranz Yale University, Department of Computer Science Yale University, Department of Computer ScienceView Profile Authors Info & Claims POPL '84: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1984 Pages 122–132https://doi.org/10.1145/800017.800523Online:15 January 1984Publication History 24citation0DownloadsMetricsTotal Citations24Total Downloads0Last 12 Months0Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800523", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + }, + { + "first_name": "David", + "last_name": "Kranz", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/HudakK84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800530", + "title": "Editing by Example", + "abstract": "An editing by example system is an automatic program synthesis facility embedded in a text editor that can be used to solve repetitive text editing problems. The user provides the editor with a few examples of a text transformation. The system analyzes the examples and generalizes them into a program that can perform the transformation to the rest of the user's text.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800530", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Nix", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/Nix84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800518", + "title": "Stop Losing Sleep Over Incomplete Data Type Specifications", + "abstract": "We give an algorithm to test the completeness of definitions holding on the rewrite systems that they generate. At the opposite of existing techniques that are very restrictive (left-hand sides of definitions must be linear) or rather inefficient our solution is both powerful and efficient. Also, the algorithm that we give detects ambigous or/and incomplete definitions and can tell you why they are ambigous or/and incomplete. It applies too to definitions in presence of equations.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800518", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean Jacques", + "last_name": "Thiel", + "institution": "Centre de Recherche en Informatique" + } + ], + "dblp_key": "conf/popl/Thiel84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800524", + "title": "Treat - An Applicative Code Generator", + "abstract": "Treat is a special purpose language for use in compiler writing. A Treat program translates a graph into c-trees (the intermediate language of the pcc compiler) and uses the back end of the C compiler to generate code. Treat has been developed specifically for use in an AdaTM compiler. A Treat program consists of applicative transformation rules. Treat's distinctive aspects include triggering transformations during pattern matching, a context mechanism for dynamic binding and assignment in a language with lazy evaluation.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800524", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jerald S.", + "last_name": "Schwarz", + "institution": "" + }, + { + "first_name": "Dean", + "last_name": "Rubine", + "institution": "" + } + ], + "dblp_key": "conf/popl/SchwarzR84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800537", + "title": "On Relative Completeness of Programming Logics", + "abstract": "In this paper a generalization of a certain Lipton's theorem (see Lipton [5]) is presented. Namely, we show that for a wide class of programming languages the following holds: the set of all partial correctness assertions true in an expressive interpretation I is uniformly decidable (in I) in the theory of I iff the halting problem is decidable for finite interpretations. In the effect we show that such limitations as effectiveness or Herbrand definability of interpretation (they are relevant in the previous proofs) can be removed in the case of partial correctness.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800537", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michał", + "last_name": "Grabowski", + "institution": "University of Warsaw" + } + ], + "dblp_key": "conf/popl/Grabowski84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800521", + "title": "Constraining-Unification and the Programming Language Unicorn", + "abstract": "Up to this point direct implementations of axiomatic or equational specifications have been limited because the implementation mechanisms used are incapable of capturing the full semantics of the specifications. The programming language Unicorn was designed and implemented with the intention of exploring the full potential of programming with equations. Unicorn introduces a new language mechanism, called constraining-unification. When coupled with semantic unification, constraining-unification closely models the semantics of equational specifications thereby allowing for the implementation of a wider class of specifications. Unlike the language mechanisms of rewrite-rule and logic programming, constraining-unification is free of order dependencies. The same results are produced regardless of the order in which the axioms are stated. The use of viewpoints contributes to the flexibility of the Unicorn language. Preconditions for partial operations can be specified without added machinery.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800521", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert G.", + "last_name": "Bandes", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/Bandes84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800535", + "title": "Static Inference of Properties of Applicative Programs", + "abstract": "An applicative program denotes a function mapping values from some domain to some range. Abstract interpretation of applicative programs involves using the standard denotation to describe an abstract function from a “simplified” domain to a “simplified” range, such that computation of the abstract function is effective and yields some information, such as type information, about the standard denotation. We develop a general framework for a restricted class of abstract interpretations that deal with non-strict functions defined on non-flat domains. As a consequence, we can develop inference schemes for a large and useful class of functional programs, including functions defined on streams. We describe several practical problems and solve them using abstract interpretation. These include inferring minor signatures and relevant clauses of functions, which have arisen out of our work on a strongly-typed applicative language.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800535", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Prateek", + "last_name": "Mishra", + "institution": "University of Utah" + }, + { + "first_name": "Robert", + "last_name": "Keller", + "institution": "" + } + ], + "dblp_key": "conf/popl/MishraK84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800517", + "title": "Efficient Applicative Data Types", + "abstract": "Article Efficient applicative data types Share on Author: Eugene W. Myers Department of Computer Science, The University of Arizona, Tucson, Arizona Department of Computer Science, The University of Arizona, Tucson, ArizonaView Profile Authors Info & Claims POPL '84: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1984 Pages 66–75https://doi.org/10.1145/800017.800517Online:15 January 1984Publication History 46citation450DownloadsMetricsTotal Citations46Total Downloads450Last 12 Months18Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800517", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eugene W.", + "last_name": "Myers", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/Myers84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800540", + "title": "A Less Dynamic Memory Allocation Scheme for Algol-like Languages", + "abstract": "The conventional storage allocation scheme for block structured languages requires the allocation of stack space and the building of a display with each procedure call. This paper describes a technique for analyzing the call graph of a program in a block structured language that makes it possible to eliminate these operations from many call sequences, even in the presence of recursion.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800540", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas P.", + "last_name": "Murtagh", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/Murtagh84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800520", + "title": "Systems Programming in Concurrent Prolog", + "abstract": "Concurrent Prolog [28] combines the logic programming computation model with guarded-command indeterminacy and dataflow synchronization. It will form the basis of the Kernel Language [21] of the Parallel Inference Machine [36], planned by Japan's Fifth Generation Computers Project. This paper explores the feasibility of programming such a machine solely in Concurrent Prolog (in the absence of a lower-level programming language), by implementing in it a representative collection of systems programming problems.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800520", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ehud", + "last_name": "Shapiro", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/popl/Shapiro84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800515", + "title": "Generalized Fair Termination", + "abstract": "We present a generalization of the known fairness and equifairness notions, called @@@@-fairness, in three versions: unconditional, weak and strong. For each such version, we introduce a proof rule for the @@@@-fair termination induced by it, using well-foundedness and countable ordinals. Each such rule is proved to be sound and semantically complete. We suggest directions for further research.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800515", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nissim", + "last_name": "Francez", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "" + } + ], + "dblp_key": "conf/popl/FrancezK84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800519", + "title": "Completion of a Set of Rules Modulo a Set of Equations", + "abstract": "Article Completion of a set of rules modulo a set of equations Share on Authors: Jean-Pierre Jouannaud CRIN, BP 239, 54506 Vandoeuvre les Nancy, CEDEX (FRENCE) CRIN, BP 239, 54506 Vandoeuvre les Nancy, CEDEX (FRENCE)View Profile , Helene Kirchner CRIN, BP 239, 54506 Vandoeuvre les Nancy, CEDEX (FRENCE) CRIN, BP 239, 54506 Vandoeuvre les Nancy, CEDEX (FRENCE)View Profile Authors Info & Claims POPL '84: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1984 Pages 83–92https://doi.org/10.1145/800017.800519Online:15 January 1984Publication History 41citation373DownloadsMetricsTotal Citations41Total Downloads373Last 12 Months8Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800519", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean-Pierre", + "last_name": "Jouannaud", + "institution": "Centre de Recherche en Automatique de Nancy" + }, + { + "first_name": "Claude", + "last_name": "Kirchner", + "institution": "Centre de Recherche en Automatique de Nancy" + } + ], + "dblp_key": "conf/popl/JouannaudK84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800542", + "title": "Efficient Implementation of the Smalltalk-80 System", + "abstract": "The Smalltalk-80* programming language includes dynamic storage allocation, full upward funargs, and universally polymorphic procedures; the Smalltalk-80 programming system features interactive execution with incremental compilation, and implementation portability. These features of modern programming systems are among the most difficult to implement efficiently, even individually. A new implementation of the Smalltalk-80 system, hosted on a small microprocessor-based computer, achieves high performance while retaining complete (object code) compatibility with existing implementations. This paper discusses the most significant optimization techniques developed over the course of the project, many of which are applicable to other languages. The key idea is to represent certain runtime state (both code and data) in more than one form, and to convert between forms when needed.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800542", + "conference_name": "POPL", + "authors": [ + { + "first_name": "L. Peter", + "last_name": "Deutsch", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Allan M.", + "last_name": "Schiffman", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/popl/DeutschS84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800522", + "title": "Implementation of an Interpreter for Abstract Equations", + "abstract": "This paper summarizes a project, introduced in [HO79, HO82b], whose goal is the implementation of a useful interpreter for abstract equations that is absolutely faithful to the logical semantics of equations. The Interpreter was first distributed to Berkeley UNIX VAX sites in May, 1983. The main novelties of the interpreter are", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800522", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christoph M.", + "last_name": "Hoffmann", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Michael J.", + "last_name": "O’Donnell", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/popl/HoffmannO84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800528", + "title": "An Ideal Model for Recursive Polymorphic Types", + "abstract": "Article Free Access Share on An ideal model for recursive polymorphic types Authors: David MacQueen Bell Laboratories, Murray Hill, New Jersey Bell Laboratories, Murray Hill, New JerseyView Profile , Gordon Plotkin Department of Computer Science, University of Edinburgh, Edinburgh EH9 3J2 Department of Computer Science, University of Edinburgh, Edinburgh EH9 3J2View Profile , Ravi Sethi Bell Laboratories, Murray Hill, New Jersey Bell Laboratories, Murray Hill, New JerseyView Profile Authors Info & Claims POPL '84: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1984 Pages 165–174https://doi.org/10.1145/800017.800528Online:15 January 1984Publication History 79citation712DownloadsMetricsTotal Citations79Total Downloads712Last 12 Months48Last 6 weeks7 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800528", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "MacQueen", + "institution": "" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" + }, + { + "first_name": "Ravi", + "last_name": "Sethi", + "institution": "" + } + ], + "dblp_key": "conf/popl/MacQueenPS84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800533", + "title": "Applicative Programming and Digital Design", + "abstract": "This paper adapts applicative programming techniques to the synthesis of mynchronaua system descriptions. It presents a unifying perspective on hardware and software engineering and shows that a functional design paradigm is suitable in both realms. Established techniques for program synthesis are extended to yield hardware descriptions. This work stems from research in general programming methods for systems. Synchronous systems are a valuable special case. They are a preferred basis for hardware design: logical synchrony makes circuits easier to conceptualize, and physical synchrony makes them easier to test. Applicative notation is well suited to the description of digital circuits because it has an immediate interpretation in terms of wiring. Digital circuits are a reasonable target for synthesis because they are functional in character.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800533", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steven", + "last_name": "Johnson", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/Johnson84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800534", + "title": "Pattern Driven Lazy Reduction: A Unifying Evaluation Mechanism for Functional and Logic Programs", + "abstract": "A novel lazy evaluation mechanism, pattern-driven lazy reduction, is developed that serves as a unifying evaluation mechanism for both functional and logic programs. The reduction of a function call can be viewed as “semantically” unifying the function call with the left hand side of a defining equation, and applying the unifier to the right hand side. Lazy reduction is achieved by the pattern which the function call matches against. Function reductions are actually “driven” by patterns in this sense. It is shown that this evaluation mechanism works well for both functional programs and logic programs that involve “executable” functions. As a result, logic programs can be enhanced with (1) the availability of a functional computing environment where there is no notion of backtracking, thus alleviating the degree of control difficulties typically encountered in logic programs, and (2) the ability to terminate “infinite computations” without the introduction of complex control issues at the user-level. On the other hand, functional programs can be equipped with the power of logic programming languages, e.g., Prolog.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800534", + "conference_name": "POPL", + "authors": [ + { + "first_name": "P. A.", + "last_name": "Subrahmanyam", + "institution": "University of Utah" + }, + { + "first_name": "J-H.", + "last_name": "You", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/SubrahmanyamY84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800512", + "title": "Grids: A New Program Structuring Mechanism Based on Layered Graphs", + "abstract": "Article Grids: A new program structuring mechanism based on layered graphs Share on Author: Harold L. Ossher Computer Science Department, Stanford University, Stanford, CA Computer Science Department, Stanford University, Stanford, CAView Profile Authors Info & Claims POPL '84: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1984 Pages 11–22https://doi.org/10.1145/800017.800512Online:15 January 1984Publication History 16citation269DownloadsMetricsTotal Citations16Total Downloads269Last 12 Months5Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800512", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harold", + "last_name": "Ossher", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Ossher84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800516", + "title": "Temporal Verification of Carrier-Sense Local Area Network Protocols", + "abstract": "We examine local area network protocols and verify the correctness of two representative algorithms using temporal logic. We introduce an interval temporal logic that allows us to make assertions of the form “in the next k units, X holds.” This logic encodes intuitive arguments about contention protocols quite directly. We present two proofs of an Ethernet-like contention protocol, one using the interval temporal logic and one using classical temporal logic. We also verify a contention-free protocol using an invariant that seems to have wide applicability for such protocols.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800516", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dennis", + "last_name": "Shasha", + "institution": "Harvard University" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Harvard University" + }, + { + "first_name": "William", + "last_name": "Ewald", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/ShashaPE84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800527", + "title": "A Types-as-Sets Semantics for Milner-Style Polymorphism", + "abstract": "In this paper we present a semantics for Milner-style polymorphism in which types are sets. The basic picture is that our programs are actually terms in a typed λ-calculus, in which the type information can be safely deleted from the concrete syntax. In order to allow for common programming constructs, we allow reflexive or infinite types, and we also allow opaque types, which have private representations.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800527", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/Wand84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800514", + "title": "Interactive Proof Checking", + "abstract": "Knowledge of logical inference rules allows a specialized proof editor to provide a user with feedback about errors in a proof under development. Providing such feedback involves checking a collection of constraints on the strings of the proof language. Because attribute grammars allow such constraints to be expressed in a modular, declarative fashion, they are a suitable underlying formalism for a proof-checking editor. This paper discusses how an attribute grammar can be used in an editor for partial-correctness program proofs in Hoare-style logic, where verification conditions are proved using the sequent calculus.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800514", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "Cornell University" + }, + { + "first_name": "Bowen", + "last_name": "Alpern", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/RepsA84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800539", + "title": "A Hierarchical Basis for Reordering Transformations", + "abstract": "In this paper, we propose a new dependence baaed program representation.This representation is the union of two previously separate concepts: loop carried dependence and hierarchical abstraction.The resulting form has the property that all information necessary to reorder the set of all executions of the statements contained in a given loop exists in the representation of that loop.Thus, this representation provides an ideal basis for reordering transformations such as vectorisation and loop fusion.As evidence of this, we give efficient algorithms for these two transformations based on this representation.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800539", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joe", + "last_name": "Warren", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Warren84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800525", + "title": "Inverse Currying Transformation on Attribute Grammars", + "abstract": "Inverse currying transformation of an attribute grammar moves a context condition to places in the grammar where the violation of the condition can be detected as soon as the semantic information used in the condition is computed. It thereby takes into account the evaluation order chosen for the attribute grammar. Inverse currying transformations can be used to enhance context sensitive parsing using predicates on attributes, to eliminate sources of backtrack when parsing according to ambiguous grammars, and to facilitate semantics-supported error correction.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800525", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Reinhard", + "last_name": "Wilhelm", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/Wilhelm84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800541", + "title": "Creating Efficient Systems for Object-Oriented Languages", + "abstract": "Increasingly computer science research has been done using workstations with high-resolution bitmap display systems. Smalltalk-80↑ is a very attractive programming language for such computation environments, since it has very sophisticated graphical systems and programming environments. Unfortunately there are still very few computer systems on which Smalltalk-80 can run with satisfactory speed, and furthermore they are quite expensive. In order to make Smalltalk-80 accessible to a large group of people at low cost,. we have developed compiler techniques useful to generate efficient code for standard register machines such as MC68000. We have also extended Smalltalk-80 to include type expressions, which allow compilers to generate efficient code", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800541", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norihisa", + "last_name": "Suzuki", + "institution": "The University of Tokyo" + }, + { + "first_name": "Minoru", + "last_name": "Terada", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/SuzukiT84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800532", + "title": "Paragon: Novel Uses of Type Hierarchies for Data Abstraction", + "abstract": "Article Free Access Share on Paragon: Novel uses of type hierarchies for data abstraction Author: Mark Sherman Department of Math. and Computer Science, Dartmouth College, Hanover, NH Department of Math. and Computer Science, Dartmouth College, Hanover, NHView Profile Authors Info & Claims POPL '84: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1984 Pages 208–217https://doi.org/10.1145/800017.800532Published:15 January 1984Publication History 2citation195DownloadsMetricsTotal Citations2Total Downloads195Last 12 Months12Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800532", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark", + "last_name": "Sherman", + "institution": "Dartmouth College" + } + ], + "dblp_key": "conf/popl/Sherman84", + "venue": "popl", + "year": 1984 + }, + { + "paper_id": "10.1145/800017.800511", + "title": "Expressional Loops", + "abstract": "This paper proposes an expressional loop notation (XLoop) based on the ideas described in [16,17] which makes it practical to express loops as compositions of functions. The primary benefit of XLoop is that it brings the powerful metaphor of expressions and decomposability to bear on the domain of loops. Wherever this metaphor can be applied, it makes algorithms much easier to construct, understand, and modify.", + "date": "1984-01-01", + "link": "https://doi.org/10.1145/800017.800511", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard C.", + "last_name": "Waters", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Waters84", + "venue": "popl", + "year": 1984 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1985.json b/data/pl_conferences/popl/1985.json new file mode 100644 index 0000000..de9f65a --- /dev/null +++ b/data/pl_conferences/popl/1985.json @@ -0,0 +1,702 @@ +[ + { + "paper_id": "10.1145/318593.318654", + "title": "Constraining Control", + "abstract": "Continuations, when available an first-claae objects, pmvide a general control abstraction in programming languaga. They liberate the programmer from specific control rtructuns, increasing programming language extemibility. Such continuations may be extended by embedding them in functional objects. Thir technique L fimt used to nrtore a fluid environment when a continuation object ir invoked. We then consider techniquea for constraining the power of continuations in the interest of security and efficiency. Do. main mechanisma, which create dynamic barrien for enclosing control, are implemented using fluids. Domti am then used to implement an unwind-protect facility in the presence of first-class continuations. Finally, we demonstrate two mechanisma, wind-unwind and dynamic-rind, that generalire unwind-protect.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318654", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Christopher T.", + "last_name": "Haynes", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/FriedmanH85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318642", + "title": "High-Level Language Facilities for Low-Level Services", + "abstract": "EZ is a language-based programming environment that offers the services provided separately by programming languages and operating systems in traditional environments. These services are provided as facilities of a high-level string processing language with a 'persistent' memory in which values exist indefinitely or until changed. In EZ, strings and associative tables provide traditional file and directory services. This paper concentrates on the use of EZ procedures and their activations, which, like other values, have indefinite lifetimes. In EZ, the low-level aspects of procedure execution, such as activation record creation, references to local variables, and access to state information, are accessible via high-level language constructs. As a result, traditionally distinct services can be provided by a single service in the EZ environment. Furthermore, such services can be written in EZ itself. An editor/debugger that illustrates the details of this approach is described.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318642", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "University of Arizona" + }, + { + "first_name": "David R.", + "last_name": "Hanson", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/FraserH85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318634", + "title": "A Greedy Approach to Incremental Code Generation", + "abstract": "The PSEP System represents a novel approach to incremental compilation for block structured languages. PSEP implements a very fine grain, “greedy” approach as a highly concurrent system of two processes: an editor and a code generator. The design allows the two processes to execute without locking their shared data objects, utilizing semantic information about the concurrent system to guarantee the consistency of the shared objects. This design is compared with the more common “demand” approach to incremental compilation.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318634", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ray", + "last_name": "Ford", + "institution": "University of Iowa" + }, + { + "first_name": "Duangkaew", + "last_name": "Sawamiphakdi", + "institution": "University of Iowa" + } + ], + "dblp_key": "conf/popl/FordS85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318660", + "title": "The Aggregate Update Problem in Functional Programming Systems", + "abstract": "We discuss the problem of efficiently implementing aggregates (contiguous data structures) such as arrays in functional programming systems. Simple changes to an aggregate conceptually involve making a new copy of the aggregate differing only in the changed component, but such copying can be expensive. We present both static and dynamic techniques for avoiding this copying, and argue that they allow one to program functionally using aggregates, without loss of efficiency over conventional programs.1", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318660", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + }, + { + "first_name": "Adrienne", + "last_name": "Bloss", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/HudakB85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318620", + "title": "Modalities for Model Checking: Branching Time Strikes Back", + "abstract": "Article Modalities for model checking (extended abstract): branching time strikes back Share on Authors: E. Allen Emerson Department of Computer Sciences, University of Texas at Austin, Austin, Texas Department of Computer Sciences, University of Texas at Austin, Austin, TexasView Profile , Chin-Laung Lei Department of Computer Sciences, University of Texas at Austin, Austin, Texas Department of Computer Sciences, University of Texas at Austin, Austin, TexasView Profile Authors Info & Claims POPL '85: Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1985 Pages 84–96https://doi.org/10.1145/318593.318620Online:01 January 1985Publication History 110citation612DownloadsMetricsTotal Citations110Total Downloads612Last 12 Months13Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318620", + "conference_name": "POPL", + "authors": [ + { + "first_name": "E. Allen", + "last_name": "Emerson", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Chin‐Laung", + "last_name": "Lei", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/EmersonL85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318656", + "title": "Closurize and Concentrate", + "abstract": "This paper considers current solutions to the problem of representing multiple environments, and uses the results to develop a new model. The motivation is partly a consequence of the renewed interest in the more sophisticated forms of access and control [Sussman & Steele 1978], [Smith 1983]. [Friedman et al. 1984], and partly because the problem identified by Moses [1970] has not, as yet, been satisfactorily resolved. The new model is derived from a consideration of the semantics of identifier binding interrogation. The implementation itself rests on the existence of an environment labeling function which solves a variant of a well known graph theory problem called nearest common ancestor. We describe a suitable implementation of such a function. The new scheme has been implemented in two different LISP systems (Cambridge LISP and Portable Standard LISP), and a third (LISP/VM) is under consideration. In addition, pure deep binding and full shallow binding have both been implemented on top the same base system (Cambridge LISP). Thus it is possible to collect comparisons of the relative efficiencies running simple (stack behavior) programs and complex (multiple context) programs. Some timing results for various tests are given in the final section.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318656", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julián", + "last_name": "Padget", + "institution": "University of Bath" + }, + { + "first_name": "John", + "last_name": "Fitch", + "institution": "University of Bath" + } + ], + "dblp_key": "conf/popl/PadgetF85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318638", + "title": "Compiling Path Expressions into VLSI Circuits", + "abstract": "Path expressions were originally proposed by Campbell and Habermann [1] as a mechanism for process synchronization at the monitor level in software. Not unexpectedly, they also provide a useful notation for specifying the behavior of asynchronous circuits. Motivated by this potential application we investigate how to directly translate path expressions into hardware.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318638", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Anantharaman", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "E. M.", + "last_name": "Clarke", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Michael J.", + "last_name": "Foster", + "institution": "Columbia University" + }, + { + "first_name": "Bud", + "last_name": "Mishra", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/AnantharamanCFM85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318640", + "title": "Constraints: A Uniform Approach to Aliasing and Typing", + "abstract": "A constraint is a relation among program variables that is maintained throughout execution. Type declarations and a very general form of aliasing can be expressed as constraints. A proof system based upon the interpretation of Hoare triples as temporal logic formulas is given for reasoning about programs with constraints. The proof system is shown to be sound and relatively complete, and example program proofs are given.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318640", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leslie", + "last_name": "Lamport", + "institution": "SRI International" + }, + { + "first_name": "Fred B.", + "last_name": "Schneider", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/LamportS85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318663", + "title": "Efficient Tree Pattern Matching: An Aid to Code Generation", + "abstract": "We show that tree pattern matching has significant advantages in the specification and implementation of efficient code generators. We present a top-down tree-matching algorithm that is particularly well suited to code generation applications. Finally, we present a new back-end language that incorporates tree pattern matching with dynamic programming into a uniform framework for the specification and implementation of efficient code generators.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318663", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alfred V.", + "last_name": "Aho", + "institution": "Nokia (United States)" + }, + { + "first_name": "Mahadevan", + "last_name": "Ganapathi", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/AhoG85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318644", + "title": "Matchmaker: An Interface Specification Language for Distributed Processing", + "abstract": "Matchmaker, a language used to specify and automate the generation of interprocess communication interfaces, is presented. The process of and reasons for the evolution of Matchmaker are described. Performance and usage statistics are presented. Comparisons are made between Matchmaker and other related systems. Possible future directions are examined.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318644", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael B.", + "last_name": "Jones", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Richard F.", + "last_name": "Rashid", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Mary R.", + "last_name": "Thompson", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/JonesRT85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318616", + "title": "What It Means for a Concurrent Program to Satisfy a Specification: Why No One Has Specified Priority", + "abstract": "The formal correspondence between an implementation and its specification is examined. It is shown that existing specifications that claim to describe priority are either vacuous or else too restrictive to be implemented in some reasonable situations. This is illustrated with a precisely formulated problem of specifying a first-come-first-served mutual exclusion algorithm, which it is claimed cannot be solved by existing methods.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318616", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leslie", + "last_name": "Lamport", + "institution": "SRI International" + } + ], + "dblp_key": "conf/popl/Lamport85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318658", + "title": "Analyzing Aliases of Reference Formal Parameters", + "abstract": "Compilers for languages with call-by-reference formal parameters must deal with aliases arising from the renaming effects at call sites. This paper presents a set of techniques for analyzing aliasing patterns. The analysis is divided into detecting the introduction of aliases and tracking their propagation. The algorithm for introduction analysis is simple enough to be performed in a structured editor or parser. A data flow analysis framework is given for the propagation problem, making it possible to solve using standard algorithms from global data flow analysis. Several optimizations are shown which can shrink the size of the problem, and extensions are given to handle ALGOL-style name scoping. Finally, this technique is compared to an alternative implementation strategy and an approximate technique.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318658", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/Cooper85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318606", + "title": "Abstract Types Have Existential Type", + "abstract": "Article Free Access Share on Abstract types have existential types Authors: John C. Mitchell AT&T Bell Laboratories, Murray Hill, New Jersey AT&T Bell Laboratories, Murray Hill, New JerseyView Profile , Gordon D. Plotkin Department of Computer Science, University of Edinburgh, Edinburgh EH9 3J2 Department of Computer Science, University of Edinburgh, Edinburgh EH9 3J2View Profile Authors Info & Claims POPL '85: Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1985 Pages 37–51https://doi.org/10.1145/318593.318606Published:01 January 1985Publication History 75citation402DownloadsMetricsTotal Citations75Total Downloads402Last 12 Months31Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318606", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Nokia (United States)" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/MitchellP85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318622", + "title": "Checking That Finite State Concurrent Programs Satisfy Their Linear Specification", + "abstract": "We present an algorithm for checking satisfiability of a linear time temporal logic formula over a finite state concurrent program. The running time of the algorithm is exponential in the size of the formula but linear in the size of the checked program. The algorithm yields also a formal proof in case the formula is valid over the program. The algorithm has four versions that check satisfiability by unrestricted, impartial, just and fair computations of the given program.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318622", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Orna", + "last_name": "Lichtenstein", + "institution": "Tel Aviv University" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/popl/LichtensteinP85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318636", + "title": "On Linearizing Parallel Code", + "abstract": "We consider the problem of generating sequential code for programs written in a language which contains a Multiple GOTO operator, predicates and statements. This problem arises when compiling a parallel intermediate form (such as the PDG [3,4]) to run on a sequential machine; in a source-to-source FORTRAN translator when vectorization of a loop has failed; and when compiling logic designs written in a parallel design language for simulation on a sequential machine. It is easy to generate sequential code for this sort of parallel program if one allows either duplication of code or the insertion of guard variables at merge points; in fact, it is in general impossible without this addition. However, for a large class of parallel programs (such as those originally arising from sequential programs, even after some optimizations have been applied) it is possible to generate sequential code without duplication or the addition of guard variables. In this paper we present an efficient algorithm which will generate sequential code from a parallel program without duplication or additional guard variables for a large class of parallel programs.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318636", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeanne", + "last_name": "Ferrante", + "institution": "IBM (United States)" + }, + { + "first_name": "Mary E.", + "last_name": "Mace", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/FerranteM85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318629", + "title": "Incremental Compilation of Locally Optimized Code", + "abstract": "Although optimizing compilers have successfully been used to reduce the size and running times of compiled programs, present incremental compilers only support the incremental update of unoptimized code. In this work, we extend the notion of incremental compilation to include optimized code. Techniques to incrementally compile locally optimized code, given intermediate code modifications are developed using a program representation based on flow graphs and dags. A model is designed to represent both unoptimized and optimized code and to maintain an optimizing history. Changes to the optimized code which either destroy optimizations or create conditions for further optimizations are incorporated into the model and the optimized code without recompiling unaffected optimizations.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318629", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lori", + "last_name": "Pollock", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Mary Lou", + "last_name": "Soffa", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/popl/PollockS85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318610", + "title": "Principles of OBJ2", + "abstract": "Article Principles of OBJ2 Share on Authors: Kokichi Futatsugi Electrotechnical Laboratory, 1-1-4 Umezono, Sakura, Niibari, Ibaraki 305, Japan Electrotechnical Laboratory, 1-1-4 Umezono, Sakura, Niibari, Ibaraki 305, JapanView Profile , Joseph A. Goguen SRI International, Menlo Park CA and Center for the Study of Language and Information, Stanford University SRI International, Menlo Park CA and Center for the Study of Language and Information, Stanford UniversityView Profile , Jean-Pierre Jouannaud CRIN, Campus Scientifique, BP 239, 54506 Vandoeuvre-les-Nancy, Cedex, France CRIN, Campus Scientifique, BP 239, 54506 Vandoeuvre-les-Nancy, Cedex, FranceView Profile , José Meseguer SRI International, Menlo Park CA and Center for the Study of Language and Information, Stanford Universit SRI International, Menlo Park CA and Center for the Study of Language and Information, Stanford UniversitView Profile Authors Info & Claims POPL '85: Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1985 Pages 52–66https://doi.org/10.1145/318593.318610Online:01 January 1985Publication History 308citation447DownloadsMetricsTotal Citations308Total Downloads447Last 12 Months14Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318610", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kokichi", + "last_name": "Futatsugi", + "institution": "" + }, + { + "first_name": "Joseph A.", + "last_name": "Goguen", + "institution": "SRI International" + }, + { + "first_name": "Jean-Pierre", + "last_name": "Jouannaud", + "institution": "" + }, + { + "first_name": "José", + "last_name": "Meseguer", + "institution": "Menlo School" + } + ], + "dblp_key": "conf/popl/FutatsugiGJM85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318604", + "title": "Types as Intervals", + "abstract": "To accommodate polymorphic data types and operations, several computer scientists--most notably MacQueen, Plotkin, and Sethi--have proposed formalizing types as ideals. Although this approach is intuitively appealing, the resulting type system is both complex and restrictive because the type constructor that creates function types is not monotonic, and hence not computable. As a result, types cannot be treated as data values, precluding the formalization of type constructors and polymorphic program modules (where types are values) as higher order computable functions. Moreover, recursive definitions of new types do not necessarily have solutions.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318604", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/Cartwright85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318661", + "title": "Semantics-Directed Code Generation", + "abstract": "The intermediate representations (IR) used by most compilers have an operational semantics. The nodes in the graph (or tree, or quad-code sequence) have an interpretation as the operation codes of some abstract machine. A denotational semantics, in which each node in the IR graph has a static meaning, can lead to a clean interface between the front and back ends of the compiler. Furthermore, it is possible to concisely specify a code generator to translate the denotational representation into machine code. Combined with recent work allowing the denotational specification of front ends to translate the input language into the IR, a complete compiler with a well-defined semantics may be generated. Using this technique, compilers have been written for (most of) Pascal and C which, although they compile slowly, produce fairly good machine code. July 25, - 1 - 1 1. Introduction The intermediate representations (IR) used by most compilers have an operational semantics. The nodes in the gra...", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318661", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Laboratoire d'Informatique de Paris-Nord" + } + ], + "dblp_key": "conf/popl/Appel85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318662", + "title": "Optimal Scheduling of Arithmetic Operations in Parallel with Memory Accesses", + "abstract": "We propose a new machine model in which load operations can be performed in parallel with arithmetic operations by two separate functional units. For this model, the evaluation of expression trees is considered. An efficient algorithm to produce an optimal order of evaluation is described and analyzed. For a tree with n vertices the algorithm runs in time Ο(n log2n). If the arithmetic operations have at most two arguments, the complexity goes down to Ο(n logn).", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318662", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Bernstein", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Ron Y.", + "last_name": "Pinter", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Michael", + "last_name": "Rodeh", + "institution": "IBM Research - Haifa" + } + ], + "dblp_key": "conf/popl/BernsteinPR85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318627", + "title": "A Meta-Language and System for Nonlocal Incremental Attribute Evaluation in Language-Based Editors", + "abstract": "Article Free Access Share on A meta-language and system for nonlocal incremental attribute evaluation in language-based editors Authors: Gregory F. Johnson Cornell University Cornell UniversityView Profile , C. N. Fischer U. of Wisconsin - Madison U. of Wisconsin - MadisonView Profile Authors Info & Claims POPL '85: Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1985Pages 141–151https://doi.org/10.1145/318593.318627Published:01 January 1985Publication History 42citation149DownloadsMetricsTotal Citations42Total Downloads149Last 12 Months14Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Publisher SiteeReaderPDF", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318627", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gregory F.", + "last_name": "Johnson", + "institution": "Cornell University" + }, + { + "first_name": "Charles N.", + "last_name": "Fischer", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/JohnsonF85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318657", + "title": "Functional Programming and the Logical Variable", + "abstract": "Logic programming offers a variety of computational effects which go beyond those customarily found in functional programming languages. Among these effects is the notion of the “logical variable.” i.e. a value determined by the intersection of constraints, rather than by direct binding. We argue that this concept is “separable” from logic programming, and can sensibly be incorporated into existing functional languages. Moreover, this extension appears to significantly widen the range of problems which can efficiently be addressed in function form, albeit at some loss of conceptual purity. In particular, a form of side-effects arises under this extension, since a function invocation can exert constraints on variables shared with other function invocations. Nevertheless, we demonstrate that determinacy can be retained, even under parallel execution. The graph reduction language FGL is used for this demonstration, by being extended to a language FGL+LV permitting formal parameter expressions, with variables occurring therein bound by unification. The determinacy argument is based on a novel dataflow-like rendering of unification. In addition the complete partial order employed in this proof is unusual in its explicit representation of demand, a necessity given the “benign” side-effects that arise. An implementation technique is suggested, suitable for reduction architectures.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318657", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gary", + "last_name": "Lindstrom", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/Lindstrom85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318623", + "title": "Denotational Semantics and Rewrite Rules for FP", + "abstract": "We consider languages whose operational semantics is given by a set of rewrite rules. For such languages, it is important to be able to determine that there are enough rules to completely reduce all meaningful expressions, but not so many that the system of rules is inconsistent. We develop a formal framework in which to give a precise treatment of these soundness and completeness issues. We believe our approach to be novel in that we make heavy use of denotational semantics in our proof of completeness. The particular language for which we answer these questions is an extended version of the functional programming language FP; however the applicability of these techniques extends beyond the realm of FP rewriting systems.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318623", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph Y.", + "last_name": "Halpern", + "institution": "IBM (United States)" + }, + { + "first_name": "John H.", + "last_name": "Williams", + "institution": "IBM (United States)" + }, + { + "first_name": "Edward L.", + "last_name": "Wimmers", + "institution": "IBM (United States)" + }, + { + "first_name": "Timothy", + "last_name": "Winkler", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/HalpernWWW85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318614", + "title": "Program Specification and Development in Standard ML", + "abstract": "An attempt is made to apply ideas about algebraic specification in the context of a programming language. Standard ML with modules is extended by allowing axioms in module interface specifications and in place of code. The resulting specification language, called Extended ML, is given a semantics based on the primitive specification-building operations of the kernel algebraic specification language ASL. Extended ML provides a framework for the formal development of programs from specifications by stepwise refinement, which is illustrated by means of a simple example. From its semantic basis Extended ML inherits complete independence from the logical system (institution) used to write specifications. This allows different styles of specification as well as different programming languages to be accommodated.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318614", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Donald", + "last_name": "Sannella", + "institution": "University of Edinburgh" + }, + { + "first_name": "Andrzej", + "last_name": "Tarlecki", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/SannellaT85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318624", + "title": "A Model and Temporal Proof System for Networks of Processes", + "abstract": "A model and a sound and complete proof system for networks of processes in which component processes communicate exclusively through messages is given. The model, an extension of the trace model, can describe both synchronous and asynchronous networks. The proof system uses temporal-logic assertions on sequences of observations — a generalization of traces. The use of observations (traces) makes the proof system simple, compositional and modular, since internal details can be hidden. The expressive power of temporal logic makes it possible to prove temporal properties (safety, liveness, precedence, etc.) in the system. The proof system is language-independent and works for both synchronous and asynchronous networks.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318624", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Van", + "last_name": "Nguyen", + "institution": "Cornell University" + }, + { + "first_name": "David", + "last_name": "Gries", + "institution": "Cornell University" + }, + { + "first_name": "Susan", + "last_name": "Owicki", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/NguyenGO85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318659", + "title": "Constant Propagation with Conditional Branches", + "abstract": "Constant propagation is a well-known global flow analysis problem. The goal of constant propagation is to discover values that are constant on all possible executions of a program and to propagate these constant values as far forward through the program as possible. Expressions whose operands are all constants can be evaluated at compile time and the results propagated further. Using the algorithms presented in this paper can produce smaller and faster compiled programs. The same algorithms can be used for other kinds of analyses (e.g., type determina-tion). We present four algorithms in this paper, all conservative in the sense that all constants may not be found, but each constant found is constant over all possible executions of the program. These algorithms are among the simplest, fastest, and most powerful global constant propagation algorithms known. We also present a new algorithm that performs a form of interprocedural data flow analysis in which aliasing information is gathered in conjunction with constant propagation. Several variants of this algorithm are considered.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318659", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark N.", + "last_name": "Wegman", + "institution": "IBM (United States)" + }, + { + "first_name": "F. Kenneth", + "last_name": "Zadeck", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/WegmanZ85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318648", + "title": "Smart Recompilation", + "abstract": "With current compiler technology, changing a single line in a large software system may trigger massive recompilations. If the change occurs in a file with shared definitions, all compilation units depending upon that file must be recompiled to assure consistency. However, many of those recompilations may be redundant, because the change may actually affect only a small fraction of the overall system.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318648", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Walter F.", + "last_name": "Tichy", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Mark C.", + "last_name": "Baker", + "institution": "" + } + ], + "dblp_key": "conf/popl/TichyB85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318625", + "title": "Logical and Mathematical Reasoning about Imperative Programs", + "abstract": "Logical and mathemlicnl reasoning ahout impcrdtive programs.'", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318625", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniël", + "last_name": "Leivant", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Leivant85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318603", + "title": "Declaration-Free Type Checking", + "abstract": "Conventional Milner-style polymorphic type checkers automatically infer types of functions and simple composite objects such as tuples. Types of recursive data structures (e.g. lists) have to be defined by the programmer through an abstract data type definition. In this paper, we show how abstract data types, involving type union and recursion, can be automatically inferred by a type checker. The language for describing such types is that of regular trees, a generalization of regular expressions to denote sets of tree structured terms. Inference of these types is reducible to the problem of solving simultaneous inclusion inequations over regular trees. We present algorithms to solve such inequations. Using these techniques, programs without any type definitions and type annotations for functions can be type checked.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318603", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Prateek", + "last_name": "Mishra", + "institution": "University of Utah" + }, + { + "first_name": "Uday S.", + "last_name": "Reddy", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/MishraR85", + "venue": "popl", + "year": 1985 + }, + { + "paper_id": "10.1145/318593.318602", + "title": "Embedding Type Structure in Semantics", + "abstract": "We show how a programming language designer may embed the type structure of a programming language in the more robust type structure of the typed lambda calculus. This is done by translating programs of the language into terms of the typed lambda calculus. Our translation, however, does not always yield a well-typed lambda term. Programs whose translations are not well-typed are considered meaningless, that is, ill-typed. We give a conditionally type-correct semantics for a simple language with continuation semantics. We provide a set of static type-checking rules for our source language, and prove that they are sound and complete: that is, a program passes the typing rules if and only if its translation is well-typed. This proves the correctness of our static semantics relative to the well-established typing rules of the typed lambda-calculus.", + "date": "1985-01-01", + "link": "https://doi.org/10.1145/318593.318602", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/Wand85", + "venue": "popl", + "year": 1985 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1986.json b/data/pl_conferences/popl/1986.json new file mode 100644 index 0000000..411aa4b --- /dev/null +++ b/data/pl_conferences/popl/1986.json @@ -0,0 +1,692 @@ +[ + { + "paper_id": "10.1145/512644.512666", + "title": "Distributed Data Structures in Linda", + "abstract": "A distributed data structure is a data structure that can be manipulated by many parallel processes simultaneously. Distributed data structures are the natural complement to parallel program structures, where a parallel program (for our purposes) is one that is made up of many simultaneously active, communicating processes. Distributed data structures are impossible in most parallel programming languages, but they are supported in the parallel language Linda and they are central to Linda programming style. We outline Linda, then discuss some distributed data structures that have arisen in Linda programming experiments to date. Our intent is neither to discuss the design of the Linda system nor the performance of Linda programs, though we do comment on both topics; we are concerned instead with a few of the simpler and more basic techniques made possible by a language model that, we argue, is subtly but fundamentally different in its implications from most others.This material is based upon work supported by the National Science Foundation under Grant No. MCS-8303905. Jerry Leichter is supported by a Digital Equipment Corporation Graduate Engineering Education Program fellowship.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512666", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nicholas", + "last_name": "Carriero", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Gelernter", + "institution": "" + }, + { + "first_name": "Jerrold", + "last_name": "Leichter", + "institution": "" + } + ], + "dblp_key": "conf/popl/CarrieroGL86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512654", + "title": "Retargetable High-Level Alias Analysis", + "abstract": "All optimizing compilers must deal with the problem of aliases arising due to the presence of multiple names that reference the same memory areas. Presented in this paper is a staged, high-level alias analysis methodology that provides detailed alias information to a global optimizer implemented at any level in the compilation process. The framework provides easy portability of optimizing compilers to new architectures, as well as the easy addition, of new compilers to an already existing family of optimizing compilers. The method involves the application of a set of language-specific alias rules to the source code in order to gather alias information. A language-independent component then performs a transitive closure of this information and transforms it into a presentation more suitable for use by a global optimizer. Each stage of the methodology is detailed. Results are given for an implemented family of compilers targeted for a reduced instruction set computer.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512654", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Deborah S.", + "last_name": "Coutant", + "institution": "" + } + ], + "dblp_key": "conf/popl/Coutant86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512653", + "title": "Higher-Order Strictness Analysis in Untyped Lambda Calculus", + "abstract": "A function is said to be strict in one of its formal parameters if, in all calls to the function, either the corresponding actual parameter is evaluated, or the call does not terminate. Detecting which arguments a function will surely evaluate is a problem that arises often in program transformation and compiler optimization. We present a strategy that allows one to infer strictness properties of functions expressed in the lambda calculus. Our analysis improves on previous work in that (1) a set-theoretic characterization of strictness is used that permits treatment of free variables, which in turn permits a broader range of interpretations, and (2) the analysis provides an effective treatment of higher-order functions. We also prove a result due to Meyer [15]: the problem of first-order strictness analysis is complete in deterministic exponential time. However, because the size of most functions is small, the complexity seems to be tractable in practice.This research was supported in part by NSF Grant MCS-8302018, and a Faculty Development Award from IBM.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512653", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + }, + { + "first_name": "Jonathan M.", + "last_name": "Young", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/HudakY86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512646", + "title": "Dynamically Bypassing Copy Rule Chains in Attribute Grammars", + "abstract": "Attribute grammars require copy rules to transfer values between attribute instances distant in an attributed parse tree. We introduce copy bypass attribute propagation that dynamically replaces copy rules with nonlocal dependencies, resulting in faster incremental evaluation. A evaluation strategy is used that approximates a topological ordering of attribute instances. The result is an efficient incremental evaluator that allows multiple subtree replacement on any noncircular attribute grammar.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512646", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roger", + "last_name": "Hoover", + "institution": "" + } + ], + "dblp_key": "conf/popl/Hoover86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512651", + "title": "Code Motion of Control Structures in High-Level Languages", + "abstract": "One trend among programmers is the increased use of abstractions. Through encapsulation techniques, abstractions extend the repertory of data structures and their concomitant operations that are processed directly by a compiler. For example, a compiler might not offer sets or set operations in its base language, but abstractions allow a programmer to define sets in terms of constructs already recognized by the compiler. In particular, abstractions can allow new constructs to be defined in terms of other abstractions. Although significant power is gained through the use of layered abstractions, object code quality suffers as increasingly less of a program's data structures and operations are exposed to the optimization phase of a compiler. Multiple references to abstractions are also inefficient, since the interaction between abstractions is often complex yet hidden from a compiler. Abstractions are most flexible when they are cast in general terms; a specific invocation is then tailored by the abstraction to obtain the appropriate code. A sequence of references to such abstractions can be inefficient due to functional redundancy that cannot be detected at compile-time. By integrating the references, the offending segments of code can be moved to a more advantageous position. Although procedure integration materializes abstracted constructs, the abstractions can still be ineligible for optimization using current techniques; in particular, abstractions often involve loops and conditional branches that can obscure code that would otherwise be eligible for code motion.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512651", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ron K.", + "last_name": "Cytron", + "institution": "" + }, + { + "first_name": "Andy", + "last_name": "Lowry", + "institution": "" + }, + { + "first_name": "F. Kenneth", + "last_name": "Zadeck", + "institution": "" + } + ], + "dblp_key": "conf/popl/CytronLZ86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512664", + "title": "Logic and Inheritance", + "abstract": "An elaboration of the Prolog language is described in which the notion of first-order term is replaced by a more general one. This extended form of terms allows the integration of inheritance---an IS-A taxonomy---directly into the unification process rather than indirectly through the resolution-based inference mechanism of Prolog. This results in more efficient computations and enhanced language expressiveness. The language thus obtained, called LOGIN, subsumes Prolog, in the sense that conventional Prolog programs are equally well executed by LOGIN.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512664", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hassan", + "last_name": "Aı̈t-Kaci", + "institution": "" + }, + { + "first_name": "Roger", + "last_name": "Nasr", + "institution": "" + } + ], + "dblp_key": "conf/popl/Ait-KaciN86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512665", + "title": "Unification in Many-Sorted Algebras as a Device for Incremental Semantic Analysis", + "abstract": "Language-specific editors for typed programming languages must contain a subsystem for semantic analysis in order to guarantee correctness of programs with respect to the context conditions of the language. As programs are usually incomplete during development, the semantic analysis must be able to cope with missing context information, e. g. incomplete variable declarations or calls to procedures imported from still missing modules. In this paper we present an algorithm for incremental semantic analysis, which guarantees immediate detection of semantic errors even in arbitrary incomplete program fragments. The algorithm is generated from the language's context conditions, which are described by inference rules. During editing, these rules are evaluated using a unification algorithm for many-sorted algebras with semi-lattice ordered subsorts and non-empty equational theories. The method has been implemented as part of the PSG system, which generates interactive programming environments from formal language definitions, and has been successfully used to generate an incremental semantic analysis for PASCAL and MODULA-2.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512665", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gregor", + "last_name": "Snelting", + "institution": "Darmstadt University of Applied Sciences" + }, + { + "first_name": "Wolfgang", + "last_name": "Henhapl", + "institution": "Darmstadt University of Applied Sciences" + } + ], + "dblp_key": "conf/popl/SneltingH86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512674", + "title": "Executable Specifications with Quantifiers in the FASE System", + "abstract": "We present an overview of the FASE system for executable specifications based upon final, rather than initial, algebras. Particular emphasis is placed upon the execution of expressions involving quantifiers. The need for such expressions is explained, as is our method for evaluating them. By permitting quantifiers, we are able to give very natural specifications for many data types. As an example, we give the FASE specification of Kemmerer's library system.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512674", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stan", + "last_name": "Jefferson", + "institution": "" + }, + { + "first_name": "Samuel N.", + "last_name": "Kamin", + "institution": "" + } + ], + "dblp_key": "conf/popl/JeffersonK86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512658", + "title": "Limitations of Synchronous Communication with Static Process Structure in Languages for Distributed Computing", + "abstract": "Modules in a distributed program are active, communicating entities. A language for distributed programs must choose a set of communication primitives and a structure for processes. This paper examines one possible choice: synchronous communication primitives (such as rendez-vous or remote procedure call) in combination with modules that encompass a fixed number of processes (such as Ada tasks or UNIX processes). An analysis of the concurrency requirements of distributed programs suggests that this combination imposes complex and indirect solutions to common problems and thus is poorly suited for applications such as distributed programs in which concurrency is important. To provide adequate expressive power, a language for distributed programs should abandon either synchronous communication primitives or the static process structure.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512658", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "Coral Reef Alliance" + }, + { + "first_name": "Maurice", + "last_name": "Herlihy", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Lucy", + "last_name": "Gilbert", + "institution": "Coral Reef Alliance" + } + ], + "dblp_key": "conf/popl/LiskovHG86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512660", + "title": "A Really Abstract Concurrent Model and its Temporal Logic", + "abstract": "In this paper we advance the radical notion that a computational model based on the reals provides a more abstract description of concurrent and reactive systems, than the conventional integers based behavioral model of execution sequences. The real model is studied in the setting of temporal logic, and we illustrate its advantages by providing a fully abstract temporal semantics for a simple concurrent language, and an example of verification of a concurrent program within the real temporal logic defined here. It is shown that, by imposing the crucial condition of finite variability, we achieve a balanced formalism that is insensitive to finite stuttering, but can recognize infinite stuttering, a distinction which is essential for obtaining a fully abstract semantics of non-terminating processes. Among other advantages, going into real-based semantics obviates the need for the controversial representation of concurrency by interleaving, and most of the associated fairness constraints.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512660", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Howard", + "last_name": "Barringer", + "institution": "" + }, + { + "first_name": "Ruurd", + "last_name": "Kuiper", + "institution": "" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "" + } + ], + "dblp_key": "conf/popl/BarringerKP86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512650", + "title": "Hierarchical VLSI Design Systems Based on Attribute Grammars", + "abstract": "The attribute grammar technique used for design of structure editors is suggested as a foundation for building hierarchical incremental design editors for VLSI circuits. The usual definition of attribute grammars is extended: the cycles that occur in VLSI design make us come to terms with circular attributes (under conditions that guarantee their least fixpoint solution, namely that the functions be monotone and yield values over a lattice of bounded height). Many interesting VLSI design problems can be cast in attributes meeting this condition, for example, timing verification, logic simulation, power dissipation, and adherence to clocking disciplines, to name a few. As an illustration of the formalism, attributes are presented which solve the All Bidirectional Edges problem that labels the direction of information flow in a circuit. The incremental evaluation algorithm of [Rep82] is extended to handle fixpoint computations of circular attributes by noting that when the dependency graph is broken into its strongly connected components, a directed acyclic graph results. The worst-case running time of the resulting incremental evaluation algorithm is bounded by O (hk |AFFECTEDSCC|), where h is the height of the largest attribute lattice, k the largest number of attributes in any one strongly connected component, and |AFFECTEDSCC| the number of strongly connected components affected by a single modification to the design tree.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512650", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Larry G.", + "last_name": "Jones", + "institution": "" + }, + { + "first_name": "Janoš", + "last_name": "Šimon", + "institution": "" + } + ], + "dblp_key": "conf/popl/JonesS86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512649", + "title": "A Maximum-Flow Approach to Anomaly Isolation in Unification-Based Incremental Type Inference", + "abstract": "A crucial aspect of a program intended for general use is its behavior in the presence of erroneous inputs. For instance, much attention has been devoted to the problems of error detection, reporting, and correction in compilers1,2. As programming languages and systems based in one way or another on unification3 become more common, it becomes increasingly important to develop a theory of error detection and correction for unification-based systems. We report here on a language-based editor for a variant of ML4 that uses a novel approach to the isolation of likely causes of user errors. As the user edits and manipulates his or her program, unification is incrementally applied to determine its type correctness. If a type inconsistency arises, a maximum flow technique is applied to the set of type equations to determine the most likely source of error. In this way a determination can be made as to the relative strengths with which the set of type equations asserts multiple contradictory hypotheses. In a language such as ML, the type of an object is inferred from patterns of usage. Often it is the case that most uses of a given object are mutually consistent, whereas one or a very small number of uses conflict with the general usage pattern. In MOE (ML-Oriented Editor), if it is possible to discern that such a situation has arisen, likely errors are highlighted at high intensity and all other program components that contributed to the inferred type of the object are highlighted at a lower intensity. In providing error information to the user, two principles are observed:(1) Error indications should be complete but parsimonious; the user should see highlighted on the screen everything that contributed directly to an error, but nothing. more,(2) The user's attention should be drawn to what appear to be the anomalies that are responsible for errors.Language-based editors permit a new level of quality in the process of helping users when inputs are, for one reason or another, invalid. Unification-based type inference in language-based editors appears to have been first considered by Meertens 5. Snelting and Bahlke have more recently also explored this approach.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512649", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gregory F.", + "last_name": "Johnson", + "institution": "" + }, + { + "first_name": "Janet A.", + "last_name": "Walz", + "institution": "" + } + ], + "dblp_key": "conf/popl/JohnsonW86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512656", + "title": "A Parallel Language and its Compilation to Multiprocessor Machines or VLSI", + "abstract": "A language Crystal and its compiler for parallel programming is presented. The goal of Crystal is to help programmers in seeking efficient parallel implementations of an algorithm, and managing the complexity that might arise in dealing with hundreds of thousands of autonomous parallel processes. In Crystal, a program consists of a system of recursion equations and is interpreted as a parallel system. Crystal views a large complex system as consisting of a hierarchy of parallel sub-systems, built upon a set of Crystal programs by composition and abstraction. There is no mention of explicit communications in a Crystal program. The Crystal compiler automatically incorporates pipelining into programs, and generates a parallel program that is optimal with respect to an algorithm. Each optimizing compiler, targeted for a particular machine, determines the appropriate granular size of parallelism and attains a balance between computations and communications. Based on the language, a unified theory for understanding and generating any systolic design has been devised and it constitues a part of the compiler.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512656", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marina C.", + "last_name": "Chen", + "institution": "" + } + ], + "dblp_key": "conf/popl/Chen86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512652", + "title": "Compilers and Staging Transformations", + "abstract": "Computations can generally be separated into stages, which are distinguished from one another by either frequency of execution or availability of data. Precomputation and frequency reduction involve moving computation among a collection of stages so that work is done as early as possible (so less time is required in later steps) and as infrequently as possible (to reduce overall time).We present, by means of examples, several general transformation techniques for carrying out precomputation transformations. We illustrate the techniques by deriving fragments of simple compilers from interpreters, including an example of Prolog compilation, but the techniques are applicable in a broad range of circumstances. Our aim is to demonstrate how perspicuous accounts of precomputation and frequency reduction can be given for a wide range of applications using a small number of relatively straightforward techniques.Related work in partial evaluation, semantically directed compilation, and compiler optimization is discussed.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512652", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ulrik", + "last_name": "Jørring", + "institution": "" + }, + { + "first_name": "William L.", + "last_name": "Scherlis", + "institution": "" + } + ], + "dblp_key": "conf/popl/JorringS86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512647", + "title": "Global Storage Allocation in Attribute Evaluation", + "abstract": "Global storage allocation for attributes in an attribute grammar evaluator is discussed and an algorithm for determining if a given set of attribute occurrences can share a common global storage is obtained.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512647", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Takuya", + "last_name": "Katayama", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Hisashi", + "last_name": "Sasaki", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "conf/popl/KatayamaS86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512655", + "title": "High-Quality Code Generation Via Bottom-Up Tree Pattern Matching", + "abstract": "High-quality local code generation is one of the most difficult tasks the compiler-writer faces. Even if register allocation decisions are postponed and common subexpressions are ignored, instruction selection on machines with complex addressing can be quite difficult. Efficient and general algorithms have been developed to do instruction selection, but these algorithms fail to always find optimal solutions. Instruction selection algorithms based on dynamic programming or complete enumeration always find optimal solutions, but seem to be too costly to be practical. This paper describes a new instruction selection algorithm, and its prototype implementation, based on bottom-up tree pattern-matching. This algorithm is both time and space efficient, and is capable of doing optimal instruction selection for the DEC VAX-11 with its rich set of addressing modes.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512655", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philip J.", + "last_name": "Hatcher", + "institution": "" + }, + { + "first_name": "Thomas W.", + "last_name": "Christopher", + "institution": "" + } + ], + "dblp_key": "conf/popl/HatcherC86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512672", + "title": "Data Flow Analysis of Applicative Programs Using Minimal Function Graphs", + "abstract": "Data or program flow analysis is concerned with the static analysis of programs, to obtain as much information as possible about their possible run time behavior without actually having to run the programs. Due to the unsolvability of the halting problem (and nearly any other question concerning program behavior), such analyses are necessarily only approximate whenever the analysis algorithm is guaranteed to terminate. Further, exact analysis may be impossible due to the lack of knowledge of input data values, so the analysis can at best yield information about sets of possible computations.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512672", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neil D.", + "last_name": "Jones", + "institution": "" + }, + { + "first_name": "Alan", + "last_name": "Mycroft", + "institution": "Bridge University" + } + ], + "dblp_key": "conf/popl/JonesM86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512659", + "title": "Atomic Data Abstractions in a Distributed Collaborative Editing System", + "abstract": "This paper describes our experience implementing CES, a distributed Collaborative Editing System written in Argus, a language that includes facilities for managing long-lived distributed data. Argus provides atomic actions, which simplify the handling of concurrency and failures, and mechanisms for implementing atomic data types, which ensure serializability and recoverability of actions that use them. This paper focuses on the support for atomicity in Argus, especially the support for building new atomic types. Overall the mechanisms in Argus made it relatively easy to build CES; however, we encountered interesting problems in several areas. For example, much of the processing of an atomic action in Argus is handled automatically by the run-time system; several examples are presented that illustrate areas where more explicit control in the implementations of atomic types would be useful.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512659", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Irene", + "last_name": "Greif", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Robert", + "last_name": "Seliger", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "William E.", + "last_name": "Weihl", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/GreifSW86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512673", + "title": "A Mechanically Certified Theorem about Optimal Concurrency of Sorting Networks", + "abstract": "Our concern is the mechanical certification of transformations of sequential program executions into parallel executions with equivalent semantics. The objective of such transformations is to accelerate the execution of programs. The result reported here is a mechanically certified theorem of optimality. We present a transformation which applies to every program in a particular programming language, the language of sorting networks. This transformation transforms the sequential execution of any sorting network into an execution which is as fast or faster than any other transformation which applies to every sorting network. The theorem is stated formally in a mechanized logic.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512673", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christian", + "last_name": "Lengauer", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Chua-Huang", + "last_name": "Huang", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/LengauerH86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512662", + "title": "Operational Semantics of a Parallel Object-Oriented Language", + "abstract": "In this paper the semantics of the programming language POOL is described.It is a language that integrates the object-oriented structure of languages like Smalltalk-80 with facilities for concurrency and communication like the ones in Ada.The semantics is described in an operational way: it is based on transition systems.By using a way of representing parallel processes that is different from the traditional one, it is possible to overcome some difficulties pertaining to the latter.The resulting semantics shows a close resemblance with the informal language description and at the same time there are good prospects that it can serve as a secure guide for the implementation of the language.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512662", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "America", + "institution": "Philips (Netherlands)" + }, + { + "first_name": "Jaco de", + "last_name": "Bakker", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Joost N.", + "last_name": "Kok", + "institution": "Research!America (United States)" + }, + { + "first_name": "J.J.M.M.", + "last_name": "Rutten", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/popl/AmericaBKR86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512657", + "title": "Towards Programming with Knowledge Expressions", + "abstract": "Explicit use of knowledge expressions in the design of distributed algorithms is explored. A non-trivial case study is carried through, illustrating the facilities that a design language could have for setting and deleting the knowledge that the processes possess about the global state and about the knowledge of other processes. No implicit capabilities for logical reasoning are assumed. A language basis is used that allows common knowledge not only by an eager protocol but also in the true sense. The observation is made that the distinction between these two kinds of common knowledge can be associated with the level of abstraction: true common knowledge of higher levels of abstraction: true common knowledge of higher levels can be implemented as eager common knowledge on lower levels. A knowledge-motivated abstraction tool is therefore suggested to be useful in supporting stepwise refinement of distributed algorithms.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512657", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Reino", + "last_name": "Kurki-Suonio", + "institution": "" + } + ], + "dblp_key": "conf/popl/Kurki-Suonio86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512669", + "title": "Representation Independence and Data Abstraction", + "abstract": "One purpose of type checking in programming languages is to guarantee a degree of \"representation independence:\" programs should not depend on the way stacks are represented, only on the behavior of stacks with respect to push and pop operations. In languages with abstract data type declarations, representation independence should hold for user-defined types as well as built-in types. We study the representation independence properties of a typed functional language (second-order lambda calculus) with polymorphic functions and abstract data type declarations in which data type implementations (packages) may be passed as function parameters and returned as results. The type checking rules of the language guarantee that two data type implementations P and Q are equivalence whenever there is a correspondence between the behavior of the operations of P and the behavior of the operations of Q.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512669", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/popl/Mitchell86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512671", + "title": ""Type" Is Not A Type", + "abstract": "A function has a dependent type when the type of its result depends upon the value of its argument. Dependent types originated in the type theory of intuitionistic mathematics and have reappeared independently in programming languages such as CLU, Pebble, and Russell. Some of these languages make the assumption that there exists a type-of-all-types which is its own type as well as the type of all other types. Girard proved that this approach is inconsistent from the perspective of intuitionistic logic. We apply Girard's techniques to establish that the type-of-all-types assumption creates serious pathologies from a programming perspective: a system using this assumption is inherently not normalizing, term equality is undecidable, and the resulting theory fails to be a conservative extension of the theory of the underlying base types. The failure of conservative extension means that classical reasoning about programs in such a system is not sound.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512671", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Mark B.", + "last_name": "Reinhold", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/MeyerR86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512645", + "title": "Remote Attribute Updating for Language-Based Editors", + "abstract": "A major drawback to the use of attribute grammars in language-based editors has been that attributes can only depend on neighboring attributes in a program's syntax tree. This paper concerns new attribute-grammar-based methods that, for a suitable class of grammars, overcome this fundamental limitation. The techniques presented allow the updating algorithm to skip over arbitrarily large sections of the tree that more straightforward updating methods visit node by node. These techniques are then extended to deal with aggregate values, so that the attribute updating procedure need only follow dependencies due to a changed component of an aggregate value. Although our methods work only for a restricted class of attribute grammars, satisfying the necessary restrictions should not place an undue burden on the writer of the grammar.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512645", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "" + }, + { + "first_name": "Carla", + "last_name": "Marceau", + "institution": "" + }, + { + "first_name": "Tim", + "last_name": "Teitelbaum", + "institution": "" + } + ], + "dblp_key": "conf/popl/RepsMT86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512663", + "title": "Equational Logic Programming: An Extension to Equational Programming", + "abstract": "The paradigm of equational programming potentially possesses all the features provided by Prolog-like languages. In addition, the ability to reason about equations, which is not provided by Prolog, can be accommodated by equational languages. In this paper, we propose an extended equational programming paradigm, and describe an equational logic programming language which is an extension of the equational language defined in [Hoff82]. Semantic foundations for the extension are discussed. The extended language is a powerful logic programming language in the sense of Prolog and thus enjoys the programming features that Prolog possesses. Furthermore, it provides an ability to solve equations, which captures the essential power of equational programming.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512663", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jia-Huai", + "last_name": "You", + "institution": "" + }, + { + "first_name": "P. A.", + "last_name": "Subrahmanyam", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/popl/YouS86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512668", + "title": "Annotations for Distributed Programming in Logic", + "abstract": "It has been recognised that languages like Concurrent Prolog and Parlog which use committed choice non-determinism have departed from the original concept of logic programming, but no new paradigm has been suggested. In this paper we propose that programs in such languages be viewed as rewrite rules that hierarchically decompose a process into a network of distributed processes. Logical variables and unification provide a powerful means of communication, and annotations can provide a synchronization mechanism that complements them.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512668", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Raghu", + "last_name": "Ramakrishnan", + "institution": "" + }, + { + "first_name": "Abraham", + "last_name": "Silberschatz", + "institution": "" + } + ], + "dblp_key": "conf/popl/RamakrishnanS86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512667", + "title": "Para-Functional Programming: A Paradigm for Programming Multiprocessor Systems", + "abstract": "One of the most important pragmatic advantages of functional languages is that concurrency in a program is implicit -- there is no need for special constructs to express parallelism as is required in most conventional languages. Furthermore, it is fairly easy for compilers to automatically determine the concurrency as a step toward decomposing a program for execution on a suitable parallel architecture. Yet it is often the case that one knows precisely the optimal decomposition for execution on a particular machine, and one can never expect a compiler to determine such optimal mappings in all cases. This paper is concerned with ways to allow the programmer to explicitly express this mapping of program to machine, by using annotations that, given a few minor constraints, cannot alter the functional semantics of the program. We show through several detailed examples the expressiveness and conciseness of the resulting para-functional programming methodology, using an experimental language called ParAlfl based on our ideas. We also give a formal denotational description of the mapping semantics using a notion of execution trees.This research was supported in part by NSF Grants DCR-8403304 and DCR-8451415, and a Faculty Development Award from IBM.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512667", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "" + }, + { + "first_name": "Lauren", + "last_name": "Smith", + "institution": "" + } + ], + "dblp_key": "conf/popl/HudakS86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512661", + "title": "Expressing Interesting Properties of Programs in Propositional Temporal Logic", + "abstract": "We show that the class of properties of programs expressible in propositional temporal logic can be substantially extended if we assume the programs to be data-independent. Basically, a program is data-independent if its behavior does not depend on the specific data it operates upon. Our results significantly extend the applicability of program verification and synthesis methods based on propositional temporal logic.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512661", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Wolper", + "institution": "" + } + ], + "dblp_key": "conf/popl/Wolper86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512648", + "title": "Finding the Source of Type Errors", + "abstract": "It is a truism that most bugs are detected only at a great distance from their source. Although polymorphic type-checking systems like those in ML help greatly by detecting potential run-time type errors at compile-time, such systems are still not very helpful for locating the source of a type error. Typically, an error is reported only when the type-checker can proceed no further, even though the programmer's actual error may have occurred much earlier in the text. We describe an algorithm which appears to be quite helpful in isolating and explaining the source of type errors. The algorithm works by keeping track of the reasons the checker makes deductions about the types of variables.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512648", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "" + } + ], + "dblp_key": "conf/popl/Wand86", + "venue": "popl", + "year": 1986 + }, + { + "paper_id": "10.1145/512644.512670", + "title": "Using Dependent Types to Express Modular Structure", + "abstract": "Writing any large program poses difficult problems of organization. In many modern programming languages these problems are addressed by special linguistic constructs, variously known as modules, packages, or clusters, which provide for partitioning programs into manageable components and for securely combining these components to form complete programs. Some general purpose components are able to take on a life of their own, being separately compiled and stored in libraries of generic, reusable program units. Usually modularity constructs also support some form of information hiding, such as \"abstract data types.\" \"Programming in the large\" is concerned with using such constructs to impose structure on large programs, in contrast to \"programming in the small\", which deals with the detailed implementation of algorithms in terms of data structures and control constructs. Our goal here is to examine some of the proposed linguistic notions with respect to how they meet the pragmatic requirements of programming in the large.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/512644.512670", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "MacQueen", + "institution": "" + } + ], + "dblp_key": "conf/popl/MacQueen86", + "venue": "popl", + "year": 1986 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1987.json b/data/pl_conferences/popl/1987.json new file mode 100644 index 0000000..00eecc3 --- /dev/null +++ b/data/pl_conferences/popl/1987.json @@ -0,0 +1,661 @@ +[ + { + "paper_id": "10.1145/41625.41641", + "title": "Lustre: A Declarative Language for Programming Synchronous Systems", + "abstract": "LUSTRE is a synchronous data-flow language for programming systems which interact with their environments in real-time. After an informal presentation of the language, we describe its semantics by means of structural inference rules. Moreover, we show how to use this semantics in order to generate efficient sequential code, namely, a finite state automaton which represents the control of the program. Formal rules for program transformation are also presented.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41641", + "conference_name": "POPL", + "authors": [ + { + "first_name": "P.", + "last_name": "Caspi", + "institution": "" + }, + { + "first_name": "D.", + "last_name": "Pilaud", + "institution": "" + }, + { + "first_name": "Nicolas", + "last_name": "Halbwachs", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Plaice", + "institution": "" + } + ], + "dblp_key": "conf/popl/CaspiPHP87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41633", + "title": "Binding Performance at Language Design Time", + "abstract": "An important research goal in software engineering and programming languages is the development of principles underlying the specification of computable problems, the translation of these problems into efficient and correct programs, and the performance analysis of these programs. This paper uncovers some of these principles, which are used to design a problem specification language L1 restricted to problems that can be compiled automatically into programs whose worst case asymptotic time and space complexities are linear in the input/output space. Any problem expressible in L1 can be compiled into a linear cost program. A compiler for L1 has been implemented in the RAPTS transformational programming system.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41633", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jie", + "last_name": "Cai", + "institution": "Courant Institute of Mathematical Sciences" + }, + { + "first_name": "Robert", + "last_name": "Paige", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/popl/CaiP87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41637", + "title": "Compiling Strictness into Streams", + "abstract": "Article Free Access Share on Compiling strictness into streams Authors: C. V. Hall Indiana University, 101 Lindley Hall, Bloomington, Indiana, U.S.A. Indiana University, 101 Lindley Hall, Bloomington, Indiana, U.S.A.View Profile , D. S. Wise Indiana University, 101 Lindley Hall, Bloomington, Indiana, U.S.A. Indiana University, 101 Lindley Hall, Bloomington, Indiana, U.S.A.View Profile Authors Info & Claims POPL '87: Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesOctober 1987 Pages 132–143https://doi.org/10.1145/41625.41637Online:01 October 1987Publication History 15citation176DownloadsMetricsTotal Citations15Total Downloads176Last 12 Months5Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41637", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cordelia", + "last_name": "Hall", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "David S.", + "last_name": "Wise", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/HallW87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41634", + "title": "Environments as First Class Objects", + "abstract": "We describe a programming language called Symmetric Lisp that treats environments as first­class objects. Symmetric Lisp allows programmers to write expressions that evaluate to environments, and to create and denote variables and constants of type environment as well. One consequence is that the roles filled in other languages by a variety of limited, special purpose environment forms like records, structures, closures, modules, classes and abstract data types are filled instead by a single versatile and powerful structure. In addition to being its fundamental structuring tool, environments also serve as the basic functional object in the language. Because the elements of an environment are evaluated in parallel, Symmetric Lisp is a parallel programming language; because they may be assembled dyamically as well as statically, Symmetric Lisp accomodates an unusually flexible and simple (parallel) interpreter as well as other history­sensitive applications requiring dynamic environments. We show that first­class environments bring about fundamental changes in a language&apos;s structure: conventional distinctions between declarations and expressions, data structures and program structures, passive modules and active processes disappear. We argue that the resulting language is clean, simple and powerful.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41634", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Gelernter", + "institution": "Yale University" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "T.B.", + "last_name": "London", + "institution": "Nokia (United States)" + } + ], + "dblp_key": "conf/popl/GelernterJL87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41635", + "title": "Constraint Logic Programming", + "abstract": "We address the problem of designing programming systems to reason with and about constraints. Taking a logic programming approach, we define a class of programming languages, the CLP languages, all of which share the same essential semantic properties. From a conceptual point of view, CLP programs are highly declarative and are soundly based within a unified framework of formal semantics. This framework not only subsumes that of logic programming, but satisfies the core properties of logic programs more naturally. From a user's point of view, CLP programs have great expressive power due to the constraints which they naturally manipulate. Intuition in the reasoning about programs is enhanced as a result of working directly in the intended domain of discourse. This contrasts with working in the Herbrand Universe wherein every semantic object has to be explicitly coded into a Herbrand term; this enforces reasoning at a primitive level. Finally, from an implementor's point of view, CLP systems can be efficient because of the exploitation of constraint solving techniques over specific domains.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41635", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joxan", + "last_name": "Jaffar", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "J.-L.", + "last_name": "Lassez", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/JaffarL87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41649", + "title": "Scheduling Arithmetic and Load Operations in Parallel with No Spilling", + "abstract": "We consider a machine model in which load operations can be performed in parallel with arithmetic operations by two separate functional units. For this model, the evaluation of a set of expression trees is discussed. A dynamic programming algorithm to produce an approximate solution is described and analyzed. For binary trees its worse case cost is at most 9.1% worse than the optimal cost.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41649", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Bernstein", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Jeffrey M.", + "last_name": "Jaffe", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Michael", + "last_name": "Rodeh", + "institution": "IBM Research - Haifa" + } + ], + "dblp_key": "conf/popl/BernsteinJR87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41631", + "title": "Automatic Decomposition of Scientific Programs for Parallel Execution", + "abstract": "An algorithm for transforming sequential programs into equivalent parallel programs is presented. The method concentrates on finding loops whose separate iterations can be run in parallel without syn-chronization. Although a simple version of the method can be shown to be optimal, the problem of generating optimal code when loop interchange is employed is shown to be intractable. These methods are implemented in an experimental translation system developed at Rice University. 1.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41631", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Randy", + "last_name": "Allen", + "institution": "Rice University" + }, + { + "first_name": "David", + "last_name": "Callahan", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/AllenCK87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41632", + "title": "Macro-by-Example: Deriving Syntactic Transformations from their Specifications", + "abstract": "This paper presents two new developments. First, it describes a “macro-by-example” specification language for syntactic abstractions in Lisp and related languages. This specification language allows a more declarative specification of macros than conventional macro facilities do by giving a better treatment of iteration and mapping constructs. Second, it gives a formal semantics for the language and a derivation of a compiler from the semantics. This derivation is a practical application of semantics-directed compiler development methodology.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41632", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eugene E.", + "last_name": "Kohlbecker", + "institution": "Indiana University" + }, + { + "first_name": "M.", + "last_name": "Wand", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/popl/KohlbeckerW87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41629", + "title": "Semantic Parallelization: A Practical Exercise in Abstract Interpretation", + "abstract": "The parallelization of sequential programs is an adequate approach for the easy use of architectural features provided on parallel computers. We propose to enhance this technique with the notion of semantic parallelization. The principle is to consider the transformations of programs induced by parallelization as non-standard denotational semantics of the source programming language. We show how to apply this concept to detect, in a toy language ALL, parallelizable complex commands and to deal with some type of programs using indirections. Thanks to results in domain theory and abstract interpretation, we give correctness proofs for these transformations with respect to ALL standard semantic. A byproduct of our approach is that a denotational specification is also an executable prototype ;hence, we were able to implement a semantic parallelizer in the ML functional language. Running examples are supplied.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41629", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Jouvelot", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/popl/Jouvelot87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41627", + "title": "Axioms for Concurrent Objects", + "abstract": "Specification and verification techniques for abstract data types that have been successful for sequential programs can be extended in a natural way to provide the same benefits for concurrent programs. We propose an approach to specifying and verifying concurrent objects based on a novel correctness condition, which we call “linearizability.” Linearizability provides the illusion that each operation takes effect instantaneously at some point between its invocation and its response, implying that the meaning of a concurrent object's operations can still be given by pre- and post-conditions. In this paper, we will define and discuss linearizability, and then give examples of how to reason about concurrent objects and verify their implementations based on their (sequential) axiomatic specifications.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41627", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Maurice", + "last_name": "Herlihy", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "J.M.", + "last_name": "Wing", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/HerlihyW87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41654", + "title": "A Calculus for Assignments in Higher-Order Languages", + "abstract": "Imperative assignments are abstractions of recurring programming patterns in purely functional programming languages. When added to higher-order functional languages, they provide a higher-level of modularity and security but invalidate the simple substitution semantics. We show that, given an operational interpretation of a denotational semantics for such a language, it is possible to design a two-level extension of the lu-calculus. This calculus provides a location-free rewriting semantics of the language and offers new possibilities for reasoning with assignments. The upper level of the calculus factors out all the steps in a reduction sequence which must be in a linear order; the lower level allows a partial ordering of reduction steps.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41654", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/FelleisenF87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41647", + "title": "Skinny and Fleshy Failures of Relative Completeness", + "abstract": "The notion of relative completeness of logics of programs was delineated almost ten years ago, in particular by Wand, Cook and Clarke. More recently, it has been felt that Cook's notion hinges on a fragile balance between the semantics of a programming language and first-order expressiveness in structures. This fragility underlies the negative results about relative completeness.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41647", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniël", + "last_name": "Leivant", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Tim", + "last_name": "Fernando", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/LeivantF87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41651", + "title": "A Realistic Compiler Generator Based on High-Level Semantics", + "abstract": "We have developed a new style of semantic definition called high-level semantics. In constrast to traditional denotational semantics, high-level semantics is suitable for both defining the functional meaning of programming languages, as well as describing realistic compiler implementations. Moreover, high-level specifications are considerably more descriptive and intelligible than traditional specifications.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41651", + "conference_name": "POPL", + "authors": [ + { + "first_name": "P.", + "last_name": "Lee", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Uwe F.", + "last_name": "Pleban", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/popl/LeeP87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41645", + "title": "Full Abstraction of a Real-Time Denotational Semantics for an Occam-like Language", + "abstract": "We present a fully abstract semantics for real-time distributed computing of the Ada and OCCAM kind in a denotational style. This semantics turns termination, communication along channels, and the time communication takes place, into observables. Yet it is the coarsest semantics to do so which is syntax-directed (this is known as full abstraction). It extends the linear history semantics for CSP of Francez, Lehman and Pnueli. Our execution model is based on maximizing concurrent activity as opposed to interleaving (in which only one action occurs at the time and arbitrary delays are incurred between actions). It is a variant of the maximal parallelism model of Salwicki and Müldner.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41645", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cornelis", + "last_name": "Huizing", + "institution": "Eindhoven University of Technology" + }, + { + "first_name": "Rob", + "last_name": "Gerth", + "institution": "Eindhoven University of Technology" + }, + { + "first_name": "W.P.", + "last_name": "deRoever", + "institution": "Eindhoven University of Technology" + } + ], + "dblp_key": "conf/popl/HuizingGR87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41638", + "title": "On Strictness and its Analysis", + "abstract": "We study the strictness problem for the untyped lambda-calculus and for an ML-like typed calculus. We establish that strictness is a necessary and sufficient condition for the “eager” evaluation of function arguments. For the untyped calculus, we show that the strictness problem is elementary and describe a complete algorithm for strictness analysis of convergent terms. We show that typed terms possess a much richer set of strictness properties. A type-theoretic characterization of strictness is developed and it is shown that the strictness properties of a term can be represented as a collection of types related to the standard term type. A set of type inference rules that support reasoning about strictness related types is given. The inference rules are shown to be invariant under type change by substitution. This provides a sound basis for reasoning about strictness properties of terms by considering only their principal type. For our final result, we describe a practical system that carries out type checking and strictness analysis simultaneously in a unified framework. Our main result is thus the discovery that the problem of strictness analysis is a particular case of type inference.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41638", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tsung-Min", + "last_name": "Kuo", + "institution": "Stony Brook University" + }, + { + "first_name": "Prateek", + "last_name": "Mishra", + "institution": "State University of New York" + } + ], + "dblp_key": "conf/popl/KuoM87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41652", + "title": "Extensions for Multi-Module Records in Conventional Programming Languages", + "abstract": "An extended record facility is described that supports multi-module records by providing:", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41652", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David R.", + "last_name": "Cheriton", + "institution": "Stanford University" + }, + { + "first_name": "Michael E.", + "last_name": "Wolf", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/CheritonW87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41640", + "title": "An Improvement to Bottom-up Tree Pattern Matching", + "abstract": "Article Free Access Share on An improvement to bottom-up tree pattern matching Author: D. R. Chase Department of Computer Science, Rice University, Houston, Texas Department of Computer Science, Rice University, Houston, TexasView Profile Authors Info & Claims POPL '87: Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesOctober 1987Pages 168–177https://doi.org/10.1145/41625.41640Published:01 October 1987Publication History 56citation855DownloadsMetricsTotal Citations56Total Downloads855Last 12 Months79Last 6 weeks7 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Publisher SiteeReaderPDF", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41640", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Chase", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/Chase87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41642", + "title": "Appraising Fairness in Languages for Distributed Programming", + "abstract": "The relations among various languages and models for distributed computation and various possible definitions of fairness are considered. Natural semantic criteria are presented which an acceptable notion of fairness should satisfy. These are then used to demonstrate differences among the basic models, the added power of the fairness notion, and the sensitivity of the fairness notion to irrelevant semantic interleavings of independent operations. These results are used to show that from the considerable variety of commonly used possibilities, only strong process fairness is appropriate for CSP if these criteria are adopted. We also show that under these criteria, none of the commonly used notions of fairness are fully acceptable for a model with an n-way synchronization mechanism. Finally, the notion of fairness most often mentioned for Ada is shown to be fully acceptable.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41642", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krzysztof R.", + "last_name": "Apt", + "institution": "École Normale Supérieure - PSL" + }, + { + "first_name": "Nissim", + "last_name": "Francez", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Shmuel", + "last_name": "Katz", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/AptFK87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41648", + "title": "Empty Types in Polymorphic Lambda Calculus", + "abstract": "The model theory of simply typed and polymorphic (second-order) lambda calculus changes when types are allowed to be empty. For example, the “polymorphic Boolean” type really has exactly two elements in a polymorphic model only if the “absurd” type ∀t.t is empty. The standard β-ε axioms and equational inference rules which are complete when all types are nonempty are not complete for models with empty types. Without a little care about variable elimination, the standard rules are not even sound for empty types. We extend the standard system to obtain a complete proof system for models with empty types. The completeness proof is complicated by the fact that equational “term models” are not so easily obtained: in contrast to the nonempty case, not every theory with empty types is the theory of a single model.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41648", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "AT&T (United States)" + }, + { + "first_name": "Eugenio", + "last_name": "Moggi", + "institution": "University of Edinburgh" + }, + { + "first_name": "Rick", + "last_name": "Statman", + "institution": "" + } + ], + "dblp_key": "conf/popl/MeyerMMS87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41626", + "title": "Specification and Verification of Concurrent Programs By Forall-Automata", + "abstract": "∀-automata are non-deterministic finite-state automata over infinite sequences. They differ from conventional automata in that a sequence is accepted if all runs of the automaton over the sequence are accepting. These automata are suggested as a formalism for the specification and verification of temporal properties of concurrent programs. It is shown that they are as expressive as extended-temporal-logic (ETL), and in some cases provide a more compact representation of properties than temporal logic. A structured diagram notation is suggested for the graphical representation of these automata. A single sound and complete proof rule is presented for proving that all computations of a program have the property specified by a ∀-automaton.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41626", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Z.", + "last_name": "Monna", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/MannaP87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41653", + "title": "Views: A Way for Pattern Matching to Cohabit with Data Abstraction", + "abstract": "Pattern matching and dta abstraction are important concepts in designing programs, but they do not it well together. Pattern matching depend on making public a free data type mpresentaiion, while data abstraction depends on hiding the repreentaiion. This paper proposes the vdws mechanism at a means of reconc&apos;dlng this conflict. A view allows any type to be viewed at a free data type, thus combining the clarity of pattern matching with the eiclency of data abstraction.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41653", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/Wadler87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41650", + "title": "Computation of Aliases and Support Sets", + "abstract": "We provide a scheme for determining which global variables are involved when an expression is evaluated in a language with higher order constructs and imperative features. The heart of our scheme is a mechanism for computing the support of an expression, i.e. the set of global variables involved in its evaluation. This computation requires knowledge of all the aliases of an expression. The inference schemes are presented as abstract semantic interpretations. We prove the soundness of our estimates by establishing a correspondence between the abstract semantics and the standard semantics of the programming language.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41650", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anne Denise", + "last_name": "Neirynck", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/NeirynckPD87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41646", + "title": "Computable Values Can Be Classical", + "abstract": "In programming languages of universal power, the computational integers must be distinguished from the classical integers because of the “divergent” integer. Even the equational theory corresponding to evaluation of integer expressions is distinct from the theory of classical integers, and classical reasoning about computational integers yields inconsistencies. We show that there exist “programming languages”, actually extensions of the polymorphic lambda calculus, that have tremendous computing power and yet whose computational integers, or any other algebraically specified abstract data type, coincide with their classical counterpart. In particular, the equational theory of the programming language is a conservative extension of the theory of the underlying base types as given by algebraic data type specifications.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41646", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Val", + "last_name": "Breazu-Tannen", + "institution": "" + }, + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "" + } + ], + "dblp_key": "conf/popl/TannenM87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41643", + "title": "Concurrent Transition System Semantics of Process Networks", + "abstract": "Using concurrent transition systems [Sta86], we establish connections between three models of concurrent process networks, Kahn functions, input/output automata, and labeled processes. For each model, we define three kinds of algebraic operations on processes: the product operation, abstraction operations, and connection operations. We obtain homomorphic mappings, from input/output automata to labeled processes, and from a subalgebra (called “input/output processes”) of labeled processes to Kahn functions. The proof that the latter mapping preserves connection operations amounts to a new proof of the “Kahn Principle.” Our approach yields: (1) extremely simple definitions of the process operations; (2) a simple and natural proof of the Kahn Principle that does not require the use of “strategies” or “scheduling arguments”; (3) a semantic characterization of a large class of labeled processes for which the Kahn Principle is valid, (4) a convenient operational semantics for nondeterminate process networks.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41643", + "conference_name": "POPL", + "authors": [ + { + "first_name": "E.", + "last_name": "Stark", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/popl/Stark87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41630", + "title": "The Concurrent Logic Programming Language CP: Definition and Operational Semantics", + "abstract": "In this paper we present some of the control constructs of the language CP, which is based on a concurrent interpretation of Horn logic programming. We present a formal structural operational semantics and relate the meaning of programs in this language to the underlying (pure) Horn clause axioms.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41630", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vijay", + "last_name": "Saraswat", + "institution": "Laboratoire d'Informatique de Paris-Nord" + } + ], + "dblp_key": "conf/popl/Saraswat87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41644", + "title": "Semantics for Concurrency without Powerdomains", + "abstract": "Article Free Access Share on Semantics for concurrency without powerdomains Author: F. J. Oles Mathematical Sciences Department, IBM Thomas J. Watson Research Center, Yorktown Heights, New York Mathematical Sciences Department, IBM Thomas J. Watson Research Center, Yorktown Heights, New YorkView Profile Authors Info & Claims POPL '87: Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesOctober 1987 Pages 211–222https://doi.org/10.1145/41625.41644Published:01 October 1987Publication History 4citation169DownloadsMetricsTotal Citations4Total Downloads169Last 12 Months9Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41644", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Frank J.", + "last_name": "Oles", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/Oles87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41636", + "title": "Strictness Analysis and Denotational Abstract Interpretation", + "abstract": "A theory of abstract interpretation [CoCo79] is developed for a typed λ-calculus. The typed λ-calculus is the “static” part of a two-level denotational metalanguage for which abstract interpretation was developed in [Nie86]. The present development relaxes a condition imposed in [Nie86] and this suffices to make the framework applicable to strictness analysis for the λ-calculus. This shows the possibility of a general theory (and hence a system) for the analysis of functional programs. Furthermore, it gives more insight into the relative precision of the various analyses. In particular, it is shown that a collecting (static [CoCo79]) semantics exists, thus answering a problem left open in [BHA86].", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41636", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Flemming", + "last_name": "Nielson", + "institution": "Aalborg University" + } + ], + "dblp_key": "conf/popl/Nielson87", + "venue": "popl", + "year": 1987 + }, + { + "paper_id": "10.1145/41625.41628", + "title": "Completeness and Incompleteness of Trace-Based Network Proof Systems", + "abstract": "Abstract. Most trace-based proof systems for networks of processes are known to be incomplete. Extensions to achieve completeness are generally complicated and cumbersome. In this paper, a simple trace logic is defined and two examples are presented to show its inherent incompleteness. Surprisingly, both examples consist of only one process, indicating that network composition is not a cause of incompleteness. Axioms necessary and sufficient for the relative completeness of a trace logic are then presented.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/41625.41628", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jennifer", + "last_name": "Widom", + "institution": "Cornell University" + }, + { + "first_name": "David", + "last_name": "Gries", + "institution": "Cornell University" + }, + { + "first_name": "F.B.", + "last_name": "Schneider", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/WidomGS87", + "venue": "popl", + "year": 1987 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1988.json b/data/pl_conferences/popl/1988.json new file mode 100644 index 0000000..4467438 --- /dev/null +++ b/data/pl_conferences/popl/1988.json @@ -0,0 +1,613 @@ +[ + { + "paper_id": "10.1145/73560.73570", + "title": "A Collecting Interpretation of Expressions (Without Powerdomains)", + "abstract": "A collecting interpretation of expressions is an interpretation of a program that allows one to answer questions of the sort: “What are all possible values to which an expression might evaluate during program execution?” Answering such questions in a denotational framework is akin to traditional data flow analysis, and when used in the context of abstract interpretation allows one to infer properties that approximate the run-time behavior of expression evaluation. In this paper collecting interpretations of expressions are developed for three abstract functional languages: (1) a first-order language with call-by-value semantics, (2) a first-order language with call-by-name semantics, and (3) a higher-order language with call-by-name semantics (i.e., the full untyped lambda calculus with constants). It is argued that the method is simple (in particular, no powerdomains are needed), natural (it captures the intuitive operational behavior of a cache), yet more expressive than existing methods (it is the first exact collecting interpretation for either lazy or higher-order programs).", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73570", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + }, + { + "first_name": "Jonathan M.", + "last_name": "Young", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/HudakY88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73587", + "title": "Compiler Optimizations for Asynchronous Systolic Array Programs", + "abstract": "A programmable systolic array of high-performance cells is an attractive computation engine if it attains the same utilization of dedicated arrays of simple cells. However, typical implementation techniques used in high-performance processors, such as pipelining and parallel functional units, further complicate the already difficult task of systolic algorithm design. This paper shows that high-performance systolic arrays can be used effectively by presenting the machine to the user as an array of conventional processors communicating asynchronously. This abstraction allows the user to focus on the higher level problem of partitioning a computation across cells in the array. Efficient fine-grain parallelism can be achieved by code motion of communication operations made possible by the asynchronous communication model. This asynchronous communication model is recommended even for programming algorithms on systolic arrays without dynamic flow control between cells.The ideas presented in the paper have been validated in the compiler for the Warp machine [4]. The compiler has been in use in various application areas including robot navigation, low-level vision, signal processing and scientific programming. Near-optimal code has been generated for many published systolic algorithms.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73587", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Lam88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73581", + "title": "A Compositional Approach to Superimposition", + "abstract": "A general definition of the notion of superimposition is presented. We show that previous constructions under the same name can be seen as special cases of our definition. We consider several properties of superimposition definable in our terms, notably the nonfreezing property. We also consider a syntactic representation of our construct in CSP", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73581", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luc", + "last_name": "Bougé", + "institution": "Université d'Orléans" + }, + { + "first_name": "Nissim", + "last_name": "Francez", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/BougeF88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73572", + "title": "Integrating Non-Interfering Versions of Programs", + "abstract": "The need to integrate several versions of a program into a common one arises frequently, but it is a tedious and time consuming task to integrate programs by hand. The main contribution of this paper is an algorithm, called integrate, that takes as input three programs A, B, and Base, where A and B are two variants of Base. Whenever the changes made to Base to create A and B do not “interfere” (in a sense defined in the paper), Integrate produces a program M that integrates A and B.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73572", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Jan F.", + "last_name": "Prins", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/HorwitzPR88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73573", + "title": "On the Adequacy of Program Dependence Graphs for Representing Programs", + "abstract": "Program dependence graphs were introduced by Kuck as an intermediate program representation well suited for performing optimizations, vectorization, and parallelization. There are also additional applications for them as an internal program representation in program development environments.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73573", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Jan F.", + "last_name": "Prins", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/HorwitzPR88a", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73563", + "title": "The Essence of ML", + "abstract": "Standard ML is a useful programming language with polymorphic expressions and a flexible module facility. One notable feature of the expression language is an algorithm which allows type information to be omitted. We study the implicitly-typed expression language by giving a “syntactically isomorphic” explicitly-typed, polymorphic function calculus. Unlike the Girard-Reynolds polymorphic calculus, for example, the types of our ML calculus may be built-up by induction on type levels (universes). For this reason, the pure ML calculus has straightforward set-theoretic, recursion-theoretic and domain-theoretic semantics, and operational properties such as the termination of all recursion-free programs may be proved relatively simply. The signatures, structures, and functors of the module language are easily incorporated into the typed ML calculus, providing a unified framework for studying the major features of the language (including the novel “sharing constraints” on functor parameters). We show that, in a precise sense, the language becomes inconsistent if restrictions imposed by type levels are relaxed. More specifically, we prove that the important programming features of ML cannot be added to any impredicative language, such as the Girard-Reynolds calculus, without implicitly assuming a type of all types.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73563", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Nokia (United States)" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/MitchellH88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73588", + "title": "Supernode Partitioning", + "abstract": "Supercompilers must reschedule computations defined by nested DO-loops in order to make an efficient use of supercomputer features (vector units, multiple elementary processors, cache memory, etc…). Many rescheduling techniques like loop interchange, loop strip-mining or rectangular partitioning have been described to speedup program execution. We present here a class of partitionings that encompasses previous techniques and provides enough flexibility to adapt code to multiprocessors with two levels of parallelism and two levels of memory.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73588", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Irigoin", + "institution": "École Nationale Supérieure des Mines de Paris" + }, + { + "first_name": "Rémi", + "last_name": "Triolet", + "institution": "École Nationale Supérieure des Mines de Paris" + } + ], + "dblp_key": "conf/popl/IrigoinT88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73561", + "title": "Detecting Equality of Variables in Programs", + "abstract": "Article Free Access Share on Detecting equality of variables in programs Authors: B. Alpern IBM Thomas J. Watson Research Center, Yorktown Heights, NY IBM Thomas J. Watson Research Center, Yorktown Heights, NYView Profile , M. N. Wegman IBM Thomas J. Watson Research Center, Yorktown Heights, NY IBM Thomas J. Watson Research Center, Yorktown Heights, NYView Profile , F. K. Zadeck Department of Computer Science, Brown University, Providence, RI Department of Computer Science, Brown University, Providence, RIView Profile Authors Info & Claims POPL '88: Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1988 Pages 1–11https://doi.org/10.1145/73560.73561Published:13 January 1988Publication History 264citation2,559DownloadsMetricsTotal Citations264Total Downloads2,559Last 12 Months137Last 6 weeks21 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73561", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bowen", + "last_name": "Alpern", + "institution": "IBM (United States)" + }, + { + "first_name": "Mark N.", + "last_name": "Wegman", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "F. K.", + "last_name": "Zadeck", + "institution": "Brown University" + } + ], + "dblp_key": "conf/popl/AlpernWZ88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73565", + "title": "A Proper Extension of ML with an Effective Type-Assignment", + "abstract": "We extend the functional language ML by allowing the recursive calls to a function F on the right-hand side of its definition to be at different types, all generic instances of the (derived) type of F on the left-hand side of its definition. The original definition of ML does not allow this feature. This extension does not produce new types beyond the usual universal polymorphic types of ML and satisfies the properties already enjoyed by ML: the principal-type property and the effective type-assignment property.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73565", + "conference_name": "POPL", + "authors": [ + { + "first_name": "A. J.", + "last_name": "Kfoury", + "institution": "Boston University" + }, + { + "first_name": "Jerzy", + "last_name": "Tiuryn", + "institution": "Washington State University" + }, + { + "first_name": "Paweł", + "last_name": "Urzyczyn", + "institution": "Institute of Mathematics" + } + ], + "dblp_key": "conf/popl/KfouryTU88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73566", + "title": "Structural Subtyping and the Notion of Power Type", + "abstract": "types We have used the term abstract type for types of the form P = Some(A:Type) B, because this models the concept of having an unknown type A which supports a set of operations of signature B. It should be pointed out that, unlike abstract types in second-order lambda calculus [Mitchell Plotkin 85] this notion of type abstraction does not prevent impersonation. That is, given a particular implementation p = pair(A:Type = C) b:B of P, the representation type C is visible, hence one can build an object of type A without using the operations in b. This problems can be partially solved by scoping techniques; e.g., a function which must operate on arbitrary implementations of P cannot make assumptions about any particular C. A complete solution to the impersonation problem requires introducing additional concepts [MacQueen 86]. On the positive side, the fact that even abstract types are matched by structure means that redefining an abstract type does not create a &quot;new&quot; one. This is co...", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73566", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "" + } + ], + "dblp_key": "conf/popl/Cardelli88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73562", + "title": "Global Value Numbers and Redundant Computations", + "abstract": "Article Free Access Share on Global value numbers and redundant computations Authors: B. K. Rosen IBM Thomas J. Watson Research Center, Yorktown Heights, NY IBM Thomas J. Watson Research Center, Yorktown Heights, NYView Profile , M. N. Wegman IBM Thomas J. Watson Research Center, Yorktown Heights, NY IBM Thomas J. Watson Research Center, Yorktown Heights, NYView Profile , F. K. Zadeck Department of Computer Science, Brown University, Providence, RI Department of Computer Science, Brown University, Providence, RIView Profile Authors Info & Claims POPL '88: Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1988 Pages 12–27https://doi.org/10.1145/73560.73562Published:13 January 1988Publication History 278citation1,997DownloadsMetricsTotal Citations278Total Downloads1,997Last 12 Months240Last 6 weeks26 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73562", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Barry K.", + "last_name": "Rosen", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Mark N.", + "last_name": "Wegman", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "F. K.", + "last_name": "Zadeck", + "institution": "Brown University" + } + ], + "dblp_key": "conf/popl/RosenWZ88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73564", + "title": "Polymorphic Effect Systems", + "abstract": "We present a new approach to programming languages for parallel computers that uses an effect system to discover expression scheduling constraints. This effect system is part of a 'kinded' type system with three base kinds: types, which describe the value that an expression may return; effects, which describe the side-effects that an expression may have; and regions, which describe the area of the store in which side-effects may occur. Types, effects and regions are collectively called descriptions.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73564", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jan", + "last_name": "Lucassen", + "institution": "" + }, + { + "first_name": "David K.", + "last_name": "Gifford", + "institution": "" + } + ], + "dblp_key": "conf/popl/LucassenG88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73567", + "title": "Inheritance in Smalltalk-80: A Denotational Definition", + "abstract": "A denotational semantic definition of SMALLTALK-80 is given. Its most notable characteristic is a surprisingly simple treatment of inheritance. An executable version of the semantics, written in STANDARD ML, is also described.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73567", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Samuel", + "last_name": "Kamin", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/Kamin88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73577", + "title": "Towards Fully Abstract Semantics for Local Variables", + "abstract": "The Store Model of Halpern-Meyer-Trakhtenbrot is shown—after suitable repair—to be a fully abstract model for a limited fragment of ALGOL in which procedures do not take procedure parameters. A simple counter-example involving a parameter of program type shows that the model is not fully abstract in general. Previous proof systems for reasoning about procedures are typically sound for the HMT store model, so it follows that theorems about the counter-example are independent of such proof systems. Based on a generalization of standard cpo based models to structures called locally complete partial orders (lcpo's), improved models and stronger proof rules are developed to handle such examples.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73577", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "" + }, + { + "first_name": "Kurt", + "last_name": "Sieber", + "institution": "" + } + ], + "dblp_key": "conf/popl/MeyerS88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73584", + "title": "Incremental Data Flow Analysis via Dominator and Attribute Updates", + "abstract": "We present an algorithm for updating data flow information derived from a program, in response to program edits. Our algorithm, applicable to intraprocedural or interprocedural data flow problems, is more general than previous methods because it can update any monotone data flow problem defined on a reducible flow graph and can handle arbitrary program edits.Rather than design yet another special-purpose data flow update algorithm, we show how to reduce the class of data flow problems to another class of problems which already has a fast update algorithm. More specifically, we reduce a monotone data flow problem formulated for solution using Graham-Wegman elimination [12] to the problem of constructing and decorating an attributed tree structurally isomorphic to the dominator tree of the program flow graph.To update this dominator tree in response to program changes, we first show how to express domination in terms of two local properties of nodes and edges in the flow graph — niceness and deepness. Domination is then updated in response to an edge addition or deletion by repeatedly performing two local operations on the dominator tree, each operation restoring the local properties violated by the edge change. Second, we extend Reps' attributed tree update techniques [19,21,20] and his complexity analysis, to update attribute values in response to changes in this structure.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73584", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin D.", + "last_name": "Carroll", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/popl/CarrollR88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73569", + "title": "Automatic Binding Time Analysis for a Typed Lambda-Calculus", + "abstract": "For a typed λ-calculus we develop an algorithm that, given some partial information about what must happen at run-time, will work out what actually can be computed at compile-time and what must be deferred to run-time.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73569", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Flemming", + "last_name": "Nielson", + "institution": "Technical University of Denmark" + }, + { + "first_name": "R. H.", + "last_name": "Nielson", + "institution": "Technical University of Denmark" + } + ], + "dblp_key": "conf/popl/NielsonN88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73576", + "title": "The Theory and Practice of First-Class Prompts", + "abstract": "An analysis of the λugr;-C-calculus and its problematic relationship to operational equivalence leads to a new control facility: the prompt-application. With the introduction of prompt-applications, the control calculus becomes a traditional calculus all of whose equations imply operational equivalence. In addition, prompt-applications enhance the expressiveness and efficiency of the language. We illustrate the latter claim with examples from such distinct areas as systems programming and tree processing.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73576", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/Felleisen88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73583", + "title": "Efficient Dataflow Analysis of Logic Programs", + "abstract": "We investigate a framework for efficient flow analyses of logic programs. A major problem in this context is that unification can give rise to aliasing and dependencies between variables whose effects are difficult to predict, and which make sound flow analysis algorithms computationally expensive. We give a simple characterization of the class of flow analysis problems for which aliasing effects can be ignored without loss of soundness, and describe an efficient analysis procedure for this class of problems. The utility of our approach is illustrated by discussing its application to several analysis and optimization problems for logic programs. Our results are useful in the design of efficient flow analysis systems for logic programming languages.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73583", + "conference_name": "POPL", + "authors": [ + { + "first_name": "S.", + "last_name": "Debray", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/Debray88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73579", + "title": "Inductive Methods for Reasoning about Abstract Data Types", + "abstract": "Rewriting techniques have been used to reason about a variety of topics related to programming languages, e.g., abstract data types, Petri Nets, FP programs, and data bases. They have also been used in the implementation and definition of a variety of programming languages.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73579", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen J.", + "last_name": "Garland", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "John V.", + "last_name": "Guttag", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/GarlandG88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73580", + "title": "Bisimulation Can't Be Traced", + "abstract": "Bisimulation is the primitive notion of equivalence between concurrent processes in Milner's Calculus of Communicating Systems (CCS); there is a nontrivial game-like protocol for distinguishing nonbisimular processes. In contrast, process distinguishability in Hoare's theory of Communicating Sequential Processes (CSP) is determined solely on the basis of traces of visible actions. We examine what additional operations are needed to explain bisimulation similarly—specifically in the case of finitely branching processes without silent moves. We formulate a general notion of Structured Operational Semantics for processes with Guarded recursion (GSOS), and demonstrate that bisimulation does not agree with trace congruence with respect to any set of GSOS-definable contexts. In justifying the generality and significance of GSOS's, we work out some of the basic proof theoretic facts which justify the SOS discipline.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73580", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bard", + "last_name": "Bloom", + "institution": "" + }, + { + "first_name": "Sorin", + "last_name": "Istrail", + "institution": "Wesleyan University" + }, + { + "first_name": "Albert R.", + "last_name": "Meyer", + "institution": "" + } + ], + "dblp_key": "conf/popl/BloomIM88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73571", + "title": "Strictness Analysis Aids Time Analysis", + "abstract": "Analyzing time complexity of functional programs in a lazy language is problematic, because the time required to evaluate a function depends on how much of the result is “needed” in the computation. Recent results in strictness analysis provide a formalisation of this notion of “need”, and thus can be adapted to analyse time complexity.The future of programming may be in this paradigm: to create software, first write a specification that is clear, and then refine it to an implementation that is efficient. In particular, this paradigm is a prime motivation behind the study of functional programming. Much has been written about the process of transforming one functional program into another. However, a key part of the process has been largely ignored, for very little has been written about assessing the efficiency of the resulting programs.Traditionally, the major indicators of efficiency are time and space complexity. This paper focuses on the former.Functional programming can be split into two camps, strict and lazy. In a strict functional language, analysis of time complexity is straightforward, because of the following compositional rule:The time to evaluate (ƒ(g x)) equals the time to evaluate (g x) plus the time to evaluate (ƒ y), where y is the value of (g x).However, in a lazy language, this rule only gives an upper bound, possibly a crude one. For example, if ƒ is the head function, then (g x) need only be evaluated far enough to determine the first element of the list, and this may take much less time than evaluating (g x) completely.The key to a better analysis is to describe formally just how much of the result “needs” to be evaluated; we call such a description a context. Recent results in strictness analysis show how such contexts can be modelled using the domain-theoretic notion of a projection [WH87]. This paper describes how these results can be applied to the analysis of time complexity. The method used was inspired by work of Bror Bjerner on the complexity analysis of programs in Martin-Luf's type theory [Bje87]. The main contribution of this paper is to simplify Bjerner's notation, and to show how contexts can replace his “demand notes”.The language used in this paper is a first-order language. This restriction is made because context analysis for higher-order languages is still under development. An approach to higher-order context analysis is outlined in [Hug87b]. Context analysis is based on backwards analysis, rather than the earlier approach of abstract interpretation; both are discussed in [AH87].Some work on complexity analysis [Weg75,LeM85] has concentrated on automated analysis: algorithms that derive a closed form for the time complexity of a program. The goal here is less ambitious. We are simply concerned with describing a method of converting a functional program into a series of equations that describe its time complexity. This modest beginning is a necessary precursor to any automatic analysis. The time equations can be solved by traditional methods, yielding either an exact solution, an upper bound, or an approximate solution. (Incidentally, although [LeM85] claims to analyse a lazy language, the analysis uses exactly the composition rule above, and so is more suited for a strict language.)The analysis given here involves two kinds of equations. First are equations defining projection transformers that specify how much of a value is “needed”. Second are equations that specify the time complexity; these depend on the projection transformers defined by the first equations.In both cases, we will be more concerned with setting up the equations that with finding their solutions. As already noted, traditional methods may be applied to satisfy the time complexity equations. Solving the projection transformer equations is more problematic. In some cases, we can find an appropriate solution by choosing an appropriate finite domain of projections, and then applying the method of [WH87] to find the solution in this domain. In other cases, no finite domain of solutions is appropriate, and we will find a solution by a more ad-hoc method: guessing one and verifying that it satisfies the required conditions. More work is required to determine what sort of solutions to the projection transformer equations will be most useful for time analysis, and how to find these solutions.This paper is organized as follows. Section 1 describes the language to be analysed. Section 2 presents the evaluation model. Section 3 gives a form of time analysis suitable for strict evaluation. Section 4 shows how projections can describe what portion of a value is “needed”, and introduces projection transformers. Section 5 gives the time analysis for lazy evaluation. Section 6 presents a useful extension to the analysis method. Section 7 concludes.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73571", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/popl/Wadler88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73586", + "title": "Optimal Code Generation for Expression Trees: An Application of BURS Theory", + "abstract": "A Rewrite System is a collection of rewrite rules of the form α β where α and β are tree patterns. A rewrite system can be extended by associating a cost with each rewrite rule, and by defining the cost of a rewrite sequence as the sum of the costs of all the rewrite rules in the sequence. The REACHABILITY problem for a rewrite system R is, given an input tree T and a fixed goal tree G, to determine if there exists a rewrite sequence in R, rewriting T into G and, if so, to obtain one such sequence. The C-REACHABILITY problem is similar except that the obtained sequence must have minimal cost among all those sequences writing T into G.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73586", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eduardo", + "last_name": "Pelegri-Llopart", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Stuart L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/Pelegri-LlopartG88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73582", + "title": "A Temporal Fixpoint Calculus", + "abstract": "Two distinct extensions of temporal logic has been recently advocated in the literature. The first extension is the addition of fixpoint operators that enable the logic to make assertions about arbitrary regular events. The second extension is the addition of past temporal connectives that enables the logic to refer directly to the history of the computation. Both extensions are motivated by the desire to adapt temporal logic to modular, i.e., compositional, verification (as opposed to global verification). We introduce and study here the logic μTL, which is the extension of temporal logic by fixpoint operators and past temporal connectives. We extend the automata-theoretic paradigm to μTL. That is, we show how, given an μTL formula @@@@, we can produce a finite-state Büchi automaton A@@@@, whose size is at most exponentially bigger than the size of @@@@, such that A@@@@ accepts precisely the computations that satisfy @@@@. The result has immediate applications, e.g., an optimal decision procedure and a model-checking algorithm for μTL.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73582", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Moshe Y.", + "last_name": "Vardi", + "institution": "IBM Research - Almaden" + } + ], + "dblp_key": "conf/popl/Vardi88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73575", + "title": "Sacrificing Simplicity for Convenience: Where Do You Draw the Line?", + "abstract": "The designers of (functional) programming languages are faced with two occasionally conflicting goals: programmer convenience and semantic simplicity. For example, it is convenient to treat I/O operations as primitive “functions” with side effects, but doing so destroys referential transparency.FL is a functional language that is designed to trade some of the semantic simplicity of a pure language for some of the convenience of a procedural language, by treating I/O operations as primitives with “side effects”, but by using a structuring technique that localizes the scope of those effects. In this way, surprisingly little of the semantic simplicity is lost, as can be seen by comparing the underlying algebraic laws of FL with those of its pure counterpart. FP.This paper describes that comparison and shows that, in fact, for programs involving I/O, the structures of the algebraic laws of the two languages are identical! It concludes by showing that this technique cannot be extended to allow assignment statements without incurring a massive loss in the expressiveness and simplicity of the underlying algebra.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73575", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John H.", + "last_name": "Williams", + "institution": "IBM (United States)" + }, + { + "first_name": "Edward L.", + "last_name": "Wimmers", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/WilliamsW88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73568", + "title": "Type Inference with Subtypes", + "abstract": "We give an algorithm for type inference in a language with functions, records, and variant records. A similar language was studied by Cardelli who gave a type checking algorithm. This language is interesting because it captures aspects of object-oriented programming using subtype polymorphism. We give a type system for deriving types of expressions in the language and prove the type inference algorithm is sound, i.e., it returns a type derivable from the proof system. We also prove that the type the algorithm finds is a “principal” type, i.e., one which characterizes all others. The approach taken here is due to Milner for universal polymorphism. The result is a synthesis of subtype polymorphism and universal polymorphism.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73568", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Stansifer", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/Stansifer88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73578", + "title": "Correct Flow Analysis in Continuation Semantics", + "abstract": "Three semantics-preserving transformations (static replacement, factoring, and combinator selection) are used to convert a continuation semantics into a formal description of a semantic analyzer and code generator. The result of this derivation is a compilation algorithm which performs type checking before code generation so that type-checking instructions are not generated in the target code. Both the flow analysis and the resulting optimizations are proved correct with respect to the original definition of the source language. The proof consists of showing that all restructuring transformations preserve the semantics of the source language. This transformational approach can be extended to derive correctness proofs of other flow analysis and code optimization techniques.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73578", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Margaret", + "last_name": "Montenyohl", + "institution": "" + }, + { + "first_name": "M.", + "last_name": "Wand", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/popl/MontenyohlW88", + "venue": "popl", + "year": 1988 + }, + { + "paper_id": "10.1145/73560.73585", + "title": "Lifetime Analysis of Dynamically Allocated Objects", + "abstract": "The choice of binding time disciplines has major consequences for both the run-time efficiency of programs and the convenience of the language expressing algorithms. Late storage binding time, dynamic allocation, provides the flexibility necessary to implement the complex data structures common in today's object oriented style of programming. In this paper we show that compile-time lifetime analysis can be applied to programs written in languages with static type systems and dynamically allocated objects, to provide earlier storage binding time for objects, while maintaining all the advantages of dynamic allocation.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/73560.73585", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cristina", + "last_name": "Ruggieri", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "ThomasP.", + "last_name": "Murtagh", + "institution": "Williams College" + } + ], + "dblp_key": "conf/popl/RuggieriM88", + "venue": "popl", + "year": 1988 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1989.json b/data/pl_conferences/popl/1989.json new file mode 100644 index 0000000..2c07741 --- /dev/null +++ b/data/pl_conferences/popl/1989.json @@ -0,0 +1,692 @@ +[ + { + "paper_id": "10.1145/75277.75305", + "title": "Incremental Computation via Function Caching", + "abstract": "Article Free Access Share on Incremental computation via function caching Authors: W. Pugh Dept. of Computer Science, Cornell University, Ithaca, NY and Dept. of Comp. Sci., Univ. of Maryland, College Park, Md. Dept. of Computer Science, Cornell University, Ithaca, NY and Dept. of Comp. Sci., Univ. of Maryland, College Park, Md.View Profile , T. Teitelbaum Dept. of Computer Science, Cornell University, Ithaca, NY Dept. of Computer Science, Cornell University, Ithaca, NYView Profile Authors Info & Claims POPL '89: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1989 Pages 315–328https://doi.org/10.1145/75277.75305Published:03 January 1989Publication History 138citation969DownloadsMetricsTotal Citations138Total Downloads969Last 12 Months130Last 6 weeks25 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75305", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William", + "last_name": "Pugh", + "institution": "" + }, + { + "first_name": "Tim", + "last_name": "Teitelbaum", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/PughT89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75289", + "title": "Fully Abstract Compositional Semantics for Logic Programs", + "abstract": "We propose a framework for discussing fully abstract compositional semantics, which exposes the interrelations between the choices of observables, compositions, and meanings. Every choice of observables and compositions determines a unique fully abstract equivalence. A semantics is fully abstract if it induces this equivalence.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75289", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Haim", + "last_name": "Gaifman", + "institution": "Institute of Mathematics and Computer Science" + }, + { + "first_name": "Ehud", + "last_name": "Shapiro", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/popl/GaifmanS89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75303", + "title": "Continuation-Passing, Closure-Passing Style", + "abstract": "We implemented a continuation-passing style (CPS) code generator for ML. Our CPS language is represented as an ML datatype in which all functions are named and most kinds of ill-formed expressions are impossible. We separate the code generation into phases that rewrite this representation into ever-simpler forms. Closures are represented explicitly as records, so that closure strategies can be communicated from one phase to another. No stack is used. Our benchmark data shows that the new method is an improvement over our previous, abstract-machine based code generator.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75303", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "Trevor", + "last_name": "Jim", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/popl/AppelJ89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75293", + "title": "On the Synthesis of a Reactive Module", + "abstract": "We consider the synthesis of a reactive module with input x and output y, which is specified by the linear temporal formula @@@@(x, y). We show that there exists a program satisfying @@@@ iff the branching time formula (∀x) (∃y) A@@@@(x, y) is valid over all tree models. For the restricted case that all variables range over finite domains, the validity problem is decidable, and we present an algorithm for constructing the program whenever it exists. The algorithm is based on a new procedure for checking the emptiness of Rabin automata on infinite trees in time exponential in the number of pairs, but only polynomial in the number of states. This leads to a synthesis algorithm whose complexity is double exponential in the length of the given specification.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75293", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Roni", + "last_name": "Rosner", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/popl/PnueliR89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75291", + "title": "A Fully Abstract Trace Model for Dataflow Networks", + "abstract": "A dataflow network consists of nodes that communicate over perfect FIFO channels. For dataflow networks containing only deterministic nodes, a simple and elegant semantic model has been presented by Kahn. However, for nondeterministic networks, the straight-forward generalization of Kahn's model is not compositional. We present a compositional model for nondeterministic networks, which is fully abstract, i.e., it has added the least amount of extra information to Kahn's model which is necessary for attaining compositionality. The model is based on traces.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75291", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bengt", + "last_name": "Jönsson", + "institution": "Swedish Institute" + } + ], + "dblp_key": "conf/popl/Jonsson89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75292", + "title": "Efficient Temporal Reasoning", + "abstract": "There has been much interest in decision procedures for testing satisfiability (or validity) of formulae in various systems of Temporal Logic. This is due to the potential applications of such decision procedures to mechanical reasoning about correctness of concurrent programs. We show that there exist Temporal Logics that are (i) decidable in polynomial time, and (ii) still useful in applications. One surprising corollary of our results is that the fragment of CTL (Computation Tree Logic) actually used by Emerson & Clarke [EC82] to synthesize concurrent programs from temporal specifications is decidable in polynomial time. Another is that the verification of many correctness properties of concurrent programs (such as in Owicki & Lamport [OL82]) can be efficiently automated. This demonstrates that many useful correctness properties can be expressed with a rather restricted syntax. Finally, our results provide insight into the relation between the structural (i.e., syntactic) complexity of temporal logics and the complexity of their decision problems.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75292", + "conference_name": "POPL", + "authors": [ + { + "first_name": "E. Allen", + "last_name": "Emerson", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Tom", + "last_name": "Sadler", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "J.", + "last_name": "Srinivasan", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/EmersonSS89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75284", + "title": "Typechecking Records and Variants in a Natural Extension of ML", + "abstract": "Strongly typed languages with records may have inclusion rules so that records with more fields can be used instead of records with less fields. But these rules lead to a global treatment of record types as a special case. We solve this problem by giving an ordinary status to records without any ad hoc assertions, replacing inclusion rules by extra information in record types. With this encoding ML naturally extends its polymorphism to records but any other host language will also transmit its power.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75284", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Remy89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75278", + "title": "The Program Dependence Graph and Vectorization", + "abstract": "Previous attempts at vectorizing programs written in a sequential high level language focused on converting control dependences to data dependences using a mechanism known as IF-conversion. After IF-conversion vector optimizations are performed on a data dependence graph. However, IF-conversion is an irrevocable process which can introduce high run-time overhead if the input program is not amenable to vectorization.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75278", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William", + "last_name": "Baxter", + "institution": "University of Wyoming" + }, + { + "first_name": "Henry R.", + "last_name": "Bauer", + "institution": "University of Wyoming" + } + ], + "dblp_key": "conf/popl/BaxterB89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75298", + "title": "Generalized Conjunctive Types", + "abstract": "The definitions of Conjunctive types and their subtype relation, as introduced by Coppo-Dezani, are extended to consider the conjunction as a partial mapping from pairs of types to types, and the subtype relation as a relation between finite sets of types and types. These extensions basically mean that only conjunctions of compatible types are allowed and that the subtype relation is more like, so to speak, the implication in propositional logic. We show that the basic properties of the typing system with conjunctive types are still true. The terms that have a type are exactly the terms that are convertible to a head normal form and it is possible to characterize the terms with normal form by means of the types that are derivable for them in the system. Furthermore, the type assignment defines the interpretation of terms in a very general class of models of the λ-calculus: the models that are based on an information system, as defined by Scott.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75298", + "conference_name": "POPL", + "authors": [ + { + "first_name": "G.", + "last_name": "Monteleone", + "institution": "" + } + ], + "dblp_key": "conf/popl/Monteleone89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75304", + "title": "Copy Elimination in Functional Languages", + "abstract": "Copy elimination is an important optimization for compiling functional languages. Copies arise because these languages lack the concepts of state and variable; hence updating an object involves a copy in a naive implementation. Copies are also possible if proper targeting has not been carried out inside functions and across function calls. Targeting is the proper selection of a storage area for evaluating an expression. By abstracting a collection of functions by a target operator, we compute targets of function bodies that can then be used to define an optimized interpreter to eliminate copies due to updates and copies across function calls. The language we consider is typed lambda calculus with higher-order functions and special constructs for array operations. Our approach can eliminate copies in divide and conquer problems like quicksort and bitonic sort that previous approaches could not handle.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75304", + "conference_name": "POPL", + "authors": [ + { + "first_name": "K.", + "last_name": "Gopinath", + "institution": "Stanford University" + }, + { + "first_name": "John L.", + "last_name": "Hennessy", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/GopinathH89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75288", + "title": "CLP* and Constraint Abstraction", + "abstract": "CLP*(D) is a class of constraint logic programming languages which incorporates the notion of abstraction. Predicates in CLP*(D) are (potentially) infinite rational trees which represent abstractions of constraint expressions. This view of predicates as constraint abstractions was motivated by the language Scheme, where closures are viewed as abstractions of functional expressions. A semantics and an efficient implementation of the language are provided, along with several examples of the novel programming techniques provided by this class of languages.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75288", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Timothy J.", + "last_name": "Hickey", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/popl/Hickey89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75300", + "title": "Partial Order Programming", + "abstract": "We introduce a programming paradigm in which statements are constraints over partial orders. A partial order programming problem has the form minimize u subject to u1 ⊒ v1, u2 ⊒ v2, ··· where u is the goal, and u1 ⊒ v1, u2 ⊒ v2, ··· is a collection of constraints called the program. A solution of the problem is a minimal value for u determined by values for u1, v1, etc. satisfying the constraints. The domain of values here is a partial order, a domain D with ordering relation ⊒.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75300", + "conference_name": "POPL", + "authors": [ + { + "first_name": "D. Stott", + "last_name": "Parker", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/popl/Parker89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75286", + "title": "Polymorphic Unification and ML Typing", + "abstract": "We study the complexity of type inference for a core fragment of ML with lambda abstraction, function application, and the polymorphic let declaration. Our primary technical tool is the unification problem for a class of “polymorphic” type expressions. This form of unification, which we call polymorphic unification, allows us to separate a combinatorial aspect of type inference from the syntax of ML programs. After observing that ML typing is in DEXPTIME, we show that polymorphic unification is PSPACE hard. From this, we prove that recognizing the typable core ML programs is also PSPACE hard. Our lower bound stands in contrast to the common belief that typing ML programs is “efficient,” and to practical experience which suggests that the algorithms commonly used for this task do not slow compilation substantially.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75286", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paris C.", + "last_name": "Kanellakis", + "institution": "Brown University" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/KanellakisM89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75280", + "title": "An Efficient Method of Computing Static Single Assignment Form", + "abstract": "Article An efficient method of computing static single assignment form Share on Authors: R. Cytron IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NY IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NYView Profile , J. Ferrante IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NY IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NYView Profile , B. K. Rosen IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NY IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NYView Profile , M. N. Wegman IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NY IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NYView Profile , F. K. Zadeck Computer Science Dept., Brown University, Providence, RI Computer Science Dept., Brown University, Providence, RIView Profile Authors Info & Claims POPL '89: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1989 Pages 25–35https://doi.org/10.1145/75277.75280Online:03 January 1989Publication History 308citation1,950DownloadsMetricsTotal Citations308Total Downloads1,950Last 12 Months119Last 6 weeks14 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75280", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ron K.", + "last_name": "Cytron", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Jeanne", + "last_name": "Ferrante", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Barry K.", + "last_name": "Rosen", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Mark N.", + "last_name": "Wegman", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "F. K.", + "last_name": "Zadeck", + "institution": "Brown University" + } + ], + "dblp_key": "conf/popl/CytronFRWZ89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75295", + "title": "The Modula-3 Type System", + "abstract": "This paper presents an overview of the programming language Modula-3, and a more detailed description of its type system.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75295", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Donahue", + "institution": "" + }, + { + "first_name": "Mick", + "last_name": "Jordan", + "institution": "" + }, + { + "first_name": "Bill", + "last_name": "Kalsow", + "institution": "" + }, + { + "first_name": "Greg", + "last_name": "Nelson", + "institution": "" + } + ], + "dblp_key": "conf/popl/CardelliDJKN89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75301", + "title": "Temporal Logic Programming is Complete and Expressive", + "abstract": "This paper addresses semantic and expressiveness issues for temporal logic programming and in particular for the TEMPLOG language proposed by Abadi and Manna. Two equivalent formulations of TEMPLOG's declarative semantics are given: in terms of a minimal Herbrand model and in terms of a least fixpoint. By relating these semantics to TEMPLOG's operational semantics, we prove the completeness of the resolution proof system underlying TEMPLOG's execution mechanism. To study TEMPLOG's expressiveness, we consider its propositional version. We show how propositional TEMPLOG programs can be translated into a temporal fixpoint calculus and prove that they can express essentially all regular properties of sequences.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75301", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marianne", + "last_name": "Baudinet", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Baudinet89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75296", + "title": "Dynamic Typing in a Statically-Typed Language", + "abstract": "Statically-typed programming languages allow earlier error checking, better enforcement of disciplined programming styles, and generation of more efficient object code than languages where all type-consistency checks are performed at runtime. However, even in statically-type languages, there is often the need to deal with data whose type cannot be known at compile time. To handle such situations safely, we propose to add a type Dynamic whose values are pairs of a value v and a type tag T where v has the type denoted by T. Instances of Dynamic are built with an explicit tagging construct and inspected with a type-safe typecase construct.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75296", + "conference_name": "POPL", + "authors": [ + { + "first_name": "M.", + "last_name": "Abadi", + "institution": "Digital Equipment (Germany)" + }, + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "Digital Equipment (Germany)" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/AbadiCPP89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75302", + "title": "Realistic Compilation by Program Transformation", + "abstract": "Using concepts from denotational semantics, we have produced a very simple compiler that can be used to compile standard programming languages and produces object code as efficient as that of production compilers. The compiler is based entirely on source-to-source transformations performed on programs that have been translated into an intermediate language resembling the lambda calculus. The output of the compiler, while still in the intermediate language, can be trivially translated into machine code for the target machine. The compilation by transformation strategy is simple: the goal is to remove any dependencies on the intermediate language semantics that the target machine cannot implement directly. Front-ends have been written for Pascal, BASIC, and Scheme and the compiler produces code for the MC68020 microprocessor.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75302", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard", + "last_name": "Kelsey", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/KelseyH89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75299", + "title": "Rewrite, Rewrite, Rewrite, Rewrite, Rewrite", + "abstract": "We study properties of rewrite systems that are not necessarily terminating, but allow instead for transfinite derivations that have a limit.In particular, we give conditions for the existence of a limit and for its uniqueness and relate the operational and algebraic semantics of infinitary theories.We also consider sufficient completeness of hierarchical systems.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75299", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nachum", + "last_name": "Dershowitz", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "S.", + "last_name": "Kaplan", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/popl/DershowitzK89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75294", + "title": "Synthesis of Concurrent Systems with Many Similar Sequential Processes", + "abstract": "Methods for synthesizing concurrent programs from Temporal Logic specifications based on the use of a decision procedure for testing temporal satisfiability have been proposed by Emerson & Clarke [EC82] and Manna & Wolper [MW84]. An important advantage of these synthesis methods is that they obviate the need to manually compose a program and manually construct a proof of its correctness. One only has to formulate a precise problem specification; the synthesis method then mechanically constructs a correct solution. A serious drawback of these methods in practice, however, is that they suffer from the state explosion problem. To synthesize a concurrent system consisting of K sequential processes, each having N states in its local transition diagram, requires construction of the global product-machine having at least NK global states in general. This exponential growth in K makes it infeasible to synthesize systems composed of more than 2 or 3 processes. In this paper, we show how to synthesize concurrent systems consisting of many (i.e., a finite but arbitrarily large number K of) similar sequential processes. Our approach avoids construction of the global product-machine for K processes; instead, it constructs a two process product-machine for a single pair of generic sequential processes. The method is uniform in K, providing a simple template that can be instantiated for each process to yield a solution for any fixed K. The method is also illustrated on synchronization problems from the literature.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75294", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul C.", + "last_name": "Attie", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "E. Allen", + "last_name": "Emerson", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/AttieE89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75307", + "title": "Bisimulation Through Probabilistic Testing", + "abstract": "We propose a language for testing concurrent processes and examine its strength in terms of the processes that are distinguished by a test. By using probabilistic transition systems as the underlying semantic model, we show how a testing algorithm with a probability arbitrary close to 1 can distinguish processes that are not bisimulation equivalent. We also show a similar result (in a slightly stronger form) for a new process relation called 2/3-bisimulation — lying strictly between that of simulation and bisimulation. Finally, the ultimately strength of the testing language is shown to identify an even stronger process relation, called probabilistic bisimulation.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75307", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kim G.", + "last_name": "Larsen", + "institution": "Aalborg University" + }, + { + "first_name": "Arne", + "last_name": "Skou", + "institution": "University of Sussex" + } + ], + "dblp_key": "conf/popl/LarsenS89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75282", + "title": "Fast Interprocedural Alias Analysis", + "abstract": "We present a new algorithm for computing interprocedural aliases due to passing parameters by reference. This algorithm runs in O(N2+NE) time and, when combined with algorithms for alias-free, flow-insensitive data-flow problems, yields algorithms for solution of the general flow-insensitive problems that also run in O(N2+NE) time.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75282", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/CooperK89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75281", + "title": "Resolving Circularity in Attribute Grammars with Applications to Data Flow Analysis", + "abstract": "Circular attribute grammars appear in many data flow analysis problems. As one way of making the notion useful, an automatic translation of circular attribute grammars to equivalent non-circular attribute grammars is presented. It is shown that for circular attribute grammars that arise in many data flow analysis problems, the translation does not increase the asymptotic complexity of the semantic equations. Therefore, the translation may be used in conjunction with any evaluator generator to automate the development of efficient data flow analysis algorithms. As a result, the integration of such algorithms with other parts of a compiler becomes easier.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75281", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shmuel", + "last_name": "Sagiv", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Orit", + "last_name": "Edelstein", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Nissim", + "last_name": "Francez", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Rodeh", + "institution": "IBM Research - Haifa" + } + ], + "dblp_key": "conf/popl/SagivEFR89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75297", + "title": "Relating Models of Polymorphism", + "abstract": "A new general notion of model for the polymorphic lambda calculus based on the simple idea of a universe, is proposed. Although impossible in nonconstructive set theory, the notion is unproblematic for constructive sets, yields completeness and initiality theorems, and can be used to unify and relate many different notions of model that have been proposed in the literature, including those that extend the basic calculus with additional features such as fixpoints or a type of all types. Moreover, the polymorphic lambda calculus and Martin-Lof type theory are related by a map of logics. A categorical and initial model semantics is given for the basic calculus and for richer calculi that extend the basic one with fixpoints or with a type of all types.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75297", + "conference_name": "POPL", + "authors": [ + { + "first_name": "José", + "last_name": "Meseguer", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Meseguer89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75285", + "title": "Extracting F(omega)'s Programs from Proofs in the Calculus of Constructions", + "abstract": "We define in this paper a notion of realizability for the Calculus of Constructions. The extracted programs are terms of the Calculus that do not contain dependent types. We introduce a distinction between informative and non-informative propositions. This distinction allows the removal of the “logical” part in the development of a program. We show also how to use our notion of realizability in order to interpret various axioms like the axiom of choice or the induction on integers. A practical example of development of program is given in the appendix.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75285", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christine", + "last_name": "Paulin-Mohring", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Paulin-Mohring89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75306", + "title": "Unified Algebras and Modules", + "abstract": "This paper concerns the algebraic specification of abstract data types. It introduces and motivates the recently-developed framework of unified algebras, and provides a practical notation for their modular specification. It also compares unified algebras with the well-known framework of order-sorted algebras, which underlies the OBJ specification language.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75306", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter D.", + "last_name": "Mosses", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/Mosses89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75279", + "title": "A Rewriting Semantics for Program Dependence Graphs", + "abstract": "Program dependence graphs are an important program representation technique for use in vectorization, parallelization and programming environments. We present a graph rewriting semantics for program dependence graphs and prove the equivalence between the program dependence graphs semantics and the operational semantics for programs. We then propose a framework for studying program transformations using program dependence graphs and a programming language calculus based on this rewriting semantics.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75279", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R.", + "last_name": "Parsons-Selke", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/Selke89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75283", + "title": "How to Make ad-hoc Polymorphism Less ad-hoc", + "abstract": "This paper presents type classes, a new approach to ad-hoc polymorphism. Type classes permit overloading of arithmetic operators such as multiplication, and generalise the “eqtype variables” of Standard ML. Type classes extend the Hindley/Milner polymorphic type system, and provide a new approach to issues that arise in object-oriented programming, bounded type quantification, and abstract data types. This paper provides an informal introduction to type classes, and defines them formally by means of type inference rules.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75283", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Glasgow" + }, + { + "first_name": "Stephen", + "last_name": "Blott", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/popl/WadlerB89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75287", + "title": "Moded Type Systems for Logic Programming", + "abstract": "Most of the theoretical work on the semantics of logic programs assumes an interpreter that provides a complete resolution procedure. In contrast, for reasons of efficiency, most logic programming languages are built around incomplete procedures. This difference is rooted in Prolog, which evaluates resolvent trees in a depth-first rather than a breadth-first order. The gap is widened by some equational logic languages, which combine the incompleteness of depth-first evaluation with incomplete approximations to equational unification. Because of this gap, it is unsound to reason about logic programs using their declarative semantics. This in turn makes it difficult to develop abstraction mechanisms that can be used to partition a logic program into independently specifiable modules.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75287", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kathy", + "last_name": "Yelick", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Joseph L.", + "last_name": "Zachary", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/YelickZ89", + "venue": "popl", + "year": 1989 + }, + { + "paper_id": "10.1145/75277.75290", + "title": "A Calculus of Higher Order Communicating Systems", + "abstract": "In this paper we present A Calculus of Higher Order Communicating Systems. This calculus considers sending and receiving processes to be as fundamental as nondeterminism and parallel composition.", + "date": "1989-01-01", + "link": "https://doi.org/10.1145/75277.75290", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bent", + "last_name": "Thomsen", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/Thomsen89", + "venue": "popl", + "year": 1989 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1990.json b/data/pl_conferences/popl/1990.json new file mode 100644 index 0000000..08027d9 --- /dev/null +++ b/data/pl_conferences/popl/1990.json @@ -0,0 +1,695 @@ +[ + { + "paper_id": "10.1145/96709.96733", + "title": "Concurrent Constraint Programming", + "abstract": "This paper presents a new and very rich class of (con-current) programming languages, based on the notion of comput.ing with parhal information, and the con-commitant notions of consistency and entailment. ’ In this framework, computation emerges from the inter-action of concurrently executing agents that communi-cate by placing, checking and instantiating constraints on shared variables. Such a view of computation is in-teresting in the context of programming languages be-cause of the ability to represent and manipulate partial information about the domain of discourse, in the con-text of concurrency because of the use of constraints for communication and control, and in the context of AI because of the availability of simple yet powerful mechanisms for controlling inference, and the promise that very rich representational/programming languages, sharing the same set of abstract properties, may be pos-sible. To reflect this view of computation, [Sar89] develops the cc family of languages. We present here one mem-ber of the family, CC(.L,+) (pronounced “cc with Ask and Choose”) which provides the basic operations of blocking Ask and atomic Tell and an algebra of be-haviors closed under prefixing, indeterministic choice, interleaving, and hiding, and provides a mutual recur-sion operator. cc(.L,-t) is (intentionally!) very similar to Milner’s CCS, but for the radically different under-lying concept of communication, which, in fact, pro-’ The class is founded on the notion of “constraint logic pro-gramming ” [JL87,Mah87], fundamentally generalizes concurrent logic programming, and is the subject of the first author’s disser-tation [Sar89], on which this paper is substantially based.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96733", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vijay A.", + "last_name": "Saraswat", + "institution": "Xerox (United States)" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/SaraswatR90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96738", + "title": "Automata-Driven Indexing of Prolog Clauses", + "abstract": "Indexing Prolog clauses is an important optimization step that reduces the number of clauses on which unification will be performed and can avoid the pushing of a choice point. It is quite desirable to increase the number of functors used in indexing as this can considerably reduce the size of the filtered set. However this can cause an enormous increase in running time if indexing is done naively. This paper describes a new technique for indexing that utilizes all the functors in a clause-head. More importantly, in spite of using all the functors, this technique is still able to quickly select relevant clause-heads at run time. This is made possible primarily by a finite-state automaton that guides the indexing process. The automaton is constructed at compile time by preprocessing all the clause-heads.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96738", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R.", + "last_name": "Ramesh", + "institution": "The University of Texas at Dallas" + }, + { + "first_name": "I. V.", + "last_name": "Ramakrishnan", + "institution": "State University of New York" + }, + { + "first_name": "David S.", + "last_name": "Warren", + "institution": "State University of New York" + } + ], + "dblp_key": "conf/popl/RameshRW90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96744", + "title": "Higher-Order Modules and the Phase Distinction", + "abstract": "In earlier work, we used a typed function calculus, XML, with dependent types to analyze several aspects of the Standard ML type system. In this paper, we introduce a refinement of XML with a clear compile-time/run-time phase distinction, and a direct compile-time type checking algorithm. The calculus uses a finer separation of types into universes than XML and enforces the phase distinction using a nonstandard equational theory for module and signature expressions. While unusual from a type-theoretic point of view, the nonstandard equational theory arises naturally from the well-known Grothendieck construction on an indexed category.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96744", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + }, + { + "first_name": "Eugenio", + "last_name": "Moggi", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/HarperMM90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96735", + "title": "Combining Generational and Conservative Garbage Collection: Framework and Implementations", + "abstract": "Two key ideas in garbage collection are generational collection and conservative pointer-finding. Generational collection and conservative pointer-finding are hard to use together, because generational collection is usually expressed in terms of copying objects, while conservative pointer-finding precludes copying. We present a new framework for defining garbage collectors. When applied to generational collection, it generalizes the notion of younger/older to a partial order. It can describe traditional generational and conservative techniques, and lends itself to combining different techniques in novel ways. We study in particular two new garbage collectors inspired by this framework. Both these collectors use conservative pointer-finding. The first one is based on a rewrite of an existing trace-and-sweep collector to use one level of generation. The second one has a single parameter, which controls how objects are partitioned into generations: the value of this parameter can be changed dynamically with no overhead. We have implemented both collectors and present measurements of their performance in practice.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96735", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Demmers", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Mark", + "last_name": "Weiser", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Barry", + "last_name": "Hayes", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Hans J.", + "last_name": "Boehm", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Daniel G.", + "last_name": "Bobrow", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Scott", + "last_name": "Shenker", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/DemersWHBBS90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96721", + "title": "Inheritance Is Not Subtyping", + "abstract": "In typed object-oriented languages the subtype relation is typically based on the inheritance hierarchy. This approach, however, leads either to insecure type-systems or to restrictions on inheritance that make it less flexible than untyped Smalltalk inheritance. We present a new typed model of inheritance that allows more of the flexibility of Smalltalk inheritance within a statically-typed system. Significant features of our analysis are the introduction of polymorphism into the typing of inheritance and the uniform application of inheritance to objects, classes and types. The resulting notion of type inheritance allows us to show that the type of an inherited object is an inherited type but not always a subtype.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96721", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Walter L.", + "last_name": "Hill", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Peter S.", + "last_name": "Canning", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/popl/CookHC90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96717", + "title": "The Chemical Abstract Machine", + "abstract": "We introduce a new kind of abstract machine based on the chemical metaphor used in the Γ language of Banâtre & al. States of a machine are chemical solutions where floating molecules can interact according to reaction rules. Solutions can be stratified by encapsulating subsolutions within membranes that force reactions to occur locally. We illustrate the use of this model by describing the operational semantics of the TCCS and CCS process calculi. We also show how to extract a higher-order concurrent λ-calculus out of the basic concepts of the chemical abstract machine.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96717", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gérard", + "last_name": "Berry", + "institution": "École Nationale Supérieure des Mines de Paris" + }, + { + "first_name": "Gérard", + "last_name": "Boudol", + "institution": "Research Centre Inria Sophia Antipolis - Méditerranée" + } + ], + "dblp_key": "conf/popl/BerryB90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96718", + "title": "Interaction Nets", + "abstract": "We propose a new kind of programming language, with the following features:a simple graph rewriting semantics,a complete symmetry between constructors and destructors,a type discipline for deterministic and deadlock-free (microscopic) parallelism.Interaction nets generalize Girard's proof nets of linear logic and illustrate the advantage of an integrated logic approach, as opposed to the external one. In other words, we did not try to design a logic describing the behaviour of some given computational system, but a programming language for which the type discipline is already (almost) a logic.In fact, we shall scarcely refer to logic, because we adopt a naive and pragmatic style. A typical application we have in mind for this language is the design of interactive softwares such as editors or window managers.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96718", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yves", + "last_name": "Lafont", + "institution": "École Normale Supérieure - PSL" + } + ], + "dblp_key": "conf/popl/Lafont90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96711", + "title": "An Algorithm for Optimal Lambda Calculus Reduction", + "abstract": "We present an algorithm for lambda expression reduction that avoids any copying that could later cause duplication of work. It is optimal in the sense defined by Lévy. The basis of the algorithm is a graphical representation of the kinds of commonality that can arise from substitutions; the idea can be adapted to represent other kinds of expressions besides lambda expressions. The algorithm is also well suited to parallel implementations, consisting of a fixed set of local graph rewrite rules.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96711", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Lamping", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/Lamping90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96710", + "title": "On Laziness and Optimality in Lambda Interpreters: Tools for Specification and Analysis", + "abstract": "In this paper, we introduce a new formal system, $\\Lambda CCL$, based on Curien's Categorical Combinators [Cur86a]. We show that $\\Lambda CCL$ has properties that make it especially suitable for analysis and implementation of a wide range of $\\lambda$-reduction schemes using shared environments, closures, or $\\lambda$-terms. In particular, the term structure of $\\Lamda CCL$ is very closely related to the structure of existing abstract machines for $\\lambda$-reduction. $\\Lambda CCL$ is powerful enough to mimic arbitrary (strong) reduction in the $\\lambda$-calculus, yet in contrast to the systems in [Cur86a] it is also confluent (on ground terms).As an example of the practical utility of this formalism, we use it to specify a simple lazy interpreter for the $\\lambda$-calculus, whose correctness follows trivially from the properties of $\\LambdaCCL$. We then describe a labeled variant of $\\Lambda CCL, \\Lambda CCL^{L}$, which can be used as a tool to determine the degree of \"laziness\" possessed by various $\\lambda$-reduction schemes. In particular, $\\Lambda CCL^{L}$ is applied to the problem of optimal reduction in the $\\lambda$-calculus. A reduction scheme for the $\\lambda$-calculus is optimal if the number of redex contractions that must be performed in the course of reducing any $\\lambda$-term to a normal form (if one exists) is guaranteed to be minimal. Results of Levy [Lev78, Lev80] showed that for a natural class of reduction strategies allowing shared redexes, optimal reductions were, at least in principle, possible. He conjectured that an optimal reduction strategy might be realized in practice using shared closures and environments as well as shared $\\lambda$-terms. However, using $\\Lambda CCL^{L}$, we show that the sharing allowed by environments and closures in $\\Lambda CCL$ as implemented using standard term graph-rewriting techniques [BvEG$^{+}$87] is insufficient to implement optimal reduction.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96710", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John K.", + "last_name": "Field", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Field90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96739", + "title": "Fairness and Hyperfairness in Multi-Party Interactions", + "abstract": "In this paper, a new fairness notion is proposed for languages with multi-party interactions as the sole interprocess synchronization and communication primitive. The main advantage of this fairness notion is the elimination of starvation occurring solely due to race conditions (i.e., ordering of independent actions). Also, this is the first fairness notion for such languages which is fully-adequate with respect to the criteria presented in [AFK88]. The paper defines the notion, proves its properties, and presents examples of its usefulness.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96739", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul C.", + "last_name": "Attie", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Nissim", + "last_name": "Francez", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Orna", + "last_name": "Grümberg", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/AttieFG90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96724", + "title": "A Relationship Between Abstract Interpretation and Projection Analysis", + "abstract": "Abstract interpretation and projection analysis are two techniques for finding out information about lazy functional programs. Two typical uses of these techniques are speeding up sequential implementations, and the introduction of parallelism into parallel implementations.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96724", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Geoffrey", + "last_name": "Burn", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/Burn90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96731", + "title": "Making Asynchronous Parallelism Safe for the World", + "abstract": "We need a programming model that combines the advantages of the synchronous and asynchronous parallel styles. Synchronous programs are determinate (thus easier to reason about) and avoid synchronization overheads. Asynchronous programs are more flexible and handle conditionals more efficiently.Here we propose a programming model with the benefits of both styles. We allow asynchronous threads of control but restrict shared-memory accesses and other side effects so as to prevent the behavior of the program from depending on any accidents of execution order that can arise from the indeterminacy of the asynchronous process model.These restrictions may be enforced either dynamically (at run time) or statically (at compile time). In this paper we concentrate on dynamic enforcement, and exhibit an implementation of a parallel dialect of Scheme based on these ideas. A single successful execution of a parallel program in this model constitutes a proof that the program is free of race conditions (for that particular set of input data).We also speculate on a design for a programming language using static enforcement. The notion of distinctness is important to proofs of noninterference. An appropriately designed programming language must support such concepts as “all the elements of this array are distinct,” perhaps through its type system.This parallel programming model does not support all styles of parallel programming, but we argue that it can support a large class of interesting algorithms with considerably greater efficiency (in some cases) than a strict SIMD approach and considerably greater safety (in all cases) than a full-blown MIMD approach.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96731", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "" + } + ], + "dblp_key": "conf/popl/Steele90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96748", + "title": "Deciding ML Typability is Complete for Deterministic Exponential Time", + "abstract": "A well known but incorrect piece of functional programming folklore is that ML expressions can be efficiently typed in polynomial time. In probing the truth of that folklore, various researchers, including Wand, Buneman, Kanellakis, and Mitchell, constructed simple counterexamples consisting of typable ML programs having length n, with principal types having Ω(2cn) distinct type variables and length Ω(22cn). When the types associated with these ML constructions were represented as directed acyclic graphs, their sizes grew as Ω(2cn). The folklore was even more strongly contradicted by the recent result of Kanellakis and Mitchell that simply deciding whether or not an ML expression is typable is PSPACE-hard.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96748", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/popl/Mairson90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96729", + "title": "A Finite Presentation Theorem for Approximating Logic Programs", + "abstract": "The notion of Cartesian closure on a set of unifiers has been used to define approximations of the least models of logic programs. Such approximations, often called types, are not known to be recursive. In this paper, we use Cartesian closure to define a similar, but more accurate, approximation. The main result proves that our approximation is not only recursive, but that it can be finitely represented in the form of a cyclic term graph. This explicit representation can be used as a starting point for logic program analyzers.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96729", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nevin", + "last_name": "Heintze", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Joxan", + "last_name": "Jaffar", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/HeintzeJ90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96734", + "title": "Parallelism in Logic Programs", + "abstract": "Article Free Access Share on Parallelism in logic programs Author: Raghu Ramakrishnan Computer Sciences Department, University of Wisconsin-Madison, WI Computer Sciences Department, University of Wisconsin-Madison, WIView Profile Authors Info & Claims POPL '90: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesDecember 1989 Pages 246–260https://doi.org/10.1145/96709.96734Online:01 December 1989Publication History 1citation225DownloadsMetricsTotal Citations1Total Downloads225Last 12 Months10Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96734", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Raghu", + "last_name": "Ramakrishnan", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/Ramakrishnan90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96741", + "title": "Relating Total and Partial Correctness Interpretations of Non-Deterministic Programs", + "abstract": "The purpose of this paper is to discuss the relationship between the interpretations of non-deterministic programs using the upper (total correctness) powerdomain on the one hand and the lower (partial correctness) powerdomain on the other. It is shown that there is a close semantic relationship between these two interpretations which suggests the formulation of a new operator called the mixed powerdomain. It is shown that the mixed powerdomain has many pleasing domain-theoretic and algebraic properties. The mixed powerdomain is closely related to new powerdomains which have been recently investigated as mathematical models of partial information in databases. Some of the basic intuitions captured by such structures may have uses for the specification of non-deterministic computations. The paper includes a sample non-deterministic programming language and a semantics using the mixed powerdomain.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96741", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Carl A.", + "last_name": "Gunter", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/Gunter90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96742", + "title": "On Oraclizable Networks and Kahn's Principle", + "abstract": "In this paper we investigate generalizations of Kahn's principle to nondeterministic dataflow networks. Specifically, we show that for the class of \"oraclizable\" networks a semantic model in which networks are represented by certain sets of continuous functions is fully abstract and has the fixed-point property. We go on to show that the oraclizable networks are the largest class representable by this model, and are a proper superclass of the networks implementable with the infinity fair merge primitive. Finally, we use this characterization to show that infinity fair merge networks and oraclizable networks are proper subclasses of the networks with Egli-Milner monotone input-output relations.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96742", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James R.", + "last_name": "Russell", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Russell90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96722", + "title": "A Type System for Smalltalk", + "abstract": "This paper describes a type system for Smalltalk that is type-safe, that allows most Smalltalk programs to be type-checked, and that can be used as the basis of an optimizing compiler.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96722", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Justin O.", + "last_name": "Graver", + "institution": "University of Florida" + }, + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/GraverJ90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96712", + "title": "Explicit Substitutions", + "abstract": "The λσ-calculus is a refinement of the λ-calculus where substitutions are manipulated explicitly. The λσ-calculus provides a setting for studying the theory of substitutions, with pleasant mathematical properties. It is also a useful bridge between the classical λ-calculus and concrete implementations.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96712", + "conference_name": "POPL", + "authors": [ + { + "first_name": "M.", + "last_name": "Abadi", + "institution": "Digital Equipment (Germany)" + }, + { + "first_name": "Pierre-Louis", + "last_name": "Curien", + "institution": "École Normale Supérieure d'Abidjan" + }, + { + "first_name": "Jean-Jacques", + "last_name": "Lévy", + "institution": "Digital Equipment (Germany)" + } + ], + "dblp_key": "conf/popl/AbadiCCL90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96714", + "title": "A Formulae-as-Types Notion of Control", + "abstract": "The programming language Scheme contains the control construct call/cc that allows access to the current continuation (the current control context). This, in effect, provides Scheme with first-class labels and jumps. We show that the well-known formulae-as-types correspondence, which relates a constructive proof of a formula α to a program of type α, can be extended to a typed Idealized Scheme. What is surprising about this correspondence is that it relates classical proofs to typed programs. The existence of computationally interesting “classical programs” —programs of type α, where α holds classically, but not constructively — is illustrated by the definition of conjunctively, disjunctive, and existential types using standard classical definitions. We also prove that all evaluations of typed terms in Idealized Scheme are finite.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96714", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Timothy G.", + "last_name": "Griffin", + "institution": "Universidade Estadual de Campinas (UNICAMP)" + } + ], + "dblp_key": "conf/popl/Griffin90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96737", + "title": "Scheduling Time-Critical Instructions on RISC Machines", + "abstract": "We present a polynomial time algorithm for constructing a minimum completion time schedule of instructions from a basic block on RISC machines such as the Sun SPARC, the IBM 801, the Berkeley RISC machine, and the HP Precision Architecture. Our algorithm can be used as a heuristic for RISC processors with longer pipelines, for which there is no known optimal algorithm. Our algorithm can also handle time-critical instructions, which are instructions that have to be completed by a specific time. Time-critical instructions occur in some real-time computations, and can also be used to make shared resources such as registers quickly available for reuse. We also prove that in the absence of time-critical constraints, a greedy scheduling algorithm always produces a schedule for a target machine with multiple identical pipelines that has a length less than twice that of an optimal schedule. The behavior of the heuristic is of interest because, as we show, the instruction scheduling problem becomes NP-hard for arbitrary length pipelines, even when the basic block of code being input consists of only several independent streams of straightline code, and there are no time-critical constraints, Finally, we prove that the problem becomes NP-hard even for small pipelines, no time-critical constraints, and input of several independent streams of straightline code if either there is only a single register or if no two instructions are allowed to complete simultaneously because of some shared resource such as a bus", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96737", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krishna V.", + "last_name": "Palem", + "institution": "" + }, + { + "first_name": "Barbara", + "last_name": "Sımons", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/PalemS90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96746", + "title": "Safe Run-time Overloading", + "abstract": "We present a functional language featuring a form of dynamic overloading akin to message passing in object oriented languages. We give a dynamic semantics describing a non-deterministic evaluation, as well as a type discipline (static semantics) supporting type inference. The type system ensures that a well-typed program has a correct execution, unique up to a semantic equivalence relation, and allows this execution to proceed deterministically, while resolving overloading at run-time.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96746", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Rouaix", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Rouaix90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96725", + "title": "On Determining Lifetime and Aliasing of Dynamically Allocated Data in Higher-Order Functional Specifications", + "abstract": "We present a static analysis method for determining aliasing and lifetime of dynamically allocated data in lexically scoped, higher-order, strict and polymorphic languages with first class continuations. The goal is validate program transformations that introduce imperative constructs such as destructive updatings, stack allocations and explicit deallocations in order to reduce the run-time memory management overhead. Our method is based on an operational model of higher order functional programs from which we construct statically computable abstractions using the abstract interpretation framework. Our method provides a solution to a problem left open [Hudak 86]: determining isolation of data in the case of higher order languages with structured data.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96725", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Deutsch", + "institution": "École Polytechnique" + } + ], + "dblp_key": "conf/popl/Deutsch90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96716", + "title": "Computable processes", + "abstract": "In this paper we study concurrent, asynchronous processes and functions on them which can be programmed using the (full) unfair or the fair merge operations. The main result is a normal form theorem for these (relatively) “computable process functions” which implies that although they can be very complex when viewed as classical set-functions, they are all “loosely implementable” in the sense of Park [7]. We also announce a variation and a substantial strengthening of the main “transfer principle” of [4] which have applications to the semantics and logic of programming languages with interactive (deterministic) or concurrent (non-deterministic) constructs.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96716", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yiannis N.", + "last_name": "Moschovakis", + "institution": "" + } + ], + "dblp_key": "conf/popl/Moschovakis90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96730", + "title": "Program Transformation in the Presence of Errors", + "abstract": "Language designers and implementors have avoided specifying and preserving the meaning of programs that produce errors. This is apparently because being forced to preserve error behavior severely limits the scope of program optimization, even for correct programs. However, preserving error behavior is desirable for debugging, and error behavior must be preserved in any language that permits user-generated exceptions.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96730", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "IBM (United States)" + }, + { + "first_name": "Edward L.", + "last_name": "Wimmers", + "institution": "IBM (United States)" + }, + { + "first_name": "John H.", + "last_name": "Williams", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/AikenWW90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96715", + "title": "Implicative Formulae in the "Proofs as Computations" Analogy", + "abstract": "In [As87] a correspondence between the subset of Linear Logic [Gi86] involving the conjunctive tensor product only and Place/Transition Petri Nets [Rei85] is established. In this correspondence, formulae are regarded as distributed states and provable sequents are computations in the net. Developing this idea, Martì-Oliet and Meseguer [MaM89] have suggested that all the other computations of Linear Logic, which do not have an immediate correspondence with Petri Nets, should be regarded as “gedanken” or idealized processes, providing a richer language for the specification and the study of properties of distributed computations. In this paper we apply this program to the fundamental connective of linear implication. We prove that the introduction of linear implication allows us to observe the net at a lower, more decentralized level of atomicity, where the preemption of each resource needed for the firing of a transition is represented as a separate move. We give a conservative theorem relating computations at different levels of abstraction. The categorical semantics establishes a tight correspondence among Petri nets, monoidal closed categories and tensor theories, reminiscent of the well known relation among functional languages, Cartesian closed categories and intuitionistic logic [LS86]. The identification of computations in the categorical model naturally suggests the generalisation of the notion of process [DMM89] at the lower level of atomicity.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96715", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Asperti", + "institution": "University of Pisa" + }, + { + "first_name": "Gian-Luigi", + "last_name": "Ferrari", + "institution": "University of Pisa" + }, + { + "first_name": "Roberto", + "last_name": "Gorrieri", + "institution": "University of Pisa" + } + ], + "dblp_key": "conf/popl/AspertiFG90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96743", + "title": "On the Relations Computable by a Class of Concurrent Automata", + "abstract": "We consider monotone input/output automata, which model a usefully large class of dataflow networks of indeterminate (or nonfunctional) processes. We obtain a characterization of the relations computable by these automata, which states that a relation R : X ! 2 Y (viewed as a &quot;nondeterministic function&quot;) is the input /output relation of an automaton iff there exists a certain kind of Scott domain D, a continuous function F : X ! [D ! Y ] and a continuous function G : X ! P(D), such that R(x) = F (x) y (G(x)) for all inputs x 2 X. Here P denotes a certain powerdomain operator, and y denotes the pointwise extension to the powerdomain of a function on the underlying domain. An attractive feature of this result is that it specializes to two subclasses of automata, determinate automata, for which G is single-valued, and semi-determinate automata, for which G is a constant function. A corollary of the latter result is the impossibility of implementing &quot;angelic merge&quot; by a network of de...", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96743", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eugene W.", + "last_name": "Stark", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/popl/Stark90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96747", + "title": "Quasi-Static Typing", + "abstract": "We present a new approach to dynamic typing in a static framework. Our main innovation is the use of structural subtyping for dynamic types based on the idea that possible dynamic typing as a property should be inherited by objects of all types. Two properties of our system set it apart from existing systems which combine static and dynamic typing: all tagging and checking takes place via implicit coercions, and the semantics of dynamic typing is representation independent. The latter property leads to a significant increase in expressive power—for instance it allows us to define a general call-by-value fixpoint operator.The resulting system—which we call quasi-static typing—is a seamless merger of static and dynamic typing. The system divides programs into three categories: well-typed, ill-typed and ambivalent programs. Ill-typed programs contain expressions that are guaranteed to go wrong. Run-time checking is limited to doubtful function applications in ambivalent programs. Conceptually, quasi-static typing takes place in an unusual two-phase process—a first phase infers types and coercions and a second plausibility checking phase identifies ill-typed programs. The typing rules allow minimal typing judgements and plausibility checking can be characterized as simplification via a canonical set of rewrite rules. The two phase process can therefore be implemented with a one pass algorithm.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96747", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Satish R.", + "last_name": "Thatté", + "institution": "Clarkson University" + } + ], + "dblp_key": "conf/popl/Thatte90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96719", + "title": "Toward a Typed Foundation for Method Specialization and Inheritance", + "abstract": "This paper discusses the phenomenon of method specialization in object-oriented programming languages. A typed function calculus of objects and classes is presented, featuring method specialization when methods are added or redefined. The soundness of the typing rules (without subtyping) is suggested by a translation into a more traditional calculus with recursively-defined record types. However, semantic questions regarding the subtype relation on classes remain open.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96719", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Mitchell90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96728", + "title": "An Efficient Hybrid Algorithm for Incremental Data Flow Analysis", + "abstract": "Our exhaustive and incremental hybrid data flow analysis algorithms, based on iteration and elimination techniques, are designed for incremental update of a wide variety of monotone data flow problems in response to source program changes. Unlike previous incremental iterative methods, this incremental algorithm efficiently computes precise and correct solutions. We give theoretical results on the imprecision of restarting iteration for incremental update by fixed point iteration which provided motivation for our algorithm design. Described intuitively, the main algorithm idea is to factor the data flow solution on strong connected components of the flow graph into local and external parts, solving for the local parts by iteration and propagating these effects on the condensation of the flow graph to obtain the entire data flow solution. The incremental hybrid algorithm re-performs those algorithm steps affected by the program changes.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96728", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas J.", + "last_name": "Marlowe", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers Sexual and Reproductive Health and Rights" + } + ], + "dblp_key": "conf/popl/MarloweR90", + "venue": "popl", + "year": 1990 + }, + { + "paper_id": "10.1145/96709.96727", + "title": "Small Domains Spell Fast Strictness Analysis", + "abstract": "Use of strictness analysis in parallel evaluation and optimization of lazy functional languages is well known. The first formal treatment of strictness analysis appeared in Mycroft's seminal work which however dealt only with flat domains. Unlike flat domains, strictness analysis on non-flat domains involves determining how a function transforms a demand (degree of strictness) on its output into a demand on its arguments. Solutions to this problem in its full generality require large domains and appear both complex and expensive to implement. However, only two kinds of demands arise naturally in lazy normalization of terms, viz., e-demand (normal form needed) and d-demand (root stable or head normal form needed). Based on this observation, we identify three useful forms of strictness for non-flat domains - ee, dd and de. Each of these three forms of strictness play an important role in evaluation of functional programs. Specifically, ee strictness is used for transforming call-by-need to call-by-value and dd strictness is useful in repairing violations of strong sequentiality of equational programs as well as in a critical optimization step used in rewriting implementations of such languages. We present intuitively simple methods to compute them. Our methods are computationally efficient as they are based on small domains (1 point for ee and dd and 2 points for de). They are powerful enough to extract all useful strictness information in practice and are general enough to handle functions defined by rewrite rules. We are able to reason about all user defined data types within a single framework and also handle polymorphism.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/96709.96727", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R.", + "last_name": "Sekar", + "institution": "Stony Brook University" + }, + { + "first_name": "Shaunak", + "last_name": "Pawagi", + "institution": "Stony Brook University" + }, + { + "first_name": "I. V.", + "last_name": "Ramarkrishnan", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/popl/SekarPR90", + "venue": "popl", + "year": 1990 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1991.json b/data/pl_conferences/popl/1991.json new file mode 100644 index 0000000..a1c8a7d --- /dev/null +++ b/data/pl_conferences/popl/1991.json @@ -0,0 +1,712 @@ +[ + { + "paper_id": "10.1145/99583.99603", + "title": "A Record Calculus Based on Symmetric Concatenation", + "abstract": "Abstract: \"A number of different formulations of record calculi have been proposed. These may be broadly classified according to whether or not they are based on subsumption and whether they admit the specification of positive or negative information about record type variables. The systems considered by Wand (and their derivatives) may be classified as subsumption-free, negative information calculi. Early systems of bounded quantification are subsumption-based, and admit specification only of positive information. More recently, Cardelli and Mitchell have proposed a subsumption-based system featuring both positive and negative constraints, and, in earlier work, the authors have considered a subsumption-free variant. None of these systems copes well with the \"symmetric merge\" operation in which two records are considered mergeable only if they have no overlapping fields.To address this question, Cardelli and Mitchell suggest an extension to their subsumption-based calculus to admit mergeability constrains [sic]. In this paper we show that a subsumption-free calculus based only on mergeability constraints suffices not only for symmetric merge, but also for a wide class of other record operations. Moreover, the proposed calculus avoids some known difficulties with recursive types associated with positive-information calculi; in particular, the motivating examples for F-bounded quantification may be readily expressed without extending the language. A number of object oriented features, such as those considered by Wand and Buneman and Ohori, may also be represented naturally in this calculus.\"", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99603", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/HarperP91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99590", + "title": "How to Make Destructive Updates Less Destructive", + "abstract": "We present a safe embedding of mutable data structures in functional languages. With safety we mean that confluence and (in some sense) referential transparency are maintained. We develop a static criterion based on abstract interpretation which checks that any side-effect which a function may exert via a destructive update remains invisible. The technique opens up the possibility of designing safe and efficient wide-spectrum languages which combine functional and imperative language constructs.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99590", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/Odersky91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99629", + "title": "Temporal Proof Methodologies for Real-time Systems", + "abstract": ". We extend the specification language of temporal logic, the corresponding verification framework, and the underlying computational model to deal with real-time properties of concurrent and reactive systems. A global, discrete, and asynchronous clock is incorporated into the model by defining the abstract notion of a real-time transition system as a conservative extension of traditional transition systems: qualitative fairness requirements are replaced (and superseded) by quantitative lower-bound and upperbound real-time requirements for transitions. We show how to model real-time systems that communicate either through shared variables or by message passing, and how to represent the important real-time constructs of priorities (interrupts), scheduling, and timeouts in this framework. Two styles for the specification of real-time properties are presented. The first style uses bounded versions of the temporal operators; the real-time requirements expressed in this style are classified ...", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99629", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tom", + "last_name": "Henzinger", + "institution": "Stanford University" + }, + { + "first_name": "Zohar", + "last_name": "Manna", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/popl/HenzingerMP91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99602", + "title": "The Complexity of Type Inference for Higher-Order Typed Lambda Calculi", + "abstract": "We analyze the computational complexity of type inference for untyped A.terms in the second-order polymorphic typed ~-calculus (l'z) invented by Giprove useful in the ultimate resolution of the complexity of the type inference problem.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99602", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fritz", + "last_name": "Henglein", + "institution": "Courant Institute of Mathematical Sciences" + }, + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/popl/HengleinM91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99626", + "title": "A Logical View of Composition and Refinement", + "abstract": "We define two logics of safety specifications for reactive systems. The logics provide a setting for the study of composition and refinement rules, and a framework for the use of the modular specification methods that these rules underpin. The two logics arise naturally from extant specification approaches; one of the logics is intuitionistic, while the other one is linear.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99626", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/AbadiP91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99618", + "title": "Optimal Derivations in Weak Lambda-calculi and in Orthogonal Terms Rewriting Systems", + "abstract": "Article Free Access Share on Optimal derivations in weak lambda-calculi and in orthogonal term rewriting systems Author: Luc Maranget INRIA Rocquencourt INRIA RocquencourtView Profile Authors Info & Claims POPL '91: Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1991Pages 255–269https://doi.org/10.1145/99583.99618Published:03 January 1991Publication History 44citation270DownloadsMetricsTotal Citations44Total Downloads270Last 12 Months17Last 6 weeks6 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99618", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Maranget91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99588", + "title": "Static and Dynamic Semantics Processing", + "abstract": "This paper presents a step forward in the use of partial evaluation for interpreting and compiling programs, as well as for automatically generating a compiler from denotational definitions of programming languages. We determine the static and dynamic semantics of a programming language, reduce the expressions representing the static semantics, and generate object code by instantiating the expressions representing the dynamic semantics. By processing the static semantics of the language, programs get compiled. By processing the static semantics of the partial evaluator, compilers are generated. The correctness of a compiler is guaranteed by the correctness of both the executable specification and our partial evaluator. The results reported in this paper improve on previous work in the domain of compiler generation [16, 30], and solves several open problems in the domain of partial evaluation [15]. In essence: ffl Our compilation goes beyond a mere syntax-tosemantics mapping since the ...", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99588", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Charles", + "last_name": "Consel", + "institution": "Yale University" + }, + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Kansas State University" + } + ], + "dblp_key": "conf/popl/ConselD91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99616", + "title": "Parameter-Passing and the Lambda Calculus", + "abstract": "The choice of a parameter-passing technique is an important decision in the design of a high-level programming language. To clarify some of the semantic aspects of the decision, we develop, analyze, and compare modifications of the $\\\\lambda$-calculus for the most common parameter-passing techniques. More specifically, for each parameter-passing technique we provide (1) a program rewriting semantics for a language with side-effects and first-class procedures based on the respective parameter-passing technique; (2) an equational theory derived from the rewriting semantics; (3) a formal analysis of the correspondence between the calculus and the semantics; and (4) a strong normalization theorem for the largest possible imperative fragment of the theory.\\nA comparison of the various systems reveals that Algol's call-by-name indeed satisfies the well-known $\\\\beta$ rule of the original $\\\\lambda$-calculus, but at the cost of complicated axioms for the imperative part of the theory. The simplest and most appealing axiom system appears to be the one for a call-by-value language with reference cells as first-class values.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99616", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Erik", + "last_name": "Crank", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/CrankF91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99608", + "title": "Typing First-Class Continuations in ML", + "abstract": "An extension of Standard ML with continuation primitives similar to those found in Scheme is considered. A number of alternative type systems are discussed, and several programming examples are given. The semantics of type assignment for a small, purely functional fragment of the language is presented, for which both a Milner-style soundness theorem and an observational soundness theorem may be established.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99608", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bruce F.", + "last_name": "Duba", + "institution": "Rice University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "David", + "last_name": "MacQueen", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/popl/DubaHM91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99595", + "title": "Dependence Flow Graphs: An Algebraic Approach to Program Dependencies", + "abstract": "The topic of intermediate languages for optimizing and parallelizing compilers has received muchattention lately. In this paper, we argue that any good representation of a program must havetwo crucial properties: first, it must be a data structure that can be rapidly traversed to determine dependence information, and second this representation must be a program in its own right, with a parallel, local model of execution. In this paper, we illustrate the importance of these points by examining algorithms for a standard optimization --- global constant propagation. We discuss the problems in working with current representations. Then, we propose a novel representation called the dependence flow graph which has each of the properties mentioned above. Weshow that this representation leads to a simple algorithm, based on abstract interpretation, for solving the constant propagation problem. Our algorithm is simpler than, and as efficient as, the best known algorithms for this problem. An interesting feature of our representation is that it naturally incorporates the best aspects of many other representations, including continuation-passing style, data and program dependence graphs, static single assignment form and dataflow program graphs.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99595", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "Cornell University" + }, + { + "first_name": "Micah", + "last_name": "Beck", + "institution": "Cornell University" + }, + { + "first_name": "Richard", + "last_name": "Johnson", + "institution": "Cornell University" + }, + { + "first_name": "Mayan", + "last_name": "Moudgill", + "institution": "Cornell University" + }, + { + "first_name": "Paul", + "last_name": "Stodghill", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/PingaliBJMS91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99607", + "title": "Macros That Work", + "abstract": "Article Macros that work Share on Authors: William Clinger Department of Computer Science, University of Oregon Department of Computer Science, University of OregonView Profile , Jonathan Rees Artificial Intelligence Laboratory, Massachusetts Institute of Technology, Cambridge, MA Artificial Intelligence Laboratory, Massachusetts Institute of Technology, Cambridge, MAView Profile Authors Info & Claims POPL '91: Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1991 Pages 155–162https://doi.org/10.1145/99583.99607Online:03 January 1991Publication History 102citation1,489DownloadsMetricsTotal Citations102Total Downloads1,489Last 12 Months27Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99607", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William", + "last_name": "Clinger", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/popl/ClingerR91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99612", + "title": "Parallel Programming With Coordination Structures", + "abstract": "Parallel programs display two fundamentally different kinds of execution behavior: synchronous and asynchronous. Some methodologies, such as distributed data structures, are best suited to the construction of asynchronous programs. In this paper, we propose a methodology for synchronous parallel programming based on the notion of a coordination structure, a direct representation of the multidimensional dataflow patterns common to synchronous programs. We introduce Delirium, a language in which one can concisely express many useful coordination structures.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99612", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steven", + "last_name": "Lucco", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Oliver", + "last_name": "Sharp", + "institution": "Berkeley College" + } + ], + "dblp_key": "conf/popl/LuccoS91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99617", + "title": "Fully Abstract Translations between Functional Languages", + "abstract": "Article Fully abstract translations between functional languages Share on Author: Jon G. Riecke MIT Laboratory for Computer Science MIT Laboratory for Computer ScienceView Profile Authors Info & Claims POPL '91: Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1991 Pages 245–254https://doi.org/10.1145/99583.99617Online:03 January 1991Publication History 21citation355DownloadsMetricsTotal Citations21Total Downloads355Last 12 Months11Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99617", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jon G.", + "last_name": "Riecke", + "institution": "" + } + ], + "dblp_key": "conf/popl/Riecke91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99622", + "title": "Polymorphic Type Inference and Assignment", + "abstract": "We present a new approach to the polymorphic typing of data accepting in-place modification in ML-like languages. This approach is based on restrictions over type generalization, and a refined typing of functions. The type system given here leads to a better integration of imperative programming style with the purely applicative kernel of ML. In particular, generic functions that allocate mutable data can safely be given fully polymorphic types. We show the soundness of this type system, and give a type reconstruction algorithm.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99622", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "École Normale Supérieure - PSL" + }, + { + "first_name": "Pierre", + "last_name": "Weis", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/LeroyW91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99621", + "title": "Static Type Inference in a Dynamically Typed Language", + "abstract": "We present a type inference system for FL based on an operational, rather than a denotational, formulation of types. The essential elements of the system are a type language based on regular trees and a type inference logic that implements an abstract interpretation of the operational semantics of FL. We use a non-standard approach to type inference because our requirements---using type information in the optimization of functional programs---differ substantially from those of other type systems. 1 Introduction Compilers derive at least two benefits from static type inference: the ability to detect and report potential run-time errors at compile-time, and the use of type information in program optimization. Traditionally, type systems have emphasized the detection of type errors. Statically typed functional languages such as Haskell [HWA*88] and ML [HMT89] include type constraints as part of the language definition, making some type inference necessary to ensure that type constraints ...", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99621", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "IBM (United States)" + }, + { + "first_name": "Brian", + "last_name": "Murphy", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/AikenM91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99593", + "title": "A Relational Approach to Strictness Analysis for Higher-Order Polymorphic Functions", + "abstract": "This paper defines the categorical notions of relators and transformations and shows that these concepts enable us to give a semantics for polymorphic, higher order functional programs. We demonstrate the pertinence of this semantics to the analysis of polymorphic programs by proving that strictness analysis is a polymorphic invariant. 1", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99593", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Samson", + "last_name": "Abramsky", + "institution": "Imperial College London" + }, + { + "first_name": "Thomas Wiben", + "last_name": "Jensen", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/AbramskyJ91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99600", + "title": "Subtyping Recursive Types", + "abstract": "Article Free Access Share on Subtyping recursive types Authors: Roberto M. Amadio LIENS, Ecole Normale Supérieure, Paris LIENS, Ecole Normale Supérieure, ParisView Profile , Luca Cardelli DEC, Systems Research Center DEC, Systems Research CenterView Profile Authors Info & Claims POPL '91: Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1991 Pages 104–118https://doi.org/10.1145/99583.99600Published:03 January 1991Publication History 58citation352DownloadsMetricsTotal Citations58Total Downloads352Last 12 Months13Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99600", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roberto M.", + "last_name": "Amadio", + "institution": "École Normale Supérieure" + }, + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "" + } + ], + "dblp_key": "conf/popl/AmadioC91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99614", + "title": "Coordinating First-Order Multiparty Interactions", + "abstract": "A first-order multiparty interaction is an abstraction mechanism that defines communication among a set of formal process roles. Actual processes participate in a first-order interaction by enroling into roles, and execution of the interaction can proceed when all roles are filled by distinct processes. As in CSP, enrolement statements can serve as guards in alternative commands. The enrolement guard scheduling problem then is to enable the execution of first-order interactions through the judicious scheduling of roles to processes currently ready to execute enrolement guards. We present a fully distributed and message-efficient algorithm for the enrolement guard scheduling problem, the first such solution of which we are aware. We also describe several extensions of the algorithm, including generic roles, dynamically changing environments where processes can be created and destroyed at run time, and nested-enrolement which allows interactions to be nested.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99614", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuh-Jzer", + "last_name": "Joung", + "institution": "Stony Brook University" + }, + { + "first_name": "Scott A.", + "last_name": "Smolka", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/popl/JoungS91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99594", + "title": "Automatic Construction of Sparse Data Flow Evaluation Graphs", + "abstract": "In this paper, we present an algorithm that con-structs sparse evaluation graphs for forward or backward monotone data flow problems. The sparse graph combines information as early as possible, yet directly connects nodes that generate and use information. This allows problems from the large, general class of monotone data flow problems to err joy the advantages of solutions based on Static Single Assignment (SSA) form. 1", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99594", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Ron K.", + "last_name": "Cytron", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Jeanne", + "last_name": "Ferrante", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/ChoiCF91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99605", + "title": ""Look Ma, No Hashing, And No Arrays Neither"", + "abstract": "It is generally assumed that hashing is essential to many algorithms related to efficient compilation; e.g., symbol table formation and maintenance, grammar manipulation, basic block optimization, and global optimization. This paper questions this assumption, and initiates development of an efficient alternative compiler methodology without hashing or sorting. Underlying this methodology are several generic algorithmic tools, among which special importance is given to Multiset Discrimination, which partitions a multiset into blocks of duplicate elements. We show how multiset discrimination, together with other tools, can be tailored to rid compilation of hashing without loss in asymptotic performance. Because of the simplicity of these tools, our results maybe of practical as well as theoretical interest. The various applications presented culminate with a new algorithm to solve iterated strength reduction folded with useless code elimination that runs in worst case asymptotic time and auxiliary space linear in the maximum text length of the initial and optimized programs. 1. Introduction. with linear search time and a hash table. They also pro-An important practical and theoretical question in Computer Science is whether there are algorithms whose worst case performance can match the expected performance of solutions that utilize hashing. In the context of this broader question, we initiate an investigation of efficient compilation without hashing and, consequently, raise some doubts about the prevailing view that hashing (e.g., universal hashing [5]) is essential to the various aspects of compilation from symbol table management [2] to reduction in strength by hashed temporaries [6]. Aho, Sethi, and Unman [2] present only two data structures for storing symbol tables -a linear linked list pose these two data structures for methods to turn an expression tree into a dag and the more general basic block optimization of value numbering. Hashing is involved in preprocessing for global optimization to perform constant propagation [22], global redundant code elimination [4], and code motion [8]. The best methods of strength reduction [3,6] rely on hashed temporaries to obtain efficient implementations. There are several reasons why hashing is used in these applications. Hashing has O(1) expected time performance and Iincar auxiliary space. The method of Universal Hashing, due to Carter and Wegman [5], is especially desirable, since the expected O(1) time is independent of the input distribution. Universal hashing is well suited to applications such as compilation, where the hash tables do not persist beyond a single compilation run. In the applications mentioned above hashing leads to", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99605", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jiazhen", + "last_name": "Cai", + "institution": "Courant Institute of Mathematical Sciences" + }, + { + "first_name": "Robert", + "last_name": "Paige", + "institution": "New York University" + } + ], + "dblp_key": "conf/popl/CaiP91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99625", + "title": "Modeling Concurrency with Geometry", + "abstract": "The phenomena of branching time and true or noninterleaving concurrency find their respective homes in automata and schedules. But these two models of computation are formally equivalent via Birkhoff duality, an equivalence we expound on here in tutorial detail. So why should these phenomena prefer one over the other? We identify dimension as the culprit: l-dimensional automata are skeletons permitting only interleaving concurrency, whereas true n-fold concurrency resides in transitions of dimension n. The truly concurrent automaton dual to a schedule is not a skeletal distributive lattice but a solid one! We introduce true nondeterminism and define it as monoidal homotopy; from this perspective nondeterminism in ordinary automata arises from forking and joining creating nontrivial homotopy, The automaton dual to a poset schedule is simply connected whereas that dual to an event structure schedule need not be, according to monoidal homotopy though not to group homotopy. We conclude with a formal definition of higher dimensional automaton as an n-complex or n-category, whose two essential axioms are associativity of concatenation within dimension and an interchange principle between dimensions. 1 Background A central problem in the semantics of imperative computation is the construction of convenient models of computation embodying the apparent aspects of both branching time and true or noninterleaving or causal", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99625", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vaughn", + "last_name": "Pratt", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Pratt91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99623", + "title": "Algebraic Reconstruction of Types and Effects", + "abstract": "We present the first algorithm for reconstructing the types and effects of expressions in the presence of first class procedures in a polymorphic typed language, Effects are static descriptions of the dynamic behavior of expressions. Just as a type describes what an expression computes, an effect describes howan expression computes. Types are more complicated to reconstruct in the presence of effects because the algebra of effects induces complex constraints on both effects and types. In this paper we show how to perform reconstruction in the presence of such constraints with a new algorithm called algebraic reconstruction, prove that it is sound and complete, and discuss its practical import.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99623", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Jouvelot", + "institution": "École Nationale Supérieure des Mines de Paris" + }, + { + "first_name": "David K.", + "last_name": "Gifford", + "institution": "" + } + ], + "dblp_key": "conf/popl/JouvelotG91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99599", + "title": "Pointer-Induced Aliasing: A Problem Classification", + "abstract": "A?iasing occurs at some program point during execution when two or more names exist for the same location. We have isolated various programming language mechanisms which create aliases. We have classified the complexity of the fllas problem induced by each mechanism alone and in combination, as AfP-hard, complement tip-hard, or polynomial (’P). We present our problem classification, give an overview of our proof that finding interprocedural aliases in the presence of single level pointers is in 7, and present a represent tive proof for the NP-hard problems.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99599", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William", + "last_name": "Landi", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/popl/LandiR91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99620", + "title": "An Extension of Standard ML Modules with Subtyping and Inheritance", + "abstract": "We describe a general module language integrating abstract data types, specifications and object-oriented concepts. The framework is based on the Standard ML module system, with three main extensions: subtyping, a form of object derived from ML structures, and inheritance primitives. The language aims at supporting a range of programming styles, including mixtures of object-oriented programming and programs built around specified algebraic or higher-order abstract data types. We separate specification from implementation, and provide independent inheritance mechanisms for each. In order to support binary operations on objects within this framework, we introduce &quot;internal interfaces&quot; which govern the way that function components of one structure may access components of another. The language design has been tested by writing a number of program examples; an implementation is under development in the context of a larger project. 1 Introduction This paper describes a general module sys...", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99620", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + }, + { + "first_name": "Sigurd", + "last_name": "Meldal", + "institution": "University of Bergen" + }, + { + "first_name": "Neel", + "last_name": "Madhav", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/MitchellMM91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99587", + "title": "Incremental Compilation via Partial Evaluation", + "abstract": "Article A theory of incremental computation and its application Share on Authors: R. S. Sundaresh Yale University, Department of Computer Science, Box 2158 Yale Station, New Haven, CT Yale University, Department of Computer Science, Box 2158 Yale Station, New Haven, CTView Profile , Paul Hudak Yale University, Department of Computer Science, Box 2158 Yale Station, New Haven, CT Yale University, Department of Computer Science, Box 2158 Yale Station, New Haven, CTView Profile Authors Info & Claims POPL '91: Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1991 Pages 1–13https://doi.org/10.1145/99583.99587Online:03 January 1991Publication History 22citation447DownloadsMetricsTotal Citations22Total Downloads447Last 12 Months7Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99587", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R. S.", + "last_name": "Sundaresh", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/SundareshH91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99591", + "title": "On the Power and Limitation of Strictness Analysis Based on Abstract Interpretation", + "abstract": "Strictness analysis based on abstract interpretation is an important technique for optimization of lazy functional languages. It is well known that all strictness analysis methods are incomplete, i.e., fail to report some strictness properties. In this paper, we provide the first precise and formal characterization of the loss of information that leads to this incompleteness. Specifically, we establish the following characterization theorem for", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99591", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R.", + "last_name": "Sekar", + "institution": "Stony Brook University" + }, + { + "first_name": "Prateek", + "last_name": "Mishra", + "institution": "Stony Brook University" + }, + { + "first_name": "I. V.", + "last_name": "Ramakrishnan", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/popl/SekarMR91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99610", + "title": "A Dynamic Extent Control Operator for Partial Continuations", + "abstract": "A partial continuation is a prefix of the computation that remains to be done. We propose in this paper a new operator which precisely controls which prefix is to be abstracted into a partial continuation. This operator is strongly related to the notion of dynamic extent which we denotationally characterize. Some programming examples are commented and we also show how to express previously proposed control operators. A suggested implementation is eventually discussed.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99610", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christian", + "last_name": "Queinnec", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Bernard", + "last_name": "Serpette", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/QueinnecS91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99611", + "title": "Modeling Continuations without Continuations", + "abstract": "Article Free Access Share on Models of continuations without continuations Authors: Dorai Sitaram Department of Computer Science, Rice University, Houston, TX Department of Computer Science, Rice University, Houston, TXView Profile , Matthias Felleisen Department of Computer Science, Rice University, Houston, TX Department of Computer Science, Rice University, Houston, TXView Profile Authors Info & Claims POPL '91: Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1991 Pages 185–196https://doi.org/10.1145/99583.99611Online:03 January 1991Publication History 4citation439DownloadsMetricsTotal Citations4Total Downloads439Last 12 Months7Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99611", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dorai", + "last_name": "Sitaram", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/SitaramF91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99597", + "title": "Program Optimization and Parallelization Using Idioms", + "abstract": "in languages such as FORTRAN, Pascal, and which our method indeed outperforms existing analysis techniques.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99597", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shlomit S.", + "last_name": "Pinter", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Ron Y.", + "last_name": "Pinter", + "institution": "IBM Research - Haifa" + } + ], + "dblp_key": "conf/popl/PinterP91", + "venue": "popl", + "year": 1991 + }, + { + "paper_id": "10.1145/99583.99627", + "title": "Semantic Foundations of Concurrent Constraint Programming", + "abstract": "Concurrent constraint programming [Sar89 ,SR90] is a simple and powerful model of concurrent computation based on the notions of store-as-constraint and process as information", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/99583.99627", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vijay", + "last_name": "Saraswat", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Stanford University" + }, + { + "first_name": "Prakash", + "last_name": "Panangaden", + "institution": "McGill University" + } + ], + "dblp_key": "conf/popl/SaraswatRP91", + "venue": "popl", + "year": 1991 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1992.json b/data/pl_conferences/popl/1992.json new file mode 100644 index 0000000..bcb3d10 --- /dev/null +++ b/data/pl_conferences/popl/1992.json @@ -0,0 +1,629 @@ +[ + { + "paper_id": "10.1145/143165.143216", + "title": "Generalized Dominators and Post-Dominators", + "abstract": "The notion of dominators is generalized to include multiple-vertex dominators in addition to single-vertex dominators. A multiple-vertex dominator of a vertex is a group of vertices that collectively dominate the vertex. Existing algorithms compute immediate single-vertex dominators, and an algorithm for computing immediate multiple-vertex dominators is presented in this paper. The immediate dominator information is expressed in the form of a directed acyclic graph referred to as the dominator DAG or the DDAG. The generalized dominator set of any vertex dominators of the vertex, can be computed from the DDAG. The single-vertex dominator information restricts the propagation of loop invariant statements and array bound checks out of loops. Generalized dominator information avoids these restrictions. In addition, it can be used to identify natural loops and improve the existing optimization algorithm for code hoisting. The dual notion of generalized post-dominators can be used for computing control dependences and automatic generation of compact test suites for programs.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143216", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/popl/Gupta92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143182", + "title": "Bounded Fixed Point Iteration", + "abstract": "In the context of abstract interpretation we study the number of times a functional need to be unfolded in order to give the least fixed point. For the cases of the total or monotone functions we obtain an exponential bound and in the case of strict and additive (or distributive) functions we obtain a quadratic bound. These bounds are shown to be tight. Specialising the case of strict and additive functions to functionals of a form that would correspond to iterative programs we show that a linear bound is tight. We demonstrate the relation to several analyses studied in the literature (including strictness analysis).", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143182", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hanne Riis", + "last_name": "Nielson", + "institution": "Aarhus University" + }, + { + "first_name": "Flemming", + "last_name": "Nielson", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/NielsonN92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143232", + "title": "Observable Sequentiality and Full Abstraction", + "abstract": "ion Robert Cartwright Matthias Felleisen Department of Computer Science Rice University Houston, TX 77251-1892 Rice Technical Report CS 91-167 A preliminary version of this technical report appeared in the Proceedings of the 19th Annual ACM Symposium on Principles of Programming Languages, January 19--22, 1992, Albuquerque, New Mexico. Copyright c fl1992 by Robert Cartwright and Matthias Felleisen 1 Full Abstraction and Sequentiality 1 1.1 Summary of Previous Work : : : : : : : : : : : : : : : : : : : : : : : : : : : 2 1.2 Summary of Results : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 3 2 PCF 4 2.1 Formal Semantics : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 5 2.2 Observational Equivalence, Sequentiality : : : : : : : : : : : : : : : : : : : : 8 3 Observing Sequentiality 9 3.1 Using errors, programmers can observe the order of evaluation. : : : : : : : 10 3.2 Using control operators, programs can observe the order of evaluation. : : : 10...", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143232", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "" + } + ], + "dblp_key": "conf/popl/CartwrightF92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143223", + "title": "Partial Evaluation of High-Level Imperative Programming Languages, with Applications in Hard Real-Time Systems", + "abstract": "Article Free Access Share on Partial evaluation of high-level imperative programming languages with applications in hard real-time systems Authors: Vivek Nirkhe View Profile , William Pugh View Profile Authors Info & Claims POPL '92: Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesFebruary 1992 Pages 269–280https://doi.org/10.1145/143165.143223Published:01 February 1992Publication History 25citation374DownloadsMetricsTotal Citations25Total Downloads374Last 12 Months15Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143223", + "conference_name": "POPL", + "authors": [ + { + "first_name": "V.", + "last_name": "Nirkhe", + "institution": "" + }, + { + "first_name": "William", + "last_name": "Pugh", + "institution": "" + } + ], + "dblp_key": "conf/popl/NirkheP92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143210", + "title": "Composable Attribute Grammars: Support for Modularity in Translator Design and Implementation", + "abstract": "This paper introduces Composable Attribute Grammars (CAGs), a formalism that extends classical attribute grammars to allow for the modular composition of translation specifications and of translators. CAGs bring to complex translator writing systems the same benefits of modularity found in modern programming languages, including comprehensibility, reusability, and incremental meta-compilation.A CAG is built from several smaller component AGs, each of which solves a particular subproblem, such as name analysis or register allocation. A component AG is based upon a simplified phrase-structure that reflects the properties of its subproblem rather than the phrase-structure of the source language. Different component phrase-structures for various subproblems are combined by mapping them into a phrase-structure for the source language. Both input and output attributes can be associated with the terminal symbols of a component AG. Output attributes enable the results of solving a subproblem to be distributed back to anywhere that originally contributed part of the subproblem, e.g. transparently distributing the results of global name analysis back to every symbolic reference in the source program.After introducing CAGs by way of an example, we provide a formal definition of CAGs and their semantics. We describe a subclass of CAGs and their semantics. We describe a subclass of CAGs, called separable CAGs, that have favorable implementation properties. We discuss the novel aspects of CAGs, compare them to other proposals for inserting modularity into attribute grammars, and relate our experience using CAGs in the Linguist translator-writing system.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143210", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rodney", + "last_name": "Farrow", + "institution": "" + }, + { + "first_name": "Thomas J.", + "last_name": "Marlowe", + "institution": "" + }, + { + "first_name": "Daniel M.", + "last_name": "Yellin", + "institution": "" + } + ], + "dblp_key": "conf/popl/FarrowMY92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143227", + "title": "Algorithmic Aspects of Type Inference with Subtypes", + "abstract": "We study the complexity of type inference for programming languages with subtypes. There are three language variations that effect the problem: (i) basic functions may have polymorphic or more limited types, (ii) the subtype hierarchy may be fixed or vary as a result of subtype declarations within a program, and (iii) the subtype hierarchy may be an arbitrary partial order or may have a more restricted form, such as a tree or lattice. The naive algorithm for infering a most general polymorphic type, undervariable subtype hypotheses, requires deterministic exponential time. If we fix the subtype ordering, this upper bound grows to nondeterministic exponential time. We show that it is NP-hard to decide whether a lambda term has a type with respect to a fixed subtype hierarchy (involving only atomic type names). This lower bound applies to monomorphic or polymorphic languages. We give PSPACE upper bounds for deciding polymorphic typability if the subtype hierarchy has a lattice structure or the subtype hierarchy varies arbitrarily. We also give a polynomial time algorithm for the limited case where there are of no function constants and the type hierarchy is either variable or any fixed lattice.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143227", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Lincoln", + "institution": "" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "" + } + ], + "dblp_key": "conf/popl/LincolnM92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143184", + "title": "Inductive Definitions, Semantics and Abstract Interpretation", + "abstract": "We introduce and illustrate a specification method combining rule-based inductive definitions, well-founded induction principles, fixed-point theory and abstract interpretation for general use in computer science. Finite as well as infinite objects can be specified, at various levels of details related by abstraction. General proof principles are applicable to prove properties of the specified objects.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143184", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "Université Paris Sciences et Lettres" + } + ], + "dblp_key": "conf/popl/CousotC92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143213", + "title": "Recognizing Substrings of LR(k) Languages in Linear Time", + "abstract": "LR parsing techniques have long been studied as efficient and powerful methods for processing context free languages. A linear time algorithm for recognizing languages representable by LR(k) grammars has long been known. Recognizing substrings of a context-free language is at least as hard as recognizing full strings of the language, as the latter problem easily reduces to the former. In this paper we present a linear time algorithm for recognizing substrings of LR(k) languages, thus showing that the substring recognition problem for these languages is no harder than the full string recognition problem. An interesting data structure, the Forest Structured Stack, allows the algorithm to track all possible parses of a substring without loosing the efficiency of the original LR parser. We present the algorithm, prove its correctness, analyze its complexity, and mention several applications that have been constructed.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143213", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Bates", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Alon", + "last_name": "Lavie", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/BatesL92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143228", + "title": "Bounded Quantification is Undecidable", + "abstract": "F≤ is a typed λ-calculus with subtyping and bounded second-order polymorphism. First proposed by Cardelli and Wegner, it has been widely studied as a core calculus for type systems with subtyping.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143228", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/Pierce92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143209", + "title": "Pattern-Based Tree Attribution", + "abstract": "Attribute grammars have been used for many language-oriented tasks, including the formal description of semantics and the implementation of compilation tasks from simple type checking through code generation. Despite their successful use, attribute grammars have some disadvantages, including the monolithic nature of the grammar and the fixed factoring of all attribute descriptions by a single set of grammar productions. Attribute pattern sets provide a more expressive attribution system by using pattern matching, instead of grammar productions, to perform case analysis. Attribute pattern sets can be implemented in terms of attribute grammars in a way that maintains the dependency structure of the attribute system, making it straightforward to convert many of the practical results from attribute grammar theory to similar results for attribute pattern sets.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143209", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Charles", + "last_name": "Farnum", + "institution": "Wright State University" + } + ], + "dblp_key": "conf/popl/Farnum92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143194", + "title": "Compile-Time Analysis of Parallel Programs that Share Memory", + "abstract": "Traditional optimization techniques for sequential programs are not directly applicable to parallel programs where concurrent activities may interfere with each other through shared variables. New compiler techniques must be developed to accommodate features found in parallel languages. In this paper, we use abstract interpretation to obtain useful properties of programs, e.g., side effects, data dependences, object lifetime and concurrent expressions, for a language that supports first-class functions, pointers, dynamic allocations and explicit parallelism through cobegin. These analyses may facilitate many applications, such as program optimization, parallelization, restructuring, memory management, and detecting access anomalies.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143194", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jyh-Herng", + "last_name": "Chow", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "W.L.", + "last_name": "Harrison", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/ChowH92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143220", + "title": "Generating a Compiler for a Lazy Language by Partial Evaluation", + "abstract": "Compiler generation is often emphasized as being the most important application of partial evaluation. But most of the larger practical applications have, to the best of our knowledge, been outside this field. Expecially, no one has generated compilers for languages other than small languages. This paper describes a large application of partial evaluation where a realistic compiler was generated for a strongly typed lazy functional language. The language, that was called BAWL, was modeled after the language in Bird and Wadler [BW88] and is a combinator language with pattern matching, guarded alternatives, local definitions and list comprehensions. The paper describes the most important techniques used, especially the binding time improvements needed in order to get small and efficient target programs. Finally, the performance of the compiler is compared with two compilers for similar languages: Miranda and LML.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143220", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jesper", + "last_name": "Jørgensen", + "institution": "" + } + ], + "dblp_key": "conf/popl/Jorgensen92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143174", + "title": "Linear Continuations", + "abstract": "We present a functional interpretation of classical linear logic based on the concept of linear continuations. Unlike their non-linear counterparts, such continuations lead to a model of control that does not inherently impose any particular evaluation strategy. Instead, such additional structure is expressed by admitting closely controlled copying and discarding of continuations. We also emphasize the importance of classicality in obtaining computationally appealing categorical models of linear logic and propose a simple “coreflective subcategory” interpretation of the modality “!”.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143174", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrzej", + "last_name": "Filinski", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Filinski92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143208", + "title": "Type Isomorphisms in a Type-Assignment Framework", + "abstract": "This paper contains a full treatment of isomorphic types for languages equipped with an ML style polymorphic type inference mechanism. Surprisingly enough the results obtained contradict the common-place feeling that (the core of) ML is a subset of second order λ-calculus: we can provide an isomorphism of types that holds in the core ML language, but not in second order λ-calculus. This new isomorphism not only allows to provide a complete (and decidable) axiomatisation of all the type isomorphic in ML style languages, a relevant issue for the type as specifications paradigm in library searches, but also suggest a natural extension that in a sense completes the type-inference mechanism in ML. This extension is easy to implement and allows to get a further insight in the nature of the let polymorphic construct.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143208", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robero Di", + "last_name": "Cosmo", + "institution": "University of Pisa" + } + ], + "dblp_key": "conf/popl/Cosmo92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143191", + "title": "A Semantics for ML Concurrency Primitives", + "abstract": "We present a set of concurrency primitives for Standard ML. We define these by giving the transitional semantics of a simple language. We prove that our semantics preserves the expected behaviour of sequential programs. We also show that we can define stores as processes, such that the representation has the same behaviour as a direct definition. These proofs are the first steps towards integrating our semantics with the full definition of Standard ML.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143191", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dave", + "last_name": "Berry", + "institution": "" + }, + { + "first_name": "Robin", + "last_name": "Milner", + "institution": "" + }, + { + "first_name": "David N.", + "last_name": "Turner", + "institution": "" + } + ], + "dblp_key": "conf/popl/BerryMT92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143178", + "title": "A Mark-and-Sweep Collector for C++", + "abstract": "Our research is concerned with compiler-independent, tag-free garbage collection for the C++ programming language. We have previously presented a copying collector based on root registration. This paper presents a mark-and-sweep garbage collector that ameliorates shortcomings of the previous collector. We describe the two collectors and discuss why the new one is an improvement over the old one. We have tested this collector and a conservative collector in a VLSI CAD application, and this paper discusses the differences. Currently this prototype of the collector imposes too much overhead on our application. We intend to solve that problem, and then use the techniques described in this paper to implement a generational Mark-and-Sweep collector for C++.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143178", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel R.", + "last_name": "Edelson", + "institution": "" + } + ], + "dblp_key": "conf/popl/Edelson92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143172", + "title": "The Geometry of Optimal Lambda Reduction", + "abstract": "Lamping discovered an optimal graph-reduction implementation of the λ-calculus. Simultaneously, Girard invented the geometry of interaction, a mathematical foundation for operational semantics. In this paper, we connect and explain the geometry of interaction and Lamping's graphs. The geometry of interaction provides a suitable semantic basis for explaining and improving Lamping's system. On the other hand, graphs similar to Lamping's provide a concrete representation of the geometry of interaction. Together, they offer a new understanding of computation, as well as ideas for efficient and correct implementations.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143172", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Georges", + "last_name": "Gonthier", + "institution": "" + }, + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "" + }, + { + "first_name": "Jean-Jacques", + "last_name": "Lévy", + "institution": "" + } + ], + "dblp_key": "conf/popl/GonthierAL92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143180", + "title": "Optimally Profiling and Tracing Programs", + "abstract": "This paper describes algorithms for inserting monitoring code to profile and trace programs. These algorithms greatly reduce the cost of measuring programs with respect to the commonly used technique of placing code in each basic block. Program profiling counts the number of times each basic block in a program executes. Instruction tracing records the sequence of basic blocks traversed in a program execution. The algorithms optimize the placement of counting/tracing code with respect to the expected or measured frequency of each block or edge in a program's control-flow graph. We have implemented the algorithms in a profiling/tracing tool, and they substantially reduce the overhead of profiling and tracing.We also define and study the hierarchy of profiling problems. These problems have two dimensions: what is profiled (i.e., vertices (basic blocks) or edges in a control-flow graph) and where the instrumentation code is placed (in blocks or along edges). We compare the optimal solutions to the profiling problems and describe a new profiling problem: basic-block profiling with edge counters. This problem is important because an optimal solution to any other profiling problem (for a given control-flow graph) is never better than an optimal solution to this problem. Unfortunately, finding an optimal placement of edge counters for vertex profiling appears to be a hard problem in general. However, our work shows that edge profiling with edge counters works well in practice because it is simple and efficient and finds optimal counter placements in most cases. Furthermore, it yields more information than a vertex profile. Tracing also benefits from placing instrumentation code along edges rather than on vertices.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143180", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/BallL92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143235", + "title": "Model Checking and Abstraction", + "abstract": "We describe a method for using abstraction to reduce the complexity of temporal logic model checking. The basis of this method is a way of constructing an abstract model of a program without ever examining the corresponding unabstracted model. We show how this abstract model can be used to verify properties of the original program. We have implemented a system based on these techniques, and we demonstrate their practicality using a number of examples, including a pipelined ALU circuit with over 101300 states.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143235", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Edmund M.", + "last_name": "Clarke", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Orna", + "last_name": "Grümberg", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "David E.", + "last_name": "Long", + "institution": "Nokia (United States)" + } + ], + "dblp_key": "conf/popl/ClarkeGL92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143236", + "title": "Abstract Semantics for a Higher-Order Functional Language with Logic Variables", + "abstract": "there is considerable experience in using languages that combine the functional and logic programlogic variables can be viewed as a language of incremental definition of functions.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143236", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Radha", + "last_name": "Jagadeesan", + "institution": "Imperial College London" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "" + } + ], + "dblp_key": "conf/popl/JagadeesanP92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143202", + "title": "Typing Record Concatenation for Free", + "abstract": "We show that any functional language with record extension possesses record concatenation for free. We exhibit a translation from the latter into the former. We obtain a type system for a language with record concatenation by composing the translation with type-checking in a language with record extension. We apply this method to a version of ML with a record extension and obtain an extension of ML with either asymmetric or symmetric concatenation. The latter extension is simple, flexible and has a very efficient type inference algorithm in practice. Concatenation together with removal of fields needs one more construct than extension of records. It can be added to the version of ML with record extension. However, many typed languages with record cannot type such a construct. The method still applies to them, producing type systems for record concatenation without removal of fields. Object systems also benefit of the encoding which shows that multiple inheritance does not actually require the concatenation of records but only their extension.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143202", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Remy92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143189", + "title": "Semantic Foundations of Jade", + "abstract": "Jade is a language designed to support coarse-grain parallelism on both shared and distributed address-space machines. Jade is data-oriented: a Jade programmer simply augments a sequential imperative program with declarations specifying how the program accesses data. A Jade implementation dynamically interprets the access specification to execute the program concurrently while enforcing the program's data dependence constraints, thus preserving the sequential semantics.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143189", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/RinardL92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143206", + "title": "Principal Signatures for Higher-Order Program Modules", + "abstract": "Under the Damas-Milner type discipline for functional languages, every expression has principal type, if it elaborates at all. In the type discipline for ML Modules, a signature expression has a principal signature, if it elaborates at all. However, while functions can be higher-order in ML, parameterised modules in ML are first-order only. We present a type discipline for a skeletal higher-order module language which has principal signatures. Sharing and multiple views of structures are handled in a manner which is compatible with the semantics of the first-order ML modules.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143206", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mads", + "last_name": "Tofte", + "institution": "" + } + ], + "dblp_key": "conf/popl/Tofte92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143225", + "title": "Parametricity as Subtyping", + "abstract": "A polymorphic function is parametric if it has uniform behavior for all type parameters. This property is useful when writing, reasoning about, and compiling functional programs.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143225", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Qingming", + "last_name": "Ma", + "institution": "" + } + ], + "dblp_key": "conf/popl/Ma92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143176", + "title": "Garbage Collecting the World", + "abstract": "Distributed symbolic computations involve the existence of remote references allowing an object, local to a processor, to designate another object located on another processor. To reclaim inaccessible objects is the non trivial task of a distributed Garbage Collector (GC). We present in this paper a new distributed GC algorithm which (i) is fault-tolerant, (ii) is largely independent of how a processor garbage collects its own data space, (iii) does not need centralized control nor global stop-the-world synchronization, (iv) allows for multiple concurrent active GCs, (v) does not require to migrate objects from processor to processor and (vi) eventually reclaims all inaccessible objects including distributed cycles.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143176", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bernard", + "last_name": "Lang", + "institution": "" + }, + { + "first_name": "Christian", + "last_name": "Queinnec", + "institution": "École Polytechnique" + }, + { + "first_name": "José", + "last_name": "Piquer", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/popl/LangQP92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143200", + "title": "A Compilation Method for ML-Style Polymorphic Record Calculi", + "abstract": "Polymorphic record calculi have recently attracted much attention as a typed foundation for object-oriented programming. This is based on the fact that a function that selects a field l of a record can be given a polymorphic type that enables it to be applied to various records containing a field l. Recent studies have established techniques to develop an ML-style type inference algorithm for such a polymorphic type system. There seems to be, however, no established method to compile an ML-style polymorphic record calculus into efficient code. The purpose of this paper is to present one such method. We define a polymorphic record calculus as an extension of Damas and Miler's proof system for ML. For this calculus, we define an implementation calculus where records are represented as arrays of (references to) values and field selection is performed by direct indexing. To represent polymorphic field selection, the implementation calculus contains an abstraction mechanism over indexes. We then develop an algorithm to translate the polymorphic record calculus into the implementation calculus by refining a type inference algorithm; it simultaneously computes a principal type scheme in the polymorphic record calculus and a correct implementation term in the implementation calculus. The type inference is shown to be sound and complete in the sense of Damas-Milner's algorithm for ML. Moreover, the polymorphic type system is shown to be sound with respect to an operational semantics of the translated terms in the implementation calculus.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143200", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Oki Electric Industry (Japan)" + } + ], + "dblp_key": "conf/popl/Ohori92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143169", + "title": "The Essence of Functional Programming", + "abstract": "This paper explores the use monads to structure functional programs. No prior knowledge of monads or category theory is required.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143169", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "" + } + ], + "dblp_key": "conf/popl/Wadler92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143205", + "title": "Unboxed Objects and Polymorphic Typing", + "abstract": "This paper presents a program transformation that allows languages with polymorphic typing (e.g. ML) to be implemented with unboxed, multi-word data representations. The transformation introduces coercions between various representations, based on a typing derivation. A prototype ML compiler utilizing this transformation demonstrates important speedups.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143205", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "École Normale Supérieure" + } + ], + "dblp_key": "conf/popl/Leroy92", + "venue": "popl", + "year": 1992 + }, + { + "paper_id": "10.1145/143165.143197", + "title": "A Comprehensive Study of the Complexity of Multiparty Interaction", + "abstract": "We present a taxonomy of languages for multiparty interaction, which covers all proposals of which we are aware. Based on this taxonomy, we present a comprehensive analysis of the computational complexity of the multiparty interaction implementation problem, the problem of scheduling multiparty interactions in a given execution environment.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143165.143197", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuh-Jzer", + "last_name": "Joung", + "institution": "National Taiwan University" + }, + { + "first_name": "Scott A.", + "last_name": "Smolka", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/popl/JoungS92", + "venue": "popl", + "year": 1992 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1993.json b/data/pl_conferences/popl/1993.json new file mode 100644 index 0000000..8fa1203 --- /dev/null +++ b/data/pl_conferences/popl/1993.json @@ -0,0 +1,996 @@ +[ + { + "paper_id": "10.1145/158511.158706", + "title": "Quasi-Static Scoping: Sharing Variable Bindings Across Multiple Lexical Scopes", + "abstract": "Static scoping embodies a strong encapsulation mechanism for hiding the details of program units. Yet, it does not allow the sharing of variable bindings (locations) across independent program units. Facilities such as module and object systems that require cross references of variables therefore must be added as special features. In this paper we present an alternative: quasi-static scoping. Quasi-static scoping is more flexible than static scoping, but has the same encapsulation mechanism. The user can control when and in what scope to resolve a quasi-static variable, i.e., to associate it with a variable binding. To demonstrate its versatility, we add quasi-static scoping to Scheme and show how to build the aforementioned facilities at the user-level. We also show that quasi-static scoping can be implemented efficiently.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158706", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shinn-Der", + "last_name": "Lee", + "institution": "" + }, + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "" + } + ], + "dblp_key": "conf/popl/LeeF93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158521", + "title": "Call by Name, Assignment, and the Lambda Calculus", + "abstract": "We define an extension of the call-by-name lambda calculus with additional constructs and reduction rules that represent mutable variables and assignments. The extended calculus has neither a concept of an explicit store nor a concept of evaluation order; nevertheless, we show that programs in the calculus can be implemented using a single-threaded store. We also show that the new calculus has the Church-Rosser property and that it is a conservative extension of classical lambda calculus with respect to operational equivalence; that is, all algebraic laws of the functional subset are preserved.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158521", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "" + }, + { + "first_name": "Dan", + "last_name": "Rabin", + "institution": "" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "" + } + ], + "dblp_key": "conf/popl/OderskyRH93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158632", + "title": "Polymorphism by Name for References and Continuations", + "abstract": "This article investigates an ML-like language with byname semantics for polymorphism: polymorphic objects are not evaluated once for all at generalization time, but re-evaluated at each specialization. Unlike the standard ML semantics, the by-name semantics works well with polymorphic references and polymorphic continuations: the naive typing rules for references and for continuations are sound with respect to this semantics. Polymorphism by name leads to a better integration of these imperative features into the ML type discipline. Practical experience shows that it retains most of the efficiency and predictability of polymorphism by value.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158632", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "École Normale Supérieure - PSL" + } + ], + "dblp_key": "conf/popl/Leroy93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158700", + "title": "Efficient Recursive Subtyping", + "abstract": "Subtyping in the presence of recursive types for the l-calculus was studied by Amadio and Cardelli in 1991 [1]. In that paper they showed that the problem of deciding whether one recursive type is a sub-type of another is decidable in exponential time.In this paper we give an O(n2) algorithm. Our algorithm is based on a simplification of the definition of the subtype relation, which allows us to reduce the problem to the emptiness problem for a certain finite automaton with quadratically many states.It is known that equality of recursive types and the covariant Bo¨hm order can be decided efficiently by means of finite automata. Our results extend the automata-theoretic approach to handle orderings based on contravariance.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158700", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Aalborg University" + }, + { + "first_name": "Michael I.", + "last_name": "Schwartzbach", + "institution": "Aalborg University" + } + ], + "dblp_key": "conf/popl/KozenPS93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158613", + "title": "Separating Stages in the Continuation-Passing Style Transformation", + "abstract": "The continuation-passing style (CPS) transformation is powerful but complex. Our thesis is that this transformation is in fact compound, and we set out to stage it. We factor the CPS transformation into several steps, separating aspects in each step: (1) Intermediate values are named; (2) Continuations are introduced; (3) Sequencing order is decided and administrative reductions are performed.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158613", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julia L.", + "last_name": "Lawall", + "institution": "" + }, + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "" + } + ], + "dblp_key": "conf/popl/LawallD93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158647", + "title": "Constructing Call Multigraphs Using Dependence Graphs", + "abstract": "Article Constructing call multigraphs using dependence graphs Share on Author: Arun Lakhotia View Profile Authors Info & Claims POPL '93: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesMarch 1993 Pages 273–284https://doi.org/10.1145/158511.158647Online:01 March 1993Publication History 22citation351DownloadsMetricsTotal Citations22Total Downloads351Last 12 Months7Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158647", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arun", + "last_name": "Lakhotia", + "institution": "" + } + ], + "dblp_key": "conf/popl/Lakhotia93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158692", + "title": "Evicted Variables and the Interaction of Global Register Allocation and Symbolic Debugging", + "abstract": "A symbolic debugger allows a user to display the values of program variables at a breakpoint. However, problems arise if the program is translated by an optimizing compiler. This paper addresses the effects of global register allocation and assignment: a register assigned to a variable V may not be holding V's value at a breakpoint since the register can also be assigned to other variables. We define the problem of determining whether a variable is in its assigned register as the residence problem. Prior work on debugging of optimized code has focused on the currency problem; detecting whether a variable's run-time value is the expected value. Determining residence is a more serious problem than currency detection. We present a data flow algorithm that accurately computes a variable's residency, by determining when a variable becomes evicted from its register. We measure the effectiveness of different approaches to determine variable residence for three C programs from the SPEC suite.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158692", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "" + } + ], + "dblp_key": "conf/popl/Adl-TabatabaiG93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158622", + "title": "Formal Parametric Polymorphism", + "abstract": "A polymorphic function is parametric if its behavior does not depend on the type at which it is instantiated. Starting with Reynolds' work, the study of parametricity is typically semantic. In this paper, we develop a syntactic approach to parametricity, and a formal system that embodies this approach: system ℜ. Girard's system F deals with terms and types; ℜ is an extension of F that deals also with relations between types.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158622", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Digital Wave (United States)" + }, + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "Digital Wave (United States)" + }, + { + "first_name": "Pierre-Louis", + "last_name": "Curien", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/AbadiCC93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158701", + "title": "A Sort Inference Algorithm for the Polyadic Pi-Calculus", + "abstract": "In Milner's polyadic π-calculus there is a notion of sorts which is analogous to the notion of types in functional programming. As a well-typed program applies functions to arguments in a consistent way, a well-sorted process uses communication channels in a consistent way. An open problem is whether there is an algorithm to infer sorts in the π-calculus in the same way that types can be inferred in functional programming. Here we solve the problem by presenting an algorithm which infers the most general sorting for a process in the first-order calculus, and proving its correctness. The algorithm is similar in style to those used for Hindley-Milner type inference in functional languages.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158701", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon J.", + "last_name": "Gay", + "institution": "Imperial Valley College" + } + ], + "dblp_key": "conf/popl/Gay93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158611", + "title": "A Concurrent, Generational Garbage Collector for a Multithreaded Implementation of ML", + "abstract": "This paper presents the design and implementation of a “quasi real-time” garbage collector for Concurrent Caml Light, an implementation of ML with threads. This two-generation system combines a fast, asynchronous copying collector on the young generation with a non-disruptive concurrent marking collector on the old generation. This design crucially relies on the ML compile-time distinction between mutable and immutable objects.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158611", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Damien", + "last_name": "Doligez", + "institution": "Laboratoire de l'Informatique du Parallélisme" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "École Normale Supérieure" + } + ], + "dblp_key": "conf/popl/DoligezL93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158517", + "title": "Automatic Array Alignment in Data-Parallel Programs", + "abstract": "Data-parallel languages like Fortran 90 express parallelism in the form of operations on data aggregates such as arrays. Misalignment of the operands of an array operation can reduce program performance on a distributed-memory parallel machine by requiring nonlocal data accesses. Determining array alignments that reduce communication is therefore a key issue in compiling such languages.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158517", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Siddhartha", + "last_name": "Chatterjee", + "institution": "" + }, + { + "first_name": "John R.", + "last_name": "Gilbert", + "institution": "" + }, + { + "first_name": "Robert", + "last_name": "Schreiber", + "institution": "" + }, + { + "first_name": "Shang‐Hua", + "last_name": "Teng", + "institution": "" + } + ], + "dblp_key": "conf/popl/ChatterjeeGST93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158526", + "title": "Communicating Reactive Processes", + "abstract": "We present a new programming paradigm called Communicating Reactive Processes or CRP that unifies the capabilities of asynchronous and synchronous concurrent programming languages. Asynchronous languages such as CSP, Occam, or Ada are well-suited for distributed algorithms; their processes are loosely coupled and communication takes time. The Esterel synchronous language is dedicated to reactive systems; its processes are tightly coupled and deterministic, communication being realized by instantaneous broadcasting. Complex applications such as process or robot control require to couple both forms of concurrency, which is the object of CRP. A CRP program consists of independent locally reactive Esterel nodes that communicate with each other by CSP rendezvous. CRP faithfully extends both Esterel and CSP and adds new possibilities such as precise local watchdogs on rendezvous. We present the design of CRP, its semantics, a translation into classical process calculi for program verificatio...", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158526", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gérard", + "last_name": "Berry", + "institution": "" + }, + { + "first_name": "S.", + "last_name": "Ramesh", + "institution": "" + }, + { + "first_name": "R. K.", + "last_name": "Shyamasundar", + "institution": "" + } + ], + "dblp_key": "conf/popl/BerryRS93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158694", + "title": "Incremental Program Testing Using Program Dependence Graphs", + "abstract": "Program dependence graphs have been proposed for use in optimizing, vectorizing, and parallelizing compilers, and for program integration. This paper proposes their use as the basis for incremental program testing when using test data adequacy criteria. Test data adequacy is commonly used to provide some confidence that a particular test suite does a reasonable job of testing a program. Incremental program testing using test data adequacy criteria addresses the problem of testing a modified program given an adequate test suite for the original program. Ideally, one would like to create an adequate test suite for the modified program that reuses as many files from the old test suite as possible. Furthermore, one would like to know, for every file that is in both the old and the new test suites, whether the program components exercised by that file have been affected by the program modification; if no components have been affected, then it is not necessary to rerun the program using that file.In this paper we define adequacy criteria based on the program dependence graph, and propose techniques based on program slicing to identify components of the modified program that can be tested using files from the old test suite, and components that have been affected by the modification. This information can be used to reduce the time required to create new test files, and to avoid unproductive retesting of unaffected components. Although exact identification of the components listed above is, in general, undecidable, we demonstrate that our techniques provide safe approximations.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158694", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Samuel", + "last_name": "Bates", + "institution": "" + }, + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "" + } + ], + "dblp_key": "conf/popl/BatesH93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158702", + "title": "Smartest Recompilation", + "abstract": "To separately compile a program module in traditional statically-typed languages, one has to manually write down an import interface which explicitly specifies all the external symbols referenced in the module. Whenever the definitions of these external symbols are changed, the module has to be recompiled. In this paper, we present an algorithm which can automatically infer the “minimum” import interface for any module in languages based on the Damas-Milner type discipline (e.g., ML). By “minimum”, we mean that the interface specifies a set of assumptions (for external symbols) that are just enough to make the module type-check and compile. By compiling each module using its “minimum” import interface, we get a separate compilation method that can achieve the following optimal property: A compilation unit never needs to be recompiled unless its own implementation changes.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158702", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/ShaoA93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158650", + "title": "Safe Type Checking in a Statically-Typed Object-Oriented Programming Language", + "abstract": "In this paper we introduce a statically-typed, functional, object-oriented programming language, TOOPL, which supports classes, objects, methods, instance variable, subtypes, and inheritance.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158650", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kim B.", + "last_name": "Bruce", + "institution": "Williams College" + } + ], + "dblp_key": "conf/popl/Bruce93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158689", + "title": "Differential Logic Programming", + "abstract": "In this paper we define a compositional semantics for a generalized composition operator on logic programs. Static and dynamic inheritance as well as composition by union of clauses can all be obtained by specializing the general operator. The semantics is based on the notion of differential programs, logic programs annotated with declarations that establish the programs' external interfaces.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158689", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Annalisa", + "last_name": "Bossi", + "institution": "" + }, + { + "first_name": "Michele", + "last_name": "Bugliesi", + "institution": "" + }, + { + "first_name": "Maurizio", + "last_name": "Gabbrielli", + "institution": "" + }, + { + "first_name": "Giorgio", + "last_name": "Levi", + "institution": "" + }, + { + "first_name": "Maria Chiara", + "last_name": "Meo", + "institution": "" + } + ], + "dblp_key": "conf/popl/BossiB93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158513", + "title": "Computer Architectures and Programming Models for Scalable Parallel Computing", + "abstract": "No abstract available.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158513", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marc", + "last_name": "Snir", + "institution": "" + } + ], + "dblp_key": "conf/popl/Snir93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158630", + "title": "Explicit Polymorphism and CPS Conversion", + "abstract": "We study the typing properties of CPS conversion for an extension of Fω with control operators. Two classes of evaluation strategies are considered, each with call-by-name and call-by-value variants. Under the “standard” strategies, constructor abstractions are values, and constructor applications can lead to non-trivial control effects. In contrast, the “ML-like” strategies evaluate beneath constructor abstractions, reflecting the usual interpretation of programs in languages based on implicit polymorphism. Three continuation passing style sub-languages are considered, one on which the standard strategies coincide, one on which the ML-like strategies coincide, and one on which all strategies coincide. Compositional, type-preserving CPS transformation algorithms are given for the standard strategies, resulting in terms on which all evaluation strategies coincide. This has as a corollary the soundness and termination of well-typed programs under the standard evaluation strategies. A similar result is obtained for the ML-like call-by-name strategy. In contrast, such results are obtained for the call-by-name strategy. In contrast, such results are obtained for the call-by value ML-like strategy only for a restricted sub-language in which constructor abstractions are limited to values.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158630", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Mark", + "last_name": "Lillibridge", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/HarperL93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158698", + "title": "Type Checking Type Classes", + "abstract": "We study the type inference problem for a system with type classes as in the functional programming language Haskell. Type classes are an extension of ML-style polymorphism with overloading. We generalize Milner's work on polymorphism by introducing a separate context constraining the type variables in a typing judgement. This lead to simple type inference systems and algorithms which closely resemble those for ML. In particular we present a new unification algorithm which is an extension of syntactic unification with constraint solving. The existence of principal types follows from an analysis of this unification algorithm.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158698", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tobias", + "last_name": "Nipkow", + "institution": "" + }, + { + "first_name": "Christian", + "last_name": "Prehofer", + "institution": "" + } + ], + "dblp_key": "conf/popl/NipkowP93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158657", + "title": "A Constructive Logic of Multiple Subtyping", + "abstract": "We show how a higher order logic, the calculus of constructions, can be used to give a simple, first principles treatment of record calculi, polymorphism, and subtyping. The development follows the constructive idiom of extracting implementations of equationally specified programs from proofs of their termination, with a logic for reasoning about programs, and a semantics that comes as a gratuity. In this framework, records are finitely specified functions where equality is decidable over the domain, with types that are a particular kind of logical assertion. By proving that a record specification satisfies its type, we can extract its implementation. While program extraction serves as a sort of compiler, proof normalization serves as an interpreter; the latter serves to ensure in some sense the coherence of the translation embedded in the former.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158657", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/popl/Mairson93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158704", + "title": "Extending Record Typing to Type Parametric Modules with Sharing", + "abstract": "We extend term unification techniques used to type extensible records in order to solve the two main typing problems for modules in Standard ML: matching and sharing. We obtain a type system for modules based only on well known unification problems, modulo some equational theories we define. Our formalization is simple and has the elegance of polymorphic type disciplines based on unification. It can be seen as a synthesis of previous work on module and record typing.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158704", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Maria Virginia", + "last_name": "Aponte", + "institution": "Early Manuscripts Electronic Library" + } + ], + "dblp_key": "conf/popl/Aponte93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158707", + "title": "Tutorial Notes on Partial Evaluation", + "abstract": "The last years have witnessed a flurry of new results in the area of partial evaluation. These tutorial notes survey the field and present a critical assessment of the state of the art.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158707", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Charles", + "last_name": "Consel", + "institution": "Neumann University" + }, + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Neumann University" + } + ], + "dblp_key": "conf/popl/ConselD93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158639", + "title": "Efficient Flow-Sensitive Interprocedural Computation of Pointer-Induced Aliases and Side Effects", + "abstract": "We present practical approximation methods for computing interprocedural aliases and side effects for a program written in a language that includes pointers, reference parameters and recursion. We present the following results: 1) An algorithm for flow-sensitive interprocedural alias analysis which is more precise and efficient than the best interprocedural method known. 2) An extension of traditional flow-insensitive alias analysis which accommodates pointers and provides a framework for a family of algorithms which trade off precision for efficiency. 3) An algorithm which correctly computes side effects in the presence of pointers. Pointers cannot be correctly handled by conventional methods for side effect analysis. 4) An alias naming technique which handles dynamically allocated objects and guarantees the correctness of data-flow analysis. 5) A compact representation based on transitive reduction which does not result in a loss of precision and improves precision in some case. 6) A method for intraprocedural alias analysis which is based on a sparse representation.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158639", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Burke", + "institution": "" + }, + { + "first_name": "Paul", + "last_name": "Carini", + "institution": "" + } + ], + "dblp_key": "conf/popl/ChoiBC93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158628", + "title": "Graph Types", + "abstract": "Recursive data structures are abstractions of simple records and pointers. They impose a shape invariant, which is verified at compile-time and exploited to automatically generate code for building, copying, comparing, and traversing values without loss of efficiency. However, such values are always tree shaped, which is a major obstacle to practical use.We propose a notion of graph types, which allow common shapes, such as doubly-linked lists or threaded trees, to be expressed concisely and efficiently. We define regular languages of routing expressions to specify relative addresses of extra pointers in a canonical spanning tree. An efficient algorithm for computing such addresses is developed. We employ a second-order monadic logic to decide well-formedness of graph type specifications. This logic can also be used for automated reasoning about pointer structures.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158628", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nils", + "last_name": "Klarlund", + "institution": "" + }, + { + "first_name": "Michael I.", + "last_name": "Schwartzbach", + "institution": "" + } + ], + "dblp_key": "conf/popl/KlarlundS93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158687", + "title": "Layer Sharing: An Improved Structure-Sharing Framework", + "abstract": "We present in this paper a structure–sharing framework originally developed for a Dynamic Programming interpreter of Logic programs called DyALog. This mechanism should be of interest for alternative execution models of PROLOG which maintain multiple computation branches and reuse sub-computations in various contexts (computation sharing). This category includes, besides our Dynamic Programming model, the tabular models (OLDT, SLDAL, XWAM), the “magic-set” models, and the independent AND and OR parallelism with solution sharing models. These models raise the problem of storing vast amount of data, motivating us to discard copying mechanisms in favor of structure-sharing mechanisms. Unfortunately, computation sharing requires joining computation branches and possibly renaming some variables, which generally leads to complex structure-sharing mechanisms. The proposed “layer-sharing” framework succeeds however in remaining understandable and easy to implement.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158687", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Éric Villemonte de la", + "last_name": "Clergerie", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Clergerie93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158618", + "title": "A Natural Semantics for Lazy Evaluation", + "abstract": "We define an operational semantics for lazy evaluation which provides an accurate model for sharing. The only computational structure we introduce is a set of bindings which corresponds closely to a heap. The semantics is set at a considerably higher level of abstraction than operational semantics for particular abstract machines, so is more suitable for a variety of proofs. Furthermore, because a heap is explicitly modelled, the semantics provides a suitable framework for studies about space behaviour of terms under lazy evaluation.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158618", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "" + } + ], + "dblp_key": "conf/popl/Launchbury93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158696", + "title": "Complexity of Bidirectional Data Flow Analysis", + "abstract": "The concept of an information flow path arising from the generalized theory of data flow analysis [21] is used to analyze the complexity of data flow analysis. The width (w) of a program flow graph with respect to a class of data flow problems is introduced as a measure of the complexity of round-robin iterative analysis. This provides the first known complexity result for round robin iterative analysis of bidirectional data flows commonly used in algorithms based on the suppression of partial redundancies [6, 7, 8, 9, 17, 18, 25]. We also show that width provides a better bound on the complexity of unidirectional data flows than the classical notion of depth.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158696", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dhananjay M.", + "last_name": "Dhamdhere", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Uday P.", + "last_name": "Khedker", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "conf/popl/DhamdhereK93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158524", + "title": "Imperative Functional Programming", + "abstract": "We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system, and extends smoothly to incorporate mixed-language working and in-place array updates.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158524", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon", + "last_name": "Jones", + "institution": "University of Glasgow" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "" + } + ], + "dblp_key": "conf/popl/JonesW93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158659", + "title": "Stratified Functional Programs and Computational Complexity", + "abstract": "We develop two notions of stratified recur-1 introduction rence. The first is predicative recurrence, and is similar to", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158659", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniël", + "last_name": "Leivant", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/Leivant93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158519", + "title": "A Novel Framework of Register Allocation for Software Pipelining", + "abstract": "Although software pipelining has been proposed as one of the most important loop scheduling methods, simultaneous scheduling and register allocation is less understood and remains an open problem [28]. The objective of this paper is to develop a unified algorithmic framework for concurrent scheduling and register allocation to support time-optimal software pipelining. A key intuition leading to this surprisingly simple formulation and its efficient solution is the association of maximum computation rate of a program graph with its critical cycles due to Reiter's pioneering work on Karp-Miller computation graphs [29]. In particular, our method generalizes the work by Callahan, Carr and Kennedy on scalar expansion[6], the work by Lam on modular variable expansion for software pipelined loops [20], and the work by Rau et al. on register allocation for modulo scheduled loops[28].", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158519", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ning", + "last_name": "Qi", + "institution": "" + }, + { + "first_name": "Guang R.", + "last_name": "Gao", + "institution": "" + } + ], + "dblp_key": "conf/popl/NingG93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158703", + "title": "Compositional Analysis of Modular Logic Programs", + "abstract": "This paper describes a semantic basis for a compositional approach to the analysis of logic programs. A logic program is viewed as consisting of a set of modules, each module defining a subset of the program's predicates. Analyses are constructed by considering abstract interpretations of a compositional semantics. The abstract meaning of a module corresponds to its analysis and composition of abstract meanings corresponds to composition of analyses. Such an approach is essential for large program development so that altering one module does not require re-analysis of the entire program. We claim that for a substantial class of programs, compositional analyses which are based on a notion of abstract unfolding provide the same precision as non-compositional analysis. A compositional analysis for ground dependencies is included to illustrate the approach. To the best of our knowledge this is the first account of a compositional framework for the analysis of logic programs.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158703", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Codish", + "institution": "KU Leuven" + }, + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "KU Leuven" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/popl/CodishDG93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158515", + "title": "Array Data-Flow Analysis and its Use in Array Privatization", + "abstract": "Data-flow analysis of scalar variables and data dependence analysis on array elements are two important program analyses used in optimizing and parallelizing compilers. Traditional data-flow analysis models accesses of array elements simply as accesses to the entire array, and is inadequate for parallelizing loops in array-based programs. On the other hand, data dependence analysis differentiates between different array elements but is flow-insensitive.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158515", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dror", + "last_name": "Maydan", + "institution": "" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "" + } + ], + "dblp_key": "conf/popl/MaydanAL93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158710", + "title": "A Categorized Bibliography on Incremental Computation", + "abstract": "In many kinds of emnputatiomd contexts, modifications of the input data are to be processed at once so as to have immediate effect on the output. Because small changes in the input to a computation often cause only small changes in the outpu~ the challenge is to compute the new output incrementally by updating parts of the old outpu~ rather than by recomputing the entire output from scratch (as a “batch computation”)", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158710", + "conference_name": "POPL", + "authors": [ + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "" + } + ], + "dblp_key": "conf/popl/RamalingamR93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158624", + "title": "Relational Parametricity and Local Variables", + "abstract": "J. C. Reynolds suggested that Strachey's intuitive concept of “parametric” (i.e., uniform) polymorphism is closely linked to representation independence, and used logical relations to formalize this principle in languages with type variables and user-defined types. Here, we use relational parametricity to address long-standing problems with the semantics of local-variable declarations, by showing that interactions between local and non-local entities satisfy certain relational criteria.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158624", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "" + }, + { + "first_name": "R. D.", + "last_name": "Tennent", + "institution": "" + } + ], + "dblp_key": "conf/popl/OHearnT93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158653", + "title": "Object-Oriented Programming without Recursive Types", + "abstract": "It is widely agreed that recursive types are inherent in the static typing of the essential mechanisms of object-oriented programming: encapsulation, message passing, subtyping, and inheritance. We demonstrate here that modeling object encapsulation in terms of existential types yields a substantially more straightforward explanation of these features in a simpler calculus without recursive types.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158653", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "" + }, + { + "first_name": "David N.", + "last_name": "Turner", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/PierceT93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158685", + "title": "The 3 R's of Optimizing Constraint Logic Programs: Refinement, Removal and Reordering", + "abstract": "Central to constraint logic programming (CLP) languages is the notion of a global constraint solver which is queried to direct execution and to which constraints are monotonically added. We present a methodology for use in the compilation of CLP languages which is designed to reduce the overhead of the global constraint solver. This methododology is based on three optimizations. The first, refinement, involves adding new constraints, which in effect make information available earlier in the computation, guiding subsequent execution away from unprofitable choices. The second, removal, involves eliminating constraints from the solver when they are redundant. The last, reordering, involves moving constraint addition later and constraint removal earlier in the computation. Determining the applicability of each optimization requires sophisticated global analysis. These analyses are based on abstract interpretation and provide information about potential and definite interaction between constraints.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158685", + "conference_name": "POPL", + "authors": [ + { + "first_name": "K", + "last_name": "Marriott", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Peter J.", + "last_name": "Stuckey", + "institution": "IBM Research - Austin" + } + ], + "dblp_key": "conf/popl/MarriottS93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158621", + "title": "An Introduction to Logical Relations and Parametric Polymorphism - Tutorial", + "abstract": "No abstract available.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158621", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Reynolds", + "institution": "" + } + ], + "dblp_key": "conf/popl/Reynolds93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158642", + "title": "Automatic Generation and Management of Interprocedural Program Analyses", + "abstract": "We have designed and implemented an interprocedural program analyzer generator, called system Z. Our goal is to automate the generation and management of semantics-based interprocedural program analysis for a wide range of target languages.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158642", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Williams Ludwell", + "last_name": "Harrison", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/YiH93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158523", + "title": "On the Orthogonality of Assignments and Procedures in Algol", + "abstract": "According to folklore, Algol is an “orthogonal” extension of a simple imperative programming language with a call-by-name functional language. The former contains assignments, branching constructs, and compound statements; the latter is based on the typed λ-calculus. In an attempt to formalize the claim of “orthogonality”, we define a simple version of Algol and an extended λ-calculus. The calculus includes the full β-rule and rules for the reduction of assignment statements and commands. It has the usual properties, e.g., it satisfies a Church-Rosser and Strong Normalization Theorem. In support of the claim that the imperative and functional components are orthogonal to each other, we show that the proofs of these theorems are combinations of separate Church-Rosser and Strong Normalization theorems for each sublanguage.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158523", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Weeks", + "institution": "" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "" + } + ], + "dblp_key": "conf/popl/WeeksF93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158529", + "title": "Semantics for Communication Primitives in an Polymorphic Language", + "abstract": "We propose a method to extend an ML-style polymorphic language with transparent communication primitives, and give their precise operational semantics. These primitives allow any polymorphic programs definable in ML to be used remotely in a manner completely transparent to the programmer. Furthermore, communicating programs may be based on different architecture and use different data representations.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158529", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Kansai University" + }, + { + "first_name": "Kazuhiko", + "last_name": "Kato", + "institution": "Kansai University" + } + ], + "dblp_key": "conf/popl/OhoriK93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158627", + "title": "Algebraic Reasoning and Completeness in Typed Languages", + "abstract": "We consider the following problem in proving observational congruences in functional languages: given a call-by-name language based on the simply-typed λ-calculus with algebraic operations axiomatized by algebraic equations E, is the set of observational congruences between terms exactly those provable from (β), (η), and E? We find conditions for determining whether βηE-equational reasoning is complete for proving the observational congruences between such terms. We demonstrate the power and generality of the theorems by presenting a number of easy corollaries for particular algebras.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158627", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jon G.", + "last_name": "Riecke", + "institution": "" + }, + { + "first_name": "Ramesh", + "last_name": "Subrahmanyam", + "institution": "" + } + ], + "dblp_key": "conf/popl/ReickeS93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158614", + "title": "Specifying the Correctness of Binding-Time Analysis", + "abstract": "Mogensen has exhibited a very compact partial evaluator for the pure lambda calculus, using binding-time analysis followed by specialization. We give a correctness criterion for this partial evaluator and prove its correctness relative to this specification. We show that the conventional properties of partial evaluators, such as the Futamura projections, are consequences of this specification. By considering both a flow analysis and the transformation it justifies together, this proof suggests a framework for the incorporating flow analyses into verified compilers.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158614", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "" + } + ], + "dblp_key": "conf/popl/Wand93", + "venue": "popl", + "year": 1993 + }, + { + "paper_id": "10.1145/158511.158644", + "title": "Static Single Assignment for Explicitely Parallel Programs", + "abstract": "We describe and prove algorithms to convert programs which use the Parallel Computing Forum Parallel Sections construct into Static Single Assignment (SSA) form. This proces allows compilers to apply classical scalar optimization algorithms to explicitly parallel programs. To do so, we must define what the concept of dominator and dominance frontier mean in parallel programs. We also describe how we extend SSA form to handle parallel updates and still preserve the SSA properties.", + "date": "1993-01-01", + "link": "https://doi.org/10.1145/158511.158644", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harini", + "last_name": "Srinivasan", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Hook", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Wolfe", + "institution": "" + } + ], + "dblp_key": "conf/popl/SrinivasanHW93", + "venue": "popl", + "year": 1993 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1994.json b/data/pl_conferences/popl/1994.json new file mode 100644 index 0000000..3250d18 --- /dev/null +++ b/data/pl_conferences/popl/1994.json @@ -0,0 +1,904 @@ +[ + { + "paper_id": "10.1145/174675.177838", + "title": "A Type System for Prototyping Languages", + "abstract": "RAPIDE is a programming language framework designed for the development of large, concurrent, real-time systems by prototyping. The framework consists of a type language and default executable, specification and architecture languages, along with associated programming tools. We describe the main features of the type language, its intended use in a prototyping environment, and rationale for selected design decisions.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177838", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dinesh", + "last_name": "Katiyar", + "institution": "Stanford University" + }, + { + "first_name": "D", + "last_name": "Luckham", + "institution": "Stanford University" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/KatiyarLM94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177844", + "title": "Decidable Bounded Quantification", + "abstract": "The standard formulation of bounded quantification, system F≤, is difficult to work with and lacks important syntactic properties, such as decidability. More tractable variants have been studied, but those studied so far either exclude significant classes of useful programs or lack a compelling semantics.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177844", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Littoral, Environnement et Sociétés" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "" + } + ], + "dblp_key": "conf/popl/CastagnaP94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.175935", + "title": "Dominators, Super Blocks, and Program Coverage", + "abstract": "In this paper we present techniques to find subsets of nodes of a flowgraph that satisfy the following property: A test set that exercises all nodes in a subset exercises all nodes in the flowgraph. Analogous techniques to find subsets of edges are also proposed. These techniques may be used to significantly reduce the cost of coverage testing of programs. A notion of a super block consisting of one or more basic blocks in that super block must be exercised by the same input. Dominator relationships among super blocks are used to identify a subset of the super blocks whose coverage implies that of all super blocks and, in turn, that of all basic blocks. Experiments with eight systems in the range of 1-75K lines of code show that, on the average, test cases targeted to cover just 29% of the basic blocks and 32% of the branches ensure 100% block and branch coverage, respectively.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.175935", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hiralal", + "last_name": "Agrawal", + "institution": "" + } + ], + "dblp_key": "conf/popl/Agrawal94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.175188", + "title": "Correctness of Trap-Based Breakpoint Implementations", + "abstract": "It is common for debuggers to implement breakpoints by a combination of planting traps and single stepping. When the target program contains multiple threads of execution, a debugger that is not carefully implemented may miss breakpoints. This paper gives a formal model of a breakpoint in a two-threaded program. The model describes correct and incorrect breakpoint implementations. Automatic search of the model's state space shows that the correct implementation does miss a breakpoint. The results apply even to debuggers like dbx and gdb, which are apparently for single-threaded programs; when the user evaluates an expression containing function calls, the debugger executes the call in the target address space, in effect creating a new thread.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.175188", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Core Competence" + } + ], + "dblp_key": "conf/popl/Ramsey94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.178047", + "title": "Representing Monads", + "abstract": "We show that any monad whose unit and extension operations are expressible as purely functional terms can be embedded in a call-by-value language with “composable continuations”. As part of the development, we extend Meyer and Wand's characterization of the relationship between continuation-passing and direct style to one for continuation-passing vs. general “monadic” style. We further show that the composable-continuations construct can itself be represented using ordinary, non-composable first-class continuations and a single piece of state. Thus, in the presence of two specific computational effects - storage and escapes - any expressible monadic structure (e.g., nondeterminism as represented by the list monad) can be added as a purely definitional extension, without requiring a reinterpretation of the whole language. The paper includes an implementation of the construction (in Standard ML with some New Jersey extensions) and several examples.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.178047", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrzej", + "last_name": "Filinski", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Filinski94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177874", + "title": "Formally Optimal Boxing", + "abstract": "An important implementation decision in polymorphically typed functional programming languages is whether to rep-resent data in boxed or unboxed form and when to transform them from one representation to the other. Using a language with explicit representation types and boxing/unboxing ope-rations we axiomatize equationally the set of all explicitly boxed versions, called completions, of a given source pro-gram. In a two-stage process we give some of the equa-tions a rewriting interpretation that captures eliminating boxing/unboxing operations without relying on a specific implementation or even semantics of the underlying lan-guage. The resulting reduction systems operate on con-gruence classes of completions defined by the remaining equations E, which can be understood as moving box-ing/unboxing operations along data flow paths in the source program. We call a completion eopt formally optimal if ev-ery other completion for the same program (and at the same representation type) reduces to eopt under this two-stage re-duction. We show that every source program has formally optimal completions, which are unique modulo E. This is accom-plished by first “polarizing ” the equations in E and orienting them to obtain two canonical (confluent and strongly nor-malizing) rewriting systems. The completions produced by Leroy’s and Poulsen’s algorithms are generally not formally optimal in our sense. The rewriting systems have been implemented and ap-plied to some simple Standard ML programs. Our results show that the amount of boxing and unboxing operations is also in practice substantially reduced in comparison to Leroy’s completions. This analysis is intended to be inte-grated into Tofte’s region-based implementation of Standard ML currently underway at DIKU.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177874", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fritz", + "last_name": "Henglein", + "institution": "University of Copenhagen" + }, + { + "first_name": "Jesper", + "last_name": "Jørgensen", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/popl/HengleinJ94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.174434", + "title": "The Typed Polymorphic Label-Selective lambda-Calculus", + "abstract": "Formal calculi of record structures have recently been a focus of active research. However, scarcely anyone has studied formally the dual notion—i.e., argument-passing to functions by keywords, and its harmonization with currying. We have. Recently, we introduced the label-selective λ-calculus, a conservative extension of λ-calculus that uses a labeling of abstractions and applications to perform unordered currying. In other words, it enables some form of commutation between arguments. This improves program legibility, thanks to the presence of labels, and efficiency, thanks to argument commuting. In this paper, we propose a simply typed version of the calculus, then extend it to one with ML-like polymorphic types. For the latter calculus, we establish the existence of principal types and we give an algorithm to compute them. Thanks to the fact that label-selective λ-calculus is a conservative extension of λ-calculus by adding numeric labels to stand for argument positions, its polymorphic typing provides us with a keyword argument-passing extension of ML obviating the need of records. In this context, conventional ML syntax can be seen as a restriction of the more general keyword-oriented syntax limited to using only implicit positions instead of keywords.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.174434", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jacques", + "last_name": "Garrigue", + "institution": "The University of Tokyo" + }, + { + "first_name": "Hassan", + "last_name": "Aı̈t-Kaci", + "institution": "" + } + ], + "dblp_key": "conf/popl/GarrigueA94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177899", + "title": "A Needed Narrowing Strategy", + "abstract": "Narrowing is the operational principle of languages that integrate functional and logic programming. We propose a notion of a needed narrowing step that, for inductively sequential rewrite systems, extends the Huet and Le´vy notion of a needed reduction step. We define a strategy, based on this notion, that computes only needed narrowing steps. Our strategy is sound and complete for a large class of rewrite systems, is optimal w.r.t. the cost measure that counts the number of distinct steps of a derivation, computes only independent unifiers, and is efficiently implemented by pattern matching.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177899", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sergio", + "last_name": "Antoy", + "institution": "Portland State University" + }, + { + "first_name": "Rachid", + "last_name": "Echahed", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Michael", + "last_name": "Hanus", + "institution": "Max Planck Society" + } + ], + "dblp_key": "conf/popl/AntoyEH94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177847", + "title": "Soft Typing with Conditional Types", + "abstract": "We present a simple and powerful type inference method for dynamically typed languages where no type information is supplied by the user. Type inference is reduced to the problem of solvability of a system of type inclusion constraints over a type language that includes function types, constructor types, union, intersection, and recursive types, and conditional types. Conditional types enable us to analyze control flow using type inference, thus facilitating computation of accurate types. We demonstrate the power and practicality of the method with examples and performance results from an implementation.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177847", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "IBM Research - Almaden" + }, + { + "first_name": "Edward L.", + "last_name": "Wimmers", + "institution": "IBM Research - Almaden" + }, + { + "first_name": "T. K.", + "last_name": "Lakshman", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/AikenWL94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177911", + "title": "Lazy Array Data-Flow Dependence Analysis", + "abstract": "Automatic parallelization of real FORTRAN programs does not live up to users expectations yet, and dependence analysis algorithms which either produce too many false dependences or are too slow to contribute significantly to this. In this paper we introduce dataflow dependence analysis algorithm which exactly computes value-based dependence relations for program fragments in which all subscripts, loop bound and IF conditions are affine. Our algorithm also computes good affine approximations of dependence relations for non-affine program fragments. Actually, we do not know about any other algorithm which can compute better approximations.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177911", + "conference_name": "POPL", + "authors": [ + { + "first_name": "V.O.", + "last_name": "Maslov", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/popl/Maslov94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177905", + "title": "An Incremental Algorithm for Maintaining the Dominator Tree of a Reducible Flowgraph", + "abstract": "We present a new incremental algorithm for the problem of maintaining the dominator tree of a reducible flowgraph as the flowgraph undergoes changes such as the insertion and deletion of edges. Such an algorithm has applications in incremental dataflow analysis and incremental compilation.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177905", + "conference_name": "POPL", + "authors": [ + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/RamalingamR94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.174538", + "title": "Higher-Order Concurrent Programs with Finite Communication Topology", + "abstract": "Concurrent ML (CML) is an extension of the functional language Standard ML(SML) with primitives for the dynamic creation of processes and channels and for the communication of values over channels. Because of the powerful abstraction mechanisms the communication topology of a given program may be very complex and therefore an efficient implementation may be facilitated by knowledge of the topology.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.174538", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hanne Riis", + "last_name": "Nielson", + "institution": "Aarhus University" + }, + { + "first_name": "Flemming", + "last_name": "Nielson", + "institution": "" + } + ], + "dblp_key": "conf/popl/NielsonN94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.174707", + "title": "From Lambda-sigma to Lambda-upsilon a Journey Through Calculi of Explicit Substitutions", + "abstract": "This paper gives a systematic description of several calculi of explicit substitutions. These systems are orthogonal and have easy proofs of termination of their substitution calculus. The last system, called λv, entails a very simple environment machine for strong normalization of λ-terms.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.174707", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Lescanne", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/Lescanne94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177973", + "title": "Reducing Indirect Function call Overhead in C++ Programs", + "abstract": "Modern computer architectures increasingly depend on mechanisms that estimate future control flow decisions to increase performance. Mechanisms such as speculative execution and prefetching are becoming standard architectural mechanisms that rely on control flow prediction to prefetch and speculatively execute future instructions. At the same time, computer programmers are increasingly turning to object-oriented languages to increase their productivity. These languages commonly use run time dispatching to implement object polymorphism. Dispatching is usually implemented using an indirect function call, which presents challenges to existing control flow prediction techniques.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177973", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brad", + "last_name": "Calder", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Dirk", + "last_name": "Grunwald", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/popl/CalderG94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177858", + "title": "Deriving Algorithms From Type Inference Systems: Application to Strictness Analysis", + "abstract": "The role of non-standard type inference in static program analysis has been much studied recently. Early work emphasised the efficiency of type inference algorithms and paid little attention to the correctness of the inference system. Recently more powerful inference systems have been investigated but the connection with efficient inference algorithms has been obscured. The contribution of this paper is twofold: first we show how to transform a program logic into an algorithm and, second, we introduce the notion of lazy types and show how to derive an efficient algorithm or strictness analysis.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177858", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chris", + "last_name": "Hankin", + "institution": "Imperial College London" + }, + { + "first_name": "Daniel Le", + "last_name": "Métayer", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/popl/HankinM94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.174673", + "title": "Portable, Unobtrusive Garbage Collection for Multiprocessor Systems", + "abstract": "We describe and prove the correctness of a new concurrent mark-and-sweep garbage collection algorithm. This algorithm derives from the classical on-the-fly algorithm from Dijkstra et al. [9]. A distinguishing feature of our algorithm is that it supports multiprocessor environments where the registers of running processes are not readily accessible, without imposing any overhead on the elementary operations of loading a register or reading or initializing a field. Furthermore our collector never blocks running mutator processes except possibly on requests for free memory; in particular, updating a field or creating or marking or sweeping a heap object does not involve system-dependent synchronization primitives such as locks. We also provide support for process creation and deletion, and for managing an extensible heap of variable-sized objects.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.174673", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Damien", + "last_name": "Doligez", + "institution": "École Normale Supérieure" + }, + { + "first_name": "Georges", + "last_name": "Gonthier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/DoligezG94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.175187", + "title": "A Functional Theory of Local Names", + "abstract": "λv is an extension of the λ-calculus with a binding construct for local names. The extension has properties analogous to classical λ-calculus and preserves all observational equivalences of λ. It is useful as a basis for modeling wide-spectrum languages that build on a functional core.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.175187", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "Karlsruhe University of Education" + } + ], + "dblp_key": "conf/popl/Odersky94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177948", + "title": "CHOCOLATE: Calculi of Higher Order COmmunication and LAmbda TErms", + "abstract": "We propose a general definition of higher-order process calculi, generalizing CHOCS [Tho89] and related calculi, and investigate its basic properties. We give sufficient conditions under which a calculus is finitely-branching and effective. We show that a suitable notion of higher-order bisimulation is a congruence for a subclass of higher-order calculi. We illustrate our definitions with a simple calculus strictly stronger than CHOCS.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177948", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bard", + "last_name": "Bloom", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Bloom94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.178043", + "title": "The Revival Transformation", + "abstract": "The notion that a definition of a variable is dead is used by optimizing compilers to delete code whose execution is useless. We extend the notion of deadness to that of partial deadness, and define a transformation, the revival transformation, which eliminates useless executions of a (partially dead) definition by tightening its execution conditions without changing the set of uses which it reaches or the conditions under which it reaches each of them.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.178043", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lawrence", + "last_name": "Feigen", + "institution": "Micro Focus (United States)" + }, + { + "first_name": "David", + "last_name": "Klappholz", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Robert", + "last_name": "Casazza", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Xing", + "last_name": "Xue", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "conf/popl/FeigenKCX94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177883", + "title": "Analyzing Logic Programs with Dynamic Scheduling", + "abstract": "Traditional logic programming languages, such as Prolog, use a fixed left-to-right atom scheduling rule. Recent logic programming languages, however, usually provide more flexible scheduling in which computation generally proceed left-to-right but in which some calls are dynamically “delayed” until their arguments are sufficiently instantiated to allow the call to run efficiently. Such dynamic scheduling has a significant cost. We give a framework for the global analysis of logic programming languages with dynamic scheduling and show that program analysis based on this framework supports optimizations which remove much of the overhead of dynamic scheduling.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177883", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kim", + "last_name": "Marriott", + "institution": "Monash University" + }, + { + "first_name": "María García de la", + "last_name": "Banda", + "institution": "Universidad Politécnica de Madrid" + }, + { + "first_name": "Manuel V.", + "last_name": "Hermenegildo", + "institution": "Universidad Politécnica de Madrid" + } + ], + "dblp_key": "conf/popl/MarriottBH94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.176925", + "title": "Proving Concurrent Constraint Programs Correct", + "abstract": "We develop a compositional proof-system for the partial correctness of concurrent constraint programs. Soundness and (relative) completeness of the system are proved with respect to a denotational semantics based on the notion of strongest postcondition. The strongest postcondition semantics provides a justification of the declarative nature of concurrent constraint programs, since it allows to view programs as theories in the specification logic.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.176925", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Frank S. de", + "last_name": "Boer", + "institution": "University of Amsterdam" + }, + { + "first_name": "Maurizio", + "last_name": "Gabbrielli", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Elena", + "last_name": "Marchiori", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Catuscia", + "last_name": "Palamidessi", + "institution": "" + } + ], + "dblp_key": "conf/popl/BoerGMP94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177907", + "title": "Value Dependence Graphs: Representation without Taxation", + "abstract": "The value dependence graph (VDG) is a sparse dataflow-like representation that simplifies program analysis and transformation. It is a functional representation that represents control flow as data flow and makes explicit all machine quantities, such as stores and I/O channels. We are developing a compiler that builds a VDG representing a program, analyzes and transforms the VDG, then produces a control flow graph (CFG) [ASU86] from the optimized VDG. This framework simplifies transformations and improves upon several published results. For example, it enables more powerful code motion than [CLZ86, FOW87], eliminates as many redundancies as [AWZ88, RWZ88] (except for redundant loops), and provides important information to the code scheduler [BR91]. We exhibit a fast, one-pass method for elimination of partial redundancies that never performs redundant code motion [KFS92, DS93] and is simpler than the classical [MR79, Dha91] or SSA [RWZ88] methods. These results accrue from eliminating the CFG from the analysis/transformation phases and using demand dependences in preference to control dependences.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177907", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Weise", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Roger F.", + "last_name": "Crew", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Bjarne", + "last_name": "Steensgaard", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/WeiseCES94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177953", + "title": "Combinatory Representation of Mobile Processes", + "abstract": "A theory of combinators in the setting of concurrent processes is formulated. The new combinators are derived from an analysis of the operation called asynchronous name passing, just as an analysis of logical substitution gave rise to the sequential combinators. A system with seven atoms and fixed interaction rules, but with no notion of prefixing, is introduced, and is shown to be capable of representing input and output prefixes over arbitrary terms in a behaviourally correct way, just as SK-combinators are closed under functional abstraction without having it as a proper syntactic construct. The basic equational correspondence between concurrent combinators and a system of asynchronous mobile processes, as well as the embedding of the finite part of π-calculus in concurrent combinators, is proved. These results will hopefully serve as a cornerstone for further investigation of the theoretical as well as pragmatic possibilities of the presented construction.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177953", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kohei", + "last_name": "Honda", + "institution": "Keio University" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Keio University" + } + ], + "dblp_key": "conf/popl/HondaY94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177880", + "title": "Combinations of Abstract Domains for Logic Programming", + "abstract": "Abstract interpretation [7] is a systematic methodology to design static program analysis which has been studied extensively in the logic programming community, because of the potential for optimizations in logic programming compilers and the sophistication of the analyses which require conceptual support. With the emergence of efficient generic abstract interpretation algorithms for logic programming, the main burden in building an analysis is the abstract domain which gives a safe approximation of the concrete domain of computation. However, accurate abstract domains for logic programming are often complex because of the variety of analyses to perform their interdependence, and the need to maintain structural information. The purpose of this paper is to propose conceptual and software support for the design of abstract domains. It contains two main contributions: the notion of open product and a generic pattern domain. The open product is a new way of combining abstract domains allowing each combined domain to benefit from information from the other components through the notions of queries and open operations. The open product is general-purpose and can be used for other programming paradigms as well. The generic pattern domain Pat (R)automatically upgrades a domain D with structural information yielding a more accurate domain Pat (D) without additional design or implementation cost. The two contributions are orthogonal and can be combined in various ways to obtain sophisticated domains while imposing minimal requirements on the designer. Both contributions are characterized theoretically and experimentally and were used to design very complex abstract domains such as PAT(OProp⊗OMode⊗OPS) which would be very difficult to design otherwise. On this last domain, designers need only contribute about 20% (about 3,400 lines) of the complete system (about 17,700 lines).", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177880", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Agostino", + "last_name": "Cortesi", + "institution": "Butler Hospital" + }, + { + "first_name": "Baudouin Le", + "last_name": "Charlier", + "institution": "Butler Hospital" + }, + { + "first_name": "Pascal Van", + "last_name": "Hentenryck", + "institution": "Butler Hospital" + } + ], + "dblp_key": "conf/popl/CortesiCH94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.178041", + "title": "Call Forwarding: A Simple Interprocedural Optimization Technique for Dynamically Typed Languages", + "abstract": "This paper discusses call forwarding, a simple interprocedural optimization technique for dynamically typed languages. The basic idea behind the optimization is straightforward: find an ordering for the “entry actions” of a procedure, and generate multiple entry points for the procedure, so as to maximize the savings realized from different call sites bypassing different sets of entry actions. We show that the problem of computing optimal solutions to arbitrary call forwarding problems is NP-complete, and describe an efficient greedy algorithm for the problem. Experimental results indicate that (i) this algorithm is effective, in that the solutions produced are generally close to optimal; and (ii) the resulting optimization leads to significant performance improvements for a number of benchmarks tested.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.178041", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Koen De", + "last_name": "Bosschere", + "institution": "Ghent University" + }, + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "University of Arizona" + }, + { + "first_name": "David", + "last_name": "Gudeman", + "institution": "University of Arizona" + }, + { + "first_name": "Sampath", + "last_name": "Kannan", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/BosschereDGK94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177850", + "title": "Automated Synthesis of Interface Adapters for Reusable Classes", + "abstract": "The need to fit together reusable components and system designs in spite of differences in protocol and representation choices occurs often in object-oriented software construction. It is therefore necessary to use adapters to achieve an exact fit between the available “socket” for a reusable part and the actual part. In this paper we discuss an approach to the construction of tools that largely automate the synthesis of adapter code. Such tools are important in reducing the effort involved in reuse since adapter synthesis can be challenging and error-prone in the complex type environment of an object-oriented language. Our approach is applicable to statically typed languages like C++ and Eiffel, and is based on a formal notion of adaptability which is related to but distinct from both subtyping and inheritance.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177850", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Satish R.", + "last_name": "Thatté", + "institution": "Clarkson University" + } + ], + "dblp_key": "conf/popl/Thatte94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177971", + "title": "Composing Tree Attributions", + "abstract": "Using the simple tree attributions described in this paper, attribute values can themselves be trees, enabling attribution to be used for tree transformations. Unlike higher-order attribute grammars, simple tree attributions have the property of descriptional composition, which allows a complex transformation to be built up from simpler ones, yet be executed efficiently. In contrast to other formalisms that admit descriptional composition, notably composable attribute grammars, simple tree attributions have the expressive power to handle remote references and recursive syntactic (tree-generating) functions, providing significantly more general forms of attribution and transformation.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177971", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Boyland", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/BoylandG94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177855", + "title": "Implementation of the Typed Call-by-Value lambda-Calculus using a Stack of Regions", + "abstract": "We present a translation scheme for the polymorphically typed call-by-value λ-calculus. All runtime values, including function closures, are put into regions. The store consists of a stack of regions. Region inference and effect inference are used to infer where regions can be allocated and de-allocated. Recursive functions are handled using a limited form of polymorphic recursion. The translation is proved correct with respect to a store semantics, which models as a region-based run-time system. Experimental results suggest that regions tend to be small, that region allocation is frequent and that overall memory demands are usually modest, even without garbage collection.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177855", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mads", + "last_name": "Tofte", + "institution": "University of Copenhagen" + }, + { + "first_name": "Jean-Pierre", + "last_name": "Talpin", + "institution": "" + } + ], + "dblp_key": "conf/popl/TofteT94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.176926", + "title": "Manifest Types, Modules, and Separate Compilation", + "abstract": "This paper presents a variant of the SML module system that introduces a strict distinction between abstract types and manifest types (types whose definitions are part of the module specification), while retaining most of the expressive power of the SML module system. The resulting module system provides much better support for separate compila- tion.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.176926", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Leroy94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.178068", + "title": "Building Interpreters by Composing Monads", + "abstract": "We exhibit a set of functions coded in Haskell that can be used as building blocks to construct a variety of interpreters for Lisp-like languages. The building blocks are joined merely through functional composition. Each building block contributes code to support a specific feature, such as numbers, continuations, functions calls, or nondeterminism. The result of composing some number of building blocks is a parser, an interpreter, and a printer that support exactly the expression forms and data types needed for the combined set of features, and no more.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.178068", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "" + } + ], + "dblp_key": "conf/popl/Steele94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.178053", + "title": "A Generic Account of Continuation-Passing Styles", + "abstract": "We unify previous work on the continuation-passing style (CPS) transformations in a generic framework based on Moggi's computational met a-language. This framework is used to obtain GPS transformations for a variety of evaluation strategies and to characterize the corresponding administrative reductions and inverse transformations. We establish generic formal connections between operational semantics and equational theories. Formal properties of transformations for specific evaluation orders follow as corollaries. Essentially, we factor transformations through Moggi's computational meta-language. Mapping A-terms into the met a-language captures computational properties (e.g., partiality, strictness) and evaluation order explicitly in both the term and the type structure of the meta-language. The CPS transformation is then obtained by applying a generic transformation from terms and types in the meta-language to CPS terms and types, based on a typed term representation of the continuation monad. We prove an adequacy property for the generic transformation and establish an equational correspondence between the meta-language and CPS terms. These generic results generalize Plotkin's seminal theorems, subsume more recent results, and enable new uses of CPS transformations and their inverses. We discuss how to apply these results to compilation.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.178053", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Hatcliff", + "institution": "Kansas State University" + }, + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/HatcliffD94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177972", + "title": "A Staging Calculus and its Application to the Verification of Translators", + "abstract": "We develop a calculus in which the computation steps required to execute a computer program can be separated into discrete stages. The calculus, denoted λ2, is embedded within the pure untyped λ-calculus. The main result of the paper is a characterization of sufficient conditions for confluence for terms in the calculus. The condition can be taken as a correctness criterion for translators that perform reductions in one stage leaving residual redexes over for subsequent computation stages. As an application of the theory, we verify the correctness of a macro expansion algorithm. The expansion algorithm is of some interest in its own right since it solves the problem of desired variable capture using only the familiar capture avoiding substitutions.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177972", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Muller", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/popl/Muller94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.174710", + "title": "Memory Subsystem Performance of Programs Using Copying Garbage Collection", + "abstract": "Heap allocation with copying garbage collection is believed to have poor memory subsystem performance. We conducted a study of the memory subsystem performance of heap allocation for memory subsystems found on many machines. We found that many machines support heap allocation poorly. However, with the appropriate memory subsystem organization, heap allocation can have good memory subsystem performance.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.174710", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "David", + "last_name": "Tarditi", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/DiwanTM94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177941", + "title": "An Operational Framework for Value-Passing Processes", + "abstract": "This paper develops a semantic framework for concurrent languages with value passing. An operation analogous to substitution in the λ-calculus is given, and a semantics is given for a value-passing version of Milner's Calculus of Communicating Systems (CCS). An operational equivalence is then defined and shown to coincide with Milner's (early) bisimulation equivalence. We also show how semantics maybe given for languages with asynchronous communication primitives. In contrast with existing approaches to value passing, this semantics does not reduce data exchange to pure synchronization over (potentially infinite) families of ports indexed by data, and it avoids variable renamings that are not local to processes engaged in communication.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177941", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rance", + "last_name": "Cleaveland", + "institution": "North Carolina State University" + }, + { + "first_name": "Daniel", + "last_name": "Yankelevich", + "institution": "North Carolina State University" + } + ], + "dblp_key": "conf/popl/CleavelandY94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.176927", + "title": "A Type-Theoretic Approach to Higher-Order Modules with Sharing", + "abstract": "The design of a module system for constructing and maintaining large programs is a difficult task that raises a number of theoretical and practical issues. A fundamental issue is the management of the flow of information between program units at compile time via the notion of an interface. Experience has shown that fully opaque interfaces are awkward to use in practice since too much information is hidden, and that fully transparent interfaces lead to excessive interdependencies, creating problems for maintenance and separate compilation. The “sharing” specifications of Standard ML address this issue by allowing the programmer to specify equational relationships between types in separated modules, but are not expressive enough to allow the programmer complete control over the propagation of type information between modules.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.176927", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Mark", + "last_name": "Lillibridge", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/HarperL94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177889", + "title": "Higher-Order Equational Logic Programming", + "abstract": "Higher-order equational logic programming is a paradigm which combines first-order equational and higher-order logic programming, where higher-order logic programming is based on a subclass of simply typed l-terms, called higher-order patterns. Central to the notion of higher-order equational logic programming is the so-called higher-order equational unification. This paper extends several important classes of first-order equational unification algorithms to the higher-order setting: only problems of the extensions are discussed and first-order equational unifications are viewed as black boxes whenever possible.We first extend narrowing and show that the completeness of many higher-order narrowing strategies reduces to that of their underlying first-order counterparts. Then we propose an algorithm or higher-order equational unification of free higher-order patterns in an arbitrary equational theory. Finally a general approach to extend first-order unification combination algorithms is sketched informally. The termination property of the above higher-order extensions is considered in a uniform way.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177889", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhenyu", + "last_name": "Qian", + "institution": "University of Bremen" + } + ], + "dblp_key": "conf/popl/Qian94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177904", + "title": "Detecting Pipeline Structural Hazards Quickly", + "abstract": "This paper describes a method for detecting structural hazards 5--80 times faster than its predecessors, which generally have simulated the pipeline at compile time. It accepts a compact specification of the pipeline and creates a finitestate automaton that can detect structural hazards in one table lookup per instruction. The automaton maintains an integer state that encodes all potential structural hazards for all instructions in the pipe. It accepts an instruction type and a state and either reports a hazard or produces the state that folds in the new instruction and advances the pipeline by one cy-", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177904", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "University of Arizona" + }, + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/popl/ProebstingF94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.177965", + "title": "Multi-Pass Execution of Functional Logic Programs", + "abstract": "An operational semantics for functional logic programs is presented. In such programs functional terms provide for reduction of expressions, provided that they ground. The semantics is based on multi-pass evaluation techniques originally developed for attribute grammars. Program execution is divided into two phases: (1) construction of an incomplete proof tree, and (2) its decoration into a complete proof tree. The construction phase applies a modified SLD-resolution scheme, and the decoration phase a partial (multi-pass) traversal over the tree. The phase partition is generated by static analysis where data dependencies are extracted for the functional elements of the program. The method guarantees that all the functional terms of a program can be evaluated, and no dynamic groundness checks are needed.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.177965", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jukka", + "last_name": "Paakki", + "institution": "University of Jyväskylä" + } + ], + "dblp_key": "conf/popl/Paakki94", + "venue": "popl", + "year": 1994 + }, + { + "paper_id": "10.1145/174675.178044", + "title": "Selective and Lightweight Closure Conversion", + "abstract": "We consider the problem of selective and lightweight closure conversion, in which multiple procedure-calling protocols may coexist in the same code. Flow analysis is used to match the protocol expected by each procedure and the protocol used at each of its possible call sites. We formulate the flow analysis as the solution of a set of constraints, and show that any solution to the constraints justifies the resulting transformation. Some of the techniques used are suggested by those of abstract interpretation, but others arise out of alternative approaches.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/174675.178044", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + }, + { + "first_name": "Paul", + "last_name": "Steckler", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/WandS94", + "venue": "popl", + "year": 1994 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1995.json b/data/pl_conferences/popl/1995.json new file mode 100644 index 0000000..776c056 --- /dev/null +++ b/data/pl_conferences/popl/1995.json @@ -0,0 +1,847 @@ +[ + { + "paper_id": "10.1145/199448.199481", + "title": "Lower Bounds on Type Inference with Subtypes", + "abstract": "We investigate type inference for programming languages with subtypes. As described in previous work, there are several type inference problems for any given expression language, depending on the form of the subtype partial order and the ability to define new subtypes in programs. Our first main result is that for any specific subtype partial order, the problem of determining whether a lambda term is typable is algorithmically (polynomial-time) equivalent to a form of satisfiability problem over the same partial order. This gives the first exact characterization of the problem that is independent of the syntax of expressions. In addition, since this form of satisfiability problem is PSPACE-hard over certain partial orders, this equivalence strengthens the previous lower bound of NP-hard to PSPACE-hard. Our second main result is a lower bound on the length of most general types when the subtype hierarchy may change as a result of additional type declarations within the program. More specifically, given any input expression, a type inference algorithm tries to find a most general (or principal) typing. The property of a most general typing is that it has all other possible typings as instances. However, there are several sound notions of instance in the presence of subtyping. Our lower bound is that no sound definition of instance would allow the set of additional subtyping hypotheses about a term to grow less than linearly in the size of the term.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199481", + "conference_name": "POPL", + "authors": [ + { + "first_name": "M.", + "last_name": "Hoang", + "institution": "Stanford University" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/HoangM95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199468", + "title": "Reasoning about Rings", + "abstract": "The ring is a useful means of structuring concurrent processes. Processes communicate by passing a token in a fixed direction; the process that possesses the token is allowed to make certain moves. Usually, correctness properties are expected to hold irrespective of the size of the ring. We show that the problem of checking many useful correctness properties for rings of all sizes can be reduced to checking them on a ring of small size. The results do not depend on the processes being finite state. We illustrate our results on examples.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199468", + "conference_name": "POPL", + "authors": [ + { + "first_name": "E. Allen", + "last_name": "Emerson", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kedar S.", + "last_name": "Namjoshi", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/EmersonN95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199507", + "title": "The Call-by-Need Lambda Calculus", + "abstract": "The mismatch between the operational semantics of the lambda calculus and the actual behavior of implementations is a major obstacle for compiler writers. They cannot explain the behavior of their evaluator in terms of source level syntax, and they cannot easily compare distinct implementations of different lazy strategies. In this paper we derive an equational characterization of call-by-need and prove it correct with respect to the original lambda calculus. The theory is a strictly smaller theory than the lambda calculus. Immediate applications of the theory concern the correctness proofs of a number of implementation strategies, e.g., the call-by-need continuation passing transformation and the realization of sharing via assignments.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199507", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "University of Oregon" + }, + { + "first_name": "John", + "last_name": "Maraist", + "institution": "Karlsruhe University of Applied Sciences" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/popl/AriolaFMOW95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199470", + "title": "Verifying Infinite State Processes with Sequential and Parallel Composition", + "abstract": "We investigate the verification problem of infinite-state process w.r.t. logic-based specifications that express properties which may be nonregular. We consider the process algebra PA which integrates and strictly subsumes the algebras BPA (basic process algebra) and BPP (basic parallel processes), by allowing both sequential and parallel compositions as well as nondeterministic choice and recursion. Many relevant properties of PA processes are nonregular, and thus can be expressed neither by classical temporal logics nor by finite state ω-automata. Properties of particular interest are those involving constraints on numbers of occurrences of events. In order to express such properties, which are nonregular in general, we use the temporal logic PCTL which combines the branching-time temporal logic CTL with Presburger arithmetics. Then we tackle the verification problem of guarded PA processes w.r.t. PCTL formulas. We mainly prove that, while this problem is undecidable for the full PCTL, it is actually decidable for the class of guarded PA processes (and thus for the class of guarded BPA's and guarded BPP's), and a large fragment of PCTL called PCTL+.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199470", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Verimag" + }, + { + "first_name": "Rachid", + "last_name": "Echahed", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Peter", + "last_name": "Habermehl", + "institution": "Verimag" + } + ], + "dblp_key": "conf/popl/BouajjaniEH95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199528", + "title": "Monad Transformers and Modular Interpreters", + "abstract": "We show how a set of building blocks can be used to construct programming language interpreters, and present implementations of such building blocks capable of supporting many commonly known features, including simple expressions, three different function call mechanisms (call-by-name, call-by-value and lazy evaluation), references and assignment, nondeterminism, first-class continuations, and program tracing.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199528", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sheng", + "last_name": "Liang", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + }, + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/LiangHJ95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199530", + "title": "Structuring Depth-First Search Algorithms in Haskell", + "abstract": "Depth-first search is the key to a wide variety of graph algorithms. In this paper we express depth-first search in a lazy functional language, obtaining a linear-time implementation. Unlike traditional imperative presentations, we use the structuring methods of functional languages to construct algorithms from individual reusable components. This style of algorithm construction turns out to be quite amenable to formal proof, which we exemplify through a calculational-style proof of a far from obvious strongly-connected components algorithm.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199530", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David J.", + "last_name": "King", + "institution": "University of Glasgow" + }, + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "conf/popl/KingL95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199539", + "title": "Corrigendum: Decidable Bounded Quantification", + "abstract": "No abstract available.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199539", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/CastagnaP95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199475", + "title": "Compiling Polymorphism Using Intensional Type Analysis", + "abstract": "The views and conclusions contained in this document are those of the authors and should not be interpreted as", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199475", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/HarperM95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199516", + "title": "A Language with Distributed Scope", + "abstract": "Obliq is a lexically-scoped, untyped, interpreted language that supports distributed object-oriented computation. Obliq objects have state and are local to a site. Obliq computations can roam over the network, while maintaining network connections. Distributed lexical scoping is the key mechanism for managing distributed computation.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199516", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "" + } + ], + "dblp_key": "conf/popl/Cardelli95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199482", + "title": "Positive Subtyping", + "abstract": "The statement S≤T in a λ-calculus with subtyping is traditionally interpreted by a semantic coercion function of type [[S]]→[[T]] that extracts the “T part” of an element of S. If the subtyping relation is restricted to covariant positions, this interpretation may be enriched to include both the implicit coercion and an overwriting function put[S,T] ∈ [[S]]→[[T]]→[[S]] that updates the T part of an element of S. We give a realizability model and a sound equational theory for a second-order calculus of positive subtyping.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199482", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Hofmann", + "institution": "" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "" + } + ], + "dblp_key": "conf/popl/HofmannP95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199466", + "title": "An Extended Form of Must Alias Analysis for Dynamic Allocation", + "abstract": "The paper presents methods that we have implemented to improve the quality of the def-uses reported for dynamically allocated locations. The methods presented are based on the Ruggieri/Murtagh naming scheme for dynamically created locations. We expand upon this scheme to name dynamically allocated locations for some user written allocation routines. Using this expanded naming scheme, we introduce an inexpensive, non-iterative, and localized calculation of extended must alias analysis to handle dynamically allocated locations, and show how this information can be used to improve def-use information. This is the first attempt to specify must alias information for names which represent a set of dynamically allocated locations. Empirical results are presented to illustrate the usefulness of our method. We consider this work a step towards developing practical re-engineering tools for C.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199466", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rita Z.", + "last_name": "Altucher", + "institution": "Siemens (Germany)" + }, + { + "first_name": "William", + "last_name": "Landi", + "institution": "Siemens (Germany)" + } + ], + "dblp_key": "conf/popl/AltucherL95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199536", + "title": "A Unified Treatment of Flow Analysis in Higher-Order Languages", + "abstract": "We describe a framework for flow analysis in higher-order languages. It is both a synthesis and extension of earlier work in this area, most notably [20, 22]", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199536", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Princeton University" + }, + { + "first_name": "Stephen", + "last_name": "Weeks", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/JagannathanW95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199484", + "title": "The Semantics of Future and Its Use in Program Optimizations", + "abstract": "The future annotations of MultiLisp provide a simple method for taming the implicit parallelism of functional programs. Past research concerning futures has focused on implementation issues. In this paper, we present a series of operational semantics for an idealized functional language with futures with varying degrees of intensionality. We develop a set-based analysis algorithm from the most intensional semantics, and use that algorithm to perform touch optimization on programs. Experiments with the Gambit compiler indicates that this optimization substantially reduces program execution times. 1 Implicit Parallelism via Annotations Programs in functional languages offer numerous opportunities for executing program components in parallel. In a call-by-value language, for example, the evaluation of every function application could spawn a parallel thread for each sub-expression. However, if such a strategy were applied indiscriminately, the execution of a program would generate far t...", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199484", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/FlanaganF95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199509", + "title": "Unification Factoring for Efficient Execution of Logic Programs", + "abstract": "The efficiency of resolution-based logic programming languages, such as Prolog, depends critically on selecting and executing sets of applicable clause heads to resolve against subgoals. Traditional approaches to this problem have focused on using indexing to determine the smallest possible applicable set. Despite their usefulness, these approaches ignore the non-determinism inherent in many programming languages to the extent that they do not attempt to optimize execution after the applicable set theory has been determined.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199509", + "conference_name": "POPL", + "authors": [ + { + "first_name": "S L", + "last_name": "Dawson", + "institution": "Stony Brook University" + }, + { + "first_name": "C. R.", + "last_name": "Ramakrishnan", + "institution": "Stony Brook University" + }, + { + "first_name": "I. V.", + "last_name": "Ramakrishnan", + "institution": "Stony Brook University" + }, + { + "first_name": "Konstantinos", + "last_name": "Sagonas", + "institution": "Stony Brook University" + }, + { + "first_name": "Steven", + "last_name": "Skiena", + "institution": "Stony Brook University" + }, + { + "first_name": "Theresa", + "last_name": "Swift", + "institution": "Stony Brook University" + }, + { + "first_name": "David S.", + "last_name": "Warren", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/popl/DawsonRRSSSW95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199451", + "title": "Sequential Algorithms, Deterministic Parallelism, and Intensional Expressiveness", + "abstract": "We call language L1 intensionally more expressive than L2 if there are functions which can be computed faster in L1 than in L2. We study the intensional expressiveness of several languages: the Berry-Curien programming language of sequential algorithms, CDS0, a deterministic parallel extension to it, named CDSP, and various parallel extensions to the functional programming language PCF. The paper consists of two parts.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199451", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Brookes", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Denis Razuan", + "last_name": "Dancanet", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/BrookesD95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199472", + "title": "Structured Operational Semantics as a Specification Language", + "abstract": "Standard specification languages have very limited abilities to define new operations on processes. We introduce the concept of a Protean specification language, with general definitional facilities supported by the appropriate theory. Protean languages allow elegant, readable, and useful specifications at all levels of abstraction. A good Protean specification language will admit methods of verifying that one specification is a refinement of another. We sketch a family of Protean specification languages (with references to the full details) which allow a vast amount of expressive power in defining operations, but nonetheless have all the essential theoretical and specification power of CCS and ACP.We illustrate these techniques by presenting several specifications of the job of protecting an arbitrary server by a checkpoint/backup scheme. The high-level specification of the protected server simply says, “It does everything it did before, and it doesn't crash.” The middle-level specification describes checkpointing cleanly and abstractly, without prescribing any particular implementation. The low-level specification is fairly close to an implementation. We show the high- and medium-level specifications equivalent by bisimulation relation techniques, and the medium- and low-level specifications equivalent by equational reasoning using automatically-generated equations. We also show that the operations expressing checkpointing behavior are not definable in standard process algebras.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199472", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bard", + "last_name": "Bloom", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Bloom95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199533", + "title": "A Type System Equivalent to Flow Analysis", + "abstract": "Flow-based safety analysis of higher-order languages has been studied by Shivers, and Palsberg and Schwartzbach. Open until now is the problem of finding a type system that accepts exactly the same programs as safety analysis.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199533", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Aarhus University" + }, + { + "first_name": "Patrick", + "last_name": "O'Keefe", + "institution": "" + } + ], + "dblp_key": "conf/popl/PalsbergO95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199473", + "title": "Generic Polymorphism", + "abstract": "We present the extensional polymorphism, a framework to type check ad hoc polymorphic functions. This formalism is compatible with parametric polymorphism, and supports a large class of functions defined by structural pattern matching on types.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199473", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Catherine", + "last_name": "Dubois", + "institution": "Université d'Évry Val-d'Essonne" + }, + { + "first_name": "François", + "last_name": "Rouaix", + "institution": "Université d'Évry Val-d'Essonne" + }, + { + "first_name": "Pierre", + "last_name": "Weis", + "institution": "Université d'Évry Val-d'Essonne" + } + ], + "dblp_key": "conf/popl/DuboisRW95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199483", + "title": "The Geometry of Interaction Machine", + "abstract": "We investigate implementation techniques arising directly from Girard's Geometry of Interaction semantics for Linear Logic, specifically for a simple functional programming language (PCF). This gives rise to a very simple, compact, compilation schema and run-time system. We analyse various properties of this kind of computation that suggest substantial optimisations that could make this paradigm of implementation not only practical, but potentially more efficient than extant paradigms.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199483", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ian", + "last_name": "Mackie", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/Mackie95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199534", + "title": "Parametric Program Slicing", + "abstract": "Program slicing is a technique for isolating computational threads in programs. In this paper, we show how to mechanically extract a family of practical algorithms for computing slices directly from semantic specifications. These algorithms are based on combining the notion of dynamic dependence tracking in term rewriting systems with a program representation whose behavior is defined via an equational logic. Our approach is distinguished by the fact that changes to the behavior of the slicing algorithm can be accomplished through simple changes in rewriting rules that define the semantics of the program representation. Thus, e.g., different notions of dependence may be specified, properties of language-specific datatypes can be exploited, and various time, space, and precision tradeoffs may be made. This flexibility enables us to generalize the traditional notions of static and dynamic slices to that of a constrained slice, where any subset of the inputs of a program may be supplied.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199534", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John K.", + "last_name": "Field", + "institution": "IBM (United States)" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM (United States)" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/popl/FieldRT95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199517", + "title": "A Formal Model of Procedure Calling Conventions", + "abstract": "Procedure calling conventions are used to provide uniform procedure-call interfaces. Applications, such as compilers and debuggers, which generate, or process procedures at the machine-language abstraction level require knowledge of the calling convention. In this paper, we develop a formal model for procedure calling conventions called P-FSA's. Using this model, we are able to ensure several completeness and consistency properties of calling conventions. Currently, applications that manipulate procedures implement conventions in an ad-hoc manner. The resulting code is complicated with details, difficult to maintain, and often riddled with errors. To alleviate the situation, we introduce a calling convention specification language, called CCL. The combination of CCL and P-FSA's facilitates the accurate specification of conventions that can be shown to be both consistent and complete.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199517", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark W.", + "last_name": "Bailey", + "institution": "University of Virginia" + }, + { + "first_name": "Jack W.", + "last_name": "Davidson", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/popl/BaileyD95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199461", + "title": "Demand-driven Computation of Interprocedural Data Flow", + "abstract": "This paper presents a general framework for deriving demand-driven algorithms for interprocedural data flow analysis of imperative programs. The goal of demand-driven analysis is to reduce the time and/or space overhead of conventional exhaustive analysis by avoiding the collection of information that is not needed. In our framework, a demand for data flow information is modeled as a set of date flow queries. The derived demand-driven algorithms find responses to these queries through a partial reversal of the respective data flow analysis. Depending on whether minimizing time or space is of primary concern, result caching may be incorporated in the derived algorithm. Our framework is applicable to interprocedural data flow problems with a finite domain set. If the problem's flow functions are distributive, the derived demand algorithms provide as precise information as the corresponding exhaustive analysis. For problems with monotone but non-distributive flow functions the provided data flow solutions are only approximate. We demonstrate our approach using the example of interprocedural copy constant propagation.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199461", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Evelyn", + "last_name": "Duesterwald", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Mary Lou", + "last_name": "Soffa", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/popl/DuesterwaldGS95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199478", + "title": "Higher-Order Functors with Transparent Signatures", + "abstract": "The programming language Standard ML provides first-order functors, i.e. modules parameterized by modules. First-order functors in the language have a simple and elegant static semantics. The type structure of higher-order modules, i.e. modules parameterized by functors, is well understood. But it is only in the recent past that we have seen an implementation of higher-order functors with a formally defined static semantics in a dialect of Standard ML, SML/NJ. A study of this static semantics shows it to be much more complicated than the static semantics of first-order functors. This paper investigates whether we can trade some semantic features in the module language to obtain a simpler static semantics, closer in spirit to that of first-order functors. This work helps in a conceptual understanding of the semantics of higher-order modules.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199478", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sandip K.", + "last_name": "Biswas", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/Biswas95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199526", + "title": "Optimizing an ANSI C Interpreter with Superoperators", + "abstract": "This paper introduces superoperators, an optimization technique for bytecoded interpreters. Superoperators are virtual machine operations automatically synthesized from smaller operations to avoid costly per-operation overheads. Superoperators decrease executable size and can double or triple the speed of interpreted programs. The paper describes a simple and effective heuristic for inferring powerful superoperators from the usage patterns of simple operators.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199526", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/Proebsting95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199524", + "title": "Obtaining Sequential Efficiency for Concurrent Object-Oriented Languages", + "abstract": "Concurrent object-oriented programming (COOP) languages focus the abstraction and encapsulation power of abstract data types on the problem of concurrency control. In particular, pure fine-grained concurrent object-oriented languages (as opposed to hybrid or data parallel) provides the programmer with a simple, uniform, and flexible model while exposing maximum concurrency. While such languages promise to greatly reduce the complexity of large-scale concurrent programming, the popularity of these languages has been hampered by efficiency which is often many orders of magnitude less than that of comparable sequential code. We present a sufficiency set of techniques which enables the efficiency of fine-grained concurrent object-oriented languages to equal that of traditional sequential languages (like C) when the required data is available. These techniques are empirically validated by the application to a COOP implementation of the Livermore Loops.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199524", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Plevyak", + "institution": "Urbana University" + }, + { + "first_name": "Xingbin", + "last_name": "Zhang", + "institution": "Urbana University" + }, + { + "first_name": "Andrew A.", + "last_name": "Chien", + "institution": "Urbana University" + } + ], + "dblp_key": "conf/popl/PlevyakZC95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199450", + "title": "Isolating Side Effects in Sequential Languages", + "abstract": "It is well known that adding side effects to functional languages changes the operational equivalences of the language. We develop a new language construct, encap, that forces imperative pieces of code to behave purely functionally, i.e., without any visible side effects. The coercion operator encap provides a means of extending the simple reasoning principles for equivalences of code in a functional language to a language with side effects. In earlier work [36], similar coercion operators were developed, but their correctness required the underlying functional language to include parallel operations. The coercion operators developed here are simpler and are proven correct for purely sequential languages. The sequential setting requires the construction of fully abstract models for sequential call-by-value languages and the formulation of a weak form of &quot;monad&quot; suitable for expressing the semantics of call-by-value languages with side effects. 1 Introduction Two pieces of code are...", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199450", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jon G.", + "last_name": "Riecke", + "institution": "Nokia (United States)" + }, + { + "first_name": "Ramesh", + "last_name": "Viswanathan", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/RieckeV95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199464", + "title": "A Linear Time Algorithm for Placing phi-nodes", + "abstract": "Dataflow analysis framework based on Static Single Assignment (SSA) form and Sparse Evaluation Graphs (SEGs) demand fast computation of program points where data flow information must be merged, the so-called φ-nodes. In this paper, we present a surprisingly simple algorithm for computing φ-nodes for arbitrary flowgraphs (reducible or irreducible) that runs in linear time. We employ a novel program representation—the DJ graph—by augmenting the dominator tree of a flowgraph with edges which may lead to a potential “merge” of dataflow information. In searching for φ-nodes we never visit an edge in the DJ-graph more than once by guiding the search of nodes by their levels in the dominator tree.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199464", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vugranam C.", + "last_name": "Sreedhar", + "institution": "McGill University" + }, + { + "first_name": "Guang R.", + "last_name": "Gao", + "institution": "McGill University" + } + ], + "dblp_key": "conf/popl/SreedharG95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199476", + "title": "Applicative Functors and Fully Transparent Higher-Order Modules", + "abstract": "we present a variety of the Standard ML module system where parameterized abstract types (i.e. functors returning generative types) map provably equal arguments to compatible abstract types, instead of generating distinct types at each applications as in Standard ML. This extension solves the full transparency problem (how to give syntactic signatures for higher-order functors that express exactly their propagation of type equations), and also provides better support for non-closed code fragments.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199476", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Leroy95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199513", + "title": "Default Timed Concurrent Constraint Programming", + "abstract": "We extend the model of [SJG94b] to express strong time-outs (and pre-emption): if an event A does not happen through time t, cause event B to happen at time t. Such constructs arise naturally in practice (e.g. in modeling transistors) and are supported in languages such as ESTEREL (through instantaneous watchdogs) and LUSTRE (through the “current” operator).", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199513", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vijay", + "last_name": "Saraswat", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Radha", + "last_name": "Jagadeesan", + "institution": "Loyola University Chicago" + }, + { + "first_name": "Vineet", + "last_name": "Gupta", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/popl/SaraswatJG95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199511", + "title": "Separation Constraint Partitioning - A New Algorithm for Partitioning Non-strict Programs into Sequential Threads", + "abstract": "In this paper we present substantially improved thread partitioning algorithms for modern implicitly parallel languages. We present a new block partitioning algorithm, separation constraint partitioning, which is both more powerful and more flexible than previous algorithms. Our algorithm is guaranteed to derive maximal threads. We present a theoretical framework for proving the correctness of our partitioning approach, and we show how separation constraint partitioning makes interprocedural partitioning viable.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199511", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Klaus E.", + "last_name": "Schauser", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "David", + "last_name": "Culler", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Seth Copen", + "last_name": "Goldstein", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/SchauserCG95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199452", + "title": "Using Functor Categories to Generate Intermediate Code", + "abstract": "In the early 80's Oles and Reynolds devised a semantic model of Algol-like languages using a category of functors from a category of store shapes to the category of predomains. Here we will show how a variant of this idea can be used to define the translation of an Algol-like language to intermediate code in a uniform way that avoids unnecessary temporary variables, provides control-flow translation of boolean expressions, permits online expansion of procedures, and minimizes the storage overhead of calls of closed procedures. The basic idea is to replace continuations by instruction sequences and store shapes by descriptions of the structure of the run-time stack.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199452", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Reynolds", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Reynolds95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199531", + "title": "Time and Space Profiling for Non-Strict Higher-Order Functional Languages", + "abstract": "We present the first profiler for a compiled, non-strict, higher-order, purely functional language capable of measuring time as well as space usage. Our profiler is implemented in a production-quality optimising compiler for Haskell, has low overheads, and can successfully profile large applications.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199531", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick M.", + "last_name": "Sansom", + "institution": "University of Glasgow" + }, + { + "first_name": "Simon", + "last_name": "Jones", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/popl/SansomJ95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199462", + "title": "Precise Interprocedural Dataflow Analysis via Graph Reachability", + "abstract": "The paper shows how a large class of interprocedural dataflow-analysis problems can be solved precisely in polynomial time by transforming them into a special kind of graph-reachability problem. The only restrictions are that the set of dataflow facts must be a finite set, and that the dataflow functions must distribute over the confluence operator (either union or intersection). This class of probable problems includes—but is not limited to—the classical separable problems (also known as “gen/kill” or “bit-vector” problems)—e.g., reaching definitions, available expressions, and live variables. In addition, the class of problems that our techniques handle includes many non-separable problems, including truly-live variables, copy constant propagation, and possibly-uninitialized variables.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199462", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/RepsHS95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199479", + "title": "Structural Decidable Extensions of Bounded Quantification", + "abstract": "We show how the subtype relation of the well-known system F<, the second-order polymorphic A-calculus with bounded u~lversal type quantification and subtyping, due to Cardelli, Wegner, Bruce, Longo, Curien, Ghelli [6, 2, 8], proved undecidable by Pierce [12], can be interpreted in the (weak) order theory of several successor functions (W)SnS. 1", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199479", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sergei", + "last_name": "Vorobyov", + "institution": "Max Planck Institute for Informatics" + } + ], + "dblp_key": "conf/popl/Vorobyov95", + "venue": "popl", + "year": 1995 + }, + { + "paper_id": "10.1145/199448.199485", + "title": "Total Correctness by Local Improvement in Program Transformation", + "abstract": "The goal of program transformation is to improve efficiency while preserving meaning. One of the best known transformation techniques is Burstall and Darlington's unfold-fold method. Unfortunately the unfold-fold method itself guarantees neither improvement in efficiency nor total-correctness. The correctness problem for unfold-fold is an instance of a strictly more general problem: transformation by locally equivalence-preserving steps does not necessarily preserve (global) equivalence.", + "date": "1995-01-01", + "link": "https://doi.org/10.1145/199448.199485", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Sands", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/popl/Sands95", + "venue": "popl", + "year": 1995 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1996.json b/data/pl_conferences/popl/1996.json new file mode 100644 index 0000000..e69ade6 --- /dev/null +++ b/data/pl_conferences/popl/1996.json @@ -0,0 +1,794 @@ +[ + { + "paper_id": "10.1145/237721.237742", + "title": "On the Complexity of Beta-Reduction", + "abstract": "We prove that the complexity of Lamping's optimal graph reduction technique for the λ-calculus can be exponential in the number of Lévy's family reductions. Starting from this consideration, we propose a new measure for what could be considered as \"the intrinsic complexity\" of λ-terms.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237742", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Asperti", + "institution": "" + } + ], + "dblp_key": "conf/popl/Asperti96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237779", + "title": "Generating Machine Specific Optimizing Compilers", + "abstract": "Article Generating machine specific optimizing compilers Share on Authors: Roger Hoover Computer Science Department, IBM TJ Watson Research Center, PO Box 704, Yorktown Heights, NY Computer Science Department, IBM TJ Watson Research Center, PO Box 704, Yorktown Heights, NYView Profile , Kenneth Zadeck Computer Science Department, IBM TJ Watson Research Center, PO Box 704, Yorktown Heights, NY Computer Science Department, IBM TJ Watson Research Center, PO Box 704, Yorktown Heights, NYView Profile Authors Info & Claims POPL '96: Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1996 Pages 219–229https://doi.org/10.1145/237721.237779Published:01 January 1996 6citation31DownloadsMetricsTotal Citations6Total Downloads31Last 12 Months5Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237779", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roger", + "last_name": "Hoover", + "institution": "IBM (United States)" + }, + { + "first_name": "Kenneth", + "last_name": "Zadeck", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/HooverZ96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237776", + "title": "Trace-Based Program Analysis", + "abstract": "We present trace-based program analysis, a semantics-based framework for statically analyzing and transforming programs with loops, assignments, and nested record structures. Trace-based analyses are based on transfer transition systems, which define the small-step operational semantics of programming languages. Intuitively, transfer transition systems provide direct support for reasoning about the possible execution traces of a program, instead of just individual program states. The traces in a transfer transition system have many uses, including the finite representation of all possible terminating executions of a loop. Also, traces may be systematically &quot;pieced together,&quot; thus allowing the composition of separately analyzed program fragments. The utility of the approach is demonstrated by showing three applications: software pipelining, loop-invariant removal, and data alias detection. 1 Introduction In this paper, we consider semantics-based program analysis for the purposes of s...", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237776", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Colby", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Peter", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/ColbyL96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237804", + "title": "Linearity and the Pi-Calculus", + "abstract": "The economy and flexibility of the pi-calculus make it attractive both as an object of theoretical study and as a basis for concurrent language design and implementation. However, such generality has a cost: encoding higher-level features like functional computation in pi-calculus throws away potentially useful information. We show how a linear type system can be used to recover important static information about a process's behaviour. In particular, we can guarantee that two processes communicating over a linear channel cannot interfere with other communicating processes. This enables more aggressive optimisation of communications over linear channels and allows useful refinements to the usual notions of process equivalence for pi-calculus.After developing standard results such as soundness of typing, we focus on equivalences, adapting the standard notion of barbed bisimulation to the linear setting and showing how reductions on linear channels induce a useful \"partial confluence\" of process behaviors.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237804", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Cambridge" + }, + { + "first_name": "David N.", + "last_name": "Turner", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/popl/KobayashiPT96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237792", + "title": "Revisiting Catamorphisms over Datatypes with Embedded Functions (or, Programs from Outer Space)", + "abstract": "We revisit the work of Paterson and of Meijer & Hutton, which describes how to construct catamorphisms for recursive datatype definitions that embed contravariant occurrences of the type being defined. Their construction requires, for each catamorphism, the definition of an anamorphism that has an inverse-like relationship to that catamorphism. We present an alternative construction, which replaces the stringent requirement that an inverse anamorphism be defined for each catamorphism with a more lenient restriction. The resulting construction has a more efficient implementation than that of Paterson, Meijer, and Hutton and the relevant restriction can be enforced by a Hindley-Milner type inference algorithm. We provide numerous examples illustrating our method.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237792", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leonidas", + "last_name": "Fegaras", + "institution": "Oregon Museum of Science and Industry" + }, + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Oregon Museum of Science and Industry" + } + ], + "dblp_key": "conf/popl/FegarasS96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237791", + "title": "Typed Closure Conversion", + "abstract": "Closure conversion is a program transformation used by compilers to separate code from data. Previous accounts of closure conversion use only untyped target languages. Recent studies show that translating to typed target languages is a useful methodology for building compilers, because a compiler can use the types to implement efficient data representations, calling conventions, and tag-free garbage collection. Furthermore, type-based translations facilitate security and debugging through automatic type checking, as well as correctness arguments through the method of logical relations.We present closure conversion as a type-directed, and type-preserving translation for both the simply-typed and the polymorphic λ-calculus. Our translations are based on a simple \"closures as objects\" principle: higher-order functions are viewed as objects consisting of a single method (the code) and a single instance variable (the environment). In the simply-typed case, the Pierce-Turner model of object typing where objects are packages of existential type suffices. In the polymorphic case, more careful tracking of type sharing is required. We exploit a variant of the Harper-Lillibridge \"translucent type\" formalism to characterize the types of polymorphic closures.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237791", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yasuhiko", + "last_name": "Minamide", + "institution": "Kyoto University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/MinamideMH96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237777", + "title": "Iterated Register Coalescing", + "abstract": "An important function of any register allocator is to target registers so as to eliminate copy instructions. Graph-coloring register allocation is an elegant approach to this problem. If the source and destination of a move instruction do not interfere, then their nodes can be coalesced in the interference graph. Chaitin's coalescing heuristic could make a graph uncolorable (i.e., introduce spills); Briggs et al. demonstrated a conservative coalescing heuristic that preserves colorability. But Briggs's algorithm is too conservative, and leaves too many move instructions in our programs. We show how to interleave coloring reductions with Briggs's coalescing heuristic, leading to an algorithm that is safe but much more aggressive.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237777", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lal", + "last_name": "George", + "institution": "Nokia (United States)" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/GeorgeA96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237765", + "title": "C: A Language for High-Level, Efficient, and Machine-Independent Dynamic Code Generation", + "abstract": "Dynamic code generation allows specialized code sequences to be created using runtime information. Since this information is by definition not available statically, the use of dynamic code generation can achieve performance inherently beyond that of static code generation. Previous attempts to support dynamic code generation have been low-level, expensive, or machine-dependent. Despite the growing use of dynamic code generation, no mainstream language provides flexible, portable, and efficient support for it.We describe 'C (Tick C), a superset of ANSI C that allows flexible, high-level. efficient, and machine-independent specification of dynamically generated code. 'C provides many of the performance benefits of pure partial evaluation, but in the context of a complex, statically typed, but widely used language. 'C examples illustrate the ease of specifying dynamically generated code and how it can be put to use. Experiments with a prototype compiler show that 'C enables excellent performance improvement (in some cases, more than an order of magnitude).", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237765", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dawson", + "last_name": "Engler", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Wilson C.", + "last_name": "Hsieh", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "M. Frans", + "last_name": "Kaashoek", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/EnglerHK96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237724", + "title": "Is it a Tree, a DAG, or a Cyclic Graph? A Shape Analysis for Heap-Directed Pointers in C", + "abstract": "This paper reports on the design and implementation of a practical shape analysis for C. The purpose of the analysis is to aid in the disambiguation of heap-allocated data structures by estimating the shape (Tree, DAG, or Cyclic Graph) of the data structure accessible from each heap-directed pointer. This shape information can be used to improve dependence testing and in parallelization, and to guide the choice of more complex heap analyses.The method has been implemented as a context-sensitive interprocedural analysis in the McCAT conlpiler. Experimental results and observations are given for 16 benchmark programs. These results show that the analysis gives accurate and useful results for an important group of applications.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237724", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rakesh", + "last_name": "Ghiya", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/popl/GhiyaH96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237771", + "title": "From Region Inference to von Neumann Machines via Region Representation Inference", + "abstract": "Region Inference is a technique for implementing programming languages that are based on typed call-by-value lambda calculus, such as Standard ML. The mathematical runtime model of region inference uses a stack of regions, each of which can contain an unbounded number of values. This paper is concerned with mapping the mathematical model onto real machines. This is done by composing region inference with Region Representation Inference, which gradually refines region information till it is directly implementable on conventional von Neumann machines. The performance of a new region-based ML compiler is compared to the performance of Standard ML of New Jersey, a state-of-the-art ML compiler.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237771", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Mads", + "last_name": "Tofte", + "institution": "University of Copenhagen" + }, + { + "first_name": "Magnus", + "last_name": "Vejlstrup", + "institution": "" + } + ], + "dblp_key": "conf/popl/BirkedalTV96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237773", + "title": "A Practical and Flexible Flow Analysis for Higher-Order Languages", + "abstract": "A flow analysis collects data-flow and control-flow information about programs. A compiler can use this information to enable optimizations. The analysis described in this article unifies and extends previous work on flow analyses for higher-order languages supporting assignment and control operators. The analysis is abstract interpretation based and is parameterized over two polyvariance operators and a projection operator. These operators are used to regulate the speed and accuracy of the analysis. An implementation of the analysis is incorporated into and used in a production Scheme compiler. The analysis can process any legal Scheme program without modification. Others have demonstrated that a 0CFA analysis can enable optimizations, but a 0CFA analysis is O(n3). An O(n) instantiation of our analysis successfully enables the optimization of closure representations and procedure calls. Experiments with the cheaper instantiation show that it is as effective as 0CFA for these optimizations.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237773", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John M.", + "last_name": "Ashley", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/Ashley96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237733", + "title": "Faster Checking of Software Specifications by Eliminating Isomorphs", + "abstract": "Both software specifications and their intended properties can be expressed in a simple relational language. The claim that a specification satisfies a property becomes a relational formula that can be checked automatically by enumerating the formula's interpretations. Because the number of interpretations is usually huge, this approach has not been thought to be practical. But by eliminating isomorphic interpretations, the enumeration can be reduced substantially, with a factor of roughly k! contributed by each type of k elements.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237733", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Jackson", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Somesh", + "last_name": "Jha", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Craig A.", + "last_name": "Damon", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/JacksonJD96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237799", + "title": "Static Analysis to Reduce Synchronization Costs in Data-Parallel Programs", + "abstract": "For a program with sufficient parallelism, reducing synchronization costs is one of the most important objectives for achieving efficient execution on any parallel machine. This paper presents a novel methodology for reducing synchronization costs of programs compiled for SPMD execution. This methodology combines data flow analysis with communication analysis to determine the ordering between production and consumption of data on different processors, which helps in identifying redundant synchronization. The resulting framework is more powerful than any that have been previously presented, as it provides the first algorithm that can eliminate synchronization messages even from computations that need communication. We show that several commonly occurring computation patterns such as reductions and stencil computations with reciprocal producer-consumer relationship between processors lend themselves well to this optimization, an observation that is confirmed by an examination of some HPF benchmark programs. Our framework also recognizes situations where the synchronization needs for multiple data transfers can be satisfied by a single synchronization message. This analysis, while applicable to all shared memory machines as well, is especially useful for those with a flexible cache-coherence protocol, as it identifies efficient ways of moving data directly from producers to consumers, often without any extra synchronization.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237799", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Manish", + "last_name": "Gupta", + "institution": "IBM (United States)" + }, + { + "first_name": "Edith", + "last_name": "Schonberg", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/GuptaS96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237797", + "title": "A Provably Time-Efficient Parallel Implementation of Full Speculation", + "abstract": "Speculative evaluation, including leniency and futures, is often used to produce high degrees of parallelism, Existing speculative implementations, however, may serialize computation because of their implementation of queues of suspended threads. We give a provably efficient parallel implementation of a speculative functional language on various machine models. The implementation includes proper parallelization of the necessary queuing operations on suspended threads. Our target machine models are a butterfly network, hypercube, and PRAM. To prove the efficiency of our implementation, we provide a cost model using a profiling semantics and relate the cost model to implementations on the parallel machine models.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237797", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Greiner", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/GreinerB96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237805", + "title": "The Reflexive CHAM and the Join-Calculus", + "abstract": "By adding reflexion to the chemical machine of Berry and Boudol, we obtain a formal model of concurrency that is consistent with mobility and distribution. Our model provides the foundations of a programming language with functional and object-oriented features. It can also be seen as a process calculus, the join-calculus, which we prove equivalent to the π-calculus of Milner, Parrow and Walker.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237805", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Georges", + "last_name": "Gonthier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/FournetG96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237767", + "title": "A General Approach for Run-Time Specialization and its Application to C", + "abstract": "Specializing programs with respect to run-time invariants is an optimization technique that has shown to improve the performance of programs substantially. It allows a program to adapt to execution contexts that are valid for a limited time.Run-time specialization is being actively investigated in a variety of areas. For example, recently, major operating system research projects have been focusing on run-time specialization as a means to obtain efficiency from highly extensible and parameterized systems.This paper describes a general approach to run-time specialization. For a given program and a declaration of its run-time invariants, it automatically produces source templates at compile time, and transforms them so that they can be processed by a standard compiler. At run time, only minor operations need to be performed: selecting and copying templates, filling holes with run-time values, and relocating jump targets. As a consequence, run-time specialization is performed very efficiently and thus does not require the specialized code to be executed many times before its cost is amortized.Our approach improves on previous work in that: (1) templates are automatically produced from the source program and its invariants, (2) the approach is not machine dependent, (3) it is formally defined and proved correct, (4) it is efficient, as shown by our implementation for the C language.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237767", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Charles", + "last_name": "Consel", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "François", + "last_name": "Noël", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + } + ], + "dblp_key": "conf/popl/ConselN96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237769", + "title": "Discovering Auxiliary Information for Incremental Computation", + "abstract": "This paper presents program analyses and transformations that discover a general class of auxiliary information for any incremental computation problem. Combining these techniques with previous techniques for caching intermediate results, we obtain a systematic approach that transforms nonincremental programs into efficient incremental programs that use and maintain useful auxiliary information as well as useful intermediate results. The use of auxiliary information allows us to achieve a greater degree of incrementality than otherwise possible. Applications of the approach include strength reduction in optimizing compilers and finite differencing in transformational programming.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237769", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yanhong A.", + "last_name": "Liu", + "institution": "Cornell University" + }, + { + "first_name": "Scott D.", + "last_name": "Stoller", + "institution": "Cornell University" + }, + { + "first_name": "Tim", + "last_name": "Teitelbaum", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/LiuST96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237788", + "title": "A Modal Analysis of Staged Computation", + "abstract": "We show that a type system based on the intuitionistic modal logic S4 provides an expressive framework for specifying and analyzing computation stages in the context of functional languages. Our main technical result is a conservative embedding of Nielson & Nielson's two-level functional language in our language Mini-ML, thus proving that binding-time correctness is equivalent to modal correctness on this fragment. In addition Mini-ML can also express immediate evaluation and sharing of code across multiple stages, thus supporting run-time code generation as well as partial evaluation.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237788", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rowan", + "last_name": "Davies", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/DaviesP96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237784", + "title": "Type-Directed Partial Evaluation", + "abstract": "We present a strikingly simple partial evaluator, that is type-directed and reifies a compiled program into the text of a residual, specialized program. Our partial evaluator is concise (a few lines) and it handles the flagship examples of offline monovariant partial evaluation. Its source programs are constrained in two ways: they must be closed and monomorphically typable. Thus dynamic free variables need to be factored out in a \"dynamic initial environment\". Type-directed partial evaluation uses no symbolic evaluation for specialization, and naturally processes static computational effects.Our partial evaluator is the part of an offline partial evaluator that residualizes static values in dynamic contexts. Its restriction to the simply typed lambda-calculus coincides with Berger and Schwichtenberg's \"inverse of the evaluation functional\" (LICS'91), which is an instance of normalization in a logical setting. As such, type-directed partial evaluation essentially achieves lambda-calculus normalization. We extend it to produce specialized programs that are recursive and that use disjoint sums and computational effects. We also analyze its limitations: foremost, it does not handle inductive types.This paper therefore bridges partial evaluation and λ-calculus normalization through higher-order abstract syntax, and touches upon parametricity, proof theory, and type theory (including subtyping and coercions), compiler optimization, and rut-time code generation (including decompilation). It also offers a simple solution to denotational semantics-based compilation and compiler generation.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237784", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/Danvy96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237802", + "title": "Composing Processes", + "abstract": "We present a theory of types for concurrency based on a simple notion of typed algebras, and discuss its applications. The basic idea is to determine a partial algebra of processes by a partial algebra of types, thus controlling process composability, just as types in a typed applicative structure [25] determine composability of elements of the underlying applicative structure. A class of typed algebras with a simple operator for process composition are introduced, which are shown to encompass a wide range of type disciplines for processes, placing extant theories such as Milner's sorting [22] and Lafont's typed nets [20] on a uniform technical footing, suggesting generalisations, and offering a secure basis for integration. We also prove that the class of typable operations in the underlying partial algebras is completely characterised by a certain modularity principle in process composition, which gives us the basic understanding on the nature of the type disciplines representable in the proposed construction.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237802", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kohei", + "last_name": "Honda", + "institution": "University of Manchester" + } + ], + "dblp_key": "conf/popl/Honda96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237809", + "title": "An Interpretation of Objects and Object Types", + "abstract": "We present an interpretation of typed object-oriented concepts in terms of well-understood, purely procedural concepts. More precisely, we give a compositional subtype-preserving translation of a basic object calculus supporting method invocation, functional method update, and subtyping, into the polymorphic λ-calculus with recursive types and subtyping. The translation techniques apply also to an imperative version of the object calculus which includes in-place method update and object cloning. Finally, the translation easily extends to \"Self types\" and other interesting object-oriented constructs.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237809", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "" + }, + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "" + }, + { + "first_name": "Ramesh", + "last_name": "Viswanathan", + "institution": "Isaac Newton Institute for Mathematical Sciences" + } + ], + "dblp_key": "conf/popl/AbadiCV96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.240882", + "title": "Proving the Correctness of Reactive Systems Using Sized Types", + "abstract": "We have designed and implemented a type-based analysis for proving some basic properties of reactive systems. The analysis manipulates rich type expressions that contain information about the sizes of recursively defined data structures. Sized types are useful for detecting deadlocks, nontermination, and other errors in embedded programs. To establish the soundness of the analysis we have developed an appropriate semantic model of sized types.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.240882", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Lars", + "last_name": "Pareto", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/HughesPS96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237735", + "title": "Optimization and Relaxation in Constraint Logic Languages", + "abstract": "Optimization and relaxation are two important operations that naturally arise in many applications involving constraints, e.g., engineering design, scheduling, decision support, etc. In optimization, we are interested in finding the optimal (i.e., best) solutions to a set of constraints with respect to an objective function. In many applications, optimal solutions may be difficult or impossible to obtain, and hence we are interested in finding suboptimal solutions, by either relaxing the constraints or relaxing the objective function. The contribution of this paper lies in providing a logical framework for performing optimization and relaxation in a constraint logic programming language. Our proposed framework is called preference logic programming (PLP), and its use for optimization was discussed in [8]. Essentially, in PLP we can designate certain predicates as optimization predicates, and we can specify the objective function by stating preference criteria for determining the optimal solutions to these predicates. This paper extends the PLP paradigm with facilities to formulate relaxation problems in a natural manner. We introduce the concept of a relaxation goal, and discuss its use for preference relaxation. Our model-theoretic semantics of relaxation is based on simple concepts from modal logic: Essentially, each world in the possible-worlds semantics for a preference logic program is a model for the constraints of the program, and an ordering over these worlds is determined by the objective function. Optimization can then be expressed as truth in strongly optimal worlds, while relaxation becomes truth in suitably-defined suboptimal worlds. We also present an operational semantics for relaxation as well as correctness results. Our conclusion is that the concept of preference provides a unifying framework for formulating optimization as well as relaxation problems.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237735", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kannan", + "last_name": "Govindarajan", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Bharat", + "last_name": "Jayaraman", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Surya", + "last_name": "Mantha", + "institution": "Xerox (France)" + } + ], + "dblp_key": "conf/popl/GovindarajanJM96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237731", + "title": "Using Parameterized Signatures to Express Modular Structure", + "abstract": "Module systems are a powerful, practical tool for managing the complexity of large software systems. Previous attempts to formulate a type-theoretic foundation for modular programming have been based on existential, dependent, or manifest types. These approaches can be distinguished by their use of different quantifiers to package the operations that a module exports together with appropriate implementation types. In each case, the underlying type theory is simple and elegant, but significant and sometimes complex extensions are needed to account for features that are important in practical systems, such as separate compilation and propagation of type information between modules.This paper presents a simple type-theoretic framework for modular programming using parameterized signatures. The use of quantifiers is treated as a necessary, but independent concern. Using familiar concepts of polymorphism, the resulting module system is easy to understand and admits true separate compilation. It is also very powerful, supporting high-order, polymorphic, and first-class modules without further extension.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237731", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/popl/Jones96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237794", + "title": "Concurrent Haskell", + "abstract": "No abstract available.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237794", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "" + }, + { + "first_name": "Sigbjørn", + "last_name": "Finne", + "institution": "" + } + ], + "dblp_key": "conf/popl/JonesGF96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237807", + "title": "Bisimilarity for a First-Order Calculus of Objects with Subtyping", + "abstract": "Bisimilarity (also known as 'applicative bisimulation') has attracted a good deal of attention as an operational equivalence for λ-calculi. It approximates or even equals Morris-style contextual equivalence and admits proofs of program equivalence via co-induction. It has an elementary construction from the operational definition of a language. We consider bisimilarity for one of the typed object calculi of Abadi and Cardelli. By defining a labelled transition system for the calculus in the style of Crole and Gordon and using a variation of Howe's method we establish two central results: that bisimilarity is a congruence, and that it equals contextual equivalence. So two objects are bisimilarity no amount of programming can tell them apart. Our third contribution is to show that bisimilarity soundly models the equational theory of Abadi and Cardelli. This is the first study of contextual equivalence for an object calculus and the first application of Howe's method to subtyping. By these results, we intend to demonstrate that operational methods are a promising new direction for the foundations of object-oriented programming.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237807", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "University of Cambridge" + }, + { + "first_name": "Gareth D.", + "last_name": "Rees", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/GordonR96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237741", + "title": "Pure versus Impure LISP", + "abstract": "The aspect of purity versus impurity that we address involves the absence versus presence of mutation: the use of primitives (RPLACA and RPLACD in Lisp, set-car! and set-cdr! in Scheme) that change the state of pairs without creating new pairs. It is well known that cyclic list structures can be created by impure programs, but not by pure ones. In this sense, impure Lisp is more powerful than pure Lisp. If the inputs and outputs of programs are restricted to be sequences of atomic symbols, however, this difference in computability disappears. We shall show that if the temporal sequence of input and output operations must be maintained (that is, if computations must be online), then a difference in complexity remains: for a pure program to do what an impure program does in n steps, O(n log n) steps are sufficient, and in some cases Ω(n log n) steps are necessary.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237741", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nicholas", + "last_name": "Pippenger", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/popl/Pippenger96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237780", + "title": "Minimum Cost Interprocedural Register Allocation", + "abstract": "Past register allocators have applied heuristics to allocate registers at the local, global, and interprocedural levels. This paper presents a polynomial time interprocedural register allocator that models the cost of allocating registers to procedures and spilling registers across calls. To find the minimum cost allocation, our allocator maps solutions from a dual network flow problem that can be solved in polynomial time. Experiments show that our interprocedural register allocator can yield significant improvements in execution time.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237780", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steven M.", + "last_name": "Kurlander", + "institution": "University of Dayton" + }, + { + "first_name": "Charles N.", + "last_name": "Fischer", + "institution": "University of Dayton" + } + ], + "dblp_key": "conf/popl/KurlanderF96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237801", + "title": "Functional Computation as Concurrent Computation", + "abstract": "Available from TIB Hannover: RR 1812(95-14) / FIZ - Fachinformationszzentrum Karlsruhe / TIB - Technische Informationsbibliothek", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237801", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joachim", + "last_name": "Niehren", + "institution": "German Research Centre for Artificial Intelligence" + } + ], + "dblp_key": "conf/popl/Niehren96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237728", + "title": "What Are Principal Typings and What Are They Good For?", + "abstract": "We demonstrate the pragmatic value of the principal typing property, a property distinct from ML's principal type property, by studying a type system with principal typings. The type system is based on rank 2 intersection types and is closely related to ML. Its principal typing property provides elegant support for separate compilation, including \"smartest recompilation\" and incremental type inference. Moreover, it motivates a new rule for typing recursive definitions that can type some interesting examples of polymorphic recursion.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237728", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Trevor", + "last_name": "Jim", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Jim96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237729", + "title": "Putting Type Annotations to Work", + "abstract": "We study an extension of the Hindley/Milner system with explicit type scheme annotations and type declarations. The system can express polymorphic function arguments, user-defined data types with abstract components, and structure types with polymorphic fields. More generally, all programs of the polymorphic lambda calculus can be encoded by a translation between typing derivations. We show that type reconstruction in this system can be reduced to the decidable problem of first-order unification under a mixed prefix.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237729", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "" + }, + { + "first_name": "Konstantin", + "last_name": "Läufer", + "institution": "Loyola University Chicago" + } + ], + "dblp_key": "conf/popl/OderskyL96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237725", + "title": "Solving Shape-Analysis Problems in Languages with Destructive Updating", + "abstract": "This paper concerns the static analysis of programs that perform destructive updating on heap-allocated storage. We give an algorithm that conservatively solves this problem by using a finite shape-graph to approximate the possible \"shapes\" that heap-allocated structures in a program can take on. In contrast with previous work, our method is even accurate for certain programs that update cyclic data structures. For example, our method can determine that when the input to a program that searches a list and splices in a new element is a possibly circular list, the output is a possibly circular list.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237725", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "Madison Group (United States)" + }, + { + "first_name": "Reinhard", + "last_name": "Wilhelm", + "institution": "" + } + ], + "dblp_key": "conf/popl/SagivRW96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237727", + "title": "Points-to Analysis in Almost Linear Time", + "abstract": "We present an interprocedural flow-insensitive points-to analysis based on type inference methods with an almost linear time cost complexity To our knowledge, this is the asymptotically fastest non-trivial interprocedural points-to analysis algorithm yet described The algorithm is based on a non-standard type system. The type inferred for any variable represents a set of locations and includes a type which in turn represents a set of locations possibly pointed to by the variable. The type inferred for a function variable represents a set of functions It may point to and includes a type signature for these functions The results are equivalent to those of a flow-insensitive alias analysis (and control flow analysis) that assumes alias relations are reflexive and transitive.This work makes three contributions. The first is a type system for describing a universally valid storage shape graph for a program in linear space. The second is a constraint system which often leads to better results than the \"obvious\" constraint system for the given type system The third is an almost linear time algorithm for points-to analysis by solving a constraint system.", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237727", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bjarne", + "last_name": "Steensgaard", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/Steensgaard96", + "venue": "popl", + "year": 1996 + }, + { + "paper_id": "10.1145/237721.237760", + "title": "Filter Fusion", + "abstract": "Article Free AccessFilter fusion Share on Authors: Todd A. Proebsting Department of Computer Science, University of Arizona, Tucson, AZ Department of Computer Science, University of Arizona, Tucson, AZView Profile , Scott A. Watterson Department of Computer Science, University of Arizona, Tucson, AZ Department of Computer Science, University of Arizona, Tucson, AZView Profile Authors Info & Claims POPL '96: Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1996 Pages 119–130https://doi.org/10.1145/237721.237760Online:01 January 1996Publication History 32citation32DownloadsMetricsTotal Citations32Total Downloads32Last 12 Months3Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1996-01-01", + "link": "https://doi.org/10.1145/237721.237760", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "University of Arizona" + }, + { + "first_name": "Scott A.", + "last_name": "Watterson", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/ProebstingW96", + "venue": "popl", + "year": 1996 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1997.json b/data/pl_conferences/popl/1997.json new file mode 100644 index 0000000..920986c --- /dev/null +++ b/data/pl_conferences/popl/1997.json @@ -0,0 +1,793 @@ +[ + { + "paper_id": "10.1145/263699.263722", + "title": "A Curry-Howard Foundation for Functional Computation with Control", + "abstract": "We introduce the type theory λμv, a call-by-value variant of Parigot's λμ-calculus, as a Curry-Howard representation theory of classical propositional proofs. The associated rewrite system is Church-Rosser and strongly normalizing, and definitional equality of the type theory is consistent, compatible with cut, congruent and decidable. The attendant call-by-value programming language μPCFv is obtained from λμv by augmenting it by basic arithmetic, conditionals and fixpoints. We study the behavioural properties of μPCFv and show that, though simple, it is a very general language for functional computation with control: it can express all the main control constructs such as exceptions and first-class continuations. Proof-theoretically the dual λμv-constructs of naming and μ-abstraction witness the introduction and elimination rules of absurdity respectively. Computationally they give succinct expression to a kind of generic (forward) \"jump\" operator, which may be regarded as a unifying control construct for functional computation. Our goal is that λμv and μPCFv respectively should be to functional computation with first-class access to the flow of control what λ-calculus and PCF respectively are to pure functional programming: λμv gives the logical basis via the Curry-Howard correspondence, and μPCFv is a prototypical language albeit in purified form.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263722", + "conference_name": "POPL", + "authors": [ + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + }, + { + "first_name": "Charles", + "last_name": "Stewart", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/OngS97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263712", + "title": "Proof-Carrying Code", + "abstract": "This paper describes proof-carrying code (PCC), a mechanism by which a host system can determine with certainty that it is safe to execute a program supplied (possibly in binary form) by an untrusted source. For this to be possible, the untrusted code producer must supply with the code a safety proof that attests to the code's adherence to a previously defined safety policy. The host can then easily and quickly validate the proof without using cryptography and without consulting any external agents.In order to gain preliminary experience with PCC, we have performed several case studies. We show in this paper how proof-carrying code might be used to develop safe assembly-language extensions of ML programs. In the context of this case study, we present and prove the adequacy of concrete representations for the safety policy, the safety proofs, and the proof validation. Finally, we briefly discuss how we use proof-carrying code to develop network packet filters that are faster than similar filters developed using other techniques and are formally guaranteed to be safe with respect to a given operating system safety policy.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263712", + "conference_name": "POPL", + "authors": [ + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Necula97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263719", + "title": "Maximizing Parallelism and Minimizing Synchronization with Affine Transforms", + "abstract": "This paper presents the first algorithm to find the optimal affine transform that maximizes the degree of parallelism while minimizing the degree of synchronization in a program with arbitrary loop nestings and affine data accesses. The problem is formulated without the use of imprecise data dependence abstractions such as data dependence vectors. The algorithm presented subsumes previously proposed program transformation algorithms that are based on unimodular transformations, loop fusion, fission, scaling, reindexing and/or statement reordering.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263719", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amy W.", + "last_name": "Lim", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/LimL97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263744", + "title": "Types as Abstract Interpretations", + "abstract": "Starting from a denotational semantics of the eager untyped lambda-calculus with explicit runtime errors, the standard collecting semantics is defined as specifying the strongest program properties. By a first abstraction, a new sound type collecting semantics is derived in compositional fix-point form. Then by successive (semi-dual) Galois connection based abstractions, type systems and/or type inference algorithms are designed as abstract semantics or abstract interpreters approximating the type collecting semantics. This leads to a hierarchy of type systems, which is part of the lattice of abstract interpretations of the untyped lambda-calculus. This hierarchy includes two new a la Church/Curry polytype systems. Abstractions of this polytype semantics lead to classical Milner/Mycroft and Damas/Milner polymorphic type schemes, Church/Curry monotypes and Hindley principal typing algorithm. This shows that types are abstract interpretations.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263744", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "École Normale Supérieure - PSL" + } + ], + "dblp_key": "conf/popl/Cousot97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263731", + "title": "Comparing the Expressive Power of the Synchronous and the Asynchronous pi-calculus", + "abstract": "The Asynchronous π-calculus, as recently proposed by Boudol and, independently, by Honda and Tokoro, is a subset of the π-calculus which contains no explicit operators for choice and output-prefixing. The communication mechanism of this calculus, however, is powerful enough to simulate output-prefixing, as shown by Boudol, and input-guarded choice, as shown recently by Nestmann and Pierce. A natural question arises, then, whether or not it is possible to embed in it the full π-calculus. We show that this is not possible, i.e. there does not exist any uniform, parallel-preserving, translation from the π-calculus into the asynchronous π-calculus, up to any \"reasonable\" notion of equivalence. This result is based on the incapablity of the asynchronous π-calculus of breaking certain symmetries possibly present in the initial communication graph. By similar arguments, we prove a separation result between the π-calculus and CCS.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263731", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Catuscia", + "last_name": "Palamidessi", + "institution": "" + } + ], + "dblp_key": "conf/popl/Palamidessi97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263708", + "title": "Rolling Your Own MADT - A Connection Between Linear Types and Monads", + "abstract": "A methodology is described whereby a linear ADT may be rigorously encapsulated within a state monad. A CPS-like translation from the original ADT axioms into monadic ones is also described and proven correct, so that reasoning can be accomplished at the monadic level without exposing the state. The ADT axioms are suitably constrained by a linear type system to make this translation possible. This constraint also allows the state to be &quot;updated in place,&quot; a notion made precise via a graph-rewrite operational semantics. 1 Introduction In recent years, numerous proposals for I/O, destructive updates to data structures, mutable variables, nondeterminism, and concurrency have been put forth, all using monads to structure programs in such a way that details of the computation are effectively hidden and encapsulated [18, 20]. One of the most important uses of monads is in dealing with state, resulting in a style of programming referred to appropriately by Peyton Jones and Wadler as imperativ...", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263708", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chih‐Ping", + "last_name": "Chen", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/ChenH97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263765", + "title": "First-class Polymorphism with Type Inference", + "abstract": "Languages like ML and Haskell encourage the view of values as first-class entities that can be passed as arguments or results of functions, or stored as components of data structures. The same languages offer parametric polymorphism, which allows the use of values that behave uniformly over a range of different types. But the combination of these features is not supported-- polymorphic values are not first-class. This restriction is sometimes attributed to the dependence of such languages on type inference, in contrast to more expressive, explicitly typed languages, like System F, that do support first-class polymorphism.This paper uses relationships between types and logic to develop a type system, FCP, that supports first-class polymorphism, type inference, and also first-class abstract datatypes. The immediate result is a more expressive language, but there are also long term implications for language design.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263765", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/popl/Jones97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263759", + "title": "Reducing Nondeterminism while Specializing Logic Programs", + "abstract": "Program specialization is a collection of program transformation techniques for improving program efficiency by exploiting some information available at compile-time about the input data. We show that current techniques for program specialization based on partial evaluation do not perform well on nondeterministic logic programs. We then consider a set of transformation rules which extend the ones used for partial evaluation, and we propose a strategy to direct the application of these extended rules so to derive very efficient specialized programs. The efficiency improvements which may even be exponential, are achieved because the derived programs are semi-deterministic and the operations which are performed by the initial programs in different branches of the computation trees, are performed in the specialized programs within single branches. We also make use of mode information to guide the unfolding process and to reduce nondeterminism. To exemplify our technique, we show that we can automatically derive very efficient semi-deterministic matching programs and semi-deterministic parsers for regular languages. The derivations we have performed could not have been done by previously known partial evaluation techniques.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263759", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alberto", + "last_name": "Pettorossi", + "institution": "University of Rome Tor Vergata" + }, + { + "first_name": "Maurizio", + "last_name": "Proietti", + "institution": "Istituto di Analisi dei Sistemi ed Informatica Antonio Ruberti" + }, + { + "first_name": "Sophie", + "last_name": "Renault", + "institution": "University of Rome Tor Vergata" + } + ], + "dblp_key": "conf/popl/PettorossiPR97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263763", + "title": "Polyp - A Polytypic Programming Language", + "abstract": "Many functions have to be written over and over again for different datatypes, either because datatypes change during the development of programs, or because functions with similar functionality are needed on different datatypes. Examples of such functions are pretty printers, debuggers, equality functions, unifiers, pattern matchers, rewriting functions, etc. Such functions are called polytypic functions. A polytypic function is a function that is defined by induction on the structure of user-defined datatypes. This paper extends a functional language (a subset of Haskell) with a construct for writing polytypic functions. The extended language type checks definitions of polytypic functions, and infers the types of all other expressions using an extension of Jones' theories of qualified types and higher-order polymorphism. The semantics of the programs in the extended language is obtained by adding type arguments to functions in a dictionary passing style. Programs in the extended language are translated to Haskell.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263763", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrik", + "last_name": "Jansson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Johan", + "last_name": "Jeuring", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/JanssonJ97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263714", + "title": "Parameterized Types for Java", + "abstract": "Java offers the real possibility that most programs can be written in a type-safe language. However, for Java to be broadly useful, it needs additional expressive power. This paper extends Java in one area where more power is needed: support for parametric polymorphism, which allows the definition and implementation of generic abstractions. We discuss both the rationale for our design decisions and the impact of the extension on other parts of Java, including arrays and the class library. We also describe optional extensions to the Java virtual machine to allow parameterized bytecodes, and how to verify them efficiently. We have extended the Java bytecode interpreter to provide good performance for parameterized code in both execution speed and code size, without slowing down non-parameterized code.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263714", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph A.", + "last_name": "Bank", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/BankLM97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263710", + "title": "A Unified Computation Model for Functional and Logic Programming", + "abstract": "We propose a new computation model which combines the operational principles of functional languages (reduction), logic languages (non-deterministic search for solutions), and integrated functional logic languages (residuation and narrowing). This computation model combines efficient evaluation principles of functional languages with the problem-solving capabilities of logic programming. Since the model allows the delay of function calls which are not sufficiently instantiated, it also supports a concurrent style of programming. We provide soundness and completeness results and show that known evaluation principles of functional logic languages are particular instances of this model. Thus, our model is a suitable basis for future declarative programming languages.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263710", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Hanus", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "conf/popl/Hanus97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263716", + "title": "Determining the Idle Time of a Tiling", + "abstract": "This paper investigates the idle time associated with a parallel computation, that is, the time that processors are idle because they are either waiting for data from other processors or waiting to synchronize with other processors. We study doubly-nested loops corresponding to parallelogram- or trapezoidal-shaped iteration spaces that have been parallelized by the well-known tiling transformation. We introduce the notion of rise r, which relates the shape of the iteration space to that of the tiles. For parallelogram- shaped iteration spaces, we show that when r < -2, the idle time is linear in P, the number of processors, but when r > -1, it is quadratic in P. In the context of hierarchical tiling, where multiple levels of tiling are used, a good choice of rise can lead to less idle time and better performance. While idle time is not the only cost that should be considered in evaluating a tiling strategy, current architectural trends (of deeper memory hierarchies and multiple levels of parallelism) suggest it has increasing importance.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263716", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karin", + "last_name": "Högstedt", + "institution": "University of California, San Diego" + }, + { + "first_name": "Larry", + "last_name": "Carter", + "institution": "University of California, San Diego" + }, + { + "first_name": "Jeanne", + "last_name": "Ferrante", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/popl/CarterFH97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263735", + "title": "Program Fragments, Linking, and Modularization", + "abstract": "Module mechanisms have received considerable theoretical attention, but the associated concepts of separate compilation and linking have not been emphasized. Anomalous module systems have emerged in functional and object-oriented programming where software components are not separately typecheckable and compilable. In this paper we provide a context where linking can be studied, and separate compilability can be formally stated and checked. We propose a framework where each module is separately compiled to a self-contained entity called a linkset; we show that separately compiled, compatible modules can be safely linked together. 1 Introduction Program modularization arose from the necessity of splitting large programs into fragments in order to compile them. As system libraries grew in size, it became essential to compile the libraries separately from the user programs; libraries acquired interfaces that minimized compilation dependencies. A linker was used to patch compiled fragmen...", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263735", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "Digital Equipment (Germany)" + } + ], + "dblp_key": "conf/popl/Cardelli97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263713", + "title": "Is "Just in Time" = "Better Late than Never"?", + "abstract": "The World-Wide Web is emerging as a medium for distributing platform-independent, intermediate-form programs. Most Java vendors have recently announced plans to construct \"just-in-time\" systems, which translate the intermediate text into native code on demand. In this paper, we present experiments that show the benefits of just-in-time systems as compared with the traditional (compile prior to execution) systems. We introduce a new method--the continuous compiler-- that can outperform just-in-time systems by overlapping compilation with program interpretation and native execution. Based on those results, we then present a smart just-in-time system that blends interpretation with native-code execution, thereby obtaining improved performance.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263713", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael P.", + "last_name": "Plezbert", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Ron K.", + "last_name": "Cytron", + "institution": "Washington University in St. Louis" + } + ], + "dblp_key": "conf/popl/PlezbertC97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263758", + "title": "Constraints to Stop Higher-Order Deforestation", + "abstract": "Wadler&apos;s deforestation algorithm removes intermediate data structures from functional programs. To be appropriate for inclusion in a compiler, deforestation must terminate on all programs. Several techniques exist to ensure termination of deforestation on all first-order programs, but a technique for higher-order programs was only recently introduced by Hamilton and later Marlow. We present a new technique for ensuring termination of deforestation on all higher-order programs that allows useful transformation steps prohibited in Hamilton&apos;s and Marlow&apos;s techniques. The technique uses a constraint-based higher-order control-flow analysis. 1 Introduction Lazy, higher-order, functional programming languages lend themselves to a certain style of programming which uses intermediate data structures [28]. However, this style also leads to inefficient programs. Example 1 Consider the following program. letrec a = x; y: case x of [] ! y (h : t) ! h : a t y in u; v; w: a (a u v) w The mai...", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263758", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Helmut", + "last_name": "Seidl", + "institution": "Universität Trier" + }, + { + "first_name": "Morten Heine", + "last_name": "Sørensen", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/popl/SeidlS97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263729", + "title": "Behavioral Equivalence in the Polymorphic Pi-calculus", + "abstract": "We investigate parametric polymorphism in message-based concurrent programming, focusing on behavioral equivalences in a typed process calculus analogous to the polymorphic lambda-calculus of Girard and Reynolds.Polymorphism constrains the power of observers by preventing them from directly manipulating data values whose types are abstract, leading to notions of equivalence much coarser than the standard untyped ones. We study the nature of these constraints through simple examples of concurrent abstract data types and develop basic theoretical machinery for establishing bisimilarity of polymorphic processes.We also observe some surprising interactions between polymorphism and aliasing, drawing examples from both the polymorphic pi-calculus and ML.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263729", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Davide", + "last_name": "Sangiorgi", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/PierceS97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263745", + "title": "Infinitary Control Flow Analysis: a Collecting Semantics for Closure Analysis", + "abstract": "Defining the collecting semantics is usually the first crucial step in adapting the general methodology of abstract interpretation to the semantic framework or programming language at hand. In this paper we show how to define a collecting semantics for control flow analysis: due to the generality of the formulation we need to appeal to coinduction (or greatest fixed points) in order to define the analysis. We then prove the semantic soundness of the collecting semantics and that all totally deterministic instantiations have a least solution; this incorporates k-CFA, polymorphic splitting and a new class of uniform-k-CFA analyses.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263745", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Flemming", + "last_name": "Nielson", + "institution": "Aarhus University" + }, + { + "first_name": "Hanne Riis", + "last_name": "Nielson", + "institution": "Technical University of Denmark" + } + ], + "dblp_key": "conf/popl/NielsonN97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263743", + "title": "Type-Checking Higher-Order Polymorphic Multi-Methods", + "abstract": "We present a new predicative and decidable type system, called ML≤, suitable for languages that integrate functional programming and parametric polymorphism in the tradition of ML [21, 28], and class-based object-oriented programming and higher-order multimethods in the tradition of CLOS [12]. Instead of using extensible records as a foundation for object-oriented extensions of functional languages, we propose to reinterpret ML datatype declarations as abstract and concrete class declarations, and to replace pattern matching on run-time values by dynamic dispatch on run-time types. ML≤ is based on universally quantified polymorphic constrained types. Constraints are conjunctions of inequalities between monotypes built from type constructors organized into extensible and partially ordered classes. We give type checking rules for a small, explicitly typed functional language á la XML [20] with multi-methods, show that the resulting system has decidable minimal types, and discuss subject reduction. Finally, we propose a new object-oriented programming language based on the ML≤ type system.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263743", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Bourdoncle", + "institution": "École Nationale Supérieure des Mines de Paris" + }, + { + "first_name": "Stephan", + "last_name": "Merz", + "institution": "" + } + ], + "dblp_key": "conf/popl/BourdoncleM97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263726", + "title": "The Pi-calculus in Direct Style", + "abstract": "We introduce a calculus which is a direct extension of both the λ and the π calculi. We give a simple type system for it, that encompasses both Curry's type inference for the λ-calculus, and Milner's sorting for the π-calculus as particular cases of typing. We observe that the various continuation passing style transformations for λ-terms, written in our calculus, actually correspond to encodings already given by Milner and others for evaluation strategies of λ-terms into the π-calculus. Furthermore, the associated sortings correspond to well-known double negation translations on types. Finally we provide an adequate CPS transform from our calculus to the π-calculus. This shows that the latter may be regarded as an \"assembly language\", while our calculus seems to provide a better programming notation for higher-order concurrency.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263726", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gérard", + "last_name": "Boudol", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Boudol97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263718", + "title": "Synchronization Transformations for Parallel Computing", + "abstract": "As parallel machines become part of the mainstream computing environment, compilers will need to apply synchronization optimizations to deliver efficient parallel software. This paper describes a new framework for synchronization optimizations and a new set of transformations for programs that implement critical sections using mutual exclusion locks. These transformations allow the compiler to move constructs that acquire and release locks both within and between procedures and to eliminate acquire and release constructs.The paper also presents a new synchronization algorithm, lock elimination, for reducing synchronization overhead. This optimization locates computations that repeatedly acquire and release the same lock, then uses the transformations to obtain equivalent computations that acquire and release the lock only once. Experimental results from a parallelizing compiler for object-based programs illustrate the practical utility of this optimization. For three benchmark programs the optimization dramatically reduces the number of times the computations acquire and release locks, which significantly reduces the amount of time processors spend acquiring and releasing locks. For one of the three benchmarks, the optimization always significantly improves the overall performance. Depending on the number of processors executing the computation, the optimized version runs between 2.11 and 1.83 times faster than the unoptimized version. For one of the other benchmarks, the optimized version runs between 1.13 and 0.96 times faster than the unoptimized version, with a mean of 1.08 times faster. For the final benchmark, the optimization reduces the overall performance.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263718", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pedro C.", + "last_name": "Diniz", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/popl/RinardD97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263706", + "title": "Shape Types", + "abstract": "Type systems currently available for imperative languages are too weak to detect a significant class of programming errors. For example, they cannot express the property that a list is doubly-linked or circular. We propose a solution to this problem based on a notion of shape types defined as context-free graph grammars. We define graphs in set-theoretic terms, and graph modifications as multiset rewrite rules. These rules can be checked statically to ensure that they preserve the structure of the graph specified by the grammar. We provide a syntax for a smooth integration of shape types in C. The programmer can still express pointer manipulations with the expected constant time execution and benefits from the additional guarantee that the property specified by the shape type is an invariant of the program.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263706", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pascal", + "last_name": "Fradet", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Daniel Le", + "last_name": "Métayer", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + } + ], + "dblp_key": "conf/popl/FradetM97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263753", + "title": "A Demand-Driven Set-Based Analysis", + "abstract": "In this paper we present an analysis technique for isolating dead code in higher-order functional programs. First, we formalize what it means for a program fragment to contribute to the value returned by the program. Next, we provide a purely declarative specification of a subset of terms which constitute dead code. This is done by a refinement of the set-based semantics technique, developed by Nevin Heintze, by the introduction of a concept of demand. We then develop a demand-driven set-based analysis to compute dead code specified by the declarative specification. The demand-driven set-based analysis developed in this paper is polynomial time, in the size of the input program.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263753", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sandip K.", + "last_name": "Biswas", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/Biswas97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263709", + "title": "Search and Imperative Programming", + "abstract": "We augment the expressive power of imperative programming in order to make it a more attractive vehicle for problems that involve search. The proposed additions are limited yet powerful and are inspired by the logic programming paradigm. We illustrate their use by presenting solutions to a number of classical problems, including the straight search problem, the knapsack problem, and the 8 queens problem. These solutions are substantially simpler than their counterparts written in the conventional way and can be used for different purposes without any modification.The proposed language is an intermediate stage on the road towards a realization of a strongly typed constraint programming language that combines the advantages of the logic programming and imperative programming.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263709", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krzysztof R.", + "last_name": "Apt", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Andrea", + "last_name": "Schaerf", + "institution": "Sapienza University of Rome" + } + ], + "dblp_key": "conf/popl/AptS97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263762", + "title": "High Level Reading and Data Structure Compilation", + "abstract": "In [Paige89], it was shown how to simulate a set machine in real-time on a RAM that provides cursor or even only pointer access to data. The underlying assumption was that the establishment of efficient data structures would be provided by some 'client' program. In the current paper, we fill in the gap by presenting a linear-time high level reading method that translates external input in string form into data structures that facilitate such real-time simulation. The algorithm builds the data structures for a much richer type system than what appeared in [Paige94], and is powerful enough to support our reading algorithm itself in an efficient way. Consequently, it equips a high level set-theoretic language with I/O, without the loss of computational transparency.This work alleviates the burden of creating low-level data structures manually, and builds the internal pointer-based inputs required by most pointer algorithms [Ben-Amram95] from the external string representation.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263762", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Paige", + "institution": "New York University" + }, + { + "first_name": "Zhe", + "last_name": "Yang", + "institution": "New York University" + } + ], + "dblp_key": "conf/popl/PaigeY97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263747", + "title": "Automatic Verification of Parameterized Linear Networks of Processes", + "abstract": "This paper describes a method to verify safety properties of parameterized linear networks of processes. The method is based on the construction of a network invariant, defined as a fixpoint. Such invariants can often be automatically computed using heuristics based on Cousot's widening techniques. These techniques have been implemented and some non-trivial examples are presented.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263747", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Lesens", + "institution": "Université Grenoble Alpes" + }, + { + "first_name": "Nicolas", + "last_name": "Halbwachs", + "institution": "Université Grenoble Alpes" + }, + { + "first_name": "Pascal", + "last_name": "Raymond", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/Halbwachs97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263750", + "title": "On the Complexity of Escape Analysis", + "abstract": "Escape analysis is an abstract interpretation technique for statically optimizing storage management devised by Park & Goldberg [30]. The main application of escape analysis is the optimization of storage management and data locality in garbage-collected languages such as ML or JAVA.We improve the previously known exponential complexity bound of Park & Goldberg: we show that first-order escape analysis (EA1) can be solved in almost linear time, and that second-order escape analysis (EA2) is DEXPTIME-hard. We exhibit a fast, equational, path-compression based abstract interpretation algorithm for EA1. We prove that it is sound and complete, and that its time complexity is O(n log2 n).We sketch an extension of the analysis to higher-order functions and imperative operations that is approximate. Finally we briefly present some experimental evidence that escape analysis may be useful in practice.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263750", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alain", + "last_name": "Deutsch", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Deutsch97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263707", + "title": "Objective ML: A Simple Object-Oriented Extension of ML", + "abstract": "Objective ML is a small practical extension of ML with objects and toplevel classes. It is fully compatible with ML; its type system is based on ML polymorphism, record types with polymorphic access, and a better treatment of type abbreviations. Objective ML allows for most features of object-oriented languages including multiple inheritance, methods returning self and binary methods as well as parametric classes. This demonstrates that objects can be added to strongly typed languages based on ML polymorphism.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263707", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jérôme", + "last_name": "Vouillon", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/RemyV97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263715", + "title": "Pizza into Java: Translating Theory into Practice", + "abstract": "Pizza is a strict superset of Java that incorporates three ideas from the academic community: parametric polymorphism, higher-order functions, and algebraic data types. Pizza is defined by translation into Java and compiles into the Java Virtual Machine, requirements which strongly constrain the design space. Nonetheless, Pizza fits smoothly to Java, with only a few rough edges.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263715", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/popl/OderskyW97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263717", + "title": "Model Checking for Programming Languages using Verisoft", + "abstract": "Verification by state-space exploration, also often referred to as \"model checking\", is an effective method for analyzing the correctness of concurrent reactive systems (e.g., communication protocols). Unfortunately, existing model-checking techniques are restricted to the verification of properties of models, i.e., abstractions, of concurrent systems.In this paper, we discuss how model checking can be extended to deal directly with \"actual\" descriptions of concurrent systems, e.g., implementations of communication protocols written in programming languages such as C or C++. We then introduce a new search technique that is suitable for exploring the state spaces of such systems. This algorithm has been implemented in VeriSoft, a tool for systematically exploring the state spaces of systems composed of several concurrent processes executing arbitrary C code. As an example of application, we describe how VeriSoft successfully discovered an error in a 2500-line C program controlling robots operating in an unpredictable environment.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263717", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "" + } + ], + "dblp_key": "conf/popl/Godefroid97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263738", + "title": "Minimal Typings in Atomic Subtyping", + "abstract": "This paper studies the problem of simplifying typings and the size-complexity of most general typings in typed programming languages with atomic subtyping. We define a notion of minimal typings relating all typings which are equivalent with respect to instantiation. The notion of instance is that of Fuh and Mishra [13], which supports many interesting simplifications. We prove that every typable term has a unique minimal typing, which is the logically most succinct among all equivalent typings. We study completeness properties, with respect to our notion of minimality, of well-known simplification techniques. Drawing upon these results, we prove a tight exponential lower bound for the worst case dag-size of constraint sets as well as of types in most general typings. To the best of our knowledge, the best previously proven lower bound was linear. 1 Introduction Subtyping is a fundamental idea in type systems for programming languages, which can in principle be integrated into standar...", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263738", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/popl/Rehof97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263711", + "title": "Call by Need Computations to Root-Stable Form", + "abstract": "The following theorem of Huet and Lévy forms the basis of all results on optimal reduction strategies for orthogonal term rewriting systems: every term not in normal form contains a needed redex, and repeated contraction of needed redexes results in the normal form, if the term under consideration has one. We generalize this theorem to computations to root-stable form and we argue that the resulting notion of root-neededness is more fundamental than (other variants of) neededness when it comes to infinitary normalization.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263711", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aart", + "last_name": "Middeldorp", + "institution": "University of Tsukuba" + } + ], + "dblp_key": "conf/popl/Middeldorp97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263705", + "title": "Partitioning Dataflow Analyses Using Types", + "abstract": "We present a simple method for partitioning a dataflow analysis problem into a series of related subproblems. We use type information (either declared by the programmer, or computed via nonstandard type inference) to conservatively approximate analysis-time data dependences between program quantities. This dependence information frees us from the need to model all program quantities simultaneously in a single, monolithic analysis. Instead, we can model quantities in any order, or even in parallel, so long as we respect the dependences. Our approach is independent of the means used to solve the subproblems, and enables the wider application of existing sparse approaches previously restricted to \"separable\" dataflow problems. Preliminary experiments applying our technique to flow-sensitive points-to analysis of C programs have achieved storage savings of 1.3-7.2x over existing methods.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263705", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Erik", + "last_name": "Ruf", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/Ruf97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263761", + "title": "Relational Parametricity and Units of Measure", + "abstract": "Type systems for programming languages with numeric types can be extended to support the checking of units of measure. Quantification over units then introduces a new kind of parametric polymorphism with a corresponding Reynolds-style representation independence principle: that the behaviour of programs is invariant under changes to the units used. We prove this 'dimensional invariance' result and describe four consequences. The first is that the type of an expression can be used to derive equations which describe its properties with respect to scaling (akin to Wadler's 'theorems for free' for System F). Secondly there are certain types which are inhabited only by trivial terms. For example, we prove that a fully polymorphic square root function cannot be written using just the usual arithmetic primitives. Thirdly we exhibit interesting isomorphisms between types and for first-order types relate these to the central theorem of classical dimensional analysis. Finally we suggest that for any expression whose behaviour is dimensionally invariant there exists some equivalent expression whose type reflects this behaviour, a consequence of which would be a full abstraction result for a model of the language.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263761", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "École Polytechnique" + } + ], + "dblp_key": "conf/popl/Kennedy97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263742", + "title": "Typing Algorithm in Type Theory with Inheritance", + "abstract": "We propose and study a new typing algorithm for dependent type theory. This new algorithm typechecks more terms by using inheritance between classes. This inheritance mechanism turns out to be powerful: it supports multiple inheritance, classes with parameters and uses new abstract classes FUNCLASS and SORTCLASS (respectively classes of functions and sorts). We also defines classes as records, particularily suitable for the formal development of mathematical theories. This mechanism, implemented in the proof checker Coq, can be adapted to all typed -calculus. 1 Introduction In the last years, proof checkers based on type theory appeared as convincing systems to formalize mathematics (especially constructive mathematics) and to prove correctness of software and hardware. In a proof checker, one can interactively build definitions, statements and proofs. The system is then able to check automatically whether the definitions are well-formed and the proofs are correct. Modern systems ar...", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263742", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amokrane", + "last_name": "Saïbi", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Saibi97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263760", + "title": "From SOS Rules to Proof Principles: An Operational Metatheory for Functional Languages", + "abstract": "Structural Operational Semantics (SOS) is a widely used formalism for specifying the computational meaning of programs, and is commonly used in specifying the semantics of functional languages. Despite this widespread use there has been relatively little work on the for such semantics. As a consequence the operational approach to reasoning is considered ad hoc since the same basic proof techniques and reasoning tools are reestablished over and over, once for each operational semantics specification. This paper develops some metatheory for a certain class of SOS language specifications for functional languages. We define a rule format, Globally Deterministic SOS (GDSOS), and establish some proof principles for reasoning about equivalence which are sound for all languages which can be expressed in this format. More specifically, if the SOS rules for the operators of a language conform to the syntax of the GDSOS format, then - a syntactic analogy of continuity holds, which relates a recursive function to its finite unwindings, and forms the basis of a Scott-style fixed-point induction technique; - a powerful induction principle called improvement induction holds for a certain class of GDSOS semantics; the Improvement Theorem from [Sands, POPL'95] is a simple corollary; - a useful bisimulation-based coinductive proof technique for operational approximation (and its instrumented variants) is sound.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263760", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Sands", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/Sands97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263703", + "title": "Fast and Accurate Flow-Insensitive Points-To Analysis", + "abstract": "In order to analyze a program that involves pointers, it is necessary to have (safe) information about what each pointer points to. There are many different approaches to computing points-to information. This paper addresses techniques for flow- and context-insensitive interprocedural analysis of stack-based storage.The paper makes two contributions to work in this area: - The first contribution is a set of experiments that explore the trade-offs between techniques previously defined by Lars Andersen and Bjarne Steensgaard. The former has a cubic worst-case running time, while the latter is essentially linear. However, the former may be much more precise than the latter. We have found that in practice, Andersen's algorithm is consistently more precise than Steensgaard's. For small programs, there is very little difference in the times required by the two approaches; however, for larger programs, Andersen's algorithm can be much slower than Steensgaard's. - The second contribution is the definition of two new algorithms. The first algorithm can be \"tuned\" so that its worst-case time and space requirements, as well as its accuracy range from those of Steensgaard to those of Andersen. We have experimented with several versions of this algorithm; one version provided a significant increase in accuracy over Steensgaard's algorithm, while keeping the running time within a factor of two. The second algorithm uses the first as a subroutine. Its worst-case time and space requirements are a factor of log N (where N is the number of variables in the program) worse than those of Steensgaard's algorithm. In practice, it appears to run about ten times slower than Steensgaard's algorithm; however it is significantly more accurate than Steensgaard's algorithm, and significantly faster than Andersen's algorithm on large programs.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263703", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marc", + "last_name": "Shapiro", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/ShapiroH97", + "venue": "popl", + "year": 1997 + }, + { + "paper_id": "10.1145/263699.263755", + "title": "Denotational Semantics Using an Operationally-Based Term Model", + "abstract": "We introduce a method for proving the correctness of transformations of programs in languages like Scheme and ML. The method consists of giving the programs a denotational semantics in an operationally-based term model in which interaction is the basic observable, and showing that the transformation is meaning-preserving. This allows us to consider correctness for programs that interact with their environment without terminating, and also for transformations that change the internal store behavior of the program. We illustrate the technique on one of the Meyer-Sieber examples, and we use it to prove the correctness of assignment elimination for Scheme. The latter is an important but subtle step for Scheme compilers; we believe ours is the first proof of its correctness.", + "date": "1997-01-01", + "link": "https://doi.org/10.1145/263699.263755", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + }, + { + "first_name": "Gregory T.", + "last_name": "Sullivan", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/WandS97", + "venue": "popl", + "year": 1997 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1998.json b/data/pl_conferences/popl/1998.json new file mode 100644 index 0000000..333a31c --- /dev/null +++ b/data/pl_conferences/popl/1998.json @@ -0,0 +1,778 @@ +[ + { + "paper_id": "10.1145/268946.268973", + "title": "Single and Loving It: Must-Alias Analysis for Higher-Order Languages", + "abstract": "In standard control-flow analyses for higher-order languages, a single abstract binding for a variable represents a set of exact bindings, and a single abstract reference cell represents a set of exact reference cells. While such analyses provide useful may-alias information, they are unable to answer mustalias questions about variables and cells, as these questions ask about equality of specific bindings and references.In this paper, we present a novel program analysis for higher-order languages that answers must-alias questions. At every program point, the analysis associates with each variable and abstract cell a cardinality, which is either single or multiple. If variable x is single at program point p, then all bindings for x in the heap reachable from the environment at p hold the same value. If abstract cell r is single at p, then at most one exact cell corresponding to r is reachable from the environment at p.Must-alias information facilitates various program optimizations such as lightweight closure conversion [19]. In addition, must-alias information permits analyses to perform strong updates [3] on abstract reference cells known to be single. Strong updates improve analysis precision for programs that make significant use of state.A prototype implementation of our analysis yields encouraging results. Over a range of benchmarks, our analysis classifies a large majority of the variables as single.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268973", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Princeton University" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Tübingen" + }, + { + "first_name": "Stephen", + "last_name": "Weeks", + "institution": "Princeton University" + }, + { + "first_name": "Andrew K.", + "last_name": "Wright", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/JagannathanTWW98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268953", + "title": "A Functional Representation of Data Structures with a Hole", + "abstract": "Data structures with a hole, in other words data structures with an uninitialized field, are useful to write efficient programs: they enable us to construct functional data structures flexibly and write functions such as append and map as tail recursive functions. In this paper we present an approach to introducing data structures with a hole into call-by-value functional programming languages like ML. Data structures with a hole are formalized as a new form of λ-abstraction called hole abstraction. The novel features of hole abstraction are that expressions inside hole abstraction are evaluated and application is implemented by destructive update of a hole. We present a simply typed call-by-value λ-calculus extended with hole abstractions. Then we show a compilation method of hole abstraction and prove correctness of the compilation.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268953", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yasuhiko", + "last_name": "Minamide", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/popl/Minamide98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268951", + "title": "Bridging the Gulf: A Common Intermediate Language for ML and Haskell", + "abstract": "Compilers for ML and Haskell use intermediate languages that incorporate deeply-embedded assumptions about order of evaluation and side effects. We propose an intermediate language into which one can compile both ML and Haskell, thereby facilitating the sharing of ideas and infrastructure, and supporting language developments that move each language in the direction of the other. Achieving this goal without compromising the ability to Compile as good code as a more direct route turned out to be much more subtle than we expected. We address this challenge using monads and unpointed types, identify two alternative language designs, and explore the choices they embody.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268951", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Oregon Research Institute" + }, + { + "first_name": "Mark", + "last_name": "Shields", + "institution": "Oregon Research Institute" + }, + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Oregon Research Institute" + }, + { + "first_name": "Andrew", + "last_name": "Tolmach", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/popl/JonesSLT98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268957", + "title": "Putting Pointer Analysis to Work", + "abstract": "This paper addresses the problem of how to apply pointer analysis to a wide variety of compiler applications. We are not presenting a new pointer analysis. Rather, we focus on putting two existing pointer analyses, points-to analysis and connection analysis, to work.We demonstrate that the fundamental problem is that one must be able to compare the memory locations read/written via pointer indirections, at different program points, and one must also be able to summarize the effect of pointer references over regions in the program. It is straightforward to compute read/write sets for indirections involving stack-directed pointers using points-to information. However, for heap-directed pointers we show that one needs to introduce the notion of anchor handles into the connection analysis and then express read/write sets to the heap with respect to these anchor handles.Based on the read/write sets we show how to extend traditional analyses like common subexpression elimination, loop-invariant removal and location-invariant removal to include pointer references. We also demonstrate the use of our information on more advanced techniques such as array dependence testing and program understanding. We have implemented our techniques in our McCAT C compiler, and we demonstrate examples of applying our methods on a set of pointer-intensive C benchmarks, as well as present concrete empirical data on the improvements achieved.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268957", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rakesh", + "last_name": "Ghiya", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/popl/GhiyaH98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268962", + "title": "Manufacturing Cheap, Resilient, and Stealthy Opaque Constructs", + "abstract": "It has become common to distribute software in forms that are isomorphic to the original source code. An important example is Java bytecode. Since such codes are easy to decompile, they increase the risk of malicious reverse engineering attacks.In this paper we describe the design of a Java code obfuscator, a tool which - through the application of code transformations - converts a Java program into an equivalent one that is more difficult to reverse engineer.We describe a number of transformations which obfuscate control-flow. Transformations are evaluated with respect to potency (To what degree is a human reader confused?), resilience (How well are automatic deobfuscation attacks resisted?), cost (How much time/space overhead is added?), and stealth (How well does obfuscated code blend in with the original code?).The resilience of many control-altering transformations rely on the resilience of opaque predicates. These are boolean valued expressions whose values are known to the obfuscator but difficult to determine for an automatic deobfuscator. We show how to construct resilient, cheap, and stealthy opaque predicates based on the intractability of certain static analysis problems such as alias analysis.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268962", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christian", + "last_name": "Collberg", + "institution": "University of Auckland" + }, + { + "first_name": "Clark", + "last_name": "Thomborson", + "institution": "University of Auckland" + }, + { + "first_name": "Douglas", + "last_name": "Low", + "institution": "University of Auckland" + } + ], + "dblp_key": "conf/popl/CollbergTL98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268974", + "title": "Barrier Inference", + "abstract": "Many parallel programs are written in SPMD style i.e. by running the same sequential program on all processes. SPMD programs include synchronization, but it is easy to write incorrect synchronization patterns. We propose a system that verifies a program's synchronization pattern. We also propose language features to make the synchronization pattern more explicit and easily checked. We have implemented a prototype of our system for Split-C and successfully verified the synchronization structure of realistic programs.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268974", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + }, + { + "first_name": "David", + "last_name": "Gay", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/AikenG98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268966", + "title": "Path-Sensitive Value-Flow Analysis", + "abstract": "When analyzing programs for value recomputation, one faces the problem of naming the value that flows between equivalent computations with different lexical names. This paper presents a data-flow analysis framework that overcomes this problem by synthesizing a name space tailored for tracing the values whose flow is of interest to a given data-flow problem. Furthermore, to exploit recomputation of a value with multiple, synonymous names, path-sensitive value numbering on the synthetic name space is developed. Optimizations that rely on value flow to detect redundant computations, such as partial redundancy elimination and constant propagation, become more powerful when phrased in our framework. The framework is built on a new program representation called Value Name Graph (VNG) which gains its power from integrating three orthogonal techniques: symbolic back-substitution, value numbering, and data-flow analysis. Our experiments with the implementation show that analysis on the VNG is p...", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268966", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rastisalv", + "last_name": "Bodík", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Sadun", + "last_name": "Anik", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/popl/BodikA98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268949", + "title": "Escape Analysis: Correctness Proof, Implementation and Experimental Results", + "abstract": "We describe an escape analysis [32, 14], used to determine whether the lifetime of data exceeds its static scope.We give a new correctness proof starting directly from a semantics. Contrary to previous proofs, it takes into account all the features of functional languages, including imperative features and polymorphism. The analysis has been designed so that it can be implemented under the small complexity bound of O(n log2 n) where n is the size of the analyzed program. We have included it in the Caml Special Light compiler (an implementation of ML), and applied it to very large programs. We plan to apply these techniques to the Java programming language.Escape analysis has been applied to stack allocation. We improve the optimization technique by determining minimal lifetime for stack allocated data, and using inlining. We manage to stack allocate 25% of data in the theorem prover Coq. We analyzed the effect of this optimization, and noticed that its main effect is to improve data locality, which is important for efficiency.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268949", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bruno", + "last_name": "Blanchet", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Blanchet98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268958", + "title": "Edge Profiling versus Path Profiling: The Showdown", + "abstract": "Edge profiles are the traditional control flow profile of choice for profile-directed compilation. They have been the basis of path-based optimizations that select paths, even though edge profiles contain strictly less information than path profiles. Recent work on path profiling has suggested that path profiles are superior to edge profiles in practice.We present theoretic and algorithmic results that may be used to determine when an edge profile is a good predictor of hot paths (and what those hot paths are) and when it is a poor predictor. Our algorithms efficiently compute sets of definitely and potentially hot paths in a graph annotated with an edge profile. A definitely hot path has a frequency greater than some non-zero lower bound in all path profiles that induce a given edge profile.Experiments on the SPEC95 benchmarks show that a huge percentage of the execution frequency in these programs is dominated by definitely hot paths (on average, 84% for FORTRAN benchmarks and 76% for C benchmarks). We also show that various hot path selection algorithms based on edge profiles work extremely well in most cases, but that path profiling is needed in some cases. These results indicate the usefulness of our algorithms for characterizing edge profiles and selecting hot paths.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268958", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Peter", + "last_name": "Mataga", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/BallMS98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268975", + "title": "Secure Information Flow in a Multi-Threaded Imperative Language", + "abstract": "Previously, we developed a type system to ensure secure information flow in a sequential, imperative programming language [VSI96]. Program variables are classified as either high or low security; intuitively, we wish to prevent information from flowing from high variables to low variables. Here, we extend the analysis to deal with a multithreaded language. We show that the previous type system is insufficient to ensure a desirable security property called noninterference. Noninterference basically means that the final values of low variables are independent of the initial values of high variables. By modifying the sequential type system, we are able to guarantee noninterference for concurrent programs. Crucial to this result, however, is the use of purely nondeterministic thread scheduling. Since implementing such scheduling is problematic, we also show how a more restrictive type system can guarantee noninterference, given a more deterministic (and easily implementable) scheduling policy, such as round-robin time slicing. Finally, we consider the consequences of adding a clock to the language.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268975", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Geoffrey", + "last_name": "Smith", + "institution": "Florida International University" + }, + { + "first_name": "Dennis", + "last_name": "Volpano", + "institution": "Naval Postgraduate School" + } + ], + "dblp_key": "conf/popl/SmithV98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268968", + "title": "Static Typing for Dynamic Messages", + "abstract": "Dynamic messages are first-class messages dynamically bound to program variables. By dynamic messages, the methods to be invoked can be varied dynamically at run-time, which provides a powerful abstraction mechanism for object-oriented languages. Dynamic messages are critically needed for some programs, but it seems that there has been no proposal of static type systems for dynamic messages. This paper presents a static typing discipline for dynamic messages and formalizes it into a second order polymorphic type system. The type system satisfies the type soundness property and has a principal type inference algorithm. The type system therefore provides a foundation for a statically typed object-oriented language enriched with polymorphic dynamic messages.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268968", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Susumu", + "last_name": "Nishimura", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/popl/Nishimura98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268979", + "title": "Security Properties of Typed Applets", + "abstract": "This paper formalizes the folklore result that strongly-typed applets are more secure than untyped ones. We formulate and prove several security properties that all well-typed applets possess, and identify sufficient conditions for the applet execution environment to be safe, such as procedural encapsulation, type abstraction, and systematic type-based placement of run-time checks. These results are a first step towards formal techniques for developing and validating safe execution environments for applets.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268979", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "François", + "last_name": "Rouaix", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/LeroyR98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268972", + "title": "Parallelization in Calculational Forms", + "abstract": "The problems involved in developing efficient parallel programs have proved harder than those in developing efficient sequential ones, both for programmers and for compilers. Although program calculation has been found to be a promising way to solve these problems in the sequential world, we believe that it needs much more effort to study its effective use in the parallel world. In this paper, we propose a calculational framework for the derivation of efficient parallel programs with two main innovations:. -We propose a novel inductive synthesis lemma based on which an elementary but powerful parallelization theorem is developed. -We make the first attempt to construct a calculational algorithm for parallelization, deriving associative operators from data type definition and making full use of existing fusion and tupling calculations.Being more constructive, our method is not only helpful in the design of efficient parallel programs in general but also promising in the construction of parallelizing compiler. Several interesting examples are used for illustration.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268972", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "The University of Tokyo" + }, + { + "first_name": "Masato", + "last_name": "Takeichi", + "institution": "Tokyo University of Information Sciences" + }, + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/popl/HuTC98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268961", + "title": "Classes and Mixins", + "abstract": "While class-based object-oriented programming languages provide a flexible mechanism for re-using and managing related pieces of code, they typically lack linguistic facilities for specifying a uniform extension of many classes with one set of fields and methods. As a result, programmers are unable to express certain abstractions over classes.In this paper we develop a model of class-to-class functions that we refer to as mixins. A mixin function maps a class to an extended class by adding or overriding fields and methods. Programming with mixins is similar to programming with single inheritance classes, but mixins more directly encourage programming to interfaces.The paper develops these ideas within the context of Java. The results are 1. an intuitive model of an essential Java subset; 2. an extension that explains and models mixins; and 3. type soundness theorems for these languages.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268961", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "Rice University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/FlattKF98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268971", + "title": "Parallel Beta Reduction is not Elementary Recursive", + "abstract": "We analyze the inherent complexity of implementing Lévy's notion of optimal evaluation for the &lambda-calculus, where similar redexes are contracted in one step via so-called parallel β-reduction. optimal evaluation was finally realized by Lamping, who introduced a beautiful graph reduction technology for sharing evaluation contexts dual to the sharing of values. His pioneering insights have been modified and improved in subsequent implementations of optimal reduction.We prove that the cost of parallel β-reduction is not bounded by any Kalmár-elementary recursive function. Not merely do we establish that the parallel β-step cannot, be a unit-cost operation, we demonstrate that the time complexity of implementing a sequence of n parallel β-steps is not bounded as O(2n), O(22n), O(222n), or in general, O(Kl(n)) where Kl(n) is a fixed stack of l 2s with an n on top.A key insight, essential to the establishment of this nonelementary lower bound, is that any simply-typed λ-term can be reduced to normal form in a number of parallel β-steps that is only polynomial in the length of the explicitly-typed term. The result follows from Statman's theorem that deciding equivalence of typed λ-terms is not elementary recursive.The main theorem gives a lower bound on the work that must be done by any technology that implements Lévy's notion of optimal reduction. However, in the significant case of Lamping's solution, we make some important remarks addressing how work done by β-reduction is translated into equivalent work carried out by his bookkeeping nodes. In particular, we identify the computational paradigms of superposition of values and of higher-order sharing, appealing to compelling analogies with quantum mechanics and SIMD-parallelism.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268971", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Asperti", + "institution": "University of Bologna" + }, + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/popl/AspertiM98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268952", + "title": "Correctness of Monadic State: An Imperative Call-by-Need Calculus", + "abstract": "The extension of Haskell with a built-in state monad combines mathematical elegance with operational efficiency: -Semantically, at the source language level, constructs that act on the state are viewed as functions that pass an explicit store data structure around. -Operationally, at the implementation level, constructs that act on the state are viewed as statements whose evaluation has the side-effect of updating the implicit global store in place.There are several unproven conjectures that the two views are consistent.Recently, we have noted that the consistency of the two views is far from obvious: all it takes for the implementation to become unsound is one judiciously-placed beta-step in the optimization phase of the compiler. This discovery motivates the current paper in which we formalize and show the correctness of the implementation of monadic state.For the proof, we first design a typed call-by-need language that models the intermediate language of the compiler, together with a type-preserving compilation map. Second, we show that the compilation is semantics-preserving by proving that the compilation of every source axiom yields an observational equivalence of the target language. Because of the wide semantic gap between the source and target languages, we perform this last step using an additional intermediate language.The imperative call-by-need λ-Calculus is of independent interest for reasoning about system-level Haskell code providing services such as memo-functions, generation of new names, etc., and is the starting point for reasoning about the space usage of Haskell programs.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268952", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "University of Oregon" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/popl/AriolaS98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268967", + "title": "Local Type Inference", + "abstract": "We study two partial type inference methods for a language combining subtyping and impredicative polymorphism. Both methods are local in the sense that missing annotations are recovered using only information from adjacent nodes in the syntax tree, without long-distance constraints such as unification variables. One method infers type arguments in polymorphic applications using a local constraint solver. The other infers annotations on bound variables in function abstractions by propagating type constraints downward from enclosing application nodes. We motivate our design choices by a statistical analysis of the uses of type inference in a sizable body of existing ML code. 1 Introduction Most statically typed programming languages offer some form of type inference, allowing programmers to omit type annotations that can be recovered from context. Such a facility can eliminate a great deal of needless verbosity, making programs easier both to read and to write. Unfortunately, type infe...", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268967", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "David N.", + "last_name": "Turner", + "institution": "" + } + ], + "dblp_key": "conf/popl/PierceT98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268965", + "title": "Fast Interprocedural Class Analysis", + "abstract": "Previous algorithms for interprocedural control flow analysis of higher-order and/or object-oriented languages have been described that perform propagation or constraint satisfaction and take O(N3) time (such as Shivers's O-CFA and Heintze's set-based analysis), or unification and take O(Nα (N,N) time (such as Steensgaard's pointer analysis), or optimistic reachability analysis and take O(N) time (such as Bacon and Sweeney's Rapid Type Analysis). We describe a general parameterized analysis framework that integrates propagation-based and unification-based analysis primitives and optimistic reachability analysis, whose instances mimic these existing algorithms as well as several new algorithms taking O(N), O(Nα(N,N)), O(N2), and O(N2α(N,N)) time; our O(N) and O(Nα(N,N)) algorithms produce more precise results than the previous algorithms with these complexities. We implemented our algorithm framework in the Vortex optimizing compiler, and we measured the cost and benefit of these interprocedural analysis algorithms in practice on a collection of substantial Cecil and Java programs.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268965", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Greg", + "last_name": "DeFouw", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Grove", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/DeFouwGC98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268960", + "title": "Javalight is Type-Safe - Definitely", + "abstract": "Javalight is a large sequential sublanguage of Java. We formalize its abstract syntax, type system, well-formedness conditions, and an operational evaluation semantics. Based on this formalization, we can express and prove type soundness. All definitions and proofs have been done formally in the theorem prover Isabelle/HOL. Thus this paper demonstrates that machine-checking the design of non-trivial programming languages has become a reality.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268960", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tobias", + "last_name": "Nipkow", + "institution": "Technical University of Munich" + }, + { + "first_name": "David von", + "last_name": "Oheimb", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/popl/NipkowO98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268964", + "title": "Inference of Polymorphic and Conditional Strictness Properties", + "abstract": "We define an inference system for modular strictness analysis of functional programs by extending a conjunctive strictness logic with polymorphic and conditional properties. This extended set of properties is used to define a syntax-directed, polymorphic strictness analysis based on polymorphic recursion whose soundness is established via a translation from the polymorphic system into the conjunctive system. From the polymorphic analysis, an inference algorithm based on constraint resolution is derived and shown complete for variant of the polymorphic analysis. The algorithm deduces at the same time a property and a set of hypotheses on the free variables of an expression which makes it suitable for analysis of program with module structure.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268964", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas Wiben", + "last_name": "Jensen", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/Jensen98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268948", + "title": "Alias Analysis of Executable Code", + "abstract": "Recent years have seen increasing interest in systems that reason about and manipulate executable code. Such systems can generally benefit from information about aliasing. Unfortunately, most existing alias analyses are formulated in terms of high-level language features, and are unable to cope with features, such as pointer arithmetic, that pervade executable programs. This paper describes a simple algorithm that can be used to obtain aliasing information for executabie code. In order to be practical, the algorithm is carefut to keep its memory requirements low, sacrificing precision where necessary to achieve this goal. Experimental results indicate that it is nevertheless able to provide a reasonable amount of information about memory references across a variety of benchmark programs.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268948", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "University of Arizona" + }, + { + "first_name": "Robert", + "last_name": "Muth", + "institution": "University of Arizona" + }, + { + "first_name": "Matthew", + "last_name": "Weippert", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/DebrayMW98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268947", + "title": "Higher-Order unCurrying", + "abstract": "We present a formal specification of unCurrying for a higherorder, functional language with ML-style let-polymorphism. This specification supports the general unCurrying of functions, even for functions which are passed as arguments or returned as values. The specification also supports partial unCurrying of any consecutive parameters of a function, rather than only unCurrying all of a function's parameters. We present the specification as a deductive system which axiomatizes a judgment relating a source term with an unCurried form of the term. We prove that this system relates only typable terms and that it is correct with respect to an operational semantics. We define a practical algorithm, based on algorithm W, which implements the unCurrying and prove this algorithm sound and complete with respect to the deductive system. This algorithm generates maximally unCurried forms of source terms. These results provide a declarative framework for reasoning about unCurrying and support a richer form of unCurrying than is currently found in compilers for functional languages.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268947", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Hannan", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Patrick", + "last_name": "Hicks", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/HannanH98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268955", + "title": "Maximal Static Expansion", + "abstract": "Memory expansions are classical means to extract parallelism from imperative programs. However, for dynamic control programs with general memory accesses, such transformations either fail or require some run-time mechanism to restore the data flow. This paper presents an expansion framework for any type of data structure in any imperative program, without the need for dynamic data flow restoration. The key idea is to group together the write operations that participate in the flow of the same datum. We show that such an expansion boils down to mapping each group to a single memory cell. We give a practical algorithm for code transformation. This algorithm, however, is valid for (possibly non-affine) loops over arrays only.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268955", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Denis", + "last_name": "Barthou", + "institution": "Université de Versailles Saint-Quentin-en-Yvelines" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Université de Versailles Saint-Quentin-en-Yvelines" + }, + { + "first_name": "Jean-François", + "last_name": "Collard⋆", + "institution": "Institut Lavoisier de Versailles" + } + ], + "dblp_key": "conf/popl/BarthouCC98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268976", + "title": "The SLam Calculus: Programming with Secrecy and Integrity", + "abstract": "The SLam calculus is a typed λ-calculus that maintains security information as well as type information. The type system propagates security information for each object in four forms: the object's creators and readers, and the object's indirect creators and readers (i.e., those agents who, through flow-of-control or the actions of other agents, can influence or be influenced by the content of the object). We prove that the type system prevents security violations and give some examples of its power.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268976", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nevin", + "last_name": "Heintze", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Jon G.", + "last_name": "Riecke", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/popl/HeintzeR98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268963", + "title": "From Polyvariant Flow Information to Intersection and Union Types", + "abstract": "Many polyvariant program analyses have been studied in the 199Os, including k-CFA, poly-k-CFA, and the Cartesian product algorithm. The idea of polyvariance is to analyze functions more than once and thereby obtain better precision for each call site. In this paper we present the first formal relationship between polyvariant analysis and standard notions of type. In the spirit of Nielson and Nielson, we study a parameterized flow analysis which can be instantiated to the analyses of Agesen, Schmidt, and as a simple case also 0-CFA. Extended with safety checks, the flow analysis accepts and rejects programs, much like a type checker. We prove that if a program can be safety-checked by a finitary instantiation of the flow analysis, then it can also be typed in a type system with intersection types, union types, subtyping, and recursive types, but no universal or existential quantifiers. This provides a framework for designing and understanding combinations of flow analyses and type systems.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268963", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Christina", + "last_name": "Pavlopoulou", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/PalsbergP98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268978", + "title": "A Typed Language for Distributed Mobile Processes (Extended Abstract)", + "abstract": "We describe a foundational language for specifying dynamically evolving networks of distributed processes, Dπ. The language is a distributed extension of the π-calculus which incorporates the notions of remote execution, migration, and site failure. Novel features of Dπ include 1. Communication channels are explicitly located: the use of a channel requires knowledge of both the channel and its location. 2. Names are endowed with permissions: the holder of a name may only use that name in the manner allowed by these permissions.A type system is proposed in which-the types control the allocation of permissions; in well-typed processes all names are used in accordance with the permissions allowed by the types. We prove Subject Reduction and Type Safety Theorems for the type system. In the final section we define a semantic theory based on barbed bisimulations and discuss its characterization in terms of a bisimulation relation over a relativized labelled transition system.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268978", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James", + "last_name": "Riely", + "institution": "University of Sussex" + }, + { + "first_name": "Matthew", + "last_name": "Hennessy", + "institution": "University of Sussex" + } + ], + "dblp_key": "conf/popl/RielyH98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268969", + "title": "Second-Order Unification and Type Inference for Church-Style Polymorphism", + "abstract": "We present a proof of the undecidability of type inference for the Church-style system F --- an abstraction of polymorphism. A natural reduction from the second-order unification problem to type inference leads to strong restriction on instances --- arguments of variables cannot contain variables. This requires another proof of the undecidability of the second-order unification since known results use variables in arguments of other variables. Moreover, our proof uses elementary techniques, which is important from the methodological point of view, because Goldfarb&apos;s proof [Gol81] highly relies on the undecidability of the tenth Hilbert&apos;s problem. 1 1 Introduction The Church-style system F was independently introduced by Girard [Gir72] and Reynolds [Rey74] as an extension of the simply-typed -calculus a type system introduced of H. B. Curry [Cur69]. As usual for type systems, the decidability of so called sequent decision problems was considered. A sequent decision problem in some ty...", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268969", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aleksy", + "last_name": "Schubert", + "institution": "University of Warsaw" + } + ], + "dblp_key": "conf/popl/Schubert98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268950", + "title": "Data Flow Analysis is Model Checking of Abstract Interpretations", + "abstract": "This expository paper simplifies and clarifies Steffen's depiction of data flow analysis (d.f.a.) as model checking: By employing abstract interpretation (a.i.) to generate program traces and by utilizing Kozen's modal mu-calculus to express trace properties, we express in simplest possible terms that a d.f.a. is a model check of a program's a.i. trace. In particular, the classic flow equations for bit-vector-based d.f.a.s reformat trivially into modal mu-Calculus formulas. A surprising consequence is that two of the classical d.f.a.s are exposed as unsound; this problem is analyzed and simply repaired. In the process of making the above discoveries, we clarify the relationship between a.i. and d.f.a. in terms of the often-misunderstood notion of collecting semantics and we highlight how the research areas of flow analysis, abstract interpretation, and model checking have grown together.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268950", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David A.", + "last_name": "Schmidt", + "institution": "Kansas State University" + } + ], + "dblp_key": "conf/popl/Schmidt98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268959", + "title": "A Type System for Java Bytecode Subroutines", + "abstract": "Java is typically compiled into an intermediate language, JVML, that is interpreted by the Java Virtual Machine. Because mobile JVML code is not always trusted, a bytecode verifier enforces static constraints that prevent various dynamic errors. Given the importance of the bytecode verifier for security, its current descriptions are inadequate. This paper proposes using typing rules to describe the bytecode verifier because they are more precise than prose, clearer than code, and easier to reason about than either.JVML has a subroutine construct used for the compilation of Java's try-finally statement. Subroutines are a major source of complexity for the bytecode verifier because they are not obviously last-in/first-out and because they require a kind of polymorphism. Focusing on subroutines, we isolate an interesting, small subset of JVML. We give typing rules for this subset and prove their correctness. Our type system constitutes a sound basis for bytecode verification and a rational reconstruction of a delicate part of Sun's bytecode verifier.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268959", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Raymie", + "last_name": "Stata", + "institution": "Digital Equipment (Germany)" + }, + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Digital Equipment (Germany)" + } + ], + "dblp_key": "conf/popl/StataA98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268970", + "title": "Dynamic Typing as Staged Type Inference", + "abstract": "Dynamic typing extends statically typed languages with a universal datatype, simplifying programs which must manipulate other programs as data, such as distributed, persistent, interpretive and generic programs. Current approaches, however, limit the use of polymorphism in dynamic values, and can be syntactically awkward.We introduce a new approach to dynamic typing, based on staged computation, which allows a single type-reconstruction algorithm to execute partly at compile time and partly at run-time. This approach seamlessly extends a single type system to accommodate types that are only known at run-time, while still supporting both type inference and polymorphism. The system is significantly more expressive than other approaches. Furthermore it can be implemented efficiently; most of the type inference is done at compile-time, leaving only some residual unification for run-time.We demonstrate our approach by examples in a small polymorphic functional language, and present its type system, type reconstruction algorithm, and operational semantics. Our proposal could also be readily adapted to many other programming languages.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268970", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark", + "last_name": "Shields", + "institution": "University of Glasgow" + }, + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Oregon Research Institute" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/popl/ShieldsSJ98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268956", + "title": "Array SSA Form and Its Use in Parallelization", + "abstract": "Static single assignment (SSA) form for scalars has been a significant advance. It has simplified the way we think about scalar variables. It has simplified the design of some optimizations and has made other optimizations more effective. Unfortunately none of this can be be said for SSA form for arrays. The current SSA processing of arrays views an array as a single object. But the kinds of analyses that sophisticated compilers need to perform on arrays, for example those that drive loop parallelization, are at the element level. Current SSA form for arrays is incapable of providing the element-level data flow information required for such analyses.In this paper, we introduce an Array SSA form that captures precise element-level data flow information for array variables in all cases. It is general and simple, and coincides with standard SSA form when applied to scalar variables. It can also be used for structures and other variable types that can be modeled as arrays. An important application of Array SSA form is in automatic parallelization. We show how Array SSA form can enable parallelization of any loop that is free of loop-carried true data dependences. This includes loops with loop-carried anti and output dependences, unanalyzable subscript expressions, and arbitrary control flow within an iteration. Array SSA form achieves this level of generality by making manifest its - functions as runtime computations in cases that are not amenable to compile-time analysis.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268956", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kathleen", + "last_name": "Knobe", + "institution": "" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/KnobeS98", + "venue": "popl", + "year": 1998 + }, + { + "paper_id": "10.1145/268946.268954", + "title": "From System F to Typed Assembly Language", + "abstract": "We motivate the design of a statically typed assembly language (TAL) and present a type-preserving translation from System F to TAL. The TAL we present is based on a conventional RISC assembly language, but its static type system provides support for enforcing high-level language abstractions, such as closures, tuples, and objects, as well as user-defined abstract data types. The type system ensures that well-typed programs cannot violate these abstractions. In addition, the typing constructs place almost no restrictions on low-level optimizations such as register allocation, instruction selection, or instruction scheduling.Our translation to TAL is specified as a sequence of type-preserving transformations, including CPS and closure conversion phases; type-correct source programs are mapped to type-correct assembly language. A key contribution is an approach to polymorphic closure conversion that is considerably simpler than previous work. The compiler and typed assembly language provide a fully automatic way to produce proof carrying code, suitable for use in systems where untrusted and potentially malicious code must be checked for safety before execution.", + "date": "1998-01-01", + "link": "https://doi.org/10.1145/268946.268954", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Cornell University" + }, + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Cornell University" + }, + { + "first_name": "Neal", + "last_name": "Glew", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/MorrisettWCG98", + "venue": "popl", + "year": 1998 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/1999.json b/data/pl_conferences/popl/1999.json new file mode 100644 index 0000000..b4ce3d5 --- /dev/null +++ b/data/pl_conferences/popl/1999.json @@ -0,0 +1,597 @@ +[ + { + "paper_id": "10.1145/292540.292557", + "title": "Representing Layered Monads", + "abstract": "There has already been considerable research on constructing modular, monad-based specifications of computational effects (state, exceptions, nondeterminism, etc.) in programming languages. We present a simple framework in this tradition, based on a Church-style effect-typing system for an ML-like language. The semantics of this language is formally defined by a series of monadic translations, each one expanding away a layer of effects. Such a layered specification is easy to reason about, but its direct implementation (whether by parameterized interpretation or by actual translation) is often prohibitively inefficient.By exploiting deeper semantic properties of monads, however, it is also possible to derive a vastly more efficient implementation: we show that each layer of effects can be uniformly simulated by continuation-passing, and further that multiple such layers can themselves be simulated by a standard semantics for call/cc and mutable state. Thus, even multi-effect programs can be executed in Scheme or SML/NJ at full native speed, generalizing an earlier single-effect result. As an example, we show how a simple resumption-based semantics of concurrency allows us to directly simulate a shared-state program across all possible dynamic interleavings of execution threads.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292557", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrzej", + "last_name": "Filinski", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/Filinski99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292551", + "title": "Trust and Partial Typing in Open Systems of Mobile Agents", + "abstract": "We present a partially-typed semantics for Dπ, a distributed π-calculus. The semantics is designed for mobile agents in open distributed systems in which some sites may harbor malicious intentions. Nonetheless, the semantics guarantees traditional type-safety properties at \"good\" locations by using a mixture of static and dynamic type-checking. We show how the semantics can be extended to allow trust between sites, improving performance and expressiveness without compromising type-safety.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292551", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James", + "last_name": "Riely", + "institution": "North Carolina State University" + }, + { + "first_name": "Matthew", + "last_name": "Hennessy", + "institution": "University of Sussex" + } + ], + "dblp_key": "conf/popl/RielyH99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292547", + "title": "Improvement in a Lazy Context: An Operational Theory for Call-by-Need", + "abstract": "The standard implementation technique for lazy functional languages is call-by-need, which ensures that an argument to a function in any given call is evaluated at most once. A significant problem with call-by-need is that it is difficult -- even for compiler writers -- to predict the effects of program transformations. The traditional theories for lazy functional languages are based on call-by-name models, and offer no help in determining which transformations do indeed optimize a program.In this article we present an operational theory for call-by-need, based upon an improvement ordering on programs: M is improved by N if in all program-contexts C, when C[M] terminates then C[N] terminates at least as cheaply.We show that this improvement relation satisfies a \"context lemma\", and supports a rich inequational theory, subsuming the call-by-need lambda calculi of Ariola et al. [AFM+95]. The reduction-based call-by-need calculi are inadequate as a theory of lazy-program transformation since they only permit transformations which speed up programs by at most a constant factor (a claim we substantiate); we go beyond the various reduction-based calculi for call-by-need by providing powerful proof rules for recursion, including syntactic continuity -- the basis of fixed-point-induction style reasoning, and an improvement theorem, suitable for arguing the correctness and safety of recursion-based program transformations.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292547", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Moran", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "David", + "last_name": "Sands", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/MoranS99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292543", + "title": "AnnoDomini: From Type Theory to Year 2000 Conversion Tool", + "abstract": "AnnoDomini is a source-to-source conversion tool for making COBOL programs Year 2000 compliant. It is technically and conceptually built upon type-theoretic techniques and methods: type-based specification, program analysis by type inference and type-directed transformation. These are combined into an integrated software reengineering tool and method for finding and fixing Year 2000 problems. AnnoDomini's primary goals have been flexibility (support for multiple year representations), completeness (identifying all potential Year 2000 problems), correctness (correct fixes for Year 2000 problems) and a high degree of safe automation in all phases (declarative specification of conversions, no second-guessing or dangerous heuristics).In this paper we present the type-theoretic foundations of AnnoDomini: type system, type inference, unification theory, semantic soundness, and correctness of conversion. We also describe how these foundations have been applied and extended to a common COBOL mainframe dialect, and how AnnoDomini is packaged with graphical user interface and syntax-sensitive editor into a commercially available software tool.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292543", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter Harry", + "last_name": "Eidorff", + "institution": "University of Copenhagen" + }, + { + "first_name": "Fritz", + "last_name": "Henglein", + "institution": "University of Copenhagen" + }, + { + "first_name": "Christian", + "last_name": "Mossin", + "institution": "University of Copenhagen" + }, + { + "first_name": "Henning", + "last_name": "Niss", + "institution": "University of Copenhagen" + }, + { + "first_name": "Morten Heine", + "last_name": "Sørensen", + "institution": "University of Copenhagen" + }, + { + "first_name": "Mads", + "last_name": "Tofte", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/popl/EidorffHMNST99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292550", + "title": "Types for Mobile Ambients", + "abstract": "Java has demonstrated the utility of type systems for mobile code, and in particular their use and implications for security. Security properties rest on the fact that a well-typed Java program (or the corresponding verified bytecode) cannot cause certain kinds of damage.In this paper we provide a type system for mobile computation, that is, for computation that is continuously active before and after movement. We show that a well-typed mobile computation cannot cause certain kinds of run-time fault: it cannot cause the exchange of values of the wrong kind, anywhere in a mobile system.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292550", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/CardelliG99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292565", + "title": "Type-Based Analysis of Uncaught Exceptions", + "abstract": "This paper presents a program analysis to estimate uncaught exceptions in ML programs. This analysis relies on unification-based type inference in a non-standard type system, using rows to approximate both the flow of escaping exceptions (a la effect systems) and the flow of result values (a la control-flow analyses). The resulting analysis is efficient and precise; in particular, arguments carried by exceptions are accurately handled.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292565", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Pessaux", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/PessauxL99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292563", + "title": "Type-Safe Linking and Modular Assembly Language", + "abstract": "Linking is a low-level task that is usually vaguely specified, if at all, by language definitions. However, the security of web browsers and other extensible systems depends crucially upon a set of checks that must be performed at link time. Building upon the simple, but elegant ideas of Cardelli, and module constructs from high-level languages, we present a formal model of typed object files and a set of inference rules that are sufficient to guarantee that type safety is preserved by the linking process.\\n\\nWhereas Cardelli's link calculus is built on top of the simply-typed lambda calculus, our object files are based upon typed assembly language so that we may model important low-level implementation issues. Furthermore, unlike Cardelli, we provide support for abstract types and higher-order type constructors - features critical for building extensible systems or modern programming languages such as ML.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292563", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neal", + "last_name": "Glew", + "institution": "Cornell University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/GlewM99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292555", + "title": "A Core Calculus of Dependency", + "abstract": "Notions of program dependency arise in many settings: security, partial evaluation, program slicing, and call-tracking. We argue that there is a central notion of dependency common to these settings that can be captured within a single calculus, the Dependency Core Calculus (DCC), a small extension of Moggi's computational lambda calculus. To establish this thesis, we translate typed calculi for secure information flow, binding-time analysis, slicing, and call-tracking into DCC. The translations help clarify aspects of the source calculi. We also define a semantic model for DCC and use it to give simple proofs of noninterference results for each case.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292555", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Nevin", + "last_name": "Heintze", + "institution": "Bell (Canada)" + }, + { + "first_name": "Jon G.", + "last_name": "Riecke", + "institution": "Nokia (United States)" + } + ], + "dblp_key": "conf/popl/AbadiBHR99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292553", + "title": "Aggregate Structure Identification and Its Application to Program Analysis", + "abstract": "In this paper, we describe an efficient algorithm for lazily decomposing aggregates such as records and arrays into simpler components based on the access patterns specific to a given program. This process allows us both to identify implicit aggregate structure not evident from declarative information in the program, and to simplify the representation of declared aggregates when references are made only to a subset of their components. We show that the structure identification process can be exploited to yield the following principal results: - A fast type analysis algorithm applicable to program maintenance applications such as date usage inference for the \"Year 2000\" problem. - An efficient algorithm for atomization of aggregates. Given a program, an aggregate atomization decomposes all of the data that can be manipulated by the program into a set of disjoint atoms such that each data reference can be modeled as one or more references to atoms without loss of semantic information. Aggregate atomization can be used to adapt program analyses and representations designed for scalar data to aggregate data. In particular, atomization can be used to build more precise versions of program representations such as SSA form or PDGs. Such representations can in turn yield more accurate results for problems such as program slicing.Our techniques are especially useful in weakly-typed languages such as Cobol (where a variable need not be declared as an aggregate to store an aggregate value) and in languages where references to statically-defined subranges of data such as arrays or strings are allowed.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292553", + "conference_name": "POPL", + "authors": [ + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM (United States)" + }, + { + "first_name": "John K.", + "last_name": "Field", + "institution": "IBM (United States)" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/RamalingamFT99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292569", + "title": "Software Watermarking: Models and Dynamic Embeddings", + "abstract": "Watermarking embeds a secret message into a cover message. In media watermarking the secret is usually a copyright notice and the cover a digital image. Watermarking an object discourages intellectual property theft, or when such theft has occurred, allows us to prove ownership.The Software Watermarking problem can be described as follows. Embed a structure W into a program P such that: W can be reliably located and extracted from P even after P has been subjected to code transformations such as translation, optimization and obfuscation; W is stealthy; W has a high data rate; embedding W into P does not adversely affect the performance of P; and W has a mathematical property that allows us to argue that its presence in P is the result of deliberate actions.In the first part of the paper we construct an informal taxonomy of software watermarking techniques. In the second part we formalize these results. Finally, we propose a new software watermarking technique in which a dynamic graphic watermark is stored in the execution state of a program.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292569", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christian", + "last_name": "Collberg", + "institution": "University of Arizona" + }, + { + "first_name": "Clark", + "last_name": "Thomborson", + "institution": "University of Auckland" + } + ], + "dblp_key": "conf/popl/CollbergT99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292554", + "title": "Relevant Context Inference", + "abstract": "Relevant context inference (RCI) is a modular technique for flow- and context-sensitive data-flow analysis of statically typed object-oriented programming languages such as C++ and Java. RCI can be used to analyze complete programs as well as incomplete programs such as libraries; this approach does not require that the entire program be memory-resident during the analysis. RCI is presented in the context of points-to analysis for a realistic subset of C++. The empirical evidence obtained from a prototype implementation argues the effectiveness of RCI.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292554", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ramkrishna", + "last_name": "Chatterjee", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "William", + "last_name": "Landi", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/ChatterjeeRL99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292546", + "title": "Quasi-Linear Types", + "abstract": "Linear types (types of values that can be used just once) have been drawing a great deal of attention because they are useful for memory management, in-place update of data structures, etc.: an obvious advantage is that a value of a linear type can be immediately deallocated after being used. However, the linear types have not been applied so widely in practice, probably because linear values (values of linear types) in the traditional sense do not so often appear in actual programs. In order to increase the applicability of linear types, we relax the condition of linearity by extending the types with information on an evaluation order and simple dataflow information. The extended type system, called a quasi-linear type system, is formalized and its correctness is proved. We have implemented a prototype type inference system for the core-ML that can automatically find out which value is linear in the relaxed sense. Promising results were obtained from preliminary experiments with the prototype system.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292546", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/Kobayashi99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292558", + "title": "Stochastic Processes as Concurrent Constraint Programs", + "abstract": ") Vineet Gupta Radha Jagadeesan Prakash Panangaden y vgupta@mail.arc.nasa.gov radha@cs.luc.edu prakash@cs.mcgill.ca Caelum Research Corporation Dept. of Math. and Computer Sciences School of Computer Science NASA Ames Research Center Loyola University--Lake Shore Campus McGill University Moffett Field CA 94035, USA Chicago IL 60626, USA Montreal, Quebec, Canada Abstract This paper describes a stochastic concurrent constraint language for the description and programming of concurrent probabilistic systems. The language can be viewed both as a calculus for describing and reasoning about stochastic processes and as an executable language for simulating stochastic processes. In this language programs encode probability distributions over (potentially infinite) sets of objects. We illustrate the subtleties that arise from the interaction of constraints, random choice and recursion. We describe operational semantics of these programs (programs are run by sampling random choices), deno...", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292558", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vineet", + "last_name": "Gupta", + "institution": "Ames Research Center" + }, + { + "first_name": "Radha", + "last_name": "Jagadeesan", + "institution": "Loyola University Chicago" + }, + { + "first_name": "Prakash", + "last_name": "Panangaden", + "institution": "McGill University" + } + ], + "dblp_key": "conf/popl/GuptaJP99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292549", + "title": "A Simple, Comprehensive Type System for Java Bytecode Subroutines", + "abstract": "A type system with proven soundness is a prerequisite for the safe and efficient execution of Java bytecode programs. So far, efforts to construct such a type system have followed a forward dataflow approach, in the spirit of the original Java Virtual Machine bytecode verifier. We present an alternative type system, based on conventional ideas of type constraints, polymorphic recursion and continuations. We compare it to Stata and Abadi's JVML-0 type system for bytecode subroutines, and demonstrate that our system is simpler and able to type strictly more programs, including code that could be produced by Java compilers and cannot be typed in JVML-0. Examination of real Java programs shows that such code is rare but does occur. We explain some of the apparently arbitrary constraints imposed by previous approaches by showing that they are consequences of our simpler type rules, or actually unnecessary.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292549", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "O'Callahan", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/OCallahn99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292562", + "title": "Optimal Code Selection in DAGs", + "abstract": "We extend the tree parsing approach to code selection to DAGs. In general, our extension does not produce the optimal code selection for all DAGs (this problem would be NPcomplete) , but for certain code selection grammars, it does. We present a method for checking whether a code selection grammar belongs to this set of DAG-optimal grammars, and use this method to check code selection grammars adapted from lcc: the grammars for the MIPS and SPARC architectures are DAG-optimal, and the code selection grammar for the 386 architecture is almost DAG-optimal.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292562", + "conference_name": "POPL", + "authors": [ + { + "first_name": "M. Anton", + "last_name": "Ertl", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/popl/Ertl99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292561", + "title": "JFlow: Practical Mostly-Static Information Flow Control", + "abstract": "A promising technique for protecting privacy and integrity of sensitive data is to statically check information flow within programs that manipulate the data. While previous work has proposed programming language extensions to allow this static checking, the resulting languages are too restrictive for practical use and have not been implemented. In this paper, we describe the new language JFlow, an extension to the Java language that adds statically-checked information flow annotations. JFlow provides several new features that make information flow checking more flexible and convenient than in previous models: a decentralized label model, label polymorphism, run-time label checking, and automatic label inference. JFlow also supports many language features that have never been integrated successfully with static information flow control, including objects, subclassing, dynamic type tests, access control, and exceptions. This paper defines the JFlow language and presents formal rules that are used to check JFlow programs for correctness. Because most checking is static, there is little code space, data space, or run-time overhead in the JFlow implementation.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292561", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Myers99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292556", + "title": "Principality and Decidable Type Inference for Finite-Rank Intersection Types", + "abstract": "Principality of typings is the property that for each typable term, there is a typing from which all other typings are obtained via some set of operations. Type inference is the problem of finding a typing for a given term, if possible. We define an intersection type system which has principal typings and types exactly the strongly normalizable α-terms. More interestingly, every finite-rank restriction of this system (using Leivant's first notion of rank) has principal typings and also has decidable type inference. This is in contrast to System F where the finite rank restriction for every finite rank at 3 and above has neither principal typings nor decidable type inference. This is also in contrast to earlier presentations of intersection types where the status (decidable or undecidable) of these properties is unknown for the finite-rank restrictions at 3 and above. Furthermore, the notion of principal typings for our system involves only one operation, substitution, rather than several operations (not all substitution-based) as in earlier presentations of principality for intersection types (without rank restrictions). In our system the earlier notion of expansion is integrated in the form of expansion variables, which are subject to substitution as are ordinary variables. A unification-based type inference algorithm is presented using a new form of unification, β-unification.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292556", + "conference_name": "POPL", + "authors": [ + { + "first_name": "A. J.", + "last_name": "Kfoury", + "institution": "" + }, + { + "first_name": "J. B.", + "last_name": "Wells", + "institution": "" + } + ], + "dblp_key": "conf/popl/KfouryW99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292564", + "title": "Typed Memory Management in a Calculus of Capabilities", + "abstract": "Abstract An increasing number of systems rely on programming language technology to ensure safety and security of low-level code. Unfortunately, these systems typically rely on a complex, trusted garbage collector. Region-based type systems provide an alternative to garbage collection by making memory management explicit but verifiably safe. However, it has not been clear how to use regions in low-level, type-safe code. We present a compiler intermediate language, called the Capability Calculus, that supports region-based memory management, enjoys a provably safe type system, and is straightforward to compile to a typed assembly language. Source languages may be compiled to our language using known region inference algorithms. Furthermore, region lifetimes need not be lexically scoped in our language, yet the language may be checked for safety without complex analyses. Finally, our soundness proof is relatively simple, employing only standard techniques.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292564", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Cornell University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/CraryWM99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292560", + "title": "Dependent Types in Practical Programming", + "abstract": "We present an approach to enriching the type system of ML with a restricted form of dependent types, where type index objects are drawn from a constraint domain C, leading to the DML(C) language schema. This allows specification and inference of significantly more precise type information, facilitating program error detection and compiler optimization. A major complication resulting from introducing dependent types is that pure type inference for the enriched system is no longer possible, but we show that type-checking a sufficiently annotated program in DML(C) can be reduced to constraint satisfaction in the constraint domain C. We exhibit the unobtrusiveness of our approach through practical examples and prove that DML(C) is conservative over ML. The main contribution of the paper lies in our language design, including the formulation of type-checking rules which makes the approach practical. To our knowledge, no previous type system for a general purpose programming language such as ML has combined dependent types with features including datatype declarations, higher-order functions, general recursions, let-polymorphism, mutable references, and exceptions. In addition, we have finished a prototype implementation of DML(C) for an integer constraint domain C, where constraints are linear inequalities (Xi and Pfenning 1998).", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292560", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hongwei", + "last_name": "Xi", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/XiP99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292567", + "title": "Constraint Systems for Useless Variable Elimination", + "abstract": "A useless variable is one whose value contributes nothing to the final outcome of a computation. Such variables are unlikely to occur in human-produced code, but may be introduced by various program transformations. We would like to eliminate useless parameters from procedures and eliminate the corresponding actual parameters from their call sites. This transformation is the extension to higher-order programming of a variety of dead-code elimination optimizations that are important in compilers for first-order imperative languages.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292567", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + }, + { + "first_name": "Igor", + "last_name": "Siveroni", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/WandS99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292552", + "title": "Parametric Shape Analysis via 3-Valued Logic", + "abstract": "We present a family of abstract-interpretation algorithms that are capable of determining \"shape invariants\" of programs that perform destructive updating on dynamically allocated storage. The main idea is to represent the stores that can possibly arise during execution using three-valued logical structures.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292552", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "" + }, + { + "first_name": "Reinhard", + "last_name": "Wilhelm", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/popl/SagivRW99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292568", + "title": "Continuous Grammars", + "abstract": "After defining appropriate metrics on strings and parse trees, the classic definition of continuity is adapted and applied to functions from strings to parse trees. Grammars that yield continuous mappings are of special interest, because they provide a sound theoretical framework for syntax error correction. Continuity justifies the approach, taken by many error correctors, to use the function output (the parse tree), and all the additional information it provides, in order to find corrections to the function input (the string). We prove that all Bounded Context grammars are continuous and that all continuous grammars are Bounded Context Parseable grammars, giving a characterization of continuous grammars in terms of possible parsing algorithms.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292568", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Rückert", + "institution": "SUNY New Paltz" + } + ], + "dblp_key": "conf/popl/Ruckert99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292548", + "title": "A Compositional Account of the Java Virtual Machine", + "abstract": "The Java Virtual Machine (or JVM) is central to the system's aim of providing a secure program execution environment that operates identically on a wide variety of computing platforms. To be most effective in this role, the JVM needs a rigorous, complete description, to specify precisely the behavior required of implementations. In response, a number of researchers have produced formal accounts of the JVM that seek to define it in an unambiguous and comprehensible manner. Unfortunately, the size and complexity of the JVM means that many of these formal accounts must either restrict their scope substantially, or risk becoming unwieldy and intractable. This paper suggests an alternative approach to the specification of the JVM that seeks to ameliorate such problems by composing together a small set of \"microinstructions\" to produce the full bytecode set. These microinstructions are encapsulated as functions in the polymorphic functional programming language Haskell, using the familiar mechanisms of Hindley-Milner type inference to characterize the JVM's rather thorny verifier. In this way, its is hoped that a foundation will be laid for formal descriptions of the Java Virtual Machine that need not trade tractability for completeness.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292548", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Phillip M.", + "last_name": "Yelland", + "institution": "" + } + ], + "dblp_key": "conf/popl/Yelland99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292545", + "title": "Once Upon a Polymorphic Type", + "abstract": "We present a sound type-based `usage analysis&apos; for a realistic lazy functional language. Accurate information on the usage of program subexpressions in a lazy functional language permits a compiler to perform a number of useful optimisations. However, existing analyses are either ad-hoc and approximate, or defined over restricted languages. Our work extends the Once Upon A Type system of Turner, Mossin, and Wadler (FPCA&apos;95). Firstly, we add type polymorphism, an essential feature of typed functional programming languages. Secondly, we include general Haskell-style user-defined algebraic data types. Thirdly, we explain and solve the `poisoning problem&apos;, which causes the earlier analysis to yield poor results. Interesting design choices turn up in each of these areas. Our analysis is sound with respect to a Launchbury-style operational semantics, and it is straightforward to implement. Good results have been obtained from a prototype implementation, and we are currently integrating the system into the Glasgow Haskell Compiler.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292545", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Keith", + "last_name": "Wansbrough", + "institution": "University of Cambridge" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/WansbroughJ99", + "venue": "popl", + "year": 1999 + }, + { + "paper_id": "10.1145/292540.292559", + "title": "Extending the Scope of Syntactic Abstraction", + "abstract": "The benefits of module systems and lexically scoped syntactic abstraction (macro) facilities are well-established in the literature. This paper presents a system that seamlessly integrates modules and lexically scoped macros. The system is fully static, permits mutually recursive modules, and supports separate compilation. We show that more dynamic module facilities are easily implemented at the source level in the extended language supported by the system.", + "date": "1999-01-01", + "link": "https://doi.org/10.1145/292540.292559", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oscar", + "last_name": "Waddell", + "institution": "University of Kansas" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/popl/WaddellD99", + "venue": "popl", + "year": 1999 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2000.json b/data/pl_conferences/popl/2000.json new file mode 100644 index 0000000..3e0fa32 --- /dev/null +++ b/data/pl_conferences/popl/2000.json @@ -0,0 +1,745 @@ +[ + { + "paper_id": "10.1145/325694.325711", + "title": "Shape Analysis for Mobile Ambients", + "abstract": "The ambient calculus is a calculus of computation that allows active processes to move between sites. We present an analysis inspired by state-of-the-art pointer analyses that safety and accurately predicts which processes may turn up at what sites during the execution of a composite system. The analysis models sets of processes by sets of regular tree grammars enhanced with context-dependent counts, and it obtains its precision by combining a powerful redex materialisation with a strong redex reduction (in the manner of the strong updates performed in pointer analyses). The underlying ideas are flexible and scale up to general tree structures admitting powerful restructuring operations.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325711", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hanne Riis", + "last_name": "Nielson", + "institution": "Aarhus University" + }, + { + "first_name": "Flemming", + "last_name": "Nielson", + "institution": "" + } + ], + "dblp_key": "conf/popl/NielsonN00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325725", + "title": "Type Elaboration and Subtype Completion for Java Bytecode", + "abstract": "Java source code is strongly typed, but the translation from Java source to bytecode omits much of the type information originally contained within methods. Type elaboration is a technique for reconstructing strongly typed programs from incompletely typed bytecode by inferring types for local variables.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325725", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Todd B.", + "last_name": "Knoblock", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/KnoblockR00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325702", + "title": "Transforming Out Timing Leaks", + "abstract": "One aspect of security in mobile code is privacy: private (or secret) data should not be leaked to unauthorised agents. Most of the work on secure information flow has until recently only been concerned with detecting direct and indirect flows. Secret information can however be leaked to the attacker also through covert channels. It is very reasonable to assume that the attacker, even as an external observer, can monitor the timing (including termination) behaviour of the program. Thus to claim a program secure, the security analysis must take also these into account.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325702", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Johan", + "last_name": "Agat", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/Agat00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325710", + "title": "First-Class Macros have Types", + "abstract": "In modern Scheme, a macro captures the lexical environment where it is defined. This creates an opportunity for extending Scheme so that macros are first-class values. The key to achieving this goal, while preserving the ability to compile programs into reasonable code, is the addition of a type system. Many interesting things can be done with first-class macros, including the construction of a useful module system in which modules are also first-class. Clams got legs! — B.C.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325710", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Bawden", + "institution": "" + } + ], + "dblp_key": "conf/popl/Bawden00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325738", + "title": "Analytic Constraint Solving and Interval Arithmetic", + "abstract": "In this paper we describe the syntax, semantics, and implementation of the constraint logic programming language CLP(F) and we prove that the implementation is sound. A CLP(F) constraint is a conjunction of equations and inequations in a first order theory of analytic univariate functions over the reals. The theory allows vector-valued functions over closed intervals to be constrained in several ways, including specifying functional equations (possibly involving the differentiation operator) that must hold at each point in the domain, arithmetic constraints on the value of a function at a particular point in its domain, and bounds on the range of a function over its domain. After describing the syntax and semantics of the constraint language for CLP(F) and giving several examples, we show how to convert these analytic constraints into a subclass of simpler functional constraints which involve neither differentiation nor evaluation of functions. We then present an algorithm for solving these latter constraints and prove that it is sound. This implies the soundness of the CLP(F) interpreter. We also provide some timing results from an implementation of CLP(F) based on GNU Prolog. The current implementation is able to solve a wide variety of analytic constraints, but on particular classes of constraints (such as initial value problems for autonomous ODEs), it is not competitive with other non-constraint based, interval solvers such as Lohner's AWA system. CLP(F) should be viewed as a first step toward the long term goal of developing a practical, declarative, logic-based approach to numerical analysis.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325738", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Timothy J.", + "last_name": "Hickey", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/popl/Hickey00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325716", + "title": "Resource Bound Certification", + "abstract": "Various code certification systems allow the certification and static verification of important safety properties such as memory and control-flow safety. These systems are valuable tools for verifying that untrusted and potentially malicious code is safe before execution. However, one important safety property that is not usually included is that programs adhere to specific bounds on resource consumption, such as running time.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325716", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/CraryW00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325741", + "title": "Controlling Interference in Ambients", + "abstract": "Two forms of interferences are individuated in Cardelli and Gordon's Mobile Ambients (MA): plain interferences, which are similar to the interferences one finds in CCS and φ-calculus; and grave interferences, which are more dangerous and may be regarded as programming errors. To control interferences, the MA movement primitives are modified. On the new calculus, the Mobile Safe Ambients (SA), a type system is defined that: controls the mobility of ambients; removes all grave interferences. Other advantages of SA are: a useful algebraic theory; programs sometimes more robust (they require milder conditions for correctness) and/or simpler. These points are illustrated on several examples.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325741", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Francesca", + "last_name": "Levi", + "institution": "University of Pisa" + }, + { + "first_name": "Davide", + "last_name": "Sangiorgi", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/LeviS00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325700", + "title": "A Framework for Combining Analysis and Verification", + "abstract": "We present a general framework for combining program verification and program analysis. This framework enhances program analysis because it takes advantage of user assertions, and it enhances program verification because assertions can be refined using automatic program analysis. Both enhancements in general produce a better way of reasoning about programs than using verification techniques alone or analysis techniques alone. More importantly, the combination is better than simply running the verification and analysis in isolation and then combining the results at the last step. In other words, our framework explores synergistic interaction between verification and analysis.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325700", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nevin", + "last_name": "Heintze", + "institution": "Nokia (United States)" + }, + { + "first_name": "Joxan", + "last_name": "Jaffar", + "institution": "National University of Singapore" + }, + { + "first_name": "Răzvan", + "last_name": "Voicu", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/popl/HeintzeJV00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325713", + "title": "Semantics-Preserving Procedure Extraction", + "abstract": "Procedure extraction is an important program transformation that can be used to make programs easier to understand and maintain, to facilitate code reuse, and to convert “monolithic” code to modular or object-oriented code. Procedure extraction involves the following steps:", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325713", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Raghavan", + "last_name": "Komondoor", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/KomondoorH00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325709", + "title": "A New Approach to Generic Functional Programming", + "abstract": "This paper describes a new approach to generic functional programming, which allows us to define functions generically for all datatypes expressible in Haskell. A generic function is one that is defined by induction on the structure of types. Typical examples include pretty printers, parsers, and comparison functions. The advanced type system of Haskell presents a real challenge: datatypes may be parameterized not only by types but also by type constructors, type definitions may involve mutual recursion, and recursive calls of type constructors can be arbitrarily nested. We show that—despite this complexity—a generic function is uniquely defined by giving cases for primitive types and type constructors (such as disjoint unions and cartesian products). Given this information a generic function can be specialized to arbitrary Haskell datatypes. The key idea of the approach is to model types by terms of the simply typed λ-calculus augmented by a family of recursion operators. While conceptually simple, our approach places high demands on the type system: it requires polymorphic recursion, rank-n types, and a strong form of type constructor polymorphism. Finally, we point out connections to Haskell's class system and show that our approach generalizes type classes in some respects.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325709", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Bonn" + } + ], + "dblp_key": "conf/popl/Hinze00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325742", + "title": "Anytime, Anywhere: Modal Logics for Mobile Ambients", + "abstract": "The Ambient Calculus is a process calculus where processes may reside within a hierarchy of locations and modify it. The purpose of the calculus is to study mobility, which is seen as the change of spatial configurations over time. In order to describe properties of mobile computations we devise a modal logic that can talk about space as well as time, and that has the Ambient Calculus as a model.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325742", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/CardelliG00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325699", + "title": "Temporal Abstract Interpretation", + "abstract": "We study the abstract interpretation of temporal calculi and logics in a general syntax, semantics and abstraction independent setting. This is applied to the @@@@-calculus, a generalization of the μ-calculus with new reversal and abstraction modalities as well as a new time-symmetric trace-based semantics. The more classical set-based semantics is shown to be an abstract interpretation of the trace-based semantics which leads to the understanding of model-checking and its application to data-flow analysis as incomplete temporal abstract interpretations. Soundness and incompleteness of the abstractions are discussed. The sources of incompleteness, even for finite systems, are pointed out, which leads to the identification of relatively complete sublogics, à la CTL.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325699", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "Laboratoire d'Informatique de l'École Polytechnique" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "École Normale Supérieure" + } + ], + "dblp_key": "conf/popl/CousotC00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325727", + "title": "A Semantic Model of Types and Machine Instructions for Proof-Carrying Code", + "abstract": "Proof-carrying code is a framework for proving the safety of machine-language programs with a machinecheckable proof. Such proofs have previously defined type-checking rules as part of the logic. We show a universal type framework for proof-carrying code that will allow a code producer to choose a programming language, prove the type rules for that language as lemmas in higher-order logic, then use those lemmas to prove the safety of a particular program. We show how to handle traversal, allocation, and initialization of values in a wide variety of types, including functions, records, unions, existentials, and covariant recursive types. 1 Introduction When a host computer runs an untrusted program, the host may want some assurance that the program does no harm: does not access unauthorized resources, read private data, or overwrite valuable data. Proof-carrying code [Nec97] is a technique for providing such assurances. With PCC, the host -- called the &quot;code consumer&quot; -- specifies a sa...", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325727", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "Amy", + "last_name": "Felty", + "institution": "University of Ottawa" + } + ], + "dblp_key": "conf/popl/AppelF00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325734", + "title": "Authentication Primitives and Their Compilation", + "abstract": "Adopting a programming-language perspective, we study the problem of implementing authentication in a distributed system. We define a process calculus with constructs for authentication and show how this calculus can be translated to a lower-level language using marshaling, multiplexing, and cryptographic protocols. Authentication serves for identitybased security in the source language and enables simplifications in the translation. We reason about correctness relying on the concepts of observational equivalence and full abstraction.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325734", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Georges", + "last_name": "Gonthier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/AbadiFG00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325697", + "title": "Efficient Algorithms for pre* and post* on Interprocedural Parallel Flow Graphs", + "abstract": "This paper is a contribution to the already existing series of work on the algorithmic principles of interprocedural analysis. We consider the generalization to the case of parallel programs. We give algorithms that compute the sets of backward resp. forward reachable configurations for parallel flow graph systems in linear time in the size of the graph viz. the program. These operations are important in dataflow analysis and in model checking. In our method, we first model configurations as terms (viz. trees) in the process algebra PA that can express call stack operations and parallelism. We then give a 'declarative' Horn-clause specification of the sets of predecessors resp. successors. The 'operational' computation of these sets is carried out using the Dowling-Gallier procedure for HornSat.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325697", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Javier", + "last_name": "Esparza", + "institution": "Technical University of Munich" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "Max Planck Institute for Informatics" + } + ], + "dblp_key": "conf/popl/EsparzaP00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325736", + "title": "Generalized Certificate Revocation", + "abstract": "We introduce a language for creating and manipulating certificates, that is, digitally signed data based on public key cryptography, and a system for revoking certificates. Our approach provides a uniform mechanism for secure distribution of public key bindings, authorizations, and revocation information. An external language for the description of these and other forms of data is compiled into an intermediate language with a well-defined denotational and operational semantics. The internal language is used to carry out consistency checks for security, and optimizations for efficiency. Our primary contribution is a technique for treating revocation data dually to other sorts of information using a polarity discipline in the intermediate language.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325736", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Carl A.", + "last_name": "Gunter", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Trevor", + "last_name": "Jim", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/popl/GunterJ00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325703", + "title": "Enforcing Trace Properties by Program Transformation", + "abstract": "We propose an automatic method to enforce trace properties on programs. The programmer specifies the property separately from the program; a program transformer takes the program and the property and automatically produces another “equivalent” pogram satisfying the property. This separation of concerns makes the program easier to develop and maintain. Our approach is both static and dynamic. It integrates static analyses in order to avoid useless transformations. On the other hand, it never rejects programs but adds dynamic checks when necessary. An important challenge is to make this dynamic enforcement as inexpensive as possible. The most obvious application domain is the enforcement of security policies. In particular, a potential use of the method is the securization of mobile code upon receipt.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325703", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Colcombet", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Pascal", + "last_name": "Fradet", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/popl/ColcombetF00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325730", + "title": "Paths vs. Trees in Set-Based Program Analysis", + "abstract": "Set-based analysis of logic programs provides an accurate method for descriptive type-checking of logic programs. The key idea of this method is to upper approximate the least model of the program by a regular set of trees. In 1991, Frühwirth, Shapiro, Vardi and Yardeni raised the question whether it can be more efficient to use the domain of sets of paths instead, i.e., to approximate the least model by a regular set of words. We answer the question negatively by showing that type-checking for path-based analysis is as hard as the set-based one, that is DEXPTIME-complete. This result has consequences also in the areas of set constraints, automata theory and model checking.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325730", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Witold", + "last_name": "Charatonik", + "institution": "University of Wrocław" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "Max Planck Society" + }, + { + "first_name": "Jean-Marc", + "last_name": "Talbot", + "institution": "Max Planck Society" + } + ], + "dblp_key": "conf/popl/CharatonikPT00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325731", + "title": "A Debate on Language and Tool Support for Design Patterns", + "abstract": "Design patterns have earned a place in the developer's arsenal of tools and techniques for software development. They have proved so useful, in fact, that some have called for their promotion to programming language features. In turn this has rekindled the age-old debate over the mechanism that belong in programming languages versus those that are better served by tools. The debate comes full circle when one contemplates code generation and methodological tool support for patterns. The authors compare and contrast programming languages, tools, and patterns to assess their relative merits and to clarify their roles in the development process.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325731", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + }, + { + "first_name": "Bill", + "last_name": "Harrison", + "institution": "IBM (United States)" + }, + { + "first_name": "John", + "last_name": "Vlissides", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/ChambersHV00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325707", + "title": "(Optimal) Duplication is not Elementary Recursive", + "abstract": "In 1998 Asperti and Mairson proved that the cost of reducing a lambda-term using an optimal lambda-reducer (a la Lévy) cannot be bound by any elementary function in the number of shared-beta steps. We prove in this paper that an analogous result holds for Lamping’s abstract algorithm. That is, there is no elementary function in the number of shared beta steps bounding the number of duplication steps of the optimal reducer. This theorem vindicates the oracle of Lamping’s algorithm as the culprit for the negative result of Asperti and Mairson. The result is obtained using as a technical tool Elementary Affine Logic. Key words: complexity, elementary affine logic, graph rewriting, optimal reduction", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325707", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Asperti", + "institution": "Zambon (Italy)" + }, + { + "first_name": "Paolo", + "last_name": "Coppola", + "institution": "University of Udine" + }, + { + "first_name": "Simone", + "last_name": "Martini", + "institution": "University of Udine" + } + ], + "dblp_key": "conf/popl/AspertiCM00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325704", + "title": "On the Complexity of Flow-Sensitive Dataflow Analyses", + "abstract": "This paper attempts to address the question of why certain dataflow analysis problems can be solved efficiently, but not others. We focus on flow-sensitive analyses, and give a simple and general result that shows that analyses that require the use of relational attributes for precision must be PSPACE-hard in general. We then show that if the language constructs are slightly strengthened to allow a computation to maintain a very limited summary of what happens along an execution path, inter-procedural analyses become EXPTIME-hard. We discuss applications of our results to a variety of analyses discussed in the literature. Our work elucidates the reasons behind the complexity results given by a number of authors, improves on a number of such complexity results, and exposes conceptual commonalities underlying such results that are not readily apparent otherwise.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325704", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Muth", + "institution": "University of Arizona" + }, + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/MuthD00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325746", + "title": "Modular Refinement of Hierarchic Reactive Machines", + "abstract": "Scalable formal analysis of reactive programs demands integration of modular reasoning techniques with existing analysis tools. Principles such as abstraction, compositional refinement, and assume-guarantee reasoning are well understood for architectural hierarchy that describes the communication structure between component processes, and have been shown to be useful. In this paper, we develop the theory of modular reasoning for behavior hierarchy that describes control structure using hierarchic modes. From STATECHARTS to UML, behavior hierarchy has been an integral component of many software design languages, but only syntactically. We present the hierarchic reactive modules language that retains powerful features such as nested modes, mode reuse, exceptions, group transitions, history, and conjunctive modes, and yet has a semantic notion of mode hierarchy. We present an observational trace semantics for modes that provides the basis for mode refinement. We show the refinement to be compositional with respect to the mode constructors, and develop an assume-guarantee reasoning principle.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325746", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Radu", + "last_name": "Grosu", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/AlurG00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325744", + "title": "Reducing Sweep Time for a Nearly Empty Heap", + "abstract": "Mark and sweep garbage collectors are known for using time proportional to the heap size when sweeping memory, since all objects in the heap, regardless of whether they are live or not, must be visited in order to reclaim the memory occupied by dead objects. This paper introduces a sweeping method which traverses only the live objects, so that sweeping can be done in time dependent only on the number of live objects in the heap.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325744", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yoo", + "last_name": "Chung", + "institution": "Seoul National University" + }, + { + "first_name": "Soo‐Mook", + "last_name": "Moon", + "institution": "Seoul National University" + }, + { + "first_name": "Kemal", + "last_name": "Ebci̇oğlu", + "institution": "" + }, + { + "first_name": "Dan", + "last_name": "Sahlin", + "institution": "Ericsson (Sweden)" + } + ], + "dblp_key": "conf/popl/ChungMES00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325724", + "title": "Deciding Type Equivalence with Singleton Kinds", + "abstract": "Work on the TILT compiler for Standard ML led us to study a language with singleton kinds: S(A) is the kind of all types provably equivalent to the type A. Singletons are interesting because they provide a very general form of definitions for type variables, allow fine-grained control of type computations, and allow many equational constraints to be expressed within the type system.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325724", + "conference_name": "POPL", + "authors": [ + { + "first_name": "C. Addison", + "last_name": "Stone", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/StoneH00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325708", + "title": "Implicit Parameters: Dynamic Scoping with Static Types", + "abstract": "This paper introduces a language feature, called implicit parameters, that provides dynamically scoped variables within a statically-typed Hindley-Milner framework. Implicit parameters are lexically distinct from regular identifiers, and are bound by a special with construct whose scope is dynamic, rather than static as with let. Implicit parameters are treated by the type system as parameters that are not explicitly declared, but are inferred from their use.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325708", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeffrey R.", + "last_name": "Lewis", + "institution": "Oregon Museum of Science and Industry" + }, + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Oregon Museum of Science and Industry" + }, + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "Utrecht University" + }, + { + "first_name": "Mark", + "last_name": "Shields", + "institution": "Oregon Museum of Science and Industry" + } + ], + "dblp_key": "conf/popl/LewisLMS00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325733", + "title": "A Type System for Dynamic Web Documents", + "abstract": "Many interactive Web services use the CGI interface for communication with clients. They will dynamically create HTML documents that are presented to the client who then resumes the interaction by submitting data through incorporated form fields. This protocol is difficult to statically type-check if the dynamic documents are created by arbitrary script code using printf-like statements. Previous proposals have suggested using static document templates which trades flexibility for safety. We propose a notion of typed, higher-order templates that simultaneously achieve flexibility and safety. Our type system is based on a flow analysis of which we prove soundness. We present an efficient runtime implementation that respects the semantics of only well-typed programs. This work is fully implemented as part of the system for defining interactive Web services.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325733", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anders B.", + "last_name": "Sandholm", + "institution": "Aarhus University" + }, + { + "first_name": "Michael I.", + "last_name": "Schwartzbach", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/SandholmS00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325717", + "title": "Type Systems for Distributed Data Structures", + "abstract": "Distributed-memory programs are often written using a global address space: any process can name any memory location on any processor. Some languages completely hide the distinction between local and remote memory, simplifying the programming model at some performance cost. Other languages give the programmer more explicit control, offering better potential performance but sacrificing both soundness and ease of use.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325717", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/LiblitA00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325715", + "title": "Sparse Code Motion", + "abstract": "In this article, we add a third dimension to partial redundancy elimination by considering code size as a further optimization goal in addition to the more classical consideration of computation costs and register pressure. This results in a family of sparse code motion algorithms coming as modular extensions of the algorithms for busy and lazy code motion. Each of them optimally captures a predefined choice of priority between these three optimization goals, e.g. code size can be minimized while (1) guaranteeing at least the performance of the argument program, or (2) even computational optimality. Each of them can further be refined to simultaneously reduce the lifetimes of temporaries to a minimum. These algorithms are well-suited for size-critical application areas like smart cards and embedded systems, as they provide a handle to control the code replication problem of classical code motion techniques. In fact, we believe that our systematic, priority-based treatment of trade-offs between optimization goals may substantially decrease development costs of size-critical applications: users may “play” with the priorities until the algorithm automatically delivers a satisfactory solution.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325715", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oliver", + "last_name": "Rüthing", + "institution": "TU Dortmund University" + }, + { + "first_name": "Jens", + "last_name": "Knoop", + "institution": "TU Dortmund University" + }, + { + "first_name": "Bernhard", + "last_name": "Steffen", + "institution": "TU Dortmund University" + } + ], + "dblp_key": "conf/popl/RuthingKS00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325728", + "title": "A Type System for Expressive Security Policies", + "abstract": "Certified code is a general mechanism for enforcing security properties. In this paradigm, untrusted mobile code carries annotations that allow a host to verify its trustworthiness. Before running the agent, the host checks the annotations and proves that they imply the host's security policy. Despite the flexibility of this scheme, so far, compilers that generate certified code have focused on simple type safety properties rather than more general security properties.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325728", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Walker", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Walker00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325729", + "title": "Verifying Secrets and Relative Secrecy", + "abstract": "Systems that authenticate a user based on a shared secret (such as a password or PIN) normally allow anyone to query whether the secret is a given value. For example, an ATM machine allows one to ask whether a string is the secret PIN of a (lost or stolen) ATM card. Yet such queries are prohibited in any model whose programs satisfy an information-flow property like Noninterference. But there is complexity-based justification for allowing these queries. A type system is given that provides the access control needed to prove that no well-typed program can leak secrets in polynomial time, or even leak them with nonnegligible probability if secrets are of sufficient length and randomly chosen. However, there are well-typed deterministic programs in a synchronous concurrent model capable of leaking secrets in linear time.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325729", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dennis", + "last_name": "Volpano", + "institution": "Naval Postgraduate School" + }, + { + "first_name": "Geoffrey", + "last_name": "Smith", + "institution": "Florida International University" + } + ], + "dblp_key": "conf/popl/VolpanoS00", + "venue": "popl", + "year": 2000 + }, + { + "paper_id": "10.1145/325694.325706", + "title": "Projection Merging: Reducing Redundancies in Inclusion Constraint Graphs", + "abstract": "Inclusion-based program analyses are implemented by adding new edges to directed graphs. In most analyses, there are many different ways to add a transitive edge between two nodes, namely through each different path connecting the nodes. This path redundancy limits the scalability of these analyses. We present projection merging, a technique to reduce path redundancy. Combined with cycle elimination [7], projection merging achieves orders of magnitude speedup of analysis time on programs over that of using cycle elimination alone.", + "date": "2000-01-05", + "link": "https://doi.org/10.1145/325694.325706", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/SuFA00", + "venue": "popl", + "year": 2000 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2001.json b/data/pl_conferences/popl/2001.json new file mode 100644 index 0000000..45322d4 --- /dev/null +++ b/data/pl_conferences/popl/2001.json @@ -0,0 +1,565 @@ +[ + { + "paper_id": "10.1145/360204.360212", + "title": "Efficient deductive methods for program analysis", + "abstract": "No abstract available.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360212", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harald", + "last_name": "Ganzinger", + "institution": "Max Planck Institute for Informatics" + } + ], + "dblp_key": "conf/popl/Ganzinger01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.375719", + "title": "BI as an Assertion Language for Mutable Data Structures", + "abstract": "Reynolds has developed a logic for reasoning about mutable data structures in which the pre- and postconditions are written in an intuitionistic logic enriched with a spatial form of conjunction. We investigate the approach from the point of view of the logic BI of bunched implications of O'Hearnand Pym. We begin by giving a model in which the law of the excluded middleholds, thus showing that the approach is compatible with classical logic. The relationship between the intuitionistic and classical versions of the system is established by a translation, analogous to a translation from intuitionistic logic into the modal logic S4. We also consider the question of completeness of the axioms. BI's spatial implication is used to express weakest preconditions for object-component assignments, and an axiom for allocating a cons cell is shown to be complete under an interpretation of triplesthat allows a command to be applied to states with dangling pointers. We make this latter a feature, by incorporating an operation, and axiom, for disposing of memory. Finally, we describe a local character enjoyed by specifications in the logic, and show how this enables a class of frame axioms, which say what parts of the heap don't change, to be inferred automatically.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.375719", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Samin", + "last_name": "Ishtiaq", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/IshtiaqO01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360219", + "title": "A compiler technique for improving whole-program locality", + "abstract": "Exploiting spatial and temporal locality is essential for obtaining high performance on modern computers. Writing programs that exhibit high locality of reference is difficult and error-prone. Compiler researchers have developed loop transformations that allow the conversion of programs to exploit locality. Recently, transformations that change the memory layouts of multi-dimensional arrays---called data transformations---have been proposed. Unfortunately, both data and loop transformations have some important draw-backs. In this work, we present an integrated framework that uses loop and data transformations in concert to exploit the benefits of both approaches while minimizing the impact of their disadvantages. Our approach works inter-procedurally on acyclic call graphs, uses profile data to eliminate layout conflicts, and is unique in its capability of resolving conflicting layout requirements of different references to the same array in the same nest and in different nests for regular array-based applications.The optimization technique presented in this paper has been implemented in a source-to-source translator. We evaluate its performance using standard benchmark suites and several math libraries (complete programs) with large input sizes. Experimental results show that our approach reduces the overall execution times of original codes by 17.5% on the average. This reduction comes from three important characteristics of the technique, namely, resolving layout conflicts between references to the same array in a loop nest, determining a suitable order to propagate layout modifications across loop nests, and propagating layouts between different procedures in the program --- all in a unified framework.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360219", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/Kandemir01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360221", + "title": "What packets may come: automata for network monitoring", + "abstract": "We consider the problem of monitoring an interactive device, such as an implementation of a network protocol, in order to check whether its execution is consistent with its specification. At rst glance, it appears that a monitor could simply follow the input-output trace of the device and check it against the specification. However, if the monitor is able to observe inputs and outputs only from a vantage point external to the device---as is typically the case---the problem becomes surprisingly difficult. This is because events may be bu ered, and even lost, between the monitor and the device, in which case, even for a correctly running device, the trace observed at the monitor could be inconsistent with the specification.In this paper, we formulate the problem of external monitoring as a language recognition problem. Given a specification that accepts a certain language of input-output sequences, we de ne another language that corresponds to input-output sequences observable externally. We also give an algorithm to check membership of a string in the derived language. It turns out that without any assumptions on the specification, this algorithm may take unbounded time and space. To address this problem, we de ne a series of properties of device specifications or protocols that can be exploited to construct e cient language recognizers at the monitor. We characterize these properties and provide complexity bounds for monitoring in each case.To illustrate our methodology, we describe properties of the Internet Transmission Control Protocol (TCP), and identify features of the protocol that make it challenging to monitor e ciently.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360221", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karthikeyan", + "last_name": "Bhargavan", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "Bell (Canada)" + }, + { + "first_name": "Peter J.", + "last_name": "McCann", + "institution": "Nokia (United States)" + }, + { + "first_name": "Carl A.", + "last_name": "Gunter", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/BhargavanCMG01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360216", + "title": "Oracle-based checking of untrusted software", + "abstract": "We present a variant of Proof-Carrying Code (PCC) in which the trusted inference rules are represented as a higherorder logic program, the proof checker is replaced by a nondeterministic higher-order logic interpreter and the proof by an oracle implemented as a stream of bits that resolve the nondeterministic interpretation choices. In this setting, Proof-Carrying Code allows the receiver of the code the luxury of using nondeterminism in constructing a simple yet powerful checking procedure. This oracle-based variant of PCC is able to adapt quite naturally to situations when the property being checked is simple or there is a fairly directed search procedure for it. As an example, we demonstrate that if PCC is used to verify type safety of assembly language programs compiled from Java source programs, the oracles that are needed are on the average just 12% of the size of the code, which represents an improvement of a factor of 30 over previous syntactic representations of PCC proofs. ...", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360216", + "conference_name": "POPL", + "authors": [ + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + }, + { + "first_name": "S. P.", + "last_name": "Rahul", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/NeculaR01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360210", + "title": "The size-change principle for program termination", + "abstract": "The \"size-change termination\" principle for a first-order functional language with well-founded data is: a program terminates on all inputs if every infinite call sequence (following program control flow) would cause an infinite descent in some data values.Size-change analysis is based only on local approximations to parameter size changes derivable from program syntax. The set of infinite call sequences that follow program flow and can be recognized as causing infinite descent is an ω-regular set, representable by a Büchi automaton. Algorithms for such automata can be used to decide size-change termination. We also give a direct algorithm operating on \"size-change graphs\" (without the passage to automata).Compared to other results in the literature, termination analysis based on the size-change principle is surprisingly simple and general: lexical orders (also called lexicographic orders), indirect function calls and permuted arguments (descent that is not in-situ) are all handled automatically and without special treatment, with no need for manually supplied argument orders, or theorem-proving methods not certain to terminate at analysis time.We establish the problem's intrinsic complexity. This turns out to be surprisingly high, complete for PSPACE, in spite of the simplicity of the principle. PSPACE hardness is proved by a reduction from Boolean program termination. An ineresting consequence: the same hardness result applies to many other analyses found in the termination and quasitermination literature.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360210", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chin Soon", + "last_name": "Lee", + "institution": "University of Western Australia" + }, + { + "first_name": "Neil D.", + "last_name": "Jones", + "institution": "University of Copenhagen" + }, + { + "first_name": "Amir M.", + "last_name": "Ben-Amram", + "institution": "Academic College of Tel Aviv-Yafo" + } + ], + "dblp_key": "conf/popl/LeeJB01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360220", + "title": "Avoiding exponential explosion: generating compact verification conditions", + "abstract": "Current verification condition (VC) generation algorithms, such as weakest preconditions, yield a VC whose size may be exponential in the size of the code fragment being checked. This paper describes a two-stage VC generation algorithm that generates compact VCs whose size is worst-case quadratic in the size of the source fragment, and is close to linear in practice.This two-stage VC generation algorithm has been implemented as part of the Extended Static Checker for Java. It has allowed us to check large and complex methods that would otherwise be impossible to check due to time and space constraints.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360220", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "" + }, + { + "first_name": "James B.", + "last_name": "Saxe", + "institution": "" + } + ], + "dblp_key": "conf/popl/FlanaganS01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360215", + "title": "A generic type system for the Pi-calculus", + "abstract": "We propose a general, powerful framework of type systems for the π-calculus, and show that we can obtain as its instances a variety of type systems guaranteeing non-trivial properties like deadlock-freedom and race-freedom. A key idea is to express types and type environments as abstract processes: We can check various properties of a process by checking the corresponding properties of its type environment. The framework clarifies the essence of recent complex type systems, and it also enables sharing of a large amount of work such as a proof of type preservation, making it easy to develop new type systems.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360215", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "Tokyo University of Information Sciences" + } + ], + "dblp_key": "conf/popl/IgarashiK01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360209", + "title": "Regular expression pattern matching for XML", + "abstract": "We propose regular expression pattern matching as a core feature for programming languages for manipulating XML (and similar tree-structured data formats). We extend conventional pattern-matching facilities with regular expression operators such as repetition (*), alternation (I), etc., that can match arbitrarily long sequences of subtrees, allowing a compact pattern to extract data from the middle of a complex sequence. We show how to check standard notions of exhaustiveness and redundancy for these patterns.Regular expression patterns are intended to be used in languages whose type systems are also based on the regular expression types. To avoid excessive type annotations, we develop a type inference scheme that propagates type constraints to pattern variables from the surrounding context. The type inference algorithm translates types and patterns into regular tree automata and then works in terms of standard closure operations (union, intersection, and difference) on tree automata. The main technical challenge is dealing with the interaction of repetition and alternation patterns with the first-match policy, which gives rise to subtleties concerning both the termination and the precision of the analysis. We address these issues by introducing a data structure representing closure operations lazily.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360209", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Haruo", + "last_name": "Hosoya", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/HosoyaP01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360232", + "title": "Subtyping arithmetical types", + "abstract": "We consider the type system formed by a finite set of primitive types such as integer, character, real, etc., and three type construction operators: (i) Cartesian product, (ii) disjoint sum, and (iii) recursive type definitions. Type equivalence is defined to obey the arithmetical rules: commutativity and associativity of product and sum and distributivity of product over sum. We offer a compact representation of the types in this system as multivariate algebraic functions. This type system admits two natural notions of subtyping: \"multiplicative\", which roughly corresponds to the notion of object-oriented subtyping, and \"additive\", which seems to be more appropriate in our context. Both kinds of subtyping can be efficiently computed if no recursive definitions are allowed. Our main result is that additive subtyping is undecidable in the general case. Perhaps surprisingly, this undecidability result is by reduction from Hilbert's Tenth Problem (HIO): the solution of Diophantine equations.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360232", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/Gil01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360223", + "title": "Secure safe ambients", + "abstract": "Secure Safe Ambients (SSA) are a typed variant of Safe Ambients [9], whose type system allows behavioral invariants of ambients to be expressed and verified. The most significant aspect of the type system is its ability to capture both explicit and implicit process and ambient behavior: process types account not only for immediate behavior, but also for the behavior resulting from capabilities a process acquires during its evolution in a given context. Based on that, the type system provides for static detection of security attacks such as Trojan Horses and other combinations of malicious agents.We study the type system of SSA, define algorithms for type checking and type reconstruction, define powerful languages for expressing security properties, and study a distributed version of SSA and its type system. For the latter, we show that distributed type checking ensures security even in ill-typed contexts, and discuss how it relates to the security architecture of the Java Virtual Machine.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360223", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michele", + "last_name": "Bugliesi", + "institution": "Ca' Foscari University of Venice" + }, + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "École Normale Supérieure" + } + ], + "dblp_key": "conf/popl/BugliesiC01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360222", + "title": "Computational flux", + "abstract": "No abstract available.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360222", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robin", + "last_name": "Milner", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/Milner01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360228", + "title": "Typing a multi-language intermediate code", + "abstract": "The Microsoft .NET Framework is a new computing architecture designed to support a variety of distributed applications and web-based services. .NET software components are typically distributed in an object-oriented intermediate language, Microsoft IL, executed by the Microsoft Common Language Runtime. To allow convenient multi-language working, IL supports a wide variety of high-level language constructs, including class-based objects, inheritance, garbage collection, and a security mechanism based on type safe execution.This paper precisely describes the type system for a substantial fragment of IL that includes several novel features: certain objects may be allocated either on the heap or on the stack; those on the stack may be boxed onto the heap, and those on the heap may be unboxed onto the stack; methods may receive arguments and return results via typed pointers, which can reference both the stack and the heap, including the interiors of objects on the heap. We present a formal semantics for the fragment. Our typing rules determine well-typed IL instruction sequences that can be assembled and executed. Of particular interest are rules to ensure no pointer into the stack outlives its target. Our main theorem asserts type safety, that well-typed programs in our IL fragment do not lead to untrapped execution errors.Our main theorem does not directly apply to the product. Still, the formal system of this paper is an abstraction of informal and executable specifications we wrote for the full product during its development. Our informal specification became the basis of the product team's working specification of type-checking. The process of writing this specification, deploying the executable specification as a test oracle, and applying theorem proving techniques, helped us identify several security critical bugs during development.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360228", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Don", + "last_name": "Syme", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/GordonS01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360208", + "title": "Type-base flow analysis: from polymorphic subtyping to CFL-reachability", + "abstract": "We present a novel approach to scalable implementation of type-based flow analysis with polymorphic subtyping. Using a new presentation of polymorphic subytping with instantiation constraints, we are able to apply context-free language (CFL) reachability techniques to type-based flow analysis. We develop a CFL-based algorithm for computing flow-information in time O(n³), where n is the size of the typed program. The algorithm substantially improves upon the best previously known algorithm for flow analysis based on polymorphic subtyping with complexity O(n8). Our technique also yields the first demand-driven algorithm for polymorphic subtype-based flow-computation. It works directly on higher-order programs with structured data of finite type (unbounded data structures are incorporated via finite approximations), supports context-sensitive, global flow summariztion and includes polymorphic recursion.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360208", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/RehofF01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360213", + "title": "Mobile values, new names, and secure communication", + "abstract": "We study the interaction of the \"new\" construct with a rich but common form of (first-order) communication. This interaction is crucial in security protocols, which are the main motivating examples for our work; it also appears in other programming-language contexts. Specifically, we introduce a simple, general extension of the pi calculus with value passing, primitive functions, and equations among terms. We develop semantics and proof techniques for this extended language and apply them in reasoning about some security protocols.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360213", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/AbadiF01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360217", + "title": "Stratified operational semantics for safety and correctness of the region calculus", + "abstract": "The region analysis of Tofte and Talpin is an attempt to determine statically the life span of dynamically allocated objects. But the calculus is at once intuitively simple, yet deceptively subtle, and previous theoretical analyses have been frustratingly complex: no analysis has revealed and explained in simple terms the connection between the subleties of the calculus and the imperative features it builds on. We present a novel approach for proving safety and correctness of a simplified version of the region calculus. We give a stratified operational semantics, composed of a highlevel semantics dealing with the conceptual difficulties of effect annotations, and a low-level one with explicit operations on a region-indexed store. The main results of the paper are a proof simpler than previous ones, and a modular approach to type safety and correctness. The flexibility of this approach is demonstrated by the simplicity of the extension to the full calculus with type and region polymorphism.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360217", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/Calcagno01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360230", + "title": "Type-indexed rows", + "abstract": "Record calculi use labels to distinguish between the elements of products and sums. This paper presents a novel variation, type-indexed rows, in which labels are discarded and elements are indexed by their type alone. The calculus, λTIR, can express tuples, recursive datatypes, monomorphic records, polymorphic extensible records, and closed-world style type-based overloading. Our motivating application of λTIR, however, is to encode the \"choice\" types of XML, and the \"unordered tuple\" types of SGML. Indeed, λTIR is the kernel of the language XMλ, a lazy functional language with direct support for XML types (\"DTDs\") and terms (\"documents\").The system is built from rows, equality constraints, insertion constraints and constrained, or qualified, parametric polymorphism. The test for constraint satisfaction is complete, and for constraint entailment is only mildly incomplete. We present a type checking algorithm, and show how λTIR may be implemented by a type-directed translation which replaces type-indexing by conventional natural-number indexing. Though not presented in this paper, we have also developed a constraint simplification algorithm and type inference system.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360230", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark", + "last_name": "Shields", + "institution": "Oregon Research Institute" + }, + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/popl/ShieldsM01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360205", + "title": "Programming language methods in computer security", + "abstract": "This invited talk will give a personal view of the field of computer security and summarize some ways that methods from the study of programming language principles can be applied to problems in computer security. Some background information is provided here in this short document.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360205", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Mitchell01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360233", + "title": "Combining subsumption and binary methods: an object calculus with views", + "abstract": "We presen t an object-oriented calculus whic hallows arbitrary hiding of methods in protot ypes, even in the presence of binary methods and friend functions. This combination of features permits complete control of the in terface a class exposes to the remainder of a program (which is of key importance for program readability, security and ease of maintenance), while still allowing complex in teractions with other classes belonging to the same module or softw are component.This result is made possible by the use of views. A view is a name that specifies an in terface to an object. A set of views is attached to each object and a method can be invoked either directly or via a view of the object.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360233", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jérôme", + "last_name": "Vouillon", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/Vouillon01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360225", + "title": "Modules, abstract types, and distributed versioning", + "abstract": "In a wide-area distributed system it is often impractical to synchronise software updates, so one must deal with many coexisting versions. We study static typing support for modular wide-area programming, modelling separate compilation/linking and execution of programs that interact along typed channels. Interaction may involve communication of values of abstract types; we provide the developer with fine-grain versioning control of these types to support interoperation of old and new code. The system makes use of a second-class module system with singleton kinds; we give a novel operational semantics for separate compilation/linking and execution and prove soundness.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360225", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/Sewell01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360206", + "title": "Verifying safety properties of concurrent Java programs using 3-valued logic", + "abstract": "We provide a parametric framework for verifying safety properties of concurrent Java programs. The framework combines thread-scheduling information with information about the shape of the heap. This leads to error-detection algorithms that are more precise than existing techniques. The framework also provides the most precise shape-analysis algorithm for concurrent programs. In contrast to existing verification techniques, we do not put a bound on the number of allocated objects. The framework even produces interesting results when analyzing Java programs with an unbounded number of threads. The framework is applied to successfully verify the following properties of a concurrent program: •Concurrent manipulation of linked-list based ADT preserves the ADT datatype invariant [19]. •The program does not perform inconsistent updates due to interference. •The program does not reach a deadlock. •The program does not produce run-time errors due to illegal thread interactions. We also find bugs in erroneous versions of such implementations. A prototype of our framework has been implemented.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360206", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/Yahav01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360207", + "title": "Colored local type inference", + "abstract": "We present a type system for a language based on $F_\\\\leq$ , which allows certain type annotations to be elided in actual programs. Local type inference determines types by a combination of type propagation and local constraint solving, rather than by global constraint solving. We refine the previously existing local type inference system of Pierce and Turner[PT98] by allowing partial type information to be propagated. This is expressed by coloring types to indicate propagation directions. Propagating partial type information allows us to omit type annotations for the visitor pattern, the analogue of pattern matching in languages without sum types.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360207", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Christoph", + "last_name": "Zenger", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Matthias", + "last_name": "Zenger", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/OderskyZZ01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360218", + "title": "Type-preserving garbage collectors", + "abstract": "By combining existing type systems with standard type-based compilation techniques, we describe how to write strongly typed programs that include a function that acts as a t racing garbage collector for the program. Since the garbage collector is an explicit function, we do not need to provide a t rusted garbage collector as a runtime service to manage memory.Since our language is strongly typed, the standard type soundness guarantee \"Well typed programs do not go wrong\" is extended to include the collector. Our type safety guarantee is non-trivial since not only does it guarantee the type safety of the garbage collector, but it guarantees that the collector preservers the type safety of the program being garbage collected. We describe the technique in detail and report performance measurements for a few microbench-marks as well as sketch the proofs of type soundness for our system.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360218", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel C.", + "last_name": "Wang", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/WangA01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360214", + "title": "Nomadic pict: correct communication infrastructure for mobile computation", + "abstract": "This paper addresses the design and verification of infrastructure for mobile computation. In particular, we study language primitives for communication between mobile agents. They can be classi ed into two groups. At a low level there are location dependent primitives that require a programmer to know the current site of a mobile agent in order to communicate with it. At a high level there are location independent primitives that allow communication with a mobile agent irrespective of any migrations. Implementation of the high level requires delicate distributed infrastructure algorithms. In earlier work with Wojciechowski and Pierce we made the two levels precise as process calculi, allowing such algorithms to be expressed as encodings of the high level into the low level; we built NOMADIC PICT, a distributed programming language for experimenting with such encodings. In this paper we turn to semantics, giving a de nition of the core language and proving correctness of an example infrastructure. This requires novel techniques: we develop equivalences that take migration into account, and reasoning principles for agents that are temporarily immobile (eg. waiting on a lock elsewhere in the system).", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360214", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Asis", + "last_name": "Unyapoth", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/UnyapothS01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.375707", + "title": "Extensionality and Intensionality of the Ambient Logics", + "abstract": "The ambient logic has been proposed for expressing properties of process mobility in the calculus of Mobile Ambients (MA), and as a basis for query languages on semistructured data. To understand the extensionality and the intensionality of the logic, the equivalence on MA processes induced by the logic (=L) iscompared with the standard MA behavioural equivalence and with structural congruence (an intensional equivalence, used as an auxiliary relation in thedefinition of satisfaction of the logic). The main contributions include a co-inductive characterisation of <=L as a form of labelled bisimilarity, and axiomatisations of <=L on the synchronous and asynchronous (finite) calculus. The study shows that, surprisingly, the logic allows us to observe the internal structure of the processes at a very finegrained detail, much in the same way as structural congruence does. A spin-off of the study is a better understanding of behavioural equivalence in Ambient-like calculi. For instance, behavioural equivalence is shown to be insensitive to stuttering phenomena originated by processes that may repeatedly enter and exit an ambient.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.375707", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Davide", + "last_name": "Sangiorgi", + "institution": "" + } + ], + "dblp_key": "conf/popl/Sangiorgi01", + "venue": "popl", + "year": 2001 + }, + { + "paper_id": "10.1145/360204.360211", + "title": "An abstract Monte-Carlo method for the analysis of probabilistic programs", + "abstract": "We introduce a new method, combination of random testing and abstract interpretation, for the analysis of programs featuring both probabilistic and non-probabilistic nondeterminism. After introducing \"ordinary\" testing, we show how to combine testing and abstract interpretation and give formulas linking the precision of the results to the number of iterations. We then discuss complexity and optimization issues and end with some experimental results.", + "date": "2001-01-01", + "link": "https://doi.org/10.1145/360204.360211", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Monniaux", + "institution": "École Normale Supérieure - PSL" + } + ], + "dblp_key": "conf/popl/Monniaux01", + "venue": "popl", + "year": 2001 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2002.json b/data/pl_conferences/popl/2002.json new file mode 100644 index 0000000..9f9f1ec --- /dev/null +++ b/data/pl_conferences/popl/2002.json @@ -0,0 +1,754 @@ +[ + { + "paper_id": "10.1145/503272.503290", + "title": "Systematic design of program transformation frameworks by abstract interpretation", + "abstract": "We introduce a general uniform language-independent framework for designing online and offline source-to-source program transformations by abstract interpretation of program semantics. Iterative source-to-source program transformations are designed constructively by composition of source-to-semantics, semantics-to-transformed semantics and semantics-to-source abstractions applied to fixpoint trace semantics. The correctness of the transformations is expressed through observational and performance abstractions. The framework is illustrated on three examples: constant propagation, program specialization by online and offline partial evaluation and static program monitoring.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503290", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "École Polytechnique" + } + ], + "dblp_key": "conf/popl/CousotC02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503276", + "title": "Role analysis", + "abstract": "We present a new role system in which the type (or role) of each object depends on its referencing relationships with other objects, with the role changing as these relationships change. Roles capture important object and data structure properties and provide useful information about how the actions of the program interact with these properties. Our role system enables the programmer to specify the legal aliasing relationships that define the set of roles that objects may play, the roles of procedure parameters and object fields, and the role changes that procedures perform while manipulating objects. We present an interprocedural, compositional, and context-sensitive role analysis algorithm that verifies that a program maintains role constraints.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503276", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Patrick", + "last_name": "Lam", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/KuncakLR02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503299", + "title": "Proving correctness of compiler optimizations by temporal logic", + "abstract": "Many classical compiler optimizations can be elegantly expressed using rewrite rules of form: I ⇒ I′ if φ, where I, I′ are intermediate language instructions and φ is a property expressed in a temporal logic suitable for describing program data flow. Its reading: If the current program π contains an instruction of form I at some control point p, and if flow condition φ is satisfied at p, then replace I by I′. The purpose of this paper is to show how such transformations may be proven correct. Our methodology is illustrated by three familiar optimizations, dead code elimination, constant folding and code motion. The meaning of correctness is that for any program π, if Rewrite(π, π′, p, I ⇒ I′ if φ) then [π] = [π′], i.e. π and π′ have exactly the same semantics.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503299", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Lacey", + "institution": "University of Oxford" + }, + { + "first_name": "Neil D.", + "last_name": "Jones", + "institution": "University of Copenhagen" + }, + { + "first_name": "Eric Van", + "last_name": "Wyk", + "institution": "University of Oxford" + }, + { + "first_name": "Carl Christian", + "last_name": "Frederiksen", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/popl/LaceyJWF02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503297", + "title": "The strength of non-size increasing computation", + "abstract": "We study the expressive power of non-size increasing recursive definitions over lists. This notion of computation is such that the size of all intermediate results will automatically be bounded by the size of the input so that the interpretation in a finite model is sound with respect to the standard semantics. Many well-known algorithms with this property such as the usual sorting algorithms are definable in the system in the natural way. The main result is that a characteristic function is definable if and only if it is computable in time O(2p(n)) for some polynomial p.The method used to establish the lower bound on the expressive power also shows that the complexity becomes polynomial time if we allow primitive recursion only. This settles an open question posed in [1, 7].The key tool for establishing upper bounds on the complexity of derivable functions is an interpretation in a finite relational model whose correctness with respect to the standard interpretation is shown using a semantic technique.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503297", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Hofmann", + "institution": "Ludwig-Maximilians-Universität München" + } + ], + "dblp_key": "conf/popl/Hofmann02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503296", + "title": "Adaptive functional programming", + "abstract": "An adaptive computation maintains the relationship between its input and output as the input changes. Although various techniques for adaptive computing have been proposed, they remain limited in their scope of applicability. We propose a general mechanism for adaptive computing that enables one to make any purely-functional program adaptive.We show that the mechanism is practical by giving an efficient implementation as a small ML library. The library consists of three operations for making a program adaptive, plus two operations for making changes to the input and adapting the output to these changes. We give a general bound on the time it takes to adapt the output, and based on this, show that an adaptive Quicksort adapts its output in logarithmic time when its input is extended by one key.To show the safety and correctness of the mechanism we give a formal definition of AFL, a call-by-value functional language extended with adaptivity primitives. The modal type system of AFL enforces correct usage of the adaptivity mechanism, which can only be checked at run time in the ML library. Based on the AFL dynamic semantics, we formalize the change-propagation algorithm and prove its correctness.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503296", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/AcarBH02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503279", + "title": "Lazy abstraction", + "abstract": "One approach to model checking software is based on the abstract-check-refine paradigm: build an abstract model, then check the desired property, and if the check fails, refine the model and start over. We introduce the concept of lazy abstraction to integrate and optimize the three phases of the abstract-check-refine loop. Lazy abstraction continuously builds and refines a single abstract model on demand, driven by the model checker, so that different parts of the model may exhibit different degrees of precision, namely just enough to verify the desired property. We present an algorithm for model checking safety properties using lazy abstraction and describe an implementation of the algorithm applied to C programs. We also provide sufficient conditions for the termination of the method.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503279", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Grégoire", + "last_name": "Sutre", + "institution": "Université de Bordeaux" + } + ], + "dblp_key": "conf/popl/HenzingerJMS02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503285", + "title": "From POPL to the classroom and back", + "abstract": "This invited talk presents an overview of the TeachScheme! and DrScheme projects. The former aims at bringing the principles of programming and programming languages into the introductory programming curriculum. The latter is a program development environment that supports the pedagogy and design principles of the TeachScheme! project. Carrying out these projects enriched our research life with many interesting programming language and system design problems.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503285", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/Felleisen02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503281", + "title": "A uniform type structure for secure information flow", + "abstract": "The π-calculus is a formalism of computing in which we can compositionally represent dynamics of major programming constructs by decomposing them into a single communication primitive, the name passing. This work reports our experience in using a linear/affine typed π-calculus for the analysis and development of type systems of programming languages, focussing on secure information flow analysis. After presenting a basic typed calculus for secrecy, we demonstrate its usage by a sound embedding of the dependency core calculus (DCC) and by the development of a novel type discipline for imperative programs which extends both a secure multi-threaded imperative language by Smith and Volpano and (a call-by-value version of) DCC. In each case, the embedding gives a simple proof of noninterference.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503281", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kohei", + "last_name": "Honda", + "institution": "University of London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "University of Leicester" + } + ], + "dblp_key": "conf/popl/HondaY02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503286", + "title": "CCured: type-safe retrofitting of legacy code", + "abstract": "In this paper we propose a scheme that combines type inference and run-time checking to make existing C programs type safe. We describe the CCured type system, which extends that of C by separating pointer types according to their usage. This type system allows both pointers whose usage can be verified statically to be type safe, and pointers whose safety must be checked at run time. We prove a type soundness result and then we present a surprisingly simple type inference algorithm that is able to infer the appropriate pointer kinds for existing C programs.Our experience with the CCured system shows that the inference is very effective for many C programs, as it is able to infer that most or all of the pointers are statically verifiable to be type safe. The remaining pointers are instrumented with efficient run-time checks to ensure that they are used safely. The resulting performance loss due to run-time checks is 0-150%, which is several times better than comparable approaches that use only dynamic checking. Using CCured we have discovered programming bugs in established C programs such as several SPECINT95 benchmarks.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503286", + "conference_name": "POPL", + "authors": [ + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Scott", + "last_name": "McPeak", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Westley", + "last_name": "Weimer", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/NeculaMW02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503282", + "title": "Bounding space usage of conservative garbage collectors", + "abstract": "Conservative garbage collectors can automatically reclaim unused memory in the absence of precise pointer location information. If a location can possibly contain a pointer, it is treated by the collector as though it contained a pointer. Although it is commonly assumed that this can lead to unbounded space use due to misidentified pointers, such extreme space use is rarely observed in practice, and then generally only if the number of misidentified pointers is itself unbounded.We show that if the program manipulates only data structures satisfying a simple GC-robustness criterion, then a bounded number of misidentified pointers can at most result in increasing space usage by a constant factor. We argue that nearly all common data structures are already GC-robust, and it is typically easy to identify and replace those that are not. Thus it becomes feasible to prove space bounds on programs collected by mildly conservative garbage collectors, such as the one in [2]. The worst-case space overhead introduced by such mild conservatism is comparable to the worst-case fragmentation overhead for inherent in any non-moving storage allocator.The same GC-robustness criterion also ensures the absence of temporary space leaks of the kind discussed in [13] for generational garbage collectors.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503282", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/popl/Boehm02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503274", + "title": "The SLAM project: debugging system software via static analysis", + "abstract": "The goal of the SLAM project is to check whether or not a program obeys \"API usage rules\" that specify what it means to be a good client of an API. The SLAM toolkit statically analyzes a C program to determine whether or not it violates given usage rules. The toolkit has two unique aspects: it does not require the programmer to annotate the source program (invariants are inferred); it minimizes noise (false error messages) through a process known as \"counterexample-driven refinement\". SLAM exploits and extends results from program analysis, model checking and automated deduction. We have successfully applied the SLAM toolkit to Windows XP device drivers, to both validate behavior and find defects in their usage of kernel APIs.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503274", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/BallR02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503275", + "title": "Mining specifications", + "abstract": "Program verification is a promising approach to improving program quality, because it can search all possible program executions for specific errors. However, the need to formally describe correct behavior or errors is a major barrier to the widespread adoption of program verification, since programmers historically have been reluctant to write formal specifications. Automating the process of formulating specifications would remove a barrier to program verification and enhance its practicality.This paper describes specification mining, a machine learning approach to discovering formal specifications of the protocols that code must obey when interacting with an application program interface or abstract data type. Starting from the assumption that a working program is well enough debugged to reveal strong hints of correct protocols, our tool infers a specification by observing program execution and concisely summarizing the frequent interaction patterns as state machines that capture both temporal and data dependences. These state machines can be examined by a programmer, to refine the specification and identify errors, and can be utilized by automatic verification tools, to find bugs.Our preliminary experience with the mining tool has been promising. We were able to learn specifications that not only captured the correct protocol, but also discovered serious bugs.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503275", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Glenn", + "last_name": "Ammons", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/AmmonsBL02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503277", + "title": "Analyzing security protocols with secrecy types and logic programs", + "abstract": "We study and further develop two language-based techniques for analyzing security protocols. One is based on a typed process calculus; the other, on untyped logic programs. Both focus on secrecy properties. We contribute to these two techniques, in particular by extending the former with a flexible, generic treatment of many cryptographic operations. We also establish an equivalence between the two techniques.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503277", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Bruno", + "last_name": "Blanchet", + "institution": "École Normale Supérieure" + } + ], + "dblp_key": "conf/popl/AbadiB02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503291", + "title": "Predicate abstraction for software verification", + "abstract": "Software verification is an important and difficult problem. Many static checking techniques for software require annotations from the programmer in the form of method specifications and loop invariants. This annotation overhead, particularly of loop invariants, is a significant hurdle in the acceptance of static checking. We reduce the annotation burden by inferring loop invariants automatically.Our method is based on predicate abstraction, an abstract interpretation technique in which the abstract domain is constructed from a given set of predicates over program variables. A novel feature of our approach is that it infers universally-quantified loop invariants, which are crucial for verifying programs that manipulate unbounded data such as arrays. We present heuristics for generating appropriate predicates for each loop automatically; the programmer can specify additional predicates as well. We also present an efficient algorithm for computing the abstraction of a set of states in terms of a collection of predicates.Experiments on a 44KLOC program show that our approach can automatically infer the necessary predicates and invariants for all but 31 of the 396 routines that contain loops.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503291", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "" + } + ], + "dblp_key": "conf/popl/FlanaganQ02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503280", + "title": "Bisimulation congruences in safe ambients", + "abstract": "We study a variant of Levi and Sangiorgi&apos;s Safe Ambients (SA) enriched with passwords (SAP). In SAP by managing passwords, for example generating new ones and distributing them selectively, an ambient may now program who may migrate into its computation space, and when. Moreover in SAP an ambient may provide different services depending on the passwords exhibited by its incoming clients. We give an lts based operational semantics for SAP and a labelled bisimulation based equivalence which is proved to coincide with barbed congruence. Our notion of bisimulation is used to prove a set of algebraic laws which are subsequently exploited to prove more significant examples. 1", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503280", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Massimo", + "last_name": "Merro", + "institution": "University of Sussex" + }, + { + "first_name": "Matthew", + "last_name": "Hennessy", + "institution": "University of Sussex" + } + ], + "dblp_key": "conf/popl/MerroH02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503289", + "title": "Representation independence, confinement and access control [extended abstract]", + "abstract": "Denotational semantics is given for a Java-like language with pointers, subclassing and dynamic dispatch, class oriented visibility control, recursive types and methods, and privilege-based access control. Representation independence (relational parametricity) is proved, using a semantic notion of confinement similar to ones for which static disciplines have been recently proposed.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503289", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "Kansas State University" + }, + { + "first_name": "David A.", + "last_name": "Naumann", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "conf/popl/BanerjeeN02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503298", + "title": "Composing dataflow analyses and transformations", + "abstract": "Dataflow analyses can have mutually beneficial interactions. Previous efforts to exploit these interactions have either (1) iteratively performed each individual analysis until no further improvements are discovered or (2) developed \"super-analyses\" that manually combine conceptually separate analyses. We have devised a new approach that allows analyses to be defined independently while still enabling them to be combined automatically and profitably. Our approach avoids the loss of precision associated with iterating individual analyses and the implementation difficulties of manually writing a super-analysis. The key to our approach is a novel method of implicit communication between the individual components of a super-analysis based on graph transformations. In this paper, we precisely define our approach; we demonstrate that it is sound and it terminates; finally we give experimental results showing that in practice (1) our framework produces results at least as precise as iterating the individual analyses while compiling at least 5 times faster, and (2) our framework achieves the same precision as a manually written super-analysis while incurring a compile-time overhead of less than 20%.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503298", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Grove", + "institution": "IBM (United States)" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/LernerGC02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503278", + "title": "Types as models: model checking message-passing programs", + "abstract": "Abstraction and composition are the fundamental issues in making model checking viable for software. This paper proposes new techniques for automating abstraction and decomposition using source level type information provided by the programmer. Our system includes two novel components to achieve this end: (1) a behavioral type-and-effect system for the π-calculus, which extracts sound models as types, and (2) an assume-guarantee proof rule for carrying out compositional model checking on the types. Open simulation between CCS processes is used as both the subtyping relation in the type system and the abstraction relation for compositional model checking.We have implemented these ideas in a tool---PIPER. PIPER exploits type signatures provided by the programmer to partition the model checking problem, and emit model checking obligations that are discharged using the SPIN model checker. We present the details on applying PIPER on two examples: (1) the SIS standard for managing trouble tickets across multiple organizations and (2) a file reader from the pipelined implementation of a web server.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503278", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sagar", + "last_name": "Chaki", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/ChakiRR02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503301", + "title": "Stack inspection: theory and variants", + "abstract": "Stack inspection is a security mechanism implemented in runtimes such as the JVM and the CLR to accommodate components with diverse levels of trust. Although stack inspection enables the fine-grained expression of access control policies, it has rather a complex and subtle semantics. We present a formal semantics and an equational theory to explain how stack inspection affects program behaviour and code optimisations. We discuss the security properties enforced by stack inspection, and also consider variants with stronger, simpler properties.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503301", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/FournetG02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503294", + "title": "Functional logic overloading", + "abstract": "Functional logic overloading is a novel approach to user-defined overloading that extends Haskell's concept of type classes in significant ways. Whereas type classes are conceptually predicates on types in standard Haskell, they are type functions in our approach. Thus, we can base type inference on the evaluation of functional logic programs. Functional logic programming provides a solid theoretical foundation for type functions and, at the same time, allows for programmable overloading resolution strategies by choosing different evaluation strategies for functional logic programs. Type inference with type functions is an instance of type inference with constrained types, where the underlying constraint system is defined by a functional logic program. We have designed a variant of Haskell which supports our approach to overloading, and implemented a prototype front-end for the language.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503294", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Neubauer", + "institution": "University of Fribourg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Fribourg" + }, + { + "first_name": "Martin", + "last_name": "Gasbichler", + "institution": "University of Tübingen" + }, + { + "first_name": "Michael", + "last_name": "Sperber", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/popl/NeubauerTGS02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503287", + "title": "An efficient profile-analysis framework for data-layout optimizations", + "abstract": "Data-layout optimizations rearrange fields within objects, objects within objects, and objects within the heap, with the goal of increasing spatial locality. While the importance of data-layout optimizations has been growing, their deployment has been limited, partly because they lack a unifying framework. We propose a parameterizable framework for data-layout optimization of general-purpose applications. Acknowledging that finding an optimal layout is not only NP-hard, but also poorly approximable, our framework finds a good layout by searching the space of possible layouts, with the help of profile feedback. The search process iteratively prototypes candidate data layouts, evaluating them by \"simulating\" the program on a representative trace of memory accesses. To make the search process practical, we develop space-reduction heuristics and optimize the expensive simulation via memoization. Equipped with this iterative approach, we can synthesize layouts that outperform existing non-iterative heuristics, tune application-specific memory allocators, as well as compose multiple data-layout optimizations.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503287", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shai", + "last_name": "Rubin", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/RubinBC02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503283", + "title": "The hardness of cache conscious data placement", + "abstract": "The growing gap between the speed of memory access and cache access has made cache misses an influential factor in program efficiency. Much effort has been spent recently on reducing the number of cache misses during program run. This effort includes wise rearranging of program code, cache-conscious data placement, and algorithmic modifications that improve the program cache behavior. In this work we investigate the complexity of finding the optimal placement of objects (or code) in the memory, in the sense that this placement reduces the cache misses to the minimum. We show that this problem is one of the toughest amongst the interesting algorithmic problems in computer science. In particular, suppose one is given a sequence of memory accesses and one has to place the data in the memory so as to minimize the number of cache misses for this sequence. We show that if P ≠ NP, then one cannot efficiently approximate the optimal solution even up to a very liberal approximation ratio. Thus, this problem joins the small family of extremely inapproximable optimization problems. The other two famous members in this family are minimum coloring and maximum clique.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503283", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Dror", + "last_name": "Rawitz", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/PetrankR02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503288", + "title": "Stochastic lambda calculus and monads of probability distributions", + "abstract": "Probability distributions are useful for expressing the meanings of probabilistic languages, which support formal modeling of and reasoning about uncertainty. Probability distributions form a monad, and the monadic definition leads to a simple, natural semantics for a stochastic lambda calculus, as well as simple, clean implementations of common queries. But the monadic implementation of the expectation query can be much less efficient than current best practices in probabilistic modeling. We therefore present a language of measure terms, which can not only denote discrete probability distributions but can also support the best known modeling techniques. We give a translation of stochastic lambda calculus into measure terms. Whether one translates into the probability monad or into measure terms, the results of the translations denote the same probability distribution.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503288", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Harvard University Press" + }, + { + "first_name": "Avi", + "last_name": "Pfeffer", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/RamseyP02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503300", + "title": "Exploiting prolific types for memory management and optimizations", + "abstract": "In this paper, we introduce the notion of prolific and non-prolific types, based on the number of instantiated objects of those types. We demonstrate that distinguishing between these types enables a new class of techniques for memory management and data locality, and facilitates the deployment of known techniques. Specifically, we first present a new type-based approach to garbage collection that has similar attributes but lower cost than generational collection. Then we describe the short type pointer technique for reducing memory requirements of objects (data) used by the program. We also discuss techniques to facilitate the recycling of prolific objects and to simplify object co-allocation decisions.We evaluate the first two techniques on a standard set of Java benchmarks (SPECjvm98 and SPECjbb2000). An implementation of the type-based collector in the Jalapeño VM shows improved pause times, elimination of unnecessary write barriers, and reduction in garbage collection time (compared to the analogous generational collector) by up to 15%. A study to evaluate the benefits of the short-type pointer technique shows a potential reduction in the heap space requirements of programs by up to 16%.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503300", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yefim", + "last_name": "Shuf", + "institution": "Princeton University" + }, + { + "first_name": "Manish", + "last_name": "Gupta", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Rajesh", + "last_name": "Bordawekar", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Jaswinder", + "last_name": "Singh", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/ShufGBS02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503295", + "title": "Scalable formal design methods for asynchronous VLSI", + "abstract": "This lecture will provide an overview of the field of asynchronous VLSI, and show how formal methods have played a critical role in the design of complex asynchronous systems. In particular, I will talk about program transformations and their application to asynchronous VLSI, as well as describe a simple language that I developed to describe these circuits and aid in their validation.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503295", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajit", + "last_name": "Manohar", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Manohar02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503292", + "title": "The first-order theory of subtyping constraints", + "abstract": "We investigate the first-order of subtyping constraints. We show that the first-order theory of non-structural subtyping is undecidable, and we show that in the case where all constructors are either unary or nullary, the first-order theory is decidable for both structural and non-structural subtyping. The decidability results are shown by reduction to a decision problem on tree automata. This work is a step towards resolving long-standing open problems of the decidability of entailment for non-structural subtyping.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503292", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Joachim", + "last_name": "Niehren", + "institution": "Saarland University" + }, + { + "first_name": "Tim", + "last_name": "Priesnitz", + "institution": "Saarland University" + }, + { + "first_name": "Ralf", + "last_name": "Treinen", + "institution": "Université Paris-Sud" + } + ], + "dblp_key": "conf/popl/SuANPT02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503302", + "title": "Information flow inference for ML", + "abstract": "This paper presents a type-based information flow analysis for a call-by-value λ-calculus equipped with references, exceptions and let-polymorphism, which we refer to as Core ML. The type system is constraint-based and has decidable type inference. Its non-interference proof is reasonably lightweight, thanks to the use of a number of orthogonal techniques. First, a syntactic segregation between values and expressions allows a lighter formulation of the type system. Second, non-interference is reduced to subject reduction for a non-standard language extension. Lastly, a semi-syntactic approach to type soundness allows dealing with constraint-based polymorphism separately.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503302", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Vincent", + "last_name": "Simonet", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/PottierS02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503284", + "title": "Towards automatic construction of staged compilers", + "abstract": "Some compilation systems, such as offline partial evaluators and selective dynamic compilation systems, support staged optimizations. A staged optimization is one where a logically single optimization is broken up into stages, with the early stage(s) performing preplanning set-up work, given any available partial knowledge about the program to be compiled, and the final stage completing the optimization. The final stage can be much faster than the original optimization by having much of its work performed by the early stages. A key limitation of current staged optimizers is that they are written by hand, sometimes in an ad hoc manner. We have developed a framework called the Staged Compilation Framework (SCF) for systematically and automatically converting single-stage optimizations into staged versions. The framework is based on a combination of aggressive partial evaluation and dead-assignment elimination. We have implemented SCF in Standard ML. A preliminary evaluation shows that SCF can speed up classical optimization of some commonly used C functions by up to 12× (and typically between 4.5× and 5.5×).", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503284", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthai", + "last_name": "Philipose", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + }, + { + "first_name": "Susan J.", + "last_name": "Eggers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/PhiliposeCE02", + "venue": "popl", + "year": 2002 + }, + { + "paper_id": "10.1145/503272.503293", + "title": "A type system for certified binaries", + "abstract": "A certified binary is a value together with a proof that the value satisfies a given specification. Existing compilers that generate certified code have focused on simple memory and control-flow safety rather than more advanced properties. In this paper, we present a general framework for explicitly representing complex propositions and proofs in typed intermediate and assembly languages. The new framework", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/503272.503293", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Bratin", + "last_name": "Saha", + "institution": "Yale University" + }, + { + "first_name": "Valery", + "last_name": "Trifonov", + "institution": "Yale University" + }, + { + "first_name": "Nikolaos", + "last_name": "Papaspyrou", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/ShaoSTP02", + "venue": "popl", + "year": 2002 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2003.json b/data/pl_conferences/popl/2003.json new file mode 100644 index 0000000..6e22f7f --- /dev/null +++ b/data/pl_conferences/popl/2003.json @@ -0,0 +1,622 @@ +[ + { + "paper_id": "10.1145/604131.604148", + "title": "Static prediction of heap space usage for first-order functional programs", + "abstract": "We show how to efficiently obtain linear a priori bounds on the heap space consumption of first-order functional programs.The analysis takes space reuse by explicit deallocation into account and also furnishes an upper bound on the heap usage in the presence of garbage collection. It covers a wide variety of examples including, for instance, the familiar sorting algorithms for lists, including quicksort.The analysis relies on a type system with resource annotations. Linear programming (LP) is used to automatically infer derivations in this enriched type system.We also show that integral solutions to the linear programs derived correspond to programs that can be evaluated without any operating system support for memory management. The particular integer linear programs arising in this way are shown to be feasibly solvable under mild assumptions.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604148", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Hofmann", + "institution": "Ludwig-Maximilians-Universität München" + }, + { + "first_name": "Steffen", + "last_name": "Jost", + "institution": "Ludwig-Maximilians-Universität München" + } + ], + "dblp_key": "conf/popl/HofmannJ03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604140", + "title": "From symptom to cause: localizing errors in counterexample traces", + "abstract": "There is significant room for improving users' experiences with model checking tools. An error trace produced by a model checker can be lengthy and is indicative of a symptom of an error. As a result, users can spend considerable time examining an error trace in order to understand the cause of the error. Moreover, even state-of-the-art model checkers provide an experience akin to that provided by parsers before syntactic error recovery was invented: they report a single error trace per run. The user has to fix the error and run the model checker again to find more error traces.We present an algorithm that exploits the existence of correct traces in order to localize the error cause in an error trace, report a single error trace per error cause, and generate multiple error traces having independent causes. We have implemented this algorithm in the context of slam, a software model checker that automatically verifies temporal safety properties of C programs, and report on our experience using it to find and localize errors in device drivers. The algorithm typically narrows the location of a cause down to a few lines, even in traces consisting of hundreds of statements.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604140", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/BallNR03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604149", + "title": "Toward a foundational typed assembly language", + "abstract": "We present the design of a typed assembly language called TALT that supports heterogeneous tuples, disjoint sums, and a general account of addressing modes. TALT also implements the von Neumann model in which programs are stored in memory, and supports relative addressing. Type safety for execution and for garbage collection are shown by machine-checkable proofs. TALT is the first formalized typed assembly language to provide any of these features.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604149", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Crary03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604153", + "title": "Destructors, finalizers, and synchronization", + "abstract": "We compare two different facilities for running cleanup actions for objects that are about to reach the end of their life.Destructors, such as we find in C++, are invoked synchronously when an object goes out of scope. They make it easier to implement cleanup actions for objects of well-known lifetime, especially in the presence of exceptions.Languages like Java[8], Modula-3[12], and C\\#[6] provide a different kind of \"finalization\" facility: Cleanup methods may be run when the garbage collector discovers a heap object to be otherwise inaccessible. Unlike C++ destructors, such methods run in a separate thread at some much less well-defined time.Languages like Java[8], Modula-3[12], and C\\#[6] provide a different kind of \"finalization\" facility: Cleanup methods may be run when the garbage collector discovers a heap object to be otherwise inaccessible. Unlike C++ destructors, such methods run in a separate thread at some much less well-defined time.We argue that these are fundamentally different, and potentially complementary, language facilities. We also try to resolve some common misunderstandings about finalization in the process. In particular:", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604153", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/popl/Boehm03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604133", + "title": "Selective memoization", + "abstract": "We present a framework for applying memoization selectively. The framework provides programmer control over equality, space usage, and identification of precise dependences so that memoization can be applied according to the needs of an application. Two key properties of the framework are that it is efficient and yields programs whose performance can be analyzed using standard techniques.We describe the framework in the context of a functional language and an implementation as an SML library. The language is based on a modal type system and allows the programmer to express programs that reveal their true data dependences when executed. The SML implementation cannot support this modal type system statically, but instead employs run-time checks to ensure correct usage of primitives.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604133", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/AcarBH03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604134", + "title": "Environment classifiers", + "abstract": "This paper proposes and develops the basic theory for a new approach to typing multi-stage languages based a notion of environment classifiers. This approach involves explicit but lightweight tracking -- at type-checking time -- of the origination environment for future-stage computations. Classification is less restrictive than the previously proposed notions of closedness, and allows for both a more expressive typing of the run construct and for a unifying account of typed multi-stage programmin.The proposed approach to typing requires making cross-stage persistence (CSP) explicit in the language. At the same time, it offers concrete new insights into the notion of levels and in turn into CSP itself. Type safety is established in the simply-typed setting. As a first step toward introducing classifiers to the Hindley-Milner setting, we propose an approach to integrating the two, and prove type preservation in this setting.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604134", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Walid", + "last_name": "Taha", + "institution": "Rice University" + }, + { + "first_name": "Michael Florentin", + "last_name": "Nielsen", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/popl/TahaN03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604154", + "title": "Interprocedural compatibility analysis for static object preallocation", + "abstract": "We present an interprocedural and compositional algorithm for nding pairs of compatible allocation sites, which have the property that no object allocated at one site is live at the same time as any object allocated at the other site. If an allocation site is compatible with itself, it is said to be unitary : at most one object allocated at that site is live at any given point in the execution of the program. We use the results of the analysis to statically preallocate memory space for the objects allocated at unitary sites, thus simplifying the computation of an upper bound on the amount of memory required to execute the program. We also use the analysis to enable objects allocated at several compatible allocation sites to share the same preallocated memory. Our experimental results show that, for our set of Java benchmark programs, 60% of the allocation sites are unitary and can be statically preallocated. Moreover, allowing compatible unitary allocation sites to share the same preallocated memory leads to a 95% reduction in the amount of memory preallocated for these sites.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604154", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ovidiu", + "last_name": "Gheorghioiu", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Alexandru", + "last_name": "Sălcianu", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/GheorghioiuSR03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604142", + "title": "New results on the computability and complexity of points - to analysis", + "abstract": "Given a prog=I and two variables p and q, thegLI of points-to analysis is to check if p can point to q in some execution of the prog ram. This well-studied problem plays a crucial role in compiler optimization. The problem is known to be undecidable when dynamic memory is allowed. But the result is known only when variables are allowed to be structures. We extend the result to show that, the problem remains undecidable, even when only scalar variables are allowed. Our second result deals with a version of points-to analysis called flow-insensitive analysis, where one ig ores the control flow of the prog)$ and assumes that the statements can be executed in any order. The problem is known to be NP-Hard, even when dynamic memory is not allowed and variables are scalar. We show that when the variables are further restricted to have well-defined data types, the problem is in P. The corresponding flow-sensitive version, even with further restrictions, is known to be PSPACEComplete. Thus, our resultg ives some theoretical evidence that flow-insensitive analysis is easier than flow-sensitive analysis. Moreover, while most variations of the points-to analysis are known to be computationally hard, our result gO es a rare instance of a non-trivial points-to problem solvable in polynomial time.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604142", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Venkatesan T.", + "last_name": "Chakaravarthy", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/Chakaravarthy03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604155", + "title": "A real-time garbage collector with low overhead and consistent utilization", + "abstract": "Now that the use of garbage collection in languages like Java is becoming widely accepted due to the safety and software engineering benefits it provides, there is significant interest in applying garbage collection to hard real-time systems. Past approaches have generally suffered from one of two major flaws: either they were not provably real-time, or they imposed large space overheads to meet the real-time bounds. We present a mostly non-moving, dynamically defragmenting collector that overcomes both of these limitations: by avoiding copying in most cases, space requirements are kept low; and by fully incrementalizing the collector we are able to meet real-time bounds. We implemented our algorithm in the Jikes RVM and show that at real-time resolution we are able to obtain mutator utilization rates of 45% with only 1.6--2.5 times the actual space required by the application, a factor of 4 improvement in utilization over the best previously published results. Defragmentation causes no more than 4% of the traced data to be copied.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604155", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Perry", + "last_name": "Cheng", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "V. T.", + "last_name": "Rajan", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/BaconCR03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604138", + "title": "Discovering affine equalities using random interpretation", + "abstract": "We present a new polynomial-time randomized algorithm for discovering affine equalities involving variables in a program. The key idea of the algorithm is to execute a code fragment on a few random inputs, but in such a way that all paths are covered on each run. This makes it possible to rule out invalid relationships even with very few runs.The algorithm is based on two main techniques. First, both branches of a conditional are executed on each run and at joint points we perform an affine combination of the joining states. Secondly, in the branches of an equality conditional we adjust the data values on the fly to reflect the truth value of the guarding boolean expression. This increases the number of affine equalities that the analysis discovers.The algorithm is simpler to implement than alternative deterministic versions, has better computational complexity, and has an extremely small probability of error for even a small number of runs. This algorithm is an example of how randomization can provide a trade-off between the cost and complexity of program analysis, and a small probability of unsoundness.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604138", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "University of California, Berkeley" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/GulwaniN03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604141", + "title": "Folklore confirmed: reducible flow graphs are exponentially larger", + "abstract": "Many program analysis techniques used by compilers are applicable only to programs whose control flow graphs are reducible. Node-splitting is a technique that can be used to convert any control flow graph to a reducible one. However, as has been observed for various node-splitting algorithms, there can be an exponential blowup in the size of the graph.We prove that exponential blowup is unavoidable. In particular, we show that any reducible graph that is equivalent to the complete graph on n nodes (or to related bounded-degree control flow graphs) must have at least 2n-1 nodes. While this result is not a surprise, it may be relevant to the quest for finding methods of obfuscation for software protection.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604141", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Larry", + "last_name": "Carter", + "institution": "University of California, San Diego" + }, + { + "first_name": "Jeanne", + "last_name": "Ferrante", + "institution": "University of California, San Diego" + }, + { + "first_name": "Clark", + "last_name": "Thomborson", + "institution": "University of Auckland" + } + ], + "dblp_key": "conf/popl/CarterFT03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604136", + "title": "The m-calculus: a higher-order distributed process calculus", + "abstract": "This paper presents a new distributed process calculus, called the M-calculus, that can be understood as a higher-order version of the Distributed Join calculus with programmable localities. The calculus retains the implementable character of the Distributed Join calculus while overcoming several important limitations: insufficient control over communication and mobility, absence of dynamic binding, and limited locality semantics. The calculus is equipped with a polymorphic type system that guarantees the unicity of locality names, even in presence of higher-order communications -- a crucial property for the determinacy of message routing in the calculus.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604136", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Schmitt", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jean-Bernard", + "last_name": "Stefani", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/SchmittS03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604145", + "title": "Coercive subtyping for the calculus of constructions", + "abstract": "We present a coercive subtyping system for the calculus of constructions. The proposed system λCCOover≤ is obtained essentially by adding coercions and η-conversion to λC≤[10], which is a subtyping extension to the calculus of constructions without coercions. Following [17, 18], the coercive subtyping c : A η B is understood as a special case of typing in arrow type c : A → B such that the term c behaves like an identity function. We prove that, with respect to this semantic interpretation, the proposed coercive subtyping system is sound and complete, and that this completeness leads to transitivity elimination (transitivity rule is admissible). In addition, we establish the equivalence between λCCOover≤ and CCßη, this fact implies that λCCOover≤ has confluence, subject reduction and strong normalization. We propose a formalization of coercion inference problem and present a sound and complete coercion inference algorithm.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604145", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gang", + "last_name": "Chen", + "institution": "" + } + ], + "dblp_key": "conf/popl/Chen03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604137", + "title": "A generic approach to the static analysis of concurrent programs with procedures", + "abstract": "We present a generic aproach to the static analysis of concurrent programs with procedures. We model programs as communicating pushdown systems. It is known that typical dataflow problems for this model are undecidable, because the emptiness problem for the intersection of context-free languages, which is undecidable, can be reduced to them. In this paper we propose an algebraic framework for defining abstractions (upper approximations) of context-free languages. We consider two classes of abstractions: finite-chain abstractions, which are abstractions whose domains do not contain any infinite chains, and commutative abstractions corresponding to classes of languages that contain a word if and only if they contain all its permutations. We show how to compute such approximations by combining automata theoretic techniques with algorithms for solving systems of polynomial inequations in Kleene algebras.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604137", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Université Paris Cité" + }, + { + "first_name": "Javier", + "last_name": "Esparza", + "institution": "University of Edinburgh" + }, + { + "first_name": "Tayssir", + "last_name": "Touili", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/popl/BouajjaniET03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604152", + "title": "Pure patterns type systems", + "abstract": "International audience", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604152", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Horatiu", + "last_name": "Cirstea", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Claude", + "last_name": "Kirchner", + "institution": "Laboratoire Lorrain de Recherche en Informatique et ses Applications" + }, + { + "first_name": "Luigi", + "last_name": "Liquori", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/BartheCKL03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604156", + "title": "Ownership types for object encapsulation", + "abstract": "Ownership types provide a statically enforceable way of specifying object encapsulation and enable local reasoning about program correctness in object-oriented languages. However, a type system that enforces strict object encapsulation is too constraining: it does not allow efficient implementation of important constructs like iterators. This paper argues that the right way to solve the problem is to allow objects of classes defined in the same module to have privileged access to each other's representations; we show how to do this for inner classes. This approach allows programmers to express constructs like iterators and yet supports local reasoning about the correctness of the classes, because a class and its inner classes together can be reasoned about as a module. The paper also sketches how we use our variant of ownership types to enable efficient software upgrades in persistent object stores.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604156", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chandrasekhar", + "last_name": "Boyapati", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Liuba", + "last_name": "Shrira", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/popl/BoyapatiLS03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604132", + "title": "The essence of XML", + "abstract": "The World-Wide Web Consortium (W3C) promotes XML and related standards, including XML Schema, XQuery, and XPath. This paper describes a formalization of XML Schema. A formal semantics based on these ideas is part of the official XQuery and XPath specification, one of the first uses of formal methods by a standards body. XML Schema features both named and structural types, with structure based on tree grammars. While structural types and matching have been studied in other work (notably XDuce, Relax NG, and a previous formalization of XML Schema), this is the first work to study the relation between named types and structural types, and the relation between matching and validation.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604132", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jérǒme", + "last_name": "Simèon", + "institution": "Bell (Canada)" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "Avaya (Bermuda)" + } + ], + "dblp_key": "conf/popl/SimeonW03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604151", + "title": "A type system for higher-order modules", + "abstract": "We present a type theory for higher-order modules that accounts for many central issues in module system design, including translucency, applicativity, generativity, and modules as first-class values. Our type system harmonizes design elements from previous work, resulting in a simple, economical account of modular programming. The main unifying principle is the treatment of abstraction mechanisms as computational effects. Our language is the first to provide a complete and practical formalization of all of these critical issues in module system design.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604151", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/DreyerCH03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604144", + "title": "From control effects to typed continuation passing", + "abstract": "First-class continuations are a powerful computational effect, allowing the programmer to express any form of jumping. Types and effect systems can be used to reason about continuations, both in the source language and in the target language of the continuation-passing transform. In this paper, we establish the connection between an effect system for first-class continuations and typed versions of continuation-passing style. A region in the effect system determines a local answer type for continuations, such that the continuation transforms of pure expressions are parametrically polymorphic in their answer types. We use this polymorphism to derive transforms that make use of effect information, in particular, a mixed linear/non-linear continuation-passing transform, in which expressions without control effects are passed their continuations linearly.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604144", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hayo", + "last_name": "Thielecke", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/popl/Thielecke03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604147", + "title": "A type theory for memory allocation and data layout", + "abstract": "Ordered type theory is an extension of linear type theory in which variables in the context may be neither dropped nor re-ordered. This restriction gives rise to a natural notion of adjacency. We show that a language based on ordered types can use this property to give an exact account of the layout of data in memory. The fuse constructor from ordered logic describes adjacency of values in memory, and the mobility modal describes pointers into the heap. We choose a particular allocation model based on a common implementation scheme for copying garbage collection and show how this permits us to separate out the allocation and initialization of memory locations in such a way as to account for optimizations such as the coalescing of multiple calls to the allocator.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604147", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leaf", + "last_name": "Petersen", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/PetersenHCP03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604150", + "title": "Guarded recursive datatype constructors", + "abstract": "We introduce a notion of guarded recursive (g.r.) datatype constructors, generalizing the notion of recursive datatypes in functional programming languages such as ML and Haskell.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604150", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hongwei", + "last_name": "Xi", + "institution": "" + }, + { + "first_name": "Chiyan", + "last_name": "Chen", + "institution": "" + }, + { + "first_name": "Gang", + "last_name": "Chen", + "institution": "" + } + ], + "dblp_key": "conf/popl/XiCC03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604146", + "title": "Efficient algorithms for isomorphisms of simple types", + "abstract": "The first order isomorphism problem is to decide whether two nonrecursive types using product- and function-type constructors, are isomorphic under the axioms of commutative and associative products, and currying and distributivity of functions over products. We show that this problem can be solved in 2 is the input size. This result improves upon the space bounds of the best previous algorithm. We also describe an time algorithm for the linear isomorphism problem, which does not include the distributive axiom, whereby improving upon the time of the best previous algorithm for this problem.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604146", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yoav", + "last_name": "Zibin", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Jeffrey", + "last_name": "Considine", + "institution": "" + } + ], + "dblp_key": "conf/popl/ZibinGC03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604139", + "title": "Bitwidth aware global register allocation", + "abstract": "Multimedia and network processing applications make extensive use of subword data. Since registers are capable of holding a full data word, when a subword variable is assigned a register, only part of the register is used. New embedded processors have started sup-porting instruction sets that allow direct referencing of bit sections within registers and therefore multiple subword variables can be made to simultaneously reside in the same register without hinder-ing accesses to these variables. However, a new register allocation algorithm is needed that is aware of the bitwidths of program vari-ables and is capable of packing multiple subword variables into a single register. This paper presents one such algorithm. The algorithm we propose has two key steps. First, a combina-tion of forward and backward data flow analyses are developed to determine the bitwidths of program variables throughout the pro-gram. This analysis is required because the declared bitwidths of variables are often larger than their true bitwidths and moreover the minimal bitwidths of a program variable can vary from one pro-gram point to another. Second, a novel interference graph represen-tation is designed to enable support for a fast and highly accurate algorithm for packing of subword variables into a single register. Packing is carried out by a node coalescing phase that precedes the conventional graph coloring phase of register allocation. In contrast to traditional node coalescing, packing coalesces a set of interfering nodes. Our experiments show that our bitwidth aware register allo-cation algorithm reduces the register requirements by 10 % to 50% over a traditional register allocation algorithm that assigns separate registers to simultaneously live subword variables.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604139", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sriraman", + "last_name": "Tallam", + "institution": "University of Arizona" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/TallamG03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604143", + "title": "Incremental algorithms for dispatching in dynamically typed languages", + "abstract": "A fundamental problem in the implementation of object-oriented languages is that of a frugal dispatching data structure, i.e., support for quick response to dispatching queries combined with compact representation of the type hierarchy and the method families. Previous theoretical algorithms tend to be impractical due to their complexity and large hidden constant. In contrast, successful practical heuristics, including Vitek and Horspool's compact dispatch tables (CT) [16] designed for dynamically typed languages, lack theoretical support. In subjecting CT to theoretical analysis, we are not only able to improve and generalize it, but also provide the first non-trivial bounds on the performance of such a heuristic.Let n,ml denote the total number of types, messages, and different method implementations, respectively. Then, the dispatching matrix, whose size isnm, can be compressed by a factor of at most ι ≡ (nm)/l. Our main variant to CT achieves a compression factor of ½ √ι. More generally, we describe a sequence of algorithms CT1, CT2, CT3,..., where CTd achieves compression by a factor of (at least) 1overdι1—1/d, while using d memory dereferencing operations during dispatch. This tradeoff represents the first bounds on the compression ratio of constant-time dispatching algorithms.A generalization of these algorithms to a multiple-inheritance setting, increases the space by a factor of κ1-1/d, where κ is a metric of the complexity of the topology of the inheritance hierarchy, which (as indicated by our measurements) is typically small. The most important generalization is an incremental variant of the CTd scheme for a single-inheritance setting. This variant uses at most twice the space of CTd, and its time of inserting a new type into the hierarchy is optimal. We therefore obtain algorithms for efficient management of dispatching in dynamic-typing, dynamic-loading languages, such as Smalltalk and even the Java invokeinterface instruction.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604143", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yoav", + "last_name": "Zibin", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/ZibinG03", + "venue": "popl", + "year": 2003 + }, + { + "paper_id": "10.1145/604131.604135", + "title": "Bigraphs and transitions", + "abstract": "A bigraphical reactive system (BRS) involves bigraphs, in which the nesting of nodes represents locality, independently of the edges connecting them. BRSs represent a wide variety of calculi for mobility, including λ-calculus and ambient calculus. A labelled transition system (LTS) for each BRS is here derived uniformly, adapting previous work of Leifer and Milner, so that under certain conditions the resulting bisimilarity is automatically a congruence. For an asynchronous λ-calculus, this LTS and its bisimilarity agree closely with the standard.", + "date": "2003-01-15", + "link": "https://doi.org/10.1145/604131.604135", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ole Høgh", + "last_name": "Jensen", + "institution": "Aalborg University" + }, + { + "first_name": "Robin", + "last_name": "Milner", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/JensenM03", + "venue": "popl", + "year": 2003 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2004.json b/data/pl_conferences/popl/2004.json new file mode 100644 index 0000000..83b5b2d --- /dev/null +++ b/data/pl_conferences/popl/2004.json @@ -0,0 +1,671 @@ +[ + { + "paper_id": "10.1145/964001.964018", + "title": "A semantics for web services authentication", + "abstract": "We consider the problem of specifying and verifying cryptographic security protocols for XML web services. The security specification WS-Security describes a range of XML security tokens, such as username tokens, public-key certificates, and digital signature blocks, amounting to a flexible vocabulary for expressing protocols. To describe the syntax of these tokens, we extend the usual XML data model with symbolic representations of cryptographic values. We use predicates on this data model to describe the semantics of security tokens and of sample protocols distributed with the Microsoft WSE implementation of WS-Security. By embedding our data model within Abadi and Fournet's applied pi calculus, we formulate and prove security properties with respect to the standard Dolev-Yao threat model. Moreover, we informally discuss issues not addressed by the formal model. To the best of our knowledge, this is the first approach to the specification and verification of security protocols based on a faithful account of the XML wire format.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964018", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karthikeyan", + "last_name": "Bhargavan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/BhargavanFG04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964008", + "title": "Isomorphisms of generic recursive polynomial types", + "abstract": "This paper gives the first decidability results on type isomorphism for recursive types, establishing the explicit decidability of type isomorphism for the type theory of sums and products over an inhabited generic recursive polynomial type. The technical development provides connections between themes in programming-language theory (type isomorphism) and computational algebra (Gröbner bases).", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964008", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marcelo", + "last_name": "Fiore", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/Fiore04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964013", + "title": "A logic you can count on", + "abstract": "We prove the decidability of the quantifier-free, static fragment of ambient logic, with composition adjunct and iteration, which corresponds to a kind of regular expression language for semistructured data. The essence of this result is a surprising connection between formulas of the ambient logic and counting constraints on (nested) vectors of integers.Our proof method is based on a new class of tree automata for unranked, unordered trees, which may result in practical algorithms for deciding the satisfiability of a formula. A benefit of our approach is to naturally lead to an extension of the logic with recursive definitions, which is also decidable. Finally, we identify a simple syntactic restriction on formulas that improves the effectiveness of our algorithms on large examples.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964013", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Silvano Dal", + "last_name": "Zilio", + "institution": "" + }, + { + "first_name": "Denis", + "last_name": "Lugiez", + "institution": "" + }, + { + "first_name": "Charles", + "last_name": "Meyssonnier", + "institution": "" + } + ], + "dblp_key": "conf/popl/Dal-ZilioLM04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964025", + "title": "Tridirectional typechecking", + "abstract": "In prior work we introduced a pure type assignment system that encompasses a rich set of property types, including intersections, unions, and universally and existentially quantified dependent types. This system was shown sound with respect to a call-by-value operational semantics with effects, yet is inherently undecidable. In this paper we provide a decidable formulation for this system based on bidirectional checking, combining type synthesis and analysis following logical principles. The presence of unions and existential quantification requires the additional abiity to visit subterms in evaluation position before the context in which they occur, leading to a tridirectional type system. While soundness with respect to the type assignment system is immediate, completeness requires the novel concept of contextual type annotations, introducing a notion from the study of principal typings into the source program.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964025", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/DunfieldP04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964026", + "title": "A type system for well-founded recursion", + "abstract": "In the interest of designing a recursive module extension to ML that is as simple and general as possible, we propose a novel type system for general recursion over effectful expressions. The presence of effects seems to necessitate a backpatching semantics for recursion similar to that of Scheme. Our type system ensures statically that recursion is well-founded---that the body of a recursive expression will evaluate without attempting to access the undefined recursive variable---which avoids some unnecessary run-time costs associated with backpatching. To ensure well-founded recursion in the presence of multiple recursive variables and separate compilation, we track the usage of individual recursive variables, represented statically by \"names\". So that our type system may eventually be integrated smoothly into ML's, reasoning involving names is only required inside code that uses our recursive construct and need not infect existing ML code, although instrumentation of some existing code can help to improve the precision of our type system.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964026", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Dreyer04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964019", + "title": "The space cost of lazy reference counting", + "abstract": "Reference counting memory management is often advocated as a technique for reducing or avoiding the pauses associated with tracing garbage collection. We present some measurements to remind the reader that classic reference count implementations may in fact exhibit longer pauses than tracing collectors.We then analyze reference counting with lazy deletion, the standard technique for avoiding long pauses by deferring deletions and associated reference count decrements, usually to allocation time. Our principal result is that if each reference count operation is constrained to take constant time, then the overall space requirements can be increased by a factor of Ω(R) in the worst case, where R is the ratio between the size of the largest and smallest allocated object. This bound is achievable, but probably large enough to render this design point useless for most real-time applications.We show that this space cost can largely be avoided if allocating an $n$ byte object is allowed to additionally perform O(n) reference counting work.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964019", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/popl/Boehm04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964020", + "title": "Local reasoning about a copying garbage collector", + "abstract": "We present a programming language, model, and logic appropriate for implementing and reasoning about a memory management system. We then state what is meant by correctness of a copying garbage collector, and employ a variant of the novel separation logics [18, 23] to formally specify partial correctness of Cheney's copying garbage collector [8]. Finally, we prove that our implementation of Cheney's algorithm meets its specification, using the logic we have given, and auxiliary variables [19].", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964020", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Noah", + "last_name": "Torp-Smith", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "John", + "last_name": "Reynolds", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/BirkedalTR04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964003", + "title": "Simple relational correctness proofs for static analyses and program transformations", + "abstract": "We show how some classical static analyses for imperative programs, and the optimizing transformations which they enable, may be expressed and proved correct using elementary logical and denotationaltechniques. The key ingredients are an interpretation of program properties as relations, rather than predicates, and a realization that although many program analyses are traditionally formulated in very intensional terms, the associated transformations are actually enabled by more liberal extensional properties.We illustrate our approach with formal systems for analysing and transforming while-programs. The first is a simple type system which tracks constancy and dependency information and can be used to perform dead-code elimination, constant propagation and program slicing as well as capturing a form of secure information flow. The second is a relational version of Hoare logic, which significantly generalizes our first type system and can also justify optimizations including hoisting loop invariants. Finally we show how a simple available expression analysis and redundancy elimination transformation may be justified by translation into relational Hoare logic.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964003", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/Benton04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964029", + "title": "Precise interprocedural analysis through linear algebra", + "abstract": "We apply linear algebra techniques to precise interprocedural dataflow analysis. Specifically, we describe analyses that determine for each program point identities that are valid among the program variables whenever control reaches that program point. Our analyses fully interpret assignment statements with affine expressions on the right hand side while considering other assignments as non-deterministic and ignoring conditions at branches. Under this abstraction, the analysis computes the set of all affine relations and, more generally, all polynomial relations of bounded degree precisely. The running time of our algorithms is linear in the program size and polynomial in the number of occurring variables. We also show how to deal with affine preconditions and local variables and indicate how to handle parameters and return values of procedures.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964029", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Markus", + "last_name": "Müller-Olm", + "institution": "University of Hagen" + }, + { + "first_name": "Helmut", + "last_name": "Seidl", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/popl/Muller-OlmS04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964007", + "title": "Extensional normalisation and type-directed partial evaluation for typed lambda calculus with sums", + "abstract": "International audience", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964007", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vincent", + "last_name": "Balat", + "institution": "Université Paris Cité" + }, + { + "first_name": "Roberto Di", + "last_name": "Cosmo", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Marcelo", + "last_name": "Fiore", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/BalatCF04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964030", + "title": "Global value numbering using random interpretation", + "abstract": "We present a polynomial time randomized algorithm for global value numbering. Our algorithm is complete when conditionals are treated as non-deterministic and all operators are treated as uninterpreted functions. We are not aware of any complete polynomial-time deterministic algorithm for the same problem. The algorithm does not require symbolic manipulations and hence is simpler to implement than the deterministic symbolic algorithms. The price for these benefits is that there is a probability that the algorithm can report a false equality. We prove that this probability can be made arbitrarily small by controlling various parameters of the algorithm.Our algorithm is based on the idea of random interpretation, which relies on executing a program on a number of random inputs and discovering relationships from the computed values. The computations are done by giving random linear interpretations to the operators in the program. Both branches of a conditional are executed. At join points, the program states are combined using a random affine combination. We discuss ways in which this algorithm can be made more precise by using more accurate interpretations for the linear arithmetic operators and other language constructs.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964030", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "University of California, Berkeley" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/GulwaniN04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964027", + "title": "Principal typings for Java-like languages", + "abstract": "The contribution of the paper is twofold. First, we define a general notion of type system equipped with an entailment relation between type environments; this generalisation serves as a pattern for instantiating type systems able to support separate compilation and inter-checking of Java-like languages, and allows a formal definition of soundess and completeness of inter-checking w.r.t. global compilation. These properties are important in practice since they allow selective recompilation. In particular, we show that they are guaranteed when the type system has principal typings and provides sound and complete entailment relation between type environments.The second contribution is more specific, and is an instantiation of the notion of type system previously defined for Featherweight Java with method overloading and field hiding. The aim is to show that it is possible to define type systems for Java-like languages, which, in contrast to those used by standard compilers, have principal typings, hence can be used as a basis for selective recompilation.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964027", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Davide", + "last_name": "Ancona", + "institution": "University of Genoa" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/popl/AnconaZ04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964022", + "title": "Summarizing procedures in concurrent programs", + "abstract": "The ability to summarize procedures is fundamental to building scalable interprocedural analyses. For sequential programs, procedure summarization is well-understood and used routinely in a variety of compiler optimizations and software defect-detection tools. However, the benefit of summarization is not available to multithreaded programs, for which a clear notion of summaries has so far remained unarticulated in the research literature.In this paper, we present an intuitive and novel notion of procedure summaries for multithreaded programs. We also present a model checking algorithm for these programs that uses procedure summarization as an essential component. Our algorithm can also be viewed as a precise interprocedural dataflow analysis for multithreaded programs. Our method for procedure summarization is based on the insight that in well-synchronized programs, any computation of a thread can be viewed as a sequence of transactions, each of which appears to execute atomically to other threads. We summarize within each transaction; the summary of a procedure comprises the summaries of all transactions within the procedure. We leverage the theory of reduction [17] to infer boundaries of these transactions.The procedure summaries computed by our algorithm allow reuse of analysis results across different call sites in a multithreaded program, a benefit that has hitherto been available only to sequential programs. Although our algorithm is not guaranteed to terminate on multithreaded programs that use recursion (reachability analysis for multithreaded programs with recursive procedures is undecidable [18]), there is a large class of programs for which our algorithm does terminate. We give a formal characterization of this class, which includes programs that use shared variables, synchronization, and recursion.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964022", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/QadeerRR04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964010", + "title": "Free theorems in the presence of seq", + "abstract": "Parametric polymorphism constrains the behavior of pure functional programs in a way that allows the derivation of interesting theorems about them solely from their types, i.e., virtually for free. Unfortunately, the standard parametricity theorem fails for nonstrict languages supporting a polymorphic strict evaluation primitive like Haskell's seq. Contrary to the folklore surrounding seq and parametricity, we show that not even quantifying only over strict and bottom-reflecting relations in the $\\forall$-clause of the underlying logical relation --- and thus restricting the choice of functions with which such relations are instantiated to obtain free theorems to strict and total ones --- is sufficient to recover from this failure. By addressing the subtle issues that arise when propagating up the type hierarchy restrictions imposed on a logical relation in order to accommodate the strictness primitive, we provide a parametricity theorem for the subset of Haskell corresponding to a Girard-Reynolds-style calculus with fixpoints, algebraic datatypes, and seq. A crucial ingredient of our approach is the use of an asymmetric logical relation, which leads to \"inequational\" versions of free theorems enriched by preconditions guaranteeing their validity in the described setting. Besides the potential to obtain corresponding preconditions for standard equational free theorems by combining some new inequational ones, the latter also have value in their own right, as is exemplified with a careful analysis of seq's impact on familiar program transformations.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964010", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patricia", + "last_name": "Johann", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Janis", + "last_name": "Voigtländer", + "institution": "Technische Universität Dresden" + } + ], + "dblp_key": "conf/popl/JohannV04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964011", + "title": "Parsing expression grammars: a recognition-based syntactic foundation", + "abstract": "For decades we have been using Chomsky's generative system of grammars, particularly context-free grammars (CFGs) and regular expressions (REs), to express the syntax of programming languages and protocols. The power of generative grammars to express ambiguity is crucial to their original purpose of modelling natural languages, but this very power makes it unnecessarily difficult both to express and to parse machine-oriented languages using CFGs. Parsing Expression Grammars (PEGs) provide an alternative, recognition-based formal foundation for describing machine-oriented syntax, which solves the ambiguity problem by not introducing ambiguity in the first place. Where CFGs express nondeterministic choice between alternatives, PEGs instead use prioritized choice. PEGs address frequently felt expressiveness limitations of CFGs and REs, simplifying syntax definitions and making it unnecessary to separate their lexical and hierarchical components. A linear-time parser can be built for any PEG, avoiding both the complexity and fickleness of LR parsers and the inefficiency of generalized CFG parsing. While PEGs provide a rich set of operators for constructing grammars, they are reducible to two minimal recognition schemas developed around 1970, TS/TDPL and gTS/GTDPL, which are here proven equivalent in effective recognition power.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964011", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bryan", + "last_name": "Ford", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Ford04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964016", + "title": "An abstract interpretation-based framework for software watermarking", + "abstract": "Software watermarking consists in the intentional embedding of indelible stegosignatures or watermarks into the subject software and extraction of the stegosignatures embedded in the stegoprograms for purposes such as intellectual property protection. We introduce the novel concept of abstract software watermarking. The basic idea is that the watermark is hidden in the program code in such a way that it can only be extracted by an abstract interpretation of the (maybe non-standard) concrete semantics of this code. This static analysis-based approach allows the watermark to be recovered even if only a small part of the program code is present and does not even need that code to be executed. We illustrate the technique by a simple abstract watermarking protocol for methods of Java™ classes. The concept applies equally well to any other kind of software (including hardware originally specified by software).", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964016", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "Laboratoire de Géologie de l’École Normale Supérieure" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/CousotC04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964012", + "title": "Asynchronous and deterministic objects", + "abstract": "This paper aims at providing confluence and determinism properties in concurrent processes, more specifically within the paradigm of object-oriented systems. Such results should allow one to program parallel and distributed applications that behave in a deterministic manner, even if they are distributed over local or wide area networks. For that purpose, an object calculus is proposed. Its key characteristics are asynchronous communications with futures, and sequential execution within each process.While most of previous works exhibit confluence properties only on specific programs -- or patterns of programs, a general condition for confluence is presented here. It is further put in practice to show the deterministic behavior of a typical example.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964012", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Denis", + "last_name": "Caromel", + "institution": "Université Côte d'Azur" + }, + { + "first_name": "Ludovic", + "last_name": "Henrio", + "institution": "Université Côte d'Azur" + }, + { + "first_name": "Bernard", + "last_name": "Serpette", + "institution": "Université Côte d'Azur" + } + ], + "dblp_key": "conf/popl/CaromelHS04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964021", + "title": "Abstractions from proofs", + "abstract": "The success of model checking for large programs depends crucially on the ability to efficiently construct parsimonious abstractions. A predicate abstraction is parsimonious if at each control location, it specifies only relationships between current values of variables, and only those which are required for proving correctness. Previous methods for automatically refining predicate abstractions until sufficient precision is obtained do not systematically construct parsimonious abstractions: predicates usually contain symbolic variables, and are added heuristically and often uniformly to many or all control locations at once. We use Craig interpolation to efficiently construct, from a given abstract error trace which cannot be concretized, a parsominous abstraction that removes the trace. At each location of the trace, we infer the relevant predicates as an interpolant between the two formulas that define the past and the future segment of the trace. Each interpolant is a relationship between current values of program variables, and is relevant only at that particular program location. It can be found by a linear scan of the proof of infeasibility of the trace.We develop our method for programs with arithmetic and pointer expressions, and call-by-value function calls. For function calls, Craig interpolation offers a systematic way of generating relevant predicates that contain only the local variables of the function and the values of the formal parameters when the function was called. We have extended our model checker Blast with predicate discovery by Craig interpolation, and applied it successfully to C programs with more than 130,000 lines of code, which was not possible with approaches that build less parsimonious abstractions.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964021", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Kenneth L.", + "last_name": "McMillan", + "institution": "Cadence Design Systems (United States)" + } + ], + "dblp_key": "conf/popl/HenzingerJMM04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964023", + "title": "Atomizer: a dynamic atomicity checker for multithreaded programs", + "abstract": "Ensuring the correctness of multithreaded programs is difficult, due to the potential for unexpected interactions between concurrent threads. Much previous work has focused on detecting race conditions, but the absence of race conditions does not by itself prevent undesired thread interactions. We focus on the more fundamental non-interference property of atomicity; a method is atomic if its execution is not affected by and does not interfere with concurrently-executing threads. Atomic methods can be understood according to their sequential semantics, which significantly simplifies (formal and informal) correctness arguments.This paper presents a dynamic analysis for detecting atomicity violations. This analysis combines ideas from both Lipton's theory of reduction and earlier dynamic race detectors. Experience with a prototype checker for multithreaded Java code demonstrates that this approach is effective for detecting errors due to unintended interactions between threads. In particular, our atomicity checker detects errors that would be missed by standard race detectors, and it produces fewer false alarms on benign races that do not cause atomicity violations. Our experimental results also indicate that the majority of methods in our benchmarks are atomic, supporting our hypothesis that atomicity is a standard methodology in multithreaded programming.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964023", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "Williams College" + } + ], + "dblp_key": "conf/popl/FlanaganF04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964009", + "title": "Polymorphic typed defunctionalization", + "abstract": "Defunctionalization is a program transformation that aims to turn a higher-order functional program into a first-order one, that is, to eliminate the use of functions as first-class values. Its purpose is thus identical to that of closure conversion. It differs from closure conversion, however, by storing a tag, instead of a code pointer, within every closure. Defunctionalization has been used both as a reasoning tool and as a compilation technique.Defunctionalization is commonly defined and studied in the setting of a simply-typed λ-calculus, where it is shown that semantics and well-typedness are preserved. It has been observed that, in the setting of a polymorphic type system, such as ML or System F, defunctionalization is not type-preserving. In this paper, we show that extending System F with guarded algebraic data types allows recovering type preservation. This result allows adding defunctionalization to the toolbox of type-preserving compiler writers.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964009", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Nadji", + "last_name": "Gauthier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/PottierG04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964014", + "title": "Channel dependent types for higher-order mobile processes", + "abstract": "This paper introduces a new expressive theory of types for the higher-order π-calculus and demonstrates its applicability via two security analyses for higher-order code mobility. The new theory significantly improves our previous one presented in [55] by the use of channel dependent/existential types. New dependent types control dynamic change of process accessibility via channel passing, while existential types guarantee safe scope-extrusion in higher-order process passing. This solves an open issue in [55], leading to significant enlargement of original typability. The resulting typing system is coherently integrated with the linear/affine typing disciplines as well as state, concurrency and distribution [53, 5, 56, 22], allowing precise analysis of software behaviour with higher-order mobility. As illustration of the usage of the typed calculus, two basic security concerns for mobile computation, secrecy for data confidentiality and rôle-based access control for authorised resources, are analysed in a uniform type-based framework, leading to the noninterference theorem and authority-error freedom in the presence of higher-order code mobility.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964014", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/Yoshida04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964006", + "title": "Semantic types: a fresh look at the ideal model for types", + "abstract": "We present a generalization of the ideal model for recursive polymorphic types. Types are defined as sets of terms instead of sets of elements of a semantic domain. Our proof of the existence of types (computed by fixpoint of a typing operator) does not rely on metric properties, but on the fact that the identity is the limit of a sequence of projection terms. This establishes a connection with the work of Pitts on relational properties of domains. This also suggests that ideals are better understood as closed sets of terms defined by orthogonality with respect to a set of contexts.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964006", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jérôme", + "last_name": "Vouillon", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Paul-André", + "last_name": "Melliès", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "conf/popl/VouillonM04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964004", + "title": "Incremental execution of transformation specifications", + "abstract": "We aim to specify program transformations in a declarative style, and then to generate executable program transformers from such specifications. Many transformations require non-trivial program analysis to check their applicability, and it is prohibitively expensive to re-run such analyses after each transformation. It is desirable, therefore, that the analysis information is incrementally updated. We achieve this by drawing on two pieces of previous work: first, Bernhard Steffen&apos;s proposal to use model checking for certain analysis problems, and second, John Conway&apos;s theory of language factors. The first allows the neat specification of transformations, while the second opens the way for an incremental implementation. The two ideas are linked by using regular patterns instead of Steffen&apos;s modal logic: these patterns can be viewed as queries on the set of program paths.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964004", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ganesh", + "last_name": "Sittampalam", + "institution": "University of Oxford" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + }, + { + "first_name": "Ken Friis", + "last_name": "Larsen", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/popl/SittampalamML04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964005", + "title": "Formalization of generics for the .NET common language runtime", + "abstract": "We present a formalization of the implementation of generics in the .NET Common Language Runtime (CLR), focusing on two novel aspectsof the implementation: mixed specialization and sharing, and efficient support for run-time types. Some crucial constructs used in the implementation are dictionaries and run-time type representations. We formalize these aspects type-theoretically in a way that corresponds in spirit to the implementation techniques used in practice. Both the techniques and the formalization also help us understand the range of possible implementation techniques for other languages, e.g., ML, especially when additional source language constructs such as run-time types are supported. A useful by-product of this study is a type system for a subset of the polymorphic IL proposed for the .NET CLR.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964005", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dachuan", + "last_name": "Yu", + "institution": "Yale University" + }, + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Don", + "last_name": "Syme", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/YuKS04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964002", + "title": "Symbolic transfer function-based approaches to certified compilation", + "abstract": "We present a framework for the certification of compilation and of compiled programs. Our approach uses a symbolic transfer functions-based representation of programs, so as to check that source and compiled programs present similar behaviors. This checking can be done either for a concrete semantic interpretation (Translation Validation) or for an abstract semantic interpretation (Invariant Translation) of the symbolic transfer functions. We propose to design a checking procedure at the concrete level in order to validate both the transformation and the translation of abstract invariants. The use of symbolic transfer functions makes possible a better treatment of compiler optimizations and is adapted to the checking of precise invariants at the assembly level. The approach proved successful in the implementation point of view, since it rendered the translation of very precise invariants on very large assembly programs feasible.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964002", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Laboratoire de Géologie de l’École Normale Supérieure" + } + ], + "dblp_key": "conf/popl/Rival04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964024", + "title": "Separation and information hiding", + "abstract": "We investigate proof rules for information hiding, using the recent formalism of separation logic. In essence, we use the separating conjunction to partition the internal resources of a module from those accessed by the module's clients. The use of a logical connective gives rise to a form of dynamic partitioning, where we track the transfer of ownership of portions of heap storage between program components. It also enables us to enforce separation in the presence of mutable data structures with embedded addresses that may be aliased.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964024", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Seoul National University" + }, + { + "first_name": "John", + "last_name": "Reynolds", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/OHearnYR04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964015", + "title": "A bisimulation for dynamic sealing", + "abstract": "We define λseal, an untyped call-by-value λ-calculus with primitives for protecting abstract data by sealing, and develop a bisimulation proof method that is sound and complete with respect to contextual equivalence. This provides a formal basis for reasoning about data abstraction in open, dynamic settings where static techniques such as type abstraction and logical relations are not applicable.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964015", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eijiro", + "last_name": "Sumii", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/SumiiP04", + "venue": "popl", + "year": 2004 + }, + { + "paper_id": "10.1145/964001.964028", + "title": "Non-linear loop invariant generation using Gröbner bases", + "abstract": "We present a new technique for the generation of non-linear (algebraic) invariants of a program. Our technique uses the theory of ideals over polynomial rings to reduce the non-linear invariant generation problem to a numerical constraint solving problem. So far, the literature on invariant generation has been focussed on the construction of linear invariants for linear programs. Consequently, there has been little progress toward non-linear invariant generation. In this paper, we demonstrate a technique that encodes the conditions for a given template assertion being an invariant into a set of constraints, such that all the solutions to these constraints correspond to non-linear (algebraic) loop invariants of the program. We discuss some trade-offs between the completeness of the technique and the tractability of the constraint-solving problem generated. The application of the technique is demonstrated on a few examples.", + "date": "2004-01-01", + "link": "https://doi.org/10.1145/964001.964028", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sriram", + "last_name": "Sankaranarayanan", + "institution": "Stanford University" + }, + { + "first_name": "Henny B.", + "last_name": "Sipma", + "institution": "Stanford University" + }, + { + "first_name": "Zohar", + "last_name": "Manna", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/SankaranarayananSM04", + "venue": "popl", + "year": 2004 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2005.json b/data/pl_conferences/popl/2005.json new file mode 100644 index 0000000..f2a7505 --- /dev/null +++ b/data/pl_conferences/popl/2005.json @@ -0,0 +1,840 @@ +[ + { + "paper_id": "10.1145/1040305.1040314", + "title": "Synthesis of interface specifications for Java classes", + "abstract": "While a typical software component has a clearly specified (static) interface in terms of the methods and the input/output types they support, information about the correct sequencing of method calls the client must invoke is usually undocumented. In this paper, we propose a novel solution for automatically extracting such temporal specifications for Java classes. Given a Java class, and a safety property such as “the exception E should not be raised”, the corresponding (dynamic) interface is the most general way of invoking the methods in the class so that the safety property is not violated. Our synthesis method first constructs a symbolic representation of the finite state-transition system obtained from the class using predicate abstraction. Constructingthe interface then corresponds to solving a partial-information two-player game on this symbolic graph. We present a sound approach to solve this computationally-hard problem approximately using algorithms for learning finite automata and symbolic model checking for branching-time logics. We describe an implementation of the proposed techniques in the tool JIST — Java Interface Synthesis Tool—and demonstrate that the tool can construct interfaces accurately and efficiently for sample Java2SDK library classes. Categories and Subject Descriptors: D.2.4 [Software Engineering] Software/Program Verification-formal methods, model checking; D.2.1 [Software Engineering] Requirements/Specification-methodologies, tools; D.2.2 [Software", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040314", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Pavol", + "last_name": "Černý", + "institution": "University of Pennsylvania" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Wonhong", + "last_name": "Nam", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/AlurCMN05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040332", + "title": "Precise interprocedural analysis using random interpretation", + "abstract": "We describe a unified framework for random interpretation that generalizes previous randomized intraprocedural analyses, and also extends naturally to efficient interprocedural analyses. There is no such natural extension known for deterministic algorithms. We present a general technique for extending any intraprocedural random interpreter to perform a context-sensitive interprocedural analysis with only polynomial increase in running time. This technique involves computing random summaries of procedures, which are complete and probabilistically sound.As an instantiation of this general technique, we obtain the first polynomial-time randomized algorithm that discovers all linear relationships interprocedurally in a linear program. We also obtain the first polynomial-time randomized algorithm for precise interprocedural value numbering over a program with unary uninterpreted functions.We present experimental evidence that quantifies the precision and relative speed of the analysis for discovering linear relationships along two dimensions: intraprocedural vs. interprocedural, and deterministic vs. randomized. We also present results that show the variation of the error probability in the randomized analysis with changes in algorithm parameters. These results suggest that the error probability is much lower than the existing conservative theoretical bounds.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040332", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "University of California, Berkeley" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/GulwaniN05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040323", + "title": "Theoretical foundations for compensations in flow composition languages", + "abstract": "A key aspect when aggregating business processes and web services is to assure transactional properties of process ex-ecutions. Since transactions in this context may require long periods of time to complete, traditional mechanisms for guaranteeing atomicity are not always appropriate. Gen-erally the concept of long running transactions relies on a weaker notion of atomicity based on compensations. For this reason, programming languages for service composition cannot leave out two key aspects: compensations, i.e. ad hoc activities that can undo the effects of a process that fails to complete, and transactional boundaries to delimit the scope of a transactional flow. This paper presents a hierarchy of transactional calculi with increasing expressiveness. We start from a very small language in which activities can only be composed sequentially. Then, we progressively introduce parallel composition, nesting, programmable compensations and exception handling. A running example illustrates the main features of each calculus in the hierarchy.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040323", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roberto", + "last_name": "Bruni", + "institution": "University of Pisa" + }, + { + "first_name": "Hernán", + "last_name": "Melgratti", + "institution": "University of Pisa" + }, + { + "first_name": "Ugo", + "last_name": "Montanari", + "institution": "University of Pisa" + } + ], + "dblp_key": "conf/popl/BruniMM05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040313", + "title": "Slot games: a quantitative model of computation", + "abstract": "We present a games-based denotational semantics for a quantitative analysis of programming languages. We define a Hyland-Ong-style games framework called slot games, which consists of HO games augmented with a new action called token. We develop a slot-game model for the language Idealised Concurrent Algol by instrumenting the strategies in its HO game model with token actions. We show that the slot-game model is a denotational semantics induced by a notion of observation formalised in the operational theory of improvement of Sands, and we give a full abstraction result. A quantitative analysis of programs has many potential applications, from compiler optimisations to resource-constrained execution and static performance profiling. We illustrate several such applications with putative examples that would be nevertheless difficult, if not impossible, to handle using known operational techniques.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040313", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dan R.", + "last_name": "Ghica", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/Ghica05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040308", + "title": "Polymorphic bytecode: compositional compilation for Java-like languages", + "abstract": "We define compositional compilation as the ability to typecheck source code fragments in isolation, generate We define compositional compilation as the ability to typecheck source code fragments in isolation, generate corresponding binaries,and link together fragments whose mutual assumptions are satisfied, without reinspecting the code. Even though compositional compilation is a highly desirable feature, in Java-like languages it can hardly be achieved. This is due to the fact that the bytecode generated for a fragment (say, a class) is not uniquely determined by its source code, but also depends on the compilation context.We propose a way to obtain compositional compilation for Java, by introducing a polymorphic form of bytecode containing type variables (ranging over class names) and equipped with a set of constraints involving type variables. Thus, polymorphic bytecode provides a representation for all the (standard) bytecode that can be obtained by replacing type variables with classes satisfying the associated constraints.We illustrate our proposal by developing a typing and a linking algorithm. The typing algorithm compiles a class in isolation generating the corresponding polymorphic bytecode fragment and constraints on the classes it depends on. The linking algorithm takes a collection of polymorphic bytecode fragments, checks their mutual consistency, and possibly simplifies and specializes them. In particular, linking a self-contained collection of fragments either fails, or produces standard bytecode (the same as would have been produced by standard compilation of all fragments).", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040308", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Davide", + "last_name": "Ancona", + "institution": "University of Genoa" + }, + { + "first_name": "Ferruccio", + "last_name": "Damiani", + "institution": "University of Turin" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/popl/AnconaDDZ05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040309", + "title": "A simple typed intermediate language for object-oriented languages", + "abstract": "Traditional class and object encodings are difficult to use in practical type-preserving compilers because of the complexity of the encodings. We propose a simple typed intermediate language for compiling object-oriented languages and prove its soundness. The key ideas are to preserve lightweight notions of classes and objects instead of compiling them away and to separate name-based subclassing from structure-based subtyping. The language can express standard implementation techniques for both dynamic dispatch and runtime type tests. It has decidable type checking even with subtyping between quantified types with different bounds. Because of its simplicity, the language is a more suitable starting point for a practical type-preserving compiler than traditional encoding techniques.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040309", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "David", + "last_name": "Tarditi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/ChenT05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040307", + "title": "Environmental acquisition revisited", + "abstract": "In 1996, Gil and Lorenz proposed programming language constructs for specifying environmental acquisition in addition to inheritance acquisition for objects. They noticed that in many programs, objects are arranged in containment hierarchies and need to obtain information from their container objects. Therefore, if languages allowed programmers to specify such relationships directly, type systems and run-time environments could enforce the invariants that make these programming patterns work.In this paper, we present a formal version of environmental acquisition for class-based languages. Specifically, we introduce an extension of the ClassicJava model with constructs for environmental acquisition of fields and methods, a type system for the model, a reduction semantics, and a type soundness proof. We also discuss how to scale the model to a full-scale Java-like programming language.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040307", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard", + "last_name": "Cobbe", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/CobbeF05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040312", + "title": "A syntactic approach to eta equality in type theory", + "abstract": "This paper outlines an elementary approach for showing the decidability of type checking for type theories with βη-equality, relevant to foundations for modules systems and type theory-based proof systems. The key to the approach is a syntactic translation mapping terms in the βη presentation into their full η-expansions in the β presentation. Decidability of type checking is lifted from the target β presentation to the βη presentation. The approach extends to other inductive kinds with a single constructor, and is demonstrated for singletons and dependent pairs.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040312", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Healfdene", + "last_name": "Goguen", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/popl/Goguen05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040322", + "title": "Transactors: a programming model for maintaining globally consistent distributed state in unreliable environments", + "abstract": "We introduce transactors, a fault-tolerant programming model for composing loosely-coupled distributed components running in an unreliable environment such as the internet into systems that reliably maintain globally consistent distributed state. The transactor model incorporates certain elements of traditional transaction processing, but allows these elements to be composed in different ways without the need for central coordination, thus facilitating the study of distributed fault-tolerance from a semantic point of view. We formalize our approach via the τ-calculus, an extended lambda-calculus based on the actor model, and illustrate its usage through a number of examples. The τ-calculus incorporates constructs which distributed processes can use to create globally-consistent checkpoints. We provide an operational semantics for the τ-calculus, and formalize the following safety and liveness properties: first, we show that globally-consistent checkpoints have equivalent execution traces without any node failures or application-level failures, and second, we show that it is possible to reach globally-consistent checkpoints provided that there is some bounded failure-free interval during which checkpointing can occur.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040322", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John K.", + "last_name": "Field", + "institution": "IBM (United States)" + }, + { + "first_name": "Carlos A.", + "last_name": "Varela", + "institution": "Rensselaer Polytechnic Institute" + } + ], + "dblp_key": "conf/popl/FieldV05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040318", + "title": "Communicating quantum processes", + "abstract": "We define a language CQP (Communicating Quantum Processes) for modelling systems which combine quantum and classical communication and computation. CQP combines the communication primitives of the pi-calculus with primitives for measurement and transformation of quantum state; in particular, quantum bits (qubits) can be transmitted from process to process along communication channels. CQP has a static type system which classifies channels, distinguishes between quantum and classical data, and controls the use of quantum state. We formally define the syntax, operational semantics and type system of CQP, prove that the semantics preserves typing, and prove that typing guarantees that each qubit is owned by a unique process within a system. We illustrate CQP by defining models of several quantum communication systems, and outline our plans for using CQP as the foundation for formal analysis and verification of combined quantum and classical systems.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040318", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon J.", + "last_name": "Gay", + "institution": "University of Glasgow" + }, + { + "first_name": "Rajagopal", + "last_name": "Nagarajan", + "institution": "University of Warwick" + } + ], + "dblp_key": "conf/popl/GayN05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040333", + "title": "A framework for numeric analysis of array operations", + "abstract": "Automatic discovery of relationships among values of array elements is a challenging problem due to the unbounded nature of arrays. We present a framework for analyzing array operations that is capable of capturing numeric properties of array elements.In particular, the analysis is able to establish that all array elements are initialized by an array-initialization loop, as well as to discover numeric constraints on the values of initialized elements.The analysis is based on the combination of canonical abstraction and summarizing numeric domains. We describe a prototype implementation of the analysis and discuss our experience with applying the prototype to several examples, including the verification of correctness of an insertion-sort procedure.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040333", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Denis", + "last_name": "Gopan", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/GopanRS05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040325", + "title": "Combinators for bi-directional tree transformations: a linguistic approach to the view update problem", + "abstract": "We propose a novel approach to the well-known view update problem for the case of tree-structured data: a domain-specific programming language in which all expressions denote bi-directional transformations on trees. In one direction, these transformations---dubbed lenses---map a \"concrete\" tree into a simplified \"abstract view\"; in the other, they map a modified abstract view, together with the original concrete tree, to a correspondingly modified concrete tree. Our design emphasizes both robustness and ease of use, guaranteeing strong well-behavedness and totality properties for well-typed lenses.We identify a natural space of well-behaved bi-directional transformations over arbitrary structures, study definedness and continuity in this setting, and state a precise connection with the classical theory of \"update translation under a constant complement\" from databases. We then instantiate this semantic framework in the form of a collection of lens combinators that can be assembled to describe transformations on trees. These combinators include familiar constructs from functional programming (composition, mapping, projection, conditionals, recursion) together with some novel primitives for manipulating trees (splitting, pruning, copying, merging, etc.). We illustrate the expressiveness of these combinators by developing a number of bi-directional list-processing transformations as derived forms.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040325", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J. Nathan", + "last_name": "Foster", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Michael B.", + "last_name": "Greenwald", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Jonathan T.", + "last_name": "Moore", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Alan", + "last_name": "Schmitt", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/FosterGMPS05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040319", + "title": "Downgrading policies and relaxed noninterference", + "abstract": "In traditional information-flow type systems, the security policy is often formalized as noninterference properties. However, noninterference alone is too strong to express security properties useful in practice. If we allow downgrading in such systems, it is challenging to formalize the security policy as an extensional property of the system.This paper presents a generalized framework of downgrading policies. Such policies can be specified in a simple and tractable language and can be statically enforced by mechanisms such as type systems. The security guarantee is then formalized as a concise extensional property using program equivalences. This relaxed noninterference generalizes traditional pure noninterference and precisely characterizes the information released due to downgrading.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040319", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peng", + "last_name": "Li", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/LiZ05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040315", + "title": "Dynamic partial-order reduction for model checking software", + "abstract": "We present a new approach to partial-order reduction for model checking software. This approach is based on initially exploring an arbitrary interleaving of the various concurrent processes/threads, and dynamically tracking interactions between these to identify backtracking points where alternative paths in the state space need to be explored. We present examples of multi-threaded programs where our new dynamic partial-order reduction technique significantly reduces the search space, even though traditional partial-order algorithms are helpless.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040315", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/popl/FlanaganG05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040316", + "title": "Proof-guided underapproximation-widening for multi-process systems", + "abstract": "This paper presents a procedure for the verification of multi-process systems based on considering a series of underapproximated models. The procedure checks models with an increasing set of allowed interleavings of the given set of processes, starting from a single interleaving. The procedure relies on SAT solvers' ability to produce proofs of unsatisfiability: from these proofs it derives information that guides the process of adding interleavings on the one hand, and determines termination on the other. The presented approach is integrated in a SAT-based Bounded Model Checking (BMC) framework. Thus, a BMC formulation of a multi-process system is introduced, which allows controlling which interleavings are considered. Preliminary experimental results demonstrate the practical impact of the presented method.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040316", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Orna", + "last_name": "Grümberg", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Flavio", + "last_name": "Lerda", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ofer", + "last_name": "Strichman", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Theobald", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/GrumbergLST05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040324", + "title": "From sequential programs to multi-tier applications by program transformation", + "abstract": "Modern applications are designed in multiple tiers to separate concerns. Since each tier may run at a separate location, middleware is required to mediate access between tiers. However, introducing this middleware is tiresome and error-prone.We propose a multi-tier calculus and a splitting transformation to address this problem. The multi-tier calculus serves as a sequential core programming language for constructing a multi-tier application. The application can be developed in the sequential setting. Splitting extracts one process per tier from the sequential program such that their concurrent execution behaves like the original program.The splitting transformation starts from an assignment of primitive operations to tiers. A program analysis determines communication requirements and inserts remote procedure calls. The next transformation step performs resource pooling: it optimizes the communication behavior by transforming sequences of remote procedure calls to a stream-based protocol. The final transformation step splits the resulting program into separate communicating processes.The multi-tier calculus is also applicable to the construction of interactive Web applications. It facilitates their development by providing a uniform programming framework for client-side and server-side programming.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040324", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Neubauer", + "institution": "University of Freiburg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/popl/NeubauerT05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040306", + "title": "Associated types with class", + "abstract": "Haskell's type classes allow ad-hoc overloading, or type-indexing, of functions. A natural generalisation is to allow type-indexing of data types as well. It turns out that this idea directly supports a powerful form of abstraction called associated types, which are available in C++ using traits classes. Associated types are useful in many applications, especially for self-optimising libraries that adapt their data representations and algorithms in a type-directed manner.In this paper, we introduce and motivate associated types as a rather natural generalisation of Haskell's existing type classes. Formally, we present a type system that includes a type-directed translation into an explicitly typed target language akin to System F; the existence of this translation ensures that the addition of associated data types to an existing Haskell compiler only requires changes to the front end.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040306", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "UNSW Sydney" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/ChakravartyKJM05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040331", + "title": "Region-based shape analysis with tracked locations", + "abstract": "This paper proposes a novel approach to shape analysis: using local reasoning about individual heap locations instead of global reasoning about entire heap abstractions. We present an inter-procedural shape analysis algorithm for languages with destructive updates. The key feature is a novel memory abstraction that differs from traditional abstractions in two ways. First, we build the shape abstraction and analysis on top of a pointer analysis. Second, we decompose the shape abstraction into a set of independent configurations, each of which characterizes one single heap location. Our approach: 1) leads to simpler algorithm specifications, because of local reasoning about the single location; 2) leads to efficient algorithms, because of the smaller granularity of the abstraction; and 3) makes it easier to develop context-sensitive, demand-driven, and incremental shape analyses.We also show that the analysis can be used to enable the static detection of memory errors in programs with explicit deallocation. We have built a prototype tool that detects memory leaks and accesses through dangling pointers in C programs. The experiments indicate that the analysis is sufficiently precise to detect errors with low false positive rates; and is sufficiently lightweight to scale to larger programs. For a set of three popular C programs, the tool has analyzed about 70K lines of code in less than 2 minutes and has produced 97 warnings, 38 of which were actual errors.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040331", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brian", + "last_name": "Hackett", + "institution": "Cornell University" + }, + { + "first_name": "Radu", + "last_name": "Rugina", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/HackettR05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040328", + "title": "Context logic and tree update", + "abstract": "Spatial logics have been used to describe properties of tree-like structures (Ambient Logic) and in a Hoare style to reason about dynamic updates of heap-like structures (Separation Logic). We integrat this work by analyzing dynamic updates to tree-like structures with pointers (such as XML with identifiers and idrefs). Naíve adaptations of the Ambient Logic are not expressive enough to capture such local updates. Instead we must explicitly reason about arbitrary tree contexts in order to capture updates throughout the tree. We introduce Context Logic, study its proof theory and models, and show how it generalizes Separation Logic and its general theory BI. We use it to reason locally about a small imperative programming language for updating trees, using a Hoare logic in the style of O'Hearn, Reynolds and Yang, and show that weakest preconditions are derivable. We demonstrate the robustness of our approach by using Context Logic to capture the locality of term rewrite systems.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040328", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "University of London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "University of London" + }, + { + "first_name": "Uri", + "last_name": "Zarfaty", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/CalcagnoGZ05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040327", + "title": "Permission accounting in separation logic", + "abstract": "A lightweight logical approach to race-free sharing of heap storage between concurrent threads is described, based on the notion of permission to access. Transfer of permission between threads, subdivision and combination of permission is discussed. The roots of the approach are in Boyland's [3] demonstration of the utility of fractional permissions in specifying non-interference between concurrent threads. We add the notion of counting permission, which mirrors the programming technique called permission counting. Both fractional and counting permissions permit passivity, the specification that a program can be permitted to access a heap cell yet prevented from altering it. Models of both mechanisms are described. The use of two different mechanisms is defended. Some interesting problems are acknowledged and some intriguing possibilities for future development, including the notion of resourcing as a step beyond typing, are paraded.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040327", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard", + "last_name": "Bornat", + "institution": "Middlesex University" + }, + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "Imperial College London" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/BornatCOP05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040329", + "title": "Connecting effects and uniqueness with adoption", + "abstract": "In a previous paper, we discussed how the concepts of uniqueness and effects are interdependent. In this paper, we show how &quot;Adoption and Focus,&quot; a proposal for handling linear pointers in shared variables can be extended to connect the two concepts. Our innovations include the ability to define adoption relations between individual fields rather than whole objects, and the ability to &quot;focus&quot; on more than one adoptee at a time. The resulting system uses recursive alias types, &quot;permission closures&quot; and &quot;conditional permissions.&quot; Then we show how previously proposed effect and uniqueness annotations can be represented in the type system.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040329", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Boyland", + "institution": "University of Wisconsin–Milwaukee" + }, + { + "first_name": "William", + "last_name": "Retert", + "institution": "University of Wisconsin–Milwaukee" + } + ], + "dblp_key": "conf/popl/BoylandR05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040326", + "title": "Separation logic and abstraction", + "abstract": "In this paper we address the problem of writing specifications for programs that use various forms of modularity, including procedures and Java-like classes. We build on the formalism of separation logic and introduce the new notion of an abstract predicate and, more generally, abstract predicate families. This provides a flexible mechanism for reasoning about the different forms of abstraction found in modern programming languages, such as abstract datatypes and objects. As well as demonstrating the soundness of our proof system, we illustrate its utility with a series of examples.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040326", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "University of Cambridge" + }, + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/ParkinsonB05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040320", + "title": "A probabilistic language based upon sampling functions", + "abstract": "As probabilistic computations play an increasing role in solving various problems, researchers have designed probabilistic languages that treat probability distributions as primitive datatypes. Most probabilistic languages, however, focus only on discrete distributions and have limited expressive power. In this paper, we present a probabilistic language, called λο, which uniformly supports all kinds of probability distributions -- discrete distributions, continuous distributions, and even those belonging to neither group. Its mathematical basis is sampling functions, i.e., mappings from the unit interval (0.0,1.0] to probability domains.We also briefly describe the implementation of λο as an extension of Objective CAML and demonstrate its practicality with three applications in robotics: robot localization, people tracking, and robotic mapping. All experiments have been carried out with real robots.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040320", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sungwoo", + "last_name": "Park", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sebastian", + "last_name": "Thrun", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/ParkPT05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040336", + "title": "The Java memory model", + "abstract": "This paper describes the new Java memory model, which has been revised as part of Java 5.0. The model specifies the legal behaviors for a multithreaded program; it defines the semantics of multithreaded Java programs and partially determines legal implementations of Java virtual machines and compilers.The new Java model provides a simple interface for correctly synchronized programs -- it guarantees sequential consistency to data-race-free programs. Its novel contribution is requiring that the behavior of incorrectly synchronized programs be bounded by a well defined notion of causality. The causality requirement is strong enough to respect the safety and security properties of Java and weak enough to allow standard compiler and hardware optimizations. To our knowledge, other models are either too weak because they do not provide for sufficient safety/security, or are too strong because they rely on a strong notion of data and control dependences that precludes some standard compiler transformations.Although the majority of what is currently done in compilers is legal, the new model introduces significant differences, and clearly defines the boundaries of legal transformations. For example, the commonly accepted definition for control dependence is incorrect for Java, and transformations based on it may be invalid.In addition to providing the official memory model for Java, we believe the model described here could prove to be a useful basis for other programming languages that currently lack well-defined models, such as C++ and C#.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040336", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Manson", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "William", + "last_name": "Pugh", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Sarita V.", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/MansonPA05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040335", + "title": "Automated soundness proofs for dataflow analyses and transformations via local rules", + "abstract": "We present Rhodium, a new language for writing compiler optimizations that can be automatically proved sound. Unlike our previous work on Cobalt, Rhodium expresses optimizations using explicit dataflow facts manipulated by local propagation and transformation rules. This new style allows Rhodium optimizations to be mutually recursively defined, to be automatically composed, to be interpreted in both flow-sensitive and -insensitive ways, and to be applied interprocedurally given a separate context-sensitivity strategy, all while retaining soundness. Rhodium also supports infinite analysis domains while guaranteeing termination of analysis. We have implemented a soundness checker for Rhodium and have specified and automatically proven the soundness of all of Cobalt's optimizations plus a variety of optimizations not expressible in Cobalt, including Andersen's points-to analysis, arithmetic-invariant detection, loop-induction-variable strength reduction, and redundant array load elimination.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040335", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of Washington" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "UCLA Health" + }, + { + "first_name": "Erika", + "last_name": "Rice", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/LernerMRC05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040311", + "title": "A bisimulation for type abstraction and recursion", + "abstract": "We present a sound, complete, and elementary proof method, based on bisimulation, for contextual equivalence in a λ-calculus with full universal, existential, and recursive types. Unlike logical relations (either semantic or syntactic), our development is elementary, using only sets and relations and avoiding advanced machinery such as domain theory, admissibility, and ΤΤ-closure. Unlike other bisimulations, ours is complete even for existential types. The key idea is to consider sets of relations---instead of just relations---as bisimulations.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040311", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eijiro", + "last_name": "Sumii", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/SumiiP05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040321", + "title": "Mutatis mutandis: safe and predictable dynamic software updating", + "abstract": "Dynamic software updates can be used to fix bugs or add features to a running program without downtime. Essential for some applications and convenient for others, low-level dynamic updating has been used for many years. Perhaps surprisingly, there is little high-level understanding or language support to help programmers write dynamic updates effectively.To bridge this gap, we present Proteus, a core calculus for dynamic software updating in C-like languages that is flexible, safe, and predictable. Proteus supports dynamic updates to functions (even active ones), to named types and to data, allowing on-line evolution to match source-code evolution as we have observed it in practice. We ensure updates are type-safe by checking for a property we call \"con-freeness\" for updated types t at the point of update. This means that non-updated code will not use t concretely beyond that point (concrete usages are via explicit coercions) and thus t's representation can safely change. We show how con-freeness can be enforced dynamically for a particular program state. We additionally define a novel and efficient static updateability analysis to establish con-freeness statically, and can thus automatically infer program points at which all future (well-formed) updates will be type-safe. We have implemented our analysis for C and tested it on several well-known programs.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040321", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gareth", + "last_name": "Stoyle", + "institution": "University of Cambridge" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/popl/StoyleHBSN05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040310", + "title": "Parametric polymorphism for XML", + "abstract": "Despite the extensiveness of recent investigations on static typing for XML, parametric polymorphism has rarely been treated. This well-established typing discipline can also be useful in XML processing in particular for programs involving \"parametric schemas,\" i.e., schemas parameterized over other schemas (e.g., SOAP). The difficulty in treating polymorphism for XML lies in how to extend the \"semantic\" approach used in the mainstream (monomorphic) XML type systems. A naive extension would be \"semantic\" quantification over all substitutions for type variables. However, this approach reduces to an NEXPTIME-complete problem for which no practical algorithm is known. In this paper, we propose a different method that smoothly extends the semantic approach yet is algorithmically easier. In this, we devise a novel and simple marking technique, where we interpret a polymorphic type as a set of values with annotations of which subparts are parameterized. We exploit this interpretation in every ingredient of our polymorphic type system such as subtyping, inference of type arguments, and so on. As a result, we achieve a sensible system that directly represents a usual expected behavior of polymorphic type systems---\"values of variable types are never reconstructed\"---in a reminiscence of Reynold's parametricity theory. Also, we obtain a set of practical algorithms for typechecking by local modifications to existing ones for a monomorphic system.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040310", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Haruo", + "last_name": "Hosoya", + "institution": "The University of Tokyo" + }, + { + "first_name": "Alain", + "last_name": "Frisch", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "École Normale Supérieure" + } + ], + "dblp_key": "conf/popl/HosoyaFC05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040317", + "title": "Transition predicate abstraction and fair termination", + "abstract": "Predicate abstraction is the basis of many program verification tools. Until now, the only known way to overcome the inherent limitation of predicate abstraction to safety properties was to manually annotate the finite-state abstraction of a program. We extend predicate abstraction to transition predicate abstraction. Transition predicate abstraction goes beyond the idea of finite abstract-state programs (and checking the absence of loops). Instead, our abstraction algorithm transforms a program into a finite abstract-transition program. Then, a second algorithm checks fair termination. The two algorithms together yield an automated method for the verification of liveness properties under full fairness assumptions (justice and compassion). In summary, we exhibit principles that extend the applicability of predicate abstraction-based program verification to the full set of temporal properties.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040317", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "Max Planck Society" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Max Planck Society" + } + ], + "dblp_key": "conf/popl/PodelskiR05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040334", + "title": "Scalable error detection using boolean satisfiability", + "abstract": "We describe a software error-detection tool that exploits recent advances in boolean satisfiability (SAT) solvers. Our analysis is path sensitive, precise down to the bit level, and models pointers and heap data. Our approach is also highly scalable, which we achieve using two techniques. First, for each program function, several optimizations compress the size of the boolean formulas that model the control- and data-flow and the heap locations accessed by a function. Second, summaries in the spirit of type signatures are computed for each function, allowing inter-procedural analysis without a dramatic increase in the size of the boolean constraints to be solved.We demonstrate the effectiveness of our approach by constructing a lock interface inference and checking tool. In an interprocedural analysis of more than 23,000 lock related functions in the latest Linux kernel, the checker generated 300 warnings, of which 179 were unique locking errors, a false positive rate of only 40%.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040334", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yichen", + "last_name": "Xie", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/XieA05", + "venue": "popl", + "year": 2005 + }, + { + "paper_id": "10.1145/1040305.1040330", + "title": "A semantics for procedure local heaps and its abstractions", + "abstract": "The goal of this work is to develop compile-time algorithms for automatically verifying properties of imperative programs that manipulate dynamically allocated storage. The paper presents an analysis method that uses a characterization of a procedure's behavior in which parts of the heap not relevant to the procedure are ignored. The paper has two main parts: The first part introduces a non-standard concrete semantics, LSL, in which called procedures are only passed parts of the heap. In this semantics, objects are treated specially when they separate the \"local heap\" that can be mutated by a procedure from the rest of the heap, which---from the viewpoint of that procedure---is non-accessible and immutable. The second part concerns abstract interpretation of LSL and develops a new static-analysis algorithm using canonical abstraction.", + "date": "2005-01-12", + "link": "https://doi.org/10.1145/1040305.1040330", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Jörg", + "last_name": "Bauer", + "institution": "Saarland University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Reinhard", + "last_name": "Wilhelm", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/popl/RinetzkyBRSW05", + "venue": "popl", + "year": 2005 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2006.json b/data/pl_conferences/popl/2006.json new file mode 100644 index 0000000..4a19ccd --- /dev/null +++ b/data/pl_conferences/popl/2006.json @@ -0,0 +1,940 @@ +[ + { + "paper_id": "10.1145/1111037.1111070", + "title": "The essence of command injection attacks in web applications", + "abstract": "Web applications typically interact with a back-end database to retrieve persistent data and then present the data to the user as dynamically generated output, such as HTML web pages. However, this interaction is commonly done through a low-level API by dynamically constructing query strings within a general-purpose programming language, such as Java. This low-level interaction is ad hoc because it does not take into account the structure of the output language. Accordingly, user inputs are treated as isolated lexical entities which, if not properly sanitized, can cause the web application to generate unintended output. This is called a command injection attack, which poses a serious threat to web application security. This paper presents the first formal definition of command injection attacks in the context of web applications, and gives a sound and complete algorithm for preventing them based on context-free grammars and compiler parsing techniques. Our key observation is that, for an attack to succeed, the input that gets propagated into the database query or the output document must change the intended syntactic structure of the query or document. Our definition and algorithm are general and apply to many forms of command injection attacks. We validate our approach with SqlCheckS, an implementation for the setting of SQL command injection attacks. We evaluated SqlCheckS on real-world web applications with systematically compiled real-world attack data as input. SqlCheckS produced no false positives or false negatives, incurred low runtime overhead, and applied straightforwardly to web applications written in different languages.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111070", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + }, + { + "first_name": "Gary", + "last_name": "Wassermann", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/popl/SuW06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111063", + "title": "Interruptible iterators", + "abstract": "This paper introduces interruptible iterators, a language feature that makes expressive iteration abstractions much easier to implement. Iteration abstractions are valuable for software design, as shown by their frequent use in well-designed data structure libraries such as the Java Collections Framework. While Java iterators support iteration abstraction well from the standpoint of client code, they are awkward to implement correctly and efficiently, especially if the iterator needs to support imperative update of the underlying collection, such as removing the current element. Some languages, such as CLU and C# 2.0, support iteration through a limited coroutine mechanism, but these mechanisms do not support imperative updates. Interruptible iterators are more powerful coroutines in which the loop body is able to interrupt the iterator with requests to perform updates. Interrupts are similar to exceptions, but propagate differently and have resumption semantics. Interruptible iterators have been implemented as part of the JMatch programming language, an extended version of Java. A JMatch reimplementation of the Java Collections Framework shows that implementations can be made substantially shorter and simpler; performance results show that this language mechanism can also be implemented efficiently.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111063", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jed", + "last_name": "Liu", + "institution": "Cornell University" + }, + { + "first_name": "Aaron", + "last_name": "Kimball", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/LiuKM06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111041", + "title": "Simplifying reductions", + "abstract": "We present optimization techniques for high level equational programs that are generalizations of affine control loops (ACLs). Significant parts of the SpecFP and PerfectClub benchmarks are ACLs. They often contain reductions: associative and commutative operators applied to a collection of values. They also often exhibit reuse: intermediate values computed or used at different index points being identical. We develop various techniques to automatically exploit reuse to simplify the computational complexity of evaluating reductions. Finally, we present an algorithm for the optimal application of such simplifications resulting in an equivalent specification with minimum complexity.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111041", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gautam", + "last_name": "", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Sanjay", + "last_name": "Rajopadhye", + "institution": "Colorado State University" + } + ], + "dblp_key": "conf/popl/GuptaR06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111059", + "title": "Hybrid type checking", + "abstract": "Traditional static type systems are very effective for verifying basic interface specifications, but are somewhat limited in the kinds specifications they support. Dynamically-checked contracts can enforce more precise specifications, but these are not checked until run time, resulting in incomplete detection of defects. Hybrid type checking is a synthesis of these two approaches that enforces precise interface specifications, via static analysis where possible, but also via dynamic checks where necessary. This paper explores the key ideas and implications of hybrid type checking, in the context of the simply-typed A-calculus with arbitrary refinements of base types.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111059", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/popl/Flanagan06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111038", + "title": "Why dependent types matter", + "abstract": "Language designers have in recent years proposed a wealth of richer type systems for programming which seek to extend the range of statically enforced guarantees on data and code. Most such proposals have been evolutionary extensions of ML or Haskell, offering programmers a balanced compromise between expressive strength and existing well-understood technology. Typically they revolve around type- or kind-indexed types such as GADTs, supported by limited equality reasoning at the type-checking level, thus separating the dynamic behaviour of programs from the (simpler) static behaviour of indexing information occurring in their types.I want to argue in this talk for a more radical departure from such practice by examining full spectrum type dependency, lifting such restrictions on the data upon which types may depend. Conor McBride and I designed the language EPIGRAM for experiments in programming with inductive families of data (of which GADTs are a special case). Using it for illustration, I will explore some of the possibilities and challenges afforded by full spectrum type dependency at the static and dynamic level:", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111038", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James", + "last_name": "McKinna", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/popl/McKinna06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111043", + "title": "Engineering with logic: HOL specification and symbolic-evaluation testing for TCP implementations", + "abstract": "The TCP/IP protocols and Sockets API underlie much of modern computation, but their semantics have historically been very complex and ill-defined. The real standard is the de facto one of the common implementations, including, for example, the 15,000--20,000 lines of C in the BSD implementation. Dealing rigorously with the behaviour of such bodies of code is challenging.We have recently developed a post-hoc specification of TCP, UDP, and Sockets that is rigorous, detailed, readable, has broad coverage, and is remarkably accurate. In this paper we describe the novel techniques that were required.Working within a general-purpose proof assistant (HOL), we developed language idioms (within higher-order logic) in which to write the specification: operational semantics with nondeterminism, time, system calls, monadic relational programming, etc. We followed an experimental semantics approach, validating the specification against several thousand traces captured from three implementations (FreeBSD, Linux, and WinXP). Many differences between these were identified, and a number of bugs. Validation was done using a special-purpose symbolic model checker programmed above HOL.We suggest that similar logic engineering techniques could be applied to future critical software infrastructure at design time, leading to cleaner designs and (via specification-based testing using a similar checker) more predictable implementations.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111043", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steve", + "last_name": "Bishop", + "institution": "Bridge University" + }, + { + "first_name": "Matthew", + "last_name": "Fairbairn", + "institution": "University of Cambridge" + }, + { + "first_name": "Michael", + "last_name": "Norrish", + "institution": "Canberra (United Kingdom)" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Michael", + "last_name": "Smith", + "institution": "University of Cambridge" + }, + { + "first_name": "Keith", + "last_name": "Wansbrough", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/BishopFNSSW06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111055", + "title": "Compiler-directed channel allocation for saving power in on-chip networks", + "abstract": "Increasing complexity in the communication patterns of embedded applications parallelized over multiple processing units makes it difficult to continue using the traditional bus-based on-chip communication techniques. The main contribution of this paper is to demonstrate the importance of compiler technology in reducing power consumption of applications designed for emerging multi processor, NoC (Network-on-Chip) based embedded systems. Specifically, we propose and evaluate a compiler-directed approach to NoC power management in the context of array-intensive applications, used frequently in embedded image/video processing. The unique characteristic of the compiler-based approach proposed in this paper is that it increases the idle periods of communication channels by reusing the same set of channels for as many communication messages as possible. The unused channels in this case take better advantage of the underlying power saving mechanism employed by the network architecture. However, this channel reuse optimization should be applied with care as it can hurt performance if two or more simultaneous communications are mapped onto the same set of channels. Therefore, the problem addressed in this paper is one of reducing the number of channels used to implement a set of communications without increasing the communication latency significantly. To test the effectiveness of our approach, we implemented it within an optimizing compiler and performed experiments using twelve application codes and a network simulation environment. Our experiments show that the proposed compiler-based approach is very successful in practice and works well under both hardware based and software based channel turn-off schemes.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111055", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Guangyu", + "last_name": "Chen", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Feihui", + "last_name": "Li", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/ChenLK06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111066", + "title": "Certified assembly programming with embedded code pointers", + "abstract": "Embedded code pointers (ECPs) are stored handles of functions and continuations commonly seen in low-level binaries as well as functional or higher-order programs. ECPs are known to be very hard to support well in Hoare-logic style verification systems. As a result, existing proof-carrying code (PCC) systems have to either sacrifice the expressiveness or the modularity of program specifications, or resort to construction of complex semantic models. In Reynolds's LICS'02 paper, supporting ECPs is listed as one of the main open problems for separation logic.In this paper we present a simple and general technique for solving the ECP problem for Hoare-logic-based PCC systems. By adding a small amount of syntax to the assertion language, we show how to combine semantic consequence relation with syntactic proof techniques. The result is a new powerful framework that can perform modular reasoning on ECPs while still retaining the expressiveness of Hoare logic. We show how to use our techniques to support polymorphism, closures, and other language extensions and how to solve the ECP problem for separation logic. Our system is fully mechanized. We give its complete soundness proof and a full verification of Reynolds's CPS-style \"list-append\" example in the Coq proof assistant.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111066", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhaozhong", + "last_name": "Ni", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/NiS06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111042", + "title": "Formal certification of a compiler back-end or: programming a compiler with a proof assistant", + "abstract": "This paper reports on the development and formal certification (proof of semantic preservation) of a compiler from Cminor (a C-like imperative language) to PowerPC assembly code, using the Coq proof assistant both for programming the compiler and for proving its correctness. Such a certified compiler is useful in the context of formal methods applied to the certification of critical software: the certification of the compiler guarantees that the safety properties proved on the source code hold for the executable compiled code as well.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111042", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Leroy06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111060", + "title": "A polymorphic modal type system for lisp-like multi-staged languages", + "abstract": "This article presents a polymorphic modal type system and its principal type inference algorithm that conservatively extend ML by all of Lisp's staging constructs (the quasi-quotation system). The combination is meaningful because ML is a practical higher-order, impure, and typed language, while Lisp's quasi-quotation system has long evolved complying with the demands from multi-staged programming practices. Our type system supports open code, unrestricted operations on references, intentional variable-capturing substitution as well as capture-avoiding substitution, and lifting values into code, whose combination escaped all the previous systems.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111060", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ik-Soon", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + }, + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "Imperial Valley College" + } + ], + "dblp_key": "conf/popl/KimYC06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111068", + "title": "Autolocker: synchronization inference for atomic sections", + "abstract": "The movement to multi-core processors increases the need for simpler, more robust parallel programming models. Atomic sections have been widely recognized for their ease of use. They are simpler and safer to use than manual locking and they increase modularity. But existing proposals have several practical problems, including high overhead and poor interaction with I/O. We present pessimistic atomic sections, a fresh approach that retains many of the advantages of optimistic atomic sections as seen in \"transactional memory\" without sacrificing performance or compatibility. Pessimistic atomic sections employ the locking mechanisms familiar to programmers while relieving them of most burdens of lock-based programming, including deadlocks. Significantly, pessimistic atomic sections separate correctness from performance: they allow programmers to extract more parallelism via finer-grained locking without fear of introducing bugs. We believe this property is crucial for exploiting multi-core processor designs.We describe a tool, Autolocker, that automatically converts pessimistic atomic sections into standard lock-based code. Autolocker relies extensively on program analysis to determine a correct locking policy free of deadlocks and race conditions. We evaluate the expressiveness of Autolocker by modifying a 50,000 line high-performance web server to use atomic sections while retaining the original locking policy. We analyze Autolocker's performance using microbenchmarks, where Autolocker outperforms software transactional memory by more than a factor of 3.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111068", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bill", + "last_name": "McCloskey", + "institution": "Berkeley College" + }, + { + "first_name": "Feng", + "last_name": "Zhou", + "institution": "Berkeley College" + }, + { + "first_name": "David", + "last_name": "Gay", + "institution": "Intel (United States)" + }, + { + "first_name": "Eric", + "last_name": "Brewer", + "institution": "Intel (United Kingdom)" + } + ], + "dblp_key": "conf/popl/McCloskeyZGB06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111056", + "title": "Fast and loose reasoning is morally correct", + "abstract": "Functional programmers often reason about programs as if they were written in a total language, expecting the results to carry over to non-total (partial) languages. We justify such reasoning.Two languages are defined, one total and one partial, with identical syntax. The semantics of the partial language includes partial and infinite values, and all types are lifted, including the function spaces. A partial equivalence relation (PER) is then defined, the domain of which is the total subset of the partial language. For types not containing function spaces the PER relates equal values, and functions are related if they map related values to related values.It is proved that if two closed terms have the same semantics in the total language, then they have related semantics in the partial language. It is also shown that the PER gives rise to a bicartesian closed category which can be used to reason about values in the domain of the relation.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111056", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nils Anders", + "last_name": "Danielsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Patrik", + "last_name": "Jansson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/DanielssonHJG06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111044", + "title": "Decidability and proof systems for language-based noninterference relations", + "abstract": "Noninterference is the basic semantical condition used to account for confidentiality and integrity-related properties in programming languages. There appears to be an at least implicit belief in the programming languages community that partial approaches based on type systems or other static analysis techniques are necessary for noninterference analyses to be tractable. In this paper we show that this belief is not necessarily true. We focus on the notion of strong low bisimulation proposed by Sabelfeld and Sands. We show that, relative to a decidable expression theory, strong low bisimulation is decidable for a simple parallel while-language, and we give a sound and relatively complete proof system for deriving noninterference assertions. The completeness proof provides an effective proof search strategy. Moreover, we show that common alternative noninterference relations based on traces or input-output relations are undecidable. The first part of the paper is cast in terms of multi-level security. In the second part of the paper we generalize the setting to accommodate a form of intransitive interference. We discuss the model and show how the decidability and proof system results generalize to this richer setting.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111044", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mads", + "last_name": "Dam", + "institution": "Kista Photonics Research Center" + } + ], + "dblp_key": "conf/popl/Dam06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111051", + "title": "A fixpoint calculus for local and global program flows", + "abstract": "We define a new fixpoint modal logic, the visibly pushdown μ-calculus (VP-μ), as an extension of the modal μ-calculus. The models of this logic are execution trees of structured programs where the procedure calls and returns are made visible. This new logic can express pushdown specifications on the model that its classical counterpart cannot, and is motivated by recent work on visibly pushdown languages [4]. We show that our logic naturally captures several interesting program specifications in program verification and dataflow analysis. This includes a variety of program specifications such as computing combinations of local and global program flows, pre/post conditions of procedures, security properties involving the context stack, and interprocedural dataflow analysis properties. The logic can capture flow-sensitive and inter-procedural analysis, and it has constructs that allow skipping procedure calls so that local flows in a procedure can also be tracked. The logic generalizes the semantics of the modal μ-calculus by considering summaries instead of nodes as first-class objects, with appropriate constructs for concatenating summaries, and naturally captures the way in which pushdown models are model-checked. The main result of the paper is that the model-checking problem for VP-μ is effectively solvable against pushdown models with no more effort than that required for weaker logics such as CTL. We also investigate the expressive power of the logic VP-μ: we show that it encompasses all properties expressed by a corresponding pushdown temporal logic on linear structures (caret [2]) as well as by the classical μ-calculus. This makes VP-μ the most expressive known program logic for which algorithmic software model checking is feasible. In fact, the decidability of most known program logics (μ-calculus, temporal logics LTL and CTL, caret, etc.) can be understood by their interpretation in the monadic second-order logic over trees. This is not true for the logic VP-μ, making it a new powerful tractable program logic.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111051", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/AlurCM06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111073", + "title": "Staged allocation: a compositional technique for specifying and implementing procedure calling conventions", + "abstract": "We present staged allocation, a technique for specifying calling conventions by composing tiny allocators called stages. A specification written using staged allocation has a precise, formal semantics, and it can be executed directly inside a compiler. Specifications of nine standard C~calling conventions range in size from 15 to 30 lines each. An implementation of staged allocation takes about 250 lines of ML or 650~lines of C++. Each specification can be used not only to help a compiler implement the calling convention but also to generate a test suite.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111073", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Reuben", + "last_name": "Olinsky", + "institution": "Harvard University Press" + }, + { + "first_name": "Christian", + "last_name": "Lindig", + "institution": "Harvard University Press" + }, + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/OlinskyLR06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111045", + "title": "On flow-sensitive security types", + "abstract": "This article investigates formal properties of a family of semantically sound flow-sensitive type systems for tracking information flow in simple While programs. The family is indexed by the choice of flow lattice.By choosing the flow lattice to be the powerset of program variables, we obtain a system which, in a very strong sense, subsumes all other systems in the family (in particular, for each program, it provides a principal typing from which all others may be inferred). This distinguished system is shown to be equivalent to, though more simply described than, Amtoft and Banerjee's Hoare-style independence logic (SAS'04).In general, some lattices are more expressive than others. Despite this, we show that no type system in the family can give better results for a given choice of lattice than the type system for that lattice itself.Finally, for any program typeable in one of these systems, we show how to construct an equivalent program which is typeable in a simple flow-insensitive system. We argue that this general approach could be useful in a proof-carrying-code setting.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111045", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Hunt", + "institution": "City, University of London" + }, + { + "first_name": "David", + "last_name": "Sands", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/HuntS06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111039", + "title": "The next 700 data description languages", + "abstract": "In the spirit of Landin, we present a calculus of dependent types to serve as the semantic foundation for a family of languages called data description languages. Such languages, which include pads, datascript, and packettypes, are designed to facilitate programming with ad hoc data, ie, data not in well-behaved relational or xml formats. In the calculus, each type describes the physical layout and semantic properties of a data source. In the semantics, we interpret types simultaneously as the in-memory representation of the data described and as parsers for the data source. The parsing functions are robust, automatically detecting and recording errors in the data stream without halting parsing. We show the parsers are type-correct, returning data whose type matches the simple-type interpretation of the specification. We also prove the parsers are \"error-correct,\" accurately reporting the number of physical and semantic errors that occur in the returned data. We use the calculus to describe the features of various data description languages, and we discuss how we have used the calculus to improve PADS.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111039", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "AT&T (United States)" + }, + { + "first_name": "Yitzhak", + "last_name": "Mandelbaum", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/FisherMW06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111050", + "title": "Small bisimulations for reasoning about higher-order imperative programs", + "abstract": "We introduce a new notion of bisimulation for showing contextual equivalence of expressions in an untyped lambda-calculus with an explicit store, and in which all expressed values, including higher-order values, are storable. Our notion of bisimulation leads to smaller and more tractable relations than does the method of Sumii and Pierce [31]. In particular, our method allows one to write down a bisimulation relation directly in cases where [31] requires an inductive specification, and where the principle of local invariants [22] is inapplicable. Our method can also express examples with higher-order functions, in contrast with the most widely known previous methods [4, 22, 32] which are limited in their ability to deal with such examples. The bisimulation conditions are derived by manually extracting proof obligations from a hypothetical direct proof of contextual equivalence.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111050", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vasileios", + "last_name": "Koutavas", + "institution": "Universidad del Noreste" + }, + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/popl/KoutavasW06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111053", + "title": "Adventures in time and space", + "abstract": "Abstract. This paper investigates what is essentially a call-by-value version of PCF under a complexity-theoretically motivated type system. The programming formalism, ATR, has its first-order programs characterize the polynomial-time computable functions, and its second-order programs characterize the type-2 basic feasible functionals of Mehlhorn and of Cook and Urquhart. (The ATR-types are confined to levels 0, 1, and 2.) The type system comes in two parts, one that primarily restricts the sizes of values of expressions and a second that primarily restricts the time required to evaluate expressions. The size-restricted part is motivated by Bellantoni and Cook’s and Leivant’s implicit characterizations of polynomial-time. The time-restricting part is an affine version of Barber and Plotkin’s DILL. Two semantics are constructed for ATR. The first is a pruning of the naïve denotational semantics for ATR. This pruning removes certain functions that cause otherwise feasible forms of recursion to go wrong. The second semantics is a model for ATR’s time complexity relative to a certain abstract machine. This model provides a setting for complexity recurrences arising from ATR recursions, the solutions of which yield second-order polynomial time bounds. The time-complexity semantics is also shown to be sound relative to the costs of interpretation on the abstract machine. 1.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111053", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norman", + "last_name": "Danner", + "institution": "Wesleyan University" + }, + { + "first_name": "James S.", + "last_name": "Royer", + "institution": "Syracuse University" + } + ], + "dblp_key": "conf/popl/DannerR06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111065", + "title": "Frame rules from answer types for code pointers", + "abstract": "We define a type system, which may also be considered as a simple Hoare logic, for a fragment of an assembly language that deals with code pointers and jumps. The typing is aimed at local reasoning in the sense that only the type of a code pointer is needed, and there is no need to know the whole code itself. The main features of the type system are separation logic connectives for describing the heap, and polymorphic answer types of continuations for keeping track of jumps. Specifically, we address an interaction between separation and answer types: frame rules for local reasoning in the presence of jumps are recovered by instantiating the answer type. However, the instantiation of answer types is not sound for all types. To guarantee soundness, we restrict instantiation to closed types, where the notion of closedness arises from biorthogonality (in a sense inspired by Krivine and Pitts). A machine state is orthogonal to a disjoint heap if their combination does not lead to a fault. Closed types are sets of machine states that are orthogonal to a set of heaps. We use closed types as well-behaved answer types.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111065", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hayo", + "last_name": "Thielecke", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/popl/Thielecke06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111069", + "title": "Protecting representation with effect encapsulation", + "abstract": "Representation exposure is a well-known problem in the object-oriented realm. Object encapsulation mechanisms have established a tradition for solving this problem based on a principle of reference containment. This paper proposes a novel type system which is based on a different principle, we call effect encapsulation, which confines side effects, rather than object references, according to an ownership structure. Compared to object encapsulation, effect encapsulation liberates us from the restriction on object referenceability and offers more flexibility. In this paper, we show that effect encapsulation can be statically type checked.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111069", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yi", + "last_name": "Lu", + "institution": "UNSW Sydney" + }, + { + "first_name": "John", + "last_name": "Potter", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/popl/LuP06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111048", + "title": "Verifying properties of well-founded linked lists", + "abstract": "We describe a novel method for verifying programs that manipulate linked lists, based on two new predicates that characterize reachability of heap cells. These predicates allow reasoning about both acyclic and cyclic lists uniformly with equal ease. The crucial insight behind our approach is that a circular list invariably contains a distinguished head cell that provides a handle on the list. This observation suggests a programming methodology that requires the heap of the program at each step to be well-founded, i.e., for any field f in the program, every sequence u.f,u.f.f,... contains at least one head cell. We believe that our methodology captures the most common idiom of programming with linked data structures. We enforce our methodology by automatically instrumenting the program with updates to two auxiliary variables representing these predicates and adding assertions in terms of these auxiliary variables. To prove program properties and the instrumented assertions, we provide a first-order axiomatization of our two predicates. We also introduce a novel induction principle made possible by the well-foundedness of the heap. We use our induction principle to derive from two basic axioms a small set of additional first-order axioms that are useful for proving the correctness of several programs. We have implemented our method in a tool and used it to verify the correctness of a variety of nontrivial programs manipulating both acyclic and cyclic singly-linked lists and doubly-linked lists. We also demonstrate the use of indexed predicate abstraction to automatically synthesize loop invariants for these examples.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111048", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/LahiriQ06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111062", + "title": "A virtual class calculus", + "abstract": "Virtual classes are class-valued attributes of objects. Like virtual methods, virtual classes are defined in an object's class and may be redefined within subclasses. They resemble inner classes, which are also defined within a class, but virtual classes are accessed through object instances, not as static components of a class. When used as types, virtual classes depend upon object identity -- each object instance introduces a new family of virtual class types. Virtual classes support large-scale program composition techniques, including higher-order hierarchies and family polymorphism. The original definition of virtual classes in BETA left open the question of static type safety, since some type errors were not caught until runtime. Later the languages Caesar and gbeta have used a more strict static analysis in order to ensure static type safety. However, the existence of a sound, statically typed model for virtual classes has been a long-standing open question. This paper presents a virtual class calculus, VC, that captures the essence of virtual classes in these full-fledged programming languages. The key contributions of the paper are a formalization of the dynamic and static semantics of VC and a proof of the soundness of VC.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111062", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Erik", + "last_name": "Ernst", + "institution": "Aarhus University" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/ErnstOC06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111072", + "title": "A verifiable SSA program representation for aggressive compiler optimization", + "abstract": "We present a verifiable low-level program representation to embed, propagate, and preserve safety information in high perfor-mance compilers for safe languages such as Java and C#. Our representation precisely encodes safety information via static single-assignment (SSA) [11, 3] proof variables that are first-class constructs in the program.We argue that our representation allows a compiler to both (1) express aggressively optimized machine-independent code and (2) leverage existing compiler infrastructure to preserve safety information during optimization. We demonstrate that this approach supports standard compiler optimizations, requires minimal changes to the implementation of those optimizations, and does not artificially impede those optimizations to preserve safety. We also describe a simple type system that formalizes type safety in an SSA-style control-flow graph program representation. Through the types of proof variables, our system enables compositional verification of memory safety in optimized code. Finally, we discuss experiences integrating this representation into the machine-independent global optimizer of STARJIT, a high-performance just-in-time compiler that performs aggressive control-flow, data-flow, and algebraic optimizations and is competitive with top production systems.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111072", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vijay", + "last_name": "Menon", + "institution": "Intel (United States)" + }, + { + "first_name": "Neal", + "last_name": "Glew", + "institution": "Intel (United States)" + }, + { + "first_name": "Brian", + "last_name": "Murphy", + "institution": "Intel (United States)" + }, + { + "first_name": "Andrew", + "last_name": "McCreight", + "institution": "Yale University" + }, + { + "first_name": "Tatiana", + "last_name": "Shpeisman", + "institution": "Intel (United States)" + }, + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Intel (United States)" + }, + { + "first_name": "Leaf", + "last_name": "Petersen", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/popl/MenonGMMSAP06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111054", + "title": "N-synchronous Kahn networks: a relaxed model of synchrony for real-time systems", + "abstract": "The design of high-performance stream-processing systems is a fast growing domain, driven by markets such like high-end TV, gaming, 3D animation and medical imaging. It is also a surprisingly demanding task, with respect to the algorithmic and conceptual simplicity of streaming applications. It needs the close cooperation between numerical analysts, parallel programming experts, real-time control experts and computer architects, and incurs a very high level of quality insurance and optimization.In search for improved productivity, we propose a programming model and language dedicated to high-performance stream processing. This language builds on the synchronous programming model and on domain knowledge -- the periodic evolution of streams -- to allow correct-by-construction properties to be proven by the compiler. These properties include resource requirements and delays between input and output streams. Automating this task avoids tedious and error-prone engineering, due to the combinatorics of the composition of filters with multiple data rates and formats. Correctness of the implementation is also difficult to assess with traditional (asynchronous, simulation-based) approaches. This language is thus provided with a relaxed notion of synchronous composition, called n-synchrony: two processes are n-synchronous if they can communicate in the ordinary (0-)synchronous model with a FIFO buffer of size n.Technically, we extend a core synchronous data-flow language with a notion of periodic clocks, and design a relaxed clock calculus (a type system for clocks) to allow non strictly synchronous processes to be composed or correlated. This relaxation is associated with two sub-typing rules in the clock calculus. Delay, buffer insertion and control code for these buffers are automatically inferred from the clock types through a systematic transformation into a standard synchronous program. We formally define the semantics of the language and prove the soundness and completeness of its clock calculus and synchronization transformation. Finally, the language is compared with existing formalisms.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111054", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Marc", + "last_name": "Duranton", + "institution": "Philips (Netherlands)" + }, + { + "first_name": "Christine", + "last_name": "Eisenbeis", + "institution": "Laboratoire de Recherche en Informatique" + }, + { + "first_name": "Claire", + "last_name": "Pagetti", + "institution": "Laboratoire de Recherche en Informatique" + }, + { + "first_name": "Florence", + "last_name": "Plateau", + "institution": "Laboratoire de Recherche en Informatique" + }, + { + "first_name": "Marc", + "last_name": "Pouzet", + "institution": "Université Paris-Sud" + } + ], + "dblp_key": "conf/popl/CohenDEPPP06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111049", + "title": "Environment analysis via Delta CFA", + "abstract": "We describe a new program-analysis framework, based on CPS and procedure-string abstractions, that can handle critical analyses which the k-CFA framework cannot. We present the main theorems concerning correctness, show an application analysis, and describe a running implementation.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111049", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/popl/MightS06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111071", + "title": "Harmless advice", + "abstract": "This paper defines an object-oriented language with harmless aspect-oriented advice. A piece of harmless advice is a computation that, like ordinary aspect-oriented advice, executes when control reaches a designated control-flow point. However, unlike ordinary advice, harmless advice is designed to obey a weak non-interference property. Harmless advice may change the termination behavior of computations and use I/O, but it does not otherwise influence the final result of the mainline code. The benefit of harmless advice is that it facilitates local reasoning about program behavior. More specifically, programmers may ignore harmless advice when reasoning about the partial correctness properties of their programs. In addition, programmers may add new pieces of harmless advice to pre-existing programs in typical \"after-the-fact\" aspect-oriented style without fear they will break important data invariants used by the mainline code.In order to detect and enforce harmlessness, the paper defines a novel type and effect system related to information-flow type systems. The central technical result is that well-typed harmless advice does not interfere with the mainline computation. The paper also presents an implementation of the language and a case study using harmless advice to implement security policies.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111071", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel S.", + "last_name": "Dantas", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/Dantas06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111046", + "title": "A logic for information flow in object-oriented programs", + "abstract": "This paper specifies, via a Hoare-like logic, an interprocedural and flow sensitive (but termination insensitive) information flow analysis for object-oriented programs. Pointer aliasing is ubiquitous in such programs, and can potentially leak confidential information. Thus the logic employs independence assertions to describe the noninterference property that formalizes confidentiality, and employs region assertions to describe possible aliasing. Programmer assertions, in the style of JML, are also allowed, thereby permitting a more fine-grained specification of information flow policy.The logic supports local reasoning about state in the style of separation logic. Small specifications are used; they mention only the variables and addresses relevant to a command. Specifications are combined using a frame rule. An algorithm for the computation of postconditions is described: under certain assumptions, there exists a strongest postcondition which the algorithm computes.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111046", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Torben", + "last_name": "Amtoft", + "institution": "Kansas State University" + }, + { + "first_name": "Sruthi", + "last_name": "Bandhakavi", + "institution": "Kansas State University" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "Kansas State University" + } + ], + "dblp_key": "conf/popl/AmtoftBB06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111064", + "title": "Specifying C++ concepts", + "abstract": "C++ templates are key to the design of current successful mainstream libraries and systems. They are the basis of programming techniques in diverse areas ranging from conventional general-purpose programming to software for safety-critical embedded systems. Current work on improving templates focuses on the notion of concepts (a type system for templates), which promises significantly improved error diagnostics and increased expressive power such as concept-based overloading and function template partial specialization. This paper presents C++ templates with an emphasis on problems related to separate compilation. We consider the problem of how to express concepts in a precise way that is simple enough to be usable by ordinary programmers. In doing so, we expose a few weakness of the current specification of the C++ standard library and suggest a far more precise and complete specification. We also present a systematic way of translating our proposed concept definitions, based on use-patterns rather than function signatures, into constraint sets that can serve as convenient basis for concept checking in a compiler.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111064", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gabriel Dos", + "last_name": "Reis", + "institution": "" + }, + { + "first_name": "Bjarne", + "last_name": "Stroustrup", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/popl/ReisS06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111052", + "title": "The Scala experiment: can we provide better language support for component systems?", + "abstract": "No abstract available.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111052", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "" + } + ], + "dblp_key": "conf/popl/Odersky06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111067", + "title": "Associating synchronization constraints with data in an object-oriented language", + "abstract": "Concurrency-related bugs may happen when multiple threads access shared data and interleave in ways that do not correspond to any sequential execution. Their absence is not guaranteed by the traditional notion of “data race ” freedom. We present a new definition of data races in terms of 11 problematic interleaving scenarios, and prove that it is complete by showing that any execution not exhibiting these scenarios is serializable for a chosen set of locations. Our definition subsumes the traditional definition of a data race as well as high-level data races such as stale-value errors and inconsistent views. We also propose a language feature called atomic sets of locations, which lets programmers specify the existence of consistency properties between fields in objects, without specifying the properties themselves. We use static analysis to automatically infer those points in the code where synchronization is needed to avoid data races under our new definition. An important benefit of this approach is that, in general, far fewer annotations are required than is the case with existing approaches such as synchronized blocks or atomic sections. Our implementation successfully inferred the appropriate synchronization for a significant subset of Java’s Standard Collections framework.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111067", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mandana", + "last_name": "Vaziri", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/VaziriTD06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111047", + "title": "Polymorphic regular tree types and patterns", + "abstract": "We propose a type system based on regular tree grammars, where algebraic datatypes are interpreted in a structural way. Thus, the same constructors can be reused for different types and a flexible subtyping relation can be defined between types, corresponding to the inclusion of their semantics. For instance, one can define a type for lists and a subtype of this type corresponding to lists of even length. Patterns are simply types annotated with binders. This provides a generalization of algebraic patterns with the ability of matching arbitrarily deep in a value. Our main contribution, compared to languages such as XDuce and CDuce, is that we are able to deal with both polymorphism and function types.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111047", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jérôme", + "last_name": "Vouillon", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/Vouillon06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111040", + "title": "A hierarchical model of data locality", + "abstract": "In POPL 2002, Petrank and Rawitz showed a universal result— finding optimal data placement is not only NP-hard but also impossible to approximate within a constant factor if P ̸ = NP. Here we study a recently published concept called reference affinity, which characterizes a group of data that are always accessed together in computation. On the theoretical side, we give the complexity for finding reference affinity in program traces, using a novel reduction that converts the notion of distance into satisfiability. We also prove that reference affinity automatically captures the hierarchical locality in divide-and-conquer computations including matrix solvers and N-body simulation. The proof establishes formal links between computation patterns in time and locality relations in space. On the practical side, we show that efficient heuristics exist. In particular, we present a sampling method and show that it is more effective than the previously published technique, especially for data that are often but not always accessed together. We show the effect on generated and real traces. These theoretical and empirical results demonstrate that effective data placement is still attainable in general-purpose programs because common (albeit not all) locality patterns can be precisely modeled and efficiently analyzed.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111040", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chengliang", + "last_name": "Zhang", + "institution": "University of Rochester" + }, + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + }, + { + "first_name": "Mitsunori", + "last_name": "Ogihara", + "institution": "University of Rochester" + }, + { + "first_name": "Yutao", + "last_name": "Zhong", + "institution": "George Mason University" + }, + { + "first_name": "Youfeng", + "last_name": "Wu", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/popl/ZhangDOZW06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111058", + "title": "Stratified type inference for generalized algebraic data types", + "abstract": "Stratified type inference for generalized algebraic data types.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111058", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Yann", + "last_name": "Régis-Gianas", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/PottierR06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111057", + "title": "Modular set-based analysis from contracts", + "abstract": "In PLT Scheme, programs consist of modules with contracts. The latter describe the inputs and outputs of functions and objects via predicates. A run-time system enforces these predicates; if a predicate fails, the enforcer raises an exception that blames a specific module with an explanation of the fault.In this paper, we show how to use such module contracts to turn set-based analysis into a fully modular parameterized analysis. Using this analysis, a static debugger can indicate for any given contract check whether the corresponding predicate is always satisfied, partially satisfied, or (potentially) completely violated. The static debugger can also predict the source of potential errors, i.e., it is sound with respect to the blame assignment of the contract system.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111057", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philippe", + "last_name": "Meunier", + "institution": "Universidad del Noreste" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "University of Chicago" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/popl/MeunierFF06", + "venue": "popl", + "year": 2006 + }, + { + "paper_id": "10.1145/1111037.1111061", + "title": "The next mainstream programming language: a game developer's perspective", + "abstract": "Game developers have long been early adopters of new technologies. This is so because we are largely unburdened by legacy code: With each new hardware generation, we are free to rethink our software assumptions and develop new products using new tools and even new programming languages. As a result, games are fertile ground for applying academic advances in these areas.And never has our industry been in need of such advances as it is now! The scale and scope of game development has increased more than ten-fold over the past ten years, yet the underlying limitations of the mainstream C/C++/Java/C# language family remain largely unaddressed.The talk begins with a high-level presentation of the game developer's world: the kinds of algorithms we employ on modern CPUs and GPUs, the difficulties of componentization and concurrency, and the challenges of writing very complex software with real-time performance requirements.The talk then outlines the ways that future programming languages could help us write better code, providing examples derived from experience writing games and software frameworks that support games. The major areas covered are abstraction facilities -- how we can use them to develop more extensible frameworks and components; practical opportunities for employing stronger typing to reduce run-time failures; and the need for pervasive concurrency support, both implicit and explicit, to effectively exploit the several forms of parallelism present in games and graphics.", + "date": "2006-01-11", + "link": "https://doi.org/10.1145/1111037.1111061", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tim", + "last_name": "Sweeney", + "institution": "" + } + ], + "dblp_key": "conf/popl/Sweeney06", + "venue": "popl", + "year": 2006 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2007.json b/data/pl_conferences/popl/2007.json new file mode 100644 index 0000000..aea5f9e --- /dev/null +++ b/data/pl_conferences/popl/2007.json @@ -0,0 +1,869 @@ +[ + { + "paper_id": "10.1145/1190216.1190222", + "title": "A typed intermediate language for compiling multiple inheritance", + "abstract": "Type-preserving compilation can improve software reliability by generating code that can be verified independently of the compiler. Practical type preserving compilation does not exist for languages with multiple inheritance. This paper presents Emi, the first typed intermediate language to support practical compilation of a programming language with fully general multiple inheritance. The paper demonstrates the practicality of Emi by showing that Emi can be used to faithfully model standard implementation strategies of multiple inheritance for C++, the most widely-used programming language with general multiple inheritance.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190222", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/Chen07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190227", + "title": "Locality approximation using time", + "abstract": "Reuse distance (i.e. LRU stack distance) precisely characterizes program locality and has been a basic tool for memory system research since the 1970s. However, the high cost of measuring has restricted its practical uses in performance debugging, locality analysis and optimizations of long-running applications.In this work, we improve the efficiency by exploring the connection between time and locality. We propose a statistical model that converts cheaply obtained time distance to the more costly reuse distance. Compared to the state-of-the-art technique, this approach reduces measuring time by a factor of 17, and approximates cache line reuses with over 99% accuracy and the cache miss rate with less than 0.4% average error for 12 SPEC 2000 integer and floating-point benchmarks. By exploiting the strong correlations between time and locality, this work makes precise locality as easy to obtain as data access frequency, and opens new opportunities for program optimizations.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190227", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "William & Mary" + }, + { + "first_name": "Jonathan", + "last_name": "Shaw", + "institution": "" + }, + { + "first_name": "Brian", + "last_name": "Meeker", + "institution": "University of Rochester" + }, + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/popl/ShenSMD07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190220", + "title": "Operational semantics for multi-language programs", + "abstract": "Inter-language interoperability is big business, as the success of Microsoft's .NET and COM and Sun's JVM show. Programming language designers are designing programming languages that reflect that fact --- SML#, Mondrian, and Scala, to name just a few examples, all treat interoperability with other languages as a central design feature. Still, current multi-language research tends not to focus on the semantics of interoperation features, but only on how to implement them efficiently. In this paper, we take first steps toward higher-level models of interoperating systems. Our technique abstracts away the low-level details of interoperability like garbage collection and representation coherence, and lets us focus on semantic properties like type-safety and observable equivalence.Beyond giving simple expressive models that are natural compositions of single-language models, our studies have uncovered several interesting facts about interoperability. For example, higher-order contracts naturally emerge as the glue to ensure that interoperating languages respect each other's type systems. While we present our results in an abstract setting, they shed light on real multi-language systems and tools such as the JNI, SWIG, and Haskell's stable pointers.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190220", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Matthews", + "institution": "University of Chicago" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/popl/MatthewsF07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190269", + "title": "Geometry of synthesis: a structured approach to VLSI design", + "abstract": "We propose a new technique for hardware synthesis from higher-order functional languages with imperative features based on Reynolds's Syntactic Control of Interference. The restriction on contraction in the type system is useful for managing the thorny issue of sharing of physical circuits. We use a semantic model inspired by game semantics and the geometry of interaction, and express it directly as a certain class of digital circuits that form a cartesian, monoidal-closed category. A soundness result is given, which is also a correctness result for the compilation technique.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190269", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dan R.", + "last_name": "Ghica", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/popl/Ghica07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190261", + "title": "Modular verification of a non-blocking stack", + "abstract": "This paper contains a model and a proof of soundness for a range of program logics based on separation logic and including the notions of permission and ownership for stack variables. It shows that there is no loss of expressive power (all proofs in Hoare logic are expressible). This permits the construction of program-reasoning tools that use the notion of ‘variables as resource'. \\nThis is a highly technical piece of work, and its impact will emerge when more tools have been constructed. Variables-as-resource will be necessary if such tools are to emerge. \\n\"", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190261", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "University of Cambridge" + }, + { + "first_name": "Richard", + "last_name": "Bornat", + "institution": "Middlesex University" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/ParkinsonBO07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190245", + "title": "Towards a mechanized metatheory of standard ML", + "abstract": "We present an internal language with equivalent expressive power to Standard ML, and discuss its formalization in LF and the machine-checked verification of its type safety in Twelf. The internal language is intended to serve as the target of elaboration in an elaborative semantics for Standard ML in the style of Harper and Stone. Therefore, it includes all the programming mechanisms necessary to implement Standard ML, including translucent modules, abstraction, polymorphism, higher kinds, references, exceptions, recursive types, and recursive functions. Our successful formalization of the proof involved a careful interplay between the precise formulations of the various mechanisms, and required the invention of new representation and proof techniques of general interest.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190245", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel K.", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/LeeCH07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190238", + "title": "From implementation to theory in product synthesis", + "abstract": "Future software development will rely on product synthesis, i.e., the synthesis of code and non-code artifacts for a target component or application. Prior work on feature-based product synthesis can be understood and generalized using elementary ideas from category theory. Doing so reveals (a) practical and previously unrecognized properties that product synthesis tools must satisfy, and (b) non-obvious generalizations of current techniques that will guide future research efforts in automated product development.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190238", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Don", + "last_name": "Batory", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/Batory07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190260", + "title": "Lock allocation", + "abstract": "We introduce lock allocation, an automatic technique that takes a multi-threaded program annotated with atomic sections (that must be executed atomically), and infers a lock assignment from global variables to locks and a lock instrumentation that determines where each lock should be acquired and released such that the resulting instrumented program is guaranteed to preserve atomicity and deadlock freedom (provided all shared state is accessed only within atomic sections). Our algorithm works in the presence of pointers and procedures, and sets up the lock allocation problem as a 0-1 ILP which minimizes the conflict cost between atomic sections while simultaneously minimizing the number of locks. We have implemented our algorithm for both C with pthreads and Java, and have applied it to infer locks in 15K lines of AOLserver code. Our automatic allocation produces the same results as hand annotations for most of this code, while solving the optimization instances within a second for most programs.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190260", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "UtopiaCompression (United States)" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Fischer", + "institution": "UtopiaCompression (United States)" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "UtopiaCompression (United States)" + } + ], + "dblp_key": "conf/popl/EmmiFJM07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190257", + "title": "Proving that programs eventually do something good", + "abstract": "In recent years we have seen great progress made in the area of automatic source-level static analysis tools. However, most of today's program verification tools are limited to properties that guarantee the absence of bad events (safety properties). Until now no formal software analysis tool has provided fully automatic support for proving properties that ensure that good events eventually happen (liveness properties). In this paper we present such a tool, which handles liveness properties of large systems written in C. Liveness properties are described in an extension of the specification language used in the SDV system. We have used the tool to automatically prove critical liveness properties of Windows device drivers and found several previously unknown liveness bugs.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190257", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "University of Cambridge" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "" + }, + { + "first_name": "Moshe Y.", + "last_name": "Vardi", + "institution": "Rice University" + } + ], + "dblp_key": "conf/popl/CookGPRV07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190264", + "title": "Specialization of CML message-passing primitives", + "abstract": "Concurrent ML (CML) is a statically-typed higher-order concurrent language that is embedded in Standard ML. Its most notable feature is its support for first-class synchronous operations. This mechanism allows programmers to encapsulate complicated communication and synchronization protocols as first-class abstractions, which encourages a modular style of programming where the underlying channels used to communicate with a given thread are hidden behind data and type abstraction.While CML has been in active use for well over a decade, little attention has been paid to optimizing CML programs. In this paper, we present a new program analysis for statically-typed higher-order concurrent languages that enables the compile-time specialization of communication operations. This specialization is particularly important in a multiprocessor or multicore setting, where the synchronization overhead for general-purpose operations are high. Preliminary results from a prototype that we have built demonstrate that specialized channel operations are much faster than the general-purpose operations.Our analysis technique is modular (i.e.,, it analyzes and optimizes a single unit of abstraction at a time), which plays to the modular style of many CML programs. The analysis consists of three steps: the first is a type-sensitive control-flow analysis that uses the program's type-abstractions to compute more precise results. The second is the construction of an extended control-flow graph using the results of the CFA. The last step is an iterative analysis over the graph that approximates the usage patterns of known channels. Our analysis is designed to detect special patterns of use, such as one-shot channels, fan-in channels, and fan-out channels. We have proven the safety of our analysis and state those results.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190264", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Chicago" + }, + { + "first_name": "Yingqi", + "last_name": "Xiao", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/popl/ReppyX07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190265", + "title": "Conditional must not aliasing for static race detection", + "abstract": "Race detection algorithms for multi-threaded programs using the common lock-based synchronization idiom must correlate locks with the memory locations they guard. The heart of a proof of race freedom is showing that if two locks are distinct, then the memory locations they guard are also distinct. This is an example of a general property we call conditional must not aliasing: Under the assumption that two objects are not aliased, prove that two other objects are not aliased. This paper introduces and gives an algorithm for conditional must not alias analysis and discusses experimental results for sound race detection of Java programs.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190265", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/NaikA07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190247", + "title": "Logic-flow analysis of higher-order programs", + "abstract": "This work presents a framework for fusing flow analysis and theorem proving called logic-flow analysis (LFA). The framework itself is the reduced product of two abstract interpretations: (1) an abstract state machine and (2) a set of propositions in a restricted first-order logic. The motivating application for LFA is the safe removal of implicit array-bounds checks without type information, user interaction or program annotation. LFA achieves this by delegating a given task to either the prover or the flow analysis depending on which is best suited to discharge it. Described within are a concrete semantics for continuation-passing style; a restricted, first-order logic; a woven product of two abstract interpretations; proofs of correctness; and a worked example.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190247", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/popl/Might07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190258", + "title": "Program verification as probabilistic inference", + "abstract": "In this paper, we propose a new algorithm for proving the validity or invalidity of a pre/postcondition pair for a program. The algorithm is motivated by the success of the algorithms for probabilistic inference developed in the machine learning community for reasoning in graphical models. The validity or invalidity proof consists of providing an invariant at each program point that can be locally verified. The algorithm works by iteratively randomly selecting a program point and updating the current abstract state representation to make it more locally consistent (with respect to the abstractions at the neighboring points). We show that this simple algorithm has some interesting aspects: (a) It brings together the complementary powers of forward and backward analyses; (b) The algorithm has the ability to recover itself from excessive under-approximation or over-approximation that it may make. (Because the algorithm does not distinguish between the forward and backward information, the information could get both under-approximated and over-approximated at any step.) (c) The randomness in the algorithm ensures that the correct choice of updates is eventually made as there is no single deterministic strategy that would provably work for any interesting class of programs. In our experiments we use this algorithm to produce the proof of correctness of a small (but non-trivial) example. In addition, we empirically illustrate several important properties of the algorithm.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190258", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Nebojša", + "last_name": "Jojić", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/GulwaniJ07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190224", + "title": "Cork: dynamic memory leak detection for garbage-collected languages", + "abstract": "A memory leak in a garbage-collected program occurs when the program inadvertently maintains references to objects that it no longer needs. Memory leaks cause systematic heap growth, degrading performance and resulting in program crashes after perhaps days or weeks of execution. Prior approaches for detecting memory leaks rely on heap differencing or detailed object statistics which store state proportional to the number of objects in the heap. These overheads preclude their use on the same processor for deployed long-running applications.This paper introduces a dynamic heap-summarization technique based on type that accurately identifies leaks, is space efficient (adding less than 1% to the heap), and is time efficient (adding 2.3% on average to total execution time). We implement this approach in Cork which utilizes dynamic type information and garbage collection to summarize the live objects in a type points-from graph (TPFG) whose nodes (types) and edges (references between types) are annotated with volume. Cork compares TPFGs across multiple collections, identifies growing data structures, and computes a type slice for the user. Cork is accurate: it identifies systematic heap growth with no false positives in 4 of 15 benchmarks we tested. Cork's slice report enabled us (non-experts) to quickly eliminate growing data structures in SPECjbb2000 and Elipse, something their developers had not previously done. Cork is accurate, scalable, and efficient enough to consider using online.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190224", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Maria", + "last_name": "Jump", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/JumpM07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190242", + "title": "Lazy multivariate higher-order forward-mode AD", + "abstract": "A method is presented for computing all higher-order partial derivatives of a multivariate function R n → R. This method works by evaluating the function under a nonstandard interpretation, lifting reals to multivariate power series. Multivariate power series, with potentially an infinite number of terms with nonzero coefficients, are represented using a lazy data structure constructed out of linear terms. A complete implementation of this method in Scheme is presented, along with a straightforward exposition, based on Taylor expansions, of the method's correctness.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190242", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Barak A.", + "last_name": "Pearlmutter", + "institution": "National University of Ireland, Maynooth" + }, + { + "first_name": "Jeffrey Mark", + "last_name": "Siskind", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/PearlmutterS07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190251", + "title": "Assessing security threats of looping constructs", + "abstract": "There is a clear intuitive connection between the notion of leakage of information in a program and concepts from information theory. This intuition has not been satisfactorily pinned down, until now. In particular, previous information-theoretic models of programs are imprecise, due to their overly conservative treatment of looping constructs. In this paper we provide the first precise information-theoretic semantics of looping constructs. Our semantics describes both the amount and rate of leakage; if either is small enough, then a program might be deemed \"secure\". Using the semantics we provide an investigation and classification of bounded and unbounded covert channels.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190251", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pasquale", + "last_name": "Malacaria", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/Malacaria07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190253", + "title": "Secure implementations of typed channel abstractions", + "abstract": "The challenges hidden in the implementation of high-level process calculi into low-level environments are well understood [3]. This paper develops a secure implementation of a typed pi calculus, in which capability types are employed to realize the policies for the access to communication channels. Our implementation compiles high-level processes of the pi-calculus into low-level principals of a cryptographic process calculus based on the applied-pi calculus [1]. In this translation, the high-level type capabilities are implemented as term capabilities protected by encryption keys only known to the intended receivers. As such, the implementation is effective even when the compiled, low-level principals are deployed in open contexts for which no assumption on trust and behavior may be made. Our technique and results draw on, and extend, previous work on secure implementation of channel abstractions in a dialect of the join calculus [2]. In particular, our translation preserves the forward secrecy of communications in a calculus that includes matching and supports the dynamic exchange of write and read access-rights among processes. We establish the adequacy and full abstraction of the implementation by contrasting the untyped equivalences of the low-level cryptographic calculus, with the typed equivalences of the high-level source calculus.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190253", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michele", + "last_name": "Bugliesi", + "institution": "Ca' Foscari University of Venice" + }, + { + "first_name": "Marco", + "last_name": "Giunti", + "institution": "Ca' Foscari University of Venice" + } + ], + "dblp_key": "conf/popl/BugliesiG07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190266", + "title": "Interprocedural analysis of asynchronous programs", + "abstract": "An asynchronous program is one that contains procedure calls which are not immediately executed from the callsite, but stored and “dispatched” in a non-deterministic order by an external scheduler at a later point. We formalize the problem of interprocedural dataflow analysis for asynchronous programs as AIFDS problems, a generalization of the IFDS problems for interprocedural dataflow analysis. We give an algorithm for computing the precise meet-over-valid-paths solution for any AIFDS instance, as well as a demand-driven algorithm for solving the corresponding demand AIFDS instances. Our algorithm can be easily implemented on top of any existing interprocedural dataflow analysis framework. We have implemented the algorithm on top of BLAST, thereby obtaining the first safety verification tool for unbounded asynchronous programs. Though the problem of solving AIFDS instances is EXPSPACE-hard, we find that in practice our technique can efficiently analyze programs by exploiting standard optimizations of interprocedural dataflow analyses.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190266", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "UtopiaCompression (United States)" + } + ], + "dblp_key": "conf/popl/JhalaM07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190235", + "title": "A very modal model of a modern, major, general type system", + "abstract": "International audience", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190235", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Paul-André", + "last_name": "Melliès", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Christina D.", + "last_name": "Richards", + "institution": "Princeton University" + }, + { + "first_name": "Jérôme", + "last_name": "Vouillon", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/AppelMRV07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190268", + "title": "Preferential path profiling: compactly numbering interesting paths", + "abstract": "Path profiles provide a more accurate characterization of a program's dynamic behavior than basic block or edge profiles, but are relatively more expensive to collect. This has limited their use in practice despite demonstrations of their advantages over edge profiles for a wide variety of applications.We present a new algorithm called preferential path profiling (PPP), that reduces the overhead of path profiling. PPP leverages the observation that most consumers of path profiles are only interested in a subset of all program paths. PPP achieves low overhead by separating interesting paths from other paths and assigning a set of unique and compact numbers to these interesting paths. We draw a parallel between arithmetic coding and path numbering, and use this connection to prove an optimality result for the compactness of path numbering produced by PPP. This compact path numbering enables our PPP implementation to record path information in an array instead of a hash table. Our experimental results indicate that PPP reduces the runtime overhead of profiling paths exercised by the largest (ref) inputs of the SPEC CPU2000 benchmarks from 50% on average (maximum of 132%) to 15% on average (maximum of 26%) as compared to a state-of-the-art path profiler.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190268", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kapil", + "last_name": "Vaswani", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/VaswaniNC07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190241", + "title": "Lightweight fusion by fixed point promotion", + "abstract": "This paper proposes a lightweight fusion method for general recursive function definitions. Compared with existing proposals, our method has several significant practical features: it works for general recursive functions on general algebraic data types; it does not produce extra runtime overhea (except for possible code size increase due to the success of fusion); and it is readily incorporated in standard inlining optimization. This is achieved by extending the ordinary inlining process with a new fusion law that transforms a term of the form f o (fixgλx.E) to a new fixed point term fixhλx.E′ by promoting the function f through the fixed point operator. This is a sound syntactic transformation rule that is not sensitive to the types of f and g. This property makes our method applicable to wide range of functions including those with multi-parameters in both curried and uncurried forms. Although this method does not guarantee any form of completeness, it fuses typical examples discussed in the literature and others that involve accumulating parameters, either in the tt foldl-like specific forms or in general recursive forms, without any additional machinery. In order to substantiate our claim, we have implemented our method in a compiler. Although it is preliminary, it demonstrates practical feasibility of this method.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190241", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Tohoku University" + }, + { + "first_name": "Isao", + "last_name": "Sasano", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/popl/OhoriS07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190255", + "title": "Advanced programming language design in enterprise software: a lambda-calculus theorist wanders into a datacenter", + "abstract": "Enterprise software systems automate the business processes of most nontrivial organizations in the world economy. These systems are immensely complex, and their function is critical to our living standards and everyday lives. Their design, implementation, and maintenance occupies many thousands of programmers and engineers, who work in what are aptly called the \"COBOL dungeons\"1 of the IT sector. These systems have persisted, growing by accretion -- some for decades; there are enterprise systems in existence today whose original and even subsequent authors are retired or deceased. Such extraordinarly old, multi-layered systems might appear to be the last place to apply avante-garde techniques, but in fact, they are extremely promising candidates, and for reasons directly connected to their history and structure.In this talk we take a tour of several deployed enterprise software systems, and demonstrate that the appropriate application of methods from functional programming can and does in fact yield dramatic performance improvements and thus commercial advan-tage in the design and implementation of enterprise software. This concrete application is an instance of a general plan for the application of advanced programming language design and analysis methods, to the problem of improving enterprise software. It is the thesis of this talk that to a great extent, it is in enterprise software that advanced PL techniques can find their most advantageous application. This talk literally breaks no new ground in PL research: every technique discussed is nearly two decades old, and our goal is to introduce PL researchers to what we feel is an ideal target for their work.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190255", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chet", + "last_name": "Murthy", + "institution": "" + } + ], + "dblp_key": "conf/popl/Murthy07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190226", + "title": "Compositional dynamic test generation", + "abstract": "Dynamic test generation is a form of dynamic program analysis that attempts to compute test inputs to drive a program along a specific program path. Directed Automated Random Testing, or DART for short, blends dynamic test generation with model checking techniques with the goal of systematically executing all feasible program paths of a program while detecting various types of errors using run-time checking tools (like Purify, for instance). Unfortunately, systematically executing all feasible program paths does not scale to large, realistic programs.This paper addresses this major limitation and proposes to perform dynamic test generation compositionally, by adapting known techniques for interprocedural static analysis. Specifically, we introduce a new algorithm, dubbed SMART for Systematic Modular Automated Random Testing, that extends DART by testing functions in isolation, encoding test results as function summaries expressed using input preconditions and output postconditions, and then re-using those summaries when testing higher-level functions. We show that, for a fixed reasoning capability, our compositional approach to dynamic test generation (SMART) is both sound and complete compared to monolithic dynamic test generation (DART). In other words, SMART can perform dynamic test generation compositionally without any reduction in program path coverage. We also show that, given a bound on the maximum number of feasible paths in individual program functions, the number of program executions explored by SMART is linear in that bound, while the number of program executions explored by DART can be exponential in that bound. We present examples of C programs and preliminary experimental results that illustrate and validate empirically these properties.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190226", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/Godefroid07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190225", + "title": "Dynamic heap type inference for program understanding and debugging", + "abstract": "C programs can be difficult to debug due to lax type enforcement and low-level access to memory. We present a dynamic analysis for C that checks heap snapshots for consistency with program types. Our approach builds on ideas from physical subtyping and conservative garbage collection. We infer a program-defined type for each allocated storage location or identify \"untypable\" blocks that reveal heap corruption or type safety violations. The analysis exploits symbolic debug information if present, but requires no annotation or recompilation beyond a list of defined program types and allocated heap blocks. We have integrated our analysis into the GNU Debugger (gdb), and describe our initial experience using this tool with several small to medium-sized programs.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190225", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marina", + "last_name": "Polishchuk", + "institution": "Microsoft (Finland)" + }, + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Chloë W.", + "last_name": "Schulze", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/popl/PolishchukLS07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190221", + "title": "Semantics of static pointcuts in aspectJ", + "abstract": "In aspect-oriented programming, one can intercept events by writing patterns called pointcuts. The pointcut language of the most popular aspect-oriented programming language, AspectJ, allows the expression of highly complex properties of the static program structure.We present the first rigorous semantics of the AspectJ pointcut language, by translating static patterns into safe ( i.e. range-restricted and stratified) Datalog queries. Safe Datalog is a logic language like Prolog, but it does not have data structures; consequently it has a straightforward least fixpoint semantics and all queries terminate.The translation from pointcuts to safe Datalog consists of a set of simple conditional rewrite rules, implemented using the Stratego system. The resulting queries are themselves executable with the CodeQuest system. We present experiments indicating that direct execution of our semantics is not prohibitively expensive.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190221", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Avgustinov", + "institution": "University of Oxford" + }, + { + "first_name": "Elnar", + "last_name": "Hajiyev", + "institution": "University of Oxford" + }, + { + "first_name": "Neil", + "last_name": "Ongkingco", + "institution": "University of Oxford" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + }, + { + "first_name": "Damien", + "last_name": "Sereni", + "institution": "University of Oxford" + }, + { + "first_name": "Julian", + "last_name": "Tibble", + "institution": "University of Oxford" + }, + { + "first_name": "Mathieu", + "last_name": "Verbaere", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/AvgustinovHOMSTV07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190229", + "title": "Modular type classes", + "abstract": "ML modules and Haskell type classes have proven to be highly effective tools for program structuring. Modules emphasize explicit configuration of program components and the use of data abstraction. Type classes emphasize implicit program construction and ad hoc polymorphism. In this paper, we show how the implicitly-typed style of type class programming may be supported within the framework of an explicitly-typed module language by viewing type classes as a particular mode of use of modules. This view offers a harmonious integration of modules and type classes, where type class features, such as class hierarchies and associated types, arise naturally as uses of existing module-language constructs, such as module hierarchies and type components. In addition, programmers have explicit control over which type class instances are available for use by type inference in a given scope. We formalize our approach as a Harper-Stone-style elaboration relation, and provide a sound type inference algorithm as a guide to implementation.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190229", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/popl/DreyerHCK07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190230", + "title": "First-class nonstandard interpretations by opening closures", + "abstract": "We motivate and discuss a novel functional programming construct that allows convenient modular run-time nonstandard interpretation via reflection on closure environments. This map-closure construct encompasses both the ability to examine the contents of a closure environment and to construct a new closure with a modified environment. From the user's perspective, map-closure is a powerful and useful construct that supports such tasks as tracing, security logging, sandboxing, error checking, profiling, code instrumentation and metering, run-time code patching, and resource monitoring. From the implementor's perspective, map-closure is analogous to call/cc. Just as call/cc is a non-referentially-transparent mechanism that reifies the continuations that are only implicit in programs written in direct style, map-closure is a non-referentially-transparent mechanism that reifies the closure environments that are only implicit in higher-order programs. Just as CPS conversion is a non-local but purely syntactic transformation that can eliminate references to call/cc, closure conversion is a non-local but purely syntactic transformation that can eliminate references to map-closure. We show how the combination of map-closure and call/cc can be used to implement set! as a procedure definition and a local macro transformation.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190230", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeffrey Mark", + "last_name": "Siskind", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Barak A.", + "last_name": "Pearlmutter", + "institution": "National University of Ireland, Maynooth" + } + ], + "dblp_key": "conf/popl/SiskindP07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190234", + "title": "Types, bytes, and separation logic", + "abstract": "We present a formal model of memory that both captures the low-level features of C's pointers and memory, and that forms the basis for an expressive implementation of separation logic. At the low level, we do not commit common oversimplifications, but correctly deal with C's model of programming language values and the heap. At the level of separation logic, we are still able to reason abstractly and efficiently. We implement this framework in the theorem prover Isabelle/HOL and demonstrate it on two case studies. We show that the divide between detailed and abstract does not impose undue verification overhead, and that simple programs remain easy to verify. We also show that the framework is applicable to real, security- and safety-critical code by formally verifying the memory allocator of the L4 microkernel.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190234", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harvey", + "last_name": "Tuch", + "institution": "Data61" + }, + { + "first_name": "Gerwin", + "last_name": "Klein", + "institution": "UNSW Sydney" + }, + { + "first_name": "Michael", + "last_name": "Norrish", + "institution": "Data61" + } + ], + "dblp_key": "conf/popl/TuchKN07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190244", + "title": "A complete, co-inductive syntactic theory of sequential control and state", + "abstract": "We present a new co-inductive syntactic theory, eager normal form bisimilarity, for the untyped call-by-value lambda calculus extended with continuations and mutable references.We demonstrate that the associated bisimulation proof principle is easy to use and that it is a powerful tool for proving equivalences between recursive imperative higher-order programs.The theory is modular in the sense that eager normal form bisimilarity for each of the calculi extended with continuations and/or mutable references is a fully abstract extension of eager normal form bisimilarity for its sub-calculi. For each calculus, we prove that eager normal form bisimilarity is a congruence and is sound with respect to contextual equivalence. Furthermore, for the calculus with both continuations and mutable references, we show that eager normal form bisimilarity is complete: it coincides with contextual equivalence.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190244", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kristian", + "last_name": "Støvring", + "institution": "Aarhus University" + }, + { + "first_name": "Søren B.", + "last_name": "Lassen", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/popl/StovringL07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190218", + "title": "Perl 6: reconciling the irreconcilable", + "abstract": "Perl is a general-purpose language, known for its vast number of freely available libraries. The Perl 6 project was started to improve the language's support for multi-paradigmatic programming, while retaining compatibility with the existing code base. This talk discusses how Perl 6 attempts to reconcile various competing paradigms in the field of programming language design, such as static vs. dynamic typechecking, nominal vs. structural subtyping, prototype vs. class-based objects, and lazy vs. eager evaluation. Moreover, this talk also covers the design and development of Pugs, a self-hosting Perl 6 implementation bootstrapped from Haskell, targeting multiple runtime environments, including Perl 5, JavaScript and Parrot.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190218", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Audrey", + "last_name": "Tang", + "institution": "Taipei City Government" + } + ], + "dblp_key": "conf/popl/Tang07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190270", + "title": "A semantics-based approach to malware detection", + "abstract": "Malware detection is a crucial aspect of software security. Current malware detectors work by checking for \"signatures,\" which attempt to capture (syntactic) characteristics of the machine-level byte sequence of the malware. This reliance on a syntactic approach makes such detectors vulnerable to code obfuscations, increasingly used by malware writers, that alter syntactic properties of the malware byte sequence without significantly affecting their execution behavior.This paper takes the position that the key to malware identification lies in their semantics. It proposes a semantics-based framework for reasoning about malware detectors and proving properties such as soundness and completeness of these detectors. Our approach uses a trace semantics to characterize the behaviors of malware as well as the program being checked for infection, and uses abstract interpretation to \"hide\" irrelevant aspects of these behaviors. As a concrete application of our approach, we show that the semantics-aware malware detector proposed by Christodorescu et al. is complete with respect to a number of common obfuscations used by malware writers.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190270", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mila Dalla", + "last_name": "Preda", + "institution": "University of Verona" + }, + { + "first_name": "Mihai", + "last_name": "Christodorescu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Somesh", + "last_name": "Jha", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/popl/PredaCJD07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190248", + "title": "Extracting queries by static analysis of transparent persistence", + "abstract": "Transparent persistence promises to integrate programming languages and databases by allowing procedural programs to access persistent data with the same ease as non-persistent data. When the data is stored in a relational database, however, transparent persistence does not naturally leverage the performance benefits of relational query optimization. We present a program analysis that combines the benefits of both approaches by extracting database queries from programs with transparent access to persistent data. The analysis uses a sound abstract interpretation of the original program to approximate the data traversal paths in the program and the conditions under which the paths are used. The resulting paths are then converted into a query, and the program is simplified by removing redundant tests. We study an imperative kernel language with read-only access to persistent data and identify the conditions under which the transformations can be applied. This analysis approach promises to combine the software engineering benefits of transparent data persistence with the performance benefits of database query optimization.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190248", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ben", + "last_name": "Wiedermann", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/WiedermannC07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190232", + "title": "Generative unbinding of names", + "abstract": "This paper is concerned with a programming language construct for typed name binding that enforces αequivalence. It proves a new result about what operations on names can co-exist with this construct. The particular form of typed name binding studied is that used by the FreshML family of languages. Its characteristic feature is that a name binding is represented by an abstract (name,value)-pair that may only be deconstructed via the generation of fresh bound names. In FreshML the only observation one can make of names is to test whether or not they are equal. This restricted amount of observation was thought necessary to ensure that there is no observable difference between αequivalent name binders. Yet from an algorithmic point of view it would be desirable to allow other operations and relations on names, such as a total ordering. This paper shows that, contrary to expectations, one may add not just ordering, but almost any relation or numerical function on names without disturbing the fundamental correctness result about this form of typed name binding (that object-level αequivalence precisely corresponds to contextual equivalence at the programming meta-level), so long as one takes the state of dynamically created names into account.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190232", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew M.", + "last_name": "Pitts", + "institution": "Bridge University" + }, + { + "first_name": "Mark R.", + "last_name": "Shinwell", + "institution": "" + } + ], + "dblp_key": "conf/popl/PittsS07", + "venue": "popl", + "year": 2007 + }, + { + "paper_id": "10.1145/1190216.1190252", + "title": "JavaScript instrumentation for browser security", + "abstract": "It is well recognized that JavaScript can be exploited to launch browser-based security attacks. We propose to battle such attacks using program instrumentation. Untrusted JavaScript code goes through a rewriting process which identifies relevant operations, modifies questionable behaviors, and prompts the user (a web page viewer) for decisions on how to proceed when appropriate. Our solution is parametric with respect to the security policy-the policy is implemented separately from the rewriting, and the same rewriting process is carried out regardless of which policy is in use. Be-sides providing a rigorous account of the correctness of our solution, we also discuss practical issues including policy management and prototype experiments. A useful by-product of our work is an operational semantics of a core subset of JavaScript, where code embedded in (HTML) documents may generate further document pieces (with new code embedded) at runtime, yielding a form of self-modifying code.", + "date": "2007-01-17", + "link": "https://doi.org/10.1145/1190216.1190252", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dachuan", + "last_name": "Yu", + "institution": "DoCoMo Communications Laboratories Europe GmbH" + }, + { + "first_name": "Ajay", + "last_name": "Chander", + "institution": "DoCoMo Communications Laboratories Europe GmbH" + }, + { + "first_name": "Nayeem", + "last_name": "Islam", + "institution": "DoCoMo Communications Laboratories Europe GmbH" + }, + { + "first_name": "Igor", + "last_name": "Serikov", + "institution": "DoCoMo Communications Laboratories Europe GmbH" + } + ], + "dblp_key": "conf/popl/YuCIS07", + "venue": "popl", + "year": 2007 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2008.json b/data/pl_conferences/popl/2008.json new file mode 100644 index 0000000..638d2d9 --- /dev/null +++ b/data/pl_conferences/popl/2008.json @@ -0,0 +1,951 @@ +[ + { + "paper_id": "10.1145/1328438.1328441", + "title": "Caml trading", + "abstract": "Jane Street Capital is a successful proprietary trading company that has shifted from developing software in mainstream programming languages to developing software almost entirely in OCaml, a statically typed functional programming language that has only modest industrial use. The scope of the enterprise is small but growing: Jane Street now has over 20 OCaml programmers that have collectively written hundreds of thousands of lines of OCaml code. OCaml is used for building everything from trading systems to research infrastructure to user interfaces to systems administration tools. This talk will discuss the motivations behind Jane Street's adoption of OCaml, and why we think that statically typed functional programming languages are such a good fit for the world of trading and finance.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328441", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yaron", + "last_name": "Minsky", + "institution": "Capital University" + } + ], + "dblp_key": "conf/popl/Minsky08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328463", + "title": "Automatic inference of stationary fields: a generalization of java's final fields", + "abstract": "Java programmers can document that the relationship between two objects is unchanging by declaring the field that encodes that relationship to be final. This information can be used in program understanding and detection of errors in new code additions. Unfortunately, few fields in programs are actually declared final. Programs often contain fields that could be final, but are not declared so. Moreover, the definition of final has restrictions on initializationthat limit its applicability.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328463", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Unkel", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/UnkelL08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328483", + "title": "A type-theoretic foundation for programming with higher-order abstract syntax and first-class substitutions", + "abstract": "Higher-order abstract syntax (HOAS) is a simple, powerful technique for implementing object languages, since it directly supports common and tricky routines dealing with variables, such as capture-avoiding substitution and renaming. This is achieved by representing binders in the object-language via binders in the meta-language. However, enriching functional programming languages with direct support for HOAS has been a major challenge, because recursion over HOAS encodings requires one to traverse lambda-abstractions and necessitates programming with open objects.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328483", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "conf/popl/Pientka08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328448", + "title": "High-level small-step operational semantics for transactions", + "abstract": "Software transactions have received significant attention as a way to simplify shared-memory concurrent programming, but insufficient focus has been given to the precise meaning of software transactions or their interaction with other language features. This work begins to rectify that situation by presenting a family of formal languages that model a wide variety of behaviors for software transactions. These languages abstract away implementation details of transactional memory, providing high-level definitions suitable for programming languages. We use small-step semantics in order to represent explicitly the interleaved execution of threads that is necessary to investigate pertinent issues.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328448", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Katherine F.", + "last_name": "Moore", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/MooreG08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328475", + "title": "Foundations for structured programming with GADTs", + "abstract": "GADTs are at the cutting edge of functional programming and becomemore widely used every day. Nevertheless, the semantic foundations underlying GADTs are not well understood. In this paper we solve this problem by showing that the standard theory of data types as carriers of initial algebras of functors can be extended from algebraic and nested data types to GADTs. We then use this observation to derivean initial algebra semantics for GADTs, thus ensuring that all of the accumulated knowledge about initial algebras can be brought to bear on them. Next, we use our initial algebra semantics for GADTs to derive expressive and principled tools --- analogous to the well-known and widely-used ones for algebraic and nested data types---for reasoning about, programming with, and improving the performance of programs involving, GADTs; we christen such a collection of tools for a GADT an initial algebra package. Along the way, we give a constructive demonstration that every GADT can be reduced to one which uses only the equality GADT and existential quantification. Although other such reductions exist in the literature, ours is entirely local, is independent of any particular syntactic presentation of GADTs, and can be implemented in the host language, rather than existing solely as a metatheoretical artifact. The main technical ideas underlying our approach are (i) to modify the notion of a higher-order functor so that GADTs can be seen as carriers of initial algebras of higher-order functors, and (ii) to use left Kan extensions to trade arbitrary GADTs for simpler-but-equivalent ones for which initial algebra semantics can bederived.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328475", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patricia", + "last_name": "Johann", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Neil", + "last_name": "Ghani", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/popl/JohannG08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328484", + "title": "An approach to call-by-name delimited continuations", + "abstract": "We show that a variant of Parigot's λμ-calculus, originally due to de Groote and proved to satisfy Boehm's theorem by Saurin, is canonically interpretable as a call-by-name calculus of delimited control. This observation is expressed using Ariola et al's call-by-value calculus of delimited control, an extension of λμ-calculus with delimited control known to be equationally equivalent to Danvy and Filinski's calculus with shift and reset. Our main result then is that de Groote and Saurin's variant of λμ-calculus is equivalent to a canonical call-by-name variant of Ariola et al's calculus. The rest of the paper is devoted to a comparative study of the call-by-name and call-by-value variants of Ariola et al's calculus, covering in particular the questions of simple typing, operational semantics, and continuation-passing-style semantics. Finally, we discuss the relevance of Ariola et al's calculus as a uniform framework for representing different calculi of delimited continuations, including \"lazy\" variants such as Sabry's shift and lazy reset calculus.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328484", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hugo", + "last_name": "Herbelin", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Silvia", + "last_name": "Ghilezan", + "institution": "University of Novi Sad" + } + ], + "dblp_key": "conf/popl/HerbelinG08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328488", + "title": "From dirt to shovels: fully automatic tool generation from ad hoc data", + "abstract": "An ad hoc data source is any semistructured data source for which useful data analysis and transformation tools are not readily available. Such data must be queried, transformed and displayed by systems administrators, computational biologists, financial analysts and hosts of others on a regular basis. In this paper, we demonstrate that it is possible to generate a suite of useful data processing tools, including a semi-structured query engine, several format converters, a statistical analyzer and data visualization routines directly from the ad hoc data itself, without any human intervention. The key technical contribution of the work is a multi-phase algorithm that automatically infers the structure of an ad hoc data source and produces a format specification in the PADS data description language. Programmers wishing to implement custom data analysis tools can use such descriptions to generate printing and parsing libraries for the data. Alternatively, our software infrastructure will push these descriptions through the PADS compiler, creating format-dependent modules that, when linked with format-independent algorithms for analysis and transformation, result infully functional tools. We evaluate the performance of our inference algorithm, showing it scales linearlyin the size of the training data - completing in seconds, as opposed to the hours or days it takes to write a description by hand. We also evaluate the correctness of the algorithm, demonstrating that generating accurate descriptions often requires less than 5% of theavailable data.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328488", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "AT&T (United States)" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Kenny Q.", + "last_name": "Zhu", + "institution": "Princeton University" + }, + { + "first_name": "Peter S.", + "last_name": "White", + "institution": "Galois (United States)" + } + ], + "dblp_key": "conf/popl/FisherWZW08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328476", + "title": "Imperative self-adjusting computation", + "abstract": "Self-adjusting computation enables writing programs that can automatically and efficiently respond to changes to their data (e.g., inputs). The idea behind the approach is to store all data that can change over time in modifiable references and to let computations construct traces that can drive change propagation. After changes have occurred, change propagation updates the result of the computation by re-evaluating only those expressions that depend on the changed data. Previous approaches to self-adjusting computation require that modifiable references be written at most once during execution---this makes the model applicable only in a purely functional setting.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328476", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "M.", + "last_name": "Blume", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/popl/AcarAB08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328467", + "title": "Generating precise and concise procedure summaries", + "abstract": "We present a framework for generating procedure summaries that are (a) precise - applying the summary in a given context yields the same result as re-analyzing the procedure in that context, and(b) concise - the summary exploits the commonalitiesin the ways the procedure manipulates abstract values, and does not contain superfluous context information.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328467", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Greta", + "last_name": "Yorsh", + "institution": "Tel Aviv University" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "IBM (United States)" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/YorshYC08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328445", + "title": "Much ado about two (pearl): a pearl on parallel prefix computation", + "abstract": "This pearl develops a statement about parallel prefix computation in the spirit of Knuth's 0-1-Principle for oblivious sorting algorithms. It turns out that 0-1 is not quite enough here. The perfect hammer for the nails we are going to drive in is relational parametricity.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328445", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Janis", + "last_name": "Voigtländer", + "institution": "TU Dresden" + } + ], + "dblp_key": "conf/popl/Voigtlander08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328451", + "title": "Separation logic, abstraction and inheritance", + "abstract": "Inheritance is a fundamental concept in object-oriented programming, allowing new classes to be defined in terms of old classes. When used with care, inheritance is an essential tool for object-oriented programmers. Thus, for those interested in developing formal verification techniques, the treatment of inheritance is of paramount importance. Unfortunately, inheritance comes in a number of guises, all requiring subtle techniques.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328451", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "University of Cambridge" + }, + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/ParkinsonB08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328460", + "title": "Subcubic algorithms for recursive state machines", + "abstract": "We show that the reachability problem for recursive state machines (or equivalently, pushdown systems), believed for long to have cubic worst-case complexity, can be solved in slightly subcubic time. All that is necessary for the new bound is a simple adaptation of a known technique. We also show that a better algorithm exists if the input machine does not have infinite recursive loops.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328460", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/Chaudhuri08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328440", + "title": "Relevance heuristics for program analysis", + "abstract": "Relevance heuristics allow us to tailor a program analysis to a particular property to be verified. This in turn makes it possible to improve the precision of the analysis where needed, while maintaining scalability. In this talk I will discuss the principles by which SAT solvers and other decision procedures decide what information is relevant to a given proof. Then we will see how these ideas can be exploited in program verification using the method of Craig interpolation. The result is an analysis that is finely tuned to prove a given property of a program. At the end of the talk, I will cover some recent research in this area, including the use of interpolants for verifying heap-manipulating programs.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328440", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kenneth L.", + "last_name": "McMillan", + "institution": "Cadence Design Systems (United States)" + } + ], + "dblp_key": "conf/popl/McMillan08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328456", + "title": "A logical account of pspace", + "abstract": "We propose a characterization of PSPACE by means of atype assignment for an extension of lambda calculus with a conditional construction. The type assignment STAB is an extension of STA, a type assignment for lambda-calculus inspired by Lafont's Soft Linear Logic.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328456", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University of Turin" + }, + { + "first_name": "Jean-Yves", + "last_name": "Marion", + "institution": "Laboratoire Lorrain de Recherche en Informatique et ses Applications" + }, + { + "first_name": "Simona Ronchi Della", + "last_name": "Rocca", + "institution": "University of Turin" + } + ], + "dblp_key": "conf/popl/GaboardiMR08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328486", + "title": "The design and implementation of typed scheme", + "abstract": "When scripts in untyped languages grow into large programs, maintaining them becomes difficult. A lack of types in typical scripting languages means that programmers must (re)discover critical pieces of design information every time they wish to change a program. This analysis step both slows down the maintenance process and may even introduce mistakes due to the violation of undiscovered invariants.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328486", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/Tobin-HochstadtF08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328465", + "title": "A theory of platform-dependent low-level software", + "abstract": "The C language definition leaves the sizes and layouts of types partially unspecified. When a C program makes assumptions about type layout, its semantics is defined only on platforms (C compilers and the underlying hardware) on which those assumptions hold. Previous work on formalizing C-like languages has ignored this issue, either by assuming that programs do not make such assumptions or by assuming that all valid programs target only one platform. In the latter case, the platform's choices are hard-wired in the language semantics.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328465", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marius", + "last_name": "Nita", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/NitaGC08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328480", + "title": "Extensible encoding of type hierarchies", + "abstract": "The subtyping test consists of checking whether a type t is a descendant of a type r (Agrawal et al. 1989). We study how to perform such a test efficiently, assuming a dynamic hierarchy when new types are inserted at run-time. The goal is to achieve time and space efficiency, even as new types are inserted. We propose an extensible scheme, named ESE, that ensures (1) efficient insertion of new types, (2) efficient subtyping tests, and (3) small space usage. On the one hand ESE provides comparable test times to the most efficient existing static schemes (e.g.,Zibin et al. (2001)). On the other hand, ESE has comparable insertion times to the most efficient existing dynamic scheme (Baehni et al. 2007), while ESE outperforms it by a factor of 2-3 times in terms of space usage.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328480", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hamed S.", + "last_name": "Alavi", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Seth", + "last_name": "Gilbert", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/AlaviGG08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328447", + "title": "Contextual effects for version-consistent dynamic software updatingalland safe concurrent programming", + "abstract": "This paper presents a generalization of standard effect systems that we call contextual effects. A traditional effect system computes the effect of an expression e. Our system additionally computes the effects of the computational context in which e occurs. More specifically, we computethe effect of the computation that has already occurred(the prior effect) and the effect of the computation yet to take place (the future effect).", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328447", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Polyvios", + "last_name": "Pratikakis", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/popl/NeamtiuHFP08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328478", + "title": "Cryptographically sound implementations for typed information-flow security", + "abstract": "In language-based security, confidentiality and integrity policies conveniently specify the permitted flows of information between different parts of a program with diverse levels of trust. These policies enable a simple treatment of security, and they can often be verified by typing. However, their enforcement in concrete systems involves delicate compilation issues.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328478", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tamara", + "last_name": "Rezk", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/FournetR08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328482", + "title": "Focusing and higher-order abstract syntax", + "abstract": "Focusing is a proof-search strategy, originating in linear logic, that elegantly eliminates inessential nondeterminism, with one byproduct being a correspondence between focusing proofs and programs with explicit evaluation order. Higher-order abstract syntax (HOAS) is a technique for representing higher-order programming language constructs (e.g., λ's) by higher-order terms at the\"meta-level\", thereby avoiding some of the bureaucratic headaches of first-order representations (e.g., capture-avoiding substitution).", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328482", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Noam", + "last_name": "Zeilberger", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Zeilberger08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328479", + "title": "On the computational soundness of cryptographically masked flows", + "abstract": "To speak about the security of information flow in programs employing cryptographic operations, definitions based on computational indistinguish ability of distributions over program states have to be used. These definitions, as well as the accompanying analysis tools, are complex and error-prone to argue about. Cryptographically masked flows, proposed by Askarov, Hedin and Sabelfeld, are an abstract execution model and security definition that attempt to abstract away the details of computational security. This abstract model is useful because analysis of programs can be conducted using the usual techniques for enforcing non-interference.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328479", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peeter", + "last_name": "Laud", + "institution": "University of Tartu" + } + ], + "dblp_key": "conf/popl/Laud08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328472", + "title": "Multiparty asynchronous session types", + "abstract": "Communication is becoming one of the central elements in software development. As a potential typed foundation for structured communication-centred programming, session types have been studied over the last decade for a wide range of process calculi and programming languages, focussing on binary (two-party) sessions. This work extends the foregoing theories of binary session types to multiparty, asynchronous sessions, which often arise in practical communication-centred applications. Presented as a typed calculus for mobile processes, the theory introduces a new notion of types in which interactions involving multiple peers are directly abstracted as a global scenario. Global types retain a friendly type syntax of binary session types while capturing complex causal chains of multiparty asynchronous interactions. A global type plays the role of a shared agreement among communication peers, and is used as a basis of efficient type checking through its projection onto individual peers. The fundamental properties of the session type discipline such as communication safety, progress and session fidelity are established for generaln-party asynchronous interactions.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328472", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kohei", + "last_name": "Honda", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + }, + { + "first_name": "Marco", + "last_name": "Carbone", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/HondaYC08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328459", + "title": "Proving non-termination", + "abstract": "The search for proof and the search for counterexamples (bugs) are complementary activities that need to be pursued concurrently in order to maximize the practical success rate of verification tools.While this is well-understood in safety verification, the current focus of liveness verification has been almost exclusively on the search for termination proofs. A counterexample to termination is an infinite programexecution. In this paper, we propose a method to search for such counterexamples. The search proceeds in two phases. We first dynamically enumerate lasso-shaped candidate paths for counterexamples, and then statically prove their feasibility. We illustrate the utility of our nontermination prover, called TNT, on several nontrivial examples, some of which require bit-level reasoning about integer representations.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328459", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ashutosh", + "last_name": "Gupta", + "institution": "Max Planck Society" + }, + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "UtopiaCompression (United States)" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Max Planck Institute for Informatics" + }, + { + "first_name": "Ru-Gang", + "last_name": "Xu", + "institution": "UtopiaCompression (United States)" + } + ], + "dblp_key": "conf/popl/GuptaHMRX08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328443", + "title": "Engineering formal metatheory", + "abstract": "Machine-checked proofs of properties of programming languages have become acritical need, both for increased confidence in large and complex designsand as a foundation for technologies such as proof-carrying code. However, constructing these proofs remains a black art, involving many choices in the formulation of definitions and theorems that make a huge cumulative difference in the difficulty of carrying out large formal developments. There presentation and manipulation of terms with variable binding is a key issue.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328443", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brian", + "last_name": "Aydemir", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Randy", + "last_name": "Pollack", + "institution": "University of Edinburgh" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/AydemirCPPW08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328474", + "title": "Clowns to the left of me, jokers to the right (pearl): dissecting data structures", + "abstract": "This paper introduces a small but useful generalisation to the 'derivative' operation on datatypes underlying Huet's notion of 'zipper', giving a concrete representation to one-hole contexts in data which is undergoing transformation. This operator, 'dissection', turns a container-like functor into a bifunctor representing a one-hole context in which elements to the left of the hole are distinguished in type from elements to its right.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328474", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/popl/McBride08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328468", + "title": "Lifting abstract interpreters to quantified logical domains", + "abstract": "We describe a general technique for building abstract interpreters over powerful universally quantified abstract domains that leverage existing quantifier-free domains. Our quantified abstract domain can represent universally quantified facts like ∀i(0 ≤ i < n ⇒ α[i] = 0). The principal challenge in this effort is that, while most domains supply over-approximations of operations like join, meet, and variable elimination, working with the guards of quantified facts requires under-approximation. We present an automatic technique to convert the standard over-approximation operations provided with all domains into sound under-approximations. We establish the correctness of our abstract interpreters by identifying two lattices---one that establishes the soundness of the abstract interpreter and another that defines its precision, or completeness. Our experiments on a variety of programs using arrays and pointers (including several sorting algorithms) demonstrate the feasibility of the approach on challenging examples.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328468", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Bill", + "last_name": "McCloskey", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "Menlo School" + } + ], + "dblp_key": "conf/popl/GulwaniMT08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328471", + "title": "A theory of contracts for web services", + "abstract": "Contracts are behavioural descriptions of Web services. We devise a theory of contracts that formalises the compatibility of a client to a service, and the safe replacement of a service with another service. The use of contracts statically ensures the successful completion of every possible interaction between compatible clients and services.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328471", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Université Paris Cité" + }, + { + "first_name": "Nils", + "last_name": "Gesbert", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Luca", + "last_name": "Padovani", + "institution": "University of Urbino" + } + ], + "dblp_key": "conf/popl/CastagnaGP08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328461", + "title": "Back to the future: revisiting precise program verification using SMT solvers", + "abstract": "This paper takes a fresh look at the problem of precise verification of heap-manipulating programs using first-order Satisfiability-Modulo-Theories (SMT) solvers. We augment the specification logic of such solvers by introducing the Logic of Interpreted Sets and Bounded Quantification for specifying properties of heap-manipulating programs. Our logic is expressive, closed under weakest preconditions, and efficiently implementable on top of existing SMT solvers. We have created a prototype implementation of our logic over the solvers Simplify and Z3 and used our prototype to verify many programs. Our preliminary experience is encouraging; the completeness and the efficiency of the decisionprocedure is clearly evident in practice and has greatly improved the user experience of the verifier.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328461", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/LahiriQ08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328469", + "title": "Relational inductive shape analysis", + "abstract": "Shape analyses are concerned with precise abstractions of the heap to capture detailed structural properties. To do so, they need to build and decompose summaries of disjoint memory regions. Unfortunately, many data structure invariants require relations be tracked across disjoint regions, such as intricate numerical data invariants or structural invariants concerning back and cross pointers. In this paper, we identify issues inherent to analyzing relational structures and design an abstract domain that is parameterized both by an abstract domain for pure data properties and by user-supplied specifications of the data structure invariants to check. Particularly, it supports hybrid invariants about shape and data and features a generic mechanism for materializing summaries at the beginning, middle, or end of inductive structures. Around this domain, we build a shape analysis whose interesting components include a pre-analysis on the user-supplied specifications that guides the abstract interpretation and a widening operator over the combined shape and data domain. We then demonstrate our techniques on the proof of preservation of the red-black tree invariants during insertion.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328469", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/ChangR08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328487", + "title": "Boomerang: resourceful lenses for string data", + "abstract": "A lens is a bidirectional program. When read from left toright, it denotes an ordinary function that maps inputs to outputs. When read from right to left, it denotes an ''update translator'' that takes an input together with an updated output and produces a new input that reflects the update. Many variants of this idea have been explored in the literature, but none deal fully with ordered data. If, for example, an update changes the order of a list in theoutput, the items in the output list and the chunks of the input that generated them can be misaligned, leading to lost or corrupted data.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328487", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Bohannon", + "institution": "University of Pennsylvania" + }, + { + "first_name": "J. Nathan", + "last_name": "Foster", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Alexandre", + "last_name": "Pilkiewicz", + "institution": "École Polytechnique" + }, + { + "first_name": "Alan", + "last_name": "Schmitt", + "institution": "Centre Inria de l'Université Grenoble Alpes" + } + ], + "dblp_key": "conf/popl/BohannonFPPS08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328455", + "title": "The intensional content of Rice's theorem", + "abstract": "The proofs of major results of Computability Theory like Rice, Rice-Shapiro or Kleene's fixed point theorem hidemore information of what is usually expressed in theirrespective statements. We make this information explicit, allowing to state stronger, complexity theoretic-versions of all these theorems. In particular, we replace the notion of extensional set of indices of programs, by a set of indices of programs having not only the same extensional behavior but also similar complexity (Complexity Clique). We prove, under very weak complexity assumptions, that any recursive Complexity Clique is trivial, and any r.e. Complexity Clique is an extensional set (and thus satisfies Rice-Shapiro conditions). This allows, for instance, to use Rice's argument to prove that the property of having polynomial complexity is not decidable, and to use Rice-Shapiro to conclude that it is not even semi-decidable. We conclude the paper with a discussion of \"complexity-theoretic\" versions of Kleene's Fixed Point Theorem.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328455", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Asperti", + "institution": "University of Bologna" + } + ], + "dblp_key": "conf/popl/Asperti08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328439", + "title": "Systems biology, models, and concurrency", + "abstract": "Models will play a central role in the representation, storage, manipulation, and communication of knowledge in systems biology. Models capable of fulfilling such a role will likely differ from the all familiar styles deployed with great success in the physical sciences. Molecular systems at the basis of cellular decision processes are concurrent and combinatorial. Their behavior is as much constrained by relationships of causality between molecular interactions as it is by chemical kinetics. Understanding how such systems give rise to coherent behavior and designing effective interventions to fight disease will require a notion of model that is akin to the concept of program in computer science. I will discuss recent progress in implementing a platform and tools for formal analysis that bring us closer to this vision. Protein interactions are represented by means of rules expressed in a formal language that captures a very simple, yet effective and biologically meaningful level of abstraction. Models, then, are collections of rules operating on an initial set of agents, in complete analogy to rules of organic chemical reactions. I will describe tools for analyzing and navigating rule collections as well as exploring their dynamics. We draw on concepts familiar to computer science, especially event structures, and adapt them to biological needs with the goal of formalizing the notion of \"pathway\". The challenges are many, but a road map for the future is discernible. Computer science will play a central role in providing an additional foundational layer, both theoretical and practical, that neither physics nor chemistry can offer on their own in the future definition of the biological sciences.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328439", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Walter", + "last_name": "Fontana", + "institution": "Harvard University" + } + ], + "dblp_key": "conf/popl/Fontana08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328453", + "title": "Cyclic proofs of program termination in separation logic", + "abstract": "We propose a novel approach to proving the termination of heap-manipulating programs, which combines separation logic with cyclic proof within a Hoare-style proof system.Judgements in this system express (guaranteed) termination of the program when started from a given line in the program and in a state satisfying a given precondition, which is expressed as a formula of separation logic. The proof rules of our system are of two types: logical rules that operate on preconditions; and symbolic execution rules that capture the effect of executing program commands.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328453", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J G.", + "last_name": "Brotherston", + "institution": "Imperial College London" + }, + { + "first_name": "Richard", + "last_name": "Bornat", + "institution": "Middlesex University" + }, + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/BrotherstonBC08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328444", + "title": "Formal verification of translation validators: a case study on instruction scheduling optimizations", + "abstract": "Translation validation consists of transforming a program and a posteriori validating it in order to detect a modification of itssemantics. This approach can be used in a verified compiler, provided that validation is formally proved to be correct. We present two such validators and their Coq proofs of correctness. The validators are designed for two instruction scheduling optimizations: list scheduling and trace scheduling.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328444", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean-Baptiste", + "last_name": "Tristan", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/TristanL08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328457", + "title": "Lightweight semiformal time complexity analysis for purely functional data structures", + "abstract": "Okasaki and others have demonstrated how purely functional data structures that are efficient even in the presence of persistence can be constructed. To achieve good time bounds essential use is often made of laziness. The associated complexity analysis is frequently subtle, requiring careful attention to detail, and hence formalising it is valuable. This paper describes a simple library which can be used to make the analysis of a class of purely functional data structures and algorithms almost fully formal. The basic idea is to use the type system to annotate every function with the time required to compute its result. An annotated monad is used to combine time complexity annotations. The library has been used to analyse some existing data structures, for instance the deque operations of Hinze and Paterson's finger trees.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328457", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nils Anders", + "last_name": "Danielsson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/Danielsson08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328449", + "title": "Semantics of transactional memory and automatic mutual exclusion", + "abstract": "Software Transactional Memory (STM) is an attractive basis for the development of language features for concurrent programming. However, the semantics of these features can be delicate and problematic. In this paper we explore the tradeoffs between semantic simplicity, the viability of efficient implementation strategies, and the flexibilityof language constructs. Specifically, we develop semantics and type systems for the constructs of the Automatic Mutual Exclusion (AME) programming model; our results apply also to other constructs, such as atomic blocks. With this semantics as a point of reference, we study several implementation strategies. We model STM systems that use in-place update, optimistic concurrency, lazy conflict detection, and roll-back. These strategies are correct only under non-trivial assumptions that we identify and analyze. One important source of errors is that some efficient implementations create dangerous 'zombie' computations where a transaction keeps running after experiencing a conflict; the assumptions confine the effects of these computations.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328449", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Andrew", + "last_name": "Birrell", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Tim", + "last_name": "Harris", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Michael", + "last_name": "Isard", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/popl/AbadiBHI08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328452", + "title": "Enhancing modular OO verification with separation logic", + "abstract": "Conventional specifications for object-oriented (OO) programs must adhere to behavioral subtyping in support of class inheritance and method overriding. However, this requirement inherently weakens the specifications of overridden methods in superclasses, leading to imprecision during program reasoning. To address this, we advocate a fresh approach to OO verification that focuses on the distinction and relation between specifications that cater to calls with static dispatching from those for calls with dynamic dispatching. We formulate a novel specification subsumption that can avoid code re-verification, where possible. Using a predicate mechanism, we propose a flexible scheme for supporting class invariant and lossless casting. Our aim is to lay the foundation for a practical verification system that is precise, concise and modular for sequential OO programs. We exploit the separation logic formalism to achieve this.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328452", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + }, + { + "first_name": "Cristina", + "last_name": "David", + "institution": "National University of Singapore" + }, + { + "first_name": "Huu Hai", + "last_name": "Nguyen", + "institution": "Singapore-MIT Alliance for Research and Technology" + }, + { + "first_name": "Shengchao", + "last_name": "Qin", + "institution": "Durham University" + } + ], + "dblp_key": "conf/popl/ChinDNQ08", + "venue": "popl", + "year": 2008 + }, + { + "paper_id": "10.1145/1328438.1328464", + "title": "Demand-driven alias analysis for C", + "abstract": "This paper presents a demand-driven, flow-insensitive analysisalgorithm for answering may-alias queries. We formulate thecomputation of alias queries as a CFL-reachability problem, and use this formulation to derive a demand-driven analysis algorithm. The analysis uses a worklist algorithm that gradually explores the program structure and stops as soon as enough evidence is gathered to answer the query. Unlike existing techniques, our approach does not require building or intersecting points-to sets.", + "date": "2008-01-07", + "link": "https://doi.org/10.1145/1328438.1328464", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xin", + "last_name": "Zheng", + "institution": "Cornell University" + }, + { + "first_name": "Radu", + "last_name": "Rugina", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/ZhengR08", + "venue": "popl", + "year": 2008 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2009.json b/data/pl_conferences/popl/2009.json new file mode 100644 index 0000000..2227046 --- /dev/null +++ b/data/pl_conferences/popl/2009.json @@ -0,0 +1,1024 @@ +[ + { + "paper_id": "10.1145/1480881.1480935", + "title": "Automated verification of practical garbage collectors", + "abstract": "Garbage collectors are notoriously hard to verify, due to their low-level interaction with the underlying system and the general difficulty in reasoning about reachability in graphs. Several papers have presented verified collectors, but either the proofs were hand-written or the collectors were too simplistic to use on practical applications. In this work, we present two mechanically verified garbage collectors, both practical enough to use for real-world C# benchmarks. The collectors and their associated allocators consist of x86 assembly language instructions and macro instructions, annotated with preconditions, postconditions, invariants, and assertions. We used the Boogie verification generator and the Z3 automated theorem prover to verify this assembly language code mechanically. We provide measurements comparing the performance of the verified collector with that of the standard Bartok collectors on off-the-shelf C# benchmarks, demonstrating their competitiveness.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480935", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/HawblitzelP09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480923", + "title": "Classical BI: a logic for reasoning about dualising resources", + "abstract": "We show how to extend O'Hearn and Pym's logic of bunched implications, BI, to classical BI (CBI), in which both the additive and the multiplicative connectives behave classically. Specifically, CBI is a non-conservative extension of (propositional) Boolean BI that includes multiplicative versions of falsity, negation and disjunction. We give an algebraic semantics for CBI that leads us naturally to consider resource models of CBI in which every resource has a unique dual. We then give a cut-eliminating proof system for CBI, based on Belnap's display logic, and demonstrate soundness and completeness of this proof system with respect to our semantics.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480923", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J G.", + "last_name": "Brotherston", + "institution": "Imperial College London" + }, + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/BrotherstonC09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480893", + "title": "Modular code generation from synchronous block diagrams: modularity vs. code size", + "abstract": "We study modular, automatic code generation from hierarchical block diagrams with synchronous semantics. Such diagrams are the fundamental model behind widespread tools in the embedded software domain, such as Simulink and SCADE. Code is modular in the sense that it is generated for a given composite block independently from context (i.e., without knowing in which diagrams the block is to be used) and using minimal information about the internals of the block. In previous work, we have shown how modular code can be generated by computing a set of interface functions for each block and a set of dependencies between these functions that is exported along with the interface. We have also introduced a quantified notion of modularity in terms of the number of interface functions generated per block, and showed how to minimize this number, which is essential for scalability. Finally, we have exposed the fundamental trade-off between modularity and reusability (set of diagrams the block can be used in).", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480893", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roberto", + "last_name": "Lublinerman", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Christian", + "last_name": "Szegedy", + "institution": "Cadence Design Systems (United States)" + }, + { + "first_name": "Stavros", + "last_name": "Tripakis", + "institution": "Cadence Design Systems (United States)" + } + ], + "dblp_key": "conf/popl/LublinermanST09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480891", + "title": "Flexible types: robust type inference for first-class polymorphism", + "abstract": "We present HML, a type inference system that supports full first-class polymorphism where few annotations are needed: only function parameters with a polymorphic type need to be annotated. HML is a simplification of MLF where only flexibly quantified types are used. This makes the types easier to work with from a programmers perspective, and simplifies the implementation of the type inference algorithm. Still, HML retains much of the expressiveness of MLF, it is robust with respect to small program transformations, and has a simple specification of the type rules with an effective type inference algorithm that infers principal types. A small reference implementation with many examples is available at: http://research.microsoft.com/users/daan/pubs.html.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480891", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/Leijen09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480933", + "title": "Types and higher-order recursion schemes for verification of higher-order programs", + "abstract": "We propose a new verification method for temporal properties of higher-order functional programs, which takes advantage of Ong's recent result on the decidability of the model-checking problem for higher-order recursion schemes (HORS's). A program is transformed to an HORS that generates a tree representing all the possible event sequences of the program, and then the HORS is model-checked. Unlike most of the previous methods for verification of higher-order programs, our verification method is sound and complete. Moreover, this new verification framework allows a smooth integration of abstract model checking techniques into verification of higher-order programs. We also present a type-based verification algorithm for HORS's. The algorithm can deal with only a fragment of the properties expressed by modal mu-calculus, but the algorithm and its correctness proof are (arguably) much simpler than those of Ong's game-semantics-based algorithm. Moreover, while the HORS model checking problem is n-EXPTIME in general, our algorithm is linear in the size of HORS, under the assumption that the sizes of types and specification formulas are bounded by a constant.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480933", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/popl/Kobayashi09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480912", + "title": "A combination framework for tracking partition sizes", + "abstract": "We describe an abstract interpretation based framework for proving relationships between sizes of memory partitions. Instances of this framework can prove traditional properties such as memory safety and program termination but can also establish upper bounds on usage of dynamically allocated memory. Our framework also stands out in its ability to prove properties of programs manipulating both heap and arrays which is considered a difficult task. Technically, we define an abstract domain that is parameterized by an abstract domain for tracking memory partitions (sets of memory locations) and by a numerical abstract domain for tracking relationships between cardinalities of the partitions. We describe algorithms to construct the transfer functions for the abstract domain in terms of the corresponding transfer functions of the parameterized abstract domains. A prototype of the framework was implemented and used to prove interesting properties of realistic programs, including programs that could not have been automatically analyzed before.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480912", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tal", + "last_name": "Lev-Ami", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/GulwaniLS09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480898", + "title": "SPEED: precise and efficient static estimation of program computational complexity", + "abstract": "This paper describes an inter-procedural technique for computing symbolic bounds on the number of statements a procedure executes in terms of its scalar inputs and user-defined quantitative functions of input data-structures. Such computational complexity bounds for even simple programs are usually disjunctive, non-linear, and involve numerical properties of heaps. We address the challenges of generating these bounds using two novel ideas.We introduce a proof methodology based on multiple counter instrumentation (each counter can be initialized and incremented at potentially multiple program locations) that allows a given linear invariant generation tool to compute linear bounds individually on these counter variables. The bounds on these counters are then composed together to generate total bounds that are non-linear and disjunctive. We also give an algorithm for automating this proof methodology. Our algorithm generates complexity bounds that are usually precise not only in terms of the computational complexity, but also in terms of the constant factors.Next, we introduce the notion of user-defined quantitative functions that can be associated with abstract data-structures, e.g., length of a list, height of a tree, etc. We show how to compute bounds in terms of these quantitative functions using a linear invariant generation tool that has support for handling uninterpreted functions. We show application of this methodology to commonly used data-structures (namely lists, list of lists, trees, bit-vectors) using examples from Microsoft product code. We observe that a few quantitative functions for each data-structure are usually sufficient to allow generation of symbolic complexity bounds of a variety of loops that iterate over these data-structures, and that it is straightforward to define these quantitative functions.The combination of these techniques enables generation of precise computational complexity bounds for real-world examples (drawn from Microsoft product code and C++ STL library code) for some of which it is non-trivial to even prove termination. Such automatically generated bounds are very useful for early detection of egregious performance problems in large modular codebases that are constantly being changed by multiple developers who make heavy use of code written by others without a good understanding of their implementation complexity.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480898", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Krishna K.", + "last_name": "Mehra", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/GulwaniMC09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480885", + "title": "A calculus of atomic actions", + "abstract": "We present a proof calculus and method for the static verification of assertions and procedure specifications in shared-memory concurrent programs. The key idea in our approach is to use atomicity as a proof tool and to simplify the verification of assertions by rewriting programs to consist of larger atomic actions. We propose a novel, iterative proof style in which alternating use of abstraction and reduction is exploited to compute larger atomic code blocks in a sound manner. This makes possible the verification of assertions in the transformed program by simple sequential reasoning within atomic blocks, or significantly simplified application of existing concurrent program verification techniques such as the Owicki-Gries or rely-guarantee methods. Our method facilitates a clean separation of concerns where at each phase of the proof, the user worries only about only either the sequential properties or the concurrency control mechanisms in the program. We implemented our method in a tool called QED. We demonstrate the simplicity and effectiveness of our approach on a number of benchmarks including ones with intricate concurrency protocols.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480885", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tayfun", + "last_name": "Elmas", + "institution": "Koç University" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Serdar", + "last_name": "Taşiran", + "institution": "Koç University" + } + ], + "dblp_key": "conf/popl/ElmasQT09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480897", + "title": "A foundation for flow-based program matching: using temporal logic and model checking", + "abstract": "Reasoning about program control-flow paths is an important functionality of a number of recent program matching languages and associated searching and transformation tools. Temporal logic provides a well-defined means of expressing properties of control-flow paths in programs, and indeed an extension of the temporal logic CTL has been applied to the problem of specifying and verifying the transformations commonly performed by optimizing compilers. Nevertheless, in developing the Coccinelle program transformation tool for performing Linux collateral evolutions in systems code, we have found that existing variants of CTL do not adequately support rules that transform subterms other than the ones matching an entire formula. Being able to transform any of the subterms of a matched term seems essential in the domain targeted by Coccinelle.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480897", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julien", + "last_name": "Brunel", + "institution": "University of Copenhagen" + }, + { + "first_name": "Damien", + "last_name": "Doligez", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "René Rydhof", + "last_name": "Hansen", + "institution": "Aalborg University" + }, + { + "first_name": "Julia L.", + "last_name": "Lawall", + "institution": "University of Copenhagen" + }, + { + "first_name": "Gilles", + "last_name": "Muller", + "institution": "École Centrale de Nantes" + } + ], + "dblp_key": "conf/popl/BrunelDHLM09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480887", + "title": "A model of cooperative threads", + "abstract": "We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a trace-based denotational semantics for this language; this semantics is fully abstract but mathematically elementary. We also give an equational theory for the computational effects that underlie the language, including thread spawning. We then analyze threads in terms of the free algebra monad for this theory.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480887", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Silicon Valley University" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/AbadiP09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480921", + "title": "Unifying type checking and property checking for low-level code", + "abstract": "We present a unified approach to type checking and property checking for low-level code. Type checking for low-level code is challenging because type safety often depends on complex, program-specific invariants that are difficult for traditional type checkers to express. Conversely, property checking for low-level code is challenging because it is difficult to write concise specifications that distinguish between locations in an untyped program's heap. We address both problems simultaneously by implementing a type checker for low-level code as part of our property checker.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480921", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Condit", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Brian", + "last_name": "Hackett", + "institution": "Stanford University" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/ConditHLQ09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480927", + "title": "Focusing on pattern matching", + "abstract": "In this paper, we show how pattern matching can be seen to arise from a proof term assignment for the focused sequent calculus. This use of the Curry-Howard correspondence allows us to give a novel coverage checking algorithm, and makes it possible to give a rigorous correctness proof for the classical pattern compilation strategy of building decision trees via matrices of patterns.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480927", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Krishnaswami09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480903", + "title": "Lazy evaluation and delimited control", + "abstract": "The call-by-need lambda calculus provides an equational framework for reasoning syntactically about lazy evaluation. This paper examines its operational characteristics.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480903", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "Rice University" + }, + { + "first_name": "Andrew", + "last_name": "Lumsdaine", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/GarciaLS09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480909", + "title": "Feedback-directed barrier optimization in a strongly isolated STM", + "abstract": "Speed improvements in today's processors have largely been delivered in the form of multiple cores, increasing the importance of abstractions that ease parallel programming. Software transactional memory (STM) addresses many of the complications of concurrency by providing a simple and composable model for safe access to shared data structures. Software transactions extend a language with an atomic primitive that declares that the effects of a block of code should not be interleaved with actions executing concurrently on other threads. Adding barriers to shared memory accesses provides atomicity, consistency and isolation.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480909", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nathan", + "last_name": "Bronson", + "institution": "Stanford University" + }, + { + "first_name": "Christos", + "last_name": "Kozyrakis", + "institution": "Palo Alto University" + }, + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/BronsonKO09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480901", + "title": "Wild control operators", + "abstract": "Linguists seek to understand the semantics of expressions in human languages. Certainly there are many natural language expressions--operators in the wild, so to speak--that control evaluation in ways that are familiar from programming languages: just think of the natural-language counterparts of if, unless, while, etc. But in general, how well-behaved are control operators found in the wild? Can we always understand them in terms of familiar programming constructs, or do they go significantly beyond the expressive power of programming languages?", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480901", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chris", + "last_name": "Barker", + "institution": "" + } + ], + "dblp_key": "conf/popl/Barker09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480911", + "title": "Semi-sparse flow-sensitive pointer analysis", + "abstract": "Pointer analysis is a prerequisite for many program analyses, and the effectiveness of these analyses depends on the precision of the pointer information they receive. Two major axes of pointer analysis precision are flow-sensitivity and context-sensitivity, and while there has been significant recent progress regarding scalable context-sensitive pointer analysis, relatively little progress has been made in improving the scalability of flow-sensitive pointer analysis.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480911", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ben", + "last_name": "Hardekopf", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Calvin", + "last_name": "Lin", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/HardekopfL09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480930", + "title": "Relaxed memory models: an operational approach", + "abstract": "Memory models define an interface between programs written in some language and their implementation, determining which behaviour the memory (and thus a program) is allowed to have in a given model. A minimal guarantee memory models should provide to the programmer is that well-synchronized, that is, data-race free code has a standard semantics. Traditionally, memory models are defined axiomatically, setting constraints on the order in which memory operations are allowed to occur, and the programming language semantics is implicit as determining some of these constraints. In this work we propose a new approach to formalizing a memory model in which the model itself is part of a weak operational semantics for a (possibly concurrent) programming language. We formalize in this way a model that allows write operations to the store to be buffered. This enables us to derive the ordering constraints from the weak semantics of programs, and to prove, at the programming language level, that the weak semantics implements the usual interleaving semantics for data-race free programs, hence in particular that it implements the usual semantics for sequential code.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480930", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gérard", + "last_name": "Boudol", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Gustavo", + "last_name": "Petri", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/BoudolP09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480925", + "title": "State-dependent representation independence", + "abstract": "Mitchell's notion of representation independence is a particularly useful application of Reynolds' relational parametricity -- two different implementations of an abstract data type can be shown contextually equivalent so long as there exists a relation between their type representations that is preserved by their operations. There have been a number of methods proposed for proving representation independence in various pure extensions of System F (where data abstraction is achieved through existential typing), as well as in Algol- or Java-like languages (where data abstraction is achieved through the use of local mutable state). However, none of these approaches addresses the interaction of existential type abstraction and local state. In particular, none allows one to prove representation independence results for generative ADTs -- i.e. ADTs that both maintain some local state and define abstract types whose internal representations are dependent on that local state.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480925", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/AhmedDR09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480922", + "title": "Local rely-guarantee reasoning", + "abstract": "Rely-Guarantee reasoning is a well-known method for verification of shared-variable concurrent programs. However, it is difficult for users to define rely/guarantee conditions, which specify threads' behaviors over the whole program state. Recent efforts to combine Separation Logic with Rely-Guarantee reasoning have made it possible to hide thread-local resources, but the shared resources still need to be globally known and specified. This greatly limits the reuse of verified program modules.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480922", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/popl/Feng09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480916", + "title": "Positive supercompilation for a higher order call-by-value language", + "abstract": "Previous deforestation and supercompilation algorithms may introduce accidental termination when applied to call-by-value programs. This hides looping bugs from the programmer, and changes the behavior of a program depending on whether it is optimized or not. We present a supercompilation algorithm for a higher-order call-by-value language and we prove that the algorithm both terminates and preserves termination properties. This algorithm utilizes strictness information for deciding whether to substitute or not and compares favorably with previous call-by-name transformations.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480916", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Jönsson", + "institution": "Luleå University of Technology" + }, + { + "first_name": "Johan", + "last_name": "Nordlander", + "institution": "Luleå University of Technology" + } + ], + "dblp_key": "conf/popl/JonssonN09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480886", + "title": "Proving that non-blocking algorithms don't block", + "abstract": "A concurrent data-structure implementation is considered nonblocking if it meets one of three following liveness criteria: waitfreedom, lock-freedom,orobstruction-freedom. Developers of nonblocking algorithms aim to meet these criteria. However, to date their proofs for non-trivial algorithms have been only manual pencil-and-paper semi-formal proofs. This paper proposes the first fully automatic tool that allows developers to ensure that their algorithms are indeed non-blocking. Our tool uses rely-guarantee reasoning while overcoming the technical challenge of sound reasoning in the presence of interdependent liveness properties.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480886", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "University of Cambridge" + }, + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "University of Cambridge" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/GotsmanCPV09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480895", + "title": "Verifying liveness for asynchronous programs", + "abstract": "Asynchronous or 'event-driven' programming is a popular technique to efficiently and flexibly manage concurrent interactions. In these programs, the programmer can post tasks that get stored in a task buffer and get executed atomically by a non-preemptive scheduler at a future point. We give a decision procedure for the fair termination property of asynchronous programs. The fair termination problem asks, given an asynchronous program and a fairness condition on its executions, does the program always terminate on fair executions? The fairness assumptions rule out certain undesired bad behaviors, such as where the scheduler ignores a set of posted tasks forever, or where a non-deterministic branch is always chosen in one direction. Since every liveness property reduces to a fair termination property, our decision procedure extends to liveness properties of asynchronous programs. Our decision procedure for the fair termination of asynchronous programs assumes all variables are finite-state. Even though variables are finite-state, asynchronous programs can have an unbounded stack from recursive calls made by tasks, as well as an unbounded task buffer of pending tasks. We show a reduction from the fair termination problem for asynchronous programs to fair termination problems on Petri Nets, and our main technical result is a reduction of the latter problem to Presburger satisfiability. Our decidability result is in contrast to multithreaded recursive programs, for which liveness properties are undecidable. While we focus on fair termination, we show our reduction to Petri Nets can be used to prove related properties such as fair nonstarvation (every posted task is eventually executed) and safety properties such as boundedness (find a bound on the maximum number of posted tasks that can be in the task buffer at any point).", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480895", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Ganty", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/GantyMR09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480917", + "title": "Compositional shape analysis by means of bi-abduction", + "abstract": "This paper describes a compositional shape analysis, where each procedure is analyzed independently of its callers. The analysis uses an abstract domain based on a restricted fragment of separation logic, and assigns a collection of Hoare triples to each procedure; the triples provide an over-approximation of data structure usage. Compositionality brings its usual benefits -- increased potential to scale, ability to deal with unknown calling contexts, graceful way to deal with imprecision -- to shape analysis, for the first time.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480917", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "Imperial College London" + }, + { + "first_name": "Dino", + "last_name": "Distefano", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/CalcagnoDOY09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480883", + "title": "Language constructs for transactional memory", + "abstract": "Building concurrent shared-memory data structures is a notoriously difficult problem, and so the widespread move to multi-core and multi-processor hardware has led to increasing interest in language constructs that may make concurrent programming easier. One technique that has been studied widely is the use of atomic blocks built over transactional memory (TM): the programmer marks a section of code as atomic, and the language implementation speculatively executes it using transactions. Transactions can run in parallel so long as they access different data.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480883", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tim", + "last_name": "Harris", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/Harris09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480907", + "title": "A cost semantics for self-adjusting computation", + "abstract": "Self-adjusting computation is an evaluation model in which programs can respond efficiently to small changes to their input data by using a change-propagation mechanism that updates computation by re-building only the parts affected by changes. Previous work has proposed language techniques for self-adjusting computation and showed the approach to be effective in a number of application areas. However, due to the complex semantics of change propagation and the indirect nature of previously proposed language techniques, it remains difficult to reason about the efficiency of self-adjusting programs and change propagation.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480907", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ruy", + "last_name": "Ley-Wild", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/popl/Ley-WildAF09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480931", + "title": "The semantics of progress in lock-based transactional memory", + "abstract": "Transactional memory (TM) is a promising paradigm for concurrent programming. Whereas the number of TM implementations is growing, however, little research has been conducted to precisely define TM semantics, especially their progress guarantees. This paper is the first to formally define the progress semantics of lockbased TMs, which are considered the most effective in practice.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480931", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Michał", + "last_name": "Kapałka", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/GuerraouiK09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480894", + "title": "Formal certification of code-based cryptographic proofs", + "abstract": "As cryptographic proofs have become essentially unverifiable, cryptographers have argued in favor of developing techniques that help tame the complexity of their proofs. Game-based techniques provide a popular approach in which proofs are structured as sequences of games and in which proof steps establish the validity of transitions between successive games. Code-based techniques form an instance of this approach that takes a code-centric view of games, and that relies on programming language theory to justify proof steps. While code-based techniques contribute to formalize the security statements precisely and to carry out proofs systematically, typical proofs are so long and involved that formal verification is necessary to achieve a high degree of confidence. We present Certicrypt, a framework that enables the machine-checked construction and verification of code-based proofs. Certicrypt is built upon the general-purpose proof assistant Coq, and draws on many areas, including probability, complexity, algebra, and semantics of programming languages. Certicrypt provides certified tools to reason about the equivalence of probabilistic programs, including a relational Hoare logic, a theory of observational equivalence, verified program transformations, and game-based techniques such as reasoning about failure events. The usefulness of Certicrypt is demonstrated through various examples, including a proof of semantic security of OAEP (with a bound that improves upon existing published results), and a proof of existential unforgeability of FDH signatures. Our work provides a first yet significant step towards Halevi's ambitious programme of providing tool support for cryptographic proofs.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480894", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Santiago", + "last_name": "Zanella-Béguelin", + "institution": "Centre de Recherche en Informatique" + } + ], + "dblp_key": "conf/popl/BartheGB09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480904", + "title": "Bidirectionalization for free! (Pearl)", + "abstract": "A bidirectional transformation consists of a function get that takes a source (document or value) to a view and a function put that takes an updated view and the original source back to an updated source, governed by certain consistency conditions relating the two functions. Both the database and programming language communities have studied techniques that essentially allow a user to specify only one of get and put and have the other inferred automatically. All approaches so far to this bidirectionalization task have been syntactic in nature, either proposing a domain-specific language with limited expressiveness but built-in (and composable) backward components, or restricting get to a simple syntactic form from which some algorithm can synthesize an appropriate definition for put. Here we present a semantic approach instead. The idea is to take a general-purpose language, Haskell, and write a higher-order function that takes (polymorphic) get-functions as arguments and returns appropriate put-functions. All this on the level of semantic values, without being willing, or even able, to inspect the definition of get, and thus liberated from syntactic restraints. Our solution is inspired by relational parametricity and uses free theorems for proving the consistency conditions. It works beautifully.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480904", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Janis", + "last_name": "Voigtländer", + "institution": "TU Dresden" + } + ], + "dblp_key": "conf/popl/Voigtlander09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480908", + "title": "Copy-on-write in the PHP language", + "abstract": "PHP is a popular language for server-side applications. In PHP, assignment to variables copies the assigned values, according to its so-called copy-on-assignment semantics. In contrast, a typical PHP implementation uses a copy-on-write scheme to reduce the copy overhead by delaying copies as much as possible. This leads us to ask if the semantics and implementation of PHP coincide, and actually this is not the case in the presence of sharings within values. In this paper, we describe the copy-on-assignment semantics with three possible strategies to copy values containing sharings. The current PHP implementation has inconsistencies with these semantics, caused by its naïve use of copy-on-write. We fix this problem by the novel mostly copy-on-write scheme, making the copy-on-write implementations faithful to the semantics. We prove that our copy-on-write implementations are correct, using bisimulation with the copy-on-assignment semantics.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480908", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Akihiko", + "last_name": "Tozawa", + "institution": "IBM (United States)" + }, + { + "first_name": "Michiaki", + "last_name": "Tatsubori", + "institution": "IBM (United States)" + }, + { + "first_name": "Tamiya", + "last_name": "Onodera", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Yasuhiko", + "last_name": "Minamide", + "institution": "University of Tsukuba" + } + ], + "dblp_key": "conf/popl/TozawaTOM09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480905", + "title": "The third homomorphism theorem on trees: downward & upward lead to divide-and-conquer", + "abstract": "Parallel programs on lists have been intensively studied. It is well known that associativity provides a good characterization for divide-and-conquer parallel programs. In particular, the third homomorphism theorem is not only useful for systematic development of parallel programs on lists, but it is also suitable for automatic parallelization. The theorem states that if two sequential programs iterate the same list leftward and rightward, respectively, and compute the same value, then there exists a divide-and-conquer parallel program that computes the same value as the sequential programs.While there have been many studies on lists, few have been done for characterizing and developing of parallel programs on trees. Naive divide-and-conquer programs, which divide a tree at the root and compute independent subtrees in parallel, take time that is proportional to the height of the input tree and have poor scalability with respect to the number of processors when the input tree is ill-balanced.In this paper, we develop a method for systematically constructing scalable divide-and-conquer parallel programs on trees, in which two sequential programs lead to a scalable divide-andconquer parallel program. We focus on paths instead of trees so as to utilize rich results on lists and demonstrate that associativity provides good characterization for scalable divide-and-conquer parallel programs on trees. Moreover, we generalize the third homomorphism theorem from lists to trees.We demonstrate the effectiveness of our method with various examples. Our results, being generalizations of known results for lists, are generic in the sense that they work well for all polynomial data structures.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480905", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Akimasa", + "last_name": "Morihata", + "institution": "The University of Tokyo" + }, + { + "first_name": "Kiminori", + "last_name": "Matsuzaki", + "institution": "The University of Tokyo" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Masato", + "last_name": "Takeichi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/MorihataMHT09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480913", + "title": "The theory of deadlock avoidance via discrete control", + "abstract": "Deadlock in multithreaded programs is an increasingly important problem as ubiquitous multicore architectures force parallelization upon an ever wider range of software. This paper presents a theoretical foundation for dynamic deadlock avoidance in concurrent programs that employ conventional mutual exclusion and synchronization primitives (e.g., multithreaded C/Pthreads programs). Beginning with control flow graphs extracted from program source code, we construct a formal model of the program and then apply Discrete Control Theory to automatically synthesize deadlock-avoidance control logic that is implemented by program instrumentation. At run time, the control logic avoids deadlocks by postponing lock acquisitions. Discrete Control Theory guarantees that the program instrumented with our synthesized control logic cannot deadlock. Our method furthermore guarantees that the control logic is maximally permissive: it postpones lock acquisitions only when necessary to prevent deadlocks, and therefore permits maximal runtime concurrency. Our prototype for C/Pthreads scales to real software including Apache, OpenLDAP, and two kinds of benchmarks, automatically avoiding both injected and naturally occurring deadlocks while imposing modest runtime overheads.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480913", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yin", + "last_name": "Wang", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Stéphane", + "last_name": "Lafortune", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Terence", + "last_name": "Kelly", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Manjunath", + "last_name": "Kudlur", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/popl/WangLKKM09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480890", + "title": "Masked types for sound object initialization", + "abstract": "This paper presents a type-based solution to the long-standing problem of object initialization. Constructors, the conventional mechanism for object initialization, have semantics that are surprising to programmers and that lead to bugs. They also contribute to the problem of null-pointer exceptions, which make software less reliable. Masked types are a new type-state mechanism that explicitly tracks the initialization state of objects and prevents reading from uninitialized fields. In the resulting language, constructors are ordinary methods that operate on uninitialized objects, and no special default value (null) is needed in the language. Initialization of cyclic data structures is achieved with the use of conditionally masked types. Masked types are modular and compatible with data abstraction. The type system is presented in a simplified object calculus and is proved to soundly prevent reading from uninitialized fields. Masked types have been implemented as an extension to Java, in which compilation simply erases extra type information. Experience using the extended language suggests that masked types work well on real code.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480890", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xin", + "last_name": "Qi", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/QiM09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480929", + "title": "The semantics of x86-CC multiprocessor machine code", + "abstract": "Multiprocessors are now dominant, but real multiprocessors do not provide the sequentially consistent memory that is assumed by most work on semantics and verification. Instead, they have subtle relaxed (or weak) memory models, usually described only in ambiguous prose, leading to widespread confusion.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480929", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Cambridge" + }, + { + "first_name": "Tom", + "last_name": "Ridge", + "institution": "University of Cambridge" + }, + { + "first_name": "Thomas", + "last_name": "Braibant", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "" + }, + { + "first_name": "Jade", + "last_name": "Alglave", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/SarkarSNORBMA09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480934", + "title": "Verifying distributed systems: the operational approach", + "abstract": "This work develops an integrated approach to the verification of behaviourally rich programs, founded directly on operational semantics. The power of the approach is demonstrated with a state-of-the-art verification of a core piece of distributed infrastructure, involving networking, a filesystem, and concurrent OCaml code. The formalization is in higher-order logic and proof support is provided by the HOL4 theorem prover.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480934", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas J.", + "last_name": "Ridge", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/Ridge09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480899", + "title": "Automatic modular abstractions for linear constraints", + "abstract": "We propose a method for automatically generating abstract transformers for static analysis by abstract interpretation. The method focuses on linear constraints on programs operating on rational, real or floating-point variables and containing linear assignments and tests.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480899", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Monniaux", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/Monniaux09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480915", + "title": "Equality saturation: a new approach to optimization", + "abstract": "Optimizations in a traditional compiler are applied sequentially, with each optimization destructively modifying the program to produce a transformed program that is then passed to the next optimization. We present a new approach for structuring the optimization phase of a compiler. In our approach, optimizations take the form of equality analyses that add equality information to a common intermediate representation. The optimizer works by repeatedly applying these analyses to infer equivalences between program fragments, thus saturating the intermediate representation with equalities. Once saturated, the intermediate representation encodes multiple optimized versions of the input program. At this point, a profitability heuristic picks the final optimized program from the various programs represented in the saturated representation. Our proposed way of structuring optimizers has a variety of benefits over previous approaches: our approach obviates the need to worry about optimization ordering, enables the use of a global optimization heuristic that selects among fully optimized programs, and can be used to perform translation validation, even on compilers other than our own. We present our approach, formalize it, and describe our choice of intermediate representation. We also present experimental results showing that our approach is practical in terms of time and space overhead, is effective at discovering intricate optimization opportunities, and is effective at performing translation validation for a realistic optimizer.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480915", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Stepp", + "institution": "" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "" + } + ], + "dblp_key": "conf/popl/TateSTL09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480889", + "title": "Static contract checking for Haskell", + "abstract": "Program errors are hard to detect and are costly both to programmers who spend significant efforts in debugging, and for systems that are guarded by runtime checks. Static verification techniques have been applied to imperative and object-oriented languages, like Java and C#, but few have been applied to a higher-order lazy functional language, like Haskell. In this paper, we describe a sound and automatic static verification framework for Haskell, that is based on contracts and symbolic execution. Our approach is modular and gives precise blame assignments at compile-time in the presence of higher-order functions and laziness.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480889", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dana N.", + "last_name": "Xu", + "institution": "University of Cambridge" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/XuJC09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480926", + "title": "Modeling abstract types in modules with open existential types", + "abstract": "We propose F-zip, a calculus of open existential types that is an extension of System F obtained by decomposing the introduction and elimination of existential types into more atomic constructs. Open existential types model modular type abstraction as done in module systems. The static semantics of F-zip adapts standard techniques to deal with linearity of typing contexts, its dynamic semantics is a small-step reduction semantics that performs extrusion of type abstraction as needed during reduction, and the two are related by subject reduction and progress lemmas. Applying the Curry-Howard isomorphism, F-zip can be also read back as a logic with the same expressive power as second-order logic but with more modular ways of assembling partial proofs. We also extend the core calculus to handle the double vision problem as well as type-level and term-level recursion. The resulting language turns out to be a new formalization of (a minor variant of) Dreyer's internal language for recursive and mixin modules.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480926", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benoît", + "last_name": "Montagu", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/MontaguR09", + "venue": "popl", + "year": 2009 + }, + { + "paper_id": "10.1145/1480881.1480919", + "title": "Linear types for computational effects", + "abstract": "I shall present an extension of Moggi's computational metalanguage with primitives from linear logic, the enriched effect-calculus. Illustrative applications to side effects, continuations, nondeterminism and polymorphism will be considered. The talk is based on joint work with Jeff Egger and Rasmus Mogelberg.", + "date": "2009-01-20", + "link": "https://doi.org/10.1145/1480881.1480919", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alex", + "last_name": "Simpson", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/Simpson09", + "venue": "popl", + "year": 2009 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2010.json b/data/pl_conferences/popl/2010.json new file mode 100644 index 0000000..a673d58 --- /dev/null +++ b/data/pl_conferences/popl/2010.json @@ -0,0 +1,1165 @@ +[ + { + "paper_id": "10.1145/1706299.1706323", + "title": "A relational modal logic for higher-order stateful ADTs", + "abstract": "The method of logical relations is a classic technique for proving the equivalence of higher-order programs that implement the same observable behavior but employ different internal data representations. Although it was originally studied for pure, strongly normalizing languages like System F, it has been extended over the past two decades to reason about increasingly realistic languages. In particular, Appel and McAllester's idea of step-indexing has been used recently to develop syntactic Kripke logical relations for ML-like languages that mix functional and imperative forms of data abstraction. However, while step-indexed models are powerful tools, reasoning with them directly is quite painful, as one is forced to engage in tedious step-index arithmetic to derive even simple results.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706323", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Georg", + "last_name": "Neis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/popl/DreyerNRB10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706339", + "title": "Programming with angelic nondeterminism", + "abstract": "Angelic nondeterminism can play an important role in program development. It simplifies specifications, for example in deriving programs with a refinement calculus; it is the formal basis of regular expressions; and Floyd relied on it to concisely express backtracking algorithms such as N-queens.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706339", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Joel", + "last_name": "Galenson", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Doug", + "last_name": "Kimelman", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Nicholas", + "last_name": "Tung", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Shaon", + "last_name": "Barman", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Casey", + "last_name": "Rodarmor", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/popl/BodikCGKTBR10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706313", + "title": "Verified just-in-time compiler on x86", + "abstract": "This paper presents a method for creating formally correct just-in-time (JIT) compilers. The tractability of our approach is demonstrated through, what we believe is the first, verification of a JIT compiler with respect to a realistic semantics of self-modifying x86 machine code. Our semantics includes a model of the instruction cache. Two versions of the verified JIT compiler are presented: one generates all of the machine code at once, the other one is incremental i.e. produces code on-demand. All proofs have been performed inside the HOL4 theorem prover.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706313", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/Myreen10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706301", + "title": "Reconfigurable asynchronous logic automata: (RALA)", + "abstract": "Computer science has served to insulate programs and programmers from knowledge of the underlying mechanisms used to manipulate information, however this fiction is increasingly hard to maintain as computing devices decrease in size and systems increase in complexity. Manifestations of these limits appearing in computers include scaling issues in interconnect, dissipation, and coding. Reconfigurable Asynchronous Logic Automata (RALA) is an alternative formulation of computation that seeks to align logical and physical descriptions by exposing rather than hiding this underlying reality. Instead of physical units being represented in computer programs only as abstract symbols, RALA is based on a lattice of cells that asynchronously pass state tokens corresponding to physical resources. We introduce the design of RALA, review its relationships to its many progenitors, and discuss its benefits, implementation, programming, and extensions", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706301", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neil", + "last_name": "Gershenfeld", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "David", + "last_name": "Dalrymple", + "institution": "MIT-Harvard Center for Ultracold Atoms" + }, + { + "first_name": "Kailiang", + "last_name": "Chen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ara N.", + "last_name": "Knaian", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Forrest", + "last_name": "Green", + "institution": "MIT-Harvard Center for Ultracold Atoms" + }, + { + "first_name": "Erik D.", + "last_name": "Demaine", + "institution": "MIT-Harvard Center for Ultracold Atoms" + }, + { + "first_name": "Scott", + "last_name": "Greenwald", + "institution": "MIT-Harvard Center for Ultracold Atoms" + }, + { + "first_name": "Peter", + "last_name": "Schmidt-Nielsen", + "institution": "MIT-Harvard Center for Ultracold Atoms" + } + ], + "dblp_key": "conf/popl/GershenfeldDCKGDGS10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706351", + "title": "Dynamically checking ownership policies in concurrent c/c++ programs", + "abstract": "Concurrent programming errors arise when threads share data incorrectly. Programmers often avoid these errors by using synchronization to enforce a simple ownership policy: data is either owned exclusively by a thread that can read or write the data, or it is read owned by a set of threads that can read but not write the data. Unfortunately, incorrect synchronization often fails to enforce these policies and memory errors in languages like C and C++ can violate these policies even when synchronization is correct.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706351", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean-Phillipe", + "last_name": "Martin", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Manuel", + "last_name": "Costa", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Periklis", + "last_name": "Akritidis", + "institution": "University of Cambridge" + }, + { + "first_name": "Miguel", + "last_name": "Castro", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/MartinHCAC10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706327", + "title": "Static determination of quantitative resource usage for higher-order programs", + "abstract": "We describe a new automatic static analysis for determining upper-bound functions on the use of quantitative resources for strict, higher-order, polymorphic, recursive programs dealing with possibly-aliased data. Our analysis is a variant of Tarjan's manual amortised cost analysis technique. We use a type-based approach, exploiting linearity to allow inference, and place a new emphasis on the number of references to a data object. The bounds we infer depend on the sizes of the various inputs to a program. They thus expose the impact of specific inputs on the overall cost behaviour.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706327", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steffen", + "last_name": "Jost", + "institution": "University of St Andrews" + }, + { + "first_name": "Kevin", + "last_name": "Hammond", + "institution": "University of St Andrews" + }, + { + "first_name": "Hans‐Wolfgang", + "last_name": "Loidl", + "institution": "Ludwig-Maximilians-Universität München" + }, + { + "first_name": "Martin", + "last_name": "Hofmann", + "institution": "Ludwig-Maximilians-Universität München" + } + ], + "dblp_key": "conf/popl/JostHLH10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706307", + "title": "Compositional may-must program analysis: unleashing the power of alternation", + "abstract": "Program analysis tools typically compute two types of information: (1) may information that is true of all program executions and is used to prove the absence of bugs in the program, and (2) must information that is true of some program executions and is used to prove the existence of bugs in the program. In this paper, we propose a new algorithm, dubbed SMASH, which computes both may and must information compositionally . At each procedure boundary, may and must information is represented and stored as may and must summaries, respectively. Those summaries are computed in a demand driven manner and possibly using summaries of the opposite type. We have implemented SMASH using predicate abstraction (as in SLAM) for the may part and using dynamic test generation (as in DART) for the must part. Results of experiments with 69 Microsoft Windows 7 device drivers show that SMASH can significantly outperform may-only, must-only and non-compositional may-must algorithms. Indeed, our empirical results indicate that most complex code fragments in large programs are actually often either easy to prove irrelevant to the specific property of interest using may analysis or easy to traverse using directed testing. The fine-grained coupling and alternation of may (universal) and must (existential) summaries allows SMASH to easily navigate through these code fragments while traditional may-only, must-only or non-compositional may-must algorithms are stuck in their specific analyses.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706307", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sai Deep", + "last_name": "Tetali", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/popl/GodefroidNRT10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706308", + "title": "Continuity analysis of programs", + "abstract": "We present an analysis to automatically determine if a program represents a continuous function, or equivalently, if infinitesimal changes to its inputs can only cause infinitesimal changes to its outputs. The analysis can be used to verify the robustness of programs whose inputs can have small amounts of error and uncertainty---e.g., embedded controllers processing slightly unreliable sensor data, or handheld devices using slightly stale satellite data.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706308", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Roberto", + "last_name": "Lublinerman", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/ChaudhuriGL10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706303", + "title": "On the verification problem for weak memory models", + "abstract": "We address the verification problem of finite-state concurrent programs running under weak memory models. These models capture the reordering of program (read and write) operations done by modern multi-processor architectures for performance. The verification problem we study is crucial for the correctness of concurrency libraries and other performance-critical system services employing lock-free synchronization, as well as for the correctness of compiler backends that generate code targeted to run on such architectures.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706303", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Université Paris Cité" + }, + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Laboratoire d'Informatique Algorithmique: Fondements et Applications" + }, + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/AtigBBM10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706329", + "title": "Toward a verified relational database management system", + "abstract": "We report on our experience implementing a lightweight, fully verified relational database management system (RDBMS). The functional specification of RDBMS behavior, RDBMS implementation, and proof that the implementation meets the specification are all written and verified in Coq. Our contributions include: (1) a complete specification of the relational algebra in Coq; (2) an efficient realization of that model (B+ trees) implemented with the Ynot extension to Coq; and (3) a set of simple query optimizations proven to respect both semantics and run-time cost. In addition to describing the design and implementation of these artifacts, we highlight the challenges we encountered formalizing them, including the choice of representation for finite relations of typed tuples and the challenges of reasoning about data structures with complex sharing. Our experience shows that though many challenges remain, building fully-verified systems software in Coq is within reach.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706329", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gregory", + "last_name": "Malecha", + "institution": "Harvard University Press" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + }, + { + "first_name": "Avraham", + "last_name": "Shinnar", + "institution": "Harvard University Press" + }, + { + "first_name": "Ryan", + "last_name": "Wisnesky", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/MalechaMSW10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706331", + "title": "Structuring the verification of heap-manipulating programs", + "abstract": "Most systems based on separation logic consider only restricted forms of implication or non-separating conjunction, as full support for these connectives requires a non-trivial notion of variable context, inherited from the logic of bunched implications (BI). We show that in an expressive type theory such as Coq, one can avoid the intricacies of BI, and support full separation logic very efficiently, using the native structuring primitives of the type theory.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706331", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Josh", + "last_name": "Berdine", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/NanevskiVB10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706335", + "title": "Modular session types for distributed object-oriented programming", + "abstract": "Session types allow communication protocols to be specified type-theoretically so that protocol implementations can be verified by static type-checking. We extend previous work on session types for distributed object-oriented languages in three ways. (1) We attach a session type to a class definition, to specify the possible sequences of method calls. (2) We allow a session type (protocol) implementation to be modularized , i.e. partitioned into separately-callable methods. (3) We treat session-typed communication channels as objects, integrating their session types with the session types of classes. The result is an elegant unification of communication channels and their session types, distributed object-oriented programming, and a form of typestates supporting non-uniform objects, i.e. objects that dynamically change the set of available methods. We define syntax, operational semantics, a sound type system, and a correct and complete type checking algorithm for a small distributed class-based object-oriented language. Static typing guarantees that both sequences of messages on channels, and sequences of method calls on objects, conform to type-theoretic specifications, thus ensuring type-safety. The language includes expected features of session types, such as delegation, and expected features of object-oriented programming, such as encapsulation of local state. We also describe a prototype implementation as an extension of Java.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706335", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon J.", + "last_name": "Gay", + "institution": "University of Glasgow" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + }, + { + "first_name": "António", + "last_name": "Ravara", + "institution": "University of Lisbon" + }, + { + "first_name": "Nils", + "last_name": "Gesbert", + "institution": "University of Glasgow" + }, + { + "first_name": "Alexandre Z.", + "last_name": "Caldeira", + "institution": "University of Lisbon" + } + ], + "dblp_key": "conf/popl/GayVRGC10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706354", + "title": "Monads in action", + "abstract": "In functional programming, monadic characterizations of computational effects are normally understood denotationally: they describe how an effectful program can be systematically expanded or translated into a larger, pure program, which can then be evaluated according to an effect-free semantics. Any effect-specific operations expressible in the monad are also given purely functional definitions, but these definitions are only directly executable in the context of an already translated program. This approach thus takes an inherently Church-style view of effects: the nominal meaning of every effectful term in the program depends crucially on its type.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706354", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrzej", + "last_name": "Filinski", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/popl/Filinski10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706309", + "title": "Program analysis via satisfiability modulo path programs", + "abstract": "Path-sensitivity is often a crucial requirement for verifying safety properties of programs. As it is infeasible to enumerate and analyze each path individually, analyses compromise by soundly merging information about executions along multiple paths. However, this frequently results in a loss of precision. We present a program analysis technique that we call Satisfiability Modulo Path Programs (SMPP), based on a path-based decomposition of a program. It is inspired by insights that have driven the development of modern SMT(Satisfiability Modulo Theory) solvers. SMPP symbolically enumerates path programs using a SAT formula over control edges in the program. Each enumerated path program is verified using an oracle, such as abstract interpretation or symbolic execution, to either find a proof of correctness or report a potential violation. If a proof is found, then SMPP extracts a sufficient set of control edges and corresponding interference edges, as a form of proof-based learning. Blocking clauses derived from these edges are added back to the SAT formula to avoid enumeration of other path programs guaranteed to be correct, thereby improving performance and scalability. We have applied SMPP in the F-Soft program verification framework, to verify properties of real-world C programs that require path-sensitive reasoning. Our results indicate that the precision from analyzing individual path programs, combined with their efficient enumeration by SMPP, can prove properties as well as indicate potential violations in the large.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706309", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William R.", + "last_name": "Harris", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Sriram", + "last_name": "Sankaranarayanan", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Franjo", + "last_name": "Ivančić", + "institution": "Princeton University" + }, + { + "first_name": "Aarti", + "last_name": "Gupta", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/HarrisSIG10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706346", + "title": "Automatically generating instruction selectors using declarative machine descriptions", + "abstract": "Despite years of work on retargetable compilers, creating a good, reliable back end for an optimizing compiler still entails a lot of hard work. Moreover, a critical component of the back end---the instruction selector---must be written by a person who is expert in both the compiler's intermediate code and the target machine's instruction set. By generating the instruction selector from declarative machine descriptions we have (a) made it unnecessary for one person to be both a compiler expert and a machine expert, and (b) made creating an optimizing back end easier than ever before.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706346", + "conference_name": "POPL", + "authors": [ + { + "first_name": "João", + "last_name": "Dias", + "institution": "Tufts University" + }, + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/popl/DiasR10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706355", + "title": "Higher-order multi-parameter tree transducers and recursion schemes for program verification", + "abstract": "We introduce higher-order, multi-parameter, tree transducers (HMTTs, for short), which are kinds of higher-order tree transducers that take input trees and output a (possibly infinite) tree. We study the problem of checking whether the tree generated by a given HMTT conforms to a given output specification, provided that the input trees conform to input specifications (where both input/output specifications are regular tree languages). HMTTs subsume higher-order recursion schemes and ordinary tree transducers, so that their verification has a number of potential applications to verification of functional programs using recursive data structures, including resource usage verification, string analysis, and exact type-checking of XML-processing programs.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706355", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "Tohoku University" + }, + { + "first_name": "Naoshi", + "last_name": "Tabuchi", + "institution": "Tohoku University" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/popl/KobayashiTU10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706347", + "title": "Semantics and algorithms for data-dependent grammars", + "abstract": "We present the design and theory of a new parsing engine, YAKKER, capable of satisfying the many needs of modern programmers and modern data processing applications. In particular, our new parsing engine handles (1) full scannerless context-free grammars with (2) regular expressions as right-hand sides for defining nonterminals. YAKKER also includes (3) facilities for binding variables to intermediate parse results and (4) using such bindings within arbitrary constraints to control parsing. These facilities allow the kind of data-dependent parsing commonly needed in systems applications, particularly those that operate over binary data. In addition, (5) nonterminals may be parameterized by arbitrary values, which gives the system good modularity and abstraction properties in the presence of data-dependent parsing. Finally, (6) legacy parsing libraries,such as sophisticated libraries for dates and times, may be directly incorporated into parser specifications. We illustrate the importance and utility of this rich collection of features by presenting its use on examples ranging from difficult programming language grammars to web server logs to binary data specification. We also show that our grammars have important compositionality properties and explain why such properties areimportant in modern applications such as automatic grammar induction.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706347", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Trevor", + "last_name": "Jim", + "institution": "AT&T (United States)" + }, + { + "first_name": "Yitzhak", + "last_name": "Mandelbaum", + "institution": "AT&T (United States)" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/JimMW10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706334", + "title": "Pure subtype systems", + "abstract": "This paper introduces a new approach to type theory called pure subtype systems . Pure subtype systems differ from traditional approaches to type theory (such as pure type systems) because the theory is based on subtyping, rather than typing. Proper types and typing are completely absent from the theory; the subtype relation is defined directly over objects. The traditional typing relation is shown to be a special case of subtyping, so the loss of types comes without any loss of generality.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706334", + "conference_name": "POPL", + "authors": [ + { + "first_name": "DeLesley", + "last_name": "Hutchins", + "institution": "MZA Associates (United States)" + } + ], + "dblp_key": "conf/popl/Hutchins10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706321", + "title": "Nominal system T", + "abstract": "This paper introduces a new recursion principle for inductive data modulo α-equivalence of bound names. It makes use of Odersky-style local names when recursing over bound names. It is formulated in an extension of Gödel's System T with names that can be tested for equality, explicitly swapped in expressions and restricted to a lexical scope. The new recursion principle is motivated by the nominal sets notion of \"α-structural recursion\", whose use of names and associated freshness side-conditions in recursive definitions formalizes common practice with binders. The new Nominal System T presented here provides a calculus of total functions that is shown to adequately represent α-structural recursion while avoiding the need to verify freshness side-conditions in definitions and computations. Adequacy is proved via a normalization-by-evaluation argument that makes use of a new semantics of local names in Gabbay-Pitts nominal sets.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706321", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew M.", + "last_name": "Pitts", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/Pitts10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706304", + "title": "Coarse-grained transactions", + "abstract": "Traditional transactional memory systems suffer from overly conservative conflict detection, yielding so-called false conflicts, because they are based on fine-grained, low-level read/write conflicts. In response, the recent trend has been toward integrating various abstract data-type libraries using ad-hoc methods of high-level conflict detection. These proposals have led to improved performance but a lack of a unified theory has led to confusion in the literature.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706304", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "University of Cambridge" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "University of Cambridge" + }, + { + "first_name": "Maurice", + "last_name": "Herlihy", + "institution": "Brown University" + } + ], + "dblp_key": "conf/popl/KoskinenPH10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706333", + "title": "Dependent types and program equivalence", + "abstract": "The definition of type equivalence is one of the most important design issues for any typed language. In dependently typed languages, because terms appear in types, this definition must rely on a definition of term equivalence. In that case, decidability of type checking requires decidability for the term equivalence relation.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706333", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yun", + "last_name": "Zhao", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Vilhelm", + "last_name": "Sjöberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/JiaZSW10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706319", + "title": "From Boolean to quantitative notions of correctness", + "abstract": "Classical formalizations of systems and properties are boolean: given a system and a property, the property is either true or false of the system. Correspondingly, classical methods for system analysis determine the truth value of a property, preferably giving a proof if the property is true, and a counterexample if the property is false; classical methods for system synthesis construct a system for which a property is true; classical methods for system transformation, composition, and abstraction aim to preserve the truth of properties. The boolean view is prevalent even if the system, the property, or both refer to numerical quantities, such as the times or probabilities of events. For example, a timed automaton either satisfies or violates a formula of a real-time logic; a stochastic process either satisfies or violates a formula of a probabilistic logic. The classical black-and-white view partitions the world into \"correct\" and \"incorrect\" systems, offering few nuances. In reality, of several systems that satisfy a property in the boolean sense, often some are more desirable than others, and of the many systems that violate a property, usually some are less objectionable than others. For instance, among the systems that satisfy the response property that every request be granted, we may prefer systems that grant requests quickly (the quicker, the better), or we may prefer systems that issue few unnecessary grants (the fewer, the better); and among the systems that violate the response property, we may prefer systems that serve many initial requests (the more, the better), or we may prefer systems that serve many requests in the long run (the greater the fraction of served to unserved requests, the better).", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706319", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "conf/popl/Henzinger10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706353", + "title": "Nested interpolants", + "abstract": "In this paper, we explore the potential of the theory of nested words for partial correctness proofs of recursive programs. Our conceptual contribution is a simple framework that allows us to shine a new light on classical concepts such as Floyd/Hoare proofs and predicate abstraction in the context of recursive programs. Our technical contribution is an interpolant-based software model checking method for recursive programs. The method avoids the costly construction of the abstract transformer by constructing a nested word automaton from an inductive sequence of `nested interpolants' (i.e., interpolants for a nested word which represents an infeasible error trace).", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706353", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Heizmann", + "institution": "University of Freiburg" + }, + { + "first_name": "Jochen", + "last_name": "Hoenicke", + "institution": "University of Freiburg" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/popl/HeizmannHP10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706341", + "title": "Contracts made manifest", + "abstract": "Since Findler and Felleisen introduced higher-order contracts , many variants have been proposed. Broadly, these fall into two groups: some follow Findler and Felleisen in using latent contracts, purely dynamic checks that are transparent to the type system; others use manifest contracts, where refinement types record the most recent check that has been applied to each value. These two approaches are commonly assumed to be equivalent---different ways of implementing the same idea, one retaining a simple type system, and the other providing more static information. Our goal is to formalize and clarify this folklore understanding.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706341", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/GreenbergPW10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706349", + "title": "Paralocks: role-based information flow control and beyond", + "abstract": "This paper presents Paralocks, a language for building expressive but statically verifiable fine-grained information flow policies. Paralocks combine the expressive power of Flow Locks (Broberg & Sands, ESOP'06) with the ability to express policies involving run-time principles, roles (in the style of role-based access control), and relations (such as \"acts-for\" in discretionary access control). We illustrate the Paralocks policy language by giving a simple encoding of Myers and Liskov's Decentralized Label Model (DLM). Furthermore - and unlike the DLM - we provide an information flow semantics for full Paralock policies. Lastly we illustrate how Paralocks can be statically verified by providing a simple programming language incorporating Paralock policy specifications, and a static type system which soundly enforces information flow security according to the Paralock semantics.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706349", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Niklas", + "last_name": "Broberg", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "David", + "last_name": "Sands", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/BrobergS10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706322", + "title": "A theory of indirection via approximation", + "abstract": "Building semantic models that account for various kinds of indirect reference has traditionally been a difficult problem. Indirect reference can appear in many guises, such as heap pointers, higher-order functions, object references, and shared-memory mutexes.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706322", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aquinas", + "last_name": "Hobor", + "institution": "National University of Singapore" + }, + { + "first_name": "Robert", + "last_name": "Dockins", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/HoborDA10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706305", + "title": "Sequential verification of serializability", + "abstract": "Serializability is a commonly used correctness condition in concurrent programming. When a concurrent module is serializable, certain other properties of the module can be verified by considering only its sequential executions. In many cases, concurrent modules guarantee serializability by using standard locking protocols, such as tree locking or two-phase locking. Unfortunately, according to the existing literature, verifying that a concurrent module adheres to these protocols requires considering concurrent interleavings.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706305", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hagit", + "last_name": "Attiya", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/AttiyaRR10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706312", + "title": "A verified compiler for an impure functional language", + "abstract": "We present a verified compiler to an idealized assembly language from a small, untyped functional language with mutable references and exceptions. The compiler is programmed in the Coq proof assistant and has a proof of total correctness with respect to big-step operational semantics for the source and target languages. Compilation is staged and includes standard phases like translation to continuation-passing style and closure conversion, as well as a common subexpression elimination optimization. In this work, our focus has been on discovering and using techniques that make our proofs easy to engineer and maintain. While most programming language work with proof assistants uses very manual proof styles, all of our proofs are implemented as adaptive programs in Coq's tactic language, making it possible to reuse proofs unchanged as new language features are added.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706312", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/Chlipala10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706350", + "title": "Modular verification of security protocol code by typing", + "abstract": "We propose a method for verifying the security of protocol implementations. Our method is based on declaring and enforcing invariants on the usage of cryptography. We develop cryptographic libraries that embed a logic model of their cryptographic structures and that specify preconditions and postconditions on their functions so as to maintain their invariants. We present a theory to justify the soundness of modular code verification via our method.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706350", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karthikeyan", + "last_name": "Bhargavan", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/BhargavanFG10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706326", + "title": "Automatic numeric abstractions for heap-manipulating programs", + "abstract": "We present a logic for relating heap-manipulating programs to numeric abstractions. These numeric abstractions are expressed as simple imperative programs over integer variables and have the property that termination and safety of the numeric program ensures termination and safety of the original, heap-manipulating program. We have implemented an automated version of this abstraction process and present experimental results for programs involving a variety of data structures.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706326", + "conference_name": "POPL", + "authors": [ + { + "first_name": "S.", + "last_name": "Magill", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ming-Hsien", + "last_name": "Tsai", + "institution": "National Taiwan University" + }, + { + "first_name": "Peter", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yih-Kuen", + "last_name": "Tsay", + "institution": "National Taiwan University" + } + ], + "dblp_key": "conf/popl/MagillTLT10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706342", + "title": "Threesomes, with and without blame", + "abstract": "How to integrate static and dynamic types? Recent work focuses on casts to mediate between the two. However, adding casts may degrade tail calls into a non-tail calls, increasing space consumption from constant to linear in the depth of calls.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706342", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/SiekW10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706338", + "title": "Abstraction-guided synthesis of synchronization", + "abstract": "We present a novel framework for automatic inference of efficient synchronization in concurrent programs, a task known to be difficult and error-prone when done manually.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706338", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "IBM (United States)" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "IBM (United States)" + }, + { + "first_name": "Greta", + "last_name": "Yorsh", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/popl/VechevYY10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706325", + "title": "Decision procedures for algebraic data types with abstractions", + "abstract": "We describe a family of decision procedures that extend the decision procedure for quantifier-free constraints on recursive algebraic data types (term algebras) to support recursive abstraction functions. Our abstraction functions are catamorphisms (term algebra homomorphisms) mapping algebraic data type values into values in other decidable theories (e.g. sets, multisets, lists, integers, booleans). Each instance of our decision procedure family is sound; we identify a widely applicable many-to-one condition on abstraction functions that implies the completeness. Complete instances of our decision procedure include the following correctness statements: 1) a functional data structure implementation satisfies a recursively specified invariant, 2) such data structure conforms to a contract given in terms of sets, multisets, lists, sizes, or heights, 3) a transformation of a formula (or lambda term) abstract syntax tree changes the set of free variables in the specified way.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706325", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philippe", + "last_name": "Suter", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Mirco", + "last_name": "Dotta", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/SuterDK10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706337", + "title": "From program verification to program synthesis", + "abstract": "This paper describes a novel technique for the synthesis of imperative programs. Automated program synthesis has the potential to make programming and the design of systems easier by allowing programs to be specified at a higher-level than executable code. In our approach, which we call proof-theoretic synthesis, the user provides an input-output functional specification, a description of the atomic operations in the programming language, and a specification of the synthesized program’s looping structure, allowed stack space, and bound on usage of certain operations. Our technique synthesizes a program, if there exists one, that meets the inputoutput specification and uses only the given resources. The insight behind our approach is to interpret program synthesis as generalized program verification, which allows us to bring verification tools and techniques to program synthesis. Our synthesis", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706337", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Saurabh", + "last_name": "Srivastava", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/popl/SrivastavaGF10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706330", + "title": "Counterexample-guided focus", + "abstract": "The automated inference of quantified invariants is considered one of the next challenges in software verification. The question of the right precision-efficiency tradeoff for the corresponding program analyses here boils down to the question of the right treatment of disjunction below and above the universal quantifier. In the closely related setting of shape analysis one uses the focus operator in order to adapt the treatment of disjunction (and thus the efficiency-precision tradeoff) to the individual program statement. One promising research direction is to design parameterized versions of the focus operator which allow the user to fine-tune the focus operator not only to the individual program statements but also to the specific verification task. We carry this research direction one step further. We fine-tune the focus operator to each individual step of the analysis (for a specific verification task). This fine-tuning must be done automatically. Our idea is to use counterexamples for this purpose. We realize this idea in a tool that automatically infers quantified invariants for the verification of a variety of heap-manipulating programs.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706330", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/PodelskiW10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706316", + "title": "Low-level liquid types", + "abstract": "We present Low-Level Liquid Types , a refinement type system for C based on Liquid Types . Low-Level Liquid Types combine refinement types with three key elements to automate verification of critical safety properties of low-level programs: First, by associating refinement types with individual heap locations and precisely tracking the locations referenced by pointers, our system is able to reason about complex invariants of in-memory data structures and sophisticated uses of pointer arithmetic. Second, by adding constructs which allow strong updates to the types of heap locations, even in the presence of aliasing, our system is able to verify properties of in-memory data structures in spite of temporary invariant violations. By using this strong update mechanism, our system is able to verify the correct initialization of newly-allocated regions of memory. Third, by using the abstract interpretation framework of Liquid Types, we are able to use refinement type inference to automatically verify important safety properties without imposing an onerous annotation burden. We have implemented our approach in CSOLVE, a tool for Low-Level Liquid Type inference for C programs. We demonstrate through several examples that CSOLVE is able to precisely infer complex invariants required to verify important safety properties, like the absence of array bounds violations and null-dereferences, with a minimal annotation overhead.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706316", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick M.", + "last_name": "Rondon", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ming", + "last_name": "Kawaguchi", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/popl/RondonKJ10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706315", + "title": "Dependent types from counterexamples", + "abstract": "Motivated by recent research in abstract model checking, we present a new approach to inferring dependent types. Unlike many of the existing approaches, our approach does not rely on programmers to supply the candidate (or the correct) types for the recursive functions and instead does counterexample-guided refinement to automatically generate the set of candidate dependent types. The main idea is to extend the classical fixed-point type inference routine to return a counterexample if the program is found untypable with the current set of candidate types. Then, an interpolating theorem prover is used to validate the counterexample as a real type error or generate additional candidate dependent types to refute the spurious counterexample. The process is repeated until either a real type error is found or sufficient candidates are generated to prove the program typable. Our system makes non-trivial use of \"linear\" intersection types in the refinement phase.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706315", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/popl/Terauchi10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706343", + "title": "Integrating typed and untyped code in a scripting language", + "abstract": "Many large software systems originate from untyped scripting language code. While good for initial development, the lack of static type annotations can impact code-quality and performance in the long run. We present an approach for integrating untyped code and typed code in the same system to allow an initial prototype to smoothly evolve into an efficient and robust program. We introduce like types , a novel intermediate point between dynamic and static typing. Occurrences of like types variables are checked statically within their scope but, as they may be bound to dynamic values, their usage is checked dynamically. Thus like types provide some of the benefits of static typing without decreasing the expressiveness of the language. We provide a formal account of like types in a core object calculus and evaluate their applicability in the context of a new scripting language.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706343", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Kista Photonics Research Center" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Sylvain", + "last_name": "Lebresne", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Johan", + "last_name": "Östlund", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/WrigstadNLOV10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706345", + "title": "Generating compiler optimizations from proofs", + "abstract": "We present an automated technique for generating compiler optimizations from examples of concrete programs before and after improvements have been made to them. The key technical insight of our technique is that a proof of equivalence between the original and transformed concrete programs informs us which aspects of the programs are important and which can be discarded. Our technique therefore uses these proofs, which can be produced by translation validation or a proof-carrying compiler, as a guide to generalize the original and transformed programs into broadly applicable optimization rules.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706345", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "University of California, San Diego" + }, + { + "first_name": "Michael", + "last_name": "Stepp", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/popl/TateSL10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706311", + "title": "A simple, verified validator for software pipelining", + "abstract": "Software pipelining is a loop optimization that overlaps the execution of several iterations of a loop to expose more instruction-level parallelism. It can result in first-class performance characteristics, but at the cost of significant obfuscation of the code, making this optimization difficult to test and debug. In this paper, we present a translation validation algorithm that uses symbolic evaluation to detect semantics discrepancies between a loop and its pipelined version. Our algorithm can be implemented simply and efficiently, is provably sound, and appears to be complete with respect to most modulo scheduling algorithms. A conclusion of this case study is that it is possible and effective to use symbolic evaluation to reason about loop transformations.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706311", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean-Baptiste", + "last_name": "Tristan", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/TristanL10", + "venue": "popl", + "year": 2010 + }, + { + "paper_id": "10.1145/1706299.1706317", + "title": "Type inference for datalog with complex type hierarchies", + "abstract": "Type inference for Datalog can be understood as the problem of mapping programs to a sublanguage for which containment is decidable. To wit, given a program in Datalog, a schema describing the types of extensional relations, and a user-supplied set of facts about the basic types (stating conditions such as disjointness, implication or equivalence), we aim to infer an over-approximation of the semantics of the program, which should be expressible in a suitable sublanguage of Datalog.", + "date": "2010-01-17", + "link": "https://doi.org/10.1145/1706299.1706317", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Max", + "last_name": "Schäfer", + "institution": "" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "" + } + ], + "dblp_key": "conf/popl/SchaferM10", + "venue": "popl", + "year": 2010 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2011.json b/data/pl_conferences/popl/2011.json new file mode 100644 index 0000000..116a65c --- /dev/null +++ b/data/pl_conferences/popl/2011.json @@ -0,0 +1,1440 @@ +[ + { + "paper_id": "10.1145/1926385.1926441", + "title": "Space overhead bounds for dynamic memory management with partial compaction", + "abstract": "Dynamic memory allocation is ubiquitous in today's runtime environments. Allocation and de-allocation of objects during program execution may cause fragmentation and foil the program's ability to allocate objects. Robson has shown that a worst case scenario can create a space overhead within a factor of log(n) of the space that is actually required by the program, where n is the size of the largest possible object. Compaction can eliminate fragmentation, but is too costly to be run frequently. Many runtime systems employ partial compaction, in which only a small fraction of the allocated objects are moved. Partial compaction reduces some of the existing fragmentation at an acceptable cost. In this paper we study the effectiveness of partial compaction and provide the first rigorous lower and upper bounds on its effectiveness in reducing fragmentation at a low cost.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926441", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anna", + "last_name": "Bendersky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/BenderskyP11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926410", + "title": "Correct blame for contracts: no more scapegoating", + "abstract": "Behavioral software contracts supplement interface information with logical assertions. A rigorous enforcement of contracts provides useful feedback to developers if it signals contract violations as soon as they occur and if it assigns blame to violators with preciseexplanations. Correct blame assignment gets programmers started with the debugging process and can significantly decrease the time needed to discover and fix bugs.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926410", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northeastern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/DimoulasFFF11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926435", + "title": "Dynamic multirole session types", + "abstract": "Multiparty session types enforce structured safe communications between several participants, as long as their number is fixed when the session starts. In order to handle common distributed interaction patterns such as peer-to-peer protocols or cloud algorithms, we propose a new role-based multiparty session type theory where roles are defined as classes of local behaviours that an arbitrary number of participants can dynamically join and leave. We offer programmers a polling operation that gives access to the current set of a role's participants in order to fork processes. Our type system with universal types for polling can handle this dynamism and retain type safety. A multiparty locking mechanism is introduced to provide communication safety, but also to ensure a stronger progress property for joining participants that has never been guaranteed in previous systems. Finally, we present some implementation mechanisms used in our prototype extension of ML.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926435", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre-Malo", + "last_name": "Deniélou", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/DenielouY11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926407", + "title": "Precise reasoning for programs using containers", + "abstract": "Containers are general-purpose data structures that provide functionality for inserting, reading, removing, and iterating over elements. Since many applications written in modern programming languages, such as C++ and Java, use containers as standard building blocks, precise analysis of many programs requires a fairly sophisticated understanding of container contents. In this paper, we present a sound, precise, and fully automatic technique for static reasoning about contents of containers. We show that the proposed technique adds useful precision for verifying real C++ applications and that it scales to applications with over 100,000 lines of code.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926407", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/DilligDA11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926409", + "title": "Blame for all", + "abstract": "Several programming languages are beginning to integrate static and dynamic typing, including Racket (formerly PLT Scheme), Perl 6, and C# 4.0 and the research languages Sage (Gronski, Knowles, Tomb, Freund, and Flanagan, 2006) and Thorn (Wrigstad, Eugster, Field, Nystrom, and Vitek, 2009). However, an important open question remains, which is how to add parametric polymorphism to languages that combine static and dynamic typing. We present a system that permits a value of dynamic type to be cast to a polymorphic type and vice versa, with relational parametricity enforced by a kind of dynamic sealing along the lines proposed by Matthews and Ahmed (2008) and Neis, Dreyer, and Rossberg (2009). Our system includes a notion of blame, which allows us to show that when casting between a more-precise type and a less-precise type, any cast failures are due to the less-precisely-typed portion of the program. We also show that a cast from a subtype to its supertype cannot fail.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926409", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/AhmedFSW11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926437", + "title": "Dynamic inference of static types for ruby", + "abstract": "There have been several efforts to bring static type inference to object-oriented dynamic languages such as Ruby, Python, and Perl. In our experience, however, such type inference systems are extremely difficult to develop, because dynamic languages are typically complex, poorly specified, and include features, such as eval and reflection, that are hard to analyze.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926437", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jong-hoon", + "last_name": "An", + "institution": "Epic Systems (United States)" + }, + { + "first_name": "Avik", + "last_name": "Chaudhuri", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/popl/AnCFH11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926416", + "title": "Modular reasoning for deterministic parallelism", + "abstract": "Weaving a concurrency control protocol into a program is difficult and error-prone. One way to alleviate this burden is deterministic parallelism. In this well-studied approach to parallelisation, a sequential program is annotated with sections that can execute concurrently, with automatically injected control constructs used to ensure observable behaviour consistent with the original program.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926416", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mike", + "last_name": "Dodds", + "institution": "University of Cambridge" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/DoddsJP11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926431", + "title": "Making prophecies with decision predicates", + "abstract": "We describe a new algorithm for proving temporal properties expressed in LTL of infinite-state programs. Our approach takes advantage of the fact that LTL properties can often be proved more efficiently using techniques usually associated with the branching-time logic CTL than they can with native LTL algorithms. The caveat is that, in certain instances, nondeterminism in the system's transition relation can cause CTL methods to report counter examples that are spurious with respect to the original LTL formula. To address this problem we describe an algorithm that, as it attempts to apply CTL proof methods, finds and then removes problematic nondeterminism via an analysis on the potentially spurious counterexamples. Problematic nondeterminism is characterized using decision predicates, and removed using a partial, symbolic determinization procedure which introduces new prophecy variables to predict the future outcome of these choices. We demonstrate---using examples taken from the PostgreSQL database server, Apache web server, and Windows OS kernel---that our method can yield enormous performance improvements in comparison to known tools, allowing us to automatically prove properties of programs where we could not prove them before.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926431", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/CookK11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926447", + "title": "Safe nondeterminism in a deterministic-by-default parallel language", + "abstract": "A number of deterministic parallel programming models with strong safety guarantees are emerging, but similar support for nondeterministic algorithms, such as branch and bound search, remains an open question. We present a language together with a type and effect system that supports nondeterministic computations with a deterministic-by-default guarantee: nondeterminism must be explicitly requested via special parallel constructs (marked nd), and any deterministic construct that does not execute any nd construct has deterministic input-output behavior. Moreover, deterministic parallel constructs are always equivalent to a sequential composition of their constituent tasks, even if they enclose, or are enclosed by, nd constructs. Finally, in the execution of nd constructs, interference may occur only between pairs of accesses guarded by atomic statements, so there are no data races, either between atomic statements and unguarded accesses (strong isolation) or between pairs of unguarded accesses (stronger than strong isolation alone). We enforce the guarantees at compile time with modular checking using novel extensions to a previously described effect system. Our effect system extensions also enable the compiler to remove unnecessary transactional synchronization. We provide a static semantics, dynamic semantics, and a complete proof of soundness for the language, both with and without the barrier removal feature. An experimental evaluation shows that our language can achieve good scalability for realistic parallel algorithms, and that the barrier removal techniques provide significant performance gains.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926447", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert L.", + "last_name": "Bocchino", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stephen", + "last_name": "Heumann", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Nima", + "last_name": "Honarmand", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Sarita V.", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Adam", + "last_name": "Welc", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Tatiana", + "last_name": "Shpeisman", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/popl/BocchinoHHAAWS11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926432", + "title": "Delay-bounded scheduling", + "abstract": "We provide a new characterization of scheduling nondeterminism by allowing deterministic schedulers to delay their next-scheduled task. In limiting the delays an otherwise-deterministic scheduler is allowed, we discover concurrency bugs efficiently---by exploring few schedules---and robustly---i.e., independent of the number of tasks, context switches, or buffered events. Our characterization elegantly applies to any systematic exploration (e.g., testing, model checking) of concurrent programs with dynamic task-creation. Additionally, we show that certain delaying schedulers admit efficient reductions from concurrent to sequential program analysis.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926432", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "Université Paris Cité" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Zvonimir", + "last_name": "Rakamarić", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/popl/EmmiQR11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926394", + "title": "Mathematizing C++ concurrency", + "abstract": "Shared-memory concurrency in C and C++ is pervasive in systems programming, but has long been poorly defined. This motivated an ongoing shared effort by the standards committees to specify concurrent behaviour in the next versions of both languages. They aim to provide strong guarantees for race-free programs, together with new (but subtle) relaxed-memory atomic primitives for high-performance concurrent code. However, the current draft standards, while the result of careful deliberation, are not yet clear and rigorous definitions, and harbour substantial problems in their details.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926394", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Cambridge" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Cambridge" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Tjark", + "last_name": "Weber", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/BattyOSSW11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926401", + "title": "Step-indexed kripke models over recursive worlds", + "abstract": "Over the last decade, there has been extensive research on modelling challenging features in programming languages and program logics, such as higher-order store and storable resource invariants. A recent line of work has identified a common solution to some of these challenges: Kripke models over worlds that are recursively defined in a category of metric spaces. In this paper, we broaden the scope of this technique from the original domain-theoretic setting to an elementary, operational one based on step indexing. The resulting method is widely applicable and leads to simple, succinct models of complicated language features, as we demonstrate in our semantics of Charguéraud and Pottier's type-and-capability system for an ML-like higher-order language. Moreover, the method provides a high-level understanding of the essence of recent approaches based on step indexing.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926401", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Bernhard", + "last_name": "Reus", + "institution": "University of Sussex" + }, + { + "first_name": "Jan", + "last_name": "Schwinghammer", + "institution": "Saarland University" + }, + { + "first_name": "Kristian", + "last_name": "Støvring", + "institution": "University of Copenhagen" + }, + { + "first_name": "Jacob", + "last_name": "Thamsborg", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/BirkedalRSSTY11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926454", + "title": "Streaming transducers for algorithmic verification of single-pass list-processing programs", + "abstract": "We introduce streaming data string transducers that map input data strings to output data strings in a single left-to-right pass in linear time. Data strings are (unbounded) sequences of data values, tagged with symbols from a finite set, over a potentially infinite data domain that supports only the operations of equality and ordering. The transducer uses a finite set of states, a finite set of variables ranging over the data domain, and a finite set of variables ranging over data strings. At every step, it can make decisions based on the next input symbol, updating its state, remembering the input data value in its data variables, and updating data-string variables by concatenating data-string variables and new symbols formed from data variables, while avoiding duplication. We establish PSPACE bounds for the problems of checking functional equivalence of two streaming transducers, and of checking whether a streaming transducer satisfies pre/post verification conditions specified by streaming acceptors over input/output data-strings.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926454", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Pavol", + "last_name": "Černý", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "conf/popl/AlurC11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926399", + "title": "A parametric segmentation functor for fully automatic and scalable array content analysis", + "abstract": "We introduce FunArray, a parametric segmentation abstract domain functor for the fully automatic and scalable analysis of array content properties. The functor enables a natural, painless and efficient lifting of existing abstract domains for scalar variables to the analysis of uniform compound data-structures such as arrays and collections. The analysis automatically and semantically divides arrays into consecutive non-overlapping possibly empty segments. Segments are delimited by sets of bound expressions and abstracted uniformly. All symbolic expressions appearing in a bound set are equal in the concrete. The FunArray can be naturally combined via reduced product with any existing analysis for scalar variables. The analysis is presented as a general framework parameterized by the choices of bound expressions, segment abstractions and the reduction operator. Once the functor has been instantiated with fixed parameters, the analysis is fully automatic.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926399", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "Laboratoire de Géologie de l’École Normale Supérieure" + }, + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/CousotCL11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926442", + "title": "Laws of order: expensive synchronization in concurrent algorithms cannot be eliminated", + "abstract": "Building correct and efficient concurrent algorithms is known to be a difficult problem of fundamental importance. To achieve efficiency, designers try to remove unnecessary and costly synchronization. However, not only is this manual trial-and-error process ad-hoc, time consuming and error-prone, but it often leaves designers pondering the question of: is it inherently impossible to eliminate certain synchronization, or is it that I was unable to eliminate it on this attempt and I should keep trying?", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926442", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hagit", + "last_name": "Attiya", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Danny", + "last_name": "Hendler", + "institution": "Ben-Gurion University of the Negev" + }, + { + "first_name": "Petr", + "last_name": "Kuznetsov", + "institution": "Deutsche Telekom (Germany)" + }, + { + "first_name": "Maged M.", + "last_name": "Michael", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/AttiyaGHKMV11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926397", + "title": "Static analysis of multi-staged programs via unstaging translation", + "abstract": "Static analysis of multi-staged programs is challenging because the basic assumption of conventional static analysis no longer holds: the program text itself is no longer a fixed static entity, but rather a dynamically constructed value. This article presents a semantic-preserving translation of multi-staged call-by-value programs into unstaged programs and a static analysis framework based on this translation. The translation is semantic-preserving in that every small-step reduction of a multi-staged program is simulated by the evaluation of its unstaged version. Thanks to this translation we can analyze multi-staged programs with existing static analysis techniques that have been developed for conventional unstaged programs: we first apply the unstaging translation, then we apply conventional static analysis to the unstaged version, and finally we cast the analysis results back in terms of the original staged program. Our translation handles staging constructs that have been evolved to be useful in practice (typified in Lisp's quasi-quotation): open code as values, unrestricted operations on references and intentional variable-capturing substitutions. This article omits references for which we refer the reader to our companion technical report.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926397", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wontae", + "last_name": "Choi", + "institution": "Seoul National University" + }, + { + "first_name": "Barış", + "last_name": "Aktemur", + "institution": "Özyeğin University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + }, + { + "first_name": "Makoto", + "last_name": "Tatsuta", + "institution": "National Institute of Informatics" + } + ], + "dblp_key": "conf/popl/ChoiAYT11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926423", + "title": "Automating string processing in spreadsheets using input-output examples", + "abstract": "We describe the design of a string programming/expression language that supports restricted forms of regular expressions, conditionals and loops. The language is expressive enough to represent a wide variety of string manipulation tasks that end-users struggle with. We describe an algorithm based on several novel concepts for synthesizing a desired program in this language from input-output examples. The synthesis algorithm is very efficient taking a fraction of a second for various benchmark examples. The synthesis algorithm is interactive and has several desirable features: it can rank multiple solutions and has fast convergence, it can detect noise in the user input, and it supports an active interaction model wherein the user is prompted to provide outputs on inputs that may have multiple computational interpretations.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926423", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/Gulwani11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926446", + "title": "Bisimulation for quantum processes", + "abstract": "Quantum cryptographic systems have been commercially available, with a striking advantage over classical systems that their security and ability to detect the presence of eavesdropping are provable based on the principles of quantum mechanics. On the other hand, quantum protocol designers may commit much more faults than classical protocol designers since human intuition is much better adapted to the classical world than the quantum world. To offer formal techniques for modeling and verification of quantum protocols, several quantum extensions of process algebra have been proposed. One of the most serious issues in quantum process algebra is to discover a quantum generalization of the notion of bisimulation, which lies in a central position in process algebra, preserved by parallel composition in the presence of quantum entanglement, which has no counterpart in classical computation. Quite a few versions of bisimulation have been defined for quantum processes in the literature, but in the best case they are only proved to be preserved by parallel composition of purely quantum processes where no classical communications are involved.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926446", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuan", + "last_name": "Feng", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Runyao", + "last_name": "Duan", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "University of Technology Sydney" + } + ], + "dblp_key": "conf/popl/FengDY11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926425", + "title": "Geometry of synthesis III: resource management through type inference", + "abstract": "Geometry of Synthesis is a technique for compiling higher-level programming languages into digital circuits via their game semantic model. Ghica (2007) first presented the key idea, then Ghica and Smith (2010) gave a provably correct compiler into asynchronous circuits for Syntactic Control of Interference (SCI), an affine-typed version of Reynolds's Idealized Algol. Affine typing has the dual benefits of ruling out race conditions through the type system and having a finite-state game-semantic model for any term, which leads to a natural circuit representation and simpler correctness proofs. In this paper we go beyond SCI to full Idealized Algol, enhanced with shared-memory concurrency and semaphores.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926425", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dan R.", + "last_name": "Ghica", + "institution": "University of Birmingham" + }, + { + "first_name": "Alex", + "last_name": "Smith", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/popl/GhicaS11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926439", + "title": "Robin Milner 1934--2010: verification, languages, and concurrency", + "abstract": "No abstract available.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926439", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "John", + "last_name": "Harrison", + "institution": "Intel (United States)" + }, + { + "first_name": "Alan", + "last_name": "Jeffrey", + "institution": "" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/GordonHHJS11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926450", + "title": "The essence of compiling with traces", + "abstract": "The technique of trace-based just-in-time compilation was introduced by Bala et al. and was further developed by Gal et al. It currently enjoys success in Mozilla Firefox's JavaScript engine. A trace-based JIT compiler leverages run-time profiling to optimize frequently-executed paths while enabling the optimized code to ``bail out'' to the original code when the path has been invalidated. This optimization strategy differs from those of other JIT compilers and opens the question of which trace optimizations are sound. In this paper we present a framework for reasoning about the soundness of trace optimizations, and we show that some traditional optimization techniques are sound when used in a trace compiler while others are unsound. The converse is also true: some trace optimizations are sound when used in a traditional compiler while others are unsound. So, traditional and trace optimizations form incomparable sets. Our setting is an imperative calculus for which tracing is explicitly spelled out in the semantics. We define optimization soundness via a notion of bisimulation, and we show that sound optimizations lead to confluence and determinacy of stores.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926450", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shuyu", + "last_name": "Guo", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/popl/GuoP11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926443", + "title": "Complexity of pattern-based verification for multithreaded programs", + "abstract": "Pattern-based verification checks the correctness of the program executions that follow a given pattern, a regular expression over the alphabet of program transitions of the form w1* ... wn*. For multithreaded programs, the alphabet of the pattern is given by the synchronization operations between threads. We study the complexity of pattern-based verification for abstracted multithreaded programs in which, as usual in program analysis, conditions have been replaced by nondeterminism (the technique works also for boolean programs). While unrestricted verification is undecidable for abstracted multithreaded programs with recursive procedures and PSPACE-complete for abstracted multithreaded while-programs, we show that pattern-based verification is NP-complete for both classes. We then conduct a multiparameter analysis in which we study the complexity in the number of threads, the number of procedures per thread, the size of the procedures, and the size of the pattern. We first show that no algorithm for pattern-based verification can be polynomial in the number of threads, procedures per thread, or the size of the pattern (unless P=NP). Then, using recent results about Parikh images of regular languages and semilinear sets, we present an algorithm exponential in the number of threads, procedures per thread, and size of the pattern, but polynomial in the size of the procedures.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926443", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Javier", + "last_name": "Esparza", + "institution": "Technical University of Munich" + }, + { + "first_name": "Pierre", + "last_name": "Ganty", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/popl/EsparzaG11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926427", + "title": "Multivariate amortized resource analysis", + "abstract": "We study the problem of automatically analyzing the worst-case resource usage of procedures with several arguments. Existing automatic analyses based on amortization, or sized types bound the resource usage or result size of such a procedure by a sum of unary functions of the sizes of the arguments.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926427", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Ludwig-Maximilians-Universität München" + }, + { + "first_name": "Klaus", + "last_name": "Aehlig", + "institution": "Ludwig-Maximilians-Universität München" + }, + { + "first_name": "Martin", + "last_name": "Hofmann", + "institution": "Ludwig-Maximilians-Universität München" + } + ], + "dblp_key": "conf/popl/HoffmannAH11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926429", + "title": "Regular expression containment: coinductive axiomatization and computational interpretation", + "abstract": "We present a new sound and complete axiomatization of regular expression containment. It consists of the conventional axiomatization of concatenation, alternation, empty set and (the singleton set containing) the empty string as an idempotent semiring, the fixed- point rule E* = 1 + E × E* for Kleene-star, and a general coinduction rule as the only additional rule.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926429", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fritz", + "last_name": "Henglein", + "institution": "University of Copenhagen" + }, + { + "first_name": "Lasse", + "last_name": "Nielsen", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/popl/HengleinN11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926428", + "title": "Symmetric lenses", + "abstract": "Lenses--bidirectional transformations between pairs of connected structures--have been extensively studied and are beginning to find their way into industrial practice. However, some aspects of their foundations remain poorly understood. In particular, most previous work has focused on the special case of asymmetric lenses, where one of the structures is taken as primary and the other is thought of as a projection, or view. A few studies have considered symmetric variants, where each structure contains information not present in the other, but these all lack the basic operation of composition. Moreover, while many domain-specific languages based on lenses have been designed, lenses have not been thoroughly explored from an algebraic perspective.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926428", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Hofmann", + "institution": "Ludwig-Maximilians-Universität München" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Daniel", + "last_name": "Wägner", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/HofmannPW11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926402", + "title": "A kripke logical relation between ML and assembly", + "abstract": "There has recently been great progress in proving the correctness of compilers for increasingly realistic languages with increasingly realistic runtime systems. Most work on this problem has focused on proving the correctness of a particular compiler, leaving open the question of how to verify the correctness of assembly code that is hand-optimized or linked together from the output of multiple compilers. This has led Benton and other researchers to propose more abstract, compositional notions of when a low-level program correctly realizes a high-level one. However, the state of the art in so-called \"compositional compiler correctness\" has only considered relatively simple high-level and low-level languages.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926402", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/HurD11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926387", + "title": "Verified squared: does critical software deserve verified tools?", + "abstract": "The formal verification of programs has progressed tremendously in the last decade. In this talk, I review some of the obstacles that [6, 8, 15, 18] remain to be lifted before source-level verification tools can be taken really seriously in the critical software industry. A direction I advocate is the systematic formal verification of the development tools that participate in the production and verification of critical software.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926387", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Leroy11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926424", + "title": "Predicate abstraction and refinement for verifying multi-threaded programs", + "abstract": "Automated verification of multi-threaded programs requires explicit identification of the interplay between interacting threads, so-called environment transitions, to enable scalable, compositional reasoning. Once the environment transitions are identified, we can prove program properties by considering each program thread in isolation, as the environment transitions keep track of the interleaving with other threads. Finding adequate environment transitions that are sufficiently precise to yield conclusive results and yet do not overwhelm the verifier with unnecessary details about the interleaving with other threads is a major challenge. In this paper we propose a method for safety verification of multi-threaded programs that applies (transition) predicate abstraction-based discovery of environment transitions, exposing a minimal amount of information about the thread interleaving. The crux of our method is an abstraction refinement procedure that uses recursion-free Horn clauses to declaratively state abstraction refinement queries. Then, the queries are resolved by a corresponding constraint solving algorithm. We present preliminary experimental results for mutual exclusion protocols and multi-threaded device drivers.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926424", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ashutosh", + "last_name": "Gupta", + "institution": "Technical University of Munich" + }, + { + "first_name": "Corneliu", + "last_name": "Popeea", + "institution": "Technical University of Munich" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/popl/GuptaPR11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926457", + "title": "A technique for the effective and automatic reuse of classical compiler optimizations on multithreaded code", + "abstract": "A large body of data-flow analyses exists for analyzing and optimizing sequential code. Unfortunately, much of it cannot be directly applied on parallel code, for reasons of correctness. This paper presents a technique to automatically, aggressively, yet safely apply sequentially-sound data-flow transformations, without change, on shared-memory programs. The technique is founded on the notion of program references being \"siloed\" on certain control-flow paths. Intuitively, siloed references are free of interference from other threads within the confines of such paths. Data-flow transformations can, in general, be unblocked on siloed references.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926457", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pramod G.", + "last_name": "Joisha", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Robert", + "last_name": "Schreiber", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Prithviraj", + "last_name": "Banerjee", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Hans J.", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Dhruva R.", + "last_name": "Chakrabarti", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/popl/JoishaSBBC11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926413", + "title": "The design of kodu: a tiny visual programming language for children on the Xbox 360", + "abstract": "Kodu is a relatively new programming language designed specifically for young children to learn through independent exploration. Kodu seeks to lower the barrier to entry for new programmers by presenting a radically simplified programming model which nevertheless has significant expressive power. Kodu is integrated in a real-time 3D gaming environment and is designed to compete with modern console games in terms of intuitive user interface and graphical production values. In this paper we will review key tradeoffs made in the design of the programming language and illustrate how it is one of very few languages designed using user interface design principles and methodologies, to the extent that the blend of subjective and objective factors considered in the language design have succeeded in presenting a model of programming which is uniquely approachable and creatively empowering for non-technical users.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926413", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew B.", + "last_name": "MacLaurin", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/MacLaurin11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926417", + "title": "Expressive modular fine-grained concurrency specification", + "abstract": "Compared to coarse-grained external synchronization of operations on data structures shared between concurrent threads, fine-grained, internal synchronization can offer stronger progress guarantees and better performance. However, fully specifying operations that perform internal synchronization modularly is a hard, open problem. The state of the art approaches, based on linearizability or on concurrent abstract predicates, have important limitations on the expressiveness of specifications. Linearizability does not support ownership transfer, and the concurrent abstract predicates-based specification approach requires hardcoding a particular usage protocol. In this paper, we propose a novel approach that lifts these limitations and enables fully general specification of fine-grained concurrent data structures. The basic idea is that clients pass the ghost code required to instantiate an operation's specification for a specific client scenario into the operation in a simple form of higher-order programming.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926417", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bart", + "last_name": "Jacobs", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/popl/JacobsP11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926455", + "title": "Decidable logics combining heap structures and data", + "abstract": "We define a new logic, STRAND, that allows reasoning with heap-manipulating programs using deductive verification and SMT solvers. STRAND logic (\"STRucture ANd Data\" logic) formulas express constraints involving heap structures and the data they contain; they are defined over a class of pointer-structures R defined using MSO-defined relations over trees, and are of the form ∃→x∀→y (→x,→) x\" , where \"φ\" is a monadic second-order logic (MSO) formulawith additional quantification that combines structural constraints as well as data-constraints, but where the data-constraints are only allowed to refer to \"→x\" and \"→y\"", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926455", + "conference_name": "POPL", + "authors": [ + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gennaro", + "last_name": "Parlato", + "institution": "Université Paris Cité" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/MadhusudanPQ11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926453", + "title": "Verifying higher-order functional programs with pattern-matching algebraic data types", + "abstract": "Type-based model checking algorithms for higher-order recursion schemes have recently emerged as a promising approach to the verification of functional programs. We introduce pattern-matching recursion schemes (PMRS) as an accurate model of computation for functional programs that manipulate algebraic data-types. PMRS are a natural extension of higher-order recursion schemes that incorporate pattern-matching in the defining rules.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926453", + "conference_name": "POPL", + "authors": [ + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + }, + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/OngR11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926403", + "title": "A typed store-passing translation for general references", + "abstract": "We present a store-passing translation of System F with general references into an extension of System Fω with certain well-behaved recursive kinds. This seems to be the first type-preserving store-passing translation for general references. It can be viewed as a purely syntactic account of a possible worlds model.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926403", + "conference_name": "POPL", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/Pottier11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926421", + "title": "Vector addition system reachability problem: a short self-contained proof", + "abstract": "The reachability problem for Vector Addition Systems (VASs) is a central problem of net theory. The general problem is known decidable by algorithms exclusively based on the classical Kosaraju-Lambert-Mayr-Sacerdote-Tenney decomposition (KLMTS decomposition). Recently from this decomposition, we deduced that a final configuration is not reachable from an initial one if and only if there exists a Presburger inductive invariant that contains the initial configuration but not the final one. Since we can decide if a Preburger formula denotes an inductive invariant, we deduce from this result that there exist checkable certificates of non-reachability in the Presburger arithmetic. In particular, there exists a simple algorithm for deciding the general VAS reachability problem based on two semi-algorithms. A first one that tries to prove the reachability by enumerating finite sequences of actions and a second one that tries to prove the non-reachability by enumerating Presburger formulas. In this paper we provide the first proof of the VAS reachability problem that is not based on the KLMST decomposition. The proof is based on the notion of production relations inspired from Hauschildt that directly provides the existence of Presburger inductive invariants.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926421", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jérôme", + "last_name": "Leroux", + "institution": "Laboratoire Bordelais de Recherche en Informatique" + } + ], + "dblp_key": "conf/popl/Leroux11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926389", + "title": "Points-to analysis with efficient strong updates", + "abstract": "This paper explores a sweet spot between flow-insensitive and flow-sensitive subset-based points-to analysis. Flow-insensitive analysis is efficient: it has been applied to million-line programs and even its worst-case requirements are quadratic space and cubic time. Flow-sensitive analysis is precise because it allows strong updates, so that points-to relationships holding in one program location can be removed from the analysis when they no longer hold in other locations. We propose a \"Strong Update\" analysis combining both features: it is efficient like flow-insensitive analysis, with the same worst-case bounds, yet its precision benefits from strong updates like flow-sensitive analysis. The key enabling insight is that strong updates are applicable when the dereferenced points-to set is a singleton, and a singleton set is cheap to analyze. The analysis therefore focuses flow sensitivity on singleton sets. Larger sets, which will not lead to strong updates, are modelled flow insensitively to maintain efficiency. We have implemented and evaluated the analysis as an extension of the standard flow-insensitive points-to analysis in the LLVM compiler infrastructure.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926389", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "Kwok-Chiang Andrew", + "last_name": "Chung", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/popl/LhotakC11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926405", + "title": "A shape analysis for optimizing parallel graph programs", + "abstract": "Computations on unstructured graphs are challenging to parallelize because dependences in the underlying algorithms are usually complex functions of runtime data values, thwarting static parallelization. One promising general-purpose parallelization strategy for these algorithms is optimistic parallelization.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926405", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dimitrios", + "last_name": "Prountzos", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Roman", + "last_name": "Manevich", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/PrountzosMPM11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926419", + "title": "The tree width of auxiliary storage", + "abstract": "We propose a generalization of results on the decidability of emptiness for several restricted classes of sequential and distributed automata with auxiliary storage (stacks, queues) that have recently been proved. Our generalization relies on reducing emptiness of these automata to finite-state graph automata (without storage) restricted to monadic second-order (MSO) definable graphs of bounded tree-width, where the graph structure encodes the mechanism provided by the auxiliary storage. Our results outline a uniform mechanism to derive emptiness algorithms for automata, explaining and simplifying several existing results, as well as proving new decidability results.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926419", + "conference_name": "POPL", + "authors": [ + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gennaro", + "last_name": "Parlato", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/MadhusudanP11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926445", + "title": "EigenCFA: accelerating flow analysis with GPUs", + "abstract": "We describe, implement and benchmark EigenCFA, an algorithm for accelerating higher-order control-flow analysis (specifically, 0CFA) with a GPU. Ultimately, our program transformations, reductions and optimizations achieve a factor of 72 speedup over an optimized CPU implementation.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926445", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tarun", + "last_name": "Prabhu", + "institution": "University of Utah" + }, + { + "first_name": "S.", + "last_name": "Ramalingam", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "Mary", + "last_name": "Hall", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/PrabhuRMH11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926391", + "title": "Learning minimal abstractions", + "abstract": "Static analyses are generally parametrized by an abstraction which is chosen from a family of abstractions. We are interested in flexible families of abstractions with many parameters, as these families can allow one to increase precision in ways tailored to the client without sacrificing scalability. For example, we consider k-limited points-to analyses where each call site and allocation site in a program can have a different k value. We then ask a natural question in this paper: What is the minimal (coarsest) abstraction in a given family which is able to prove a set of queries? In addressing this question, we make the following two contributions: (i) We introduce two machine learning algorithms for efficiently finding a minimal abstraction; and (ii) for a static race detector backed by a k-limited points-to analysis, we show empirically that minimal abstractions are actually quite coarse: It suffices to provide context/object sensitivity to a very small fraction (0.4-2.3%) of the sites to yield equally precise results as providing context/object sensitivity uniformly to all sites.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926391", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Percy", + "last_name": "Liang", + "institution": "Berkeley College" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/popl/LiangTN11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926451", + "title": "Resourceable, retargetable, modular instruction selection using a machine-independent, type-based tiling of low-level intermediate code", + "abstract": "We present a novel variation on the standard technique of selecting instructions by tiling an intermediate-code tree. Typical compilers use a different set of tiles for every target machine. By analyzing a formal model of machine-level computation, we have developed a single set of tiles that is machine-independent while retaining the expressive power of machine code. Using this tileset, we reduce the number of tilers required from one per machine to one per architectural family (e.g., register architecture or stack architecture). Because the tiler is the part of the instruction selector that is most difficult to reason about, our technique makes it possible to retarget an instruction selector with significantly less effort than standard techniques. Retargeting effort is further reduced by applying an earlier result which generates the machine-dependent implementation of our tileset automatically from a declarative description of instructions' semantics. Our design has the additional benefit of enabling modular reasoning about three aspects of code generation that are not typically separated: the semantics of the compiler's intermediate representation, the semantics of the target instruction set, and the techniques needed to generate good target code.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926451", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Tufts University" + }, + { + "first_name": "João", + "last_name": "Dias", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/popl/RamseyD11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926436", + "title": "Practical affine types", + "abstract": "Alms is a general-purpose programming language that supports practical affine types. To offer the expressiveness of Girard's linear logic while keeping the type system light and convenient, Alms uses expressive kinds that minimize notation while maximizing polymorphism between affine and unlimited types.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926436", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jesse A.", + "last_name": "Tov", + "institution": "Northeastern University" + }, + { + "first_name": "Riccardo", + "last_name": "Pucella", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/TovP11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926395", + "title": "Formal verification of object layout for c++ multiple inheritance", + "abstract": "Object layout - the concrete in-memory representation of objects - raises many delicate issues in the case of the C++ language, owing in particular to multiple inheritance, C compatibility and separate compilation. This paper formalizes a family of C++ object layout schemes and mechanically proves their correctness against the operational semantics for multiple inheritance of Wasserrab et al. This formalization is flexible enough to account for space-saving techniques such as empty base class optimization and tail-padding optimization. As an application, we obtain the first formal correctness proofs for realistic, optimized object layout algorithms, including one based on the popular \"common vendor\" Itanium C++ application binary interface. This work provides semantic foundations to discover and justify new layout optimizations; it is also a first step towards the verification of a C++ compiler front-end.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926395", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Gabriel Dos", + "last_name": "Reis", + "institution": "Texas A&M University" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/RamananandroRL11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926420", + "title": "Fresh-register automata", + "abstract": "What is a basic automata-theoretic model of computation with names and fresh-name generation? We introduce Fresh-Register Automata (FRA), a new class of automata which operate on an infinite alphabet of names and use a finite number of registers to store fresh names, and to compare incoming names with previously stored ones. These finite machines extend Kaminski and Francez's Finite-Memory Automata by being able to recognise globally fresh inputs, that is, names fresh in the whole current run. We examine the expressivity of FRA's both from the aspect of accepted languages and of bisimulation equivalence. We establish primary properties and connections between automata of this kind, and answer key decidability questions. As a demonstrating example, we express the theory of the pi-calculus in FRA's and characterise bisimulation equivalence by an appropriate, and decidable in the finitary case, notion in these automata.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926420", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nikos", + "last_name": "Tzevelekos", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/Tzevelekos11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926415", + "title": "A separation logic for refining concurrent objects", + "abstract": "Fine-grained concurrent data structures are crucial for gaining performance from multiprocessing, but their design is a subtle art. Recent literature has made large strides in verifying these data structures, using either atomicity refinement or separation logic with rely-guarantee reasoning. In this paper we show how the ownership discipline of separation logic can be used to enable atomicity refinement, and we develop a new rely-guarantee method that is localized to the definition of a data structure. We present the first semantics of separation logic that is sensitive to atomicity, and show how to control this sensitivity through ownership. The result is a logic that enables compositional reasoning about atomicity and interference, even for programs that use fine-grained synchronization and dynamic memory allocation.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926415", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Northeastern University" + }, + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/TuronW11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926406", + "title": "Calling context abstraction with shapes", + "abstract": "Interprocedural program analysis is often performed by computing procedure summaries. While possible, computing adequate summaries is difficult, particularly in the presence of recursive procedures. In this paper, we propose a complementary framework for interprocedural analysis based on a direct abstraction of the calling context. Specifically, our approach exploits the inductive structure of a calling context by treating it directly as a stack of activation records. We then build an abstraction based on separation logic with inductive definitions. A key element of this abstract domain is the use of parameters to refine the meaning of such call stack summaries and thus express relations across activation records and with the heap. In essence, we define an abstract interpretation-based analysis framework for recursive programs that permits a fluid per call site abstraction of the call stack--much like how shape analyzers enable a fluid per program point abstraction of the heap.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926406", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/popl/RivalC11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926398", + "title": "Static analysis of interrupt-driven programs synchronized via the priority ceiling protocol", + "abstract": "We consider programs for embedded real-time systems which use priority-driven preemptive scheduling with task priorities adjusted dynamically according to the immediate ceiling priority protocol. For these programs, we provide static analyses for detecting data races between tasks running at different priorities as well as methods to guarantee transactional execution of procedures. Beyond that, we demonstrate how general techniques for value analyses can be adapted to this setting by developing a precise analysis of affine equalities.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926398", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin D.", + "last_name": "Schwarz", + "institution": "Technical University of Munich" + }, + { + "first_name": "Helmut", + "last_name": "Seidl", + "institution": "Technical University of Munich" + }, + { + "first_name": "Vesal", + "last_name": "Vojdani", + "institution": "Technical University of Munich" + }, + { + "first_name": "Peter", + "last_name": "Lammich", + "institution": "University of Münster" + }, + { + "first_name": "Markus", + "last_name": "Müller-Olm", + "institution": "University of Münster" + } + ], + "dblp_key": "conf/popl/SchwarzSVLM11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926393", + "title": "Relaxed-memory concurrency and verified compilation", + "abstract": "In this paper, we consider the semantic design and verified compilation of a C-like programming language for concurrent shared-memory computation above x86 multiprocessors. The design of such a language is made surprisingly subtle by several factors: the relaxed-memory behaviour of the hardware, the effects of compiler optimisation on concurrent code, the need to support high-performance concurrent algorithms, and the desire for a reasonably simple programming model. In turn, this complexity makes verified (or verifying) compilation both essential and challenging.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926393", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jaroslav", + "last_name": "Ševčík", + "institution": "University of Cambridge" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/SevcikVNJS11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926411", + "title": "Generative type abstraction and type-level computation", + "abstract": "Modular languages support generative type abstraction, ensuring that an abstract type is distinct from its representation, except inside the implementation where the two are synonymous. We show that this well-established feature is in tension with the non-parametric features of newer type systems, such as indexed type families and GADTs. In this paper we solve the problem by using kinds to distinguish between parametric and non-parametric contexts. The result is directly applicable to Haskell, which is rapidly developing support for type-level computation, but the same issues should arise whenever generativity and non-parametric features are combined.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926411", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/WeirichVJZ11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926390", + "title": "Pick your contexts well: understanding object-sensitivity", + "abstract": "Object-sensitivity has emerged as an excellent context abstraction for points-to analysis in object-oriented languages. Despite its practical success, however, object-sensitivity is poorly understood. For instance, for a context depth of 2 or higher, past scalable implementations deviate significantly from the original definition of an object-sensitive analysis. The reason is that the analysis has many degrees of freedom, relating to which context elements are picked at every method call and object creation. We offer a clean model for the analysis design space, and discuss a formal and informal understanding of object-sensitivity and of how to create good object-sensitive analyses. The results are surprising in their extent. We find that past implementations have made a sub-optimal choice of contexts, to the severe detriment of precision and performance. We define a \"full-object-sensitive\" analysis that results in significantly higher precision, and often performance, for the exact same context depth. We also introduce \"type-sensitivity\" as an explicit approximation of object-sensitivity that preserves high context quality at substantially reduced cost. A type-sensitive points-to analysis makes an unconventional use of types as context: the context types are not dynamic types of objects involved in the analysis, but instead upper bounds on the dynamic types of their allocator objects. Our results expose the influence of context choice on the quality of points-to analysis and demonstrate type-sensitivity to be an idea with major impact: It decisively advances the state-of-the-art with a spectrum of analyses that simultaneously enjoy speed (several times faster than an analogous object-sensitive analysis), scalability (comparable to analyses with much less context-sensitivity), and precision (comparable to the best object-sensitive analysis with the same context depth).", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926390", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Martin", + "last_name": "Bravenboer", + "institution": "" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/popl/SmaragdakisBL11", + "venue": "popl", + "year": 2011 + }, + { + "paper_id": "10.1145/1926385.1926449", + "title": "Loop transformations: convexity, pruning and optimization", + "abstract": "High-level loop transformations are a key instrument in mapping computational kernels to effectively exploit the resources in modern processor architectures. Nevertheless, selecting required compositions of loop transformations to achieve this remains a significantly challenging task; current compilers may be off by orders of magnitude in performance compared to hand-optimized programs. To address this fundamental challenge, we first present a convex characterization of all distinct, semantics-preserving, multidimensional affine transformations. We then bring together algebraic, algorithmic, and performance analysis results to design a tractable optimization algorithm over this highly expressive space. Our framework has been implemented and validated experimentally on a representative set of benchmarks running on state-of-the-art multi-core platforms.", + "date": "2011-01-24", + "link": "https://doi.org/10.1145/1926385.1926449", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "The Ohio State University" + }, + { + "first_name": "Uday", + "last_name": "Bondhugula", + "institution": "IBM (United States)" + }, + { + "first_name": "Cédric", + "last_name": "Bastoul", + "institution": "" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "" + }, + { + "first_name": "J.", + "last_name": "Ramanujam", + "institution": "Louisiana State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + }, + { + "first_name": "Nicolas", + "last_name": "Vasilache", + "institution": "Reservoir Labs (United States)" + } + ], + "dblp_key": "conf/popl/PouchetBBCRSV11", + "venue": "popl", + "year": 2011 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2012.json b/data/pl_conferences/popl/2012.json new file mode 100644 index 0000000..621a9e7 --- /dev/null +++ b/data/pl_conferences/popl/2012.json @@ -0,0 +1,1351 @@ +[ + { + "paper_id": "10.1145/2103656.2103658", + "title": "Presentation of the SIGPLAN distinguished achievement award to Sir Charles Antony Richard Hoare, FRS, FREng, FBCS; and interview", + "abstract": "No abstract available.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103658", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew P.", + "last_name": "Black", + "institution": "Portland State University" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/BlackO12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103713", + "title": "A unified approach to fully lazy sharing", + "abstract": "We give an axiomatic presentation of sharing-via-labelling for weak lambda-calculi, that makes it possible to formally compare many different approaches to fully lazy sharing, and obtain two important results. We prove that the known implementations of full laziness are all equivalent in terms of the number of beta-reductions performed, although they behave differently regarding the duplication of terms. We establish a link between the optimality theories of weak lambda-calculi and first-order rewriting systems by expressing fully lazy lambda-lifting in our framework, thus emphasizing the first-order essence of weak reduction.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103713", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thibaut", + "last_name": "Balabonski", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/Balabonski12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103686", + "title": "Nested refinements: a logic for duck typing", + "abstract": "Programs written in dynamic languages make heavy use of features --- run-time type tests, value-indexed dictionaries, polymorphism, and higher-order functions --- that are beyond the reach of type systems that employ either purely syntactic or purely semantic reasoning. We present a core calculus, System D, that merges these two modes of reasoning into a single powerful mechanism of nested refinement types wherein the typing relation is itself a predicate in the refinement logic. System D coordinates SMT-based logical implication and syntactic subtyping to automatically typecheck sophisticated dynamic language programs. By coupling nested refinements with McCarthy's theory of finite maps, System D can precisely reason about the interaction of higher-order functions, polymorphism, and dictionaries. The addition of type predicates to the refinement logic creates a circularity that leads to unique technical challenges in the metatheory, which we solve with a novel stratification approach that we use to prove the soundness of System D.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103686", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of California, San Diego" + }, + { + "first_name": "Patrick M.", + "last_name": "Rondon", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/popl/ChughRJ12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103699", + "title": "On the power of coercion abstraction", + "abstract": "Erasable coercions in System F-eta, also known as retyping functions, are well-typed eta-expansions of the identity. They may change the type of terms without changing their behavior and can thus be erased before reduction. Coercions in F-eta can model subtyping of known types and some displacement of quantifiers, but not subtyping assumptions nor certain forms of delayed type instantiation. We generalize F-eta by allowing abstraction over retyping functions. We follow a general approach where computing with coercions can be seen as computing in the lambda-calculus but keeping track of which parts of terms are coercions. We obtain a language where coercions do not contribute to the reduction but may block it and are thus not erasable. We recover erasable coercions by choosing a weak reduction strategy and restricting coercion abstraction to value-forms or by restricting abstraction to coercions that are polymorphic in their domain or codomain. The latter variant subsumes F-eta, F-sub, and MLF in a unified framework.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103699", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julien", + "last_name": "Cretin", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/CretinR12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103719", + "title": "An executable formal semantics of C with applications", + "abstract": "This paper describes an executable formal semantics of C. Being executable, the semantics has been thoroughly tested against the GCC torture test suite and successfully passes 99.2% of 776 test programs. It is the most complete and thoroughly tested formal definition of C to date. The semantics yields an interpreter, debugger, state space search tool, and model checker \"for free\". The semantics is shown capable of automatically finding program errors, both statically and at runtime. It is also used to enumerate nondeterministic behavior.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103719", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chucky", + "last_name": "Ellison", + "institution": "University of Illinois System" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois System" + } + ], + "dblp_key": "conf/popl/EllisonR12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103704", + "title": "Towards nominal computation", + "abstract": "Nominal sets are a different kind of set theory, with a more relaxed notion of finiteness. They offer an elegant formalism for describing lambda-terms modulo alpha-conversion, or automata on data words. This paper is an attempt at defining computation in nominal sets. We present a rudimentary programming language, called Nlambda. The key idea is that it includes a native type for finite sets in the nominal sense. To illustrate the power of our language, we write short programs that process automata on data words.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103704", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mikołaj", + "last_name": "Bojańczyk", + "institution": "University of Warsaw" + }, + { + "first_name": "Laurent", + "last_name": "Braud", + "institution": "University of Warsaw" + }, + { + "first_name": "Bartek", + "last_name": "Klin", + "institution": "University of Warsaw" + }, + { + "first_name": "Sławomir", + "last_name": "Lasota", + "institution": "University of Warsaw" + } + ], + "dblp_key": "conf/popl/BojanczykBKL12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103681", + "title": "Analysis of recursively parallel programs", + "abstract": "We propose a general formal model of isolated hierarchical parallel computations, and identify several fragments to match the concurrency constructs present in real-world programming languages such as Cilk and X10. By associating fundamental formal models (vector addition systems with recursive transitions) to each fragment, we provide a common platform for exposing the relative difficulties of algorithmic reasoning. For each case we measure the complexity of deciding state-reachability for finite-data recursive programs, and propose algorithms for the decidable cases. The complexities which include PTIME, NP, EXPSPACE, and 2EXPTIME contrast with undecidable state-reachability for recursive multi-threaded programs.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103681", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "conf/popl/BouajjaniE12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103677", + "title": "Multiple facets for dynamic information flow", + "abstract": "JavaScript has become a central technology of the web, but it is also the source of many security problems, including cross-site scripting attacks and malicious advertising code. Central to these problems is the fact that code from untrusted sources runs with full privileges. We implement information flow controls in Firefox to help prevent violations of data confidentiality and integrity. Most previous information flow techniques have primarily relied on either static type systems, which are a poor fit for JavaScript, or on dynamic analyses that sometimes get stuck due to problematic implicit flows, even in situations where the target web application correctly satisfies the desired security policy. We introduce faceted values, a new mechanism for providing information flow security in a dynamic manner that overcomes these limitations. Taking inspiration from secure multi-execution, we use faceted values to simultaneously and efficiently simulate multiple executions for different security levels, thus providing non-interference with minimal overhead, and without the reliance on the stuck executions of prior dynamic approaches.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103677", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas H.", + "last_name": "Austin", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/popl/AustinF12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103694", + "title": "Resource-sensitive synchronization inference by abduction", + "abstract": "We present an analysis which takes as its input a sequential program, augmented with annotations indicating potential parallelization opportunities, and a sequential proof, written in separation logic, and produces a correctly-synchronized parallelized program and proof of that program. Unlike previous work, ours is not an independence analysis; we insert synchronization constructs to preserve relevant dependencies found in the sequential program that may otherwise be violated by a naive translation. Separation logic allows us to parallelize fine-grained patterns of resource-usage, moving beyond straightforward points-to analysis. Our analysis works by using the sequential proof to discover dependencies between different parts of the program. It leverages these discovered dependencies to guide the insertion of synchronization primitives into the parallelized program, and to ensure that the resulting parallelized program satisfies the same specification as the original sequential program, and exhibits the same sequential behaviour. Our analysis is built using frame inference and abduction, two techniques supported by an increasing number of separation logic tools.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103694", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matko", + "last_name": "Botinčan", + "institution": "University of Cambridge" + }, + { + "first_name": "Mike", + "last_name": "Dodds", + "institution": "University of Cambridge" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/BotincanDJ12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103670", + "title": "Probabilistic relational reasoning for differential privacy", + "abstract": "Differential privacy is a notion of confidentiality that protects the privacy of individuals while allowing useful computations on their private data. Deriving differential privacy guarantees for real programs is a difficult and error-prone task that calls for principled approaches and tool support. Approaches based on linear types and static analysis have recently emerged; however, an increasing number of programs achieve privacy using techniques that cannot be analyzed by these approaches. Examples include programs that aim for weaker, approximate differential privacy guarantees, programs that use the Exponential mechanism, and randomized programs that achieve differential privacy without using any standard mechanism. Providing support for reasoning about the privacy of such programs has been an open problem.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103670", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" + }, + { + "first_name": "Boris", + "last_name": "Köpf", + "institution": "IMDEA Software" + }, + { + "first_name": "Federico", + "last_name": "Olmedo", + "institution": "IMDEA Software" + }, + { + "first_name": "Santiago", + "last_name": "Zanella-Béguelin", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/popl/BartheKOB12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103721", + "title": "A type theory for probability density functions", + "abstract": "There has been great interest in creating probabilistic programming languages to simplify the coding of statistical tasks; however, there still does not exist a formal language that simultaneously provides (1) continuous probability distributions, (2) the ability to naturally express custom probabilistic models, and (3) probability density functions (PDFs). This collection of features is necessary for mechanizing fundamental statistical techniques. We formalize the first probabilistic language that exhibits these features, and it serves as a foundational framework for extending the ideas to more general languages. Particularly novel are our type system for absolutely continuous (AC) distributions (those which permit PDFs) and our PDF calculation procedure, which calculates PDF s for a large class of AC distributions. Our formalization paves the way toward the rigorous encoding of powerful statistical reformulations.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103721", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sooraj", + "last_name": "Bhat", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Ashish", + "last_name": "Agarwal", + "institution": "New York University" + }, + { + "first_name": "Richard", + "last_name": "Vuduc", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Alexander", + "last_name": "Gray", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/popl/BhatAVG12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103687", + "title": "An abstract interpretation framework for termination", + "abstract": "Proof, verification and analysis methods for termination all rely on two induction principles: (1) a variant function or induction on data ensuring progress towards the end and (2) some form of induction on the program structure. The abstract interpretation design principle is first illustrated for the design of new forward and backward proof, verification and analysis methods for safety. The safety collecting semantics defining the strongest safety property of programs is first expressed in a constructive fixpoint form. Safety proof and checking/verification methods then immediately follow by fixpoint induction. Static analysis of abstract safety properties such as invariance are constructively designed by fixpoint abstraction (or approximation) to (automatically) infer safety properties. So far, no such clear design principle did exist for termination so that the existing approaches are scattered and largely not comparable with each other.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103687", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/CousotC12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103717", + "title": "Clarifying and compiling C/C++ concurrency: from C++11 to POWER", + "abstract": "The upcoming C and C++ revised standards add concurrency to the languages, for the first time, in the form of a subtle *relaxed memory model* (the *C++11 model*). This aims to permit compiler optimisation and to accommodate the differing relaxed-memory behaviours of mainstream multiprocessors, combining simple semantics for most code with high-performance *low-level atomics* for concurrency libraries. In this paper, we first establish two simpler but provably equivalent models for C++11, one for the full language and another for the subset without consume operations. Subsetting further to the fragment without low-level atomics, we identify a subtlety arising from atomic initialisation and prove that, under an additional condition, the model is equivalent to sequential consistency for race-free programs.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103717", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Cambridge" + }, + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Cambridge" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/BattyMOSS12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103680", + "title": "Deciding choreography realizability", + "abstract": "Since software systems are becoming increasingly more concurrent and distributed, modeling and analysis of interactions among their components is a crucial problem. In several application domains, message-based communication is used as the interaction mechanism, and the communication contract among the components of the system is specified semantically as a state machine. In the service-oriented computing domain such communication contracts are called \"choreography\" specifications. A choreography specification identifies allowable ordering of message exchanges in a distributed system. A fundamental question about a choreography specification is determining its realizability, i.e., given a choreography specification, is it possible to build a distributed system that communicates exactly as the choreography specifies? Checking realizability of choreography specifications has been an open problem for several years and it was not known if this was a decidable problem. In this paper we give necessary and sufficient conditions for realizability of choreographies. We implemented the proposed realizability check and our experiments show that it can efficiently determine the realizability of 1) web service choreographies, 2) Singularity OS channel contracts, and 3) UML collaboration (communication) diagrams.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103680", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Samik", + "last_name": "Basu", + "institution": "Iowa State University" + }, + { + "first_name": "Tevfik", + "last_name": "Bultan", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Meriem", + "last_name": "Ouederni", + "institution": "Universidad de Málaga" + } + ], + "dblp_key": "conf/popl/BasuBO12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103705", + "title": "Programming with binders and indexed data-types", + "abstract": "We show how to combine a general purpose type system for an existing language with support for programming with binders and contexts by refining the type system of ML with a restricted form of dependent types where index objects are drawn from contextual LF. This allows the user to specify formal systems within the logical framework LF and index ML types with contextual LF objects. Our language design keeps the index language generic only requiring decidability of equality of the index language providing a modular design. To illustrate the elegance and effectiveness of our language, we give programs for closure conversion and normalization by evaluation.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103705", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Cave", + "institution": "McGill University" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "conf/popl/CaveP12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103693", + "title": "Verification of parameterized concurrent programs by modular reasoning about data and control", + "abstract": "In this paper, we consider the problem of verifying thread-state properties of multithreaded programs in which the number of active threads cannot be statically bounded. Our approach is based on decomposing the task into two modules, where one reasons about data and the other reasons about control. The data module computes thread-state invariants (e.g., linear constraints over global variables and local variables of one thread) using the thread interference information computed by the control module. The control module computes a representation of thread interference, as an incrementally constructed data flow graph, using the data invariants provided by the data module. These invariants are used to rule out patterns of thread interference that can not occur in a real program execution. The two modules are incorporated into a feedback loop, so that the abstractions of data and interference are iteratively coarsened as the algorithm progresses (that is, they become weaker) until a fixed point is reached. Our approach is sound and terminating, and applicable to programs with infinite state (e.g., unbounded integers) and unboundedly many threads. The verification method presented in this paper has been implemented into a tool, called Duet. We demonstrate the effectiveness of our technique by verifying properties of a selection of Linux device drivers using Duet, and also compare Duet with previous work on verification of parameterized Boolean program using the Boolean abstractions of these drivers.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103693", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/popl/FarzanK12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103659", + "title": "Message of thanks: on the receipt of the 2011 ACM SIGPLAN distinguished achievement award", + "abstract": "Share on Message of thanks: on the receipt of the 2011 ACM SIGPLAN distinguished achievement award Author: Tony Hoare Microsoft Research, Cambridge, United Kingdom Microsoft Research, Cambridge, United KingdomView Profile Authors Info & Claims POPL '12: Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 2012 Pages 3–6https://doi.org/10.1145/2103656.2103659Published:25 January 2012Publication History 1citation355DownloadsMetricsTotal Citations1Total Downloads355Last 12 Months5Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103659", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tony", + "last_name": "Hoare", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/Hoare12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103715", + "title": "Edit lenses", + "abstract": "A lens is a bidirectional transformation between a pair of connected data structures, capable of translating an edit on one structure into an appropriate edit on the other. Many varieties of lenses have been studied, but none, to date, has offered a satisfactory treatment of how edits are represented. Many foundational accounts only consider edits of the form \"overwrite the whole structure,\" leading to poor behavior in many situations by failing to track the associations between corresponding parts of the structures when elements are inserted and deleted in ordered lists, for example. Other theories of lenses do maintain these associations, either by annotating the structures themselves with change information or using auxiliary data structures, but every extant theory assumes that the entire original source structure is part of the information passed to the lens.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103715", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Hofmann", + "institution": "Ludwig-Maximilians-Universität München" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Daniel S.", + "last_name": "Wagner", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/HofmannPW12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103671", + "title": "Access permission contracts for scripting languages", + "abstract": "International audience", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103671", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Phillip", + "last_name": "Heidegger", + "institution": "University of Freiburg" + }, + { + "first_name": "Annette", + "last_name": "Bieniusa", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/popl/HeideggerBT12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103667", + "title": "Information effects", + "abstract": "Computation is a physical process which, like all other physical processes, is fundamentally reversible. From the notion of type isomorphisms, we derive a typed, universal, and reversible computational model in which information is treated as a linear resource that can neither be duplicated nor erased. We use this model as a semantic foundation for computation and show that the \"gap\" between conventional irreversible computation and logically reversible computation can be captured by a type-and-effect system. Our type-and-effect system is structured as an arrow metalanguage that exposes creation and erasure of information as explicit effect operations. Irreversible computations arise from interactions with an implicit information environment, thus making them a derived notion, much like open systems in Physics. We sketch several applications which can benefit from an explicit treatment of information effects, such as quantitative information-flow security and differential privacy.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103667", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roshan P.", + "last_name": "James", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/JamesS12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103689", + "title": "Playing in the grey area of proofs", + "abstract": "Interpolation is an important technique in verification and static analysis of programs. In particular, interpolants extracted from proofs of various properties are used in invariant generation and bounded model checking. A number of recent papers studies interpolation in various theories and also extraction of smaller interpolants from proofs. In particular, there are several algorithms for extracting of interpolants from so-called local proofs. The main contribution of this paper is a technique of minimising interpolants based on transformations of what we call the \"grey area\" of local proofs. Another contribution is a technique of transforming, under certain common conditions, arbitrary proofs into local ones.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103689", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kryštof", + "last_name": "Hoder", + "institution": "University of Manchester" + }, + { + "first_name": "Laura", + "last_name": "Kovács", + "institution": "TU Wien" + }, + { + "first_name": "Андрей", + "last_name": "Воронков", + "institution": "University of Manchester" + } + ], + "dblp_key": "conf/popl/HoderKV12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103663", + "title": "Towards a program logic for JavaScript", + "abstract": "JavaScript has become the most widely used language for client-side web programming. The dynamic nature of JavaScript makes understanding its code notoriously difficult, leading to buggy programs and a lack of adequate static-analysis tools. We believe that logical reasoning has much to offer JavaScript: a simple description of program behaviour, a clear understanding of module boundaries, and the ability to verify security contracts. We introduce a program logic for reasoning about a broad subset of JavaScript, including challenging features such as prototype inheritance and \"with\". We adapt ideas from separation logic to provide tractable reasoning about JavaScript code: reasoning about easy programs is easy; reasoning about hard programs is possible. We prove a strong soundness result. All libraries written in our subset and proved correct with respect to their specifications will be well-behaved, even when called by arbitrary JavaScript code.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103663", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + }, + { + "first_name": "Sergio", + "last_name": "Maffeis", + "institution": "Imperial College London" + }, + { + "first_name": "Gareth", + "last_name": "Smith", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/GardnerMS12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103707", + "title": "Meta-level features in an industrial-strength theorem prover", + "abstract": "The ACL2 theorem prover---the current incarnation of \"the\" Boyer-Moore theorem prover---is a theorem prover for an extension of a first-order, applicative subset of Common Lisp. The ACL2 system provides a useful specification and modeling language as well as a useful mechanical theorem proving environment. ACL2 is in use at several major microprocessor manufacturers to verify functional correctness of important components of commercial designs. This talk explores the design of ACL2 and the tradeoffs that have turned out to be pivotal to its success.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103707", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J. Strother", + "last_name": "Moore", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/popl/Moore12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103685", + "title": "A compiler and run-time system for network programming languages", + "abstract": "Software-defined networks (SDNs) are a new kind of network architecture in which a controller machine manages a distributed collection of switches by instructing them to install or uninstall packet-forwarding rules and report traffic statistics. The recently formed Open Networking Consortium, whose members include Google, Facebook, Microsoft, Verizon, and others, hopes to use this architecture to transform the way that enterprise and data center networks are implemented.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103685", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Monsanto", + "institution": "Princeton University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Rob", + "last_name": "Harrison", + "institution": "United States Military Academy" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/MonsantoFHW12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103698", + "title": "Algebraic foundations for effect-dependent optimisations", + "abstract": "We present a general theory of Gifford-style type and effect annotations, where effect annotations are sets of effects. Generality is achieved by recourse to the theory of algebraic effects, a development of Moggi's monadic theory of computational effects that emphasises the operations causing the effects at hand and their equational theory. The key observation is that annotation effects can be identified with operation symbols. We develop an annotated version of Levy's Call-by-Push-Value language with a kind of computations for every effect set; it can be thought of as a sequential, annotated intermediate language. We develop a range of validated optimisations (i.e., equivalences), generalising many existing ones and adding new ones. We classify these optimisations as structural, algebraic, or abstract: structural optimisations always hold; algebraic ones depend on the effect theory at hand; and abstract ones depend on the global nature of that theory (we give modularly-checkable sufficient conditions for their validity).", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103698", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Edinburgh" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/KammarP12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103691", + "title": "Run your research: on the effectiveness of lightweight mechanization", + "abstract": "Formal models serve in many roles in the programming language community. In its primary role, a model communicates the idea of a language design; the architecture of a language tool; or the essence of a program analysis. No matter which role it plays, however, a faulty model doesn't serve its purpose.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103691", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Casey", + "last_name": "Klein", + "institution": "Northwestern University" + }, + { + "first_name": "John", + "last_name": "Clements", + "institution": "California Polytechnic State University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northeastern University" + }, + { + "first_name": "Carl", + "last_name": "Eastlund", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Jay", + "last_name": "McCarthy", + "institution": "Brigham Young University" + }, + { + "first_name": "Jon", + "last_name": "Rafkind", + "institution": "University of Utah" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Northeastern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/popl/KleinCDEFFMRTF12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103665", + "title": "Higher-order functional reactive programming in bounded space", + "abstract": "Functional reactive programming (FRP) is an elegant and successful approach to programming reactive systems declaratively. The high levels of abstraction and expressivity that make FRP attractive as a programming model do, however, often lead to programs whose resource usage is excessive and hard to predict. In this paper, we address the problem of space leaks in discrete-time functional reactive programs. We present a functional reactive programming language that statically bounds the size of the dataflow graph a reactive program creates, while still permitting use of higher-order functions and higher-type streams such as streams of streams. We achieve this with a novel linear type theory that both controls allocation and ensures that all recursive definitions are well-founded.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103665", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/KrishnaswamiBH12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103675", + "title": "Constraints as control", + "abstract": "We present an extension of Scala that supports constraint programming over bounded and unbounded domains. The resulting language, Kaplan, provides the benefits of constraint programming while preserving the existing features of Scala. Kaplan integrates constraint and imperative programming by using constraints as an advanced control structure; the developers use the monadic 'for' construct to iterate over the solutions of constraints or branch on the existence of a solution. The constructs we introduce have simple semantics that can be understood as explicit enumeration of values, but are implemented more efficiently using symbolic reasoning. Kaplan programs can manipulate constraints at run-time, with the combined benefits of type-safe syntax trees and first-class functions. The language of constraints is a functional subset of Scala, supporting arbitrary recursive function definitions over algebraic data types, sets, maps, and integers.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103675", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ali Sinan", + "last_name": "Köksal", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Philippe", + "last_name": "Suter", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/KoksalKS12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103662", + "title": "Underspecified harnesses and interleaved bugs", + "abstract": "Static assertion checking of open programs requires setting up a precise harness to capture the environment assumptions. For instance, a library may require a file handle to be properly initialized before it is passed into it. A harness is used to set up or specify the appropriate preconditions before invoking methods from the program. In the absence of a precise harness, even the most precise automated static checkers are bound to report numerous false alarms. This often limits the adoption of static assertion checking in the hands of a user.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103662", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Saurabh", + "last_name": "Joshi", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/popl/JoshiLL12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103666", + "title": "The marriage of bisimulations and Kripke logical relations", + "abstract": "There has been great progress in recent years on developing effective techniques for reasoning about program equivalence in ML-like languages---that is, languages that combine features like higher-order functions, recursive types, abstract types, and general mutable references. Two of the most prominent types of techniques to have emerged are *bisimulations* and *Kripke logical relations (KLRs)*. While both approaches are powerful, their complementary advantages have led us and other researchers to wonder whether there is an essential tradeoff between them. Furthermore, both approaches seem to suffer from fundamental limitations if one is interested in scaling them to inter-language reasoning. In this paper, we propose *relation transition systems (RTSs)*, which marry together some of the most appealing aspects of KLRs and bisimulations. In particular, RTSs show how bisimulations' support for reasoning about recursive features via *coinduction* can be synthesized with KLRs' support for reasoning about local state via *state transition systems*. Moreover, we have designed RTSs to avoid the limitations of KLRs and bisimulations that preclude their generalization to inter-language reasoning. Notably, unlike KLRs, RTSs are transitively composable.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103666", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Georg", + "last_name": "Neis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/HurDNV12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103697", + "title": "Canonicity for 2-dimensional type theory", + "abstract": "Higher-dimensional dependent type theory enriches conventional one-dimensional dependent type theory with additional structure expressing equivalence of elements of a type. This structure may be employed in a variety of ways to capture rather coarse identifications of elements, such as a universe of sets considered modulo isomorphism. Equivalence must be respected by all families of types and terms, as witnessed computationally by a type-generic program. Higher-dimensional type theory has applications to code reuse for dependently typed programming, and to the formalization of mathematics. In this paper, we develop a novel judgemental formulation of a two-dimensional type theory, which enjoys a canonicity property: a closed term of boolean type is definitionally equal to true or false. Canonicity is a necessary condition for a computational interpretation of type theory as a programming language, and does not hold for existing axiomatic presentations of higher-dimensional type theory. The method of proof is a generalization of the NuPRL semantics, interpreting types as syntactic groupoids rather than equivalence relations.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103697", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/LicataH12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103711", + "title": "A rely-guarantee-based simulation for verifying concurrent program transformations", + "abstract": "Verifying program transformations usually requires proving that the resulting program (the target) refines or is equivalent to the original one (the source). However, the refinement relation between individual sequential threads cannot be preserved in general with the presence of parallel compositions, due to instruction reordering and the different granularities of atomic operations at the source and the target. On the other hand, the refinement relation defined based on fully abstract semantics of concurrent programs assumes arbitrary parallel environments, which is too strong and cannot be satisfied by many well-known transformations. In this paper, we propose a Rely-Guarantee-based Simulation (RGSim) to verify concurrent program transformations. The relation is parametrized with constraints of the environments that the source and the target programs may compose with. It considers the interference between threads and their environments, thus is less permissive than relations over sequential programs. It is compositional w.r.t. parallel compositions as long as the constraints are satisfied. Also, RGSim does not require semantics preservation under all environments, and can incorporate the assumptions about environments made by specific program transformations in the form of rely/guarantee conditions. We use RGSim to reason about optimizations and prove atomicity of concurrent objects. We also propose a general garbage collector verification framework based on RGSim, and verify the Boehm et al. concurrent mark-sweep GC.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103711", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Ming", + "last_name": "Fu", + "institution": "University of Science and Technology of China" + } + ], + "dblp_key": "conf/popl/LiangFF12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103673", + "title": "Recursive proofs for inductive tree data-structures", + "abstract": "We develop logical mechanisms and procedures to facilitate the verification of full functional properties of inductive tree data-structures using recursion that are sound, incomplete, but terminating. Our contribution rests in a new extension of first-order logic with recursive definitions called Dryad, a syntactical restriction on pre- and post-conditions of recursive imperative programs using Dryad, and a systematic methodology for accurately unfolding the footprint on the heap uncovered by the program that leads to finding simple recursive proofs using formula abstraction and calls to SMT solvers. We evaluate our methodology empirically and show that several complex tree data-structure algorithms can be checked against full functional specifications automatically, given pre- and post-conditions. This results in the first automatic terminating methodology for proving a wide variety of annotated algorithms on tree data-structures correct, including max-heaps, treaps, red-black trees, AVL trees, binomial heaps, and B-trees.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103673", + "conference_name": "POPL", + "authors": [ + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Andrei", + "last_name": "Ștefănescu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/MadhusudanQS12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103722", + "title": "A type system for borrowing permissions", + "abstract": "In object-oriented programming, unique permissions to object references are useful for checking correctness properties such as consistency of typestate and noninterference of concurrency. To be usable, unique permissions must be borrowed --- for example, one must be able to read a unique reference out of a field, use it for something, and put it back. While one can null out the field and later reassign it, this paradigm is ungainly and requires unnecessary writes, potentially hurting cache performance. Therefore, in practice borrowing must occur in the type system, without requiring memory updates. Previous systems support borrowing with external alias analysis and/or explicit programmer management of fractional permissions. While these approaches are powerful, they are also awkward and difficult for programmers to understand. We present an integrated language and type system with unique, immutable, and shared permissions, together with new local permissions that say that a reference may not be stored to the heap. Our system also includes change permissions such as unique>>unique and unique>>none that describe how permissions flow in and out of method formal parameters. Together, these features support common patterns of borrowing, including borrowing multiple local permissions from a unique reference and recovering the unique reference when the local permissions go out of scope, without any explicit management of fractions in the source language. All accounting of fractional permissions is done by the type system \"under the hood.\" We present the syntax and static and dynamic semantics of a formal core language and state soundness results. We also illustrate the utility and practicality of our design by using it to express several realistic examples.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103722", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karl", + "last_name": "Naden", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert L.", + "last_name": "Bocchino", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kevin", + "last_name": "Bierhoff", + "institution": "Two Sigma Investments (United States)" + } + ], + "dblp_key": "conf/popl/NadenBAB12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103714", + "title": "The ins and outs of gradual type inference", + "abstract": "Gradual typing lets programmers evolve their dynamically typed programs by gradually adding explicit type annotations, which confer benefits like improved performance and fewer run-time failures.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103714", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Stony Brook University" + }, + { + "first_name": "Avik", + "last_name": "Chaudhuri", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Basil", + "last_name": "Hosmer", + "institution": "Adobe Systems (United States)" + } + ], + "dblp_key": "conf/popl/RastogiCH12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103701", + "title": "Abstractions from tests", + "abstract": "We present a framework for leveraging dynamic analysis to find good abstractions for static analysis. A static analysis in our framework is parametrised. Our main insight is to directly and efficiently compute from a concrete trace, a necessary condition on the parameter configurations to prove a given query, and thereby prune the space of parameter configurations that the static analysis must consider. We provide constructive algorithms for two instance analyses in our framework: a flow- and context-sensitive thread-escape analysis and a flow- and context-insensitive points-to analysis. We show the efficacy of these analyses, and our approach, on six Java programs comprising two million bytecodes: the thread-escape analysis resolves 80% of queries on average, disproving 28% and proving 52%; the points-to analysis resolves 99% of queries on average, disproving 29% and proving 70%.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103701", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + }, + { + "first_name": "Ghila", + "last_name": "Castelnuovo", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/NaikYCS12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103678", + "title": "Defining code-injection attacks", + "abstract": "This paper shows that existing definitions of code-injection attacks (e.g., SQL-injection attacks) are flawed. The flaws make it possible for attackers to circumvent existing mechanisms, by supplying code-injecting inputs that are not recognized as such. The flaws also make it possible for benign inputs to be treated as attacks. After describing these flaws in conventional definitions of code-injection attacks, this paper proposes a new definition, which is based on whether the symbols input to an application get used as (normal-form) values in the application's output. Because values are already fully evaluated, they cannot be considered \"code\" when injected. This simple new definition of code-injection attacks avoids the problems of existing definitions, improves our understanding of how and when such attacks occur, and enables us to evaluate the effectiveness of mechanisms for mitigating such attacks.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103678", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Donald", + "last_name": "Ray", + "institution": "University of South Florida" + }, + { + "first_name": "Jay", + "last_name": "Ligatti", + "institution": "University of South Florida" + } + ], + "dblp_key": "conf/popl/RayL12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103695", + "title": "Syntactic control of interference for separation logic", + "abstract": "Separation Logic has witnessed tremendous success in recent years in reasoning about programs that deal with heap storage. Its success owes to the fundamental principle that one should keep separate areas of the heap storage separate in program reasoning. However, the way Separation Logic deals with program variables continues to be based on traditional Hoare Logic without taking any benefit of the separation principle. This has led to unwieldy proof rules suffering from lack of clarity as well as questions surrounding their soundness. In this paper, we extend the separation idea to the treatment of variables in Separation Logic, especially Concurrent Separation Logic, using the system of Syntactic Control of Interference proposed by Reynolds in 1978. We extend the original system with permission algebras, making it more powerful and able to deal with the issues of concurrent programs. The result is a streamined presentation of Concurrent Separation Logic, whose rules are memorable and soundness obvious. We also include a discussion of how the new rules impact the semantics and devise static analysis techniques to infer the required permissions automatically.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103695", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Uday S.", + "last_name": "Reddy", + "institution": "University of Birmingham" + }, + { + "first_name": "John", + "last_name": "Reynolds", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/ReddyR12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103683", + "title": "Programming languages for programmable networks", + "abstract": "Today's computer networks perform a bewildering array of tasks, from routing and access control, to traffic monitoring and load balancing. To support wireless users accessing services hosted in the cloud, enterprise and data-center networks are under increasing pressure to support client mobility, virtual-machine migration, resource isolation between cloud services, and energy-efficient operation. Yet, network administrators must configure the network through closed and proprietary interfaces to heterogeneous devices, such as routers, switches, firewalls, load balancers, network address translators, and intrusion detection systems. Not surprisingly, configuring these complex networks is expensive and error-prone, and innovation in network management proceeds at a snail's pace.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103683", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jennifer", + "last_name": "Rexford", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/Rexford12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103718", + "title": "A mechanized semantics for C++ object construction and destruction, with applications to resource management", + "abstract": "We present a formal operational semantics and its Coq mechanization for the C++ object model, featuring object construction and destruction, shared and repeated multiple inheritance, and virtual function call dispatch. These are key C++ language features for high-level system programming, in particular for predictable and reliable resource management. This paper is the first to present a formal mechanized account of the metatheory of construction and destruction in C++, and applications to popular programming techniques such as \"resource acquisition is initialization\". We also report on irregularities and apparent contradictions in the ISO C++03 and C++11 standards.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103718", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Gabriel Dos", + "last_name": "Reis", + "institution": "Texas A&M University" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/RamananandroRL12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103709", + "title": "Formalizing the LLVM intermediate representation for verified program transformations", + "abstract": "This paper presents Vellvm (verified LLVM), a framework for reasoning about programs expressed in LLVM's intermediate representation and transformations that operate on it. Vellvm provides a mechanized formal semantics of LLVM's intermediate representation, its type system, and properties of its SSA form. The framework is built using the Coq interactive theorem prover. It includes multiple operational semantics and proves relations among them to facilitate different reasoning styles and proof techniques.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103709", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yun", + "last_name": "Zhao", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Milo M. K.", + "last_name": "Martin", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/ZhaoNMZ12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103690", + "title": "Static and user-extensible proof checking", + "abstract": "Despite recent successes, large-scale proof development within proof assistants remains an arcane art that is extremely time-consuming. We argue that this can be attributed to two profound shortcomings in the architecture of modern proof assistants. The first is that proofs need to include a large amount of minute detail; this is due to the rigidity of the proof checking process, which cannot be extended with domain-specific knowledge. In order to avoid these details, we rely on developing and using tactics, specialized procedures that produce proofs. Unfortunately, tactics are both hard to write and hard to use, revealing the second shortcoming of modern proof assistants. This is because there is no static knowledge about their expected use and behavior. As has recently been demonstrated, languages that allow type-safe manipulation of proofs, like Beluga, Delphin and VeriML, can be used to partly mitigate this second issue, by assigning rich types to tactics. Still, the architectural issues remain. In this paper, we build on this existing work, and demonstrate two novel ideas: an extensible conversion rule and support for static proof scripts. Together, these ideas enable us to support both user-extensible proof checking, and sophisticated static checking of tactics, leading to a new point in the design space of future proof assistants. Both ideas are based on the interplay between a light-weight staging construct and the rich type information available.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103690", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Antonis", + "last_name": "Stampoulis", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/StampoulisS12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103702", + "title": "Sound predictive race detection in polynomial time", + "abstract": "Data races are among the most reliable indicators of programming errors in concurrent software. For at least two decades, Lamport's happens-before (HB) relation has served as the standard test for detecting races--other techniques, such as lockset-based approaches, fail to be sound, as they may falsely warn of races. This work introduces a new relation, causally-precedes (CP), which generalizes happens-before to observe more races without sacrificing soundness. Intuitively, CP tries to capture the concept of happens-before ordered events that must occur in the observed order for the program to observe the same values. What distinguishes CP from past predictive race detection approaches (which also generalize an observed execution to detect races in other plausible executions) is that CP-based race detection is both sound and of polynomial complexity. We demonstrate that the unique aspects of CP result in practical benefit. Applying CP to real-world programs, we successfully analyze server-level applications (e.g., Apache FtpServer) and show that traces longer than in past predictive race analyses can be analyzed in mere seconds to a few minutes. For these programs, CP race detection uncovers races that are hard to detect by repeated execution and HB race detection: a single run of CP race detection produces several races not discovered by 10 separate rounds of happens-before race detection.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103702", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Jacob", + "last_name": "Evans", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Caitlin", + "last_name": "Sadowski", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Jaeheon", + "last_name": "Yi", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/popl/SmaragdakisESYF12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103661", + "title": "Freefinement", + "abstract": "Freefinement is an algorithm that constructs a sound refinement calculus from a verification system under certain conditions. In this paper, a verification system is any formal system for establishing whether an inductively defined term, typically a program, satisfies a specification. Examples of verification systems include Hoare logics and type systems. Freefinement first extends the term language to include specification terms, and builds a verification system for the extended language that is a sound and conservative extension of the original system. The extended system is then transformed into a sound refinement calculus. The resulting refinement calculus can interoperate closely with the verification system - it is even possible to reuse and translate proofs between them. Freefinement gives a semantics to refinement at an abstract level: it associates each term of the extended language with a set of terms from the original language, and refinement simply reduces this set. The paper applies freefinement to a simple type system for the lambda calculus and also to a Hoare logic.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103661", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephan van", + "last_name": "Staden", + "institution": "ETH Zurich" + }, + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "Imperial College London" + }, + { + "first_name": "Bertrand", + "last_name": "Meyer", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/popl/StadenCM12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103674", + "title": "Symbolic finite state transducers: algorithms and applications", + "abstract": "Finite automata and finite transducers are used in a wide range of applications in software engineering, from regular expressions to specification languages. We extend these classic objects with symbolic alphabets represented as parametric theories. Admitting potentially infinite alphabets makes this representation strictly more general and succinct than classical finite transducers and automata over strings. Despite this, the main operations, including composition, checking that a transducer is single-valued, and equivalence checking for single-valued symbolic finite transducers are effective given a decision procedure for the background theory. We provide novel algorithms for these operations and extend composition to symbolic transducers augmented with registers. Our base algorithms are unusual in that they are nonconstructive, therefore, we also supply a separate model generation algorithm that can quickly find counterexamples in the case two symbolic finite transducers are not equivalent. The algorithms give rise to a complete decidable algebra of symbolic transducers. Unlike previous work, we do not need any syntactic restriction of the formulas on the transitions, only a decision procedure. In practice we leverage recent advances in satisfiability modulo theory (SMT) solvers. We demonstrate our techniques on four case studies, covering a wide range of applications. Our techniques can synthesize string pre-images in excess of 8,000 bytes in roughly a minute, and we find that our new encodings significantly outperform previous techniques in succinctness and speed of analysis.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103674", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Pieter", + "last_name": "Hooimeijer", + "institution": "University of Virginia" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dávid", + "last_name": "Molnár", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nikolaj", + "last_name": "Bjørner", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/VeanesHLMB12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103669", + "title": "A language for automatically enforcing privacy policies", + "abstract": "It is becoming increasingly important for applications to protect sensitive data. With current techniques, the programmer bears the burden of ensuring that the application's behavior adheres to policies about where sensitive values may flow. Unfortunately, privacy policies are difficult to manage because their global nature requires coordinated reasoning and enforcement. To address this problem, we describe a programming model that makes the system responsible for ensuring adherence to privacy policies. The programming model has two components: 1) core programs describing functionality independent of privacy concerns and 2) declarative, decentralized policies controlling how sensitive values are disclosed. Each sensitive value encapsulates multiple views; policies describe which views are allowed based on the output context. The system is responsible for automatically ensuring that outputs are consistent with the policies. We have implemented this programming model in a new functional constraint language named Jeeves. In Jeeves, sensitive values are introduced as symbolic variables and policies correspond to constraints that are resolved at output channels. We have implemented Jeeves as a Scala library using an SMT solver as a model finder. In this paper we describe the dynamic and static semantics of Jeeves and the properties about policy enforcement that the semantics guarantees. We also describe our experience implementing a conference management system and a social network.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103669", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean", + "last_name": "Yang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Kuat", + "last_name": "Yessenov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/YangYS12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103723", + "title": "Self-certification: bootstrapping certified typecheckers in F* with Coq", + "abstract": "Well-established dependently-typed languages like Agda and Coq provide reliable ways to build and check formal proofs. Several other dependently-typed languages such as Aura, ATS, Cayenne, Epigram, F*, F7, Fine, Guru, PCML5, and Ur also explore reliable ways to develop and verify programs. All these languages shine in their own regard, but their implementations do not themselves enjoy the degree of safety provided by machine-checked verification. We propose a general technique called self-certification that allows a typechecker for a suitably expressive language to be certified for correctness. We have implemented this technique for F*, a dependently typed language on the .NET platform. Self-certification involves implementing a typechecker for F* in F*, while using all the conveniences F* provides for the compiler-writer (e.g., partiality, effects, implicit conversions, proof automation, libraries). This typechecker is given a specification (in~F*) strong enough to ensure that it computes valid typing derivations. We obtain a typing derivation for the core typechecker by running it on itself, and we export it to Coq as a type-derivation certificate. By typechecking this derivation (in Coq) and applying the F* metatheory (also mechanized in Coq), we conclude that our type checker is correct. Once certified in this manner, the F* typechecker is emancipated from Coq.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103723", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/StrubSFC12", + "venue": "popl", + "year": 2012 + }, + { + "paper_id": "10.1145/2103656.2103710", + "title": "Randomized accuracy-aware program transformations for efficient approximate computations", + "abstract": "Despite the fact that approximate computations have come to dominate many areas of computer science, the field of program transformations has focused almost exclusively on traditional semantics-preserving transformations that do not attempt to exploit the opportunity, available in many computations, to acceptably trade off accuracy for benefits such as increased performance and reduced resource consumption.", + "date": "2012-01-24", + "link": "https://doi.org/10.1145/2103656.2103710", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zeyuan Allen", + "last_name": "Zhu", + "institution": "IIT@MIT" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "IIT@MIT" + }, + { + "first_name": "Jonathan A.", + "last_name": "Kelner", + "institution": "IIT@MIT" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "IIT@MIT" + } + ], + "dblp_key": "conf/popl/ZhuMKR12", + "venue": "popl", + "year": 2012 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2013.json b/data/pl_conferences/popl/2013.json new file mode 100644 index 0000000..c11579b --- /dev/null +++ b/data/pl_conferences/popl/2013.json @@ -0,0 +1,1333 @@ +[ + { + "paper_id": "10.1145/2429069.2429129", + "title": "Principled parsing for indentation-sensitive languages: revisiting landin's offside rule", + "abstract": "Several popular languages, such as Haskell, Python, and F#, use the indentation and layout of code as part of their syntax. Because context-free grammars cannot express the rules of indentation, parsers for these languages currently use ad hoc techniques to handle layout. These techniques tend to be low-level and operational in nature and forgo the advantages of more declarative specifications like context-free grammars. For example, they are often coded by hand instead of being generated by a parser generator.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429129", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/popl/Adams13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429078", + "title": "On the linear ranking problem for integer linear-constraint loops", + "abstract": "In this paper we study the complexity of the Linear Ranking problem: given a loop, described by linear constraints over a finite set of integer variables, is there a linear ranking function for this loop? While existence of such a function implies termination, this problem is not equivalent to termination. When the variables range over the rationals or reals, the Linear Ranking problem is known to be PTIME decidable. However, when they range over the integers, whether for single-path or multipath loops, the complexity of the Linear Ranking problem has not yet been determined. We show that it is coNP-complete. However, we point out some special cases of importance of PTIME complexity. We also present complete algorithms for synthesizing linear ranking functions, both for the general case and the special PTIME cases.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429078", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amir M.", + "last_name": "Ben-Amram", + "institution": "Academic College of Tel Aviv-Yafo" + }, + { + "first_name": "Samir", + "last_name": "Genaim", + "institution": "Universidad Complutense de Madrid" + } + ], + "dblp_key": "conf/popl/Ben-AmramG13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429085", + "title": "Quantitative abstraction refinement", + "abstract": "We propose a general framework for abstraction with respect to quantitative properties, such as worst-case execution time, or power consumption. Our framework provides a systematic way for counter-example guided abstraction refinement for quantitative properties. The salient aspect of the framework is that it allows anytime verification, that is, verification algorithms that can be stopped at any time (for example, due to exhaustion of memory), and report approximations that improve monotonically when the algorithms are given more time.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429085", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pavol", + "last_name": "Černý", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "conf/popl/CernyHR13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429099", + "title": "Library abstraction for C/C++ concurrency", + "abstract": "When constructing complex concurrent systems, abstraction is vital: programmers should be able to reason about concurrent libraries in terms of abstract specifications that hide the implementation details. Relaxed memory models present substantial challenges in this respect, as libraries need not provide sequentially consistent abstractions: to avoid unnecessary synchronisation, they may allow clients to observe relaxed memory effects, and library specifications must capture these.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429099", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Cambridge" + }, + { + "first_name": "Mike", + "last_name": "Dodds", + "institution": "University of York" + }, + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "Madrid Institute for Advanced Studies" + } + ], + "dblp_key": "conf/popl/BattyDG13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429077", + "title": "Cache and I/O efficent functional algorithms", + "abstract": "The widely studied I/O and ideal-cache models were developed to account for the large difference in costs to access memory at different levels of the memory hierarchy. Both models are based on a two level memory hierarchy with a fixed size primary memory(cache) of size M, an unbounded secondary memory organized in blocks of size B. The cost measure is based purely on the number of block transfers between the primary and secondary memory. All other operations are free. Many algorithms have been analyzed in these models and indeed these models predict the relative performance of algorithms much more accurately than the standard RAM model. The models, however, require specifying algorithms at a very low level requiring the user to carefully lay out their data in arrays in memory and manage their own memory allocation.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429077", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/BlellochH13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429101", + "title": "Deadlock-freedom-by-design: multiparty asynchronous global programming", + "abstract": "Over the last decade, global descriptions have been successfully employed for the verification and implementation of communicating systems, respectively as protocol specifications and choreographies. In this work, we bring these two practices together by proposing a purely-global programming model. We show a novel interpretation of asynchrony and parallelism in a global setting and develop a typing discipline that verifies choreographies against protocol specifications, based on multiparty sessions. Exploiting the nature of global descriptions, our type system defines a new class of deadlock-free concurrent systems (deadlock-freedom-by-design), provides type inference, and supports session mobility. We give a notion of Endpoint Projection (EPP) which generates correct entity code (as pi-calculus terms) from a choreography. Finally, we evaluate our approach by providing a prototype implementation for a concrete programming language and by applying it to some examples from multicore and service-oriented programming.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429101", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Carbone", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Fabrizio", + "last_name": "Montesi", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/popl/CarboneM13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429123", + "title": "Sigma*: symbolic learning of input-output specifications", + "abstract": "We present Sigma*, a novel technique for learning symbolic models of software behavior. Sigma* addresses the challenge of synthesizing models of software by using symbolic conjectures and abstraction. By combining dynamic symbolic execution to discover symbolic input-output steps of the programs and counterexample guided abstraction refinement to over-approximate program behavior, Sigma* transforms arbitrary source representation of programs into faithful input-output models. We define a class of stream filters---programs that process streams of data items---for which Sigma* converges to a complete model if abstraction refinement eventually builds up a sufficiently strong abstraction. In other words, Sigma* is complete relative to abstraction. To represent inferred symbolic models, we use a variant of symbolic transducers that can be effectively composed and equivalence checked. Thus, Sigma* enables fully automatic analysis of behavioral properties such as commutativity, reversibility and idempotence, which is useful for web sanitizer verification and stream programs compiler optimizations, as we show experimentally. We also show how models inferred by Sigma* can boost performance of stream programs by parallelized code generation.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429123", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matko", + "last_name": "Botinčan", + "institution": "University of Cambridge" + }, + { + "first_name": "Domagoj", + "last_name": "Babić", + "institution": "Menlo School" + } + ], + "dblp_key": "conf/popl/BotincanB13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429103", + "title": "The type discipline of behavioral separation", + "abstract": "We introduce the concept of behavioral separation as a general principle for disciplining interference in higher-order imperative concurrent programs, and present a type-based approach that systematically develops the concept in the context of an ML-like language extended with concurrency and synchronization primitives. Behavioral separation builds on notions originally introduced for behavioral type systems and separation logics, but shifts the focus from the separation of static program state properties towards the separation of dynamic usage behaviors of runtime values. Behavioral separation types specify how values may be safely used by client code, and can enforce fine-grained interference control disciplines while preserving compositionality, information hiding, and flexibility. We illustrate how our type system, even if based on a small set of general primitives, is already able to tackle fairly challenging program idioms, involving aliasing at various types, concurrency with first-class threads, manipulation of linked data structures, behavioral borrowing, and invariant-based separation.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429103", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luı́s", + "last_name": "Caires", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "João Costa", + "last_name": "Seco", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "conf/popl/CairesS13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429082", + "title": "Abstraction and invariance for algebraically indexed types", + "abstract": "Reynolds' relational parametricity provides a powerful way to reason about programs in terms of invariance under changes of data representation. A dazzling array of applications of Reynolds' theory exists, exploiting invariance to yield \"free theorems\", non-inhabitation results, and encodings of algebraic datatypes. Outside computer science, invariance is a common theme running through many areas of mathematics and physics. For example, the area of a triangle is unaltered by rotation or flipping. If we scale a triangle, then we scale its area, maintaining an invariant relationship between the two. The transformations under which properties are invariant are often organised into groups, with the algebraic structure reflecting the composability and invertibility of transformations.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429082", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Atkey", + "institution": "University of Strathclyde" + }, + { + "first_name": "Patricia", + "last_name": "Johann", + "institution": "University of Strathclyde" + }, + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/AtkeyJK13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429087", + "title": "Abstract conflict driven learning", + "abstract": "Modern satisfiability solvers implement an algorithm, called Conflict Driven Clause Learning, which combines search for a model with analysis of conflicts. We show that this algorithm can be generalised to solve the lattice-theoretic problem of determining if an additive transformer on a Boolean lattice is always bottom. Our generalised procedure combines overapproximations of greatest fixed points with underapproximation of least fixed points to obtain more precise results than computing fixed points in isolation. We generalise implication graphs used in satisfiability solvers to derive underapproximate transformers from overapproximate ones. Our generalisation provides a new method for static analysers that operate over non-distributive lattices to reason about properties that require disjunction.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429087", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vijay", + "last_name": "D’Silva", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Leopold", + "last_name": "Haller", + "institution": "University of Oxford" + }, + { + "first_name": "Daniel", + "last_name": "Kroening", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/DSilvaHK13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429075", + "title": "Copatterns: programming infinite structures by observations", + "abstract": "Inductive datatypes provide mechanisms to define finite data such as finite lists and trees via constructors and allow programmers to analyze and manipulate finite data via pattern matching. In this paper, we develop a dual approach for working with infinite data structures such as streams. Infinite data inhabits coinductive datatypes which denote greatest fixpoints. Unlike finite data which is defined by constructors we define infinite data by observations. Dual to pattern matching, a tool for analyzing finite data, we develop the concept of copattern matching, which allows us to synthesize infinite data. This leads to a symmetric language design where pattern matching on finite and infinite data can be mixed.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429075", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "Ludwig-Maximilians-Universität München" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + }, + { + "first_name": "David", + "last_name": "Thibodeau", + "institution": "McGill University" + }, + { + "first_name": "Anton", + "last_name": "Setzer", + "institution": "Swansea University" + } + ], + "dblp_key": "conf/popl/AbelPTS13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429083", + "title": "Static and dynamic semantics of NoSQL languages", + "abstract": "We present a calculus for processing semistructured data that spans differences of application area among several novel query languages, broadly categorized as \"NoSQL\". This calculus lets users define their own operators, capturing a wider range of data processing capabilities, whilst providing a typing precision so far typical only of primitive hard-coded operators. The type inference algorithm is based on semantic type checking, resulting in type information that is both precise, and flexible enough to handle structured and semistructured data. We illustrate the use of this calculus by encoding a large fragment of Jaql, including operations and iterators over JSON, embedded SQL expressions, and co-grouping, and show how the encoding directly yields a typing discipline for Jaql as it is, namely without the addition of any type definition or type annotation in the code.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429083", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Véronique", + "last_name": "Benzaken", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Sorbonne Paris Cité" + }, + { + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Laboratoire de Recherche en Informatique" + }, + { + "first_name": "Jérǒme", + "last_name": "Simèon", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/popl/BenzakenCNS13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429094", + "title": "Meta-theory à la carte", + "abstract": "Formalizing meta-theory, or proofs about programming languages, in a proof assistant has many well-known benefits. Unfortunately, the considerable effort involved in mechanizing proofs has prevented it from becoming standard practice. This cost can be amortized by reusing as much of existing mechanized formalizations as possible when building a new language or extending an existing one. One important challenge in achieving reuse is that the inductive definitions and proofs used in these formalizations are closed to extension. This forces language designers to cut and paste existing definitions and proofs in an ad-hoc manner and to expend considerable effort to patch up the results.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429094", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "National University of Singapore" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "Ghent University" + } + ], + "dblp_key": "conf/popl/DelawareOS13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429133", + "title": "Automatic detection of floating-point exceptions", + "abstract": "It is well-known that floating-point exceptions can be disastrous and writing exception-free numerical programs is very difficult. Thus, it is important to automatically detect such errors. In this paper, we present Ariadne, a practical symbolic execution system specifically designed and implemented for detecting floating-point exceptions. Ariadne systematically transforms a numerical program to explicitly check each exception triggering condition. Ariadne symbolically executes the transformed program using real arithmetic to find candidate real-valued inputs that can reach and trigger an exception. Ariadne converts each candidate input into a floating-point number, then tests it against the original program. In general, approximating floating-point arithmetic with real arithmetic can change paths from feasible to infeasible and vice versa. The key insight of this work is that, for the problem of detecting floating-point exceptions, this approximation works well in practice because, if one input reaches an exception, many are likely to, and at least one of them will do so over both floating-point and real arithmetic. To realize Ariadne, we also devised a novel, practical linearization technique to solve nonlinear constraints. We extensively evaluated Ariadne over 467 scalar functions in the widely used GNU Scientific Library (GSL). Our results show that Ariadne is practical and identifies a large number of real runtime exceptions in GSL. The GSL developers confirmed our preliminary findings and look forward to Ariadne's public release, which we plan to do in the near future.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429133", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Earl T.", + "last_name": "Barr", + "institution": "University of California, Davis" + }, + { + "first_name": "Thanh", + "last_name": "Vo", + "institution": "University of California, Davis" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/popl/BarrVLS13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429110", + "title": "Plan B: a buffered memory model for Java", + "abstract": "Recent advances in verification have made it possible to envision trusted implementations of real-world languages. Java with its type-safety and fully specified semantics would appear to be an ideal candidate; yet, the complexity of the translation steps used in production virtual machines have made it a challenging target for verifying compiler technology. One of Java's key innovations, its memory model, poses significant obstacles to such an endeavor. The Java Memory Model is an ambitious attempt at specifying the behavior of multithreaded programs in a portable, hardware agnostic, way. While experts have an intuitive grasp of the properties that the model should enjoy, the specification is complex and not well-suited for integration within a verifying compiler infrastructure. Moreover, the specification is given in an axiomatic style that is distant from the intuitive reordering-based reasonings traditionally used to justify or rule out behaviors, and ill suited to the kind of operational reasoning one would expect to employ in a compiler. This paper takes a step back, and introduces a Buffered Memory Model (BMM) for Java. We choose a pragmatic point in the design space sacrificing generality in favor of a model that is fully characterized in terms of the reorderings it allows, amenable to formal reasoning, and which can be efficiently applied to a specific hardware family, namely x86 multiprocessors. Although the BMM restricts the reorderings compilers are allowed to perform, it serves as the key enabling device to achieving a verification pathway from bytecode to machine instructions. Despite its restrictions, we show that it is backwards compatible with the Java Memory Model and that it does not cripple performance on TSO architectures.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429110", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Delphine", + "last_name": "Demange", + "institution": "École Normale Supérieure Paris-Saclay" + }, + { + "first_name": "Vincent", + "last_name": "Laporte", + "institution": "École Normale Supérieure Paris-Saclay" + }, + { + "first_name": "Lei", + "last_name": "Zhao", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/DemangeLZJPV13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429124", + "title": "Checking NFA equivalence with bisimulations up to congruence", + "abstract": "We introduce bisimulation up to congruence as a technique for proving language equivalence of non-deterministic finite automata. Exploiting this technique, we devise an optimisation of the classical algorithm by Hopcroft and Karp. We compare our approach to the recently introduced antichain algorithms, by analysing and relating the two underlying coinductive proof methods. We give concrete examples where we exponentially improve over antichains; experimental results moreover show non negligible improvements.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429124", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Filippo", + "last_name": "Bonchi", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Damien", + "last_name": "Pous", + "institution": "École Normale Supérieure de Lyon" + } + ], + "dblp_key": "conf/popl/BonchiP13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429086", + "title": "Inductive data flow graphs", + "abstract": "The correctness of a sequential program can be shown by the annotation of its control flow graph with inductive assertions. We propose inductive data flow graphs, data flow graphs with incorporated inductive assertions, as the basis of an approach to verifying concurrent programs. An inductive data flow graph accounts for a set of dependencies between program actions in interleaved thread executions, and therefore stands as a representation for the set of concurrent program traces which give rise to these dependencies. The approach first constructs an inductive data flow graph and then checks whether all program traces are represented. The size of the inductive data flow graph is polynomial in the number of data dependencies (in a sense that can be made formal); it does not grow exponentially in the number of threads unless the data dependencies do. The approach shifts the burden of the exponential explosion towards the check whether all program traces are represented, i.e., to a combinatorial problem (over finite graphs).", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429086", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "University of Toronto" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/popl/FarzanKP13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429071", + "title": "Engineering mathematics: the odd order theorem proof", + "abstract": "Even with the assistance of computer tools, the formalized de-scription and verification of research-level mathematics remains a daunting task, not least because of the talent with which mathema-ticians combine diverse theories to achieve their ends. By combin-ing tools and techniques from type theory, language design, and software engineering we have managed to capture enough of these practices to formalize the proof of the Odd Order theorem, a landmark result in Group Theory.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429071", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Georges", + "last_name": "Gonthier", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/Gonthier13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429117", + "title": "The principles and practice of probabilistic programming", + "abstract": "models, probabilistic programs Probabilities describe degrees of belief, and probabilistic inference describes rational reasoning under uncertainty. It is no wonder, then, that probabilistic models have exploded onto the scene of modern artificial intelligence, cognitive science, and applied statistics: these are all sciences of inference under uncertainty. But as probabilistic models have become more sophisticated, the tools to formally describe them and to perform probabilistic inference have wrestled with new complexity. Just as programming beyond the simplest algorithms requires tools for abstraction and composition, complex probabilistic modeling requires new progress in model representation—probabilistic programming languages. These languages provide compositional means for describing complex probability distributions; implementations of these languages provide generic inference engines: tools for performing efficient probabilistic", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429117", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Noah D.", + "last_name": "Goodman", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/Goodman13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429104", + "title": "Views: compositional reasoning for concurrent programs", + "abstract": "Compositional abstractions underly many reasoning principles for concurrent programs: the concurrent environment is abstracted in order to reason about a thread in isolation; and these abstractions are composed to reason about a program consisting of many threads. For instance, separation logic uses formulae that describe part of the state, abstracting the rest; when two threads use disjoint state, their specifications can be composed with the separating conjunction. Type systems abstract the state to the types of variables; threads may be composed when they agree on the types of shared variables.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429104", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Dinsdale-Young", + "institution": "Imperial College London" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/Dinsdale-YoungBGPY13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429114", + "title": "Fully abstract compilation to JavaScript", + "abstract": "Many tools allow programmers to develop applications in high-level languages and deploy them in web browsers via compilation to JavaScript. While practical and widely used, these compilers are ad hoc: no guarantee is provided on their correctness for whole programs, nor their security for programs executed within arbitrary JavaScript contexts. This paper presents a compiler with such guarantees. We compile an ML-like language with higher-order functions and references to JavaScript, while preserving all source program properties. Relying on type-based invariants and applicative bisimilarity, we show full abstraction: two programs are equivalent in all source contexts if and only if their wrapped translations are equivalent in all JavaScript contexts. We evaluate our compiler on sample programs, including a series of secure libraries.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429114", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Pierre-Évariste", + "last_name": "Dagand", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/FournetSCDSL13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429113", + "title": "Linear dependent types for differential privacy", + "abstract": "Differential privacy offers a way to answer queries about sensitive information while providing strong, provable privacy guarantees, ensuring that the presence or absence of a single individual in the database has a negligible statistical effect on the query's result. Proving that a given query has this property involves establishing a bound on the query's sensitivity---how much its result can change when a single record is added or removed.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429113", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Andreas", + "last_name": "Haeberlen", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Arjun", + "last_name": "Narayan", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/GaboardiHHNP13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429097", + "title": "From principles to programming languages (and back)", + "abstract": "No abstract available.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429097", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "conf/popl/Krishnamurthi13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429089", + "title": "The Lambda Lambda-Bar calculus: a dual calculus for unconstrained strategies", + "abstract": "We present a calculus which combines a simple, CCS-like representation of finite behaviors, with two dual binders λ and λ¯. Infinite behaviors are obtained through a syntactical fixed-point operator, which is used to give a translation of λ-terms. The duality of the calculus makes the roles of a function and its environment symmetrical. As usual, the environment is allowed to call a function at any given point, each time with a different argument. Dually, the function is allowed to answer any given call, each time with a different behavior. This grants terms in our language the power of functional references.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429089", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexis", + "last_name": "Goyet", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/popl/Goyet13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429134", + "title": "Subjective auxiliary state for coarse-grained concurrency", + "abstract": "From Owicki-Gries' Resource Invariants and Jones' Rely/Guarantee to modern variants based on Separation Logic, axiomatic logics for concurrency require auxiliary state to explicitly relate the effect of all threads to the global invariant on the shared resource. Unfortunately, auxiliary state gives the proof of an individual thread access to the auxiliaries of all other threads. This makes proofs sensitive to the global context, which prevents local reasoning and compositionality.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429134", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ruy", + "last_name": "Ley-Wild", + "institution": "IMDEA Software" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/popl/Ley-WildN13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429109", + "title": "Quantitative relaxation of concurrent data structures", + "abstract": "There is a trade-off between performance and correctness in implementing concurrent data structures. Better performance may be achieved at the expense of relaxing correctness, by redefining the semantics of data structures. We address such a redefinition of data structure semantics and present a systematic and formal framework for obtaining new data structures by quantitatively relaxing existing ones. We view a data structure as a sequential specification S containing all \"legal\" sequences over an alphabet of method calls. Relaxing the data structure corresponds to defining a distance from any sequence over the alphabet to the sequential specification: the k-relaxed sequential specification contains all sequences over the alphabet within distance k from the original specification. In contrast to other existing work, our relaxations are semantic (distance in terms of data structure states). As an instantiation of our framework, we present two simple yet generic relaxation schemes, called out-of-order and stuttering relaxation, along with several ways of computing distances. We show that the out-of-order relaxation, when further instantiated to stacks, queues, and priority queues, amounts to tolerating bounded out-of-order behavior, which cannot be captured by a purely syntactic relaxation (distance in terms of sequence manipulation, e.g. edit distance). We give concurrent implementations of relaxed data structures and demonstrate that bounded relaxations provide the means for trading correctness for performance in a controlled way. The relaxations are monotonic which further highlights the trade-off: increasing k increases the number of permitted sequences, which as we demonstrate can lead to better performance. Finally, since a relaxed stack or queue also implements a pool, we actually have new concurrent pool implementations that outperform the state-of-the-art ones.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429109", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Christoph", + "last_name": "Kirsch", + "institution": "University of Salzburg" + }, + { + "first_name": "Hannes", + "last_name": "Payer", + "institution": "University of Salzburg" + }, + { + "first_name": "Ali", + "last_name": "Sezgin", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Ana", + "last_name": "Sokolova", + "institution": "University of Salzburg" + } + ], + "dblp_key": "conf/popl/HenzingerKPSS13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429125", + "title": "Synthesis of biological models from mutation experiments", + "abstract": "Executable biology presents new challenges to formal methods. This paper addresses two problems that cell biologists face when developing formally analyzable models.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429125", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ali Sinan", + "last_name": "Köksal", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Yewen", + "last_name": "Pu", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Saurabh", + "last_name": "Srivastava", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Jasmin", + "last_name": "Fisher", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Nir", + "last_name": "Piterman", + "institution": "University of Leicester" + } + ], + "dblp_key": "conf/popl/KoksalPSBFP13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429131", + "title": "The ramifications of sharing in data structures", + "abstract": "Programs manipulating mutable data structures with intrinsic sharing present a challenge for modular verification. Deep aliasing inside data structures dramatically complicates reasoning in isolation over parts of these objects because changes to one part of the structure (say, the left child of a dag node) can affect other parts (the right child or some of its descendants) that may point into it. The result is that finding intuitive and compositional proofs of correctness is usually a struggle. We propose a compositional proof system that enables local reasoning in the presence of sharing.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429131", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aquinas", + "last_name": "Hobor", + "institution": "National University of Singapore" + }, + { + "first_name": "Jules", + "last_name": "Villard", + "institution": "University College London" + } + ], + "dblp_key": "conf/popl/HoborV13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429119", + "title": "A model-learner pattern for bayesian reasoning", + "abstract": "A Bayesian model is based on a pair of probability distributions, known as the prior and sampling distributions. A wide range of fundamental machine learning tasks, including regression, classification, clustering, and many others, can all be seen as Bayesian models. We propose a new probabilistic programming abstraction, a typed Bayesian model, which is based on a pair of probabilistic expressions for the prior and sampling distributions. A sampler for a model is an algorithm to compute synthetic data from its sampling distribution, while a learner for a model is an algorithm for probabilistic inference on the model. Models, samplers, and learners form a generic programming pattern for model-based inference. They support the uniform expression of common tasks including model testing, and generic compositions such as mixture models, evidence-based model averaging, and mixtures of experts. A formal semantics supports reasoning about model equivalence and implementation correctness. By developing a series of examples and three learner implementations based on exact inference, factor graphs, and Markov chain Monte Carlo, we demonstrate the broad applicability of this new programming pattern.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429119", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Mihhail", + "last_name": "Aizatulin", + "institution": "The Open University" + }, + { + "first_name": "Johannes", + "last_name": "Borgström", + "institution": "Uppsala University" + }, + { + "first_name": "Guillaume", + "last_name": "Claret", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Thore", + "last_name": "Graepel", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Claudio", + "last_name": "Russo", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/GordonABCGNRR13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429105", + "title": "High-level separation logic for low-level code", + "abstract": "Separation logic is a powerful tool for reasoning about structured, imperative programs that manipulate pointers. However, its application to unstructured, lower-level languages such as assembly language or machine code remains challenging. In this paper we describe a separation logic tailored for this purpose that we have applied to x86 machine-code programs.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429105", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jonas Braband", + "last_name": "Jensen", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/JensenBK13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429093", + "title": "The power of parameterization in coinductive proof", + "abstract": "Coinduction is one of the most basic concepts in computer science. It is therefore surprising that the commonly-known lattice-theoretic accounts of the principles underlying coinductive proofs are lacking in two key respects: they do not support compositional reasoning (i.e. breaking proofs into separate pieces that can be developed in isolation), and they do not support incremental reasoning (i.e. developing proofs interactively by starting from the goal and generalizing the coinduction hypothesis repeatedly as necessary).", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429093", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Georg", + "last_name": "Neis", + "institution": "Saarland University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Society" + } + ], + "dblp_key": "conf/popl/HurNDV13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429115", + "title": "Towards fully automatic placement of security sanitizers and declassifiers", + "abstract": "A great deal of research on sanitizer placement, sanitizer correctness, checking path validity, and policy inference, has been done in the last five to ten years, involving type systems, static analysis and runtime monitoring and enforcement. However, in pretty much all work thus far, the burden of sanitizer placement has fallen on the developer. However, sanitizer placement in large-scale applications is difficult, and developers are likely to make errors, and thus create security vulnerabilities.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429115", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/popl/LivshitsC13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429107", + "title": "How languages can save distributed computing", + "abstract": "No abstract available.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429107", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Myers13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429073", + "title": "Full abstraction for nominal Scott domains", + "abstract": "We develop a domain theory within nominal sets and present programming language constructs and results that can be gained from this approach. The development is based on the concept of orbit-finite subset, that is, a subset of a nominal sets that is both finitely supported and contained in finitely many orbits. This concept appears prominently in the recent research programme of Bojanczyk et al. on automata over infinite languages, and our results establish a connection between their work and a characterisation of topological compactness discovered, in a quite different setting, by Winskel and Turner as part of a nominal domain theory for concurrency. We use this connection to derive a notion of Scott domain within nominal sets. The functionals for existential quantification over names and `definite description' over names turn out to be compact in the sense appropriate for nominal Scott domains. Adding them, together with parallel-or, to a programming language for recursively defined higher-order functions with name abstraction and locally scoped names, we prove a full abstraction result for nominal Scott domains analogous to Plotkin's classic result about PCF and conventional Scott domains: two program phrases have the same observable operational behaviour in all contexts if and only if they denote equal elements of the nominal Scott domain model. This is the first full abstraction result we know of for higher-order functions with local names that uses a domain theory based on ordinary extensional functions, rather than using the more intensional approach of game semantics.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429073", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steffen", + "last_name": "Lösch", + "institution": "University of Cambridge" + }, + { + "first_name": "Andrew M.", + "last_name": "Pitts", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/LoschP13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429100", + "title": "Fault tolerance via idempotence", + "abstract": "Building distributed services and applications is challenging due to the pitfalls of distribution such as process and communication failures. A natural solution to these problems is to detect potential failures, and retry the failed computation and/or resend messages. Ensuring correctness in such an environment requires distributed services and applications to be idempotent.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429100", + "conference_name": "POPL", + "authors": [ + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Kapil", + "last_name": "Vaswani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/RamalingamV13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429090", + "title": "The geometry of types", + "abstract": "We show that time complexity analysis of higher-order functional programs can be effectively reduced to an arguably simpler (although computationally equivalent) verification problem, namely checking first-order inequalities for validity. This is done by giving an efficient inference algorithm for linear dependent types which, given a PCF term, produces in output both a linear dependent type and a cost expression for the term, together with a set of proof obligations. Actually, the output type judgement is derivable iff all proof obligations are valid. This, coupled with the already known relative completeness of linear dependent types, ensures that no information is lost, i.e., that there are no false positives or negatives. Moreover, the procedure reflects the difficulty of the original problem: simple PCF terms give rise to sets of proof obligations which are easy to solve. The latter can then be put in a format suitable for automatic or semi-automatic verification by external solvers. Ongoing experimental evaluation has produced encouraging results, which are briefly presented in the paper.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429090", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Barbara", + "last_name": "Petit", + "institution": "University of Bologna" + } + ], + "dblp_key": "conf/popl/LagoP13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429079", + "title": "Advanced automata minimization", + "abstract": "International audience", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429079", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard", + "last_name": "Mayr", + "institution": "University of Edinburgh" + }, + { + "first_name": "Lorenzo", + "last_name": "Clemente", + "institution": "Université de Bordeaux" + } + ], + "dblp_key": "conf/popl/MayrC13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429120", + "title": "Hyperstream processing systems: nonstandard modeling of continuous-time signals", + "abstract": "We exploit the apparent similarity between (discrete-time) stream processing and (continuous-time) signal processing and transfer a deductive verification framework from the former to the latter. Our development is based on rigorous semantics that relies on nonstandard analysis (NSA).", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429120", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kohei", + "last_name": "Suenaga", + "institution": "Kyoto University" + }, + { + "first_name": "Hiroyoshi", + "last_name": "Sekine", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ichiro", + "last_name": "Hasuo", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/SuenagaSH13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429074", + "title": "The sequential semantics of producer effect systems", + "abstract": "Effects are fundamental to programming languages. Even the lambda calculus has effects, and consequently the two famous evaluation strategies produce different semantics. As such, much research has been done to improve our understanding of effects. Since Moggi introduced monads for his computational lambda calculus, further generalizations have been designed to formalize increasingly complex computational effects, such as indexed monads followed by layered monads followed by parameterized monads. This succession prompted us to determine the most general formalization possible. In searching for this formalization we came across many surprises, such as the insufficiencies of arrows, as well as many unexpected insights, such as the importance of considering an effect as a small component of a whole system rather than just an isolated feature. In this paper we present our semantic formalization for producer effect systems, which we call a productor, and prove its maximal generality by focusing on only sequential composition of effectful computations, consequently guaranteeing that the existing monadic techniques are specializations of productors.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429074", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/Tate13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429095", + "title": "A theorem prover for Boolean BI", + "abstract": "While separation logic is acknowledged as an enabling technology for large-scale program verification, most of the existing verification tools use only a fragment of separation logic that excludes separating implication. As the first step towards a verification tool using full separation logic, we develop a nested sequent calculus for Boolean BI (Bunched Implications), the underlying theory of separation logic, as well as a theorem prover based on it. A salient feature of our nested sequent calculus is that its sequent may have not only smaller child sequents but also multiple parent sequents, thus producing a graph structure of sequents instead of a tree structure. Our theorem prover is based on backward search in a refinement of the nested sequent calculus in which weakening and contraction are built into all the inference rules. We explain the details of designing our theorem prover and provide empirical evidence of its practicality.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429095", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jong‐Hyun", + "last_name": "Park", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Jeongbong", + "last_name": "Seo", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Sungwoo", + "last_name": "Park", + "institution": "Pohang University of Science and Technology" + } + ], + "dblp_key": "conf/popl/ParkSP13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429128", + "title": "Optimizing data structures in high-level programs: new directions for extensible compilers based on staging", + "abstract": "High level data structures are a cornerstone of modern programming and at the same time stand in the way of compiler optimizations. In order to reason about user- or library-defined data structures compilers need to be extensible. Common mechanisms to extend compilers fall into two categories. Frontend macros, staging or partial evaluation systems can be used to programmatically remove abstraction and specialize programs before they enter the compiler. Alternatively, some compilers allow extending the internal workings by adding new transformation passes at different points in the compile chain or adding new intermediate representation (IR) types. None of these mechanisms alone is sufficient to handle the challenges posed by high level data structures. This paper shows a novel way to combine them to yield benefits that are greater than the sum of the parts.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429128", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Arvind K.", + "last_name": "Sujeeth", + "institution": "Stanford University" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Kevin J.", + "last_name": "Brown", + "institution": "Stanford University" + }, + { + "first_name": "Vojin", + "last_name": "Jovanović", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "HyoukJoong", + "last_name": "Lee", + "institution": "Palo Alto University" + }, + { + "first_name": "Manohar", + "last_name": "Jonnalagedda", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/RompfSABJLJOO13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429111", + "title": "Logical relations for fine-grained concurrency", + "abstract": "Fine-grained concurrent data structures (or FCDs) reduce the granularity of critical sections in both time and space, thus making it possible for clients to access different parts of a mutable data structure in parallel. However, the tradeoff is that the implementations of FCDs are very subtle and tricky to reason about directly. Consequently, they are carefully designed to be contextual refinements of their coarse-grained counterparts, meaning that their clients can reason about them as if all access to them were sequentialized.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429111", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Northeastern University" + }, + { + "first_name": "Jacob", + "last_name": "Thamsborg", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/TuronTABD13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429132", + "title": "Complete instantiation-based interpolation", + "abstract": "Craig interpolation has been a valuable tool for formal methods with interesting applications in program analysis and verification. Modern SMT solvers implement interpolation procedures for the theories that are most commonly used in these applications. However, many application-specific theories remain unsupported, which limits the class of problems to which interpolation-based techniques apply. In this paper, we present a generic framework to build new interpolation procedures via reduction to existing interpolation procedures. We consider the case where an application-specific theory can be formalized as an extension of a base theory with additional symbols and axioms. Our technique uses finite instantiation of the extension axioms to reduce an interpolation problem in the theory extension to one in the base theory. We identify a model-theoretic criterion that allows us to detect the cases where our technique is complete. We discuss specific theories that are relevant in program verification and that satisfy this criterion. In particular, we obtain complete interpolation procedures for theories of arrays and linked lists. The latter is the first complete interpolation procedure for a theory that supports reasoning about complex shape properties of heap-allocated data structures. We have implemented this procedure in a prototype on top of existing SMT solvers and used it to automatically infer loop invariants of list-manipulating programs.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429132", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nishant", + "last_name": "Totla", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "conf/popl/TotlaW13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429091", + "title": "Universal properties of impure programming languages", + "abstract": "We investigate impure, call-by-value programming languages. Our first language only has variables and let-binding. Its equational theory is a variant of Lambek's theory of multicategories that omits the commutativity axiom.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429091", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Cambridge" + }, + { + "first_name": "Paul Blain", + "last_name": "Levy", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/popl/StatonL13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429081", + "title": "Automating relatively complete verification of higher-order functional programs", + "abstract": "We present an automated approach to relatively completely verifying safety (i.e., reachability) property of higher-order functional programs. Our contribution is two-fold. First, we extend the refinement type system framework employed in the recent work on (incomplete) automated higher-order verification by drawing on the classical work on relatively complete \"Hoare logic like\" program logic for higher-order procedural languages. Then, by adopting the recently proposed techniques for solving constraints over quantified first-order logic formulas, we develop an automated type inference method for the type system, thereby realizing an automated relatively complete verification of higher-order programs.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429081", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Nagoya University" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/UnnoTK13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429127", + "title": "Sub-polyhedral scheduling using (unit-)two-variable-per-inequality polyhedra", + "abstract": "International audience", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429127", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ramakrishna", + "last_name": "Upadrasta", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/UpadrastaC13", + "venue": "popl", + "year": 2013 + }, + { + "paper_id": "10.1145/2429069.2429121", + "title": "HALO: haskell to logic through denotational semantics", + "abstract": "Even well-typed programs can go wrong in modern functional languages, by encountering a pattern-match failure, or simply returning the wrong answer. An increasingly-popular response is to allow programmers to write contracts that express semantic properties, such as crash-freedom or some useful post-condition. We study the static verification of such contracts. Our main contribution is a novel translation to first-order logic of both Haskell programs, and contracts written in Haskell, all justified by denotational semantics. This translation enables us to prove that functions satisfy their contracts using an off-the-shelf first-order logic theorem prover.", + "date": "2013-01-22", + "link": "https://doi.org/10.1145/2429069.2429121", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Dan", + "last_name": "Rosén", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/VytiniotisJCR13", + "venue": "popl", + "year": 2013 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2014.json b/data/pl_conferences/popl/2014.json new file mode 100644 index 0000000..cf90d68 --- /dev/null +++ b/data/pl_conferences/popl/2014.json @@ -0,0 +1,1672 @@ +[ + { + "paper_id": "10.1145/2535838.2535863", + "title": "Counter-factual typing for debugging type errors", + "abstract": "Changing a program in response to a type error plays an important part in modern software development. However, the generation of good type error messages remains a problem for highly expressive type systems. Existing approaches often suffer from a lack of precision in locating errors and proposing remedies. Specifically, they either fail to locate the source of the type error consistently, or they report too many potential error locations. Moreover, the change suggestions offered are often incorrect. This makes the debugging process tedious and ineffective.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535863", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "Oregon State University" + }, + { + "first_name": "Martin", + "last_name": "Erwig", + "institution": "Oregon State University" + } + ], + "dblp_key": "conf/popl/0008E14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2537849", + "title": "Modular reasoning about concurrent higher-order imperative programs", + "abstract": "No abstract available.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2537849", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/Birkedal14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535867", + "title": "From parametricity to conservation laws, via Noether's theorem", + "abstract": "Invariance is of paramount importance in programming languages and in physics. In programming languages, John Reynolds' theory of relational parametricity demonstrates that parametric polymorphic programs are invariant under change of data representation, a property that yields \"free\" theorems about programs just from their types. In physics, Emmy Noether showed that if the action of a physical system is invariant under change of coordinates, then the physical system has a conserved quantity: a quantity that remains constant for all time. Knowledge of conserved quantities can reveal deep properties of physical systems. For example, the conservation of energy is by Noether's theorem a consequence of a system's invariance under time-shifting.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535867", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Atkey", + "institution": "" + } + ], + "dblp_key": "conf/popl/Atkey14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2537851", + "title": "The essence of Reynolds", + "abstract": "John Reynolds (1935-2013) was a pioneer of programming languages research. In this paper we pay tribute to the man, his ideas, and his influence.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2537851", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Brookes", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Uday S.", + "last_name": "Reddy", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/popl/BrookesOR14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535875", + "title": "Battery transition systems", + "abstract": "The analysis of the energy consumption of software is an important goal for quantitative formal methods. Current methods, using weighted transition systems or energy games, model the energy source as an ideal resource whose status is characterized by one number, namely the amount of remaining energy. Real batteries, however, exhibit behaviors that can deviate substantially from an ideal energy resource. Based on a discretization of a standard continuous battery model, we introduce {\\em battery transition systems}. In this model, a battery is viewed as consisting of two parts -- the available-charge tank and the bound-charge tank. Any charge or discharge is applied to the available-charge tank. Over time, the energy from each tank diffuses to the other tank.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535875", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Udi", + "last_name": "Boker", + "institution": "Reichman University" + }, + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "conf/popl/BokerHR14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535847", + "title": "Probabilistic relational verification for cryptographic implementations", + "abstract": "International audience", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535847", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Research Centre Inria Sophia Antipolis - Méditerranée" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "IMDEA Software" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Santiago", + "last_name": "Zanella-Béguelin", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/BartheFGSSB14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535852", + "title": "A relationally parametric model of dependent type theory", + "abstract": "Reynolds' theory of relational parametricity captures the invariance of polymorphically typed programs under change of data representation. Reynolds' original work exploited the typing discipline of the polymorphically typed lambda-calculus System F, but there is now considerable interest in extending relational parametricity to type systems that are richer and more expressive than that of System F.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535852", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robert", + "last_name": "Atkey", + "institution": "" + }, + { + "first_name": "Neil", + "last_name": "Ghani", + "institution": "University of Strathclyde" + }, + { + "first_name": "Patricia", + "last_name": "Johann", + "institution": "Appalachian State University" + } + ], + "dblp_key": "conf/popl/AtkeyGJ14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535869", + "title": "Abstract effects and proof-relevant logical relations", + "abstract": "We give a denotational semantics for a region-based effect system that supports type abstraction in the sense that only externally visible effects need to be tracked: non-observable internal modifications, such as the reorganisation of a search tree or lazy initialisation, can count as 'pure' or 'read only'. This 'fictional purity' allows clients of a module to validate soundly more effect-based program equivalences than would be possible with previous semantics. Our semantics uses a novel variant of logical relations that maps types not merely to partial equivalence relations on values, as is commonly done, but rather to a proof-relevant generalisation thereof, namely setoids. The objects of a setoid establish that values inhabit semantic types, whilst its morphisms are understood as proofs of semantic equivalence. The transition to proof-relevance solves twoawkward problems caused by naïve use of existential quantification in Kripke logical relations, namely failure of admissibility and spurious functional dependencies.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535869", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Martin", + "last_name": "Hofmann", + "institution": "LMU Klinikum" + }, + { + "first_name": "Vivek", + "last_name": "Nigam", + "institution": "Universidade Federal da Paraíba" + } + ], + "dblp_key": "conf/popl/Benton0N14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535839", + "title": "A verified information-flow architecture", + "abstract": "SAFE is a clean-slate design for a highly secure computer system, with pervasive mechanisms for tracking and limiting information flows. At the lowest level, the SAFE hardware supports fine-grained programmable tags, with efficient and flexible propagation and combination of tags as instructions are executed. The operating system virtualizes these generic facilities to present an information-flow abstract machine that allows user programs to label sensitive data with rich confidentiality policies. We present a formal, machine-checked model of the key hardware and software mechanisms used to control information flow in SAFE and an end-to-end proof of noninterference for this model.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535839", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Nathan", + "last_name": "Collins", + "institution": "Portland State University" + }, + { + "first_name": "André", + "last_name": "DeHon", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Delphine", + "last_name": "Demange", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "State Key Laboratory of Cryptology" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "Harvard University Press" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Randy", + "last_name": "Pollack", + "institution": "Harvard University Press" + }, + { + "first_name": "Andrew", + "last_name": "Tolmach", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/popl/AmorimCDDHPPPT14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535877", + "title": "Verifying eventual consistency of optimistic replication systems", + "abstract": "We address the verification problem of eventual consistency of optimistic replication systems. Such systems are typically used to implement distributed data structures over large scale networks. We introduce a formal definition of eventual consistency that applies to a wide class of existing implementations, including the ones using speculative executions. Then, we reduce the problem of checking eventual consistency to reachability and model checking problems. This reduction enables the use of existing verification tools for message-passing programs in the context of verifying optimistic replication systems. Furthermore, we derive from these reductions decision procedures for checking eventual consistency of systems implemented as finite-state programs communicating through unbounded unordered channels. Categories and Subject Descriptors Theory of Computation [Log-ics and meanings of programs]: General Keywords message passing concurrency, model checking, static program analysis 1.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535877", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Sorbonne Paris Cité" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Université Paris Cité" + }, + { + "first_name": "Jad", + "last_name": "Hamza", + "institution": "Sorbonne Paris Cité" + } + ], + "dblp_key": "conf/popl/BouajjaniEH14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535862", + "title": "NetkAT: semantic foundations for networks", + "abstract": "Recent years have seen growing interest in high-level languages for programming networks. But the design of these languages has been largely ad hoc, driven more by the needs of applications and the capabilities of network hardware than by foundational principles. The lack of a semantic foundation has left language designers with little guidance in determining how to incorporate new features, and programmers without a means to reason precisely about their code.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535862", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Carolyn Jane", + "last_name": "Anderson", + "institution": "Swarthmore College" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Jean-Baptiste", + "last_name": "Jeannin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Cole", + "last_name": "Schlesinger", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/AndersonFGJKSW14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535886", + "title": "A nonstandard standardization theorem", + "abstract": "Standardization is a fundamental notion for connecting programming languages and rewriting calculi. Since both programming languages and calculi rely on substitution for defining their dynamics, explicit substitutions (ES) help further close the gap between theory and practice.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535886", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Eduardo", + "last_name": "Bonelli", + "institution": "National University of Quilmes" + }, + { + "first_name": "Delia", + "last_name": "Kesner", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Carlos", + "last_name": "Lombardi", + "institution": "National University of Quilmes" + } + ], + "dblp_key": "conf/popl/AccattoliBKL14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535876", + "title": "A trusted mechanised JavaScript specification", + "abstract": "JavaScript is the most widely used web language for client-side applications. Whilst the development of JavaScript was initially just led by implementation, there is now increasing momentum behind the ECMA standardisation process. The time is ripe for a formal, mechanised specification of JavaScript, to clarify ambiguities in the ECMA standards, to serve as a trusted reference for high-level language compilation and JavaScript implementations, and to provide a platform for high-assurance proofs of language properties.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535876", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Bodin", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Daniele", + "last_name": "Filaretti", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + }, + { + "first_name": "Sergio", + "last_name": "Maffeis", + "institution": "Imperial College London" + }, + { + "first_name": "Daiva", + "last_name": "Naudžiūnienė", + "institution": "Imperial College London" + }, + { + "first_name": "Alan", + "last_name": "Schmitt", + "institution": "Centre Inria de l'Université de Rennes" + }, + { + "first_name": "Gareth", + "last_name": "Smith", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/BodinCFGMNSS14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535845", + "title": "Optimal dynamic partial order reduction", + "abstract": "Stateless model checking is a powerful technique for program verification, which however suffers from an exponential growth in the number of explored executions. A successful technique for reducing this number, while still maintaining complete coverage, is Dynamic Partial Order Reduction (DPOR). We present a new DPOR algorithm, which is the first to be provably optimal in that it always explores the minimal number of executions. It is based on a novel class of sets, called source sets, which replace the role of persistent sets in previous algorithms. First, we show how to modify an existing DPOR algorithm to work with source sets, resulting in an efficient and simple to implement algorithm. Second, we extend this algorithm with a novel mechanism, called wakeup trees, that allows to achieve optimality. We have implemented both algorithms in a stateless model checking tool for Erlang programs. Experiments show that source sets significantly increase the performance and that wakeup trees incur only a small overhead in both time and space.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535845", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Stavros", + "last_name": "Aronis", + "institution": "Uppsala University" + }, + { + "first_name": "Bengt", + "last_name": "Jönsson", + "institution": "Uppsala University" + }, + { + "first_name": "Konstantinos", + "last_name": "Sagonas", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/popl/AbdullaAJS14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535860", + "title": "A constraint-based approach to solving games on infinite graphs", + "abstract": "We present a constraint-based approach to computing winning strategies in two-player graph games over the state space of infinite-state programs. Such games have numerous applications in program verification and synthesis, including the synthesis of infinite-state reactive programs and branching-time verification of infinite-state programs. Our method handles games with winning conditions given by safety, reachability, and general Linear Temporal Logic (LTL) properties. For each property class, we give a deductive proof rule that --- provided a symbolic representation of the game players --- describes a winning strategy for a particular player. Our rules are sound and relatively complete. We show that these rules can be automated by using an off-the-shelf Horn constraint solver that supports existential quantification in clause heads. The practical promise of the rules is demonstrated through several case studies, including a challenging \"Cinderella-Stepmother game\" that allows infinite alternation of discrete and continuous choices by two players, as well as examples derived from prior work on program repair and synthesis.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535860", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tewodros A.", + "last_name": "Beyene", + "institution": "" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + }, + { + "first_name": "Corneliu", + "last_name": "Popeea", + "institution": "" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/BeyeneCPR14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535853", + "title": "Bias-variance tradeoffs in program analysis", + "abstract": "It is often the case that increasing the precision of a program analysis leads to worse results. It is our thesis that this phenomenon is the result of fundamental limits on the ability to use precise abstract domains as the basis for inferring strong invariants of programs. We show that bias-variance tradeoffs, an idea from learning theory, can be used to explain why more precise abstractions do not necessarily lead to better results and also provides practical techniques for coping with such limitations. Learning theory captures precision using a combinatorial quantity called the VC dimension. We compute the VC dimension for different abstractions and report on its usefulness as a precision metric for program analyses. We evaluate cross validation, a technique for addressing bias-variance tradeoffs, on an industrial strength program verification tool called YOGI. The tool produced using cross validation has significantly better running time, finds new defects, and has fewer time-outs than the current production version. Finally, we make some recommendations for tackling bias-variance tradeoffs in program analysis.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535853", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/0001NA14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535844", + "title": "Parametric completeness for separation theories", + "abstract": "In this paper, we close the logical gap between provability in the logic BBI, which is the propositional basis for separation logic, and validity in an intended class of separation models, as employed in applications of separation logic such as program verification. An intended class of separation models is usually specified by a collection of axioms describing the specific model properties that are expected to hold, which we call a separation theory.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535844", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J G.", + "last_name": "Brotherston", + "institution": "University College London" + }, + { + "first_name": "Jules", + "last_name": "Villard", + "institution": "University College London" + } + ], + "dblp_key": "conf/popl/BrotherstonV14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535858", + "title": "Consistency analysis of decision-making programs", + "abstract": "Applications in many areas of computing make discrete decisions under uncertainty, for reasons such as limited numerical precision in calculations and errors in sensor-derived inputs. As a result, individual decisions made by such programs may be nondeterministic, and lead to contradictory decisions at different points of an execution. This means that an otherwise correct program may execute along paths, that it would not follow under its ideal semantics, violating essential program invariants on the way. A program is said to be consistent if it does not suffer from this problem despite uncertainty in decisions.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535858", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + }, + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/popl/ChaudhuriFK14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535848", + "title": "Replicated data types: specification, verification, optimality", + "abstract": "International audience", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535848", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + }, + { + "first_name": "Marek", + "last_name": "Zawirski", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/BurckhardtGYZ14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2537850", + "title": "A Galois connection calculus for abstract interpretation", + "abstract": "International audience", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2537850", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "École Normale Supérieure - PSL" + } + ], + "dblp_key": "conf/popl/CousotC14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535887", + "title": "Profiling for laziness", + "abstract": "While many programmers appreciate the benefits of lazy programming at an abstract level, determining which parts of a concrete program to evaluate lazily poses a significant challenge for most of them. Over the past thirty years, experts have published numerous papers on the problem, but developing this level of expertise requires a significant amount of experience.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535887", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Chang", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/ChangF14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535840", + "title": "Polymorphic functions with set-theoretic types: part 1: syntax, semantics, and evaluation", + "abstract": "This article is the first part of a two articles series about a calculus with higher-order polymorphic functions, recursive types with arrow and product type constructors and set-theoretic type connectives (union, intersection, and negation).", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535840", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Zhiwu", + "last_name": "Xu", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Hyeonseung", + "last_name": "Im", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Sergueï", + "last_name": "Lenglet", + "institution": "Université de Lorraine" + }, + { + "first_name": "Luca", + "last_name": "Padovani", + "institution": "University of Turin" + } + ], + "dblp_key": "conf/popl/Castagna0XILP14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535883", + "title": "Combining proofs and programs in a dependently typed language", + "abstract": "Most dependently-typed programming languages either require that all expressions terminate (e.g. Coq, Agda, and Epigram), or allow infinite loops but are inconsistent when viewed as logics (e.g. Haskell, ATS, Ωmega. Here, we combine these two approaches into a single dependently-typed core language. The language is composed of two fragments that share a common syntax and overlapping semantics: a logic that guarantees total correctness, and a call-by-value programming language that guarantees type safety but not termination. The two fragments may interact: logical expressions may be used as programs; the logic may soundly reason about potentially nonterminating programs; programs can require logical proofs as arguments; and \"mobile\" program values, including proofs computed at runtime, may be used as evidence by the logic. This language allows programmers to work with total and partial functions uniformly, providing a smooth path from functional programming to dependently-typed programming.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535883", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chris", + "last_name": "Casinghino", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Vilhelm", + "last_name": "Sjöberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/CasinghinoSW14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535881", + "title": "Fair reactive programming", + "abstract": "Functional Reactive Programming (FRP) models reactive systems with events and signals, which have previously been observed to correspond to the \"eventually\" and \"always\" modalities of linear temporal logic (LTL). In this paper, we define a constructive variant of LTL with least fixed point and greatest fixed point operators in the spirit of the modal mu-calculus, and give it a proofs-as-programs interpretation as a foundational calculus for reactive programs. Previous work emphasized the propositions-as-types part of the correspondence between LTL and FRP; here we emphasize the proofs-as-programs part by employing structural proof theory. We show that the type system is expressive enough to enforce liveness properties such as the fairness of schedulers and the eventual delivery of results. We illustrate programming in this calculus using (co)iteration operators. We prove type preservation of our operational semantics, which guarantees that our programs are causal. We give also a proof of strong normalization which provides justification that our programs are productive and that they satisfy liveness properties derived from their types.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535881", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Cave", + "institution": "McGill University" + }, + { + "first_name": "Francisco", + "last_name": "Ferreira", + "institution": "McGill University" + }, + { + "first_name": "Prakash", + "last_name": "Panangaden", + "institution": "McGill University" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "conf/popl/CaveFPP14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535855", + "title": "Fissile type analysis: modular checking of almost everywhere invariants", + "abstract": "We present a generic analysis approach to the imperative relationship update problem, in which destructive updates temporarily violate a global invariant of interest. Such invariants can be conveniently and concisely specified with dependent refinement types, which are efficient to check flow-insensitively. Unfortunately, while traditional flow-insensitive type checking is fast, it is inapplicable when the desired invariants can be temporarily broken. To overcome this limitation, past works have directly ratcheted up the complexity of the type analysis and associated type invariants, leading to inefficient analysis and verbose specifications. In contrast, we propose a generic lifting of modular refinement type analyses with a symbolic analysis to efficiently and effectively check concise invariants that hold almost everywhere. The result is an efficient, highly modular flow-insensitive type analysis to optimistically check the preservation of global relationship invariants that can fall back to a precise, disjunctive symbolic analysis when the optimistic assumption is violated. This technique permits programmers to temporarily break and then re-establish relationship invariants--a flexibility that is crucial for checking relationships in real-world, imperative languages. A significant challenge is selectively violating the global type consistency invariant over heap locations, which we achieve via almost type-consistent heaps. To evaluate our approach, we have encoded the problem of verifying the safety of reflective method calls in dynamic languages as a refinement type checking problem. Our analysis is capable of validating reflective call safety at interactive speeds on commonly-used Objective-C libraries and applications.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535855", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Devin", + "last_name": "Coughlin", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/popl/CoughlinC14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535859", + "title": "Bridging boolean and quantitative synthesis using smoothed proof search", + "abstract": "We present a new technique for parameter synthesis under boolean and quantitative objectives. The input to the technique is a \"sketch\" --- a program with missing numerical parameters --- and a probabilistic assumption about the program's inputs. The goal is to automatically synthesize values for the parameters such that the resulting program satisfies: (1) a {boolean specification}, which states that the program must meet certain assertions, and (2) a {quantitative specification}, which assigns a real valued rating to every program and which the synthesizer is expected to optimize. Our method --- called smoothed proof search --- reduces this task to a sequence of unconstrained smooth optimization problems that are then solved numerically. By iteratively solving these problems, we obtain parameter values that get closer and closer to meeting the boolean specification; at the limit, we obtain values that provably meet the specification. The approximations are computed using a new notion of smoothing for program abstractions, where an abstract transformer is approximated by a function that is continuous according to a metric over abstract states. We present a prototype implementation of our synthesis procedure, and experimental results on two benchmarks from the embedded control domain. The experiments demonstrate the benefits of smoothed proof search over an approach that does not meet the boolean and quantitative synthesis goals simultaneously.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535859", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + }, + { + "first_name": "Martin", + "last_name": "Clochard", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/ChaudhuriCS14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535882", + "title": "A sound and complete abstraction for reasoning about parallel prefix sums", + "abstract": "Prefix sums are key building blocks in the implementation of many concurrent software applications, and recently much work has gone into efficiently implementing prefix sums to run on massively parallel graphics processing units (GPUs). Because they lie at the heart of many GPU-accelerated applications, the correctness of prefix sum implementations is of prime importance.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535882", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nathan", + "last_name": "Chong", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Jeroen", + "last_name": "Ketema", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/ChongDK14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535849", + "title": "Minimization of symbolic automata", + "abstract": "Symbolic Automata extend classical automata by using symbolic alphabets instead of finite ones. Most of the classical automata algorithms rely on the alphabet being finite, and generalizing them to the symbolic setting is not a trivial task. In this paper we study the problem of minimizing symbolic automata. We formally define and prove the basic properties of minimality in the symbolic setting, and lift classical minimization algorithms (Huffman-Moore's and Hopcroft's algorithms) to symbolic automata. While Hopcroft's algorithm is the fastest known algorithm for DFA minimization, we show how, in the presence of symbolic alphabets, it can incur an exponential blowup. To address this issue, we introduce a new algorithm that fully benefits from the symbolic representation of the alphabet and does not suffer from the exponential blowup. We provide comprehensive performance evaluation of all the algorithms over large benchmarks and against existing state-of-the-art implementations. The experiments show how the new symbolic algorithm is faster than previous implementations.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535849", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/DAntoniV14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535874", + "title": "Sound compilation of reals", + "abstract": "Writing accurate numerical software is hard because of many sources of unavoidable uncertainties, including finite numerical precision of implementations. We present a programming model where the user writes a program in a real-valued implementation and specification language that explicitly includes different types of uncertainties. We then present a compilation algorithm that generates a finite-precision implementation that is guaranteed to meet the desired precision with respect to real numbers. Our compilation performs a number of verification steps for different candidate precisions. It generates verification conditions that treat all sources of uncertainties in a unified way and encode reasoning about finite-precision roundoff errors into reasoning about real numbers. Such verification conditions can be used as a standardized format for verifying the precision and the correctness of numerical programs. Due to their non-linear nature, precise reasoning about these verification conditions remains difficult and cannot be handled using state-of-the art SMT solvers alone. We therefore propose a new procedure that combines exact SMT solving over reals with approximate and sound affine and interval arithmetic. We show that this approach overcomes scalability limitations of SMT solvers while providing improved precision over affine and interval arithmetic. Our implementation gives promising results on several numerical models, including dynamical systems, transcendental functions, and controller implementations.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535874", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eva", + "last_name": "Darulová", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/DarulovaK14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535866", + "title": "Tracing compilation by abstract interpretation", + "abstract": "Tracing just-in-time compilation is a popular compilation schema for the efficient implementation of dynamic languages, which is commonly used for JavaScript, Python, and PHP. It relies on two key ideas. First, it monitors the execution of the program to detect so-called hot paths, i.e., the most frequently executed paths. Then, it uses some store information available at runtime to optimize hot paths. The result is a residual program where the optimized hot paths are guarded by sufficient conditions ensuring the equivalence of the optimized path and the original program. The residual program is persistently mutated during its execution, e.g., to add new optimized paths or to merge existing paths. Tracing compilation is thus fundamentally different than traditional static compilation. Nevertheless, despite the remarkable practical success of tracing compilation, very little is known about its theoretical foundations.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535866", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stefano", + "last_name": "Dissegna", + "institution": "University of Padua" + }, + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Francesco", + "last_name": "Ranzato", + "institution": "University of Padua" + } + ], + "dblp_key": "conf/popl/DissegnaLR14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535865", + "title": "Probabilistic coherence spaces are fully abstract for probabilistic PCF", + "abstract": "Probabilistic coherence spaces (PCoh) yield a semantics of higher-order probabilistic computation, interpreting types as convex sets and programs as power series. We prove that the equality of interpretations in Pcoh characterizes the operational indistinguishability of programs in PCF with a random primitive.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535865", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ehrhard", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Christine", + "last_name": "Tasson", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Michele", + "last_name": "Pagani", + "institution": "Université Sorbonne Paris Nord" + } + ], + "dblp_key": "conf/popl/EhrhardTP14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535868", + "title": "Abstract satisfaction", + "abstract": "This article introduces an abstract interpretation framework that codifies the operations in SAT and SMT solvers in terms of lattices, transformers and fixed points. We develop the idea that a formula denotes a set of models in a universe of structures. This set of models has characterizations as fixed points of deduction, abduction and quantification transformers. A wide range of satisfiability procedures can be understood as computing and refining approximations of such fixed points. These include procedures in the DPLL family, those for preprocessing and inprocessing in SAT solvers, decision procedures for equality logics, weak arithmetics, and procedures for approximate quantification. Our framework provides a unified, mathematical basis for studying and combining program analysis and satisfiability procedures. A practical benefit of our work is a new, logic-agnostic architecture for implementing solvers.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535868", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vijay", + "last_name": "D’Silva", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Leopold", + "last_name": "Haller", + "institution": "University of Oxford" + }, + { + "first_name": "Daniel", + "last_name": "Kroening", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/DSilvaHK14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2537848", + "title": "30 years of research and development around Coq", + "abstract": "No abstract available.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2537848", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gérard", + "last_name": "Huet", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Hugo", + "last_name": "Herbelin", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/HuetH14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535846", + "title": "Parametric effect monads and semantics of effect systems", + "abstract": "We study fundamental properties of a generalisation of monad called parametric effect monad, and apply it to the interpretation of general effect systems whose effects have sequential composition operators. We show that parametric effect monads admit analogues of the structures and concepts that exist for monads, such as Kleisli triples, the state monad and the continuation monad, Plotkin and Power's algebraic operations, and the categorical ┬┬-lifting. We also show a systematic method to generate both effects and a parametric effect monad from a monad morphism. Finally, we introduce two effect systems with explicit and implicit subeffecting, and discuss their denotational semantics and the soundness of effect systems.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535846", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "" + } + ], + "dblp_key": "conf/popl/Katsumata14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535856", + "title": "Closed type families with overlapping equations", + "abstract": "Open, type-level functions are a recent innovation in Haskell that move Haskell towards the expressiveness of dependent types, while retaining the look and feel of a practical programming language. This paper shows how to increase expressiveness still further, by adding closed type functions whose equations may overlap, and may have non-linear patterns over an open type universe. Although practically useful and simple to implement, these features go beyond conventional dependent type theory in some respects, and have a subtle metatheory.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535856", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/EisenbergVJW14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535885", + "title": "Proofs that count", + "abstract": "Counting arguments are among the most basic proof methods in mathematics. Within the field of formal verification, they are useful for reasoning about programs with infinite control, such as programs with an unbounded number of threads, or (concurrent) programs with recursive procedures. While counting arguments are common in informal, hand-written proofs of such programs, there are no fully automated techniques to construct counting arguments. The key questions involved in automating counting arguments are: how to decide what should be counted?, and how to decide when a counting argument is valid? In this paper, we present a technique for automatically constructing and checking counting arguments, which includes novel solutions to these questions.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535885", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "University of Toronto" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/popl/FarzanKP14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535884", + "title": "Backpack: retrofitting Haskell with interfaces", + "abstract": "Module systems like that of Haskell permit only a weak form of modularity in which module implementations depend directly on other implementations and must be processed in dependency order. Module systems like that of ML, on the other hand, permit a stronger form of modularity in which explicit interfaces express assumptions about dependencies, and each module can be typechecked and reasoned about independently.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535884", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Scott E.", + "last_name": "Kilpatrick", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Meta (United Kingdom)" + } + ], + "dblp_key": "conf/popl/KilpatrickDJM14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535864", + "title": "Proof search for propositional abstract separation logics via labelled sequents", + "abstract": "Abstract separation logics are a family of extensions of Hoare logic for reasoning about programs that mutate memory. These logics are \"abstract\" because they are independent of any particular concrete memory model. Their assertion languages, called propositional abstract separation logics, extend the logic of (Boolean) Bunched Implications (BBI) in various ways.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535864", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhé", + "last_name": "Hóu", + "institution": "Australian National University" + }, + { + "first_name": "Ranald", + "last_name": "Clouston", + "institution": "Australian National University" + }, + { + "first_name": "Rajeev", + "last_name": "Goré", + "institution": "Australian National University" + }, + { + "first_name": "Alwen", + "last_name": "Tiu", + "institution": "Nanyang Technological University" + } + ], + "dblp_key": "conf/popl/HouCGT14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535850", + "title": "Tabular: a schema-driven probabilistic programming language", + "abstract": "We propose a new kind of probabilistic programming language for machine learning. We write programs simply by annotating existing relational schemas with probabilistic model expressions. We describe a detailed design of our language, Tabular, complete with formal semantics and type system. A rich series of examples illustrates the expressiveness of Tabular. We report an implementation, and show evidence of the succinctness of our notation relative to current best practice. Finally, we describe and verify a transformation of Tabular schemas so as to predict missing values in a concrete database. The ability to query for missing values provides a uniform interface to a wide variety of tasks, including classification, clustering, recommendation, and ranking.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535850", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "University of Edinburgh" + }, + { + "first_name": "Thore", + "last_name": "Graepel", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Nicolas", + "last_name": "Rolland", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Claudio", + "last_name": "Russo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Johannes", + "last_name": "Borgström", + "institution": "Uppsala University" + }, + { + "first_name": "John", + "last_name": "Guiver", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/GordonGRRBG14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535854", + "title": "Modular reasoning about heap paths via effectively propositional formulas", + "abstract": "First order logic with transitive closure, and separation logic enable elegant interactive verification of heap-manipulating programs. However, undecidabilty results and high asymptotic complexity of checking validity preclude complete automatic verification of such programs, even when loop invariants and procedure contracts are specified as formulas in these logics. This paper tackles the problem of procedure-modular verification of reachability properties of heap-manipulating programs using efficient decision procedures that are complete: that is, a SAT solver must generate a counterexample whenever a program does not satisfy its specification. By (a) requiring each procedure modifies a fixed set of heap partitions and creates a bounded amount of heap sharing, and (b) restricting program contracts and loop invariants to use only deterministic paths in the heap, we show that heap reachability updates can be described in a simple manner. The restrictions force program specifications and verification conditions to lie within a fragment of first-order logic with transitive closure that is reducible to effectively propositional logic, and hence facilitate sound, complete and efficient verification. We implemented a tool atop Z3 and report on preliminary experiments that establish the correctness of several programs that manipulate linked data structures.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535854", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/ItzhakyBILNS14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535843", + "title": "Abstract acceleration of general linear loops", + "abstract": "We present abstract acceleration techniques for computing loop invariants for numerical programs with linear assignments and conditionals. Whereas abstract interpretation techniques typically over-approximate the set of reachable states iteratively, abstract acceleration captures the effect of the loop with a single, non-iterative transfer function applied to the initial states at the loop head. In contrast to previous acceleration techniques, our approach applies to any linear loop without restrictions. Its novelty lies in the use of the Jordan normal form decomposition of the loop body to derive symbolic expressions for the entries of the matrix modeling the effect of η ≥ Ο iterations of the loop. The entries of such a matrix depend on η through complex polynomial, exponential and trigonometric functions. Therefore, we introduces an abstract domain for matrices that captures the linear inequality relations between these complex expressions. This results in an abstract matrix for describing the fixpoint semantics of the loop.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535843", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bertrand", + "last_name": "Jeannet", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Peter", + "last_name": "Schrammel", + "institution": "University of Oxford" + }, + { + "first_name": "Sriram", + "last_name": "Sankaranarayanan", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/popl/JeannetSS14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535842", + "title": "Freeze after writing: quasi-deterministic parallel programming with LVars", + "abstract": "Deterministic-by-construction parallel programming models offer the advantages of parallel speedup while avoiding the nondeterministic, hard-to-reproduce bugs that plague fully concurrent code. A principled approach to deterministic-by-construction parallel programming with shared state is offered by LVars: shared memory locations whose semantics are defined in terms of an application-specific lattice. Writes to an LVar take the least upper bound of the old and new values with respect to the lattice, while reads from an LVar can observe only that its contents have crossed a specified threshold in the lattice. Although it guarantees determinism, this interface is quite limited.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535842", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "University of Birmingham" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/KuperTKN14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535841", + "title": "CakeML: a verified implementation of ML", + "abstract": "We have developed and mechanically verified an ML system called CakeML, which supports a substantial subset of Standard ML. CakeML is implemented as an interactive read-eval-print loop (REPL) in x86-64 machine code. Our correctness theorem ensures that this REPL implementation prints only those results permitted by the semantics of CakeML. Our verification effort touches on a breadth of topics including lexing, parsing, type checking, incremental and dynamic compilation, garbage collection, arbitrary-precision arithmetic, and compiler bootstrapping.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535841", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ramana", + "last_name": "Kumar", + "institution": "University of Cambridge" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "University of Cambridge" + }, + { + "first_name": "Michael", + "last_name": "Norrish", + "institution": "Data61" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/popl/KumarMNO14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535878", + "title": "An operational and axiomatic semantics for non-determinism and sequence points in C", + "abstract": "The C11 standard of the C programming language does not specify the execution order of expressions. Besides, to make more effective optimizations possible (eg. delaying of side-effects and interleaving), it gives compilers in certain cases the freedom to use even more behaviors than just those of all execution orders.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535878", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "conf/popl/Krebbers14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535857", + "title": "Symbolic optimization with SMT solvers", + "abstract": "The rise in efficiency of Satisfiability Modulo Theories (SMT) solvers has created numerous uses for them in software verification, program synthesis, functional programming, refinement types, etc. In all of these applications, SMT solvers are used for generating satisfying assignments (e.g., a witness for a bug) or proving unsatisfiability/validity(e.g., proving that a subtyping relation holds). We are often interested in finding not just an arbitrary satisfying assignment, but one that optimizes (minimizes/maximizes) certain criteria. For example, we might be interested in detecting program executions that maximize energy usage (performance bugs), or synthesizing short programs that do not make expensive API calls. Unfortunately, none of the available SMT solvers offer such optimization capabilities.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535857", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yi", + "last_name": "Li", + "institution": "University of Toronto" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Toronto" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "University of Toronto" + }, + { + "first_name": "Arie", + "last_name": "Gurfinkel", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Marsha", + "last_name": "Chećhik", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/popl/LiAKGC14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535872", + "title": "On coinductive equivalences for higher-order probabilistic functional programs", + "abstract": "We study bisimulation and context equivalence in a probabilistic lambda-calculus. The contributions of this paper are threefold. Firstly we show a technique for proving congruence of probabilistic applicative bisimilarity. While the technique follows Howe's method, some of the technicalities are quite different, relying on non-trivial \"disentangling\" properties for sets of real numbers. Secondly we show that, while bisimilarity is in general strictly finer than context equivalence, coincidence between the two relations is attained on pure lambda-terms. The resulting equality is that induced by Levy-Longo trees, generally accepted as the finest extensional equivalence on pure lambda-terms under a lazy regime. Finally, we derive a coinductive characterisation of context equivalence on the whole probabilistic language, via an extension in which terms akin to distributions may appear in redex position. Another motivation for the extension is that its operational semantics allows us to experiment with a different congruence technique, namely that of logical bisimilarity.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535872", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Davide", + "last_name": "Sangiorgi", + "institution": "University of Bologna" + }, + { + "first_name": "Michele", + "last_name": "Alberti", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/LagoSA14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535851", + "title": "Authenticated data structures, generically", + "abstract": "An authenticated data structure (ADS) is a data structure whose operations can be carried out by an untrusted prover, the results of which a verifier can efficiently check as authentic. This is done by having the prover produce a compact proof that the verifier can check along with each operation's result. ADSs thus support outsourcing data maintenance and processing tasks to untrusted servers without loss of integrity. Past work on ADSs has focused on particular data structures (or limited classes of data structures), one at a time, often with support only for particular operations.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535851", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Miller", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jonathan", + "last_name": "Katz", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Elaine", + "last_name": "Shi", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/popl/MillerHKS14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535888", + "title": "Sound input filter generation for integer overflow errors", + "abstract": "We present a system, SIFT, for generating input filters that nullify integer overflow errors associated with critical program sites such as memory allocation or block copy sites. SIFT uses a static pro- gram analysis to generate filters that discard inputs that may trigger integer overflow errors in the computations of the sizes of allocated memory blocks or the number of copied bytes in block copy operations. Unlike all previous techniques of which we are aware, SIFT is sound -- if an input passes the filter, it will not trigger an integer overflow error at any analyzed site. Our results show that SIFT successfully analyzes (and therefore generates sound input filters for) 56 out of 58 memory allocation and block memory copy sites in analyzed input processing modules from five applications (VLC, Dillo, Swfdec, Swftools, and GIMP). These nullified errors include six known integer overflow vulnerabilities. Our results also show that applying these filters to 62895 real-world inputs produces no false positives. The analysis and filter generation times are all less than a second.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535888", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fan", + "last_name": "Long", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Stelios", + "last_name": "Sidiroglou-Douskos", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Deokhwan", + "last_name": "Kim", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/LongSKR14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535871", + "title": "A proof system for separation logic with magic wand", + "abstract": "Separation logic is an extension of Hoare logic which is acknowledged as an enabling technology for large-scale program verification. It features two new logical connectives, separating conjunction and separating implication, but most of the applications of separation logic have exploited only separating conjunction without considering separating implication. Nevertheless the power of separating implication has been well recognized and there is a growing interest in its use for program verification. This paper develops a proof system for full separation logic which supports not only separating conjunction but also separating implication. The proof system is developed in the style of sequent calculus and satisfies the admissibility of cut. The key challenge in the development is to devise a set of inference rules for manipulating heap structures that ensure the completeness of the proof system with respect to separation logic. We show that our proof of completeness directly translates to a proof search strategy.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535871", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Sungwoo", + "last_name": "Park", + "institution": "Pohang University of Science and Technology" + } + ], + "dblp_key": "conf/popl/LeeP14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535880", + "title": "Game semantics for interface middleweight Java", + "abstract": "We consider an object calculus in which open terms interact with the environment through interfaces. The calculus is intended to capture the essence of contextual interactions of Middleweight Java code. Using game semantics, we provide fully abstract models for the induced notions of contextual approximation and equivalence. These are the first denotational models of this kind.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535880", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrzej S.", + "last_name": "Murawski", + "institution": "University of Warwick" + }, + { + "first_name": "Nikos", + "last_name": "Tzevelekos", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/popl/MurawskiT14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535879", + "title": "Applying quantitative semantics to higher-order quantum computing", + "abstract": "Finding a denotational semantics for higher order quantum computation is a long-standing problem in the semantics of quantum programming languages. Most past approaches to this problem fell short in one way or another, either limiting the language to an unusably small finitary fragment, or giving up important features of quantum physics such as entanglement. In this paper, we propose a denotational semantics for a quantum lambda calculus with recursion and an infinite data type, using constructions from quantitative semantics of linear logic.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535879", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michele", + "last_name": "Pagani", + "institution": "Université Paris Cité" + }, + { + "first_name": "Peter", + "last_name": "Selinger", + "institution": "Dalhousie University" + }, + { + "first_name": "Benoît", + "last_name": "Valiron", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/PaganiSV14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535861", + "title": "Modular, higher-order cardinality analysis in theory and practice", + "abstract": "Since the mid '80s, compiler writers for functional languages (especially lazy ones) have been writing papers about identifying and exploiting thunks and lambdas that are used only once. However it has proved difficult to achieve both power and simplicity in practice. We describe a new, modular analysis for a higher-order language, which is both simple and effective, and present measurements of its use in a full-scale, state of the art optimising compiler. The analysis finds many single-entry thunks and one-shot lambdas and enables a number of program optimisations.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535861", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/SergeyVJ14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535870", + "title": "Toward general diagnosis of static errors", + "abstract": "We introduce a general way to locate programmer mistakes that are detected by static analyses such as type checking. The program analysis is expressed in a constraint language in which mistakes result in unsatisfiable constraints. Given an unsatisfiable system of constraints, both satisfiable and unsatisfiable constraints are analyzed, to identify the program expressions most likely to be the cause of unsatisfiability. The likelihood of different error explanations is evaluated under the assumption that the programmer's code is mostly correct, so the simplest explanations are chosen, following Bayesian principles. For analyses that rely on programmer-stated assumptions, the diagnosis also identifies assumptions likely to have been omitted. The new error diagnosis approach has been implemented for two very different program analyses: type inference in OCaml and information flow checking in Jif. The effectiveness of the approach is evaluated using previously collected programs containing errors. The results show that when compared to existing compilers and other tools, the general technique identifies the location of programmer errors significantly more accurately.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535870", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/ZhangM14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535873", + "title": "A type-directed abstraction refinement approach to higher-order model checking", + "abstract": "The trivial-automaton model checking problem for higher-order recursion schemes has become a widely studied object in connection with the automatic verification of higher-order programs. The problem is formidably hard: despite considerable progress in recent years, no decision procedures have been demonstrated to scale robustly beyond recursion schemes that comprise more than a few hundred rewrite rules. We present a new, fixed-parameter polynomial time algorithm, based on a novel, type directed form of abstraction refinement in which behaviours of a scheme are distinguished by the abstraction according to the intersection types that they inhabit (the properties that they satisfy). Unlike other intersection type approaches, our algorithm reasons both about acceptance by the property automaton and acceptance by its dual, simultaneously, in order to minimize the amount of work done by converging on the solution to a problem instance from both sides. We have constructed Preface, a prototype implementation of the algorithm, and assembled an extensive body of evidence to demonstrate empirically that the algorithm readily scales to recursion schemes of several thousand rules, well beyond the capabilities of current state-of-the-art higher-order model checkers.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535873", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Oxford" + }, + { + "first_name": "Robin P.", + "last_name": "Neatherway", + "institution": "University of Oxford" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/RamsayNO14", + "venue": "popl", + "year": 2014 + }, + { + "paper_id": "10.1145/2535838.2535889", + "title": "Gradual typing embedded securely in JavaScript", + "abstract": "JavaScript's flexible semantics makes writing correct code hard and writing secure code extremely difficult. To address the former problem, various forms of gradual typing have been proposed, such as Closure and TypeScript. However, supporting all common programming idioms is not easy; for example, TypeScript deliberately gives up type soundness for programming convenience. In this paper, we propose a gradual type system and implementation techniques that provide important safety and security guarantees.", + "date": "2014-01-08", + "link": "https://doi.org/10.1145/2535838.2535889", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Karthikeyan", + "last_name": "Bhargavan", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "IMDEA Software" + }, + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/SwamyFRBCSB14", + "venue": "popl", + "year": 2014 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2015.json b/data/pl_conferences/popl/2015.json new file mode 100644 index 0000000..568df94 --- /dev/null +++ b/data/pl_conferences/popl/2015.json @@ -0,0 +1,1587 @@ +[ + { + "paper_id": "10.1145/2676726.2677004", + "title": "Ur/Web: A Simple Model for Programming the Web", + "abstract": "The World Wide Web has evolved gradually from a document delivery platform to an architecture for distributed programming. This largely unplanned evolution is apparent in the set of interconnected languages and protocols that any Web application must manage. This paper presents Ur/Web, a domain-specific, statically typed functional programming language with a much simpler model for programming modern Web applications. Ur/Web's model is unified, where programs in a single programming language are compiled to other \"Web standards\" languages as needed; supports novel kinds of encapsulation of Web-specific state; and exposes simple concurrency, where programmers can reason about distributed, multithreaded applications via a mix of transactions and cooperative preemption. We give a tutorial introduction to the main features of Ur/Web and discuss the language implementation and the production Web applications that use it.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677004", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Chlipala15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676982", + "title": "K-Java: A Complete Semantics of Java", + "abstract": "This paper presents K-Java, a complete executable formal semantics of Java 1.4. K-Java was extensively tested with a test suite developed alongside the project, following the Test Driven Development methodology. In order to maintain clarity while handling the great size of Java, the semantics was split into two separate definitions -- a static semantics and a dynamic semantics. The output of the static semantics is a preprocessed Java program, which is passed as input to the dynamic semantics for execution. The preprocessed program is a valid Java program, which uses a subset of the features of Java. The semantics is applied to model-check multi-threaded programs. Both the test suite and the static semantics are generic and ready to be used in other Java-related projects.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676982", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Denis", + "last_name": "Bogdanas", + "institution": "Alexandru Ioan Cuza University" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/BogdanasR15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677013", + "title": "Towards the Essence of Hygiene", + "abstract": "Hygiene is an essential aspect of Scheme's macro system that prevents unintended variable capture. However, previous work on hygiene has focused on algorithmic implementation rather than precise, mathematical definition of what constitutes hygiene. This is in stark contrast with lexical scope, alpha-equivalence and capture-avoiding substitution, which also deal with preventing unintended variable capture but have widely applicable and well-understood mathematical definitions.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677013", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/Adams15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2682620", + "title": "Databases and Programming: Two Subjects Divided by a Common Language?", + "abstract": "The 1990s saw a hugely productive interaction between database and programming language research. Ideas about type systems from programming languages played a central role in generalizing and adapting relational database systems to new data models. At the same time databases provided some of the best concrete examples of the application of concurrency theory and of the benefits of high-level optimization in functional programming languages. One of the driving ambitions behind this research was the idea that database access should be properly embedded in programming languages: one should not have to be bilingual in order to use a database from a programming language; and that goal has to some extent been realized.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2682620", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Buneman", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/Buneman15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676972", + "title": "Sound Modular Verification of C Code Executing in an Unverified Context", + "abstract": "Over the past decade, great progress has been made in the static modular verification of C code by means of separation logic-based program logics. However, the runtime guarantees offered by such verification are relatively limited when the verified modules are part of a whole program that also contains unverified modules. In particular, a memory safety error in an unverified module can corrupt the runtime state, leading to assertion failures or invalid memory accesses in the verified modules. This paper develops runtime checks to be inserted at the boundary between the verified and the unverified part of a program, to guarantee that no assertion failures or invalid memory accesses can occur at runtime in any verified module. One of the key challenges is enforcing the separation logic frame rule, which we achieve by checking the integrity of the footprint of the verified part of the program on each control flow transition from the unverified to the verified part. This in turn requires the presence of some support for module-private memory at runtime. We formalize our approach and prove soundness. We implement the necessary runtime checks by means of a program transformation that translates C code with separation logic annotations into plain C, and that relies on a protected module architecture for providing module-private memory and restricted module entry points. Benchmarks show the performance impact of this transformation depends on the choice of boundary between the verified and unverified parts of the program, but is below 4% for real-world applications.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676972", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pieter", + "last_name": "Agten", + "institution": "KU Leuven" + }, + { + "first_name": "Bart", + "last_name": "Jacobs", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/popl/Agten0P15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677000", + "title": "Higher-Order Approximate Relational Refinement Types for Mechanism Design and Differential Privacy", + "abstract": "Mechanism design is the study of algorithm design where the inputs to the algorithm are controlled by strategic agents, who must be incentivized to faithfully report them. Unlike typical programmatic properties, it is not sufficient for algorithms to merely satisfy the property, incentive properties are only useful if the strategic agents also believe this fact.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677000", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University of Dundee" + }, + { + "first_name": "Emilio Jesús Gallego", + "last_name": "Arias", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Aaron", + "last_name": "Roth", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/popl/BartheGAHRS15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676968", + "title": "Quantitative Interprocedural Analysis", + "abstract": "We consider the quantitative analysis problem for interprocedural control-flow graphs (ICFGs). The input consists of an ICFG, a positive weight function that assigns every transition a positive integer-valued number, and a labelling of the transitions (events) as good, bad, and neutral events. The weight function assigns to each transition a numerical value that represents a measure of how good or bad an event is. The quantitative analysis problem asks whether there is a run of the ICFG where the ratio of the sum of the numerical weights of good events versus the sum of weights of bad events in the long-run is at least a given threshold (or equivalently, to compute the maximal ratio among all valid paths in the ICFG). The quantitative analysis problem for ICFGs can be solved in polynomial time, and we present an efficient and practical algorithm for the problem.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676968", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Yaron", + "last_name": "Velner", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/ChatterjeePV15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676973", + "title": "Program Boosting: Program Synthesis via Crowd-Sourcing", + "abstract": "In this paper, we investigate an approach to program synthesis that is based on crowd-sourcing. With the help of crowd-sourcing, we aim to capture the \"wisdom of the crowds\" to find good if not perfect solutions to inherently tricky programming tasks, which elude even expert developers and lack an easy-to-formalize specification. We propose an approach we call program boosting, which involves crowd-sourcing imperfect solutions to a difficult programming problem from developers and then blending these programs together in a way that improves their correctness. We implement this approach in a system called CROWDBOOST and show in our experiments that interesting and highly non-trivial tasks such as writing regular expressions for URLs or email addresses can be effectively crowd-sourced. We demonstrate that carefully blending the crowd-sourced results together consistently produces a boost, yielding results that are better than any of the starting programs. Our experiments on 465 program pairs show consistent boosts in accuracy and demonstrate that program boosting can be performed at a relatively modest monetary cost.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676973", + "conference_name": "POPL", + "authors": [ + { + "first_name": "R", + "last_name": "Cochran", + "institution": "University of North Carolina at Chapel Hill" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dávid", + "last_name": "Molnár", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/CochranDLMV15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677002", + "title": "Tractable Refinement Checking for Concurrent Objects", + "abstract": "Efficient implementations of concurrent objects such as semaphores, locks, and atomic collections are essential to modern computing. Yet programming such objects is error prone: in minimizing the synchronization overhead between concurrent object invocations, one risks the conformance to reference implementations --- or in formal terms, one risks violating observational refinement. Testing this refinement even within a single execution is intractable, limiting existing approaches to executions with very few object invocations.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677002", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Laboratoire d'Informatique Algorithmique: Fondements et Applications" + }, + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Université Paris Cité" + }, + { + "first_name": "Jad", + "last_name": "Hamza", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/popl/BouajjaniEEH15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676988", + "title": "Self-Representation in Girard's System U", + "abstract": "In 1991, Pfenning and Lee studied whether System F could support a typed self-interpreter. They concluded that typed self-representation for System F \"seems to be impossible\", but were able to represent System F in Fω. Further, they found that the representation of Fω requires kind polymorphism, which is outside Fω. In 2009, Rendel, Ostermann and Hofer conjectured that the representation of kind-polymorphic terms would require another, higher form of polymorphism. Is this a case of infinite regress? We show that it is not and present a typed self-representation for Girard's System U, the first for a λ-calculus with decidable type checking. System U extends System Fω with kind polymorphic terms and types. We show that kind polymorphic types (i.e. types that depend on kinds) are sufficient to \"tie the knot\" -- they enable representations of kind polymorphic terms without introducing another form of polymorphism. Our self-representation supports operations that iterate over a term, each of which can be applied to a representation of itself. We present three typed self-applicable operations: a self-interpreter that recovers a term from its representation, a predicate that tests the intensional structure of a term, and a typed continuation-passing-style (CPS) transformation -- the first typed self-applicable CPS transformation. Our techniques could have applications from verifiably type-preserving metaprograms, to growable typed languages, to more efficient self-interpreters.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676988", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matt", + "last_name": "Brown", + "institution": "UCLA Health" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "UCLA Health" + } + ], + "dblp_key": "conf/popl/BrownP15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676991", + "title": "Polymorphic Functions with Set-Theoretic Types: Part 2: Local Type Inference and Type Reconstruction", + "abstract": "This article is the second part of a two articles series about the definition of higher order polymorphic functions in a type system with recursive types and set-theoretic type connectives (unions, intersections, and negations).", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676991", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Sorbonne Paris Cité" + }, + { + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Zhiwu", + "last_name": "Xu", + "institution": "China Southern Power Grid (China)" + }, + { + "first_name": "Pietro", + "last_name": "Abate", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/popl/Castagna0XA15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677003", + "title": "From Network Interface to Multithreaded Web Applications: A Case Study in Modular Program Verification", + "abstract": "Many verifications of realistic software systems are monolithic, in the sense that they define single global invariants over complete system state. More modular proof techniques promise to support reuse of component proofs and even reduce the effort required to verify one concrete system, just as modularity simplifies standard software development. This paper reports on one case study applying modular proof techniques in the Coq proof assistant. To our knowledge, it is the first modular verification certifying a system that combines infrastructure with an application of interest to end users. We assume a nonblocking API for managing TCP networking streams, and on top of that we work our way up to certifying multithreaded, database-backed Web applications. Key verified components include a cooperative threading library and an implementation of a domain-specific language for XML processing. We have deployed our case-study system on mobile robots, where it interfaces with off-the-shelf components for sensing, actuation, and control.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677003", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/Chlipala15a", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676977", + "title": "Specification Inference Using Context-Free Language Reachability", + "abstract": "We present a framework for computing context-free language reachability properties when parts of the program are missing. Our framework infers candidate specifications for missing program pieces that are needed for verifying a property of interest, and presents these specifications to a human auditor for validation. We have implemented this framework for a taint analysis of Android apps that relies on specifications for Android library methods. In an extensive experimental study on 179 apps, our tool performs verification with only a small number of queries to a human auditor.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676977", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "Stanford University" + }, + { + "first_name": "Saswat", + "last_name": "Anand", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/popl/BastaniAA15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676993", + "title": "Full Abstraction for Signal Flow Graphs", + "abstract": "Network theory uses the string diagrammatic language of monoidal categories to study graphical structures formally, eschewing specialised translations into intermediate formalisms. Recently, there has been a concerted research focus on developing a network theoretic approach to signal flow graphs, which are classical structures in control theory, signal processing and a cornerstone in the study of feedback. In this approach, signal flow graphs are given a relational denotational semantics in terms of formal power series.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676993", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Filippo", + "last_name": "Bonchi", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Paweł", + "last_name": "Sobociński", + "institution": "Bournemouth University" + }, + { + "first_name": "Fabio", + "last_name": "Zanasi", + "institution": "École Normale Supérieure de Lyon" + } + ], + "dblp_key": "conf/popl/BonchiSZ15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676981", + "title": "DReX: A Declarative Language for Efficiently Evaluating Regular String Transformations", + "abstract": "We present DReX, a declarative language that can express all regular string-to string transformations, and can still be efficiently evaluated. The class of regular string transformations has a robust theoretical foundation including multiple characterizations, closure properties, and decidable analysis questions, and admits a number of string operations such as insertion, deletion, substring swap, and reversal. Recent research has led to a characterization of regular string transformations using a primitive set of function combinators analogous to the definition of regular languages using regular expressions. While these combinators form the basis for the language DReX proposed in this paper, our main technical focus is on the complexity of evaluating the output of a DReX program on a given input string. It turns out that the natural evaluation algorithm involves dynamic programming, leading to complexity that is cubic in the length of the input string. Our main contribution is identifying a consistency restriction on the use of combinators in DReX programs, and a single-pass evaluation algorithm for consistent programs with time complexity that is linear in the length of the input string and polynomial in the size of the program. We show that the consistency restriction does not limit the expressiveness, and whether a DReX program is consistent can be checked efficiently. We report on a prototype implementation, and evaluate it using a representative set of text processing tasks.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676981", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/AlurDR15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676979", + "title": "Faster Algorithms for Algebraic Path Properties in Recursive State Machines with Constant Treewidth", + "abstract": "Interprocedural analysis is at the heart of numerous applications in programming languages, such as alias analysis, constant propagation, etc. Recursive state machines (RSMs) are standard models for interprocedural analysis. We consider a general framework with RSMs where the transitions are labeled from a semiring, and path properties are algebraic with semiring operations. RSMs with algebraic path properties can model interprocedural dataflow analysis problems, the shortest path problem, the most probable path problem, etc. The traditional algorithms for interprocedural analysis focus on path properties where the starting point is fixed as the entry point of a specific method. In this work, we consider possible multiple queries as required in many applications such as in alias analysis. The study of multiple queries allows us to bring in a very important algorithmic distinction between the resource usage of the one-time preprocessing vs for each individual query. The second aspect that we consider is that the control flow graphs for most programs have constant treewidth. Our main contributions are simple and implementable algorithms that support multiple queries for algebraic path properties for RSMs that have constant treewidth. Our theoretical results show that our algorithms have small additional one-time preprocessing, but can answer subsequent queries significantly faster as compared to the current best-known solutions for several important problems, such as interprocedural reachability and shortest path. We provide a prototype implementation for interprocedural reachability and intraprocedural shortest path that gives a significant speed-up on several benchmarks.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676979", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Rasmus", + "last_name": "Ibsen-Jensen", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Prateesh", + "last_name": "Goyal", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "conf/popl/ChatterjeeIPG15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676984", + "title": "A Calculus for Relaxed Memory", + "abstract": "We propose a new approach to programming multi-core, relaxed-memory architectures in imperative, portable programming languages. Our memory model is based on explicit, programmer-specified requirements for order of execution and the visibility of writes. The compiler then realizes those requirements in the most efficient manner it can. This is in contrast to existing memory models, which---if they allow programmer control over synchronization at all---are based on inferring the execution and visibility consequences of synchronization operations or annotations in the code.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676984", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Michael J.", + "last_name": "Sullivan", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/CraryS15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677006", + "title": "Fiat: Deductive Synthesis of Abstract Data Types in a Proof Assistant", + "abstract": "We present Fiat, a library for the Coq proof assistant supporting refinement of declarative specifications into efficient functional programs with a high degree of automation. Each refinement process leaves a proof trail, checkable by the normal Coq kernel, justifying its soundness. We focus on the synthesis of abstract data types that package methods with private data. We demonstrate the utility of our framework by applying it to the synthesis of query structures -- abstract data types with SQL-like query and insert operations. Fiat includes a library for writing specifications of query structures in SQL-inspired notation, expressing operations over relations (tables) in terms of mathematical sets. This library includes a suite of tactics for automating the refinement of specifications into efficient, correct-by-construction OCaml code. Using these tactics, a programmer can generate such an implementation completely automatically by only specifying the equivalent of SQL indexes, data structures capturing useful views of the abstract data. Throughout we speculate on the new programming modularity possibilities enabled by an automated refinement system with proved-correct rules.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677006", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "" + }, + { + "first_name": "Jason", + "last_name": "Gross", + "institution": "" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "" + } + ], + "dblp_key": "conf/popl/DelawarePGC15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677005", + "title": "Differential Privacy: Now it's Getting Personal", + "abstract": "Differential privacy provides a way to get useful information about sensitive data without revealing much about any one individual. It enjoys many nice compositionality properties not shared by other approaches to privacy, including, in particular, robustness against side-knowledge.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677005", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hamid", + "last_name": "Ebadi", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "David", + "last_name": "Sands", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Gerardo", + "last_name": "Schneider", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "conf/popl/EbadiSS15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2682621", + "title": "Automating Repetitive Tasks for the Masses", + "abstract": "The programming languages (PL) research community has traditionally catered to the needs of professional programmers in the continuously evolving technical industry. However, there is a new opportunity that knocks our doors. The recent IT revolution has resulted in the masses having access to personal computing devices. More than 99% of these computer users are non-programmers and are today limited to being passive consumers of the software that is made available to them. Can we empower these users to more effectively leverage computers for their daily tasks? The formalisms, techniques, and tools developed in the PL and the formal methods research communities can play a pivotal role!", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2682621", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/Gulwani15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676967", + "title": "Space-Efficient Manifest Contracts", + "abstract": "The standard algorithm for higher-order contract checking can lead to unbounded space consumption and can destroy tail recursion, altering a program's asymptotic space complexity. While space efficiency for gradual types---contracts mediating untyped and typed code---is well studied, sound space efficiency for manifest contracts---contracts that check stronger properties than simple types, e.g., \"is a natural'' instead of \"is an integer''---remains an open problem.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676967", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/Greenberg15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676963", + "title": "A Scalable, Correct Time-Stamped Stack", + "abstract": "Concurrent data-structures, such as stacks, queues, and deques, often implicitly enforce a total order over elements in their underlying memory layout. However, much of this order is unnecessary: linearizability only requires that elements are ordered if the insert methods ran in sequence. We propose a new approach which uses timestamping to avoid unnecessary ordering. Pairs of elements can be left unordered if their associated insert operations ran concurrently, and order imposed as necessary at the eventual removal.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676963", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mike", + "last_name": "Dodds", + "institution": "University of York" + }, + { + "first_name": "Andreas", + "last_name": "Haas", + "institution": "University of Salzburg" + }, + { + "first_name": "Christoph", + "last_name": "Kirsch", + "institution": "University of Salzburg" + } + ], + "dblp_key": "conf/popl/DoddsHK15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677010", + "title": "On Characterizing the Data Access Complexity of Programs", + "abstract": "Technology trends will cause data movement to account for the majority of energy expenditure and execution time on emerging computers. Therefore, computational complexity will no longer be a sufficient metric for comparing algorithms, and a fundamental characterization of data access complexity will be increasingly important. The problem of developing lower bounds for data access complexity has been modeled using the formalism of Hong and Kung's red/blue pebble game for computational directed acyclic graphs (CDAGs). However, previously developed approaches to lower bounds analysis for the red/blue pebble game are very limited in effectiveness when applied to CDAGs of real programs, with computations comprised of multiple sub-computations with differing DAG structure. We address this problem by developing an approach for effectively composing lower bounds based on graph decomposition. We also develop a static analysis algorithm to derive the asymptotic data-access lower bounds of programs, as a function of the problem size and cache size.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677010", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Venmugil", + "last_name": "Elango", + "institution": "The Ohio State University" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "The Ohio State University" + }, + { + "first_name": "J.", + "last_name": "Ramanujam", + "institution": "Louisiana State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/popl/ElangoRPRS15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677012", + "title": "Proof Spaces for Unbounded Parallelism", + "abstract": "In this paper, we present a new approach to automatically ver-ify multi-threaded programs which are executed by an unbounded number of threads running in parallel. The starting point for our work is the problem of how we can leverage existing automated verification technology for sequential programs (abstract interpretation, Craig interpolation, constraint solving, etc.) for multi-threaded programs. Suppose that we are given a correctness proof for a trace of a program (or for some other program fragment). We observe that the proof can always be decomposed into a finite set of Hoare triples, and we ask what can be proved from the finite set of Hoare triples using only simple combinatorial inference rules (without access to a theorem prover and without the possibility to infer genuinely new Hoare triples)? We introduce a proof system where one proves the correctness of a multi-threaded program by showing that for each trace of the program, there exists a correctness proof in the space of proofs that are derivable from a finite set of axioms using simple combinatorial inference rules. This proof system is complete with respect to the classical proof method of establishing an inductive invariant (which uses thread quantification and control predicates). Moreover, it is possible to algorithmically check whether a given set of axioms is sufficient to prove the correctness of a multi-threaded program, using ideas from well-structured transition systems. 1.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677012", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "University of Toronto" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/popl/FarzanKP15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676975", + "title": "Deep Specifications and Certified Abstraction Layers", + "abstract": "Modern computer systems consist of a multitude of abstraction layers (e.g., OS kernels, hypervisors, device drivers, network protocols), each of which defines an interface that hides the implementation details of a particular set of functionality. Client programs built on top of each layer can be understood solely based on the interface, independent of the layer implementation. Despite their obvious importance, abstraction layers have mostly been treated as a system concept; they have almost never been formally specified or verified. This makes it difficult to establish strong correctness properties, and to scale program verification across multiple layers.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676975", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Yale University" + }, + { + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" + }, + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Xiongnan", + "last_name": "Wu", + "institution": "Yale University" + }, + { + "first_name": "Shu-Chun", + "last_name": "Weng", + "institution": "Yale University" + }, + { + "first_name": "Haozhong", + "last_name": "Zhang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Yu", + "last_name": "Guo", + "institution": "University of Science and Technology of China" + } + ], + "dblp_key": "conf/popl/GuKRSWWZG15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676987", + "title": "Analyzing Program Analyses", + "abstract": "We want to prove that a static analysis of a given program is complete, namely, no imprecision arises when asking some query on the program behavior in the concrete (ie, for its concrete semantics) or in the abstract (ie, for its abstract interpretation). Completeness proofs are therefore useful to assign confidence to alarms raised by static analyses. We introduce the completeness class of an abstraction as the set of all programs for which the abstraction is complete. Our first result shows that for any nontrivial abstraction, its completeness class is not recursively enumerable. We then introduce a stratified deductive system to prove the completeness of program analyses over an abstract domain A. We prove the soundness of the deductive system. We observe that the only sources of incompleteness are assignments and Boolean tests --- unlikely a common belief in static analysis, joins do not induce incompleteness. The first layer of this proof system is generic, abstraction-agnostic, and it deals with the standard constructs for program composition, that is, sequential composition, branching and guarded iteration. The second layer is instead abstraction-specific: the designer of an abstract domain A provides conditions for completeness in A of assignments and Boolean tests which have to be checked by a suitable static analysis or assumed in the completeness proof as hypotheses. We instantiate the second layer of this proof system first with a generic nonrelational abstraction in order to provide a sound rule for the completeness of assignments. Orthogonally, we instantiate it to the numerical abstract domains of Intervals and Octagons, providing necessary and sufficient conditions for the completeness of their Boolean tests and of assignments for Octagons.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676987", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Verona" + }, + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Francesco", + "last_name": "Ranzato", + "institution": "University of Padua" + } + ], + "dblp_key": "conf/popl/GiacobazziLR15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676989", + "title": "Conjugate Hylomorphisms - Or: The Mother of All Structured Recursion Schemes", + "abstract": "The past decades have witnessed an extensive study of structured recursion schemes. A general scheme is the hylomorphism, which captures the essence of divide-and-conquer: a problem is broken into sub-problems by a coalgebra; sub-problems are solved recursively; the sub-solutions are combined by an algebra to form a solution. In this paper we develop a simple toolbox for assembling recursive coalgebras, which by definition ensure that their hylo equations have unique solutions, whatever the algebra. Our main tool is the conjugate rule, a generic rule parametrized by an adjunction and a conjugate pair of natural transformations. We show that many basic adjunctions induce useful recursion schemes. In fact, almost every structured recursion scheme seems to arise as an instance of the conjugate rule. Further, we adapt our toolbox to the more expressive setting of parametrically recursive coalgebras, where the original input is also passed to the algebra. The formal development is complemented by a series of worked-out examples in Haskell.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676989", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Oxford" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "University of Oxford" + }, + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/HinzeWG15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677001", + "title": "Probabilistic Termination: Soundness, Completeness, and Compositionality", + "abstract": "We propose a framework to prove almost sure termination for probabilistic programs with real valued variables. It is based on ranking supermartingales, a notion analogous to ranking functions on non-probabilistic programs. The framework is proven sound and complete for a meaningful class of programs involving randomization and bounded nondeterminism. We complement this foundational insigh by a practical proof methodology, based on sound conditions that enable compositional reasoning and are amenable to a direct implementation using modern theorem provers. This is integrated in a small dependent type system, to overcome the problem that lexicographic ranking functions fail when combined with randomization. Among others, this compositional methodology enables the verification of probabilistic programs outside the complete class that admits ranking supermartingales.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677001", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luis María Ferrer", + "last_name": "Fioriti", + "institution": "Saarland University" + }, + { + "first_name": "Holger", + "last_name": "Hermanns", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/popl/FioritiH15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677011", + "title": "A Coalgebraic Decision Procedure for NetKAT", + "abstract": "NetKAT is a domain-specific language and logic for specifying and verifying network packet-processing functions. It consists of Kleene algebra with tests (KAT) augmented with primitives for testing and modifying packet headers and encoding network topologies. Previous work developed the design of the language and its standard semantics, proved the soundness and completeness of the logic, defined a PSPACE algorithm for deciding equivalence, and presented several practical applications.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677011", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Mae", + "last_name": "Milano", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Laure", + "last_name": "Thompson", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/popl/FosterKM0T15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676992", + "title": "Principal Type Schemes for Gradual Programs", + "abstract": "Gradual typing is a discipline for integrating dynamic checking into a static type system. Since its introduction in functional languages, it has been adapted to a variety of type systems, including object-oriented, security, and substructural. This work studies its application to implicitly typed languages based on type inference. Siek and Vachharajani designed a gradual type inference system and algorithm that infers gradual types but still rejects ill-typed static programs. However, the type system requires local reasoning about type substitutions, an imperative inference algorithm, and a subtle correctness statement.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676992", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + }, + { + "first_name": "Matteo", + "last_name": "Cimini", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/GarciaC15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676998", + "title": "Leveraging Weighted Automata in Compositional Reasoning about Concurrent Probabilistic Systems", + "abstract": "We propose the first sound and complete learning-based compositional verification technique for probabilistic safety properties on concurrent systems where each component is an Markov decision process. Different from previous works, weighted assumptions are introduced to attain completeness of our framework. Since weighted assumptions can be implicitly represented by multi-terminal binary decision diagrams (MTBDD's), we give an L*-based learning algorithm for MTBDD's to infer weighted assumptions. Experimental results suggest promising outlooks for our compositional technique.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676998", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + }, + { + "first_name": "Xiaowei", + "last_name": "Gao", + "institution": "Tsinghua University" + }, + { + "first_name": "Bow-Yaw", + "last_name": "Wang", + "institution": "Academia Sinica" + }, + { + "first_name": "Lijun", + "last_name": "Zhang", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "conf/popl/HeGWZ15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676966", + "title": "A Formally-Verified C Static Analyzer", + "abstract": "This paper reports on the design and soundness proof, using the Coq proof assistant, of Verasco, a static analyzer based on abstract interpretation for most of the ISO C 1999 language (excluding recursion and dynamic allocation). Verasco establishes the absence of run-time errors in the analyzed programs. It enjoys a modular architecture that supports the extensible combination of multiple abstract domains, both relational and non-relational. Verasco integrates with the CompCert formally-verified C compiler so that not only the soundness of the analysis results is guaranteed with mathematical certitude, but also the fact that these guarantees carry over to the compiled code.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676966", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Vincent", + "last_name": "Laporte", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "École Normale Supérieure de Rennes" + } + ], + "dblp_key": "conf/popl/JourdanLBLP15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677008", + "title": "Succinct Representation of Concurrent Trace Sets", + "abstract": "We present a method and a tool for generating succinct representations of sets of concurrent traces. We focus on trace sets that contain all correct or all incorrect permutations of events from a given trace. We represent trace sets as HB-Formulas that are Boolean combinations of happens-before constraints between events. To generate a representation of incorrect interleavings, our method iteratively explores interleavings that violate the specification and gathers generalizations of the discovered interleavings into an HB-Formula; its complement yields a representation of correct interleavings.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677008", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ashutosh", + "last_name": "Gupta", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Thorsten", + "last_name": "Tarrach", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "conf/popl/GuptaHRST15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676980", + "title": "Iris: Monoids and Invariants as an Orthogonal Basis for Concurrent Reasoning", + "abstract": "We present Iris, a concurrent separation logic with a simple premise: monoids and invariants are all you need. Partial commutative monoids enable us to express---and invariants enable us to enforce---user-defined *protocols* on shared state, which are at the conceptual core of most recent program logics for concurrency. Furthermore, through a novel extension of the concept of a *view shift*, Iris supports the encoding of *logically atomic specifications*, i.e., Hoare-style specs that permit the client of an operation to treat the operation essentially as if it were atomic, even if it is not.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676980", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Saarland University" + }, + { + "first_name": "David", + "last_name": "Swasey", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "Aarhus University" + }, + { + "first_name": "Kasper", + "last_name": "Svendsen", + "institution": "Aarhus University" + }, + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/JungSSSTBD15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676994", + "title": "Dependent Information Flow Types", + "abstract": "In this paper, we develop a novel notion of dependent information flow types. Dependent information flow types fit within the standard framework of dependent type theory, but, unlike usual dependent types, crucially allow the security level of a type, rather than just the structural data type itself, to depend on runtime values.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676994", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luísa", + "last_name": "Lourenço", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Luı́s", + "last_name": "Caires", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "conf/popl/LourencoC15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2682622", + "title": "Coding by Everyone, Every Day", + "abstract": "In recent years, advances in machine learning and related fields have led to significant advances in a range of user-interface technologies, including audio processing, speech recognition, and natural language processing. These advances in turn have enabled speech-based digital assistants and speech-to-speech translation systems to become practical to deploy on a large scale. In essence, machines are becoming capable of hearing what we are saying. But will they understand what we want them to do when we talk to them? What are the prospects for getting useful work done in essence, by synthesizing programs -- through the act of having a conversation with a computer? In this lecture, I will speculate on the central role that programming-language design and program synthesis may have in this possible -- and I will argue, likely -- future of computing, one in which every user writes programs, every day, by conversing with a computing system.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2682622", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Lee", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/Lee15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676969", + "title": "Integrating Linear and Dependent Types", + "abstract": "In this paper, we show how to integrate linear types with type dependency, by extending the linear/non-linear calculus of Benton to support type dependency. Next, we give an application of this calculus by giving a proof-theoretic account of imperative programming, which requires extending the calculus with computationally irrelevant quantification, proof irrelevance, and a monad of computations. We show the soundness of our theory by giving a realizability model in the style of Nuprl, which permits us to validate not only the beta-laws for each type, but also the eta-laws. These extensions permit us to decompose Hoare triples into a collection of simpler type-theoretic connectives, yielding a rich equational theory for dependently-typed higher-order imperative programs. Furthermore, both the type theory and its model are relatively simple, even when all of the extensions are considered.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676969", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "University of Birmingham" + }, + { + "first_name": "Pierre", + "last_name": "Pradic", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/KrishnaswamiPB15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677009", + "title": "Predicting Program Properties from "Big Code"", + "abstract": "We present a new approach for predicting program properties from massive codebases (aka \"Big Code\"). Our approach first learns a probabilistic model from existing data and then uses this model to predict properties of new, unseen programs.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677009", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Andreas", + "last_name": "Krause", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/popl/RaychevVK15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676964", + "title": "From Communicating Machines to Graphical Choreographies", + "abstract": "Graphical choreographies, or global graphs, are general multiparty session specifications featuring expressive constructs such as forking, merging, and joining for representing application-level protocols. Global graphs can be directly translated into modelling notations such as BPMN and UML. This paper presents an algorithm whereby a global graph can be constructed from asynchronous interactions represented by communicating finite-state machines (CFSMs). Our results include: a sound and complete characterisation of a subset of safe CFSMs from which global graphs can be constructed; an algorithm to translate CFSMs to global graphs; a time complexity analysis; and an implementation of our theory, as well as an experimental evaluation.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676964", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julien", + "last_name": "Lange", + "institution": "Imperial College London" + }, + { + "first_name": "Emilio", + "last_name": "Tuosto", + "institution": "University of Leicester" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/LangeTY15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676974", + "title": "Programming up to Congruence", + "abstract": "This paper presents the design of Zombie, a dependently-typed programming language that uses an adaptation of a congruence closure algorithm for proof and type inference. This algorithm allows the type checker to automatically use equality assumptions from the context when reasoning about equality. Most dependently-typed languages automatically use equalities that follow from beta-reduction during type checking; however, such reasoning is incompatible with congruence closure. In contrast, Zombie does not use automatic beta-reduction because types may contain potentially diverging terms. Therefore Zombie provides a unique opportunity to explore an alternative definition of equivalence in dependently-typed language design.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676974", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vilhelm", + "last_name": "Sjöberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/SjobergW15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676970", + "title": "Functors are Type Refinement Systems", + "abstract": "The standard reading of type theory through the lens of category theory is based on the idea of viewing a type system as a category of well-typed terms. We propose a basic revision of this reading: rather than interpreting type systems as categories, we describe them as functors from a category of typing derivations to a category of underlying terms. Then, turning this around, we explain how in fact any functor gives rise to a generalized type system, with an abstract notion of typing judgment, typing derivations and typing rules. This leads to a purely categorical reformulation of various natural classes of type systems as natural classes of functors.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676970", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul-André", + "last_name": "Melliès", + "institution": "Sorbonne Paris Cité" + }, + { + "first_name": "Noam", + "last_name": "Zeilberger", + "institution": "Inria Saclay - Île de France" + } + ], + "dblp_key": "conf/popl/MelliesZ15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676978", + "title": "Runtime Enforcement of Security Policies on Black Box Reactive Programs", + "abstract": "Security enforcement mechanisms like execution monitors are used to make sure that some untrusted program complies with a policy. Different enforcement mechanisms have different strengths and weaknesses and hence it is important to understand the qualities of various enforcement mechanisms.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676978", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Minh", + "last_name": "Ngo", + "institution": "University of Trento" + }, + { + "first_name": "Fabio", + "last_name": "Massacci", + "institution": "University of Trento" + }, + { + "first_name": "Dimiter", + "last_name": "Milushev", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/popl/NgoMMP15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676983", + "title": "Higher Inductive Types as Homotopy-Initial Algebras", + "abstract": "Homotopy Type Theory is a new field of mathematics based on the recently-discovered correspondence between Martin-Löf's constructive type theory and abstract homotopy theory. We have a powerful interplay between these disciplines - we can use geometric intuition to formulate new concepts in type theory and, conversely, use type-theoretic machinery to verify and often simplify existing mathematical proofs.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676983", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kristina", + "last_name": "Sojakova", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Sojakova15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676990", + "title": "Decentralizing SDN Policies", + "abstract": "Software-defined networking (SDN) is a new paradigm for operating and managing computer networks. SDN enables logically-centralized control over network devices through a \"controller\" --- software that operates independently of the network hardware. Network operators can run both in-house and third-party SDN programs on top of the controller, e.g., to specify routing and access control policies.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676990", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Tel Aviv University" + }, + { + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Aleksandr", + "last_name": "Karbyshev", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Academic College of Tel Aviv-Yafo" + } + ], + "dblp_key": "conf/popl/PadonIKLSS15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676985", + "title": "Compositional CompCert", + "abstract": "This paper reports on the development of Compositional CompCert, the first verified separate compiler for C.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676985", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gordon", + "last_name": "Stewart", + "institution": "Princeton University" + }, + { + "first_name": "Lennart", + "last_name": "Beringer", + "institution": "Princeton University" + }, + { + "first_name": "Santiago", + "last_name": "Cuéllar", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/StewartBCA15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677007", + "title": "Symbolic Algorithms for Language Equivalence and Kleene Algebra with Tests", + "abstract": "We propose algorithms for checking language equivalence of finite automata over a large alphabet. We use symbolic automata, where the transition function is compactly represented using (multi-terminal) binary decision diagrams (BDD). The key idea consists in computing a bisimulation by exploring reachable pairs symbolically, so as to avoid redundancies. This idea can be combined with already existing optimisations, and we show in particular a nice integration with the disjoint sets forest data-structure from Hopcroft and Karp's standard algorithm.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677007", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Damien", + "last_name": "Pous", + "institution": "Université Claude Bernard Lyon 1" + } + ], + "dblp_key": "conf/popl/Pous15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676996", + "title": "Manifest Contracts for Datatypes", + "abstract": "We study algebraic data types in a manifest contract system, a software contract system where contract information occurs as refinement types. We first compare two simple approaches: refinements on type constructors and refinements on data constructors. For example, lists of positive integers can be described by {l:int list | for_all (lambda y. y > 0) l} in the former, whereas by a user-defined datatype pos_list with cons of type {x:int | x > 0} X pos_list -> pos_list in the latter. The two approaches are complementary: the former makes it easier for a programmer to write types and the latter enables more efficient contract checking. To take the best of both worlds, we propose (1) a syntactic translation from refinements on type constructors to equivalent refinements on data constructors and (2) dynamically checked casts between different but compatible datatypes such as int list and pos_list. We define a manifest contract calculus to formalize the semantics of the casts and prove that the translation is correct.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676996", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "Kyoto University" + }, + { + "first_name": "Yuki", + "last_name": "Nishida", + "institution": "Kyoto University" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/popl/SekiyamaNI15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676986", + "title": "Abstract Symbolic Automata: Mixed syntactic/semantic similarity analysis of executables", + "abstract": "We introduce a model for mixed syntactic/semantic approximation of programs based on symbolic finite automata (SFA). The edges of SFA are labeled by predicates whose semantics specifies the denotations that are allowed by the edge. We introduce the notion of abstract symbolic finite automaton (ASFA) where approximation is made by abstract interpretation of symbolic finite automata, acting both at syntactic (predicate) and semantic (denotation) level. We investigate in the details how the syntactic and semantic abstractions of SFA relate to each other and contribute to the determination of the recognized language. Then we introduce a family of transformations for simplifying ASFA. We apply this model to prove properties of commonly used tools for similarity analysis of binary executables. Following the structure of their control flow graphs, disassembled binary executables are represented as (concrete) SFA, where states are program points and predicates represent the (possibly infinite) I/O semantics of each basic block in a constraint form. Known tools for binary code analysis are viewed as specific choices of symbolic and semantic abstractions in our framework, making symbolic finite automata and their abstract interpretations a unifying model for comparing and reasoning about soundness and completeness of analyses of low-level code.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676986", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mila Dalla", + "last_name": "Preda", + "institution": "University of Verona" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Verona" + }, + { + "first_name": "Arun", + "last_name": "Lakhotia", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Isabella", + "last_name": "Mastroeni", + "institution": "University of Verona" + } + ], + "dblp_key": "conf/popl/PredaGLM15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676971", + "title": "Safe & Efficient Gradual Typing for TypeScript", + "abstract": "Current proposals for adding gradual typing to JavaScript, such as Closure, TypeScript and Dart, forgo soundness to deal with issues of scale, code reuse, and popular programming patterns. We show how to address these issues in practice while retaining soundness. We design and implement a new gradual type system, prototyped for expediency as a 'Safe' compilation mode for TypeScript. Our compiler achieves soundness by enforcing stricter static checks and embedding residual runtime checks in compiled code. It emits plain JavaScript that runs on stock virtual machines. Our main theorem is a simulation that ensures that the checks introduced by Safe TypeScript (1) catch any dynamic type error, and (2) do not alter the semantics of type-safe TypeScript code.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676971", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Oracle (United States)" + }, + { + "first_name": "Panagiotis", + "last_name": "Vekris", + "institution": "University of California San Diego" + } + ], + "dblp_key": "conf/popl/RastogiSFBV15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676965", + "title": "Equations, Contractions, and Unique Solutions", + "abstract": "One of the most studied behavioural equivalences is bisimilarity. Its success is much due to the associated bisimulation proof method, which can be further enhanced by means of \"up-to bisimulation\" techniques such as \"up-to context\".", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676965", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Davide", + "last_name": "Sangiorgi", + "institution": "University of Bologna" + } + ], + "dblp_key": "conf/popl/Sangiorgi15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676976", + "title": "A Meta Lambda Calculus with Cross-Level Computation", + "abstract": "We propose meta lambda calculus Lambda-* as a basic model of textual substitution via metavariables. The most important feature of the calculus is that every beta-redex can be reduced regardless of whether the beta-redex contains meta-level variables or not. Such a meta lambda calculus has never been achieved before due to difficulty to manage binding structure consistently with alpha-renaming in the presence of meta-level variables. We overcome the difficulty by introducing a new mechanism to deal with substitution and binding structure in a systematic way without the notion of free variables and alpha-renaming.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676976", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kazunori", + "last_name": "Tobisawa", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/Tobisawa15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676999", + "title": "Algebraic Effects, Linearity, and Quantum Programming Languages", + "abstract": "We develop a new framework of algebraic theories with linear parameters, and use it to analyze the equational reasoning principles of quantum computing and quantum programming languages. We use the framework as follows:", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676999", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "conf/popl/Staton15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676997", + "title": "Summary-Based Context-Sensitive Data-Dependence Analysis in Presence of Callbacks", + "abstract": "Building a summary for library code is a common approach to speeding up the analysis of client code. In presence of callbacks, some reachability relationships between library nodes cannot be obtained during library-code summarization. Thus, the library code may have to be analyzed again during the analysis of the client code with the library summary. In this paper, we propose to summarize library code with tree-adjoining-language (TAL) reachability. Compared with the summary built with context-free-language (CFL) reachability, the summary built with TAL reachability further contains conditional reachability relationships. The conditional reachability relationships can lead to much lighter analysis of the library code during the client code analysis with the TAL-reachability-based library summary. We also performed an experimental comparison of context-sensitive data-dependence analysis with the TAL-reachability-based library summary and context-sensitive data-dependence analysis with the CFL-reachability-based library summary using 15 benchmark subjects. Our experimental results demonstrate that the former has an 8X speed-up over the latter on average.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676997", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hao", + "last_name": "Tang", + "institution": "Peking University" + }, + { + "first_name": "Xiaoyin", + "last_name": "Wang", + "institution": "The University of Texas at San Antonio" + }, + { + "first_name": "Lingming", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Bing", + "last_name": "Xie", + "institution": "Peking University" + }, + { + "first_name": "Lu", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Hong", + "last_name": "Mei", + "institution": "Peking University" + } + ], + "dblp_key": "conf/popl/TangWZXZM15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2677014", + "title": "Data-Parallel String-Manipulating Programs", + "abstract": "String-manipulating programs are an important class of programs with applications in malware detection, graphics, input sanitization for Web security, and large-scale HTML processing. This paper extends prior work on BEK, an expressive domain-specific language for writing string-manipulating programs, with algorithmic insights that make BEK both analyzable and data-parallel. By analyzable we mean that unlike most general purpose programming languages, many algebraic properties of a BEK program are decidable (i.e., one can check whether two programs commute or compute the inverse of a program). By data-parallel we mean that a BEK program can compute on arbitrary subsections of its input in parallel, thus exploiting parallel hardware. This latter requirement is particularly important for programs which operate on large data: without data parallelism, a programmer cannot hide the latency of reading data from various storage media (i.e., reading a terabyte of data from a modern hard drive takes about 3 hours). With a data-parallel approach, the system can split data across multiple disks and thus hide the latency of reading the data.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2677014", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dávid", + "last_name": "Molnár", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/VeanesMML15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676995", + "title": "Common Compiler Optimisations are Invalid in the C11 Memory Model and what we can do about it", + "abstract": "We show that the weak memory model introduced by the 2011 C and C++ standards does not permit many common source-to-source program transformations (such as expression linearisation and \"roach motel\" reorderings) that modern compilers perform and that are deemed to be correct. As such it cannot be used to define the semantics of intermediate languages of compilers, as, for instance, LLVM aimed to. We consider a number of possible local fixes, some strengthening and some weakening the model. We evaluate the proposed fixes by determining which program transformations are valid with respect to each of the patched models. We provide formal Coq proofs of their correctness or counterexamples as appropriate.", + "date": "2014-12-19", + "link": "https://doi.org/10.1145/2676726.2676995", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Society" + }, + { + "first_name": "Thibaut", + "last_name": "Balabonski", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Robin", + "last_name": "Morisset", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/VafeiadisBCMN15", + "venue": "popl", + "year": 2015 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2016.json b/data/pl_conferences/popl/2016.json new file mode 100644 index 0000000..d18d724 --- /dev/null +++ b/data/pl_conferences/popl/2016.json @@ -0,0 +1,1868 @@ +[ + { + "paper_id": "10.1145/2837614.2837654", + "title": "Printing floating-point numbers: a faster, always correct method", + "abstract": "Floating-point numbers are an essential part of modern software, recently gaining particular prominence on the web as the exclusive numeric format of Javascript. To use floating-point numbers, we require a way to convert binary machine representations into human readable decimal outputs. Existing conversion algorithms make trade-offs between completeness and performance. The classic Dragon4 algorithm by Steele and White and its later refinements achieve completeness --- i.e. produce correct and optimal outputs on all inputs --- by using arbitrary precision integer (bignum) arithmetic which leads to a high performance cost. On the other hand, the recent Grisu3 algorithm by Loitsch shows how to recover performance by using native integer arithmetic but sacrifices optimality for 0.5% of all inputs. We present Errol, a new complete algorithm that is guaranteed to produce correct and optimal results for all inputs while simultaneously being 2x faster than the incomplete Grisu3 and 4x faster than previous complete methods.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837654", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marc", + "last_name": "Andrysco", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/popl/AndryscoJL16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837637", + "title": "Overhauling SC atomics in C11 and OpenCL", + "abstract": "Despite the conceptual simplicity of sequential consistency (SC), the semantics of SC atomic operations and fences in the C11 and OpenCL memory models is subtle, leading to convoluted prose descriptions that translate to complex axiomatic formalisations. We conduct an overhaul of SC atomics in C11, reducing the associated axioms in both number and complexity. A consequence of our simplification is that the SC operations in an execution no longer need to be totally ordered. This relaxation enables, for the first time, efficient and exhaustive simulation of litmus tests that use SC atomics. We extend our improved C11 model to obtain the first rigorous memory model formalisation for OpenCL (which extends C11 with support for heterogeneous many-core programming). In the OpenCL setting, we refine the SC axioms still further to give a sensible semantics to SC operations that employ a ‘memory scope’ to restrict their visibility to specific threads. Our overhaul requires slight strengthenings of both the C11 and the OpenCL memory models, causing some behaviours to become disallowed. We argue that these strengthenings are natural, and that all of the formalised C11 and OpenCL compilation schemes of which we are aware (Power and x86 CPUs for C11, AMD GPUs for OpenCL) remain valid in our revised models. Using the HERD memory model simulator, we show that our overhaul leads to an exponential improvement in simulation time for C11 litmus tests compared with the original model, making *exhaustive* simulation competitive, time-wise, with the *non-exhaustive* CDSChecker tool.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837637", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/BattyDW16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837660", + "title": "System f-omega with equirecursive types for datatype-generic programming", + "abstract": "Traversing an algebraic datatype by hand requires boilerplate code which duplicates the structure of the datatype. Datatype-generic programming (DGP) aims to eliminate such boilerplate code by decomposing algebraic datatypes into type constructor applications from which generic traversals can be synthesized. However, different traversals require different decompositions, which yield isomorphic but unequal types. This hinders the interoperability of different DGP techniques. In this paper, we propose Fωμ, an extension of the higher-order polymorphic lambda calculus Fω with records, variants, and equirecursive types. We prove the soundness of the type system, and show that type checking for first-order recursive types is decidable with a practical type checking algorithm. In our soundness proof we define type equality by interpreting types as infinitary λ-terms (in particular, Berarducci-trees). To decide type equality we β-normalize types, and then use an extension of equivalence checking for usual equirecursive types. Thanks to equirecursive types, new decompositions for a datatype can be added modularly and still interoperate with each other, allowing multiple DGP techniques to work together. We sketch how generic traversals can be synthesized, and apply these components to some examples. Since the set of datatype decomposition becomes extensible, System Fωμ enables using DGP techniques incrementally, instead of planning for them upfront or doing invasive refactoring.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837660", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yufei", + "last_name": "Cai", + "institution": "University of Tübingen" + }, + { + "first_name": "Paolo G.", + "last_name": "Giarrusso", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/popl/CaiGO16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837636", + "title": "SMO: an integrated approach to intra-array and inter-array storage optimization", + "abstract": "The polyhedral model provides an expressive intermediate representation that is convenient for the analysis and subsequent transformation of affine loop nests. Several heuristics exist for achieving complex program transformations in this model. However, there is also considerable scope to utilize this model to tackle the problem of automatic memory footprint optimization. In this paper, we present a new automatic storage optimization technique which can be used to achieve both intra-array as well as inter-array storage reuse with a pre-determined schedule for the computation. Our approach works by finding statement-wise storage partitioning hyperplanes that partition a unified global array space so that values with overlapping live ranges are not mapped to the same partition. Our heuristic is driven by a fourfold objective function which not only minimizes the dimensionality and storage requirements of arrays required for each high-level statement, but also maximizes inter-statement storage reuse. The storage mappings obtained using our heuristic can be asymptotically better than those obtained by any existing technique. We implement our technique and demonstrate its practical impact by evaluating its effectiveness on several benchmarks chosen from the domains of image processing, stencil computations, and high-performance computing.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837636", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Somashekaracharya G.", + "last_name": "Bhaskaracharya", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Uday", + "last_name": "Bondhugula", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/BhaskaracharyaB16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837628", + "title": "Maximal specification synthesis", + "abstract": "Many problems in program analysis, verification, and synthesis require inferring specifications of unknown procedures. Motivated by a broad range of applications, we formulate the problem of maximal specification inference: Given a postcondition Phi and a program P calling a set of unknown procedures F_1,…,F_n, what are the most permissive specifications of procedures F_i that ensure correctness of P? In other words, we are looking for the smallest number of assumptions we need to make about the behaviours of F_i in order to prove that $P$ satisfies its postcondition. To solve this problem, we present a novel approach that utilizes a counterexample-guided inductive synthesis loop and reduces the maximal specification inference problem to multi-abduction. We formulate the novel notion of multi-abduction as a generalization of classical logical abduction and present an algorithm for solving multi-abduction problems. On the practical side, we evaluate our specification inference technique on a range of benchmarks and demonstrate its ability to synthesize specifications of kernel routines invoked by device drivers.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837628", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Arie", + "last_name": "Gurfinkel", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/AlbarghouthiDG16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837656", + "title": "PolyCheck: dynamic verification of iteration space transformations on affine programs", + "abstract": "High-level compiler transformations, especially loop transformations, are widely recognized as critical optimizations to restructure programs to improve data locality and expose parallelism. Guaranteeing the correctness of program transformations is essential, and to date three main approaches have been developed: proof of equivalence of affine programs, matching the execution traces of programs, and checking bit-by-bit equivalence of program outputs. Each technique suffers from limitations in the kind of transformations supported, space complexity, or the sensitivity to the testing dataset. In this paper, we take a novel approach that addresses all three limitations to provide an automatic bug checker to verify any iteration reordering transformations on affine programs, including non-affine transformations, with space consumption proportional to the original program data and robust to arbitrary datasets of a given size. We achieve this by exploiting the structure of affine program control- and data-flow to generate at compile-time lightweight checker code to be executed within the transformed program. Experimental results assess the correctness and effectiveness of our method and its increased coverage over previous approaches.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837656", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wenlei", + "last_name": "Bao", + "institution": "The Ohio State University" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "The Ohio State University" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/popl/BaoKPRS16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837665", + "title": "Principal type inference for GADTs", + "abstract": "We present a new method for GADT type inference that improves the precision of previous approaches. In particular, our approach accepts more type-correct programs than previous approaches when they do not employ type annotations. A side benefit of our approach is that it can detect a wide range of runtime errors that are missed by previous approaches. Our method is based on the idea to represent type refinements in pattern-matching branches by choice types, which facilitate a separation of the typing and reconciliation phases and thus support case expressions. This idea is formalized in a type system, which is both sound and a conservative extension of the classical Hindley-Milner system. We present the results of an empirical evaluation that compares our algorithm with previous approaches.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837665", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Martin", + "last_name": "Erwig", + "institution": "Oregon State University" + } + ], + "dblp_key": "conf/popl/0008E16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837664", + "title": "Learning invariants using decision trees and implication counterexamples", + "abstract": "Inductive invariants can be robustly synthesized using a learning model where the teacher is a program verifier who instructs the learner through concrete program configurations, classified as positive, negative, and implications. We propose the first learning algorithms in this model with implication counter-examples that are based on machine learning techniques. In particular, we extend classical decision-tree learning algorithms in machine learning to handle implication samples, building new scalable ways to construct small decision trees using statistical measures. We also develop a decision-tree learning algorithm in this model that is guaranteed to converge to the right concept (invariant) if one exists. We implement the learners and an appropriate teacher, and show that the resulting invariant synthesis is efficient and convergent for a large suite of programs.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837664", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pranav", + "last_name": "Garg", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Daniel", + "last_name": "Neider", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Dan", + "last_name": "Roth", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/popl/0001NMR16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837624", + "title": "Algorithms for algebraic path properties in concurrent systems of constant treewidth components", + "abstract": "We study algorithmic questions for concurrent systems where the transitions are labeled from a complete, closed semiring, and path properties are algebraic with semiring operations. The algebraic path properties can model dataflow analysis problems, the shortest path problem, and many other natural problems that arise in program analysis. We consider that each component of the concurrent system is a graph with constant treewidth, a property satisfied by the controlflow graphs of most programs. We allow for multiple possible queries, which arise naturally in demand driven dataflow analysis. The study of multiple queries allows us to consider the tradeoff between the resource usage of the one-time preprocessing and for each individual query. The traditional approach constructs the product graph of all components and applies the best-known graph algorithm on the product. In this approach, even the answer to a single query requires the transitive closure (i.e., the results of all possible queries), which provides no room for tradeoff between preprocessing and query time. Our main contributions are algorithms that significantly improve the worst-case running time of the traditional approach, and provide various tradeoffs depending on the number of queries. For example, in a concurrent system of two components, the traditional approach requires hexic time in the worst case for answering one query as well as computing the transitive closure, whereas we show that with one-time preprocessing in almost cubic time, each subsequent query can be answered in at most linear time, and even the transitive closure can be computed in almost quartic time. Furthermore, we establish conditional optimality results showing that the worst-case running time of our algorithms cannot be improved without achieving major breakthroughs in graph algorithms (i.e., improving the worst-case bound for the shortest path problem in general graphs). Preliminary experimental results show that our algorithms perform favorably on several benchmarks.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837624", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Rasmus", + "last_name": "Ibsen-Jensen", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "conf/popl/ChatterjeeGIP16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837621", + "title": "Model checking for symbolic-heap separation logic with inductive predicates", + "abstract": "We investigate the *model checking* problem for symbolic-heap separation logic with user-defined inductive predicates, i.e., the problem of checking that a given stack-heap memory state satisfies a given formula in this language, as arises e.g. in software testing or runtime verification. First, we show that the problem is *decidable*; specifically, we present a bottom-up fixed point algorithm that decides the problem and runs in exponential time in the size of the problem instance. Second, we show that, while model checking for the full language is EXPTIME-complete, the problem becomes NP-complete or PTIME-solvable when we impose natural syntactic restrictions on the schemata defining the inductive predicates. We additionally present NP and PTIME algorithms for these restricted fragments. Finally, we report on the experimental performance of our procedures on a variety of specifications extracted from programs, exercising multiple combinations of syntactic restrictions.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837621", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J G.", + "last_name": "Brotherston", + "institution": "University College London" + }, + { + "first_name": "Nikos", + "last_name": "Gorogiannis", + "institution": "Middlesex University" + }, + { + "first_name": "Max", + "last_name": "Kanovich", + "institution": "National Research University Higher School of Economics" + }, + { + "first_name": "Reuben N. S.", + "last_name": "Rowe", + "institution": "University College London" + } + ], + "dblp_key": "conf/popl/BrotherstonGKR16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837649", + "title": "Symbolic computation of differential equivalences", + "abstract": "Ordinary differential equations (ODEs) are widespread in many natural sciences including chemistry, ecology, and systems biology, and in disciplines such as control theory and electrical engineering. Building on the celebrated molecules-as-processes paradigm, they have become increasingly popular in computer science, with high-level languages and formal methods such as Petri nets, process algebra, and rule-based systems that are interpreted as ODEs. We consider the problem of comparing and minimizing ODEs automatically. Influenced by traditional approaches in the theory of programming, we propose differential equivalence relations. We study them for a basic intermediate language, for which we have decidability results, that can be targeted by a class of high-level specifications. An ODE implicitly represents an uncountable state space, hence reasoning techniques cannot be borrowed from established domains such as probabilistic programs with finite-state Markov chain semantics. We provide novel symbolic procedures to check an equivalence and compute the largest one via partition refinement algorithms that use satisfiability modulo theories. We illustrate the generality of our framework by showing that differential equivalences include (i) well-known notions for the minimization of continuous-time Markov chains (lumpability), (ii)~bisimulations for chemical reaction networks recently proposed by Cardelli et al., and (iii) behavioral relations for process algebra with ODE semantics. With a prototype implementation we are able to detect equivalences in biochemical models from the literature that cannot be reduced using competing automatic techniques.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837649", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Cardelli", + "institution": "University of Oxford" + }, + { + "first_name": "Mirco", + "last_name": "Tribastone", + "institution": "IMT School for Advanced Studies Lucca" + }, + { + "first_name": "Max", + "last_name": "Tschaikowski", + "institution": "IMT School for Advanced Studies Lucca" + }, + { + "first_name": "Andrea", + "last_name": "Vandin", + "institution": "IMT School for Advanced Studies Lucca" + } + ], + "dblp_key": "conf/popl/CardelliTTV16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837623", + "title": "Breaking through the normalization barrier: a self-interpreter for f-omega", + "abstract": "According to conventional wisdom, a self-interpreter for a strongly normalizing lambda-calculus is impossible. We call this the normalization barrier. The normalization barrier stems from a theorem in computability theory that says that a total universal function for the total computable functions is impossible. In this paper we break through the normalization barrier and define a self-interpreter for System F_omega, a strongly normalizing lambda-calculus. After a careful analysis of the classical theorem, we show that static type checking in F_omega can exclude the proof's diagonalization gadget, leaving open the possibility for a self-interpreter. Along with the self-interpreter, we program four other operations in F_omega, including a continuation-passing style transformation. Our operations rely on a new approach to program representation that may be useful in theorem provers and compilers.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837623", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matt", + "last_name": "Brown", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/popl/BrownP16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837653", + "title": "Fabular: regression formulas as probabilistic programming", + "abstract": "Regression formulas are a domain-specific language adopted by several R packages for describing an important and useful class of statistical models: hierarchical linear regressions. Formulas are succinct, expressive, and clearly popular, so are they a useful addition to probabilistic programming languages? And what do they mean? We propose a core calculus of hierarchical linear regression, in which regression coefficients are themselves defined by nested regressions (unlike in R). We explain how our calculus captures the essence of the formula DSL found in R. We describe the design and implementation of Fabular, a version of the Tabular schema-driven probabilistic programming language, enriched with formulas based on our regression calculus. To the best of our knowledge, this is the first formal description of the core ideas of R's formula notation, the first development of a calculus of regression formulas, and the first demonstration of the benefits of composing regression formulas and latent variables in a probabilistic programming language.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837653", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Borgström", + "institution": "Uppsala University" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Long", + "last_name": "Ouyang", + "institution": "Stanford University" + }, + { + "first_name": "Claudio", + "last_name": "Russo", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Adam", + "last_name": "Ścibior", + "institution": "University of Cambridge" + }, + { + "first_name": "Marcin", + "last_name": "Szymczak", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/BorgstromGORSS16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837638", + "title": "Type theory in type theory using quotient inductive types", + "abstract": "We present an internal formalisation of a type heory with dependent types in Type Theory using a special case of higher inductive types from Homotopy Type Theory which we call quotient inductive types (QITs). Our formalisation of type theory avoids referring to preterms or a typability relation but defines directly well typed objects by an inductive definition. We use the elimination principle to define the set-theoretic and logical predicate interpretation. The work has been formalized using the Agda system extended with QITs using postulates.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837638", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thorsten", + "last_name": "Altenkirch", + "institution": "University of Nottingham" + }, + { + "first_name": "Ambrus", + "last_name": "Kaposi", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/popl/AltenkirchK16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837639", + "title": "Algorithmic analysis of qualitative and quantitative termination problems for affine probabilistic programs", + "abstract": "In this paper, we consider termination of probabilistic programs with real-valued variables. The questions concerned are: 1. qualitative ones that ask (i) whether the program terminates with probability 1 (almost-sure termination) and (ii) whether the expected termination time is finite (finite termination); 2. quantitative ones that ask (i) to approximate the expected termination time (expectation problem) and (ii) to compute a bound B such that the probability to terminate after B steps decreases exponentially (concentration problem). To solve these questions, we utilize the notion of ranking supermartingales which is a powerful approach for proving termination of probabilistic programs. In detail, we focus on algorithmic synthesis of linear ranking-supermartingales over affine probabilistic programs (APP's) with both angelic and demonic non-determinism. An important subclass of APP's is LRAPP which is defined as the class of all APP's over which a linear ranking-supermartingale exists. Our main contributions are as follows. Firstly, we show that the membership problem of LRAPP (i) can be decided in polynomial time for APP's with at most demonic non-determinism, and (ii) is NP-hard and in PSPACE for APP's with angelic non-determinism; moreover, the NP-hardness result holds already for APP's without probability and demonic non-determinism. Secondly, we show that the concentration problem over LRAPP can be solved in the same complexity as for the membership problem of LRAPP. Finally, we show that the expectation problem over LRAPP can be solved in 2EXPTIME and is PSPACE-hard even for APP's without probability and non-determinism (i.e., deterministic programs). Our experimental results demonstrate the effectiveness of our approach to answer the qualitative and quantitative questions over APP's with at most demonic non-determinism.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837639", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Petr", + "last_name": "Novotný", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Rouzbeh", + "last_name": "Hasheminezhad", + "institution": "Sharif University of Technology" + } + ], + "dblp_key": "conf/popl/ChatterjeeFNH16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837666", + "title": "Optimizing synthesis with metasketches", + "abstract": "Many advanced programming tools---for both end-users and expert developers---rely on program synthesis to automatically generate implementations from high-level specifications. These tools often need to employ tricky, custom-built synthesis algorithms because they require synthesized programs to be not only correct, but also optimal with respect to a desired cost metric, such as program size. Finding these optimal solutions efficiently requires domain-specific search strategies, but existing synthesizers hard-code the strategy, making them difficult to reuse. This paper presents metasketches, a general framework for specifying and solving optimal synthesis problems. metasketches make the search strategy a part of the problem definition by specifying a fragmentation of the search space into an ordered set of classic sketches. We provide two cooperating search algorithms to effectively solve metasketches. A global optimizing search coordinates the activities of local searches, informing them of the costs of potentially-optimal solutions as they explore different regions of the candidate space in parallel. The local searches execute an incremental form of counterexample-guided inductive synthesis to incorporate information sent from the global search. We present Synapse, an implementation of these algorithms, and show that it effectively solves optimal synthesis problems with a variety of different cost functions. In addition, metasketches can be used to accelerate classic (non-optimal) synthesis by explicitly controlling the search strategy, and we show that Synapse solves classic synthesis problems that state-of-the-art tools cannot.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837666", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James", + "last_name": "Bornholt", + "institution": "University of Washington" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/popl/BornholtTGC16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837632", + "title": "The gradualizer: a methodology and algorithm for generating gradual type systems", + "abstract": "Many languages are beginning to integrate dynamic and static typing. Siek and Taha offered gradual typing as an approach to this integration that provides a coherent and full-span migration between the two disciplines. However, the literature lacks a general methodology for designing gradually typed languages. Our first contribution is to provide a methodology for deriving the gradual type system and the compilation to the cast calculus. Based on this methodology, we present the Gradualizer, an algorithm that generates a gradual type system from a well-formed type system and also generates a compiler to the cast calculus. Our algorithm handles a large class of type systems and generates systems that are correct with respect to the formal criteria of gradual typing. We also report on an implementation of the Gradualizer that takes a type system expressed in lambda-prolog and outputs its gradually typed version and a compiler to the cast calculus in lambda-prolog.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837632", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matteo", + "last_name": "Cimini", + "institution": "Indiana University" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/popl/CiminiS16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837645", + "title": "Symbolic abstract data type inference", + "abstract": "Formal specification is a vital ingredient to scalable verification of software systems. In the case of efficient implementations of concurrent objects like atomic registers, queues, and locks, symbolic formal representations of their abstract data types (ADTs) enable efficient modular reasoning, decoupling clients from implementations. Writing adequate formal specifications, however, is a complex task requiring rare expertise. In practice, programmers write reference implementations as informal specifications. In this work we demonstrate that effective symbolic ADT representations can be automatically generated from the executions of reference implementations. Our approach exploits two key features of naturally-occurring ADTs: violations can be decomposed into a small set of representative patterns, and these patterns manifest in executions with few operations. By identifying certain algebraic properties of naturally-occurring ADTs, and exhaustively sampling executions up to a small number of operations, we generate concise symbolic ADT representations which are complete in practice, enabling the application of efficient symbolic verification algorithms without the burden of manual specification. Furthermore, the concise ADT violation patterns we generate are human-readable, and can serve as useful, formal documentation.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837645", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "IMDEA Software" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "conf/popl/EmmiE16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837620", + "title": "Binding as sets of scopes", + "abstract": "Our new macro expander for Racket builds on a novel approach to hygiene. Instead of basing macro expansion on variable renamings that are mediated by expansion history, our new expander tracks binding through a set of scopes that an identifier acquires from both binding forms and macro expansions. The resulting model of macro expansion is simpler and more uniform than one based on renaming, and it is sufficiently compatible with Racket's old expander to be practical.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837620", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/Flatt16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837652", + "title": "A theory of effects and resources: adjunction models and polarised calculi", + "abstract": "We consider the Curry-Howard-Lambek correspondence for effectful computation and resource management, specifically proposing polarised calculi together with presheaf-enriched adjunction models as the starting point for a comprehensive semantic theory relating logical systems, typed calculi, and categorical models in this context. Our thesis is that the combination of effects and resources should be considered orthogonally. Model theoretically, this leads to an understanding of our categorical models from two complementary perspectives: (i) as a linearisation of CBPV (Call-by-Push-Value) adjunction models, and (ii) as an extension of linear/non-linear adjunction models with an adjoint resolution of computational effects. When the linear structure is cartesian and the resource structure is trivial we recover Levy’s notion of CBPV adjunction model, while when the effect structure is trivial we have Benton’s linear/non-linear adjunction models. Further instances of our model theory include the dialogue categories with a resource modality of Melliès and Tabareau, and the [E]EC ([Enriched] Effect Calculus) models of Egger, Møgelberg and Simpson. Our development substantiates the approach by providing a lifting theorem of linear models into cartesian ones. To each of our categorical models we systematically associate a typed term calculus, each of which corresponds to a variant of the sequent calculi LJ (Intuitionistic Logic) or ILL (Intuitionistic Linear Logic). The adjoint resolution of effects corresponds to polarisation whereby, syntactically, types locally determine a strict or lazy evaluation order and, semantically, the associativity of cuts is relaxed. In particular, our results show that polarisation provides a computational interpretation of CBPV in direct style. Further, we characterise depolarised models: those where the cut is associative, and where the evaluation order is unimportant. We explain possible advantages of this style of calculi for the operational semantics of effects.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837652", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre-Louis", + "last_name": "Curien", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Marcelo", + "last_name": "Fiore", + "institution": "University of Cambridge" + }, + { + "first_name": "Guillaume", + "last_name": "Munch-Maccagnoni", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/CurienFM16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837618", + "title": "Fully-abstract compilation by approximate back-translation", + "abstract": "A compiler is fully-abstract if the compilation from source language programs to target language programs reflects and preserves behavioural equivalence. Such compilers have important security benefits, as they limit the power of an attacker interacting with the program in the target language to that of an attacker interacting with the program in the source language. Proving compiler full-abstraction is, however, rather complicated. A common proof technique is based on the back-translation of target-level program contexts to behaviourally-equivalent source-level contexts. However, constructing such a back-translation is problematic when the source language is not strong enough to embed an encoding of the target language. For instance, when compiling from the simply-typed λ-calculus (λτ) to the untyped λ-calculus (λu), the lack of recursive types in λτ prevents such a back-translation. We propose a general and elegant solution for this problem. The key insight is that it suffices to construct an approximate back-translation. The approximation is only accurate up to a certain number of steps and conservative beyond that, in the sense that the context generated by the back-translation may diverge when the original would not, but not vice versa. Based on this insight, we describe a general technique for proving compiler full-abstraction and demonstrate it on a compiler from λτ to λu . The proof uses asymmetric cross-language logical relations and makes innovative use of step-indexing to express the relation between a context and its approximate back-translation. We believe this proof technique can scale to challenging settings and enable simpler, more scalable proofs of compiler full-abstraction.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837618", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/popl/DevriesePP16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837629", + "title": "Example-directed synthesis: a type-theoretic interpretation", + "abstract": "Input-output examples have emerged as a practical and user-friendly specification mechanism for program synthesis in many environments. While example-driven tools have demonstrated tangible impact that has inspired adoption in industry, their underlying semantics are less well-understood: what are \"examples\" and how do they relate to other kinds of specifications? This paper demonstrates that examples can, in general, be interpreted as refinement types. Seen in this light, program synthesis is the task of finding an inhabitant of such a type. This insight provides an immediate semantic interpretation for examples. Moreover, it enables us to exploit decades of research in type theory as well as its correspondence with intuitionistic logic rather than designing ad hoc theoretical frameworks for synthesis from scratch. We put this observation into practice by formalizing synthesis as proof search in a sequent calculus with intersection and union refinements that we prove to be sound with respect to a conventional type system. In addition, we show how to handle negative examples, which arise from user feedback or counterexample-guided loops. This theory serves as the basis for a prototype implementation that extends our core language to support ML-style algebraic data types and structurally inductive functions. Users can also specify synthesis goals using polymorphic refinements and import monomorphic libraries. The prototype serves as a vehicle for empirically evaluating a number of different strategies for resolving the nondeterminism of the sequent calculus---bottom-up theorem-proving, term enumeration with refinement type checking, and combinations of both---the results of which classify, explain, and validate the design choices of existing synthesis systems. It also provides a platform for measuring the practical value of a specification language that combines \"examples\" with the more general expressiveness of refinements.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837629", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Frankle", + "institution": "Princeton University" + }, + { + "first_name": "Peter-Michael", + "last_name": "Osera", + "institution": "Grinnell College" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/FrankleOWZ16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837670", + "title": "Abstracting gradual typing", + "abstract": "Language researchers and designers have extended a wide variety of type systems to support gradual typing, which enables languages to seamlessly combine dynamic and static checking. These efforts consistently demonstrate that designing a satisfactory gradual counterpart to a static type system is challenging, and this challenge only increases with the sophistication of the type system. Gradual type system designers need more formal tools to help them conceptualize, structure, and evaluate their designs. In this paper, we propose a new formal foundation for gradual typing, drawing on principles from abstract interpretation to give gradual types a semantics in terms of pre-existing static types. Abstracting Gradual Typing (AGT for short) yields a formal account of consistency---one of the cornerstones of the gradual typing approach---that subsumes existing notions of consistency, which were developed through intuition and ad hoc reasoning. Given a syntax-directed static typing judgment, the AGT approach induces a corresponding gradual typing judgment. Then the type safety proof for the underlying static discipline induces a dynamic semantics for gradual programs defined over source-language typing derivations. The AGT approach does not resort to an externally justified cast calculus: instead, run-time checks naturally arise by deducing evidence for consistent judgments during proof reduction. To illustrate the approach, we develop a novel gradually-typed counterpart for a language with record subtyping. Gradual languages designed with the AGT approach satisfy by construction the refined criteria for gradual typing set forth by Siek and colleagues.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837670", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + }, + { + "first_name": "Alison M.", + "last_name": "Clark", + "institution": "University of British Columbia" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/popl/GarciaCT16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837631", + "title": "Pushdown control-flow analysis for free", + "abstract": "Traditional control-flow analysis (CFA) for higher-order languages introduces spurious connections between callers and callees, and different invocations of a function may pollute each other's return flows. Recently, three distinct approaches have been published that provide perfect call-stack precision in a computable manner: CFA2, PDCFA, and AAC. Unfortunately, implementing CFA2 and PDCFA requires significant engineering effort. Furthermore, all three are computationally expensive. For a monovariant analysis, CFA2 is in O(2^n), PDCFA is in O(n^6), and AAC is in O(n^8). In this paper, we describe a new technique that builds on these but is both straightforward to implement and computationally inexpensive. The crucial insight is an unusual state-dependent allocation strategy for the addresses of continuations. Our technique imposes only a constant-factor overhead on the underlying analysis and costs only O(n^3) in the monovariant case. We present the intuitions behind this development, benchmarks demonstrating its efficacy, and a proof of the precision of this analysis.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837631", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Gilray", + "institution": "University of Utah" + }, + { + "first_name": "Steven", + "last_name": "Lyde", + "institution": "University of Utah" + }, + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/popl/GilrayL0MH16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837650", + "title": "PSync: a partially synchronous language for fault-tolerant distributed algorithms", + "abstract": "Fault-tolerant distributed algorithms play an important role in many critical/high-availability applications. These algorithms are notoriously difficult to implement correctly, due to asynchronous communication and the occurrence of faults, such as the network dropping messages or computers crashing. We introduce PSync, a domain specific language based on the Heard-Of model, which views asynchronous faulty systems as synchronous ones with an adversarial environment that simulates asynchrony and faults by dropping messages. We define a runtime system for PSync that efficiently executes on asynchronous networks. We formalise the relation between the runtime system and PSync in terms of observational refinement. The high-level lockstep abstraction introduced by PSync simplifies the design and implementation of fault-tolerant distributed algorithms and enables automated formal verification. We have implemented an embedding of PSync in the Scala programming language with a runtime system for partially synchronous networks. We show the applicability of PSync by implementing several important fault-tolerant distributed algorithms and we compare the implementation of consensus algorithms in PSync against implementations in other languages in terms of code size, runtime efficiency, and verification.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837650", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cezara", + "last_name": "Drăgoi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Damien", + "last_name": "Zufferey", + "institution": "Vassar College" + } + ], + "dblp_key": "conf/popl/DragoiHZ16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837615", + "title": "Modelling the ARMv8 architecture, operationally: concurrency and ISA", + "abstract": "In this paper we develop semantics for key aspects of the ARMv8 multiprocessor architecture: the concurrency model and much of the 64-bit application-level instruction set (ISA). Our goal is to clarify what the range of architecturally allowable behaviour is, and thereby to support future work on formal verification, analysis, and testing of concurrent ARM software and hardware. Establishing such models with high confidence is intrinsically difficult: it involves capturing the vendor's architectural intent, aspects of which (especially for concurrency) have not previously been precisely defined. We therefore first develop a concurrency model with a microarchitectural flavour, abstracting from many hardware implementation concerns but still close to hardware-designer intuition. This means it can be discussed in detail with ARM architects. We then develop a more abstract model, better suited for use as an architectural specification, which we prove sound w.r.t.~the first. The instruction semantics involves further difficulties, handling the mass of detail and the subtle intensional information required to interface to the concurrency model. We have a novel ISA description language, with a lightweight dependent type system, letting us do both with a rather direct representation of the ARM reference manual instruction descriptions. We build a tool from the combined semantics that lets one explore, either interactively or exhaustively, the full range of architecturally allowed behaviour, for litmus tests and (small) ELF executables. We prove correctness of some optimisations needed for tool performance. We validate the models by discussion with ARM staff, and by comparison against ARM hardware behaviour, for ISA single- instruction tests and concurrent litmus tests.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837615", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shaked", + "last_name": "Flur", + "institution": "University of Cambridge" + }, + { + "first_name": "Kathryn E.", + "last_name": "Gray", + "institution": "University of Cambridge" + }, + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of St Andrews" + }, + { + "first_name": "Ali", + "last_name": "Sezgin", + "institution": "University of Cambridge" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Will", + "last_name": "Deacon", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/FlurGPSSMDS16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837646", + "title": "The complexity of interaction", + "abstract": "In this paper, we analyze the complexity of functional programs written in the interaction-net computation model, an asynchronous, parallel and confluent model that generalizes linear-logic proof nets. Employing user-defined sized and scheduled types, we certify concrete time, space and space-time complexity bounds for both sequential and parallel reductions of interaction-net programs by suitably assigning complexity potentials to typed nodes. The relevance of this approach is illustrated on archetypal programming examples. The provided analysis is precise, compositional and is, in theory, not restricted to particular complexity classes.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837646", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stéphane", + "last_name": "Gimenez", + "institution": "Universität Innsbruck" + }, + { + "first_name": "Georg", + "last_name": "Moser", + "institution": "Universität Innsbruck" + } + ], + "dblp_key": "conf/popl/GimenezM16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837673", + "title": "Lattice-theoretic progress measures and coalgebraic model checking", + "abstract": "In the context of formal verification in general and model checking in particular, parity games serve as a mighty vehicle: many problems are encoded as parity games, which are then solved by the seminal algorithm by Jurdzinski. In this paper we identify the essence of this workflow to be the notion of progress measure, and formalize it in general, possibly infinitary, lattice-theoretic terms. Our view on progress measures is that they are to nested/alternating fixed points what invariants are to safety/greatest fixed points, and what ranking functions are to liveness/least fixed points. That is, progress measures are combination of the latter two notions (invariant and ranking function) that have been extensively studied in the context of (program) verification. We then apply our theory of progress measures to a general model-checking framework, where systems are categorically presented as coalgebras. The framework's theoretical robustness is witnessed by a smooth transfer from the branching-time setting to the linear-time one. Although the framework can be used to derive some decision procedures for finite settings, we also expect the proposed framework to form a basis for sound proof methods for some undecidable/infinitary problems.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837673", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ichiro", + "last_name": "Hasuo", + "institution": "The University of Tokyo" + }, + { + "first_name": "Shunsuke", + "last_name": "Shimizu", + "institution": "The University of Tokyo" + }, + { + "first_name": "Corina", + "last_name": "Ĉırstea", + "institution": "University of Southampton" + } + ], + "dblp_key": "conf/popl/HasuoSC16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837647", + "title": "Kleenex: compiling nondeterministic transducers to deterministic streaming transducers", + "abstract": "We present and illustrate Kleenex, a language for expressing general nondeterministic finite transducers, and its novel compilation to streaming string transducers with essentially optimal streaming behavior, worst-case linear-time performance and sustained high throughput. Its underlying theory is based on transducer decomposition into oracle and action machines: the oracle machine performs streaming greedy disambiguation of the input; the action machine performs the output actions. In use cases Kleenex achieves consistently high throughput rates around the 1 Gbps range on stock hardware. It performs well, especially in complex use cases, in comparison to both specialized and related tools such as GNUawk, GNUsed, GNUgrep, RE2, Ragel and regular-expression libraries.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837647", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bjørn Bugge", + "last_name": "Grathwohl", + "institution": "University of Copenhagen" + }, + { + "first_name": "Fritz", + "last_name": "Henglein", + "institution": "University of Copenhagen" + }, + { + "first_name": "Ulrik Terp", + "last_name": "Rasmussen", + "institution": "University of Copenhagen" + }, + { + "first_name": "Kristoffer Aalund", + "last_name": "Søholm", + "institution": "" + }, + { + "first_name": "Sebastian Paaske", + "last_name": "Tørholm", + "institution": "" + } + ], + "dblp_key": "conf/popl/GrathwohlHRST16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837663", + "title": "Abstraction refinement guided by a learnt probabilistic model", + "abstract": "The core challenge in designing an effective static program analysis is to find a good program abstraction -- one that retains only details relevant to a given query. In this paper, we present a new approach for automatically finding such an abstraction. Our approach uses a pessimistic strategy, which can optionally use guidance from a probabilistic model. Our approach applies to parametric static analyses implemented in Datalog, and is based on counterexample-guided abstraction refinement. For each untried abstraction, our probabilistic model provides a probability of success, while the size of the abstraction provides an estimate of its cost in terms of analysis time. Combining these two metrics, probability and cost, our refinement algorithm picks an optimal abstraction. Our probabilistic model is a variant of the Erdos--Renyi random graph model, and it is tunable by what we call hyperparameters. We present a method to learn good values for these hyperparameters, by observing past runs of the analysis on an existing codebase. We evaluate our approach on an object sensitive pointer analysis for Java programs, with two client analyses (PolySite and Downcast).", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837663", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Radu", + "last_name": "Grigore", + "institution": "University of Oxford" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/GrigoreY16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837627", + "title": "Unboundedness and downward closures of higher-order pushdown automata", + "abstract": "We show the diagonal problem for higher-order pushdown automata (HOPDA), and hence the simultaneous unboundedness problem, is decidable. From recent work by Zetzsche this means that we can construct the downward closure of the set of words accepted by a given HOPDA. This also means we can construct the downward closure of the Parikh image of a HOPDA. Both of these consequences play an important role in verifying concurrent higher-order programs expressed as HOPDA or safe higher-order recursion schemes.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837627", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "University of London" + }, + { + "first_name": "Jonathan", + "last_name": "Kochems", + "institution": "University of Oxford" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/popl/HagueKO16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837625", + "title": "'Cause I'm strong enough: reasoning about consistency choices in distributed systems", + "abstract": "Large-scale distributed systems often rely on replicated databases that allow a programmer to request different data consistency guarantees for different operations, and thereby control their performance. Using such databases is far from trivial: requesting stronger consistency in too many places may hurt performance, and requesting it in too few places may violate correctness. To help programmers in this task, we propose the first proof rule for establishing that a particular choice of consistency guarantees for various operations on a replicated database is enough to ensure the preservation of a given data integrity invariant. Our rule is modular: it allows reasoning about the behaviour of every operation separately under some assumption on the behaviour of other operations. This leads to simple reasoning, which we have automated in an SMT-based tool. We present a nontrivial proof of soundness of our rule and illustrate its use on several examples.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837625", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "IMDEA Software" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + }, + { + "first_name": "Carla", + "last_name": "Ferreira", + "institution": "University of Lisbon" + }, + { + "first_name": "Mahsa", + "last_name": "Najafzadeh", + "institution": "Sorbonne Université" + }, + { + "first_name": "Marc", + "last_name": "Shapiro", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "conf/popl/GotsmanYFNS16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837642", + "title": "Lightweight verification of separate compilation", + "abstract": "Major compiler verification efforts, such as the CompCert project, have traditionally simplified the verification problem by restricting attention to the correctness of whole-program compilation, leaving open the question of how to verify the correctness of separate compilation. Recently, a number of sophisticated techniques have been proposed for proving more flexible, compositional notions of compiler correctness, but these approaches tend to be quite heavyweight compared to the simple \"closed simulations\" used in verifying whole-program compilation. Applying such techniques to a compiler like CompCert, as Stewart et al. have done, involves major changes and extensions to its original verification. In this paper, we show that if we aim somewhat lower---to prove correctness of separate compilation, but only for a *single* compiler---we can drastically simplify the proof effort. Toward this end, we develop several lightweight techniques that recast the compositional verification problem in terms of whole-program compilation, thereby enabling us to largely reuse the closed-simulation proofs from existing compiler verifications. We demonstrate the effectiveness of these techniques by applying them to CompCert 2.4, converting its verification of whole-program compilation into a verification of separate compilation in less than two person-months. This conversion only required a small number of changes to the original proofs, and uncovered two compiler bugs along the way. The result is SepCompCert, the first verification of separate compilation for the full CompCert compiler.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837642", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Seoul National University" + }, + { + "first_name": "Yoonseung", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/KangKHDV16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837662", + "title": "Monitors and blame assignment for higher-order session types", + "abstract": "Session types provide a means to prescribe the communication behavior between concurrent message-passing processes. However, in a distributed setting, some processes may be written in languages that do not support static typing of sessions or may be compromised by a malicious intruder, violating invariants of the session types. In such a setting, dynamically monitoring communication between processes becomes a necessity for identifying undesirable actions. In this paper, we show how to dynamically monitor communication to enforce adherence to session types in a higher-order setting. We present a system of blame assignment in the case when the monitor detects an undesirable action and an alarm is raised. We prove that dynamic monitoring does not change system behavior for welltyped processes, and that one of an indicated set of possible culprits must have been compromised in case of an alarm.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837662", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Hannah", + "last_name": "Gommerstadt", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/JiaGP16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837674", + "title": "Estimating types in binaries using predictive modeling", + "abstract": "Reverse engineering is an important tool in mitigating vulnerabilities in binaries. As a lot of software is developed in object-oriented languages, reverse engineering of object-oriented code is of critical importance. One of the major hurdles in reverse engineering binaries compiled from object-oriented code is the use of dynamic dispatch. In the absence of debug information, any dynamic dispatch may seem to jump to many possible targets, posing a significant challenge to a reverse engineer trying to track the program flow. We present a novel technique that allows us to statically determine the likely targets of virtual function calls. Our technique uses object tracelets – statically constructed sequences of operations performed on an object – to capture potential runtime behaviors of the object. Our analysis automatically pre-labels some of the object tracelets by relying on instances where the type of an object is known. The resulting type-labeled tracelets are then used to train a statistical language model (SLM) for each type.We then use the resulting ensemble of SLMs over unlabeled tracelets to generate a ranking of their most likely types, from which we deduce the likely targets of dynamic dispatches.We have implemented our technique and evaluated it over real-world C++ binaries. Our evaluation shows that when there are multiple alternative targets, our approach can drastically reduce the number of targets that have to be considered by a reverse engineer.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837674", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Omer", + "last_name": "Katz", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Ran", + "last_name": "El‐Yaniv", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/popl/KatzEY16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2843894", + "title": "Synthesis of reactive controllers for hybrid systems (keynote)", + "abstract": "Decision-making logic in hybrid systems is responsible for selecting modes of operation for the underlying (continuous) control system, reacting to external events and failures in the system, and insuring that the overall control system is satisfying safety and performance specifications. Tools from computer science, such as model-checking and logic synthesis, combined with design patterns from feedback control theory provide new approaches to solving these problems. A major shift is the move from ``design then verify'' to ``specify then synthesize'' approaches to controller design that allow simultaneous synthesis of high-performance, robust control laws and correct-by-construction decision-making logic.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2843894", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Richard M.", + "last_name": "Murray", + "institution": "California Institute of Technology" + } + ], + "dblp_key": "conf/popl/Murray16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837643", + "title": "Taming release-acquire consistency", + "abstract": "We introduce a strengthening of the release-acquire fragment of the C11 memory model that (i) forbids dubious behaviors that are not observed in any implementation; (ii) supports fence instructions that restore sequential consistency; and (iii) admits an equivalent intuitive operational semantics based on point-to-point communication. This strengthening has no additional implementation cost: it allows the same local optimizations as C11 release and acquire accesses, and has exactly the same compilation schemes to the x86-TSO and Power architectures. In fact, the compilation to Power is complete with respect to a recent axiomatic model of Power; that is, the compiled program exhibits exactly the same behaviors as the source one. Moreover, we provide criteria for placing enough fence instructions to ensure sequential consistency, and apply them to an efficient RCU implementation.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837643", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Nick", + "last_name": "Giannarakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/LahavGV16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2843895", + "title": "Programming the world of uncertain things (keynote)", + "abstract": "Computing has entered the era of uncertain data, in which hardware and software generate and reason about estimates. Applications use estimates from sensors, machine learning, big data, humans, and approximate hardware and software. Unfortunately, developers face pervasive correctness, programmability, and optimization problems due to estimates. Most programming languages unfortunately make these problems worse. We propose a new programming abstraction called Uncertain embedded into languages, such as C#, C++, Java, Python, and JavaScript. Applications that consume estimates use familiar discrete operations for their estimates; overloaded conditional operators specify hypothesis tests and applications use them control false positives and negatives; and new compositional operators express domain knowledge. By carefully restricting the expressiveness, the runtime automatically implements correct statistical reasoning at conditionals, relieving developers of the need to implement or deeply understand statistics. We demonstrate substantial programmability, correctness, and efficiency benefits of this programming model for GPS sensor navigation, approximate computing, machine learning, and xBox.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2843895", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/McKinley16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837648", + "title": "Reducing crash recoverability to reachability", + "abstract": "Software applications run on a variety of platforms (filesystems, virtual slices, mobile hardware, etc.) that do not provide 100% uptime. As such, these applications may crash at any unfortunate moment losing volatile data and, when re-launched, they must be able to correctly recover from potentially inconsistent states left on persistent storage. From a verification perspective, crash recovery bugs can be particularly frustrating because, even when it has been formally proved for a program that it satisfies a property, the proof is foiled by these external events that crash and restart the program. In this paper we first provide a hierarchical formal model of what it means for a program to be crash recoverable. Our model captures the recoverability of many real world programs, including those in our evaluation which use sophisticated recovery algorithms such as shadow paging and write-ahead logging. Next, we introduce a novel technique capable of automatically proving that a program correctly recovers from a crash via a reduction to reachability. Our technique takes an input control-flow automaton and transforms it into an encoding that blends the capture of snapshots of pre-crash states into a symbolic search for a proof that recovery terminates and every recovered execution simulates some crash-free execution. Our encoding is designed to enable one to apply existing abstraction techniques in order to do the work that is necessary to prove recoverability. We have implemented our technique in a tool called Eleven82, capable of analyzing C programs to detect recoverability bugs or prove their absence. We have applied our tool to benchmark examples drawn from industrial file systems and databases, including GDBM, LevelDB, LMDB, PostgreSQL, SQLite, VMware and ZooKeeper. Within minutes, our tool is able to discover bugs or prove that these fragments are crash recoverable.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837648", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Yale University" + }, + { + "first_name": "Junfeng", + "last_name": "Yang", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/popl/KoskinenY16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837635", + "title": "A program logic for concurrent objects under fair scheduling", + "abstract": "Existing work on verifying concurrent objects is mostly concerned with safety only, e.g., partial correctness or linearizability. Although there has been recent work verifying lock-freedom of non-blocking objects, much less efforts are focused on deadlock-freedom and starvation-freedom, progress properties of blocking objects. These properties are more challenging to verify than lock-freedom because they allow the progress of one thread to depend on the progress of another, assuming fair scheduling. We propose LiLi, a new rely-guarantee style program logic for verifying linearizability and progress together for concurrent objects under fair scheduling. The rely-guarantee style logic unifies thread-modular reasoning about both starvation-freedom and deadlock-freedom in one framework. It also establishes progress-aware abstraction for concurrent objects, which can be applied when verifying safety and liveness of client code. We have successfully applied the logic to verify starvation-freedom or deadlock-freedom of representative algorithms such as ticket locks, queue locks, lock-coupling lists, optimistic lists and lazy lists.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837635", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "University of Science and Technology of China" + } + ], + "dblp_key": "conf/popl/LiangF16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837641", + "title": "String solving with word equations and transducers: towards a logic for analysing mutation XSS", + "abstract": "We study the fundamental issue of decidability of satisfiability over string logics with concatenations and finite-state transducers as atomic operations. Although restricting to one type of operations yields decidability, little is known about the decidability of their combined theory, which is especially relevant when analysing security vulnerabilities of dynamic web pages in a more realistic browser model. On the one hand, word equations (string logic with concatenations) cannot precisely capture sanitisation functions (e.g. htmlescape) and implicit browser transductions (e.g. innerHTML mutations). On the other hand, transducers suffer from the reverse problem of being able to model sanitisation functions and browser transductions, but not string concatenations. Naively combining word equations and transducers easily leads to an undecidable logic. Our main contribution is to show that the \"straight-line fragment\" of the logic is decidable (complexity ranges from PSPACE to EXPSPACE). The fragment can express the program logics of straight-line string-manipulating programs with concatenations and transductions as atomic operations, which arise when performing bounded model checking or dynamic symbolic executions. We demonstrate that the logic can naturally express constraints required for analysing mutation XSS in web applications. Finally, the logic remains decidable in the presence of length, letter-counting, regular, indexOf, and disequality constraints.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837641", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "Yale-NUS College" + }, + { + "first_name": "Pablo", + "last_name": "Barceló", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/popl/LinB16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837617", + "title": "Automatic patch generation by learning correct code", + "abstract": "We present Prophet, a novel patch generation system that works with a set of successful human patches obtained from open- source software repositories to learn a probabilistic, application-independent model of correct code. It generates a space of candidate patches, uses the model to rank the candidate patches in order of likely correctness, and validates the ranked patches against a suite of test cases to find correct patches. Experimental results show that, on a benchmark set of 69 real-world defects drawn from eight open-source projects, Prophet significantly outperforms the previous state-of-the-art patch generation system.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837617", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fan", + "last_name": "Long", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/LongR16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837622", + "title": "Chapar: certified causally consistent distributed key-value stores", + "abstract": "Today’s Internet services are often expected to stay available and render high responsiveness even in the face of site crashes and network partitions. Theoretical results state that causal consistency is one of the strongest consistency guarantees that is possible under these requirements, and many practical systems provide causally consistent key-value stores. In this paper, we present a framework called Chapar for modular verification of causal consistency for replicated key-value store implementations and their client programs. Specifically, we formulate separate correctness conditions for key-value store implementations and for their clients. The interface between the two is a novel operational semantics for causal consistency. We have verified the causal consistency of two key-value store implementations from the literature using a novel proof technique. We have also implemented a simple automatic model checker for the correctness of client programs. The two independently verified results for the implementations and clients can be composed to conclude the correctness of any of the programs when executed with any of the implementations. We have developed and checked our framework in Coq, extracted it to OCaml, and built executable stores.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837622", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Christian J.", + "last_name": "Bell", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/LesaniBC16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837669", + "title": "The hardness of data packing", + "abstract": "A program can benefit from improved cache block utilization when contemporaneously accessed data elements are placed in the same memory block. This can reduce the program's memory block working set and thereby, reduce the capacity miss rate. We formally define the problem of data packing for arbitrary number of blocks in the cache and packing factor (the number of data objects fitting in a cache block) and study how well the optimal solution can be approximated for two dual problems. On the one hand, we show that the cache hit maximization problem is approximable within a constant factor, for every fixed number of blocks in the cache. On the other hand, we show that unless P=NP, the cache miss minimization problem cannot be efficiently approximated.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837669", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rahman", + "last_name": "Lavaee", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/popl/Lavaee16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837667", + "title": "Temporal verification of higher-order functional programs", + "abstract": "We present an automated approach to verifying arbitrary omega-regular properties of higher-order functional programs. Previous automated methods proposed for this class of programs could only handle safety properties or termination, and our approach is the first to be able to verify arbitrary omega-regular liveness properties. Our approach is automata-theoretic, and extends our recent work on binary-reachability-based approach to automated termination verification of higher-order functional programs to fair termination published in ESOP 2014. In that work, we have shown that checking disjunctive well-foundedness of (the transitive closure of) the ``calling relation'' is sound and complete for termination. The extension to fair termination is tricky, however, because the straightforward extension that checks disjunctive well-foundedness of the fair calling relation turns out to be unsound, as we shall show in the paper. Roughly, our solution is to check fairness on the transition relation instead of the calling relation, and propagate the information to determine when it is necessary and sufficient to check for disjunctive well-foundedness on the calling relation. We prove that our approach is sound and complete. We have implemented a prototype of our approach, and confirmed that it is able to automatically verify liveness properties of some non-trivial higher-order programs.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837667", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Akihiro", + "last_name": "Murase", + "institution": "Nagoya University" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Japan Advanced Institute of Science and Technology" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryosuke", + "last_name": "Sato", + "institution": "The University of Tokyo" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" + } + ], + "dblp_key": "conf/popl/MuraseT0SU16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837672", + "title": "Memoryful geometry of interaction II: recursion and adequacy", + "abstract": "A general framework of Memoryful Geometry of Interaction (mGoI) is introduced recently by the authors. It provides a sound translation of lambda-terms (on the high-level) to their realizations by stream transducers (on the low-level), where the internal states of the latter (called memories) are exploited for accommodating algebraic effects of Plotkin and Power. The translation is compositional, hence ``denotational,'' where transducers are inductively composed using an adaptation of Barbosa's coalgebraic component calculus. In the current paper we extend the mGoI framework and provide a systematic treatment of recursion---an essential feature of programming languages that was however missing in our previous work. Specifically, we introduce two new fixed-point operators in the coalgebraic component calculus. The two follow the previous work on recursion in GoI and are called Girard style and Mackie style: the former obviously exhibits some nice domain-theoretic properties, while the latter allows simpler construction. Their equivalence is established on the categorical (or, traced monoidal) level of abstraction, and is therefore generic with respect to the choice of algebraic effects. Our main result is an adequacy theorem of our mGoI translation, against Plotkin and Power's operational semantics for algebraic effects.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837672", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Koko", + "last_name": "Muroya", + "institution": "The University of Tokyo" + }, + { + "first_name": "Naohiko", + "last_name": "Hoshino", + "institution": "Kyoto University" + }, + { + "first_name": "Ichiro", + "last_name": "Hasuo", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/MuroyaHH16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837644", + "title": "Sound type-dependent syntactic language extension", + "abstract": "Syntactic language extensions can introduce new facilities into a programming language while requiring little implementation effort and modest changes to the compiler. It is typical to desugar language extensions in a distinguished compiler phase after parsing or type checking, not affecting any of the later compiler phases. If desugaring happens before type checking, the desugaring cannot depend on typing information and type errors are reported in terms of the generated code. If desugaring happens after type checking, the code generated by the desugaring is not type checked and may introduce vulnerabilities. Both options are undesirable. We propose a system for syntactic extensibility where desugaring happens after type checking and desugarings are guaranteed to only generate well-typed code. A major novelty of our work is that desugarings operate on typing derivations instead of plain syntax trees. This provides desugarings access to typing information and forms the basis for the soundness guarantee we provide, namely that a desugaring generates a valid typing derivation. We have implemented our system for syntactic extensibility in a language-independent fashion and instantiated it for a substantial subset of Java, including generics and inheritance. We provide a sound Java extension for Scala-like for-comprehensions.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837644", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Florian", + "last_name": "Lorenzen", + "institution": "Technische Universität Berlin" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/popl/LorenzenE16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837661", + "title": "Combining static analysis with probabilistic models to enable market-scale Android inter-component analysis", + "abstract": "Static analysis has been successfully used in many areas, from verifying mission-critical software to malware detection. Unfortunately, static analysis often produces false positives, which require significant manual effort to resolve. In this paper, we show how to overlay a probabilistic model, trained using domain knowledge, on top of static analysis results, in order to triage static analysis results. We apply this idea to analyzing mobile applications. Android application components can communicate with each other, both within single applications and between different applications. Unfortunately, techniques to statically infer Inter-Component Communication (ICC) yield many potential inter-component and inter-application links, most of which are false positives. At large scales, scrutinizing all potential links is simply not feasible. We therefore overlay a probabilistic model of ICC on top of static analysis results. Since computing the inter-component links is a prerequisite to inter-component analysis, we introduce a formalism for inferring ICC links based on set constraints. We design an efficient algorithm for performing link resolution. We compute all potential links in a corpus of 11,267 applications in 30 minutes and triage them using our probabilistic approach. We find that over 95.1% of all 636 million potential links are associated with probability values below 0.01 and are thus likely unfeasible links. Thus, it is possible to consider only a small subset of all links without significant loss of information. This work is the first significant step in making static inter-application analysis more tractable, even at large scales.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837661", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Damien", + "last_name": "Octeau", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Somesh", + "last_name": "Jha", + "institution": "IMDEA Software" + }, + { + "first_name": "Matthew L.", + "last_name": "Dering", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Patrick", + "last_name": "McDaniel", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Alexandre", + "last_name": "Bartel", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Li", + "last_name": "Li", + "institution": "University of Luxembourg" + }, + { + "first_name": "Jacques", + "last_name": "Klein", + "institution": "University of Luxembourg" + }, + { + "first_name": "Yves Le", + "last_name": "Traon", + "institution": "University of Luxembourg" + } + ], + "dblp_key": "conf/popl/OcteauJDMB0KT16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837634", + "title": "Effects as sessions, sessions as effects", + "abstract": "Effect and session type systems are two expressive behavioural type systems. The former is usually developed in the context of the lambda-calculus and its variants, the latter for the pi-calculus. In this paper we explore their relative expressive power. Firstly, we give an embedding from PCF, augmented with a parameterised effect system, into a session-typed pi-calculus (session calculus), showing that session types are powerful enough to express effects. Secondly, we give a reverse embedding, from the session calculus back into PCF, by instantiating PCF with concurrency primitives and its effect system with a session-like effect algebra; effect systems are powerful enough to express sessions. The embedding of session types into an effect system is leveraged to give a new implementation of session types in Haskell, via an effect system encoding. The correctness of this implementation follows from the second embedding result. We also discuss various extensions to our embeddings.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837634", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/OrchardY16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2843896", + "title": "Confluences in programming languages research (keynote)", + "abstract": "A confluence occurs when two rivers flow together; downstream the combined forces gather strength and propel their waters forward with increased vigor. In academic research, according to Varghese, a confluence occurs after some trigger, perhaps a discovery or a change in technology, and brings two previously separate branches of research together. In this talk, I will discuss confluences in programming languages research. Here, confluences often occur when basic research finds application in some important new domain. Two prime examples from my own career involve the confluence of research in type theory and systems security, triggered by new theoretical tools for reasoning about programming language safety, and the confluence of formal methods and networking, triggered by the rise of data centers. These experiences may shed light on what to teach our students and what is next for programming languages research.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2843896", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/Walker16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837640", + "title": "Decidability of inferring inductive invariants", + "abstract": "Induction is a successful approach for verification of hardware and software systems. A common practice is to model a system using logical formulas, and then use a decision procedure to verify that some logical formula is an inductive safety invariant for the system. A key ingredient in this approach is coming up with the inductive invariant, which is known as invariant inference. This is a major difficulty, and it is often left for humans or addressed by sound but incomplete abstract interpretation. This paper is motivated by the problem of inductive invariants in shape analysis and in distributed protocols. This paper approaches the general problem of inferring first-order inductive invariants by restricting the language L of candidate invariants. Notice that the problem of invariant inference in a restricted language L differs from the safety problem, since a system may be safe and still not have any inductive invariant in L that proves safety. Clearly, if L is finite (and if testing an inductive invariant is decidable), then inferring invariants in L is decidable. This paper presents some interesting cases when inferring inductive invariants in L is decidable even when L is an infinite language of universal formulas. Decidability is obtained by restricting L and defining a suitable well-quasi-order on the state space. We also present some undecidability results that show that our restrictions are necessary. We further present a framework for systematically constructing infinite languages while keeping the invariant inference problem decidable. We illustrate our approach by showing the decidability of inferring invariants for programs manipulating linked-lists, and for distributed protocols.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837640", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Tel Aviv University" + }, + { + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Academic College of Tel Aviv-Yafo" + }, + { + "first_name": "Aleksandr", + "last_name": "Karbyshev", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/popl/PadonISKS16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837616", + "title": "A concurrency semantics for relaxed atomics that permits optimisation and avoids thin-air executions", + "abstract": "Despite much research on concurrent programming languages, especially for Java and C/C++, we still do not have a satisfactory definition of their semantics, one that admits all common optimisations without also admitting undesired behaviour. Especially problematic are the ``thin-air'' examples involving high-performance concurrent accesses, such as C/C++11 relaxed atomics. The C/C++11 model is in a per-candidate-execution style, and previous work has identified a tension between that and the fact that compiler optimisations do not operate over single candidate executions in isolation; rather, they operate over syntactic representations that represent all executions. In this paper we propose a novel approach that circumvents this difficulty. We define a concurrency semantics for a core calculus, including relaxed-atomic and non-atomic accesses, and locks, that admits a wide range of optimisation while still forbidding the classic thin-air examples. It also addresses other problems relating to undefined behaviour. The basic idea is to use an event-structure representation of the current state of each thread, capturing all of its potential executions, and to permit interleaving of execution and transformation steps over that to reflect optimisation (possibly dynamic) of the code. These are combined with a non-multi-copy-atomic storage subsystem, to reflect common hardware behaviour. The semantics is defined in a mechanised and executable form, and designed to be implementable above current relaxed hardware and strong enough to support the programming idioms that C/C++11 does for this fragment. It offers a potential way forward for concurrent programming language semantics, beyond the current C/C++11 and Java models.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837616", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/Pichon-Pharabod16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837657", + "title": "Scaling network verification using symmetry and surgery", + "abstract": "On the surface, large data centers with about 100,000 stations and nearly a million routing rules are complex and hard to verify. However, these networks are highly regular by design; for example they employ fat tree topologies with backup routers interconnected by redundant patterns. To exploit these regularities, we introduce network transformations: given a reachability formula and a network, we transform the network into a simpler to verify network and a corresponding transformed formula, such that the original formula is valid in the network if and only if the transformed formula is valid in the transformed network. Our network transformations exploit network surgery (in which irrelevant or redundant sets of nodes, headers, ports, or rules are ``sliced'' away) and network symmetry (say between backup routers). The validity of these transformations is established using a formal theory of networks. In particular, using Van Benthem-Hennessy-Milner style bisimulation, we show that one can generally associate bisimulations to transformations connecting networks and formulas with their transforms. Our work is a development in an area of current wide interest: applying programming language techniques (in our case bisimulation and modal logic) to problems in switching networks. We provide experimental evidence that our network transformations can speed up by 65x the task of verifying the communication between all pairs of Virtual Machines in a large datacenter network with about 100,000 VMs. An all-pair reachability calculation, which formerly took 5.5 days, can be done in 2 hours, and can be easily parallelized to complete in", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837657", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" + }, + { + "first_name": "Nikolaj", + "last_name": "Bjørner", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "George", + "last_name": "Varghese", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/PlotkinBLRV16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837659", + "title": "Newtonian program analysis via tensor product", + "abstract": "Recently, Esparza et al. generalized Newton's method -- a numerical-analysis algorithm for finding roots of real-valued functions---to a method for finding fixed-points of systems of equations over semirings. Their method provides a new way to solve interprocedural dataflow-analysis problems. As in its real-valued counterpart, each iteration of their method solves a simpler ``linearized'' problem. One of the reasons this advance is exciting is that some numerical analysts have claimed that ```all' effective and fast iterative [numerical] methods are forms (perhaps very disguised) of Newton's method.'' However, there is an important difference between the dataflow-analysis and numerical-analysis contexts: when Newton's method is used on numerical-analysis problems, multiplicative commutativity is relied on to rearrange expressions of the form ``c*X + X*d'' into ``(c+d) * X.'' Such equations correspond to path problems described by regular languages. In contrast, when Newton's method is used for interprocedural dataflow analysis, the ``multiplication'' operation involves function composition, and hence is non-commutative: ``c*X + X*d'' cannot be rearranged into ``(c+d) * X.'' Such equations correspond to path problems described by linear context-free languages (LCFLs). In this paper, we present an improved technique for solving the LCFL sub-problems produced during successive rounds of Newton's method. Our method applies to predicate abstraction, on which most of today's software model checkers rely.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837659", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Emma", + "last_name": "Turetsky", + "institution": "GrammaTech (United States)" + }, + { + "first_name": "Prathmesh", + "last_name": "Prabhu", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/popl/RepsTP16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837651", + "title": "Environmental bisimulations for probabilistic higher-order languages", + "abstract": "Environmental bisimulations for probabilistic higher-order languages are studied. In contrast with applicative bisimulations, environmental bisimulations are known to be more robust and do not require sophisticated techniques such as Howe’s in the proofs of congruence. As representative calculi, call-by-name and call-by-value λ- calculus, and a (call-by-value) λ-calculus extended with references (i.e., a store) are considered. In each case full abstraction results are derived for probabilistic environmental similarity and bisimilarity with respect to contextual preorder and contextual equivalence, respectively. Some possible enhancements of the (bi)simulations, as ‘up-to techniques’, are also presented. Probabilities force a number of modifications to the definition of environmental bisimulations in non-probabilistic languages. Some of these modifications are specific to probabilities, others may be seen as general refinements of environmental bisimulations, applicable also to non-probabilistic languages. Several examples are presented, to illustrate the modifications and the differences.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837651", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Davide", + "last_name": "Sangiorgi", + "institution": "University of Bologna" + }, + { + "first_name": "Valeria", + "last_name": "Vignudelli", + "institution": "University of Bologna" + } + ], + "dblp_key": "conf/popl/SangiorgiV16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837671", + "title": "Learning programs from noisy data", + "abstract": "We present a new approach for learning programs from noisy datasets. Our approach is based on two new concepts: a regularized program generator which produces a candidate program based on a small sample of the entire dataset while avoiding overfitting, and a dataset sampler which carefully samples the dataset by leveraging the candidate program's score on that dataset. The two components are connected in a continuous feedback-directed loop. We show how to apply this approach to two settings: one where the dataset has a bound on the noise, and another without a noise bound. The second setting leads to a new way of performing approximate empirical risk minimization on hypotheses classes formed by a discrete search space. We then present two new kinds of program synthesizers which target the two noise settings. First, we introduce a novel regularized bitstream synthesizer that successfully generates programs even in the presence of incorrect examples. We show that the synthesizer can detect errors in the examples while combating overfitting -- a major problem in existing synthesis techniques. We also show how the approach can be used in a setting where the dataset grows dynamically via new examples (e.g., provided by a human). Second, we present a novel technique for constructing statistical code completion systems. These are systems trained on massive datasets of open source programs, also known as ``Big Code''. The key idea is to introduce a domain specific language (DSL) over trees and to learn functions in that DSL directly from the dataset. These learned functions then condition the predictions made by the system. This is a flexible and powerful technique which generalizes several existing works as we no longer need to decide a priori on what the prediction should be conditioned (another benefit is that the learned functions are a natural mechanism for explaining the prediction). As a result, our code completion system surpasses the prediction capabilities of existing, hard-wired systems.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837671", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Pavol", + "last_name": "Bielik", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Andreas", + "last_name": "Krause", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/popl/RaychevBVK16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837658", + "title": "Query-guided maximum satisfiability", + "abstract": "We propose a new optimization problem \"Q-MaxSAT\", an extension of the well-known Maximum Satisfiability or MaxSAT problem. In contrast to MaxSAT, which aims to find an assignment to all variables in the formula, Q-MaxSAT computes an assignment to a desired subset of variables (or queries) in the formula. Indeed, many problems in diverse domains such as program reasoning, information retrieval, and mathematical optimization can be naturally encoded as Q-MaxSAT instances. We describe an iterative algorithm for solving Q-MaxSAT. In each iteration, the algorithm solves a subproblem that is relevant to the queries, and applies a novel technique to check whether the partial assignment found is a solution to the Q-MaxSAT problem. If the check fails, the algorithm grows the subproblem with a new set of clauses identified as relevant to the queries. Our empirical evaluation shows that our Q-MaxSAT solver Pilot achieves significant improvements in runtime and memory consumption over conventional MaxSAT solvers on several Q-MaxSAT instances generated from real-world problems in program analysis and information retrieval.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837658", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Ravi", + "last_name": "Mangal", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/popl/ZhangMNN16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837668", + "title": "Transforming spreadsheet data types using examples", + "abstract": "Cleaning spreadsheet data types is a common problem faced by millions of spreadsheet users. Data types such as date, time, name, and units are ubiquitous in spreadsheets, and cleaning transformations on these data types involve parsing and pretty printing their string representations. This presents many challenges to users because cleaning such data requires some background knowledge about the data itself and moreover this data is typically non-uniform, unstructured, and ambiguous. Spreadsheet systems and Programming Languages provide some UI-based and programmatic solutions for this problem but they are either insufficient for the user's needs or are beyond their expertise. In this paper, we present a programming by example methodology of cleaning data types that learns the desired transformation from a few input-output examples. We propose a domain specific language with probabilistic semantics that is parameterized with declarative data type definitions. The probabilistic semantics is based on three key aspects: (i) approximate predicate matching, (ii) joint learning of data type interpretation, and (iii) weighted branches. This probabilistic semantics enables the language to handle non-uniform, unstructured, and ambiguous data. We then present a synthesis algorithm that learns the desired program in this language from a set of input-output examples. We have implemented our algorithm as an Excel add-in and present its successful evaluation on 55 benchmark problems obtained from online help forums and Excel product team.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837668", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/SinghG16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837619", + "title": "Casper: an efficient approach to call trace collection", + "abstract": "Call traces, i.e., sequences of function calls and returns, are fundamental to a wide range of program analyses such as bug reproduction, fault diagnosis, performance analysis, and many others. The conventional approach to collect call traces that instruments each function call and return site incurs large space and time overhead. Our approach aims at reducing the recording overheads by instrumenting only a small amount of call sites while keeping the capability of recovering the full trace. We propose a call trace model and a logged call trace model based on an LL(1) grammar, which enables us to define the criteria of a feasible solution to call trace collection. Based on the two models, we prove that to collect call traces with minimal instrumentation is an NP-hard problem. We then propose an efficient approach to obtaining a suboptimal solution. We implemented our approach as a tool Casper and evaluated it using the DaCapo benchmark suite. The experiment results show that our approach causes significantly lower runtime (and space) overhead than two state-of-the-arts approaches.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837619", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rongxin", + "last_name": "Wu", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Xiao", + "last_name": "Xiao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Shing-Chi", + "last_name": "Cheung", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Hongyu", + "last_name": "Zhang", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/popl/WuXCZZ16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837655", + "title": "Dependent types and multi-monadic effects in F", + "abstract": "We present a new, completely redesigned, version of F*, a language that works both as a proof assistant as well as a general-purpose, verification-oriented, effectful programming language. In support of these complementary roles, F* is a dependently typed, higher-order, call-by-value language with _primitive_ effects including state, exceptions, divergence and IO. Although primitive, programmers choose the granularity at which to specify effects by equipping each effect with a monadic, predicate transformer semantics. F* uses this to efficiently compute weakest preconditions and discharges the resulting proof obligations using a combination of SMT solving and manual proofs. Isolated from the effects, the core of F* is a language of pure functions used to write specifications and proof terms---its consistency is maintained by a semantic termination check based on a well-founded order. We evaluate our design on more than 55,000 lines of F* we have authored in the last year, focusing on three main case studies. Showcasing its use as a general-purpose programming language, F* is programmed (but not verified) in F*, and bootstraps in both OCaml and F#. Our experience confirms F*'s pay-as-you-go cost model: writing idiomatic ML-like code with no finer specifications imposes no user burden. As a verification-oriented language, our most significant evaluation of F* is in verifying several key modules in an implementation of the TLS-1.2 protocol standard. For the modules we considered, we are able to prove more properties, with fewer annotations using F* than in a prior verified implementation of TLS-1.2. Finally, as a proof assistant, we discuss our use of F* in mechanizing the metatheory of a range of lambda calculi, starting from the simply typed lambda calculus to System F-omega and even micro-F*, a sizeable fragment of F* itself---these proofs make essential use of F*'s flexible combination of SMT automation and constructive proofs, enabling a tactic-free style of programming and proving at a relatively large scale.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837655", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Chantal", + "last_name": "Keller", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Antoine", + "last_name": "Delignat-Lavaud", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Simon", + "last_name": "Forest", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Karthikeyan", + "last_name": "Bhargavan", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Markulf", + "last_name": "Kohlweiss", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jean-Karim", + "last_name": "Zinzindohoué", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Santiago", + "last_name": "Zanella-Béguelin", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/popl/SwamyHKRDFBFSKZ16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837630", + "title": "Is sound gradual typing dead?", + "abstract": "Programmers have come to embrace dynamically-typed languages for prototyping and delivering large and complex systems. When it comes to maintaining and evolving these systems, the lack of explicit static typing becomes a bottleneck. In response, researchers have explored the idea of gradually-typed programming languages which allow the incremental addition of type annotations to software written in one of these untyped languages. Some of these new, hybrid languages insert run-time checks at the boundary between typed and untyped code to establish type soundness for the overall system. With sound gradual typing, programmers can rely on the language implementation to provide meaningful error messages when type invariants are violated. While most research on sound gradual typing remains theoretical, the few emerging implementations suffer from performance overheads due to these checks. None of the publications on this topic comes with a comprehensive performance evaluation. Worse, a few report disastrous numbers. In response, this paper proposes a method for evaluating the performance of gradually-typed programming languages. The method hinges on exploring the space of partial conversions from untyped to typed. For each benchmark, the performance of the different versions is reported in a synthetic metric that associates runtime overhead to conversion effort. The paper reports on the results of applying the method to Typed Racket, a mature implementation of sound gradual typing, using a suite of real-world programs of various sizes and complexities. Based on these results the paper concludes that, given the current state of implementation technologies, sound gradual typing faces significant challenges. Conversely, it raises the question of how implementations could reduce the overheads associated with soundness and how tools could be used to steer programmers clear from pathological cases.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837630", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Asumu", + "last_name": "Takikawa", + "institution": "Northeastern University" + }, + { + "first_name": "Daniel", + "last_name": "Feltey", + "institution": "Northeastern University" + }, + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Northeastern University" + }, + { + "first_name": "Max S.", + "last_name": "New", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/TakikawaFGNVF16", + "venue": "popl", + "year": 2016 + }, + { + "paper_id": "10.1145/2837614.2837633", + "title": "From MinX to MinC: semantics-driven decompilation of recursive datatypes", + "abstract": "Reconstructing the meaning of a program from its binary executable is known as reverse engineering; it has a wide range of applications in software security, exposing piracy, legacy systems, etc. Since reversing is ultimately a search for meaning, there is much interest in inferring a type (a meaning) for the elements of a binary in a consistent way. Unfortunately existing approaches do not guarantee any semantic relevance for their reconstructed types. This paper presents a new and semantically-founded approach that provides strong guarantees for the reconstructed types. Key to our approach is the derivation of a witness program in a high-level language alongside the reconstructed types. This witness has the same semantics as the binary, is type correct by construction, and it induces a (justifiable) type assignment on the binary. Moreover, the approach effectively yields a type-directed decompiler. We formalise and implement the approach for reversing MinX, an abstraction of x86, to MinC, a type-safe dialect of C with recursive datatypes. Our evaluation compiles a range of textbook C algorithms to MinX and then recovers the original structures.", + "date": "2016-01-07", + "link": "https://doi.org/10.1145/2837614.2837633", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Edward", + "last_name": "Robbins", + "institution": "University of Kent" + }, + { + "first_name": "Andy", + "last_name": "King", + "institution": "University of Kent" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/popl/RobbinsKS16", + "venue": "popl", + "year": 2016 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2017.json b/data/pl_conferences/popl/2017.json new file mode 100644 index 0000000..2d51031 --- /dev/null +++ b/data/pl_conferences/popl/2017.json @@ -0,0 +1,1890 @@ +[ + { + "paper_id": "10.1145/3009837.3009886", + "title": "Type systems as macros", + "abstract": "We present Turnstile, a metalanguage for creating typed embedded languages. To implement the type system, programmers write type checking rules resembling traditional judgment syntax. To implement the semantics, they incorporate elaborations into these rules. Turnstile critically depends on the idea of linguistic reuse. It exploits a macro system in a novel way to simultaneously type check and rewrite a surface program into a target language. Reusing a macro system also yields modular implementations whose rules may be mixed and matched to create other languages. Combined with typical compiler and runtime reuse, Turnstile produces performant typed embedded languages with little effort.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009886", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Chang", + "institution": "Northeastern University" + }, + { + "first_name": "Alex", + "last_name": "Knauth", + "institution": "Northeastern University" + }, + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/ChangKG17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009867", + "title": "LMS-Verify: abstraction without regret for verified systems programming", + "abstract": "Performance critical software is almost always developed in C, as programmers do not trust high-level languages to deliver the same reliable performance. This is bad because low-level code in unsafe languages attracts security vulnerabilities and because development is far less productive, with PL advances mostly lost on programmers operating under tight performance constraints. High-level languages provide memory safety out of the box, but they are deemed too slow and unpredictable for serious system software.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009867", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/AminR17a", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009853", + "title": "Typed self-evaluation via intensional type functions", + "abstract": "Many popular languages have a self-interpreter, that is, an interpreter for the language written in itself. So far, work on polymorphically-typed self-interpreters has concentrated on self-recognizers that merely recover a program from its representation. A larger and until now unsolved challenge is to implement a polymorphically-typed self-evaluator that evaluates the represented program and produces a representation of the result. We present Fωμi, the first λ-calculus that supports a polymorphically-typed self-evaluator. Our calculus extends Fω with recursive types and intensional type functions and has decidable type checking. Our key innovation is a novel implementation of type equality proofs that enables us to define a versatile representation of programs. Our results establish a new category of languages that can support polymorphically-typed self-evaluators.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009853", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matt", + "last_name": "Brown", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/popl/BrownP17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009863", + "title": "Automatically generating the dynamic semantics of gradually typed languages", + "abstract": "Many language designers have adopted gradual typing. However, there remains open questions regarding how to gradualize languages. Cimini and Siek (2016) created a methodology and algorithm to automatically generate the type system of a gradually typed language from a fully static version of the language. In this paper, we address the next challenge of how to automatically generate the dynamic semantics of gradually typed languages. Such languages typically use an intermediate language with explicit casts.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009863", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matteo", + "last_name": "Cimini", + "institution": "Indiana University" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/popl/CiminiS17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009878", + "title": "Dijkstra monads for free", + "abstract": "Dijkstra monads enable a dependent type theory to be enhanced with support for specifying and verifying effectful code via weakest preconditions. Together with their closely related counterparts, Hoare monads, they provide the basis on which verification tools like F*, Hoare Type Theory (HTT), and Ynot are built. We show that Dijkstra monads can be derived \"for free\" by applying a continuation-passing style (CPS) translation to the standard monadic definitions of the underlying computational effects. Automatically deriving Dijkstra monads in this way provides a correct-by-construction and efficient way of reasoning about user-defined effects in dependent type theories. We demonstrate these ideas in EMF*, a new dependently typed calculus, validating it via both formal proof and a prototype implementation within F*. Besides equipping F* with a more uniform and extensible effect system, EMF* enables a novel mixture of intrinsic and extrinsic proofs within F*.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009878", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "University of Edinburgh" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "State Key Laboratory of Cryptology" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/AhmanHMMPPRS17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009895", + "title": "Serializability for eventual consistency: criterion, analysis, and applications", + "abstract": "Developing and reasoning about systems using eventually consistent data stores is a difficult challenge due to the presence of unexpected behaviors that do not occur under sequential consistency. A fundamental problem in this setting is to identify a correctness criterion that precisely captures intended application behaviors yet is generic enough to be applicable to a wide range of applications.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009895", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lucas", + "last_name": "Brutschy", + "institution": "ETH Zurich" + }, + { + "first_name": "Dimitar", + "last_name": "Dimitrov", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/popl/BrutschyD0V17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009889", + "title": "Hypercollecting semantics and its application to static analysis of information flow", + "abstract": "We show how static analysis for secure information flow can be expressed and proved correct entirely within the framework of abstract interpretation. The key idea is to define a Galois connection that directly approximates the hyperproperty of interest. To enable use of such Galois connections, we introduce a fixpoint characterisation of hypercollecting semantics, i.e. a \"set of sets\" transformer. This makes it possible to systematically derive static analyses for hyperproperties entirely within the calculational framework of abstract interpretation. We evaluate this technique by deriving example static analyses. For qualitative information flow, we derive a dependence analysis similar to the logic of Amtoft and Banerjee (SAS '04) and the type system of Hunt and Sands (POPL '06). For quantitative information flow, we derive a novel cardinality analysis that bounds the leakage conveyed by a program instead of simply deciding whether it exists. This encompasses problems that are hypersafety but not k-safety. We put the framework to use and introduce variations that achieve precision rivalling the most recent and precise static analyses for information flow.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009889", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mounir", + "last_name": "Assaf", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "David A.", + "last_name": "Naumann", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Julien", + "last_name": "Signoles", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Éric", + "last_name": "Totel", + "institution": "CentraleSupélec" + }, + { + "first_name": "Frédéric", + "last_name": "Tronel", + "institution": "CentraleSupélec" + } + ], + "dblp_key": "conf/popl/AssafNSTT17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009866", + "title": "Type soundness proofs with definitional interpreters", + "abstract": "While type soundness proofs are taught in every graduate PL class, the gap between realistic languages and what is accessible to formal proofs is large. In the case of Scala, it has been shown that its formal model, the Dependent Object Types (DOT) calculus, cannot simultaneously support key metatheoretic properties such as environment narrowing and subtyping transitivity, which are usually required for a type soundness proof. Moreover, Scala and many other realistic languages lack a general substitution property.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009866", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/popl/AminR17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009873", + "title": "Stochastic invariants for probabilistic termination", + "abstract": "Termination is one of the basic liveness properties, and we study the termination problem for probabilistic programs with real-valued variables. Previous works focused on the qualitative problem that asks whether an input program terminates with probability 1 (almost-sure termination). A powerful approach for this qualitative problem is the notion of ranking supermartingales with respect to a given set of invariants. The quantitative problem (probabilistic termination) asks for bounds on the termination probability, and this problem has not been addressed yet. A fundamental and conceptual drawback of the existing approaches to address probabilistic termination is that even though the supermartingales consider the probabilistic behaviour of the programs, the invariants are obtained completely ignoring the probabilistic aspect (i.e., the invariants are obtained considering all behaviours with no information about the probability).", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009873", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Petr", + "last_name": "Novotný", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Đorđe", + "last_name": "Žikelić", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/ChatterjeeNZ17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009896", + "title": "Coupling proofs are probabilistic product programs", + "abstract": "Couplings are a powerful mathematical tool for reasoning about pairs of probabilistic processes. Recent developments in formal verification identify a close connection between couplings and pRHL, a relational program logic motivated by applications to provable security, enabling formal construction of couplings from the probability theory literature. However, existing work using pRHL merely shows existence of a coupling and does not give a way to prove quantitative properties about the coupling, needed to reason about mixing and convergence of probabilistic processes. Furthermore, pRHL is inherently incomplete, and is not able to capture some advanced forms of couplings such as shift couplings. We address both problems as follows.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009896", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/popl/BartheGHS17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009890", + "title": "A semantic account of metric preservation", + "abstract": "Program sensitivity measures how robust a program is to small changes in its input, and is a fundamental notion in domains ranging from differential privacy to cyber-physical systems. A natural way to formalize program sensitivity is in terms of metrics on the input and output spaces, requiring that an r-sensitive function map inputs that are at distance d to outputs that are at distance at most r · d. Program sensitivity is thus an analogue of Lipschitz continuity for programs.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009890", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Buffalo State University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "Kyoto University" + }, + { + "first_name": "Ikram", + "last_name": "Cherigui", + "institution": "" + } + ], + "dblp_key": "conf/popl/AmorimGHKC17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009861", + "title": "Computational higher-dimensional type theory", + "abstract": "Formal constructive type theory has proved to be an effective language for mechanized proof. By avoiding non-constructive principles, such as the law of the excluded middle, type theory admits sharper proofs and broader interpretations of results. From a computer science perspective, interest in type theory arises from its applications to programming languages. Standard constructive type theories used in mechanization admit computational interpretations based on meta-mathematical normalization theorems. These proofs are notoriously brittle; any change to the theory potentially invalidates its computational meaning. As a case in point, Voevodsky's univalence axiom raises questions about the computational meaning of proofs.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009861", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Carlo", + "last_name": "Angiuli", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Todd M.", + "last_name": "Wilson", + "institution": "California State University, Fresno" + } + ], + "dblp_key": "conf/popl/AngiuliHW17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009846", + "title": "Rigorous floating-point mixed-precision tuning", + "abstract": "Virtually all real-valued computations are carried out using floating-point data types and operations. The precision of these data types must be set with the goals of reducing the overall round-off error, but also emphasizing performance improvements. Often, a mixed-precision allocation achieves this optimum; unfortunately, there are no techniques available to compute such allocations and conservatively meet a given error target across all program inputs. In this work, we present a rigorous approach to precision allocation based on formal analysis via Symbolic Taylor Expansions, and error analysis based on interval functions. This approach is implemented in an automated tool called FPTuner that generates and solves a quadratically constrained quadratic program to obtain a precision-annotated version of the given expression. FPTuner automatically introduces all the requisite precision up and down casting operations. It also allows users to flexibly control precision allocation using constraints to cap the number of high precision operators as well as group operators to allocate the same precision to facilitate vectorization. We evaluate FPTuner by tuning several benchmarks and measuring the proportion of lower precision operators allocated as we increase the error threshold. We also measure the reduction in energy consumption resulting from executing mixed-precision tuned code on a real hardware platform. We observe significant energy savings in response to mixed-precision tuning, but also observe situations where unexpected compiler behaviors thwart intended optimizations.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009846", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wei‐Fan", + "last_name": "Chiang", + "institution": "University of Utah" + }, + { + "first_name": "Mark", + "last_name": "Baranowski", + "institution": "University of Utah" + }, + { + "first_name": "Ian", + "last_name": "Briggs", + "institution": "University of Utah" + }, + { + "first_name": "Alexey", + "last_name": "Solovyev", + "institution": "University of Utah" + }, + { + "first_name": "Ganesh", + "last_name": "Gopalakrishnan", + "institution": "University of Utah" + }, + { + "first_name": "Zvonimir", + "last_name": "Rakamarić", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/ChiangBBSGR17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009888", + "title": "On verifying causal consistency", + "abstract": "Causal consistency is one of the most adopted consistency criteria for distributed implementations of data structures. It ensures that operations are executed at all sites according to their causal precedence. We address the issue of verifying automatically whether the executions of an implementation of a data structure are causally consistent. We consider two problems: (1) checking whether one single execution is causally consistent, which is relevant for developing testing and bug finding algorithms, and (2) verifying whether all the executions of an implementation are causally consistent.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009888", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Jad", + "last_name": "Hamza", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/BouajjaniEGH17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009883", + "title": "Ogre and Pythia: an invariance proof method for weak consistency models", + "abstract": "We design an invariance proof method for concurrent programs parameterised by a weak consistency model. The calculational design of the invariance proof method is by abstract interpretation of a truly parallel analytic semantics. This generalises the methods by Lamport and Owicki-Gries for sequential consistency. We use cat as an example of language to write consistency specifications of both concurrent programs and machine architectures.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009883", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jade", + "last_name": "Alglave", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" + } + ], + "dblp_key": "conf/popl/AlglaveC17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009858", + "title": "Relational cost analysis", + "abstract": "Establishing quantitative bounds on the execution cost of programs is essential in many areas of computer science such as complexity analysis, compiler optimizations, security and privacy. Techniques based on program analysis, type systems and abstract interpretation are well-studied, but methods for analyzing how the execution costs of two programs compare to each other have not received attention. Naively combining the worst and best case execution costs of the two programs does not work well in many cases because such analysis forgets the similarities between the programs or the inputs.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009858", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ezgi", + "last_name": "Çiçek", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Buffalo State University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/CicekBG0H17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009892", + "title": "Modules, abstraction, and parametric polymorphism", + "abstract": "Reynolds's Abstraction theorem forms the mathematical foundation for data abstraction. His setting was the polymorphic lambda calculus. Today, many modern languages, such as the ML family, employ rich module systems designed to give more expressive support for data abstraction than the polymorphic lambda calculus, but analogues of the Abstraction theorem for such module systems have lagged far behind.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009892", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Crary17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009862", + "title": "Intersection type calculi of bounded dimension", + "abstract": "A notion of dimension in intersection typed λ-calculi is presented. The dimension of a typed λ-term is given by the minimal norm of an elaboration (a proof theoretic decoration) necessary for typing the term at its type, and, intuitively, measures intersection introduction as a resource.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009862", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrej", + "last_name": "Dudenhefner", + "institution": "TU Dortmund University" + }, + { + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "TU Dortmund University" + } + ], + "dblp_key": "conf/popl/DudenhefnerR17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009882", + "title": "Polymorphism, subtyping, and type inference in MLsub", + "abstract": "We present a type system combining subtyping and ML-style parametric polymorphism. Unlike previous work, our system supports type inference and has compact principal types. We demonstrate this system in the minimal language MLsub, which types a strict superset of core ML programs.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009882", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen K.", + "last_name": "Dolan", + "institution": "University of Cambridge" + }, + { + "first_name": "Alan", + "last_name": "Mycroft", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/DolanM17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009844", + "title": "Monadic second-order logic on finite sequences", + "abstract": "We extend the weak monadic second-order logic of one successor on finite strings (M2L-STR) to symbolic alphabets by allowing character predicates to range over decidable quantifier free theories instead of finite alphabets. We call this logic, which is able to describe sequences over complex and potentially infinite domains, symbolic M2L-STR (S-M2L-STR). We then present a decision procedure for S-M2L-STR based on a reduction to symbolic finite automata, a decidable extension of finite automata that allows transitions to carry predicates and can therefore model symbolic alphabets. The reduction constructs a symbolic automaton over an alphabet consisting of pairs of symbols where the first element of the pair is a symbol in the original formula’s alphabet, while the second element is a bit-vector. To handle this modified alphabet we show that the Cartesian product of two decidable Boolean algebras (e.g., the formula’s one and the bit-vector’s one) also forms a decidable Boolean algebras. To make the decision procedure practical, we propose two efficient representations of the Cartesian product of two Boolean algebras, one based on algebraic decision diagrams and one on a variant of Shannon expansions. Finally, we implement our decision procedure and evaluate it on more than 10,000 formulas. Despite the generality, our implementation has comparable performance with the state-of-the-art M2L-STR solvers.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009844", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/DAntoniV17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009841", + "title": "The exp-log normal form of types: decomposing extensional equality and representing terms compactly", + "abstract": "Lambda calculi with algebraic data types lie at the core of functional programming languages and proof assistants, but conceal at least two fundamental theoretical problems already in the presence of the simplest non-trivial data type, the sum type. First, we do not know of an explicit and implemented algorithm for deciding the beta-eta-equality of terms---and this in spite of the first decidability results proven two decades ago. Second, it is not clear how to decide when two types are essentially the same, i.e. isomorphic, in spite of the meta-theoretic results on decidability of the isomorphism. In this paper, we present the exp-log normal form of types---derived from the representation of exponential polynomials via the unary exponential and logarithmic functions---that any type built from arrows, products, and sums, can be isomorphically mapped to. The type normal form can be used as a simple heuristic for deciding type isomorphism, thanks to the fact that it is a systematic application of the high-school identities. We then show that the type normal form allows to reduce the standard beta-eta equational theory of the lambda calculus to a specialized version of itself, while preserving the completeness of equality on terms. We end by describing an alternative representation of normal terms of the lambda calculus with sums, together with a Coq-implemented converter into/from our new term calculus. The difference with the only other previously implemented heuristic for deciding interesting instances of eta-equality by Balat, Di Cosmo, and Fiore, is that we exploit the type information of terms substantially and this often allows us to obtain a canonical representation of terms without performing sophisticated term analyses.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009841", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Danko", + "last_name": "Ilik", + "institution": "" + } + ], + "dblp_key": "conf/popl/Ilik17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009871", + "title": "Java generics are turing complete", + "abstract": "This paper describes a reduction from the halting problem of Turing machines to subtype checking in Java. It follows that subtype checking in Java is undecidable, which answers a question posed by Kennedy and Pierce in 2007. It also follows that Java's type checker can recognize any recursive language, which improves a result of Gill and Levy from 2016. The latter point is illustrated by a parser generator for fluent interfaces.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009871", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Radu", + "last_name": "Grigore", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/popl/Grigore17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009893", + "title": "Thread modularity at many levels: a pearl in compositional verification", + "abstract": "A thread-modular proof for the correctness of a concurrent program is based on an inductive and interference-free annotation of each thread. It is well-known that the corresponding proof system is not complete (unless one adds auxiliary variables). We describe a hierarchy of proof systems where each level k corresponds to a generalized notion of thread modularity (level 1 corresponds to the original notion). Each level is strictly more expressive than the previous. Further, each level precisely captures programs that can be proved using uniform Ashcroft invariants with k universal quantifiers. We demonstrate the usefulness of the hierarchy by giving a compositional proof of the Mach shootdown algorithm for TLB consistency. We show a proof at level 2 that shows the algorithm is correct for an arbitrary number of CPUs. However, there is no proof for the algorithm at level 1 which does not involve auxiliary state.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009893", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jochen", + "last_name": "Hoenicke", + "institution": "University of Freiburg" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/popl/HoenickeMP17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009899", + "title": "A posteriori environment analysis with Pushdown Delta CFA", + "abstract": "Flow-driven higher-order inlining is blocked by free variables, yet current theories of environment analysis cannot reliably cope with multiply-bound variables. One of these, ΔCFA, is a promising theory based on stack change but is undermined by its finite-state model of the stack. We present Pushdown ΔCFA which takes a ΔCFA-approach to pushdown models of control flow and can cope with multiply-bound variables, even in the face of recursion.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009899", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kimball", + "last_name": "Germane", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/popl/GermaneM17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009851", + "title": "Component-based synthesis for complex APIs", + "abstract": "Component-based approaches to program synthesis assemble programs from a database of existing components, such as methods provided by an API. In this paper, we present a novel type-directed algorithm for component-based synthesis. The key novelty of our approach is the use of a compact Petri-net representation to model relationships between methods in an API. Given a target method signature S, our approach performs reachability analysis on the underlying Petri-net model to identify sequences of method calls that could be used to synthesize an implementation of S. The programs synthesized by our algorithm are guaranteed to type check and pass all test cases provided by the user.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009851", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ruben", + "last_name": "Martins", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/FengM0DR17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009839", + "title": "Mixed-size concurrency: ARM, POWER, C/C++11, and SC", + "abstract": "Previous work on the semantics of relaxed shared-memory concurrency has only considered the case in which each load reads the data of exactly one store. In practice, however, multiprocessors support mixed-size accesses, and these are used by systems software and (to some degree) exposed at the C/C++ language level. A semantic foundation for software, therefore, has to address them.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009839", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shaked", + "last_name": "Flur", + "institution": "University of Cambridge" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of St Andrews" + }, + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Kyndylan", + "last_name": "Nienhuis", + "institution": "University of Cambridge" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Kathryn E.", + "last_name": "Gray", + "institution": "University of Cambridge" + }, + { + "first_name": "Ali", + "last_name": "Sezgin", + "institution": "University of Cambridge" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/FlurSPNMGSBS17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009865", + "title": "Sums of uncertainty: refinements go gradual", + "abstract": "A long-standing shortcoming of statically typed functional languages is that type checking does not rule out pattern-matching failures (run-time match exceptions). Refinement types distinguish different values of datatypes; if a program annotated with refinements passes type checking, pattern-matching failures become impossible. Unfortunately, refinement is a monolithic property of a type, exacerbating the difficulty of adding refinement types to nontrivial programs.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009865", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Khurram A.", + "last_name": "Jafery", + "institution": "University of British Columbia" + }, + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/popl/JaferyD17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009876", + "title": "LOIS: syntax and semantics", + "abstract": "We present the semantics of an imperative programming language called LOIS (Looping Over Infinite Sets), which allows iterating through certain infinite sets, in finite time. Our semantics intuitively correspond to execution of infinitely many threads in parallel. This allows to merge the power of abstract mathematical constructions into imperative programming. Infinite sets are internally represented using first order formulas over some underlying logical structure, and SMT solvers are employed to evaluate programs.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009876", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eryk", + "last_name": "Kopczyński", + "institution": "University of Warsaw" + }, + { + "first_name": "Szymon", + "last_name": "Toruńczyk", + "institution": "University of Warsaw" + } + ], + "dblp_key": "conf/popl/KopczynskiT17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009854", + "title": "On the relationship between higher-order recursion schemes and higher-order fixpoint logic", + "abstract": "We study the relationship between two kinds of higher-order extensions", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009854", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Étienne", + "last_name": "Lozes", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Florian", + "last_name": "Bruse", + "institution": "University of Kassel" + } + ], + "dblp_key": "conf/popl/KobayashiLB17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009842", + "title": "Towards automatic resource bound analysis for OCaml", + "abstract": "This article presents a resource analysis system for OCaml programs. The system automatically derives worst-case resource bounds for higher-order polymorphic programs with user-defined inductive types. The technique is parametric in the resource and can derive bounds for time, memory allocations and energy usage. The derived bounds are multivariate resource polynomials which are functions of different size parameters that depend on the standard OCaml types. Bound inference is fully automatic and reduced to a linear optimization problem that is passed to an off-the-shelf LP solver. Technically, the analysis system is based on a novel multivariate automatic amortized resource analysis (AARA). It builds on existing work on linear AARA for higher-order programs with user-defined inductive types and on multivariate AARA for first-order programs with built-in lists and binary trees. This is the first amortized analysis, that automatically derives polynomial bounds for higher-order functions and polynomial bounds that depend on user-defined inductive types. Moreover, the analysis handles a limited form of side effects and even outperforms the linear bound inference of previous systems. At the same time, it preserves the expressivity and efficiency of existing AARA techniques. The practicality of the analysis system is demonstrated with an implementation and integration with Inria's OCaml compiler. The implementation is used to automatically derive resource bounds for 411 functions and 6018 lines of code derived from OCaml libraries, the CompCert compiler, and implementations of textbook algorithms. In a case study, the system infers bounds on the number of queries that are sent by OCaml programs to DynamoDB, a commercial NoSQL cloud database service.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009842", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ankush", + "last_name": "Das", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Shu-Chun", + "last_name": "Weng", + "institution": "Yale University" + } + ], + "dblp_key": "conf/popl/HoffmannDW17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009855", + "title": "Interactive proofs in higher-order concurrent separation logic", + "abstract": "When using a proof assistant to reason in an embedded logic -- like separation logic -- one cannot benefit from the proof contexts and basic tactics of the proof assistant. This results in proofs that are at a too low level of abstraction because they are cluttered with bookkeeping code related to manipulating the object logic.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009855", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "KU Leuven" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/KrebbersTB17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009860", + "title": "A short counterexample property for safety and liveness verification of fault-tolerant distributed algorithms", + "abstract": "Distributed algorithms have many mission-critical applications ranging from embedded systems and replicated databases to cloud computing. Due to asynchronous communication, process faults, or network failures, these algorithms are difficult to design and verify. Many algorithms achieve fault tolerance by using threshold guards that, for instance, ensure that a process waits until it has received an acknowledgment from a majority of its peers. Consequently, domain-specific languages for fault-tolerant distributed systems offer language support for threshold guards.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009860", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Igor", + "last_name": "Konnov", + "institution": "TU Wien" + }, + { + "first_name": "Marijana", + "last_name": "Lazić", + "institution": "TU Wien" + }, + { + "first_name": "Helmut", + "last_name": "Veith", + "institution": "TU Wien" + }, + { + "first_name": "Josef", + "last_name": "Widder", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/popl/KonnovLVW17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009880", + "title": "Stream fusion, to completeness", + "abstract": "Stream processing is mainstream (again): Widely-used stream libraries are now available for virtually all modern OO and functional languages, from Java to C# to Scala to OCaml to Haskell. Yet expressivity and performance are still lacking. For instance, the popular, well-optimized Java 8 streams do not support the zip operator and are still an order of magnitude slower than hand-written loops.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009880", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "Tohoku University" + }, + { + "first_name": "Aggelos", + "last_name": "Biboudis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Nick", + "last_name": "Palladinos", + "institution": "" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/popl/KiselyovBPS17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009850", + "title": "A promising semantics for relaxed-memory concurrency", + "abstract": "Despite many years of research, it has proven very difficult to develop a memory model for concurrent programming languages that adequately balances the conflicting desiderata of programmers, compilers, and hardware. In this paper, we propose the first relaxed memory model that (1) accounts for a broad spectrum of features from the C++11 concurrency model, (2) is implementable, in the sense that it provably validates many standard compiler optimizations and reorderings, as well as standard compilation schemes to x86-TSO and Power, (3) justifies simple invariant-based reasoning, thus demonstrating the absence of bad \"out-of-thin-air\" behaviors, (4) supports \"DRF\" guarantees, ensuring that programmers who use sufficient synchronization need not understand the full complexities of relaxed-memory semantics, and (5) defines the semantics of racy programs without relying on undefined behaviors, which is a prerequisite for applicability to type-safe languages like Java.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009850", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/popl/KangHLVD17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009877", + "title": "A relational model of types-and-effects in higher-order concurrent separation logic", + "abstract": "Recently we have seen a renewed interest in programming languages that tame the complexity of state and concurrency through refined type systems with more fine-grained control over effects. In addition to simplifying reasoning and eliminating whole classes of bugs, statically tracking effects opens the door to advanced compiler optimizations.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009877", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Morten", + "last_name": "Krogh-Jespersen", + "institution": "Aarhus University" + }, + { + "first_name": "Kasper", + "last_name": "Svendsen", + "institution": "University of Cambridge" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/popl/Krogh-Jespersen17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009869", + "title": "Parallel functional arrays", + "abstract": "The goal of this paper is to develop a form of functional arrays (sequences) that are as efficient as imperative arrays, can be used in parallel, and have well defined cost-semantics. The key idea is to consider sequences with functional value semantics but non-functional cost semantics. Because the value semantics is functional, \"updating\" a sequence returns a new sequence. We allow operations on \"older\" sequences (called interior sequences) to be more expensive than operations on the \"most recent\" sequences (called leaf sequences).", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009869", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ananya", + "last_name": "Kumar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/KumarBH17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009887", + "title": "Coming to terms with quantified reasoning", + "abstract": "The theory of finite term algebras provides a natural framework to describe the semantics of functional languages. The ability to efficiently reason about term algebras is essential to automate program analysis and verification for functional or imperative programs over inductively defined data types such as lists and trees. However, as the theory of finite term algebras is not finitely axiomatizable, reasoning about quantified properties over term algebras is challenging.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009887", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Laura", + "last_name": "Kovács", + "institution": "TU Wien" + }, + { + "first_name": "Simon", + "last_name": "Robillard", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Андрей", + "last_name": "Воронков", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/popl/KovacsRV17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009872", + "title": "Type directed compilation of row-typed algebraic effects", + "abstract": "Algebraic effect handlers, introduced by Plotkin and Power in 2002,", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009872", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/Leijen17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009868", + "title": "Beginner's luck: a language for property-based generators", + "abstract": "Property-based random testing à la QuickCheck requires building efficient generators for well-distributed random data satisfying complex logical predicates, but writing these generators can be difficult and error prone. We propose a domain-specific language in which generators are conveniently expressed by decorating predicates with lightweight annotations to control both the distribution of generated values and the amount of constraint solving that happens before each variable is instantiated. This language, called Luck, makes generators easier to write, read, and maintain.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009868", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Diane", + "last_name": "Gallois-Wong", + "institution": "State Key Laboratory of Cryptology" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Li-yao", + "last_name": "Xia", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/popl/LampropoulosGHH17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009847", + "title": "Fencing off go: liveness and safety for channel-based programming", + "abstract": "Go is a production-level statically typed programming language whose design features explicit message-passing primitives and lightweight threads, enabling (and encouraging) programmers to develop concurrent systems where components interact through communication more so than by lock-based shared memory concurrency. Go can only detect global deadlocks at runtime, but provides no compile-time protection against all too common communication mismatches or partial deadlocks.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009847", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julien", + "last_name": "Lange", + "institution": "Imperial College London" + }, + { + "first_name": "Nicholas", + "last_name": "Ng", + "institution": "Imperial College London" + }, + { + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/LangeNTY17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009859", + "title": "The geometry of parallelism: classical, probabilistic, and quantum effects", + "abstract": "We introduce a Geometry of Interaction model for higher-order quantum computation, and prove its adequacy for a fully fledged quantum programming language in which entanglement, duplication, and recursion are all available.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009859", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Claudia", + "last_name": "Faggian", + "institution": "Institut de Recherche en Informatique Fondamentale" + }, + { + "first_name": "Benoît", + "last_name": "Valiron", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Akira", + "last_name": "Yoshimizu", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/LagoFVY17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009870", + "title": "Analyzing divergence in bisimulation semantics", + "abstract": "Some bisimulation based abstract equivalence relations may equate divergent systems with non-divergent ones, examples including weak bisimulation equivalence and branching bisimulation equivalence. Thus extra efforts are needed to analyze divergence for the compared systems. In this paper we propose a new method for analyzing divergence in bisimulation semantics, which relies only on simple observations of individual transitions. We show that this method can verify several typical divergence preserving bisimulation equivalences including two well-known ones. As an application case study, we use the proposed method to verify the HSY collision stack to draw the conclusion that the stack implementation is correct in terms of linearizability with lock-free progress condition.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009870", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xinxin", + "last_name": "Liu", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Tingting", + "last_name": "Yu", + "institution": "Institute of Software" + }, + { + "first_name": "Wenhui", + "last_name": "Zhang", + "institution": "Institute of Software" + } + ], + "dblp_key": "conf/popl/LiuYZ17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009898", + "title": "Contextual isomorphisms", + "abstract": "What is the right notion of \"isomorphism\" between types, in a simple type theory? The traditional answer is: a pair of terms that are inverse up to a specified congruence. We firstly argue that, in the presence of effects, this answer is too liberal and needs to be restricted, using Führmann's notion of thunkability in the case of value types (as in call-by-value), or using Munch-Maccagnoni's notion of linearity in the case of computation types (as in call-by-name). Yet that leaves us with different notions of isomorphism for different kinds of type.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009898", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul Blain", + "last_name": "Levy", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/popl/Levy17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009856", + "title": "Gradual refinement types", + "abstract": "Refinement types are an effective language-based verification technique. However, as any expressive typing discipline, its strength is its weakness, imposing sometimes undesired rigidity. Guided by abstract interpretation, we extend the gradual typing agenda and develop the notion of gradual refinement types, allowing smooth evolution and interoperability between simple types and logically-refined types. In doing so, we address two challenges unexplored in the gradual typing literature: dealing with imprecise logical information, and with dependent function types. The first challenge leads to a crucial notion of locality for refinement formulas, and the second yields novel operators related to type- and term-level substitution, identifying new opportunity for runtime errors in gradual dependently-typed languages. The gradual language we present is type safe, type sound, and satisfies the refined criteria for gradually-typed languages of Siek et al. We also explain how to extend our approach to richer refinement logics, anticipating key challenges to consider.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009856", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nico", + "last_name": "Lehmann", + "institution": "University of Chile" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/popl/LehmannT17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009857", + "title": "Dynamic race detection for C++11", + "abstract": "The intricate rules for memory ordering and synchronisation associated with the C/C++11 memory model mean that data races can be difficult to eliminate from concurrent programs. Dynamic data race analysis can pinpoint races in large and complex applications, but the state-of-the-art ThreadSanitizer (tsan) tool for C/C++ considers only sequentially consistent program executions, and does not correctly model synchronisation between C/C++11 atomic operations. We present a scalable dynamic data race analysis for C/C++11 that correctly captures C/C++11 synchronisation, and uses instrumentation to support exploration of a class of non sequentially consistent executions. We concisely define the memory model fragment captured by our instrumentation via a restricted axiomatic semantics, and show that the axiomatic semantics permits exactly those executions explored by our instrumentation. We have implemented our analysis in tsan, and evaluate its effectiveness on benchmark programs, enabling a comparison with the CDSChecker tool, and on two large and highly concurrent applications: the Firefox and Chromium web browsers. Our results show that our method can detect races that are beyond the scope of the original tsan tool, and that the overhead associated with applying our enhanced instrumentation to large applications is tolerable.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009857", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Lidbury", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/LidburyD17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009881", + "title": "Semantic-directed clumping of disjunctive abstract states", + "abstract": "To infer complex structural invariants, shape analyses rely on expressive families of logical properties. Many such analyses manipulate abstract memory states that consist of separating conjunctions of basic predicates describing atomic blocks or summaries. Moreover, they use finite disjunctions of abstract memory states in order to account for dissimilar shapes. Disjunctions should be kept small for the sake of scalability, though precision often requires to keep additional case splits. In this context, deciding when and how to merge case splits and to replace them with summaries is critical both for the precision and for the efficiency. Existing techniques use sets of syntactic rules, which are tedious to design and prone to failure. In this paper, we design a semantic criterion to clump abstract states based on their silhouette which applies not only to the conservative union of disjuncts, but also to the weakening of separating conjunction of memory predicates into inductive summaries. Our approach allows to define union and widening operators that aim at preserving the case splits that are required for the analysis to succeed. We implement this approach in the MemCAD analyzer, and evaluate it on real-world C codes from existing libraries, including programs dealing with doubly linked lists, red-black trees and AVL-trees.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009881", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Huisong", + "last_name": "Li", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Francois", + "last_name": "Berenger", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/popl/LiBCR17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009897", + "title": "Do be do be do", + "abstract": "We explore the design and implementation of Frank, a strict functional programming language with a bidirectional effect type system designed from the ground up around a novel variant of Plotkin and Pretnar's effect handler abstraction.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009897", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" + }, + { + "first_name": "Craig", + "last_name": "McLaughlin", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/popl/LindleyMM17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009874", + "title": "Contract-based resource verification for higher-order functions with memoization", + "abstract": "We present a new approach for specifying and verifying resource utilization of higher-order functional programs that use lazy evaluation and memoization. In our approach, users can specify the desired resource bound as templates with numerical holes e.g. as steps <= ? not asymptotic to size(l) + ? in the contracts of functions. They can also express invariants necessary for establishing the bounds that may depend on the state of memoization. Our approach operates in two phases: first generating an instrumented first-order program that accurately models the higher-order control flow and the effects of memoization on resources using sets, algebraic datatypes and mutual recursion, and then verifying the contracts of the first-order program by producing verification conditions of the form there exists for all using an extended assume/guarantee reasoning. We use our approach to verify precise bounds on resources such as evaluation steps and number of heap-allocated objects on 17 challenging data structures and algorithms. Our benchmarks, comprising of 5K lines of functional Scala code, include lazy mergesort, Okasaki's real-time queue and deque data structures that rely on aliasing of references to first-class functions; lazy data structures based on numerical representations such as the conqueue data structure of Scala's data-parallel library, cyclic streams, as well as dynamic programming algorithms such as knapsack and Viterbi. Our evaluations show that when averaged over all benchmarks the actual runtime resource consumption is 80% of the value inferred by our tool when estimating the number of evaluation steps, and is 88% for the number of heap-allocated objects.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009874", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ravichandhran", + "last_name": "Madhavan", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Sumith", + "last_name": "Kulal", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/popl/MadhavanKK17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009875", + "title": "Stateful manifest contracts", + "abstract": "This paper studies hybrid contract verification for an imperative higher-order language based on a so-called manifest contract system. In manifest contract systems, contracts are part of static types and contract verification is hybrid in the sense that some contracts are statically verified, typically by subtyping, but others are dynamically by casts. It is, however, not trivial to extend existing manifest contract systems, which have been designed mostly for pure functional languages, to imperative features, mainly because of the lack of flow-sensitivity, which should be taken into account in verifying imperative programs statically.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009875", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/popl/SekiyamaI17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009894", + "title": "QWIRE: a core language for quantum circuits", + "abstract": "This paper introduces QWIRE (``choir''), a language for defining quantum circuits and an interface for manipulating them inside of an arbitrary classical host language. QWIRE is minimal---it contains only a few primitives---and sound with respect to the physical properties entailed by quantum mechanics. At the same time, QWIRE is expressive and highly modular due to its relationship with the host language, mirroring the QRAM model of computation that places a quantum computer (controlled by circuits) alongside a classical computer (controlled by the host language).", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009894", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jennifer", + "last_name": "Paykin", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Robert W.", + "last_name": "Rand", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/Paykin0Z17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009879", + "title": "Learning nominal automata", + "abstract": "We present an Angluin-style algorithm to learn nominal automata, which are acceptors of languages over infinite (structured) alphabets. The abstract approach we take allows us to seamlessly extend known variations of the algorithm to this new setting. In particular we can learn a subclass of nominal non-deterministic automata. An implementation using a recently developed Haskell library for nominal computation is provided for preliminary experiments.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009879", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Moerman", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Matteo", + "last_name": "Sammartino", + "institution": "University College London" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "University College London" + }, + { + "first_name": "Bartek", + "last_name": "Klin", + "institution": "University of Warsaw" + }, + { + "first_name": "Michał", + "last_name": "Szynwelski", + "institution": "University of Warsaw" + } + ], + "dblp_key": "conf/popl/MoermanS0KS17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009901", + "title": "Deciding equivalence with sums and the empty type", + "abstract": "The logical technique of focusing can be applied to the λ-calculus; in a simple type system with atomic types and negative type formers (functions, products, the unit type), its normal forms coincide with βη-normal forms. Introducing a saturation phase gives a notion of quasi-normal forms in presence of positive types (sum types and the empty type). This rich structure let us prove the decidability of βη-equivalence in presence of the empty type, the fact that it coincides with contextual equivalence, and with set-theoretic equality in all finite models.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009901", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/Scherer17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009900", + "title": "Hazelnut: a bidirectionally typed structure editor calculus", + "abstract": "Structure editors allow programmers to edit the tree structure of a program directly. This can have cognitive benefits, particularly for novice and end-user programmers. It also simplifies matters for tool designers, because they do not need to contend with malformed program text.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009900", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ian", + "last_name": "Voysey", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Michael", + "last_name": "Hilton", + "institution": "Oregon State University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/popl/OmarVHAH17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009891", + "title": "A program optimization for automatic database result caching", + "abstract": "Most popular Web applications rely on persistent databases based on languages like SQL for declarative specification of data models and the operations that read and modify them. As applications scale up in user base, they often face challenges responding quickly enough to the high volume of requests. A common aid is caching of database results in the application's memory space, taking advantage of program-specific knowledge of which caching schemes are sound and useful, embodied in handwritten modifications that make the program less maintainable. These modifications also require nontrivial reasoning about the read-write dependencies across operations. In this paper, we present a compiler optimization that automatically adds sound SQL caching to Web applications coded in the Ur/Web domain-specific functional language, with no modifications required to source code. We use a custom cache implementation that supports concurrent operations without compromising the transactional semantics of the database abstraction. Through experiments with microbenchmarks and production Ur/Web applications, we show that our optimization in many cases enables an easy doubling or more of an application's throughput, requiring nothing more than passing an extra command-line flag to the compiler.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009891", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ziv", + "last_name": "Scully", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/popl/ScullyC17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009885", + "title": "Fast polyhedra abstract domain", + "abstract": "Numerical abstract domains are an important ingredient of modern static analyzers used for verifying critical program properties (e.g., absence of buffer overflow or memory safety). Among the many numerical domains introduced over the years, Polyhedra is the most expressive one, but also the most expensive: it has worst-case exponential space and time complexity. As a consequence, static analysis with the Polyhedra domain is thought to be impractical when applied to large scale, real world programs.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009885", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "ETH Zurich" + }, + { + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/popl/SinghPV17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3011999", + "title": "Rust: from POPL to practice (keynote)", + "abstract": "In 2015, a language based fundamentally on substructural typing–Rust–hit its 1.0 release, and less than a year later it has been put into production use in a number of tech companies, including some household names. The language has started a trend, with several other mainstream languages, including C++ and Swift, in the early stages of incorporating ideas about ownership. How did this come about?", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3011999", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "" + } + ], + "dblp_key": "conf/popl/Turon17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009923", + "title": "The influence of dependent types (keynote)", + "abstract": "What has dependent type theory done for Haskell? In this talk, I will discuss the influence of dependent types on the design of programming languages and on the practice of functional programmers. Over the past ten years, the Glasgow Haskell compiler has adopted several type system features inspired by dependent type theory. However, this process has not been a direct translation; working in the context of an existing language has lead us to new designs in the semantics of dependent types. I will take a close look at what we have achieved in GHC and discuss what we have learned from this experiment: what works now, what doesn't work yet, and what has surprised us along the way.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009923", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/Weirich17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009852", + "title": "Exact Bayesian inference by symbolic disintegration", + "abstract": "Bayesian inference, of posterior knowledge from prior knowledge and observed evidence, is typically defined by Bayes's rule, which says the posterior multiplied by the probability of an observation equals a joint probability. But the observation of a continuous quantity usually has probability zero, in which case Bayes's rule says only that the unknown times zero is zero. To infer a posterior distribution from a zero-probability observation, the statistical notion of disintegration tells us to specify the observation as an expression rather than a predicate, but does not tell us how to compute the posterior. We present the first method of computing a disintegration from a probabilistic program and an expression of a quantity to be observed, even when the observation has probability zero. Because the method produces an exact posterior term and preserves a semantics in which monadic terms denote measures, it composes with other inference methods in a modular way-without sacrificing accuracy or performance.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009852", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Indiana University" + }, + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/popl/ShanR17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009843", + "title": "Cantor meets scott: semantic foundations for probabilistic networks", + "abstract": "ProbNetKAT is a probabilistic extension of NetKAT with a denotational semantics based on Markov kernels. The language is expressive enough to generate continuous distributions, which raises the question of how to compute effectively in the language. This paper gives an new characterization of ProbNetKAT’s semantics using domain theory, which provides the foundation needed to build a practical implementation. We show how to use the semantics to approximate the behavior of arbitrary ProbNetKAT programs using distributions with finite support. We develop a prototype implementation and show how to use it to solve a variety of problems including characterizing the expected congestion induced by different routing schemes and reasoning probabilistically about reachability in a network.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009843", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steffen", + "last_name": "Smolka", + "institution": "Cornell University" + }, + { + "first_name": "Praveen", + "last_name": "Kumar", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "University College London" + } + ], + "dblp_key": "conf/popl/SmolkaKFK017", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009864", + "title": "Complexity verification using guided theorem enumeration", + "abstract": "Determining if a given program satisfies a given bound on the amount of resources that it may use is a fundamental problem with critical practical applications. Conventional automatic verifiers for safety properties cannot be applied to address this problem directly because such verifiers target properties expressed in decidable theories; however, many practical bounds are expressed in nonlinear theories, which are undecidable.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009864", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Akhilesh", + "last_name": "Srikanth", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Burak", + "last_name": "Sahin", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "William R.", + "last_name": "Harris", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/popl/SrikanthSH17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009845", + "title": "Genesis: synthesizing forwarding tables in multi-tenant networks", + "abstract": "Operators in multi-tenant cloud datacenters require support for diverse and complex end-to-end policies, such as, reachability, middlebox traversals, isolation, traffic engineering, and network resource management. We present Genesis, a datacenter network management system which allows policies to be specified in a declarative manner without explicitly programming the network data plane. Genesis tackles the problem of enforcing policies by synthesizing switch forwarding tables. It uses the formal foundations of constraint solving in combination with fast off-the-shelf SMT solvers. To improve synthesis performance, Genesis incorporates a novel search strategy that uses regular expressions to specify properties that leverage the structure of datacenter networks, and a divide-and-conquer synthesis procedure which exploits the structure of policy relationships. We have prototyped Genesis, and conducted experiments with a variety of workloads on real-world topologies to demonstrate its performance.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009845", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kausik", + "last_name": "Subramanian", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aditya", + "last_name": "Akella", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/popl/SubramanianDA17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009848", + "title": "Context-sensitive data-dependence analysis via linear conjunctive language reachability", + "abstract": "Many program analysis problems can be formulated as graph reachability problems. In the literature, context-free language (CFL) reachability has been the most popular formulation and can be computed in subcubic time. The context-sensitive data-dependence analysis is a fundamental abstraction that can express a broad range of program analysis problems. It essentially describes an interleaved matched-parenthesis language reachability problem. The language is not context-free, and the problem is well-known to be undecidable. In practice, many program analyses adopt CFL-reachability to exactly model the matched parentheses for either context-sensitivity or structure-transmitted data-dependence, but not both. Thus, the CFL-reachability formulation for context-sensitive data-dependence analysis is inherently an approximation.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009848", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/popl/ZhangS17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009849", + "title": "Big types in little runtime: open-world soundness and collaborative blame for gradual type systems", + "abstract": "Gradual typing combines static and dynamic typing in the same language, offering programmers the error detection and strong guarantees of static types and the rapid prototyping and flexible programming idioms of dynamic types. Many gradually typed languages are implemented by translation into an untyped target language (e.g., Typed Clojure, TypeScript, Gradualtalk, and Reticulated Python). For such languages, it is desirable to support arbitrary interaction between translated code and legacy code in the untyped language while maintaining the type soundness of the translated code. In this paper we formalize this goal in the form of the open-world soundness criterion. We discuss why it is challenging to achieve open-world soundness using the traditional proxy-based approach for higher-order casts. However, the transient design satisfies open-world soundness. Indeed, we present a formal semantics for the transient design and prove that our semantics satisfies open-world soundness. In this paper we also solve a challenging problem for the transient design: how to provide blame tracking without proxies. We define a semantics for blame and prove the Blame Theorem. We also prove that the Gradual Guarantee holds for this system, ensuring that programs can be evolved freely between static and dynamic typing. Finally, we demonstrate that the runtime overhead of the transient approach is low in the context of Reticulated Python, an implementation of gradual typing for Python.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009849", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael M.", + "last_name": "Vitousek", + "institution": "Indiana University" + }, + { + "first_name": "Cameron", + "last_name": "Swords", + "institution": "Indiana University" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/popl/VitousekSS17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009838", + "title": "Automatically comparing memory consistency models", + "abstract": "A memory consistency model (MCM) is the part of a programming language or computer architecture specification that defines which values can legally be read from shared memory locations. Because MCMs take into account various optimisations employed by architectures and compilers, they are often complex and counterintuitive, which makes them challenging to design and to understand.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009838", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + }, + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "Imperial College London" + }, + { + "first_name": "George A.", + "last_name": "Constantinides", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/WickersonBSC17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009840", + "title": "Invariants of quantum programs: characterisations and generation", + "abstract": "Program invariant is a fundamental notion widely used in program verification and analysis. The aim of this paper is twofold: (i) find an appropriate definition of invariants for quantum programs; and (ii) develop an effective technique of invariant generation for verification and analysis of quantum programs.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009840", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Tsinghua University" + }, + { + "first_name": "Shenggang", + "last_name": "Ying", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/popl/YingYW17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009884", + "title": "LightDP: towards automating differential privacy proofs", + "abstract": "The growing popularity and adoption of differential privacy in academic and industrial settings has resulted in the development of increasingly sophisticated algorithms for releasing information while preserving privacy. Accompanying this phenomenon is the natural rise in the development and publication of incorrect algorithms, thus demonstrating the necessity of formal verification tools. However, existing formal methods for differential privacy face a dilemma: methods based on customized logics can verify sophisticated algorithms but come with a steep learning curve and significant annotation burden on the programmers, while existing programming platforms lack expressive power for some sophisticated algorithms.", + "date": "2016-12-22", + "link": "https://doi.org/10.1145/3009837.3009884", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Daniel", + "last_name": "Kifer", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/popl/ZhangK17", + "venue": "popl", + "year": 2017 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2018.json b/data/pl_conferences/popl/2018.json new file mode 100644 index 0000000..6dd6e19 --- /dev/null +++ b/data/pl_conferences/popl/2018.json @@ -0,0 +1,2075 @@ +[ + { + "paper_id": "10.1145/3158154", + "title": "RustBelt: securing the foundations of the rust programming language", + "abstract": "Rust is a new systems programming language that promises to overcome the seemingly fundamental tradeoff between high-level safety guarantees and low-level control over resource management. Unfortunately, none of Rust's safety claims have been formally proven, and there is good reason to question whether they actually hold. Specifically, Rust employs a strong, ownership-based type system, but then extends the expressive power of this core type system through libraries that internally use unsafe features. In this paper, we give the first formal (and machine-checked) safety proof for a language representing a realistic subset of Rust. Our proof is extensible in the sense that, for each new Rust library that uses unsafe features, we can say what verification condition it must satisfy in order for it to be deemed a safe extension to the language. We have carried out this verification for some of the most important libraries that are used throughout the Rust ecosystem.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158154", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/0002JKD18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158100", + "title": "Relatively complete refinement type system for verification of higher-order non-deterministic programs", + "abstract": "This paper considers verification of non-deterministic higher-order functional programs. Our contribution is a novel type system in which the types are used to express and verify (conditional) safety, termination, non-safety, and non-termination properties in the presence of ∀-∃ branching behavior due to non-determinism. For instance, the judgement ⊢ e :{ u : int | φ( u ) } ∀∀ says that every evaluation of e either diverges or reduces to some integer u satisfying φ( u ), whereas ⊢ e :{ u : int | ψ( u ) } ∃∀ says that there exists an evaluation of e that either diverges or reduces to some integer u satisfying ψ( u ). Note that the former is a safety property whereas the latter is a counterexample to a (conditional) termination property. Following the recent work on type-based verification methods for deterministic higher-order functional programs, we formalize the idea on the foundation of dependent refinement types , thereby allowing the type system to express and verify rich properties involving program values, branching behaviors, and the combination thereof. Our type system is able to seamlessly combine deductions of both universal and existential facts within a unified framework, paving the way for an exciting opportunity for new type-based verification methods that combine both universal and existential reasoning. For example, our system can prove the existence of a path violating some safety property from a proof of termination that uses a well-foundedness termination argument. We prove that our type system is sound and relatively complete, and further, thanks to having both modes of non-determinism, we show that our types are closed under complement.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158100", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" + }, + { + "first_name": "Yuki", + "last_name": "Satake", + "institution": "University of Tsukuba" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Waseda University" + } + ], + "dblp_key": "journals/pacmpl/0001ST18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158153", + "title": "Recalling a witness: foundations and applications of monotonic state", + "abstract": "We provide a way to ease the verification of programs whose state evolves monotonically. The main idea is that a property witnessed in a prior state can be soundly recalled in the current state, provided (1) state evolves according to a given preorder, and (2) the property is preserved by this preorder. In many scenarios, such monotonic reasoning yields concise modular proofs, saving the need for explicit program invariants. We distill our approach into the monotonic-state monad , a general yet compact interface for Hoare-style reasoning about monotonic state in a dependently typed language. We prove the soundness of the monotonic-state monad and use it as a unified foundation for reasoning about monotonic state in the F ⋆ verification system. Based on this foundation, we build libraries for various mutable data structures like monotonic references and apply these libraries at scale to the verification of several distributed applications.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158153", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/AhmanFHMRS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158144", + "title": "Verifying equivalence of database-driven applications", + "abstract": "This paper addresses the problem of verifying equivalence between a pair of programs that operate over databases with different schemas. This problem is particularly important in the context of web applications, which typically undergo database refactoring either for performance or maintainability reasons. While web applications should have the same externally observable behavior before and after schema migration, there are no existing tools for proving equivalence of such programs. This paper takes a first step towards solving this problem by formalizing the equivalence and refinement checking problems for database-driven applications. We also propose a proof methodology based on the notion of bisimulation invariants over relational algebra with updates and describe a technique for synthesizing such bisimulation invariants. We have implemented the proposed technique in a tool called Mediator for verifying equivalence between database-driven applications written in our intermediate language and evaluate our tool on 21 benchmarks extracted from textbooks and real-world web applications. Our results show that the proposed methodology can successfully verify 20 of these benchmarks.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158144", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/0001DLC18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158140", + "title": "Collapsing towers of interpreters", + "abstract": "Given a tower of interpreters, i.e., a sequence of multiple interpreters interpreting one another as input programs, we aim to collapse this tower into a compiler that removes all interpretive overhead and runs in a single pass. In the real world, a use case might be Python code executed by an x86 runtime, on a CPU emulated in a JavaScript VM, running on an ARM CPU. Collapsing such a tower can not only exponentially improve runtime performance, but also enable the use of base-language tools for interpreted programs, e.g., for analysis and verification. In this paper, we lay the foundations in an idealized but realistic setting. We present a multi-level lambda calculus that features staging constructs and stage polymorphism: based on runtime parameters, an evaluator either executes source code (thereby acting as an interpreter) or generates code (thereby acting as a compiler). We identify stage polymorphism, a programming model from the domain of high-performance program generators, as the key mechanism to make such interpreters compose in a collapsible way. We present Pink, a meta-circular Lisp-like evaluator on top of this calculus, and demonstrate that we can collapse arbitrarily many levels of self-interpretation, including levels with semantic modifications. We discuss several examples: compiling regular expressions through an interpreter to base code, building program transformers from modi ed interpreters, and others. We develop these ideas further to include reflection and reification, culminating in Purple, a reflective language inspired by Brown, Blond, and Black, which realizes a conceptually infinite tower, where every aspect of the semantics can change dynamically. Addressing an open challenge, we show how user programs can be compiled and recompiled under user-modified semantics.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158140", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "University of Cambridge" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/AminR18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158095", + "title": "Handling fibred algebraic effects", + "abstract": "We study algebraic computational effects and their handlers in the dependently typed setting. We describe computational effects using a generalisation of Plotkin and Pretnar's effect theories, whose dependently typed operations allow us to capture precise notions of computation, e.g., state with location-dependent store types and dependently typed update monads. Our treatment of handlers is based on an observation that their conventional term-level definition leads to unsound program equivalences being derivable in languages that include a notion of homomorphism. We solve this problem by giving handlers a novel type-based treatment via a new computation type, the user-defined algebra type, which pairs a value type (the carrier) with a set of value terms (the operations), capturing Plotkin and Pretnar's insight that effect handlers denote algebras. We then show that the conventional presentation of handlers can be routinely derived, and demonstrate that this type-based treatment of handlers provides a useful mechanism for reasoning about effectful computations. We also equip the resulting language with a sound denotational semantics based on families fibrations.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158095", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/Ahman18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158146", + "title": "Synthesizing coupling proofs of differential privacy", + "abstract": "Differential privacy has emerged as a promising probabilistic formulation of privacy, generating intense interest within academia and industry. We present a push-button, automated technique for verifying ε-differential privacy of sophisticated randomized algorithms. We make several conceptual, algorithmic, and practical contributions: (i) Inspired by the recent advances on approximate couplings and randomness alignment, we present a new proof technique called coupling strategies, which casts differential privacy proofs as a winning strategy in a game where we have finite privacy resources to expend. (ii) To discover a winning strategy, we present a constraint-based formulation of the problem as a set of Horn modulo couplings (HMC) constraints, a novel combination of first-order Horn clauses and probabilistic constraints. (iii) We present a technique for solving HMC constraints by transforming probabilistic constraints into logical constraints with uninterpreted functions. (iv) Finally, we implement our technique in the FairSquare verifier and provide the first automated privacy proofs for a number of challenging algorithms from the differential privacy literature, including Report Noisy Max, the Exponential Mechanism, and the Sparse Vector Mechanism.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158146", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/AlbarghouthiH18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158120", + "title": "Analytical modeling of cache behavior for affine programs", + "abstract": "Optimizing compilers implement program transformation strategies aimed at reducing data movement to or from main memory by exploiting the data-cache hierarchy. However, instead of attempting to minimize the number of cache misses, very approximate cost models are used, due to the lack of precise compile-time models for misses for hierarchical caches. The current state of practice for cache miss analysis is based on accurate simulation. However, simulation requires time proportional to the dataset/problem size, as well as the number of distinct cache configurations of interest to be evaluated. This paper takes a fundamentally different approach, by focusing on polyhedral programs with static control flow. Instead of relying on costly simulation, a closed-form solution for modeling of misses in a set associative cache hierarchy is developed. This solution can enable program transformation choice at compile time to optimize cache misses. A tool implementing the approach has been developed and used for validation of the framework.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158120", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wenlei", + "last_name": "Bao", + "institution": "The Ohio State University" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Colorado State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "journals/pacmpl/BaoKPS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158110", + "title": "Type-preserving CPS translation of Σ and Π types is not not possible", + "abstract": "Dependently typed languages such as Coq are used to specify and prove functional correctness of source programs, but what we ultimately need are guarantees about correctness of compiled code. By preserving dependent types through each compiler pass, we could preserve source-level specifications and correctness proofs into the generated target-language programs. Unfortunately, type-preserving compilation of dependent types is hard. In 2002, Barthe and Uustalu showed that type-preserving CPS is not possible for languages such as Coq. Specifically, they showed that for strong dependent pairs (Σ types), the standard typed call-by-name CPS is not type preserving . They further proved that for dependent case analysis on sums, a class of typed CPS translations—including the standard translation—is not possible . In 2016, Morrisett noticed a similar problem with the standard call-by-value CPS translation for dependent functions (Π types). In essence, the problem is that the standard typed CPS translation by double-negation, in which computations are assigned types of the form ( A → ⊥) → ⊥, disrupts the term/type equivalence that is used during type checking in a dependently typed language. In this paper, we prove that type-preserving CPS translation for dependently typed languages is not not possible. We develop both call-by-name and call-by-value CPS translations from the Calculus of Constructions with both Π and Σ types (CC) to a dependently typed target language, and prove type preservation and compiler correctness of each translation. Our target language is CC extended with an additional equivalence rule and an additional typing rule, which we prove consistent by giving a model in the extensional Calculus of Constructions. Our key observation is that we can use a CPS translation that employs answer-type polymorphism , where CPS-translated computations have type ∀ α. ( A → α) → α. This type justifies, by a free theorem , the new equality rule in our target language and allows us to recover the term/type equivalences that CPS translation disrupts. Finally, we conjecture that our translation extends to dependent case analysis on sums, despite the impossibility result, and provide a proof sketch.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158110", + "conference_name": "POPL", + "authors": [ + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "Northeastern University" + }, + { + "first_name": "Youyou", + "last_name": "Cong", + "institution": "Ochanomizu University" + }, + { + "first_name": "Nick", + "last_name": "Rioux", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/BowmanCRA18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158096", + "title": "Handle with care: relational interpretation of algebraic effects and handlers", + "abstract": "Algebraic effects and handlers have received a lot of attention recently, both from the theoretical point of view and in practical language design. This stems from the fact that algebraic effects give the programmer unprecedented freedom to define, combine, and interpret computational effects. This plenty-of-rope, however, demands not only a deep understanding of the underlying semantics, but also access to practical means of reasoning about effectful code, including correctness and program equivalence. In this paper we tackle this problem by constructing a step-indexed relational interpretation of a call-by-value calculus with algebraic effect handlers and a row-based polymorphic type-and-effect system. Our calculus, while striving for simplicity, enjoys desirable theoretical properties, and is close to the cores of programming languages with algebraic effects used in the wild, while the logical relation we build for it can be used to reason about non-trivial properties, such as contextual equivalence and contextual approximation of programs. Our development has been fully formalised in the Coq proof assistant.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158096", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dariusz", + "last_name": "Biernacki", + "institution": "University of Wrocław" + }, + { + "first_name": "Maciej", + "last_name": "Piróg", + "institution": "University of Wrocław" + }, + { + "first_name": "Piotr", + "last_name": "Polesiuk", + "institution": "University of Wrocław" + }, + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "University of Wrocław" + } + ], + "dblp_key": "journals/pacmpl/BiernackiPPS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158111", + "title": "Decidability of conversion for type theory in type theory", + "abstract": "Type theory should be able to handle its own meta-theory, both to justify its foundational claims and to obtain a verified implementation. At the core of a type checker for intensional type theory lies an algorithm to check equality of types, or in other words, to check whether two types are convertible. We have formalized in Agda a practical conversion checking algorithm for a dependent type theory with one universe à la Russell, natural numbers, and η-equality for Π types. We prove the algorithm correct via a Kripke logical relation parameterized by a suitable notion of equivalence of terms. We then instantiate the parameterized fundamental lemma twice: once to obtain canonicity and injectivity of type formers, and once again to prove the completeness of the algorithm. Our proof relies on inductive-recursive definitions, but not on the uniqueness of identity proofs. Thus, it is valid in variants of intensional Martin-Löf Type Theory as long as they support induction-recursion, for instance, Extensional, Observational, or Homotopy Type Theory.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158111", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "University of Gothenburg" + }, + { + "first_name": "Joakim", + "last_name": "Öhman", + "institution": "IMDEA Software" + }, + { + "first_name": "Andrea", + "last_name": "Vezzosi", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "journals/pacmpl/0001OV18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158102", + "title": "Jones-optimal partial evaluation by specialization-safe normalization", + "abstract": "We present partial evaluation by specialization-safe normalization, a novel partial evaluation technique that is Jones-optimal, that can be self-applied to achieve the Futamura projections and that can be type-checked to ensure it always generates code with the correct type. Jones-optimality is the gold-standard for nontrivial partial evaluation and guarantees that a specializer can remove an entire layer of interpretation. We achieve Jones-optimality by using a novel affine-variable static analysis that directs specialization-safe normalization to always decrease a program’s runtime. We demonstrate the robustness of our approach by showing Jones-optimality in a variety of settings. We have formally proved that our partial evaluator is Jones-optimal for call-by-value reduction, and we have experimentally shown that it is Jones-optimal for call-by-value, normal-order, and memoized normal-order. Each of our experiments tests Jones-optimality with three different self-interpreters. We implemented our partial evaluator in F ω µ i , a recent language for typed self-applicable meta-programming. It is the first Jones-optimal and self-applicable partial evaluator whose type guarantees that it always generates type-correct code.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158102", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matt", + "last_name": "Brown", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/BrownP18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158093", + "title": "Linear Haskell: practical linearity in a higher-order polymorphic language", + "abstract": "Linear type systems have a long and storied history, but not a clear path forward to integrate with existing languages such as OCaml or Haskell. In this paper, we study a linear type system designed with two crucial properties in mind: backwards-compatibility and code reuse across linear and non-linear users of a library. Only then can the benefits of linear types permeate conventional functional programming. Rather than bifurcate types into linear and non-linear counterparts, we instead attach linearity to function arrows . Linear functions can receive inputs from linearly-bound values, but can also operate over unrestricted, regular values. To demonstrate the efficacy of our linear type system — both how easy it can be integrated in an existing language implementation and how streamlined it makes it to write programs with linear types — we implemented our type system in ghc, the leading Haskell compiler, and demonstrate two kinds of applications of linear types: mutable data with pure interfaces; and enforcing protocols in I/O-performing functions.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158093", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "University of Gothenburg" + }, + { + "first_name": "Mathieu", + "last_name": "Boespflug", + "institution": "" + }, + { + "first_name": "Ryan R.", + "last_name": "Newton", + "institution": "Indiana University" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Arnaud", + "last_name": "Spiwack", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/BernardyBNJS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158145", + "title": "Proving expected sensitivity of probabilistic programs", + "abstract": "Program sensitivity, also known as Lipschitz continuity, describes how small changes in a program’s input lead to bounded changes in the output. We propose an average notion of program sensitivity for probabilistic programs—expected sensitivity—that averages a distance function over a probabilistic coupling of two output distributions from two similar inputs. By varying the distance, expected sensitivity recovers useful notions of probabilistic function sensitivity, including stability of machine learning algorithms and convergence of Markov chains. Furthermore, expected sensitivity satisfies clean compositional properties and is amenable to formal verification. We develop a relational program logic called EpRHL for proving expected sensitivity properties. Our logic features two key ideas. First, relational pre-conditions and post-conditions are expressed using distances, a real-valued generalization of typical boolean-valued (relational) assertions. Second, judgments are interpreted in terms of expectation coupling, a novel, quantitative generalization of probabilistic couplings which supports compositional reasoning. We demonstrate our logic on examples beyond the reach of prior relational logics. Our main example formalizes uniform stability of the stochastic gradient method. Furthermore, we prove rapid mixing for a probabilistic model of population dynamics. We also extend our logic with a transitivity principle for expectation couplings to capture the path coupling proof technique by Bubley and Dyer, and formalize rapid mixing of the Glauber dynamics from statistical physics.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158145", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Thomas", + "last_name": "Espitau", + "institution": "Computer Algorithms for Medicine" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "École Polytechnique" + } + ], + "dblp_key": "journals/pacmpl/BartheEGHS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158099", + "title": "Higher-order constrained horn clauses for verification", + "abstract": "Motivated by applications in automated verification of higher-order functional programs, we develop a notion of constrained Horn clauses in higher-order logic and a decision problem concerning their satisfiability. We show that, although satisfiable systems of higher-order clauses do not generally have least models, there is a notion of canonical model obtained through a reduction to a problem concerning a kind of monotone logic program. Following work in higher-order program verification, we develop a refinement type system in order to reason about and automate the search for models. This provides a sound but incomplete method for solving the decision problem. Finally, we show that there is a sense in which we can use refinement types to express properties of terms whilst staying within the higher-order constrained Horn clause framework.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158099", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Toby Cathcart", + "last_name": "Burn", + "institution": "University of Oxford" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + }, + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/BurnOR18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158103", + "title": "Migrating gradual types", + "abstract": "Gradual typing allows programs to enjoy the benefits of both static typing and dynamic typing. While it is often desirable to migrate a program from more dynamically-typed to more statically-typed or vice versa, gradual typing itself does not provide a way to facilitate this migration. This places the burden on programmers who have to manually add or remove type annotations. Besides the general challenge of adding type annotations to dynamically typed code, there are subtle interactions between these annotations in gradually typed code that exacerbate the situation. For example, to migrate a program to be as static as possible, in general, all possible combinations of adding or removing type annotations from parameters must be tried out and compared. In this paper, we address this problem by developing migrational typing, which efficiently types all possible ways of adding or removing type annotations from a gradually typed program. The typing result supports automatically migrating a program to be as static as possible, or introducing the least number of dynamic types necessary to remove a type error. The approach can be extended to support user-defined criteria about which annotations to modify. We have implemented migrational typing and evaluated it on large programs. The results show that migrational typing scales linearly with the size of the program and takes only 2–4 times longer than plain gradual typing.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158103", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John Peter", + "last_name": "Campora", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Martin", + "last_name": "Erwig", + "institution": "Oregon State University" + }, + { + "first_name": "Eric", + "last_name": "Walkingshaw", + "institution": "Oregon State University" + } + ], + "dblp_key": "journals/pacmpl/Campora0EW18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158122", + "title": "Lexicographic ranking supermartingales: an efficient approach to termination of probabilistic programs", + "abstract": "Probabilistic programs extend classical imperative programs with real-valued random variables and random branching. The most basic liveness property for such programs is the termination property. The qualitative (aka almost-sure) termination problem asks whether a given program program terminates with probability 1. While ranking functions provide a sound and complete method for non-probabilistic programs, the extension of them to probabilistic programs is achieved via ranking supermartingales (RSMs). Although deep theoretical results have been established about RSMs, their application to probabilistic programs with nondeterminism has been limited only to programs of restricted control-flow structure. For non-probabilistic programs, lexicographic ranking functions provide a compositional and practical approach for termination analysis of real-world programs. In this work we introduce lexicographic RSMs and show that they present a sound method for almost-sure termination of probabilistic programs with nondeterminism. We show that lexicographic RSMs provide a tool for compositional reasoning about almost-sure termination, and for probabilistic programs with linear arithmetic they can be synthesized efficiently (in polynomial time). We also show that with additional restrictions even asymptotic bounds on expected termination time can be obtained through lexicographic RSMs. Finally, we present experimental results on benchmarks adapted from previous work to demonstrate the effectiveness of our approach.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158122", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sheshansh", + "last_name": "Agrawal", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Petr", + "last_name": "Novotný", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "journals/pacmpl/AgrawalC018", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158119", + "title": "Data-centric dynamic partial order reduction", + "abstract": "We present a new dynamic partial-order reduction method for stateless model checking of concurrent programs. A common approach for exploring program behaviors relies on enumerating the traces of the program, without storing the visited states (aka stateless exploration). As the number of distinct traces grows exponentially, dynamic partial-order reduction (DPOR) techniques have been successfully used to partition the space of traces into equivalence classes ( Mazurkiewicz partitioning), with the goal of exploring only few representative traces from each class. We introduce a new equivalence on traces under sequential consistency semantics, which we call the observation equivalence. Two traces are observationally equivalent if every read event observes the same write event in both traces. While the traditional Mazurkiewicz equivalence is control-centric, our new definition is data-centric. We show that our observation equivalence is coarser than the Mazurkiewicz equivalence, and in many cases even exponentially coarser. We devise a DPOR exploration of the trace space, called data-centric DPOR, based on the observation equivalence. For acyclic architectures, our algorithm is guaranteed to explore exactly one representative trace from each observation class, while spending polynomial time per class. Hence, our algorithm is optimal wrt the observation equivalence, and in several cases explores exponentially fewer traces than any enumerative method based on the Mazurkiewicz equivalence. For cyclic architectures, we consider an equivalence between traces which is finer than the observation equivalence; but coarser than the Mazurkiewicz equivalence, and in some cases is exponentially coarser. Our data-centric DPOR algorithm remains optimal under this trace equivalence. Finally, we perform a basic experimental comparison between the existing Mazurkiewicz-based DPOR and our data-centric DPOR on a set of academic benchmarks. Our results show a significant reduction in both running time and the number of explored equivalence classes.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158119", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marek", + "last_name": "Chalupa", + "institution": "Masaryk University" + }, + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Nishant", + "last_name": "Sinha", + "institution": "" + }, + { + "first_name": "Kapil", + "last_name": "Vaidya", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "journals/pacmpl/ChalupaCPSV18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158150", + "title": "Bonsai: synthesis-based reasoning for type systems", + "abstract": "When designing a type system, we may want to mechanically check the design to guide its further development. We describe algorithms that perform symbolic reasoning about executable models of type systems. The algorithms support three queries. First, they check type soundness and synthesize a counterexample program if such a soundness bug is found. Second, they compare two versions of a type system, synthesizing a program accepted by one but rejected by the other. Third, they minimize the size of synthesized counterexample programs. These algorithms symbolically evaluate typecheckers and interpreters, producing formulas that characterize the set of programs that fail or succeed in the typechecker and the interpreter. However, symbolically evaluating interpreters poses efficiency challenges, which are caused by having to merge execution paths of the various possible input programs. Our main contribution is the bonsai tree , a novel symbolic representation of programs and program states that addresses these challenges. Bonsai trees encode complex syntactic information in terms of logical constraints, enabling more efficient merging. We implement these algorithms in the Bonsai tool, an assistant for type system designers. We perform case studies on how Bonsai helps test and explore a variety of type systems. Bonsai efficiently synthesizes counterexamples for soundness bugs previously inaccessible to automatic tools and is the first automated tool to find a counterexample for the recently discovered Scala soundness bug SI-9633.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158150", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kartik", + "last_name": "Chandra", + "institution": "Stanford University" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/ChandraB18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158132", + "title": "Univalent higher categories via complete Semi-Segal types", + "abstract": "Category theory in homotopy type theory is intricate as categorical laws can only be stated \"up to homotopy\", and thus require coherences. The established notion of a univalent category (as introduced by Ahrens et al.) solves this by considering only truncated types, roughly corresponding to an ordinary category. This fails to capture many naturally occurring structures, stemming from the fact that the naturally occurring structures in homotopy type theory are not ordinary, but rather higher categories. Out of the large variety of approaches to higher category theory that mathematicians have proposed, we believe that, for type theory, the simplicial strategy is best suited. Work by Lurie and Harpaz motivates the following definition. Given the first ( n +3) levels of a semisimplicial type S , we can equip S with three properties: first, contractibility of the types of certain horn fillers; second, a completeness property; and third, a truncation condition. We call this a complete semi-Segal n -type . This is very similar to an earlier suggestion by Schreiber. The definition of a univalent (1-) category by Ahrens et al. can easily be extended or restricted to the definition of a univalent n -category (more precisely, ( n ,1)-category) for n ∈ {0,1,2}, and we show that the type of complete semi-Segal n -types is equivalent to the type of univalent n -categories in these cases. Thus, we believe that the notion of a complete semi-Segal n -type can be taken as the definition of a univalent n -category. We provide a formalisation in the proof assistant Agda using a completely explicit representation of semi-simplicial types for levels up to 4.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158132", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paolo", + "last_name": "Capriotti", + "institution": "University of Nottingham" + }, + { + "first_name": "Nicolai", + "last_name": "Kraus", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/CapriottiK18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158128", + "title": "Symbolic types for lenient symbolic execution", + "abstract": "We present lambda_sym, a typed λ-calculus for lenient symbolic execution , where some language constructs do not recognize symbolic values. Its type system, however, ensures safe behavior of all symbolic values in a program. Our calculus extends a base occurrence typing system with symbolic types and mutable state, making it a suitable model for both functional and imperative symbolically executed languages. Naively allowing mutation in this mixed setting introduces soundness issues, however, so we further add concreteness polymorphism , which restores soundness without rejecting too many valid programs. To show that our calculus is a useful model for a real language, we implemented Typed Rosette, a typed extension of the solver-aided Rosette language. We evaluate Typed Rosette by porting a large code base, demonstrating that our type system accommodates a wide variety of symbolically executed programs.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158128", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Chang", + "institution": "Northeastern University" + }, + { + "first_name": "Alex", + "last_name": "Knauth", + "institution": "Northeastern University" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/ChangKT18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158127", + "title": "Linearity in higher-order recursion schemes", + "abstract": "Higher-order recursion schemes (HORS) have recently emerged as a promising foundation for higher-order program verification. We examine the impact of enriching HORS with linear types. To that end, we introduce two frameworks that blend non-linear and linear types: a variant of the λY -calculus and an extension of HORS, called linear HORS (LHORS). First we prove that the two formalisms are equivalent and there exist polynomial-time translations between them. Then, in order to support model-checking of (trees generated by) LHORS, we propose a refined version of alternating parity tree automata, called LNAPTA, whose behaviour depends on information about linearity. We show that the complexity of LNAPTA model-checking for LHORS depends on two type-theoretic parameters: linear order and linear depth. The former is in general smaller than the standard notion of order and ignores linear function spaces. In contrast, the latter measures the depth of linear clusters inside a type. Our main result states that LNAPTA model-checking of LHORS of linear order n is n-EXPTIME-complete, when linear depth is fixed. This generalizes and improves upon the classic result of Ong, which relies on the standard notion of order. To illustrate the significance of the result, we consider two applications: the MSO model-checking problem on variants of HORS with case distinction (RSFD and HORSC) on a finite domain and a call-by-value resource verification problem. In both cases, decidability can be established by translation into HORS, but the implied complexity bounds will be suboptimal due to increases in type order. In contrast, we show that the complexity bounds derived by translations into LHORS and appealing to our result are optimal in that they match the respective hardness results.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158127", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Clairambault", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Charles", + "last_name": "Grellois", + "institution": "University of Bologna" + }, + { + "first_name": "Andrzej S.", + "last_name": "Murawski", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/ClairambaultGM18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158091", + "title": "What is decidable about string constraints with the ReplaceAll function", + "abstract": "The theory of strings with concatenation has been widely argued as the basis of constraint solving for verifying string-manipulating programs. However, this theory is far from adequate for expressing many string constraints that are also needed in practice; for example, the use of regular constraints (pattern matching against a regular expression), and the string-replace function (replacing either the first occurrence or all occurrences of a ``pattern'' string constant/variable/regular expression by a ``replacement'' string constant/variable), among many others. Both regular constraints and the string-replace function are crucial for such applications as analysis of JavaScript (or more generally HTML5 applications) against cross-site scripting (XSS) vulnerabilities, which motivates us to consider a richer class of string constraints. The importance of the string-replace function (especially the replace-all facility) is increasingly recognised, which can be witnessed by the incorporation of the function in the input languages of several string constraint solvers. Recently, it was shown that any theory of strings containing the string-replace function (even the most restricted version where pattern/replacement strings are both constant strings) becomes undecidable if we do not impose some kind of straight-line (aka acyclicity) restriction on the formulas. Despite this, the straight-line restriction is still practically sensible since this condition is typically met by string constraints that are generated by symbolic execution. In this paper, we provide the first systematic study of straight-line string constraints with the string-replace function and the regular constraints as the basic operations. We show that a large class of such constraints (i.e. when only a constant string or a regular expression is permitted in the pattern) is decidable. We note that the string-replace function, even under this restriction, is sufficiently powerful for expressing the concatenation operator and much more (e.g. extensions of regular expressions with string variables). This gives us the most expressive decidable logic containing concatenation, replace, and regular constraints under the same umbrella. Our decision procedure for the straight-line fragment follows an automata-theoretic approach, and is modular in the sense that the string-replace terms are removed one by one to generate more and more regular constraints, which can then be discharged by the state-of-the-art string constraint solvers. We also show that this fragment is, in a way, a maximal decidable subclass of the straight-line fragment with string-replace and regular constraints. To this end, we show undecidability results for the following two extensions: (1) variables are permitted in the pattern parameter of the replace function, (2) length constraints are permitted.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158091", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Taolue", + "last_name": "Chen", + "institution": "University of London" + }, + { + "first_name": "Yan", + "last_name": "Chen", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Oxford" + }, + { + "first_name": "Zhilin", + "last_name": "Wu", + "institution": "Institute of Software" + } + ], + "dblp_key": "journals/pacmpl/ChenCHLW18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158106", + "title": "Transactions in relaxed memory architectures", + "abstract": "The integration of transactions into hardware relaxed memory architectures is a topic of current research both in industry and academia. In this paper, we provide a general architectural framework for the introduction of transactions into models of relaxed memory in hardware, including the SC, TSO, ARMv8 and PPC models. Our framework incorporates flexible and expressive forms of transaction aborts and execution that have hitherto been in the realm of software transactional memory. In contrast to software transactional memory, we account for the characteristics of relaxed memory as a restricted form of distributed system, without a notion of global time. We prove abstraction theorems to demonstrate that the programmer API matches the intuitions and expectations about transactions.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158106", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "Brunel University of London" + }, + { + "first_name": "Radha", + "last_name": "Jagadeesan", + "institution": "DePaul University" + }, + { + "first_name": "James", + "last_name": "Riely", + "institution": "DePaul University" + } + ], + "dblp_key": "journals/pacmpl/DongolJR18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158126", + "title": "Parametricity versus the universal type", + "abstract": "There has long been speculation in the scientific literature on how to dynamically enforce parametricity such as that yielded by System F. Almost 20 years ago, Sumii and Pierce proposed a formal compiler from System F into the cryptographic lambda calculus: an untyped lambda calculus extended with an idealised model of encryption. They conjectured that this compiler was fully abstract, i.e. that compiled terms are contextually equivalent if and only if the original terms were, a property that can be seen as a form of secure compilation. The conjecture has received attention in several other publications since then, but remains open to this day. More recently, several researchers have been looking at gradually-typed languages that extend System F. In this setting it is natural to wonder whether embedding System F into these gradually-typed languages preserves contextual equivalence and thus parametricity. In this paper, we answer both questions negatively. We provide a concrete counterexample: two System F terms whose contextual equivalence is not preserved by the Sumii-Pierce compiler, nor the embedding into the polymorphic blame calculus. This counterexample relies on the absence in System F of what we call a universal type, i.e., a type that all other types can be injected into and extracted from. As the languages in which System F is compiled have a universal type, the compilation cannot be fully abstract; this paper explains why. We believe this paper thus sheds light on recent results in the field of gradually typed languages and it provides a perspective for further research into secure compilation of polymorphic languages.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158126", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/DevriesePP18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158147", + "title": "Measurable cones and stable, measurable functions: a model for probabilistic higher-order programming", + "abstract": "We define a notion of stable and measurable map between cones endowed with measurability tests and show that it forms a cpo-enriched cartesian closed category. This category gives a denotational model of an extension of PCF supporting the main primitives of probabilistic functional programming, like continuous and discrete probabilistic distributions, sampling, conditioning and full recursion. We prove the soundness and adequacy of this model with respect to a call-by-name operational semantics and give some examples of its denotations.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158147", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ehrhard", + "institution": "Université Paris Cité" + }, + { + "first_name": "Michele", + "last_name": "Pagani", + "institution": "Université Paris Cité" + }, + { + "first_name": "Christine", + "last_name": "Tasson", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "journals/pacmpl/EhrhardPT18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158118", + "title": "Optimal Dyck reachability for data-dependence and alias analysis", + "abstract": "A fundamental algorithmic problem at the heart of static analysis is Dyck reachability. The input is a graph where the edges are labeled with different types of opening and closing parentheses, and the reachability information is computed via paths whose parentheses are properly matched. We present new results for Dyck reachability problems with applications to alias analysis and data-dependence analysis. Our main contributions, that include improved upper bounds as well as lower bounds that establish optimality guarantees, are as follows: First, we consider Dyck reachability on bidirected graphs, which is the standard way of performing field-sensitive points-to analysis. Given a bidirected graph with n nodes and m edges, we present: (i) an algorithm with worst-case running time O ( m + n · α( n )), where α( n ) is the inverse Ackermann function, improving the previously known O ( n 2 ) time bound; (ii) a matching lower bound that shows that our algorithm is optimal wrt to worst-case complexity; and (iii) an optimal average-case upper bound of O ( m ) time, improving the previously known O ( m · log n ) bound. Second, we consider the problem of context-sensitive data-dependence analysis, where the task is to obtain analysis summaries of library code in the presence of callbacks. Our algorithm preprocesses libraries in almost linear time, after which the contribution of the library in the complexity of the client analysis is only linear, and only wrt the number of call sites. Third, we prove that combinatorial algorithms for Dyck reachability on general graphs with truly sub-cubic bounds cannot be obtained without obtaining sub-cubic combinatorial algorithms for Boolean Matrix Multiplication, which is a long-standing open problem. Thus we establish that the existing combinatorial algorithms for Dyck reachability are (conditionally) optimal for general graphs. We also show that the same hardness holds for graphs of constant treewidth. Finally, we provide a prototype implementation of our algorithms for both alias analysis and data-dependence analysis. Our experimental evaluation demonstrates that the new algorithms significantly outperform all existing methods on the two problems, over real-world benchmarks.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158118", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Bhavya", + "last_name": "Choudhary", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "journals/pacmpl/ChatterjeeCP18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158131", + "title": "Up-to techniques using sized types", + "abstract": "Up-to techniques are used to make it easier—or feasible—to construct, for instance, proofs of bisimilarity. This text shows how many up-to techniques can be framed as size-preserving functions , using sized types to keep track of sizes. Through a number of examples it is argued that this approach to up-to techniques is often convenient to use in practice. Some examples of functions that cannot be made size-preserving are also included, in order to illustrate the limits of the approach. On the more theoretical side a class of up-to techniques intended to capture a natural mode of use of size-preserving functions is defined. This class turns out to correspond closely to \"functions below the companion\", a notion recently introduced by Pous.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158131", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nils Anders", + "last_name": "Danielsson", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "journals/pacmpl/Danielsson18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158113", + "title": "Sound, complete, and tractable linearizability monitoring for concurrent collections", + "abstract": "While many program properties like the validity of assertions and in-bounds array accesses admit nearly-trivial monitoring algorithms, the standard correctness criterion for concurrent data structures does not. Given an implementation of an arbitrary abstract data type, checking whether the operations invoked in one single concurrent execution are linearizable, i.e., indistinguishable from an execution where the same operations are invoked atomically, requires exponential time in the number of operations. In this work we identify a class of collection abstract data types which admit polynomial-time linearizability monitors. Collections capture the majority of concurrent data structures available in practice, including stacks, queues, sets, and maps. Although monitoring executions of arbitrary abstract data types requires enumerating exponentially-many possible linearizations, collections enjoy combinatorial properties which avoid the enumeration. We leverage these properties to reduce linearizability to Horn satisfiability. As far as we know, ours is the first sound, complete, and tractable algorithm for monitoring linearizability for types beyond single-value registers.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158113", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "SRI International" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "journals/pacmpl/EmmiE18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158136", + "title": "Online detection of effectively callback free objects with applications to smart contracts", + "abstract": "Callbacks are essential in many programming environments, but drastically complicate program understanding and reasoning because they allow to mutate object's local states by external objects in unexpected fashions, thus breaking modularity. The famous DAO bug in the cryptocurrency framework Ethereum, employed callbacks to steal $150M. We define the notion of Effectively Callback Free (ECF) objects in order to allow callbacks without preventing modular reasoning. An object is ECF in a given execution trace if there exists an equivalent execution trace without callbacks to this object. An object is ECF if it is ECF in every possible execution trace. We study the decidability of dynamically checking ECF in a given execution trace and statically checking if an object is ECF. We also show that dynamically checking ECF in Ethereum is feasible and can be done online. By running the history of all execution traces in Ethereum, we were able to verify that virtually all existing contract executions, excluding these of the DAO or of contracts with similar known vulnerabilities, are ECF. Finally, we show that ECF, whether it is verified dynamically or statically, enables modular reasoning about objects with encapsulated state.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158136", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shelly", + "last_name": "Grossman", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ittai", + "last_name": "Abraham", + "institution": "Kitware (United States)" + }, + { + "first_name": "Guy", + "last_name": "Golan-Gueta", + "institution": "Kitware (United States)" + }, + { + "first_name": "Yan", + "last_name": "Michalevsky", + "institution": "Stanford University" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Yoni", + "last_name": "Zohar", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/GrossmanAGMRSZ18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158090", + "title": "WebRelate: integrating web data with spreadsheets using examples", + "abstract": "Data integration between web sources and relational data is a key challenge faced by data scientists and spreadsheet users. There are two main challenges in programmatically joining web data with relational data. First, most websites do not expose a direct interface to obtain tabular data, so the user needs to formulate a logic to get to different webpages for each input row in the relational table. Second, after reaching the desired webpage, the user needs to write complex scripts to extract the relevant data, which is often conditioned on the input data. Since many data scientists and end-users come from diverse backgrounds, writing such complex regular-expression based logical scripts to perform data integration tasks is unfortunately often beyond their programming expertise. We present WebRelate, a system that allows users to join semi-structured web data with relational data in spreadsheets using input-output examples. WebRelate decomposes the web data integration task into two sub-tasks of i) URL learning and ii) input-dependent web extraction. We introduce a novel synthesis paradigm called \"Output-constrained Programming By Examples\", which allows us to use the finite set of possible outputs for the new inputs to efficiently constrain the search in the synthesis algorithm. We instantiate this paradigm for the two sub-tasks in WebRelate. The first sub-task generates the URLs for the webpages containing the desired data for all rows in the relational table. WebRelate achieves this by learning a string transformation program using a few example URLs. The second sub-task uses examples of desired data to be extracted from the corresponding webpages and learns a program to extract the data for the other rows. We design expressive domain-specific languages for URL generation and web data extraction, and present efficient synthesis algorithms for learning programs in these DSLs from few input-output examples. We evaluate WebRelate on 88 real-world web data integration tasks taken from online help forums and Excel product team, and show that WebRelate can learn the desired programs within few seconds using only 1 example for the majority of the tasks.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158090", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jeevana Priya", + "last_name": "Inala", + "institution": "Moscow Institute of Thermal Technology" + }, + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/InalaS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158149", + "title": "Strategy synthesis for linear arithmetic games", + "abstract": "Many problems in formal methods can be formalized as two-player games. For several applications—program synthesis, for example—in addition to determining which player wins the game, we are interested in computing a winning strategy for that player. This paper studies the strategy synthesis problem for games defined within the theory of linear rational arithmetic. Two types of games are considered. A satisfiability game , described by a quantified formula, is played by two players that take turns instantiating quantifiers. The objective of each player is to prove (or disprove) satisfiability of the formula. A reachability game , described by a pair of formulas defining the legal moves of each player, is played by two players that take turns choosing positions—rational vectors of some fixed dimension. The objective of each player is to reach a position where the opposing player has no legal moves (or to play the game forever). We give a complete algorithm for synthesizing winning strategies for satisfiability games and a sound (but necessarily incomplete) algorithm for synthesizing winning strategies for reachability games.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158149", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/FarzanK18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158137", + "title": "Correctness of speculative optimizations with dynamic deoptimization", + "abstract": "High-performance dynamic language implementations make heavy use of speculative optimizations to achieve speeds close to statically compiled languages. These optimizations are typically performed by a just-in-time compiler that generates code under a set of assumptions about the state of the program and its environment. In certain cases, a program may execute code compiled under assumptions that are no longer valid. The implementation must then deoptimize the program on-the-fly; this entails finding semantically equivalent code that does not rely on invalid assumptions, translating program state to that expected by the target code, and transferring control. This paper looks at the interaction between optimization and deoptimization, and shows that reasoning about speculation is surprisingly easy when assumptions are made explicit in the program representation. This insight is demonstrated on a compiler intermediate representation, named sourir, modeled after the high-level representation for a dynamic language. Traditional compiler optimizations such as constant folding, unreachable code elimination, and function inlining are shown to be correct in the presence of assumptions. Furthermore, the paper establishes the correctness of compiler transformations specific to deoptimization: namely unrestricted deoptimization, predicate hoisting, and assume composition.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158137", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Flückiger", + "institution": "Northeastern University" + }, + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Ming-Ho", + "last_name": "Yee", + "institution": "Northeastern University" + }, + { + "first_name": "Aviral", + "last_name": "Goel", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Vitek", + "institution": "Czech Technical University in Prague" + } + ], + "dblp_key": "journals/pacmpl/FluckigerSYGAV18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158115", + "title": "Alone together: compositional reasoning and inference for weak isolation", + "abstract": "Serializability is a well-understood correctness criterion that simplifies reasoning about the behavior of concurrent transactions by ensuring they are isolated from each other while they execute. However, enforcing serializable isolation comes at a steep cost in performance because it necessarily restricts opportunities to exploit concurrency even when such opportunities would not violate application-specific invariants. As a result, database systems in practice support, and often encourage, developers to implement transactions using weaker alternatives. These alternatives break the strong isolation guarantees offered by serializable transactions to permit greater concurrency. Unfortunately, the semantics of weak isolation is poorly understood, and usually explained only informally in terms of low-level implementation artifacts. Consequently, verifying high-level correctness properties in such environments remains a challenging problem. To address this issue, we present a novel program logic that enables compositional reasoning about the behavior of concurrently executing weakly-isolated transactions. Recognizing that the proof burden necessary to use this logic may dissuade application developers, we also describe an inference procedure based on this foundation that ascertains the weakest isolation level that still guarantees the safety of high-level consistency assertions associated with such transactions. The key to effective inference is the observation that weakly-isolated transactions can be viewed as functional (monadic) computations over an abstract database state, allowing us to treat their operations as state transformers over the database. This interpretation enables automated verification using off-the-shelf SMT solvers. Our development is parametric over a transaction’s specific isolation semantics, allowing it to be applicable over a range of concurrency control mechanisms. Case studies and experiments on real-world applications (written in an embedded DSL in OCaml) demonstrate the utility of our approach, and provide strong evidence that automated verification of weakly-isolated transactions can be placed on the same formal footing as their strongly-isolated serializable counterparts.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158115", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kartik", + "last_name": "Nagar", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Mahsa", + "last_name": "Najafzadeh", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/KakiNNJ18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158142", + "title": "Non-linear reasoning for invariant synthesis", + "abstract": "Automatic generation of non-linear loop invariants is a long-standing challenge in program analysis, with many applications. For instance, reasoning about exponentials provides a way to find invariants of digital-filter programs, and reasoning about polynomials and/or logarithms is needed for establishing invariants that describe the time or memory usage of many well-known algorithms. An appealing approach to this challenge is to exploit the powerful recurrence-solving techniques that have been developed in the field of computer algebra, which can compute exact characterizations of non-linear repetitive behavior. However, there is a gap between the capabilities of recurrence solvers and the needs of program analysis: (1) loop bodies are not merely systems of recurrence relations---they may contain conditional branches, nested loops, non-deterministic assignments, etc., and (2) a client program analyzer must be able to reason about the closed-form solutions produced by a recurrence solver (e.g., to prove assertions). This paper presents a method for generating non-linear invariants of general loops based on analyzing recurrence relations. The key components are an abstract domain for reasoning about non-linear arithmetic, a semantics-based method for extracting recurrence relations from loop bodies, and a recurrence solver that avoids closed forms that involve complex or irrational numbers. Our technique has been implemented in a program analyzer that can analyze general loops and mutually recursive procedures. Our experiments show that our technique shows promise for non-linear assertion-checking and resource-bound generation.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158142", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "John", + "last_name": "Cyphert", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Jason", + "last_name": "Breck", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/KincaidCBR18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158105", + "title": "Effective stateless model checking for C/C++ concurrency", + "abstract": "We present a stateless model checking algorithm for verifying concurrent programs running under RC11, a repaired version of the C/C++11 memory model without dependency cycles. Unlike most previous approaches, which enumerate thread interleavings up to some partial order reduction improvements, our approach works directly on execution graphs and (in the absence of RMW instructions and SC atomics) avoids redundant exploration by construction. We have implemented a model checker, called RCMC, based on this approach and applied it to a number of challenging concurrent programs. Our experiments confirm that RCMC is significantly faster, scales better than other model checking tools, and is also more resilient to small changes in the benchmarks.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158105", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "National Technical University of Athens" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Konstantinos", + "last_name": "Sagonas", + "institution": "Uppsala University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/Kokologiannakis18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158092", + "title": "String constraints with concatenation and transducers solved efficiently", + "abstract": "String analysis is the problem of reasoning about how strings are manipulated by a program. It has numerous applications including automatic detection of cross-site scripting, and automatic test-case generation. A popular string analysis technique includes symbolic executions, which at their core use constraint solvers over the string domain, a.k.a. string solvers. Such solvers typically reason about constraints expressed in theories over strings with the concatenation operator as an atomic constraint. In recent years, researchers started to recognise the importance of incorporating the replace-all operator (i.e. replace all occurrences of a string by another string) and, more generally, finite-state transductions in the theories of strings with concatenation. Such string operations are typically crucial for reasoning about XSS vulnerabilities in web applications, especially for modelling sanitisation functions and implicit browser transductions (e.g. innerHTML). Although this results in an undecidable theory in general, it was recently shown that the straight-line fragment of the theory is decidable, and is sufficiently expressive in practice. In this paper, we provide the first string solver that can reason about constraints involving both concatenation and finite-state transductions. Moreover, it has a completeness and termination guarantee for several important fragments (e.g. straight-line fragment). The main challenge addressed in the paper is the prohibitive worst-case complexity of the theory (double-exponential time), which is exponentially harder than the case without finite-state transductions. To this end, we propose a method that exploits succinct alternating finite-state automata as concise symbolic representations of string constraints. In contrast to previous approaches using nondeterministic automata, alternation offers not only exponential savings in space when representing Boolean combinations of transducers, but also a possibility of succinct representation of otherwise costly combinations of transducers and concatenation. Reasoning about the emptiness of the AFA language requires a state-space exploration in an exponential-sized graph, for which we use model checking algorithms (e.g. IC3). We have implemented our algorithm and demonstrated its efficacy on benchmarks that are derived from cross-site scripting analysis and other examples in the literature.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158092", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" + }, + { + "first_name": "Petr", + "last_name": "Janků", + "institution": "Brno University of Technology" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Oxford" + }, + { + "first_name": "Philipp", + "last_name": "Rümmer", + "institution": "Uppsala University" + }, + { + "first_name": "Tomáš", + "last_name": "Vojnar", + "institution": "Brno University of Technology" + } + ], + "dblp_key": "journals/pacmpl/HolikJLRV18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158129", + "title": "An axiomatic basis for bidirectional programming", + "abstract": "Among the frameworks of bidirectional transformations proposed for addressing various synchronisation (consistency maintenance) problems, Foster et al.’s [2007] asymmetric lenses have influenced the design of a generation of bidirectional programming languages. Most of these languages are based on a declarative programming model, and only allow the programmer to describe a consistency specification with ad hoc and/or awkward control over the consistency restoration behaviour. However, synchronisation problems are diverse and require vastly different consistency restoration strategies, and to cope with the diversity, the programmer must have the ability to fully control and reason about the consistency restoration behaviour. The putback-based approach to bidirectional programming aims to provide exactly this ability, and this paper strengthens the putback-based position by proposing the first fully fledged reasoning framework for a bidirectional language — a Hoare-style logic for Ko et al.’s [2016] putback-based language BiGUL. The Hoare-style logic lets the BiGUL programmer precisely characterise the bidirectional behaviour of their programs by reasoning solely in the putback direction, thereby offering a unidirectional programming abstraction that is reasonably straightforward to work with and yet provides full control not achieved by previous approaches. The theory has been formalised and checked in Agda, but this paper presents the Hoare-style logic in a semi-formal way to make it easily understood and usable by the working BiGUL programmer.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158129", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hsiang−Shang", + "last_name": "Ko", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "National Institute of Informatics" + } + ], + "dblp_key": "journals/pacmpl/KoH18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158112", + "title": "Safety and conservativity of definitions in HOL and Isabelle/HOL", + "abstract": "Definitions are traditionally considered to be a safe mechanism for introducing concepts on top of a logic known to be consistent. In contrast to arbitrary axioms, definitions should in principle be treatable as a form of abbreviation, and thus compiled away from the theory without losing provability. In particular, definitions should form a conservative extension of the pure logic. These properties are crucial for modern interactive theorem provers, since they ensure the consistency of the logic, as well as a valid environment for total/certified functional programming. We prove these properties, namely, safety and conservativity, for Higher-Order Logic (HOL), a logic implemented in several mainstream theorem provers and relied upon by thousands of users. Some unique features of HOL, such as the requirement to give non-emptiness proofs when defining new types and the impossibility to unfold type definitions, make the proof of these properties, and also the very formulation of safety, nontrivial. Our study also factors in the essential variation of HOL definitions featured by Isabelle/HOL, a popular member of the HOL-based provers family. The current work improves on recent results which showed a weaker property, consistency of Isabelle/HOL's definitions.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158112", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ondřej", + "last_name": "Kunčar", + "institution": "" + }, + { + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "Romanian Academy" + } + ], + "dblp_key": "journals/pacmpl/Kuncar018", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158133", + "title": "Generating good generators for inductive relations", + "abstract": "Property-based random testing (PBRT) is widely used in the functional programming and verification communities. For testing simple properties, PBRT tools such as QuickCheck can automatically generate random inputs of a given type. But for more complex properties, effective testing often demands generators for random inputs that belong to a given type and satisfy some logical condition. QuickCheck provides a library of combinators for building such generators by hand, but this can be tedious for simple conditions and error prone for more complex ones. Fortunately, the process can often be automated. The most prominent method, narrowing, works by traversing the structure of the condition, lazily instantiating parts of the data structure as constraints involving them are met. We show how to use ideas from narrowing to compile a large subclass of Coq's inductive relations into efficient generators, avoiding the interpretive overhead of previous implementations. More importantly, the same compilation technique allows us to produce proof terms certifying that each derived generator is good---i.e., sound and complete with respect to the inductive relation it was derived from. We implement our algorithm as an extension of QuickChick, an existing tool for property-based testing in Coq. We evaluate our method by automatically deriving good generators for the majority of the specifications in Software Foundations, a formalized textbook on programming language foundations.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158133", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Princeton University" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LampropoulosPP18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158125", + "title": "Go with the flow: compositional abstractions for concurrent data structures", + "abstract": "Concurrent separation logics have helped to significantly simplify correctness proofs for concurrent data structures. However, a recurring problem in such proofs is that data structure abstractions that work well in the sequential setting are much harder to reason about in a concurrent setting due to complex sharing and overlays. To solve this problem, we propose a novel approach to abstracting regions in the heap by encoding the data structure invariant into a local condition on each individual node. This condition may depend on a quantity associated with the node that is computed as a fixpoint over the entire heap graph. We refer to this quantity as a flow . Flows can encode both structural properties of the heap (e.g. the reachable nodes from the root form a tree) as well as data invariants (e.g. sortedness). We then introduce the notion of a flow interface , which expresses the relies and guarantees that a heap region imposes on its context to maintain the local flow invariant with respect to the global heap. Our main technical result is that this notion leads to a new semantic model of separation logic. In this model, flow interfaces provide a general abstraction mechanism for describing complex data structures. This abstraction mechanism admits proof rules that generalize over a wide variety of data structures. To demonstrate the versatility of our approach, we show how to extend the logic RGSep with flow interfaces. We have used this new logic to prove linearizability and memory safety of nontrivial concurrent data structures. In particular, we obtain parametric linearizability proofs for concurrent dictionary algorithms that abstract from the details of the underlying data structure representation. These proofs cannot be easily expressed using the abstraction mechanisms provided by existing separation logics.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158125", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Siddharth", + "last_name": "Krishna", + "institution": "New York University" + }, + { + "first_name": "Dennis", + "last_name": "Shasha", + "institution": "New York University" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/KrishnaSW18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158135", + "title": "On automatically proving the correctness of math.h implementations", + "abstract": "Industry standard implementations of math.h claim (often without formal proof) tight bounds on floating-point errors. We demonstrate a novel static analysis that proves these bounds and verifies the correctness of these implementations. Our key insight is a reduction of this verification task to a set of mathematical optimization problems that can be solved by off-the-shelf computer algebra systems. We use this analysis to prove the correctness of implementations in Intel's math library automatically. Prior to this work, these implementations could only be verified with significant manual effort.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158135", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Stanford University" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/Lee0A18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158123", + "title": "Algorithmic analysis of termination problems for quantum programs", + "abstract": "We introduce the notion of linear ranking super-martingale (LRSM) for quantum programs (with nondeterministic choices, namely angelic and demonic choices). Several termination theorems are established showing that the existence of the LRSMs of a quantum program implies its termination. Thus, the termination problems of quantum programs is reduced to realisability and synthesis of LRSMs. We further show that the realisability and synthesis problem of LRSMs for quantum programs can be reduced to an SDP (Semi-Definite Programming) problem, which can be settled with the existing SDP solvers. The techniques developed in this paper are used to analyse the termination of several example quantum programs, including quantum random walks and quantum Bernoulli factory for random number generation. This work is essentially a generalisation of constraint-based approach to the corresponding problems for probabilistic programs developed in the recent literature by adding two novel ideas: (1) employing the fundamental Gleason's theorem in quantum mechanics to guide the choices of templates; and (2) a generalised Farkas' lemma in terms of observables (Hermitian operators) in quantum physics.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158123", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yangjia", + "last_name": "Li", + "institution": "Institute of Software" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "journals/pacmpl/LiY18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158098", + "title": "Foundations for natural proofs and quantifier instantiation", + "abstract": "We give foundational results that explain the efficacy of heuristics used for dealing with quantified formulas and recursive definitions. We develop a framework for first order logic (FOL) over an uninterpreted combination of background theories. Our central technical result is that systematic term instantiation is complete for a fragment of FOL that we call safe . Coupled with the fact that unfolding recursive definitions is essentially term instantiation and with the observation that heap verification engines generate verification conditions in the safe fragment explains the efficacy of verification engines like natural proofs that resort to such heuristics. Furthermore, we study recursive definitions with least fixpoint semantics and show that though they are not amenable to complete procedures, we can systematically introduce induction principles that in practice bridge the divide between FOL and FOL with recursive definitions.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158098", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christof", + "last_name": "Löding", + "institution": "RWTH Aachen University" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Lucas", + "last_name": "Peña", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/LodingMP18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158134", + "title": "Why is random testing effective for partition tolerance bugs?", + "abstract": "Random testing has proven to be an effective way to catch bugs in distributed systems in the presence of network partition faults. This is surprising, as the space of potentially faulty executions is enormous, and the bugs depend on a subtle interplay between sequences of operations and faults. We provide a theoretical justification of the effectiveness of random testing in this context. First, we show a general construction, using the probabilistic method from combinatorics, that shows that whenever a random test covers a fixed coverage goal with sufficiently high probability, a small randomly-chosen set of tests achieves full coverage with high probability. In particular, we show that our construction can give test sets exponentially smaller than systematic enumeration. Second, based on an empirical study of many bugs found by random testing in production distributed systems, we introduce notions of test coverage relating to network partition faults which are effective in finding bugs. Finally, we show using combinatorial arguments that for these notions of test coverage we introduce, we can find a lower bound on the probability that a random test covers a given goal. Our general construction then explains why random testing tools achieve good coverage---and hence, find bugs---quickly. While we formulate our results in terms of network partition faults, our construction provides a step towards rigorous analysis of random testing algorithms, and can be applicable in other scenarios.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158134", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Filip", + "last_name": "Niksic", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/MajumdarN18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158094", + "title": "Polyadic approximations, fibrations and intersection types", + "abstract": "Starting from an exact correspondence between linear approximations and non-idempotent intersection types, we develop a general framework for building systems of intersection types characterizing normalization properties. We show how this construction, which uses in a fundamental way Melliès and Zeilberger's ``type systems as functors'' viewpoint, allows us to recover equivalent versions of every well known intersection type system (including Coppo and Dezani's original system, as well as its non-idempotent variants independently introduced by Gardner and de Carvalho). We also show how new systems of intersection types may be built almost automatically in this way.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158094", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Damiano", + "last_name": "Mazza", + "institution": "Université Sorbonne Paris Nord" + }, + { + "first_name": "Luc", + "last_name": "Pellissier", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Pierre", + "last_name": "Vial", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "journals/pacmpl/MazzaPV18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158121", + "title": "A new proof rule for almost-sure termination", + "abstract": "We present a new proof rule for proving almost-sure termination of probabilistic programs, including those that contain demonic non-determinism. An important question for a probabilistic program is whether the probability mass of all its diverging runs is zero, that is that it terminates \"almost surely\". Proving that can be hard, and this paper presents a new method for doing so. It applies directly to the program's source code, even if the program contains demonic choice. Like others, we use variant functions (a.k.a. \"super-martingales\") that are real-valued and decrease randomly on each loop iteration; but our key innovation is that the amount as well as the probability of the decrease are parametric. We prove the soundness of the new rule, indicate where its applicability goes beyond existing rules, and explain its connection to classical results on denumerable (non-demonic) Markov chains.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158121", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Annabelle", + "last_name": "McIver", + "institution": "Macquarie University" + }, + { + "first_name": "Carroll", + "last_name": "Morgan", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/McIverMKK18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158089", + "title": "Synthesizing bijective lenses", + "abstract": "Bidirectional transformations between different data representations occur frequently in modern software systems. They appear as serializers and deserializers, as parsers and pretty printers, as database views and view updaters, and as a multitude of different kinds of ad hoc data converters. Manually building bidirectional transformations---by writing two separate functions that are intended to be inverses---is tedious and error prone. A better approach is to use a domain-specific language in which both directions can be written as a single expression. However, these domain-specific languages can be difficult to program in, requiring programmers to manage fiddly details while working in a complex type system. We present an alternative approach. Instead of coding transformations manually, we synthesize them from declarative format descriptions and examples. Specifically, we present Optician, a tool for type-directed synthesis of bijective string transformers. The inputs to Optician are a pair of ordinary regular expressions representing two data formats and a few concrete examples for disambiguation. The output is a well-typed program in Boomerang (a bidirectional language based on the theory of lenses). The main technical challenge involves navigating the vast program search space efficiently. In particular, and unlike most prior work on type-directed synthesis, our system operates in the context of a language with a rich equivalence relation on types (the theory of regular expressions). Consequently, program synthesis requires search in two dimensions: First, our synthesis algorithm must find a pair of \"syntactically compatible types,\" and second, using the structure of those types, it must find a type- and example-compliant term. Our key insight is that it is possible to reduce the size of this search space without losing any computational power by defining a new language of lenses designed specifically for synthesis. The new language is free from arbitrary function composition and operates only over types and terms in a new disjunctive normal form. We prove (1) our new language is just as powerful as a more natural, compositional, and declarative language and (2) our synthesis algorithm is sound and complete with respect to the new language. We also demonstrate empirically that our new language changes the synthesis problem from one that admits intractable solutions to one that admits highly efficient solutions, able to synthesize intricate lenses between complex file formats in seconds. We evaluate Optician on a benchmark suite of 39 examples that includes both microbenchmarks and realistic examples derived from other data management systems including Flash Fill, a tool for synthesizing string transformations in spreadsheets, and Augeas, a tool for bidirectional processing of Linux system configuration files.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158089", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anders", + "last_name": "Miltner", + "institution": "Princeton University" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/MiltnerFPWZ18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158139", + "title": "Soft contract verification for higher-order stateful programs", + "abstract": "Software contracts allow programmers to state rich program properties using the full expressive power of an object language. However, since they are enforced at runtime, monitoring contracts imposes significant overhead and delays error discovery. So contract veri cation aims to guarantee all or most of these properties ahead of time, enabling valuable optimizations and yielding a more general assurance of correctness. Existing methods for static contract verification satisfy the needs of more restricted target languages, but fail to address the challenges unique to those conjoining untyped, dynamic programming, higher-order functions, modularity, and statefulness. Our approach tackles all these features at once, in the context of the full Racket system—a mature environment for stateful, higher-order, multi-paradigm programming with or with- out types. Evaluating our method using a set of both pure and stateful benchmarks, we are able to verify 99.94% of checks statically (all but 28 of 49, 861). Stateful, higher-order functions pose significant challenges for static contract verification in particular. In the presence of these features, a modular analysis must permit code from the current module to escape permanently to an opaque context (unspecified code from outside the current module) that may be stateful and therefore store a reference to the escaped closure. Also, contracts themselves, being predicates wri en in unrestricted Racket, may exhibit stateful behavior; a sound approach must be robust to contracts which are arbitrarily expressive and interwoven with the code they monitor. In this paper, we present and evaluate our solution based on higher-order symbolic execution, explain the techniques we used to address such thorny issues, formalize a notion of behavioral approximation, and use it to provide a mechanized proof of soundness.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158139", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Phúc C.", + "last_name": "Nguyễn", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Thomas", + "last_name": "Gilray", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/NguyenGTH18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158117", + "title": "Inference of static semantics for incomplete C programs", + "abstract": "Incomplete source code naturally emerges in software development: during the design phase, while evolving, testing and analyzing programs. Therefore, the ability to understand partial programs is a valuable asset. However, this problem is still unsolved in the C programming language. Difficulties stem from the fact that parsing C requires, not only syntax, but also semantic information. Furthermore, inferring types so that they respect C's type system is a challenging task. In this paper we present a technique that lets us solve these problems. We provide a unification-based type inference capable of dealing with C intricacies. The ideas we present let us reconstruct partial C programs into complete well-typed ones. Such program reconstruction has several applications: enabling static analysis tools in scenarios where software components may be absent; improving static analysis tools that do not rely on build-specifications; allowing stub-generation and testing tools to work on snippets; and assisting programmers on the extraction of reusable data-structures out of the program parts that use them. Our evaluation is performed on source code from a variety of C libraries such as GNU's Coreutils, GNULib, GNOME's GLib, and GDSL; on implementations from Sedgewick's books; and on snippets from popular open-source projects like CPython, FreeBSD, and Git.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158117", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leandro T. C.", + "last_name": "Melo", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Rodrigo", + "last_name": "Ribeiro", + "institution": "Universidade Federal de Ouro Preto" + }, + { + "first_name": "Marcus Rodrigues de", + "last_name": "Araújo", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "journals/pacmpl/MeloRAP18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158130", + "title": "Simplicitly: foundations and applications of implicit function types", + "abstract": "Understanding a program entails understanding its context; dependencies, configurations and even implementations are all forms of contexts. Modern programming languages and theorem provers offer an array of constructs to define contexts, implicitly. Scala offers implicit parameters which are used pervasively, but which cannot be abstracted over. This paper describes a generalization of implicit parameters to implicit function types , a powerful way to abstract over the context in which some piece of code is run. We provide a formalization based on bidirectional type-checking that closely follows the semantics implemented by the Scala compiler. To demonstrate their range of abstraction capabilities, we present several applications that make use of implicit function types. We show how to encode the builder pattern, tagless interpreters, reader and free monads and we assess the performance of the monadic structures presented.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158130", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Olivier", + "last_name": "Blanvillain", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Fengyun", + "last_name": "Liu", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Aggelos", + "last_name": "Biboudis", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Heather", + "last_name": "Miller", + "institution": "Northeastern University" + }, + { + "first_name": "Sandro", + "last_name": "Stucki", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/OderskyBLBMS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158114", + "title": "Reducing liveness to safety in first-order logic", + "abstract": "We develop a new technique for verifying temporal properties of infinite-state (distributed) systems. The main idea is to reduce the temporal verification problem to the problem of verifying the safety of infinite-state systems expressed in first-order logic. This allows to leverage existing techniques for safety verification to verify temporal properties of interesting distributed protocols, including some that have not been mechanically verified before. We model infinite-state systems using first-order logic, and use first-order temporal logic (FO-LTL) to specify temporal properties. This general formalism allows to naturally model distributed systems, while supporting both unbounded-parallelism (where the system is allowed to dynamically create processes), and infinite-state per process. The traditional approach for verifying temporal properties of infinite-state systems employs well-founded relations (e.g. using linear arithmetic ranking functions). In contrast, our approach is based the idea of fair cycle detection. In finite-state systems, temporal verification can always be reduced to fair cycle detection (a system contains a fair cycle if it revisits a state after satisfying all fairness constraints). However, with both infinitely many states and infinitely many fairness constraints, a straightforward reduction to fair cycle detection is unsound. To regain soundness, we augment the infinite-state transition system by a dynamically computed finite set, that exploits the locality of transitions. This set lets us define a form of fair cycle detection that is sound in the presence of both infinitely many states, and infinitely many fairness constraints. Our approach allows a new style of temporal verification that does not explicitly involve ranking functions. This fits well with pure first-order verification which does not explicitly reason about numerical values. In particular, it can be used with effectively propositional first-order logic (EPR), in which case checking verification conditions is decidable. We applied our technique to verify temporal properties of several interesting protocols. To the best of our knowledge, we have obtained the first mechanized liveness proof for both TLB Shootdown, and Stoppable Paxos.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158114", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Tel Aviv University" + }, + { + "first_name": "Jochen", + "last_name": "Hoenicke", + "institution": "University of Freiburg" + }, + { + "first_name": "Giuliano", + "last_name": "Losa", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/PadonHLPSS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158104", + "title": "Intrinsically-typed definitional interpreters for imperative languages", + "abstract": "A definitional interpreter defines the semantics of an object language in terms of the (well-known) semantics of a host language, enabling understanding and validation of the semantics through execution. Combining a definitional interpreter with a separate type system requires a separate type safety proof. An alternative approach, at least for pure object languages, is to use a dependently-typed language to encode the object language type system in the definition of the abstract syntax. Using such intrinsically-typed abstract syntax definitions allows the host language type checker to verify automatically that the interpreter satisfies type safety. Does this approach scale to larger and more realistic object languages, and in particular to languages with mutable state and objects? In this paper, we describe and demonstrate techniques and libraries in Agda that successfully scale up intrinsically-typed definitional interpreters to handle rich object languages with non-trivial binding structures and mutable state. While the resulting interpreters are certainly more complex than the simply-typed λ-calculus interpreter we start with, we claim that they still meet the goals of being concise, comprehensible, and executable, while guaranteeing type safety for more elaborate object languages. We make the following contributions: (1) A dependent-passing style technique for hiding the weakening of indexed values as they propagate through monadic code. (2) An Agda library for programming with scope graphs and frames , which provides a uniform approach to dealing with name binding in intrinsically-typed interpreters. (3) Case studies of intrinsically-typed definitional interpreters for the simply-typed λ-calculus with references (STLC+Ref) and for a large subset of Middleweight Java (MJ).", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158104", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Arjen", + "last_name": "Rouvoet", + "institution": "Delft University of Technology" + }, + { + "first_name": "Andrew", + "last_name": "Tolmach", + "institution": "Portland State University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/PoulsenRTKV18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158101", + "title": "Unifying analytic and statically-typed quasiquotes", + "abstract": "Metaprograms are programs that manipulate (generate, analyze and evaluate) other programs. These tasks are greatly facilitated by quasiquotation, a technique to construct and deconstruct program fragments using quoted code templates expressed in the syntax of the manipulated language. We argue that two main flavors of quasiquotes have existed so far: Lisp-style quasiquotes, which can both construct and deconstruct programs but may produce code that contains type mismatches and unbound variables; and MetaML-style quasiquotes, which rely on static typing to prevent these errors, but can only construct programs. In this paper, we show how to combine the advantages of both flavors into a unified framework: we allow the construction, deconstruction and evaluation of program fragments while ensuring that generated programs are well-typed and well-scoped, a combination unseen in previous work. We formalize our approach as λ {} , a multi-stage calculus with code pattern matching and rewriting, and prove its type safety. We also present its realization in Squid, a metaprogramming framework for Scala, leveraging Scala’s expressive type system. To demonstrate the usefulness of our approach, we introduce speculative rewrite rules , a novel code transformation technique that makes decisive use of these capabilities, and we outline how it simplifies the design of some crucial query compiler optimizations.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158101", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Antoine", + "last_name": "Voizard", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Christoph", + "last_name": "Koch", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/ParreauxVSK18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158124", + "title": "Monadic refinements for relational cost analysis", + "abstract": "Formal frameworks for cost analysis of programs have been widely studied in the unary setting and, to a limited extent, in the relational setting. However, many of these frameworks focus only on the cost aspect, largely side-lining functional properties that are often a prerequisite for cost analysis, thus leaving many interesting programs out of their purview. In this paper, we show that elegant, simple, expressive proof systems combining cost analysis and functional properties can be built by combining already known ingredients: higher-order refinements and cost monads. Specifically, we derive two syntax-directed proof systems, U C and R C , for unary and relational cost analysis, by adding a cost monad to a (syntax-directed) logic of higher-order programs. We study the metatheory of the systems, show that several nontrivial examples can be verified in them, and prove that existing frameworks for cost analysis (RelCost and RAML) can be embedded in them.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158124", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ivan", + "last_name": "Radiček", + "institution": "TU Wien" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Buffalo State University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Florian", + "last_name": "Zuleger", + "institution": "TU Wien" + } + ], + "dblp_key": "journals/pacmpl/RadicekBG0Z18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158107", + "title": "Simplifying ARM concurrency: multicopy-atomic axiomatic and operational models for ARMv8", + "abstract": "ARM has a relaxed memory model, previously specified in informal prose for ARMv7 and ARMv8. Over time, and partly due to work building formal semantics for ARM concurrency, it has become clear that some of the complexity of the model is not justified by the potential benefits. In particular, the model was originally non-multicopy-atomic : writes could become visible to some other threads before becoming visible to all — but this has not been exploited in production implementations, the corresponding potential hardware optimisations are thought to have insufficient benefits in the ARM context, and it gives rise to subtle complications when combined with other ARMv8 features. The ARMv8 architecture has therefore been revised: it now has a multicopy-atomic model. It has also been simplified in other respects, including more straightforward notions of dependency, and the architecture now includes a formal concurrency model. In this paper we detail these changes and discuss their motivation. We define two formal concurrency models: an operational one, simplifying the Flowing model of Flur et al., and the axiomatic model of the revised ARMv8 specification. The models were developed by an academic group and by ARM staff, respectively, and this extended collaboration partly motivated the above changes. We prove the equivalence of the two models. The operational model is integrated into an executable exploration tool with new web interface, demonstrated by exhaustively checking the possible behaviours of a loop-unrolled version of a Linux kernel lock implementation, a previously known bug due to unprevented speculation, and a fixed version.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158107", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Shaked", + "last_name": "Flur", + "institution": "University of Cambridge" + }, + { + "first_name": "Will", + "last_name": "Deacon", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Jon", + "last_name": "French", + "institution": "University of Cambridge" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of St Andrews" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/PulteFDFSS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158108", + "title": "Progress of concurrent objects with partial methods", + "abstract": "Various progress properties have been proposed for concurrent objects, such as wait-freedom, lock-freedom, starvation-freedom and deadlock-freedom. However, none of them applies to concurrent objects with partial methods, i.e., methods that are supposed not to return under certain circumstances. A typical example is the lock_acquire method, which must not return when the lock has already been acquired. In this paper we propose two new progress properties, partial starvation-freedom (PSF) and partial deadlock-freedom (PDF), for concurrent objects with partial methods. We also design four patterns to write abstract specifications for PSF or PDF objects under strongly or weakly fair scheduling, so that these objects contextually refine the abstract specifications. Our Abstraction Theorem shows the equivalence between PSF (or PDF) and the progress-aware contextual refinement. Finally, we generalize the program logic LiLi to have a new logic to verify the PSF (or PDF) property and linearizability of concurrent objects.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158108", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Nanjing University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/LiangF18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158116", + "title": "Programming and proving with distributed protocols", + "abstract": "Distributed systems play a crucial role in modern infrastructure, but are notoriously difficult to implement correctly. This difficulty arises from two main challenges: (a) correctly implementing core system components (e.g., two-phase commit), so all their internal invariants hold, and (b) correctly composing standalone system components into functioning trustworthy applications (e.g., persistent storage built on top of a two-phase commit instance). Recent work has developed several approaches for addressing (a) by means of mechanically verifying implementations of core distributed components, but no methodology exists to address (b) by composing such verified components into larger verified applications. As a result, expensive verification efforts for key system components are not easily reusable, which hinders further verification efforts. In this paper, we present Disel, the first framework for implementation and compositional verification of distributed systems and their clients, all within the mechanized, foundational context of the Coq proof assistant. In Disel, users implement distributed systems using a domain specific language shallowly embedded in Coq and providing both high-level programming constructs as well as low-level communication primitives. Components of composite systems are specified in Disel as protocols, which capture system-specific logic and disentangle system definitions from implementation details. By virtue of Disel's dependent type system, well-typed implementations always satisfy their protocols' invariants and never go wrong, allowing users to verify system implementations interactively using Disel's Hoare-style program logic, which extends state-of-the-art techniques for concurrency verification to the distributed setting. By virtue of the substitution principle and frame rule provided by Disel's logic, system components can be composed leading to modular, reusable verified distributed systems. We describe Disel, illustrate its use with a series of examples, outline its logic and metatheory, and report on our experience using it as a framework for implementing, specifying, and verifying distributed systems.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158116", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "University College London" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/SergeyWT18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158138", + "title": "JaVerT: JavaScript verification toolchain", + "abstract": "The dynamic nature of JavaScript and its complex semantics make it a difficult target for logic-based verification. We introduce JaVerT, a semi-automatic JavaScript Verification Toolchain, based on separation logic and aimed at the specialist developer wanting rich, mechanically verified specifications of critical JavaScript code. To specify JavaScript programs, we design abstractions that capture its key heap structures (for example, prototype chains and function closures), allowing the developer to write clear and succinct specifications with minimal knowledge of the JavaScript internals. To verify JavaScript programs, we develop JaVerT, a verification pipeline consisting of: JS-2-JSIL, a well-tested compiler from JavaScript to JSIL, an intermediate goto language capturing the fundamental dynamic features of JavaScript; JSIL Verify, a semi-automatic verification tool based on a sound JSIL separation logic; and verified axiomatic specifications of the JavaScript internal functions. Using JaVerT, we verify functional correctness properties of: data-structure libraries (key-value map, priority queue) written in an object-oriented style; operations on data structures such as binary search trees (BSTs) and lists; examples illustrating function closures; and test cases from the official ECMAScript test suite. The verification times suggest that reasoning about larger, more complex code using JaVerT is feasible.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158138", + "conference_name": "POPL", + "authors": [ + { + "first_name": "José Fragoso", + "last_name": "Santos", + "institution": "Imperial College London" + }, + { + "first_name": "Petar", + "last_name": "Maksimović", + "institution": "Imperial College London" + }, + { + "first_name": "Daiva", + "last_name": "Naudžiūnienė", + "institution": "Imperial College London" + }, + { + "first_name": "Thomas", + "last_name": "Wood", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/SantosMNWG18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158148", + "title": "Denotational validation of higher-order Bayesian inference", + "abstract": "We present a modular semantic account of Bayesian inference algorithms for probabilistic programming languages, as used in data science and machine learning. Sophisticated inference algorithms are often explained in terms of composition of smaller parts. However, neither their theoretical justification nor their implementation reflects this modularity. We show how to conceptualise and analyse such inference algorithms as manipulating intermediate representations of probabilistic programs using higher-order functions and inductive types, and their denotational semantics. Semantic accounts of continuous distributions use measurable spaces. However, our use of higher-order functions presents a substantial technical difficulty: it is impossible to define a measurable space structure over the collection of measurable functions between arbitrary measurable spaces that is compatible with standard operations on those functions, such as function application. We overcome this difficulty using quasi-Borel spaces, a recently proposed mathematical structure that supports both function spaces and continuous distributions. We define a class of semantic structures for representing probabilistic programs, and semantic validity criteria for transformations of these representations in terms of distribution preservation. We develop a collection of building blocks for composing representations. We use these building blocks to validate common inference algorithms such as Sequential Monte Carlo and Markov Chain Monte Carlo. To emphasize the connection between the semantic manipulation and its traditional measure theoretic origins, we use Kock's synthetic measure theory. We demonstrate its usefulness by proving a quasi-Borel counterpart to the Metropolis-Hastings-Green theorem.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158148", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Adam", + "last_name": "Ścibior", + "institution": "University of Cambridge" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Oxford" + }, + { + "first_name": "Matthijs", + "last_name": "Vákár", + "institution": "University of Oxford" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Yufei", + "last_name": "Cai", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + }, + { + "first_name": "Sean", + "last_name": "Moss", + "institution": "University of Cambridge" + }, + { + "first_name": "Chris", + "last_name": "Heunen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Zoubin", + "last_name": "Ghahramani", + "institution": "Uber AI (United States)" + } + ], + "dblp_key": "journals/pacmpl/ScibiorKVSYCOMH18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158152", + "title": "A logical relation for monadic encapsulation of state: proving contextual equivalences in the presence of runST", + "abstract": "We present a logical relations model of a higher-order functional programming language with impredicative polymorphism, recursive types, and a Haskell-style ST monad type with runST. We use our logical relations model to show that runST provides proper encapsulation of state, by showing that effectful computations encapsulated by runST are heap independent. Furthermore, we show that contextual refinements and equivalences that are expected to hold for pure computations do indeed hold in the presence of runST. This is the first time such relational results have been proven for a language with monadic encapsulation of state. We have formalized all the technical development and results in Coq.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158152", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "KU Leuven" + }, + { + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Morten", + "last_name": "Krogh-Jespersen", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/TimanySKB18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158143", + "title": "A practical construction for decomposing numerical abstract domains", + "abstract": "Numerical abstract domains such as Polyhedra, Octahedron, Octagon, Interval, and others are an essential component of static program analysis. The choice of domain offers a performance/precision tradeoff ranging from cheap and imprecise (Interval) to expensive and precise (Polyhedra). Recently, significant speedups were achieved for Octagon and Polyhedra by manually decomposing their transformers to work with the Cartesian product of projections associated with partitions of the variable set. While practically useful, this manual process is time consuming, error-prone, and has to be applied from scratch for every domain. In this paper, we present a generic approach for decomposing the transformers of sub-polyhedra domains along with conditions for checking whether the decomposed transformers lose precision with respect to the original transformers. These conditions are satisfied by most practical transformers, thus our approach is suitable for increasing the performance of these transformers without compromising their precision. Furthermore, our approach is ``black box:'' it does not require changes to the internals of the original non-decomposed transformers or additional manual effort per domain. We implemented our approach and applied it to the domains of Zones, Octagon, and Polyhedra. We then compared the performance of the decomposed transformers obtained with our generic method versus the state of the art: the (non-decomposed) PPL for Polyhedra and the much faster ELINA (which uses manual decomposition) for Polyhedra and Octagon. Against ELINA we demonstrate finer partitions and an associated speedup of about 2x on average. Our results indicate that the general construction presented in this work is a viable method for improving the performance of sub-polyhedra domains. It enables designers of abstract domains to benefit from decomposition without re-writing all of their transformers from scratch as required by prior work.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158143", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "ETH Zurich" + }, + { + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/SinghPV18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158141", + "title": "Refinement reflection: complete verification with SMT", + "abstract": "We introduce Refinement Reflection , a new framework for building SMT-based deductive verifiers. The key idea is to reflect the code implementing a user-defined function into the function’s (output) refinement type. As a consequence, at uses of the function, the function definition is instantiated in the SMT logic in a precise fashion that permits decidable verification. Reflection allows the user to write equational proofs of programs just by writing other programs using pattern-matching and recursion to perform case-splitting and induction. Thus, via the propositions-as-types principle, we show that reflection permits the specification of arbitrary functional correctness properties. Finally, we introduce a proof-search algorithm called Proof by Logical Evaluation that uses techniques from model checking and abstract interpretation, to completely automate equational reasoning. We have implemented reflection in Liquid Haskell and used it to verify that the widely used instances of the Monoid, Applicative, Functor, and Monad typeclasses actually satisfy key algebraic laws required to make the clients safe, and have used reflection to build the first library that actually verifies assumptions about associativity and ordering that are crucial for safe deterministic parallelism.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158141", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Anish", + "last_name": "Tondwalkar", + "institution": "University of California, San Diego" + }, + { + "first_name": "Vikraman", + "last_name": "Choudhury", + "institution": "Indiana University" + }, + { + "first_name": "Ryan G.", + "last_name": "Scott", + "institution": "Indiana University" + }, + { + "first_name": "Ryan R.", + "last_name": "Newton", + "institution": "Indiana University" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/VazouTCSNWJ18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158097", + "title": "Automated lemma synthesis in symbolic-heap separation logic", + "abstract": "The symbolic-heap fragment of separation logic has been actively developed and advocated for verifying the memory-safety property of computer programs. At present, one of its biggest challenges is to effectively prove entailments containing inductive heap predicates. These entailments are usually proof obligations generated when verifying programs that manipulate complex data structures like linked lists, trees, or graphs. To assist in proving such entailments, this paper introduces a lemma synthesis framework, which automatically discovers lemmas to serve as eureka steps in the proofs. Mathematical induction and template-based constraint solving are two pillars of our framework. To derive the supporting lemmas for a given entailment, the framework firstly identifies possible lemma templates from the entailment's heap structure. It then sets up unknown relations among each template's variables and conducts structural induction proof to generate constraints about these relations. Finally, it solves the constraints to find out actual definitions of the unknown relations, thus discovers the lemmas. We have integrated this framework into a prototype prover and have experimented it on various entailment benchmarks. The experimental results show that our lemma-synthesis-assisted prover can prove many entailments that could not be handled by existing techniques. This new proposal opens up more opportunities to automatically reason with complex inductive heap predicates.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158097", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Quang-Trung", + "last_name": "Ta", + "institution": "National University of Singapore" + }, + { + "first_name": "Ton Chanh", + "last_name": "Le", + "institution": "National University of Singapore" + }, + { + "first_name": "Siau‐Cheng", + "last_name": "Khoo", + "institution": "National University of Singapore" + }, + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/TaLKC18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158109", + "title": "A principled approach to ornamentation in ML", + "abstract": "Ornaments are a way to describe changes in datatype definitions reorganizing, adding, or dropping some pieces of data so that functions operating on the bare definition can be partially and sometimes totally lifted into functions operating on the ornamented structure. We propose an extension of ML with higher-order ornaments, demonstrate its expressiveness with a few typical examples, including code refactoring, study the metatheoretical properties of ornaments, and describe their elaboration process. We formalize ornamentation via an a posteriori abstraction of the bare code, returning a generic term, which lives in a meta-language above ML. The lifted code is obtained by application of the generic term to well-chosen arguments, followed by staged reduction, and some remaining simplifications. We use logical relations to closely relate the lifted code to the bare code.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158109", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas J.", + "last_name": "Williams", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/WilliamsR18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158151", + "title": "Program synthesis using abstraction refinement", + "abstract": "We present a new approach to example-guided program synthesis based on counterexample-guided abstraction refinement . Our method uses the abstract semantics of the underlying DSL to find a program P whose abstract behavior satisfies the examples. However, since program P may be spurious with respect to the concrete semantics, our approach iteratively refines the abstraction until we either find a program that satisfies the examples or prove that no such DSL program exists. Because many programs have the same input-output behavior in terms of their abstract semantics , this synthesis methodology significantly reduces the search space compared to existing techniques that use purely concrete semantics. While synthesis using abstraction refinement (SYNGAR) could be implemented in different settings, we propose a refinement-based synthesis algorithm that uses abstract finite tree automata (AFTA) . Our technique uses a coarse initial program abstraction to construct an initial AFTA, which is iteratively refined by constructing a proof of incorrectness of any spurious program. In addition to ruling out the spurious program accepted by the previous AFTA, proofs of incorrectness are also useful for ruling out many other spurious programs. We implement these ideas in a framework called Blaze, which can be instantiated in different domains by providing a suitable DSL and its corresponding concrete and abstract semantics. We have used the Blaze framework to build synthesizers for string and matrix transformations, and we compare Blaze with existing techniques. Our results for the string domain show that Blaze compares favorably with FlashFill, a domain-specific synthesizer that is now deployed in Microsoft PowerShell. In the context of matrix manipulations, we compare Blaze against Prose, a state-of-the-art general-purpose VSA-based synthesizer, and show that Blaze results in a 90x speed-up over Prose. In both application domains, Blaze also consistently improves upon the performance of two other existing techniques by at least an order of magnitude.", + "date": "2017-12-27", + "link": "https://doi.org/10.1145/3158151", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/WangDS18", + "venue": "popl", + "year": 2018 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2019.json b/data/pl_conferences/popl/2019.json new file mode 100644 index 0000000..24aa4fe --- /dev/null +++ b/data/pl_conferences/popl/2019.json @@ -0,0 +1,2348 @@ +[ + { + "paper_id": "10.1145/3290365", + "title": "Adventures in monitorability: from branching to linear time and back again", + "abstract": "This paper establishes a comprehensive theory of runtime monitorability for Hennessy-Milner logic with recursion, a very expressive variant of the modal µ-calculus. It investigates the monitorability of that logic with a linear-time semantics and then compares the obtained results with ones that were previously presented in the literature for a branching-time setting. Our work establishes an expressiveness hierarchy of monitorable fragments of Hennessy-Milner logic with recursion in a linear-time setting and exactly identifies what kinds of guarantees can be given using runtime monitors for each fragment in the hierarchy. Each fragment is shown to be complete, in the sense that it can express all properties that can be monitored under the corresponding guarantees. The study is carried out using a principled approach to monitoring that connects the semantics of the logic and the operational semantics of monitors. The proposed framework supports the automatic, compositional synthesis of correct monitors from monitorable properties.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290365", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Aceto", + "institution": "Reykjavík University" + }, + { + "first_name": "Antonis", + "last_name": "Achilleos", + "institution": "Reykjavík University" + }, + { + "first_name": "Adrian", + "last_name": "Francalanza", + "institution": "University of Malta" + }, + { + "first_name": "Anna", + "last_name": "Ingólfsdóttir", + "institution": "Reykjavík University" + }, + { + "first_name": "Karoliina", + "last_name": "Lehtinen", + "institution": "University of Liverpool" + } + ], + "dblp_key": "journals/pacmpl/AcetoAFIL19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290347", + "title": "Quantitative separation logic: a logic for reasoning about probabilistic pointer programs", + "abstract": "We present quantitative separation logic (QSL). In contrast to classical separation logic, QSL employs quantities which evaluate to real numbers instead of predicates which evaluate to Boolean values. The connectives of classical separation logic, separating conjunction and separating implication, are lifted from predicates to quantities. This extension is conservative: Both connectives are backward compatible to their classical analogs and obey the same laws, e.g. modus ponens, adjointness, etc. Furthermore, we develop a weakest precondition calculus for quantitative reasoning about probabilistic pointer programs in QSL. This calculus is a conservative extension of both Ishtiaq’s, O’Hearn’s and Reynolds’ separation logic for heap-manipulating programs and Kozen’s / McIver and Morgan’s weakest preexpectations for probabilistic programs. Soundness is proven with respect to an operational semantics based on Markov decision processes. Our calculus preserves O’Hearn’s frame rule , which enables local reasoning. We demonstrate that our calculus enables reasoning about quantities such as the probability of terminating with an empty heap, the probability of reaching a certain array permutation, or the expected length of a list.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290347", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Thomas", + "last_name": "Noll", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/BatzKKMN19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290335", + "title": "Bindings as bounded natural functors", + "abstract": "We present a general framework for specifying and reasoning about syntax with bindings. Abstract binder types are modeled using a universe of functors on sets, subject to a number of operations that can be used to construct complex binding patterns and binding-aware datatypes, including non-well-founded and infinitely branching types, in a modular fashion. Despite not committing to any syntactic format, the framework is ``concrete'' enough to provide definitions of the fundamental operators on terms (free variables, alpha-equivalence, and capture-avoiding substitution) and reasoning and definition principles. This work is compatible with classical higher-order logic and has been formalized in the proof assistant Isabelle/HOL.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290335", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jasmin Christian", + "last_name": "Blanchette", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Lorenzo", + "last_name": "Gheri", + "institution": "Middlesex University" + }, + { + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "Romanian Academy" + }, + { + "first_name": "Dmitriy", + "last_name": "Traytel", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/BlanchetteGPT19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290363", + "title": "Modular quantitative monitoring", + "abstract": "In real-time decision making and runtime monitoring applications, declarative languages are commonly used as they facilitate modular high-level specifications with the compiler guaranteeing evaluation over data streams in an efficient and incremental manner. We introduce the model of Data Transducers to allow modular compilation of queries over streaming data. A data transducer maintains a finite set of data variables and processes a sequence of tagged data values by updating its variables using an allowed set of operations. The model allows unambiguous nondeterminism, exponentially succinct control, and combining values from parallel threads of computation. The semantics of the model immediately suggests an efficient streaming algorithm for evaluation. The expressiveness of data transducers coincides with streamable regular transductions , a robust and streamable class of functions characterized by MSO-definable string-to-DAG transformations with no backward edges. We show that the novel features of data transducers, unlike previously studied transducers, make them as succinct as traditional imperative code for processing data streams, but the structuring of the transition function permits modular compilation. In particular, we show that operations such as parallel composition, union, prefix-sum, and quantitative analogs of combinators for unambiguous parsing, can be implemented by natural and succinct constructions on data transducers. To illustrate the benefits of such modularity in compilation, we define a new language for quantitative monitoring, QRE-Past, that integrates features of past-time temporal logic and quantitative regular expressions. While this combination allows a natural specification of a cardiac arrhythmia detection algorithm in QRE-Past, compilation of QRE-Past specifications into efficient monitors comes for free thanks to succinct constructions on data transducers.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290363", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + }, + { + "first_name": "Caleb", + "last_name": "Stanford", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/AlurMS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290378", + "title": "Iron: managing obligations in higher-order concurrent separation logic", + "abstract": "Precise management of resources and the obligations they impose, such as the need to dispose of memory, close locks, and release file handles, is hard---especially in the presence of concurrency, when some resources are shared, and different threads operate on them concurrently. We present Iron, a novel higher-order concurrent separation logic that allows for precise reasoning about resources that are transferable among dynamically allocated threads. In particular, Iron can be used to show the correctness of challenging examples, where the reclamation of memory is delegated to a forked-off thread. We show soundness of Iron by means of a model of Iron, defined on top of the Iris base logic, and we use this model to prove that memory resources are accounted for precisely and not leaked. We have formalized all of the developments in the Coq proof assistant.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290378", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aleš", + "last_name": "Bizjak", + "institution": "Aarhus University" + }, + { + "first_name": "Daniel", + "last_name": "Gratzer", + "institution": "Aarhus University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/BizjakGKB19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290364", + "title": "Bounded model checking of signal temporal logic properties using syntactic separation", + "abstract": "Signal temporal logic (STL) is a temporal logic formalism for specifying properties of continuous signals. STL is widely used for analyzing programs in cyber-physical systems (CPS) that interact with physical entities. However, existing methods for analyzing STL properties are incomplete even for bounded signals, and thus cannot guarantee the correctness of CPS programs. This paper presents a new symbolic model checking algorithm for CPS programs that is refutationally complete for general STL properties of bounded signals. To address the difficulties of dealing with an infinite state space over a continuous time domain, we first propose a syntactic separation of STL, which decomposes an STL formula into an equivalent formula so that each subformula depends only on one of the disjoint segments of a signal. Using the syntactic separation, an STL model checking problem can be reduced to the satisfiability of a first-order logic formula, which is decidable for CPS programs with polynomial dynamics using satisfiability modulo theories (SMT). Unlike the previous methods, our method can verify the correctness of CPS programs for STL properties up to given bounds.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290364", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kyungmin", + "last_name": "Bae", + "institution": "Korea Post" + }, + { + "first_name": "Jia", + "last_name": "Lee", + "institution": "Pohang University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/BaeL19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290319", + "title": "Abstracting algebraic effects", + "abstract": "Proposed originally by Plotkin and Pretnar, algebraic effects and their handlers are a leading-edge approach to computational effects: exceptions, mutable state, nondeterminism, and such. Appreciated for their elegance and expressiveness, they are now progressing into mainstream functional programming languages. In this paper, we introduce and examine programming language constructs that back adoption of programming with algebraic effects on a larger scale in a modular fashion by providing mechanisms for abstraction. We propose two such mechanisms: existential effects (which hide the details of a particular effect from the user) and local effects (which guarantee that no code coming from the outside can interfere with a given effect). The main technical difficulty arises from the dynamic nature of coupling an effectful operation with the right handler during execution, but, as we show in this paper, a carefully designed type system can ensure that this will not break the abstraction. Our main contribution is a novel calculus for algebraic effects and handlers, called λ HEL , equipped with local and existential algebraic effects, in which the dynamic nature of handlers is kept in check by typed runtime coercions. As a proof of concept, we present an experimental programming language based on our calculus, which provides strong abstraction mechanisms via an ML-style module system.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290319", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dariusz", + "last_name": "Biernacki", + "institution": "University of Wrocław" + }, + { + "first_name": "Maciej", + "last_name": "Piróg", + "institution": "University of Wrocław" + }, + { + "first_name": "Piotr", + "last_name": "Polesiuk", + "institution": "University of Wrocław" + }, + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "University of Wrocław" + } + ], + "dblp_key": "journals/pacmpl/BiernackiPPS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290357", + "title": "Skeletal semantics and their interpretations", + "abstract": "The development of mechanised language specification based on structured operational semantics, with applications to verified compilers and sound program analysis, requires huge effort. General theory and frameworks have been proposed to help with this effort. However, none of this work provides a systematic way of developing concrete and abstract semantics, connected together by a general consistency result. We introduce a skeletal semantics of a language, where each skeleton describes the complete semantic behaviour of a language construct. We define a general notion of interpretation , which provides a systematic and language-independent way of deriving semantic judgements from the skeletal semantics. We explore four generic interpretations: a simple well-formedness interpretation; a concrete interpretation; an abstract interpretation; and a constraint generator for flow-sensitive analysis. We prove general consistency results between interpretations, depending only on simple language-dependent lemmas. We illustrate our ideas using a simple While language.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290357", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Bodin", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + }, + { + "first_name": "Thomas", + "last_name": "Jensen", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Alan", + "last_name": "Schmitt", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/BodinGJS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290340", + "title": "Two sides of the same coin: session types and game semantics: a synchronous side and an asynchronous side", + "abstract": "Game semantics and session types are two formalisations of the same concept: message-passing open programs following certain protocols. Game semantics represents protocols as games, and programs as strategies; while session types specify protocols, and well-typed π-calculus processes model programs. Giving faithful models of the π-calculus and giving a precise description of strategies as a programming language are two difficult problems. In this paper, we show how these two problems can be tackled at the same time by building an accurate game semantics model of the session π-calculus. Our main contribution is to fill a semantic gap between the synchrony of the (session) π-calculus and the asynchrony of game semantics, by developing an event-structure based game semantics for synchronous concurrent computation. This model supports the first truly concurrent fully abstract (for barbed congruence) interpretation of the synchronous (session) π-calculus. We further strengthen this correspondence, establishing finite definability of asynchronous strategies by the internal session π-calculus. As an application of these results, we propose a faithful encoding of synchronous strategies into asynchronous strategies by call-return protocols, which induces automatically an encoding at the level of processes. Our results bring session types and game semantics into the same picture, proposing the session calculus as a programming language for strategies, and strategies as a very accurate model of the session calculus. We implement a prototype which computes the interpretation of session processes as synchronous strategies.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290340", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon", + "last_name": "Castellan", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/CastellanY19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290342", + "title": "Distributed programming using role-parametric session types in go: statically-typed endpoint APIs for dynamically-instantiated communication structures", + "abstract": "This paper presents a framework for the static specification and safe programming of message passing protocols where the number and kinds of participants are dynamically instantiated. We develop the first theory of distributed multiparty session types (MPST) to support parameterised protocols with indexed roles—our framework statically infers the different kinds of participants induced by a protocol definition as role variants, and produces decoupled endpoint projections of the protocol onto each variant. This enables safe MPST-based programming of the parameterised endpoints in distributed settings: each endpoint can be implemented separately by different programmers, using different techniques (or languages). We prove the decidability of role variant inference and well-formedness checking, and the correctness of projection. We implement our theory as a toolchain for programming such role-parametric MPST protocols in Go. Our approach is to generate API families of lightweight, protocol- and variant-specific type wrappers for I/O. The APIs ensure a well-typed Go endpoint program (by native Go type checking) will perform only compliant I/O actions w.r.t. the source protocol. We leverage the abstractions of MPST to support the specification and implementation of Go applications involving multiple channels, possibly over mixed transports (e.g., Go channels, TCP), and channel passing via a unified programming interface. We evaluate the applicability and run-time performance of our generated APIs using microbenchmarks and real-world applications.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290342", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Castro", + "institution": "Imperial College London" + }, + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "Imperial College London" + }, + { + "first_name": "Sung-Shik", + "last_name": "Jongmans", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Nicholas", + "last_name": "Ng", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/CastroHJNY19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290339", + "title": "Fixpoint games on continuous lattices", + "abstract": "Many analysis and verifications tasks, such as static program analyses and model-checking for temporal logics, reduce to the solution of systems of equations over suitable lattices. Inspired by recent work on lattice-theoretic progress measures, we develop a game-theoretical approach to the solution of systems of monotone equations over lattices, where for each single equation either the least or greatest solution is taken. A simple parity game, referred to as fixpoint game, is defined that provides a correct and complete characterisation of the solution of systems of equations over continuous lattices, a quite general class of lattices widely used in semantics. For powerset lattices the fixpoint game is intimately connected with classical parity games for µ-calculus model-checking, whose solution can exploit as a key tool Jurdziński’s small progress measures. We show how the notion of progress measure can be naturally generalised to fixpoint games over continuous lattices and we prove the existence of small progress measures. Our results lead to a constructive formulation of progress measures as (least) fixpoints. We refine this characterisation by introducing the notion of selection that allows one to constrain the plays in the parity game, enabling an effective (and possibly efficient) solution of the game, and thus of the associated verification problem. We also propose a logic for specifying the moves of the existential player that can be used to systematically derive simplified equations for efficiently computing progress measures. We discuss potential applications to the model-checking of latticed µ-calculi.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290339", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paolo", + "last_name": "Baldan", + "institution": "University of Padua" + }, + { + "first_name": "Barbara", + "last_name": "König", + "institution": "University of Duisburg-Essen" + }, + { + "first_name": "Christina", + "last_name": "Mika-Michalski", + "institution": "University of Duisburg-Essen" + }, + { + "first_name": "Tommaso", + "last_name": "Padoan", + "institution": "University of Padua" + } + ], + "dblp_key": "journals/pacmpl/BaldanKMP19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290353", + "title": "code2vec: learning distributed representations of code", + "abstract": "We present a neural model for representing snippets of code as continuous distributed vectors (``code embeddings''). The main idea is to represent a code snippet as a single fixed-length code vector, which can be used to predict semantic properties of the snippet. To this end, code is first decomposed to a collection of paths in its abstract syntax tree. Then, the network learns the atomic representation of each path while simultaneously learning how to aggregate a set of them. We demonstrate the effectiveness of our approach by using it to predict a method's name from the vector representation of its body. We evaluate our approach by training a model on a dataset of 12M methods. We show that code vectors trained on this dataset can predict method names from files that were unobserved during training. Furthermore, we show that our model learns useful method name vectors that capture semantic similarities, combinations, and analogies. A comparison of our approach to previous techniques over the same dataset shows an improvement of more than 75%, making it the first to successfully predict method names based on a large, cross-project corpus. Our trained model, visualizations and vector similarities are available as an interactive online demo at http://code2vec.org. The code, data and trained models are available at https://github.com/tech-srl/code2vec.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290353", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Uri", + "last_name": "Alon", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Meital", + "last_name": "Zilberstein", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Omer", + "last_name": "Levy", + "institution": "Meta (United States)" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AlonZLY19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290338", + "title": "Diagrammatic algebra: from linear to concurrent systems", + "abstract": "We introduce the resource calculus, a string diagrammatic language for concurrent systems. Significantly, it uses the same syntax and operational semantics as the signal flow calculus --- an algebraic formalism for signal flow graphs, which is a combinatorial model of computation of interest in control theory. Indeed, our approach stems from the simple but fruitful observation that, by replacing real numbers (modelling signals) with natural numbers (modelling resources) in the operational semantics, concurrent behaviour patterns emerge. The resource calculus is canonical: we equip it and its stateful extension with equational theories that characterise the underlying space of definable behaviours---a convex algebraic universe of additive relations---via isomorphisms of categories. Finally, we demonstrate that our calculus is sufficiently expressive to capture behaviour definable by classical Petri nets.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290338", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Filippo", + "last_name": "Bonchi", + "institution": "University of Pisa" + }, + { + "first_name": "Joshua", + "last_name": "Holland", + "institution": "University of Southampton" + }, + { + "first_name": "Robin", + "last_name": "Piedeleu", + "institution": "University of Oxford" + }, + { + "first_name": "Paweł", + "last_name": "Sobociński", + "institution": "University of Southampton" + }, + { + "first_name": "Fabio", + "last_name": "Zanasi", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/BonchiHPSZ19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290360", + "title": "Inferring frame conditions with static correlation analysis", + "abstract": "We introduce the abstract domain of correlations to denote equality relations between parts of inputs and outputs of programs. We formalise the theory of correlations, and mechanically verify their semantic properties. We design a static inter-procedural dataflow analysis for automatically inferring correlations for programs written in a first-order language equipped with algebraic data-types and arrays. The analysis, its precision and execution cost, have been evaluated on the code and functional specification of an industrial-size micro-kernel. We exploit the inferred correlations to automatically discharge two thirds of the proof obligations related to the preservation of invariants for this micro-kernel.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290360", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oana F.", + "last_name": "Andreescu", + "institution": "Institut de Mécanique et d'Ingénierie de Bordeaux" + }, + { + "first_name": "Thomas Wiben", + "last_name": "Jensen", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Stéphane", + "last_name": "Lescuyer", + "institution": "" + }, + { + "first_name": "Benoît", + "last_name": "Montagu", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/AndreescuJLM19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290384", + "title": "ISA semantics for ARMv8-a, RISC-v, and CHERI-MIPS", + "abstract": "Architecture specifications notionally define the fundamental interface between hardware and software: the envelope of allowed behaviour for processor implementations, and the basic assumptions for software development and verification. But in practice, they are typically prose and pseudocode documents, not rigorous or executable artifacts, leaving software and verification on shaky ground. In this paper, we present rigorous semantic models for the sequential behaviour of large parts of the mainstream ARMv8-A, RISC-V, and MIPS architectures, and the research CHERI-MIPS architecture, that are complete enough to boot operating systems, variously Linux, FreeBSD, or seL4. Our ARMv8-A models are automatically translated from authoritative ARM-internal definitions, and (in one variant) tested against the ARM Architecture Validation Suite. We do this using a custom language for ISA semantics, Sail, with a lightweight dependent type system, that supports automatic generation of emulator code in C and OCaml, and automatic generation of proof-assistant definitions for Isabelle, HOL4, and (currently only for MIPS) Coq. We use the former for validation, and to assess specification coverage. To demonstrate the usability of the latter, we prove (in Isabelle) correctness of a purely functional characterisation of ARMv8-A address translation. We moreover integrate the RISC-V model into the RMEM tool for (user-mode) relaxed-memory concurrency exploration. We prove (on paper) the soundness of the core Sail type system. We thereby take a big step towards making the architectural abstraction actually well-defined, establishing foundations for verification and reasoning.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290384", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alasdair", + "last_name": "Armstrong", + "institution": "University of Cambridge" + }, + { + "first_name": "Thomas", + "last_name": "Bauereiß", + "institution": "University of Cambridge" + }, + { + "first_name": "B. K.", + "last_name": "Campbell", + "institution": "University of Edinburgh" + }, + { + "first_name": "Alastair", + "last_name": "Reid", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Kathryn E.", + "last_name": "Gray", + "institution": "University of Cambridge" + }, + { + "first_name": "Robert M.", + "last_name": "Norton", + "institution": "University of Cambridge" + }, + { + "first_name": "Prashanth", + "last_name": "Mundkur", + "institution": "SRI International" + }, + { + "first_name": "Mark P.", + "last_name": "Wassell", + "institution": "University of Cambridge" + }, + { + "first_name": "Jon", + "last_name": "French", + "institution": "University of Cambridge" + }, + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Shaked", + "last_name": "Flur", + "institution": "University of Cambridge" + }, + { + "first_name": "Ian", + "last_name": "Stark", + "institution": "University of Edinburgh" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/ArmstrongBCRGNM19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290329", + "title": "Gradual typing: a new perspective", + "abstract": "We define a new, more semantic interpretation of gradual types and use it to ``gradualize'' two forms of polymorphism: subtyping polymorphism and implicit parametric polymorphism. In particular, we use the new interpretation to define three gradual type systems ---Hindley-Milner, with subtyping, and with union and intersection types--- in terms of two preorders, subtyping and materialization. We define these systems both declaratively ---by adding two subsumption-like rules--- which yields clearer, more intelligible, and streamlined definitions, and algorithmically by reusing existing techniques such as unification and tallying.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290329", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Université Paris Cité" + }, + { + "first_name": "Victor", + "last_name": "Lanvin", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Tommaso", + "last_name": "Petrucciani", + "institution": "University of Genoa" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/CastagnaLPS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290314", + "title": "Higher inductive types in cubical computational type theory", + "abstract": "Homotopy type theory proposes higher inductive types (HITs) as a means of defining and reasoning about inductively-generated objects with higher-dimensional structure. As with the univalence axiom, however, homotopy type theory does not specify the computational behavior of HITs. Computational interpretations have now been provided for univalence and specific HITs by way of cubical type theories, which use a judgmental infrastructure of dimension variables. We extend the cartesian cubical computational type theory introduced by Angiuli et al. with a schema for indexed cubical inductive types (CITs), an adaptation of higher inductive types to the cubical setting. In doing so, we isolate the canonical values of a cubical inductive type and prove a canonicity theorem with respect to these values.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290314", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Evan", + "last_name": "Cavallo", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/CavalloH19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290383", + "title": "Grounding thin-air reads with event structures", + "abstract": "The key challenge in defining the concurrency semantics of a programming language is how to enable the most efficient compilation to existing hardware architectures, and yet forbid programs from reading thin-air values, i.e., ones that do not appear in the program. At POPL'17, Kang et al. achieved a major breakthrough by introducing the `promising' semantics that came with results showing that it was a good candidate solution to the problem. Unfortunately, however, the promising semantics is rather complicated, and due to its complexity it contains some flaws and limitations that are very hard to address. In response, we present an alternative solution to this problem based on event structures. We show that it is indeed a solution by establishing the standard results about the semantics (DRF theorems, implementation and optimization correctness) as well as a formal connection to the semantics of Kang et al. Further, we show that it is easier to adapt, by extending the semantics to cover features (such as SC accesses) that are not supported by Kang et al. and to rule out some dubious behaviors admitted by the promising semantics.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290383", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/ChakrabortyV19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290362", + "title": "Decision procedures for path feasibility of string-manipulating programs with complex operations", + "abstract": "The design and implementation of decision procedures for checking path feasibility in string-manipulating programs is an important problem, with such applications as symbolic execution of programs with strings and automated detection of cross-site scripting (XSS) vulnerabilities in web applications. A (symbolic) path is given as a finite sequence of assignments and assertions (i.e. without loops), and checking its feasibility amounts to determining the existence of inputs that yield a successful execution. Modern programming languages (e.g. JavaScript, PHP, and Python) support many complex string operations, and strings are also often implicitly modified during a computation in some intricate fashion (e.g. by some autoescaping mechanisms). In this paper we provide two general semantic conditions which together ensure the decidability of path feasibility: (1) each assertion admits regular monadic decomposition (i.e. is an effectively recognisable relation), and (2) each assignment uses a (possibly nondeterministic) function whose inverse relation preserves regularity. We show that the semantic conditions are expressive since they are satisfied by a multitude of string operations including concatenation, one-way and two-way finite-state transducers, replaceall functions (where the replacement string could contain variables), string-reverse functions, regular-expression matching, and some (restricted) forms of letter-counting/length functions. The semantic conditions also strictly subsume existing decidable string theories (e.g. straight-line fragments, and acyclic logics), and most existing benchmarks (e.g. most of Kaluza’s, and all of SLOG’s, Stranger’s, and SLOTH’s benchmarks). Our semantic conditions also yield a conceptually simple decision procedure, as well as an extensible architecture of a string solver in that a user may easily incorporate his/her own string functions into the solver by simply providing code for the pre-image computation without worrying about other parts of the solver. Despite these, the semantic conditions are unfortunately too general to provide a fast and complete decision procedure. We provide strong theoretical evidence for this in the form of complexity results. To rectify this problem, we propose two solutions. Our main solution is to allow only partial string functions (i.e., prohibit nondeterminism) in condition (2). This restriction is satisfied in many cases in practice, and yields decision procedures that are effective in both theory and practice. Whenever nondeterministic functions are still needed (e.g. the string function split), our second solution is to provide a syntactic fragment that provides a support of nondeterministic functions, and operations like one-way transducers, replaceall (with constant replacement string), the string-reverse function, concatenation, and regular-expression matching. We show that this fragment can be reduced to an existing solver SLOTH that exploits fast model checking algorithms like IC3. We provide an efficient implementation of our decision procedure (assuming our first solution above, i.e., deterministic partial string functions) in a new string solver OSTRICH. Our implementation provides built-in support for concatenation, reverse, functional transducers (FFT), and replaceall and provides a framework for extensibility to support further string functions. We demonstrate the efficacy of our new solver against other competitive solvers.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290362", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Taolue", + "last_name": "Chen", + "institution": "Birkbeck, University of London" + }, + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Oxford" + }, + { + "first_name": "Philipp", + "last_name": "Rümmer", + "institution": "Uppsala University" + }, + { + "first_name": "Zhilin", + "last_name": "Wu", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "journals/pacmpl/ChenHLRW19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290366", + "title": "Efficient parameterized algorithms for data packing", + "abstract": "There is a huge gap between the speeds of modern caches and main memories, and therefore cache misses account for a considerable loss of efficiency in programs. The predominant technique to address this issue has been Data Packing: data elements that are frequently accessed within time proximity are packed into the same cache block, thereby minimizing accesses to the main memory. We consider the algorithmic problem of Data Packing on a two-level memory system. Given a reference sequence R of accesses to data elements, the task is to partition the elements into cache blocks such that the number of cache misses on R is minimized. The problem is notoriously difficult: it is NP-hard even when the cache has size 1, and is hard to approximate for any cache size larger than 4. Therefore, all existing techniques for Data Packing are based on heuristics and lack theoretical guarantees. In this work, we present the first positive theoretical results for Data Packing, along with new and stronger negative results. We consider the problem under the lens of the underlying access hypergraphs, which are hypergraphs of affinities between the data elements, where the order of an access hypergraph corresponds to the size of the affinity group. We study the problem parameterized by the treewidth of access hypergraphs, which is a standard notion in graph theory to measure the closeness of a graph to a tree. Our main results are as follows: we show that there is a number q * depending on the cache parameters such that (a) if the access hypergraph of order q * has constant treewidth, then there is a linear-time algorithm for Data Packing; (b) the Data Packing problem remains NP-hard even if the access hypergraph of order q * −1 has constant treewidth. Thus, we establish a fine-grained dichotomy depending on a single parameter, namely, the highest order among access hypegraphs that have constant treewidth; and establish the optimal value q * of this parameter. Finally, we present an experimental evaluation of a prototype implementation of our algorithm. Our results demonstrate that, in practice, access hypergraphs of many commonly-used algorithms have small treewidth. We compare our approach with several state-of-the-art heuristic-based algorithms and show that our algorithm leads to significantly fewer cache-misses.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290366", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Nastaran", + "last_name": "Okati", + "institution": "Ferdowsi University of Mashhad" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/ChatterjeeGOP19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290322", + "title": "Sound and complete bidirectional typechecking for higher-rank polymorphism with existentials and indexed types", + "abstract": "Bidirectional typechecking, in which terms either synthesize a type or are checked against a known type, has become popular for its applicability to a variety of type systems, its error reporting, and its ease of implementation. Following principles from proof theory, bidirectional typing can be applied to many type constructs. The principles underlying a bidirectional approach to indexed types (generalized algebraic datatypes) are less clear. Building on proof-theoretic treatments of equality, we give a declarative specification of typing based on focalization. This approach permits declarative rules for coverage of pattern matching, as well as support for first-class existential types using a focalized subtyping judgment. We use refinement types to avoid explicitly passing equality proofs in our term syntax, making our calculus similar to languages such as Haskell and OCaml. We also extend the declarative specification with an explicit rules for deducing when a type is principal, permitting us to give a complete declarative specification for a rich type system with significant type inference. We also give a set of algorithmic typing rules, and prove that it is sound and complete with respect to the declarative system. The proof requires a number of technical innovations, including proving soundness and completeness in a mutually recursive fashion.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290322", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "Queen's University" + }, + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/DunfieldK19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290321", + "title": "Principality and approximation under dimensional bound", + "abstract": "We develop an algebraic and algorithmic theory of principality for the recently introduced framework of intersection type calculi with dimensional bound. The theory enables inference of principal type information under dimensional bound, it provides an algebraic and algorithmic theory of approximation of classical principal types in terms of computable bases of abstract vector spaces (more precisely, semimodules), and it shows a systematic connection of dimensional calculi to the theory of approximants. Finite, computable bases are shown to span standard principal typings of a given term for sufficiently high dimension, thereby providing an approximation to standard principality by type inference, and capturing it precisely for sufficiently large dimensional parameter. Subsidiary results include decidability of principal inhabitation for intersection types (given a type does there exist a normal form for which the type is principal?). Remarkably, combining bounded type inference with principal inhabitation allows us to compute approximate normal forms of arbitrary terms without using beta-reduction.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290321", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrej", + "last_name": "Dudenhefner", + "institution": "TU Dortmund University" + }, + { + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "TU Dortmund University" + } + ], + "dblp_key": "journals/pacmpl/DudenhefnerR19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290358", + "title": "Refinement of path expressions for static analysis", + "abstract": "Algebraic program analyses compute information about a program’s behavior by first (a) computing a valid path expression —i.e., a regular expression that recognizes all feasible execution paths (and usually more)—and then (b) interpreting the path expression in a semantic algebra that defines the analysis. There are an infinite number of different regular expressions that qualify as valid path expressions, which raises the question “ Which one should we choose? ” While any choice yields a sound result, for many analyses the choice can have a drastic effect on the precision of the results obtained. This paper investigates the following two questions: (1) What does it mean for one valid path expression to be “better” than another ? (2) Can we compute a valid path expression that is “better,” and if so, how ? We show that it is not satisfactory to compare two path expressions E 1 and E 2 solely by means of the languages that they generate . Counter to one’s intuition, it is possible for L ( E 2 ) ⊊ L ( E 1 ), yet for E 2 to produce a less-precise analysis result than E 1 —and thus we would not want to perform the transformation E 1 → E 2 . However, the exclusion of paths so as to analyze a smaller language of paths is exactly the refinement criterion used by some prior methods. In this paper, we develop an algorithm that takes as input a valid path expression E , and returns a valid path expression E ′ that is guaranteed to yield analysis results that are at least as good as those obtained using E . While the algorithm sometimes returns E itself, it typically does not: (i) we prove a no-degradation result for the algorithm’s base case—for transforming a leaf loop (i.e., a most-deeply-nested loop); (ii) at a non-leaf loop L , the algorithm treats each loop L ′ in the body of L as an indivisible atom, and applies the leaf-loop algorithm to L ; the no-degradation result carries over to (ii), as well. Our experiments show that the technique has a substantial impact: the loop-refinement algorithm allows the implementation of Compositional Recurrence Analysis to prove over 25% more assertions for a collection of challenging loop micro-benchmarks.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290358", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Cyphert", + "institution": "" + }, + { + "first_name": "Jason", + "last_name": "Breck", + "institution": "" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "GrammaTech (United States)" + } + ], + "dblp_key": "journals/pacmpl/CyphertBKR19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290355", + "title": "A²I: abstract² interpretation", + "abstract": "The fundamental idea of Abstract 2 Interpretation (A 2 I), also called meta-abstract interpretation, is to apply abstract interpretation to abstract interpretation-based static program analyses. A 2 I is generally meant to use abstract interpretation to analyse properties of program analysers. A 2 I can be either offline or online. Offline A 2 I is performed either before the program analysis, such as variable packing used by the Astrée program analyser, or after the program analysis, such as in alarm diagnosis. Online A 2 I is performed during the program analysis, such as Venet’s cofibred domains or Halbwachs et al.’s and Singh et al.’s variable partitioning techniques for fast polyhedra/numerical abstract domains. We formalize offline and online meta-abstract interpretation and illustrate this notion with the design of widenings and the decomposition of relational abstract domains to speed-up program analyses. This shows how novel static analyses can be extracted as meta-abstract interpretations to design efficient and precise program analysis algorithms.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290355", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Verona" + }, + { + "first_name": "Francesco", + "last_name": "Ranzato", + "institution": "University of Padua" + } + ], + "dblp_key": "journals/pacmpl/CousotGR19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290374", + "title": "A calculus for Esterel: if can, can. if no can, no can", + "abstract": "The language Esterel has found success in many safety-critical applications, such as fly-by-wire systems and nuclear power plant control software. Its imperative style is natural to programmers building such systems and its precise semantics makes it work well for reasoning about programs. Existing semantics of Esterel generally fall into two categories: translation to Boolean circuits, or operational semantics that give a procedure for running a whole program. In contrast, equational theories enable reasoning about program behavior via equational rewrites at the source level. Such theories form the basis for proofs of transformations inside compilers or for program refactorings, and defining program evaluation syntactically. This paper presents the first such equational calculus for Esterel. It also illustrates the calculus’s usefulness with a series of example equivalences and discuss how it enabled us to find bugs in Esterel implementations.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290374", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Spencer P.", + "last_name": "Florence", + "institution": "Northwestern University" + }, + { + "first_name": "Shu-Hung", + "last_name": "You", + "institution": "Northwestern University" + }, + { + "first_name": "Jesse A.", + "last_name": "Tov", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/FlorenceYTF19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290345", + "title": "Game semantics for quantum programming", + "abstract": "Quantum programming languages permit a hardware independent, high-level description of quantum algo rithms. In particular, the quantum lambda-calculus is a higher-order programming language with quantum primitives, mixing quantum data and classical control. Giving satisfactory denotational semantics to the quantum lambda-calculus is a challenging problem that has attracted significant interest in the past few years. Several models have been proposed but for those that address the whole quantum λ-calculus, they either do not represent the dynamics of computation, or they lack the compositionality one often expects from denotational models. In this paper, we give the first compositional and interactive model of the full quantum lambda-calculus, based on game semantics. To achieve this we introduce a model of quantum games and strategies, combining quantum data with a representation of the dynamics of computation inspired from causal models of concurrent systems. In this model we first give a computationally adequate interpretation of the affine fragment. Then, we extend the model with a notion of symmetry, allowing us to deal with replication. In this refined setting, we interpret and prove adequacy for the full quantum lambda-calculus. We do this both from a sequential and a parallel interpretation, the latter representing faithfully the causal independence between sub-computations.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290345", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Clairambault", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Marc de", + "last_name": "Visme", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Glynn", + "last_name": "Winskel", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/ClairambaultVW19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290373", + "title": "Weak-consistency specification via visibility relaxation", + "abstract": "Effective software specifications enable modular reasoning, allowing clients to establish program properties without knowing the details of module implementations. While some modules’ operations behave atomically, others admit weaker consistencies to increase performance. Consequently, since current methodologies do not capture the guarantees provided by operations of varying non-atomic consistencies, specifications are ineffective, forfeiting the ability to establish properties of programs that invoke non-atomic operations. In this work we develop a methodology for specifying software modules whose operations satisfy multiple distinct consistency levels. In particular, we develop a simple annotation language for specifying weakly-consistent operations via visibility relaxation, wherein annotations impose varying constraints on the visibility among operations. To integrate with modern software platforms, we identify a novel characterization of consistency called sequential happens-before consistency, which admits effective validation. Empirically, we demonstrate the efficacy of our approach by deriving and validating relaxed-visibility specifications for Java concurrent objects. Furthermore, we demonstrate an optimality of our annotation language, empirically, by establishing that even finer-grained languages do not capture stronger specifications for Java objects.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290373", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "SRI International" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "journals/pacmpl/EmmiE19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290323", + "title": "Fully abstract module compilation", + "abstract": "We give a translation suitable for compilation of modern module calculi supporting sealing, generativity, translucent signatures, applicative functors, higher-order functors and/or first-class modules. Ours is the first module-compilation translation with a dynamic correctness theorem. The theorem states that the translation produces target terms that are contextually equivalent to the source, in an appropriate sense. A corollary of the theorem is that the translation is fully abstract. Consequently, the translation preserves all abstraction present in the source. In passing, we also show that modules are a definitional extension of the underlying core language. All of our proofs are formalized in Coq.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290323", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/Crary19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290341", + "title": "Exceptional asynchronous session types: session types without tiers", + "abstract": "Session types statically guarantee that communication complies with a protocol. However, most accounts of session typing do not account for failure, which means they are of limited use in real applications---especially distributed applications---where failure is pervasive. We present the first formal integration of asynchronous session types with exception handling in a functional programming language. We define a core calculus which satisfies preservation and progress properties, is deadlock free, confluent, and terminating. We provide the first implementation of session types with exception handling for a fully-fledged functional programming language, by extending the Links web programming language; our implementation draws on existing work on effect handlers. We illustrate our approach through a running example of two-factor authentication, and a larger example of a session-based chat application where communication occurs over session-typed channels and disconnections are handled gracefully.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290341", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon", + "last_name": "Fowler", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Kansas" + }, + { + "first_name": "Sára", + "last_name": "Decova", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/FowlerLMD19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290376", + "title": "A verified, efficient embedding of a verifiable assembly language", + "abstract": "High-performance cryptographic libraries often mix code written in a high-level language with code written in assembly. To support formally verifying the correctness and security of such hybrid programs, this paper presents an embedding of a subset of x64 assembly language in F* that allows efficient verification of both assembly and its interoperation with C code generated from F*. The key idea is to use the computational power of a dependent type system's type checker to run a verified verification-condition generator during type checking. This allows the embedding to customize the verification condition sent by the type checker to an SMT solver. By combining our proof-by-reflection style with SMT solving, we demonstrate improved automation for proving the correctness of assembly-language code. This approach has allowed us to complete the first-ever proof of correctness of an optimized implementation of AES-GCM, a cryptographic routine used by 90% of secure Internet traffic.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290376", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aymeric", + "last_name": "Fromherz", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Nick", + "last_name": "Giannarakis", + "institution": "Princeton University" + }, + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Bryan", + "last_name": "Parno", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/FromherzGHPRS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290316", + "title": "Definitional proof-irrelevance without K", + "abstract": "Definitional equality—or conversion—for a type theory with a decidable type checking is the simplest tool to prove that two objects are the same, letting the system decide just using computation. Therefore, the more things are equal by conversion, the simpler it is to use a language based on type theory. Proof-irrelevance, stating that any two proofs of the same proposition are equal, is a possible way to extend conversion to make a type theory more powerful. However, this new power comes at a price if we integrate it naively, either by making type checking undecidable or by realizing new axioms—such as uniqueness of identity proofs (UIP)—that are incompatible with other extensions, such as univalence. In this paper, taking inspiration from homotopy type theory, we propose a general way to extend a type theory with definitional proof irrelevance, in a way that keeps type checking decidable and is compatible with univalence. We provide a new criterion to decide whether a proposition can be eliminated over a type (correcting and improving the so-called singleton elimination of Coq) by using techniques coming from recent development on dependent pattern matching without UIP. We show the generality of our approach by providing implementations for both Coq and Agda, both of which are planned to be integrated in future versions of those proof assistants.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290316", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gaëtan", + "last_name": "Gilbert", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jesper", + "last_name": "Cockx", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/GilbertCST19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290372", + "title": "Pretend synchrony: synchronous verification of asynchronous distributed programs", + "abstract": "We present pretend synchrony , a new approach to verifying distributed systems, based on the observation that while distributed programs must execute asynchronously, we can often soundly treat them as if they were synchronous when verifying their correctness. To do so, we compute a synchronization , a semantically equivalent program where all sends, receives, and message buffers, have been replaced by simple assignments, yielding a program that can be verified using Floyd-Hoare style Verification Conditions and SMT. We implement our approach as a framework for writing verified distributed programs in Go and evaluate it with four challenging case studies— the classic two-phase commit protocol, the Raft leader election protocol, single-decree Paxos protocol, and a Multi-Paxos based distributed key-value store. We find that pretend synchrony allows us to develop performant systems while making verification of functional correctness simpler by reducing manually specified invariants by a factor of 6, and faster , by reducing checking time by three orders of magnitude.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290372", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Klaus von", + "last_name": "Gleissenthall", + "institution": "University of California, San Diego" + }, + { + "first_name": "Rami Gökhan", + "last_name": "Kıcı", + "institution": "University of California, San Diego" + }, + { + "first_name": "Alexander", + "last_name": "Bakst", + "institution": "University of California, San Diego" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/GleissenthallKB19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290348", + "title": "Probabilistic programming with densities in SlicStan: efficient, flexible, and deterministic", + "abstract": "Stan is a probabilistic programming language that has been increasingly used for real-world scalable projects. However, to make practical inference possible, the language sacrifices some of its usability by adopting a block syntax, which lacks compositionality and flexible user-defined functions. Moreover, the semantics of the language has been mainly given in terms of intuition about implementation, and has not been formalised. This paper provides a formal treatment of the Stan language, and introduces the probabilistic programming language SlicStan --- a compositional, self-optimising version of Stan. Our main contributions are (1) the formalisation of a core subset of Stan through an operational density-based semantics; (2) the design and semantics of the Stan-like language SlicStan, which facilities better code reuse and abstraction through its compositional syntax, more flexible functions, and information-flow type system; and (3) a formal, semantic-preserving procedure for translating SlicStan to Stan.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290348", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Maria I.", + "last_name": "Gorinova", + "institution": "University of Edinburgh" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "University of Edinburgh" + }, + { + "first_name": "Charles", + "last_name": "Sutton", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/GorinovaGS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290370", + "title": "A true positives theorem for a static race detector", + "abstract": "RacerD is a static race detector that has been proven to be effective in engineering practice: it has seen thousands of data races fixed by developers before reaching production, and has supported the migration of Facebook's Android app rendering infrastructure from a single-threaded to a multi-threaded architecture. We prove a True Positives Theorem stating that, under certain assumptions, an idealized theoretical version of the analysis never reports a false positive. We also provide an empirical evaluation of an implementation of this analysis, versus the original RacerD. The theorem was motivated in the first case by the desire to understand the observation from production that RacerD was providing remarkably accurate signal to developers, and then the theorem guided further analyzer design decisions. Technically, our result can be seen as saying that the analysis computes an under-approximation of an over-approximation, which is the reverse of the more usual (over of under) situation in static analysis. Until now, static analyzers that are effective in practice but unsound have often been regarded as ad hoc; in contrast, we suggest that, in the future, theorems of this variety might be generally useful in understanding, justifying and designing effective static analyses for bug catching.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290370", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nikos", + "last_name": "Gorogiannis", + "institution": "Middlesex University" + }, + { + "first_name": "Peter W.", + "last_name": "O'Hearn", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/GorogiannisOS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290334", + "title": "Familial monads and structural operational semantics", + "abstract": "We propose a categorical framework for structural operational semantics, in which we prove that under suitable hypotheses bisimilarity is a congruence. We then refine the framework to prove soundness of bisimulation up to context, an efficient method for reducing the size of bisimulation relations. Finally, we demonstrate the flexibility of our approach by reproving known results in three variants of the π-calculus.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290334", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tom", + "last_name": "Hirschowitz", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/Hirschowitz19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290344", + "title": "Quantitative robustness analysis of quantum programs", + "abstract": "Quantum computation is a topic of significant recent interest, with practical advances coming from both research and industry. A major challenge in quantum programming is dealing with errors (quantum noise) during execution. Because quantum resources (e.g., qubits) are scarce, classical error correction techniques applied at the level of the architecture are currently cost-prohibitive. But while this reality means that quantum programs are almost certain to have errors, there as yet exists no principled means to reason about erroneous behavior. This paper attempts to fill this gap by developing a semantics for erroneous quantum while-programs, as well as a logic for reasoning about them. This logic permits proving a property we have identified, called є-robustness, which characterizes possible “distance” between an ideal program and an erroneous one. We have proved the logic sound, and showed its utility on several case studies, notably: (1) analyzing the robustness of noisy versions of the quantum Bernoulli factory (QBF) and quantum walk (QW); (2) demonstrating the (in)effectiveness of different error correction schemes on single-qubit errors; and (3) analyzing the robustness of a fault-tolerant version of QBF.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290344", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shih-Han", + "last_name": "Hung", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Kesha", + "last_name": "Hietala", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Shaopeng", + "last_name": "Zhu", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Institute of Software" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/HungHZYHW19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290315", + "title": "Constructing quotient inductive-inductive types", + "abstract": "Quotient inductive-inductive types (QIITs) generalise inductive types in two ways: a QIIT can have more than one sort and the later sorts can be indexed over the previous ones. In addition, equality constructors are also allowed. We work in a setting with uniqueness of identity proofs, hence we use the term QIIT instead of higher inductive-inductive type. An example of a QIIT is the well-typed (intrinsic) syntax of type theory quotiented by conversion. In this paper first we specify finitary QIITs using a domain-specific type theory which we call the theory of signatures. The syntax of the theory of signatures is given by a QIIT as well. Then, using this syntax we show that all specified QIITs exist and they have a dependent elimination principle. We also show that algebras of a signature form a category with families (CwF) and use the internal language of this CwF to show that dependent elimination is equivalent to initiality.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290315", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ambrus", + "last_name": "Kaposi", + "institution": "Eötvös Loránd University" + }, + { + "first_name": "András", + "last_name": "Kovács", + "institution": "Eötvös Loránd University" + }, + { + "first_name": "Thorsten", + "last_name": "Altenkirch", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/KaposiKA19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290333", + "title": "Modalities, cohesion, and information flow", + "abstract": "It is informally understood that the purpose of modal type constructors in programming calculi is to control the flow of information between types. In order to lend rigorous support to this idea, we study the category of classified sets, a variant of a denotational semantics for information flow proposed by Abadi et al. We use classified sets to prove multiple noninterference theorems for modalities of a monadic and comonadic flavour. The common machinery behind our theorems stems from the the fact that classified sets are a (weak) model of Lawvere's theory of axiomatic cohesion. In the process, we show how cohesion can be used for reasoning about multi-modal settings. This leads to the conclusion that cohesion is a particularly useful setting for the study of both information flow, but also modalities in type theory and programming languages at large.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290333", + "conference_name": "POPL", + "authors": [ + { + "first_name": "G. A.", + "last_name": "Kavvos", + "institution": "Wesleyan University" + } + ], + "dblp_key": "journals/pacmpl/Kavvos19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290336", + "title": "Categorical combinatorics of scheduling and synchronization in game semantics", + "abstract": "Game semantics is the art of interpreting types as games and programs as strategies interacting in space and time with their environment. In order to reflect the interactive behavior of programs, strategies are required to follow specific scheduling policies. Typically, in the case of a purely sequential programming language, the program (Player) and its environment (Opponent) will play one after the other, in a strictly alternating way. On the other hand, in the case of a concurrent language, Player and Opponent will be allowed to play several moves in a row, in a non-alternating way. In both cases, the scheduling policy is designed very carefully in order to ensure that the strategies synchronize properly and compose well when plugged together. A longstanding conceptual problem has been to understand when and why a given scheduling policy works and is compositional in that sense. In this paper, we exhibit a number of simple and fundamental combinatorial structures which ensure that a given scheduling policy encoded as synchronization template defines a symmetric monoidal closed (and in fact star-autonomous) bicategory of games, strategies and simulations. To that purpose, we choose to work at a very general level, and illustrate our method by constructing two template game models of linear logic with different flavors (alternating and non-alternating) using the same categorical combinatorics, performed in the category of small categories. As a whole, the paper may be seen as a hymn in praise of synchronization, building on the notion of synchronization algebra in process calculi and adapting it smoothly to programming language semantics, using a combination of ideas at the converging point of game semantics and of categorical algebra.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290336", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul-André", + "last_name": "Melliès", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "journals/pacmpl/Mellies19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290359", + "title": "Decidable verification of uninterpreted programs", + "abstract": "We study the problem of completely automatically verifying uninterpreted programs—programs that work over arbitrary data models that provide an interpretation for the constants, functions and relations the program uses. The verification problem asks whether a given program satisfies a postcondition written using quantifier-free formulas with equality on the final state, with no loop invariants, contracts, etc. being provided. We show that this problem is undecidable in general. The main contribution of this paper is a subclass of programs, called coherent programs that admits decidable verification, and can be decided in Pspace. We then extend this class of programs to classes of programs that are k -coherent, where k ∈ ℕ, obtained by (automatically) adding k ghost variables and assignments that make them coherent. We also extend the decidability result to programs with recursive function calls and prove several undecidability results that show why our restrictions to obtain decidability seem necessary.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290359", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MathurMV19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290368", + "title": "Closed forms for numerical loops", + "abstract": "This paper investigates the problem of reasoning about non-linear behavior of simple numerical loops. Our approach builds on classical techniques for analyzing the behavior of linear dynamical systems. It is well-known that a closed-form representation of the behavior of a linear dynamical system can always be expressed using algebraic numbers, but this approach can create formulas that present an obstacle for automated-reasoning tools. This paper characterizes when linear loops have closed forms in simpler theories that are more amenable to automated reasoning. The algorithms for computing closed forms described in the paper avoid the use of algebraic numbers, and produce closed forms expressed using polynomials and exponentials over rational numbers. We show that the logic for expressing closed forms is decidable, yielding decision procedures for verifying safety and termination of a class of numerical loops over rational numbers. We also show that the procedure for computing closed forms for this class of numerical loops can be used to over-approximate the behavior of arbitrary numerical programs (with unrestricted control flow, non-deterministic assignments, and recursive procedures).", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290368", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "Jason", + "last_name": "Breck", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Cyphert", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "GrammaTech (United States)" + } + ], + "dblp_key": "journals/pacmpl/KincaidBCR19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290380", + "title": "Exploring C semantics and pointer provenance", + "abstract": "The semantics of pointers and memory objects in C has been a vexed question for many years. C values cannot be treated as either purely abstract or purely concrete entities: the language exposes their representations, but compiler optimisations rely on analyses that reason about provenance and initialisation status, not just runtime representations. The ISO WG14 standard leaves much of this unclear, and in some respects differs with de facto standard usage --- which itself is difficult to investigate. In this paper we explore the possible source-language semantics for memory objects and pointers, in ISO C and in C as it is used and implemented in practice, focussing especially on pointer provenance. We aim to, as far as possible, reconcile the ISO C standard, mainstream compiler behaviour, and the semantics relied on by the corpus of existing C code. We present two coherent proposals, tracking provenance via integers and not; both address many design questions. We highlight some pros and cons and open questions, and illustrate the discussion with a library of test cases. We make our semantics executable as a test oracle, integrating it with the Cerberus semantics for much of the rest of C, which we have made substantially more complete and robust, and equipped with a web-interface GUI. This allows us to experimentally assess our proposals on those test cases. To assess their viability with respect to larger bodies of C code, we analyse the changes required and the resulting behaviour for a port of FreeBSD to CHERI, a research architecture supporting hardware capabilities, which (roughly speaking) traps on the memory safety violations which our proposals deem undefined behaviour. We also develop a new runtime instrumentation tool to detect possible provenance violations in normal C code, and apply it to some of the SPEC benchmarks. We compare our proposal with a source-language variant of the twin-allocation LLVM semantics proposal of Lee et al. Finally, we describe ongoing interactions with WG14, exploring how our proposals could be incorporated into the ISO standard.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290380", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Victor B. F.", + "last_name": "Gomes", + "institution": "University of Cambridge" + }, + { + "first_name": "Brooks", + "last_name": "Davis", + "institution": "SRI International" + }, + { + "first_name": "Stephen", + "last_name": "Kell", + "institution": "University of Cambridge" + }, + { + "first_name": "Alexander", + "last_name": "Richardson", + "institution": "University of Cambridge" + }, + { + "first_name": "Robert N. M.", + "last_name": "Watson", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/MemarianGDKRWS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290320", + "title": "Intersection types and runtime errors in the pi-calculus", + "abstract": "We introduce a type system for the π-calculus which is designed to guarantee that typable processes are well-behaved , namely they never produce a run-time error and, even if they may diverge, there is always a chance for them to “finish their work”, i.e., to reduce to an idle process. The introduced type system is based on non-idempotent intersections, and is thus very powerful as for the class of processes it can capture. Indeed, despite the fact that the underlying property is Π 2 0 -complete, there is a way to show that the system is complete , i.e., that any well-behaved process is typable, although for obvious reasons infinitely many derivations need to be considered.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290320", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Marc de", + "last_name": "Visme", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Damiano", + "last_name": "Mazza", + "institution": "Université Sorbonne Paris Nord" + }, + { + "first_name": "Akira", + "last_name": "Yoshimizu", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/LagoVMY19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290371", + "title": "Decoupling lock-free data structures from memory reclamation for static analysis", + "abstract": "Verification of concurrent data structures is one of the most challenging tasks in software verification. The topic has received considerable attention over the course of the last decade. Nevertheless, human-driven techniques remain cumbersome and notoriously difficult while automated approaches suffer from limited applicability. The main obstacle for automation is the complexity of concurrent data structures. This is particularly true in the absence of garbage collection. The intricacy of lock-free memory management paired with the complexity of concurrent data structures makes automated verification prohibitive. In this work we present a method for verifying concurrent data structures and their memory management separately. We suggest two simpler verification tasks that imply the correctness of the data structure. The first task establishes an over-approximation of the reclamation behavior of the memory management. The second task exploits this over-approximation to verify the data structure without the need to consider the implementation of the memory management itself. To make the resulting verification tasks tractable for automated techniques, we establish a second result. We show that a verification tool needs to consider only executions where a single memory location is reused. We implemented our approach and were able to verify linearizability of Michael&Scott's queue and the DGLM queue for both hazard pointers and epoch-based reclamation. To the best of our knowledge, we are the first to verify such implementations fully automatically.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290371", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Sebastian", + "last_name": "Wolff", + "institution": "Technische Universität Braunschweig" + } + ], + "dblp_key": "journals/pacmpl/MeyerW19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290337", + "title": "Better late than never: a fully-abstract semantics for classical processes", + "abstract": "We present Hypersequent Classical Processes (HCP), a revised interpretation of the “Proofs as Processes” correspondence between linear logic and the π-calculus initially proposed by Abramsky [1994], and later developed by Bellin and Scott [1994], Caires and Pfenning [2010], and Wadler [2014], among others. HCP mends the discrepancies between linear logic and the syntax and observable semantics of parallel composition in the π-calculus, by conservatively extending linear logic to hyperenvironments (collections of environments, inspired by the hypersequents by Avron [1991]). Separation of environments in hyperenvironments is internalised by ⊗ and corresponds to parallel process behaviour. Thanks to this property, for the first time we are able to extract a labelled transition system (lts) semantics from proof rewritings. Leveraging the information on parallelism at the level of types, we obtain a logical reconstruction of the delayed actions that Merro and Sangiorgi [2004] formulated to model non-blocking I/O in the π-calculus. We define a denotational semantics for processes based on Brzozowski derivatives, and uncover that non-interference in HCP corresponds to Fubini’s theorem of double antiderivation. Having an lts allows us to validate HCP using the standard toolbox of behavioural theory. We instantiate bisimilarity and barbed congruence for HCP, and obtain a full abstraction result: bisimilarity, denotational equivalence, and barbed congruence coincide.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290337", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wen", + "last_name": "Kokke", + "institution": "University of Edinburgh" + }, + { + "first_name": "Fabrizio", + "last_name": "Montesi", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Marco", + "last_name": "Peressotti", + "institution": "University of Southern Denmark" + } + ], + "dblp_key": "journals/pacmpl/KokkeMP19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290317", + "title": "Bisimulation as path type for guarded recursive types", + "abstract": "In type theory, coinductive types are used to represent processes, and are thus crucial for the formal verification of non-terminating reactive programs in proof assistants based on type theory, such as Coq and Agda. Currently, programming and reasoning about coinductive types is difficult for two reasons: The need for recursive definitions to be productive, and the lack of coincidence of the built-in identity types and the important notion of bisimilarity. Guarded recursion in the sense of Nakano has recently been suggested as a possible approach to dealing with the problem of productivity, allowing this to be encoded in types. Indeed, coinductive types can be encoded using a combination of guarded recursion and universal quantification over clocks. This paper studies the notion of bisimilarity for guarded recursive types in Ticked Cubical Type Theory, an extension of Cubical Type Theory with guarded recursion. We prove that, for any functor, an abstract, category theoretic notion of bisimilarity for the final guarded coalgebra is equivalent (in the sense of homotopy type theory) to path equality (the primitive notion of equality in cubical type theory). As a worked example we study a guarded notion of labelled transition systems, and show that, as a special case of the general theorem, path equality coincides with an adaptation of the usual notion of bisimulation for processes. In particular, this implies that guarded recursion can be used to give simple equational reasoning proofs of bisimilarity. This work should be seen as a step towards obtaining bisimilarity as path equality for coinductive types using the encodings mentioned above.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290317", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rasmus Ejlers", + "last_name": "Møgelberg", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Niccolò", + "last_name": "Veltrì", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/MogelbergV19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290387", + "title": "Hamsaz: replication coordination analysis and synthesis", + "abstract": "Distributed system replication is widely used as a means of fault-tolerance and scalability. However, it provides a spectrum of consistency choices that impose a dilemma for clients between correctness, responsiveness and availability. Given a sequential object and its integrity properties, we automatically synthesize a replicated object that guarantees state integrity and convergence and avoids unnecessary coordination. Our approach is based on a novel sufficient condition for integrity and convergence called well-coordination that requires certain orders between conflicting and dependent operations. We statically analyze the given sequential object to decide its conflicting and dependent methods and use this information to avoid coordination. We present novel coordination protocols that are parametric in terms of the analysis results and provide the well-coordination requirements. We implemented a tool called Hamsaz that can automatically analyze the given object, instantiate the protocols and synthesize replicated objects. We have applied Hamsaz to a suite of use-cases and synthesized replicated objects that are significantly more responsive than the strongly consistent baseline.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290387", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Farzin", + "last_name": "Houshmand", + "institution": "University of California, Riverside" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "journals/pacmpl/HoushmandL19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290331", + "title": "Dynamic type inference for gradual Hindley-Milner typing", + "abstract": "Garcia and Cimini study a type inference problem for the ITGL, an implicitly and gradually typed language with let-polymorphism, and develop a sound and complete inference algorithm for it. Soundness and completeness mean that, if the algorithm succeeds, the input term can be translated to a well-typed term of an explicitly typed blame calculus by cast insertion and vice versa. However, in general, there are many possible translations depending on how type variables that were left undecided by static type inference are instantiated with concrete static types. Worse, the translated terms may behave differently—some evaluate to values but others raise blame. In this paper, we propose and formalize a new blame calculus λ B DTI that avoids such divergence as an intermediate language for the ITGL. A main idea is to allow a term to contain type variables (that have not been instantiated during static type inference) and defer instantiation of these type variables to run time. We introduce dynamic type inference (DTI) into the semantics of λ B DTI so that type variables are instantiated along reduction. The DTI-based semantics not only avoids the divergence described above but also is sound and complete with respect to the semantics of fully instantiated terms in the following sense: if the evaluation of a term succeeds (i.e., terminates with a value) in the DTI-based semantics, then there is a fully instantiated version of the term that also succeeds in the explicitly typed blame calculus and vice versa. Finally, we prove the gradual guarantee, which is an important correctness criterion of a gradually typed language, for the ITGL.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290331", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yusuke", + "last_name": "Miyazaki", + "institution": "Kyoto University" + }, + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "journals/pacmpl/MiyazakiSI19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290325", + "title": "Abstracting extensible data types: or, rows by any other name", + "abstract": "We present a novel typed language for extensible data types, generalizing and abstracting existing systems of row types and row polymorphism. Extensible data types are a powerful addition to traditional functional programming languages, capturing ideas from OOP-like record extension and polymorphism to modular compositional interpreters. We introduce row theories, a monoidal generalization of row types, giving a general account of record concatenation and projection (dually, variant injection and branching). We realize them via qualified types, abstracting the interpretation of records and variants over different row theories. Our approach naturally types terms untypable in other systems of extensible data types, while maintaining strong metatheoretic properties, such as coherence and principal types. Evidence for type qualifiers has computational content, determining the implementation of record and variant operations; we demonstrate this in giving a modular translation from our calculus, instantiated with various row theories, to polymorphic λ-calculus.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290325", + "conference_name": "POPL", + "authors": [ + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Kansas" + }, + { + "first_name": "James", + "last_name": "McKinna", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/MorrisM19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290328", + "title": "Gradual type theory", + "abstract": "Gradually typed languages are designed to support both dynamically typed and statically typed programming styles while preserving the benefits of each. While existing gradual type soundness theorems for these languages aim to show that type-based reasoning is preserved when moving from the fully static setting to a gradual one, these theorems do not imply that correctness of type-based refactorings and optimizations is preserved. Establishing correctness of program transformations is technically difficult, because it requires reasoning about program equivalence, and is often neglected in the metatheory of gradual languages. In this paper, we propose an axiomatic account of program equivalence in a gradual cast calculus, which we formalize in a logic we call gradual type theory (GTT). Based on Levy’s call-by-push-value, GTT gives an axiomatic account of both call-by-value and call-by-name gradual languages. Based on our axiomatic account we prove many theorems that justify optimizations and refactorings in gradually typed languages. For example, uniqueness principles for gradual type connectives show that if the βη laws hold for a connective, then casts between that connective must be equivalent to the so-called “lazy” cast semantics. Contrapositively, this shows that “eager” cast semantics violates the extensionality of function types. As another example, we show that gradual upcasts are pure functions and, dually, gradual downcasts are strict functions. We show the consistency and applicability of our axiomatic theory by proving that a contract-based implementation using the lazy cast semantics gives a logical relations model of our type theory, where equivalence in GTT implies contextual equivalence of the programs. Since GTT also axiomatizes the dynamic gradual guarantee, our model also establishes this central theorem of gradual typing. The model is parametrized by the implementation of the dynamic types, and so gives a family of implementations that validate type-based optimization and the gradual guarantee.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290328", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Max S.", + "last_name": "New", + "institution": "Northeastern University" + }, + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Wesleyan University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/NewLA19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290327", + "title": "Live functional programming with typed holes", + "abstract": "Live programming environments aim to provide programmers (and sometimes audiences) with continuous feedback about a program's dynamic behavior as it is being edited. The problem is that programming languages typically assign dynamic meaning only to programs that are complete, i.e. syntactically well-formed and free of type errors. Consequently, live feedback presented to the programmer exhibits temporal or perceptive gaps. This paper confronts this \"gap problem\" from type-theoretic first principles by developing a dynamic semantics for incomplete functional programs, starting from the static semantics for incomplete functional programs developed in recent work on Hazelnut. We model incomplete functional programs as expressions with holes, with empty holes standing for missing expressions or types, and non-empty holes operating as membranes around static and dynamic type inconsistencies. Rather than aborting when evaluation encounters any of these holes as in some existing systems, evaluation proceeds around holes, tracking the closure around each hole instance as it flows through the remainder of the program. Editor services can use the information in these hole closures to help the programmer develop and confirm their mental model of the behavior of the complete portions of the program as they decide how to fill the remaining holes. Hole closures also enable a fill-and-resume operation that avoids the need to restart evaluation after edits that amount to hole filling. Formally, the semantics borrows machinery from both gradual type theory (which supplies the basis for handling unfilled type holes) and contextual modal type theory (which supplies a logical basis for hole closures), combining these and developing additional machinery necessary to continue evaluation past holes while maintaining type safety. We have mechanized the metatheory of the core calculus, called Hazelnut Live, using the Agda proof assistant. We have also implemented these ideas into the Hazel programming environment. The implementation inserts holes automatically, following the Hazelnut edit action calculus, to guarantee that every editor state has some (possibly incomplete) type. Taken together with this paper's type safety property, the result is a proof-of-concept live programming environment where rich dynamic feedback is truly available without gaps, i.e. for every reachable editor state.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290327", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Chicago" + }, + { + "first_name": "Ian", + "last_name": "Voysey", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of Chicago" + }, + { + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "journals/pacmpl/OmarVCH19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290381", + "title": "On library correctness under weak memory consistency: specifying and verifying concurrent libraries under declarative consistency models", + "abstract": "Concurrent libraries are the building blocks for concurrency. They encompass a range of abstractions (locks, exchangers, stacks, queues, sets) built in a layered fashion: more advanced libraries are built out of simpler ones. While there has been a lot of work on verifying such libraries in a sequentially consistent (SC) environment, little is known about how to specify and verify them under weak memory consistency (WMC). We propose a general declarative framework that allows us to specify concurrent libraries declaratively, and to verify library implementations against their specifications compositionally. Our framework is sufficient to encode standard models such as SC, (R)C11 and TSO. Additionally, we specify several concurrent libraries, including mutual exclusion locks, reader-writer locks, exchangers, queues, stacks and sets. We then use our framework to verify multiple weakly consistent implementations of locks, exchangers, queues and stacks.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290381", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Marko", + "last_name": "Doko", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lovro", + "last_name": "Rožić", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RaadDRLV19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290324", + "title": "Polymorphic symmetric multiple dispatch with variance", + "abstract": "Many object-oriented languages provide method overloading, which allows multiple method declarations with the same name. For a given method invocation, in order to choose what method declaration to invoke, multiple dispatch considers the run-time types of the arguments. While multiple dispatch can support binary methods (such as mathematical operators) intuitively and consistently, it is difficult to guarantee that calls will be neither ambiguous nor undefined at run time, especially in the presence of expressive language features such as multiple inheritance and parametric polymorphism. Previous efforts have formalized languages that include such features by using overloading rules that guarantee a unique and type-sound resolution of each overloaded method call; in many cases, such rules resolve ambiguity by treating the arguments asymmetrically. Here we present the first formal specification of a strongly typed object-oriented language with symmetric multiple dispatch, multiple inheritance, and parametric polymorphism with variance. We define both a static (type- checking) semantics and a dynamic (dispatching) semantics and prove the type soundness of the language, thus demonstrating that our novel dynamic dispatch algorithm is consistent with the static semantics. Details of our dynamic dispatch algorithm address certain technical challenges that arise from structural asymmetries inherent in object-oriented languages (e.g., classes typically declare ancestors explicitly but not descendants).", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290324", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gyunghee", + "last_name": "Park", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jaemin", + "last_name": "Hong", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "Oracle (United States)" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ParkHSR19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290388", + "title": "LWeb: information flow security for multi-tier web applications", + "abstract": "This paper presents LWeb, a framework for enforcing label-based, information flow policies in database-using web applications. In a nutshell, LWeb marries the LIO Haskell IFC enforcement library with the Yesod web programming framework. The implementation has two parts. First, we extract the core of LIO into a monad transformer (LMonad) and then apply it to Yesod’s core monad. Second, we extend Yesod’s table definition DSL and query functionality to permit defining and enforcing label-based policies on tables and enforcing them during query processing. LWeb’s policy language is expressive, permitting dynamic per-table and per-row policies. We formalize the essence of LWeb in the λ LWeb calculus and mechanize the proof of noninterference in Liquid Haskell. This mechanization constitutes the first metatheoretic proof carried out in Liquid Haskell. We also used LWeb to build a substantial web site hosting the Build it, Break it, Fix it security-oriented programming contest. The site involves 40 data tables and sophisticated policies. Compared to manually checking security policies, LWeb imposes a modest runtime overhead of between 2% to 21%. It reduces the trusted code base from the whole application to just 1% of the application code, and 21% of the code overall (when counting LWeb too).", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290388", + "conference_name": "POPL", + "authors": [ + { + "first_name": "James", + "last_name": "Parker", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/ParkerVH19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290382", + "title": "Bridging the gap between programming languages and hardware weak memory models", + "abstract": "We develop a new intermediate weak memory model, IMM, as a way of modularizing the proofs of correctness of compilation from concurrent programming languages with weak memory consistency semantics to mainstream multi-core architectures, such as POWER and ARM. We use IMM to prove the correctness of compilation from the promising semantics of Kang et al. to POWER (thereby correcting and improving their result) and ARMv7, as well as to the recently revised ARMv8 model. Our results are mechanized in Coq, and to the best of our knowledge, these are the first machine-verified compilation correctness results for models that are weaker than x86-TSO.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290382", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anton", + "last_name": "Podkopaev", + "institution": "St Petersburg University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/PodkopaevLV19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290386", + "title": "FrAngel: component-based synthesis with control structures", + "abstract": "In component-based program synthesis, the synthesizer generates a program given a library of components (functions). Existing component-based synthesizers have difficulty synthesizing loops and other control structures, and they often require formal specifications of the components, which can be expensive to generate. We present FrAngel, a new approach to component-based synthesis that can synthesize short Java functions with control structures when given a desired signature, a set of input-output examples, and a collection of libraries (without formal specifications). FrAngel aims to discover programs with many distinct behaviors by combining two main ideas. First, it mines code fragments from partially-successful programs that only pass some of the examples. These extracted fragments are often useful for synthesis due to a property that we call special-case similarity . Second, FrAngel uses angelic conditions as placeholders for control structure conditions and optimistically evaluates the resulting program sketches. Angelic conditions decompose the synthesis process: FrAngel first finds promising partial programs and later fills in their missing conditions. We demonstrate that FrAngel can synthesize a variety of interesting programs with combinations of control structures within seconds, significantly outperforming prior state-of-the-art.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290386", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kensen", + "last_name": "Shi", + "institution": "Stanford University" + }, + { + "first_name": "Jacob", + "last_name": "Steinhardt", + "institution": "Stanford University" + }, + { + "first_name": "Percy", + "last_name": "Liang", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/ShiSL19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290351", + "title": "Formal verification of higher-order probabilistic programs: reasoning about approximation, convergence, Bayesian inference, and optimization", + "abstract": "Probabilistic programming provides a convenient lingua franca for writing succinct and rigorous descriptions of probabilistic models and inference tasks. Several probabilistic programming languages, including Anglican, Church or Hakaru, derive their expressiveness from a powerful combination of continuous distributions, conditioning, and higher-order functions. Although very important for practical applications, these features raise fundamental challenges for program semantics and verification. Several recent works offer promising answers to these challenges, but their primary focus is on foundational semantics issues. In this paper, we take a step further by developing a suite of logics, collectively named PPV for proving properties of programs written in an expressive probabilistic higher-order language with continuous sampling operations and primitives for conditioning distributions. Our logics mimic the comfortable reasoning style of informal proofs using carefully selected axiomatizations of key results from probability theory. The versatility of our logics is illustrated through the formal verification of several intricate examples from statistics, probabilistic inference, and machine learning. We further show expressiveness by giving sound embeddings of existing logics. In particular, we do this in a parametric way by showing how the semantics idea of (unary and relational) ⊤⊤-lifting can be internalized in our logics. The soundness of PPV follows by interpreting programs and assertions in quasi-Borel spaces (QBS), a recently proposed variant of Borel spaces with a good structure for interpreting higher order probabilistic programs.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290351", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tetsuya", + "last_name": "Sato", + "institution": "Buffalo State University" + }, + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Buffalo State University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/SatoABGGH19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290350", + "title": "Bayesian synthesis of probabilistic programs for automatic data modeling", + "abstract": "We present new techniques for automatically constructing probabilistic programs for data analysis, interpretation, and prediction. These techniques work with probabilistic domain-specific data modeling languages that capture key properties of a broad class of data generating processes, using Bayesian inference to synthesize probabilistic programs in these modeling languages given observed data. We provide a precise formulation of Bayesian synthesis for automatic data modeling that identifies sufficient conditions for the resulting synthesis procedure to be sound. We also derive a general class of synthesis algorithms for domain-specific languages specified by probabilistic context-free grammars and establish the soundness of our approach for these languages. We apply the techniques to automatically synthesize probabilistic programs for time series data and multivariate tabular data. We show how to analyze the structure of the synthesized programs to compute, for key qualitative properties of interest, the probability that the underlying data generating process exhibits each of these properties. Second, we translate probabilistic programs in the domain-specific language into probabilistic programs in Venture, a general-purpose probabilistic programming system. The translated Venture programs are then executed to obtain predictions of new time series data and new multivariate data records. Experimental results show that our techniques can accurately infer qualitative structure in multiple real-world data sets and outperform standard data analysis methods in forecasting and predicting new data.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290350", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Marco F.", + "last_name": "Cusumano-Towner", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ulrich", + "last_name": "Schaechtle", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin C.", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/SaadCSRM19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290385", + "title": "Structuring the synthesis of heap-manipulating programs", + "abstract": "This paper describes a deductive approach to synthesizing imperative programs with pointers from declarative specifications expressed in Separation Logic. Our synthesis algorithm takes as input a pair of assertions—a pre- and a postcondition—which describe two states of the symbolic heap, and derives a program that transforms one state into the other, guided by the shape of the heap. Our approach to program synthesis is grounded in proof theory: we introduce the novel framework of Synthetic Separation Logic (SSL), which generalises the classical notion of heap entailment P ⊢ Q to incorporate a possibility of transforming a heap satisfying an assertion P into a heap satisfying an assertion Q . A synthesized program represents a proof term for a transforming entailment statement P ↝ Q , and the synthesis procedure corresponds to a proof search. The derived programs are, thus, correct by construction, in the sense that they satisfy the ascribed pre/postconditions, and are accompanied by complete proof derivations, which can be checked independently. We have implemented a proof search engine for SSL in a form of the program synthesizer called SuSLik. For efficiency, the engine exploits properties of SSL rules, such as invertibility and commutativity of rule applications on separate heaps, to prune the space of derivations it has to consider. We explain and showcase the use of SSL on characteristic examples, describe the design of SuSLik, and report on our experience of using it to synthesize a series of benchmark programs manipulating heap-based linked data structures.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290385", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "Yale-NUS College" + } + ], + "dblp_key": "journals/pacmpl/PolikarpovaS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290379", + "title": "JaVerT 2.0: compositional symbolic execution for JavaScript", + "abstract": "We propose a novel, unified approach to the development of compositional symbolic execution tools, bridging the gap between classical symbolic execution and compositional program reasoning based on separation logic. Using this approach, we build JaVerT 2.0, a symbolic analysis tool for JavaScript that follows the language semantics without simplifications. JaVerT 2.0 supports whole-program symbolic testing, verification, and, for the first time, automatic compositional testing based on bi-abduction. The meta-theory underpinning JaVerT 2.0 is developed modularly, streamlining the proofs and informing the implementation. Our explicit treatment of symbolic execution errors allows us to give meaningful feedback to the developer during whole-program symbolic testing and guides the inference of resource of the bi-abductive execution. We evaluate the performance of JaVerT 2.0 on a number of JavaScript data-structure libraries, demonstrating: the scalability of our whole-program symbolic testing; an improvement over the state-of-the-art in JavaScript verification; and the feasibility of automatic compositional testing for JavaScript.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290379", + "conference_name": "POPL", + "authors": [ + { + "first_name": "José Fragoso", + "last_name": "Santos", + "institution": "Imperial College London" + }, + { + "first_name": "Petar", + "last_name": "Maksimović", + "institution": "London Institute for Mathematical Sciences" + }, + { + "first_name": "Gabriela", + "last_name": "Sampaio", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/SantosMSG19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290343", + "title": "Less is more: multiparty session types revisited", + "abstract": "Multiparty Session Types (MPST) are a typing discipline ensuring that a message-passing process implements a multiparty session protocol , without errors. In this paper, we propose a new, generalised MPST theory. Our contribution is fourfold. (1) We demonstrate that a revision of the theoretical foundations of MPST is necessary : classic MPST have a limited subject reduction property, with inherent restrictions that are easily overlooked, and in previous work have led to flawed type safety proofs; our new theory removes such restrictions and fixes such flaws. (2) We contribute a new MPST theory that is less complicated, and yet more general, than the classic one: it does not require global multiparty session types nor binary session type duality — instead, it is grounded on general behavioural type-level properties, and proves type safety of many more protocols and processes. (3) We produce a detailed analysis of type-level properties, showing how, in our new theory, they allow to ensure decidability of type checking, and statically guarantee that processes enjoy, , deadlock-freedom and liveness at run-time. (4) We show how our new theory can integrate type and model checking: type-level properties can be expressed in modal µ-calculus, and verified with well-established tools.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290343", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/ScalasY19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290332", + "title": "StkTokens: enforcing well-bracketed control flow and stack encapsulation using linear capabilities", + "abstract": "We propose and study StkTokens: a new calling convention that provably enforces well-bracketed control flow and local state encapsulation on a capability machine. The calling convention is based on linear capabilities: a type of capabilities that are prevented from being duplicated by the hardware. In addition to designing and formalizing this new calling convention, we also contribute a new way to formalize and prove that it effectively enforces well-bracketed control flow and local state encapsulation using what we call a fully abstract overlay semantics.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290332", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lau", + "last_name": "Skorstengaard", + "institution": "Aarhus University" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/SkorstengaardDB19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290352", + "title": "Trace abstraction modulo probability", + "abstract": "We propose trace abstraction modulo probability, a proof technique for verifying high-probability accuracy guarantees of probabilistic programs. Our proofs overapproximate the set of program traces using failure automata, finite-state automata that upper bound the probability of failing to satisfy a target specification. We automate proof construction by reducing probabilistic reasoning to logical reasoning: we use program synthesis methods to select axioms for sampling instructions, and then apply Craig interpolation to prove that traces fail the target specification with only a small probability. Our method handles programs with unknown inputs, parameterized distributions, infinite state spaces, and parameterized specifications. We evaluate our technique on a range of randomized algorithms drawn from the differential privacy literature and beyond. To our knowledge, our approach is the first to automatically establish accuracy properties of these algorithms.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290352", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Calvin", + "last_name": "Smith", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/SmithHA19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290354", + "title": "An abstract domain for certifying neural networks", + "abstract": "We present a novel method for scalable and precise certification of deep neural networks. The key technical insight behind our approach is a new abstract domain which combines floating point polyhedra with intervals and is equipped with abstract transformers specifically tailored to the setting of neural networks. Concretely, we introduce new transformers for affine transforms, the rectified linear unit (ReLU), sigmoid, tanh, and maxpool functions. We implemented our method in a system called DeepPoly and evaluated it extensively on a range of datasets, neural architectures (including defended networks), and specifications. Our experimental results indicate that DeepPoly is more precise than prior work while scaling to large networks. We also show how to combine DeepPoly with a form of abstraction refinement based on trace partitioning. This enables us to prove, for the first time, the robustness of the network when the input image is subjected to complex perturbations such as rotations that employ linear interpolation.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290354", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "ETH Zurich" + }, + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/SinghGPV19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290361", + "title": "Context-, flow-, and field-sensitive data-flow analysis using synchronized Pushdown systems", + "abstract": "Precise static analyses are context-, field- and flow-sensitive. Context- and field-sensitivity are both expressible as context-free language (CFL) reachability problems. Solving both CFL problems along the same data-flow path is undecidable, which is why most flow-sensitive data-flow analyses over-approximate field-sensitivity through k -limited access-path, or through access graphs. Unfortunately, as our experience and this paper show, both representations do not scale very well when used to analyze programs with recursive data structures. Any single CFL-reachability problem is efficiently solvable, by means of a pushdown system. This work thus introduces the concept of synchronized pushdown systems (SPDS). SPDS encode both procedure calls/returns and field stores/loads as separate but “synchronized” CFL reachability problems. An SPDS solves both individual problems precisely, and approximation occurs only in corner cases that are apparently rare in practice: at statements where both problems are satisfied but not along the same data-flow path. SPDS are also efficient: formal complexity analysis shows that SPDS shift the complexity from | F | 3 k under k -limiting to | S || F | 2 , where F is the set of fields and S the set of statements involved in a data-flow. Our evaluation using DaCapo shows this shift to pay off in practice: SPDS are almost as efficient as k -limiting with k =1 although their precision equals k =∞. For a typestate analysis SPDS accelerate the analysis up to 83× for data-flows of objects that involve many field accesses but span rather few methods. We conclude that SPDS can provide high precision and further improve scalability, in particularly when used in analyses that expose rather local data flows.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290361", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Späth", + "institution": "Fraunhofer Institute for Mechatronic Systems Design" + }, + { + "first_name": "Karim", + "last_name": "Ali", + "institution": "University of Alberta" + }, + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Paderborn University" + } + ], + "dblp_key": "journals/pacmpl/SpathAB19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290377", + "title": "A separation logic for concurrent randomized programs", + "abstract": "We present Polaris, a concurrent separation logic with support for probabilistic reasoning. As part of our logic, we extend the idea of coupling, which underlies recent work on probabilistic relational logics, to the setting of programs with both probabilistic and non-deterministic choice. To demonstrate Polaris, we verify a variant of a randomized concurrent counter algorithm and a two-level concurrent skip list. All of our results have been mechanized in Coq.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290377", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/TassarottiH19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290356", + "title": "Concerto: a framework for combined concrete and abstract interpretation", + "abstract": "Abstract interpretation promises sound but computable static summarization of program behavior. However, modern software engineering practices pose significant challenges to this vision, specifically the extensive use of frameworks and complex libraries. Frameworks heavily use reflection, metaprogramming, and multiple layers of abstraction, all of which confound even state-of-the-art abstract interpreters. Sound but conservative analysis of frameworks is impractically imprecise, and unsoundly ignoring reflection and metaprogramming is untenable given the prevalence of these features. Manually modeling framework behaviors offers excellent precision, at the cost of immense effort by the tool designer. To overcome the above difficulties, we present Concerto, a system for analyzing framework-based applications by soundly combining concrete and abstract interpretation. Concerto analyzes framework implementations using concrete interpretation, and application code using abstract interpretation. This technique is possible in practice as framework implementations typically follow a single path of execution when provided a concrete, application-specific configuration file which is often available at analysis time. Concerto exploits this configuration information to precisely resolve reflection and other metaprogramming idioms during concrete execution. In contrast, application code may have infinitely many paths of execution, so Concerto switches to abstract interpretation to analyze application code. Concerto is an analysis framework, and can be instantiated with any abstract interpretation that satisfies a small set of preconditions. In addition, unlike manual modeling, Concerto is not specialized to any specific framework implementation. We have formalized our approach and proved several important properties including soundness and termination. In addition, we have implemented an initial proof of concept prototype of Concerto for a subset of Java, and found that our combined interpretation significantly improves analysis precision and performance.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290356", + "conference_name": "POPL", + "authors": [ + { + "first_name": "John", + "last_name": "Toman", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/TomanG19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290330", + "title": "Gradual parametricity, revisited", + "abstract": "Bringing the benefits of gradual typing to a language with parametric polymorphism like System F, while preserving relational parametricity, has proven extremely challenging: first attempts were formulated a decade ago, and several designs were recently proposed. Among other issues, these proposals can however signal parametricity errors in unexpected situations, and improperly handle type instantiations when imprecise types are involved. These observations further suggest that existing polymorphic cast calculi are not well suited for supporting a gradual counterpart of System F. Consequently, we revisit the challenge of designing a gradual language with explicit parametric polymorphism, exploring the extent to which the Abstracting Gradual Typing methodology helps us derive such a language, GSF. We present the design and metatheory of GSF, and provide a reference implementation. In addition to avoiding the uncovered semantic issues, GSF satisfies all the expected properties of a gradual parametric language, save for one property: the dynamic gradual guarantee, which was left as conjecture in all prior work, is here proven to be simply incompatible with parametricity. We nevertheless establish a weaker property that allows us to disprove several claims about gradual free theorems, clarifying the kind of reasoning supported by gradual parametricity.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290330", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + }, + { + "first_name": "Elizabeth", + "last_name": "Labrada", + "institution": "University of Chile" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/ToroLT19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290367", + "title": "Fast and exact analysis for LRU caches", + "abstract": "For applications in worst-case execution time analysis and in security, it is desirable to statically classify memory accesses into those that result in cache hits, and those that result in cache misses. Among cache replacement policies, the least recently used (LRU) policy has been studied the most and is considered to be the most predictable. The state-of-the-art in LRU cache analysis presents a tradeoff between precision and analysis efficiency: The classical approach to analyzing programs running on LRU caches, an abstract interpretation based on a range abstraction, is very fast but can be imprecise. An exact analysis was recently presented, but, as a last resort, it calls a model checker, which is expensive. In this paper, we develop an analysis based on abstract interpretation that comes close to the efficiency of the classical approach, while achieving exact classification of all memory accesses as the model-checking approach. Compared with the model-checking approach we observe speedups of several orders of magnitude. As a secondary contribution we show that LRU cache analysis problems are in general NP-complete.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290367", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Valentin", + "last_name": "Touzeau", + "institution": "Université Grenoble Alpes" + }, + { + "first_name": "Claire", + "last_name": "Maïza", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "David", + "last_name": "Monniaux", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jan", + "last_name": "Reineke", + "institution": "Saarland University" + } + ], + "dblp_key": "journals/pacmpl/TouzeauMMR19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290318", + "title": "Abstraction-safe effect handlers via tunneling", + "abstract": "Algebraic effect handlers offer a unified approach to expressing control-flow transfer idioms such as exceptions, iteration, and async/await. Unfortunately, previous attempts to make these handlers type-safe have failed to support the fundamental principle of modular reasoning for higher-order abstractions. We demonstrate that abstraction-safe algebraic effect handlers are possible by giving them a new semantics. The key insight is that code should only handle effects it is aware of. In our approach, the type system guarantees all effects are handled, but it is impossible for higher-order, effect-polymorphic code to accidentally handle effects raised by functions passed in; such effects tunnel through the higher-order, calling procedures polymorphic to them. By contrast, the possibility of accidental handling threatens previous designs for algebraic effect handlers. We prove that our design is not only type-safe, but also abstraction-safe. Using a logical-relations model that we prove sound with respect to contextual equivalence, we derive previously unattainable program equivalence results. Our mechanism offers a viable approach for future language designs aiming for effect handlers with strong abstraction guarantees.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290318", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/ZhangM19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290346", + "title": "Quantum relational Hoare logic", + "abstract": "We present a logic for reasoning about pairs of interactive quantum programs – quantum relational Hoare logic (qRHL). This logic follows the spirit of probabilistic relational Hoare logic (Barthe et al. 2009) and allows us to formulate how the outputs of two quantum programs relate given the relationship of their inputs. Probabilistic RHL was used extensively for computer-verified security proofs of classical cryptographic protocols. Since pRHL is not suitable for analyzing quantum cryptography, we present qRHL as a replacement, suitable for the security analysis of post-quantum cryptography and quantum protocols. The design of qRHL poses some challenges unique to the quantum setting, e.g., the definition of equality on quantum registers. Finally, we implemented a tool for verifying proofs in qRHL and developed several example security proofs in it.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290346", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dominique", + "last_name": "Unruh", + "institution": "University of Tartu" + } + ], + "dblp_key": "journals/pacmpl/Unruh19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290349", + "title": "A domain theory for statistical probabilistic programming", + "abstract": "We give an adequate denotational semantics for languages with recursive higher-order types, continuous probability distributions, and soft constraints. These are expressive languages for building Bayesian models of the kinds used in computational statistics and machine learning. Among them are untyped languages, similar to Church and WebPPL, because our semantics allows recursive mixed-variance datatypes. Our semantics justifies important program equivalences including commutativity. Our new semantic model is based on `quasi-Borel predomains'. These are a mixture of chain-complete partial orders (cpos) and quasi-Borel spaces. Quasi-Borel spaces are a recent model of probability theory that focuses on sets of admissible random elements. Probability is traditionally treated in cpo models using probabilistic powerdomains, but these are not known to be commutative on any class of cpos with higher order functions. By contrast, quasi-Borel predomains do support both a commutative probabilistic powerdomain and higher-order functions. As we show, quasi-Borel predomains form both a model of Fiore's axiomatic domain theory and a model of Kock's synthetic measure theory.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290349", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthijs", + "last_name": "Vákár", + "institution": "Columbia University" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Oxford" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/VakarKS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290375", + "title": "An abstract stack based approach to verified compositional compilation to machine code", + "abstract": "A key ingredient contributing to the success of CompCert, the state-of-the-art verified compiler for C, is its block-based memory model, which is used uniformly for all of its languages and their verified compilation. However, CompCert's memory model lacks an explicit notion of stack. Its target assembly language represents the runtime stack as an unbounded list of memory blocks, making further compilation of CompCert assembly into more realistic machine code difficult since it is not possible to merge these blocks into a finite and continuous stack. Furthermore, various notions of verified compositional compilation rely on some kind of mechanism for protecting private stack data and enabling modification to the public stack-allocated data, which is lacking in the original CompCert. These problems have been investigated but not fully addressed before, in the sense that some advanced optimization passes that significantly change the ways stack blocks are (de-)allocated, such as tailcall recognition and inlining, are often omitted. We propose a lightweight and complete solution to the above problems. It is based on the enrichment of CompCert's memory model with an abstract stack that keeps track of the history of stack frames to bound the stack consumption and that enforces a uniform stack access policy by assigning fine-grained permissions to stack memory. Using this enriched memory model for all the languages of CompCert, we are able to reprove the correctness of the full compilation chain of CompCert, including all the optimization passes. In the end, we get Stack-Aware CompCert, a complete extension of CompCert that enforces the finiteness of the stack and fine-grained stack permissions. Based on Stack-Aware CompCert, we develop CompCertMC, the first extension of CompCert that compiles into a low-level language with flat memory spaces. Based on CompCertMC, we develop Stack-Aware CompCertX, a complete extension of CompCert that supports a notion of compositional compilation that we call contextual compilation by exploiting the uniform stack access policy provided by the abstract stack.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290375", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuting", + "last_name": "Wang", + "institution": "Yale University" + }, + { + "first_name": "Pierre", + "last_name": "Wilke", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/WangWS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290326", + "title": "Type-guided worst-case input generation", + "abstract": "This paper presents a novel technique for type-guided worst-case input generation for functional programs. The technique builds on automatic amortized resource analysis (AARA), a type-based technique for deriving symbolic bounds on the resource usage of functions. Worst-case input generation is performed by an algorithm that takes as input a function, its resource-annotated type derivation in AARA, and a skeleton that describes the shape and size of the input that is to be generated. If successful, the algorithm fills in integers, booleans, and data structures to produce a value of the shape given by the skeleton. The soundness theorem states that the generated value exhibits the highest cost among all arguments of the functions that have the shape of the skeleton. This cost corresponds exactly to the worst-case bound that is established by the type derivation. In this way, a successful completion of the algorithm proves that the bound is tight for inputs of the given shape. Correspondingly, a relative completeness theorem is proved to show that the algorithm succeeds if and only if the derived worst-case bound is tight. The theorem is relative because it depends on a decision procedure for constraint solving. The technical development is presented for a simple first-order language with linear resource bounds. However, the technique scales to and has been implemented for Resource Aware ML, an implementation of AARA for a fragment of OCaml with higher-order functions, user-defined data types, and types for polynomial bounds. Experiments demonstrate that the technique works effectively and can derive worst-case inputs with hundreds of integers for sorting algorithms, operations on search trees, and insertions into hash tables.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290326", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/WangH19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290369", + "title": "Efficient automated repair of high floating-point errors in numerical libraries", + "abstract": "Floating point computation is by nature inexact, and numerical libraries that intensively involve floating-point computations may encounter high floating-point errors. Due to the wide use of numerical libraries, it is highly desired to reduce high floating-point errors in them. Using higher precision will degrade performance and may also introduce extra errors for certain precision-specific operations in numerical libraries. Using mathematical rewriting that mostly focuses on rearranging floating-point expressions or taking Taylor expansions may not fit for reducing high floating-point errors evoked by ill-conditioned problems that are in the nature of the mathematical feature of many numerical programs in numerical libraries. In this paper, we propose a novel approach for efficient automated repair of high floating-point errors in numerical libraries. Our main idea is to make use of the mathematical feature of a numerical program for detecting and reducing high floating-point errors. The key components include a detecting method based on two algorithms for detecting high floating-point errors and a repair method for deriving an approximation of a mathematical function to generate patch to satisfy a given repair criterion. We implement our approach by constructing a new tool called AutoRNP. Our experiments are conducted on 20 numerical programs in GNU Scientific Library (GSL). Experimental results show that our approach can efficiently repair (with 100% accuracy over all randomly sampled points) high floating-point errors for 19 of the 20 numerical programs.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290369", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xin", + "last_name": "Yi", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Liqian", + "last_name": "Chen", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Xiaoguang", + "last_name": "Mao", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Tao", + "last_name": "Ji", + "institution": "National University of Defense Technology" + } + ], + "dblp_key": "journals/pacmpl/YiCMJ19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290389", + "title": "From fine- to coarse-grained dynamic information flow control and back", + "abstract": "We show that fine-grained and coarse-grained dynamic information-flow control (IFC) systems are equally expressive. To this end, we mechanize two mostly standard languages, one with a fine-grained dynamic IFC system and the other with a coarse-grained dynamic IFC system, and prove a semantics-preserving translation from each language to the other. In addition, we derive the standard security property of non-interference of each language from that of the other, via our verified translation. This result addresses a longstanding open problem in IFC: whether coarse-grained dynamic IFC techniques are less expressive than fine-grained dynamic IFC techniques (they are not!). The translations also stand to have important implications on the usability of IFC approaches. The coarse- to fine-grained direction can be used to remove the label annotation burden that fine-grained systems impose on developers, while the fine- to coarse-grained translation shows that coarse-grained systems---which are easier to design and implement---can track information as precisely as fine-grained systems and provides an algorithm for automatically retrofitting legacy applications to run on existing coarse-grained systems.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290389", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Vassena", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Alejandro", + "last_name": "Russo", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Vineet", + "last_name": "Rajani", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/VassenaRGRS19", + "venue": "popl", + "year": 2019 + }, + { + "paper_id": "10.1145/3290390", + "title": "CT-wasm: type-driven secure cryptography for the web ecosystem", + "abstract": "A significant amount of both client and server-side cryptography is implemented in JavaScript. Despite widespread concerns about its security, no other language has been able to match the convenience that comes from its ubiquitous support on the \"web ecosystem\" - the wide variety of technologies that collectively underpins the modern World Wide Web. With the introduction of the new WebAssembly bytecode language (Wasm) into the web ecosystem, we have a unique opportunity to advance a principled alternative to existing JavaScript cryptography use cases which does not compromise this convenience. We present Constant-Time WebAssembly (CT-Wasm), a type-driven, strict extension to WebAssembly which facilitates the verifiably secure implementation of cryptographic algorithms. CT-Wasm's type system ensures that code written in CT-Wasm is both information flow secure and resistant to timing side channel attacks; like base Wasm, these guarantees are verifiable in linear time. Building on an existing Wasm mechanization, we mechanize the full CT-Wasm specification, prove soundness of the extended type system, implement a verified type checker, and give several proofs of the language's security properties. We provide two implementations of CT-Wasm: an OCaml reference interpreter and a native implementation for Node.js and Chromium that extends Google's V8 engine. We also implement a CT-Wasm to Wasm rewrite tool that allows developers to reap the benefits of CT-Wasm's type system today, while developing cryptographic algorithms for base Wasm environments. We evaluate the language, our implementations, and supporting tools by porting several cryptographic primitives - Salsa20, SHA-256, and TEA - and the full TweetNaCl library. We find that CT-Wasm is fast, expressive, and generates code that we experimentally measure to be constant-time.", + "date": "2019-01-02", + "link": "https://doi.org/10.1145/3290390", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "University of Cambridge" + }, + { + "first_name": "John", + "last_name": "Renner", + "institution": "University of California, San Diego" + }, + { + "first_name": "Natalie", + "last_name": "Popescu", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sunjay", + "last_name": "Cauligi", + "institution": "University of California, San Diego" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/WattRPCS19", + "venue": "popl", + "year": 2019 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2020.json b/data/pl_conferences/popl/2020.json new file mode 100644 index 0000000..0673a88 --- /dev/null +++ b/data/pl_conferences/popl/2020.json @@ -0,0 +1,2136 @@ +[ + { + "paper_id": "10.1145/3371106", + "title": "A simple differentiable programming language", + "abstract": "Automatic differentiation plays a prominent role in scientific computing and in modern machine learning, often in the context of powerful programming systems. The relation of the various embodiments of automatic differentiation to the mathematical notion of derivative is not always entirely clear---discrepancies can arise, sometimes inadvertently. In order to study automatic differentiation in such programming contexts, we define a small but expressive programming language that includes a construct for reverse-mode differentiation. We give operational and denotational semantics for this language. The operational semantics employs popular implementation techniques, while the denotational semantics employs notions of differentiation familiar from real analysis. We establish that these semantics coincide.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371106", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Google (United States)" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/AbadiP20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371122", + "title": "Synthesis of coordination programs from linear temporal specifications", + "abstract": "This paper presents a method for synthesizing a reactive program to coordinate the actions of a group of other reactive programs so that the combined system satisfies a temporal specification of its desired long-term behavior. Traditionally, reactive synthesis has been applied to the construction of a stateful hardware circuit. This work is motivated by applications to other domains, such as the IoT (the Internet of Things) and robotics, where it is necessary to coordinate the actions of multiple sensors, devices, and robots to carry out a task. The mathematical model represents each agent as a process in Hoare’s CSP model. Given a network of interacting agents, called an environment , and a temporal specification of long-term behavior, the synthesis method constructs a coordinator process (if one exists) that guides the actions of the environment agents so that the combined system is deadlock-free and satisfies the given specification. The main technical challenge is that a coordinator may have only partial information of the environment state, due to non-determinism within the environment and internal environment actions that are hidden from the coordinator. This is the first method to handle both sources of partial information and to do so for arbitrary linear temporal logic specifications. It is established that the coordination synthesis problem is PSPACE -hard in the size of the environment. A prototype implementation is able to synthesize compact solutions for a number of coordination problems.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371122", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Suguman", + "last_name": "Bansal", + "institution": "Rice University" + }, + { + "first_name": "Kedar S.", + "last_name": "Namjoshi", + "institution": "Nokia (United States)" + }, + { + "first_name": "Yaniv", + "last_name": "Saʼar", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/BansalNS20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371094", + "title": "Parameterized verification under TSO is PSPACE-complete", + "abstract": "We consider parameterized verification of concurrent programs under the Total Store Order (TSO) semantics. A program consists of a set of processes that share a set of variables on which they can perform read and write operations. We show that the reachability problem for a system consisting of an arbitrary number of identical processes is PSPACE-complete. We prove that the complexity is reduced to polynomial time if the processes are not allowed to read the initial values of the variables in the memory. When the processes are allowed to perform atomic read-modify-write operations, the reachability problem has a non-primitive recursive complexity.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371094", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Rojin", + "last_name": "Rezvan", + "institution": "Sharif University of Technology" + } + ], + "dblp_key": "journals/pacmpl/AbdullaAR20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371089", + "title": "Relational proofs for quantum programs", + "abstract": "Relational verification of quantum programs has many potential applications in quantum and post-quantum security and other domains. We propose a relational program logic for quantum programs. The interpretation of our logic is based on a quantum analogue of probabilistic couplings. We use our logic to verify non-trivial relational properties of quantum programs, including uniformity for samples generated by the quantum Bernoulli factory, reliability of quantum teleportation against noise (bit and phase flip), security of quantum one-time pad and equivalence of quantum walks.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371089", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Nengkun", + "last_name": "Yu", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Li", + "last_name": "Zhou", + "institution": "Tsinghua University" + } + ], + "dblp_key": "journals/pacmpl/BartheHYYZ20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371124", + "title": "Augmented example-based synthesis using relational perturbation properties", + "abstract": "Example-based specifications for program synthesis are inherently ambiguous and may cause synthesizers to generate programs that do not exhibit intended behavior on unseen inputs. Existing synthesis techniques attempt to address this problem by either placing a domain-specific syntactic bias on the hypothesis space or heavily relying on user feedback to help resolve ambiguity. We present a new framework to address the ambiguity/generalizability problem in example-based synthesis. The key feature of our framework is that it places a semantic bias on the hypothesis space using \"relational perturbation properties\" that relate the perturbation/change in a program output to the perturbation/change in a program input. An example of such a property is permutation invariance: the program output does not change when the elements of the program input (array) are permuted. The framework is portable across multiple domains and synthesizers and is based on two core steps: (1) automatically augment the set of user-provided examples by \"applying\" relational perturbation properties and (2) use a generic example-based synthesizer to generate a program consistent with the augmented set of examples. Our framework can be instantiated with three different user interfaces, with varying degrees of user engagement to help infer relevant relational perturbation properties. This includes an interface in which the user only provides examples and our framework automatically infers relevant properties. We implement our framework in a tool SKETCHAX specialized to the SKETCH synthesizer and demonstrate that SKETCHAX is effective in significantly boosting the performance of SKETCH for all three user interfaces.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371124", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shengwei", + "last_name": "An", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Google (United States)" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/AnSMS20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371116", + "title": "Binders by day, labels by night: effect instances via lexically scoped handlers", + "abstract": "Handlers of algebraic effects aspire to be a practical and robust programming construct that allows one to define, use, and combine different computational effects. Interestingly, a critical problem that still bars the way to their popular adoption is how to combine different uses of the same effect in a program, particularly in a language with a static type-and-effect system. For example, it is rudimentary to define the “mutable memory cell” effect as a pair of operations, put and get , together with a handler, but it is far from obvious how to use this effect a number of times to operate a number of memory cells in a single context. In this paper, we propose a solution based on lexically scoped effects in which each use (an “instance”) of an effect can be singled out by name, bound by an enclosing handler and tracked in the type of the expression. Such a setting proves to be delicate with respect to the choice of semantics, as it depends on the explosive mixture of effects, polymorphism, and reduction under binders. Hence, we devise a novel approach to Kripke-style logical relations that can deal with open terms, which allows us to prove the desired properties of our calculus. We formalise our core results in Coq, and introduce an experimental surface-level programming language to show that our approach is applicable in practice.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371116", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dariusz", + "last_name": "Biernacki", + "institution": "University of Wrocław" + }, + { + "first_name": "Maciej", + "last_name": "Piróg", + "institution": "University of Wrocław" + }, + { + "first_name": "Piotr", + "last_name": "Polesiuk", + "institution": "University of Wrocław" + }, + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "University of Wrocław" + } + ], + "dblp_key": "journals/pacmpl/BiernackiPPS20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371075", + "title": "Formal verification of a constant-time preserving C compiler", + "abstract": "Timing side-channels are arguably one of the main sources of vulnerabilities in cryptographic implementations. One effective mitigation against timing side-channels is to write programs that do not perform secret-dependent branches and memory accesses. This mitigation, known as \"cryptographic constant-time\", is adopted by several popular cryptographic libraries. This paper focuses on compilation of cryptographic constant-time programs, and more specifically on the following question: is the code generated by a realistic compiler for a constant-time source program itself provably constant-time? Surprisingly, we answer the question positively for a mildly modified version of the CompCert compiler, a formally verified and moderately optimizing compiler for C. Concretely, we modify the CompCert compiler to eliminate sources of potential leakage. Then, we instrument the operational semantics of CompCert intermediate languages so as to be able to capture cryptographic constant-time. Finally, we prove that the modified CompCert compiler preserves constant-time. Our mechanization maximizes reuse of the CompCert correctness proof, through the use of new proof techniques for proving preservation of constant-time. These techniques achieve complementary trade-offs between generality and tractability of proof effort, and are of independent interest.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371075", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Rémi", + "last_name": "Hutin", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Vincent", + "last_name": "Laporte", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "Université de Rennes" + }, + { + "first_name": "Alix", + "last_name": "Trieu", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/BartheBGHLPT20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371110", + "title": "Abstract interpretation of distributed network control planes", + "abstract": "The control plane of most computer networks runs distributed routing protocols that determine if and how traffic is forwarded. Errors in the configuration of network control planes frequently knock down critical online services, leading to economic damage for service providers and significant hardship for users. Validation via ahead-of-time simulation can help find configuration errors but such techniques are expensive or even intractable for large industrial networks. We explore the use of abstract interpretation to address this fundamental scaling challenge and find that the right abstractions can reduce the asymptotic complexity of network simulation. Based on this observation, we build a tool called ShapeShifter for reachability analysis. On a suite of 127 production networks from a large cloud provider, ShapeShifter provides an asymptotic improvement in runtime and memory over the state-of-the-art simulator. These gains come with a minimal loss in precision. Our abstract analysis accurately predicts reachability for all destinations for 95% of the networks and for most destinations for the remaining 5%. We also find that abstract interpretation of network control planes not only speeds up existing analyses but also facilitates new kinds of analyses. We illustrate this advantage through a new destination \"hijacking\" analysis for the border gateway protocol (BGP), the globally-deployed routing protocol.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371110", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Beckett", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aarti", + "last_name": "Gupta", + "institution": "Princeton University" + }, + { + "first_name": "Ratul", + "last_name": "Mahajan", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/BeckettGMW20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371099", + "title": "Reduction monads and their signatures", + "abstract": "In this work, we study reduction monads , which are essentially the same as monads relative to the free functor from sets into multigraphs. Reduction monads account for two aspects of the lambda calculus: on the one hand, in the monadic viewpoint, the lambda calculus is an object equipped with a well-behaved substitution; on the other hand, in the graphical viewpoint, it is an oriented multigraph whose vertices are terms and whose edges witness the reductions between two terms. We study presentations of reduction monads. To this end, we propose a notion of reduction signature . As usual, such a signature plays the role of a virtual presentation, and specifies arities for generating operations—possibly subject to equations—together with arities for generating reduction rules. For each such signature, we define a category of models; any model is, in particular, a reduction monad. If the initial object of this category of models exists, we call it the reduction monad presented (or specified) by the given reduction signature . Our main result identifies a class of reduction signatures which specify a reduction monad in the above sense. We show in the examples that our approach covers several standard variants of the lambda calculus.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371099", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benedikt", + "last_name": "Ahrens", + "institution": "University of Birmingham" + }, + { + "first_name": "André", + "last_name": "Hirschowitz", + "institution": "Observatoire de la Côte d’Azur" + }, + { + "first_name": "Ambroise", + "last_name": "Lafont", + "institution": "IMT Atlantique" + }, + { + "first_name": "Marco", + "last_name": "Maggesi", + "institution": "University of Florence" + } + ], + "dblp_key": "journals/pacmpl/AhrensHLM20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371112", + "title": "Mechanized semantics and verified compilation for a dataflow synchronous language with reset", + "abstract": "Specifications based on block diagrams and state machines are used to design control software, especially in the certified development of safety-critical applications. Tools like SCADE Suite and Simulink/Stateflow are equipped with compilers that translate such specifications into executable code. They provide programming languages for composing functions over streams as typified by Dataflow Synchronous Languages like Lustre. Recent work builds on CompCert to specify and verify a compiler for the core of Lustre in the Coq Interactive Theorem Prover. It formally links the stream-based semantics of the source language to the sequential memory manipulations of generated assembly code. We extend this work to treat a primitive for resetting subsystems. Our contributions include new semantic rules that are suitable for mechanized reasoning, a novel intermediate language for generating optimized code, and proofs of correctness for the associated compilation passes.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371112", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Timothy", + "last_name": "Bourke", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Lélio", + "last_name": "Brun", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Marc", + "last_name": "Pouzet", + "institution": "Université Paris Sciences et Lettres" + } + ], + "dblp_key": "journals/pacmpl/BourkeBP20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371090", + "title": "Seminaïve evaluation for a higher-order functional language", + "abstract": "One of the workhorse techniques for implementing bottom-up Datalog engines is seminaïve evaluation. This optimization improves the performance of Datalog's most distinctive feature: recursively defined predicates. These are computed iteratively, and under a naïve evaluation strategy, each iteration recomputes all previous values. Seminaïve evaluation computes a safe approximation of the difference between iterations. This can asymptotically improve the performance of Datalog queries. Seminaïve evaluation is defined partly as a program transformation and partly as a modified iteration strategy, and takes advantage of the first-order nature of Datalog code. This paper extends the seminaïve transformation to higher-order programs written in the Datafun language, which extends Datalog with features like first-class relations, higher-order functions, and datatypes like sum types.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371090", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Arntzenius", + "institution": "University of Birmingham" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/ArntzeniusK20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371069", + "title": "Taylor subsumes Scott, Berry, Kahn and Plotkin", + "abstract": "The speculative ambition of replacing the old theory of program approximation based on syntactic continuity with the theory of resource consumption based on Taylor expansion and originating from the differential λ-calculus is nowadays at hand. Using this resource sensitive theory, we provide simple proofs of important results in λ-calculus that are usually demonstrated by exploiting Scott’s continuity, Berry’s stability or Kahn and Plotkin’s sequentiality theory. A paradigmatic example is given by the Perpendicular Lines Lemma for the Böhm tree semantics, which is proved here simply by induction, but relying on the main properties of resource approximants: strong normalization, confluence and linearity.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371069", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Davide", + "last_name": "Barbarossa", + "institution": "Université Sorbonne Paris Nord" + }, + { + "first_name": "Giulio", + "last_name": "Manzonetto", + "institution": "Université Sorbonne Paris Nord" + } + ], + "dblp_key": "journals/pacmpl/BarbarossaM20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371098", + "title": "Decomposition diversity with symmetric data and codata", + "abstract": "The expression problem describes a fundamental trade-off in program design: Should a program's primary decomposition be determined by the way its domain objects are constructed (\"functional\" decomposition), or by the way they are destructed (\"object-oriented\" decomposition)? We argue that programming languages should not force one of these decompositions on the programmer; rather, a programming language should support both ways of decomposing a program in a symmetric way, with an easy translation between these decompositions. However, current programming languages are usually not symmetric and hence make it unnecessarily hard to switch the decomposition. We propose a language that is symmetric in this regard and allows a fully automatic translation between \"functional\" and \"object-oriented\" decomposition. We present a language with algebraic data types and pattern matching for \"functional\" decomposition and codata types and copattern matching for \"object-oriented\" decomposition, together with a bijective translation that turns a data type into a codata type (\"destructorization\") or vice versa (\"constructorization\"). We present the first symmetric programming language with support for local (co)pattern matching, which includes local anonymous function or object definitions, that allows an automatic translation as described above. We also present the first mechanical formalization of such a language and prove i) that the type system is sound, that the translations between data and codata types are ii) type-preserving, iii) behavior-preserving and iv) inverses of each other. We also extract a mechanically verified implementation from our formalization and have implemented an IDE with direct support for these translations.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371098", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David A.", + "last_name": "Binder", + "institution": "University of Tübingen" + }, + { + "first_name": "Julian", + "last_name": "Jabs", + "institution": "University of Tübingen" + }, + { + "first_name": "Ingo", + "last_name": "Skupin", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/BinderJSO20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371086", + "title": "Par means parallel: multiplicative linear logic proofs as concurrent functional programs", + "abstract": "Along the lines of Abramsky’s “Proofs-as-Processes” program, we present an interpretation of multiplicative linear logic as typing system for concurrent functional programming. In particular, we study a linear multiple-conclusion natural deduction system and show it is isomorphic to a simple and natural extension of λ-calculus with parallelism and communication primitives, called λpar. We shall prove that λpar satisfies all the desirable properties for a typed programming language: subject reduction, progress, strong normalization and confluence.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371086", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Federico", + "last_name": "Aschieri", + "institution": "TU Wien" + }, + { + "first_name": "Francesco A.", + "last_name": "Genco", + "institution": "Institut d'Histoire et de Philosophie des Sciences et des Techniques" + } + ], + "dblp_key": "journals/pacmpl/AschieriG20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371123", + "title": "A probabilistic separation logic", + "abstract": "Probabilistic independence is a useful concept for describing the result of random sampling—a basic operation in all probabilistic languages—and for reasoning about groups of random variables. Nevertheless, existing verification methods handle independence poorly, if at all. We propose a probabili stic separation logic PSL, where separation models probabilistic independence. We first give a new, probabilistic model of the logic of bunched implications (BI). We then build a program logic based on these assertions, and prove soundness of the proof system. We demonstrate our logic by verifying information-theoretic security of cryptographic constructions for several well-known tasks, including private information retrieval, oblivious transfer, secure multi-party addition, and simple oblivious RAM. Our proofs reason purely in terms of high-level properties, like independence and uniformity.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371123", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Kevin", + "last_name": "Liao", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/BartheHL20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371132", + "title": "Backpropagation in the simply typed lambda-calculus with linear negation", + "abstract": "Backpropagation is a classic automatic differentiation algorithm computing the gradient of functions specified by a certain class of simple, first-order programs, called computational graphs. It is a fundamental tool in several fields, most notably machine learning, where it is the key for efficiently training (deep) neural networks. Recent years have witnessed the quick growth of a research field called differentiable programming, the aim of which is to express computational graphs more synthetically and modularly by resorting to actual programming languages endowed with control flow operators and higher-order combinators, such as map and fold. In this paper, we extend the backpropagation algorithm to a paradigmatic example of such a programming language: we define a compositional program transformation from the simply-typed lambda-calculus to itself augmented with a notion of linear negation, and prove that this computes the gradient of the source program with the same efficiency as first-order backpropagation. The transformation is completely effect-free and thus provides a purely logical understanding of the dynamics of backpropagation.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371132", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aloïs", + "last_name": "Brunel", + "institution": "" + }, + { + "first_name": "Damiano", + "last_name": "Mazza", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Michele", + "last_name": "Pagani", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "journals/pacmpl/BrunelMP20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371125", + "title": "Semantics of higher-order probabilistic programs with conditioning", + "abstract": "We present a denotational semantics for higher-order probabilistic programs in terms of linear operators between Banach spaces. Our semantics is rooted in the classical theory of Banach spaces and their tensor products, but bears similarities with the well-known semantics of higher-order programs a la Scott through the use of ordered Banach spaces which allow definitions in terms of fixed points. Our semantics is a model of intuitionistic linear logic: it is based on a symmetric monoidal closed category of ordered Banach spaces which treats randomness as a linear resource, but by constructing an exponential comonad we can also accommodate non-linear reasoning. We apply our semantics to the verification of the classical Gibbs sampling algorithm.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371125", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fredrik", + "last_name": "Dahlqvist", + "institution": "Imperial College London" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/DahlqvistK20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371071", + "title": "Dependent type systems as macros", + "abstract": "We present Turnstile+, a high-level, macros-based metaDSL for building dependently typed languages. With it, programmers may rapidly prototype and iterate on the design of new dependently typed features and extensions. Or they may create entirely new DSLs whose dependent type ``power'' is tailored to a specific domain. Our framework's support of language-oriented programming also makes it suitable for experimenting with systems of interacting components, e.g., a proof assistant and its companion DSLs. This paper explains the implementation details of Turnstile+, as well as how it may be used to create a wide-variety of dependently typed languages, from a lightweight one with indexed types, to a full spectrum proof assistant, complete with a tactic system and extensions for features like sized types and SMT interaction.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371071", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Chang", + "institution": "Northeastern University" + }, + { + "first_name": "Michael", + "last_name": "Ballantyne", + "institution": "Northeastern University" + }, + { + "first_name": "Milo", + "last_name": "Turner", + "institution": "Northeastern University" + }, + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/ChangBTB20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371096", + "title": "Abstract extensionality: on the properties of incomplete abstract interpretations", + "abstract": "In this paper we generalise the notion of extensional (functional) equivalence of programs to abstract equivalences induced by abstract interpretations . The standard notion of extensional equivalence is recovered as the special case, induced by the concrete interpretation. Some properties of the extensional equivalence, such as the one spelled out in Rice’s theorem, lift to the abstract equivalences in suitably generalised forms. On the other hand, the generalised framework gives rise to interesting and important new properties, and allows refined, non-extensional analyses. In particular, since programs turn out to be extensionally equivalent if and only if they are equivalent just for the concrete interpretation, it follows that any non-trivial abstract interpretation uncovers some intensional aspect of programs. This striking result is also effective, in the sense that it allows constructing, for any non-trivial abstraction, a pair of programs that are extensionally equivalent, but have different abstract semantics. The construction is based on the fact that abstract interpretations are always sound, but that they can be made incomplete through suitable code transformations. To construct these transformations, we introduce a novel technique for building incompleteness cliques of extensionally equivalent yet abstractly distinguishable programs: They are built together with abstract interpretations that produce false alarms. While programs are forced into incompleteness cliques using both control-flow and data-flow transformations, the main result follows from limitations of data-flow transformations with respect to control-flow ones. A further consequence is that the class of incomplete programs for a non-trivial abstraction is Turing complete. The obtained results also shed a new light on the relation between the techniques of code obfuscation and the precision in program analysis.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371096", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roberto", + "last_name": "Bruni", + "institution": "University of Pisa" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "IMDEA Software" + }, + { + "first_name": "Roberta", + "last_name": "Gori", + "institution": "University of Pisa" + }, + { + "first_name": "Isabel", + "last_name": "Garcia-Contreras", + "institution": "Universidad Politécnica de Madrid" + }, + { + "first_name": "Duško", + "last_name": "Pavlović", + "institution": "University of Hawaii System" + } + ], + "dblp_key": "journals/pacmpl/BruniGGGP20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371073", + "title": "Complexity and information in invariant inference", + "abstract": "This paper addresses the complexity of SAT-based invariant inference, a prominent approach to safety verification. We consider the problem of inferring an inductive invariant of polynomial length given a transition system and a safety property. We analyze the complexity of this problem in a black-box model, called the Hoare-query model, which is general enough to capture algorithms such as IC3/PDR and its variants. An algorithm in this model learns about the system's reachable states by querying the validity of Hoare triples. We show that in general an algorithm in the Hoare-query model requires an exponential number of queries. Our lower bound is information-theoretic and applies even to computationally unrestricted algorithms, showing that no choice of generalization from the partial information obtained in a polynomial number of Hoare queries can lead to an efficient invariant inference procedure in this class. We then show, for the first time, that by utilizing rich Hoare queries, as done in PDR, inference can be exponentially more efficient than approaches such as ICE learning, which only utilize inductiveness checks of candidates. We do so by constructing a class of transition systems for which a simple version of PDR with a single frame infers invariants in a polynomial number of queries, whereas every algorithm using only inductiveness checks and counterexamples requires an exponential number of queries. Our results also shed light on connections and differences with the classical theory of exact concept learning with queries, and imply that learning from counterexamples to induction is harder than classical exact learning from labeled examples. This demonstrates that the convergence rate of Counterexample-Guided Inductive Synthesis depends on the form of counterexamples.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371073", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yotam M. Y.", + "last_name": "Feldman", + "institution": "Tel Aviv University" + }, + { + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/FeldmanISS20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371070", + "title": "Deductive verification with ghost monitors", + "abstract": "We present a new approach to deductive program verification based on auxiliary programs called ghost monitors . This technique is useful when the syntactic structure of the target program is not well suited for verification, for example, when an essentially recursive algorithm is implemented in an iterative fashion. Our approach consists in implementing, specifying, and verifying an auxiliary program that monitors the execution of the target program, in such a way that the correctness of the monitor entails the correctness of the target. The ghost monitor maintains the necessary data and invariants to facilitate the proof. It can be implemented and verified in any suitable framework, which does not have to be related to the language of the target programs. This technique is also applicable when we want to establish relational properties between two target programs written in different languages and having different syntactic structure. We then show how ghost monitors can be used to specify and prove fine-grained properties about the infinite behaviors of target programs. Since this cannot be easily done using existing verification frameworks, we introduce a dedicated language for ghost monitors, with an original construction to catch and handle divergent executions. The soundness of the underlying program logic is established using a particular flavor of transfinite games. This language and its soundness are formalized and mechanically checked.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371070", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Clochard", + "institution": "ETH Zurich" + }, + { + "first_name": "Claude", + "last_name": "Marché", + "institution": "Numerical Method (China)" + }, + { + "first_name": "Andrei", + "last_name": "Paskevich", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/ClochardMP20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371111", + "title": "Executable formal semantics for the POSIX shell", + "abstract": "The POSIX shell is a widely deployed, powerful tool for managing computer systems. The shell is the expert’s control panel, a necessary tool for configuring, compiling, installing, maintaining, and deploying systems. Even though it is powerful, critical infrastructure, the POSIX shell is maligned and misunderstood. Its power and its subtlety are a dangerous combination. We define a formal, mechanized, executable small-step semantics for the POSIX shell, which we call Smoosh. We compared Smoosh against seven other shells that aim for some measure of POSIX compliance (bash, dash, zsh, OSH, mksh, ksh93, and yash). Using three test suites—the POSIX test suite, the Modernish test suite and shell diagnostic, and a test suite of our own device—we found Smoosh’s semantics to be the most conformant to the POSIX standard. Modernish judges Smoosh to have the fewest bugs (just one, from using dash’s parser) and no quirks. To show that our semantics is useful beyond yielding a conformant, executable shell, we also implemented a symbolic stepper to illuminate the subtle behavior of the shell. Smoosh will serve as a foundation for formal study of the POSIX shell, supporting research on and development of new shells, new tooling for shells, and new shell designs.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371111", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Pomona College" + }, + { + "first_name": "Austin J.", + "last_name": "Blatt", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/GreenbergB20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371105", + "title": "Aiming low is harder: induction for lower bounds in probabilistic program verification", + "abstract": "We present a new inductive rule for verifying lower bounds on expected values of random variables after execution of probabilistic loops as well as on their expected runtimes. Our rule is simple in the sense that loop body semantics need to be applied only finitely often in order to verify that the candidates are indeed lower bounds. In particular, it is not necessary to find the limit of a sequence as in many previous rules.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371105", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marcel", + "last_name": "Hark", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Jürgen", + "last_name": "Giesl", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/HarkKGK20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371131", + "title": "Full abstraction for the quantum lambda-calculus", + "abstract": "Quantum programming languages permit a hardware independent, high-level description of quantum algorithms. In particular, the quantum λ-calculus is a higher-order language with quantum primitives, mixing quantum data and classical control. Giving satisfactory denotational semantics to the quantum λ-calculus is a challenging problem that has attracted significant interest. In the past few years, both static (the quantum relational model) and dynamic (quantum game semantics) denotational models were given, with matching computational adequacy results. However, no model was known to be fully abstract. Our first contribution is a full abstraction result for the games model of the quantum λ-calculus. Full abstraction holds with respect to an observational quotient of strategies, obtained by summing valuations of all states matching a given observable. Our proof method for full abstraction extends a technique recently introduced to prove full abstraction for probabilistic coherence spaces with respect to probabilistic PCF. Our second contribution is an interpretation-preserving functor from quantum games to the quantum relational model, extending a long line of work on connecting static and dynamic denotational models. From this, it follows that the quantum relational model is fully abstract as well. Altogether, this gives a complete denotational landscape for the semantics of the quantum λ-calculus, with static and dynamic models related by a clean functorial correspondence, and both fully abstract.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371131", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Clairambault", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Marc de", + "last_name": "Visme", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/ClairambaultV20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371080", + "title": "Program synthesis by type-guided abstraction refinement", + "abstract": "We consider the problem of type-directed component-based synthesis where, given a set of (typed) components and a query type , the goal is to synthesize a term that inhabits the query. Classical approaches based on proof search in intuitionistic logics do not scale up to the standard libraries of modern languages, which span hundreds or thousands of components. Recent graph reachability based methods proposed for Java do scale, but only apply to monomorphic data and components: polymorphic data and components infinitely explode the size of the graph that must be searched, rendering synthesis intractable. We introduce type-guided abstraction refinement (TYGAR), a new approach for scalable type-directed synthesis over polymorphic datatypes and components. Our key insight is that we can overcome the explosion by building a graph over abstract types which represent a potentially unbounded set of concrete types. We show how to use graph reachability to search for candidate terms over abstract types, and introduce a new algorithm that uses proofs of untypeability of ill-typed candidates to iteratively refine the abstraction until a well-typed result is found. We have implemented TYGAR in H+, a tool that takes as input a set of Haskell libraries and a query type, and returns a Haskell term that uses functions from the provided libraries to implement the query type. Our support for polymorphism allows H+ to work with higher-order functions and type classes, and enables more precise queries due to parametricity. We have evaluated H+ on 44 queries using a set of popular Haskell libraries with a total of 291 components. H+ returns an interesting solution within the first five results for 32 out of 44 queries. Our results show that TYGAR allows H+ to rapidly return well-typed terms, with the median time to first solution of just 1.4 seconds. Moreover, we observe that gains from iterative refinement over exhaustive enumeration are more pronounced on harder queries.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371080", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zheng", + "last_name": "Guo", + "institution": "University of California, San Diego" + }, + { + "first_name": "Michael B.", + "last_name": "James", + "institution": "University of California, San Diego" + }, + { + "first_name": "David", + "last_name": "Justo", + "institution": "University of California, San Diego" + }, + { + "first_name": "Jiaxiao", + "last_name": "Zhou", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ziteng", + "last_name": "Wang", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/GuoJJZWJP20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371081", + "title": "Reductions for safety proofs", + "abstract": "Program reductions are used widely to simplify reasoning about the correctness of concurrent and distributed programs. In this paper, we propose a general approach to proof simplification of concurrent programs based on exploring generic classes of reductions. We introduce two classes of sound program reductions, study their theoretical properties, show how they can be effectively used in algorithmic verification, and demonstrate that they are very effective in producing proofs of a diverse class of programs without targeting specific syntactic properties of these programs. The most novel contribution of this paper is the introduction of the concept of context in the definition of program reductions. We demonstrate how commutativity of program steps in some program contexts can be used to define a generic class of sound reductions which can be used to automatically produce proofs for programs whose complete Floyd-Hoare style proofs are theoretically beyond the reach of automated verification technology of today.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371081", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Anthony", + "last_name": "Vandikas", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/FarzanV20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371118", + "title": "A language for probabilistically oblivious computation", + "abstract": "An oblivious computation is one that is free of direct and indirect information leaks, e.g., due to observable differences in timing and memory access patterns. This paper presents Lambda Obliv, a core language whose type system enforces obliviousness. Prior work on type-enforced oblivious computation has focused on deterministic programs. Lambda Obliv is new in its consideration of programs that implement probabilistic algorithms, such as those involved in cryptography. Lambda Obliv employs a substructural type system and a novel notion of probability region to ensure that information is not leaked via the observed distribution of visible events. Probability regions support reasoning about probabilistic correlation and independence between values, and our use of probability regions is motivated by a source of unsoundness that we discovered in the type system of ObliVM, a language for implementing state of the art oblivious algorithms. We prove that Lambda Obliv's type system enforces obliviousness and show that it is expressive enough to typecheck advanced tree-based oblivious RAMs.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371118", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Darais", + "institution": "University of Vermont" + }, + { + "first_name": "Ian", + "last_name": "Sweet", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Chang", + "last_name": "Liu", + "institution": "Citadel" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/DaraisSLH20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371095", + "title": "The weak call-by-value λ-calculus is reasonable for both time and space", + "abstract": "We study the weak call-by-value λ-calculus as a model for computational complexity theory and establish the natural measures for time and space — the number of beta-reduction steps and the size of the largest term in a computation — as reasonable measures with respect to the invariance thesis of Slot and van Emde Boas from 1984. More precisely, we show that, using those measures, Turing machines and the weak call-by-value λ-calculus can simulate each other within a polynomial overhead in time and a constant factor overhead in space for all computations terminating in (encodings of) ”true” or ”false”. The simulation yields that standard complexity classes like P , NP , PSPACE , or EXP can be defined solely in terms of the λ-calculus, but does not cover sublinear time or space. Note that our measures still have the well-known size explosion property, where the space measure of a computation can be exponentially bigger than its time measure. However, our result implies that this exponential gap disappears once complexity classes are considered instead of concrete computations. We consider this result a first step towards a solution for the long-standing open problem of whether the natural measures for time and space of the λ-calculus are reasonable. Our proof for the weak call-by-value λ-calculus is the first proof of reasonability (including both time and space) for a functional language based on natural measures and enables the formal verification of complexity-theoretic proofs concerning complexity classes, both on paper and in proof assistants. The proof idea relies on a hybrid of two simulation strategies of reductions in the weak call-by-value λ-calculus by Turing machines, both of which are insufficient if taken alone. The first strategy is the most naive one in the sense that a reduction sequence is simulated precisely as given by the reduction rules; in particular, all substitutions are executed immediately. This simulation runs within a constant overhead in space, but the overhead in time might be exponential. The second strategy is heap-based and relies on structure sharing, similar to existing compilers of eager functional languages. This strategy only has a polynomial overhead in time, but the space consumption might require an additional factor of log n , which is essentially due to the size of the pointers required for this strategy. Our main contribution is the construction and verification of a space-aware interleaving of the two strategies, which is shown to yield both a constant overhead in space and a polynomial overhead in time.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371095", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yannick", + "last_name": "Forster", + "institution": "Saarland University" + }, + { + "first_name": "Fabian", + "last_name": "Kunze", + "institution": "Saarland University" + }, + { + "first_name": "Marc", + "last_name": "Roth", + "institution": "Saarland University" + } + ], + "dblp_key": "journals/pacmpl/ForsterKR20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371092", + "title": "Liquidate your assets: reasoning about resource usage in liquid Haskell", + "abstract": "Liquid Haskell is an extension to the type system of Haskell that supports formal reasoning about program correctness by encoding logical properties as refinement types. In this article, we show how Liquid Haskell can also be used to reason about program efficiency in the same setting. We use the system's existing verification machinery to ensure that the results of our cost analysis are valid, together with custom invariants for particular program contexts to ensure that the results of our analysis are precise. To illustrate our approach, we analyse the efficiency of a wide range of popular data structures and algorithms, and in doing so, explore various notions of resource usage. Our experience is that reasoning about efficiency in Liquid Haskell is often just as simple as reasoning about correctness, and that the two can naturally be combined.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371092", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin A. T.", + "last_name": "Handley", + "institution": "University of Nottingham" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/HandleyVH20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371074", + "title": "Actris: session-type based reasoning in separation logic", + "abstract": "Message passing is a useful abstraction to implement concurrent programs. For real-world systems, however, it is often combined with other programming and concurrency paradigms, such as higher-order functions, mutable state, shared-memory concurrency, and locks. We present Actris: a logic for proving functional correctness of programs that use a combination of the aforementioned features. Actris combines the power of modern concurrent separation logics with a first-class protocol mechanism—based on session types—for reasoning about message passing in the presence of other concurrency paradigms. We show that Actris provides a suitable level of abstraction by proving functional correctness of a variety of examples, including a distributed merge sort, a distributed load-balancing mapper, and a variant of the map-reduce model, using relatively simple specifications. Soundness of Actris is proved using a model of its protocol mechanism in the Iris framework. We mechanised the theory of Actris, together with tactics for symbolic execution of programs, as well as all examples in the paper, in the Coq proof assistant.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371074", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Jesper", + "last_name": "Bengtson", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/HinrichsenBK20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371102", + "title": "RustBelt meets relaxed memory", + "abstract": "The Rust programming language supports safe systems programming by means of a strong ownership-tracking type system. In their prior work on RustBelt, Jung et al. began the task of setting Rust’s safety claims on a more rigorous formal foundation. Specifically, they used Iris, a Coq-based separation logic framework, to build a machine-checked proof of semantic soundness for a λ-calculus model of Rust, as well as for a number of widely-used Rust libraries that internally employ unsafe language features. However, they also made the significant simplifying assumption that the language is sequentially consistent. In this paper, we adapt RustBelt to account for the relaxed-memory operations that concurrent Rust libraries actually use, in the process uncovering a data race in the Arc library. We focus on the most interesting technical problem: how to reason about resource reclamation under relaxed memory , using a logical construction we call synchronized ghost state .", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371102", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hoang-Hai", + "last_name": "Dang", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Laboratoire de Recherche en Informatique" + }, + { + "first_name": "Jan-Oliver", + "last_name": "Kaiser", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/DangJKD20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371077", + "title": "Undecidability of d<: and its decidable fragments", + "abstract": "Dependent Object Types (DOT) is a calculus with path dependent types, intersection types, and object self-references, which serves as the core calculus of Scala 3. Although the calculus has been proven sound, it remains open whether type checking in DOT is decidable. In this paper, we establish undecidability proofs of type checking and subtyping of D <: , a syntactic subset of DOT. It turns out that even for D <: , undecidability is surprisingly difficult to show, as evidenced by counterexamples for past attempts. To prove undecidability, we discover an equivalent definition of the D <: subtyping rules in normal form. Besides being easier to reason about, this definition makes the phenomenon of subtyping reflection explicit as a single inference rule. After removing this rule, we discover two decidable fragments of D <: subtyping and identify algorithms to decide them. We prove soundness and completeness of the algorithms with respect to the fragments, and we prove that the algorithms terminate. Our proofs are mechanized in a combination of Coq and Agda.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371077", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jason Z. S.", + "last_name": "Hu", + "institution": "McGill University" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/HuL20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371127", + "title": "SyTeCi: automating contextual equivalence for higher-order programs with references", + "abstract": "We propose a framework to study contextual equivalence of programs written in a call-by-value functional language with local integer references. It reduces the problem of contextual equivalence to the problem of non-reachability in a transition system of memory configurations. This reduction is complete for recursion-free programs. Restricting to programs that do not allocate references inside the body of functions, we encode this non-reachability problem as a set of constrained Horn clause that can then be checked for satisfiability automatically. Restricting furthermore to a language with finite data-types, we also get a new decidability result for contextual equivalence at any type.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371127", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Guilhem", + "last_name": "Jaber", + "institution": "Laboratoire des Sciences du Numérique de Nantes" + } + ], + "dblp_key": "journals/pacmpl/Jaber20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371108", + "title": "Partial type constructors: or, making ad hoc datatypes less ad hoc", + "abstract": "Functional programming languages assume that type constructors are total. Yet functional programmers know better: counterexamples range from container types that make limiting assumptions about their contents (e.g., requiring computable equality or ordering functions) to type families with defining equations only over certain choices of arguments. We present a language design and formal theory of partial type constructors, capturing the domains of type constructors using qualified types. Our design is both simple and expressive: we support partial datatypes as first-class citizens (including as instances of parametric abstractions, such as the Haskell Functor and Monad classes), and show a simple type elaboration algorithm that avoids placing undue annotation burden on programmers. We show that our type system rejects ill-defined types and can be compiled to a semantic model based on System F. Finally, we have conducted an experimental analysis of a body of Haskell code, using a proof-of-concept implementation of our system; while there are cases where our system requires additional annotations, these cases are rarely encountered in practical Haskell code.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371108", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Portland State University" + }, + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Kansas" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + } + ], + "dblp_key": "journals/pacmpl/JonesME20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371097", + "title": "What is decidable about gradual types?", + "abstract": "Programmers can use gradual types to migrate programs to have more precise type annotations and thereby improve their readability, efficiency, and safety. Such migration requires an exploration of the migration space and can benefit from tool support, as shown in previous work. Our goal is to provide a foundation for better tool support by settling decidability questions about migration with gradual types. We present three algorithms and a hardness result for deciding key properties and we explain how they can be useful during an exploration. In particular, we show how to decide whether the migration space is finite, whether it has a top element, and whether it is a singleton. We also show that deciding whether it has a maximal element is NP-hard. Our implementation of our algorithms worked as expected on a suite of microbenchmarks.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371097", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zeina", + "last_name": "Migeed", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/MigeedP20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371109", + "title": "Stacked borrows: an aliasing model for Rust", + "abstract": "Type systems are useful not just for the safety guarantees they provide, but also for helping compilers generate more efficient code by simplifying important program analyses. In Rust, the type system imposes a strict discipline on pointer aliasing, and it is an express goal of the Rust compiler developers to make use of that alias information for the purpose of program optimizations that reorder memory accesses. The problem is that Rust also supports unsafe code, and programmers can write unsafe code that bypasses the usual compiler checks to violate the aliasing discipline. To strike a balance between optimizations and unsafe code, the language needs to provide a set of rules such that unsafe code authors can be sure, if they are following these rules, that the compiler will preserve the semantics of their code despite all the optimizations it is doing. In this work, we propose Stacked Borrows , an operational semantics for memory accesses in Rust. Stacked Borrows defines an aliasing discipline and declares programs violating it to have undefined behavior , meaning the compiler does not have to consider such programs when performing optimizations. We give formal proofs (mechanized in Coq) showing that this rules out enough programs to enable optimizations that reorder memory accesses around unknown code and function calls, based solely on intraprocedural reasoning. We also implemented this operational model in an interpreter for Rust and ran large parts of the Rust standard library test suite in the interpreter to validate that the model permits enough real-world unsafe Rust code.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371109", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Hoang-Hai", + "last_name": "Dang", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/JungDKD20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371133", + "title": "Does blame shifting work?", + "abstract": "Contract systems, especially of the higher-order flavor, go hand in hand with blame. The pragmatic purpose of blame is to narrow down the code that a programmer needs to examine to locate the bug when the contract system discovers a contract violation. Or so the literature on higher-order contracts claims. In reality, however, there is neither empirical nor theoretical evidence that connects blame with the location of bugs. The reputation of blame as a tool for weeding out bugs rests on anecdotes about how programmers use contracts to shift blame and their attention from one part of a program to another until they discover the source of the problem. This paper aims to fill the apparent gap and shed light to the relation between blame and bugs. To that end, we introduce an empirical methodology for investigating whether, for a given contract system, it is possible to translate blame information to the location of bugs in a systematic manner. Our methodology is inspired by how programmers attempt to increase the precision of the contracts of a blamed component in order to shift blame to another component, which becomes the next candidate for containing the bug. In particular, we construct a framework that enables us to ask for a contract system whether (i) the process of blame shifting causes blame to eventually settle to the component that contains the bug; and (ii) every shift moves blame ``closer'' to the faulty component. Our methodology offers a rigorous means for evaluating the pragmatics of contract systems, and we employ it to analyze Racket's contract system. Along the way, we uncover subtle points about the pragmatic meaning of contracts and blame in Racket: (i) the expressiveness of Racket's off-the-shelf contract language is not sufficient to narrow down the blamed portion of the code to the faulty component in all cases; and (ii) contracts that trigger state changes (even unexpectedly, perhaps in the runtime system's data structures or caches) interfere with program evaluation in subtle ways and thus blame shifting can lead programmers on a detour when searching for a bug. These points highlight how evaluations such as ours suggest fixes to language design.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371133", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lukas", + "last_name": "Lazarek", + "institution": "Northwestern University" + }, + { + "first_name": "Alexis", + "last_name": "King", + "institution": "Northwestern University" + }, + { + "first_name": "Samanvitha", + "last_name": "Sundar", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/LazarekKSFD20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371083", + "title": "Recurrence extraction for functional programs through call-by-push-value", + "abstract": "The main way of analysing the complexity of a program is that of extracting and solving a recurrence that expresses its running time in terms of the size of its input. We develop a method that automatically extracts such recurrences from the syntax of higher-order recursive functional programs. The resulting recurrences, which are programs in a call-by-name language with recursion, explicitly compute the running time in terms of the size of the input. In order to achieve this in a uniform way that covers both call-by-name and call-by-value evaluation strategies, we use Call-by-Push-Value (CBPV) as an intermediate language. Finally, we use domain theory to develop a denotational cost semantics for the resulting recurrences.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371083", + "conference_name": "POPL", + "authors": [ + { + "first_name": "G. A.", + "last_name": "Kavvos", + "institution": "Wesleyan University" + }, + { + "first_name": "Edward", + "last_name": "Morehouse", + "institution": "Wesleyan University" + }, + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Wesleyan University" + }, + { + "first_name": "Norman", + "last_name": "Danner", + "institution": "Wesleyan University" + } + ], + "dblp_key": "journals/pacmpl/KavvosMLD20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371072", + "title": "The next 700 relational program logics", + "abstract": "We propose the first framework for defining relational program logics for arbitrary monadic effects. The framework is embedded within a relational dependent type theory and is highly expressive. At the semantic level, we provide an algebraic presentation of relational specifications as a class of relative monads, and link computations and specifications by introducing relational effect observations, which map pairs of monadic computations to relational specifications in a way that respects the algebraic structure. For an arbitrary relational effect observation, we generically define the core of a sound relational program logic, and explain how to complete it to a full-fledged logic for the monadic effect at hand. We show that this generic framework can be used to define relational program logics for effects as diverse as state, input-output, nondeterminism, and discrete probabilities. We, moreover, show that by instantiating our framework with state and unbounded iteration we can embed a variant of Benton's Relational Hoare Logic, and also sketch how to reconstruct Relational Hoare Type Theory. Finally, we identify and overcome conceptual challenges that prevented previous relational program logics from properly dealing with control effects, and are the first to provide a relational program logic for exceptions.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371072", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "State Key Laboratory of Cryptology" + }, + { + "first_name": "Exequiel", + "last_name": "Rivas", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Antoine Van", + "last_name": "Muylder", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/MaillardHRM20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371082", + "title": "Deterministic parallel fixpoint computation", + "abstract": "Abstract interpretation is a general framework for expressing static program analyses. It reduces the problem of extracting properties of a program to computing an approximation of the least fixpoint of a system of equations. The de facto approach for computing this approximation uses a sequential algorithm based on weak topological order (WTO). This paper presents a deterministic parallel algorithm for fixpoint computation by introducing the notion of weak partial order (WPO). We present an algorithm for constructing a WPO in almost-linear time. Finally, we describe Pikos, our deterministic parallel abstract interpreter, which extends the sequential abstract interpreter IKOS. We evaluate the performance and scalability of Pikos on a suite of 1017 C programs. When using 4 cores, Pikos achieves an average speedup of 2.06x over IKOS, with a maximum speedup of 3.63x. When using 16 cores, Pikos achieves a maximum speedup of 10.97x.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371082", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sung Kook", + "last_name": "Kim", + "institution": "University of California, Davis" + }, + { + "first_name": "Arnaud J.", + "last_name": "Venet", + "institution": "Meta (United States)" + }, + { + "first_name": "Aditya V.", + "last_name": "Thakur", + "institution": "University of California, Davis" + } + ], + "dblp_key": "journals/pacmpl/KimVT20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371134", + "title": "Decidable subtyping for path dependent types", + "abstract": "Path dependent types have long served as an expressive component of the Scala programming language. They allow for the modelling of both bounded polymorphism and a degree of nominal subtyping. Nominality in turn provides the ability to capture first class modules. Thus a single language feature gives rise to a rich array of expressiveness. Recent work has proven path dependent types sound in the presence of both intersection and recursive types, but unfortunately typing remains undecidable, posing problems for programmers who rely on the results of type checkers. The Wyvern programming language is an object oriented language with path dependent types, recursive types and first class modules. In this paper we define two variants of Wyvern that feature decidable typing, along with machine checked proofs of decidability. Despite the restrictions, our approaches retain the ability to encode the parameteric polymorphism of Java generics along with many idioms of the Scala module system.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371134", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julian", + "last_name": "Mackay", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Lindsay", + "last_name": "Groves", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "journals/pacmpl/MackayPAG20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371084", + "title": "Towards verified stochastic variational inference for probabilistic programs", + "abstract": "Probabilistic programming is the idea of writing models from statistics and machine learning using program notations and reasoning about these models using generic inference engines. Recently its combination with deep learning has been explored intensely, which led to the development of so called deep probabilistic programming languages, such as Pyro, Edward and ProbTorch. At the core of this development lie inference engines based on stochastic variational inference algorithms. When asked to find information about the posterior distribution of a model written in such a language, these algorithms convert this posterior-inference query into an optimisation problem and solve it approximately by a form of gradient ascent or descent. In this paper, we analyse one of the most fundamental and versatile variational inference algorithms, called score estimator or REINFORCE, using tools from denotational semantics and program analysis. We formally express what this algorithm does on models denoted by programs, and expose implicit assumptions made by the algorithm on the models. The violation of these assumptions may lead to an undefined optimisation objective or the loss of convergence guarantee of the optimisation process. We then describe rules for proving these assumptions, which can be automated by static program analyses. Some of our rules use nontrivial facts from continuous mathematics, and let us replace requirements about integrals in the assumptions, such as integrability of functions defined in terms of programs' denotations, by conditions involving differentiation or boundedness, which are much easier to prove automatically (and manually). Following our general methodology, we have developed a static program analysis for the Pyro programming language that aims at discharging the assumption about what we call model-guide support match. Our analysis is applied to the eight representative model-guide pairs from the Pyro webpage, which include sophisticated neural network models such as AIR. It finds a bug in one of these cases, reveals a non-standard use of an inference engine in another, and shows that the assumptions are met in the remaining six cases.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371084", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Hangyeol", + "last_name": "Yu", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Université Paris Sciences et Lettres" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/LeeYRY20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371088", + "title": "Virtual timeline: a formal abstraction for verifying preemptive schedulers with temporal isolation", + "abstract": "The reliability and security of safety-critical real-time systems are of utmost importance because the failure of these systems could incur severe consequences (e.g., loss of lives or failure of a mission). Such properties require strong isolation between components and they rely on enforcement mechanisms provided by the underlying operating system (OS) kernel. In addition to spatial isolation which is commonly provided by OS kernels to various extents, it also requires temporal isolation, that is, properties on the schedule of one component (e.g., schedulability) are independent of behaviors of other components. The strict isolation between components relies critically on algorithmic properties of the concrete implementation of the scheduler, such as timely provision of time slots, obliviousness to preemption, etc. However, existing work either only reasons about an abstract model of the scheduler, or proves properties of the scheduler implementation that are not rich enough to establish the isolation between different components. In this paper, we present a novel compositional framework for reasoning about algorithmic properties of the concrete implementation of preemptive schedulers. In particular, we use virtual timeline , a variant of the supply bound function used in real-time scheduling analysis, to specify and reason about the scheduling of each component in isolation. We show that the properties proved on this abstraction carry down to the generated assembly code of the OS kernel. Using this framework, we successfully verify a real-time OS kernel, which extends mCertiKOS, a single-processor non-preemptive kernel, with user-level preemption, a verified timer interrupt handler, and a verified real-time scheduler. We prove that in the absence of microarchitectural-level timing channels, this new kernel enjoys temporal and spatial isolation on top of the functional correctness guarantee. All the proofs are implemented in the Coq proof assistant.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371088", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mengqi", + "last_name": "Liu", + "institution": "Yale University" + }, + { + "first_name": "Lionel", + "last_name": "Rieg", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Columbia University" + }, + { + "first_name": "David", + "last_name": "Costanzo", + "institution": "Yale University" + }, + { + "first_name": "Jungeun", + "last_name": "Kim", + "institution": "Yale University" + }, + { + "first_name": "Man-Ki", + "last_name": "Yoon", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/LiuRSGCKY20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371087", + "title": "Trace types and denotational semantics for sound programmable inference in probabilistic languages", + "abstract": "Modern probabilistic programming languages aim to formalize and automate key aspects of probabilistic modeling and inference. Many languages provide constructs for programmable inference that enable developers to improve inference speed and accuracy by tailoring an algorithm for use with a particular model or dataset. Unfortunately, it is easy to use these constructs to write unsound programs that appear to run correctly but produce incorrect results. To address this problem, we present a denotational semantics for programmable inference in higher-order probabilistic programming languages, along with a type system that ensures that well-typed inference programs are sound by construction. A central insight is that the type of a probabilistic expression can track the space of its possible execution traces, not just the type of value that it returns, as these traces are often the objects that inference algorithms manipulate. We use our semantics and type system to establish soundness properties of custom inference programs that use constructs for variational, sequential Monte Carlo, importance sampling, and Markov chain Monte Carlo inference.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371087", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Marco", + "last_name": "Cusumano-Towner", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Benjamin", + "last_name": "Sherman", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LewCSCM20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371078", + "title": "Incorrectness logic", + "abstract": "Program correctness and incorrectness are two sides of the same coin. As a programmer, even if you would like to have correctness, you might find yourself spending most of your time reasoning about incorrectness. This includes informal reasoning that people do while looking at or thinking about their code, as well as that supported by automated testing and static analysis tools. This paper describes a simple logic for program incorrectness which is, in a sense, the other side of the coin to Hoare's logic of correctness.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371078", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/OHearn20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371113", + "title": "The future is ours: prophecy variables in separation logic", + "abstract": "Early in the development of Hoare logic, Owicki and Gries introduced auxiliary variables as a way of encoding information about the history of a program’s execution that is useful for verifying its correctness. Over a decade later, Abadi and Lamport observed that it is sometimes also necessary to know in advance what a program will do in the future . To address this need, they proposed prophecy variables , originally as a proof technique for refinement mappings between state machines. However, despite the fact that prophecy variables are a clearly useful reasoning mechanism, there is (surprisingly) almost no work that attempts to integrate them into Hoare logic. In this paper, we present the first account of prophecy variables in a Hoare-style program logic that is flexible enough to verify logical atomicity (a relative of linearizability) for classic examples from the concurrency literature like RDCSS and the Herlihy-Wing queue. Our account is formalized in the Iris framework for separation logic in Coq. It makes essential use of ownership to encode the exclusive right to resolve a prophecy, which in turn enables us to enforce soundness of prophecies with a very simple set of proof rules.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371113", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rodolphe", + "last_name": "Lepigre", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "G.", + "last_name": "Parthasarathy", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Marianna", + "last_name": "Rapoport", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "KU Leuven" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Bart", + "last_name": "Jacobs", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/JungLPRTDJ20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371103", + "title": "Deciding memory safety for single-pass heap-manipulating programs", + "abstract": "We investigate the decidability of automatic program verification for programs that manipulate heaps, and in particular, decision procedures for proving memory safety for them. We extend recent work that identified a decidable subclass of uninterpreted programs to a class of alias-aware programs that can update maps. We apply this theory to develop verification algorithms for memory safety— determining if a heap-manipulating program that allocates and frees memory locations and manipulates heap pointers does not dereference an unallocated memory location. We show that this problem is decidable when the initial allocated heap forms a forest data-structure and when programs are streaming-coherent , which intuitively restricts programs to make a single pass over a data-structure. Our experimental evaluation on a set of library routines that manipulate forest data-structures shows that common single-pass algorithms on data-structures often fall in the decidable class, and that our decision procedure is efficient in verifying them.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371103", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Paul", + "last_name": "Krogmeier", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MathurMKMV20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371114", + "title": "Graduality and parametricity: together again for the first time", + "abstract": "Parametric polymorphism and gradual typing have proven to be a difficult combination, with no language yet produced that satisfies the fundamental theorems of each: parametricity and graduality. Notably, Toro, Labrada, and Tanter (POPL 2019) conjecture that for any gradual extension of System F that uses dynamic type generation, graduality and parametricity are ``simply incompatible''. However, we argue that it is not graduality and parametricity that are incompatible per se, but instead that combining the syntax of System F with dynamic type generation as in previous work necessitates type-directed computation, which we show has been a common source of graduality and parametricity violations in previous work. We then show that by modifying the syntax of universal and existential types to make the type name generation explicit, we remove the need for type-directed computation, and get a language that satisfies both graduality and parametricity theorems. The language has a simple runtime semantics, which can be explained by translation to a statically typed language where the dynamic type is interpreted as a dynamically extensible sum type. Far from being in conflict, we show that the parametricity theorem follows as a direct corollary of a relational interpretation of the graduality property.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371114", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Max S.", + "last_name": "New", + "institution": "Northeastern University" + }, + { + "first_name": "Dustin", + "last_name": "Jamner", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/NewJA20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371136", + "title": "Pointer life cycle types for lock-free data structures with memory reclamation", + "abstract": "We consider the verification of lock-free data structures that manually manage their memory with the help of a safe memory reclamation (SMR) algorithm. Our first contribution is a type system that checks whether a program properly manages its memory. If the type check succeeds, it is safe to ignore the SMR algorithm and consider the program under garbage collection. Intuitively, our types track the protection of pointers as guaranteed by the SMR algorithm. There are two design decisions. The type system does not track any shape information, which makes it extremely lightweight. Instead, we rely on invariant annotations that postulate a protection by the SMR. To this end, we introduce angels, ghost variables with an angelic semantics. Moreover, the SMR algorithm is not hard-coded but a parameter of the type system definition. To achieve this, we rely on a recent specification language for SMR algorithms. Our second contribution is to automate the type inference and the invariant check. For the type inference, we show a quadratic-time algorithm. For the invariant check, we give a source-to-source translation that links our programs to off-the-shelf verification tools. It compiles away the angelic semantics. This allows us to infer appropriate annotations automatically in a guess-and-check manner. To demonstrate the effectiveness of our type-based verification approach, we check linearizability for various list and set implementations from the literature with both hazard pointers and epoch-based memory reclamation. For many of the examples, this is the first time they are verified automatically. For the ones where there is a competitor, we obtain a speed-up of up to two orders of magnitude.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371136", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Sebastian", + "last_name": "Wolff", + "institution": "Technische Universität Braunschweig" + } + ], + "dblp_key": "journals/pacmpl/MeyerW20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371085", + "title": "Fast, sound, and effectively complete dynamic race prediction", + "abstract": "Writing concurrent programs is highly error-prone due to the nondeterminism in interprocess communication. The most reliable indicators of errors in concurrency are data races , which are accesses to a shared resource that can be executed concurrently. We study the problem of predicting data races in lock-based concurrent programs. The input consists of a concurrent trace t , and the task is to determine all pairs of events of t that constitute a data race. The problem lies at the heart of concurrent verification and has been extensively studied for over three decades. However, existing polynomial-time sound techniques are highly incomplete and can miss simple races. In this work we develop M 2: a new polynomial-time algorithm for this problem, which has no false positives. In addition, our algorithm is complete for input traces that consist of two processes, i.e., it provably detects all races in the trace. We also develop sufficient criteria for detecting completeness dynamically in cases of more than two processes. We make an experimental evaluation of our algorithm on a challenging set of benchmarks taken from recent literature on the topic. Our algorithm soundly reports hundreds of real races, many of which are missed by existing methods. In addition, using our dynamic completeness criteria, M 2 concludes that it has detected all races in the benchmark set, hence the reports are both sound and complete. Finally, its running times are comparable, and often smaller than the theoretically fastest, yet highly incomplete, existing methods. To our knowledge, M 2 is the first sound algorithm that achieves such a level of performance on both running time and completeness of the reported races.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371085", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/Pavlogiannis20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371130", + "title": "Provenance-guided synthesis of Datalog programs", + "abstract": "We propose a new approach to synthesize Datalog programs from input-output specifications. Our approach leverages query provenance to scale the counterexample-guided inductive synthesis (CEGIS) procedure for program synthesis. In each iteration of the procedure, a SAT solver proposes a candidate Datalog program, and a Datalog solver evaluates the proposed program to determine whether it meets the desired specification. Failure to satisfy the specification results in additional constraints to the SAT solver. We propose efficient algorithms to learn these constraints based on “ why ” and “ why not ” provenance information obtained from the Datalog solver. We have implemented our approach in a tool called ProSynth and present experimental results that demonstrate significant improvements over the state-of-the-art, including in synthesizing invented predicates, reducing running times, and in decreasing variances in synthesis performance. On a suite of 40 synthesis tasks from three different domains, ProSynth is able to synthesize the desired program in 10 seconds on average per task—an order of magnitude faster than baseline approaches—and takes only under a second each for 28 of them.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371130", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "University of Southern California" + }, + { + "first_name": "Jonathan", + "last_name": "Mendelson", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "David", + "last_name": "Zhao", + "institution": "University of Sydney" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Bernhard", + "last_name": "Scholz", + "institution": "University of Sydney" + } + ], + "dblp_key": "journals/pacmpl/RaghothamanMZNS20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371126", + "title": "The fire triangle: how to mix substitution, dependent elimination, and effects", + "abstract": "There is a critical tension between substitution, dependent elimination and effects in type theory. In this paper, we crystallize this tension in the form of a no-go theorem that constitutes the fire triangle of type theory. To release this tension, we propose ∂CBPV, an extension of call-by-push-value (CBPV) —a general calculus of effects—to dependent types. Then, by extending to ∂CBPV the well-known decompositions of call-by-name and call-by-value into CBPV, we show why, in presence of effects, dependent elimination must be restricted in call-by-name, and substitution must be restricted in call-by-value. To justify ∂CBPV and show that it is general enough to interpret many kinds of effects, we define various effectful syntactic translations from ∂CBPV to Martin-Löf type theory: the reader, weaning and forcing translations.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371126", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre-Marie", + "last_name": "Pédrot", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/PedrotT20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371079", + "title": "Persistency semantics of the Intel-x86 architecture", + "abstract": "Emerging non-volatile memory (NVM) technologies promise the durability of disks with the performance of RAM. To describe the persistency guarantees of NVM, several memory persistency models have been proposed in the literature. However, the persistency semantics of the ubiquitous x86 architecture remains unexplored to date. To close this gap, we develop the Px86 (‘persistent x86’) model, formalising the persistency semantics of Intel-x86 for the first time. We formulate Px86 both operationally and declaratively, and prove that the two characterisations are equivalent. To demonstrate the application of Px86, we develop two persistent libraries over Px86: a persistent transactional library, and a persistent variant of the Michael–Scott queue. Finally, we encode our declarative Px86 model in Alloy and use it to generate persistency litmus tests automatically.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371079", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Gil", + "last_name": "Neiger", + "institution": "Intel (United States)" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RaadWNV20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371120", + "title": "Synthesizing replacement classes", + "abstract": "We present a new technique for automatically synthesizing replacement classes. The technique starts with an original class O and a potential replacement class R, then uses R to synthesize a new class that implements the same interface and provides the same functionality as O. Critically, our technique works with a synthe- sized inter-class equivalence predicate between the states of O and R. It uses this predicate to ensure that original and synthesized methods leave corresponding O and R objects in equivalent states. The predicate therefore enables the technique to synthesize individual replacement methods in isolation while still obtain- ing a replacement class that leaves the original and replacement objects in equivalent states after arbitrarily long method invocation sequences. We have implemented the technique as part of a tool, named Mask, and evaluated it using open-source Java classes. The results highlight the effectiveness of Mask in synthesizing replacement classes.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371120", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Malavika", + "last_name": "Samak", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Deokhwan", + "last_name": "Kim", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/SamakKR20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371100", + "title": "The high-level benefits of low-level sandboxing", + "abstract": "Sandboxing is a common technique that allows low-level, untrusted components to safely interact with trusted code. However, previous work has only investigated the low-level memory isolation guarantees of sandboxing, leaving open the question of the end-to-end guarantees that sandboxing affords programmers. In this paper, we fill this gap by showing that sandboxing enables reasoning about the known concept of robust safety , i.e. , safety of the trusted code even in the presence of arbitrary untrusted code. To do this, we first present an idealized operational semantics for a language that combines trusted code with untrusted code. Sandboxing is built into our semantics. Then, we prove that safety properties of the trusted code (as enforced through a rich type system) are upheld in the presence of arbitrary untrusted code, so long as all interactions with untrusted code occur at the “any” type (a type inhabited by all values). Finally, to alleviate the burden of having to interact with untrusted code at only the “any” type, we formalize and prove safe several wrappers , which automatically convert values between the “any” type and much richer types. All our results are mechanized in the Coq proof assistant.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371100", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Tadeusz", + "last_name": "Litak", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + } + ], + "dblp_key": "journals/pacmpl/SammlerGDL20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371135", + "title": "Label-dependent session types", + "abstract": "Session types have emerged as a typing discipline for communication protocols. Existing calculi with session types come equipped with many different primitives that combine communication with the introduction or elimination of the transmitted value. We present a foundational session type calculus with a lightweight operational semantics. It fully decouples communication from the introduction and elimination of data and thus features a single communication reduction, which acts as a rendezvous between senders and receivers. We achieve this decoupling by introducing label-dependent session types, a minimalist value-dependent session type system with subtyping. The system is sufficiently powerful to simulate existing functional session type systems. Compared to such systems, label-dependent session types place fewer restrictions on the code. We further introduce primitive recursion over natural numbers at the type level, thus allowing to describe protocols whose behaviour depends on numbers exchanged in messages. An algorithmic type checking system is introduced and proved equivalent to its declarative counterpart. The new calculus showcases a novel lightweight integration of dependent types and linear typing, with has uses beyond session type systems.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371135", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + } + ], + "dblp_key": "journals/pacmpl/ThiemannV20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371091", + "title": "CompCertM: CompCert with C-assembly linking and lightweight modular verification", + "abstract": "Supporting multi-language linking such as linking C and handwritten assembly modules in the verified compiler CompCert requires a more compositional verification technique than that used in CompCert just supporting separate compilation. The two extensions, CompCertX and Compositional CompCert, supporting multi-language linking take different approaches. The former simplifies the problem by imposing restrictions that the source modules should have no mutual dependence and be verified against certain well-behaved specifications. On the other hand, the latter develops a new verification technique that directly solves the problem but at the expense of significantly increasing the verification cost. In this paper, we develop a novel lightweight verification technique, called RUSC (Refinement Under Self-related Contexts), and demonstrate how RUSC can solve the problem without any restrictions but still with low verification overhead. For this, we develop CompCertM, a full extension of the latest version of CompCert supporting multi-language linking. Moreover, we demonstrate the power of RUSC as a program verification technique by modularly verifying interesting programs consisting of C and handwritten assembly against their mathematical specifications.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371091", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Seoul National University" + }, + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Dongjoo", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Yonghyun", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/SongCKKKH20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371104", + "title": "Optimal approximate sampling from discrete probability distributions", + "abstract": "This paper addresses a fundamental problem in random variate generation: given access to a random source that emits a stream of independent fair bits, what is the most accurate and entropy-efficient algorithm for sampling from a discrete probability distribution ( p 1 , …, p n ), where the probabilities of the output distribution ( p̂ 1 , …, p̂ n ) of the sampling algorithm must be specified using at most k bits of precision? We present a theoretical framework for formulating this problem and provide new techniques for finding sampling algorithms that are optimal both statistically (in the sense of sampling accuracy) and information-theoretically (in the sense of entropy consumption). We leverage these results to build a system that, for a broad family of measures of statistical accuracy, delivers a sampling algorithm whose expected entropy usage is minimal among those that induce the same distribution (i.e., is “entropy-optimal”) and whose output distribution ( p̂ 1 , …, p̂ n ) is a closest approximation to the target distribution ( p 1 , …, p n ) among all entropy-optimal sampling algorithms that operate within the specified k -bit precision. This optimal approximate sampler is also a closer approximation than any (possibly entropy-suboptimal) sampler that consumes a bounded amount of entropy with the specified precision, a class which includes floating-point implementations of inversion sampling and related methods found in many software libraries. We evaluate the accuracy, entropy consumption, precision requirements, and wall-clock runtime of our optimal approximate sampling algorithms on a broad set of distributions, demonstrating the ways that they are superior to existing approximate samplers and establishing that they often consume significantly fewer resources than are needed by exact samplers.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371104", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Cameron E.", + "last_name": "Freer", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin C.", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/SaadFRM20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371129", + "title": "Guarded Kleene algebra with tests: verification of uninterpreted programs in nearly linear time", + "abstract": "Guarded Kleene Algebra with Tests (GKAT) is a variation on Kleene Algebra with Tests (KAT) that arises by restricting the union (+) and iteration (*) operations from KAT to predicate-guarded versions. We develop the (co)algebraic theory of GKAT and show how it can be efficiently used to reason about imperative programs. In contrast to KAT, whose equational theory is PSPACE-complete, we show that the equational theory of GKAT is (almost) linear time. We also provide a full Kleene theorem and prove completeness for an analogue of Salomaa’s axiomatization of Kleene Algebra.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371129", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steffen", + "last_name": "Smolka", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "University College London" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/SmolkaFHKKS20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371076", + "title": "Coq Coq correct! verification of type checking and erasure for Coq, in Coq", + "abstract": "Coq is built around a well-delimited kernel that perfoms typechecking for definitions in a variant of the Calculus of Inductive Constructions (CIC). Although the metatheory of CIC is very stable and reliable, the correctness of its implementation in Coq is less clear. Indeed, implementing an efficient type checker for CIC is a rather complex task, and many parts of the code rely on implicit invariants which can easily be broken by further evolution of the code. Therefore, on average, one critical bug has been found every year in Coq. This paper presents the first implementation of a type checker for the kernel of Coq (without the module system and template polymorphism), which is proven correct in Coq with respect to its formal specification and axiomatisation of part of its metatheory. Note that because of Gödel's incompleteness theorem, there is no hope to prove completely the correctness of the specification of Coq inside Coq (in particular strong normalisation or canonicity), but it is possible to prove the correctness of the implementation assuming the correctness of the specification, thus moving from a trusted code base (TCB) to a trusted theory base (TTB) paradigm. Our work is based on the MetaCoq project which provides metaprogramming facilities to work with terms and declarations at the level of this kernel. Our type checker is based on the specification of the typing relation of the Polymorphic, Cumulative Calculus of Inductive Constructions (PCUIC) at the basis of Coq and the verification of a relatively efficient and sound type-checker for it. In addition to the kernel implementation, an essential feature of Coq is the so-called extraction: the production of executable code in functional languages from Coq definitions. We present a verified version of this subtle type-and-proof erasure step, therefore enabling the verified extraction of a safe type-checker for Coq.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371076", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Université Paris Cité" + }, + { + "first_name": "Simon", + "last_name": "Boulier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Yannick", + "last_name": "Forster", + "institution": "Saarland University" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/SozeauBFTW20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371101", + "title": "Spy game: verifying a local generic solver in Iris", + "abstract": "We verify the partial correctness of a \"local generic solver\", that is, an on-demand, incremental, memoizing least fixed point computation algorithm. The verification is carried out in Iris, a modern breed of concurrent separation logic. The specification is simple: the solver computes the optimal least fixed point of a system of monotone equations. Although the solver relies on mutable internal state for memoization and for \"spying\", a form of dynamic dependency discovery, it is apparently pure: no side effects are mentioned in its specification. As auxiliary contributions, we provide several illustrations of the use of prophecy variables, a novel feature of Iris; we establish a restricted form of the infinitary conjunction rule; and we provide a specification and proof of Longley's modulus function, an archetypical example of spying.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371101", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paulo Emílio de", + "last_name": "Vilhena", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Laboratoire de Recherche en Informatique" + } + ], + "dblp_key": "journals/pacmpl/VilhenaPJ20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371093", + "title": "Proving expected sensitivity of probabilistic programs with randomized variable-dependent termination time", + "abstract": "The notion of program sensitivity (aka Lipschitz continuity) specifies that changes in the program input result in proportional changes to the program output. For probabilistic programs the notion is naturally extended to expected sensitivity. A previous approach develops a relational program logic framework for proving expected sensitivity of probabilistic while loops, where the number of iterations is fixed and bounded. In this work, we consider probabilistic while loops where the number of iterations is not fixed, but randomized and depends on the initial input values. We present a sound approach for proving expected sensitivity of such programs. Our sound approach is martingale-based and can be automated through existing martingale-synthesis algorithms. Furthermore, our approach is compositional for sequential composition of while loops under a mild side condition. We demonstrate the effectiveness of our approach on several classical examples from Gambler's Ruin, stochastic hybrid systems and stochastic gradient descent. We also present experimental results showing that our automated approach can handle various probabilistic programs in the literature.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371093", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peixin", + "last_name": "Wang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Yuxin", + "last_name": "Deng", + "institution": "East China Normal University" + }, + { + "first_name": "Ming", + "last_name": "Xu", + "institution": "East China Normal University" + } + ], + "dblp_key": "journals/pacmpl/WangFCDX20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371117", + "title": "Visualization by example", + "abstract": "While visualizations play a crucial role in gaining insights from data, generating useful visualizations from a complex dataset is far from an easy task. In particular, besides understanding the functionality provided by existing visualization libraries, generating the desired visualization also requires reshaping and aggregating the underlying data as well as composing different visual elements to achieve the intended visual narrative. This paper aims to simplify visualization tasks by automatically synthesizing the required program from simple visual sketches provided by the user. Specifically, given an input data set and a visual sketch that demonstrates how to visualize a very small subset of this data, our technique automatically generates a program that can be used to visualize the entire data set. From a program synthesis perspective, automating visualization tasks poses several challenges that are not addressed by prior techniques. First, because many visualization tasks require data wrangling in addition to generating plots from a given table, we need to decompose the end-to-end synthesis task into two separate sub-problems. Second, because the intermediate specification that results from the decomposition is necessarily imprecise, this makes the data wrangling task particularly challenging in our context. In this paper, we address these problems by developing a new compositional visualization-by-example technique that (a) decomposes the end-to-end task into two different synthesis problems over different DSLs and (b) leverages bi-directional program analysis to deal with the complexity that arises from having an imprecise intermediate specification. We have implemented our visualization-by-example approach in a tool called Viser and evaluate it on over 80 visualization tasks collected from on-line forums and tutorials. Viser can solve 84 of these benchmarks within a 600 second time limit, and, for those tasks that can be solved, the desired visualization is among the top-5 generated by Viser in 70% of the cases.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371117", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chenglong", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/WangFBCD20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371107", + "title": "PλωNK: functional probabilistic NetKAT", + "abstract": "This work presents PλωNK, a functional probabilistic network programming language that extends Probabilistic NetKAT (PNK). Like PNK, it enables probabilistic modelling of network behaviour, by providing probabilistic choice and infinite iteration (to simulate looping network packets). Yet, unlike PNK, it also offers abstraction and higher-order functions to make programming much more convenient. The formalisation of PλωNK is challenging for two reasons: Firstly, network programming induces multiple side effects (in particular, parallelism and probabilistic choice) which need to be carefully controlled in a functional setting. Our system uses an explicit syntax for thunks and sequencing which makes the interplay of these effects explicit. Secondly, measure theory, the standard domain for formalisations of (continuous) probablistic languages, does not admit higher-order functions. We address this by leveraging ω-Quasi Borel Spaces (ωQBSes), a recent advancement in the domain theory of probabilistic programming languages. We believe that our work is not only useful for bringing abstraction to PNK, but that—as part of our contribution—we have developed the meta-theory for a probabilistic language that combines advanced features like higher-order functions, iteration and parallelism, which may inform similar meta-theoretic efforts.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371107", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Vandenbroucke", + "institution": "KU Leuven" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/VandenbrouckeS20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371115", + "title": "Disentanglement in nested-parallel programs", + "abstract": "Nested parallelism has proved to be a popular approach for programming the rapidly expanding range of multicore computers. It allows programmers to express parallelism at a high level and relies on a run-time system and a scheduler to deliver efficiency and scalability. As a result, many programming languages and extensions that support nested parallelism have been developed, including in C/C++, Java, Haskell, and ML. Yet, writing efficient and scalable nested parallel programs remains challenging, primarily due to difficult concurrency bugs arising from destructive updates or effects. For decades, researchers have argued that functional programming can simplify writing parallel programs by allowing more control over effects but functional programs continue to underperform in comparison to parallel programs written in lower-level languages. The fundamental difficulty with functional languages is that they have high demand for memory, and this demand only grows with parallelism. In this paper, we identify a memory property, called disentanglement, of nested-parallel programs, and propose memory management techniques for improved efficiency and scalability. Disentanglement allows for (destructive) effects as long as concurrently executing threads do not gain knowledge of the memory objects allocated by each other. We formally define disentanglement by considering an ML-like higher-order language with mutable references and presenting a dynamic semantics for it that enables reasoning about computation graphs of nested parallel programs. Based on this graph semantics, we formalize a classic correctness property---determinacy race freedom---and prove that it implies disentanglement. This establishes that disentanglement applies to a relatively broad class of parallel programs. We then propose memory management techniques for nested-parallel programs that take advantage of disentanglement for improved efficiency and scalability. We show that these techniques are practical by extending the MLton compiler for Standard ML to support this form of nested parallelism. Our empirical evaluation shows that our techniques are efficient and scale well.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371115", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Rohan", + "last_name": "Yadav", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/WestrickYFA20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371119", + "title": "Interaction trees: representing recursive and impure programs in Coq", + "abstract": "Interaction trees (ITrees) are a general-purpose data structure for representing the behaviors of recursive programs that interact with their environments. A coinductive variant of “free monads,” ITrees are built out of uninterpreted events and their continuations. They support compositional construction of interpreters from event handlers , which give meaning to events by defining their semantics as monadic actions. ITrees are expressive enough to represent impure and potentially nonterminating, mutually recursive computations, while admitting a rich equational theory of equivalence up to weak bisimulation. In contrast to other approaches such as relationally specified operational semantics, ITrees are executable via code extraction, making them suitable for debugging, testing, and implementing software artifacts that are amenable to formal verification. We have implemented ITrees and their associated theory as a Coq library, mechanizing classic domain- and category-theoretic results about program semantics, iteration, monadic structures, and equational reasoning. Although the internals of the library rely heavily on coinductive proofs, the interface hides these details so that clients can use and reason about ITrees without explicit use of Coq’s coinduction tactics. To showcase the utility of our theory, we prove the termination-sensitive correctness of a compiler from a simple imperative source language to an assembly-like target whose meanings are given in an ITree-based denotational semantics. Unlike previous results using operational techniques, our bisimulation proof follows straightforwardly by structural induction and elementary rewriting via an equational theory of combinators for control-flow graphs.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371119", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Li-yao", + "last_name": "Xia", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Paul", + "last_name": "He", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Gregory", + "last_name": "Malecha", + "institution": "" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/XiaZHHMPZ20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371121", + "title": "Kind inference for datatypes", + "abstract": "In recent years, languages like Haskell have seen a dramatic surge of new features that significantly extends the expressive power of their type systems. With these features, the challenge of kind inference for datatype declarations has presented itself and become a worthy research problem on its own. This paper studies kind inference for datatypes. Inspired by previous research on type-inference, we offer declarative specifications for what datatype declarations should be accepted, both for Haskell98 and for a more advanced system we call PolyKinds, based on the extensions in modern Haskell, including a limited form of dependent types. We believe these formulations to be novel and without precedent, even for Haskell98. These specifications are complemented with implementable algorithmic versions. We study soundness, completeness and the existence of principal kinds in these systems, proving the properties where they hold. This work can serve as a guide both to language designers who wish to formalize their datatype declarations and also to implementors keen to have principled inference of principal types. This technical supplement to Kind Inference for Datatypes serves to expand upon the text in the main paper. It contains detailed typing rules, proofs, and connections to the Glasgow Haskell Compiler (GHC).", + "date": "2019-11-11", + "link": "https://doi.org/10.1145/3371121", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/XieEO20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371128", + "title": "Detecting floating-point errors via atomic conditions", + "abstract": "This paper tackles the important, difficult problem of detecting program inputs that trigger large floating-point errors in numerical code. It introduces a novel, principled dynamic analysis that leverages the mathematically rigorously analyzed condition numbers for atomic numerical operations, which we call atomic conditions , to effectively guide the search for large floating-point errors. Compared with existing approaches, our work based on atomic conditions has several distinctive benefits: (1) it does not rely on high-precision implementations to act as approximate oracles, which are difficult to obtain in general and computationally costly; and (2) atomic conditions provide accurate, modular search guidance. These benefits in combination lead to a highly effective approach that detects more significant errors in real-world code (e.g., widely-used numerical library functions) and achieves several orders of speedups over the state-of-the-art, thus making error analysis significantly more practical. We expect the methodology and principles behind our approach to benefit other floating-point program analysis tasks such as debugging, repair and synthesis. To facilitate the reproduction of our work, we have made our implementation, evaluation data and results publicly available on GitHub at <a>https://github.com/FP-Analysis/atomic-condition</a>.", + "date": "2019-12-20", + "link": "https://doi.org/10.1145/3371128", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daming", + "last_name": "Zou", + "institution": "Peking University" + }, + { + "first_name": "Muhan", + "last_name": "Zeng", + "institution": "Peking University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Zhoulai", + "last_name": "Fu", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Lu", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/ZouZXFZS20", + "venue": "popl", + "year": 2020 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2021.json b/data/pl_conferences/popl/2021.json new file mode 100644 index 0000000..b754bc8 --- /dev/null +++ b/data/pl_conferences/popl/2021.json @@ -0,0 +1,1890 @@ +[ + { + "paper_id": "10.1145/3434333", + "title": "A pre-expectation calculus for probabilistic sensitivity", + "abstract": "Sensitivity properties describe how changes to the input of a program affect the output, typically by upper bounding the distance between the outputs of two runs by a monotone function of the distance between the corresponding inputs. When programs are probabilistic, the distance between outputs is a distance between distributions. The Kantorovich lifting provides a general way of defining a distance between distributions by lifting the distance of the underlying sample space; by choosing an appropriate distance on the base space, one can recover other usual probabilistic distances, such as the Total Variation distance. We develop a relational pre-expectation calculus to upper bound the Kantorovich distance between two executions of a probabilistic program. We illustrate our methods by proving algorithmic stability of a machine learning algorithm, convergence of a reinforcement learning algorithm, and fast mixing for card shuffling algorithms. We also consider some extensions: using our calculus to show convergence of Markov chains to the uniform distribution over states and an asynchronous extension to reason about pairs of program executions with different control flow.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434333", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/0001BHKKM21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434325", + "title": "Context-bounded verification of liveness properties for multithreaded shared-memory programs", + "abstract": "We study context-bounded verification of liveness properties of multi-threaded, shared-memory programs, where each thread can spawn additional threads. Our main result shows that context-bounded fair termination is decidable for the model; context-bounded implies that each spawned thread can be context switched a fixed constant number of times. Our proof is technical, since fair termination requires reasoning about the composition of unboundedly many threads each with unboundedly large stacks. In fact, techniques for related problems, which depend crucially on replacing the pushdown threads with finite-state threads, are not applicable. Instead, we introduce an extension of vector addition systems with states (VASS), called VASS with balloons (VASSB), as an intermediate model; it is an infinite-state model of independent interest. A VASSB allows tokens that are themselves markings (balloons). We show that context bounded fair termination reduces to fair termination for VASSB. We show the latter problem is decidable by showing a series of reductions: from fair termination to configuration reachability for VASSB and thence to the reachability problem for VASS. For a lower bound, fair termination is known to be non-elementary already in the special case where threads run to completion (no context switches). We also show that the simpler problem of context-bounded termination is 2EXPSPACE-complete, matching the complexity bound---and indeed the techniques---for safety verification. Additionally, we show the related problem of fair starvation, which checks if some thread can be starved along a fair run, is also decidable in the context-bounded case. The decidability employs an intricate reduction from fair starvation to fair termination. Like fair termination, this problem is also non-elementary.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434325", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pascal", + "last_name": "Baumann", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ramanathan S.", + "last_name": "Thinniyam", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/BaumannMTZ21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434293", + "title": "Internalizing representation independence with univalence", + "abstract": "In their usual form, representation independence metatheorems provide an external guarantee that two implementations of an abstract interface are interchangeable when they are related by an operation-preserving correspondence. If our programming language is dependently-typed, however, we would like to appeal to such invariance results within the language itself, in order to obtain correctness theorems for complex implementations by transferring them from simpler, related implementations. Recent work in proof assistants has shown that Voevodsky's univalence principle allows transferring theorems between isomorphic types, but many instances of representation independence in programming involve non-isomorphic representations. In this paper, we develop techniques for establishing internal relational representation independence results in dependent type theory, by using higher inductive types to simultaneously quotient two related implementation types by a heterogeneous correspondence between them. The correspondence becomes an isomorphism between the quotiented types, thereby allowing us to obtain an equality of implementations by univalence. We illustrate our techniques by considering applications to matrices, queues, and finite multisets. Our results are all formalized in Cubical Agda, a recent extension of Agda which supports univalence and higher inductive types in a computationally well-behaved way.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434293", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Carlo", + "last_name": "Angiuli", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Evan", + "last_name": "Cavallo", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Anders", + "last_name": "Mörtberg", + "institution": "Stockholm University" + }, + { + "first_name": "Max", + "last_name": "Zeuner", + "institution": "Stockholm University" + } + ], + "dblp_key": "journals/pacmpl/AngiuliCMZ21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434295", + "title": "Generating collection transformations from proofs", + "abstract": "Nested relations, built up from atomic types via product and set types, form a rich data model. Over the last decades the nested relational calculus, NRC, has emerged as a standard language for defining transformations on nested collections. NRC is a strongly-typed functional language which allows building up transformations using tupling and projections, a singleton-former, and a map operation that lifts transformations on tuples to transformations on sets. In this work we describe an alternative declarative method of describing transformations in logic. A formula with distinguished inputs and outputs gives an implicit definition if one can prove that for each input there is only one output that satisfies it. Our main result shows that one can synthesize transformations from proofs that a formula provides an implicit definition, where the proof is in an intuitionistic calculus that captures a natural style of reasoning about nested collections. Our polynomial time synthesis procedure is based on an analog of Craig's interpolation lemma, starting with a provable containment between terms representing nested collections and generating an NRC expression that interpolates between them. We further show that NRC expressions that implement an implicit definition can be found when there is a classical proof of functionality, not just when there is an intuitionistic one. That is, whenever a formula implicitly defines a transformation, there is an NRC expression that implements it.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434295", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Benedikt", + "institution": "University of Oxford" + }, + { + "first_name": "Pierre", + "last_name": "Pradic", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/BenediktP21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434289", + "title": "Deciding accuracy of differential privacy schemes", + "abstract": "Differential privacy is a mathematical framework for developing statistical computations with provable guarantees of privacy and accuracy. In contrast to the privacy component of differential privacy, which has a clear mathematical and intuitive meaning, the accuracy component of differential privacy does not have a generally accepted definition; accuracy claims of differential privacy algorithms vary from algorithm to algorithm and are not instantiations of a general definition. We identify program discontinuity as a common theme in existing ad hoc definitions and introduce an alternative notion of accuracy parametrized by, what we call, — the of an input x w.r.t. a deterministic computation f and a distance d , is the minimal distance d ( x , y ) over all y such that f ( y )≠ f ( x ). We show that our notion of accuracy subsumes the definition used in theoretical computer science, and captures known accuracy claims for differential privacy algorithms. In fact, our general notion of accuracy helps us prove better claims in some cases. Next, we study the decidability of accuracy. We first show that accuracy is in general undecidable. Then, we define a non-trivial class of probabilistic computations for which accuracy is decidable (unconditionally, or assuming Schanuel’s conjecture). We implement our decision procedure and experimentally evaluate the effectiveness of our approach for generating proofs or counterexamples of accuracy for common algorithms from the literature.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434289", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Rohit", + "last_name": "Chadha", + "institution": "University of Missouri" + }, + { + "first_name": "Paul", + "last_name": "Krogmeier", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "A. Prasad", + "last_name": "Sistla", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/BartheCKS021", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434320", + "title": "Relatively complete verification of probabilistic programs: an expressive language for expectation-based reasoning", + "abstract": "We study a syntax for specifying quantitative assertions —functions mapping program states to numbers—for probabilistic program verification. We prove that our syntax is expressive in the following sense: Given any probabilistic program C , if a function f is expressible in our syntax, then the function mapping each initial state σ to the expected value of evaluated in the final states reached after termination of C on σ (also called the weakest preexpectation wp[ C ]( f )) is also expressible in our syntax. As a consequence, we obtain a relatively complete verification system for reasoning about expected values and probabilities in the sense of Cook: Apart from proving a single inequality between two functions given by syntactic expressions in our language, given f , g , and C , we can check whether g ≼ wp[ C ]( f ).", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434320", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/BatzKKM21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434317", + "title": "Optimal prediction of synchronization-preserving races", + "abstract": "Concurrent programs are notoriously hard to write correctly, as scheduling nondeterminism introduces subtle errors that are both hard to detect and to reproduce. The most common concurrency errors are (data) races, which occur when memory-conflicting actions are executed concurrently. Consequently, considerable effort has been made towards developing efficient techniques for race detection. The most common approach is dynamic race prediction: given an observed, race-free trace σ of a concurrent program, the task is to decide whether events of σ can be correctly reordered to a trace σ * that witnesses a race hidden in σ. In this work we introduce the notion of sync(hronization)-preserving races. A sync-preserving race occurs in σ when there is a witness σ * in which synchronization operations (e.g., acquisition and release of locks) appear in the same order as in σ. This is a broad definition that strictly subsumes the famous notion of happens-before races. Our main results are as follows. First, we develop a sound and complete algorithm for predicting sync-preserving races. For moderate values of parameters like the number of threads, the algorithm runs in Õ( N ) time and space, where N is the length of the trace σ. Second, we show that the problem has a Ω( N /log 2 N ) space lower bound, and thus our algorithm is essentially time and space optimal. Third, we show that predicting races with even just a single reversal of two sync operations is NP-complete and even W1-hard when parameterized by the number of threads. Thus, sync-preservation characterizes exactly the tractability boundary of race prediction, and our algorithm is nearly optimal for the tractable side. Our experiments show that our algorithm is fast in practice, while sync-preservation characterizes races often missed by state-of-the-art methods.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434317", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/0001P021", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434329", + "title": "Deciding ω-regular properties on linear recurrence sequences", + "abstract": "We consider the problem of deciding ω-regular properties on infinite traces produced by linear loops. Here we think of a given loop as producing a single infinite trace that encodes information about the signs of program variables at each time step. Formally, our main result is a procedure that inputs a prefix-independent ω-regular property and a sequence of numbers satisfying a linear recurrence, and determines whether the sign description of the sequence (obtained by replacing each positive entry with “+”, each negative entry with “−”, and each zero entry with “0”) satisfies the given property. Our procedure requires that the recurrence be simple, i.e., that the update matrix of the underlying loop be diagonalisable. This assumption is instrumental in proving our key technical lemma: namely that the sign description of a simple linear recurrence sequence is almost periodic in the sense of Muchnik, Sem'enov, and Ushakov. To complement this lemma, we give an example of a linear recurrence sequence whose sign description fails to be almost periodic. Generalising from sign descriptions, we also consider the verification of properties involving semi-algebraic predicates on program variables.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434329", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shaull", + "last_name": "Almagor", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Toghrul", + "last_name": "Karimov", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Edon", + "last_name": "Kelmendi", + "institution": "University of Oxford" + }, + { + "first_name": "Joël", + "last_name": "Ouaknine", + "institution": "University of Oxford" + }, + { + "first_name": "James", + "last_name": "Worrell", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/AlmagorKKO021", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434305", + "title": "Asynchronous effects", + "abstract": "We explore asynchronous programming with algebraic effects. We complement their conventional synchronous treatment by showing how to naturally also accommodate asynchrony within them, namely, by decoupling the execution of operation calls into signalling that an operation’s implementation needs to be executed, and interrupting a running computation with the operation’s result, to which the computation can react by installing interrupt handlers. We formalise these ideas in a small core calculus, called λ æ . We demonstrate the flexibility of λ æ using examples ranging from a multi-party web application, to preemptive multi-threading, to remote function calls, to a parallel variant of runners of algebraic effects. In addition, the paper is accompanied by a formalisation of λ æ ’s type safety proofs in Agda, and a prototype implementation of λ æ in OCaml.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434305", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "University of Ljubljana" + }, + { + "first_name": "Matija", + "last_name": "Pretnar", + "institution": "University of Ljubljana" + } + ], + "dblp_key": "journals/pacmpl/AhmanP21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434290", + "title": "A computational interpretation of compact closed categories: reversible programming with negative and fractional types", + "abstract": "Compact closed categories include objects representing higher-order functions and are well-established as models of linear logic, concurrency, and quantum computing. We show that it is possible to construct such compact closed categories for conventional sum and product types by defining a dual to sum types, a negative type, and a dual to product types, a fractional type. Inspired by the categorical semantics, we define a sound operational semantics for negative and fractional types in which a negative type represents a computational effect that ``reverses execution flow'' and a fractional type represents a computational effect that ``garbage collects'' particular values or throws exceptions. Specifically, we extend a first-order reversible language of type isomorphisms with negative and fractional types, specify an operational semantics for each extension, and prove that each extension forms a compact closed category. We furthermore show that both operational semantics can be merged using the standard combination of backtracking and exceptions resulting in a smooth interoperability of negative and fractional types. We illustrate the expressiveness of this combination by writing a reversible SAT solver that uses backtracking search along freshly allocated and de-allocated locations. The operational semantics, most of its meta-theoretic properties, and all examples are formalized in a supplementary Agda package.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434290", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chao-Hong", + "last_name": "Chen", + "institution": "Indiana University" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/ChenS21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434337", + "title": "Deciding reachability under persistent x86-TSO", + "abstract": "We address the problem of verifying the reachability problem in programs running under the formal model Px86 defined recently by Raad et al. in POPL'20 for the persistent Intel x86 architecture. We prove that this problem is decidable. To achieve that, we provide a new formal model that is equivalent to Px86 and that has the feature of being a well structured system. Deriving this new model is the result of a deep investigation of the properties of Px86 and the interplay of its components.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434337", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Université Paris Cité" + }, + { + "first_name": "K. Narayan", + "last_name": "Kumar", + "institution": "Chennai Mathematical Institute" + }, + { + "first_name": "Prakash", + "last_name": "Saivasan", + "institution": "Institute of Mathematical Sciences" + } + ], + "dblp_key": "journals/pacmpl/AbdullaABKS21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434327", + "title": "Formally verified speculation and deoptimization in a JIT compiler", + "abstract": "Just-in-time compilers for dynamic languages routinely generate code under assumptions that may be invalidated at run-time, this allows for specialization of program code to the common case in order to avoid unnecessary overheads due to uncommon cases. This form of software speculation requires support for deoptimization when some of the assumptions fail to hold. This paper presents a model just-in-time compiler with an intermediate representation that explicits the synchronization points used for deoptimization and the assumptions made by the compiler's speculation. We also present several common compiler optimizations that can leverage speculation to generate improved code. The optimizations are proved correct with the help of a proof assistant. While our work stops short of proving native code generation, we demonstrate how one could use the verified optimization to obtain significant speed ups in an end-to-end setting.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434327", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aurèle", + "last_name": "Barrière", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Olivier", + "last_name": "Flückiger", + "institution": "Northeastern University" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/BarriereBFPV21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434283", + "title": "Diamonds are not forever: liveness in reactive programming with guarded recursion", + "abstract": "When designing languages for functional reactive programming (FRP) the main challenge is to provide the user with a simple, flexible interface for writing programs on a high level of abstraction while ensuring that all programs can be implemented efficiently in a low-level language. To meet this challenge, a new family of modal FRP languages has been proposed, in which variants of Nakano's guarded fixed point operator are used for writing recursive programs guaranteeing properties such as causality and productivity. As an apparent extension to this it has also been suggested to use Linear Temporal Logic (LTL) as a language for reactive programming through the Curry-Howard isomorphism, allowing properties such as termination, liveness and fairness to be encoded in types. However, these two ideas are in conflict with each other, since the fixed point operator introduces non-termination into the inductive types that are supposed to provide termination guarantees. In this paper we show that by regarding the modal time step operator of LTL a submodality of the one used for guarded recursion (rather than equating them), one can obtain a modal type system capable of expressing liveness properties while retaining the power of the guarded fixed point operator. We introduce the language Lively RaTT, a modal FRP language with a guarded fixed point operator and an `until' type constructor as in LTL, and show how to program with events and fair streams. Using a step-indexed Kripke logical relation we prove operational properties of Lively RaTT including productivity and causality as well as the termination and liveness properties expected of types from LTL. Finally, we prove that the type system of Lively RaTT guarantees the absence of implicit space leaks.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434283", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Bahr", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Christian Uldal", + "last_name": "Graulund", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Rasmus Ejlers", + "last_name": "Møgelberg", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/BahrGM21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434332", + "title": "The (In)Efficiency of interaction", + "abstract": "Evaluating higher-order functional programs through abstract machines inspired by the geometry of the interaction is known to induce space efficiencies, the price being time performances often poorer than those obtainable with traditional, environment-based, abstract machines. Although families of lambda-terms for which the former is exponentially less efficient than the latter do exist, it is currently unknown how general this phenomenon is, and how far the inefficiencies can go, in the worst case. We answer these questions formulating four different well-known abstract machines inside a common definitional framework, this way being able to give sharp results about the relative time efficiencies. We also prove that non-idempotent intersection type theories are able to precisely reflect the time performances of the interactive abstract machine, this way showing that its time-inefficiency ultimately descends from the presence of higher-order types.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434332", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "École Polytechnique" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Gabriele", + "last_name": "Vanoni", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/AccattoliLV21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434331", + "title": "A graded dependent type system with a usage-aware semantics", + "abstract": "Graded Type Theory provides a mechanism to track and reason about resource usage in type systems. In this paper, we develop GraD, a novel version of such a graded dependent type system that includes functions, tensor products, additive sums, and a unit type. Since standard operational semantics is resource-agnostic, we develop a heap-based operational semantics and prove a soundness theorem that shows correct accounting of resource usage. Several useful properties, including the standard type soundness theorem, non-interference of irrelevant resources in computation and single pointer property for linear resources, can be derived from this theorem. We hope that our work will provide a base for integrating linearity, irrelevance and dependent types in practical programming languages like Haskell.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434331", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pritam", + "last_name": "Choudhury", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Harley", + "last_name": "Eades", + "institution": "Augusta University" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/ChoudhuryEEW21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434299", + "title": "Provably space-efficient parallel functional programming", + "abstract": "Because of its many desirable properties, such as its ability to control effects and thus potentially disastrous race conditions, functional programming offers a viable approach to programming modern multicore computers. Over the past decade several parallel functional languages, typically based on dialects of ML and Haskell, have been developed. These languages, however, have traditionally underperformed procedural languages (such as C and Java). The primary reason for this is their hunger for memory, which only grows with parallelism, causing traditional memory management techniques to buckle under increased demand for memory. Recent work opened a new angle of attack on this problem by identifying a memory property of determinacy-race-free parallel programs, called disentanglement, which limits the knowledge of concurrent computations about each other’s memory allocations. The work has showed some promise in delivering good time scalability. In this paper, we present provably space-efficient automatic memory management techniques for determinacy-race-free functional parallel programs, allowing both pure and imperative programs where memory may be destructively updated. We prove that for a program with sequential live memory of R * , any P -processor garbage-collected parallel run requires at most O ( R * · P ) memory. We also prove a work bound of O ( W + R * P ) for P -processor executions, accounting also for the cost of garbage collection. To achieve these results, we integrate thread scheduling with memory management. The idea is to coordinate memory allocation and garbage collection with thread scheduling decisions so that each processor can allocate memory without synchronization and independently collect a portion of memory by consulting a collection policy, which we formulate. The collection policy is fully distributed and does not require communicating with other processors. We show that the approach is practical by implementing it as an extension to the MPL compiler for Parallel ML. Our experimental results confirm our theoretical bounds and show that the techniques perform and scale well.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434299", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jatin", + "last_name": "Arora", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/0002WA21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434341", + "title": "The taming of the rew: a type theory with computational assumptions", + "abstract": "Dependently typed programming languages and proof assistants such as Agda and Coq rely on computation to automatically simplify expressions during type checking. To overcome the lack of certain programming primitives or logical principles in those systems, it is common to appeal to axioms to postulate their existence. However, one can only postulate the bare existence of an axiom, not its computational behaviour. Instead, users are forced to postulate equality proofs and appeal to them explicitly to simplify expressions, making axioms dramatically more complicated to work with than built-in primitives. On the other hand, the equality reflection rule from extensional type theory solves these problems by collapsing computation and equality, at the cost of having no practical type checking algorithm. This paper introduces Rewriting Type Theory (RTT), a type theory where it is possible to add computational assumptions in the form of rewrite rules. Rewrite rules go beyond the computational capabilities of intensional type theory, but in contrast to extensional type theory, they are applied automatically so type checking does not require input from the user. To ensure type soundness of RTT—as well as effective type checking—we provide a framework where confluence of user-defined rewrite rules can be checked modularly and automatically, and where adding new rewrite rules is guaranteed to preserve subject reduction. The properties of RTT have been formally verified using the MetaCoq framework and an implementation of rewrite rules is already available in the Agda proof assistant.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434341", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jesper", + "last_name": "Cockx", + "institution": "Delft University of Technology" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "Laboratoire des Sciences du Numérique de Nantes" + } + ], + "dblp_key": "journals/pacmpl/CockxTW21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434321", + "title": "Verified code generation for the polyhedral model", + "abstract": "The polyhedral model is a high-level intermediate representation for loop nests that supports elegantly a great many loop optimizations. In a compiler, after polyhedral loop optimizations have been performed, it is necessary and difficult to regenerate sequential or parallel loop nests before continuing compilation. This paper reports on the formalization and proof of semantic preservation of such a code generator that produces sequential code from a polyhedral representation. The formalization and proofs are mechanized using the Coq proof assistant.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434321", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nathanaël", + "last_name": "Courant", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Collège de France" + } + ], + "dblp_key": "journals/pacmpl/CourantL21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434287", + "title": "Efficient and provable local capability revocation using uninitialized capabilities", + "abstract": "Capability machines are a special form of CPUs that offer fine-grained privilege separation using a form of authority-carrying values known as capabilities. The CHERI capability machine offers local capabilities, which could be used as a cheap but restricted form of capability revocation. Unfortunately, local capability revocation is unrealistic in practice because large amounts of stack memory need to be cleared as a security precaution. In this paper, we address this shortcoming by introducing uninitialized capabilities : a new form of capabilities that represent read/write authority to a block of memory without exposing the memory’s initial contents. We provide a mechanically verified program logic for reasoning about programs on a capability machine with the new feature and we formalize and prove capability safety in the form of a universal contract for untrusted code. We use uninitialized capabilities for making a previously-proposed secure calling convention efficient and prove its security using the program logic. Finally, we report on a proof-of-concept implementation of uninitialized capabilities on the CHERI capability machine.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434287", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aïna Linn", + "last_name": "Georges", + "institution": "Aarhus University" + }, + { + "first_name": "Armaël", + "last_name": "Guéneau", + "institution": "Aarhus University" + }, + { + "first_name": "Thomas Van", + "last_name": "Strydonck", + "institution": "KU Leuven" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Alix", + "last_name": "Trieu", + "institution": "Aarhus University" + }, + { + "first_name": "Sander", + "last_name": "Huyghebaert", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/GeorgesGSTTHDB21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434291", + "title": "Mechanized logical relations for termination-insensitive noninterference", + "abstract": "We present an expressive information-flow control type system with recursive types, existential types, label polymorphism, and impredicative type polymorphism for a higher-order programming language with higher-order state. We give a novel semantic model of this type system and show that well-typed programs satisfy termination-insensitive noninterference. Our semantic approach supports compositional integration of syntactically well-typed and syntactically ill-typed---but semantically sound---components, which we demonstrate through several interesting examples. We define our model using logical relations on top of the Iris program logic framework; to capture termination-insensitivity, we develop a novel language-agnostic theory of Modal Weakest Preconditions. We formalize all of our theory and examples in the Coq proof assistant.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434291", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "Aarhus University" + }, + { + "first_name": "Johan", + "last_name": "Bay", + "institution": "Aarhus University" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/GregersenBTB21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434322", + "title": "Petr4: formal foundations for p4 data planes", + "abstract": "P4 is a domain-specific language for programming and specifying packet-processing systems. It is based on an elegant design with high-level abstractions like parsers and match-action pipelines that can be compiled to efficient implementations in software or hardware. Unfortunately, like many industrial languages, P4 has developed without a formal foundation. The P4 Language Specification is a 160-page document with a mixture of informal prose, graphical diagrams, and pseudocode, leaving many aspects of the language semantics up to individual compilation targets. The P4 reference implementation is a complex system, running to over 40KLoC of C++ code, with support for only a few targets. Clearly neither of these artifacts is suitable for formal reasoning about P4 in general. This paper presents a new framework, called Petr4, that puts P4 on a solid foundation. Petr4 consists of a clean-slate definitional interpreter and a core calculus that models a fragment of P4. Petr4 is not tied to any particular target: the interpreter is parameterized over an interface that collects features delegated to targets in one place, while the core calculus overapproximates target-specific behaviors using non-determinism. We have validated the interpreter against a suite of over 750 tests from the P4 reference implementation, exercising our target interface with tests for different targets. We validated the core calculus with a proof of type-preserving termination. While developing Petr4, we reported dozens of bugs in the language specification and the reference implementation, many of which have been fixed.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434322", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Doenges", + "institution": "Cornell University" + }, + { + "first_name": "Mina Tahmasbi", + "last_name": "Arashloo", + "institution": "Cornell University" + }, + { + "first_name": "Santiago", + "last_name": "Bautista", + "institution": "École Normale Supérieure de Rennes" + }, + { + "first_name": "Alexander", + "last_name": "Chang", + "institution": "Cornell University" + }, + { + "first_name": "Newton", + "last_name": "Ni", + "institution": "Cornell University" + }, + { + "first_name": "Samwise", + "last_name": "Parkinson", + "institution": "Cornell University" + }, + { + "first_name": "Rudy", + "last_name": "Peterson", + "institution": "Cornell University" + }, + { + "first_name": "Alaia", + "last_name": "Solko-Breslin", + "institution": "Cornell University" + }, + { + "first_name": "Amanda", + "last_name": "Xu", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/DoengesABCNPPSX21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434286", + "title": "On algebraic abstractions for concurrent separation logics", + "abstract": "Concurrent separation logic is distinguished by transfer of state ownership upon parallel composition and framing. The algebraic structure that underpins ownership transfer is that of partial commutative monoids (PCMs). Extant research considers ownership transfer primarily from the logical perspective while comparatively less attention is drawn to the algebraic considerations. This paper provides an algebraic formalization of ownership transfer in concurrent separation logic by means of structure-preserving partial functions (i.e., morphisms) between PCMs, and an associated notion of separating relations. Morphisms of structures are a standard concept in algebra and category theory, but haven't seen ubiquitous use in separation logic before. Separating relations. are binary relations that generalize disjointness and characterize the inputs on which morphisms preserve structure. The two abstractions facilitate verification by enabling concise ways of writing specs, by providing abstract views of threads' states that are preserved under ownership transfer, and by enabling user-level construction of new PCMs out of existing ones.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434286", + "conference_name": "POPL", + "authors": [ + { + "first_name": "František", + "last_name": "Farka", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Germán Andrés", + "last_name": "Delbianco", + "institution": "" + }, + { + "first_name": "Ignacio", + "last_name": "Fábregas", + "institution": "Universidad Complutense de Madrid" + } + ], + "dblp_key": "journals/pacmpl/FarkaN0DF21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434296", + "title": "Learning the boundary of inductive invariants", + "abstract": "We study the complexity of invariant inference and its connections to exact concept learning. We define a condition on invariants and their geometry, called the fence condition, which permits applying theoretical results from exact concept learning to answer open problems in invariant inference theory. The condition requires the invariant's boundary---the states whose Hamming distance from the invariant is one---to be backwards reachable from the bad states in a small number of steps. Using this condition, we obtain the first polynomial complexity result for an interpolation-based invariant inference algorithm, efficiently inferring monotone DNF invariants with access to a SAT solver as an oracle. We further harness Bshouty's seminal result in concept learning to efficiently infer invariants of a larger syntactic class of invariants beyond monotone DNF. Lastly, we consider the robustness of inference under program transformations. We show that some simple transformations preserve the fence condition, and that it is sensitive to more complex transformations.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434296", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yotam M. Y.", + "last_name": "Feldman", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/FeldmanSSW21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434323", + "title": "Distributed causal memory: modular specification and verification in higher-order distributed separation logic", + "abstract": "We present the first specification and verification of an implementation of a causally-consistent distributed database that supports modular verification of full functional correctness properties of clients and servers. We specify and reason about the causally-consistent distributed database in Aneris, a higher-order distributed separation logic for an ML-like programming language with network primitives for programming distributed systems. We demonstrate that our specifications are useful, by proving the correctness of small, but tricky, synthetic examples involving causal dependency and by verifying a session manager library implemented on top of the distributed database. We use Aneris's facilities for modular specification and verification to obtain a highly modular development, where each component is verified in isolation, relying only on the specifications (not the implementations) of other components. We have used the Coq formalization of the Aneris logic to formalize all the results presented in the paper in the Coq proof assistant.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434323", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Léon", + "last_name": "Gondelman", + "institution": "Aarhus University" + }, + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "Aarhus University" + }, + { + "first_name": "Abel", + "last_name": "Nieto", + "institution": "Aarhus University" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/GondelmanGNTB21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434298", + "title": "Verifying correct usage of context-free API protocols", + "abstract": "Several real-world libraries (e.g., reentrant locks, GUI frameworks, serialization libraries) require their clients to use the provided API in a manner that conforms to a context-free specification. Motivated by this observation, this paper describes a new technique for verifying the correct usage of context-free API protocols. The key idea underlying our technique is to over-approximate the program’s feasible API call sequences using a context-free grammar (CFG) and then check language inclusion between this grammar and the specification. However, since this inclusion check may fail due to imprecision in the program’s CFG abstraction, we propose a novel refinement technique to progressively improve the CFG. In particular, our method obtains counterexamples from CFG inclusion queries and uses them to introduce new non-terminals and productions to the grammar while still over-approximating the program’s relevant behavior. We have implemented the proposed algorithm in a tool called CFPChecker and evaluate it on 10 popular Java applications that use at least one API with a context-free specification. Our evaluation shows that CFPChecker is able to verify correct usage of the API in clients that use it correctly and produces counterexamples for those that do not. We also compare our method against three relevant baselines and demonstrate that CFPChecker enables verification of safety properties that are beyond the reach of existing tools.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434298", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kostas", + "last_name": "Ferles", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Jon", + "last_name": "Stephens", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/FerlesSD21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434297", + "title": "Precise subtyping for asynchronous multiparty sessions", + "abstract": "Session subtyping is a cornerstone of refinement of communicating processes: a process implementing a session type (i.e., a communication protocol) T can be safely used whenever a process implementing one of its supertypes T ′ is expected, in any context, without introducing deadlocks nor other communication errors. As a consequence, whenever T T ′ holds, it is safe to replace an implementation of T ′ with an implementation of the subtype T , which may allow for more optimised communication patterns. We present the first formalisation of the precise subtyping relation for asynchronous multiparty sessions. We show that our subtyping relation is sound (i.e., guarantees safe process replacement, as outlined above) and also complete : any extension of the relation is unsound. To achieve our results, we develop a novel session decomposition technique, from full session types (including internal/external choices) into single input/output session trees (without choices). Previous work studies precise subtyping for binary sessions (with just two participants), or multiparty sessions (with any number of participants) and synchronous interaction. Here, we cover multiparty sessions with asynchronous interaction, where messages are transmitted via FIFO queues (as in the TCP/IP protocol), and prove that our subtyping is both operationally and denotationally precise. In the asynchronous multiparty setting, finding the precise subtyping relation is a highly complex task: this is because, under some conditions, participants can permute the order of their inputs and outputs, by sending some messages earlier or receiving some later, without causing errors; the precise subtyping relation must capture all such valid permutations — and consequently, its formalisation, reasoning and proofs become challenging. Our session decomposition technique overcomes this complexity, expressing the subtyping relation as a composition of refinement relations between single input/output trees, and providing a simple reasoning principle for asynchronous message optimisations.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434297", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Silvia", + "last_name": "Ghilezan", + "institution": "University of Novi Sad" + }, + { + "first_name": "Jovanka", + "last_name": "Pantović", + "institution": "University of Novi Sad" + }, + { + "first_name": "Ivan", + "last_name": "Prokić", + "institution": "University of Novi Sad" + }, + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "Aston University" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/GhilezanPPSY21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434316", + "title": "Giving semantics to program-counter labels via secure effects", + "abstract": "Type systems designed for information-flow control commonly use a program-counter label to track the sensitivity of the context and rule out data leakage arising from effectful computation in a sensitive context. Currently, type-system designers reason about this label informally except in security proofs, where they use ad-hoc techniques. We develop a framework based on monadic semantics for effects to give semantics to program-counter labels. This framework leads to three results about program-counter labels. First, we develop a new proof technique for noninterference, the core security theorem for information-flow control in effectful languages. Second, we unify notions of security for different types of effects, including state, exceptions, and nontermination. Finally, we formalize the folklore that program-counter labels are a lower bound on effects. We show that, while not universally true, this folklore has a good semantic foundation.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434316", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew K.", + "last_name": "Hirsch", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ethan", + "last_name": "Cecchetti", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/HirschC21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434288", + "title": "Fully abstract from static to gradual", + "abstract": "What is a good gradual language? Siek et al. have previously proposed the refined criteria, a set of formal ideas that characterize a range of guarantees typically expected from a gradual language. While these go a long way, they are mostly focused on syntactic and type safety properties and fail to characterize how richer semantic properties and reasoning principles that hold in the static language, like non-interference or parametricity for instance, should be upheld in the gradualization. In this paper, we investigate and argue for a new criterion previously hinted at by Devriese et al.: the embedding from the static to the gradual language should be fully abstract. Rather than preserving an arbitrarily chosen interpretation of source language types, this criterion requires that all source language equivalences are preserved. We demonstrate that the criterion weeds out erroneous gradualizations that nevertheless satisfy the refined criteria. At the same time, we demonstrate that the criterion is realistic by reporting on a mechanized proof that the property holds for a standard example: GTLC µ , the natural gradualization of STLC µ , the simply typed lambda-calculus with equirecursive types. We argue thus that the criterion is useful for understanding, evaluating, and guiding the design of gradual languages, particularly those which are intended to preserve source language guarantees in a rich way.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434288", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Koen", + "last_name": "Jacobs", + "institution": "KU Leuven" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "journals/pacmpl/JacobsTD21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434339", + "title": "Paradoxes of probabilistic programming: and how to condition on events of measure zero with infinitesimal probabilities", + "abstract": "Abstract Probabilistic programming languages allow programmers to write down conditional probability distributions that represent statistical and machine learning models as programs that use observe statements. These programs are run by accumulating likelihood at each observe statement, and using the likelihood to steer random choices and weigh results with inference algorithms such as importance sampling or MCMC. We argue that naive likelihood accumulation does not give desirable semantics and leads to paradoxes when an observe statement is used to condition on a measure-zero event, particularly when the observe statement is executed conditionally on random data. We show that the paradoxes disappear if we explicitly model measure-zero events as a limit of positive measure events, and that we can execute these type of probabilistic programs by accumulating infinitesimal probabilities rather than probability densities. Our extension improves probabilistic programming languages as an executable notation for probability distributions by making it more well-behaved and more expressive, by allowing the programmer to be explicit about which limit is intended when conditioning on an event of measure zero.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434339", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/Jacobs21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434336", + "title": "Intensional datatype refinement: with application to scalable verification of pattern-match safety", + "abstract": "The pattern-match safety problem is to verify that a given functional program will never crash due to non-exhaustive patterns in its function definitions. We present a refinement type system that can be used to solve this problem. The system extends ML-style type systems with algebraic datatypes by a limited form of structural subtyping and environment-level intersection. We describe a fully automatic, sound and complete type inference procedure for this system which, under reasonable assumptions, is worst-case linear-time in the program size. Compositionality is essential to obtaining this complexity guarantee. A prototype implementation for Haskell is able to analyse a selection of packages from the Hackage database in a few hundred milliseconds.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434336", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eddie", + "last_name": "Jones", + "institution": "University of Bristol" + }, + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/JonesR21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434319", + "title": "Automata and fixpoints for asynchronous hyperproperties", + "abstract": "Hyperproperties have received increasing attention in the last decade due to their importance e.g. for security analyses. Past approaches have focussed on synchronous analyses, i.e. techniques in which different paths are compared lockstepwise. In this paper, we systematically study asynchronous analyses for hyperproperties by introducing both a novel automata model (Alternating Asynchronous Parity Automata) and the temporal fixpoint calculus H µ , the first fixpoint calculus that can systematically express hyperproperties in an asynchronous manner and at the same time subsumes the existing logic HyperLTL. We show that the expressive power of both models coincides over fixed path assignments. The high expressive power of both models is evidenced by the fact that decision problems of interest are highly undecidable, i.e. not even arithmetical. As a remedy, we propose approximative analyses for both models that also induce natural decidable fragments.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434319", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jens Oliver", + "last_name": "Gutsfeld", + "institution": "University of Münster" + }, + { + "first_name": "Markus", + "last_name": "Müller-Olm", + "institution": "University of Münster" + }, + { + "first_name": "Christoph", + "last_name": "Ohrem", + "institution": "University of Münster" + } + ], + "dblp_key": "journals/pacmpl/GutsfeldMO21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434311", + "title": "Semantics-guided synthesis", + "abstract": "This paper develops a new framework for program synthesis, called semantics-guided synthesis (SemGuS), that allows a user to provide both the syntax and the semantics for the constructs in the language. SemGuS accepts a recursively defined big-step semantics, which allows it, for example, to be used to specify and solve synthesis problems over an imperative programming language that may contain loops with unbounded behavior. The customizable nature of SemGuS also allows synthesis problems to be defined over a non-standard semantics, such as an abstract semantics. In addition to the SemGuS framework, we develop an algorithm for solving SemGuS problems that is capable of both synthesizing programs and proving unrealizability, by encoding a SemGuS problem as a proof search over Constrained Horn Clauses: in particular, our approach is the first that we are aware of that can prove unrealizabilty for synthesis problems that involve imperative programs with unbounded loops, over an infinite syntactic search space. We implemented the technique in a tool called MESSY, and applied it to SyGuS problems (i.e., over expressions), synthesis problems over an imperative programming language, and synthesis problems over regular expressions.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434311", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jinwoo", + "last_name": "Kim", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Qinheping", + "last_name": "Hu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D'Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/KimHDR21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434328", + "title": "Taming x86-TSO persistency", + "abstract": "We study the formal semantics of non-volatile memory in the x86-TSO architecture. We show that while the explicit persist operations in the recent model of Raad et al. from POPL'20 only enforce order between writes to the non-volatile memory, it is equivalent, in terms of reachable states, to a model whose explicit persist operations mandate that prior writes are actually written to the non-volatile memory. The latter provides a novel model that is much closer to common developers' understanding of persistency semantics. We further introduce a simpler and stronger sequentially consistent persistency model, develop a sound mapping from this model to x86, and establish a data-race-freedom guarantee providing programmers with a safe programming discipline. Our operational models are accompanied with equivalent declarative formulations, which facilitate our formal arguments, and may prove useful for program verification under x86 persistency.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434328", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Artem", + "last_name": "Khyzha", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/KhyzhaL21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434324", + "title": "PerSeVerE: persistency semantics for verification under ext4", + "abstract": "Although ubiquitous, modern filesystems have rather complex behaviours that are hardly understood by programmers and lead to severe software bugs such as data corruption. As a first step to ensure correctness of software performing file I/O, we formalize the semantics of the Linux ext4 filesystem, which we integrate with the weak memory consistency semantics of C/C++. We further develop an effective model checking approach for verifying programs that use the filesystem. In doing so, we discover and report bugs in commonly-used text editors such as vim, emacs and nano.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434324", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ilya", + "last_name": "Kaysin", + "institution": "National Research University Higher School of Economics" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/Kokologiannakis21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434338", + "title": "Functorial semantics for partial theories", + "abstract": "We provide a Lawvere-style definition for partial theories, extending the classical notion of equational theory by allowing partially defined operations. As in the classical case, our definition is syntactic: we use an appropriate class of string diagrams as terms. This allows for equational reasoning about the class of models defined by a partial theory. We demonstrate the expressivity of such equational theories by considering a number of examples, including partial combinatory algebras and cartesian closed categories. Moreover, despite the increase in expressivity of the syntax we retain a well-behaved notion of semantics: we show that our categories of models are precisely locally finitely presentable categories, and that free models exist.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434338", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ivan Di", + "last_name": "Liberti", + "institution": "Czech Academy of Sciences" + }, + { + "first_name": "Fosco", + "last_name": "Loregian", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Chad", + "last_name": "Nester", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Paweł", + "last_name": "Sobociński", + "institution": "Tallinn University of Technology" + } + ], + "dblp_key": "journals/pacmpl/LibertiLN021", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434335", + "title": "Combining the top-down propagation and bottom-up enumeration for inductive program synthesis", + "abstract": "We present an effective method for scalable and general-purpose inductive program synthesis. There have been two main approaches for inductive synthesis: enumerative search, which repeatedly enumerates possible candidate programs, and the top-down propagation (TDP), which recursively decomposes a given large synthesis problem into smaller subproblems. Enumerative search is generally applicable but limited in scalability, and the TDP is efficient but only works for special grammars or applications. In this paper, we synergistically combine the two approaches. We generate small program subexpressions via enumerative search and put them together into the desired program by using the TDP. Enumerative search enables to bring the power of TDP into arbitrary grammars, and the TDP helps to overcome the limited scalability of enumerative search. We apply our approach to a standard formulation, syntax-guided synthesis (SyGuS), thereby supporting a broad class of inductive synthesis problems. We have implemented our approach in a tool called Duet and evaluate it on SyGuS benchmark problems from various domains. We show that Duet achieves significant performance gains over existing general-purpose as well as domain-specific synthesizers.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434335", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Woosuk", + "last_name": "Lee", + "institution": "Hanyang University" + } + ], + "dblp_key": "journals/pacmpl/Lee21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434310", + "title": "An approach to generate correctly rounded math libraries for new floating point variants", + "abstract": "Given the importance of floating point (FP) performance in numerous domains, several new variants of FP and its alternatives have been proposed (e.g., Bfloat16, TensorFloat32, and posits). These representations do not have correctly rounded math libraries. Further, the use of existing FP libraries for these new representations can produce incorrect results. This paper proposes a novel approach for generating polynomial approximations that can be used to implement correctly rounded math libraries. Existing methods generate polynomials that approximate the real value of an elementary function 𝑓 (𝑥) and produce wrong results due to approximation errors and rounding errors in the implementation. In contrast, our approach generates polynomials that approximate the correctly rounded value of 𝑓 (𝑥) (i.e., the value of 𝑓 (𝑥) rounded to the target representation). It provides more margin to identify efficient polynomials that produce correctly rounded results for all inputs. We frame the problem of generating efficient polynomials that produce correctly rounded results as a linear programming problem. Using our approach, we have developed correctly rounded, yet faster, implementations of elementary functions for multiple target representations.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434310", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jay P.", + "last_name": "Lim", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Mridul", + "last_name": "Aanjaneya", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "John L.", + "last_name": "Gustafson", + "institution": "National University of Singapore" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "journals/pacmpl/LimAGN21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434340", + "title": "On the complexity of bidirected interleaved Dyck-reachability", + "abstract": "Many program analyses need to reason about pairs of matching actions, such as call/return, lock/unlock, or set-field/get-field. The family of Dyck languages { D k }, where D k has k kinds of parenthesis pairs, can be used to model matching actions as balanced parentheses. Consequently, many program-analysis problems can be formulated as Dyck-reachability problems on edge-labeled digraphs. Interleaved Dyck-reachability (InterDyck-reachability), denoted by D k ⊙ D k -reachability, is a natural extension of Dyck-reachability that allows one to formulate program-analysis problems that involve multiple kinds of matching-action pairs. Unfortunately, the general InterDyck-reachability problem is undecidable. In this paper, we study variants of InterDyck-reachability on bidirected graphs , where for each edge ⟨ p , q ⟩ labeled by an open parenthesis ”( a ”, there is an edge ⟨ q , p ⟩ labeled by the corresponding close parenthesis ”) a ”, and vice versa . Language-reachability on a bidirected graph has proven to be useful both (1) in its own right, as a way to formalize many program-analysis problems, such as pointer analysis, and (2) as a relaxation method that uses a fast algorithm to over-approximate language-reachability on a directed graph. However, unlike its directed counterpart, the complexity of bidirected InterDyck-reachability still remains open. We establish the first decidable variant (i.e., D 1 ⊙ D 1 -reachability) of bidirected InterDyck-reachability. In D 1 ⊙ D 1 -reachability, each of the two Dyck languages is restricted to have only a single kind of parenthesis pair. In particular, we show that the bidirected D 1 ⊙ D 1 problem is in PTIME. We also show that when one extends each Dyck language to involve k different kinds of parentheses (i.e., D k ⊙ D k -reachability with k ≥ 2), the problem is NP-hard (and therefore much harder). We have implemented the polynomial-time algorithm for bidirected D 1 ⊙ D 1 -reachability. D k ⊙ D k -reachability provides a new over-approximation method for bidirected D k ⊙ D k -reachability in the sense that D k ⊙ D k -reachability can first be relaxed to bidirected D 1 ⊙ D 1 -reachability, and then the resulting bidirected D 1 ⊙ D 1 -reachability problem is solved precisely. We compare this D 1 ⊙ D 1 -reachability-based approach against another known over-approximating D k ⊙ D k -reachability algorithm. Surprisingly, we found that the over-approximation approach based on bidirected D 1 ⊙ D 1 -reachability computes more precise solutions, even though the D 1 ⊙ D 1 formalism is inherently less expressive than the D k ⊙ D k formalism.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434340", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuanbo", + "last_name": "Li", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/LiZR21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434313", + "title": "Intersection types and (positive) almost-sure termination", + "abstract": "Randomized higher-order computation can be seen as being captured by a λ-calculus endowed with a single algebraic operation, namely a construct for binary probabilistic choice. What matters about such computations is the probability of obtaining any given result, rather than the possibility or the necessity of obtaining it, like in (non)deterministic computation. Termination, arguably the simplest kind of reachability problem, can be spelled out in at least two ways, depending on whether it talks about the probability of convergence or about the expected evaluation time, the second one providing a stronger guarantee. In this paper, we show that intersection types are capable of precisely characterizing both notions of termination inside a single system of types: the probability of convergence of any λ-term can be underapproximated by its type , while the underlying derivation’s weight gives a lower bound to the term’s expected number of steps to normal form. Noticeably, both approximations are tight—not only soundness but also completeness holds. The crucial ingredient is non-idempotency, without which it would be impossible to reason on the expected number of reduction steps which are necessary to completely evaluate any term. Besides, the kind of approximation we obtain is proved to be optimal recursion theoretically: no recursively enumerable formal system can do better than that.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434313", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Claudia", + "last_name": "Faggian", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Simona Ronchi Della", + "last_name": "Rocca", + "institution": "University of Turin" + } + ], + "dblp_key": "journals/pacmpl/LagoFR21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434318", + "title": "A verified optimizer for Quantum circuits", + "abstract": "We present VOQC, the first fully verified optimizer for quantum circuits, written using the Coq proof assistant. Quantum circuits are expressed as programs in a simple, low-level language called SQIR, a simple quantum intermediate representation, which is deeply embedded in Coq. Optimizations and other transformations are expressed as Coq functions, which are proved correct with respect to a semantics of SQIR programs. SQIR uses a semantics of matrices of complex numbers, which is the standard for quantum computation, but treats matrices symbolically in order to reason about programs that use an arbitrary number of quantum bits. SQIR's careful design and our provided automation make it possible to write and verify a broad range of optimizations in VOQC, including full-circuit transformations from cutting-edge optimizers.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434318", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kesha", + "last_name": "Hietala", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Robert W.", + "last_name": "Rand", + "institution": "University of Chicago" + }, + { + "first_name": "Shih-Han", + "last_name": "Hung", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/Hietala0HW021", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434282", + "title": "Cyclic proofs, system t, and the power of contraction", + "abstract": "We study a cyclic proof system C over regular expression types, inspired by linear logic and non-wellfounded proof theory. Proofs in C can be seen as strongly typed goto programs. We show that they denote computable total functions and we analyse the relative strength of C and Gödel’s system T. In the general case, we prove that the two systems capture the same functions on natural numbers. In the affine case, i.e., when contraction is removed, we prove that they capture precisely the primitive recursive functions—providing an alternative and more general proof of a result by Dal Lago, about an affine version of system T. Without contraction, we manage to give a direct and uniform encoding of C into T, by analysing cycles and translating them into explicit recursions. Whether such a direct and uniform translation from C to T can be given in the presence of contraction remains open. We obtain the two upper bounds on the expressivity of C using a different technique: we formalise weak normalisation of a small step reduction semantics in subsystems of second-order arithmetic: ACA 0 and RCA 0 .", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434282", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Denis", + "last_name": "Kuperberg", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Laureline", + "last_name": "Pinault", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Damien", + "last_name": "Pous", + "institution": "Université Claude Bernard Lyon 1" + } + ], + "dblp_key": "journals/pacmpl/KuperbergPP21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434309", + "title": "Automatic differentiation in PCF", + "abstract": "We study the correctness of automatic differentiation (AD) in the context of a higher-order, Turing-complete language (PCF with real numbers), both in forward and reverse mode. Our main result is that, under mild hypotheses on the primitive functions included in the language, AD is almost everywhere correct, that is, it computes the derivative or gradient of the program under consideration except for a set of Lebesgue measure zero. Stated otherwise, there are inputs on which AD is incorrect, but the probability of randomly choosing one such input is zero. Our result is in fact more precise, in that the set of failure points admits a more explicit description: for example, in case the primitive functions are just constants, addition and multiplication, the set of points where AD fails is contained in a countable union of zero sets of polynomials.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434309", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Damiano", + "last_name": "Mazza", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Michele", + "last_name": "Pagani", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "journals/pacmpl/MazzaP21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434334", + "title": "Corpse reviver: sound and efficient gradual typing via contract verification", + "abstract": "Gradually typed programming languages permit the incremental addition of static types to untyped programs. To remain sound, languages insert run-time checks at the boundaries between typed and untyped code. Unfortunately, performance studies have shown that the overhead of these checks can be disastrously high, calling into question the viability of sound gradual typing. In this paper, we show that by building on existing work on soft contract verification, we can reduce or eliminate this overhead. Our key insight is that while untyped code cannot be trusted by a gradual type system, there is no need to consider only the worst case when optimizing a gradually typed program. Instead, we statically analyze the untyped portions of a gradually typed program to prove that almost all of the dynamic checks implied by gradual type boundaries cannot fail, and can be eliminated at compile time. Our analysis is modular, and can be applied to any portion of a program. We evaluate this approach on a dozen existing gradually typed programs previously shown to have prohibitive performance overhead—with a median overhead of 2.5× and up to 80.6× in the worst case—and eliminate all overhead in most cases, suffering only 1.5× overhead in the worst case.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434334", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cameron", + "last_name": "Moy", + "institution": "Northeastern University" + }, + { + "first_name": "Phúc C.", + "last_name": "Nguyễn", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/MoyNTH21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434315", + "title": "The fine-grained and parallel complexity of andersen's pointer analysis", + "abstract": "Pointer analysis is one of the fundamental problems in static program analysis. Given a set of pointers, the task is to produce a useful over-approximation of the memory locations that each pointer may point-to at runtime. The most common formulation is Andersen’s Pointer Analysis (APA), defined as an inclusion-based set of m pointer constraints over a set of n pointers. Scalability is extremely important, as points-to information is a prerequisite to many other components in the static-analysis pipeline. Existing algorithms solve APA in O ( n 2 · m ) time, while it has been conjectured that the problem has no truly sub-cubic algorithm, with a proof so far having remained elusive. It is also well-known that APA can be solved in O ( n 2 ) time under certain sparsity conditions that hold naturally in some settings. Besides these simple bounds, the complexity of the problem has remained poorly understood. In this work we draw a rich fine-grained and parallel complexity landscape of APA, and present upper and lower bounds. First, we establish an O ( n 3 ) upper-bound for general APA, improving over O ( n 2 · m ) as n = O ( m ). Second, we show that even on-demand APA (“may a specific pointer a point to a specific location b ?”) has an Ω( n 3 ) (combinatorial) lower bound under standard complexity-theoretic hypotheses. This formally establishes the long-conjectured “cubic bottleneck” of APA, and shows that our O ( n 3 )-time algorithm is optimal. Third, we show that under mild restrictions, APA is solvable in Õ( n ω ) time, where ω<2.373 is the matrix-multiplication exponent. It is believed that ω=2+ o (1), in which case this bound becomes quadratic. Fourth, we show that even under such restrictions, even the on-demand problem has an Ω( n 2 ) lower bound under standard complexity-theoretic hypotheses, and hence our algorithm is optimal when ω=2+ o (1). Fifth, we study the parallelizability of APA and establish lower and upper bounds: (i) in general, the problem is P-complete and hence unlikely parallelizable, whereas (ii) under mild restrictions, the problem is parallelizable. Our theoretical treatment formalizes several insights that can lead to practical improvements in the future.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434315", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anders Alnor", + "last_name": "Mathiasen", + "institution": "Aarhus University" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/MathiasenP21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434306", + "title": "Modeling and analyzing evaluation cost of CUDA kernels", + "abstract": "General-purpose programming on GPUs (GPGPU) is becoming increasingly in vogue as applications such as machine learning and scientific computing demand high throughput in vector-parallel applications. NVIDIA's CUDA toolkit seeks to make GPGPU programming accessible by allowing programmers to write GPU functions, called kernels, in a small extension of C/C++. However, due to CUDA's complex execution model, the performance characteristics of CUDA kernels are difficult to predict, especially for novice programmers. This paper introduces a novel quantitative program logic for CUDA kernels, which allows programmers to reason about both functional correctness and resource usage of CUDA kernels, paying particular attention to a set of common but CUDA-specific performance bottlenecks. The logic is proved sound with respect to a novel operational cost semantics for CUDA kernels. The semantics, logic and soundness proofs are formalized in Coq. An inference algorithm based on LP solving automatically synthesizes symbolic resource bounds by generating derivations in the logic. This algorithm is the basis of RaCuda, an end-to-end resource-analysis tool for kernels, which has been implemented using an existing resource-analysis tool for imperative programs. An experimental evaluation on a suite of CUDA benchmarks shows that the analysis is effective in aiding the detection of performance bugs in CUDA kernels.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434306", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/Muller021", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434285", + "title": "Verifying observational robustness against a c11-style memory model", + "abstract": "We study the problem of verifying the robustness of concurrent programs against a C11-style memory model that includes relaxed accesses and release/acquire accesses and fences, and show that this verification problem can be reduced to a standard reachability problem under sequential consistency. We further observe that existing robustness notions do not allow the verification of programs that use speculative reads as in the sequence lock mechanism, and introduce a novel \"observational robustness\" property that fills this gap. In turn, we show how to soundly check for observational robustness. We have implemented our method and applied it to several challenging concurrent algorithms, demonstrating the applicability of our approach. To the best of our knowledge, this is the first method for verifying robustness against a programming language concurrency model that includes relaxed accesses and release/acquire fences.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434285", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roy", + "last_name": "Margalit", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/MargalitL21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434302", + "title": "On the semantic expressiveness of recursive types", + "abstract": "Recursive types extend the simply-typed lambda calculus (STLC) with the additional expressive power to enable diverging computation and to encode recursive data-types (e.g., lists). Two formulations of recursive types exist: iso-recursive and equi-recursive. The relative advantages of iso- and equi-recursion are well- studied when it comes to their impact on type-inference. However, the relative semantic expressiveness of the two formulations remains unclear so far. This paper studies the semantic expressiveness of STLC with iso- and equi-recursive types, proving that these formulations are equally expressive. In fact, we prove that they are both as expressive as STLC with only term-level recursion. We phrase these equi-expressiveness results in terms of full abstraction of three canonical compilers between these three languages (STLC with iso-, with equi-recursive types and with term-level recursion). Our choice of languages allows us to study expressiveness when interacting over both a simply-typed and a recursively-typed interface. The three proofs all rely on a typed version of a proof technique called approximate backtranslation. Together, our results show that there is no difference in semantic expressiveness between STLCs with iso- and equi-recursive types. In this paper, we focus on a simply-typed setting but we believe our results scale to more powerful type systems like System F.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434302", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Eric Mark", + "last_name": "Martin", + "institution": "Stanford University" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "journals/pacmpl/PatrignaniMD21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434300", + "title": "Data flow refinement type inference", + "abstract": "Refinement types enable lightweight verification of functional programs. Algorithms for statically inferring refinement types typically work by reduction to solving systems of constrained Horn clauses extracted from typing derivations. An example is Liquid type inference, which solves the extracted constraints using predicate abstraction. However, the reduction to constraint solving in itself already signifies an abstraction of the program semantics that affects the precision of the overall static analysis. To better understand this issue, we study the type inference problem in its entirety through the lens of abstract interpretation. We propose a new refinement type system that is parametric with the choice of the abstract domain of type refinements as well as the degree to which it tracks context-sensitive control flow information. We then derive an accompanying parametric inference algorithm as an abstract interpretation of a novel data flow semantics of functional programs. We further show that the type system is sound and complete with respect to the constructed abstract semantics. Our theoretical development reveals the key abstraction steps inherent in refinement type inference algorithms. The trade-off between precision and efficiency of these abstraction steps is controlled by the parameters of the type system. Existing refinement type systems and their respective inference algorithms, such as Liquid types, are captured by concrete parameter instantiations. We have implemented our framework in a prototype tool and evaluated it for a range of new parameter instantiations (e.g., using octagons and polyhedra for expressing type refinements). The tool compares favorably against other existing tools. Our evaluation indicates that our approach can be used to systematically construct new refinement type inference algorithms that are both robust and precise.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434300", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zvonimir", + "last_name": "Pavlinovic", + "institution": "Google (United States)" + }, + { + "first_name": "Yusen", + "last_name": "Su", + "institution": "New York University" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/PavlinovicSW21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434308", + "title": "A unifying type-theory for higher-order (amortized) cost analysis", + "abstract": "This paper presents λ-amor, a new type-theoretic framework for amortized cost analysis of higher-order functional programs and shows that existing type systems for cost analysis can be embedded in it. λ-amor introduces a new modal type for representing potentials – costs that have been accounted for, but not yet incurred, which are central to amortized analysis. Additionally, λ-amor relies on standard type-theoretic concepts like affineness, refinement types and an indexed cost monad. λ-amor is proved sound using a rather simple logical relation. We embed two existing type systems for cost analysis in λ-amor showing that, despite its simplicity, λ-amor can simulate cost analysis for different evaluation strategies (call-by-name and call-by-value), in different styles (effect-based and coeffect-based), and with or without amortization. One of the embeddings also implies that λ-amor is relatively complete for all terminating PCF programs.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434308", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vineet", + "last_name": "Rajani", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Boston University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/RajaniG0021", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434326", + "title": "A practical mode system for recursive definitions", + "abstract": "In call-by-value languages, some mutually-recursive definitions can be safely evaluated to build recursive functions or cyclic data structures, but some definitions (let rec x = x + 1) contain vicious circles and their evaluation fails at runtime. We propose a new static analysis to check the absence of such runtime failures. We present a set of declarative inference rules, prove its soundness with respect to the reference source-level semantics of Nordlander, Carlsson, and Gill [2008], and show that it can be directed into an algorithmic backwards analysis check in a surprisingly simple way. Our implementation of this new check replaced the existing check used by the OCaml programming language, a fragile syntactic criterion which let several subtle bugs slip through as the language kept evolving. We document some issues that arise when advanced features of a real-world functional language (exceptions in first-class modules, GADTs, etc.) interact with safety checking for recursive definitions.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434326", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alban", + "last_name": "Reynaud", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/ReynaudSY21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434342", + "title": "Abstracting gradual typing moving forward: precise and space-efficient", + "abstract": "Abstracting Gradual Typing (AGT) is a systematic approach to designing gradually-typed languages. Languages developed using AGT automatically satisfy the formal semantic criteria for gradual languages identified by Siek et al. Nonetheless, vanilla AGT semantics can still have important shortcomings. First, a gradual language's runtime checks should preserve the space-efficiency guarantees inherent to the underlying static and dynamic languages. To the contrary, the default operational semantics of AGT break proper tail calls. Second, a gradual language's runtime checks should enforce basic modular type-based invariants expected from the static type discipline. To the contrary, the default operational semantics of AGT may fail to enforce some invariants in surprising ways. We demonstrate this in the GTFL ≲ language of Garcia et al. This paper addresses both problems at once by refining the theory underlying AGT's dynamic checks. Garcia et al. observe that AGT involves two abstractions of static types: one for the static semantics and one for the dynamic semantics. We recast the latter as an abstract interpretation of subtyping itself, while gradual types still abstract static types. Then we show how forward-completeness (Giacobazzi and Quintarelli) is key to supporting both space-efficient execution and reliable runtime type enforcement.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434342", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Felipe Bañados", + "last_name": "Schwerter", + "institution": "University of British Columbia" + }, + { + "first_name": "Alison M.", + "last_name": "Clark", + "institution": "" + }, + { + "first_name": "Khurram A.", + "last_name": "Jafery", + "institution": "" + }, + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/SchwerterCJG21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434292", + "title": "Probabilistic programming semantics for name generation", + "abstract": "We make a formal analogy between random sampling and fresh name generation. We show that quasi-Borel spaces, a model for probabilistic programming, can soundly interpret the ν-calculus, a calculus for name generation. Moreover, we prove that this semantics is fully abstract up to first-order types. This is surprising for an ‘off-the-shelf’ model, and requires a novel analysis of probability distributions on function spaces. Our tools are diverse and include descriptive set theory and normal forms for the ν-calculus.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434292", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marcin", + "last_name": "Sabok", + "institution": "McGill University" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + }, + { + "first_name": "Dario", + "last_name": "Stein", + "institution": "University of Oxford" + }, + { + "first_name": "Michael", + "last_name": "Wolman", + "institution": "McGill University" + } + ], + "dblp_key": "journals/pacmpl/SabokSSW21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434312", + "title": "An abstract interpretation for SPMD divergence on reducible control flow graphs", + "abstract": "Vectorizing compilers employ divergence analysis to detect at which program point a specific variable is uniform, i.e. has the same value on all SPMD threads that execute this program point. They exploit uniformity to retain branching to counter branch divergence and defer computations to scalar processor units. Divergence is a hyper-property and is closely related to non-interference and binding time. There exist several divergence, binding time, and non-interference analyses already but they either sacrifice precision or make significant restrictions to the syntactical structure of the program in order to achieve soundness. In this paper, we present the first abstract interpretation for uniformity that is general enough to be applicable to reducible CFGs and, at the same time, more precise than other analyses that achieve at least the same generality. Our analysis comes with a correctness proof that is to a large part mechanized in Coq. Our experimental evaluation shows that the compile time and the precision of our analysis is on par with LLVM's default divergence analysis that is only sound on more restricted CFGs. At the same time, our analysis is faster and achieves better precision than a state-of-the-art non-interference analysis that is sound and at least as general as our analysis.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434312", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Julian", + "last_name": "Rosemann", + "institution": "Saarland University" + }, + { + "first_name": "Simon", + "last_name": "Moll", + "institution": "NEC (Germany)" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "journals/pacmpl/RosemannMH21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434330", + "title": "Automatically eliminating speculative leaks from cryptographic code with blade", + "abstract": "We introduce Blade, a new approach to automatically and efficiently eliminate speculative leaks from cryptographic code. Blade is built on the insight that to stop leaks via speculative execution, it suffices to cut the dataflow from expressions that speculatively introduce secrets ( sources ) to those that leak them through the cache ( sinks ), rather than prohibit speculation altogether. We formalize this insight in a static type system that (1) types each expression as either transient , i.e., possibly containing speculative secrets or as being stable , and (2) prohibits speculative leaks by requiring that all sink expressions are stable. Blade relies on a new abstract primitive, protect , to halt speculation at fine granularity. We formalize and implement protect using existing architectural mechanisms, and show how Blade’s type system can automatically synthesize a minimal number of protect s to provably eliminate speculative leaks. We implement Blade in the Cranelift WebAssembly compiler and evaluate our approach by repairing several verified, yet vulnerable WebAssembly implementations of cryptographic primitives. We find that Blade can fix existing programs that leak via speculation automatically , without user intervention, and efficiently even when using fences to implement protect .", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434330", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Vassena", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Craig", + "last_name": "Disselkoen", + "institution": "University of California, San Diego" + }, + { + "first_name": "Klaus von", + "last_name": "Gleissenthall", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Sunjay", + "last_name": "Cauligi", + "institution": "University of California, San Diego" + }, + { + "first_name": "Rami Gökhan", + "last_name": "Kıcı", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Dean", + "last_name": "Tullsen", + "institution": "University of California, San Diego" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/VassenaDGCKJTS21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434303", + "title": "Intrinsically typed compilation with nameless labels", + "abstract": "To avoid compilation errors it is desirable to verify that a compiler is type correct —i.e., given well-typed source code, it always outputs well-typed target code. This can be done intrinsically by implementing it as a function in a dependently typed programming language, such as Agda. This function manipulates data types of well-typed source and target programs, and is therefore type correct by construction. A key challenge in implementing an intrinsically typed compiler is the representation of labels in bytecode. Because label names are global, bytecode typing appears to be inherently a non-compositional, whole-program property. The individual operations of the compiler do not preserve this property, which requires the programmer to reason about labels, which spoils the compiler definition with proof terms. In this paper, we address this problem using a new nameless and co-contextual representation of typed global label binding, which is compositional. Our key idea is to use linearity to ensure that all labels are defined exactly once. To write concise compilers that manipulate programs in our representation, we develop a linear, dependently typed, shallowly embedded language in Agda, based on separation logic. We show that this language enables the concise specification and implementation of intrinsically typed operations on bytecode, culminating in an intrinsically typed compiler for a language with structured control-flow.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434303", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arjen", + "last_name": "Rouvoet", + "institution": "Delft University of Technology" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/RouvoetKV21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434307", + "title": "Dijkstra monads forever: termination-sensitive specifications for interaction trees", + "abstract": "This paper extends the Dijkstra monad framework, designed for writing specifications over effectful programs using monadic effects, to handle termination sensitive specifications over interactive programs. We achieve this by introducing base specification monads for non-terminating programs with uninterpreted events. We model such programs using interaction trees, a coinductive datatype for representing programs with algebraic effects in Coq, which we further develop by adding trace semantics. We show that this approach subsumes typical, simple proof principles. The framework is implemented as an extension of the Interaction Trees Coq library.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434307", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lucas", + "last_name": "Silver", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/SilverZ21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434284", + "title": "𝜆ₛ: computable semantics for differentiable programming with higher-order functions and datatypes", + "abstract": "Deep learning is moving towards increasingly sophisticated optimization objectives that employ higher-order functions, such as integration, continuous optimization, and root-finding. Since differentiable programming frameworks such as PyTorch and TensorFlow do not have first-class representations of these functions, developers must reason about the semantics of such objectives and manually translate them to differentiable code. We present a differentiable programming language, λ S , that is the first to deliver a semantics for higher-order functions, higher-order derivatives, and Lipschitz but nondifferentiable functions. Together, these features enableλ S to expose differentiable, higher-order functions for integration, optimization, and root-finding as first-class functions with automatically computed derivatives. λ S ’s semantics is computable, meaning that values can be computed to arbitrary precision, and we implement λ S as an embedded language in Haskell. We use λ S to construct novel differentiable libraries for representing probability distributions, implicit surfaces, and generalized parametric surfaces – all as instances of higher-order datatypes – and present case studies that rely on computing the derivatives of these higher-order functions and datatypes. In addition to modeling existing differentiable algorithms, such as a differentiable ray tracer for implicit surfaces, without requiring any user-level differentiation code, we demonstrate new differentiable algorithms, such as the Hausdorff distance of generalized parametric surfaces.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434284", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Sherman", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jesse", + "last_name": "Michel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ShermanMC21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434294", + "title": "Transfinite step-indexing for termination", + "abstract": "Step-indexed logical relations are an extremely useful technique for building operational-semantics-based models and program logics for realistic, richly-typed programming languages. They have proven to be indispensable for modeling features like higher-order state , which many languages support but which were difficult to accommodate using traditional denotational models. However, the conventional wisdom is that, because they only support reasoning about finite traces of computation, (unary) step-indexed models are only good for proving safety properties like “well-typed programs don’t go wrong”. There has consequently been very little work on using step-indexing to establish liveness properties, in particular termination. In this paper, we show that step-indexing can in fact be used to prove termination of well-typed programs—even in the presence of dynamically-allocated, shared, mutable, higher-order state—so long as one’s type system enforces disciplined use of such state. Specifically, we consider a language with asynchronous channels, inspired by promises in JavaScript, in which higher-order state is used to implement communication, and linearity is used to ensure termination. The key to our approach is to generalize from natural number step-indexing to transfinite step-indexing , which enables us to compute termination bounds for program expressions in a compositional way. Although transfinite step-indexing has been proposed previously, we are the first to apply this technique to reasoning about termination in the presence of higher-order state.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434294", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon", + "last_name": "Spies", + "institution": "University of Cambridge" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/SpiesKD21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434301", + "title": "Simplifying dependent reductions in the polyhedral model", + "abstract": "A Reduction – an accumulation over a set of values, using an associative and commutative operator – is a common computation in many numerical computations, including scientific computations, machine learning, computer vision, and financial analytics. Contemporary polyhedral-based compilation techniques make it possible to optimize reductions, such as prefix sums, in which each component of the reduction’s output potentially shares computation with another component in the reduction. Therefore an optimizing compiler can identify the computation shared between multiple components and generate code that computes the shared computation only once. These techniques, however, do not support reductions that – when phrased in the language of the polyhedral model – span multiple dependent statements. In such cases, existing approaches can generate incorrect code that violates the data dependences of the original, unoptimized program. In this work, we identify and formalize the optimization of dependent reductions as an integer bilinear program. We present a heuristic optimization algorithm that uses an affine sequential schedule of the program to determine how to simplfy reductions yet still preserve the program’s dependences. We demonstrate that the algorithm provides optimal complexity for a set of benchmark programs from the literature on probabilistic inference algorithms, whose performance critically relies on simplifying these reductions. The complexities for 10 of the 11 programs improve siginifcantly by factors at least of the sizes of the input data, which are in the range of 10 4 to 10 6 for typical real application inputs. We also confirm the significance of the improvement by showing speedups in wall-clock time that range from 1.1x to over 10 6 x.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434301", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cambridge", + "last_name": "Yang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Eric", + "last_name": "Atkinson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/YangAC21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434314", + "title": "A separation logic for effect handlers", + "abstract": "User-defined effects and effect handlers are advertised and advocated as a relatively easy-to-understand and modular approach to delimited control. They offer the ability of suspending and resuming a computation and allow information to be transmitted both ways between the computation, which requests a certain service, and the handler, which provides this service. Yet, a key question remains, to this day, largely unanswered: how does one modularly specify and verify programs in the presence of both user-defined effect handlers and primitive effects, such as heap-allocated mutable state? We answer this question by presenting a Separation Logic with built-in support for effect handlers, both shallow and deep. The specification of a program fragment includes a protocol that describes the effects that the program may perform as well as the replies that it can expect to receive. The logic allows local reasoning via a frame rule and a bind rule. It is based on Iris and inherits all of its advanced features, including support for higher-order functions, user-defined ghost state, and invariants. We illustrate its power via several case studies, including (1) a generic formulation of control inversion, which turns a producer that ``pushes'' elements towards a consumer into a producer from which one can ``pull'' elements on demand, and (2) a simple system for cooperative concurrency, where several threads execute concurrently, can spawn new threads, and communicate via promises.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434314", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paulo Emílio de", + "last_name": "Vilhena", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/VilhenaP21", + "venue": "popl", + "year": 2021 + }, + { + "paper_id": "10.1145/3434304", + "title": "egg: Fast and extensible equality saturation", + "abstract": "An e-graph efficiently represents a congruence relation over many expressions. Although they were originally developed in the late 1970s for use in automated theorem provers, a more recent technique known as equality saturation repurposes e-graphs to implement state-of-the-art, rewrite-driven compiler optimizations and program synthesizers. However, e-graphs remain unspecialized for this newer use case. Equality saturation workloads exhibit distinct characteristics and often require ad-hoc e-graph extensions to incorporate transformations beyond purely syntactic rewrites. This work contributes two techniques that make e-graphs fast and extensible, specializing them to equality saturation. A new amortized invariant restoration technique called rebuilding takes advantage of equality saturation's distinct workload, providing asymptotic speedups over current techniques in practice. A general mechanism called e-class analyses integrates domain-specific analyses into the e-graph, reducing the need for ad hoc manipulation. We implemented these techniques in a new open-source library called egg. Our case studies on three previously published applications of equality saturation highlight how egg's performance and flexibility enable state-of-the-art results across diverse domains.", + "date": "2021-01-04", + "link": "https://doi.org/10.1145/3434304", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Max", + "last_name": "Willsey", + "institution": "University of Washington" + }, + { + "first_name": "Chandrakana", + "last_name": "Nandi", + "institution": "University of Washington" + }, + { + "first_name": "Yisu Remy", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Oliver", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/WillseyNWFTP21", + "venue": "popl", + "year": 2021 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2022.json b/data/pl_conferences/popl/2022.json new file mode 100644 index 0000000..902974a --- /dev/null +++ b/data/pl_conferences/popl/2022.json @@ -0,0 +1,2027 @@ +[ + { + "paper_id": "10.1145/3498719", + "title": "A separation logic for negative dependence", + "abstract": "Formal reasoning about hashing-based probabilistic data structures often requires reasoning about random variables where when one variable gets larger (such as the number of elements hashed into one bucket), the others tend to be smaller (like the number of elements hashed into the other buckets). This is an example of negative dependence , a generalization of probabilistic independence that has recently found interesting applications in algorithm design and machine learning. Despite the usefulness of negative dependence for the analyses of probabilistic data structures, existing verification methods cannot establish this property for randomized programs. To fill this gap, we design LINA, a probabilistic separation logic for reasoning about negative dependence. Following recent works on probabilistic separation logic using separating conjunction to reason about the probabilistic independence of random variables, we use separating conjunction to reason about negative dependence. Our assertion logic features two separating conjunctions, one for independence and one for negative dependence. We generalize the logic of bunched implications (BI) to support multiple separating conjunctions, and provide a sound and complete proof system. Notably, the semantics for separating conjunction relies on a non-deterministic , rather than partial, operation for combining resources. By drawing on closure properties for negative dependence, our program logic supports a Frame-like rule for negative dependence and monotone operations. We demonstrate how LINA can verify probabilistic properties of hash-based data structures and balls-into-bins processes.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498719", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jialu", + "last_name": "Bao", + "institution": "Cornell University" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Boston University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Cornell University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "Boston College" + } + ], + "dblp_key": "journals/pacmpl/BaoGHT22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498698", + "title": "Type-level programming with match types", + "abstract": "Type-level programming is becoming more and more popular in the realm of functional programming. However, the combination of type-level programming and subtyping remains largely unexplored in practical programming languages. This paper presents match types , a type-level equivalent of pattern matching. Match types integrate seamlessly into programming languages with subtyping and, despite their simplicity, offer significant additional expressiveness. We formalize the feature of match types in a calculus based on System F sub and prove its soundness. We practically evaluate our system by implementing match types in the Scala 3 reference compiler, thus making type-level programming readily available to a broad audience of programmers.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498698", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Blanvillain", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Maxime", + "last_name": "Kjaer", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/BlanvillainBKO22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498715", + "title": "Formal metatheory of second-order abstract syntax", + "abstract": "Despite extensive research both on the theoretical and practical fronts, formalising, reasoning about, and implementing languages with variable binding is still a daunting endeavour – repetitive boilerplate and the overly complicated metatheory of capture-avoiding substitution often get in the way of progressing on to the actually interesting properties of a language. Existing developments offer some relief, however at the expense of inconvenient and error-prone term encodings and lack of formal foundations. We present a mathematically-inspired language-formalisation framework implemented in Agda. The system translates the description of a syntax signature with variable-binding operators into an intrinsically-encoded, inductive data type equipped with syntactic operations such as weakening and substitution, along with their correctness properties. The generated metatheory further incorporates metavariables and their associated operation of metasubstitution, which enables second-order equational/rewriting reasoning. The underlying mathematical foundation of the framework – initial algebra semantics – derives compositional interpretations of languages into their models satisfying the semantic substitution lemma by construction.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498715", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marcelo", + "last_name": "Fiore", + "institution": "University of Cambridge" + }, + { + "first_name": "Dmitrij", + "last_name": "Szamozvancev", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/FioreS22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498666", + "title": "Fair termination of binary sessions", + "abstract": "A binary session is a private communication channel that connects two processes, each adhering to a protocol description called session type . In this work, we study the first type system that ensures the fair termination of binary sessions. A session fairly terminates if all of the infinite executions admitted by its protocol are deemed unrealistic because they violate certain fairness assumptions . Fair termination entails the eventual completion of all pending input/output actions, including those that depend on the completion of an unbounded number of other actions in possibly different sessions. This form of lock freedom allows us to address a large family of natural communication patterns that fall outside the scope of existing type systems. Our type system is also the first to adopt fair subtyping , a liveness-preserving refinement of the standard subtyping relation for session types that so far has only been studied theoretically. Fair subtyping is surprisingly subtle not only to characterize concisely but also to use appropriately, to the point that the type system must carefully account for all usages of fair subtyping to avoid compromising its liveness-preserving properties.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498666", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Luca", + "last_name": "Ciccone", + "institution": "University of Turin" + }, + { + "first_name": "Luca", + "last_name": "Padovani", + "institution": "University of Turin" + } + ], + "dblp_key": "journals/pacmpl/CicconeP22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498667", + "title": "Symmetries in reversible programming: from symmetric rig groupoids to reversible programming languages", + "abstract": "The Pi family of reversible programming languages for boolean circuits is presented as a syntax of combinators witnessing type isomorphisms of algebraic data types. In this paper, we give a denotational semantics for this language, using weak groupoids à la Homotopy Type Theory, and show how to derive an equational theory for it, presented by 2-combinators witnessing equivalences of type isomorphisms. We establish a correspondence between the syntactic groupoid of the language and a formally presented univalent subuniverse of finite types. The correspondence relates 1-combinators to 1-paths, and 2-combinators to 2-paths in the universe, which is shown to be sound and complete for both levels, forming an equivalence of groupoids. We use this to establish a Curry-Howard-Lambek correspondence between Reversible Logic, Reversible Programming Languages, and Symmetric Rig Groupoids, by showing that the syntax of Pi is presented by the free symmetric rig groupoid, given by finite sets and bijections. Using the formalisation of our results, we perform normalisation-by-evaluation, verification and synthesis of reversible logic gates, motivated by examples from quantum computing. We also show how to reason about and transfer theorems between different representations of reversible circuits.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498667", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vikraman", + "last_name": "Choudhury", + "institution": "University of Cambridge" + }, + { + "first_name": "Jacek", + "last_name": "Karwowski", + "institution": "University of Warsaw" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/ChoudhuryKS22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498701", + "title": "Dependently-typed data plane programming", + "abstract": "Programming languages like P4 enable specifying the behavior of network data planes in software. However, with increasingly powerful and complex applications running in the network, the risk of faults also increases. Hence, there is growing recognition of the need for methods and tools to statically verify the correctness of P4 code, especially as the language lacks basic safety guarantees. Type systems are a lightweight and compositional way to establish program properties, but there is a significant gap between the kinds of properties that can be proved using simple type systems (e.g., SafeP4) and those that can be obtained using full-blown verification tools (e.g., p4v). In this paper, we close this gap by developing Π4, a dependently-typed version of P4 based on decidable refinements. We motivate the design of Π4, prove the soundness of its type system, develop an SMT-based implementation, and present case studies that illustrate its applicability to a variety of data plane programs.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498701", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Eichholz", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Eric Hayden", + "last_name": "Campbell", + "institution": "Cornell University" + }, + { + "first_name": "Matthias", + "last_name": "Krebs", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technische Universität Darmstadt" + } + ], + "dblp_key": "journals/pacmpl/EichholzCKFM22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498721", + "title": "Partial (In)Completeness in abstract interpretation: limiting the imprecision in program analysis", + "abstract": "Imprecision is inherent in any decidable (sound) approximation of undecidable program properties. In abstract interpretation this corresponds to the release of false alarms, e.g., when it is used for program analysis and program verification. As all alarming systems, a program analysis tool is credible when few false alarms are reported. As a consequence, we have to live together with false alarms, but also we need methods to control them. As for all approximation methods, also for abstract interpretation we need to estimate the accumulated imprecision during program analysis. In this paper we introduce a theory for estimating the error propagation in abstract interpretation, and hence in program analysis. We enrich abstract domains with a weakening of a metric distance. This enriched structure keeps coherence between the standard partial order relating approximated objects by their relative precision and the effective error made in this approximation. An abstract interpretation is precise when it is complete. We introduce the notion of partial completeness as a weakening of precision. In partial completeness the abstract interpreter may produce a bounded number of false alarms. We prove the key recursive properties of the class of programs for which an abstract interpreter is partially complete with a given bound of imprecision. Then, we introduce a proof system for estimating an upper bound of the error accumulated by the abstract interpreter during program analysis. Our framework is general enough to be instantiated to most known metrics for abstract domains.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498721", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Campion", + "institution": "University of Verona" + }, + { + "first_name": "Mila Dalla", + "last_name": "Preda", + "institution": "University of Verona" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Verona" + } + ], + "dblp_key": "journals/pacmpl/CampionPG22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498702", + "title": "Subcubic certificates for CFL reachability", + "abstract": "Many problems in interprocedural program analysis can be modeled as the context-free language (CFL) reachability problem on graphs and can be solved in cubic time. Despite years of efforts, there are no known truly sub-cubic algorithms for this problem. We study the related certification task: given an instance of CFL reachability, are there small and efficiently checkable certificates for the existence and for the non-existence of a path? We show that, in both scenarios, there exist succinct certificates ( O ( n 2 ) in the size of the problem) and these certificates can be checked in subcubic (matrix multiplication) time. The certificates are based on grammar-based compression of paths (for reachability) and on invariants represented as matrix inequalities (for non-reachability). Thus, CFL reachability lies in nondeterministic and co-nondeterministic subcubic time. A natural question is whether faster algorithms for CFL reachability will lead to faster algorithms for combinatorial problems such as Boolean satisfiability (SAT). As a consequence of our certification results, we show that there cannot be a fine-grained reduction from SAT to CFL reachability for a conditional lower bound stronger than n ω , unless the nondeterministic strong exponential time hypothesis (NSETH) fails. In a nutshell, reductions from SAT are unlikely to explain the cubic bottleneck for CFL reachability. Our results extend to related subcubic equivalent problems: pushdown reachability and 2NPDA recognition; as well as to all-pairs CFL reachability. For example, we describe succinct certificates for pushdown non-reachability (inductive invariants) and observe that they can be checked in matrix multiplication time. We also extract a new hardest 2NPDA language, capturing the “hard core” of all these problems.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498702", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dmitry", + "last_name": "Chistikov", + "institution": "University of Warwick" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Society" + }, + { + "first_name": "Philipp", + "last_name": "Schepper", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "journals/pacmpl/ChistikovMS22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498689", + "title": "Simuliris: a separation logic framework for verifying concurrent program optimizations", + "abstract": "Today’s compilers employ a variety of non-trivial optimizations to achieve good performance. One key trick compilers use to justify transformations of concurrent programs is to assume that the source program has no data races : if it does, they cause the program to have undefined behavior (UB) and give the compiler free rein. However, verifying correctness of optimizations that exploit this assumption is a non-trivial problem. In particular, prior work either has not proven that such optimizations preserve program termination (particularly non-obvious when considering optimizations that move instructions out of loop bodies), or has treated all synchronization operations as external functions (losing the ability to reorder instructions around them). In this work we present Simuliris , the first simulation technique to establish termination preservation (under a fair scheduler) for a range of concurrent program transformations that exploit UB in the source language. Simuliris is based on the idea of using ownership to reason modularly about the assumptions the compiler makes about programs with well-defined behavior. This brings the benefits of concurrent separation logics to the space of verifying program transformations: we can combine powerful reasoning techniques such as framing and coinduction to perform thread-local proofs of non-trivial concurrent program optimizations. Simuliris is built on a (non-step-indexed) variant of the Coq-based Iris framework, and is thus not tied to a particular language. In addition to demonstrating the effectiveness of Simuliris on standard compiler optimizations involving data race UB, we also instantiate it with Jung et al.’s Stacked Borrows semantics for Rust and generalize their proofs of interesting type-based aliasing optimizations to account for concurrency.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498689", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lennard", + "last_name": "Gäher", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Simon", + "last_name": "Spies", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Hoang-Hai", + "last_name": "Dang", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/GaherSSJDKKD22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498676", + "title": "Property-directed reachability as abstract interpretation in the monotone theory", + "abstract": "Inferring inductive invariants is one of the main challenges of formal verification. The theory of abstract interpretation provides a rich framework to devise invariant inference algorithms. One of the latest breakthroughs in invariant inference is property-directed reachability (PDR), but the research community views PDR and abstract interpretation as mostly unrelated techniques. This paper shows that, surprisingly, propositional PDR can be formulated as an abstract interpretation algorithm in a logical domain. More precisely, we define a version of PDR, called Λ-PDR, in which all generalizations of counterexamples are used to strengthen a frame. In this way, there is no need to refine frames after their creation, because all the possible supporting facts are included in advance. We analyze this algorithm using notions from Bshouty’s monotone theory, originally developed in the context of exact learning. We show that there is an inherent overapproximation between the algorithm’s frames that is related to the monotone theory. We then define a new abstract domain in which the best abstract transformer performs this overapproximation, and show that it captures the invariant inference process, i.e., Λ-PDR corresponds to Kleene iterations with the best transformer in this abstract domain. We provide some sufficient conditions for when this process converges in a small number of iterations, with sometimes an exponential gap from the number of iterations required for naive exact forward reachability. These results provide a firm theoretical foundation for the benefits of how PDR tackles forward reachability.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498676", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yotam M. Y.", + "last_name": "Feldman", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/FeldmanSSW22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498678", + "title": "Context-bounded verification of thread pools", + "abstract": "Thread pooling is a common programming idiom in which a fixed set of worker threads are maintained to execute tasks concurrently. The workers repeatedly pick tasks and execute them to completion. Each task is sequential, with possibly recursive code, and tasks communicate over shared memory. Executing a task can lead to more new tasks being spawned. We consider the safety verification problem for thread-pooled programs. We parameterize the problem with two parameters: the size of the thread pool as well as the number of context switches for each task. The size of the thread pool determines the number of workers running concurrently. The number of context switches determines how many times a worker can be swapped out while executing a single task---like many verification problems for multithreaded recursive programs, the context bounding is important for decidability. We show that the safety verification problem for thread-pooled, context-bounded, Boolean programs is EXPSPACE-complete, even if the size of the thread pool and the context bound are given in binary. Our main result, the EXPSPACE upper bound, is derived using a sequence of new succinct encoding techniques of independent language-theoretic interest. In particular, we show a polynomial-time construction of downward closures of languages accepted by succinct pushdown automata as doubly succinct nondeterministic finite automata. While there are explicit doubly exponential lower bounds on the size of nondeterministic finite automata accepting the downward closure, our result shows these automata can be compressed. We show that thread pooling significantly reduces computational power: in contrast, if only the context bound is provided in binary, but there is no thread pooling, the safety verification problem becomes 3EXPSPACE-complete. Given the high complexity lower bounds of related problems involving binary parameters, the relatively low complexity of safety verification with thread-pooling comes as a surprise.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498678", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pascal", + "last_name": "Baumann", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ramanathan S.", + "last_name": "Thinniyam", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/BaumannMTZ22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498714", + "title": "Profile inference revisited", + "abstract": "Profile-guided optimization (PGO) is an important component in modern compilers. By allowing the compiler to leverage the program’s dynamic behavior, it can often generate substantially faster binaries. Sampling-based profiling is the state-of-the-art technique for collecting execution profiles in data-center environments. However, the lowered profile accuracy caused by sampling fully optimized binary often hurts the benefits of PGO; thus, an important problem is to overcome the inaccuracy in a profile after it is collected. In this paper we tackle the problem, which is also known as profile inference and profile rectification . We investigate the classical approach for profile inference, based on computing minimum-cost maximum flows in a control-flow graph, and develop an extended model capturing the desired properties of real-world profiles. Next we provide a solid theoretical foundation of the corresponding optimization problem by studying its algorithmic aspects. We then describe a new efficient algorithm for the problem along with its implementation in an open-source compiler. An extensive evaluation of the algorithm and existing profile inference techniques on a variety of applications, including Facebook production workloads and SPEC CPU benchmarks, indicates that the new method outperforms its competitors by significantly improving the accuracy of profile data and the performance of generated binaries.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498714", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wenlei", + "last_name": "He", + "institution": "Meta (United States)" + }, + { + "first_name": "Julián", + "last_name": "Mestre", + "institution": "University of Sydney" + }, + { + "first_name": "Sergey", + "last_name": "Pupyrev", + "institution": "Meta (United States)" + }, + { + "first_name": "Lei", + "last_name": "Wang", + "institution": "Meta (United States)" + }, + { + "first_name": "Hongtao", + "last_name": "Yu", + "institution": "Meta (United States)" + } + ], + "dblp_key": "journals/pacmpl/HeMPWY22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498663", + "title": "Quantum information effects", + "abstract": "We study the two dual quantum information effects to manipulate the amount of information in quantum computation: hiding and allocation. The resulting type-and-effect system is fully expressive for irreversible quantum computing, including measurement. We provide universal categorical constructions that semantically interpret this arrow metalanguage with choice, starting with any rig groupoid interpreting the reversible base language. Several properties of quantum measurement follow in general, and we translate (noniterative) quantum flow charts into our language. The semantic constructions turn the category of unitaries between Hilbert spaces into the category of completely positive trace-preserving maps, and they turn the category of bijections between finite sets into the category of functions with chosen garbage. Thus they capture the fundamental theorems of classical and quantum reversible computing of Toffoli and Stinespring.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498663", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chris", + "last_name": "Heunen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Robin", + "last_name": "Kaarsgaard", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/HeunenK22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498674", + "title": "On type-cases, union elimination, and occurrence typing", + "abstract": "We extend classic union and intersection type systems with a type-case construction and show that the combination of the union elimination rule of the former and the typing rules for type-cases of our extension encompasses occurrence typing . To apply this system in practice, we define a canonical form for the expressions of our extension, called MSC-form. We show that an expression of the extension is typable if and only if its MSC-form is, and reduce the problem of typing the latter to the one of reconstructing annotations for that term. We provide a sound algorithm that performs this reconstruction and a proof-of-concept implementation.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498674", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Mickaël", + "last_name": "Laurent", + "institution": "Université Paris Cité" + }, + { + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Matthew", + "last_name": "Lutze", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "journals/pacmpl/CastagnaLNL22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498707", + "title": "Solving string constraints with Regex-dependent functions through transducers with priorities and variables", + "abstract": "Regular expressions are a classical concept in formal language theory. Regular expressions in programming languages (RegEx) such as JavaScript, feature non-standard semantics of operators (e.g. greedy/lazy Kleene star), as well as additional features such as capturing groups and references. While symbolic execution of programs containing RegExes appeals to string solvers natively supporting important features of RegEx, such a string solver is hitherto missing. In this paper, we propose the first string theory and string solver that natively provides such support. The key idea of our string solver is to introduce a new automata model, called prioritized streaming string transducers (PSST), to formalize the semantics of RegEx-dependent string functions. PSSTs combine priorities, which have previously been introduced in prioritized finite-state automata to capture greedy/lazy semantics, with string variables as in streaming string transducers to model capturing groups. We validate the consistency of the formal semantics with the actual JavaScript semantics by extensive experiments. Furthermore, to solve the string constraints, we show that PSSTs enjoy nice closure and algorithmic properties, in particular, the regularity-preserving property (i.e., pre-images of regular constraints under PSSTs are regular), and introduce a sound sequent calculus that exploits these properties and performs propagation of regular constraints by means of taking post-images or pre-images. Although the satisfiability of the string constraint language is generally undecidable, we show that our approach is complete for the so-called straight-line fragment. We evaluate the performance of our string solver on over 195000 string constraints generated from an open-source RegEx library. The experimental results show the efficacy of our approach, drastically improving the existing methods (via symbolic execution) in both precision and efficiency.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498707", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Taolue", + "last_name": "Chen", + "institution": "Birkbeck, University of London" + }, + { + "first_name": "Alejandro", + "last_name": "Flores-Lamas", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Zhilei", + "last_name": "Han", + "institution": "Tsinghua University" + }, + { + "first_name": "Denghang", + "last_name": "Hu", + "institution": "Institute of Software" + }, + { + "first_name": "Shuanglong", + "last_name": "Kan", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Philipp", + "last_name": "Rümmer", + "institution": "Uppsala University" + }, + { + "first_name": "Zhilin", + "last_name": "Wu", + "institution": "Institute of Software" + } + ], + "dblp_key": "journals/pacmpl/ChenFHHHKLRW22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498684", + "title": "Pirouette: higher-order typed functional choreographies", + "abstract": "We present Pirouette, a language for typed higher-order functional choreographic programming. Pirouette offers programmers the ability to write a centralized functional program and compile it via endpoint projection into programs for each node in a distributed system. Moreover, Pirouette is defined generically over a (local) language of messages, and lifts guarantees about the message type system to its own. Message type soundness also guarantees deadlock freedom. All of our results are verified in Coq.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498684", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew K.", + "last_name": "Hirsch", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/HirschG22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498726", + "title": "Logarithm and program testing", + "abstract": "Randomized property-based testing has gained much attention recently, but most frameworks stop short at polymorphic properties. Although Bernardy et al. have developed a theory to reduce a wide range of polymorphic properties to monomorphic ones, it relies upon ad-hoc embedding-projection pairs to massage the types into a particular form. This paper skips the embedding-projection pairs and presents a mechanical monomorphization for a general class of polymorphic functions, a step towards automatic testing for polymorphic properties. The calculation of suitable types for monomorphization turns out to be logarithm .", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498726", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kuen-Bang", + "last_name": "Hou", + "institution": "University of Minnesota" + }, + { + "first_name": "Zhuyang", + "last_name": "Wang", + "institution": "University of Minnesota" + } + ], + "dblp_key": "journals/pacmpl/HouW22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498685", + "title": "Certifying derivation of state machines from coroutines", + "abstract": "One of the biggest implementation challenges in security-critical network protocols is nested state machines. In practice today, state machines are either implemented manually at a low level, risking bugs easily missed in audits; or are written using higher-level abstractions like threads, depending on runtime systems that may sacrifice performance or compatibility with the ABIs of important platforms (e.g., resource-constrained IoT systems). We present a compiler-based technique allowing the best of both worlds, coding protocols in a natural high-level form, using freer monads to represent nested coroutines , which are then compiled automatically to lower-level code with explicit state. In fact, our compiler is implemented as a tactic in the Coq proof assistant, structuring compilation as search for an equivalence proof for source and target programs. As such, it is straightforwardly (and soundly) extensible with new hints, for instance regarding new data structures that may be used for efficient lookup of coroutines. As a case study, we implemented a core of TLS sufficient for use with popular Web browsers, and our experiments show that the extracted Haskell code achieves reasonable performance.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498685", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mirai", + "last_name": "Ikebuchi", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Andres", + "last_name": "Erbsen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/IkebuchiEC22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498662", + "title": "Connectivity graphs: a method for proving deadlock freedom based on separation logic", + "abstract": "We introduce the notion of a connectivity graph —an abstract representation of the topology of concurrently interacting entities, which allows us to encapsulate generic principles of reasoning about deadlock freedom . Connectivity graphs are parametric in their vertices (representing entities like threads and channels) and their edges (representing references between entities) with labels (representing interaction protocols). We prove deadlock and memory leak freedom in the style of progress and preservation and use separation logic as a meta theoretic tool to treat connectivity graph edges and labels substructurally. To prove preservation locally, we distill generic separation logic rules for local graph transformations that preserve acyclicity of the connectivity graph. To prove global progress locally, we introduce a waiting induction principle for acyclic connectivity graphs. We mechanize our results in Coq, and instantiate our method with a higher-order binary session-typed language to obtain the first mechanized proof of deadlock and leak freedom.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498662", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/JacobsBK22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498716", + "title": "The leaky semicolon: compositional semantic dependencies for relaxed-memory concurrency", + "abstract": "Program logics and semantics tell a pleasant story about sequential composition: when executing (S1;S2), we first execute S1 then S2. To improve performance, however, processors execute instructions out of order, and compilers reorder programs even more dramatically. By design, single-threaded systems cannot observe these reorderings; however, multiple-threaded systems can, making the story considerably less pleasant. A formal attempt to understand the resulting mess is known as a “relaxed memory model.” Prior models either fail to address sequential composition directly, or overly restrict processors and compilers, or permit nonsense thin-air behaviors which are unobservable in practice. To support sequential composition while targeting modern hardware, we enrich the standard event-based approach with preconditions and families of predicate transformers. When calculating the meaning of (S1; S2), the predicate transformer applied to the precondition of an event e from S2 is chosen based on the set of events in S1 upon which e depends. We apply this approach to two existing memory models.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498716", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alan", + "last_name": "Jeffrey", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Riely", + "institution": "DePaul University" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + }, + { + "first_name": "Simon", + "last_name": "Cooksey", + "institution": "University of Kent" + }, + { + "first_name": "Ilya", + "last_name": "Kaysin", + "institution": "University of Cambridge" + }, + { + "first_name": "Anton", + "last_name": "Podkopaev", + "institution": "National Research University Higher School of Economics" + } + ], + "dblp_key": "journals/pacmpl/JeffreyRBCKP22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498720", + "title": "Return of CFA: call-site sensitivity can be superior to object sensitivity even for object-oriented programs", + "abstract": "In this paper, we challenge the commonly-accepted wisdom in static analysis that object sensitivity is superior to call-site sensitivity for object-oriented programs. In static analysis of object-oriented programs, object sensitivity has been established as the dominant flavor of context sensitivity thanks to its outstanding precision. On the other hand, call-site sensitivity has been regarded as unsuitable and its use in practice has been constantly discouraged for object-oriented programs. In this paper, however, we claim that call-site sensitivity is generally a superior context abstraction because it is practically possible to transform object sensitivity into more precise call-site sensitivity. Our key insight is that the previously known superiority of object sensitivity holds only in the traditional k -limited setting, where the analysis is enforced to keep the most recent k context elements. However, it no longer holds in a recently-proposed, more general setting with context tunneling. With context tunneling, where the analysis is free to choose an arbitrary k -length subsequence of context strings, we show that call-site sensitivity can simulate object sensitivity almost completely, but not vice versa. To support the claim, we present a technique, called Obj2CFA, for transforming arbitrary context-tunneled object sensitivity into more precise, context-tunneled call-site-sensitivity. We implemented Obj2CFA in Doop and used it to derive a new call-site-sensitive analysis from a state-of-the-art object-sensitive pointer analysis. Experimental results confirm that the resulting call-site sensitivity outperforms object sensitivity in precision and scalability for real-world Java programs. Remarkably, our results show that even 1-call-site sensitivity can be more precise than the conventional 3-object-sensitive analysis.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498720", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Minseok", + "last_name": "Jeon", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/JeonO22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498722", + "title": "Solving constrained Horn clauses modulo algebraic data types and recursive functions", + "abstract": "This work addresses the problem of verifying imperative programs that manipulate data structures, e.g., Rust programs. Data structures are usually modeled by Algebraic Data Types (ADTs) in verification conditions. Inductive invariants of such programs often require recursively defined functions (RDFs) to represent abstractions of data structures. From the logic perspective, this reduces to solving Constrained Horn Clauses (CHCs) modulo both ADT and RDF. The underlying logic with RDFs is undecidable. Thus, even verifying a candidate inductive invariant is undecidable. Similarly, IC3-based algorithms for solving CHCs lose their progress guarantee: they may not find counterexamples when the program is unsafe. We propose a novel IC3-inspired algorithm Racer for solving CHCs modulo ADT and RDF (i.e., automatically synthesizing inductive invariants, as opposed to only verifying them as is done in deductive verification). Racer ensures progress despite the undecidability of the underlying theory, and is guaranteed to terminate with a counterexample for unsafe programs. It works with a general class of RDFs over ADTs called catamorphisms. The key idea is to represent catamorphisms as both CHCs, via relationification , and RDFs, using novel abstractions . Encoding catamorphisms as CHCs allows learning inductive properties of catamorphisms, as well as preserving unsatisfiabilty of the original CHCs despite the use of RDF abstractions, whereas encoding catamorphisms as RDFs allows unfolding the recursive definition, and relying on it in solutions. Abstractions ensure that the underlying theory remains decidable. We implement our approach in Z3 and show that it works well in practice.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498722", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hari Govind V", + "last_name": "K", + "institution": "University of Waterloo" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + }, + { + "first_name": "Arie", + "last_name": "Gurfinkel", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/KSG22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498687", + "title": "Semantics for variational Quantum programming", + "abstract": "We consider a programming language that can manipulate both classical and quantum information. Our language is type-safe and designed for variational quantum programming, which is a hybrid classical-quantum computational paradigm. The classical subsystem of the language is the Probabilistic FixPoint Calculus (PFPC), which is a lambda calculus with mixed-variance recursive types, term recursion and probabilistic choice. The quantum subsystem is a first-order linear type system that can manipulate quantum information. The two subsystems are related by mixed classical/quantum terms that specify how classical probabilistic effects are induced by quantum measurements, and conversely, how classical (probabilistic) programs can influence the quantum dynamics. We also describe a sound and computationally adequate denotational semantics for the language. Classical probabilistic effects are interpreted using a recently-described commutative probabilistic monad on DCPO. Quantum effects and resources are interpreted in a category of von Neumann algebras that we show is enriched over (continuous) domains. This strong sense of enrichment allows us to develop novel semantic methods that we use to interpret the relationship between the quantum and classical probabilistic effects. By doing so we provide a very detailed denotational analysis that relates domain-theoretic models of classical probabilistic programming to models of quantum programming.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498687", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xiaodong", + "last_name": "Jia", + "institution": "Hunan University" + }, + { + "first_name": "Andre", + "last_name": "Kornell", + "institution": "Tulane University" + }, + { + "first_name": "Bert", + "last_name": "Lindenhovius", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Mislove", + "institution": "Tulane University" + }, + { + "first_name": "Vladimir", + "last_name": "Zamdzhiev", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/JiaKLMZ22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498700", + "title": "Mœbius: metaprogramming using contextual types: the stage where system f can pattern match on itself", + "abstract": "We describe the foundation of the metaprogramming language, Mœbius, which supports the generation of polymorphic code and, more importantly, the analysis of polymorphic code via pattern matching. Mœbius has two main ingredients: 1) we exploit contextual modal types to describe open code together with the context in which it is meaningful. In Mœbius, open code can depend on type and term variables (level 0) whose values are supplied at a later stage, as well as code variables (level 1) that stand for code templates supplied at a later stage. This leads to a multi-level modal lambda-calculus that supports System-F style polymorphism and forms the basis for polymorphic code generation. 2) we extend the multi-level modal lambda-calculus to support pattern matching on code. As pattern matching on polymorphic code may refine polymorphic type variables, we extend our type-theoretic foundation to generate and track typing constraints that arise. We also give an operational semantics and prove type preservation. Our multi-level modal foundation for Mœbius provides the appropriate abstractions for both generating and pattern matching on open code without committing to a concrete representation of variable binding and contexts. Hence, our work is a step towards building a general type-theoretic foundation for multi-staged metaprogramming that, on the one hand, enforces strong type guarantees and, on the other hand, makes it easy to generate and manipulate code. This will allow us to exploit the full potential of metaprogramming without sacrificing the reliability of and trust in the code we are producing and running.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498700", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Junyoung", + "last_name": "Jang", + "institution": "McGill University" + }, + { + "first_name": "Samuel", + "last_name": "Gélineau", + "institution": "Espace pour la vie" + }, + { + "first_name": "Stefan", + "last_name": "Monnier", + "institution": "Université de Montréal" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "journals/pacmpl/JangGMP22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498727", + "title": "What's decidable about linear loops?", + "abstract": "We consider the MSO model-checking problem for simple linear loops, or equivalently discrete-time linear dynamical systems, with semialgebraic predicates (i.e., Boolean combinations of polynomial inequalities on the variables). We place no restrictions on the number of program variables, or equivalently the ambient dimension. We establish decidability of the model-checking problem provided that each semialgebraic predicate either has intrinsic dimension at most 1, or is contained within some three-dimensional subspace. We also note that lifting either of these restrictions and retaining decidability would necessarily require major breakthroughs in number theory.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498727", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Toghrul", + "last_name": "Karimov", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Engel", + "last_name": "Lefaucheux", + "institution": "Computer Algorithms for Medicine" + }, + { + "first_name": "Joël", + "last_name": "Ouaknine", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "David", + "last_name": "Purser", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Anton", + "last_name": "Varonka", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Markus A.", + "last_name": "Whiteland", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "James", + "last_name": "Worrell", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/KarimovLOPVWW22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498673", + "title": "The decidability and complexity of interleaved bidirected Dyck reachability", + "abstract": "Dyck reachability is the standard formulation of a large domain of static analyses, as it achieves the sweet spot between precision and efficiency, and has thus been studied extensively. Interleaved Dyck reachability (denoted D k ⊙ D k ) uses two Dyck languages for increased precision (e.g., context and field sensitivity) but is well-known to be undecidable. As many static analyses yield a certain type of bidirected graphs, they give rise to interleaved bidirected Dyck reachability problems. Although these problems have seen numerous applications, their decidability and complexity has largely remained open. In a recent work, Li et al. made the first steps in this direction, showing that (i) D 1 ⊙ D 1 reachability (i.e., when both Dyck languages are over a single parenthesis and act as counters) is computable in O ( n 7 ) time, while (ii) D k ⊙ D k reachability is NP-hard. However, despite this recent progress, most natural questions about this intricate problem are open. In this work we address the decidability and complexity of all variants of interleaved bidirected Dyck reachability. First, we show that D 1 ⊙ D 1 reachability can be computed in O ( n 3 · α( n )) time, significantly improving over the existing O ( n 7 ) bound. Second, we show that D k ⊙ D 1 reachability (i.e., when one language acts as a counter) is decidable, in contrast to the non-bidirected case where decidability is open. We further consider D k ⊙ D 1 reachability where the counter remains linearly bounded. Our third result shows that this bounded variant can be solved in O ( n 2 · α( n )) time, while our fourth result shows that the problem has a (conditional) quadratic lower bound, and thus our upper bound is essentially optimal. Fifth, we show that full D k ⊙ D k reachability is undecidable. This improves the recent NP-hardness lower-bound, and shows that the problem is equivalent to the non-bidirected case. Our experiments on standard benchmarks show that the new algorithms are very fast in practice, offering many orders-of-magnitude speedups over previous methods.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498673", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Adam Husted", + "last_name": "Kjelstrøm", + "institution": "Aarhus University" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/KjelstromP22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498669", + "title": "A fine-grained computational interpretation of Girard's intuitionistic proof-nets", + "abstract": "This paper introduces a functional term calculus, called pn, that captures the essence of the operational semantics of Intuitionistic Linear Logic Proof-Nets with a faithful degree of granularity, both statically and dynamically. On the static side, we identify an equivalence relation on pn-terms which is sound and complete with respect to the classical notion of structural equivalence for proof-nets. On the dynamic side, we show that every single (exponential) step in the term calculus translates to a different single (exponential) step in the graphical formalism, thus capturing the original Girard’s granularity of proof-nets but on the level of terms. We also show some fundamental properties of the calculus such as confluence, strong normalization, preservation of β-strong normalization and the existence of a strong bisimulation that captures pairs of pn-terms having the same graph reduction.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498669", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Delia", + "last_name": "Kesner", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/Kesner22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498711", + "title": "Truly stateless, optimal dynamic partial order reduction", + "abstract": "Dynamic partial order reduction (DPOR) verifies concurrent programs by exploring all their interleavings up to some equivalence relation, such as the Mazurkiewicz trace equivalence. Doing so involves a complex trade-off between space and time. Existing DPOR algorithms are either exploration-optimal (i.e., explore exactly only interleaving per equivalence class) but may use exponential memory in the size of the program, or maintain polynomial memory consumption but potentially explore exponentially many redundant interleavings. In this paper, we show that it is possible to have the best of both worlds: exploring exactly one interleaving per equivalence class with linear memory consumption. Our algorithm, TruSt, formalized in Coq, is applicable not only to sequential consistency, but also to any weak memory model that satisfies a few basic assumptions, including TSO, PSO, and RC11. In addition, TruSt is embarrassingly parallelizable: its different exploration options have no shared state, and can therefore be explored completely in parallel. Consequently, TruSt outperforms the state-of-the-art in terms of memory and/or time.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498711", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Iason", + "last_name": "Marmanis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Vladimir", + "last_name": "Gladstein", + "institution": "St Petersburg University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/Kokologiannakis22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498705", + "title": "Fully abstract models for effectful λ-calculi via category-theoretic logical relations", + "abstract": "We present a construction which, under suitable assumptions, takes a model of Moggi’s computational λ-calculus with sum types, effect operations and primitives, and yields a model that is adequate and fully abstract. The construction, which uses the theory of fibrations, categorical glueing, ⊤⊤-lifting, and ⊤⊤-closure, takes inspiration from O’Hearn & Riecke’s fully abstract model for PCF. Our construction can be applied in the category of sets and functions, as well as the category of diffeological spaces and smooth maps and the category of quasi-Borel spaces, which have been studied as semantics for differentiable and probabilistic programming.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498705", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Edinburgh" + }, + { + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Philip", + "last_name": "Saville", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/KammarKS22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498710", + "title": "Provably correct, asymptotically efficient, higher-order reverse-mode automatic differentiation", + "abstract": "In this paper, we give a simple and efficient implementation of reverse-mode automatic differentiation, which both extends easily to higher-order functions, and has run time and memory consumption linear in the run time of the original program. In addition to a formal description of the translation, we also describe an implementation of this algorithm, and prove its correctness by means of a logical relations argument.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498710", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Faustyna", + "last_name": "Krawiec", + "institution": "University of Cambridge" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + }, + { + "first_name": "T. M. R.", + "last_name": "Ellis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "" + }, + { + "first_name": "Andrew", + "last_name": "Fitzgibbon", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/KrawiecJKEEF22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498688", + "title": "Isolation without taxation: near-zero-cost transitions for WebAssembly and SFI", + "abstract": "Software sandboxing or software-based fault isolation (SFI) is a lightweight approach to building secure systems out of untrusted components. Mozilla, for example, uses SFI to harden the Firefox browser by sandboxing third-party libraries, and companies like Fastly and Cloudflare use SFI to safely co-locate untrusted tenants on their edge clouds. While there have been significant efforts to optimize and verify SFI enforcement, context switching in SFI systems remains largely unexplored: almost all SFI systems use heavyweight transitions that are not only error-prone but incur significant performance overhead from saving, clearing, and restoring registers when context switching. We identify a set of zero-cost conditions that characterize when sandboxed code has sufficient structured to guarantee security via lightweight zero-cost transitions (simple function calls). We modify the Lucet Wasm compiler and its runtime to use zero-cost transitions, eliminating the undue performance tax on systems that rely on Lucet for sandboxing (e.g., we speed up image and font rendering in Firefox by up to 29.7% and 10% respectively). To remove the Lucet compiler and its correct implementation of the Wasm specification from the trusted computing base, we (1) develop a static binary verifier , VeriZero, which (in seconds) checks that binaries produced by Lucet satisfy our zero-cost conditions, and (2) prove the soundness of VeriZero by developing a logical relation that captures when a compiled Wasm function is semantically well-behaved with respect to our zero-cost conditions. Finally, we show that our model is useful beyond Wasm by describing a new, purpose-built SFI system, SegmentZero32, that uses x86 segmentation and LLVM with mostly off-the-shelf passes to enforce our zero-cost conditions; our prototype performs on-par with the state-of-the-art Native Client SFI system.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498688", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Kolosick", + "institution": "University of California San Diego" + }, + { + "first_name": "Shravan", + "last_name": "Narayan", + "institution": "University of California San Diego" + }, + { + "first_name": "Evan", + "last_name": "Johnson", + "institution": "University of California San Diego" + }, + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "University of Cambridge" + }, + { + "first_name": "Michael", + "last_name": "LeMay", + "institution": "Intel (United States)" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/KolosickNJWLGJS22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498671", + "title": "Learning formulas in finite variable logics", + "abstract": "We consider grammar-restricted exact learning of formulas and terms in finite variable logics. We propose a novel and versatile automata-theoretic technique for solving such problems. We first show results for learning formulas that classify a set of positively- and negatively-labeled structures. We give algorithms for realizability and synthesis of such formulas along with upper and lower bounds. We also establish positive results using our technique for other logics and variants of the learning problem, including first-order logic with least fixed point definitions, higher-order logics, and synthesis of queries and terms with recursively-defined functions.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498671", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul", + "last_name": "Krogmeier", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/KrogmeierM22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498680", + "title": "Effectful program distancing", + "abstract": "Semantics is traditionally concerned with program equivalence, in which all pairs of programs which are not equivalent are treated the same, and simply dubbed as incomparable. In recent years, various forms of program metrics have been introduced such that the distance between non-equivalent programs is measured as an element of an appropriate quantale. By letting the underlying quantale vary as the type of the compared programs become more complex, the recently introduced framework of differential logical relations allows for a new contextual form of reasoning. In this paper, we show that all this can be generalised to effectful higher-order programs, in which not only the values , but also the effects computations produce can be appropriately distanced in a principled way. We show that the resulting framework is flexible, allowing various forms of effects to be handled, and that it provides compact and informative judgments about program differences.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498680", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Francesco", + "last_name": "Gavazzo", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/LagoG22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498692", + "title": "A relational theory of effects and coeffects", + "abstract": "Graded modal types systems and coeffects are becoming a standard formalism to deal with context-dependent, usage-sensitive computations, especially when combined with computational effects. From a semantic perspective, effectful and coeffectful languages have been studied mostly by means of denotational semantics and almost nothing has been done from the point of view of relational reasoning. This gap in the literature is quite surprising, since many cornerstone results — such as non-interference , metric preservation , and proof irrelevance — on concrete coeffects are inherently relational. In this paper, we fill this gap by developing a general theory and calculus of program relations for higher-order languages with combined effects and coeffects. The relational calculus builds upon the novel notion of a corelator (or comonadic lax extension ) to handle coeffects relationally. Inside such a calculus, we define three notions of effectful and coeffectful program refinements: contextual approximation , logical preorder , and applicative similarity . These are the first operationally-based notions of program refinement (and, consequently, equivalence) for languages with combined effects and coeffects appearing in the literature. We show that the axiomatics of a corelator (together with the one of a relator) is precisely what is needed to prove all the aforementioned program refinements to be precongruences, this way obtaining compositional relational techniques for reasoning about combined effects and coeffects.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498692", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Francesco", + "last_name": "Gavazzo", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/LagoG22a", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498718", + "title": "A dual number abstraction for static analysis of Clarke Jacobians", + "abstract": "We present a novel abstraction for bounding the Clarke Jacobian of a Lipschitz continuous, but not necessarily differentiable function over a local input region. To do so, we leverage a novel abstract domain built upon dual numbers, adapted to soundly over-approximate all first derivatives needed to compute the Clarke Jacobian. We formally prove that our novel forward-mode dual interval evaluation produces a sound, interval domain-based over-approximation of the true Clarke Jacobian for a given input region. Due to the generality of our formalism, we can compute and analyze interval Clarke Jacobians for a broader class of functions than previous works supported – specifically, arbitrary compositions of neural networks with Lipschitz, but non-differentiable perturbations. We implement our technique in a tool called DeepJ and evaluate it on multiple deep neural networks and non-differentiable input perturbations to showcase both the generality and scalability of our analysis. Concretely, we can obtain interval Clarke Jacobians to analyze Lipschitz robustness and local optimization landscapes of both fully-connected and convolutional neural networks for rotational, contrast variation, and haze perturbations, as well as their compositions.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498718", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Laurel", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Rem", + "last_name": "Yang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/LaurelYSM22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498699", + "title": "Safe, modular packet pipeline programming", + "abstract": "The P4 language and programmable switch hardware, like the Intel Tofino, have made it possible for network engineers to write new programs that customize operation of computer networks, thereby improving performance, fault-tolerance, energy use, and security. Unfortunately, possible does not mean easy —there are many implicit constraints that programmers must obey if they wish their programs to compile to specialized networking hardware. In particular, all computations on the same switch must access data structures in a consistent order, or it will not be possible to lay that data out along the switch’s packet-processing pipeline. In this paper, we define Lucid 2.0, a new language and type system that guarantees programs access data in a consistent order and hence are pipeline-safe . Lucid 2.0 builds on top of the original Lucid language, which is also pipeline-safe, but lacks the features needed for modular construction of data structure libraries. Hence, Lucid 2.0 adds (1) polymorphism and ordering constraints for code reuse; (2) abstract, hierarchical pipeline locations and data types to support information hiding; (3) compile-time constructors, vectors and loops to allow for construction of flexible data structures; and (4) type inference to lessen the burden of program annotations. We develop the meta-theory of Lucid 2.0, prove soundness, and show how to encode constraint checking as an SMT problem. We demonstrate the utility of Lucid 2.0 by developing a suite of useful networking libraries and applications that exploit our new language features, including Bloom filters, sketches, cuckoo hash tables, distributed firewalls, DNS reflection defenses, network address translators (NATs) and a probabilistic traffic monitoring service.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498699", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Devon", + "last_name": "Loehr", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/LoehrW22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498664", + "title": "One polynomial approximation to produce correctly rounded results of an elementary function for multiple representations and rounding modes", + "abstract": "Mainstream math libraries for floating point (FP) do not produce correctly rounded results for all inputs. In contrast, CR-LIBM and RLIBM provide correctly rounded implementations for a specific FP representation with one rounding mode. Using such libraries for a representation with a new rounding mode or with different precision will result in wrong results due to double rounding. This paper proposes a novel method to generate a single polynomial approximation that produces correctly rounded results for all inputs for multiple rounding modes and multiple precision configurations. To generate a correctly rounded library for n -bits, our key idea is to generate a polynomial approximation for a representation with n +2-bits using the round-to-odd mode. We prove that the resulting polynomial approximation will produce correctly rounded results for all five rounding modes in the standard and for multiple representations with k -bits such that | E | +1 < k ≤ n , where | E | is the number of exponent bits in the representation. Similar to our prior work in the RLIBM project, we approximate the correctly rounded result when we generate the library with n +2-bits using the round-to-odd mode. We also generate polynomial approximations by structuring it as a linear programming problem but propose enhancements to polynomial generation to handle the round-to-odd mode. Our prototype is the first 32-bit float library that produces correctly rounded results with all rounding modes in the IEEE standard for all inputs with a single polynomial approximation. It also produces correctly rounded results for any FP configuration ranging from 10-bits to 32-bits while also being faster than mainstream libraries.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498664", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jay P.", + "last_name": "Lim", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "journals/pacmpl/LimN22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498681", + "title": "VIP: verifying real-world C idioms with integer-pointer casts", + "abstract": "Systems code often requires fine-grained control over memory layout and pointers, expressed using low-level ( e.g. , bitwise) operations on pointer values. Since these operations go beyond what basic pointer arithmetic in C allows, they are performed with the help of integer-pointer casts . Prior work has explored increasingly realistic memory object models for C that account for the desired semantics of integer-pointer casts while also being sound w.r.t. compiler optimisations, culminating in PNVI, the preferred memory object model in ongoing discussions within the ISO WG14 C standards committee. However, its complexity makes it an unappealing target for verification, and no tools currently exist to verify C programs under PNVI. In this paper, we introduce VIP, a new memory object model aimed at supporting C verification. VIP sidesteps the complexities of PNVI with a simple but effective idea: a new construct that lets programmers express the intended provenances of integer-pointer casts explicitly. At the same time, we prove VIP compatible with PNVI, thus enabling verification on top of VIP to benefit from PNVI’s validation with respect to practice. In particular, we build a verification tool, RefinedC-VIP, for verifying programs under VIP semantics. As the name suggests, RefinedC-VIP extends the recently developed RefinedC tool, which is automated yet also produces foundational proofs in Coq. We evaluate RefinedC-VIP on a range of systems-code idioms, and validate VIP’s expressiveness via an implementation in the Cerberus C semantics.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498681", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rodolphe", + "last_name": "Lepigre", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/LepigreSMKDS22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498724", + "title": "Efficient algorithms for dynamic bidirected Dyck-reachability", + "abstract": "Dyck-reachability is a fundamental formulation for program analysis, which has been widely used to capture properly-matched-parenthesis program properties such as function calls/returns and field writes/reads. Bidirected Dyck-reachability is a relaxation of Dyck-reachability on bidirected graphs where each edge u → ( i v labeled by an open parenthesis “( i ” is accompanied with an inverse edge v → ) i u labeled by the corresponding close parenthesis “) i ”, and vice versa. In practice, many client analyses such as alias analysis adopt the bidirected Dyck-reachability formulation. Bidirected Dyck-reachability admits an optimal reachability algorithm. Specifically, given a graph with n nodes and m edges, the optimal bidirected Dyck-reachability algorithm computes all-pairs reachability information in O ( m ) time. This paper focuses on the dynamic version of bidirected Dyck-reachability. In particular, we consider the problem of maintaining all-pairs Dyck-reachability information in bidirected graphs under a sequence of edge insertions and deletions. Dynamic bidirected Dyck-reachability can formulate many program analysis problems in the presence of code changes. Unfortunately, solving dynamic graph reachability problems is challenging. For example, even for maintaining transitive closure, the fastest deterministic dynamic algorithm requires O ( n 2 ) update time to achieve O (1) query time. All-pairs Dyck-reachability is a generalization of transitive closure. Despite extensive research on incremental computation, there is no algorithmic development on dynamic graph algorithms for program analysis with worst-case guarantees. Our work fills the gap and proposes the first dynamic algorithm for Dyck reachability on bidirected graphs. Our dynamic algorithms can handle each graph update ( i.e. , edge insertion and deletion) in O ( n ·α( n )) time and support any all-pairs reachability query in O (1) time, where α( n ) is the inverse Ackermann function. We have implemented and evaluated our dynamic algorithm on an alias analysis and a context-sensitive data-dependence analysis for Java. We compare our dynamic algorithms against a straightforward approach based on the O ( m )-time optimal bidirected Dyck-reachability algorithm and a recent incremental Datalog solver. Experimental results show that our algorithm achieves orders of magnitude speedup over both approaches.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498724", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuanbo", + "last_name": "Li", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Kris", + "last_name": "Satya", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LiSZ22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498717", + "title": "Verified tensor-program optimization via high-level scheduling rewrites", + "abstract": "We present a lightweight Coq framework for optimizing tensor kernels written in a pure, functional array language. Optimizations rely on user scheduling using series of verified, semantics-preserving rewrites. Unusually for compilation targeting imperative code with arrays and nested loops, all rewrites are source-to-source within a purely functional language. Our language comprises a set of core constructs for expressing high-level computation detail and a set of what we call reshape operators, which can be derived from core constructs but trigger low-level decisions about storage patterns and ordering. We demonstrate that not only is this system capable of deriving the optimizations of existing state-of-the-art languages like Halide and generating comparably performant code, it is also able to schedule a family of useful program transformations beyond what is reachable in Halide.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498717", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amanda", + "last_name": "Liu", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Gilbert", + "last_name": "Bernstein", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LiuBCR22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498697", + "title": "A Quantum interpretation of separating conjunction for local reasoning of Quantum programs based on separation logic", + "abstract": "It is well-known that quantum programs are not only complicated to design but also challenging to verify because the quantum states can have exponential size and require sophisticated mathematics to encode and manipulate. To tackle the state-space explosion problem for quantum reasoning, we propose a Hoare-style inference framework that supports local reasoning for quantum programs. By providing a quantum interpretation of the separating conjunction, we are able to infuse separation logic into our framework and apply local reasoning using a quantum frame rule that is similar to the classical frame rule. For evaluation, we apply our framework to verify various quantum programs including Deutsch–Jozsa’s algorithm and Grover's algorithm.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498697", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xuan-Bach D.", + "last_name": "Le", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Shang‐Wei", + "last_name": "Lin", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Jun", + "last_name": "Sun", + "institution": "Singapore Management University" + }, + { + "first_name": "David", + "last_name": "Sanán", + "institution": "Nanyang Technological University" + } + ], + "dblp_key": "journals/pacmpl/LeLSS22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498682", + "title": "Bottom-up synthesis of recursive functional programs using angelic execution", + "abstract": "We present a novel bottom-up method for the synthesis of functional recursive programs. While bottom-up synthesis techniques can work better than top-down methods in certain settings, there is no prior technique for synthesizing recursive programs from logical specifications in a purely bottom-up fashion. The main challenge is that effective bottom-up methods need to execute sub-expressions of the code being synthesized, but it is impossible to execute a recursive subexpression of a program that has not been fully constructed yet. In this paper, we address this challenge using the concept of angelic semantics. Specifically, our method finds a program that satisfies the specification under angelic semantics (we refer to this as angelic synthesis), analyzes the assumptions made during its angelic execution, uses this analysis to strengthen the specification, and finally reattempts synthesis with the strengthened specification. Our proposed angelic synthesis algorithm is based on version space learning and therefore deals effectively with many incremental synthesis calls made during the overall algorithm. We have implemented this approach in a prototype called Burst and evaluate it on synthesis problems from prior work. Our experiments show that Burst is able to synthesize a solution to 94% of the benchmarks in our benchmark suite, outperforming prior work.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498682", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Anders", + "last_name": "Miltner", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Adrian Trejo", + "last_name": "Nuñez", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ana", + "last_name": "Brendel", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/MiltnerNBCD22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498672", + "title": "A separation logic for heap space under garbage collection", + "abstract": "We present SL♢, a Separation Logic that allows controlling the heap space consumption of a program in the presence of dynamic memory allocation and garbage collection. A user of the logic works with space credits, a resource that is consumed when an object is allocated and produced when a group of objects is logically deallocated, that is, when the user is able to prove that it has become unreachable and therefore can be collected. To prove such a fact, the user maintains pointed-by assertions that record the immediate predecessors of every object. Our calculus, SpaceLang, has mutable state, shared-memory concurrency, and code pointers. We prove that SL♢ is sound and present several simple examples of its use.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498672", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jean-Marie", + "last_name": "Madiot", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/MadiotP22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498670", + "title": "A cost-aware logical framework", + "abstract": "We present calf , a c ost- a ware l ogical f ramework for studying quantitative aspects of functional programs. Taking inspiration from recent work that reconstructs traditional aspects of programming languages in terms of a modal account of phase distinctions , we argue that the cost structure of programs motivates a phase distinction between intension and extension . Armed with this technology, we contribute a synthetic account of cost structure as a computational effect in which cost-aware programs enjoy an internal noninterference property: input/output behavior cannot depend on cost. As a full-spectrum dependent type theory, calf presents a unified language for programming and specification of both cost and behavior that can be integrated smoothly with existing mathematical libraries available in type theoretic proof assistants. We evaluate calf as a general framework for cost analysis by implementing two fundamental techniques for algorithm analysis: the method of recurrence relations and physicist’s method for amortized analysis . We deploy these techniques on a variety of case studies: we prove a tight, closed bound for Euclid’s algorithm, verify the amortized complexity of batched queues, and derive tight, closed bounds for the sequential and parallel complexity of merge sort, all fully mechanized in the Agda proof assistant. Lastly we substantiate the soundness of quantitative reasoning in calf by means of a model construction.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498670", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yue", + "last_name": "Niu", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Sterling", + "institution": "Aarhus University" + }, + { + "first_name": "Harrison", + "last_name": "Grodin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/NiuSGH22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498708", + "title": "Static prediction of parallel computation graphs", + "abstract": "Many algorithms for analyzing parallel programs, for example to detect deadlocks or data races or to calculate the execution cost, are based on a model variously known as a cost graph, computation graph or dependency graph, which captures the parallel structure of threads in a program. In modern parallel programs, computation graphs are highly dynamic and depend greatly on the program inputs and execution details. As such, most analyses that use these graphs are either dynamic analyses or are specialized static analyses that gather a subset of dependency information for a specific purpose. This paper introduces graph types, which compactly represent all of the graphs that could arise from program execution. Graph types are inferred from a parallel program using a graph type system and inference algorithm, which we present drawing on ideas from Hindley-Milner type inference, affine logic and region type systems. We have implemented the inference algorithm over a subset of OCaml, extended with parallelism primitives, and we demonstrate how graph types can be used to accelerate the development of new graph-based static analyses by presenting proof-of-concept analyses for deadlock detection and cost analysis.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498708", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Illinois Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/Muller22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498694", + "title": "Visibility reasoning for concurrent snapshot algorithms", + "abstract": "Visibility relations have been proposed by Henzinger et al. as an abstraction for proving linearizability of concurrent algorithms that obtains modular and reusable proofs. This is in contrast to the customary approach based on exhibiting the algorithm's linearization points. In this paper we apply visibility relations to develop modular proofs for three elegant concurrent snapshot algorithms of Jayanti. The proofs are divided by signatures into components of increasing level of abstraction; the components at higher abstraction levels are shared, i.e., they apply to all three algorithms simultaneously. Importantly, the interface properties mathematically capture Jayanti's original intuitions that have previously been given only informally.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498694", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joakim", + "last_name": "Öhman", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software Institute" + } + ], + "dblp_key": "journals/pacmpl/OhmanN22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498704", + "title": "PRIMA: general and precise neural network certification via scalable convex hull approximations", + "abstract": "Formal verification of neural networks is critical for their safe adoption in real-world applications. However, designing a precise and scalable verifier which can handle different activation functions, realistic network architectures and relevant specifications remains an open and difficult challenge. In this paper, we take a major step forward in addressing this challenge and present a new verification framework, called PRIMA. PRIMA is both (i) general: it handles any non-linear activation function, and (ii) precise: it computes precise convex abstractions involving multiple neurons via novel convex hull approximation algorithms that leverage concepts from computational geometry. The algorithms have polynomial complexity, yield fewer constraints, and minimize precision loss. We evaluate the effectiveness of PRIMA on a variety of challenging tasks from prior work. Our results show that PRIMA is significantly more precise than the state-of-the-art, verifying robustness to input perturbations for up to 20%, 30%, and 34% more images than existing work on ReLU-, Sigmoid-, and Tanh-based networks, respectively. Further, PRIMA enables, for the first time, the precise verification of a realistic neural network for autonomous driving within a few minutes.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498704", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mark Niklas", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Gleb", + "last_name": "Makarchuk", + "institution": "ETH Zurich" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/MullerMSPV22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498712", + "title": "Induction duality: primal-dual search for invariants", + "abstract": "Many invariant inference techniques reason simultaneously about states and predicates, and it is well-known that these two kinds of reasoning are in some sense dual to each other. We present a new formal duality between states and predicates, and use it to derive a new primal-dual invariant inference algorithm. The new induction duality is based on a notion of provability by incremental induction that is formally dual to reachability, and the duality is surprisingly symmetric. The symmetry allows us to derive the dual of the well-known Houdini algorithm, and by combining Houdini with its dual image we obtain primal-dual Houdini , the first truly primal-dual invariant inference algorithm. An early prototype of primal-dual Houdini for the domain of distributed protocol verification can handle difficult benchmarks from the literature.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498712", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Stanford University" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "" + }, + { + "first_name": "Jason R.", + "last_name": "Koenig", + "institution": "Stanford University" + }, + { + "first_name": "Kenneth L.", + "last_name": "McMillan", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/PadonWKMA22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498709", + "title": "A formal foundation for symbolic evaluation with merging", + "abstract": "Reusable symbolic evaluators are a key building block of solver-aided verification and synthesis tools. A reusable evaluator reduces the semantics of all paths in a program to logical constraints, and a client tool uses these constraints to formulate a satisfiability query that is discharged with SAT or SMT solvers. The correctness of the evaluator is critical to the soundness of the tool and the domain properties it aims to guarantee. Yet so far, the trust in these evaluators has been based on an ad-hoc foundation of testing and manual reasoning. This paper presents the first formal framework for reasoning about the behavior of reusable symbolic evaluators. We develop a new symbolic semantics for these evaluators that incorporates state merging. Symbolic evaluators use state merging to avoid path explosion and generate compact encodings. To accommodate a wide range of implementations, our semantics is parameterized by a symbolic factory, which abstracts away the details of merging and creation of symbolic values. The semantics targets a rich language that extends Core Scheme with assumptions and assertions, and thus supports branching, loops, and (first-class) procedures. The semantics is designed to support reusability, by guaranteeing two key properties: legality of the generated symbolic states, and the reducibility of symbolic evaluation to concrete evaluation. Legality makes it simpler for client tools to formulate queries, and reducibility enables testing of client tools on concrete inputs. We use the Lean theorem prover to mechanize our symbolic semantics, prove that it is sound and complete with respect to the concrete semantics, and prove that it guarantees legality and reducibility. To demonstrate the generality of our semantics, we develop Leanette, a reference evaluator written in Lean, and Rosette 4, an optimized evaluator written in Racket. We prove Leanette correct with respect to the semantics, and validate Rosette 4 against Leanette via solver-aided differential testing. To demonstrate the practicality of our approach, we port 16 published verification and synthesis tools from Rosette 3 to Rosette 4. Rosette 3 is an existing reusable evaluator that implements the classic merging semantics, adopted from bounded model checking. Rosette 4 replaces the semantic core of Rosette 3 but keeps its optimized symbolic factory. Our results show that Rosette 4 matches the performance of Rosette 3 across a wide range of benchmarks, while providing a cleaner interface that simplifies the implementation of client tools.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498709", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sorawee", + "last_name": "Porncharoenwase", + "institution": "University of Washington" + }, + { + "first_name": "Luke", + "last_name": "Nelson", + "institution": "University of Washington" + }, + { + "first_name": "Xi", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/Porncharoenwase22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498668", + "title": "Linked visualisations via Galois dependencies", + "abstract": "We present new language-based dynamic analysis techniques for linking visualisations and other structured outputs to data in a fine-grained way, allowing users to explore how data attributes and visual or other output elements are related by selecting (focusing on) substructures of interest. Our approach builds on bidirectional program slicing techiques based on Galois connections, which provide desirable round-tripping properties. Unlike the prior work, our approach allows selections to be negated, equipping the bidirectional analysis with a De Morgan dual which can be used to link different outputs generated from the same input. This offers a principled language-based foundation for a popular view coordination feature called brushing and linking where selections in one chart automatically select corresponding elements in another related chart.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498668", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roly", + "last_name": "Perera", + "institution": "The Alan Turing Institute" + }, + { + "first_name": "Minh Son", + "last_name": "Nguyen", + "institution": "University of Bristol" + }, + { + "first_name": "Tomas", + "last_name": "Petricek", + "institution": "University of Kent" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/PereraNPW22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498665", + "title": "SolType: refinement types for arithmetic overflow in solidity", + "abstract": "As smart contracts gain adoption in financial transactions, it becomes increasingly important to ensure that they are free of bugs and security vulnerabilities. Of particular relevance in this context are arithmetic overflow bugs, as integers are often used to represent financial assets like account balances. Motivated by this observation, this paper presents SolType, a refinement type system for Solidity that can be used to prevent arithmetic over- and under-flows in smart contracts. SolType allows developers to add refinement type annotations and uses them to prove that arithmetic operations do not lead to over- and under-flows. SolType incorporates a rich vocabulary of refinement terms that allow expressing relationships between integer values and aggregate properties of complex data structures. Furthermore, our implementation, called Solid, incorporates a type inference engine and can automatically infer useful type annotations, including non-trivial contract invariants. To evaluate the usefulness of our type system, we use Solid to prove arithmetic safety of a total of 120 smart contracts. When used in its fully automated mode (i.e., using Solid's type inference capabilities), Solid is able to eliminate 86.3% of redundant runtime checks used to guard against overflows. We also compare Solid against a state-of-the-art arithmetic safety verifier called VeriSmart and show that Solid has a significantly lower false positive rate, while being significantly faster in terms of verification time.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498665", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Bryan", + "last_name": "Tan", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Benjamin", + "last_name": "Mariano", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "journals/pacmpl/TanMLDF22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498693", + "title": "Observational equality: now for good", + "abstract": "Building on the recent extension of dependent type theory with a universe of definitionally proof-irrelevant types, we introduce TTobs, a new type theory based on the setoidal interpretation of dependent type theory. TTobs equips every type with an identity relation that satisfies function extensionality, propositional extensionality, and definitional uniqueness of identity proofs (UIP). Compared to other existing proposals to enrich dependent type theory with these principles, our theory features a notion of reduction that is normalizing and provides an algorithmic canonicity result, which we formally prove in Agda using the logical relation framework of Abel et al. Our paper thoroughly develops the meta-theoretical properties of TTobs, such as the decidability of the conversion and of the type checking, as well as consistency. We also explain how to extend our theory with quotient types, and we introduce a setoidal version of Swan's Id types that turn it into a proper extension of MLTT with inductive equality.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498693", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Loïc", + "last_name": "Pujet", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/PujetT22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498675", + "title": "Interval universal approximation for neural networks", + "abstract": "To verify safety and robustness of neural networks, researchers have successfully applied abstract interpretation , primarily using the interval abstract domain. In this paper, we study the theoretical power and limits of the interval domain for neural-network verification. First, we introduce the interval universal approximation (IUA) theorem. IUA shows that neural networks not only can approximate any continuous function f (universal approximation) as we have known for decades, but we can find a neural network, using any well-behaved activation function, whose interval bounds are an arbitrarily close approximation of the set semantics of f (the result of applying f to a set of inputs). We call this notion of approximation interval approximation . Our theorem generalizes the recent result of Baader et al. from ReLUs to a rich class of activation functions that we call squashable functions . Additionally, the IUA theorem implies that we can always construct provably robust neural networks under ℓ ∞ -norm using almost any practical activation function. Second, we study the computational complexity of constructing neural networks that are amenable to precise interval analysis. This is a crucial question, as our constructive proof of IUA is exponential in the size of the approximation domain. We boil this question down to the problem of approximating the range of a neural network with squashable activation functions. We show that the range approximation problem (RA) is a Δ 2 -intermediate problem, which is strictly harder than NP -complete problems, assuming coNP ⊄ NP . As a result, IUA is an inherently hard problem : No matter what abstract domain or computational tools we consider to achieve interval approximation, there is no efficient construction of such a universal approximator. This implies that it is hard to construct a provably robust network, even if we have a robust network to start with.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498675", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zi", + "last_name": "Wang", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Gautam", + "last_name": "Prakriya", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Somesh", + "last_name": "Jha", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/WangAPJ22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498683", + "title": "Extending Intel-x86 consistency and persistency: formalising the semantics of Intel-x86 memory types and non-temporal stores", + "abstract": "Existing semantic formalisations of the Intel-x86 architecture cover only a small fragment of its available features that are relevant for the consistency semantics of multi-threaded programs as well as the persistency semantics of programs interfacing with non-volatile memory. We extend these formalisations to cover: (1) non-temporal writes, which provide higher performance and are used to ensure that updates are flushed to memory; (2) reads and writes to other Intel-x86 memory types, namely uncacheable, write-combined, and write-through; as well as (3) the interaction between these features. We develop our formal model in both operational and declarative styles, and prove that the two characterisations are equivalent. We have empirically validated our formalisation of the consistency semantics of these additional features and their subtle interactions by extensive testing on different Intel-x86 implementations.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498683", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RaadMV22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498691", + "title": "Twist: sound reasoning for purity and entanglement in Quantum programs", + "abstract": "Quantum programming languages enable developers to implement algorithms for quantum computers that promise computational breakthroughs in classically intractable tasks. Programming quantum computers requires awareness of entanglement , the phenomenon in which measurement outcomes of qubits are correlated. Entanglement can determine the correctness of algorithms and suitability of programming patterns. In this work, we formalize purity as a central tool for automating reasoning about entanglement in quantum programs. A pure expression is one whose evaluation is unaffected by the measurement outcomes of qubits that it does not own, implying freedom from entanglement with any other expression in the computation. We present Twist, the first language that features a type system for sound reasoning about purity. The type system enables the developer to identify pure expressions using type annotations. Twist also features purity assertion operators that state the absence of entanglement in the output of quantum gates. To soundly check these assertions, Twist uses a combination of static analysis and runtime verification. We evaluate Twist’s type system and analyses on a benchmark suite of quantum programs in simulation, demonstrating that Twist can express quantum algorithms, catch programming errors in them, and support programs that existing languages disallow, while incurring runtime verification overhead of less than 3.5%.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498691", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Charles", + "last_name": "Yuan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Christopher M.", + "last_name": "McNally", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/YuanMC22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498686", + "title": "Verified compilation of C programs with a nominal memory model", + "abstract": "Memory models play an important role in verified compilation of imperative programming languages. A representative one is the block-based memory model of CompCert---the state-of-the-art verified C compiler. Despite its success, the abstraction over memory space provided by CompCert's memory model is still primitive and inflexible. In essence, it uses a fixed representation for identifying memory blocks in a global memory space and uses a globally shared state for distinguishing between used and unused blocks. Therefore, any reasoning about memory must work uniformly for the global memory; it is impossible to individually reason about different sub-regions of memory (i.e., the stack and global definitions). This not only incurs unnecessary complexity in compiler verification, but also poses significant difficulty for supporting verified compilation of open or concurrent programs which need to work with contextual memory, as manifested in many previous extensions of CompCert. To remove the above limitations, we propose an enhancement to the block-based memory model based on nominal techniques; we call it the nominal memory model. By adopting the key concepts of nominal techniques such as atomic names and supports to model the memory space, we are able to 1) generalize the representation of memory blocks to any types satisfying the properties of atomic names and 2) remove the global constraints for managing memory blocks, enabling flexible memory structures for open and concurrent programs. To demonstrate the effectiveness of the nominal memory model, we develop a series of extensions of CompCert based on it. These extensions show that the nominal memory model 1) supports a general framework for verified compilation of C programs, 2) enables intuitive reasoning of compiler transformations on partial memory; and 3) enables modular reasoning about programs working with contextual memory. We also demonstrate that these extensions require limited changes to the original CompCert, making the verification techniques based on the nominal memory model easy to adopt.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498686", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuting", + "last_name": "Wang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Ling", + "last_name": "Zhang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/WangZSK22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498679", + "title": "From enhanced coinduction towards enhanced induction", + "abstract": "There exist a rich and well-developed theory of enhancements of the coinduction proof method, widely used on behavioural relations such as bisimilarity. We study how to develop an analogous theory for inductive behaviour relations, i.e., relations defined from inductive observables. Similarly to the coinductive setting, our theory makes use of (semi)-progressions of the form R->F(R), where R is a relation on processes and F is a function on relations, meaning that there is an appropriate match on the transitions that the processes in R can perform in which the process derivatives are in F(R). For a given preorder, an enhancement corresponds to a sound function, i.e., one for which R->F(R) implies that R is contained in the preorder; and similarly for equivalences. We introduce weights on the observables of an inductive relation, and a weight-preserving condition on functions that guarantees soundness. We show that the class of functions contains non-trivial functions and enjoys closure properties with respect to desirable function constructors, so to be able to derive sophisticated sound functions (and hence sophisticated proof techniques) from simpler ones. We consider both strong semantics (in which all actions are treated equally) and weak semantics (in which one abstracts from internal transitions). We test our enhancements on a few non-trivial examples.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498679", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Davide", + "last_name": "Sangiorgi", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/Sangiorgi22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498713", + "title": "Oblivious algebraic data types", + "abstract": "Secure computation allows multiple parties to compute joint functions over private data without leaking any sensitive data, typically using powerful cryptographic techniques. Writing secure applications using these techniques directly can be challenging, resulting in the development of several programming languages and compilers that aim to make secure computation accessible. Unfortunately, many of these languages either lack or have limited support for rich recursive data structures, like trees. In this paper, we propose a novel representation of structured data types, which we call oblivious algebraic data types, and a language for writing secure computations using them. This language combines dependent types with constructs for oblivious computation, and provides a security-type system which ensures that adversaries can learn nothing more than the result of a computation. Using this language, authors can write a single function over private data, and then easily build an equivalent secure computation according to a desired public view of their data.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498713", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Qianchuan", + "last_name": "Ye", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/YeD22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498723", + "title": "Staging with class: a specification for typed template Haskell", + "abstract": "Multi-stage programming using typed code quotation is an established technique for writing optimizing code generators with strong type-safety guarantees. Unfortunately, quotation in Haskell interacts poorly with type classes, making it difficult to write robust multi-stage programs. We study this unsound interaction and propose a resolution, staged type class constraints, which we formalize in a source calculus λ ⇒ that elaborates into an explicit core calculus F . We show type soundness of both calculi, establishing that well-typed, well-staged source programs always elaborate to well-typed, well-staged core programs, and prove beta and eta rules for code quotations. Our design allows programmers to incorporate type classes into multi-stage programs with confidence. Although motivated by Haskell, it is also suitable as a foundation for other languages that support both overloading and quotation.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498723", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Cambridge" + }, + { + "first_name": "Matthew C.", + "last_name": "Pickering", + "institution": "" + }, + { + "first_name": "Andres", + "last_name": "Löh", + "institution": "" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/XiePLWYW22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498677", + "title": "Reasoning about "reasoning about reasoning": semantics and contextual equivalence for probabilistic programs with nested queries and recursion", + "abstract": "Metareasoning can be achieved in probabilistic programming languages (PPLs) using agent models that recursively nest inference queries inside inference queries. However, the semantics of this powerful, reflection-like language feature has defied an operational treatment, much less reasoning principles for contextual equivalence. We give formal semantics to a core PPL with continuous distributions, scoring, general recursion, and nested queries. Unlike prior work, the presence of nested queries and general recursion makes it impossible to stratify the definition of a sampling-based operational semantics and that of a measure-theoretic semantics—the two semantics must be defined mutually recursively. A key yet challenging property we establish is that probabilistic programs have well-defined meanings: limits exist for the step-indexed measures they induce. Beyond a semantics, we offer relational reasoning principles for probabilistic programs making nested queries. We construct a step-indexed, biorthogonal logical-relations model. A soundness theorem establishes that logical relatedness implies contextual equivalence. We demonstrate the usefulness of the reasoning principles by proving novel equivalences of practical relevance—in particular, game-playing and decisionmaking agents. We mechanize our technical developments leading to the soundness proof using the Coq proof assistant. Nested queries are an important yet theoretically underdeveloped linguistic feature in PPLs; we are first to give them semantics in the presence of general recursion and to provide them with sound reasoning principles for contextual equivalence.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498677", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "Harvard University Press" + } + ], + "dblp_key": "journals/pacmpl/ZhangA22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498725", + "title": "Software model-checking as cyclic-proof search", + "abstract": "This paper shows that a variety of software model-checking algorithms can be seen as proof-search strategies for a non-standard proof system, known as a cyclic proof system . Our use of the cyclic proof system as a logical foundation of software model checking enables us to compare different algorithms, to reconstruct well-known algorithms from a few simple principles, and to obtain soundness proofs of algorithms for free. Among others, we show the significance of a heuristics based on a notion that we call maximal conservativity ; this explains the cores of important algorithms such as property-directed reachability (PDR) and reveals a surprising connection to an efficient solver of games over infinite graphs that was not regarded as a kind of PDR.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498725", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" + } + ], + "dblp_key": "journals/pacmpl/TsukadaU22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498703", + "title": "Layered and object-based game semantics", + "abstract": "Large-scale software verification relies critically on the use of compositional languages, semantic models, specifications, and verification techniques. Recent work on certified abstraction layers synthesizes game semantics, the refinement calculus, and algebraic effects to enable the composition of heterogeneous components into larger certified systems. However, in existing models of certified abstraction layers, compositionality is restricted by the lack of encapsulation of state. In this paper, we present a novel game model for certified abstraction layers where the semantics of layer interfaces and implementations are defined solely based on their observable behaviors. Our key idea is to leverage Reddy's pioneer work on modeling the semantics of imperative languages not as functions on global states but as objects with their observable behaviors. We show that a layer interface can be modeled as an object type (i.e., a layer signature) plus an object strategy. A layer implementation is then essentially a regular map, in the sense of Reddy, from an object with the underlay signature to that with the overlay signature. A layer implementation is certified when its composition with the underlay object strategy implements the overlay object strategy. We also describe an extension that allows for non-determinism in layer interfaces. After formulating layer implementations as regular maps between object spaces, we move to concurrency and design a notion of concurrent object space, where sequential traces may be identified modulo permutation of independent operations. We show how to express protected shared object concurrency, and a ticket lock implementation, in a simple model based on regular maps between concurrent object spaces.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498703", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arthur Oliveira", + "last_name": "Vale", + "institution": "Yale University" + }, + { + "first_name": "Paul-André", + "last_name": "Melliès", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" + }, + { + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/ValeMSKS22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498690", + "title": "On incorrectness logic and Kleene algebra with top and tests", + "abstract": "Kleene algebra with tests (KAT) is a foundational equational framework for reasoning about programs, which has found applications in program transformations, networking and compiler optimizations, among many other areas. In his seminal work, Kozen proved that KAT subsumes propositional Hoare logic, showing that one can reason about the (partial) correctness of while programs by means of the equational theory of KAT. In this work, we investigate the support that KAT provides for reasoning about incorrectness, instead, as embodied by O'Hearn's recently proposed incorrectness logic. We show that KAT cannot directly express incorrectness logic. The main reason for this limitation can be traced to the fact that KAT cannot express explicitly the notion of codomain, which is essential to express incorrectness triples. To address this issue, we study Kleene Algebra with Top and Tests (TopKAT), an extension of KAT with a top element. We show that TopKAT is powerful enough to express a codomain operation, to express incorrectness triples, and to prove all the rules of incorrectness logic sound. This shows that one can reason about the incorrectness of while-like programs by means of the equational theory of TopKAT.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498690", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cheng", + "last_name": "Zhang", + "institution": "Boston University" + }, + { + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "Boston University" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Boston University" + } + ], + "dblp_key": "journals/pacmpl/ZhangAG22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498696", + "title": "Relational e-matching", + "abstract": "We present a new approach to e-matching based on relational join; in particular, we apply recent database query execution techniques to guarantee worst-case optimal run time. Compared to the conventional backtracking approach that always searches the e-graph \"top down\", our new relational e-matching approach can better exploit pattern structure by searching the e-graph according to an optimized query plan. We also establish the first data complexity result for e-matching, bounding run time as a function of the e-graph size and output size. We prototyped and evaluated our technique in the state-of-the-art egg e-graph framework. Compared to a conventional baseline, relational e-matching is simpler to implement and orders of magnitude faster in practice.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498696", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yihong", + "last_name": "Zhang", + "institution": "University of Washington" + }, + { + "first_name": "Yisu Remy", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Max", + "last_name": "Willsey", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/ZhangWWT22", + "venue": "popl", + "year": 2022 + }, + { + "paper_id": "10.1145/3498695", + "title": "Concurrent incorrectness separation logic", + "abstract": "Incorrectness separation logic (ISL) was recently introduced as a theory of under-approximate reasoning, with the goal of proving that compositional bug catchers find actual bugs. However, ISL only considers sequential programs. Here, we develop concurrent incorrectness separation logic (CISL), which extends ISL to account for bug catching in concurrent programs. Inspired by the work on Views, we design CISL as a parametric framework, which can be instantiated for a number of bug catching scenarios, including race detection, deadlock detection, and memory safety error detection. For each instance, the CISL meta-theory ensures the soundness of incorrectness reasoning for free, thereby guaranteeing that the bugs detected are true positives.", + "date": "2022-01-12", + "link": "https://doi.org/10.1145/3498695", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Josh", + "last_name": "Berdine", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/RaadBDO22", + "venue": "popl", + "year": 2022 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2023.json b/data/pl_conferences/popl/2023.json new file mode 100644 index 0000000..200ec56 --- /dev/null +++ b/data/pl_conferences/popl/2023.json @@ -0,0 +1,2334 @@ +[ + { + "paper_id": "10.1145/3571202", + "title": "Formally Verified Native Code Generation in an Effectful JIT: Turning the CompCert Backend into a Formally Verified JIT Compiler", + "abstract": "Modern Just-in-Time compilers (or JITs) typically interleave several mechanisms to execute a program. For faster startup times and to observe the initial behavior of an execution, interpretation can be initially used. But after a while, JITs dynamically produce native code for parts of the program they execute often. Although some time is spent compiling dynamically, this mechanism makes for much faster times for the remaining of the program execution. Such compilers are complex pieces of software with various components, and greatly rely on a precise interplay between the different languages being executed, including on-stack-replacement. Traditional static compilers like CompCert have been mechanized in proof assistants, but JITs have been scarcely formalized so far, partly due to their impure nature and their numerous components. This work presents a model JIT with dynamic generation of native code, implemented and formally verified in Coq. Although some parts of a JIT cannot be written in Coq, we propose a proof methodology to delimit, specify and reason on the impure effects of a JIT. We argue that the daunting task of formally verifying a complete JIT should draw on existing proofs of native code generation. To this end, our work successfully reuses CompCert and its correctness proofs during dynamic compilation. Finally, our prototype can be extracted and executed.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571202", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aurèle", + "last_name": "Barrière", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/BarriereBP23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571244", + "title": "Quantitative Inhabitation for Different Lambda Calculi in a Unifying Framework", + "abstract": "We solve the inhabitation problem for a language called λ!, a subsuming paradigm (inspired by call-by-push-value) being able to encode, among others, call-by-name and call-by-value strategies of functional programming. The type specification uses a non-idempotent intersection type system, which is able to capture quantitative properties about the dynamics of programs. As an application, we show how our general methodology can be used to derive inhabitation algorithms for different lambda-calculi that are encodable into λ!.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571244", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Victor", + "last_name": "Arrial", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Giulio", + "last_name": "Guerrieri", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Delia", + "last_name": "Kesner", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/ArrialGK23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571195", + "title": "Step-Indexed Logical Relations for Countable Nondeterminism and Probabilistic Choice", + "abstract": "Developing denotational models for higher-order languages that combine probabilistic and nondeterministic choice is known to be very challenging. In this paper, we propose an alternative approach based on operational techniques. We study a higher-order language combining parametric polymorphism, recursive types, discrete probabilistic choice and countable nondeterminism. We define probabilistic generalizations of may- and must-termination as the optimal and pessimal probabilities of termination. Then we define step-indexed logical relations and show that they are sound and complete with respect to the induced contextual preorders. For may-equivalence we use step-indexing over the natural numbers whereas for must-equivalence we index over the countable ordinals. We then show than the probabilities of may- and must-termination coincide with the maximal and minimal probabilities of termination under all schedulers. Finally we derive the equational theory induced by contextual equivalence and show that it validates the distributive combination of the algebraic theories for probabilistic and nondeterministic choice.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571195", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/AguirreB23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571257", + "title": "Deconstructing the Calculus of Relations with Tape Diagrams", + "abstract": "Rig categories with finite biproducts are categories with two monoidal products, where one is a biproduct and the other distributes over it. In this work we present tape diagrams, a sound and complete diagrammatic language for these categories, that can be intuitively thought as string diagrams of string diagrams. We test the effectiveness of our approach against the positive fragment of Tarski's calculus of relations.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571257", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Filippo", + "last_name": "Bonchi", + "institution": "University of Pisa" + }, + { + "first_name": "Alessandro Di", + "last_name": "Giorgio", + "institution": "University of Pisa" + }, + { + "first_name": "Alessio", + "last_name": "Santamaria", + "institution": "University of Pisa" + } + ], + "dblp_key": "journals/pacmpl/BonchiGS23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571230", + "title": "A Robust Theory of Series Parallel Graphs", + "abstract": "Motivated by distributed data processing applications, we introduce a class of labeled directed acyclic graphs constructed using sequential and parallel composition operations, and study automata and logics over them. We show that deterministic and non-deterministic acceptors over such graphs have the same expressive power, which can be equivalently characterized by Monadic Second-Order logic and the graded µ-calculus. We establish closure under composition operations and decision procedures for membership, emptiness, and inclusion. A key feature of our graphs, called synchronized series-parallel graphs (SSPG), is that parallel composition introduces a synchronization edge from the newly introduced source vertex to the sink. The transfer of information enabled by such edges is crucial to the determinization construction, which would not be possible for the traditional definition of series-parallel graphs. SSPGs allow both ordered ranked parallelism and unordered unranked parallelism. The latter feature means that in the corresponding automata, the transition function needs to account for an arbitrary number of predecessors by counting each type of state only up to a specified constant, thus leading to a notion of counting complexity that is distinct from the classical notion of state complexity. The determinization construction translates a nondeterministic automaton with n states and k counting complexity to a deterministic automaton with 2 n 2 states and kn counting complexity, and both these bounds are shown to be tight. Furthermore, for nondeterministic automata a bound of 2 on counting complexity suffices without loss of expressiveness.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571230", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Caleb", + "last_name": "Stanford", + "institution": "" + }, + { + "first_name": "Christopher", + "last_name": "Watson", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/AlurSW23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571266", + "title": "Context-Bounded Verification of Context-Free Specifications", + "abstract": "A fundamental problem in refinement verification is to check that the language of behaviors of an implementation is included in the language of the specification. We consider the refinement verification problem where the implementation is a multithreaded shared memory system modeled as a multistack pushdown automaton and the specification is an input-deterministic multistack pushdown language. Our main result shows that the context-bounded refinement problem, where we ask that all behaviors generated in runs of bounded number of context switches belong to a specification given by a Dyck language, is decidable and coNP-complete. The more general case of input-deterministic languages follows, with the same complexity. Context-bounding is essential since emptiness for multipushdown automata is already undecidable, and so is the refinement verification problem for the subclass of regular specifications. Input-deterministic languages capture many non-regular specifications of practical interest and our result opens the way for algorithmic analysis of these properties. The context-bounded refinement problem is coNP-hard already with deterministic regular specifications; our result demonstrates that the problem is not harder despite the stronger class of specifications. Our proof introduces several general techniques for formal languages and counter programs and shows that the search for counterexamples can be reduced in non-deterministic polynomial time to the satisfiability problem for existential Presburger arithmetic. These techniques are essential to ensure the coNP upper bound: existing techniques for regular specifications are not powerful enough for decidability, while simple reductions lead to problems that are either undecidable or have high complexities. As a special case, our decidability result gives an algorithmic verification technique to reason about reference counting and re-entrant locking in multithreaded programs.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571266", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pascal", + "last_name": "Baumann", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Moses", + "last_name": "Ganardi", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ramanathan S.", + "last_name": "Thinniyam", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/BaumannGMTZ23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571234", + "title": "Top-Down Synthesis for Library Learning", + "abstract": "This paper introduces corpus-guided top-down synthesis as a mechanism for synthesizing library functions that capture common functionality from a corpus of programs in a domain specific language (DSL). The algorithm builds abstractions directly from initial DSL primitives, using syntactic pattern matching of intermediate abstractions to intelligently prune the search space and guide the algorithm towards abstractions that maximally capture shared structures in the corpus. We present an implementation of the approach in a tool called Stitch and evaluate it against the state-of-the-art deductive library learning algorithm from DreamCoder. Our evaluation shows that Stitch is 3-4 orders of magnitude faster and uses 2 orders of magnitude less memory while maintaining comparable or better library quality (as measured by compressivity). We also demonstrate Stitch’s scalability on corpora containing hundreds of complex programs that are intractable with prior deductive approaches and show empirically that it is robust to terminating the search procedure early—further allowing it to scale to challenging datasets by means of early stopping.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571234", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew L.", + "last_name": "Bowers", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Theo", + "last_name": "Olausson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Lionel", + "last_name": "Wong", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Gabriel", + "last_name": "Grand", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Joshua B.", + "last_name": "Tenenbaum", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Kevin", + "last_name": "Ellis", + "institution": "Cornell University" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BowersOWGTES23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571213", + "title": "An Algebra of Alignment for Relational Verification", + "abstract": "Relational verification encompasses information flow security, regression verification, translation validation for compilers, and more. Effective alignment of the programs and computations to be related facilitates use of simpler relational invariants and relational procedure specs, which in turn enables automation and modular reasoning. Alignment has been explored in terms of trace pairs, deductive rules of relational Hoare logics (RHL), and several forms of product automata. This article shows how a simple extension of Kleene Algebra with Tests (KAT), called BiKAT, subsumes prior formulations, including alignment witnesses for forall-exists properties, which brings to light new RHL-style rules for such properties. Alignments can be discovered algorithmically or devised manually but, in either case, their adequacy with respect to the original programs must be proved; an explicit algebra enables constructive proof by equational reasoning. Furthermore our approach inherits algorithmic benefits from existing KAT-based techniques and tools, which are applicable to a range of semantic models.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571213", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Timos", + "last_name": "Antonopoulos", + "institution": "Yale University" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Ton Chanh", + "last_name": "Le", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Ramana", + "last_name": "Nagasamudram", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "David A.", + "last_name": "Naumann", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Minh", + "last_name": "Ngo", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AntonopoulosKLNNN23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571207", + "title": "babble: Learning Better Abstractions with E-Graphs and Anti-unification", + "abstract": "Library learning compresses a given corpus of programs by extracting common structure from the corpus into reusable library functions. Prior work on library learning suffers from two limitations that prevent it from scaling to larger, more complex inputs. First, it explores too many candidate library functions that are not useful for compression. Second, it is not robust to syntactic variation in the input. We propose library learning modulo theory (LLMT), a new library learning algorithm that additionally takes as input an equational theory for a given problem domain. LLMT uses e-graphs and equality saturation to compactly represent the space of programs equivalent modulo the theory, and uses a novel e-graph anti-unification technique to find common patterns in the corpus more directly and efficiently. We implemented LLMT in a tool named babble. Our evaluation shows that babble achieves better compression orders of magnitude faster than the state of the art. We also provide a qualitative evaluation showing that babble learns reusable functions on inputs previously out of reach for library learning.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571207", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Cao", + "institution": "University of California San Diego" + }, + { + "first_name": "Rose", + "last_name": "Kunkel", + "institution": "University of California San Diego" + }, + { + "first_name": "Chandrakana", + "last_name": "Nandi", + "institution": "" + }, + { + "first_name": "Max", + "last_name": "Willsey", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/CaoKNWTP23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571217", + "title": "The Geometry of Causality: Multi-token Geometry of Interaction and Its Causal Unfolding", + "abstract": "We introduce a multi-token machine for Idealized Parallel Algol (IPA), a higher-order concurrent programming language with shared state and semaphores. Our machine takes the shape of a compositional interpretation of terms as Petri structures, certain coloured Petri nets. For the purely functional fragment of IPA, our machine is conceptually close to Geometry of Interaction token machines, originating from Linear Logic and presenting higher-order computation as the low-level process of a token walking through a graph (a proof net) representing the term. We combine here these ideas with folklore ideas on the representation of first-order imperative concurrent programs as coloured Petri nets. To prove our machine computationally adequate with respect to the reference operational semantics, we follow game semantics and represent types as certain games specifying dependencies and conflict between computational events. Petri strategies are those Petri structures obeying the rules of the game extracted from the type. We show how Petri strategies unfold to concurrent strategies in the sense of concurrent games on event structures. This link with concurrent strategies not only allows us to prove adequacy of our machine, but also lets us generate operationally a causal description of the behaviour of programs at higher-order types, which is shown to coincide with that given denotationally by the interpretation in concurrent games.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571217", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Simon", + "last_name": "Castellan", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Pierre", + "last_name": "Clairambault", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/CastellanC23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571260", + "title": "A Calculus for Amortized Expected Runtimes", + "abstract": "We develop a weakest-precondition-style calculus à la Dijkstra for reasoning about amortized expected runtimes of randomized algorithms with access to dynamic memory — the aert calculus. Our calculus is truly quantitative, i.e. instead of Boolean valued predicates, it manipulates real-valued functions. En route to the aert calculus, we study the ert calculus for reasoning about expected runtimes of Kaminski et al. [2018] extended by capabilities for handling dynamic memory, thus enabling compositional and local reasoning about randomized data structures . This extension employs runtime separation logic , which has been foreshadowed by Matheja [2020] and then implemented in Isabelle/HOL by Haslbeck [2021]. In addition to Haslbeck’s results, we further prove soundness of the so-extended ert calculus with respect to an operational Markov decision process model featuring countably-branching nondeterminism, provide extensive intuitive explanations, and provide proof rules enabling separation logic-style verification for upper bounds on expected runtimes. Finally, we build the so-called potential method for amortized analysis into the ert calculus, thus obtaining the aert calculus. Soundness of the aert calculus is obtained from the soundness of the ert calculus and some probabilistic form of telescoping. Since one needs to be able to handle changes in potential which can in principle be both positive or negative, the aert calculus needs to be — essentially — capable of handling certain signed random variables. A particularly pleasing feature of our solution is that, unlike e.g. Kozen [1985], we obtain a loop rule for our signed random variables, and furthermore, unlike e.g. Kaminski and Katoen [2017], the aert calculus makes do without the need for involved technical machinery keeping track of the integrability of the random variables. Finally, we present case studies, including a formal analysis of a randomized delete-insert-find-any set data structure [Brodal et al. 1996], which yields a constant expected runtime per operation, whereas no deterministic algorithm can achieve this.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571260", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "" + }, + { + "first_name": "Lena", + "last_name": "Verscht", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/BatzKKMV23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571226", + "title": "FlashFill++: Scaling Programming by Example by Cutting to the Chase", + "abstract": "Programming-by-Examples (PBE) involves synthesizing an \"intended program\" from a small set of user-provided input-output examples. A key PBE strategy has been to restrict the search to a carefully designed small domain-specific language (DSL) with \"effectively-invertible\" (EI) operators at the top and \"effectively-enumerable\" (EE) operators at the bottom. This facilitates an effective combination of top-down synthesis strategy (which backpropagates outputs over various paths in the DSL using inverse functions) with a bottom-up synthesis strategy (which propagates inputs over various paths in the DSL). We address the problem of scaling synthesis to large DSLs with several non-EI/EE operators. This is motivated by the need to support a richer class of transformations and the need for readable code generation. We propose a novel solution strategy that relies on propagating fewer values and over fewer paths. Our first key idea is that of \"cut functions\" that prune the set of values being propagated by using knowledge of the sub-DSL on the other side. Cuts can be designed to preserve completeness of synthesis; however, DSL designers may use incomplete cuts to have finer control over the kind of programs synthesized. In either case, cuts make search feasible for non-EI/EE operators and efficient for deep DSLs. Our second key idea is that of \"guarded DSLs\" that allow a precedence on DSL operators, which dynamically controls exploration of various paths in the DSL. This makes search efficient over grammars with large fanouts without losing recall. It also makes ranking simpler yet more effective in learning an intended program from very few examples. Both cuts and precedence provide a mechanism to the DSL designer to restrict search to a reasonable, and possibly incomplete, space of programs. Using cuts and gDSLs, we have built FlashFill++, an industrial-strength PBE engine for performing rich string transformations, including datetime and number manipulations. The FlashFill++ gDSL is designed to enable readable code generation in different target languages including Excel's formula language, PowerFx, and Python. We show FlashFill++ is more expressive, more performant, and generates better quality code than comparable existing PBE systems. FlashFill++ is being deployed in several mass-market products ranging from spreadsheet software to notebooks and business intelligence applications, each with millions of users.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571226", + "conference_name": "POPL", + "authors": [ + { + "first_name": "José", + "last_name": "Cambronero", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Daniel", + "last_name": "Perelman", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Clint", + "last_name": "Simon", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/CambroneroGLPRST23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571254", + "title": "Choice Trees: Representing Nondeterministic, Recursive, and Impure Programs in Coq", + "abstract": "This paper introduces ctrees, a monad for modeling nondeterministic, recursive, and impure programs in Coq. Inspired by Xia et al.'s itrees, this novel data structure embeds computations into coinductive trees with three kind of nodes: external events, and two variants of nondeterministic branching. This apparent redundancy allows us to provide shallow embedding of denotational models with internal choice in the style of CCS, while recovering an inductive LTS view of the computation. ctrees inherit a vast collection of bisimulation and refinement tools, with respect to which we establish a rich equational theory. We connect ctrees to the itree infrastructure by showing how a monad morphism embedding the former into the latter permits to use ctrees to implement nondeterministic effects. We demonstrate the utility of ctrees by using them to model concurrency semantics in two case studies: CCS and cooperative multithreading.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571254", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Chappe", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Paul", + "last_name": "He", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Ludovic", + "last_name": "Henrio", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/ChappeHHZZ23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571196", + "title": "A Type-Based Approach to Divide-and-Conquer Recursion in Coq", + "abstract": "This paper proposes a new approach to writing and verifying divide-and-conquer programs in Coq. Extending the rich line of previous work on algebraic approaches to recursion schemes, we present an algebraic approach to divide-and-conquer recursion: recursions are represented as a form of algebra, and from outer recursions, one may initiate inner recursions that can construct data upon which the outer recursions may legally recurse. Termination is enforced entirely by the typing discipline of our recursion schemes. Despite this, our approach requires little from the underlying type system, and can be implemented in System F ω plus a limited form of positive-recursive types. Our implementation of the method in Coq does not rely on structural recursion or on dependent types. The method is demonstrated on several examples, including mergesort, quicksort, Harper’s regular-expression matcher, and others. An indexed version is also derived, implementing a form of divide-and-conquer induction that can be used to reason about functions defined via our method.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571196", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pedro", + "last_name": "Abreu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Alex", + "last_name": "Hubers", + "institution": "University of Iowa" + }, + { + "first_name": "Christa", + "last_name": "Jenkins", + "institution": "University of Iowa" + }, + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Iowa" + }, + { + "first_name": "Aaron", + "last_name": "Stump", + "institution": "University of Iowa" + } + ], + "dblp_key": "journals/pacmpl/AbreuDHJMS23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571200", + "title": "From SMT to ASP: Solver-Based Approaches to Solving Datalog Synthesis-as-Rule-Selection Problems", + "abstract": "Given a set of candidate Datalog rules, the Datalog synthesis-as-rule-selection problem chooses a subset of these rules that satisfies a specification (such as an input-output example). Building off prior work using counterexample-guided inductive synthesis, we present a progression of three solver-based approaches for solving Datalog synthesis-as-rule-selection problems. Two of our approaches offer some advantages over existing approaches, and can be used more generally to solve arbitrary SMT formulas containing Datalog predicates; the third—an encoding into standard, off-the-shelf answer set programming (ASP)—leads to significant speedups (∼ 9× geomean) over the state of the art while synthesizing higher quality programs. Our progression of solutions explores the space of interactions between SAT/SMT and Datalog, identifying ASP as a promising tool for working with and reasoning about Datalog. Along the way, we identify Datalog programs as monotonic SMT theories, which enjoy particularly efficient interactions in SMT; our plugins for popular SMT solvers make it easy to load an arbitrary Datalog program into the SMT solver as a custom monotonic theory. Finally, we evaluate our approaches using multiple underlying solvers to provide a more thorough and nuanced comparison against the current state of the art.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571200", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Bembenek", + "institution": "Harvard University Press" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "journals/pacmpl/BembenekGC23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571240", + "title": "Dargent: A Silver Bullet for Verified Data Layout Refinement", + "abstract": "Systems programmers need fine-grained control over the memory layout of data structures, both to produce performant code and to comply with well-defined interfaces imposed by existing code, standardised protocols or hardware. Code that manipulates these low-level representations in memory is hard to get right. Traditionally, this problem is addressed by the implementation of tedious marshalling code to convert between compiler-selected data representations and the desired compact data formats. Such marshalling code is error-prone and can lead to a significant runtime overhead due to excessive copying. While there are many languages and systems that address the correctness issue, by automating the generation and, in some cases, the verification of the marshalling code, the performance overhead introduced by the marshalling code remains. In particular for systems code, this overhead can be prohibitive. In this work, we address both the correctness and the performance problems. We present a data layout description language and data refinement framework, called Dargent, which allows programmers to declaratively specify how algebraic data types are laid out in memory. Our solution is applied to the Cogent language, but the general ideas behind our solution are applicable to other settings. The Dargent framework generates C code that manipulates data directly with the desired memory layout, while retaining the formal proof that this generated C code is correct with respect to the functional semantics. This added expressivity removes the need for implementing and verifying marshalling code, which eliminates copying, smoothens interoperability with surrounding systems, and increases the trustworthiness of the overall system.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571240", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zilin", + "last_name": "Chen", + "institution": "UNSW Sydney" + }, + { + "first_name": "Ambroise", + "last_name": "Lafont", + "institution": "University of Cambridge" + }, + { + "first_name": "Liam", + "last_name": "O’Connor", + "institution": "University of Edinburgh" + }, + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "Utrecht University" + }, + { + "first_name": "Craig", + "last_name": "McLaughlin", + "institution": "UNSW Sydney" + }, + { + "first_name": "Vincent", + "last_name": "Jackson", + "institution": "The University of Melbourne" + }, + { + "first_name": "Christine", + "last_name": "Rizkallah", + "institution": "The University of Melbourne" + } + ], + "dblp_key": "journals/pacmpl/ChenLOKMJR23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571219", + "title": "The Path to Durable Linearizability", + "abstract": "There is an increasing body of literature proposing new and efficient persistent versions of concurrent data structures ensuring that a consistent state can be recovered after a power failure or a crash. Their correctness is typically stated in terms of durable linearizability (DL), which requires that individual library operations appear to be executed atomically in a sequence consistent with the real-time order and, moreover, that recovering from a crash return a state corresponding to a prefix of that sequence. Sadly, however, there are hardly any formal DL proofs, and those that do exist cover the correctness of rather simple persistent algorithms on specific (simplified) persistency models. In response, we propose a general, powerful, modular, and incremental proof technique that can be used to guide the development and establish DL. Our technique is (1) general , in that it is not tied to a specific persistency and/or consistency model, (2) powerful , in that it can handle the most advanced persistent algorithms in the literature, (3) modular , in that it allows the reuse of an existing linearizability argument, and (4) incremental , in that the additional requirements for establishing DL depend on the complexity of the algorithm to be verified. We illustrate this technique on various versions of a persistent set, leading to the link-free set of Zuriel et al.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571219", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Emanuele", + "last_name": "D’Osualdo", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/DOsualdoRV23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571249", + "title": "Combining Functional and Automata Synthesis to Discover Causal Reactive Programs", + "abstract": "We present a new algorithm that synthesizes functional reactive programs from observation data. The key novelty is to iterate between a functional synthesis step, which attempts to generate a transition function over observed states, and an automata synthesis step, which adds any additional latent state necessary to fully account for the observations. We develop a functional reactive DSL called Autumn that can express a rich variety of causal dynamics in time-varying, Atari-style grid worlds, and apply our method to synthesize Autumn programs from data. We evaluate our algorithm on a benchmark suite of 30 Autumn programs as well as a third-party corpus of grid-world-style video games. We find that our algorithm synthesizes 27 out of 30 programs in our benchmark suite and 21 out of 27 programs from the third-party corpus, including several programs describing complex latent state transformations, and from input traces containing hundreds of observations. We expect that our approach will provide a template for how to integrate functional and automata synthesis in other induction domains.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571249", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ria", + "last_name": "Das", + "institution": "Stanford University" + }, + { + "first_name": "Joshua B.", + "last_name": "Tenenbaum", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Zenna", + "last_name": "Tavares", + "institution": "BASIS International (United States)" + } + ], + "dblp_key": "journals/pacmpl/DasTST23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571259", + "title": "Probabilistic Resource-Aware Session Types", + "abstract": "Session types guarantee that message-passing processes adhere to predefined communication protocols. Prior work on session types has focused on deterministic languages but many message-passing systems, such as Markov chains and randomized distributed algorithms, are probabilistic. To implement and analyze such systems, this article develops the meta theory of probabilistic session types with an application focus on automatic expected resource analysis. Probabilistic session types describe probability distributions over messages and are a conservative extension of intuitionistic (binary) session types. To send on a probabilistic channel, processes have to utilize internal randomness from a probabilistic branching or external randomness from receiving on a probabilistic channel. The analysis for expected resource bounds is smoothly integrated with the type system and is a variant of automatic amortized resource analysis. Type inference relies on linear constraint solving to automatically derive symbolic bounds for various cost metrics. The technical contributions include the meta theory that is based on a novel nested multiverse semantics and a type-reconstruction algorithm that allows flexible mixing of different sources of randomness without burdening the programmer with complex type annotations. The type system has been implemented in the language NomosPro with linear-time type checking. Experiments demonstrate that NomosPro is applicable in different domains such as cost analysis of randomized distributed algorithms, analysis of Markov chains, probabilistic analysis of amortized data structures and digital contracts. NomosPro is also shown to be scalable by (i) implementing two broadcast and a bounded retransmission protocol where messages are dropped with a fixed probability, and (ii) verifying the limiting distribution of a Markov chain with 64 states and 420 transitions.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571259", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ankush", + "last_name": "Das", + "institution": "Amazon (United States)" + }, + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/DasWH23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571242", + "title": "Stratified Commutativity in Verification Algorithms for Concurrent Programs", + "abstract": "The importance of exploiting commutativity relations in verification algorithms for concurrent programs is well-known. They can help simplify the proof and improve the time and space efficiency. This paper studies commutativity relations as a first-class object in the setting of verification algorithms for concurrent programs. A first contribution is a general framework for abstract commutativity relations . We introduce a general soundness condition for commutativity relations, and present a method to automatically derive sound abstract commutativity relations from a given proof. The method can be used in a verification algorithm based on abstraction refinement to compute a new commutativity relation in each iteration of the abstraction refinement loop. A second result is a general proof rule that allows one to combine multiple commutativity relations, with incomparable power, in a stratified way that preserves soundness and allows one to profit from the full power of the combined relations. We present an algorithm for the stratified proof rule that performs an optimal combination (in a sense made formal), enabling usage of stratified commutativity in algorithmic verification. We empirically evaluate the impact of abstract commutativity and stratified combination of commutativity relations on verification algorithms for concurrent programs.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571242", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Dominik", + "last_name": "Klumpp", + "institution": "University of Freiburg" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + } + ], + "dblp_key": "journals/pacmpl/FarzanKP23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571248", + "title": "A Partial Order View of Message-Passing Communication Models", + "abstract": "There is a wide variety of message-passing communication models, ranging from synchronous \"rendez-vous\" communications to fully asynchronous/out-of-order communications. For large-scale distributed systems, the communication model is determined by the transport layer of the network, and a few classes of orders of message delivery (FIFO, causally ordered) have been identified in the early days of distributed computing. For local-scale message-passing applications, e.g., running on a single machine, the communication model may be determined by the actual implementation of message buffers and by how FIFO queues are used. While large-scale communication models, such as causal ordering, are defined by logical axioms, local-scale models are often defined by an operational semantics. In this work, we connect these two approaches, and we present a unified hierarchy of communication models encompassing both large-scale and local-scale models, based on their concurrent behaviors. We also show that all the communication models we consider can be axiomatized in the monadic second order logic, and may therefore benefit from several bounded verification techniques based on bounded special treewidth.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571248", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cinzia Di", + "last_name": "Giusto", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Davide", + "last_name": "Ferré", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Laetitia", + "last_name": "Laversa", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Étienne", + "last_name": "Lozes", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/GiustoFLL23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571203", + "title": "On the Expressive Power of String Constraints", + "abstract": "We investigate properties of strings which are expressible by canonical types of string constraints. Specifically, we consider a landscape of 20 logical theories, whose syntax is built around combinations of four common elements of string constraints: language membership (e.g. for regular languages), concatenation, equality between string terms, and equality between string-lengths. For a variable x and formula f from a given theory, we consider the set of values for which x may be substituted as part of a satisfying assignment, or in other words, the property f expresses through x. Since we consider string-based logics, this set is a formal language. We firstly consider the relative expressive power of different combinations of string constraints by comparing the classes of languages expressible in the corresponding theories, and are able to establish a mostly complete picture in this regard. Secondly, we consider the question of deciding whether the language or property expressed by a variable/formula in one theory can be expressed in another theory. We establish several negative results which are relevant to preprocessing and normalisation of string constraints in practice. Some of our results have strong connections to important open problems regarding word equations and the theory of string solving.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571203", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joel D.", + "last_name": "Day", + "institution": "Loughborough University" + }, + { + "first_name": "Vijay", + "last_name": "Ganesh", + "institution": "University of Waterloo" + }, + { + "first_name": "Nathan", + "last_name": "Grewal", + "institution": "University of Waterloo" + }, + { + "first_name": "Florín", + "last_name": "Manea", + "institution": "University of Göttingen" + } + ], + "dblp_key": "journals/pacmpl/DayGGM23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571215", + "title": "Towards a Higher-Order Mathematical Operational Semantics", + "abstract": "Compositionality proofs in higher-order languages are notoriously involved, and general semantic frameworks guaranteeing compositionality are hard to come by. In particular, Turi and Plotkin’s bialgebraic abstract GSOS framework, which has been successfully applied to obtain off-the-shelf compositionality results for first-order languages, so far does not apply to higher-order languages. In the present work, we develop a theory of abstract GSOS specifications for higher-order languages, in effect transferring the core principles of Turi and Plotkin’s framework to a higher-order setting. In our theory, the operational semantics of higher-order languages is represented by certain dinatural transformations that we term pointed higher-order GSOS laws . We give a general compositionality result that applies to all systems specified in this way and discuss how compositionality of the SKI calculus and the λ-calculus w.r.t. a strong variant of Abramsky’s applicative bisimilarity are obtained as instances.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571215", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sergey", + "last_name": "Goncharov", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Stefan", + "last_name": "Milius", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Lutz", + "last_name": "Schröder", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Stelios", + "last_name": "Tsampas", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Henning", + "last_name": "Urbat", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + } + ], + "dblp_key": "journals/pacmpl/GoncharovMSTU23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571214", + "title": "Optimal CHC Solving via Termination Proofs", + "abstract": "Motivated by applications to open program reasoning such as maximal specification inference, this paper studies optimal CHC solving , a problem to compute maximal and/or minimal solutions of constrained Horn clauses (CHCs). This problem and its subproblems have been studied in the literature, and a major approach is to iteratively improve a solution of CHCs until it becomes optimal. So a key ingredient of optimization methods is the optimality checking of a given solution. We propose a novel optimality checking method, as well as an optimization method using the proposed optimality checker, based on a computational theoretical analysis of the optimality checking problem. The key observation is that the optimality checking problem is closely related to the termination analysis of programs, and this observation is useful both theoretically and practically. From a theoretical perspective, it clarifies a limitation of an existing method and incorrectness of another method in the literature. From a practical perspective, it allows us to apply techniques of termination analysis to the optimality checking of a solution of CHCs. We present an optimality checking method based on constraint-based synthesis of termination arguments, implemented our method, evaluated it on CHCs that encode maximal specification synthesis problems, and obtained promising results.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571214", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yu", + "last_name": "Gu", + "institution": "University of Tsukuba" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" + } + ], + "dblp_key": "journals/pacmpl/GuTU23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571239", + "title": "Affine Monads and Lazy Structures for Bayesian Programming", + "abstract": "We show that streams and lazy data structures are a natural idiom for programming with infinite-dimensional Bayesian methods such as Poisson processes, Gaussian processes, jump processes, Dirichlet processes, and Beta processes. The crucial semantic idea, inspired by developments in synthetic probability theory, is to work with two separate monads: an affine monad of probability, which supports laziness, and a commutative, non-affine monad of measures, which does not. (Affine means that T (1)≅ 1.) We show that the separation is important from a decidability perspective, and that the recent model of quasi-Borel spaces supports these two monads. To perform Bayesian inference with these examples, we introduce new inference methods that are specially adapted to laziness; they are proven correct by reference to the Metropolis-Hastings-Green method. Our theoretical development is implemented as a Haskell library, LazyPPL.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571239", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Swaraj", + "last_name": "Dash", + "institution": "University of Oxford" + }, + { + "first_name": "Younesse", + "last_name": "Kaddar", + "institution": "University of Oxford" + }, + { + "first_name": "Hugo", + "last_name": "Paquet", + "institution": "University of Oxford" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/DashKPS23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571223", + "title": "A Core Calculus for Equational Proofs of Cryptographic Protocols", + "abstract": "Many proofs of interactive cryptographic protocols (e.g., as in Universal Composability) operate by proving the protocol at hand to be observationally equivalent to an idealized specification. While pervasive, formal tool support for observational equivalence of cryptographic protocols is still a nascent area of research. Current mechanization efforts tend to either focus on diff-equivalence, which establishes observational equivalence between protocols with identical control structures, or require an explicit witness for the observational equivalence in the form of a bisimulation relation. Our goal is to simplify proofs for cryptographic protocols by introducing a core calculus, IPDL, for cryptographic observational equivalences. Via IPDL, we aim to address a number of theoretical issues for cryptographic proofs in a simple manner, including probabilistic behaviors, distributed message-passing, and resource-bounded adversaries and simulators. We demonstrate IPDL on a number of case studies, including a distributed coin toss protocol, Oblivious Transfer, and the GMW multi-party computation protocol. All proofs of case studies are mechanized via an embedding of IPDL into the Coq proof assistant.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571223", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Gancher", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kristina", + "last_name": "Sojakova", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Xiong", + "last_name": "Fan", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Elaine", + "last_name": "Shi", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/GancherSFSM23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571250", + "title": "An Order-Theoretic Analysis of Universe Polymorphism", + "abstract": "We present a novel formulation of universe polymorphism in dependent type theory in terms of monads on the category of strict partial orders, and a novel algebraic structure, displacement algebras, on top of which one can implement a generalized form of McBride’s “crude but effective stratification” scheme for lightweight universe polymorphism. We give some examples of exotic but consistent universe hierarchies, and prove that every universe hierarchy in our sense can be embedded in a displacement algebra and hence implemented via our generalization of McBride’s scheme. Many of our technical results are mechanized in Agda, and we have an OCaml library for universe levels based on displacement algebras, for use in proof assistant implementations.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571250", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kuen-Bang", + "last_name": "Hou", + "institution": "University of Minnesota" + }, + { + "first_name": "Carlo", + "last_name": "Angiuli", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Reed", + "last_name": "Mullanix", + "institution": "University of Minnesota" + } + ], + "dblp_key": "journals/pacmpl/FavoniaAM23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571221", + "title": "A General Noninterference Policy for Polynomial Time", + "abstract": "We introduce a new noninterference policy to capture the class of functions computable in polynomial time on an object-oriented programming language. This policy makes a clear separation between the standard noninterference techniques for the control flow and the layering properties required to ensure that each “security” level preserves polynomial time soundness, and is thus very powerful as for the class of programs it can capture. This new characterization is a proper extension of existing tractable characterizations of polynomial time based on safe recursion. Despite the fact that this noninterference policy is Π 1 0 -complete, we show that it can be instantiated to some decidable and conservative instance using shape analysis techniques.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571221", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Emmanuel", + "last_name": "Hainry", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Romain", + "last_name": "Péchoux", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/HainryP23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571256", + "title": "Elements of Quantitative Rewriting", + "abstract": "We introduce a general theory of quantitative and metric rewriting systems, namely systems with a rewriting relation enriched over quantales modelling abstract quantities. We develop theories of abstract and term-based systems, refining cornerstone results of rewriting theory (such as Newman’s Lemma, Church-Rosser Theorem, and critical pair-like lemmas) to a metric and quantitative setting. To avoid distance trivialisation and lack of confluence issues, we introduce non-expansive, linear term rewriting systems, and then generalise the latter to the novel class of graded term rewriting systems. These systems make quantitative rewriting modal and context-sensitive, this way endowing rewriting with coeffectful behaviours.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571256", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Francesco", + "last_name": "Gavazzo", + "institution": "University of Pisa" + }, + { + "first_name": "Cecilia Di", + "last_name": "Florio", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/GavazzoF23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571227", + "title": "Witnessability of Undecidable Problems", + "abstract": "Many problems in programming language theory and formal methods are undecidable, so they cannot be solved precisely. Practical techniques for dealing with undecidable problems are often based on decidable approximations. Undecidability implies that those approximations are always imprecise. Typically, practitioners use heuristics and ad hoc reasoning to identify imprecision issues and improve approximations, but there is a lack of computability-theoretic foundations about whether those efforts can succeed. This paper shows a surprising interplay between undecidability and decidable approximations: there exists a class of undecidable problems, such that it is computable to transform any decidable approximation to a witness input demonstrating its imprecision. We call those undecidable problems witnessable problems . For example, if a program property P is witnessable, then there exists a computable function f P , such that f P takes as input the code of any program analyzer targeting P and produces an input program w on which the program analyzer is imprecise. An even more surprising fact is that the class of witnessable problems includes almost all undecidable problems in programming language theory and formal methods. Specifically, we prove the diagonal halting problem K is witnessable, and the class of witnessable problems is closed under complements and many-one reductions. In particular, all “non-trivial semantic properties of programs” mentioned in Rice’s theorem are witnessable. We also explicitly construct a problem in the non-witnessable (and undecidable) class and show that both classes have cardinality 2 ℵ 0 . Our results offer a new perspective on the understanding of undecidability: for witnessable problems, although it is impossible to solve them precisely, it is always possible to improve any decidable approximation to make it closer to the precise solution. This fact formally demonstrates that research efforts on such approximations are promising and shows there exist universal ways to identify precision issues of program analyzers, program verifiers, SMT solvers, etc., because their essences are decidable approximations of witnessable problems.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571227", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shuo", + "last_name": "Ding", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/DingZ23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571740", + "title": "Reconciling Shannon and Scott with a Lattice of Computable Information", + "abstract": "This paper proposes a reconciliation of two different theories of information. The first, originally proposed in a lesser-known work by Claude Shannon (some five years after the publication of his celebrated quantitative theory of communication), describes how the information content of channels can be described qualitatively , but still abstractly, in terms of information elements , where information elements can be viewed as equivalence relations over the data source domain. Shannon showed that these elements have a partial ordering, expressing when one information element is more informative than another, and that these partially ordered information elements form a complete lattice. In the context of security and information flow this structure has been independently rediscovered several times, and used as a foundation for understanding and reasoning about information flow. The second theory of information is Dana Scott’s domain theory, a mathematical framework for giving meaning to programs as continuous functions over a particular topology. Scott’s partial ordering also represents when one element is more informative than another, but in the sense of computational progress – i.e. when one element is a more defined or evolved version of another. To give a satisfactory account of information flow in computer programs it is necessary to consider both theories together, in order to understand not only what information is conveyed by a program (viewed as a channel, à la Shannon) but also how the precision with which that information can be observed is determined by the definedness of its encoding (à la Scott). To this end we show how these theories can be fruitfully combined, by defining the Lattice of Computable Information (LoCI), a lattice of preorders rather than equivalence relations. LoCI retains the rich lattice structure of Shannon’s theory, filters out elements that do not make computational sense, and refines the remaining information elements to reflect how Scott’s ordering captures possible varieties in the way that information is presented. We show how the new theory facilitates the first general definition of termination-insensitive information flow properties, a weakened form of information flow property commonly targeted by static program analyses.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571740", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Hunt", + "institution": "City, University of London" + }, + { + "first_name": "David", + "last_name": "Sands", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Sandro", + "last_name": "Stucki", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/HuntSS23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571204", + "title": "Proto-Quipper with Dynamic Lifting", + "abstract": "Quipper is a functional programming language for quantum computing. Proto-Quipper is a family of languages aiming to provide a formal foundation for Quipper. In this paper, we extend Proto-Quipper-M with a construct called dynamic lifting , which is present in Quipper. By virtue of being a circuit description language, Proto-Quipper has two separate runtimes: circuit generation time and circuit execution time. Values that are known at circuit generation time are called parameters , and values that are known at circuit execution time are called states . Dynamic lifting is an operation that enables a state, such as the result of a measurement, to be lifted to a parameter, where it can influence the generation of the next portion of the circuit. As a result, dynamic lifting enables Proto-Quipper programs to interleave classical and quantum computation. We describe the syntax of a language we call Proto-Quipper-Dyn. Its type system uses a system of modalities to keep track of the use of dynamic lifting. We also provide an operational semantics, as well as an abstract categorical semantics for dynamic lifting based on enriched category theory. We prove that both the type system and the operational semantics are sound with respect to our categorical semantics. Finally, we give some examples of Proto-Quipper-Dyn programs that make essential use of dynamic lifting.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571204", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Peng", + "last_name": "Fu", + "institution": "Dalhousie University" + }, + { + "first_name": "Kohei", + "last_name": "Kishida", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Neil J.", + "last_name": "Ross", + "institution": "Dalhousie University" + }, + { + "first_name": "Peter", + "last_name": "Selinger", + "institution": "Dalhousie University" + } + ], + "dblp_key": "journals/pacmpl/FuKRS23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571229", + "title": "Higher-Order Leak and Deadlock Free Locks", + "abstract": "Reasoning about concurrent programs is challenging, especially if data is shared among threads. Program correctness can be violated by the presence of data races—whose prevention has been a topic of concern both in research and in practice. The Rust programming language is a prime example, putting the slogan fearless concurrency in practice by not only employing an ownership-based type system for memory management, but also using its type system to enforce mutual exclusion on shared data. Locking, unfortunately, not only comes at the price of deadlocks but shared access to data may also cause memory leaks . This paper develops a theory of deadlock and leak freedom for higher-order locks in a shared memory concurrent setting. Higher-order locks allow sharing not only of basic values but also of other locks and channels, and are themselves first-class citizens. The theory is based on the notion of a sharing topology , administrating who is permitted to access shared data at what point in the program. The paper first develops higher-order locks for acyclic sharing topologies, instantiated in a λ-calculus with higher-order locks and message-passing concurrency. The paper then extends the calculus to support circular dependencies with dynamic lock orders, which we illustrate with a dynamic version of Dijkstra’s dining philosophers problem. Well-typed programs in the resulting calculi are shown to be free of deadlocks and memory leaks, with proofs mechanized in the Coq proof assistant.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571229", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/JacobsB23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571245", + "title": "Fast Coalgebraic Bisimilarity Minimization", + "abstract": "Coalgebraic bisimilarity minimization generalizes classical automaton minimization to a large class of automata whose transition structure is specified by a functor, subsuming strong, weighted, and probabilistic bisimilarity. This offers the enticing possibility of turning bisimilarity minimization into an off-the-shelf technology, without having to develop a new algorithm for each new type of automaton. Unfortunately, there is no existing algorithm that is fully general, efficient, and able to handle large systems. We present a generic algorithm that minimizes coalgebras over an arbitrary functor in the category of sets as long as the action on morphisms is sufficiently computable. The functor makes at most O ( m log n ) calls to the functor-specific action, where n is the number of states and m is the number of transitions in the coalgebra. While more specialized algorithms can be asymptotically faster than our algorithm (usually by a factor of ( m / n )), our algorithm is especially well suited to efficient implementation, and our tool often uses much less time and memory on existing benchmarks, and can handle larger automata, despite being more generic.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571245", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Thorsten", + "last_name": "Wißmann", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/JacobsW23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571206", + "title": "Executing Microservice Applications on Serverless, Correctly", + "abstract": "While serverless platforms substantially simplify the provisioning, configuration, and management of cloud applications, implementing correct services on top of these platforms can present significant challenges to programmers. For example, serverless infrastructures introduce a host of failure modes that are not present in traditional deployments. Individual serverless instances can fail while others continue to make progress, correct but slow instances can be killed by the cloud provider as part of resource management, and providers will often respond to such failures by re-executing requests. For functions with side-effects, these scenarios can create behaviors that are not observable in serverful deployments. In this paper, we propose mu2sls, a framework for implementing microservice applications on serverless using standard Python code with two extra primitives: transactions and asynchronous calls. Our framework orchestrates user-written services to address several challenges, such as failures and re-executions, and provides formal guarantees that the generated serverless implementations are correct. To that end, we present a novel service specification abstraction and formalization of serverless implementations that facilitate reasoning about the correctness of a given application’s serverless implementation. This formalization forms the basis of the mu2sls prototype, which we then use to develop a few real-world microservice applications and show that the performance of the generated serverless implementations achieves significant scalability (3-5× the throughput of a sequential implementation) while providing correctness guarantees in the context of faults, re-execution, and concurrency.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571206", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Κωνσταντίνος", + "last_name": "Καλλάς", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Haoran", + "last_name": "Zhang", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Sebastian", + "last_name": "Angel", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vincent", + "last_name": "Liu", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/KallasZAAL23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571262", + "title": "Higher-Order MSL Horn Constraints", + "abstract": "The monadic shallow linear (MSL) class is a decidable fragment of first-order Horn clauses that was discovered and rediscovered around the turn of the century, with applications in static analysis and verification. We propose a new class of higher-order Horn constraints which extend MSL to higher-order logic and develop a resolution-based decision procedure. Higher-order MSL Horn constraints can quite naturally capture the complex patterns of call and return that are possible in higher-order programs, which make them well suited to higher-order program verification. In fact, we show that the higher-order MSL satisfiability problem and the HORS model checking problem are interreducible, so that higher-order MSL can be seen as a constraint-based approach to higher-order model checking. Finally, we describe an implementation of our decision procedure and its application to verified socket programming.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571262", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jerome", + "last_name": "Jochems", + "institution": "University of Bristol" + }, + { + "first_name": "Eddie", + "last_name": "Jones", + "institution": "University of Bristol" + }, + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/JochemsJR23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571216", + "title": "Unrealizability Logic", + "abstract": "We consider the problem of establishing that a program-synthesis problem is unrealizable (i.e., has no solution in a given search space of programs). Prior work on unrealizability has developed some automatic techniques to establish that a problem is unrealizable; however, these techniques are all black-box , meaning that they conceal the reasoning behind why a synthesis problem is unrealizable. In this paper, we present a Hoare-style reasoning system, called unrealizability logic for establishing that a program-synthesis problem is unrealizable. To the best of our knowledge, unrealizability logic is the first proof system for overapproximating the execution of an infinite set of imperative programs. The logic provides a general, logical system for building checkable proofs about unrealizability. Similar to how Hoare logic distills the fundamental concepts behind algorithms and tools to prove the correctness of programs, unrealizability logic distills into a single logical system the fundamental concepts that were hidden within prior tools capable of establishing that a program-synthesis problem is unrealizable.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571216", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jinwoo", + "last_name": "Kim", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/KimDR23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571201", + "title": "Why Are Proofs Relevant in Proof-Relevant Models?", + "abstract": "Relational models of λ-calculus can be presented as type systems, the relational interpretation of a λ-term being given by the set of its typings. Within a distributors-induced bicategorical semantics generalizing the relational one, we identify the class of ‘categorified’ graph models and show that they can be presented as type systems as well. We prove that all the models living in this class satisfy an Approximation Theorem stating that the interpretation of a program corresponds to the filtered colimit of the denotations of its approximants. As in the relational case, the quantitative nature of our models allows to prove this property via a simple induction, rather than using impredicative techniques. Unlike relational models, our 2-dimensional graph models are also proof-relevant in the sense that the interpretation of a λ-term does not contain only its typings, but the whole type derivations. The additional information carried by a type derivation permits to reconstruct an approximant having the same type in the same environment. From this, we obtain the characterization of the theory induced by the categorified graph models as a simple corollary of the Approximation Theorem: two λ-terms have isomorphic interpretations exactly when their B'ohm trees coincide.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571201", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Axel", + "last_name": "Kerinec", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Giulio", + "last_name": "Manzonetto", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Federico", + "last_name": "Olimpieri", + "institution": "University of Leeds" + } + ], + "dblp_key": "journals/pacmpl/KerinecMO23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571253", + "title": "Taking Back Control in an Intermediate Representation for GPU Computing", + "abstract": "We describe our experiences successfully applying lightweight formal methods to substantially improve and reformulate an important part of Standard Portable Intermediate Representation SPIRV, an industry-standard language for GPU computing. The formal model that we present has allowed us to (1) identify several ambiguities and needless complexities in the way that structured control flow was defined in the SPIRV specification; (2) interact with the authors of the SPIRV specification to rectify these problems; (3) validate the developer tools and conformance test suites that support the SPIRV language by cross-checking them against our formal model, improving the tools, test suites, and our models in the process; and (4) develop a novel method for fuzzing SPIRV compilers to detect miscompilation bugs that leverages our formal model. The latest release of the SPIRV specification incorporates the revised set of control-flow definitions that have arisen from our work. Furthermore, our novel compiler-fuzzing technique has led to the discovery of twenty distinct, previously unknown bugs in SPIRV compilers from Google, the Khronos Group, Intel, and Mozilla. Our work showcases the practical impact that formal modelling and analysis techniques can have on the design and implementation of industry-standard programming languages.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571253", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vasileios", + "last_name": "Klimis", + "institution": "Imperial College London" + }, + { + "first_name": "Jack", + "last_name": "Clark", + "institution": "Imperial College London" + }, + { + "first_name": "Alan", + "last_name": "Baker", + "institution": "Google (Canada)" + }, + { + "first_name": "David", + "last_name": "Neto", + "institution": "Google (Canada)" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Google (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/KlimisCBNWD23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571237", + "title": "When Less Is More: Consequence-Finding in a Weak Theory of Arithmetic", + "abstract": "This paper presents a theory of non-linear integer/real arithmetic and algorithms for reasoning about this theory. The theory can be conceived of as an extension of linear integer/real arithmetic with a weakly-axiomatized multiplication symbol, which retains many of the desirable algorithmic properties of linear arithmetic. In particular, we show that the conjunctive fragment of the theory can be effectively manipulated (analogously to the usual operations on convex polyhedra, the conjunctive fragment of linear arithmetic). As a result, we can solve the following consequence-finding problem: given a ground formula F , find the strongest conjunctive formula that is entailed by F . As an application of consequence-finding, we give a loop invariant generation algorithm that is monotone with respect to the theory and (in a sense) complete. Experiments show that the invariants generated from the consequences are effective for proving safety properties of programs that require non-linear reasoning.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571237", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "Nicolas", + "last_name": "Koh", + "institution": "Princeton University" + }, + { + "first_name": "Shaowei", + "last_name": "Zhu", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/KincaidKZ23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571199", + "title": "HFL(Z) Validity Checking for Automated Program Verification", + "abstract": "We propose an automated method for checking the validity of a formula of HFL(Z), a higher-order logic with fixpoint operators and integers. Combined with Kobayashi et al.'s reduction from higher-order program verification to HFL(Z) validity checking, our method yields a fully automated, uniform verification method for arbitrary temporal properties of higher-order functional programs expressible in the modal mu-calculus, including termination, non-termination, fair termination, fair non-termination, and also branching-time properties. We have implemented our method and obtained promising experimental results.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571199", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Kento", + "last_name": "Tanahashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryosuke", + "last_name": "Sato", + "institution": "The University of Tokyo" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + } + ], + "dblp_key": "journals/pacmpl/KobayashiTST23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571252", + "title": "The Fine-Grained Complexity of CFL Reachability", + "abstract": "Many problems in static program analysis can be modeled as the context-free language (CFL) reachability problem on directed labeled graphs. The CFL reachability problem can be generally solved in time O ( n 3 ), where n is the number of vertices in the graph, with some specific cases that can be solved faster. In this work, we ask the following question: given a specific CFL, what is the exact exponent in the monomial of the running time? In other words, for which cases do we have linear, quadratic or cubic algorithms, and are there problems with intermediate runtimes? This question is inspired by recent efforts to classify classic problems in terms of their exact polynomial complexity, known as fine-grained complexity. Although recent efforts have shown some conditional lower bounds (mostly for the class of combinatorial algorithms), a general picture of the fine-grained complexity landscape for CFL reachability is missing. Our main contribution is lower bound results that pinpoint the exact running time of several classes of CFLs or specific CFLs under widely believed lower bound conjectures (e.g., Boolean Matrix Multiplication, k -Clique, APSP, 3SUM). We particularly focus on the family of Dyck- k languages (which are strings with well-matched parentheses), a fundamental class of CFL reachability problems. Remarkably, we are able to show a Ω( n 2.5 ) lower bound for Dyck-2 reachability, which to the best of our knowledge is the first super-quadratic lower bound that applies to all algorithms, and shows that CFL reachability is strictly harder that Boolean Matrix Multiplication. We also present new lower bounds for the case of sparse input graphs where the number of edges m is the input parameter, a common setting in the database literature. For this setting, we show a cubic lower bound for Andersen’s Pointer Analysis which significantly strengthens prior known results.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571252", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paraschos", + "last_name": "Koutris", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Shaleen", + "last_name": "Deep", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/KoutrisD23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571212", + "title": "Kater: Automating Weak Memory Model Metatheory and Consistency Checking", + "abstract": "The metatheory of axiomatic weak memory models covers questions like the correctness of compilation mappings from one model to another and the correctness of local program transformations according to a given model---topics usually requiring lengthy human investigation. We show that these questions can be solved by answering a more basic question: \"Given two memory models, is one weaker than the other?\" Moreover, for a wide class of axiomatic memory models, we show that this basic question can be reduced to a language inclusion problem between regular languages, which is decidable. Similarly, implementing an efficient check for whether an execution graph is consistent according to a given memory model has required non-trivial manual effort. Again, we show that such efficient checks can be derived automatically for a wide class of axiomatic memory models, and that incremental consistency checks can be incorporated in GenMC, a state-of-the-art model checker for concurrent programs. As a result, we get the first time- and space-efficient bounded verifier taking the axiomatic memory model as an input parameter.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571212", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/KokologiannakisLV23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571258", + "title": "SSA Translation Is an Abstract Interpretation", + "abstract": "Static single assignment (SSA) form is a popular intermediate representation that helps implement useful static analyses, including global value numbering (GVN), sparse dataflow analyses, or SMT-based abstract interpretation or model checking. However, the precision of the SSA translation itself depends on static analyses, and a priori static analysis is even indispensable in the case of low-level input languages like machine code. To solve this chicken-and-egg problem, we propose to turn the SSA translation into a standard static analysis based on abstract interpretation. This allows the SSA translation to be combined with other static analyses in a single pass, taking advantage of the fact that it is more precise to combine analyses than applying passes in sequence. We illustrate the practicality of these results by writing a simple dataflow analysis that performs SSA translation, optimistic global value numbering, sparse conditional constant propagation, and loop-invariant code motion in a single small pass; and by presenting a multi-language static analyzer for both C and machine code that uses the SSA abstract domain as its main intermediate representation.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571258", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthieu", + "last_name": "Lemerre", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + } + ], + "dblp_key": "journals/pacmpl/Lemerre23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571263", + "title": "Inductive Synthesis of Structurally Recursive Functional Programs from Non-recursive Expressions", + "abstract": "We present a novel approach to synthesizing recursive functional programs from input-output examples. Synthesizing a recursive function is challenging because recursive subexpressions should be constructed while the target function has not been fully defined yet. We address this challenge by using a new technique we call block-based pruning. A block refers to a recursion- and conditional-free expression (i.e., straight-line code) that yields an output from a particular input. We first synthesize as many blocks as possible for each input-output example, and then we explore the space of recursive programs, pruning candidates that are inconsistent with the blocks. Our method is based on an efficient version space learning, thereby effectively dealing with a possibly enormous number of blocks. In addition, we present a method that uses sampled input-output behaviors of library functions to enable a goal-directed search for a recursive program using the library. We have implemented our approach in a system called Trio and evaluated it on synthesis tasks from prior work and on new tasks. Our experiments show that Trio outperforms prior work by synthesizing a solution to 98% of the benchmarks in our benchmark suite.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571263", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Woosuk", + "last_name": "Lee", + "institution": "Hanyang University" + }, + { + "first_name": "Hangyeol", + "last_name": "Cho", + "institution": "Hanyang University" + } + ], + "dblp_key": "journals/pacmpl/LeeC23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571205", + "title": "Smoothness Analysis for Probabilistic Programs with Application to Optimised Variational Inference", + "abstract": "We present a static analysis for discovering differentiable or more generally smooth parts of a given probabilistic program, and show how the analysis can be used to improve the pathwise gradient estimator, one of the most popular methods for posterior inference and model learning. Our improvement increases the scope of the estimator from differentiable models to non-differentiable ones without requiring manual intervention of the user; the improved estimator automatically identifies differentiable parts of a given probabilistic program using our static analysis, and applies the pathwise gradient estimator to the identified parts while using a more general but less efficient estimator, called score estimator, for the rest of the program. Our analysis has a surprisingly subtle soundness argument, partly due to the misbehaviours of some target smoothness properties when viewed from the perspective of program analysis designers. For instance, some smoothness properties, such as partial differentiability and partial continuity, are not preserved by function composition, and this makes it difficult to analyse sequential composition soundly without heavily sacrificing precision. We formulate five assumptions on a target smoothness property, prove the soundness of our analysis under those assumptions, and show that our leading examples satisfy these assumptions. We also show that by using information from our analysis instantiated for differentiability, our improved gradient estimator satisfies an important differentiability requirement and thus computes the correct estimate on average (i.e., returns an unbiased estimate) under a regularity condition. Our experiments with representative probabilistic programs in the Pyro language show that our static analysis is capable of identifying smooth parts of those programs accurately, and making our improved pathwise gradient estimator exploit all the opportunities for high performance in those programs.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571205", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Stanford University" + }, + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/LeeRY23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571233", + "title": "Tail Recursion Modulo Context: An Equational Approach", + "abstract": "The tail-recursion modulo cons transformation can rewrite functions that are not quite tail-recursive into a tail-recursive form that can be executed efficiently. In this article we generalize tail recursion modulo cons (TRMc) to modulo contexts (TRMC), and calculate a general TRMC algorithm from its specification. We can instantiate our general algorithm by providing an implementation of application and composition on abstract contexts, and showing that our context laws_ hold. We provide some known instantiations of TRMC, namely modulo evaluation contexts (CPS), and associative operations , and further instantiantions not so commonly associated with TRMC, such as defunctionalized evaluation contexts, monoids , semirings , exponents , and cons products . We study the modulo cons instantiation in particular and prove that an instantiation using Minamide’s hole calculus is sound. We also calculate a second instantiation in terms of the Perceus heap semantics to precisely reason about the soundness of in-place update. While all previous approaches to TRMc fail in the presence of non-linear control (for example induced by call/cc, shift/reset or algebraic effect handlers), we can elegantly extend the heap semantics to a hybrid approach which dynamically adapts to non-linear control flow. We have a full implementation of hybrid TRMc in the Koka language and our benchmark shows the TRMc transformed functions are always as fast or faster than using manual alternatives.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571233", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Anton", + "last_name": "Lorenzen", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/LeijenL23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571198", + "title": "ADEV: Sound Automatic Differentiation of Expected Values of Probabilistic Programs", + "abstract": "Optimizing the expected values of probabilistic processes is a central problem in computer science and its applications, arising in fields ranging from artificial intelligence to operations research to statistical computing. Unfortunately, automatic differentiation techniques developed for deterministic programs do not in general compute the correct gradients needed for widely used solutions based on gradient-based optimization. In this paper, we present ADEV, an extension to forward-mode AD that correctly differentiates the expectations of probabilistic processes represented as programs that make random choices. Our algorithm is a source-to-source program transformation on an expressive, higher-order language for probabilistic computation, with both discrete and continuous probability distributions. The result of our transformation is a new probabilistic program, whose expected return value is the derivative of the original program’s expectation. This output program can be run to generate unbiased Monte Carlo estimates of the desired gradient, that can be used within the inner loop of stochastic gradient descent. We prove ADEV correct using logical relations over the denotations of the source and target probabilistic programs. Because it modularly extends forward-mode AD, our algorithm lends itself to a concise implementation strategy, which we exploit to develop a prototype in just a few dozen lines of Haskell (https://github.com/probcomp/adev).", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571198", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Mathieu", + "last_name": "Huot", + "institution": "University of Oxford" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LewHSM23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571243", + "title": "Type-Preserving, Dependence-Aware Guide Generation for Sound, Effective Amortized Probabilistic Inference", + "abstract": "In probabilistic programming languages (PPLs), a critical step in optimization-based inference methods is constructing, for a given model program, a trainable guide program. Soundness and effectiveness of inference rely on constructing good guides, but the expressive power of a universal PPL poses challenges. This paper introduces an approach to automatically generating guides for deep amortized inference in a universal PPL. Guides are generated using a type-directed translation per a novel behavioral type system. Guide generation extracts and exploits independence structures using a syntactic approach to conditional independence, with a semantic account left to further work. Despite the control-flow expressiveness allowed by the universal PPL, generated guides are guaranteed to satisfy a critical soundness condition and moreover, consistently improve training and inference over state-of-the-art baselines for a suite of benchmarks.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571243", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jianlin", + "last_name": "Li", + "institution": "University of Waterloo" + }, + { + "first_name": "Leni", + "last_name": "Ven", + "institution": "University of Waterloo" + }, + { + "first_name": "Pengyuan", + "last_name": "Shi", + "institution": "University of Waterloo" + }, + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/LiVSZ23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571208", + "title": "MSWasm: Soundly Enforcing Memory-Safe Execution of Unsafe Code", + "abstract": "Most programs compiled to WebAssembly (Wasm) today are written in unsafe languages like C and C++. Unfortunately, memory-unsafe C code remains unsafe when compiled to Wasm—and attackers can exploit buffer overflows and use-after-frees in Wasm almost as easily as they can on native platforms. Memory- Safe WebAssembly (MSWasm) proposes to extend Wasm with language-level memory-safety abstractions to precisely address this problem. In this paper, we build on the original MSWasm position paper to realize this vision. We give a precise and formal semantics of MSWasm, and prove that well-typed MSWasm programs are, by construction, robustly memory safe. To this end, we develop a novel, language-independent memory-safety property based on colored memory locations and pointers. This property also lets us reason about the security guarantees of a formal C-to-MSWasm compiler—and prove that it always produces memory-safe programs (and preserves the semantics of safe programs). We use these formal results to then guide several implementations: Two compilers of MSWasm to native code, and a C-to-MSWasm compiler (that extends Clang). Our MSWasm compilers support different enforcement mechanisms, allowing developers to make security-performance trade-offs according to their needs. Our evaluation shows that on the PolyBenchC suite, the overhead of enforcing memory safety in software ranges from 22% (enforcing spatial safety alone) to 198% (enforcing full memory safety), and 51.7% when using hardware memory capabilities for spatial safety and pointer integrity. More importantly, MSWasm’s design makes it easy to swap between enforcement mechanisms; as fast (especially hardware-based) enforcement techniques become available, MSWasm will be able to take advantage of these advances almost for free.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571208", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexandra E.", + "last_name": "Michael", + "institution": "University of Washington" + }, + { + "first_name": "Anitha", + "last_name": "Gollamudi", + "institution": "University of Massachusetts Lowell" + }, + { + "first_name": "Jay", + "last_name": "Bosamiya", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Evan", + "last_name": "Johnson", + "institution": "" + }, + { + "first_name": "Aidan", + "last_name": "Denlinger", + "institution": "University of California San Diego" + }, + { + "first_name": "Craig", + "last_name": "Disselkoen", + "institution": "University of California San Diego" + }, + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "University of Cambridge" + }, + { + "first_name": "Bryan", + "last_name": "Parno", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "University of Trento" + }, + { + "first_name": "Marco", + "last_name": "Vassena", + "institution": "Utrecht University" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/MichaelGBJDDWPPVS23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571228", + "title": "Single-Source-Single-Target Interleaved-Dyck Reachability via Integer Linear Programming", + "abstract": "An interleaved-Dyck (InterDyck) language consists of the interleaving of two or more Dyck languages, where each Dyck language represents a set of strings of balanced parentheses.InterDyck-reachability is a fundamental framework for program analyzers that simultaneously track multiple properly-matched pairs of actions such as call/return, lock/unlock, or write-data/read-data.Existing InterDyck-reachability algorithms are based on the well-known tabulation technique. This paper presents a new perspective on solving InterDyck-reachability. Our key observation is that for the single-source-single-target InterDyck-reachability variant, it is feasible to summarize all paths from the source node to the target node based on path expressions . Therefore, InterDyck-reachability becomes an InterDyck-path-recognition problem over path expressions. Instead of computing summary edges as in traditional tabulation algorithms, this new perspective enables us to express InterDyck-reachability as a parenthesis-counting problem, which can be naturally formulated via integer linear programming (ILP). We implemented our ILP-based algorithm and performed extensive evaluations based on two client analyses (a reachability analysis for concurrent programs and a taint analysis). In particular, we evaluated our algorithm against two types of algorithms: (1) the general all-pairs InterDyck-reachability algorithms based on linear conjunctive language (LCL) reachability and synchronized pushdown system (SPDS) reachability, and (2) two domain-specific algorithms for both client analyses. The experimental results are encouraging. Our algorithm achieves 1.42×, 28.24×, and 11.76× speedup for the concurrency-analysis benchmarks compared to all-pair LCL-reachability, SPDS-reachability, and domain-specific tools, respectively; 1.2×, 69.9×, and 0.98× speedup for the taint-analysis benchmarks. Moreover, the algorithm also provides precision improvements, particularly for taint analysis, where it achieves 4.55%, 11.1%, and 6.8% improvement, respectively.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571228", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yuanbo", + "last_name": "Li", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/LiZR23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571218", + "title": "A High-Level Separation Logic for Heap Space under Garbage Collection", + "abstract": "International audience", + "date": "2022-10-20", + "link": "https://doi.org/10.1145/3571218", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexandre", + "last_name": "Moine", + "institution": "" + }, + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Central Compilation & Translation Bureau" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/MoineCP23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571209", + "title": "Grisette: Symbolic Compilation as a Functional Programming Library", + "abstract": "The development of constraint solvers simplified automated reasoning about programs and shifted the engineering burden to implementing symbolic compilation tools that translate programs into efficiently solvable constraints. We describe Grisette, a reusable symbolic evaluation framework for implementing domain-specific symbolic compilers. Grisette evaluates all execution paths and merges their states into a normal form that avoids making guards mutually exclusive. This ordered-guards representation reduces the constraint size 5-fold and the solving time more than 2-fold. Grisette is designed entirely as a library, which sidesteps the complications of lifting the host language into the symbolic domain. Grisette is purely functional, enabling memoization of symbolic compilation as well as monadic integration with host libraries. Grisette is statically typed, which allows catching programming errors at compile time rather than delaying their detection to the constraint solver. We implemented Grisette in Haskell and evaluated it on benchmarks that stress both the symbolic evaluation and constraint solving.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571209", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sirui", + "last_name": "Lu", + "institution": "University of Washington" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/LuB23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571210", + "title": "Locally Nameless Sets", + "abstract": "This paper provides a new mathematical foundation for the locally nameless representation of syntax with binders, one informed by nominal techniques. It gives an equational axiomatization of two key locally nameless operations, \"variable opening\" and \"variable closing\" and shows that a lot of the locally nameless infrastructure can be defined from that in a syntax-independent way, including crucially a \"shift\" functor for name binding. That functor operates on a category whose objects we call locally nameless sets . Functors combining shift with sums and products have initial algebras that recover the usual locally nameless representation of syntax with binders in the finitary case. We demonstrate this by uniformly constructing such an initial locally nameless set for each instance of Plotkin's notion of binding signature. We also show by example that the shift functor is useful for locally nameless sets of a semantic rather than a syntactic character. The category of locally nameless sets is proved to be isomorphic to a known topos of finitely supported M-sets, where M is the full transformation monoid on a countably infinite set. A corollary of the proof is that several categories that have been used in the literature to model variable renaming operations on syntax with binders are all equivalent to each other and to the category of locally nameless sets.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571210", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrew M.", + "last_name": "Pitts", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/Pitts23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571235", + "title": "Admissible Types-to-PERs Relativization in Higher-Order Logic", + "abstract": "Relativizing statements in Higher-Order Logic (HOL) from types to sets is useful for improving productivity when working with HOL-based interactive theorem provers such as HOL4, HOL Light and Isabelle/HOL. This paper provides the first comprehensive definition and study of types-to-sets relativization in HOL, done in the more general form of types-to-PERs (partial equivalence relations). We prove that, for a large practical fragment of HOL which includes container types such as datatypes and codatatypes, types-to-PERs relativization is admissible, in that the provability of the original, type-based statement implies the provability of its relativized, PER-based counterpart. Our results also imply the admissibility of a previously proposed axiomatic extension of HOL with local type definitions. We have implemented types-to-PERs relativization as an Isabelle tool that performs relativization of HOL theorems on demand.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571235", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "University of Sheffield" + }, + { + "first_name": "Dmitriy", + "last_name": "Traytel", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/PopescuT23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571739", + "title": "Impredicative Observational Equality", + "abstract": "In dependent type theory, impredicativity is a powerful logical principle that allows the definition of propositions that quantify over arbitrarily large types, potentially resulting in self-referential propositions. Impredicativity can provide a system with increased logical strength and flexibility, but in counterpart it comes with multiple incompatibility results. In particular, Abel and Coquand showed that adding definitional uniqueness of identity proofs (UIP) to the main proof assistants that support impredicative propositions (Coq and Lean) breaks the normalization procedure, and thus the type-checking algorithm. However, it was not known whether this stems from a fundamental incompatibility between UIP and impredicativity or if a more suitable algorithm could decide type-checking for a type theory that supports both. In this paper, we design a theory that handles both UIP and impredicativity by extending the recently introduced observational type theory TTobs with an impredicative universe of definitionally proof-irrelevant types, as initially proposed in the seminal work on observational equality of Altenkirch et al. We prove decidability of conversion for the resulting system, that we call CCobs, by harnessing proof-irrelevance to avoid computing with impredicative proof terms. Additionally, we prove normalization for CCobs in plain Martin-Löf type theory, thereby showing that adding proof-irrelevant impredicativity does not increase the computational content of the theory.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571739", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Loïc", + "last_name": "Pujet", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/PujetT23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571255", + "title": "Hefty Algebras: Modular Elaboration of Higher-Order Algebraic Effects", + "abstract": "Algebraic effects and handlers is an increasingly popular approach to programming with effects. An attraction of the approach is its modularity: effectful programs are written against an interface of declared operations, which allows the implementation of these operations to be defined and refined without changing or recompiling programs written against the interface. However, higher-order operations (i.e., operations that take computations as arguments) break this modularity. While it is possible to encode higher-order operations by elaborating them into more primitive algebraic effects and handlers, such elaborations are typically not modular. In particular, operations defined by elaboration are typically not a part of any effect interface, so we cannot define and refine their implementation without changing or recompiling programs. To resolve this problem, a recent line of research focuses on developing new and improved effect handlers. In this paper we present a (surprisingly) simple alternative solution to the modularity problem with higher-order operations: we modularize the previously non-modular elaborations commonly used to encode higher-order operations. Our solution is as expressive as the state of the art in effects and handlers.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571255", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Cas van der", + "last_name": "Rest", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/PoulsenR23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571211", + "title": "A Bowtie for a Beast: Overloading, Eta Expansion, and Extensible Data Types in F⋈", + "abstract": "The typed merge operator offers the promise of a compositional style of statically-typed programming in which solutions to the expression problem arise naturally. This approach, dubbed compositional programming , has recently been demonstrated by Zhang et al. Unfortunately, the merge operator is an unwieldy beast. Merging values from overlapping types may be ambiguous, so disjointness relations have been introduced to rule out undesired nondeterminism and obtain a well-behaved semantics. Past type systems using a disjoint merge operator rely on intersection types, but extending such systems to include union types or overloaded functions is problematic: naively adding either reintroduces ambiguity. In a nutshell: the elimination forms of unions and overloaded functions require values to be distinguishable by case analysis, but the merge operator can create exotic values that violate that requirement. This paper presents F ⋈ , a core language that demonstrates how unions, intersections, and overloading can all coexist with a tame merge operator. The key is an underlying design principle that states that any two inhabited types can support either the deterministic merging of their values, or the ability to distinguish their values, but never both. To realize this invariant, we decompose previously studied notions of disjointness into two new, dual relations that permit the operation that best suits each pair of types. This duality respects the polarization of the type structure, yielding an expressive language that we prove to be both type safe and deterministic.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571211", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nick", + "last_name": "Rioux", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Xuejing", + "last_name": "Huang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/RiouxHOZ23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571251", + "title": "Statically Resolvable Ambiguity", + "abstract": "Traditionally, a grammar defining the syntax of a programming language is typically both context free and unambiguous. However, recent work suggests that an attractive alternative is to use ambiguous grammars,thus postponing the task of resolving the ambiguity to the end user. If all programs accepted by an ambiguous grammar can be rewritten unambiguously, then the parser for the grammar is said to be resolvably ambiguous. Guaranteeing resolvable ambiguity statically---for all programs---is hard, where previous work only solves it partially using techniques based on property-based testing. In this paper, we present the first efficient, practical, and proven correct solution to the statically resolvable ambiguity problem. Our approach introduces several key ideas, including splittable productions, operator sequences, and the concept of a grouper that works in tandem with a standard parser. We prove static resolvability using a Coq mechanization and demonstrate its efficiency and practical applicability by implementing and integrating resolvable ambiguity into an essential part of the standard OCaml parser.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571251", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Viktor", + "last_name": "Palmkvist", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Elias", + "last_name": "Castegren", + "institution": "Uppsala University" + }, + { + "first_name": "Philipp", + "last_name": "Haller", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "David", + "last_name": "Broman", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/PalmkvistCHB23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571236", + "title": "You Only Linearize Once: Tangents Transpose to Gradients", + "abstract": "Automatic differentiation (AD) is conventionally understood as a family of distinct algorithms, rooted in two “modes”—forward and reverse—which are typically presented (and implemented) separately. Can there be only one? Following up on the AD systems developed in the JAX and Dex projects, we formalize a decomposition of reverse-mode AD into (i) forward-mode AD followed by (ii) unzipping the linear and non-linear parts and then (iii) transposition of the linear part. To that end, we define a (substructurally) linear type system that can prove a class of functions are (algebraically) linear. Our main results are that forward-mode AD produces such linear functions, and that we can unzip and transpose any such linear function, conserving cost, size, and linearity. Composing these three transformations recovers reverse-mode AD. This decomposition also sheds light on checkpointing, which emerges naturally from a free choice in unzipping let expressions. As a corollary, checkpointing techniques are applicable to general-purpose partial evaluation, not just AD. We hope that our formalization will lead to a deeper understanding of automatic differentiation and that it will simplify implementations, by separating the concerns of differentiation proper from the concerns of gaining efficiency (namely, separating the derivative computation from the act of running it backward).", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571236", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexey", + "last_name": "Radul", + "institution": "Google (United States)" + }, + { + "first_name": "Adam", + "last_name": "Paszke", + "institution": "" + }, + { + "first_name": "Roy", + "last_name": "Frostig", + "institution": "Google (United States)" + }, + { + "first_name": "Matthew", + "last_name": "Johnson", + "institution": "Google (United States)" + }, + { + "first_name": "Dougal", + "last_name": "Maclaurin", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/RadulPFJM23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571194", + "title": "CN: Verifying Systems C Code with Separation-Logic Refinement Types", + "abstract": "Despite significant progress in the verification of hypervisors, operating systems, and compilers, and in verification tooling, there exists a wide gap between the approaches used in verification projects and conventional development of systems software. We see two main challenges in bringing these closer together: verification handling the complexity of code and semantics of conventional systems software, and verification usability. We describe an experiment in verification tool design aimed at addressing some aspects of both: we design and implement CN, a separation-logic refinement type system for C systems software, aimed at predictable proof automation, based on a realistic semantics of ISO C. CN reduces refinement typing to decidable propositional logic reasoning, uses first-class resources to support pointer aliasing and pointer arithmetic, features resource inference for iterated separating conjunction, and uses a novel syntactic restriction of ghost variables in specifications to guarantee their successful inference. We implement CN and formalise key aspects of the type system, including a soundness proof of type checking. To demonstrate the usability of CN we use it to verify a substantial component of Google's pKVM hypervisor for Android.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571194", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Dhruv C.", + "last_name": "Makwana", + "institution": "University of Cambridge" + }, + { + "first_name": "Thomas", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/PulteMSMSK23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571220", + "title": "DimSum: A Decentralized Approach to Multi-language Semantics and Verification", + "abstract": "Prior work on multi-language program verification has achieved impressive results, including the compositional verification of complex compilers. But the existing approaches to this problem impose a variety of restrictions on the overall structure of multi-language programs (e.g. fixing the source language, fixing the set of involved languages, fixing the memory model, or fixing the semantics of interoperation). In this paper, we explore the problem of how to avoid such global restrictions. Concretely, we present DimSum : a new, decentralized approach to multi-language semantics and verification, which we have implemented in the Coq proof assistant. Decentralization means that we can define and reason about languages independently from each other (as independent modules communicating via events), but also combine and translate between them when necessary (via a library of combinators). We apply DimSum to a high-level imperative language Rec (with an abstract memory model and function calls), a low-level assembly language Asm (with a concrete memory model, arbitrary jumps, and syscalls), and a mathematical specification language Spec. We evaluate DimSum on two case studies: an Asm library extending Rec with support for pointer comparison, and a coroutine library for Rec written in Asm. In both cases, we show how DimSum allows the Asm libraries to be abstracted to Rec-level specifications, despite the behavior of the Asm libraries not being syntactically expressible in Rec itself. We also verify an optimizing multi-pass compiler from Rec to Asm, showing that it is compatible with these Asm libraries.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571220", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Simon", + "last_name": "Spies", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Emanuele", + "last_name": "D’Osualdo", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/SammlerSSDKGD23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571247", + "title": "Efficient Dual-Numbers Reverse AD via Well-Known Program Transformations", + "abstract": "Where dual-numbers forward-mode automatic differentiation (AD) pairs each scalar value with its tangent value, dual-numbers reverse-mode AD attempts to achieve reverse AD using a similarly simple idea: by pairing each scalar value with a backpropagator function. Its correctness and efficiency on higher-order input languages have been analysed by Brunel, Mazza and Pagani, but this analysis used a custom operational semantics for which it is unclear whether it can be implemented efficiently. We take inspiration from their use of linear factoring to optimise dual-numbers reverse-mode AD to an algorithm that has the correct complexity and enjoys an efficient implementation in a standard functional language with support for mutable arrays, such as Haskell. Aside from the linear factoring ingredient, our optimisation steps consist of well-known ideas from the functional programming community. We demonstrate the use of our technique by providing a practical implementation that differentiates most of Haskell98.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571247", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tom", + "last_name": "Smeding", + "institution": "Utrecht University" + }, + { + "first_name": "Matthijs", + "last_name": "Vákár", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/pacmpl/SmedingV23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571246", + "title": "An Operational Approach to Library Abstraction under Relaxed Memory Concurrency", + "abstract": "Concurrent data structures and synchronization mechanisms implemented by expert developers are indispensable for modular software development. In this paper, we address the fundamental problem of library abstraction under weak memory concurrency, and identify a general library correctness condition allowing clients of the library to reason about program behaviors using the specification code, which is often much simpler than the concrete implementation. We target (a fragment of) the RC11 memory model, and develop an equivalent operational presentation that exposes knowledge propagation between threads, and is sufficiently expressive to capture library behaviors as totally ordered operational execution traces. We further introduce novel access modes to the language that allow intricate specifications accounting for library internal synchronization that is not exposed to the client, as well as the library's demands on external synchronization by the client. We illustrate applications of our approach in several examples of different natures.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571246", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Abhishek Kr", + "last_name": "Singh", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/SinghL23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571264", + "title": "Temporal Verification with Answer-Effect Modification: Dependent Temporal Type-and-Effect System with Delimited Continuations", + "abstract": "Type-and-effect systems are a widely used approach to program verification, verifying the result of a computation using types, and its behavior using effects. This paper extends an effect system for verifying temporal, value-dependent properties on event sequences yielded by programs, to the delimited control operators shift0/reset0. While these delimited control operators enable useful and powerful programming techniques, they hinder reasoning about the behavior of programs because of their ability to suspend, resume, discard, and duplicate delimited continuations. This problem is more serious in effect systems for temporal properties because these systems must be capable of identifying what event sequences are yielded by captured continuations. Our key observation for achieving effective reasoning in the presence of the delimited control operators is that their use modifies answer effects, which are temporal effects of the continuations. Based on this observation, we extend an effect system for temporal verification to accommodate answer-effect modification. Allowing answer-effect modification enables easily reasoning about traces that captured continuations yield. Another novel feature of our effect system is the support for dependently typed continuations, which allows us to reason about programs more precisely. We prove soundness of the effect system for finite event sequences via type safety and that for infinite event sequences using a logical relation.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571264", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" + } + ], + "dblp_key": "journals/pacmpl/SekiyamaU23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571232", + "title": "Conditional Contextual Refinement", + "abstract": "Much work in formal verification of low-level systems is based on one of two approaches: refinement or separation logic. These two approaches have complementary benefits: refinement supports the use of programs as specifications, as well as transitive composition of proofs, whereas separation logic supports conditional specifications, as well as modular ownership reasoning about shared state. A number of verification frameworks employ these techniques in tandem, but in all such cases the benefits of the two techniques remain separate. For example, in frameworks that use relational separation logic to prove contextual refinement, the relational separation logic judgment does not support transitive composition of proofs, while the contextual refinement judgment does not support conditional specifications. In this paper, we propose Conditional Contextual Refinement (or CCR, for short), the first verification system to not only combine refinement and separation logic in a single framework but also to truly marry them together into a unified mechanism enjoying all the benefits of refinement and separation logic simultaneously. Specifically, unlike in prior work, CCR’s refinement specifications are both conditional (with separation logic pre- and post-conditions) and transitively composable. We implement CCR in Coq and evaluate its effectiveness on a range of interesting examples.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571232", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Seoul National University" + }, + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Dongjae", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/SongCLHSD23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571265", + "title": "Modular Primal-Dual Fixpoint Logic Solving for Temporal Verification", + "abstract": "We present a novel approach to deciding the validity of formulas in first-order fixpoint logic with background theories and arbitrarily nested inductive and co-inductive predicates defining least and greatest fixpoints. Our approach is constraint-based, and reduces the validity checking problem of the given first-order-fixpoint logic formula (formally, an instance in a language called µCLP) to a constraint satisfaction problem for a recently introduced predicate constraint language. Coupled with an existing sound-and-relatively-complete solver for the constraint language, this novel reduction alone already gives a sound and relatively complete method for deciding µCLP validity, but we further improve it to a novel modular primal-dual method. The key observations are (1) µCLP is closed under complement such that each (co-)inductive predicate in the original primal instance has a corresponding (co-)inductive predicate representing its complement in the dual instance obtained by taking the standard De Morgan’s dual of the primal instance, and (2) partial solutions for (co-)inductive predicates synthesized during the constraint solving process of the primal side can be used as sound upper-bounds of the corresponding (co-)inductive predicates in the dual side, and vice versa. By solving the primal and dual problems in parallel and exchanging each others’ partial solutions as sound bounds, the two processes mutually reduce each others’ solution spaces, thus enabling rapid convergence. The approach is also modular in that the bounds are synthesized and exchanged at granularity of individual (co-)inductive predicates. We demonstrate the utility of our novel fixpoint logic solving by encoding a wide variety of temporal verification problems in µCLP, including termination/non-termination, LTL, CTL, and even the full modal µ-calculus model checking of infinite state programs. The encodings exploit the modularity in both the program and the property by expressing each loops and (recursive) functions in the program and sub-formulas of the property as individual (possibly nested) (co-)inductive predicates. Together with our novel modular primal-dual µCLP solving, we obtain a novel approach to efficiently solving a wide range of temporal verification problems.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571265", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Waseda University" + }, + { + "first_name": "Yu", + "last_name": "Gu", + "institution": "University of Tsukuba" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/UnnoTGK23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571238", + "title": "Dynamic Race Detection with O(1) Samples", + "abstract": "Happens before-based dynamic analysis is the go-to technique for detecting data races in large scale software projects due to the absence of false positive reports. However, such analyses are expensive since they employ expensive vector clock updates at each event, rendering them usable only for in-house testing. In this paper, we present a sampling-based, randomized race detector that processes only constantly many events of the input trace even in the worst case. This is the first sub-linear time (i.e., running in o ( n ) time where n is the length of the trace) dynamic race detection algorithm; previous sampling based approaches like run in linear time (i.e., O ( n )). Our algorithm is a property tester for -race detection — it is sound in that it never reports any false positive, and on traces that are far, with respect to hamming distance, from any race-free trace, the algorithm detects an -race with high probability. Our experimental evaluation of the algorithm and its comparison with state-of-the-art deterministic and sampling based race detectors shows that the algorithm does indeed have significantly low running time, and detects races quite often.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571238", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mosaad Al", + "last_name": "Thokair", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Minjian", + "last_name": "Zhang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/ThokairZMV23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571231", + "title": "A Compositional Theory of Linearizability", + "abstract": "Compositionality is at the core of programming languages research and has become an important goal toward scalable verification of large systems. Despite that, there is no compositional account of linearizability, the gold standard of correctness for concurrent objects. In this paper, we develop a compositional semantics for linearizable concurrent objects. We start by showcasing a common issue, which is independent of linearizability, in the construction of compositional models of concurrent computation: interaction with the neutral element for composition can lead to emergent behaviors, a hindrance to compositionality. Category theory provides a solution for the issue in the form of the Karoubi envelope. Surprisingly, and this is the main discovery of our work, this abstract construction is deeply related to linearizability and leads to a novel formulation of it. Notably, this new formulation neither relies on atomicity nor directly upon happens-before ordering and is only possible because of compositionality, revealing that linearizability and compositionality are intrinsically related to each other. We use this new, and compositional, understanding of linearizability to revisit much of the theory of linearizability, providing novel, simple, algebraic proofs of the locality property and of an analogue of the equivalence with observational refinement. We show our techniques can be used in practice by connecting our semantics with a simple program logic that is nonetheless sound concerning this generalized linearizability.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571231", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arthur Oliveira", + "last_name": "Vale", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Yixuan", + "last_name": "Chen", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/ValeSC23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571225", + "title": "Qunity: A Unified Language for Quantum and Classical Computing", + "abstract": "We introduce Qunity, a new quantum programming language designed to treat quantum computing as a natural generalization of classical computing. Qunity presents a unified syntax where familiar programming constructs can have both quantum and classical effects. For example, one can use sum types to implement the direct sum of linear operators, exception-handling syntax to implement projective measurements, and aliasing to induce entanglement. Further, Qunity takes advantage of the overlooked BQP subroutine theorem, allowing one to construct reversible subroutines from irreversible quantum algorithms through the uncomputation of \"garbage\" outputs. Unlike existing languages that enable quantum aspects with separate add-ons (like a classical language with quantum gates bolted on), Qunity provides a unified syntax and a novel denotational semantics that guarantees that programs are quantum mechanically valid. We present Qunity's syntax, type system, and denotational semantics, showing how it can cleanly express several quantum algorithms. We also detail how Qunity can be compiled into a low-level qubit circuit language like OpenQASM, proving the realizability of our design.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571225", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Finn", + "last_name": "Voichick", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Liyi", + "last_name": "Li", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Robert W.", + "last_name": "Rand", + "institution": "University of Chicago" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/VoichickLRH23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571224", + "title": "Making a Type Difference: Subtraction on Intersection Types as Generalized Record Operations", + "abstract": "In programming languages with records, objects, or traits, it is common to have operators that allow dropping, updating or renaming some components. These operators are useful for programmers to explicitly deal with conflicts and override or update some components. While such operators have been studied for record types, little work has been done to generalize and study their theory for other types. This paper shows that, given subtyping and disjointness relations, we can specify and derive algorithmic implementations for a general type difference operator that works for other types, including function types, record types and intersection types. When defined in this way, the type difference algebra has many desired properties that are expected from a subtraction operator. Together with a generic merge operator, using type difference we can generalize many operations on records formalized in the literature. To illustrate the usefulness of type difference we create an intermediate calculus with a rich set of operators on expressions of arbitrary type, and demonstrate applications of these operators in CP , a prototype language for Compositional Programming . The semantics of the calculus is given by elaborating into a calculus with disjoint intersection types and a merge operator. We have implemented type difference and all the operators in the CP language. Moreover, all the calculi and related proofs are mechanically formalized in the Coq theorem prover.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571224", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Han", + "last_name": "Xu", + "institution": "Peking University" + }, + { + "first_name": "Xuejing", + "last_name": "Huang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/XuHO23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571241", + "title": "Recursive Subtyping for All", + "abstract": "Recursive types and bounded quantification are prominent features in many modern programming languages, such as Java, C#, Scala or TypeScript. Unfortunately, the interaction between recursive types, bounded quantification and subtyping has shown to be problematic in the past. Consequently, defining a simple foundational calculus that combines those features and has desirable properties, such as decidability , transitivity of subtyping, conservativity and a sound and complete algorithmic formulation has been a long time challenge. This paper presents an extension of kernel ‍ F ≤ , called F ≤ µ , with iso-recursive types. F ≤ is a well-known polymorphic calculus with bounded quantification. In F ≤ µ we add iso-recursive types, and correspondingly extend the subtyping relation with iso-recursive subtyping using the recently proposed nominal unfolding rules. We also add two smaller extensions to F ≤ . The first one is a generalization of the kernel ‍ F ≤ rule for bounded quantification that accepts equivalent rather than equal bounds. The second extension is the use of so-called structural folding/unfolding rules, inspired by the structural unfolding rule proposed by Abadi, Cardelli, and Viswanathan [1996]. The structural rules add expressive power to the more conventional folding/unfolding rules in the literature, and they enable additional applications. We present several results, including: type soundness; transitivity and decidability of subtyping; the conservativity of F ≤ µ over F ≤ ; and a sound and complete algorithmic formulation of F ≤ µ . Moreover, we study an extension of F ≤ µ , called F ≤≥ µ , which includes lower bounded quantification in addition to the conventional (upper) bounded quantification of F ≤ . All the results in this paper have been formalized in the Coq theorem prover.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571241", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Litao", + "last_name": "Zhou", + "institution": "University of Hong Kong" + }, + { + "first_name": "Yaoda", + "last_name": "Zhou", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/ZhouZO23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571197", + "title": "Comparative Synthesis: Learning Near-Optimal Network Designs by Query", + "abstract": "When managing wide-area networks, network architects must decide how to balance multiple conflicting metrics, and ensure fair allocations to competing traffic while prioritizing critical traffic. The state of practice poses challenges since architects must precisely encode their intent into formal optimization models using abstract notions such as utility functions, and ad-hoc manually tuned knobs. In this paper, we present the first effort to synthesize optimal network designs with indeterminate objectives using an interactive program-synthesis-based approach. We make three contributions. First, we present comparative synthesis, an interactive synthesis framework which produces near-optimal programs (network designs) through two kinds of queries (Validate and Compare), without an objective explicitly given. Second, we develop the first learning algorithm for comparative synthesis in which a voting-guided learner picks the most informative query in each iteration. We present theoretical analysis of the convergence rate of the algorithm. Third, we implemented Net10Q, a system based on our approach, and demonstrate its effectiveness on four real-world network case studies using black-box oracles and simulation experiments, as well as a pilot user study comprising network researchers and practitioners. Both theoretical and experimental results show the promise of our approach.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571197", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yanjun", + "last_name": "Wang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Zixuan", + "last_name": "Li", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Chuan", + "last_name": "Jiang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Sanjay", + "last_name": "Rao", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WangLJQR23", + "venue": "popl", + "year": 2023 + }, + { + "paper_id": "10.1145/3571222", + "title": "CoqQ: Foundational Verification of Quantum Programs", + "abstract": "CoqQ is a framework for reasoning about quantum programs in the Coq proof assistant. Its main components are: a deeply embedded quantum programming language, in which classic quantum algorithms are easily expressed, and an expressive program logic for proving properties of programs. CoqQ is foundational: the program logic is formally proved sound with respect to a denotational semantics based on state-of-art mathematical libraries (MathComp and MathComp Analysis). CoqQ is also practical: assertions can use Dirac expressions, which eases concise specifications, and proofs can exploit local and parallel reasoning, which minimizes verification effort. We illustrate the applicability of CoqQ with many examples from the literature.", + "date": "2023-01-09", + "link": "https://doi.org/10.1145/3571222", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Li", + "last_name": "Zhou", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "" + }, + { + "first_name": "Junyi", + "last_name": "Liu", + "institution": "Institute of Software" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "journals/pacmpl/ZhouBSLY23", + "venue": "popl", + "year": 2023 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2024.json b/data/pl_conferences/popl/2024.json index 5a83a21..05dff1f 100644 --- a/data/pl_conferences/popl/2024.json +++ b/data/pl_conferences/popl/2024.json @@ -1,214 +1,121 @@ [ { - "paper_id": "10.1145/3632928", - "title": "Flan: An Expressive and Efficient Datalog Compiler for Program Analysis", - "abstract": "Datalog has gained prominence in program analysis due to its expressiveness and ease of use. Its generic fixpoint resolution algorithm over relational domains simplifies the expression of many complex analyses. The performance and scalability issues of early Datalog approaches have been addressed by tools such as Soufflé through specialized code generation. Still, while pure Datalog is expressive enough to support a wide range of analyses, there is a growing need for extensions to accommodate increasingly complex analyses This has led to the development of various extensions, such as Flix, Datafun, and Formulog, which enhance Datalog with features like arbitrary lattices and SMT constraints. Most of these extensions recognize the need for full interoperability between Datalog and a full-fledged programming language, a functionality that high-performance systems like Soufflé lack. Specifically, in most cases, they construct languages from scratch with first-class Datalog support, allowing greater flexibility. However, this flexibility often comes at the cost of performance due to the conflicting requirements of prioritizing modularity and abstraction over efficiency. Consequently, achieving both flexibility and compilation to highly-performant specialized code poses a significant challenge. In this work, we reconcile the competing demands of expressiveness and performance with Flan, a Datalog compiler fully embedded in Scala that leverages multi-stage programming to generate specialized code for enhanced performance. Our approach combines the flexibility of Flix with Soufflé’s performance, offering seamless integration with the host language that enables the addition of powerful extensions while generating specialized code for the entire computation. Flan’s simple operator interface allows the addition of an extensive set of features, including arbitrary aggregates, user-defined functions, and lattices, with multiple execution strategies such as binary and multi-way joins, supported by different indexing structures like specialized trees and hash tables, with minimal effort. We evaluate our system on a variety of benchmarks and compare it to established Datalog engines. Our results demonstrate competitive performance and speedups in the range of to compared to state-of-the-art systems for workloads of practical importance.", + "paper_id": "10.1145/3632867", + "title": "Solvable Polynomial Ideals: The Ideal Reflection for Program Analysis", + "abstract": "This paper presents a program analysis method that generates program summaries involving polynomial arithmetic. Our approach builds on prior techniques that use solvable polynomial maps for summarizing loops. These techniques are able to generate all polynomial invariants for a restricted class of programs, but cannot be applied to programs outside of this class—for instance, programs with nested loops, conditional branching, unstructured control flow, etc. There currently lacks approaches to apply these prior methods to the case of general programs. This paper bridges that gap. Instead of restricting the kinds of programs we can handle, our method abstracts every loop into a model that can be solved with prior techniques, bringing to bear prior work on solvable polynomial maps to general programs. While no method can generate all polynomial invariants for arbitrary programs, our method establishes its merit through a monotonicty result. We have implemented our techniques, and tested them on a suite of benchmarks from the literature. Our experiments indicate our techniques show promise on challenging verification tasks requiring non-linear reasoning.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632928", + "link": "https://doi.org/10.1145/3632867", "conference_name": "POPL", "authors": [ { - "first_name": "Supun", - "last_name": "Abeysinghe", - "institution": "Purdue University West Lafayette" - }, - { - "first_name": "Anxhelo", - "last_name": "Xhebraj", - "institution": "Purdue University West Lafayette" + "first_name": "John", + "last_name": "Cyphert", + "institution": "University of Wisconsin–Madison" }, { - "first_name": "Tiark", - "last_name": "Rompf", - "institution": "Purdue University West Lafayette" + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" } ], - "dblp_key": "journals/pacmpl/AbeysingheXR24", + "dblp_key": "journals/pacmpl/CyphertK24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632903", - "title": "Probabilistic Programming Interfaces for Random Graphs: Markov Categories, Graphons, and Nominal Sets", - "abstract": "We study semantic models of probabilistic programming languages over graphs, and establish a connection to graphons from graph theory and combinatorics. We show that every well-behaved equational theory for our graph probabilistic programming language corresponds to a graphon, and conversely, every graphon arises in this way. We provide three constructions for showing that every graphon arises from an equational theory. The first is an abstract construction, using Markov categories and monoidal indeterminates. The second and third are more concrete. The second is in terms of traditional measure theoretic probability, which covers ‘black-and-white’ graphons. The third is in terms of probability monads on the nominal sets of Gabbay and Pitts. Specifically, we use a variation of nominal sets induced by the theory of graphs, which covers Erdős-Rényi graphons. In this way, we build new models of graph probabilistic programming from graphons.", + "paper_id": "10.1145/3632864", + "title": "Regular Abstractions for Array Systems", + "abstract": "Verifying safety and liveness over array systems is a highly challenging problem. Array systems naturally capture parameterized systems such as distributed protocols with an unbounded number of processes. Such distributed protocols often exploit process IDs during their computation, resulting in array systems whose element values range over an infinite domain. In this paper, we develop a novel framework for proving safety and liveness over array systems. The crux of the framework is to overapproximate an array system as a string rewriting system (i.e. over a finite alphabet) by means of a new predicate abstraction that exploits the so-called indexed predicates. This allows us to tap into powerful verification methods for string rewriting systems that have been heavily developed in the last two decades or so (e.g. regular model checking). We demonstrate how our method yields simple, automatically verifiable proofs of safety and liveness properties for challenging examples, including Dijkstra’s self-stabilizing protocol and the Chang-Roberts leader election protocol.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632903", + "link": "https://doi.org/10.1145/3632864", "conference_name": "POPL", "authors": [ { - "first_name": "Nathanael", - "last_name": "Ackerman", - "institution": "Harvard University Press" - }, - { - "first_name": "Cameron E.", - "last_name": "Freer", - "institution": "Massachusetts Institute of Technology" - }, - { - "first_name": "Younesse", - "last_name": "Kaddar", - "institution": "University of Oxford" - }, - { - "first_name": "Jacek", - "last_name": "Karwowski", - "institution": "University of Oxford" - }, - { - "first_name": "Sean", - "last_name": "Moss", - "institution": "University of Birmingham" - }, - { - "first_name": "Daniel", - "last_name": "Roy", - "institution": "University of Toronto" - }, - { - "first_name": "Sam", - "last_name": "Staton", - "institution": "University of Oxford" + "first_name": "Chih-Duo", + "last_name": "Hong", + "institution": "National Chengchi University" }, { - "first_name": "Hongseok", - "last_name": "Yang", - "institution": "Korea Advanced Institute of Science and Technology" + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Kaiserslautern" } ], - "dblp_key": "journals/pacmpl/AckermanFKKMRSY24", + "dblp_key": "journals/pacmpl/HongL24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632920", - "title": "Internal Parametricity, without an Interval", - "abstract": "Parametricity is a property of the syntax of type theory implying, e.g., that there is only one function having the type of the polymorphic identity function. Parametricity is usually proven externally, and does not hold internally. Internalising it is difficult because once there is a term witnessing parametricity, it also has to be parametric itself and this results in the appearance of higher dimensional cubes. In previous theories with internal parametricity, either an explicit syntax for higher cubes is present or the theory is extended with a new sort for the interval. In this paper we present a type theory with internal parametricity which is a simple extension of Martin-Löf type theory: there are a few new type formers, term formers and equations. Geometry is not explicit in this syntax, but emergent: the new operations and equations only refer to objects up to dimension 3. We show that this theory is modelled by presheaves over the BCH cube category. Fibrancy conditions are not needed because we use span-based rather than relational parametricity. We define a gluing model for this theory implying that external parametricity and canonicity hold. The theory can be seen as a special case of a new kind of modal type theory, and it is the simplest setting in which the computational properties of higher observational type theory can be demonstrated.", + "paper_id": "10.1145/3632899", + "title": "Solving Infinite-State Games via Acceleration", + "abstract": "Two-player graph games have found numerous applications, most notably in the synthesis of reactive systems from temporal specifications, but also in verification. The relevance of infinite-state systems in these areas has lead to significant attention towards developing techniques for solving infinite-state games. We propose novel symbolic semi-algorithms for solving infinite-state games with temporal winning conditions. The novelty of our approach lies in the introduction of an acceleration technique that enhances fixpoint-based game-solving methods and helps to avoid divergence. Classical fixpoint-based algorithms, when applied to infinite-state games, are bound to diverge in many cases, since they iteratively compute the set of states from which one player has a winning strategy. Our proposed approach can lead to convergence in cases where existing algorithms require an infinite number of iterations. This is achieved by acceleration: computing an infinite set of states from which a simpler sub-strategy can be iterated an unbounded number of times in order to win the game. Ours is the first method for solving infinite-state games to employ acceleration. Thanks to this, it is able to outperform state-of-the-art techniques on a range of benchmarks, as evidenced by our evaluation of a prototype implementation.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632920", + "link": "https://doi.org/10.1145/3632899", "conference_name": "POPL", "authors": [ { - "first_name": "Thorsten", - "last_name": "Altenkirch", - "institution": "University of Nottingham" - }, - { - "first_name": "Yorgo", - "last_name": "Chamoun", - "institution": "École Polytechnique" - }, - { - "first_name": "Ambrus", - "last_name": "Kaposi", - "institution": "Eötvös Loránd University" + "first_name": "Philippe", + "last_name": "Heim", + "institution": "Helmholtz Center for Information Security" }, { - "first_name": "Michael", - "last_name": "Shulman", - "institution": "University of San Diego" + "first_name": "Rayna", + "last_name": "Dimitrova", + "institution": "Helmholtz Center for Information Security" } ], - "dblp_key": "journals/pacmpl/AltenkirchCKS24", + "dblp_key": "journals/pacmpl/HeimD24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632916", - "title": "Securing Verified IO Programs Against Unverified Code in F", - "abstract": "We introduce SCIO ⋆ , a formally secure compilation framework for statically verified programs performing input-output (IO). The source language is an F ⋆ subset in which a verified program interacts with its IO-performing context via a higher-order interface that includes refinement types as well as pre- and post-conditions about past IO events. The target language is a smaller F ⋆ subset in which the compiled program is linked with an adversarial context that has an interface without refinement types, pre-conditions, or concrete post-conditions. To bridge this interface gap and make compilation and linking secure we propose a formally verified combination of higher-order contracts and reference monitoring for recording and controlling IO operations. Compilation uses contracts to convert the logical assumptions the program makes about the context into dynamic checks on each context-program boundary crossing. These boundary checks can depend on information about past IO events stored in the state of the monitor. But these checks cannot stop the adversarial target context before it performs dangerous IO operations. Therefore linking in SCIO ⋆ additionally forces the context to perform all IO actions via a secure IO library, which uses reference monitoring to dynamically enforce an access control policy before each IO operation. We prove in F ⋆ that SCIO ⋆ soundly enforces a global trace property for the compiled verified program linked with the untrusted context. Moreover, we prove in F ⋆ that SCIO ⋆ satisfies by construction Robust Relational Hyperproperty Preservation, a very strong secure compilation criterion. Finally, we illustrate SCIO ⋆ at work on a simple web server example.", + "paper_id": "10.1145/3632849", + "title": "Calculational Design of [In]Correctness Transformational Program Logics by Abstract Interpretation", + "abstract": "We study transformational program logics for correctness and incorrectness that we extend to explicitly handle both termination and nontermination. We show that the logics are abstract interpretations of the right image transformer for a natural relational semantics covering both finite and infinite executions. This understanding of logics as abstractions of a semantics facilitates their comparisons through their respective abstractions of the semantics (rather that the much more difficult comparison through their formal proof systems). More importantly, the formalization provides a calculational method for constructively designing the sound and complete formal proof system by abstraction of the semantics. As an example, we extend Hoare logic to cover all possible behaviors of nondeterministic programs and design a new precondition (in)correctness logic.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632916", + "link": "https://doi.org/10.1145/3632849", "conference_name": "POPL", "authors": [ { - "first_name": "Cezar-Constantin", - "last_name": "Andrici", - "institution": "Max Planck Institute for Security and Privacy" - }, - { - "first_name": "Ştefan", - "last_name": "Ciobâcă", - "institution": "Alexandru Ioan Cuza University" - }, - { - "first_name": "Cătălin", - "last_name": "Hriţcu", - "institution": "CryptoExperts (France)" - }, - { - "first_name": "Guido", - "last_name": "Martínez", - "institution": "Microsoft (United States)" - }, - { - "first_name": "Exequiel", - "last_name": "Rivas", - "institution": "Tallinn University of Technology" - }, - { - "first_name": "Éric", - "last_name": "Tanter", - "institution": "University of Chile" - }, - { - "first_name": "Théo", - "last_name": "Winterhalter", - "institution": "Centre Inria de Saclay" + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" } ], - "dblp_key": "journals/pacmpl/AndriciCHMRTW24", + "dblp_key": "journals/pacmpl/Cousot24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632915", - "title": "Predictive Monitoring against Pattern Regular Languages", - "abstract": "While current bug detection techniques for concurrent software focus on unearthing low-level issues such as data races or deadlocks, they often fall short of discovering more intricate temporal behaviours that can arise even in the absence of such low-level issues. In this paper, we focus on the problem of dynamically analysing concurrent software against high-level temporal specifications such as LTL. Existing techniques for runtime monitoring against such specifications are primarily designed for sequential software and remain inadequate in the presence of concurrency — violations may be observed only in intricate thread interleavings, requiring many re-runs of the underlying software in conjunction with the analysis. Towards this, we study the problem of predictive runtime monitoring , inspired by the analogous problem of predictive data race detection studied extensively recently. The predictive runtime monitoring question asks, given an execution σ , if it can be soundly reordered to expose violations of a specification. In general, this problem may become easily intractable when either the specifications or the notion of reorderings used is complex. In this paper, we focus on specifications that are given in regular languages. Our notion of reorderings is trace equivalence , where an execution is considered a reordering of another if it can be obtained from the latter by successively commuting adjacent independent actions. We first show that, even in this simplistic setting, the problem of predictive monitoring admits a super-linear lower bound of O ( n α ) , where n is the number of events in the execution, and α is a parameter describing the degree of commutativity, and typically corresponds to the number of threads in the execution. As a result, predictive runtime monitoring even in this setting is unlikely to be efficiently solvable, unlike in the non-predictive setting where the problem can be checked using a deterministic finite automaton (and thus, a constant-space streaming linear-time algorithm). Towards this, we identify a sub-class of regular languages, called pattern languages (and their extension generalized pattern languages ). Pattern languages can naturally express specific ordering of some number of (labelled) events, and have been inspired by popular empirical hypotheses underlying many concurrency bug detection approaches such as the “small bug depth” hypothesis. More importantly, we show that for pattern (and generalized pattern) languages, the predictive monitoring problem can be solved using a constant-space streaming linear-time algorithm. We implement and evaluate our algorithm PatternTrack on benchmarks from the literature and show that it is effective in monitoring large-scale applications.", + "paper_id": "10.1145/3632876", + "title": "On Learning Polynomial Recursive Programs", + "abstract": "We introduce the class of P-finite automata. These are a generalisation of weighted automata, in which the weights of transitions can depend polynomially on the length of the input word. P-finite automata can also be viewed as simple tail-recursive programs in which the arguments of recursive calls can non-linearly refer to a variable that counts the number of recursive calls. The nomenclature is motivated by the fact that over a unary alphabet P-finite automata compute so-called P-finite sequences, that is, sequences that satisfy a linear recurrence with polynomial coefficients. Our main result shows that P-finite automata can be learned in polynomial time in Angluin’s MAT exact learning model. This generalises the classical results that deterministic finite automata and weighted automata over a field are respectively polynomial-time learnable in the MAT model.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632915", + "link": "https://doi.org/10.1145/3632876", "conference_name": "POPL", "authors": [ { - "first_name": "Zhendong", - "last_name": "Ang", - "institution": "National University of Singapore" + "first_name": "Alex", + "last_name": "Buna-Marginean", + "institution": "University of Oxford" }, { - "first_name": "Umang", - "last_name": "Mathur", - "institution": "National University of Singapore" - } - ], - "dblp_key": "journals/pacmpl/AngM24", - "venue": "popl", - "year": 2024 - }, - { - "paper_id": "10.1145/3632895", - "title": "Disentanglement with Futures, State, and Interaction", - "abstract": "Recent work has proposed a memory property for parallel programs, called disentanglement, and showed that it is pervasive in a variety of programs, written in different languages, ranging from C/C++ to Parallel ML, and showed that it can be exploited to improve the performance of parallel functional programs. All existing work on disentanglement, however, considers the “fork/join” model for parallelism and does not apply to “futures”, the more powerful approach to parallelism. This is not surprising: fork/join parallel programs exhibit a reasonably strict dependency structure (e.g., series-parallel DAGs), which disentanglement exploits. In contrast, with futures, parallel computations become first-class values of the language, and thus can be created, and passed between functions calls or stored in memory, just like other ordinary values, resulting in complex dependency structures, especially in the presence of mutable state. For example, parallel programs with futures can have deadlocks, which is impossible with fork-join parallelism. In this paper, we are interested in the theoretical question of whether disentanglement may be extended beyond fork/join parallelism, and specifically to futures. We consider a functional language with futures, Input/Output (I/O), and mutable state (references) and show that a broad range of programs written in this language are disentangled. We start by formalizing disentanglement for futures and proving that purely functional programs written in this language are disentangled. We then generalize this result in three directions. First, we consider state (effects) and prove that stateful programs are disentangled if they are race free. Second, we show that race freedom is sufficient but not a necessary condition and non-deterministic programs, e.g. those that use atomic read-modify-operations and some non-deterministic combinators, may also be disentangled. Third, we prove that disentangled task-parallel programs written with futures are free of deadlocks, which arise due to interactions between state and the rich dependencies that can be expressed with futures. Taken together, these results show that disentanglement generalizes to parallel programs with futures and, thus, the benefits of disentanglement may go well beyond fork-join parallelism.", - "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632895", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Jatin", - "last_name": "Arora", - "institution": "Carnegie Mellon University" + "first_name": "Vincent", + "last_name": "Cheval", + "institution": "University of Oxford" }, { - "first_name": "Stefan K.", - "last_name": "Muller", - "institution": "Illinois Institute of Technology" + "first_name": "Mahsa", + "last_name": "Shirmohammadi", + "institution": "Centre National de la Recherche Scientifique" }, { - "first_name": "Umut A.", - "last_name": "Acar", - "institution": "Carnegie Mellon University" + "first_name": "James", + "last_name": "Worrell", + "institution": "University of Oxford" } ], - "dblp_key": "journals/pacmpl/AroraMA24", + "dblp_key": "journals/pacmpl/BunaMargineanCSW24", "venue": "popl", "year": 2024 }, @@ -217,7 +124,7 @@ "title": "Polynomial Time and Dependent Types", "abstract": "We combine dependent types with linear type systems that soundly and completely capture polynomial time computation. We explore two systems for capturing polynomial time: one system that disallows construction of iterable data, and one, based on the LFPL system of Martin Hofmann, that controls construction via a payment method. Both of these are extended to full dependent types via Quantitative Type Theory, allowing for arbitrary computation in types alongside guaranteed polynomial time computation in terms. We prove the soundness of the systems using a realisability technique due to Dal Lago and Hofmann. Our long-term goal is to combine the extensional reasoning of type theory with intensional reasoning about the resources intrinsically consumed by programs. This paper is a step along this path, which we hope will lead both to practical systems for reasoning about programs’ resource usage, and to theoretical use as a form of synthetic computational complexity theory .", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632918", + "link": "https://doi.org/10.1145/3632918", "conference_name": "POPL", "authors": [ { @@ -231,317 +138,183 @@ "year": 2024 }, { - "paper_id": "10.1145/3632891", - "title": "Validation of Modern JSON Schema: Formalization and Complexity", - "abstract": "JSON Schema is the de-facto standard schema language for JSON data. The language went through many minor revisions, but the most recent versions of the language, starting from Draft 2019-09, added two novel features, dynamic references and annotation-dependent validation , that change the evaluation model. Modern JSON Schema is the name used to indicate all versions from Draft 2019-09, which are characterized by these new features, while Classical JSON Schema is used to indicate the previous versions. These new “modern” features make the schema language quite difficult to understand and have generated many discussions about the correct interpretation of their official specifications; for this reason, we undertook the task of their formalization. During this process, we also analyzed the complexity of data validation in Modern JSON Schema, with the idea of confirming the polynomial complexity of Classical JSON Schema validation, and we were surprised to discover a completely different truth: data validation, which is expected to be an extremely efficient process, acquires, with Modern JSON Schema features, a PSPACE complexity. In this paper, we give the first formal description of Modern JSON Schema, which we have discussed with the community of JSON Schema tool developers, and which we consider a central contribution of this work. We then prove that its data validation problem is PSPACE-complete. We prove that the origin of the problem lies in the Draft 2020-12 version of dynamic references, and not in annotation-dependent validation. We study the schema and data complexities, showing that the problem is PSPACE-complete with respect to the schema size even with a fixed instance but is in P when the schema is fixed and only the instance size is allowed to vary. Finally, we run experiments that show that there are families of schemas where the difference in asymptotic complexity between dynamic and static references is extremely visible, even with small schemas.", - "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632891", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Lyes", - "last_name": "Attouche", - "institution": "Université Paris Dauphine-PSL" - }, - { - "first_name": "Mohamed-Amine", - "last_name": "Baazizi", - "institution": "Sorbonne Université" - }, - { - "first_name": "Dario", - "last_name": "Colazzo", - "institution": "Université Paris Dauphine-PSL" - }, - { - "first_name": "Giorgio", - "last_name": "Ghelli", - "institution": "University of Pisa" - }, - { - "first_name": "Carlo", - "last_name": "Sartiani", - "institution": "University of Basilicata" - }, - { - "first_name": "Stefanie", - "last_name": "Scherzinger", - "institution": "University of Passau" - } - ], - "dblp_key": "journals/pacmpl/AttoucheBCGSS24", - "venue": "popl", - "year": 2024 - }, - { - "paper_id": "10.1145/3633279", - "title": "Reachability in Continuous Pushdown VASS", - "abstract": "Pushdown Vector Addition Systems with States (PVASS) consist of finitely many control states, a pushdown stack, and a set of counters that can be incremented and decremented, but not tested for zero. Whether the reachability problem is decidable for PVASS is a long-standing open problem. We consider continuous PVASS , which are PVASS with a continuous semantics. This means, the counter values are rational numbers and whenever a vector is added to the current counter values, this vector is first scaled with an arbitrarily chosen rational factor between zero and one. We show that reachability in continuous PVASS is NEXPTIME -complete. Our result is unusually robust: Reachability can be decided in NEXPTIME even if all numbers are specified in binary. On the other hand, NEXPTIME -hardness already holds for coverability, in fixed dimension, for bounded stack, and even if all numbers are specified in unary.", - "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3633279", - "conference_name": "POPL", - "authors": [ - { - "first_name": "A. R.", - "last_name": "Balasubramanian", - "institution": "Max Planck Institute for Software Systems" - }, - { - "first_name": "Rupak", - "last_name": "Majumdar", - "institution": "Max Planck Institute for Software Systems" - }, - { - "first_name": "Ramanathan S.", - "last_name": "Thinniyam", - "institution": "Uppsala University" - }, - { - "first_name": "Georg", - "last_name": "Zetzsche", - "institution": "Max Planck Institute for Software Systems" - } - ], - "dblp_key": "journals/pacmpl/BalasubramanianMTZ24", - "venue": "popl", - "year": 2024 - }, - { - "paper_id": "10.1145/3632935", - "title": "Programmatic Strategy Synthesis: Resolving Nondeterminism in Probabilistic Programs", - "abstract": "We consider imperative programs that involve both randomization and pure nondeterminism. The central question is how to find a strategy resolving the pure nondeterminism such that the so-obtained determinized program satisfies a given quantitative specification, i.e., bounds on expected outcomes such as the expected final value of a program variable or the probability to terminate in a given set of states. We show how memoryless and deterministic (MD) strategies can be obtained in a semi-automatic fashion using deductive verification techniques. For loop-free programs, the MD strategies resulting from our weakest preconditionstyle framework are correct by construction. This extends to loopy programs, provided the loops are equipped with suitable loop invariants - just like in program verification. We show how our technique relates to the well-studied problem of obtaining strategies in countably infinite Markov decision processes with reachabilityreward objectives. Finally, we apply our technique to several case studies.", - "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632935", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Kevin", - "last_name": "Batz", - "institution": "RWTH Aachen University" - }, - { - "first_name": "Tom Jannik", - "last_name": "Biskup", - "institution": "RWTH Aachen University" - }, - { - "first_name": "Joost-Pieter", - "last_name": "Katoen", - "institution": "RWTH Aachen University" - }, - { - "first_name": "Tobias", - "last_name": "Winkler", - "institution": "RWTH Aachen University" - } - ], - "dblp_key": "journals/pacmpl/BatzBKW24", - "venue": "popl", - "year": 2024 - }, - { - "paper_id": "10.1145/3632843", - "title": "Ramsey Quantifiers in Linear Arithmetics", - "abstract": "We study Satisfiability Modulo Theories (SMT) enriched with the so-called Ramsey quantifiers, which assert the existence of cliques (complete graphs) in the graph induced by some formulas. The extended framework is known to have applications in proving program termination (in particular, whether a transitive binary predicate is well-founded), and monadic decomposability of SMT formulas. Our main result is a new algorithm for eliminating Ramsey quantifiers from three common SMT theories: Linear Integer Arithmetic (LIA), Linear Real Arithmetic (LRA), and Linear Integer Real Arithmetic (LIRA). In particular, if we work only with existentially quantified formulas, then our algorithm runs in polynomial time and produces a formula of linear size. One immediate consequence is that checking well-foundedness of a given formula in the aforementioned theory defining a transitive predicate can be straightforwardly handled by highly optimized SMT-solvers. We show also how this provides a uniform semi-algorithm for verifying termination and liveness with completeness guarantee (in fact, with an optimal computational complexity) for several well-known classes of infinite-state systems, which include succinct timed systems, one-counter systems, and monotonic counter systems. Another immediate consequence is a solution to an open problem on checking monadic decomposability of a given relation in quantifier-free fragments of LRA and LIRA, which is an important problem in automated reasoning and constraint databases. Our result immediately implies decidability of this problem with an optimal complexity (coNP-complete) and enables exploitation of SMT-solvers. It also provides a termination guarantee for the generic monadic decomposition algorithm of Veanes et al. for LIA, LRA, and LIRA. We report encouraging experimental results on a prototype implementation of our algorithms on micro-benchmarks.", + "paper_id": "10.1145/3632844", + "title": "Deciding Asynchronous Hyperproperties for Recursive Programs", + "abstract": "We introduce a novel logic for asynchronous hyperproperties with a new mechanism to identify relevant positions on traces. While the new logic is more expressive than a related logic presented recently by Bozzelli et al., we obtain the same complexity of the model checking problem for finite state models. Beyond this, we study the model checking problem of our logic for pushdown models. We argue that the combination of asynchronicity and a non-regular model class studied in this paper constitutes the first suitable approach for hyperproperty model checking against recursive programs.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632843", + "link": "https://doi.org/10.1145/3632844", "conference_name": "POPL", "authors": [ { - "first_name": "Pascal", - "last_name": "Bergsträßer", - "institution": "University of Kaiserslautern" - }, - { - "first_name": "Moses", - "last_name": "Ganardi", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Jens Oliver", + "last_name": "Gutsfeld", + "institution": "University of Münster" }, { - "first_name": "Anthony W.", - "last_name": "Lin", - "institution": "University of Kaiserslautern" + "first_name": "Markus", + "last_name": "Müller-Olm", + "institution": "University of Münster" }, { - "first_name": "Georg", - "last_name": "Zetzsche", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Christoph", + "last_name": "Ohrem", + "institution": "University of Münster" } ], - "dblp_key": "journals/pacmpl/BergstrasserGLZ24", + "dblp_key": "journals/pacmpl/GutsfeldMO24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632887", - "title": "Polyregular Functions on Unordered Trees of Bounded Height", - "abstract": "We consider injective first-order interpretations that input and output trees of bounded height. The corresponding functions have polynomial output size, since a first-order interpretation can use a k -tuple of input nodes to represent a single output node. We prove that the equivalence problem for such functions is decidable, i.e. given two such interpretations, one can decide whether, for every input tree, the two output trees are isomorphic. We also give a calculus of typed functions and combinators which derives exactly injective first-order interpretations for unordered trees of bounded height. The calculus is based on a type system, where the type constructors are products, coproducts and a monad of multisets. Thanks to our results about tree-to-tree interpretations, the equivalence problem is decidable for this calculus. As an application, we show that the equivalence problem is decidable for first-order interpretations between classes of graphs that have bounded tree-depth. In all cases studied in this paper, first-order logic and mso have the same expressive power, and hence all results apply also to mso interpretations.", + "paper_id": "10.1145/3632921", + "title": "Explicit Effects and Effect Constraints in ReML", + "abstract": "An important aspect of building robust systems that execute on dedicated hardware and perhaps in constrained environments is to control and manage the effects performed by program code. We present ReML, a higher-order statically-typed functional language, which allows programmers to be explicit about the effects performed by program code and in particular effects related to memory management Allowing programmers to be explicit about effects, the regions in which values reside, and the constraints under which code execute, makes programs robust to changes in the program source code and to compiler updates, including compiler optimisations. ReML is integrated with a polymorphic inference system that builds on top of region-inference, as it is implemented in the MLKit, a Standard ML compiler that uses region-based memory management as its primary memory management scheme.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632887", + "link": "https://doi.org/10.1145/3632921", "conference_name": "POPL", "authors": [ { - "first_name": "Mikołaj", - "last_name": "Bojańczyk", - "institution": "University of Warsaw" - }, - { - "first_name": "Bartek", - "last_name": "Klin", - "institution": "University of Oxford" + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" } ], - "dblp_key": "journals/pacmpl/BojanczykK24", + "dblp_key": "journals/pacmpl/Elsman24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632912", - "title": "Mechanizing Refinement Types", - "abstract": "Practical checkers based on refinement types use the combination of implicit semantic subtyping and parametric polymorphism to simplify the specification and automate the verification of sophisticated properties of programs. However, a formal metatheoretic accounting of the soundness of refinement type systems using this combination has proved elusive. We present λ R F , a core refinement calculus that combines semantic subtyping and parametric polymorphism. We develop a metatheory for this calculus and prove soundness of the type system. Finally, we give two mechanizations of our metatheory. First, we introduce data propositions , a novel feature that enables encoding derivation trees for inductively defined judgments as refined data types, and use them to show that L iquid H askell ’s refinement types can be used for mechanization. Second, we mechanize our results in C oq , which comes with stronger soundness guarantees than L iquid H askell , thereby laying the foundations for mechanizing the metatheory of L iquid H askell .", + "paper_id": "10.1145/3632919", + "title": "Generating Well-Typed Terms That Are Not "Useless"", + "abstract": "Random generation of well-typed terms lies at the core of effective random testing of compilers for functional languages. Existing techniques have had success following a top-down type-oriented approach to generation that makes choices locally, which suffers from an inherent limitation: the type of an expression is often generated independently from the expression itself. Such generation frequently yields functions with argument types that cannot be used to produce a result in a meaningful way, leaving those arguments unused. Such “use-less” functions can hinder both performance, as the argument generation code is dead but still needs to be compiled, and effectiveness, as a lot of interesting optimizations are tested less frequently. In this paper, we introduce a novel algorithm that is significantly more effective at generating functions that use their arguments. We formalize both the “local” and the “nonlocal” algorithms as step-relations in an extension of the simply-typed lambda calculus with type and arguments holes, showing how delaying the generation of types for subexpressions by allowing nonlocal generation steps leads to “useful” functions. We implement our algorithm demonstrating that it’s much closer to real programs in terms of argument usage rate, and we replicate a case study from the literature that finds bugs in the strictness analyzer of GHC, with our approach finding bugs four times faster than the current state-of-the-art local approach.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632912", + "link": "https://doi.org/10.1145/3632919", "conference_name": "POPL", "authors": [ { - "first_name": "Michael H.", - "last_name": "Borkowski", - "institution": "University of California San Diego" + "first_name": "J. Ray", + "last_name": "Frank", + "institution": "University of Maryland, College Park" }, { - "first_name": "Niki", - "last_name": "Vazou", - "institution": "IMDEA Software Institute" + "first_name": "Benjamin", + "last_name": "Quiring", + "institution": "University of Maryland, College Park" }, { - "first_name": "Ranjit", - "last_name": "Jhala", - "institution": "University of California San Diego" + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" } ], - "dblp_key": "journals/pacmpl/BorkowskiVJ24", + "dblp_key": "journals/pacmpl/FrankQL24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632874", - "title": "Implementation and Synthesis of Math Library Functions", - "abstract": "Achieving speed and accuracy for math library functions like exp , sin , and log is difficult. This is because low-level implementation languages like C do not help math library developers catch mathematical errors, build implementations incrementally, or separate high-level and low-level decision making. This ultimately puts development of such functions out of reach for all but the most experienced experts. To address this, we introduce MegaLibm, a domain-specific language for implementing, testing, and tuning math library implementations. MegaLibm is safe, modular, and tunable. Implementations in MegaLibm can automatically detect mathematical mistakes like sign flips via semantic wellformedness checks, and components like range reductions can be implemented in a modular, composable way, simplifying implementations. Once the high-level algorithm is done, tuning parameters like working precisions and evaluation schemes can be adjusted through orthogonal tuning parameters to achieve the desired speed and accuracy. MegaLibm also enables math library developers to work interactively, compiling, testing, and tuning their implementations and invoking tools like Sollya and type-directed synthesis to complete components and synthesize entire implementations. MegaLibm can express 8 state-of-the-art math library implementations with comparable speed and accuracy to the original C code, and can synthesize 5 variations and 3 from-scratch implementations with minimal guidance.", + "paper_id": "10.1145/3632865", + "title": "A Core Calculus for Documents: Or, Lambda: The Ultimate Document", + "abstract": "Passive documents and active programs now widely comingle. Document languages include Turing-complete programming elements, and programming languages include sophisticated document notations. However, there are no formal foundations that model these languages. This matters because the interaction between document and program can be subtle and error-prone. In this paper we describe several such problems, then taxonomize and formalize document languages as levels of a document calculus. We employ the calculus as a foundation for implementing complex features such as reactivity, as well as for proving theorems about the boundary of content and computation. We intend for the document calculus to provide a theoretical basis for new document languages, and to assist designers in cleaning up the unsavory corners of existing languages.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632874", + "link": "https://doi.org/10.1145/3632865", "conference_name": "POPL", "authors": [ { - "first_name": "Ian", - "last_name": "Briggs", - "institution": "University of Utah" - }, - { - "first_name": "Yash", - "last_name": "Lad", - "institution": "University of Utah" + "first_name": "Will", + "last_name": "Crichton", + "institution": "Brown University" }, { - "first_name": "Pavel", - "last_name": "Panchekha", - "institution": "University of Utah" + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" } ], - "dblp_key": "journals/pacmpl/BriggsLP24", + "dblp_key": "journals/pacmpl/CrichtonK24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632876", - "title": "On Learning Polynomial Recursive Programs", - "abstract": "We introduce the class of P-finite automata. These are a generalisation of weighted automata, in which the weights of transitions can depend polynomially on the length of the input word. P-finite automata can also be viewed as simple tail-recursive programs in which the arguments of recursive calls can non-linearly refer to a variable that counts the number of recursive calls. The nomenclature is motivated by the fact that over a unary alphabet P-finite automata compute so-called P-finite sequences, that is, sequences that satisfy a linear recurrence with polynomial coefficients. Our main result shows that P-finite automata can be learned in polynomial time in Angluin’s MAT exact learning model. This generalises the classical results that deterministic finite automata and weighted automata over a field are respectively polynomial-time learnable in the MAT model.", + "paper_id": "10.1145/3632881", + "title": "Orthologic with Axioms", + "abstract": "We study the proof theory and algorithms for orthologic, a logical system based on ortholattices, which have shown practical relevance in simplification and normalization of verification conditions. Ortholattices weaken Boolean algebras while having polynomial-time equivalence checking that is sound with respect to Boolean algebra semantics. We generalize ortholattice reasoning and obtain an algorithm for proving a larger class of classically valid formulas. As the key result, we analyze a proof system for orthologic augmented with axioms. An important feature of the system is that it limits the number of formulas in a sequent to at most two, which makes the extension with axioms non-trivial. We show a generalized form of cut elimination for this system, which implies a sub-formula property. From there we derive a cubic-time algorithm for provability from axioms, or equivalently, for validity in finitely presented ortholattices. We further show that propositional resolution of width 5 proves all formulas provable in orthologic with axioms. We show that orthologic system subsumes resolution of width 2 and arbitrarily wide unit resolution and is complete for reasoning about generalizations of propositional Horn clauses. Moving beyond ground axioms, we introduce effectively propositional orthologic (by analogy with EPR for classical logic), presenting its semantics as well as a sound and complete proof system. Our proof system implies the decidability of effectively propositional orthologic, as well as its fixed-parameter tractability for a bounded maximal number of variables in each axiom. As a special case, we obtain a generalization of Datalog with negation and disjunction.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632876", + "link": "https://doi.org/10.1145/3632881", "conference_name": "POPL", "authors": [ { - "first_name": "Alex", - "last_name": "Buna-Marginean", - "institution": "University of Oxford" - }, - { - "first_name": "Vincent", - "last_name": "Cheval", - "institution": "University of Oxford" - }, - { - "first_name": "Mahsa", - "last_name": "Shirmohammadi", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Simon", + "last_name": "Guilloud", + "institution": "École Polytechnique Fédérale de Lausanne" }, { - "first_name": "James", - "last_name": "Worrell", - "institution": "University of Oxford" + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" } ], - "dblp_key": "journals/pacmpl/BunaMargineanCSW24", + "dblp_key": "journals/pacmpl/GuilloudK24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632897", - "title": "Monotonicity and the Precision of Program Analysis", - "abstract": "It is widely known that the precision of a program analyzer is closely related to intensional program properties, namely, properties concerning how the program is written. This explains, for instance, the interest in code obfuscation techniques, namely, tools explicitly designed to degrade the results of program analysis by operating syntactic program transformations. Less is known about a possible relation between what the program extensionally computes, namely, its input-output relation, and the precision of a program analyzer. In this paper we explore this potential connection in an effort to isolate program fragments that can be precisely analyzed by abstract interpretation, namely, programs for which there exists a complete abstract interpretation. In the field of static inference of numeric invariants, this happens for programs, or parts of programs, that manifest a monotone (either non-decreasing or non-increasing) behavior. We first formalize the notion of program monotonicity with respect to a given input and a set of numerical variables of interest. A sound proof system is then introduced with judgments specifying whether a program is monotone relatively to a set of variables and a set of inputs. The interest in monotonicity is justified because we prove that the family of monotone programs admits a complete abstract interpretation over a specific class of non-trivial numerical abstractions and inputs. This class includes all non-relational abstract domains that refine interval analysis (i.e., at least as precise as the intervals abstraction) and that satisfy a topological convexity hypothesis.", + "paper_id": "10.1145/3632922", + "title": "Indexed Types for a Statically Safe WebAssembly", + "abstract": "We present Wasm-precheck, a superset of WebAssembly (Wasm) that uses indexed types to express and check simple constraints over program values. This additional static reasoning enables safely removing dynamic safety checks from Wasm, such as memory bounds checks. We implement Wasm-precheck as an extension of the Wasmtime compiler and runtime, evaluate the run-time and compile-time performance of Wasm-precheck vs Wasm configurations with explicit dynamic checks, and find an average run-time performance gain of 1.71 x faster in the widely used PolyBenchC benchmark suite, for a small overhead in binary size ( 7.18 % larger) and type-checking time (1.4% slower). We also prove type and memory safety of Wasm-precheck, prove Wasm safely embeds into Wasm-precheck ensuring backwards compatibility, prove Wasm-precheck type-erases to Wasm, and discuss design and implementation trade-offs.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632897", + "link": "https://doi.org/10.1145/3632922", "conference_name": "POPL", "authors": [ { - "first_name": "Marco", - "last_name": "Campion", - "institution": "Institut national de recherche en sciences et technologies du numérique" - }, - { - "first_name": "Mila Dalla", - "last_name": "Preda", - "institution": "University of Verona" + "first_name": "Adam T.", + "last_name": "Geller", + "institution": "University of British Columbia" }, { - "first_name": "Roberto", - "last_name": "Giacobazzi", - "institution": "University of Arizona" + "first_name": "J. Ray", + "last_name": "Frank", + "institution": "University of British Columbia" }, { - "first_name": "Caterina", - "last_name": "Urban", - "institution": "Institut national de recherche en sciences et technologies du numérique" + "first_name": "William J.", + "last_name": "Bowman", + "institution": "University of British Columbia" } ], - "dblp_key": "journals/pacmpl/CampionPGU24", + "dblp_key": "journals/pacmpl/GellerFB24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632931", - "title": "Type-Based Gradual Typing Performance Optimization", - "abstract": "Gradual typing has emerged as a popular design point in programming languages, attracting significant interests from both academia and industry. Programmers in gradually typed languages are free to utilize static and dynamic typing as needed. To make such languages sound, runtime checks mediate the boundary of typed and untyped code. Unfortunately, such checks can incur significant runtime overhead on programs that heavily mix static and dynamic typing. To combat this overhead without necessitating changes to the underlying implementations of languages, we present discriminative typing . Discriminative typing works by optimistically inferring types for functions and implementing an optimized version of the function based on this type. To preserve safety it also implements an un-optimized version of the function based purely on the provided annotations. With two versions of each function in hand, discriminative typing translates programs so that the optimized functions are called as frequently as possible while also preserving program behaviors. We have implemented discriminative typing in Reticulated Python and have evaluated its performance compared to guarded Reticulated Python. Our results show that discriminative typing improves the performance across 95% of tested programs, when compared to Reticulated, and achieves more than 4× speedup in more than 56% of these programs. We also compare its performance against a previous optimization approach and find that discriminative typing improved performance across 93% of tested programs, with 30% of these programs receiving speedups between 4 to 25 times. Finally, our evaluation shows that discriminative typing remarkably reduces the overhead of gradual typing on many mixed type configurations of programs. In addition, we have implemented discriminative typing in Grift and evaluated its performance. Our evaluation demonstrations that DT significantly improves performance of Grift.", + "paper_id": "10.1145/3632908", + "title": "How Hard Is Weak-Memory Testing?", + "abstract": "Weak-memory models are standard formal specifications of concurrency across hardware, programming languages, and distributed systems. A fundamental computational problem is consistency testing : is the observed execution of a concurrent program in alignment with the specification of the underlying system? The problem has been studied extensively across Sequential Consistency (SC) and weak memory, and proven to be N P -complete when some aspect of the input (e.g., number of threads/memory locations) is unbounded. This unboundedness has left a natural question open: are there efficient parameterized algorithms for testing? The main contribution of this paper is a deep hardness result for consistency testing under many popular weak-memory models: the problem remains N P -complete even in its bounded setting, where candidate executions contain a bounded number of threads, memory locations, and values. This hardness spreads across several Release-Acquire variants of C11, a popular variant of its Relaxed fragment, popular Causal Consistency models, and the POWER architecture. To our knowledge, this is the first result that fully exposes the hardness of weak-memory testing and proves that the problem admits no parameterization under standard input parameters. It also yields a computational separation of these models from SC, x86-TSO, PSO, and Relaxed, for which bounded consistency testing is either known (for SC), or shown here (for the rest), to be in polynomial time.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632931", + "link": "https://doi.org/10.1145/3632908", "conference_name": "POPL", "authors": [ { - "first_name": "John Peter", - "last_name": "Campora", - "institution": "" + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Delft University of Technology" }, { - "first_name": "Mohammad Wahiduzzaman", - "last_name": "Khan", - "institution": "University of Louisiana at Lafayette" + "first_name": "Shankara Narayanan", + "last_name": "Krishna", + "institution": "Indian Institute of Technology Bombay" }, { - "first_name": "Sheng", - "last_name": "Chen", - "institution": "University of Louisiana at Lafayette" + "first_name": "Umang", + "last_name": "Mathur", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" } ], - "dblp_key": "journals/pacmpl/CamporaKC24", + "dblp_key": "journals/pacmpl/ChakrabortyKMP24", "venue": "popl", "year": 2024 }, @@ -550,7 +323,7 @@ "title": "With a Few Square Roots, Quantum Computing Is as Easy as Pi", "abstract": "Rig groupoids provide a semantic model of Π , a universal classical reversible programming language over finite types. We prove that extending rig groupoids with just two maps and three equations about them results in a model of quantum computing that is computationally universal and equationally sound and complete for a variety of gate sets. The first map corresponds to an 8th root of the identity morphism on the unit 1. The second map corresponds to a square root of the symmetry on 1 + 1 . As square roots are generally not unique and can sometimes even be trivial, the maps are constrained to satisfy a nondegeneracy axiom, which we relate to the Euler decomposition of the Hadamard gate. The semantic construction is turned into an extension of Π , called Π , that is a computationally universal quantum programming language equipped with an equational theory that is sound and complete with respect to the Clifford gate set, the standard gate set of Clifford+T restricted to ≤ 2 qubits, and the computationally universal Gaussian Clifford+T gate set.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632861", + "link": "https://doi.org/10.1145/3632861", "conference_name": "POPL", "authors": [ { @@ -579,129 +352,131 @@ "year": 2024 }, { - "paper_id": "10.1145/3632882", - "title": "Polymorphic Type Inference for Dynamic Languages", - "abstract": "We present a type system that combines, in a controlled way, first-order polymorphism with intersection types, union types, and subtyping, and prove its safety. We then define a type reconstruction algorithm that is sound and terminating. This yields a system in which unannotated functions are given polymorphic types (thanks to Hindley-Milner) that can express the overloaded behavior of the functions they type (thanks to the intersection introduction rule) and that are deduced by applying advanced techniques of type narrowing (thanks to the union elimination rule). This makes the system a prime candidate to type dynamic languages.", + "paper_id": "10.1145/3632891", + "title": "Validation of Modern JSON Schema: Formalization and Complexity", + "abstract": "JSON Schema is the de-facto standard schema language for JSON data. The language went through many minor revisions, but the most recent versions of the language, starting from Draft 2019-09, added two novel features, dynamic references and annotation-dependent validation , that change the evaluation model. Modern JSON Schema is the name used to indicate all versions from Draft 2019-09, which are characterized by these new features, while Classical JSON Schema is used to indicate the previous versions. These new “modern” features make the schema language quite difficult to understand and have generated many discussions about the correct interpretation of their official specifications; for this reason, we undertook the task of their formalization. During this process, we also analyzed the complexity of data validation in Modern JSON Schema, with the idea of confirming the polynomial complexity of Classical JSON Schema validation, and we were surprised to discover a completely different truth: data validation, which is expected to be an extremely efficient process, acquires, with Modern JSON Schema features, a PSPACE complexity. In this paper, we give the first formal description of Modern JSON Schema, which we have discussed with the community of JSON Schema tool developers, and which we consider a central contribution of this work. We then prove that its data validation problem is PSPACE-complete. We prove that the origin of the problem lies in the Draft 2020-12 version of dynamic references, and not in annotation-dependent validation. We study the schema and data complexities, showing that the problem is PSPACE-complete with respect to the schema size even with a fixed instance but is in P when the schema is fixed and only the instance size is allowed to vary. Finally, we run experiments that show that there are families of schemas where the difference in asymptotic complexity between dynamic and static references is extremely visible, even with small schemas.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632882", + "link": "https://doi.org/10.1145/3632891", "conference_name": "POPL", "authors": [ { - "first_name": "Giuseppe", - "last_name": "Castagna", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Lyes", + "last_name": "Attouche", + "institution": "Université Paris Dauphine-PSL" }, { - "first_name": "Mickaël", - "last_name": "Laurent", - "institution": "Université Paris Cité" + "first_name": "Mohamed-Amine", + "last_name": "Baazizi", + "institution": "Sorbonne Université" }, { - "first_name": "Kim", - "last_name": "Nguyễn", - "institution": "Université Paris-Saclay" - } - ], - "dblp_key": "journals/pacmpl/CastagnaLN24", - "venue": "popl", - "year": 2024 - }, - { - "paper_id": "10.1145/3632885", - "title": "Quantum Bisimilarity via Barbs and Contexts: Curbing the Power of Non-deterministic Observers", - "abstract": "Past years have seen the development of a few proposals for quantum extensions of process calculi. The rationale is clear: with the development of quantum communication protocols, there is a need to abstract and focus on the basic features of quantum concurrent systems, like CCS and CSP have done for their classical counterparts. So far, though, no accepted standard has emerged, neither for the syntax nor for the behavioural semantics. Indeed, the various proposals do not agree on what should be the observational properties of quantum values, and as a matter of fact, the soundness of such properties has never been validated against the prescriptions of quantum theory. To this aim, we introduce a new calculus, Linear Quantum CCS (lqCCS), and investigate the features of behavioural equivalences based on barbs and contexts. Our calculus can be thought of as an asynchronous, linear version of qCCS, which is in turn based on value-passing CCS. The combination of linearity and asynchronous communication fits well with the properties of quantum systems (e.g. the no-cloning theorem), since it ensures that each qubit is sent exactly once, precisely specifying which qubits of a process interact with the context. We exploit contexts to examine how bisimilarities relate to quantum theory. We show that the observational power of general contexts is incompatible with quantum theory: roughly, they can perform non-deterministic moves depending on quantum values without measuring (hence perturbing) them. Therefore, we refine the operational semantics in order to prevent contexts from performing unfeasible non-deterministic choices. This induces a coarser bisimilarity that better fits the quantum setting: ( i ) it lifts the indistinguishability of quantum states to the distributions of processes and, despite the additional constraints, ( i i ) it preserves the expressiveness of non-deterministic choices based on classical information. To the best of our knowledge, our semantics is the first one that satisfies the two properties above.", - "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632885", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Lorenzo", - "last_name": "Ceragioli", - "institution": "IMT School for Advanced Studies Lucca" + "first_name": "Dario", + "last_name": "Colazzo", + "institution": "Université Paris Dauphine-PSL" }, { - "first_name": "Fabio", - "last_name": "Gadducci", + "first_name": "Giorgio", + "last_name": "Ghelli", "institution": "University of Pisa" }, { - "first_name": "Giuseppe", - "last_name": "Lomurno", - "institution": "University of Pisa" + "first_name": "Carlo", + "last_name": "Sartiani", + "institution": "University of Basilicata" }, { - "first_name": "Gabriele", - "last_name": "Tedeschi", - "institution": "University of Pisa" + "first_name": "Stefanie", + "last_name": "Scherzinger", + "institution": "University of Passau" } ], - "dblp_key": "journals/pacmpl/CeragioliGLT24", + "dblp_key": "journals/pacmpl/AttoucheBCGSS24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632908", - "title": "How Hard Is Weak-Memory Testing?", - "abstract": "Weak-memory models are standard formal specifications of concurrency across hardware, programming languages, and distributed systems. A fundamental computational problem is consistency testing : is the observed execution of a concurrent program in alignment with the specification of the underlying system? The problem has been studied extensively across Sequential Consistency (SC) and weak memory, and proven to be N P -complete when some aspect of the input (e.g., number of threads/memory locations) is unbounded. This unboundedness has left a natural question open: are there efficient parameterized algorithms for testing? The main contribution of this paper is a deep hardness result for consistency testing under many popular weak-memory models: the problem remains N P -complete even in its bounded setting, where candidate executions contain a bounded number of threads, memory locations, and values. This hardness spreads across several Release-Acquire variants of C11, a popular variant of its Relaxed fragment, popular Causal Consistency models, and the POWER architecture. To our knowledge, this is the first result that fully exposes the hardness of weak-memory testing and proves that the problem admits no parameterization under standard input parameters. It also yields a computational separation of these models from SC, x86-TSO, PSO, and Relaxed, for which bounded consistency testing is either known (for SC), or shown here (for the rest), to be in polynomial time.", + "paper_id": "10.1145/3632884", + "title": "On-the-Fly Static Analysis via Dynamic Bidirected Dyck Reachability", + "abstract": "Dyck reachability is a principled, graph-based formulation of a plethora of static analyses. Bidirected graphs are used for capturing dataflow through mutable heap data, and are usual formalisms of demand-driven points-to and alias analyses. The best (offline) algorithm runs in O ( m + n · α ( n ) ) time, where n is the number of nodes and m is the number of edges in the flow graph, which becomes O ( n 2 ) in the worst case. In the everyday practice of program analysis, the analyzed code is subject to continuous change, with source code being added and removed. On-the-fly static analysis under such continuous updates gives rise to dynamic Dyck reachability , where reachability queries run on a dynamically changing graph, following program updates. Naturally, executing the offline algorithm in this online setting is inadequate, as the time required to process a single update is prohibitively large. In this work we develop a novel dynamic algorithm for bidirected Dyck reachability that has O ( n · α ( n ) ) worst-case performance per update, thus beating the O ( n 2 ) bound, and is also optimal in certain settings. We also implement our algorithm and evaluate its performance on on-the-fly data-dependence and alias analyses, and compare it with two best known alternatives, namely (i) the optimal offline algorithm, and (ii) a fully dynamic Datalog solver. Our experiments show that our dynamic algorithm is consistently, and by far, the top performing algorithm, exhibiting speedups in the order of 1000X. The running time of each update is almost always unnoticeable to the human eye, making it ideal for the on-the-fly analysis setting.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632908", + "link": "https://doi.org/10.1145/3632884", "conference_name": "POPL", "authors": [ - { - "first_name": "Soham", - "last_name": "Chakraborty", - "institution": "Delft University of Technology" - }, { "first_name": "Shankara Narayanan", "last_name": "Krishna", "institution": "Indian Institute of Technology Bombay" }, { - "first_name": "Umang", - "last_name": "Mathur", + "first_name": "A. K.", + "last_name": "Lal", "institution": "Indian Institute of Technology Bombay" }, { "first_name": "Andreas", "last_name": "Pavlogiannis", "institution": "Aarhus University" + }, + { + "first_name": "Omkar", + "last_name": "Tuppe", + "institution": "Indian Institute of Technology Bombay" } ], - "dblp_key": "journals/pacmpl/ChakrabortyKMP24", + "dblp_key": "journals/pacmpl/KrishnaLPT24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632893", - "title": "Unboxed Data Constructors: Or, How cpp Decides a Halting Problem", - "abstract": "We propose a new language feature for ML-family languages, the ability to selectively unbox certain data constructors, so that their runtime representation gets compiled away to just the identity on their argument. Unboxing must be statically rejected when it could introduce confusion, that is, distinct values with the same representation. We discuss the use-case of big numbers, where unboxing allows to write code that is both efficient and safe, replacing either a safe but slow version or a fast but unsafe version. We explain the static analysis necessary to reject incorrect unboxing requests. We present our prototype implementation of this feature for the OCaml programming language, discuss several design choices and the interaction with advanced features such as Guarded Algebraic Datatypes. Our static analysis requires expanding type definitions in type expressions, which is not necessarily normalizing in presence of recursive type definitions. In other words, we must decide normalization of terms in the first-order λ -calculus with recursion. We provide an algorithm to detect non-termination on-the-fly during reduction, with proofs of correctness and completeness. Our algorithm turns out to be closely related to the normalization strategy for macro expansion in the cpp preprocessor.", + "paper_id": "10.1145/3632903", + "title": "Probabilistic Programming Interfaces for Random Graphs: Markov Categories, Graphons, and Nominal Sets", + "abstract": "We study semantic models of probabilistic programming languages over graphs, and establish a connection to graphons from graph theory and combinatorics. We show that every well-behaved equational theory for our graph probabilistic programming language corresponds to a graphon, and conversely, every graphon arises in this way. We provide three constructions for showing that every graphon arises from an equational theory. The first is an abstract construction, using Markov categories and monoidal indeterminates. The second and third are more concrete. The second is in terms of traditional measure theoretic probability, which covers ‘black-and-white’ graphons. The third is in terms of probability monads on the nominal sets of Gabbay and Pitts. Specifically, we use a variation of nominal sets induced by the theory of graphs, which covers Erdős-Rényi graphons. In this way, we build new models of graph probabilistic programming from graphons.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632893", + "link": "https://doi.org/10.1145/3632903", "conference_name": "POPL", "authors": [ { - "first_name": "Nicolas", - "last_name": "Chataing", - "institution": "École Normale Supérieure - PSL" + "first_name": "Nathanael", + "last_name": "Ackerman", + "institution": "Harvard University Press" }, { - "first_name": "Stephen", - "last_name": "Dolan", - "institution": "" + "first_name": "Cameron E.", + "last_name": "Freer", + "institution": "Massachusetts Institute of Technology" }, { - "first_name": "Gabriel", - "last_name": "Scherer", - "institution": "Institut national de recherche en sciences et technologies du numérique" + "first_name": "Younesse", + "last_name": "Kaddar", + "institution": "University of Oxford" }, { - "first_name": "Jeremy", - "last_name": "Yallop", - "institution": "University of Cambridge" + "first_name": "Jacek", + "last_name": "Karwowski", + "institution": "University of Oxford" + }, + { + "first_name": "Sean", + "last_name": "Moss", + "institution": "University of Birmingham" + }, + { + "first_name": "Daniel", + "last_name": "Roy", + "institution": "University of Toronto" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Korea Advanced Institute of Science and Technology" } ], - "dblp_key": "journals/pacmpl/ChataingDSY24", + "dblp_key": "journals/pacmpl/AckermanFKKMRSY24", "venue": "popl", "year": 2024 }, @@ -710,7 +485,7 @@ "title": "A Formalization of Core Why3 in Coq", "abstract": "Intermediate verification languages like Why3 and Boogie have made it much easier to build program verifiers, transforming the process into a logic compilation problem rather than a proof automation one. Why3 in particular implements a rich logic for program specification with polymorphism, algebraic data types, recursive functions and predicates, and inductive predicates; it translates this logic to over a dozen solvers and proof assistants. Accordingly, it serves as a backend for many tools, including Frama-C, EasyCrypt, and GNATProve for Ada SPARK. But how can we be sure that these tools are correct? The alternate foundational approach, taken by tools like VST and CakeML, provides strong guarantees by implementing the entire toolchain in a proof assistant, but these tools are harder to build and cannot directly take advantage of SMT solver automation. As a first step toward enabling automated tools with similar foundational guarantees, we give a formal semantics in Coq for the logic fragment of Why3. We show that our semantics are useful by giving a correct-by-construction natural deduction proof system for this logic, using this proof system to verify parts of Why3’s standard library, and proving sound two of Why3’s transformations used to convert terms and formulas into the simpler logics supported by the backend solvers.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632902", + "link": "https://doi.org/10.1145/3632902", "conference_name": "POPL", "authors": [ { @@ -729,857 +504,909 @@ "year": 2024 }, { - "paper_id": "10.1145/3632888", - "title": "The Complex(ity) Landscape of Checking Infinite Descent", - "abstract": "Cyclic proof systems, in which induction is managed implicitly, are a promising approach to automatic verification. The soundness of cyclic proof graphs is ensured by checking them against a trace-based Infinite Descent property. Although the problem of checking Infinite Descent is known to be PSPACE-complete, this leaves much room for variation in practice. Indeed, a number of different approaches are employed across the various cyclic proof systems described in the literature. In this paper, we study criteria for Infinite Descent in an abstract, logic-independent setting. We look at criteria based on Büchi automata encodings and relational abstractions, and determine their parameterized time complexities in terms of natural dimensions of cyclic proofs: the numbers of vertices of the proof-tree graphs, and the vertex width —an upper bound on the number of components (e.g., formulas) of a sequent that can be simultaneously tracked for descent. We identify novel algorithms that improve upon the parameterised complexity of the existing algorithms. We implement the studied criteria and compare their performance on various benchmarks.", + "paper_id": "10.1145/3632882", + "title": "Polymorphic Type Inference for Dynamic Languages", + "abstract": "We present a type system that combines, in a controlled way, first-order polymorphism with intersection types, union types, and subtyping, and prove its safety. We then define a type reconstruction algorithm that is sound and terminating. This yields a system in which unannotated functions are given polymorphic types (thanks to Hindley-Milner) that can express the overloaded behavior of the functions they type (thanks to the intersection introduction rule) and that are deduced by applying advanced techniques of type narrowing (thanks to the union elimination rule). This makes the system a prime candidate to type dynamic languages.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632888", + "link": "https://doi.org/10.1145/3632882", "conference_name": "POPL", "authors": [ { - "first_name": "Liron", - "last_name": "Cohen", - "institution": "Ben-Gurion University of the Negev" - }, - { - "first_name": "Adham", - "last_name": "Jabarin", - "institution": "Ben-Gurion University of the Negev" + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" }, { - "first_name": "Andrei", - "last_name": "Popescu", - "institution": "University of Sheffield" + "first_name": "Mickaël", + "last_name": "Laurent", + "institution": "Université Paris Cité" }, { - "first_name": "Reuben N. S.", - "last_name": "Rowe", - "institution": "Royal Holloway University of London" + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Université Paris-Saclay" } ], - "dblp_key": "journals/pacmpl/CohenJPR24", + "dblp_key": "journals/pacmpl/CastagnaLN24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632849", - "title": "Calculational Design of [In]Correctness Transformational Program Logics by Abstract Interpretation", - "abstract": "We study transformational program logics for correctness and incorrectness that we extend to explicitly handle both termination and nontermination. We show that the logics are abstract interpretations of the right image transformer for a natural relational semantics covering both finite and infinite executions. This understanding of logics as abstractions of a semantics facilitates their comparisons through their respective abstractions of the semantics (rather that the much more difficult comparison through their formal proof systems). More importantly, the formalization provides a calculational method for constructively designing the sound and complete formal proof system by abstraction of the semantics. As an example, we extend Hoare logic to cover all possible behaviors of nondeterministic programs and design a new precondition (in)correctness logic.", + "paper_id": "10.1145/3632913", + "title": "Enhanced Enumeration Techniques for Syntax-Guided Synthesis of Bit-Vector Manipulations", + "abstract": "Syntax-guided synthesis has been a prevalent theme in various computer-aided programming systems. However, the domain of bit-vector synthesis poses several unique challenges that have not yet been sufficiently addressed and resolved. In this paper, we propose a novel synthesis approach that incorporates a distinct enumeration strategy based on various factors. Technically, this approach weighs in subexpression recurrence by term-graph-based enumeration, avoids useless candidates by example-guided filtration, prioritizes valuable components identified by large language models. This approach also incorporates a bottom-up deduction step to enhance the enumeration algorithm by considering subproblems that contribute to the deductive resolution. We implement all the enhanced enumeration techniques in our S y G u S solver D ryad S ynth , which outperforms state-of-the-art solvers in terms of the number of solved problems, execution time, and solution size. Notably, D ryad S ynth successfully solved 31 synthesis problems for the first time, including 5 renowned Hacker’s Delight problems.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632849", + "link": "https://doi.org/10.1145/3632913", "conference_name": "POPL", "authors": [ { - "first_name": "Patrick", - "last_name": "Cousot", - "institution": "New York University" + "first_name": "Yuantian", + "last_name": "Ding", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "Purdue University West Lafayette" } ], - "dblp_key": "journals/pacmpl/Cousot24", + "dblp_key": "journals/pacmpl/DingQ24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632865", - "title": "A Core Calculus for Documents: Or, Lambda: The Ultimate Document", - "abstract": "Passive documents and active programs now widely comingle. Document languages include Turing-complete programming elements, and programming languages include sophisticated document notations. However, there are no formal foundations that model these languages. This matters because the interaction between document and program can be subtle and error-prone. In this paper we describe several such problems, then taxonomize and formalize document languages as levels of a document calculus. We employ the calculus as a foundation for implementing complex features such as reactivity, as well as for proving theorems about the boundary of content and computation. We intend for the document calculus to provide a theoretical basis for new document languages, and to assist designers in cleaning up the unsavory corners of existing languages.", + "paper_id": "10.1145/3632895", + "title": "Disentanglement with Futures, State, and Interaction", + "abstract": "Recent work has proposed a memory property for parallel programs, called disentanglement, and showed that it is pervasive in a variety of programs, written in different languages, ranging from C/C++ to Parallel ML, and showed that it can be exploited to improve the performance of parallel functional programs. All existing work on disentanglement, however, considers the “fork/join” model for parallelism and does not apply to “futures”, the more powerful approach to parallelism. This is not surprising: fork/join parallel programs exhibit a reasonably strict dependency structure (e.g., series-parallel DAGs), which disentanglement exploits. In contrast, with futures, parallel computations become first-class values of the language, and thus can be created, and passed between functions calls or stored in memory, just like other ordinary values, resulting in complex dependency structures, especially in the presence of mutable state. For example, parallel programs with futures can have deadlocks, which is impossible with fork-join parallelism. In this paper, we are interested in the theoretical question of whether disentanglement may be extended beyond fork/join parallelism, and specifically to futures. We consider a functional language with futures, Input/Output (I/O), and mutable state (references) and show that a broad range of programs written in this language are disentangled. We start by formalizing disentanglement for futures and proving that purely functional programs written in this language are disentangled. We then generalize this result in three directions. First, we consider state (effects) and prove that stateful programs are disentangled if they are race free. Second, we show that race freedom is sufficient but not a necessary condition and non-deterministic programs, e.g. those that use atomic read-modify-operations and some non-deterministic combinators, may also be disentangled. Third, we prove that disentangled task-parallel programs written with futures are free of deadlocks, which arise due to interactions between state and the rich dependencies that can be expressed with futures. Taken together, these results show that disentanglement generalizes to parallel programs with futures and, thus, the benefits of disentanglement may go well beyond fork-join parallelism.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632865", + "link": "https://doi.org/10.1145/3632895", "conference_name": "POPL", "authors": [ { - "first_name": "Will", - "last_name": "Crichton", - "institution": "Brown University" + "first_name": "Jatin", + "last_name": "Arora", + "institution": "Carnegie Mellon University" }, { - "first_name": "Shriram", - "last_name": "Krishnamurthi", - "institution": "Brown University" + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" } ], - "dblp_key": "journals/pacmpl/CrichtonK24", + "dblp_key": "journals/pacmpl/AroraMA24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632867", - "title": "Solvable Polynomial Ideals: The Ideal Reflection for Program Analysis", - "abstract": "This paper presents a program analysis method that generates program summaries involving polynomial arithmetic. Our approach builds on prior techniques that use solvable polynomial maps for summarizing loops. These techniques are able to generate all polynomial invariants for a restricted class of programs, but cannot be applied to programs outside of this class—for instance, programs with nested loops, conditional branching, unstructured control flow, etc. There currently lacks approaches to apply these prior methods to the case of general programs. This paper bridges that gap. Instead of restricting the kinds of programs we can handle, our method abstracts every loop into a model that can be solved with prior techniques, bringing to bear prior work on solvable polynomial maps to general programs. While no method can generate all polynomial invariants for arbitrary programs, our method establishes its merit through a monotonicty result. We have implemented our techniques, and tested them on a suite of benchmarks from the literature. Our experiments indicate our techniques show promise on challenging verification tasks requiring non-linear reasoning.", + "paper_id": "10.1145/3632907", + "title": "Parikh's Theorem Made Symbolic", + "abstract": "Parikh’s Theorem is a fundamental result in automata theory with numerous applications in computer science. These include software verification (e.g. infinite-state verification, string constraints, and theory of arrays), verification of cryptographic protocols (e.g. using Horn clauses modulo equational theories) and database querying (e.g. evaluating path-queries in graph databases), among others. Parikh’s Theorem states that the letter-counting abstraction of a language recognized by finite automata or context-free grammars is definable in Linear Integer Arithmetic (a.k.a. Presburger Arithmetic). In fact, there is a linear-time algorithm computing existential Presburger formulas capturing such abstractions, which enables an efficient analysis via SMT-solvers. Unfortunately, real-world applications typically require large alphabets (e.g. Unicode, containing a million of characters) — which are well-known to be not amenable to explicit treatment of the alphabets — or even worse infinite alphabets. Symbolic automata have proven in the last decade to be an effective algorithmic framework for handling large finite or even infinite alphabets. A symbolic automaton employs an effective boolean algebra, which offers a symbolic representation of character sets (i.e. in terms of predicates) and often lends itself to an exponentially more succinct representation of a language. Instead of letter-counting, Parikh’s Theorem for symbolic automata amounts to counting the number of times different predicates are satisfied by an input sequence. Unfortunately, naively applying Parikh’s Theorem from classical automata theory to symbolic automata yields existential Presburger formulas of exponential size. In this paper, we provide a new construction for Parikh’s Theorem for symbolic automata and grammars, which avoids this exponential blowup: our algorithm computes an existential formula in polynomial-time over (quantifier-free) Presburger and the base theory. In fact, our algorithm extends to the model of parametric symbolic grammars, which are one of the most expressive models of languages over infinite alphabets. We have implemented our algorithm and show it can be used to solve string constraints that are difficult to solve by existing solvers.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632867", + "link": "https://doi.org/10.1145/3632907", "conference_name": "POPL", "authors": [ { - "first_name": "John", - "last_name": "Cyphert", - "institution": "University of Wisconsin–Madison" + "first_name": "Matthew", + "last_name": "Hague", + "institution": "Royal Holloway University of London" }, { - "first_name": "Zachary", - "last_name": "Kincaid", - "institution": "Princeton University" + "first_name": "Artur", + "last_name": "Jeż", + "institution": "University of Wrocław" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Kaiserslautern" } ], - "dblp_key": "journals/pacmpl/CyphertK24", + "dblp_key": "journals/pacmpl/HagueJL24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632932", - "title": "Parametric Subtyping for Structural Parametric Polymorphism", - "abstract": "We study the interaction of structural subtyping with parametric polymorphism and recursively defined type constructors. Although structural subtyping is undecidable in this setting, we describe a notion of parametricity for type constructors and then exploit it to define parametric subtyping , a conceptually simple, decidable, and expressive fragment of structural subtyping that strictly generalizes rigid subtyping . We present and prove correct an effective saturation-based decision procedure for parametric subtyping, demonstrating its applicability using a variety of examples. We also provide an implementation of this decision procedure as an artifact.", + "paper_id": "10.1145/3632873", + "title": "Coarser Equivalences for Causal Concurrency", + "abstract": "Trace theory (formulated by Mazurkiewicz in 1987) is a principled framework for defining equivalence relations for concurrent program runs based on a commutativity relation over the set of atomic steps taken by individual program threads. Its simplicity, elegance, and algorithmic efficiency makes it useful in many different contexts including program verification and testing. It is well-understood that the larger the equivalence classes are, the more benefits they would bring to the algorithms and applications that use them. In this paper, we study relaxations of trace equivalence with the goal of maintaining its algorithmic advantages. We first prove that the largest appropriate relaxation of trace equivalence, an equivalence relation that preserves the order of steps taken by each thread and what write operation each read operation observes, does not yield efficient algorithms. Specifically, we prove a linear space lower bound for the problem of checking, in a streaming setting, if two arbitrary steps of a concurrent program run are causally concurrent (i.e. they can be reordered in an equivalent run) or causally ordered (i.e. they always appear in the same order in all equivalent runs). The same problem can be decided in constant space for trace equivalence. Next, we propose a new commutativity-based notion of equivalence called grain equivalence that is strictly more relaxed than trace equivalence, and yet yields a constant space algorithm for the same problem. This notion of equivalence uses commutativity of grains , which are sequences of atomic steps, in addition to the standard commutativity from trace theory. We study the two distinct cases when the grains are contiguous subwords of the input program run and when they are not, formulate the precise definition of causal concurrency in each case, and show that they can be decided in constant space , despite being strict relaxations of the notion of causal concurrency based on trace equivalence.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632932", + "link": "https://doi.org/10.1145/3632873", "conference_name": "POPL", "authors": [ { - "first_name": "Henry", - "last_name": "DeYoung", - "institution": "Carnegie Mellon University" - }, - { - "first_name": "Andreia", - "last_name": "Mordido", - "institution": "University of Lisbon" - }, - { - "first_name": "Frank", - "last_name": "Pfenning", - "institution": "Carnegie Mellon University" + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" }, { - "first_name": "Ankush", - "last_name": "Das", - "institution": "Amazon (United States)" + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" } ], - "dblp_key": "journals/pacmpl/DeYoungMPD24", + "dblp_key": "journals/pacmpl/FarzanM24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632901", - "title": "A Case for Synthesis of Recursive Quantum Unitary Programs", - "abstract": "Quantum programs are notoriously difficult to code and verify due to unintuitive quantum knowledge associated with quantum programming. Automated tools relieving the tedium and errors associated with low-level quantum details would hence be highly desirable. In this paper, we initiate the study of program synthesis for quantum unitary programs that recursively define a family of unitary circuits for different input sizes, which are widely used in existing quantum programming languages. Specifically, we present QSynth, the first quantum program synthesis framework, including a new inductive quantum programming language, its specification, a sound logic for reasoning, and an encoding of the reasoning procedure into SMT instances. By leveraging existing SMT solvers, QSynth successfully synthesizes 10 quantum unitary programs including quantum arithmetic programs, quantum eigenvalue inversion, quantum teleportation and Quantum Fourier Transformation, which can be readily transpiled to executable programs on major quantum platforms, e.g., Q#, IBM Qiskit, and AWS Braket.", + "paper_id": "10.1145/3632854", + "title": "Modular Denotational Semantics for Effects with Guarded Interaction Trees", + "abstract": "We present guarded interaction trees — a structure and a fully formalized framework for representing higherorder computations with higher-order effects in Coq, inspired by domain theory and the recently proposed interaction trees. We also present an accompanying separation logic for reasoning about guarded interaction trees. To demonstrate that guarded interaction trees provide a convenient domain for interpreting higher-order languages with effects, we define an interpretation of a PCF-like language with effects and show that this interpretation is sound and computationally adequate; we prove the latter using a logical relation defined using the separation logic. Guarded interaction trees also allow us to combine different effects and reason about them modularly. To illustrate this point, we give a modular proof of type soundness of cross-language interactions for safe interoperability of different higher-order languages with different effects. All results in the paper are formalized in Coq using the Iris logic over guarded type theory.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632901", + "link": "https://doi.org/10.1145/3632854", "conference_name": "POPL", "authors": [ { - "first_name": "Haowei", - "last_name": "Deng", - "institution": "University of Maryland, College Park" - }, - { - "first_name": "Runzhou", - "last_name": "Tao", - "institution": "Columbia University" + "first_name": "Dan", + "last_name": "Frumin", + "institution": "University of Groningen" }, { - "first_name": "Yuxiang", - "last_name": "Peng", - "institution": "University of Maryland, College Park" + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" }, { - "first_name": "Xiaodi", - "last_name": "Wu", - "institution": "University of Maryland, College Park" + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" } ], - "dblp_key": "journals/pacmpl/DengTPW24", + "dblp_key": "journals/pacmpl/FruminTB24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632913", - "title": "Enhanced Enumeration Techniques for Syntax-Guided Synthesis of Bit-Vector Manipulations", - "abstract": "Syntax-guided synthesis has been a prevalent theme in various computer-aided programming systems. However, the domain of bit-vector synthesis poses several unique challenges that have not yet been sufficiently addressed and resolved. In this paper, we propose a novel synthesis approach that incorporates a distinct enumeration strategy based on various factors. Technically, this approach weighs in subexpression recurrence by term-graph-based enumeration, avoids useless candidates by example-guided filtration, prioritizes valuable components identified by large language models. This approach also incorporates a bottom-up deduction step to enhance the enumeration algorithm by considering subproblems that contribute to the deductive resolution. We implement all the enhanced enumeration techniques in our S y G u S solver D ryad S ynth , which outperforms state-of-the-art solvers in terms of the number of solved problems, execution time, and solution size. Notably, D ryad S ynth successfully solved 31 synthesis problems for the first time, including 5 renowned Hacker’s Delight problems.", + "paper_id": "10.1145/3632843", + "title": "Ramsey Quantifiers in Linear Arithmetics", + "abstract": "We study Satisfiability Modulo Theories (SMT) enriched with the so-called Ramsey quantifiers, which assert the existence of cliques (complete graphs) in the graph induced by some formulas. The extended framework is known to have applications in proving program termination (in particular, whether a transitive binary predicate is well-founded), and monadic decomposability of SMT formulas. Our main result is a new algorithm for eliminating Ramsey quantifiers from three common SMT theories: Linear Integer Arithmetic (LIA), Linear Real Arithmetic (LRA), and Linear Integer Real Arithmetic (LIRA). In particular, if we work only with existentially quantified formulas, then our algorithm runs in polynomial time and produces a formula of linear size. One immediate consequence is that checking well-foundedness of a given formula in the aforementioned theory defining a transitive predicate can be straightforwardly handled by highly optimized SMT-solvers. We show also how this provides a uniform semi-algorithm for verifying termination and liveness with completeness guarantee (in fact, with an optimal computational complexity) for several well-known classes of infinite-state systems, which include succinct timed systems, one-counter systems, and monotonic counter systems. Another immediate consequence is a solution to an open problem on checking monadic decomposability of a given relation in quantifier-free fragments of LRA and LIRA, which is an important problem in automated reasoning and constraint databases. Our result immediately implies decidability of this problem with an optimal complexity (coNP-complete) and enables exploitation of SMT-solvers. It also provides a termination guarantee for the generic monadic decomposition algorithm of Veanes et al. for LIA, LRA, and LIRA. We report encouraging experimental results on a prototype implementation of our algorithms on micro-benchmarks.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632913", + "link": "https://doi.org/10.1145/3632843", "conference_name": "POPL", "authors": [ { - "first_name": "Yuantian", - "last_name": "Ding", - "institution": "Purdue University West Lafayette" + "first_name": "Pascal", + "last_name": "Bergsträßer", + "institution": "University of Kaiserslautern" }, { - "first_name": "Xiaokang", - "last_name": "Qiu", - "institution": "Purdue University West Lafayette" + "first_name": "Moses", + "last_name": "Ganardi", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" } ], - "dblp_key": "journals/pacmpl/DingQ24", + "dblp_key": "journals/pacmpl/BergstrasserGLZ24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632875", - "title": "An Infinite Needle in a Finite Haystack: Finding Infinite Counter-Models in Deductive Verification", - "abstract": "First-order logic, and quantifiers in particular, are widely used in deductive verification of programs and systems. Quantifiers are essential for describing systems with unbounded domains, but prove difficult for automated solvers. Significant effort has been dedicated to finding quantifier instantiations that establish unsatisfiability of quantified formulas, thus ensuring validity of a system’s verification conditions. However, in many cases the formulas are satisfiable—this is often the case in intermediate steps of the verification process, e.g., when an invariant is not yet inductive. For such cases, existing tools are limited to finding finite models as counterexamples. Yet, some quantified formulas are satisfiable but only have infinite models, which current solvers are unable to find. Such infinite counter-models are especially typical when first-order logic is used to approximate the natural numbers, the integers, or other inductive definitions such as linked lists, which is common in deductive verification. The inability of solvers to find infinite models makes them diverge in these cases, providing little feedback to the user as they try to make progress in their verification attempts. In this paper, we tackle the problem of finding such infinite models, specifically, finite representations thereof that can be presented to the user of a deductive verification tool. These models give insight into the verification failure, and allow the user to identify and fix bugs in the modeling of the system and its properties. Our approach consists of three parts. First, we introduce symbolic structures as a way to represent certain infinite models, and show they admit an efficient model checking procedure. Second, we describe an effective model finding procedure that symbolically explores a given (possibly infinite) family of symbolic structures in search of an infinite model for a given formula. Finally, we identify a new decidable fragment of first-order logic that extends and subsumes the many-sorted variant of EPR, where satisfiable formulas always have a model representable by a symbolic structure within a known family, making our model finding procedure a decision procedure for that fragment. We evaluate our approach on examples from the domains of distributed consensus protocols and of heapmanipulating programs (specifically, linked lists). Our implementation quickly finds infinite counter-models that demonstrate the source of verification failures in a simple way, while state-of-the-art SMT solvers and theorem provers such as Z3, cvc5, and Vampire diverge or return “unknown”.", + "paper_id": "10.1145/3632885", + "title": "Quantum Bisimilarity via Barbs and Contexts: Curbing the Power of Non-deterministic Observers", + "abstract": "Past years have seen the development of a few proposals for quantum extensions of process calculi. The rationale is clear: with the development of quantum communication protocols, there is a need to abstract and focus on the basic features of quantum concurrent systems, like CCS and CSP have done for their classical counterparts. So far, though, no accepted standard has emerged, neither for the syntax nor for the behavioural semantics. Indeed, the various proposals do not agree on what should be the observational properties of quantum values, and as a matter of fact, the soundness of such properties has never been validated against the prescriptions of quantum theory. To this aim, we introduce a new calculus, Linear Quantum CCS (lqCCS), and investigate the features of behavioural equivalences based on barbs and contexts. Our calculus can be thought of as an asynchronous, linear version of qCCS, which is in turn based on value-passing CCS. The combination of linearity and asynchronous communication fits well with the properties of quantum systems (e.g. the no-cloning theorem), since it ensures that each qubit is sent exactly once, precisely specifying which qubits of a process interact with the context. We exploit contexts to examine how bisimilarities relate to quantum theory. We show that the observational power of general contexts is incompatible with quantum theory: roughly, they can perform non-deterministic moves depending on quantum values without measuring (hence perturbing) them. Therefore, we refine the operational semantics in order to prevent contexts from performing unfeasible non-deterministic choices. This induces a coarser bisimilarity that better fits the quantum setting: ( i ) it lifts the indistinguishability of quantum states to the distributions of processes and, despite the additional constraints, ( i i ) it preserves the expressiveness of non-deterministic choices based on classical information. To the best of our knowledge, our semantics is the first one that satisfies the two properties above.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632875", + "link": "https://doi.org/10.1145/3632885", "conference_name": "POPL", "authors": [ { - "first_name": "Neta", - "last_name": "Elad", - "institution": "Tel Aviv University" + "first_name": "Lorenzo", + "last_name": "Ceragioli", + "institution": "IMT School for Advanced Studies Lucca" }, { - "first_name": "Oded", - "last_name": "Padon", - "institution": "" + "first_name": "Fabio", + "last_name": "Gadducci", + "institution": "University of Pisa" }, { - "first_name": "Sharon", - "last_name": "Shoham", - "institution": "Tel Aviv University" - } - ], - "dblp_key": "journals/pacmpl/EladPS24", - "venue": "popl", - "year": 2024 - }, - { - "paper_id": "10.1145/3632921", - "title": "Explicit Effects and Effect Constraints in ReML", - "abstract": "An important aspect of building robust systems that execute on dedicated hardware and perhaps in constrained environments is to control and manage the effects performed by program code. We present ReML, a higher-order statically-typed functional language, which allows programmers to be explicit about the effects performed by program code and in particular effects related to memory management Allowing programmers to be explicit about effects, the regions in which values reside, and the constraints under which code execute, makes programs robust to changes in the program source code and to compiler updates, including compiler optimisations. ReML is integrated with a polymorphic inference system that builds on top of region-inference, as it is implemented in the MLKit, a Standard ML compiler that uses region-based memory management as its primary memory management scheme.", - "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632921", - "conference_name": "POPL", - "authors": [ + "first_name": "Giuseppe", + "last_name": "Lomurno", + "institution": "University of Pisa" + }, { - "first_name": "Martin", - "last_name": "Elsman", - "institution": "University of Copenhagen" + "first_name": "Gabriele", + "last_name": "Tedeschi", + "institution": "University of Pisa" } ], - "dblp_key": "journals/pacmpl/Elsman24", + "dblp_key": "journals/pacmpl/CeragioliGLT24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632926", - "title": "Higher Order Bayesian Networks, Exactly", - "abstract": "Bayesian networks are graphical first-order probabilistic models that allow for a compact representation of large probability distributions, and for efficient inference, both exact and approximate. We introduce a higher-order programming language—in the idealized form of a λ -calculus—which we prove sound and complete w.r.t. Bayesian networks: each Bayesian network can be encoded as a term, and conversely each (possibly higher-order and recursive) program of ground type compiles into a Bayesian network. The language allows for the specification of recursive probability models and hierarchical structures. Moreover, we provide a compositional and cost-aware semantics which is based on factors, the standard mathematical tool used in Bayesian inference. Our results rely on advanced techniques rooted into linear logic, intersection types, rewriting theory, and Girard’s geometry of interaction, which are here combined in a novel way.", + "paper_id": "10.1145/3632897", + "title": "Monotonicity and the Precision of Program Analysis", + "abstract": "It is widely known that the precision of a program analyzer is closely related to intensional program properties, namely, properties concerning how the program is written. This explains, for instance, the interest in code obfuscation techniques, namely, tools explicitly designed to degrade the results of program analysis by operating syntactic program transformations. Less is known about a possible relation between what the program extensionally computes, namely, its input-output relation, and the precision of a program analyzer. In this paper we explore this potential connection in an effort to isolate program fragments that can be precisely analyzed by abstract interpretation, namely, programs for which there exists a complete abstract interpretation. In the field of static inference of numeric invariants, this happens for programs, or parts of programs, that manifest a monotone (either non-decreasing or non-increasing) behavior. We first formalize the notion of program monotonicity with respect to a given input and a set of numerical variables of interest. A sound proof system is then introduced with judgments specifying whether a program is monotone relatively to a set of variables and a set of inputs. The interest in monotonicity is justified because we prove that the family of monotone programs admits a complete abstract interpretation over a specific class of non-trivial numerical abstractions and inputs. This class includes all non-relational abstract domains that refine interval analysis (i.e., at least as precise as the intervals abstraction) and that satisfy a topological convexity hypothesis.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632926", + "link": "https://doi.org/10.1145/3632897", "conference_name": "POPL", "authors": [ { - "first_name": "Claudia", - "last_name": "Faggian", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Marco", + "last_name": "Campion", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Mila Dalla", + "last_name": "Preda", + "institution": "University of Verona" }, { - "first_name": "Daniele", - "last_name": "Pautasso", - "institution": "University of Turin" + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Arizona" }, { - "first_name": "Gabriele", - "last_name": "Vanoni", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Caterina", + "last_name": "Urban", + "institution": "Institut national de recherche en sciences et technologies du numérique" } ], - "dblp_key": "journals/pacmpl/FaggianPV24", + "dblp_key": "journals/pacmpl/CampionPGU24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632925", - "title": "Commutativity Simplifies Proofs of Parameterized Programs", - "abstract": "Commutativity has proven to be a powerful tool in reasoning about concurrent programs. Recent work has shown that a commutativity-based reduction of a program may admit simpler proofs than the program itself. The framework of lexicographical program reductions was introduced to formalize a broad class of reductions which accommodate sequential (thread-local) reasoning as well as synchronous programs. Approaches based on this framework, however, were fundamentally limited to program models with a fixed/bounded number of threads. In this paper, we show that it is possible to define an effective parametric family of program reductions that can be used to find simple proofs for parameterized programs , i.e., for programs with an unbounded number of threads. We show that reductions are indeed useful for the simplification of proofs for parameterized programs, in a sense that can be made precise: A reduction of a parameterized program may admit a proof which uses fewer or less sophisticated ghost variables. The reduction may therefore be within reach of an automated verification technique, even when the original parameterized program is not. As our first technical contribution, we introduce a notion of reductions for parameterized programs such that the reduction R of a parameterized program P is again a parameterized program (the thread template of R is obtained by source-to-source transformation of the thread template of P ). Consequently, existing techniques for the verification of parameterized programs can be directly applied to R instead of P . Our second technical contribution is that we define an appropriate family of pairwise preference orders which can be effectively used as a parameter to produce different lexicographical reductions. To determine whether this theoretical foundation amounts to a usable solution in practice, we have implemented the approach, based on a recently proposed framework for parameterized program verification. The results of our preliminary experiments on a representative set of examples are encouraging.", + "paper_id": "10.1145/3632912", + "title": "Mechanizing Refinement Types", + "abstract": "Practical checkers based on refinement types use the combination of implicit semantic subtyping and parametric polymorphism to simplify the specification and automate the verification of sophisticated properties of programs. However, a formal metatheoretic accounting of the soundness of refinement type systems using this combination has proved elusive. We present λ R F , a core refinement calculus that combines semantic subtyping and parametric polymorphism. We develop a metatheory for this calculus and prove soundness of the type system. Finally, we give two mechanizations of our metatheory. First, we introduce data propositions , a novel feature that enables encoding derivation trees for inductively defined judgments as refined data types, and use them to show that L iquid H askell ’s refinement types can be used for mechanization. Second, we mechanize our results in C oq , which comes with stronger soundness guarantees than L iquid H askell , thereby laying the foundations for mechanizing the metatheory of L iquid H askell .", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632925", + "link": "https://doi.org/10.1145/3632912", "conference_name": "POPL", "authors": [ { - "first_name": "Azadeh", - "last_name": "Farzan", - "institution": "University of Toronto" + "first_name": "Michael H.", + "last_name": "Borkowski", + "institution": "University of California San Diego" }, { - "first_name": "Dominik", - "last_name": "Klumpp", - "institution": "University of Freiburg" + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software Institute" }, { - "first_name": "Andreas", - "last_name": "Podelski", - "institution": "University of Freiburg" + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" } ], - "dblp_key": "journals/pacmpl/FarzanKP24", + "dblp_key": "journals/pacmpl/BorkowskiVJ24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632873", - "title": "Coarser Equivalences for Causal Concurrency", - "abstract": "Trace theory (formulated by Mazurkiewicz in 1987) is a principled framework for defining equivalence relations for concurrent program runs based on a commutativity relation over the set of atomic steps taken by individual program threads. Its simplicity, elegance, and algorithmic efficiency makes it useful in many different contexts including program verification and testing. It is well-understood that the larger the equivalence classes are, the more benefits they would bring to the algorithms and applications that use them. In this paper, we study relaxations of trace equivalence with the goal of maintaining its algorithmic advantages. We first prove that the largest appropriate relaxation of trace equivalence, an equivalence relation that preserves the order of steps taken by each thread and what write operation each read operation observes, does not yield efficient algorithms. Specifically, we prove a linear space lower bound for the problem of checking, in a streaming setting, if two arbitrary steps of a concurrent program run are causally concurrent (i.e. they can be reordered in an equivalent run) or causally ordered (i.e. they always appear in the same order in all equivalent runs). The same problem can be decided in constant space for trace equivalence. Next, we propose a new commutativity-based notion of equivalence called grain equivalence that is strictly more relaxed than trace equivalence, and yet yields a constant space algorithm for the same problem. This notion of equivalence uses commutativity of grains , which are sequences of atomic steps, in addition to the standard commutativity from trace theory. We study the two distinct cases when the grains are contiguous subwords of the input program run and when they are not, formulate the precise definition of causal concurrency in each case, and show that they can be decided in constant space , despite being strict relaxations of the notion of causal concurrency based on trace equivalence.", + "paper_id": "10.1145/3632935", + "title": "Programmatic Strategy Synthesis: Resolving Nondeterminism in Probabilistic Programs", + "abstract": "We consider imperative programs that involve both randomization and pure nondeterminism. The central question is how to find a strategy resolving the pure nondeterminism such that the so-obtained determinized program satisfies a given quantitative specification, i.e., bounds on expected outcomes such as the expected final value of a program variable or the probability to terminate in a given set of states. We show how memoryless and deterministic (MD) strategies can be obtained in a semi-automatic fashion using deductive verification techniques. For loop-free programs, the MD strategies resulting from our weakest preconditionstyle framework are correct by construction. This extends to loopy programs, provided the loops are equipped with suitable loop invariants - just like in program verification. We show how our technique relates to the well-studied problem of obtaining strategies in countably infinite Markov decision processes with reachabilityreward objectives. Finally, we apply our technique to several case studies.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632873", + "link": "https://doi.org/10.1145/3632935", "conference_name": "POPL", "authors": [ { - "first_name": "Azadeh", - "last_name": "Farzan", - "institution": "University of Toronto" + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" }, { - "first_name": "Umang", - "last_name": "Mathur", - "institution": "National University of Singapore" + "first_name": "Tom Jannik", + "last_name": "Biskup", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Tobias", + "last_name": "Winkler", + "institution": "RWTH Aachen University" } ], - "dblp_key": "journals/pacmpl/FarzanM24", + "dblp_key": "journals/pacmpl/BatzBKW24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632919", - "title": "Generating Well-Typed Terms That Are Not "Useless"", - "abstract": "Random generation of well-typed terms lies at the core of effective random testing of compilers for functional languages. Existing techniques have had success following a top-down type-oriented approach to generation that makes choices locally, which suffers from an inherent limitation: the type of an expression is often generated independently from the expression itself. Such generation frequently yields functions with argument types that cannot be used to produce a result in a meaningful way, leaving those arguments unused. Such “use-less” functions can hinder both performance, as the argument generation code is dead but still needs to be compiled, and effectiveness, as a lot of interesting optimizations are tested less frequently. In this paper, we introduce a novel algorithm that is significantly more effective at generating functions that use their arguments. We formalize both the “local” and the “nonlocal” algorithms as step-relations in an extension of the simply-typed lambda calculus with type and arguments holes, showing how delaying the generation of types for subexpressions by allowing nonlocal generation steps leads to “useful” functions. We implement our algorithm demonstrating that it’s much closer to real programs in terms of argument usage rate, and we replicate a case study from the literature that finds bugs in the strictness analyzer of GHC, with our approach finding bugs four times faster than the current state-of-the-art local approach.", + "paper_id": "10.1145/3632875", + "title": "An Infinite Needle in a Finite Haystack: Finding Infinite Counter-Models in Deductive Verification", + "abstract": "First-order logic, and quantifiers in particular, are widely used in deductive verification of programs and systems. Quantifiers are essential for describing systems with unbounded domains, but prove difficult for automated solvers. Significant effort has been dedicated to finding quantifier instantiations that establish unsatisfiability of quantified formulas, thus ensuring validity of a system’s verification conditions. However, in many cases the formulas are satisfiable—this is often the case in intermediate steps of the verification process, e.g., when an invariant is not yet inductive. For such cases, existing tools are limited to finding finite models as counterexamples. Yet, some quantified formulas are satisfiable but only have infinite models, which current solvers are unable to find. Such infinite counter-models are especially typical when first-order logic is used to approximate the natural numbers, the integers, or other inductive definitions such as linked lists, which is common in deductive verification. The inability of solvers to find infinite models makes them diverge in these cases, providing little feedback to the user as they try to make progress in their verification attempts. In this paper, we tackle the problem of finding such infinite models, specifically, finite representations thereof that can be presented to the user of a deductive verification tool. These models give insight into the verification failure, and allow the user to identify and fix bugs in the modeling of the system and its properties. Our approach consists of three parts. First, we introduce symbolic structures as a way to represent certain infinite models, and show they admit an efficient model checking procedure. Second, we describe an effective model finding procedure that symbolically explores a given (possibly infinite) family of symbolic structures in search of an infinite model for a given formula. Finally, we identify a new decidable fragment of first-order logic that extends and subsumes the many-sorted variant of EPR, where satisfiable formulas always have a model representable by a symbolic structure within a known family, making our model finding procedure a decision procedure for that fragment. We evaluate our approach on examples from the domains of distributed consensus protocols and of heapmanipulating programs (specifically, linked lists). Our implementation quickly finds infinite counter-models that demonstrate the source of verification failures in a simple way, while state-of-the-art SMT solvers and theorem provers such as Z3, cvc5, and Vampire diverge or return “unknown”.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632919", + "link": "https://doi.org/10.1145/3632875", "conference_name": "POPL", "authors": [ { - "first_name": "J. Ray", - "last_name": "Frank", - "institution": "University of Maryland, College Park" + "first_name": "Neta", + "last_name": "Elad", + "institution": "Tel Aviv University" }, { - "first_name": "Benjamin", - "last_name": "Quiring", - "institution": "University of Maryland, College Park" + "first_name": "Oded", + "last_name": "Padon", + "institution": "" }, { - "first_name": "Leonidas", - "last_name": "Lampropoulos", - "institution": "University of Maryland, College Park" + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" } ], - "dblp_key": "journals/pacmpl/FrankQL24", + "dblp_key": "journals/pacmpl/EladPS24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632854", - "title": "Modular Denotational Semantics for Effects with Guarded Interaction Trees", - "abstract": "We present guarded interaction trees — a structure and a fully formalized framework for representing higherorder computations with higher-order effects in Coq, inspired by domain theory and the recently proposed interaction trees. We also present an accompanying separation logic for reasoning about guarded interaction trees. To demonstrate that guarded interaction trees provide a convenient domain for interpreting higher-order languages with effects, we define an interpretation of a PCF-like language with effects and show that this interpretation is sound and computationally adequate; we prove the latter using a logical relation defined using the separation logic. Guarded interaction trees also allow us to combine different effects and reason about them modularly. To illustrate this point, we give a modular proof of type soundness of cross-language interactions for safe interoperability of different higher-order languages with different effects. All results in the paper are formalized in Coq using the Iris logic over guarded type theory.", + "paper_id": "10.1145/3632893", + "title": "Unboxed Data Constructors: Or, How cpp Decides a Halting Problem", + "abstract": "We propose a new language feature for ML-family languages, the ability to selectively unbox certain data constructors, so that their runtime representation gets compiled away to just the identity on their argument. Unboxing must be statically rejected when it could introduce confusion, that is, distinct values with the same representation. We discuss the use-case of big numbers, where unboxing allows to write code that is both efficient and safe, replacing either a safe but slow version or a fast but unsafe version. We explain the static analysis necessary to reject incorrect unboxing requests. We present our prototype implementation of this feature for the OCaml programming language, discuss several design choices and the interaction with advanced features such as Guarded Algebraic Datatypes. Our static analysis requires expanding type definitions in type expressions, which is not necessarily normalizing in presence of recursive type definitions. In other words, we must decide normalization of terms in the first-order λ -calculus with recursion. We provide an algorithm to detect non-termination on-the-fly during reduction, with proofs of correctness and completeness. Our algorithm turns out to be closely related to the normalization strategy for macro expansion in the cpp preprocessor.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632854", + "link": "https://doi.org/10.1145/3632893", "conference_name": "POPL", "authors": [ { - "first_name": "Dan", - "last_name": "Frumin", - "institution": "University of Groningen" + "first_name": "Nicolas", + "last_name": "Chataing", + "institution": "École Normale Supérieure - PSL" }, { - "first_name": "Amin", - "last_name": "Timany", - "institution": "Aarhus University" + "first_name": "Stephen", + "last_name": "Dolan", + "institution": "" }, { - "first_name": "Lars", - "last_name": "Birkedal", - "institution": "Aarhus University" + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" } ], - "dblp_key": "journals/pacmpl/FruminTB24", + "dblp_key": "journals/pacmpl/ChataingDSY24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632922", - "title": "Indexed Types for a Statically Safe WebAssembly", - "abstract": "We present Wasm-precheck, a superset of WebAssembly (Wasm) that uses indexed types to express and check simple constraints over program values. This additional static reasoning enables safely removing dynamic safety checks from Wasm, such as memory bounds checks. We implement Wasm-precheck as an extension of the Wasmtime compiler and runtime, evaluate the run-time and compile-time performance of Wasm-precheck vs Wasm configurations with explicit dynamic checks, and find an average run-time performance gain of 1.71 x faster in the widely used PolyBenchC benchmark suite, for a small overhead in binary size ( 7.18 % larger) and type-checking time (1.4% slower). We also prove type and memory safety of Wasm-precheck, prove Wasm safely embeds into Wasm-precheck ensuring backwards compatibility, prove Wasm-precheck type-erases to Wasm, and discuss design and implementation trade-offs.", + "paper_id": "10.1145/3632916", + "title": "Securing Verified IO Programs Against Unverified Code in F", + "abstract": "We introduce SCIO ⋆ , a formally secure compilation framework for statically verified programs performing input-output (IO). The source language is an F ⋆ subset in which a verified program interacts with its IO-performing context via a higher-order interface that includes refinement types as well as pre- and post-conditions about past IO events. The target language is a smaller F ⋆ subset in which the compiled program is linked with an adversarial context that has an interface without refinement types, pre-conditions, or concrete post-conditions. To bridge this interface gap and make compilation and linking secure we propose a formally verified combination of higher-order contracts and reference monitoring for recording and controlling IO operations. Compilation uses contracts to convert the logical assumptions the program makes about the context into dynamic checks on each context-program boundary crossing. These boundary checks can depend on information about past IO events stored in the state of the monitor. But these checks cannot stop the adversarial target context before it performs dangerous IO operations. Therefore linking in SCIO ⋆ additionally forces the context to perform all IO actions via a secure IO library, which uses reference monitoring to dynamically enforce an access control policy before each IO operation. We prove in F ⋆ that SCIO ⋆ soundly enforces a global trace property for the compiled verified program linked with the untrusted context. Moreover, we prove in F ⋆ that SCIO ⋆ satisfies by construction Robust Relational Hyperproperty Preservation, a very strong secure compilation criterion. Finally, we illustrate SCIO ⋆ at work on a simple web server example.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632922", + "link": "https://doi.org/10.1145/3632916", "conference_name": "POPL", "authors": [ { - "first_name": "Adam T.", - "last_name": "Geller", - "institution": "University of British Columbia" + "first_name": "Cezar-Constantin", + "last_name": "Andrici", + "institution": "Max Planck Institute for Security and Privacy" }, { - "first_name": "J. Ray", - "last_name": "Frank", - "institution": "University of British Columbia" + "first_name": "Ştefan", + "last_name": "Ciobâcă", + "institution": "Alexandru Ioan Cuza University" }, { - "first_name": "William J.", - "last_name": "Bowman", - "institution": "University of British Columbia" + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "CryptoExperts (France)" + }, + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Exequiel", + "last_name": "Rivas", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "Centre Inria de Saclay" } ], - "dblp_key": "journals/pacmpl/GellerFB24", + "dblp_key": "journals/pacmpl/AndriciCHMRTW24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632868", - "title": "Asynchronous Probabilistic Couplings in Higher-Order Separation Logic", - "abstract": "Probabilistic couplings are the foundation for many probabilistic relational program logics and arise when relating random sampling statements across two programs. In relational program logics, this manifests as dedicated coupling rules that, e.g ., say we may reason as if two sampling statements return the same value. However, this approach fundamentally requires aligning or “synchronizing” the sampling statements of the two programs which is not always possible. In this paper, we develop Clutch, a higher-order probabilistic relational separation logic that addresses this issue by supporting asynchronous probabilistic couplings. We use Clutch to develop a logical step-indexed logical relation to reason about contextual refinement and equivalence of higher-order programs written in a rich language with a probabilistic choice operator, higher-order local state, and impredicative polymorphism. Finally, we demonstrate our approach on a number of case studies. All the results that appear in the paper have been formalized in the Coq proof assistant using the Coquelicot library and the Iris separation logic framework.", + "paper_id": "10.1145/3632863", + "title": "An Axiomatic Basis for Computer Programming on the Relaxed Arm-A Architecture: The AxSL Logic", + "abstract": "Very relaxed concurrency memory models, like those of the Arm-A, RISC-V, and IBM Power hardware architectures, underpin much of computing but break a fundamental intuition about programs, namely that syntactic program order and the reads-from relation always both induce order in the execution. Instead, out-of-order execution is allowed except where prevented by certain pairwise dependencies, barriers, or other synchronisation. This means that there is no notion of the 'current' state of the program, making it challenging to design (and prove sound) syntax-directed, modular reasoning methods like Hoare logics, as usable resources cannot implicitly flow from one program point to the next. We present AxSL, a separation logic for the relaxed memory model of Arm-A, that captures the fine-grained reasoning underpinning the low-overhead synchronisation mechanisms used by high-performance systems code. In particular, AxSL allows transferring arbitrary resources using relaxed reads and writes when they induce inter-thread ordering. We mechanise AxSL in the Iris separation logic framework, illustrate it on key examples, and prove it sound with respect to the axiomatic memory model of Arm-A. Our approach is largely generic in the axiomatic model and in the instruction-set semantics, offering a potential way forward for compositional reasoning for other similar models, and for the combination of production concurrency models and full-scale ISAs.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632868", + "link": "https://doi.org/10.1145/3632863", "conference_name": "POPL", "authors": [ { - "first_name": "Simon Oddershede", - "last_name": "Gregersen", - "institution": "Aarhus University" + "first_name": "Angus", + "last_name": "Hammond", + "institution": "University of Cambridge" }, { - "first_name": "Alejandro", - "last_name": "Aguirre", + "first_name": "Zongyuan", + "last_name": "Liu", "institution": "Aarhus University" }, { - "first_name": "Philipp G.", - "last_name": "Haselwarter", - "institution": "Aarhus University" + "first_name": "Thibaut", + "last_name": "Pérami", + "institution": "University of Cambridge" }, { - "first_name": "Joseph", - "last_name": "Tassarotti", - "institution": "New York University" + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" }, { "first_name": "Lars", "last_name": "Birkedal", "institution": "Aarhus University" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "Aarhus University" } ], - "dblp_key": "journals/pacmpl/GregersenAHTB24", + "dblp_key": "journals/pacmpl/HammondLPSBP24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632852", - "title": "Decalf: A Directed, Effectful Cost-Aware Logical Framework", - "abstract": "We present decalf , a d irected, e ffectful c ost- a ware l ogical f ramework for studying quantitative aspects of functional programs with effects. Like calf , the language is based on a formal phase distinction between the extension and the intension of a program, its pure behavior as distinct from its cost measured by an effectful step-counting primitive. The type theory ensures that the behavior is unaffected by the cost accounting. Unlike calf , the present language takes account of effects , such as probabilistic choice and mutable state. This extension requires a reformulation of calf ’s approach to cost accounting: rather than rely on a “separable” notion of cost, here a cost bound is simply another program . To make this formal, we equip every type with an intrinsic preorder, relaxing the precise cost accounting intrinsic to a program to a looser but nevertheless informative estimate. For example, the cost bound of a probabilistic program is itself a probabilistic program that specifies the distribution of costs. This approach serves as a streamlined alternative to the standard method of isolating a cost recurrence and readily extends to higher-order, effectful programs. The development proceeds by first introducing the decalf type system, which is based on an intrinsic ordering among terms that restricts in the extensional phase to extensional equality, but in the intensional phase reflects an approximation of the cost of a program of interest. This formulation is then applied to a number of illustrative examples, including pure and effectful sorting algorithms, simple probabilistic programs, and higher-order functions. Finally, we justify decalf via a model in the topos of augmented simplicial sets.", + "paper_id": "10.1145/3632925", + "title": "Commutativity Simplifies Proofs of Parameterized Programs", + "abstract": "Commutativity has proven to be a powerful tool in reasoning about concurrent programs. Recent work has shown that a commutativity-based reduction of a program may admit simpler proofs than the program itself. The framework of lexicographical program reductions was introduced to formalize a broad class of reductions which accommodate sequential (thread-local) reasoning as well as synchronous programs. Approaches based on this framework, however, were fundamentally limited to program models with a fixed/bounded number of threads. In this paper, we show that it is possible to define an effective parametric family of program reductions that can be used to find simple proofs for parameterized programs , i.e., for programs with an unbounded number of threads. We show that reductions are indeed useful for the simplification of proofs for parameterized programs, in a sense that can be made precise: A reduction of a parameterized program may admit a proof which uses fewer or less sophisticated ghost variables. The reduction may therefore be within reach of an automated verification technique, even when the original parameterized program is not. As our first technical contribution, we introduce a notion of reductions for parameterized programs such that the reduction R of a parameterized program P is again a parameterized program (the thread template of R is obtained by source-to-source transformation of the thread template of P ). Consequently, existing techniques for the verification of parameterized programs can be directly applied to R instead of P . Our second technical contribution is that we define an appropriate family of pairwise preference orders which can be effectively used as a parameter to produce different lexicographical reductions. To determine whether this theoretical foundation amounts to a usable solution in practice, we have implemented the approach, based on a recently proposed framework for parameterized program verification. The results of our preliminary experiments on a representative set of examples are encouraging.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632852", + "link": "https://doi.org/10.1145/3632925", "conference_name": "POPL", "authors": [ { - "first_name": "Harrison", - "last_name": "Grodin", - "institution": "Carnegie Mellon University" - }, - { - "first_name": "Yue", - "last_name": "Niu", - "institution": "Carnegie Mellon University" + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" }, { - "first_name": "Jonathan", - "last_name": "Sterling", - "institution": "University of Cambridge" + "first_name": "Dominik", + "last_name": "Klumpp", + "institution": "University of Freiburg" }, { - "first_name": "Robert", - "last_name": "Harper", - "institution": "Carnegie Mellon University" + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" } ], - "dblp_key": "journals/pacmpl/GrodinNSH24", + "dblp_key": "journals/pacmpl/FarzanKP24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632881", - "title": "Orthologic with Axioms", - "abstract": "We study the proof theory and algorithms for orthologic, a logical system based on ortholattices, which have shown practical relevance in simplification and normalization of verification conditions. Ortholattices weaken Boolean algebras while having polynomial-time equivalence checking that is sound with respect to Boolean algebra semantics. We generalize ortholattice reasoning and obtain an algorithm for proving a larger class of classically valid formulas. As the key result, we analyze a proof system for orthologic augmented with axioms. An important feature of the system is that it limits the number of formulas in a sequent to at most two, which makes the extension with axioms non-trivial. We show a generalized form of cut elimination for this system, which implies a sub-formula property. From there we derive a cubic-time algorithm for provability from axioms, or equivalently, for validity in finitely presented ortholattices. We further show that propositional resolution of width 5 proves all formulas provable in orthologic with axioms. We show that orthologic system subsumes resolution of width 2 and arbitrarily wide unit resolution and is complete for reasoning about generalizations of propositional Horn clauses. Moving beyond ground axioms, we introduce effectively propositional orthologic (by analogy with EPR for classical logic), presenting its semantics as well as a sound and complete proof system. Our proof system implies the decidability of effectively propositional orthologic, as well as its fixed-parameter tractability for a bounded maximal number of variables in each axiom. As a special case, we obtain a generalization of Datalog with negation and disjunction.", + "paper_id": "10.1145/3633279", + "title": "Reachability in Continuous Pushdown VASS", + "abstract": "Pushdown Vector Addition Systems with States (PVASS) consist of finitely many control states, a pushdown stack, and a set of counters that can be incremented and decremented, but not tested for zero. Whether the reachability problem is decidable for PVASS is a long-standing open problem. We consider continuous PVASS , which are PVASS with a continuous semantics. This means, the counter values are rational numbers and whenever a vector is added to the current counter values, this vector is first scaled with an arbitrarily chosen rational factor between zero and one. We show that reachability in continuous PVASS is NEXPTIME -complete. Our result is unusually robust: Reachability can be decided in NEXPTIME even if all numbers are specified in binary. On the other hand, NEXPTIME -hardness already holds for coverability, in fixed dimension, for bounded stack, and even if all numbers are specified in unary.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632881", + "link": "https://doi.org/10.1145/3633279", "conference_name": "POPL", "authors": [ { - "first_name": "Simon", - "last_name": "Guilloud", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "A. R.", + "last_name": "Balasubramanian", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Viktor", - "last_name": "Kunčak", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Ramanathan S.", + "last_name": "Thinniyam", + "institution": "Uppsala University" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" } ], - "dblp_key": "journals/pacmpl/GuilloudK24", + "dblp_key": "journals/pacmpl/BalasubramanianMTZ24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632844", - "title": "Deciding Asynchronous Hyperproperties for Recursive Programs", - "abstract": "We introduce a novel logic for asynchronous hyperproperties with a new mechanism to identify relevant positions on traces. While the new logic is more expressive than a related logic presented recently by Bozzelli et al., we obtain the same complexity of the model checking problem for finite state models. Beyond this, we study the model checking problem of our logic for pushdown models. We argue that the combination of asynchronicity and a non-regular model class studied in this paper constitutes the first suitable approach for hyperproperty model checking against recursive programs.", + "paper_id": "10.1145/3632920", + "title": "Internal Parametricity, without an Interval", + "abstract": "Parametricity is a property of the syntax of type theory implying, e.g., that there is only one function having the type of the polymorphic identity function. Parametricity is usually proven externally, and does not hold internally. Internalising it is difficult because once there is a term witnessing parametricity, it also has to be parametric itself and this results in the appearance of higher dimensional cubes. In previous theories with internal parametricity, either an explicit syntax for higher cubes is present or the theory is extended with a new sort for the interval. In this paper we present a type theory with internal parametricity which is a simple extension of Martin-Löf type theory: there are a few new type formers, term formers and equations. Geometry is not explicit in this syntax, but emergent: the new operations and equations only refer to objects up to dimension 3. We show that this theory is modelled by presheaves over the BCH cube category. Fibrancy conditions are not needed because we use span-based rather than relational parametricity. We define a gluing model for this theory implying that external parametricity and canonicity hold. The theory can be seen as a special case of a new kind of modal type theory, and it is the simplest setting in which the computational properties of higher observational type theory can be demonstrated.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632844", + "link": "https://doi.org/10.1145/3632920", "conference_name": "POPL", "authors": [ { - "first_name": "Jens Oliver", - "last_name": "Gutsfeld", - "institution": "University of Münster" + "first_name": "Thorsten", + "last_name": "Altenkirch", + "institution": "University of Nottingham" }, { - "first_name": "Markus", - "last_name": "Müller-Olm", - "institution": "University of Münster" + "first_name": "Yorgo", + "last_name": "Chamoun", + "institution": "École Polytechnique" }, { - "first_name": "Christoph", - "last_name": "Ohrem", - "institution": "University of Münster" + "first_name": "Ambrus", + "last_name": "Kaposi", + "institution": "Eötvös Loránd University" + }, + { + "first_name": "Michael", + "last_name": "Shulman", + "institution": "University of San Diego" } ], - "dblp_key": "journals/pacmpl/GutsfeldMO24", + "dblp_key": "journals/pacmpl/AltenkirchCKS24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632907", - "title": "Parikh's Theorem Made Symbolic", - "abstract": "Parikh’s Theorem is a fundamental result in automata theory with numerous applications in computer science. These include software verification (e.g. infinite-state verification, string constraints, and theory of arrays), verification of cryptographic protocols (e.g. using Horn clauses modulo equational theories) and database querying (e.g. evaluating path-queries in graph databases), among others. Parikh’s Theorem states that the letter-counting abstraction of a language recognized by finite automata or context-free grammars is definable in Linear Integer Arithmetic (a.k.a. Presburger Arithmetic). In fact, there is a linear-time algorithm computing existential Presburger formulas capturing such abstractions, which enables an efficient analysis via SMT-solvers. Unfortunately, real-world applications typically require large alphabets (e.g. Unicode, containing a million of characters) — which are well-known to be not amenable to explicit treatment of the alphabets — or even worse infinite alphabets. Symbolic automata have proven in the last decade to be an effective algorithmic framework for handling large finite or even infinite alphabets. A symbolic automaton employs an effective boolean algebra, which offers a symbolic representation of character sets (i.e. in terms of predicates) and often lends itself to an exponentially more succinct representation of a language. Instead of letter-counting, Parikh’s Theorem for symbolic automata amounts to counting the number of times different predicates are satisfied by an input sequence. Unfortunately, naively applying Parikh’s Theorem from classical automata theory to symbolic automata yields existential Presburger formulas of exponential size. In this paper, we provide a new construction for Parikh’s Theorem for symbolic automata and grammars, which avoids this exponential blowup: our algorithm computes an existential formula in polynomial-time over (quantifier-free) Presburger and the base theory. In fact, our algorithm extends to the model of parametric symbolic grammars, which are one of the most expressive models of languages over infinite alphabets. We have implemented our algorithm and show it can be used to solve string constraints that are difficult to solve by existing solvers.", + "paper_id": "10.1145/3633280", + "title": "Answer Refinement Modification: Refinement Type System for Algebraic Effects and Handlers", + "abstract": "Algebraic effects and handlers are a mechanism to structure programs with computational effects in a modular way. They are recently gaining popularity and being adopted in practical languages, such as OCaml. Meanwhile, there has been substantial progress in program verification via refinement type systems . While a variety of refinement type systems have been proposed, thus far there has not been a satisfactory refinement type system for algebraic effects and handlers. In this paper, we fill the void by proposing a novel refinement type system for languages with algebraic effects and handlers. The expressivity and usefulness of algebraic effects and handlers come from their ability to manipulate delimited continuations , but delimited continuations also complicate programs' control flow and make their verification harder. To address the complexity, we introduce a novel concept that we call answer refinement modification (ARM for short), which allows the refinement type system to precisely track what effects occur and in what order when a program is executed, and reflect such information as modifications to the refinements in the types of delimited continuations. We formalize our type system that supports ARM (as well as answer type modification, or ATM) and prove its soundness. Additionally, as a proof of concept, we have extended the refinement type system to a subset of OCaml 5 which comes with a built-in support for effect handlers, implemented a type checking and inference algorithm for the extension, and evaluated it on a number of benchmark programs that use algebraic effects and handlers. The evaluation demonstrates that ARM is conceptually simple and practically useful. Finally, a natural alternative to directly reasoning about a program with delimited continuations is to apply a continuation passing style (CPS) transformation that transforms the program to a pure program without delimited continuations. We investigate this alternative in the paper, and show that the approach is indeed possible by proposing a novel CPS transformation for algebraic effects and handlers that enjoys bidirectional (refinement-)type-preservation. We show that there are pros and cons with this approach, namely, while one can use an existing refinement type checking and inference algorithm that can only (directly) handle pure programs, there are issues such as needing type annotations in source programs and making the inferred types less informative to a user.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632907", + "link": "https://doi.org/10.1145/3633280", "conference_name": "POPL", "authors": [ { - "first_name": "Matthew", - "last_name": "Hague", - "institution": "Royal Holloway University of London" + "first_name": "Fuga", + "last_name": "Kawamata", + "institution": "Waseda University" }, { - "first_name": "Artur", - "last_name": "Jeż", - "institution": "University of Wrocław" + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" }, { - "first_name": "Anthony W.", - "last_name": "Lin", - "institution": "University of Kaiserslautern" + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Waseda University" } ], - "dblp_key": "journals/pacmpl/HagueJL24", + "dblp_key": "journals/pacmpl/KawamataUST24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632863", - "title": "An Axiomatic Basis for Computer Programming on the Relaxed Arm-A Architecture: The AxSL Logic", - "abstract": "Very relaxed concurrency memory models, like those of the Arm-A, RISC-V, and IBM Power hardware architectures, underpin much of computing but break a fundamental intuition about programs, namely that syntactic program order and the reads-from relation always both induce order in the execution. Instead, out-of-order execution is allowed except where prevented by certain pairwise dependencies, barriers, or other synchronisation. This means that there is no notion of the 'current' state of the program, making it challenging to design (and prove sound) syntax-directed, modular reasoning methods like Hoare logics, as usable resources cannot implicitly flow from one program point to the next. We present AxSL, a separation logic for the relaxed memory model of Arm-A, that captures the fine-grained reasoning underpinning the low-overhead synchronisation mechanisms used by high-performance systems code. In particular, AxSL allows transferring arbitrary resources using relaxed reads and writes when they induce inter-thread ordering. We mechanise AxSL in the Iris separation logic framework, illustrate it on key examples, and prove it sound with respect to the axiomatic memory model of Arm-A. Our approach is largely generic in the axiomatic model and in the instruction-set semantics, offering a potential way forward for compositional reasoning for other similar models, and for the combination of production concurrency models and full-scale ISAs.", + "paper_id": "10.1145/3632874", + "title": "Implementation and Synthesis of Math Library Functions", + "abstract": "Achieving speed and accuracy for math library functions like exp , sin , and log is difficult. This is because low-level implementation languages like C do not help math library developers catch mathematical errors, build implementations incrementally, or separate high-level and low-level decision making. This ultimately puts development of such functions out of reach for all but the most experienced experts. To address this, we introduce MegaLibm, a domain-specific language for implementing, testing, and tuning math library implementations. MegaLibm is safe, modular, and tunable. Implementations in MegaLibm can automatically detect mathematical mistakes like sign flips via semantic wellformedness checks, and components like range reductions can be implemented in a modular, composable way, simplifying implementations. Once the high-level algorithm is done, tuning parameters like working precisions and evaluation schemes can be adjusted through orthogonal tuning parameters to achieve the desired speed and accuracy. MegaLibm also enables math library developers to work interactively, compiling, testing, and tuning their implementations and invoking tools like Sollya and type-directed synthesis to complete components and synthesize entire implementations. MegaLibm can express 8 state-of-the-art math library implementations with comparable speed and accuracy to the original C code, and can synthesize 5 variations and 3 from-scratch implementations with minimal guidance.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632863", + "link": "https://doi.org/10.1145/3632874", "conference_name": "POPL", "authors": [ { - "first_name": "Angus", - "last_name": "Hammond", - "institution": "University of Cambridge" - }, - { - "first_name": "Zongyuan", - "last_name": "Liu", - "institution": "Aarhus University" - }, - { - "first_name": "Thibaut", - "last_name": "Pérami", - "institution": "University of Cambridge" - }, - { - "first_name": "Peter", - "last_name": "Sewell", - "institution": "University of Cambridge" + "first_name": "Ian", + "last_name": "Briggs", + "institution": "University of Utah" }, { - "first_name": "Lars", - "last_name": "Birkedal", - "institution": "Aarhus University" + "first_name": "Yash", + "last_name": "Lad", + "institution": "University of Utah" }, { - "first_name": "Jean", - "last_name": "Pichon-Pharabod", - "institution": "Aarhus University" + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Utah" } ], - "dblp_key": "journals/pacmpl/HammondLPSBP24", + "dblp_key": "journals/pacmpl/BriggsLP24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632899", - "title": "Solving Infinite-State Games via Acceleration", - "abstract": "Two-player graph games have found numerous applications, most notably in the synthesis of reactive systems from temporal specifications, but also in verification. The relevance of infinite-state systems in these areas has lead to significant attention towards developing techniques for solving infinite-state games. We propose novel symbolic semi-algorithms for solving infinite-state games with temporal winning conditions. The novelty of our approach lies in the introduction of an acceleration technique that enhances fixpoint-based game-solving methods and helps to avoid divergence. Classical fixpoint-based algorithms, when applied to infinite-state games, are bound to diverge in many cases, since they iteratively compute the set of states from which one player has a winning strategy. Our proposed approach can lead to convergence in cases where existing algorithms require an infinite number of iterations. This is achieved by acceleration: computing an infinite set of states from which a simpler sub-strategy can be iterated an unbounded number of times in order to win the game. Ours is the first method for solving infinite-state games to employ acceleration. Thanks to this, it is able to outperform state-of-the-art techniques on a range of benchmarks, as evidenced by our evaluation of a prototype implementation.", + "paper_id": "10.1145/3632915", + "title": "Predictive Monitoring against Pattern Regular Languages", + "abstract": "While current bug detection techniques for concurrent software focus on unearthing low-level issues such as data races or deadlocks, they often fall short of discovering more intricate temporal behaviours that can arise even in the absence of such low-level issues. In this paper, we focus on the problem of dynamically analysing concurrent software against high-level temporal specifications such as LTL. Existing techniques for runtime monitoring against such specifications are primarily designed for sequential software and remain inadequate in the presence of concurrency — violations may be observed only in intricate thread interleavings, requiring many re-runs of the underlying software in conjunction with the analysis. Towards this, we study the problem of predictive runtime monitoring , inspired by the analogous problem of predictive data race detection studied extensively recently. The predictive runtime monitoring question asks, given an execution σ , if it can be soundly reordered to expose violations of a specification. In general, this problem may become easily intractable when either the specifications or the notion of reorderings used is complex. In this paper, we focus on specifications that are given in regular languages. Our notion of reorderings is trace equivalence , where an execution is considered a reordering of another if it can be obtained from the latter by successively commuting adjacent independent actions. We first show that, even in this simplistic setting, the problem of predictive monitoring admits a super-linear lower bound of O ( n α ) , where n is the number of events in the execution, and α is a parameter describing the degree of commutativity, and typically corresponds to the number of threads in the execution. As a result, predictive runtime monitoring even in this setting is unlikely to be efficiently solvable, unlike in the non-predictive setting where the problem can be checked using a deterministic finite automaton (and thus, a constant-space streaming linear-time algorithm). Towards this, we identify a sub-class of regular languages, called pattern languages (and their extension generalized pattern languages ). Pattern languages can naturally express specific ordering of some number of (labelled) events, and have been inspired by popular empirical hypotheses underlying many concurrency bug detection approaches such as the “small bug depth” hypothesis. More importantly, we show that for pattern (and generalized pattern) languages, the predictive monitoring problem can be solved using a constant-space streaming linear-time algorithm. We implement and evaluate our algorithm PatternTrack on benchmarks from the literature and show that it is effective in monitoring large-scale applications.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632899", + "link": "https://doi.org/10.1145/3632915", "conference_name": "POPL", "authors": [ { - "first_name": "Philippe", - "last_name": "Heim", - "institution": "Helmholtz Center for Information Security" + "first_name": "Zhendong", + "last_name": "Ang", + "institution": "National University of Singapore" }, { - "first_name": "Rayna", - "last_name": "Dimitrova", - "institution": "Helmholtz Center for Information Security" + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" } ], - "dblp_key": "journals/pacmpl/HeimD24", + "dblp_key": "journals/pacmpl/AngM24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632869", - "title": "Quotient Haskell: Lightweight Quotient Types for All", - "abstract": "Subtypes and quotient types are dual type abstractions. However, while subtypes are widely used both explicitly and implicitly, quotient types have not seen much practical use outside of proof assistants. A key difficulty to wider adoption of quotient types lies in the significant burden of proof-obligations that arises from their use. In this article, we address this issue by introducing a class of quotient types for which the proof-obligations are decidable by an SMT solver. We demonstrate this idea in practice by presenting Quotient Haskell , an extension of Liquid Haskell with support for quotient types.", + "paper_id": "10.1145/3632901", + "title": "A Case for Synthesis of Recursive Quantum Unitary Programs", + "abstract": "Quantum programs are notoriously difficult to code and verify due to unintuitive quantum knowledge associated with quantum programming. Automated tools relieving the tedium and errors associated with low-level quantum details would hence be highly desirable. In this paper, we initiate the study of program synthesis for quantum unitary programs that recursively define a family of unitary circuits for different input sizes, which are widely used in existing quantum programming languages. Specifically, we present QSynth, the first quantum program synthesis framework, including a new inductive quantum programming language, its specification, a sound logic for reasoning, and an encoding of the reasoning procedure into SMT instances. By leveraging existing SMT solvers, QSynth successfully synthesizes 10 quantum unitary programs including quantum arithmetic programs, quantum eigenvalue inversion, quantum teleportation and Quantum Fourier Transformation, which can be readily transpiled to executable programs on major quantum platforms, e.g., Q#, IBM Qiskit, and AWS Braket.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632869", + "link": "https://doi.org/10.1145/3632901", "conference_name": "POPL", "authors": [ { - "first_name": "B", - "last_name": "Hewer", - "institution": "University of Nottingham" + "first_name": "Haowei", + "last_name": "Deng", + "institution": "University of Maryland, College Park" }, { - "first_name": "Graham", - "last_name": "Hutton", - "institution": "University of Nottingham" + "first_name": "Runzhou", + "last_name": "Tao", + "institution": "Columbia University" + }, + { + "first_name": "Yuxiang", + "last_name": "Peng", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" } ], - "dblp_key": "journals/pacmpl/HewerH24", + "dblp_key": "journals/pacmpl/DengTPW24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632864", - "title": "Regular Abstractions for Array Systems", - "abstract": "Verifying safety and liveness over array systems is a highly challenging problem. Array systems naturally capture parameterized systems such as distributed protocols with an unbounded number of processes. Such distributed protocols often exploit process IDs during their computation, resulting in array systems whose element values range over an infinite domain. In this paper, we develop a novel framework for proving safety and liveness over array systems. The crux of the framework is to overapproximate an array system as a string rewriting system (i.e. over a finite alphabet) by means of a new predicate abstraction that exploits the so-called indexed predicates. This allows us to tap into powerful verification methods for string rewriting systems that have been heavily developed in the last two decades or so (e.g. regular model checking). We demonstrate how our method yields simple, automatically verifiable proofs of safety and liveness properties for challenging examples, including Dijkstra’s self-stabilizing protocol and the Chang-Roberts leader election protocol.", + "paper_id": "10.1145/3632900", + "title": "Guided Equality Saturation", + "abstract": "Rewriting is a principled term transformation technique with uses across theorem proving and compilation. In theorem proving, each rewrite is a proof step; in compilation, rewrites optimize a program term. While developing rewrite sequences manually is possible, this process does not scale to larger rewrite sequences. Automated rewriting techniques, like greedy simplification or equality saturation, work well without requiring human input. Yet, they do not scale to large search spaces, limiting the complexity of tasks where automated rewriting is effective, and meaning that just a small increase in term size or rewrite length may result in failure. This paper proposes a semi-automatic rewriting technique as a means to scale rewriting by allowing human insight at key decision points. Specifically, we propose guided equality saturation that embraces human guidance when fully automated equality saturation does not scale. The rewriting is split into two simpler automatic equality saturation steps: from the original term to a human-provided intermediate guide , and from the guide to the target. Complex rewriting tasks may require multiple guides, resulting in a sequence of equality saturation steps. A guide can be a complete term, or a sketch containing undefined elements that are instantiated by the equality saturation search. Such sketches may be far more concise than complete terms. We demonstrate the generality and effectiveness of guided equality saturation using two case studies. First, we integrate guided equality saturation in the Lean 4 proof assistant. Proofs are written in the style of textbook proof sketches, as a series of calculations omitting details and skipping steps. These proofs conclude in less than a second instead of minutes when compared to unguided equality saturation, and can find complex proofs that previously had to be done manually. Second, in the compiler of the RISE array language, where unguided equality saturation fails to perform optimizations within an hour and using 60 GB of memory, guided equality saturation performs the same optimizations with at most 3 guides, within seconds using less than 1 GB memory.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632864", + "link": "https://doi.org/10.1145/3632900", "conference_name": "POPL", "authors": [ { - "first_name": "Chih-Duo", - "last_name": "Hong", - "institution": "National Chengchi University" + "first_name": "Thomas", + "last_name": "Kœhler", + "institution": "Centre National de la Recherche Scientifique" }, { - "first_name": "Anthony W.", - "last_name": "Lin", - "institution": "University of Kaiserslautern" + "first_name": "Andrés", + "last_name": "Goens", + "institution": "Amsterdam University of the Arts" + }, + { + "first_name": "Siddharth", + "last_name": "Bhat", + "institution": "Edinburgh College" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Cambridge" + }, + { + "first_name": "Phil", + "last_name": "Trinder", + "institution": "University of Glasgow" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "Edinburgh College" } ], - "dblp_key": "journals/pacmpl/HongL24", + "dblp_key": "journals/pacmpl/KoehlerGBGTS24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632889", - "title": "Deadlock-Free Separation Logic: Linearity Yields Progress for Dependent Higher-Order Message Passing", - "abstract": "We introduce a linear concurrent separation logic, called LinearActris , designed to guarantee deadlock and leak freedom for message-passing concurrency. LinearActris combines the strengths of session types and concurrent separation logic, allowing for the verification of challenging higher-order programs with mutable state through dependent protocols. The key challenge is to prove the adequacy theorem of LinearActris, which says that the logic indeed gives deadlock and leak freedom “for free” from linearity. We prove this theorem by defining a step-indexed model of separation logic, based on connectivity graphs . To demonstrate the expressive power of LinearActris, we prove soundness of a higher-order (GV-style) session type system using the technique of logical relations. All our results and examples have been mechanized in Coq.", + "paper_id": "10.1145/3632931", + "title": "Type-Based Gradual Typing Performance Optimization", + "abstract": "Gradual typing has emerged as a popular design point in programming languages, attracting significant interests from both academia and industry. Programmers in gradually typed languages are free to utilize static and dynamic typing as needed. To make such languages sound, runtime checks mediate the boundary of typed and untyped code. Unfortunately, such checks can incur significant runtime overhead on programs that heavily mix static and dynamic typing. To combat this overhead without necessitating changes to the underlying implementations of languages, we present discriminative typing . Discriminative typing works by optimistically inferring types for functions and implementing an optimized version of the function based on this type. To preserve safety it also implements an un-optimized version of the function based purely on the provided annotations. With two versions of each function in hand, discriminative typing translates programs so that the optimized functions are called as frequently as possible while also preserving program behaviors. We have implemented discriminative typing in Reticulated Python and have evaluated its performance compared to guarded Reticulated Python. Our results show that discriminative typing improves the performance across 95% of tested programs, when compared to Reticulated, and achieves more than 4× speedup in more than 56% of these programs. We also compare its performance against a previous optimization approach and find that discriminative typing improved performance across 93% of tested programs, with 30% of these programs receiving speedups between 4 to 25 times. Finally, our evaluation shows that discriminative typing remarkably reduces the overhead of gradual typing on many mixed type configurations of programs. In addition, we have implemented discriminative typing in Grift and evaluated its performance. Our evaluation demonstrations that DT significantly improves performance of Grift.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632889", + "link": "https://doi.org/10.1145/3632931", "conference_name": "POPL", "authors": [ { - "first_name": "Jules", - "last_name": "Jacobs", - "institution": "Radboud University Nijmegen" + "first_name": "John Peter", + "last_name": "Campora", + "institution": "" }, { - "first_name": "Jonas Kastberg", - "last_name": "Hinrichsen", - "institution": "Aarhus University" + "first_name": "Mohammad Wahiduzzaman", + "last_name": "Khan", + "institution": "University of Louisiana at Lafayette" }, { - "first_name": "Robbert", - "last_name": "Krebbers", - "institution": "Radboud University Nijmegen" + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" } ], - "dblp_key": "journals/pacmpl/JacobsHK24", + "dblp_key": "journals/pacmpl/CamporaKC24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632924", - "title": "A Universal, Sound, and Complete Forward Reasoning Technique for Machine-Verified Proofs of Linearizability", - "abstract": "We introduce simple, universal , sound , and complete proof methods for producing machine-verifiable proofs of linearizability and strong linearizability. Universality means that our method works for any object type; soundness means that an algorithm can be proved correct by our method only if it is linearizable (resp. strong linearizable); and completeness means that any linearizable (resp. strong linearizable) implementation can be proved so using our method. We demonstrate the simplicity and power of our method by producing proofs of linearizability for the Herlihy-Wing queue and Jayanti's single-scanner snapshot, as well as a proof of strong linearizability of the Jayanti-Tarjan union-find object. All three of these proofs are machine-verified by TLAPS (the TLA+ Proof System).", + "paper_id": "10.1145/3632888", + "title": "The Complex(ity) Landscape of Checking Infinite Descent", + "abstract": "Cyclic proof systems, in which induction is managed implicitly, are a promising approach to automatic verification. The soundness of cyclic proof graphs is ensured by checking them against a trace-based Infinite Descent property. Although the problem of checking Infinite Descent is known to be PSPACE-complete, this leaves much room for variation in practice. Indeed, a number of different approaches are employed across the various cyclic proof systems described in the literature. In this paper, we study criteria for Infinite Descent in an abstract, logic-independent setting. We look at criteria based on Büchi automata encodings and relational abstractions, and determine their parameterized time complexities in terms of natural dimensions of cyclic proofs: the numbers of vertices of the proof-tree graphs, and the vertex width —an upper bound on the number of components (e.g., formulas) of a sequent that can be simultaneously tracked for descent. We identify novel algorithms that improve upon the parameterised complexity of the existing algorithms. We implement the studied criteria and compare their performance on various benchmarks.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632924", + "link": "https://doi.org/10.1145/3632888", "conference_name": "POPL", "authors": [ { - "first_name": "Prasad", - "last_name": "Jayanti", - "institution": "Dartmouth College" + "first_name": "Liron", + "last_name": "Cohen", + "institution": "Ben-Gurion University of the Negev" }, { - "first_name": "Siddhartha", - "last_name": "Jayanti", - "institution": "Google (United States)" + "first_name": "Adham", + "last_name": "Jabarin", + "institution": "Ben-Gurion University of the Negev" }, { - "first_name": "Uğur", - "last_name": "Yavuz", - "institution": "" + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "University of Sheffield" }, { - "first_name": "Lizzie", - "last_name": "Hernandez", - "institution": "Microsoft (United States)" + "first_name": "Reuben N. S.", + "last_name": "Rowe", + "institution": "Royal Holloway University of London" } ], - "dblp_key": "journals/pacmpl/JayantiJYH24", + "dblp_key": "journals/pacmpl/CohenJPR24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3633280", - "title": "Answer Refinement Modification: Refinement Type System for Algebraic Effects and Handlers", - "abstract": "Algebraic effects and handlers are a mechanism to structure programs with computational effects in a modular way. They are recently gaining popularity and being adopted in practical languages, such as OCaml. Meanwhile, there has been substantial progress in program verification via refinement type systems . While a variety of refinement type systems have been proposed, thus far there has not been a satisfactory refinement type system for algebraic effects and handlers. In this paper, we fill the void by proposing a novel refinement type system for languages with algebraic effects and handlers. The expressivity and usefulness of algebraic effects and handlers come from their ability to manipulate delimited continuations , but delimited continuations also complicate programs' control flow and make their verification harder. To address the complexity, we introduce a novel concept that we call answer refinement modification (ARM for short), which allows the refinement type system to precisely track what effects occur and in what order when a program is executed, and reflect such information as modifications to the refinements in the types of delimited continuations. We formalize our type system that supports ARM (as well as answer type modification, or ATM) and prove its soundness. Additionally, as a proof of concept, we have extended the refinement type system to a subset of OCaml 5 which comes with a built-in support for effect handlers, implemented a type checking and inference algorithm for the extension, and evaluated it on a number of benchmark programs that use algebraic effects and handlers. The evaluation demonstrates that ARM is conceptually simple and practically useful. Finally, a natural alternative to directly reasoning about a program with delimited continuations is to apply a continuation passing style (CPS) transformation that transforms the program to a pure program without delimited continuations. We investigate this alternative in the paper, and show that the approach is indeed possible by proposing a novel CPS transformation for algebraic effects and handlers that enjoys bidirectional (refinement-)type-preservation. We show that there are pros and cons with this approach, namely, while one can use an existing refinement type checking and inference algorithm that can only (directly) handle pure programs, there are issues such as needing type annotations in source programs and making the inferred types less informative to a user.", + "paper_id": "10.1145/3632868", + "title": "Asynchronous Probabilistic Couplings in Higher-Order Separation Logic", + "abstract": "Probabilistic couplings are the foundation for many probabilistic relational program logics and arise when relating random sampling statements across two programs. In relational program logics, this manifests as dedicated coupling rules that, e.g ., say we may reason as if two sampling statements return the same value. However, this approach fundamentally requires aligning or “synchronizing” the sampling statements of the two programs which is not always possible. In this paper, we develop Clutch, a higher-order probabilistic relational separation logic that addresses this issue by supporting asynchronous probabilistic couplings. We use Clutch to develop a logical step-indexed logical relation to reason about contextual refinement and equivalence of higher-order programs written in a rich language with a probabilistic choice operator, higher-order local state, and impredicative polymorphism. Finally, we demonstrate our approach on a number of case studies. All the results that appear in the paper have been formalized in the Coq proof assistant using the Coquelicot library and the Iris separation logic framework.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3633280", + "link": "https://doi.org/10.1145/3632868", "conference_name": "POPL", "authors": [ { - "first_name": "Fuga", - "last_name": "Kawamata", - "institution": "Waseda University" + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "Aarhus University" }, { - "first_name": "Hiroshi", - "last_name": "Unno", - "institution": "University of Tsukuba" + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" }, { - "first_name": "Taro", - "last_name": "Sekiyama", - "institution": "National Institute of Informatics" + "first_name": "Philipp G.", + "last_name": "Haselwarter", + "institution": "Aarhus University" }, { - "first_name": "Tachio", - "last_name": "Terauchi", - "institution": "Waseda University" + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" } ], - "dblp_key": "journals/pacmpl/KawamataUST24", + "dblp_key": "journals/pacmpl/GregersenAHTB24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632898", - "title": "Algebraic Effects Meet Hoare Logic in Cubical Agda", - "abstract": "This paper presents a novel formalisation of algebraic effects with equations in Cubical Agda. Unlike previous work in the literature that employed setoids to deal with equations, the library presented here uses quotient types to faithfully encode the type of terms quotiented by laws. Apart from tools for equational reasoning, the library also provides an effect-generic Hoare logic for algebraic effects, which enables reasoning about effectful programs in terms of their pre- and post-conditions. A particularly novel aspect is that equational reasoning and Hoare-style reasoning are related by an elimination principle of Hoare logic.", + "paper_id": "10.1145/3632932", + "title": "Parametric Subtyping for Structural Parametric Polymorphism", + "abstract": "We study the interaction of structural subtyping with parametric polymorphism and recursively defined type constructors. Although structural subtyping is undecidable in this setting, we describe a notion of parametricity for type constructors and then exploit it to define parametric subtyping , a conceptually simple, decidable, and expressive fragment of structural subtyping that strictly generalizes rigid subtyping . We present and prove correct an effective saturation-based decision procedure for parametric subtyping, demonstrating its applicability using a variety of examples. We also provide an implementation of this decision procedure as an artifact.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632898", + "link": "https://doi.org/10.1145/3632932", "conference_name": "POPL", "authors": [ { - "first_name": "Donnacha Oisín", - "last_name": "Kidney", - "institution": "Imperial College London" + "first_name": "Henry", + "last_name": "DeYoung", + "institution": "Carnegie Mellon University" }, { - "first_name": "Zhixuan", - "last_name": "Yang", - "institution": "Imperial College London" + "first_name": "Andreia", + "last_name": "Mordido", + "institution": "University of Lisbon" }, { - "first_name": "Nicolas", - "last_name": "Wu", - "institution": "Imperial College London" + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ankush", + "last_name": "Das", + "institution": "Amazon (United States)" } ], - "dblp_key": "journals/pacmpl/KidneyYW24", + "dblp_key": "journals/pacmpl/DeYoungMPD24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632900", - "title": "Guided Equality Saturation", - "abstract": "Rewriting is a principled term transformation technique with uses across theorem proving and compilation. In theorem proving, each rewrite is a proof step; in compilation, rewrites optimize a program term. While developing rewrite sequences manually is possible, this process does not scale to larger rewrite sequences. Automated rewriting techniques, like greedy simplification or equality saturation, work well without requiring human input. Yet, they do not scale to large search spaces, limiting the complexity of tasks where automated rewriting is effective, and meaning that just a small increase in term size or rewrite length may result in failure. This paper proposes a semi-automatic rewriting technique as a means to scale rewriting by allowing human insight at key decision points. Specifically, we propose guided equality saturation that embraces human guidance when fully automated equality saturation does not scale. The rewriting is split into two simpler automatic equality saturation steps: from the original term to a human-provided intermediate guide , and from the guide to the target. Complex rewriting tasks may require multiple guides, resulting in a sequence of equality saturation steps. A guide can be a complete term, or a sketch containing undefined elements that are instantiated by the equality saturation search. Such sketches may be far more concise than complete terms. We demonstrate the generality and effectiveness of guided equality saturation using two case studies. First, we integrate guided equality saturation in the Lean 4 proof assistant. Proofs are written in the style of textbook proof sketches, as a series of calculations omitting details and skipping steps. These proofs conclude in less than a second instead of minutes when compared to unguided equality saturation, and can find complex proofs that previously had to be done manually. Second, in the compiler of the RISE array language, where unguided equality saturation fails to perform optimizations within an hour and using 60 GB of memory, guided equality saturation performs the same optimizations with at most 3 guides, within seconds using less than 1 GB memory.", + "paper_id": "10.1145/3632887", + "title": "Polyregular Functions on Unordered Trees of Bounded Height", + "abstract": "We consider injective first-order interpretations that input and output trees of bounded height. The corresponding functions have polynomial output size, since a first-order interpretation can use a k -tuple of input nodes to represent a single output node. We prove that the equivalence problem for such functions is decidable, i.e. given two such interpretations, one can decide whether, for every input tree, the two output trees are isomorphic. We also give a calculus of typed functions and combinators which derives exactly injective first-order interpretations for unordered trees of bounded height. The calculus is based on a type system, where the type constructors are products, coproducts and a monad of multisets. Thanks to our results about tree-to-tree interpretations, the equivalence problem is decidable for this calculus. As an application, we show that the equivalence problem is decidable for first-order interpretations between classes of graphs that have bounded tree-depth. In all cases studied in this paper, first-order logic and mso have the same expressive power, and hence all results apply also to mso interpretations.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632900", + "link": "https://doi.org/10.1145/3632887", "conference_name": "POPL", "authors": [ { - "first_name": "Thomas", - "last_name": "Kœhler", - "institution": "Centre National de la Recherche Scientifique" - }, - { - "first_name": "Andrés", - "last_name": "Goens", - "institution": "Amsterdam University of the Arts" - }, - { - "first_name": "Siddharth", - "last_name": "Bhat", - "institution": "Edinburgh College" - }, - { - "first_name": "Tobias", - "last_name": "Grosser", - "institution": "University of Cambridge" - }, - { - "first_name": "Phil", - "last_name": "Trinder", - "institution": "University of Glasgow" + "first_name": "Mikołaj", + "last_name": "Bojańczyk", + "institution": "University of Warsaw" }, { - "first_name": "Michel", - "last_name": "Steuwer", - "institution": "Edinburgh College" + "first_name": "Bartek", + "last_name": "Klin", + "institution": "University of Oxford" } ], - "dblp_key": "journals/pacmpl/KoehlerGBGTS24", + "dblp_key": "journals/pacmpl/BojanczykK24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632884", - "title": "On-the-Fly Static Analysis via Dynamic Bidirected Dyck Reachability", - "abstract": "Dyck reachability is a principled, graph-based formulation of a plethora of static analyses. Bidirected graphs are used for capturing dataflow through mutable heap data, and are usual formalisms of demand-driven points-to and alias analyses. The best (offline) algorithm runs in O ( m + n · α ( n ) ) time, where n is the number of nodes and m is the number of edges in the flow graph, which becomes O ( n 2 ) in the worst case. In the everyday practice of program analysis, the analyzed code is subject to continuous change, with source code being added and removed. On-the-fly static analysis under such continuous updates gives rise to dynamic Dyck reachability , where reachability queries run on a dynamically changing graph, following program updates. Naturally, executing the offline algorithm in this online setting is inadequate, as the time required to process a single update is prohibitively large. In this work we develop a novel dynamic algorithm for bidirected Dyck reachability that has O ( n · α ( n ) ) worst-case performance per update, thus beating the O ( n 2 ) bound, and is also optimal in certain settings. We also implement our algorithm and evaluate its performance on on-the-fly data-dependence and alias analyses, and compare it with two best known alternatives, namely (i) the optimal offline algorithm, and (ii) a fully dynamic Datalog solver. Our experiments show that our dynamic algorithm is consistently, and by far, the top performing algorithm, exhibiting speedups in the order of 1000X. The running time of each update is almost always unnoticeable to the human eye, making it ideal for the on-the-fly analysis setting.", + "paper_id": "10.1145/3632928", + "title": "Flan: An Expressive and Efficient Datalog Compiler for Program Analysis", + "abstract": "Datalog has gained prominence in program analysis due to its expressiveness and ease of use. Its generic fixpoint resolution algorithm over relational domains simplifies the expression of many complex analyses. The performance and scalability issues of early Datalog approaches have been addressed by tools such as Soufflé through specialized code generation. Still, while pure Datalog is expressive enough to support a wide range of analyses, there is a growing need for extensions to accommodate increasingly complex analyses This has led to the development of various extensions, such as Flix, Datafun, and Formulog, which enhance Datalog with features like arbitrary lattices and SMT constraints. Most of these extensions recognize the need for full interoperability between Datalog and a full-fledged programming language, a functionality that high-performance systems like Soufflé lack. Specifically, in most cases, they construct languages from scratch with first-class Datalog support, allowing greater flexibility. However, this flexibility often comes at the cost of performance due to the conflicting requirements of prioritizing modularity and abstraction over efficiency. Consequently, achieving both flexibility and compilation to highly-performant specialized code poses a significant challenge. In this work, we reconcile the competing demands of expressiveness and performance with Flan, a Datalog compiler fully embedded in Scala that leverages multi-stage programming to generate specialized code for enhanced performance. Our approach combines the flexibility of Flix with Soufflé’s performance, offering seamless integration with the host language that enables the addition of powerful extensions while generating specialized code for the entire computation. Flan’s simple operator interface allows the addition of an extensive set of features, including arbitrary aggregates, user-defined functions, and lattices, with multiple execution strategies such as binary and multi-way joins, supported by different indexing structures like specialized trees and hash tables, with minimal effort. We evaluate our system on a variety of benchmarks and compare it to established Datalog engines. Our results demonstrate competitive performance and speedups in the range of to compared to state-of-the-art systems for workloads of practical importance.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632884", + "link": "https://doi.org/10.1145/3632928", "conference_name": "POPL", "authors": [ { - "first_name": "Shankara Narayanan", - "last_name": "Krishna", - "institution": "Indian Institute of Technology Bombay" - }, - { - "first_name": "A. K.", - "last_name": "Lal", - "institution": "Indian Institute of Technology Bombay" + "first_name": "Supun", + "last_name": "Abeysinghe", + "institution": "Purdue University West Lafayette" }, { - "first_name": "Andreas", - "last_name": "Pavlogiannis", - "institution": "Aarhus University" + "first_name": "Anxhelo", + "last_name": "Xhebraj", + "institution": "Purdue University West Lafayette" }, { - "first_name": "Omkar", - "last_name": "Tuppe", - "institution": "Indian Institute of Technology Bombay" + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" } ], - "dblp_key": "journals/pacmpl/KrishnaLPT24", + "dblp_key": "journals/pacmpl/AbeysingheXR24", "venue": "popl", "year": 2024 }, @@ -1588,7 +1415,7 @@ "title": "On Model-Checking Higher-Order Effectful Programs", "abstract": "Model-checking is one of the most powerful techniques for verifying systems and programs, which since the pioneering results by Knapik et al., Ong, and Kobayashi, is known to be applicable to functional programs with higher-order types against properties expressed by formulas of monadic second-order logic. What happens when the program in question, in addition to higher-order functions, also exhibits algebraic effects such as probabilistic choice or global store? The results in the literature range from those, mostly positive, about nondeterministic effects, to those about probabilistic effects, in the presence of which even mere reachability becomes undecidable. This work takes a fresh and general look at the problem, first of all showing that there is an elegant and natural way of viewing higher-order programs producing algebraic effects as ordinary higher-order recursion schemes. We then move on to consider effect handlers, showing that in their presence the model checking problem is bound to be undecidable in the general case, while it stays decidable when handlers have a simple syntactic form, still sufficient to capture so-called generic effects . Along the way, we hint at how a general specification language could look like, this way justifying some of the results in the literature, and deriving new ones.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632929", + "link": "https://doi.org/10.1145/3632929", "conference_name": "POPL", "authors": [ { @@ -1607,73 +1434,53 @@ "year": 2024 }, { - "paper_id": "10.1145/3632894", - "title": "Efficient Bottom-Up Synthesis for Programs with Local Variables", - "abstract": "We propose a new synthesis algorithm that can efficiently search programs with local variables (e.g., those introduced by lambdas). Prior bottom-up synthesis algorithms are not able to evaluate programs with free local variables , and therefore cannot effectively reduce the search space of such programs (e.g., using standard observational equivalence reduction techniques), making synthesis slow. Our algorithm can reduce the space of programs with local variables. The key idea, dubbed lifted interpretation , is to lift up the program interpretation process, from evaluating one program at a time to simultaneously evaluating all programs from a grammar. Lifted interpretation provides a mechanism to systematically enumerate all binding contexts for local variables, thereby enabling us to evaluate and reduce the space of programs with local variables. Our ideas are instantiated in the domain of web automation. The resulting tool, Arborist , can automate a significantly broader range of challenging tasks more efficiently than state-of-the-art techniques including WebRobot and Helena.", + "paper_id": "10.1145/3632926", + "title": "Higher Order Bayesian Networks, Exactly", + "abstract": "Bayesian networks are graphical first-order probabilistic models that allow for a compact representation of large probability distributions, and for efficient inference, both exact and approximate. We introduce a higher-order programming language—in the idealized form of a λ -calculus—which we prove sound and complete w.r.t. Bayesian networks: each Bayesian network can be encoded as a term, and conversely each (possibly higher-order and recursive) program of ground type compiles into a Bayesian network. The language allows for the specification of recursive probability models and hierarchical structures. Moreover, we provide a compositional and cost-aware semantics which is based on factors, the standard mathematical tool used in Bayesian inference. Our results rely on advanced techniques rooted into linear logic, intersection types, rewriting theory, and Girard’s geometry of interaction, which are here combined in a novel way.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632894", + "link": "https://doi.org/10.1145/3632926", "conference_name": "POPL", "authors": [ { - "first_name": "Xiang", - "last_name": "Li", - "institution": "University of Michigan" - }, - { - "first_name": "Xiangyu", - "last_name": "Zhou", - "institution": "University of Michigan" - }, - { - "first_name": "Rui", - "last_name": "Dong", - "institution": "University of Michigan" + "first_name": "Claudia", + "last_name": "Faggian", + "institution": "Centre National de la Recherche Scientifique" }, { - "first_name": "Yihong", - "last_name": "Zhang", - "institution": "University of Washington" + "first_name": "Daniele", + "last_name": "Pautasso", + "institution": "University of Turin" }, { - "first_name": "Xinyu", - "last_name": "Wang", - "institution": "University of Michigan" + "first_name": "Gabriele", + "last_name": "Vanoni", + "institution": "Centre National de la Recherche Scientifique" } ], - "dblp_key": "journals/pacmpl/LiZDZW24", + "dblp_key": "journals/pacmpl/FaggianPV24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632886", - "title": "Internalizing Indistinguishability with Dependent Types", - "abstract": "In type systems with dependency tracking, programmers can assign an ordered set of levels to computations and prevent information flow from high-level computations to the low-level ones. The key notion in such systems is indistinguishability : a definition of program equivalence that takes into account the parts of the program that an observer may depend on. In this paper, we investigate the use of dependency tracking in the context of dependently-typed languages. We present the Dependent Calculus of Indistinguishability (DCOI), a system that adopts indistinguishability as the definition of equality used by the type checker. DCOI also internalizes that relation as an observer-indexed propositional equality type, so that programmers may reason about indistinguishability within the language. Our design generalizes and extends prior systems that combine dependency tracking with dependent types and is the first to support conversion and propositional equality at arbitrary observer levels. We have proven type soundness and noninterference theorems for DCOI and have developed a prototype implementation of its type checker.", + "paper_id": "10.1145/3632869", + "title": "Quotient Haskell: Lightweight Quotient Types for All", + "abstract": "Subtypes and quotient types are dual type abstractions. However, while subtypes are widely used both explicitly and implicitly, quotient types have not seen much practical use outside of proof assistants. A key difficulty to wider adoption of quotient types lies in the significant burden of proof-obligations that arises from their use. In this article, we address this issue by introducing a class of quotient types for which the proof-obligations are decidable by an SMT solver. We demonstrate this idea in practice by presenting Quotient Haskell , an extension of Liquid Haskell with support for quotient types.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632886", + "link": "https://doi.org/10.1145/3632869", "conference_name": "POPL", "authors": [ { - "first_name": "Yiyun", - "last_name": "Liu", - "institution": "University of Pennsylvania" - }, - { - "first_name": "Jonathan", - "last_name": "Chan", - "institution": "University of Pennsylvania" - }, - { - "first_name": "Jessica", - "last_name": "Shi", - "institution": "University of Pennsylvania" + "first_name": "B", + "last_name": "Hewer", + "institution": "University of Nottingham" }, { - "first_name": "Stephanie", - "last_name": "Weirich", - "institution": "University of Pennsylvania" + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" } ], - "dblp_key": "journals/pacmpl/LiuCSW24", + "dblp_key": "journals/pacmpl/HewerH24", "venue": "popl", "year": 2024 }, @@ -1682,7 +1489,7 @@ "title": "ReLU Hull Approximation", "abstract": "Convex hulls are commonly used to tackle the non-linearity of activation functions in the verification of neural networks. Computing the exact convex hull is a costly task though. In this work, we propose a fast and precise approach to over-approximating the convex hull of the ReLU function (referred to as the ReLU hull ), one of the most used activation functions. Our key insight is to formulate a convex polytope that “wraps” the ReLU hull, by reusing the linear pieces of the ReLU function as the lower faces and constructing upper faces that are adjacent to the lower faces. The upper faces can be efficiently constructed based on the edges and vertices of the lower faces, given that an n -dimensional (or simply n d hereafter) hyperplane can be determined by an ( n - 1 ) d hyperplane and a point outside of it. We implement our approach as WraLU , and evaluate its performance in terms of precision, efficiency, constraint complexity, and scalability. WraLU outperforms existing advanced methods by generating fewer constraints to achieve tighter approximation in less time. It exhibits versatility by effectively addressing arbitrary input polytopes and higher-dimensional cases, which are beyond the capabilities of existing methods. We integrate WraLU into PRIMA, a state-of-the-art neural network verifier, and apply it to verify large-scale ReLU-based neural networks. Our experimental results demonstrate that WraLU achieves a high efficiency without compromising precision. It reduces the number of constraints that need to be solved by the linear programming solver by up to half, while delivering comparable or even superior results compared to the state-of-the-art verifiers.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632917", + "link": "https://doi.org/10.1145/3632917", "conference_name": "POPL", "authors": [ { @@ -1706,71 +1513,96 @@ "year": 2024 }, { - "paper_id": "10.1145/3632879", - "title": "Positive Almost-Sure Termination: Complexity and Proof Rules", - "abstract": "We study the recursion-theoretic complexity of Positive Almost-Sure Termination (PAST) in an imperative programming language with rational variables, bounded nondeterministic choice, and discrete probabilistic choice. A program terminates positive almost-surely if, for every scheduler, the program terminates almost-surely and the expected runtime to termination is finite. We show that PAST for our language is complete for the (lightface) co-analytic sets ( Π 1 1 -complete). This is in contrast to the related notions of Almost-Sure Termination (AST) and Bounded Termination (BAST), both of which are arithmetical ( Π 2 0 - and Σ 2 0 -complete respectively). Our upper bound implies an effective procedure to reduce reasoning about probabilistic termination to non-probabilistic fair termination in a model with bounded nondeterminism, and to simple program termination in models with unbounded nondeterminism. Our lower bound shows the opposite: for every program with unbounded nondeterministic choice, there is an effectively computable probabilistic program with bounded choice such that the original program is terminating if, and only if, the transformed program is PAST. We show that every program has an effectively computable normal form, in which each probabilistic choice either continues or terminates execution immediately, each with probability 1 / 2 . For normal form programs, we provide a sound and complete proof rule for PAST. Our proof rule uses transfinite ordinals. We show that reasoning about PAST requires transfinite ordinals up to ω 1 CK ; thus, existing techniques for probabilistic termination based on ranking supermartingales that map program states to reals do not suffice to reason about PAST.", + "paper_id": "10.1145/3632853", + "title": "DisLog: A Separation Logic for Disentanglement", + "abstract": "Disentanglement is a run-time property of parallel programs that facilitates task-local reasoning about the memory footprint of parallel tasks. In particular, it ensures that a task does not access any memory locations allocated by another concurrently executing task. Disentanglement can be exploited, for example, to implement a high-performance parallel memory manager, such as in the MPL (MaPLe) compiler for Parallel ML. Prior research on disentanglement has focused on the design of optimizations, either trusting the programmer to provide a disentangled program or relying on runtime instrumentation for detecting and managing entanglement. This paper provides the first static approach to verify that a program is disentangled: it contributes DisLog, a concurrent separation logic for disentanglement. DisLog enriches concurrent separation logic with the notions necessary for reasoning about the fork-join structure of parallel programs, allowing the verification that memory accesses are effectively disentangled. A large class of programs, including race-free programs, exhibit memory access patterns that are disentangled \"by construction\". To reason about these patterns, the paper distills from DisLog an almost standard concurrent separation logic, called DisLog+. In this high-level logic, no specific reasoning about memory accesses is needed: functional correctness proofs entail disentanglement. The paper illustrates the use of DisLog and DisLog+ on a range of case studies, including two different implementations of parallel deduplication via concurrent hashing. All our results are mechanized in the Coq proof assistant using Iris.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632879", + "link": "https://doi.org/10.1145/3632853", "conference_name": "POPL", "authors": [ { - "first_name": "Rupak", - "last_name": "Majumdar", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Alexandre", + "last_name": "Moine", + "institution": "Institut national de recherche en sciences et technologies du numérique" }, { - "first_name": "V. R.", - "last_name": "Sathiyanarayana", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" } ], - "dblp_key": "journals/pacmpl/MajumdarS24", + "dblp_key": "journals/pacmpl/MoineWB24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632934", - "title": "Efficient Matching of Regular Expressions with Lookaround Assertions", - "abstract": "Regular expressions have been extended with lookaround assertions, which are subdivided into lookahead and lookbehind assertions. These constructs are used to refine when a match for a pattern occurs in the input text based on the surrounding context. Current implementation techniques for lookaround involve backtracking search, which can give rise to running time that is super-linear in the length of input text. In this paper, we first consider a formal mathematical semantics for lookaround, which complements the commonly used operational understanding of lookaround in terms of a backtracking implementation. Our formal semantics allows us to establish several equational properties for simplifying lookaround assertions. Additionally, we propose a new algorithm for matching regular expressions with lookaround that has time complexity O m ⋅ n , where m is the size of the regular expression and n is the length of the input text. The algorithm works by evaluating lookaround assertions in a bottom-up manner. Our algorithm makes use of a new notion of nondeterministic finite automata (NFAs), which we call oracle-NFAs. These automata are augmented with epsilon-transitions that are guarded by oracle queries that provide the truth values of lookaround assertions at every position in the text. We provide an implementation of our algorithm that incorporates three performance optimizations for reducing the work performed and memory used. We present an experimental comparison against PCRE and Java’s regex library, which are state-of-the-art regex engines that support lookaround assertions. Our experimental results show that, in contrast to PCRE and Java, our implementation does not suffer from super-linear running time and is several times faster.", + "paper_id": "10.1145/3632924", + "title": "A Universal, Sound, and Complete Forward Reasoning Technique for Machine-Verified Proofs of Linearizability", + "abstract": "We introduce simple, universal , sound , and complete proof methods for producing machine-verifiable proofs of linearizability and strong linearizability. Universality means that our method works for any object type; soundness means that an algorithm can be proved correct by our method only if it is linearizable (resp. strong linearizable); and completeness means that any linearizable (resp. strong linearizable) implementation can be proved so using our method. We demonstrate the simplicity and power of our method by producing proofs of linearizability for the Herlihy-Wing queue and Jayanti's single-scanner snapshot, as well as a proof of strong linearizability of the Jayanti-Tarjan union-find object. All three of these proofs are machine-verified by TLAPS (the TLA+ Proof System).", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632934", + "link": "https://doi.org/10.1145/3632924", "conference_name": "POPL", "authors": [ { - "first_name": "Konstantinos", - "last_name": "Mamouras", - "institution": "Rice University" + "first_name": "Prasad", + "last_name": "Jayanti", + "institution": "Dartmouth College" + }, + { + "first_name": "Siddhartha", + "last_name": "Jayanti", + "institution": "Google (United States)" + }, + { + "first_name": "Uğur", + "last_name": "Yavuz", + "institution": "" }, { - "first_name": "Agnishom", - "last_name": "Chattopadhyay", - "institution": "Rice University" + "first_name": "Lizzie", + "last_name": "Hernandez", + "institution": "Microsoft (United States)" } ], - "dblp_key": "journals/pacmpl/MamourasC24", + "dblp_key": "journals/pacmpl/JayantiJYH24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632848", - "title": "An Iris Instance for Verifying CompCert C Programs", - "abstract": "Iris is a generic separation logic framework that has been instantiated to reason about a wide range of programming languages and language features. Most Iris instances are defined on simple core calculi, but by connecting Iris to new or existing formal semantics for practical languages, we can also use it to reason about real programs. In this paper we develop an Iris instance based on CompCert, the verified C compiler, allowing us to prove correctness of C programs under the same semantics we use to compile and run them. We take inspiration from the Verified Software Toolchain (VST), a prior separation logic for CompCert C, and reimplement the program logic of VST in Iris. Unlike most Iris instances, this involves both a new model of resources for CompCert memories, and a new definition of weakest preconditions/Hoare triples, as the Iris defaults for both of these cannot be applied to CompCert as is. Ultimately, we obtain a complete program logic for CompCert C within Iris, and we reconstruct enough of VST’s top-level automation to prove correctness of simple C programs.", + "paper_id": "10.1145/3632852", + "title": "Decalf: A Directed, Effectful Cost-Aware Logical Framework", + "abstract": "We present decalf , a d irected, e ffectful c ost- a ware l ogical f ramework for studying quantitative aspects of functional programs with effects. Like calf , the language is based on a formal phase distinction between the extension and the intension of a program, its pure behavior as distinct from its cost measured by an effectful step-counting primitive. The type theory ensures that the behavior is unaffected by the cost accounting. Unlike calf , the present language takes account of effects , such as probabilistic choice and mutable state. This extension requires a reformulation of calf ’s approach to cost accounting: rather than rely on a “separable” notion of cost, here a cost bound is simply another program . To make this formal, we equip every type with an intrinsic preorder, relaxing the precise cost accounting intrinsic to a program to a looser but nevertheless informative estimate. For example, the cost bound of a probabilistic program is itself a probabilistic program that specifies the distribution of costs. This approach serves as a streamlined alternative to the standard method of isolating a cost recurrence and readily extends to higher-order, effectful programs. The development proceeds by first introducing the decalf type system, which is based on an intrinsic ordering among terms that restricts in the extensional phase to extensional equality, but in the intensional phase reflects an approximation of the cost of a program of interest. This formulation is then applied to a number of illustrative examples, including pure and effectful sorting algorithms, simple probabilistic programs, and higher-order functions. Finally, we justify decalf via a model in the topos of augmented simplicial sets.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632848", + "link": "https://doi.org/10.1145/3632852", "conference_name": "POPL", "authors": [ { - "first_name": "William", - "last_name": "Mansky", - "institution": "University of Illinois Chicago" + "first_name": "Harrison", + "last_name": "Grodin", + "institution": "Carnegie Mellon University" }, { - "first_name": "Ke", - "last_name": "Du", - "institution": "University of Illinois Chicago" + "first_name": "Yue", + "last_name": "Niu", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Sterling", + "institution": "University of Cambridge" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" } ], - "dblp_key": "journals/pacmpl/ManskyD24", + "dblp_key": "journals/pacmpl/GrodinNSH24", "venue": "popl", "year": 2024 }, @@ -1779,7 +1611,7 @@ "title": "Optimal Program Synthesis via Abstract Interpretation", "abstract": "We consider the problem of synthesizing programs with numerical constants that optimize a quantitative objective, such as accuracy, over a set of input-output examples. We propose a general framework for optimal synthesis of such programs in a given domain specific language (DSL), with provable optimality guarantees. Our framework enumerates programs in a general search graph, where nodes represent subsets of concrete programs. To improve scalability, it uses A * search in conjunction with a search heuristic based on abstract interpretation; intuitively, this heuristic establishes upper bounds on the value of subtrees in the search graph, enabling the synthesizer to identify and prune subtrees that are provably suboptimal. In addition, we propose a natural strategy for constructing abstract transformers for monotonic semantics, which is a common property for components in DSLs for data classification. Finally, we implement our approach in the context of two such existing DSLs, demonstrating that our algorithm is more scalable than existing optimal synthesizers.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632858", + "link": "https://doi.org/10.1145/3632858", "conference_name": "POPL", "authors": [ { @@ -1803,58 +1635,30 @@ "year": 2024 }, { - "paper_id": "10.1145/3632853", - "title": "DisLog: A Separation Logic for Disentanglement", - "abstract": "Disentanglement is a run-time property of parallel programs that facilitates task-local reasoning about the memory footprint of parallel tasks. In particular, it ensures that a task does not access any memory locations allocated by another concurrently executing task. Disentanglement can be exploited, for example, to implement a high-performance parallel memory manager, such as in the MPL (MaPLe) compiler for Parallel ML. Prior research on disentanglement has focused on the design of optimizations, either trusting the programmer to provide a disentangled program or relying on runtime instrumentation for detecting and managing entanglement. This paper provides the first static approach to verify that a program is disentangled: it contributes DisLog, a concurrent separation logic for disentanglement. DisLog enriches concurrent separation logic with the notions necessary for reasoning about the fork-join structure of parallel programs, allowing the verification that memory accesses are effectively disentangled. A large class of programs, including race-free programs, exhibit memory access patterns that are disentangled \"by construction\". To reason about these patterns, the paper distills from DisLog an almost standard concurrent separation logic, called DisLog+. In this high-level logic, no specific reasoning about memory accesses is needed: functional correctness proofs entail disentanglement. The paper illustrates the use of DisLog and DisLog+ on a range of case studies, including two different implementations of parallel deduplication via concurrent hashing. All our results are mechanized in the Coq proof assistant using Iris.", - "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632853", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Alexandre", - "last_name": "Moine", - "institution": "Institut national de recherche en sciences et technologies du numérique" - }, - { - "first_name": "Sam", - "last_name": "Westrick", - "institution": "Carnegie Mellon University" - }, - { - "first_name": "Stephanie", - "last_name": "Balzer", - "institution": "Carnegie Mellon University" - } - ], - "dblp_key": "journals/pacmpl/MoineWB24", - "venue": "popl", - "year": 2024 - }, - { - "paper_id": "10.1145/3632930", - "title": "Effectful Software Contracts", - "abstract": "Software contracts empower programmers to describe functional properties of components. When it comes to constraining effects, though, the literature offers only one-off solutions for various effects. It lacks a universal principle. This paper presents the design of an effectful contract system in the context of effect handlers. A key metatheorem shows that contracts cannot unduly interfere with a program’s execution. An implementation of this design, along with an evaluation of its generality, demonstrates that the theory can guide practice.", + "paper_id": "10.1145/3632889", + "title": "Deadlock-Free Separation Logic: Linearity Yields Progress for Dependent Higher-Order Message Passing", + "abstract": "We introduce a linear concurrent separation logic, called LinearActris , designed to guarantee deadlock and leak freedom for message-passing concurrency. LinearActris combines the strengths of session types and concurrent separation logic, allowing for the verification of challenging higher-order programs with mutable state through dependent protocols. The key challenge is to prove the adequacy theorem of LinearActris, which says that the logic indeed gives deadlock and leak freedom “for free” from linearity. We prove this theorem by defining a step-indexed model of separation logic, based on connectivity graphs . To demonstrate the expressive power of LinearActris, we prove soundness of a higher-order (GV-style) session type system using the technique of logical relations. All our results and examples have been mechanized in Coq.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632930", + "link": "https://doi.org/10.1145/3632889", "conference_name": "POPL", "authors": [ { - "first_name": "Cameron", - "last_name": "Moy", - "institution": "Northeastern University" + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" }, { - "first_name": "Christos", - "last_name": "Dimoulas", - "institution": "Northwestern University" + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", + "institution": "Aarhus University" }, { - "first_name": "Matthias", - "last_name": "Felleisen", - "institution": "Northeastern University" + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" } ], - "dblp_key": "journals/pacmpl/MoyDF24", + "dblp_key": "journals/pacmpl/JacobsHK24", "venue": "popl", "year": 2024 }, @@ -1863,7 +1667,7 @@ "title": "Strong Invariants Are Hard: On the Hardness of Strongest Polynomial Invariants for (Probabilistic) Programs", "abstract": "We show that computing the strongest polynomial invariant for single-path loops with polynomial assignments is at least as hard as the Skolem problem, a famous problem whose decidability has been open for almost a century. While the strongest polynomial invariants are computable for affine loops , for polynomial loops the problem remained wide open. As an intermediate result of independent interest, we prove that reachability for discrete polynomial dynamical systems is Skolem -hard as well. Furthermore, we generalize the notion of invariant ideals and introduce moment invariant ideals for probabilistic programs. With this tool, we further show that the strongest polynomial moment invariant is (i) uncomputable, for probabilistic loops with branching statements, and (ii) Skolem -hard to compute for polynomial probabilistic loops without branching statements. Finally, we identify a class of probabilistic loops for which the strongest polynomial moment invariant is computable and provide an algorithm for it.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632872", + "link": "https://doi.org/10.1145/3632872", "conference_name": "POPL", "authors": [ { @@ -1887,91 +1691,109 @@ "year": 2024 }, { - "paper_id": "10.1145/3632850", - "title": "Internal and Observational Parametricity for Cubical Agda", - "abstract": "Two approaches exist to incorporate parametricity into proof assistants based on dependent type theory. On the one hand, parametricity translations conveniently compute parametricity statements and their proofs solely based on individual well-typed polymorphic programs. But they do not offer internal parametricity: formal proofs that any polymorphic program of a certain type satisfies its parametricity statement. On the other hand, internally parametric type theories augment plain type theory with additional primitives out of which internal parametricity can be derived. But those type theories lack mature proof assistant implementations and deriving parametricity in them involves low-level intractable proofs. In this paper, we contribute Agda --bridges: the first practical internally parametric proof assistant. We provide the first mechanized proofs of crucial theorems for internal parametricity, like the relativity theorem. We identify a high-level sufficient condition for proving internal parametricity which we call the structure relatedness principle (SRP) by analogy with the structure identity principle (SIP) of HoTT/UF. We state and prove a general parametricity theorem for types that satisfy the SRP. Our parametricity theorem lets us obtain one-liner proofs of standard internal free theorems. We observe that the SRP is harder to prove than the SIP and provide in Agda --bridges a shallowly embedded type theory to compose types that satisfy the SRP. This type theory is an observational type theory of logical relations and our parametricity theorem ought to be one of its inference rules.", + "paper_id": "10.1145/3632934", + "title": "Efficient Matching of Regular Expressions with Lookaround Assertions", + "abstract": "Regular expressions have been extended with lookaround assertions, which are subdivided into lookahead and lookbehind assertions. These constructs are used to refine when a match for a pattern occurs in the input text based on the surrounding context. Current implementation techniques for lookaround involve backtracking search, which can give rise to running time that is super-linear in the length of input text. In this paper, we first consider a formal mathematical semantics for lookaround, which complements the commonly used operational understanding of lookaround in terms of a backtracking implementation. Our formal semantics allows us to establish several equational properties for simplifying lookaround assertions. Additionally, we propose a new algorithm for matching regular expressions with lookaround that has time complexity O m ⋅ n , where m is the size of the regular expression and n is the length of the input text. The algorithm works by evaluating lookaround assertions in a bottom-up manner. Our algorithm makes use of a new notion of nondeterministic finite automata (NFAs), which we call oracle-NFAs. These automata are augmented with epsilon-transitions that are guarded by oracle queries that provide the truth values of lookaround assertions at every position in the text. We provide an implementation of our algorithm that incorporates three performance optimizations for reducing the work performed and memory used. We present an experimental comparison against PCRE and Java’s regex library, which are state-of-the-art regex engines that support lookaround assertions. Our experimental results show that, in contrast to PCRE and Java, our implementation does not suffer from super-linear running time and is several times faster.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632850", + "link": "https://doi.org/10.1145/3632934", "conference_name": "POPL", "authors": [ { - "first_name": "Antoine Van", - "last_name": "Muylder", - "institution": "KU Leuven" - }, - { - "first_name": "Andreas", - "last_name": "Nuyts", - "institution": "KU Leuven" + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" }, { - "first_name": "Dominique", - "last_name": "Devriese", - "institution": "KU Leuven" + "first_name": "Agnishom", + "last_name": "Chattopadhyay", + "institution": "Rice University" } ], - "dblp_key": "journals/pacmpl/MuylderND24", + "dblp_key": "journals/pacmpl/MamourasC24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632870", - "title": "Semantic Code Refactoring for Abstract Data Types", - "abstract": "Modifications to the data representation of an abstract data type (ADT) can require significant semantic refactoring of the code. Motivated by this observation, this paper presents a new method to automate semantic code refactoring tasks. Our method takes as input the original ADT implementation, a new data representation, and a so-called relational representation invariant (relating the old and new data representations), and automatically generates a new ADT implementation that is semantically equivalent to the original version. Our method is based on counterexample-guided inductive synthesis (CEGIS) but leverages three key ideas that allow it to handle real-world refactoring tasks. First, our approach reduces the underlying relational synthesis problem to a set of (simpler) programming-by-example problems, one for each method in the ADT. Second, it leverages symbolic reasoning techniques, based on logical abduction, to deduce code snippets that should occur in the refactored version. Finally, it utilizes a notion of partial equivalence to make inductive synthesis much more effective in this setting. We have implemented the proposed approach in a new tool called Revamp for automatically refactoring Java classes and evaluated it on 30 Java class mined from Github. Our evaluation shows that Revamp can correctly refactor the entire ADT in 97% of the cases and that it can successfully re-implement 144 out of the 146 methods that require modifications.", + "paper_id": "10.1145/3632923", + "title": "SimuQ: A Framework for Programming Quantum Hamiltonian Simulation with Analog Compilation", + "abstract": "Quantum Hamiltonian simulation, which simulates the evolution of quantum systems and probes quantum phenomena, is one of the most promising applications of quantum computing. Recent experimental results suggest that Hamiltonian-oriented analog quantum simulation would be advantageous over circuit-oriented digital quantum simulation in the Noisy Intermediate-Scale Quantum (NISQ) machine era. However, programming analog quantum simulators is much more challenging due to the lack of a unified interface between hardware and software. In this paper, we design and implement SimuQ, the first framework for quantum Hamiltonian simulation that supports Hamiltonian programming and pulse-level compilation to heterogeneous analog quantum simulators. Specifically, in SimuQ, front-end users specify the target quantum system with Hamiltonian Modeling Language, and the Hamiltonian-level programmability of analog quantum simulators is specified through a new abstraction called the abstract analog instruction set (AAIS) and programmed in AAIS Specification Language by hardware providers. Through a solver-based compilation, SimuQ generates executable pulse schedules for real devices to simulate the evolution of desired quantum systems, which is demonstrated on superconducting (IBM), neutral-atom (QuEra), and trapped-ion (IonQ) quantum devices. Moreover, we demonstrate the advantages of exposing the Hamiltonian-level programmability of devices with native operations or interaction-based gates and establish a small benchmark of quantum simulation to evaluate SimuQ’s compiler with the above analog quantum simulators.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632870", + "link": "https://doi.org/10.1145/3632923", "conference_name": "POPL", "authors": [ { - "first_name": "Shankara", - "last_name": "Pailoor", - "institution": "The University of Texas at Austin" + "first_name": "Yuxiang", + "last_name": "Peng", + "institution": "University of Maryland, College Park" }, { - "first_name": "Yuepeng", - "last_name": "Wang", - "institution": "Simon Fraser University" + "first_name": "Jacob", + "last_name": "Young", + "institution": "University of Maryland, College Park" }, { - "first_name": "Işıl", - "last_name": "Dillig", - "institution": "The University of Texas at Austin" + "first_name": "Pengyu", + "last_name": "Liu", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" } ], - "dblp_key": "journals/pacmpl/PailoorWD24", + "dblp_key": "journals/pacmpl/PengYLW24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632890", - "title": "When Subtyping Constraints Liberate: A Novel Type Inference Approach for First-Class Polymorphism", - "abstract": "Type inference in the presence of first-class or “ impredicative ” second-order polymorphism à la System F has been an active research area for several decades, with original works dating back to the end of the 80s. Yet, until now many basic problems remain open, such as how to type check expressions like ( λ x . ( x 123 , x True ) ) id reliably. We show that a type inference approach based on multi-bounded polymorphism , a form of implicit polymorphic subtyping with multiple lower and upper bounds, can help us resolve most of these problems in a uniquely simple and regular way. We define F ≤ , a declarative type system derived from the existing theory of implicit coercions by Cretin and Rémy (LICS 2014), and we introduce SuperF, a novel algorithm to infer polymorphic multi-bounded F ≤ types while checking user type annotations written in the syntax of System F. We use a recursion-avoiding heuristic to guarantee termination of type inference at the cost of rejecting some valid programs, which thankfully rarely triggers in practice. We show that SuperF is vastly more powerful than all first-class-polymorphic type inference systems proposed so far, significantly advancing the state of the art in type inference for general-purpose programming languages.", + "paper_id": "10.1145/3632879", + "title": "Positive Almost-Sure Termination: Complexity and Proof Rules", + "abstract": "We study the recursion-theoretic complexity of Positive Almost-Sure Termination (PAST) in an imperative programming language with rational variables, bounded nondeterministic choice, and discrete probabilistic choice. A program terminates positive almost-surely if, for every scheduler, the program terminates almost-surely and the expected runtime to termination is finite. We show that PAST for our language is complete for the (lightface) co-analytic sets ( Π 1 1 -complete). This is in contrast to the related notions of Almost-Sure Termination (AST) and Bounded Termination (BAST), both of which are arithmetical ( Π 2 0 - and Σ 2 0 -complete respectively). Our upper bound implies an effective procedure to reduce reasoning about probabilistic termination to non-probabilistic fair termination in a model with bounded nondeterminism, and to simple program termination in models with unbounded nondeterminism. Our lower bound shows the opposite: for every program with unbounded nondeterministic choice, there is an effectively computable probabilistic program with bounded choice such that the original program is terminating if, and only if, the transformed program is PAST. We show that every program has an effectively computable normal form, in which each probabilistic choice either continues or terminates execution immediately, each with probability 1 / 2 . For normal form programs, we provide a sound and complete proof rule for PAST. Our proof rule uses transfinite ordinals. We show that reasoning about PAST requires transfinite ordinals up to ω 1 CK ; thus, existing techniques for probabilistic termination based on ranking supermartingales that map program states to reals do not suffice to reason about PAST.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632890", + "link": "https://doi.org/10.1145/3632879", "conference_name": "POPL", "authors": [ { - "first_name": "Lionel", - "last_name": "Parreaux", - "institution": "Hong Kong University of Science and Technology" + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Aleksander", - "last_name": "Boruch-Gruszecki", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "V. R.", + "last_name": "Sathiyanarayana", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/MajumdarS24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632898", + "title": "Algebraic Effects Meet Hoare Logic in Cubical Agda", + "abstract": "This paper presents a novel formalisation of algebraic effects with equations in Cubical Agda. Unlike previous work in the literature that employed setoids to deal with equations, the library presented here uses quotient types to faithfully encode the type of terms quotiented by laws. Apart from tools for equational reasoning, the library also provides an effect-generic Hoare logic for algebraic effects, which enables reasoning about effectful programs in terms of their pre- and post-conditions. A particularly novel aspect is that equational reasoning and Hoare-style reasoning are related by an elimination principle of Hoare logic.", + "date": "2024-01-02", + "link": "https://doi.org/10.1145/3632898", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Donnacha Oisín", + "last_name": "Kidney", + "institution": "Imperial College London" }, { - "first_name": "Andong", - "last_name": "Fan", - "institution": "Hong Kong University of Science and Technology" + "first_name": "Zhixuan", + "last_name": "Yang", + "institution": "Imperial College London" }, { - "first_name": "Chun Yin", - "last_name": "Chau", - "institution": "Hong Kong University of Science and Technology" + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" } ], - "dblp_key": "journals/pacmpl/ParreauxBFC24", + "dblp_key": "journals/pacmpl/KidneyYW24", "venue": "popl", "year": 2024 }, @@ -1980,7 +1802,7 @@ "title": "Programming-by-Demonstration for Long-Horizon Robot Tasks", "abstract": "The goal of programmatic Learning from Demonstration (LfD) is to learn a policy in a programming language that can be used to control a robot’s behavior from a set of user demonstrations. This paper presents a new programmatic LfD algorithm that targets long-horizon robot tasks which require synthesizing programs with complex control flow structures, including nested loops with multiple conditionals. Our proposed method first learns a program sketch that captures the target program’s control flow and then completes this sketch using an LLM-guided search procedure that incorporates a novel technique for proving unrealizability of programming-by-demonstration problems. We have implemented our approach in a new tool called prolex and present the results of a comprehensive experimental evaluation on 120 benchmarks involving complex tasks and environments. We show that, given a 120 second time limit, prolex can find a program consistent with the demonstrations in 80% of the cases. Furthermore, for 81% of the tasks for which a solution is returned, prolex is able to find the ground truth program with just one demonstration. In comparison, CVC5, a syntaxguided synthesis tool, is only able to solve 25% of the cases even when given the ground truth program sketch , and an LLM-based approach, GPT-Synth, is unable to solve any of the tasks due to the environment complexity.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632860", + "link": "https://doi.org/10.1145/3632860", "conference_name": "POPL", "authors": [ { @@ -2014,86 +1836,91 @@ "year": 2024 }, { - "paper_id": "10.1145/3632923", - "title": "SimuQ: A Framework for Programming Quantum Hamiltonian Simulation with Analog Compilation", - "abstract": "Quantum Hamiltonian simulation, which simulates the evolution of quantum systems and probes quantum phenomena, is one of the most promising applications of quantum computing. Recent experimental results suggest that Hamiltonian-oriented analog quantum simulation would be advantageous over circuit-oriented digital quantum simulation in the Noisy Intermediate-Scale Quantum (NISQ) machine era. However, programming analog quantum simulators is much more challenging due to the lack of a unified interface between hardware and software. In this paper, we design and implement SimuQ, the first framework for quantum Hamiltonian simulation that supports Hamiltonian programming and pulse-level compilation to heterogeneous analog quantum simulators. Specifically, in SimuQ, front-end users specify the target quantum system with Hamiltonian Modeling Language, and the Hamiltonian-level programmability of analog quantum simulators is specified through a new abstraction called the abstract analog instruction set (AAIS) and programmed in AAIS Specification Language by hardware providers. Through a solver-based compilation, SimuQ generates executable pulse schedules for real devices to simulate the evolution of desired quantum systems, which is demonstrated on superconducting (IBM), neutral-atom (QuEra), and trapped-ion (IonQ) quantum devices. Moreover, we demonstrate the advantages of exposing the Hamiltonian-level programmability of devices with native operations or interaction-based gates and establish a small benchmark of quantum simulation to evaluate SimuQ’s compiler with the above analog quantum simulators.", + "paper_id": "10.1145/3632894", + "title": "Efficient Bottom-Up Synthesis for Programs with Local Variables", + "abstract": "We propose a new synthesis algorithm that can efficiently search programs with local variables (e.g., those introduced by lambdas). Prior bottom-up synthesis algorithms are not able to evaluate programs with free local variables , and therefore cannot effectively reduce the search space of such programs (e.g., using standard observational equivalence reduction techniques), making synthesis slow. Our algorithm can reduce the space of programs with local variables. The key idea, dubbed lifted interpretation , is to lift up the program interpretation process, from evaluating one program at a time to simultaneously evaluating all programs from a grammar. Lifted interpretation provides a mechanism to systematically enumerate all binding contexts for local variables, thereby enabling us to evaluate and reduce the space of programs with local variables. Our ideas are instantiated in the domain of web automation. The resulting tool, Arborist , can automate a significantly broader range of challenging tasks more efficiently than state-of-the-art techniques including WebRobot and Helena.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632923", + "link": "https://doi.org/10.1145/3632894", "conference_name": "POPL", "authors": [ { - "first_name": "Yuxiang", - "last_name": "Peng", - "institution": "University of Maryland, College Park" + "first_name": "Xiang", + "last_name": "Li", + "institution": "University of Michigan" }, { - "first_name": "Jacob", - "last_name": "Young", - "institution": "University of Maryland, College Park" + "first_name": "Xiangyu", + "last_name": "Zhou", + "institution": "University of Michigan" }, { - "first_name": "Pengyu", - "last_name": "Liu", - "institution": "Carnegie Mellon University" + "first_name": "Rui", + "last_name": "Dong", + "institution": "University of Michigan" }, { - "first_name": "Xiaodi", - "last_name": "Wu", - "institution": "University of Maryland, College Park" + "first_name": "Yihong", + "last_name": "Zhang", + "institution": "University of Washington" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan" } ], - "dblp_key": "journals/pacmpl/PengYLW24", + "dblp_key": "journals/pacmpl/LiZDZW24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632857", - "title": "Nominal Recursors as Epi-Recursors", - "abstract": "We study nominal recursors from the literature on syntax with bindings and compare them with respect to expressiveness. The term “nominal” refers to the fact that these recursors operate on a syntax representation where the names of bound variables appear explicitly, as in nominal logic. We argue that nominal recursors can be viewed as epi-recursors , a concept that captures abstractly the distinction between the constructors on which one actually recurses, and other operators and properties that further underpin recursion. We develop an abstract framework for comparing epi-recursors and instantiate it to the existing nominal recursors, and also to several recursors obtained from them by cross-pollination. The resulted expressiveness hierarchies depend on how strictly we perform this comparison, and bring insight into the relative merits of different axiomatizations of syntax. We also apply our methodology to produce an expressiveness hierarchy of nominal corecursors , which are principles for defining functions targeting infinitary non-well-founded terms (which underlie λ -calculus semantics concepts such as Böhm trees). Our results are validated with the Isabelle/HOL theorem prover.", + "paper_id": "10.1145/3632848", + "title": "An Iris Instance for Verifying CompCert C Programs", + "abstract": "Iris is a generic separation logic framework that has been instantiated to reason about a wide range of programming languages and language features. Most Iris instances are defined on simple core calculi, but by connecting Iris to new or existing formal semantics for practical languages, we can also use it to reason about real programs. In this paper we develop an Iris instance based on CompCert, the verified C compiler, allowing us to prove correctness of C programs under the same semantics we use to compile and run them. We take inspiration from the Verified Software Toolchain (VST), a prior separation logic for CompCert C, and reimplement the program logic of VST in Iris. Unlike most Iris instances, this involves both a new model of resources for CompCert memories, and a new definition of weakest preconditions/Hoare triples, as the Iris defaults for both of these cannot be applied to CompCert as is. Ultimately, we obtain a complete program logic for CompCert C within Iris, and we reconstruct enough of VST’s top-level automation to prove correctness of simple C programs.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632857", + "link": "https://doi.org/10.1145/3632848", "conference_name": "POPL", "authors": [ { - "first_name": "Andrei", - "last_name": "Popescu", - "institution": "University of Sheffield" + "first_name": "William", + "last_name": "Mansky", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Ke", + "last_name": "Du", + "institution": "University of Illinois Chicago" } ], - "dblp_key": "journals/pacmpl/Popescu24", + "dblp_key": "journals/pacmpl/ManskyD24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632892", - "title": "Thunks and Debits in Separation Logic with Time Credits", - "abstract": "A thunk is a mutable data structure that offers a simple memoization service: it stores either a suspended computation or the result of this computation. Okasaki [1999] presents many data structures that exploit thunks to achieve good amortized time complexity. He analyzes their complexity by associating a debit with every thunk. A debit can be paid off in several increments; a thunk whose debit has been fully paid off can be forced. Quite strikingly, a debit is associated also with future thunks, which do not yet exist in memory. Some of the debit of a faraway future thunk can be transferred to a nearer future thunk. We present a complete machine-checked reconstruction of Okasaki’s reasoning rules in Iris $ , a rich separation logic with time credits. We demonstrate the applicability of the rules by verifying a few operations on streams as well as several of Okasaki’s data structures, namely the physicist’s queue, implicit queues, and the banker’s queue.", + "paper_id": "10.1145/3632850", + "title": "Internal and Observational Parametricity for Cubical Agda", + "abstract": "Two approaches exist to incorporate parametricity into proof assistants based on dependent type theory. On the one hand, parametricity translations conveniently compute parametricity statements and their proofs solely based on individual well-typed polymorphic programs. But they do not offer internal parametricity: formal proofs that any polymorphic program of a certain type satisfies its parametricity statement. On the other hand, internally parametric type theories augment plain type theory with additional primitives out of which internal parametricity can be derived. But those type theories lack mature proof assistant implementations and deriving parametricity in them involves low-level intractable proofs. In this paper, we contribute Agda --bridges: the first practical internally parametric proof assistant. We provide the first mechanized proofs of crucial theorems for internal parametricity, like the relativity theorem. We identify a high-level sufficient condition for proving internal parametricity which we call the structure relatedness principle (SRP) by analogy with the structure identity principle (SIP) of HoTT/UF. We state and prove a general parametricity theorem for types that satisfy the SRP. Our parametricity theorem lets us obtain one-liner proofs of standard internal free theorems. We observe that the SRP is harder to prove than the SIP and provide in Agda --bridges a shallowly embedded type theory to compose types that satisfy the SRP. This type theory is an observational type theory of logical relations and our parametricity theorem ought to be one of its inference rules.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632892", + "link": "https://doi.org/10.1145/3632850", "conference_name": "POPL", "authors": [ { - "first_name": "François", - "last_name": "Pottier", - "institution": "Institut national de recherche en sciences et technologies du numérique" - }, - { - "first_name": "Armaël", - "last_name": "Guéneau", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Antoine Van", + "last_name": "Muylder", + "institution": "KU Leuven" }, { - "first_name": "Jacques-Henri", - "last_name": "Jourdan", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Andreas", + "last_name": "Nuyts", + "institution": "KU Leuven" }, { - "first_name": "Glen", - "last_name": "Mével", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" } ], - "dblp_key": "journals/pacmpl/PottierGJM24", + "dblp_key": "journals/pacmpl/MuylderND24", "venue": "popl", "year": 2024 }, @@ -2102,7 +1929,7 @@ "title": "Shoggoth: A Formal Foundation for Strategic Rewriting", "abstract": "Rewriting is a versatile and powerful technique used in many domains. Strategic rewriting allows programmers to control the application of rewrite rules by composing individual rewrite rules into complex rewrite strategies. These strategies are semantically complex, as they may be nondeterministic, they may raise errors that trigger backtracking, and they may not terminate. Given such semantic complexity, it is necessary to establish a formal understanding of rewrite strategies and to enable reasoning about them in order to answer questions like: How do we know that a rewrite strategy terminates? How do we know that a rewrite strategy does not fail because we compose two incompatible rewrites? How do we know that a desired property holds after applying a rewrite strategy? In this paper, we introduce Shoggoth: a formal foundation for understanding, analysing and reasoning about strategic rewriting that is capable of answering these questions. We provide a denotational semantics of System S, a core language for strategic rewriting, and prove its equivalence to our big-step operational semantics, which extends existing work by explicitly accounting for divergence. We further define a location-based weakest precondition calculus to enable formal reasoning about rewriting strategies, and we prove this calculus sound with respect to the denotational semantics. We show how this calculus can be used in practice to reason about properties of rewriting strategies, including termination, that they are well-composed, and that desired postconditions hold. The semantics and calculus are formalised in Isabelle/HOL and all proofs are mechanised.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3633211", + "link": "https://doi.org/10.1145/3633211", "conference_name": "POPL", "authors": [ { @@ -2141,182 +1968,271 @@ "year": 2024 }, { - "paper_id": "10.1145/3632906", - "title": "Decision and Complexity of Dolev-Yao Hyperproperties", - "abstract": "The formal analysis of cryptographic protocols traditionally focuses on trace and equivalence properties, for which decision procedures in the symbolic (or Dolev-Yao, or DY) model are known. However, many relevant security properties are expressed as DY hyperproperties that involve quantifications over both execution paths and attacker computations (which are constrained by the attacker’s knowledge in the underlying model of computation). DY hyperproperties generalise hyperproperties, for which many decision procedures exist, to the setting of DY models. Unfortunately, the subtle interactions between both forms of quantifications have been an obstacle to lifting decision procedures from hyperproperties to DY hyperproperties. The central contribution of the paper is the first procedure for deciding DY hyperproperties, in the usual setting where the number of protocol sessions is bounded and where the equational theory modelling cryptography is subterm-convergent. We prove that our decision procedure can decide the validity of any hyperproperty in which quantifications over messages are guarded and quantifications over attacker computations are limited to expressing the attacker’s knowledge. We also establish the complexity of the decision problem for several important fragments of the hyperlogic. Further, we illustrate the techniques and scope of our contributions through examples of related hyperproperties.", + "paper_id": "10.1145/3632890", + "title": "When Subtyping Constraints Liberate: A Novel Type Inference Approach for First-Class Polymorphism", + "abstract": "Type inference in the presence of first-class or “ impredicative ” second-order polymorphism à la System F has been an active research area for several decades, with original works dating back to the end of the 80s. Yet, until now many basic problems remain open, such as how to type check expressions like ( λ x . ( x 123 , x True ) ) id reliably. We show that a type inference approach based on multi-bounded polymorphism , a form of implicit polymorphic subtyping with multiple lower and upper bounds, can help us resolve most of these problems in a uniquely simple and regular way. We define F ≤ , a declarative type system derived from the existing theory of implicit coercions by Cretin and Rémy (LICS 2014), and we introduce SuperF, a novel algorithm to infer polymorphic multi-bounded F ≤ types while checking user type annotations written in the syntax of System F. We use a recursion-avoiding heuristic to guarantee termination of type inference at the cost of rejecting some valid programs, which thankfully rarely triggers in practice. We show that SuperF is vastly more powerful than all first-class-polymorphic type inference systems proposed so far, significantly advancing the state of the art in type inference for general-purpose programming languages.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632906", + "link": "https://doi.org/10.1145/3632890", "conference_name": "POPL", "authors": [ { - "first_name": "Itsaka", - "last_name": "Rakotonirina", - "institution": "Max Planck Institute for Security and Privacy" + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" }, { - "first_name": "Gilles", - "last_name": "Barthe", - "institution": "Max Planck Institute for Security and Privacy" + "first_name": "Aleksander", + "last_name": "Boruch-Gruszecki", + "institution": "École Polytechnique Fédérale de Lausanne" }, { - "first_name": "Clara", - "last_name": "Schneidewind", - "institution": "Max Planck Institute for Security and Privacy" + "first_name": "Andong", + "last_name": "Fan", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Chun Yin", + "last_name": "Chau", + "institution": "Hong Kong University of Science and Technology" } ], - "dblp_key": "journals/pacmpl/RakotonirinaBS24", + "dblp_key": "journals/pacmpl/ParreauxBFC24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632909", - "title": "Ill-Typed Programs Don't Evaluate", - "abstract": "We introduce two-sided type systems, which are sequent calculi for typing formulas. Two-sided type systems allow for hypothetical reasoning over the typing of compound program expressions, and the refutation of typing formulas. By incorporating a type of all values, these type systems support more refined notions of well-typing and ill-typing, guaranteeing both that well-typed programs don’t go wrong and that ill-typed programs don’t evaluate - that is, reach a value. This makes two-sided type systems suitable for incorrectness reasoning in higher-order program verification, which we illustrate through an application to precise data-flow typing in a language with constructors and pattern matching. Finally, we investigate the internalisation of the meta-level negation in the system as a complement operator on types. This motivates an alternative semantics for the typing judgement, which guarantees that ill-typed programs don’t evaluate, but in which well-typed programs may yet go wrong.", + "paper_id": "10.1145/3632930", + "title": "Effectful Software Contracts", + "abstract": "Software contracts empower programmers to describe functional properties of components. When it comes to constraining effects, though, the literature offers only one-off solutions for various effects. It lacks a universal principle. This paper presents the design of an effectful contract system in the context of effect handlers. A key metatheorem shows that contracts cannot unduly interfere with a program’s execution. An implementation of this design, along with an evaluation of its generality, demonstrates that the theory can guide practice.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632909", + "link": "https://doi.org/10.1145/3632930", "conference_name": "POPL", "authors": [ { - "first_name": "Steven", - "last_name": "Ramsay", - "institution": "University of Bristol" + "first_name": "Cameron", + "last_name": "Moy", + "institution": "Northeastern University" }, { - "first_name": "Charlie", - "last_name": "Walpole", - "institution": "University of Bristol" + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" } ], - "dblp_key": "journals/pacmpl/RamsayW24", + "dblp_key": "journals/pacmpl/MoyDF24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632905", - "title": "Inference of Probabilistic Programs with Moment-Matching Gaussian Mixtures", - "abstract": "Computing the posterior distribution of a probabilistic program is a hard task for which no one-fit-for-all solution exists. We propose Gaussian Semantics, which approximates the exact probabilistic semantics of a bounded program by means of Gaussian mixtures. It is parametrized by a map that associates each program location with the moment order to be matched in the approximation. We provide two main contributions. The first is a universal approximation theorem stating that, under mild conditions, Gaussian Semantics can approximate the exact semantics arbitrarily closely. The second is an approximation that matches up to second-order moments analytically in face of the generally difficult problem of matching moments of Gaussian mixtures with arbitrary moment order. We test our second-order Gaussian approximation (SOGA) on a number of case studies from the literature. We show that it can provide accurate estimates in models not supported by other approximation methods or when exact symbolic techniques fail because of complex expressions or non-simplified integrals. On two notable classes of problems, namely collaborative filtering and programs involving mixtures of continuous and discrete distributions, we show that SOGA significantly outperforms alternative techniques in terms of accuracy and computational time.", + "paper_id": "10.1145/3632878", + "title": "Efficient CHAD", + "abstract": "We show how the basic Combinatory Homomorphic Automatic Differentiation (CHAD) algorithm can be optimised, using well-known methods, to yield a simple, composable, and generally applicable reverse-mode automatic differentiation (AD) technique that has the correct computational complexity that we would expect of reverse-mode AD. Specifically, we show that the standard optimisations of sparse vectors and state-passing style code (as well as defunctionalisation/closure conversion, for higher-order languages) give us a purely functional algorithm that is most of the way to the correct complexity, with (functional) mutable updates taking care of the final log-factors. We provide an Agda formalisation of our complexity proof. Finally, we discuss how the techniques apply to differentiating parallel functional array programs: the key observations are 1) that all required mutability is (commutative, associative) accumulation, which lets us preserve task-parallelism and 2) that we can write down data-parallel derivatives for most data-parallel array primitives.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632905", + "link": "https://doi.org/10.1145/3632878", "conference_name": "POPL", "authors": [ { - "first_name": "Francesca", - "last_name": "Randone", - "institution": "IMT School for Advanced Studies Lucca" + "first_name": "Tom", + "last_name": "Smeding", + "institution": "Utrecht University" }, { - "first_name": "Luca", - "last_name": "Bortolussi", - "institution": "University of Trieste" + "first_name": "Matthijs", + "last_name": "Vákár", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/pacmpl/SmedingV24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632886", + "title": "Internalizing Indistinguishability with Dependent Types", + "abstract": "In type systems with dependency tracking, programmers can assign an ordered set of levels to computations and prevent information flow from high-level computations to the low-level ones. The key notion in such systems is indistinguishability : a definition of program equivalence that takes into account the parts of the program that an observer may depend on. In this paper, we investigate the use of dependency tracking in the context of dependently-typed languages. We present the Dependent Calculus of Indistinguishability (DCOI), a system that adopts indistinguishability as the definition of equality used by the type checker. DCOI also internalizes that relation as an observer-indexed propositional equality type, so that programmers may reason about indistinguishability within the language. Our design generalizes and extends prior systems that combine dependency tracking with dependent types and is the first to support conversion and propositional equality at arbitrary observer levels. We have proven type soundness and noninterference theorems for DCOI and have developed a prototype implementation of its type checker.", + "date": "2024-01-02", + "link": "https://doi.org/10.1145/3632886", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yiyun", + "last_name": "Liu", + "institution": "University of Pennsylvania" }, { - "first_name": "Emilio", - "last_name": "Incerto", - "institution": "IMT School for Advanced Studies Lucca" + "first_name": "Jonathan", + "last_name": "Chan", + "institution": "University of Pennsylvania" }, { - "first_name": "Mirco", - "last_name": "Tribastone", - "institution": "IMT School for Advanced Studies Lucca" + "first_name": "Jessica", + "last_name": "Shi", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" } ], - "dblp_key": "journals/pacmpl/RandoneBIT24", + "dblp_key": "journals/pacmpl/LiuCSW24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632859", - "title": "Pipelines and Beyond: Graph Types for ADTs with Futures", - "abstract": "Parallel programs are frequently modeled as dependency or cost graphs, which can be used to detect various bugs, or simply to visualize the parallel structure of the code. However, such graphs reflect just one particular execution and are typically constructed in a post-hoc manner. Graph types , which were introduced recently to mitigate this problem, can be assigned statically to a program by a type system and compactly represent the family of all graphs that could result from the program. Unfortunately, prior work is restricted in its treatment of futures , an increasingly common and especially dynamic form of parallelism. In short, each instance of a future must be statically paired with a vertex name. Previously, this led to the restriction that futures could not be placed in collections or be used to construct data structures. Doing so is not a niche exercise: such structures form the basis of numerous algorithms that use forms of pipelining to achieve performance not attainable without futures. All but the most limited of these examples are out of reach of prior graph type systems. In this paper, we propose a graph type system that allows for almost arbitrary combinations of futures and recursive data types. We do so by indexing datatypes with a type-level vertex structure , a codata structure that supplies unique vertex names to the futures in a data structure. We prove the soundness of the system in a parallel core calculus annotated with vertex structures and associated operations. Although the calculus is annotated, this is merely for convenience in defining the type system. We prove that it is possible to annotate arbitrary recursive types with vertex structures, and show using a prototype inference engine that these annotations can be inferred from OCaml-like source code for several complex parallel algorithms.", + "paper_id": "10.1145/3632857", + "title": "Nominal Recursors as Epi-Recursors", + "abstract": "We study nominal recursors from the literature on syntax with bindings and compare them with respect to expressiveness. The term “nominal” refers to the fact that these recursors operate on a syntax representation where the names of bound variables appear explicitly, as in nominal logic. We argue that nominal recursors can be viewed as epi-recursors , a concept that captures abstractly the distinction between the constructors on which one actually recurses, and other operators and properties that further underpin recursion. We develop an abstract framework for comparing epi-recursors and instantiate it to the existing nominal recursors, and also to several recursors obtained from them by cross-pollination. The resulted expressiveness hierarchies depend on how strictly we perform this comparison, and bring insight into the relative merits of different axiomatizations of syntax. We also apply our methodology to produce an expressiveness hierarchy of nominal corecursors , which are principles for defining functions targeting infinitary non-well-founded terms (which underlie λ -calculus semantics concepts such as Böhm trees). Our results are validated with the Isabelle/HOL theorem prover.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632859", + "link": "https://doi.org/10.1145/3632857", "conference_name": "POPL", "authors": [ { - "first_name": "F.", - "last_name": "Rinaldi", - "institution": "Illinois Institute of Technology" + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "University of Sheffield" + } + ], + "dblp_key": "journals/pacmpl/Popescu24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632896", + "title": "Soundly Handling Linearity", + "abstract": "We propose a novel approach to soundly combining linear types with multi-shot effect handlers. Linear type systems statically ensure that resources such as file handles and communication channels are used exactly once. Effect handlers provide a rich modular programming abstraction for implementing features ranging from exceptions to concurrency to backtracking. Whereas conventional linear type systems bake in the assumption that continuations are invoked exactly once, effect handlers allow continuations to be discarded (e.g. for exceptions) or invoked more than once (e.g. for backtracking). This mismatch leads to soundness bugs in existing systems such as the programming language Links , which combines linearity (for session types) with effect handlers. We introduce control-flow linearity as a means to ensure that continuations are used in accordance with the linearity of any resources they capture, ruling out such soundness bugs. We formalise the notion of control-flow linearity in a System F-style core calculus F eff ∘ equipped with linear types, an effect type system, and effect handlers. We define a linearity-aware semantics in order to formally prove that F eff ∘ preserves the integrity of linear values in the sense that no linear value is discarded or duplicated. In order to show that control-flow linearity can be made practical, we adapt Links based on the design of F eff ∘ , in doing so fixing a long-standing soundness bug. Finally, to better expose the potential of control-flow linearity, we define an ML-style core calculus Q eff ∘ , based on qualified types, which requires no programmer provided annotations, and instead relies entirely on type inference to infer control-flow linearity. Both linearity and effects are captured by qualified types. Q eff ∘ overcomes a number of practical limitations of F eff ∘ , supporting abstraction over linearity, linearity dependencies between type variables, and a much more fine-grained notion of control-flow linearity.", + "date": "2024-01-02", + "link": "https://doi.org/10.1145/3632896", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wenhao", + "last_name": "Tang", + "institution": "University of Edinburgh" }, { - "first_name": "june", - "last_name": "wunder", + "first_name": "Daniel", + "last_name": "Hillerström", "institution": "" }, { - "first_name": "Arthur Azevedo de", - "last_name": "Amorim", - "institution": "Rochester Institute of Technology" + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" }, { - "first_name": "Stefan K.", - "last_name": "Muller", - "institution": "Illinois Institute of Technology" + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Iowa" } ], - "dblp_key": "journals/pacmpl/RinaldiwAM24", + "dblp_key": "journals/pacmpl/TangHLM24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632933", - "title": "Inference of Robust Reachability Constraints", - "abstract": "Characterization of bugs and attack vectors is in many practical scenarios as important as their finding. Recently, Girol et al. have introduced the concept of robust reachability , which ensures a perfect reproducibility of the reported violations by distinguishing inputs that are under the control of the attacker ( controlled inputs ) from those that are not ( uncontrolled inputs ), and proposed first automated analysis for it. While it is a step toward distinguishing severe bugs from benign ones, it fails for example to describe violations that are mostly reproducible, i.e., when triggering conditions are likely to happen, meaning that they happen for all uncontrolled inputs but a few corner cases. To address this issue, we propose to leverage theory-agnostic abduction techniques to generate constraints on the uncontrolled program inputs that ensure that a target property is robustly satisfied . Our proposal comes with an extension of robust reachability that is generic on the type of trace property and on the technology used to verify the properties. We show that our approach is complete w.r.t. its inference language , and we additionally discuss strategies for the efficient exploration of the inference space. We demonstrate the feasibility of the method and its practical ability to refine the notion of robust reachability with an implementation that uses robust reachability oracles to generate constraints on standard benchmarks from software verification and security analysis. We illustrate the use of our implementation to a vulnerability characterization problem in the context of fault injection attacks. Our method overcomes a major limitation of the initial proposal of robust reachability, without complicating its definition. From a practical view, this is a step toward new verification tools that are able to characterize program violations through high-level feedback.", + "paper_id": "10.1145/3632870", + "title": "Semantic Code Refactoring for Abstract Data Types", + "abstract": "Modifications to the data representation of an abstract data type (ADT) can require significant semantic refactoring of the code. Motivated by this observation, this paper presents a new method to automate semantic code refactoring tasks. Our method takes as input the original ADT implementation, a new data representation, and a so-called relational representation invariant (relating the old and new data representations), and automatically generates a new ADT implementation that is semantically equivalent to the original version. Our method is based on counterexample-guided inductive synthesis (CEGIS) but leverages three key ideas that allow it to handle real-world refactoring tasks. First, our approach reduces the underlying relational synthesis problem to a set of (simpler) programming-by-example problems, one for each method in the ADT. Second, it leverages symbolic reasoning techniques, based on logical abduction, to deduce code snippets that should occur in the refactored version. Finally, it utilizes a notion of partial equivalence to make inductive synthesis much more effective in this setting. We have implemented the proposed approach in a new tool called Revamp for automatically refactoring Java classes and evaluated it on 30 Java class mined from Github. Our evaluation shows that Revamp can correctly refactor the entire ADT in 97% of the cases and that it can successfully re-implement 144 out of the 146 methods that require modifications.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632933", + "link": "https://doi.org/10.1145/3632870", "conference_name": "POPL", "authors": [ { - "first_name": "Yanis", - "last_name": "Sellami", - "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "The University of Texas at Austin" }, { - "first_name": "Guillaume", - "last_name": "Girol", - "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "Simon Fraser University" }, { - "first_name": "Frédéric", - "last_name": "Recoules", - "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/PailoorWD24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632859", + "title": "Pipelines and Beyond: Graph Types for ADTs with Futures", + "abstract": "Parallel programs are frequently modeled as dependency or cost graphs, which can be used to detect various bugs, or simply to visualize the parallel structure of the code. However, such graphs reflect just one particular execution and are typically constructed in a post-hoc manner. Graph types , which were introduced recently to mitigate this problem, can be assigned statically to a program by a type system and compactly represent the family of all graphs that could result from the program. Unfortunately, prior work is restricted in its treatment of futures , an increasingly common and especially dynamic form of parallelism. In short, each instance of a future must be statically paired with a vertex name. Previously, this led to the restriction that futures could not be placed in collections or be used to construct data structures. Doing so is not a niche exercise: such structures form the basis of numerous algorithms that use forms of pipelining to achieve performance not attainable without futures. All but the most limited of these examples are out of reach of prior graph type systems. In this paper, we propose a graph type system that allows for almost arbitrary combinations of futures and recursive data types. We do so by indexing datatypes with a type-level vertex structure , a codata structure that supplies unique vertex names to the futures in a data structure. We prove the soundness of the system in a parallel core calculus annotated with vertex structures and associated operations. Although the calculus is annotated, this is merely for convenience in defining the type system. We prove that it is possible to annotate arbitrary recursive types with vertex structures, and show using a prototype inference engine that these annotations can be inferred from OCaml-like source code for several complex parallel algorithms.", + "date": "2024-01-02", + "link": "https://doi.org/10.1145/3632859", + "conference_name": "POPL", + "authors": [ + { + "first_name": "F.", + "last_name": "Rinaldi", + "institution": "Illinois Institute of Technology" }, { - "first_name": "Damien", - "last_name": "Couroussé", - "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + "first_name": "june", + "last_name": "wunder", + "institution": "" }, { - "first_name": "Sébastien", - "last_name": "Bardin", - "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Illinois Institute of Technology" } ], - "dblp_key": "journals/pacmpl/SellamiGRCB24", + "dblp_key": "journals/pacmpl/RinaldiwAM24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632866", - "title": "The Essence of Generalized Algebraic Data Types", - "abstract": "This paper considers direct encodings of generalized algebraic data types (GADTs) in a minimal suitable lambda-calculus. To this end, we develop an extension of System F ω with recursive types and internalized type equalities with injective constant type constructors. We show how GADTs and associated pattern-matching constructs can be directly expressed in the calculus, thus showing that it may be treated as a highly idealized modern functional programming language. We prove that the internalized type equalities in conjunction with injectivity rules increase the expressive power of the calculus by establishing a non-macro-expressibility result in F ω , and prove the system type-sound via a syntactic argument. Finally, we build two relational models of our calculus: a simple, unary model that illustrates a novel, two-stage interpretation technique, necessary to account for the equational constraints; and a more sophisticated, binary model that relaxes the construction to allow, for the first time, formal reasoning about data-abstraction in a calculus equipped with GADTs.", + "paper_id": "10.1145/3632851", + "title": "Trillium: Higher-Order Concurrent and Distributed Separation Logic for Intensional Refinement", + "abstract": "Expressive state-of-the-art separation logics rely on step-indexing to model semantically complex features and to support modular reasoning about imperative higher-order concurrent and distributed programs. Stepindexing comes, however, with an inherent cost: it restricts the adequacy theorem of program logics to a fairly simple class of safety properties. In this paper, we explore if and how intensional refinement is a viable methodology for strengthening higher-order concurrent (and distributed) separation logic to prove non-trivial safety and liveness properties. Specifically, we introduce Trillium, a language-agnostic separation logic framework for showing intensional refinement relations between traces of a program and a model. We instantiate Trillium with a concurrent language and develop Fairis, a concurrent separation logic, that we use to show liveness properties of concurrent programs under fair scheduling assumptions through a fair liveness-preserving refinement of a model. We also instantiate Trillium with a distributed language and obtain an extension of Aneris, a distributed separation logic, which we use to show refinement relations between distributed systems and TLA + models.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632866", + "link": "https://doi.org/10.1145/3632851", "conference_name": "POPL", "authors": [ { - "first_name": "Filip", - "last_name": "Sieczkowski", - "institution": "Heriot-Watt University" + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "Aarhus University" }, { - "first_name": "Sergei", - "last_name": "Stepanenko", + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", "institution": "Aarhus University" }, { - "first_name": "Jonathan", - "last_name": "Sterling", - "institution": "University of Cambridge" + "first_name": "Léon", + "last_name": "Gondelman", + "institution": "Aarhus University" + }, + { + "first_name": "Abel", + "last_name": "Nieto", + "institution": "Aarhus University" }, { "first_name": "Lars", @@ -2324,30 +2240,40 @@ "institution": "Aarhus University" } ], - "dblp_key": "journals/pacmpl/SieczkowskiSSB24", + "dblp_key": "journals/pacmpl/TimanyGSHGNB24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632878", - "title": "Efficient CHAD", - "abstract": "We show how the basic Combinatory Homomorphic Automatic Differentiation (CHAD) algorithm can be optimised, using well-known methods, to yield a simple, composable, and generally applicable reverse-mode automatic differentiation (AD) technique that has the correct computational complexity that we would expect of reverse-mode AD. Specifically, we show that the standard optimisations of sparse vectors and state-passing style code (as well as defunctionalisation/closure conversion, for higher-order languages) give us a purely functional algorithm that is most of the way to the correct complexity, with (functional) mutable updates taking care of the final log-factors. We provide an Agda formalisation of our complexity proof. Finally, we discuss how the techniques apply to differentiating parallel functional array programs: the key observations are 1) that all required mutability is (commutative, associative) accumulation, which lets us preserve task-parallelism and 2) that we can write down data-parallel derivatives for most data-parallel array primitives.", + "paper_id": "10.1145/3632871", + "title": "EasyBC: A Cryptography-Specific Language for Security Analysis of Block Ciphers against Differential Cryptanalysis", + "abstract": "Differential cryptanalysis is a powerful algorithmic-level attack, playing a central role in evaluating the security of symmetric cryptographic primitives. In general, the resistance against differential cryptanalysis can be characterized by the maximum expected differential characteristic probability. In this paper, we present generic and extensible approaches based on mixed integer linear programming (MILP) to bound such probability. We design a high-level cryptography-specific language EasyBc tailored for block ciphers and provide various rigorous procedures as differential denotational semantics, to automate the generation of MILP from block ciphers written in EasyBc . We implement an open-sourced tool that provides support for fully automated resistance evaluation of block ciphers against differential cryptanalysis. The tool is extensively evaluated on 23 real-life cryptographic primitives including all the 10 finalists of the NIST lightweight cryptography standardization process. The experiments confirm the expressivity of EasyBc and show that the tool can effectively prove the resistance against differential cryptanalysis for all block ciphers under consideration. EasyBc makes resistance evaluation against differential cryptanalysis easily accessible to cryptographers.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632878", + "link": "https://doi.org/10.1145/3632871", "conference_name": "POPL", "authors": [ { - "first_name": "Tom", - "last_name": "Smeding", - "institution": "Utrecht University" + "first_name": "Pu", + "last_name": "Sun", + "institution": "ShanghaiTech University" }, { - "first_name": "Matthijs", - "last_name": "Vákár", - "institution": "Utrecht University" + "first_name": "Fu", + "last_name": "Song", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Yuqi", + "last_name": "Chen", + "institution": "ShanghaiTech University" + }, + { + "first_name": "Taolue", + "last_name": "Chen", + "institution": "Birkbeck, University of London" } ], - "dblp_key": "journals/pacmpl/SmedingV24", + "dblp_key": "journals/pacmpl/SunSCC24", "venue": "popl", "year": 2024 }, @@ -2356,7 +2282,7 @@ "title": "API-Driven Program Synthesis for Testing Static Typing Implementations", "abstract": "We introduce a novel approach for testing static typing implementations based on the concept of API-driven program synthesis . The idea is to synthesize type-intensive but small and well-typed programs by leveraging and combining application programming interfaces (APIs) derived from existing software libraries. Our primary insight is backed up by real-world evidence: a significant number of compiler typing bugs are caused by small test cases that employ APIs from the standard library of the language under test. This is attributed to the inherent complexity of the majority of these APIs, which often exercise a wide range of sophisticated type-related features. The main contribution of our approach is the ability to produce small client programs with increased feature coverage, without bearing the burden of generating the corresponding well-formed API definitions from scratch. To validate diverse aspects of static typing procedures (i.e., soundness, precision of type inference), we also enrich our API-driven approach with fault-injection and semantics-preserving modes, along with their corresponding test oracles. We evaluate our implemented tool, thalia , on testing the static typing implementations of the compilers for three popular languages, namely, Scala, Kotlin, and Groovy. thalia has uncovered 84 typing bugs (77 confirmed and 22 fixed), most of which are triggered by test cases featuring APIs that rely on parametric polymorphism, overloading, and higher-order functions. Our comparison with state-of-the-art shows that thalia yields test programs with distinct characteristics, offering additional and complementary benefits.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632904", + "link": "https://doi.org/10.1145/3632904", "conference_name": "POPL", "authors": [ { @@ -2380,83 +2306,73 @@ "year": 2024 }, { - "paper_id": "10.1145/3632871", - "title": "EasyBC: A Cryptography-Specific Language for Security Analysis of Block Ciphers against Differential Cryptanalysis", - "abstract": "Differential cryptanalysis is a powerful algorithmic-level attack, playing a central role in evaluating the security of symmetric cryptographic primitives. In general, the resistance against differential cryptanalysis can be characterized by the maximum expected differential characteristic probability. In this paper, we present generic and extensible approaches based on mixed integer linear programming (MILP) to bound such probability. We design a high-level cryptography-specific language EasyBc tailored for block ciphers and provide various rigorous procedures as differential denotational semantics, to automate the generation of MILP from block ciphers written in EasyBc . We implement an open-sourced tool that provides support for fully automated resistance evaluation of block ciphers against differential cryptanalysis. The tool is extensively evaluated on 23 real-life cryptographic primitives including all the 10 finalists of the NIST lightweight cryptography standardization process. The experiments confirm the expressivity of EasyBc and show that the tool can effectively prove the resistance against differential cryptanalysis for all block ciphers under consideration. EasyBc makes resistance evaluation against differential cryptanalysis easily accessible to cryptographers.", + "paper_id": "10.1145/3632905", + "title": "Inference of Probabilistic Programs with Moment-Matching Gaussian Mixtures", + "abstract": "Computing the posterior distribution of a probabilistic program is a hard task for which no one-fit-for-all solution exists. We propose Gaussian Semantics, which approximates the exact probabilistic semantics of a bounded program by means of Gaussian mixtures. It is parametrized by a map that associates each program location with the moment order to be matched in the approximation. We provide two main contributions. The first is a universal approximation theorem stating that, under mild conditions, Gaussian Semantics can approximate the exact semantics arbitrarily closely. The second is an approximation that matches up to second-order moments analytically in face of the generally difficult problem of matching moments of Gaussian mixtures with arbitrary moment order. We test our second-order Gaussian approximation (SOGA) on a number of case studies from the literature. We show that it can provide accurate estimates in models not supported by other approximation methods or when exact symbolic techniques fail because of complex expressions or non-simplified integrals. On two notable classes of problems, namely collaborative filtering and programs involving mixtures of continuous and discrete distributions, we show that SOGA significantly outperforms alternative techniques in terms of accuracy and computational time.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632871", + "link": "https://doi.org/10.1145/3632905", "conference_name": "POPL", "authors": [ { - "first_name": "Pu", - "last_name": "Sun", - "institution": "ShanghaiTech University" + "first_name": "Francesca", + "last_name": "Randone", + "institution": "IMT School for Advanced Studies Lucca" }, { - "first_name": "Fu", - "last_name": "Song", - "institution": "Chinese Academy of Sciences" + "first_name": "Luca", + "last_name": "Bortolussi", + "institution": "University of Trieste" }, { - "first_name": "Yuqi", - "last_name": "Chen", - "institution": "ShanghaiTech University" + "first_name": "Emilio", + "last_name": "Incerto", + "institution": "IMT School for Advanced Studies Lucca" }, { - "first_name": "Taolue", - "last_name": "Chen", - "institution": "Birkbeck, University of London" + "first_name": "Mirco", + "last_name": "Tribastone", + "institution": "IMT School for Advanced Studies Lucca" } ], - "dblp_key": "journals/pacmpl/SunSCC24", + "dblp_key": "journals/pacmpl/RandoneBIT24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632896", - "title": "Soundly Handling Linearity", - "abstract": "We propose a novel approach to soundly combining linear types with multi-shot effect handlers. Linear type systems statically ensure that resources such as file handles and communication channels are used exactly once. Effect handlers provide a rich modular programming abstraction for implementing features ranging from exceptions to concurrency to backtracking. Whereas conventional linear type systems bake in the assumption that continuations are invoked exactly once, effect handlers allow continuations to be discarded (e.g. for exceptions) or invoked more than once (e.g. for backtracking). This mismatch leads to soundness bugs in existing systems such as the programming language Links , which combines linearity (for session types) with effect handlers. We introduce control-flow linearity as a means to ensure that continuations are used in accordance with the linearity of any resources they capture, ruling out such soundness bugs. We formalise the notion of control-flow linearity in a System F-style core calculus F eff ∘ equipped with linear types, an effect type system, and effect handlers. We define a linearity-aware semantics in order to formally prove that F eff ∘ preserves the integrity of linear values in the sense that no linear value is discarded or duplicated. In order to show that control-flow linearity can be made practical, we adapt Links based on the design of F eff ∘ , in doing so fixing a long-standing soundness bug. Finally, to better expose the potential of control-flow linearity, we define an ML-style core calculus Q eff ∘ , based on qualified types, which requires no programmer provided annotations, and instead relies entirely on type inference to infer control-flow linearity. Both linearity and effects are captured by qualified types. Q eff ∘ overcomes a number of practical limitations of F eff ∘ , supporting abstraction over linearity, linearity dependencies between type variables, and a much more fine-grained notion of control-flow linearity.", + "paper_id": "10.1145/3632909", + "title": "Ill-Typed Programs Don't Evaluate", + "abstract": "We introduce two-sided type systems, which are sequent calculi for typing formulas. Two-sided type systems allow for hypothetical reasoning over the typing of compound program expressions, and the refutation of typing formulas. By incorporating a type of all values, these type systems support more refined notions of well-typing and ill-typing, guaranteeing both that well-typed programs don’t go wrong and that ill-typed programs don’t evaluate - that is, reach a value. This makes two-sided type systems suitable for incorrectness reasoning in higher-order program verification, which we illustrate through an application to precise data-flow typing in a language with constructors and pattern matching. Finally, we investigate the internalisation of the meta-level negation in the system as a complement operator on types. This motivates an alternative semantics for the typing judgement, which guarantees that ill-typed programs don’t evaluate, but in which well-typed programs may yet go wrong.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632896", + "link": "https://doi.org/10.1145/3632909", "conference_name": "POPL", "authors": [ { - "first_name": "Wenhao", - "last_name": "Tang", - "institution": "University of Edinburgh" - }, - { - "first_name": "Daniel", - "last_name": "Hillerström", - "institution": "" - }, - { - "first_name": "Sam", - "last_name": "Lindley", - "institution": "University of Edinburgh" + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Bristol" }, { - "first_name": "J. Garrett", - "last_name": "Morris", - "institution": "University of Iowa" + "first_name": "Charlie", + "last_name": "Walpole", + "institution": "University of Bristol" } ], - "dblp_key": "journals/pacmpl/TangHLM24", + "dblp_key": "journals/pacmpl/RamsayW24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632862", - "title": "The Logical Essence of Well-Bracketed Control Flow", - "abstract": "A program is said to be well-bracketed if every called function must return before its caller can resume execution. This is often the case. Well-bracketedness has been captured semantically as a condition on strategies in fully abstract games models and multiple prior works have studied well-bracketedness by showing correctness/security properties of programs where such properties depend on the well-bracketed nature of control flow. The latter category of prior works have all used involved relational models with explicit state-transition systems capturing the relevant parts of the control flow of the program. In this paper we present the first Hoare-style program logic based on separation logic for reasoning about well-bracketedness and use it to show correctness of well-bracketed programs both directly and also through defining unary and binary logical relations models based on this program logic. All results presented in this paper are formalized on top of the Iris framework and mechanized in the Coq proof assistant.", + "paper_id": "10.1145/3632892", + "title": "Thunks and Debits in Separation Logic with Time Credits", + "abstract": "A thunk is a mutable data structure that offers a simple memoization service: it stores either a suspended computation or the result of this computation. Okasaki [1999] presents many data structures that exploit thunks to achieve good amortized time complexity. He analyzes their complexity by associating a debit with every thunk. A debit can be paid off in several increments; a thunk whose debit has been fully paid off can be forced. Quite strikingly, a debit is associated also with future thunks, which do not yet exist in memory. Some of the debit of a faraway future thunk can be transferred to a nearer future thunk. We present a complete machine-checked reconstruction of Okasaki’s reasoning rules in Iris $ , a rich separation logic with time credits. We demonstrate the applicability of the rules by verifying a few operations on streams as well as several of Okasaki’s data structures, namely the physicist’s queue, implicit queues, and the banker’s queue.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632862", + "link": "https://doi.org/10.1145/3632892", "conference_name": "POPL", "authors": [ { - "first_name": "Amin", - "last_name": "Timany", - "institution": "Aarhus University" + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en sciences et technologies du numérique" }, { "first_name": "Armaël", @@ -2464,121 +2380,169 @@ "institution": "Centre National de la Recherche Scientifique" }, { - "first_name": "Lars", - "last_name": "Birkedal", - "institution": "Aarhus University" + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Glen", + "last_name": "Mével", + "institution": "Centre National de la Recherche Scientifique" } ], - "dblp_key": "journals/pacmpl/TimanyGB24", + "dblp_key": "journals/pacmpl/PottierGJM24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632851", - "title": "Trillium: Higher-Order Concurrent and Distributed Separation Logic for Intensional Refinement", - "abstract": "Expressive state-of-the-art separation logics rely on step-indexing to model semantically complex features and to support modular reasoning about imperative higher-order concurrent and distributed programs. Stepindexing comes, however, with an inherent cost: it restricts the adequacy theorem of program logics to a fairly simple class of safety properties. In this paper, we explore if and how intensional refinement is a viable methodology for strengthening higher-order concurrent (and distributed) separation logic to prove non-trivial safety and liveness properties. Specifically, we introduce Trillium, a language-agnostic separation logic framework for showing intensional refinement relations between traces of a program and a model. We instantiate Trillium with a concurrent language and develop Fairis, a concurrent separation logic, that we use to show liveness properties of concurrent programs under fair scheduling assumptions through a fair liveness-preserving refinement of a model. We also instantiate Trillium with a distributed language and obtain an extension of Aneris, a distributed separation logic, which we use to show refinement relations between distributed systems and TLA + models.", + "paper_id": "10.1145/3632933", + "title": "Inference of Robust Reachability Constraints", + "abstract": "Characterization of bugs and attack vectors is in many practical scenarios as important as their finding. Recently, Girol et al. have introduced the concept of robust reachability , which ensures a perfect reproducibility of the reported violations by distinguishing inputs that are under the control of the attacker ( controlled inputs ) from those that are not ( uncontrolled inputs ), and proposed first automated analysis for it. While it is a step toward distinguishing severe bugs from benign ones, it fails for example to describe violations that are mostly reproducible, i.e., when triggering conditions are likely to happen, meaning that they happen for all uncontrolled inputs but a few corner cases. To address this issue, we propose to leverage theory-agnostic abduction techniques to generate constraints on the uncontrolled program inputs that ensure that a target property is robustly satisfied . Our proposal comes with an extension of robust reachability that is generic on the type of trace property and on the technology used to verify the properties. We show that our approach is complete w.r.t. its inference language , and we additionally discuss strategies for the efficient exploration of the inference space. We demonstrate the feasibility of the method and its practical ability to refine the notion of robust reachability with an implementation that uses robust reachability oracles to generate constraints on standard benchmarks from software verification and security analysis. We illustrate the use of our implementation to a vulnerability characterization problem in the context of fault injection attacks. Our method overcomes a major limitation of the initial proposal of robust reachability, without complicating its definition. From a practical view, this is a step toward new verification tools that are able to characterize program violations through high-level feedback.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632851", + "link": "https://doi.org/10.1145/3632933", "conference_name": "POPL", "authors": [ { - "first_name": "Amin", - "last_name": "Timany", - "institution": "Aarhus University" + "first_name": "Yanis", + "last_name": "Sellami", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" }, { - "first_name": "Simon Oddershede", - "last_name": "Gregersen", - "institution": "Aarhus University" + "first_name": "Guillaume", + "last_name": "Girol", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" }, { - "first_name": "Léo", - "last_name": "Stefanesco", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Frédéric", + "last_name": "Recoules", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" }, { - "first_name": "Jonas Kastberg", - "last_name": "Hinrichsen", - "institution": "Aarhus University" + "first_name": "Damien", + "last_name": "Couroussé", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" }, { - "first_name": "Léon", - "last_name": "Gondelman", - "institution": "Aarhus University" + "first_name": "Sébastien", + "last_name": "Bardin", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + } + ], + "dblp_key": "journals/pacmpl/SellamiGRCB24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632910", + "title": "Total Type Error Localization and Recovery with Holes", + "abstract": "Type systems typically only define the conditions under which an expression is well-typed, leaving ill-typed expressions formally meaningless. This approach is insufficient as the basis for language servers driving modern programming environments, which are expected to recover from simultaneously localized errors and continue to provide a variety of downstream semantic services. This paper addresses this problem, contributing the first comprehensive formal account of total type error localization and recovery: the marked lambda calculus. In particular, we define a gradual type system for expressions with marked errors, which operate as non-empty holes, together with a total procedure for marking arbitrary unmarked expressions. We mechanize the metatheory of the marked lambda calculus in Agda and implement it, scaled up, as the new basis for Hazel, a full-scale live functional programming environment with, uniquely, no meaningless editor states. The marked lambda calculus is bidirectionally typed, so localization decisions are systematically predictable based on a local flow of typing information. Constraint-based type inference can bring more distant information to bear in discovering inconsistencies but this notoriously complicates error localization. We approach this problem by deploying constraint solving as a type-hole-filling layer atop this gradual bidirectionally typed core. Errors arising from inconsistent unification constraints are localized exclusively to type and expression holes, i.e., the system identifies unfillable holes using a system of traced provenances, rather than localized in an ad hoc manner to particular expressions. The user can then interactively shift these errors to particular downstream expressions by selecting from suggested partially consistent type hole fillings, which returns control back to the bidirectional system. We implement this type hole inference system in Hazel.", + "date": "2024-01-02", + "link": "https://doi.org/10.1145/3632910", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eric", + "last_name": "Zhao", + "institution": "University of Michigan" }, { - "first_name": "Abel", - "last_name": "Nieto", - "institution": "Aarhus University" + "first_name": "Raef", + "last_name": "Maroof", + "institution": "University of Michigan" }, { - "first_name": "Lars", - "last_name": "Birkedal", - "institution": "Aarhus University" + "first_name": "A Ambedkar", + "last_name": "Dukkipati", + "institution": "University of Michigan" + }, + { + "first_name": "Andrew", + "last_name": "Blinn", + "institution": "University of Michigan" + }, + { + "first_name": "Zhiyi", + "last_name": "Pan", + "institution": "University of Michigan" + }, + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" } ], - "dblp_key": "journals/pacmpl/TimanyGSHGNB24", + "dblp_key": "journals/pacmpl/ZhaoMDBPO24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632855", - "title": "Enriched Presheaf Model of Quantum FPC", - "abstract": "Selinger gave a superoperator model of a first-order quantum programming language and proved that it is fully definable and hence fully abstract. This paper proposes an extension of the superoperator model to higher-order programs based on modules over superoperators or, equivalently, enriched presheaves over the category of superoperators. The enriched presheaf category can be easily proved to be a model of intuitionistic linear logic with cofree exponential, from which one can cave out a model of classical linear logic by a kind of bi-orthogonality construction. Although the structures of an enriched presheaf category are usually rather complex, a morphism in the classical model can be expressed simply as a matrix of completely positive maps. The model inherits many desirable properties from the superoperator model. A conceptually interesting property is that our model has only a state whose “total probability” is bounded by 1, i.e. does not have a state where true and false each occur with probability 2 / 3 . Another convenient property inherited from the superoperator model is a ω CPO-enrichment. Remarkably, our model has a sufficient structure to interpret arbitrary recursive types by the standard domain theoretic technique. We introduce Quantum FPC , a quantum λ -calculus with recursive types, and prove that our model is a fully abstract model of Quantum FPC.", + "paper_id": "10.1145/3632866", + "title": "The Essence of Generalized Algebraic Data Types", + "abstract": "This paper considers direct encodings of generalized algebraic data types (GADTs) in a minimal suitable lambda-calculus. To this end, we develop an extension of System F ω with recursive types and internalized type equalities with injective constant type constructors. We show how GADTs and associated pattern-matching constructs can be directly expressed in the calculus, thus showing that it may be treated as a highly idealized modern functional programming language. We prove that the internalized type equalities in conjunction with injectivity rules increase the expressive power of the calculus by establishing a non-macro-expressibility result in F ω , and prove the system type-sound via a syntactic argument. Finally, we build two relational models of our calculus: a simple, unary model that illustrates a novel, two-stage interpretation technique, necessary to account for the equational constraints; and a more sophisticated, binary model that relaxes the construction to allow, for the first time, formal reasoning about data-abstraction in a calculus equipped with GADTs.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632855", + "link": "https://doi.org/10.1145/3632866", "conference_name": "POPL", "authors": [ { - "first_name": "Takeshi", - "last_name": "Tsukada", - "institution": "Chiba University" + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "Heriot-Watt University" }, { - "first_name": "Kazuyuki", - "last_name": "Asada", - "institution": "Tohoku University" + "first_name": "Sergei", + "last_name": "Stepanenko", + "institution": "Aarhus University" + }, + { + "first_name": "Jonathan", + "last_name": "Sterling", + "institution": "University of Cambridge" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" } ], - "dblp_key": "journals/pacmpl/TsukadaA24", + "dblp_key": "journals/pacmpl/SieczkowskiSSB24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632856", - "title": "Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic Programs", - "abstract": "Fueled by the success of Rust, many programming languages are adding substructural features to their type systems. The promise of tracking properties such as lifetimes and sharing is tremendous, not just for low-level memory management, but also for controlling higher-level resources and capabilities. But so are the difficulties in adapting successful techniques from Rust to higher-level languages, where they need to interact with other advanced features, especially various flavors of functional and type-level abstraction. What would it take to bring full-fidelity reasoning about lifetimes and sharing to mainstream languages? Reachability types are a recent proposal that has shown promise in scaling to higher-order but monomorphic settings, tracking aliasing and separation on top of a substrate inspired by separation logic. However, naive extensions on top of the prior reachability type system λ * with type polymorphism and/or precise reachability polymorphism are unsound, making λ * unsuitable for adoption in real languages. Combining reachability and type polymorphism that is precise, sound, and parametric remains an open challenge. This paper presents a rethinking of the design of reachability tracking and proposes new polymorphic reachability type systems. We introduce a new freshness qualifier to indicate variables whose reachability sets may grow during evaluation steps. The new system tracks variables reachable in a single step and computes transitive closures only when necessary, thus preserving chains of reachability over known variables that can be refined using substitution. These ideas yield the simply-typed λ ◆ -calculus with precise lightweight, i.e. , quantifier-free, reachability polymorphism, and the F < : ◆ -calculus with bounded parametric polymorphism over types and reachability qualifiers, paving the way for making true tracking of lifetimes and sharing practical for mainstream languages. We prove type soundness and the preservation of separation property in Coq. We discuss various applications ( e.g. , safe capability programming), possible effect system extensions, and compare our system with Scala’s capture types.", + "paper_id": "10.1145/3632914", + "title": "Fully Composable and Adequate Verified Compilation with Direct Refinements between Open Modules", + "abstract": "Verified compilation of open modules (i.e., modules whose functionality depends on other modules) provides a foundation for end-to-end verification of modular programs ubiquitous in contemporary software. However, despite intensive investigation in this topic for decades, the proposed approaches are still difficult to use in practice as they rely on assumptions about the internal working of compilers which make it difficult for external users to apply the verification results. We propose an approach to verified compositional compilation without such assumptions in the setting of verifying compilation of heterogeneous modules written in first-order languages supporting global memory and pointers. Our approach is based on the memory model of CompCert and a new discovery that a Kripke relation with a notion of memory protection can serve as a uniform and composable semantic interface for the compiler passes. By absorbing the rely-guarantee conditions on memory evolution for all compiler passes into this Kripke Memory Relation and by piggybacking requirements on compiler optimizations onto it, we get compositional correctness theorems for realistic optimizing compilers as refinements that directly relate native semantics of open modules and that are ignorant of intermediate compilation processes. Such direct refinements support all the compositionality and adequacy properties essential for verified compilation of open modules. We have applied this approach to the full compilation chain of CompCert with its Clight source language and demonstrated that our compiler correctness theorem is open to composition and intuitive to use with reduced verification complexity through end-to-end verification of non-trivial heterogeneous modules that may freely invoke each other (e.g., mutually recursively).", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632856", + "link": "https://doi.org/10.1145/3632914", "conference_name": "POPL", "authors": [ { - "first_name": "Guannan", - "last_name": "Wei", - "institution": "Purdue University West Lafayette" + "first_name": "Ling", + "last_name": "Zhang", + "institution": "Shanghai Jiao Tong University" }, { - "first_name": "Oliver", - "last_name": "Bračevac", - "institution": "Purdue University West Lafayette" + "first_name": "Yuting", + "last_name": "Wang", + "institution": "Shanghai Jiao Tong University" }, { - "first_name": "Songlin", - "last_name": "Jia", - "institution": "Purdue University West Lafayette" + "first_name": "WU", + "last_name": "Jin-hua", + "institution": "Shanghai Jiao Tong University" }, { - "first_name": "Yuyan", - "last_name": "Bao", - "institution": "Augusta University" + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" }, { - "first_name": "Tiark", - "last_name": "Rompf", - "institution": "Purdue University West Lafayette" + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" } ], - "dblp_key": "journals/pacmpl/WeiBJBR24", + "dblp_key": "journals/pacmpl/ZhangWWKS24", "venue": "popl", "year": 2024 }, @@ -2587,7 +2551,7 @@ "title": "Automatic Parallelism Management", "abstract": "On any modern computer architecture today, parallelism comes with a modest cost, born from the creation and management of threads or tasks. Today, programmers battle this cost by manually optimizing/tuning their codes to minimize the cost of parallelism without harming its benefit, performance. This is a difficult battle: programmers must reason about architectural constant factors hidden behind layers of software abstractions, including thread schedulers and memory managers, and their impact on performance, also at scale. In languages that support higher-order functions, the battle hardens: higher order functions can make it difficult, if not impossible, to reason about the cost and benefits of parallelism. Motivated by these challenges and the numerous advantages of high-level languages, we believe that it has become essential to manage parallelism automatically so as to minimize its cost and maximize its benefit. This is a challenging problem, even when considered on a case-by-case, application-specific basis. But if a solution were possible, then it could combine the many correctness benefits of high-level languages with performance by managing parallelism without the programmer effort needed to ensure performance. This paper proposes techniques for such automatic management of parallelism by combining static (compilation) and run-time techniques. Specifically, we consider the Parallel ML language with task parallelism, and describe a compiler pipeline that embeds “potential parallelism” directly into the call-stack and avoids the cost of task creation by default. We then pair this compilation pipeline with a run-time system that dynamically converts potential parallelism into actual parallel tasks. Together, the compiler and run-time system guarantee that the cost of parallelism remains low without losing its benefit. We prove that our techniques have no asymptotic impact on the work and span of parallel programs and thus preserve their asymptotic properties. We implement the proposed techniques by extending the MPL compiler for Parallel ML and show that it can eliminate the burden of manual optimization while delivering good practical performance.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632880", + "link": "https://doi.org/10.1145/3632880", "conference_name": "POPL", "authors": [ { @@ -2615,12 +2579,63 @@ "venue": "popl", "year": 2024 }, + { + "paper_id": "10.1145/3632855", + "title": "Enriched Presheaf Model of Quantum FPC", + "abstract": "Selinger gave a superoperator model of a first-order quantum programming language and proved that it is fully definable and hence fully abstract. This paper proposes an extension of the superoperator model to higher-order programs based on modules over superoperators or, equivalently, enriched presheaves over the category of superoperators. The enriched presheaf category can be easily proved to be a model of intuitionistic linear logic with cofree exponential, from which one can cave out a model of classical linear logic by a kind of bi-orthogonality construction. Although the structures of an enriched presheaf category are usually rather complex, a morphism in the classical model can be expressed simply as a matrix of completely positive maps. The model inherits many desirable properties from the superoperator model. A conceptually interesting property is that our model has only a state whose “total probability” is bounded by 1, i.e. does not have a state where true and false each occur with probability 2 / 3 . Another convenient property inherited from the superoperator model is a ω CPO-enrichment. Remarkably, our model has a sufficient structure to interpret arbitrary recursive types by the standard domain theoretic technique. We introduce Quantum FPC , a quantum λ -calculus with recursive types, and prove that our model is a fully abstract model of Quantum FPC.", + "date": "2024-01-02", + "link": "https://doi.org/10.1145/3632855", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + }, + { + "first_name": "Kazuyuki", + "last_name": "Asada", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/TsukadaA24", + "venue": "popl", + "year": 2024 + }, + { + "paper_id": "10.1145/3632862", + "title": "The Logical Essence of Well-Bracketed Control Flow", + "abstract": "A program is said to be well-bracketed if every called function must return before its caller can resume execution. This is often the case. Well-bracketedness has been captured semantically as a condition on strategies in fully abstract games models and multiple prior works have studied well-bracketedness by showing correctness/security properties of programs where such properties depend on the well-bracketed nature of control flow. The latter category of prior works have all used involved relational models with explicit state-transition systems capturing the relevant parts of the control flow of the program. In this paper we present the first Hoare-style program logic based on separation logic for reasoning about well-bracketedness and use it to show correctness of well-bracketed programs both directly and also through defining unary and binary logical relations models based on this program logic. All results presented in this paper are formalized on top of the Iris framework and mechanized in the Coq proof assistant.", + "date": "2024-01-02", + "link": "https://doi.org/10.1145/3632862", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Armaël", + "last_name": "Guéneau", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/TimanyGB24", + "venue": "popl", + "year": 2024 + }, { "paper_id": "10.1145/3632877", "title": "Mostly Automated Verification of Liveness Properties for Distributed Protocols with Ranking Functions", "abstract": "Distributed protocols have long been formulated in terms of their safety and liveness properties. Much recent work has focused on automatically verifying the safety properties of distributed protocols, but doing so for liveness properties has remained a challenging, unsolved problem. We present LVR, the first framework that can mostly automatically verify liveness properties for distributed protocols. Our key insight is that most liveness properties for distributed protocols can be reduced to a set of safety properties with the help of ranking functions. Such ranking functions for practical distributed protocols have certain properties that make them straightforward to synthesize, contrary to conventional wisdom. We prove that verifying a liveness property can then be reduced to a simpler problem of verifying a set of safety properties, namely that the ranking function is strictly decreasing and nonnegative for any protocol state transition, and there is no deadlock. LVR automatically synthesizes ranking functions by formulating a parameterized function of integer protocol variables, statically analyzing the lower and upper bounds of the variables as well as how much they can change on each state transition, then feeding the constraints to an SMT solver to determine the coefficients of the ranking function. It then uses an off-the-shelf verification tool to find inductive invariants to verify safety properties for both ranking functions and deadlock freedom. We show that LVR can mostly automatically verify the liveness properties of several distributed protocols, including various versions of Paxos, with limited user guidance.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632877", + "link": "https://doi.org/10.1145/3632877", "conference_name": "POPL", "authors": [ { @@ -2649,164 +2664,149 @@ "year": 2024 }, { - "paper_id": "10.1145/3632914", - "title": "Fully Composable and Adequate Verified Compilation with Direct Refinements between Open Modules", - "abstract": "Verified compilation of open modules (i.e., modules whose functionality depends on other modules) provides a foundation for end-to-end verification of modular programs ubiquitous in contemporary software. However, despite intensive investigation in this topic for decades, the proposed approaches are still difficult to use in practice as they rely on assumptions about the internal working of compilers which make it difficult for external users to apply the verification results. We propose an approach to verified compositional compilation without such assumptions in the setting of verifying compilation of heterogeneous modules written in first-order languages supporting global memory and pointers. Our approach is based on the memory model of CompCert and a new discovery that a Kripke relation with a notion of memory protection can serve as a uniform and composable semantic interface for the compiler passes. By absorbing the rely-guarantee conditions on memory evolution for all compiler passes into this Kripke Memory Relation and by piggybacking requirements on compiler optimizations onto it, we get compositional correctness theorems for realistic optimizing compilers as refinements that directly relate native semantics of open modules and that are ignorant of intermediate compilation processes. Such direct refinements support all the compositionality and adequacy properties essential for verified compilation of open modules. We have applied this approach to the full compilation chain of CompCert with its Clight source language and demonstrated that our compiler correctness theorem is open to composition and intuitive to use with reduced verification complexity through end-to-end verification of non-trivial heterogeneous modules that may freely invoke each other (e.g., mutually recursively).", + "paper_id": "10.1145/3632906", + "title": "Decision and Complexity of Dolev-Yao Hyperproperties", + "abstract": "The formal analysis of cryptographic protocols traditionally focuses on trace and equivalence properties, for which decision procedures in the symbolic (or Dolev-Yao, or DY) model are known. However, many relevant security properties are expressed as DY hyperproperties that involve quantifications over both execution paths and attacker computations (which are constrained by the attacker’s knowledge in the underlying model of computation). DY hyperproperties generalise hyperproperties, for which many decision procedures exist, to the setting of DY models. Unfortunately, the subtle interactions between both forms of quantifications have been an obstacle to lifting decision procedures from hyperproperties to DY hyperproperties. The central contribution of the paper is the first procedure for deciding DY hyperproperties, in the usual setting where the number of protocol sessions is bounded and where the equational theory modelling cryptography is subterm-convergent. We prove that our decision procedure can decide the validity of any hyperproperty in which quantifications over messages are guarded and quantifications over attacker computations are limited to expressing the attacker’s knowledge. We also establish the complexity of the decision problem for several important fragments of the hyperlogic. Further, we illustrate the techniques and scope of our contributions through examples of related hyperproperties.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632914", + "link": "https://doi.org/10.1145/3632906", "conference_name": "POPL", "authors": [ { - "first_name": "Ling", - "last_name": "Zhang", - "institution": "Shanghai Jiao Tong University" - }, - { - "first_name": "Yuting", - "last_name": "Wang", - "institution": "Shanghai Jiao Tong University" - }, - { - "first_name": "WU", - "last_name": "Jin-hua", - "institution": "Shanghai Jiao Tong University" + "first_name": "Itsaka", + "last_name": "Rakotonirina", + "institution": "Max Planck Institute for Security and Privacy" }, { - "first_name": "Jérémie", - "last_name": "Koenig", - "institution": "Yale University" + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" }, { - "first_name": "Zhong", - "last_name": "Shao", - "institution": "Yale University" + "first_name": "Clara", + "last_name": "Schneidewind", + "institution": "Max Planck Institute for Security and Privacy" } ], - "dblp_key": "journals/pacmpl/ZhangWWKS24", + "dblp_key": "journals/pacmpl/RakotonirinaBS24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632883", - "title": "Fusing Direct Manipulations into Functional Programs", - "abstract": "Bidirectional live programming systems (BLP) enable developers to modify a program by directly manipulating the program output, so that the updated program can produce the manipulated output. One state-of-the-art approach to BLP systems is operation-based, which captures the developer's intention of program modifications by taking how the developer manipulates the output into account. The program modifications are usually hard coded for each direct manipulation in these BLP systems, which are difficult to extend. Moreover, to reflect the manipulations to the source program, these BLP systems trace the modified output to appropriate code fragments and perform corresponding code transformations. Accordingly, they require direct manipulation users be aware of the source code and how it is changed, making “direct” manipulation (on output) be “indirect”. In this paper, we resolve this problem by presenting a novel operation-based framework for bidirectional live programming, which can automatically fuse direct manipulations into the source code, thus supporting code-insensitive direct manipulations. Firstly, we design a simple but expressive delta language DM capable of expressing common direct manipulations for output values. Secondly, we present a fusion algorithm that propagates direct manipulations into the source functional programs and applies them to the constants whenever possible; otherwise, the algorithm embeds manipulations into the “proper positions” of programs. We prove the correctness of the fusion algorithm that the updated program executes to get the manipulated output. To demonstrate the expressiveness of DM and the effectiveness of our fusion algorithm, we have implemented FuseDM, a prototype SVG editor that supports GUI-based operations for direct manipulation, and successfully designed 14 benchmark examples starting from blank code using FuseDM.", + "paper_id": "10.1145/3632911", + "title": "VST-A: A Foundationally Sound Annotation Verifier", + "abstract": "Program verifiers for imperative languages such as C may be annotation-based , in which assertions and invariants are put into source files and then checked, or tactic-based, where proof scripts separate from programs are interactively developed in a proof assistant such as Coq. Annotation verifiers have been more automated and convenient, but some interactive verifiers have richer assertion languages and formal proofs of soundness. We present VST-A, an annotation verifier that uses the rich assertion language of VST, leverages the formal soundness proof of VST, but allows users to describe functional correctness proofs intuitively by inserting assertions. VST-A analyzes control flow graphs, decomposes every C function into control flow paths between assertions, and reduces program verification problems into corresponding straightline Hoare triples . Compared to existing foundational program verification tools like VST and Iris, in VST-A such decompositions and reductions can nonstructural, which makes VST-A more flexible to use. VST-A’s decomposition and reduction is defined in Coq, proved sound in Coq, and computed call-by-value in Coq. The soundness proof for reduction is totally logical, independent of the complicated semantic model (and soundness proof) of VST’s Hoare triple. Because of the rich assertion language, not all reduced proof goals can be automatically checked, but the system allows users to prove residual proof goals using the full power of the Coq proof assistant.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632883", + "link": "https://doi.org/10.1145/3632911", "conference_name": "POPL", "authors": [ { - "first_name": "Xing", - "last_name": "Zhang", - "institution": "Peking University" - }, - { - "first_name": "Ruifeng", - "last_name": "Xie", - "institution": "Peking University" + "first_name": "Litao", + "last_name": "Zhou", + "institution": "Shanghai Jiao Tong University" }, { - "first_name": "Guanchen", - "last_name": "Guo", - "institution": "Peking University" + "first_name": "Jianxing", + "last_name": "Qin", + "institution": "Shanghai Jiao Tong University" }, { - "first_name": "Xiao", - "last_name": "He", - "institution": "University of Science and Technology Beijing" + "first_name": "Qinshi", + "last_name": "Wang", + "institution": "Princeton University" }, { - "first_name": "Tao", - "last_name": "Zan", - "institution": "Longyan University" + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" }, { - "first_name": "Zhenjiang", - "last_name": "Hu", - "institution": "Peking University" + "first_name": "Qinxiang", + "last_name": "Cao", + "institution": "Shanghai Jiao Tong University" } ], - "dblp_key": "journals/pacmpl/ZhangXGHZH24", + "dblp_key": "journals/pacmpl/ZhouQWAC24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632910", - "title": "Total Type Error Localization and Recovery with Holes", - "abstract": "Type systems typically only define the conditions under which an expression is well-typed, leaving ill-typed expressions formally meaningless. This approach is insufficient as the basis for language servers driving modern programming environments, which are expected to recover from simultaneously localized errors and continue to provide a variety of downstream semantic services. This paper addresses this problem, contributing the first comprehensive formal account of total type error localization and recovery: the marked lambda calculus. In particular, we define a gradual type system for expressions with marked errors, which operate as non-empty holes, together with a total procedure for marking arbitrary unmarked expressions. We mechanize the metatheory of the marked lambda calculus in Agda and implement it, scaled up, as the new basis for Hazel, a full-scale live functional programming environment with, uniquely, no meaningless editor states. The marked lambda calculus is bidirectionally typed, so localization decisions are systematically predictable based on a local flow of typing information. Constraint-based type inference can bring more distant information to bear in discovering inconsistencies but this notoriously complicates error localization. We approach this problem by deploying constraint solving as a type-hole-filling layer atop this gradual bidirectionally typed core. Errors arising from inconsistent unification constraints are localized exclusively to type and expression holes, i.e., the system identifies unfillable holes using a system of traced provenances, rather than localized in an ad hoc manner to particular expressions. The user can then interactively shift these errors to particular downstream expressions by selecting from suggested partially consistent type hole fillings, which returns control back to the bidirectional system. We implement this type hole inference system in Hazel.", + "paper_id": "10.1145/3632856", + "title": "Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic Programs", + "abstract": "Fueled by the success of Rust, many programming languages are adding substructural features to their type systems. The promise of tracking properties such as lifetimes and sharing is tremendous, not just for low-level memory management, but also for controlling higher-level resources and capabilities. But so are the difficulties in adapting successful techniques from Rust to higher-level languages, where they need to interact with other advanced features, especially various flavors of functional and type-level abstraction. What would it take to bring full-fidelity reasoning about lifetimes and sharing to mainstream languages? Reachability types are a recent proposal that has shown promise in scaling to higher-order but monomorphic settings, tracking aliasing and separation on top of a substrate inspired by separation logic. However, naive extensions on top of the prior reachability type system λ * with type polymorphism and/or precise reachability polymorphism are unsound, making λ * unsuitable for adoption in real languages. Combining reachability and type polymorphism that is precise, sound, and parametric remains an open challenge. This paper presents a rethinking of the design of reachability tracking and proposes new polymorphic reachability type systems. We introduce a new freshness qualifier to indicate variables whose reachability sets may grow during evaluation steps. The new system tracks variables reachable in a single step and computes transitive closures only when necessary, thus preserving chains of reachability over known variables that can be refined using substitution. These ideas yield the simply-typed λ ◆ -calculus with precise lightweight, i.e. , quantifier-free, reachability polymorphism, and the F < : ◆ -calculus with bounded parametric polymorphism over types and reachability qualifiers, paving the way for making true tracking of lifetimes and sharing practical for mainstream languages. We prove type soundness and the preservation of separation property in Coq. We discuss various applications ( e.g. , safe capability programming), possible effect system extensions, and compare our system with Scala’s capture types.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632910", + "link": "https://doi.org/10.1145/3632856", "conference_name": "POPL", "authors": [ { - "first_name": "Eric", - "last_name": "Zhao", - "institution": "University of Michigan" - }, - { - "first_name": "Raef", - "last_name": "Maroof", - "institution": "University of Michigan" + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" }, { - "first_name": "A Ambedkar", - "last_name": "Dukkipati", - "institution": "University of Michigan" + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "Purdue University West Lafayette" }, { - "first_name": "Andrew", - "last_name": "Blinn", - "institution": "University of Michigan" + "first_name": "Songlin", + "last_name": "Jia", + "institution": "Purdue University West Lafayette" }, { - "first_name": "Zhiyi", - "last_name": "Pan", - "institution": "University of Michigan" + "first_name": "Yuyan", + "last_name": "Bao", + "institution": "Augusta University" }, { - "first_name": "Cyrus", - "last_name": "Omar", - "institution": "University of Michigan" + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" } ], - "dblp_key": "journals/pacmpl/ZhaoMDBPO24", + "dblp_key": "journals/pacmpl/WeiBJBR24", "venue": "popl", "year": 2024 }, { - "paper_id": "10.1145/3632911", - "title": "VST-A: A Foundationally Sound Annotation Verifier", - "abstract": "Program verifiers for imperative languages such as C may be annotation-based , in which assertions and invariants are put into source files and then checked, or tactic-based, where proof scripts separate from programs are interactively developed in a proof assistant such as Coq. Annotation verifiers have been more automated and convenient, but some interactive verifiers have richer assertion languages and formal proofs of soundness. We present VST-A, an annotation verifier that uses the rich assertion language of VST, leverages the formal soundness proof of VST, but allows users to describe functional correctness proofs intuitively by inserting assertions. VST-A analyzes control flow graphs, decomposes every C function into control flow paths between assertions, and reduces program verification problems into corresponding straightline Hoare triples . Compared to existing foundational program verification tools like VST and Iris, in VST-A such decompositions and reductions can nonstructural, which makes VST-A more flexible to use. VST-A’s decomposition and reduction is defined in Coq, proved sound in Coq, and computed call-by-value in Coq. The soundness proof for reduction is totally logical, independent of the complicated semantic model (and soundness proof) of VST’s Hoare triple. Because of the rich assertion language, not all reduced proof goals can be automatically checked, but the system allows users to prove residual proof goals using the full power of the Coq proof assistant.", + "paper_id": "10.1145/3632883", + "title": "Fusing Direct Manipulations into Functional Programs", + "abstract": "Bidirectional live programming systems (BLP) enable developers to modify a program by directly manipulating the program output, so that the updated program can produce the manipulated output. One state-of-the-art approach to BLP systems is operation-based, which captures the developer's intention of program modifications by taking how the developer manipulates the output into account. The program modifications are usually hard coded for each direct manipulation in these BLP systems, which are difficult to extend. Moreover, to reflect the manipulations to the source program, these BLP systems trace the modified output to appropriate code fragments and perform corresponding code transformations. Accordingly, they require direct manipulation users be aware of the source code and how it is changed, making “direct” manipulation (on output) be “indirect”. In this paper, we resolve this problem by presenting a novel operation-based framework for bidirectional live programming, which can automatically fuse direct manipulations into the source code, thus supporting code-insensitive direct manipulations. Firstly, we design a simple but expressive delta language DM capable of expressing common direct manipulations for output values. Secondly, we present a fusion algorithm that propagates direct manipulations into the source functional programs and applies them to the constants whenever possible; otherwise, the algorithm embeds manipulations into the “proper positions” of programs. We prove the correctness of the fusion algorithm that the updated program executes to get the manipulated output. To demonstrate the expressiveness of DM and the effectiveness of our fusion algorithm, we have implemented FuseDM, a prototype SVG editor that supports GUI-based operations for direct manipulation, and successfully designed 14 benchmark examples starting from blank code using FuseDM.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632911", + "link": "https://doi.org/10.1145/3632883", "conference_name": "POPL", "authors": [ { - "first_name": "Litao", - "last_name": "Zhou", - "institution": "Shanghai Jiao Tong University" + "first_name": "Xing", + "last_name": "Zhang", + "institution": "Peking University" }, { - "first_name": "Jianxing", - "last_name": "Qin", - "institution": "Shanghai Jiao Tong University" + "first_name": "Ruifeng", + "last_name": "Xie", + "institution": "Peking University" }, { - "first_name": "Qinshi", - "last_name": "Wang", - "institution": "Princeton University" + "first_name": "Guanchen", + "last_name": "Guo", + "institution": "Peking University" }, { - "first_name": "Andrew W.", - "last_name": "Appel", - "institution": "Princeton University" + "first_name": "Xiao", + "last_name": "He", + "institution": "University of Science and Technology Beijing" }, { - "first_name": "Qinxiang", - "last_name": "Cao", - "institution": "Shanghai Jiao Tong University" + "first_name": "Tao", + "last_name": "Zan", + "institution": "Longyan University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" } ], - "dblp_key": "journals/pacmpl/ZhouQWAC24", + "dblp_key": "journals/pacmpl/ZhangXGHZH24", "venue": "popl", "year": 2024 }, @@ -2815,7 +2815,7 @@ "title": "Sound Gradual Verification with Symbolic Execution", "abstract": "Gradual verification, which supports explicitly partial specifications and verifies them with a combination of static and dynamic checks, makes verification more incremental and provides earlier feedback to developers. While an abstract, weakest precondition-based approach to gradual verification was previously proven sound, the approach did not provide sufficient guidance for implementation and optimization of the required run-time checks. More recently, gradual verification was implemented using symbolic execution techniques, but the soundness of the approach (as with related static checkers based on implicit dynamic frames) was an open question. This paper puts practical gradual verification on a sound footing with a formalization of symbolic execution, optimized run-time check generation, and run time execution. We prove our approach is sound; our proof also covers a core subset of the Viper tool, for which we are aware of no previous soundness result. Our formalization enabled us to find a soundness bug in an implemented gradual verification tool and describe the fix necessary to make it sound.", "date": "2024-01-02", - "link": "https://dl.acm.org/doi/10.1145/3632927", + "link": "https://doi.org/10.1145/3632927", "conference_name": "POPL", "authors": [ { diff --git a/data/pl_conferences/popl/2025.json b/data/pl_conferences/popl/2025.json new file mode 100644 index 0000000..597da19 --- /dev/null +++ b/data/pl_conferences/popl/2025.json @@ -0,0 +1,2494 @@ +[ + { + "paper_id": "10.1145/3704909", + "title": "Grove: A Bidirectionally Typed Collaborative Structure Editor Calculus", + "abstract": "Version control systems typically rely on a patch language , heuristic patch synthesis algorithms like diff , and three-way merge algorithms . Standard patch languages and merge algorithms often fail to identify conflicts correctly when there are multiple edits to one line of code or code is relocated. This paper introduces Grove, a collaborative structure editor calculus that eliminates patch synthesis and three-way merge algorithms entirely. Instead, patches are derived directly from the log of the developer’s edit actions and all edits commute, i.e. the repository state forms a commutative replicated data type (CmRDT). To handle conflicts that can arise due to code relocation, the core datatype in Grove is a labeled directed multi-graph with uniquely identified vertices and edges. All edits amount to edge insertion and deletion, with deletion being permanent. To support tree-based editing, we define a decomposition from graphs into groves , which are a set of syntax trees with conflicts–including local, relocation, and unicyclic relocation conflicts–represented explicitly using holes and references between trees. Finally, we define a type error localization system for groves that enjoys a totality property, i.e. all editor states in Grove are statically meaningful, so developers can use standard editor services while working to resolve these explicitly represented conflicts. The static semantics is defined as a bidirectional marking system in line with recent work, with gradual typing employed to handle situations where errors and conflicts prevent type determination. We then layer on a unification-based type inference system to opportunistically fill type holes and fail gracefully when no solution exists. We mechanize the metatheory of Grove using the Agda theorem prover. We implement these ideas as the Grove Workbench , which generates the necessary data structures and algorithms in OCaml given a syntax tree specification.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704909", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "National University of Singapore" + }, + { + "first_name": "Eric", + "last_name": "Griffis", + "institution": "University of Michigan" + }, + { + "first_name": "Tod S.", + "last_name": "Porter", + "institution": "University of Michigan" + }, + { + "first_name": "Sundara Vishnu", + "last_name": "Satish", + "institution": "University of Michigan" + }, + { + "first_name": "Eric", + "last_name": "Zhao", + "institution": "University of Michigan" + }, + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/AdamsGPSZO25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704915", + "title": "Tail Modulo Cons, OCaml, and Relational Separation Logic", + "abstract": "Common functional languages incentivize tail-recursive functions, as opposed to general recursive functions that consume stack space and may not scale to large inputs. This distinction occasionally requires writing functions in a tail-recursive style that may be more complex and slower than the natural, non-tail-recursive definition. This work describes our implementation of the tail modulo constructor (TMC) transformation in the OCaml compiler, an optimization that provides stack-efficiency for a larger class of functions — tail-recursive modulo constructors — which includes in particular the natural definition of List.map and many similar recursive data-constructing functions. We prove the correctness of this program transformation in a simplified setting — a small untyped calculus — that captures the salient aspects of the OCaml implementation. Our proof is mechanized in the Coq proof assistant, using the Iris base logic. An independent contribution of our work is an extension of the Simuliris approach to define simulation relations that support different calling conventions. To our knowledge, this is the first use of Simuliris to prove the correctness of a compiler transformation.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704915", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Clément", + "last_name": "Allain", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Frédéric", + "last_name": "Bour", + "institution": "" + }, + { + "first_name": "Basile", + "last_name": "Clément", + "institution": "" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/AllainBCPS25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704865", + "title": "TensorRight: Automated Verification of Tensor Graph Rewrites", + "abstract": "Tensor compilers, essential for generating efficient code for deep learning models across various applications, employ tensor graph rewrites as one of the key optimizations. These rewrites optimize tensor computational graphs with the expectation of preserving semantics for tensors of arbitrary rank and size. Despite this expectation, to the best of our knowledge, there does not exist a fully automated verification system to prove the soundness of these rewrites for tensors of arbitrary rank and size. Previous works, while successful in verifying rewrites with tensors of concrete rank, do not provide guarantees in the unbounded setting. To fill this gap, we introduce T ensor R ight , the first automatic verification system that can verify tensor graph rewrites for input tensors of arbitrary rank and size. We introduce a core language, T ensor R ight DSL, to represent rewrite rules using a novel axis definition, called aggregated-axis , which allows us to reason about an unbounded number of axes. We achieve unbounded verification by proving that there exists a bound on tensor ranks, under which bounded verification of all instances implies the correctness of the rewrite rule in the unbounded setting. We derive an algorithm to compute this rank using the denotational semantics of T ensor R ight DSL. T ensor R ight employs this algorithm to generate a finite number of bounded-verification proof obligations, which are then dispatched to an SMT solver using symbolic execution to automatically verify the correctness of the rewrite rules. We evaluate T ensor R ight ’s verification capabilities by implementing rewrite rules present in XLA ’s algebraic simplifier. The results demonstrate that T ensor R ight can prove the correctness of 115 out of 175 rules in their full generality, while the closest automatic, bounded -verification system can express only 18 of these rules.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704865", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jai", + "last_name": "Arora", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Sirui", + "last_name": "Lu", + "institution": "University of Washington" + }, + { + "first_name": "Devansh", + "last_name": "Jain", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Tianfan", + "last_name": "Xu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Farzin", + "last_name": "Houshmand", + "institution": "Google (United States)" + }, + { + "first_name": "Phitchaya Mangpo", + "last_name": "Phothilimthana", + "institution": "Google (United States)" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Praveen", + "last_name": "Narayanan", + "institution": "Google (United States)" + }, + { + "first_name": "Karthik", + "last_name": "Murthy", + "institution": "Google (United States)" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Google (United States)" + }, + { + "first_name": "Amit", + "last_name": "Sabne", + "institution": "Google (United States)" + }, + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/AroraLJXHPLNMBSM25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704879", + "title": "Fulminate: Testing CN Separation-Logic Specifications in C", + "abstract": "Separation logic has become an important tool for formally capturing and reasoning about the ownership patterns of imperative programs, originally for paper proof, and now the foundation for industrial static analyses and multiple proof tools. However, there has been very little work on program testing of separationlogic specifications in concrete execution. At first sight, separation-logic formulas are hard to evaluate in reasonable time, with their implicit quantification over heap splittings, and other explicit existentials. In this paper we observe that a restricted fragment of separation logic, adopted in the CN proof tool to enable predictable proof automation, also has a natural and readable computational interpretation, that makes it practically usable in runtime testing. We discuss various design issues and develop this as a C + CN source to C source translation, Fulminate. This adds checks – including ownership checks and ownership transfer – for C code annotated with CN pre- and post-conditions; we demonstrate this on nontrivial examples, including the allocator from a production hypervisor. We formalise our runtime ownership testing scheme, showing (and proving) how its reified ghost state correctly captures ownership passing, in a semantics for a small C-like language.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704879", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ranjita", + "last_name": "Banerjee", + "institution": "University of Cambridge" + }, + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Dhruv C.", + "last_name": "Makwana", + "institution": "University of Cambridge" + }, + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/BanerjeeMMPKS25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704891", + "title": "Interaction Equivalence", + "abstract": "Contextual equivalence is the de facto standard notion of program equivalence. A key theorem is that contextual equivalence is an equational theory . Making contextual equivalence more intensional, for example taking into account the time cost of the computation, seems a natural refinement. Such a change, however, does not induce an equational theory, for an apparently essential reason: cost is not invariant under reduction. In the paradigmatic case of the untyped λ -calculus, we introduce interaction equivalence . Inspired by game semantics, we observe the number of interaction steps between terms and contexts but–crucially–ignore their internal steps. We prove that interaction equivalence is an equational theory and characterize it as B , the well-known theory induced by Böhm tree equality. It is the first observational characterization of B obtained without enriching the discriminating power of contexts with extra features such as non-determinism. To prove our results, we develop interaction-based refinements of the Böhm-out technique and of intersection types.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704891", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "École Polytechnique" + }, + { + "first_name": "Adrienne", + "last_name": "Lancelot", + "institution": "École Polytechnique" + }, + { + "first_name": "Giulio", + "last_name": "Manzonetto", + "institution": "Université Paris Cité" + }, + { + "first_name": "Gabriele", + "last_name": "Vanoni", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "journals/pacmpl/AccattoliLMV25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704846", + "title": "Inference Plans for Hybrid Particle Filtering", + "abstract": "Advanced probabilistic programming languages (PPLs) using hybrid particle filtering combine symbolic exact inference and Monte Carlo methods to improve inference performance. These systems use heuristics to partition random variables within the program into variables that are encoded symbolically and variables that are encoded with sampled values, and the heuristics are not necessarily aligned with the developer’s performance evaluation metrics. In this work, we present inference plans , a programming interface that enables developers to control the partitioning of random variables during hybrid particle filtering. We further present Siren , a new PPL that enables developers to use annotations to specify inference plans the inference system must implement. To assist developers with statically reasoning about whether an inference plan can be implemented, we present an abstract-interpretation-based static analysis for Siren for determining inference plan satisfiability . We prove the analysis is sound with respect to Siren ’s semantics. Our evaluation applies inference plans to three different hybrid particle filtering algorithms on a suite of benchmarks. It shows that the control provided by inference plans enables speed ups of 1.76 x on average and up to 206 x to reach a target accuracy, compared to the inference plans implemented by default heuristics; the results also show that inference plans improve accuracy by 1.83 x on average and up to 595 x with less or equal runtime, compared to the default inference plans. We further show that our static analysis is precise in practice, identifying all satisfiable inference plans in 27 out of the 33 benchmark-algorithm evaluation settings.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704846", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ellie Y.", + "last_name": "Cheng", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Eric", + "last_name": "Atkinson", + "institution": "Binghamton University" + }, + { + "first_name": "Guillaume", + "last_name": "Baudart", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Louis", + "last_name": "Mandel", + "institution": "Alliance for Safe Kids" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ChengABMC25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704902", + "title": "Avoiding Signature Avoidance in ML Modules with Zippers", + "abstract": "We present ZipML , a new path-based type system for a fully fledged ML-module language that avoids the signature avoidance problem. This is achieved by introducing floating fields , which act as additional fields of a signature, invisible to the user but still accessible to the typechecker. In practice, they are handled as zippers on signatures, and can be seen as a lightweight extension of existing signatures. Floating fields allow to delay the resolution of instances of the signature avoidance problem as long as possible or desired. Since they do not exist at runtime, they can be simplified along type equivalence, and dropped once they became unreachable. We give rewriting rules for the simplification of floating fields without loss of type-sharing and present an algorithm that implements them. Remaining floating fields may fully disappear at signature ascription, especially in the presence of toplevel interfaces. Residual unavoidable floating fields can be shown to the user as a last resort, improving the quality of error messages. Besides, ZipML implements early and lazy strengthening, as well as lazy inlining of definitions, preventing duplication of signatures inside the typechecker. The correctness of the type system is proved by elaboration into M ω , which has itself been proved sound by translation to F ω . ZipML has been designed to be an improvement over OCaml that could be retrofitted into the existing implementation.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704902", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Clément", + "last_name": "Blaudeau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gabriel", + "last_name": "Radanne", + "institution": "Université Claude Bernard Lyon 1" + } + ], + "dblp_key": "journals/pacmpl/BlaudeauRR25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704905", + "title": "Automated Program Refinement: Guide and Verify Code Large Language Model with Refinement Calculus", + "abstract": "Recently, the rise of code-centric Large Language Models (LLMs) has reshaped the software engineering world with low-barrier tools like Copilot that can easily generate code. However, there is no correctness guarantee for the code generated by LLMs, which suffer from the hallucination problem, and their output is fraught with risks. Besides, the end-to-end process from specification to code through LLMs is a non-transparent and uncontrolled black box. This opacity makes it difficult for users to understand and trust the generated code. Addressing these challenges is both necessary and critical. In contrast, program refinement transforms high-level specification statements into executable code while preserving correctness. Traditional tools for program refinement are primarily designed for formal methods experts and lack automation and extensibility. We apply program refinement to guide LLM and validate the LLM-generated code while transforming refinement into a more accessible and flexible framework. To initiate this vision, we propose Refine4LLM, an approach that aims to:(1) Formally refine the specifications, (2) Automatically prompt and guide the LLM using refinement calculus, (3) Interact with the LLM to generate the code, (4) Verify that the generated code satisfies the constraints, thus guaranteeing its correctness, (5) Learn and build more advanced refinement laws to extend the refinement calculus. We evaluated Refine4LLM against the state-of-the-art baselines on program refinement and LLMs benchmarks. The experiment results show that Refine4LLM can efficiently generate more robust code and reduce the time for refinement and verification.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704905", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yufan", + "last_name": "Cai", + "institution": "Ningbo University" + }, + { + "first_name": "Zhé", + "last_name": "Hóu", + "institution": "Griffith University" + }, + { + "first_name": "David", + "last_name": "Sanán", + "institution": "Singapore Institute of Technology" + }, + { + "first_name": "Xiaokun", + "last_name": "Luan", + "institution": "Peking University" + }, + { + "first_name": "Yun", + "last_name": "Lin", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Jun", + "last_name": "Sun", + "institution": "Singapore Management University" + }, + { + "first_name": "Jin Song", + "last_name": "Dong", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/CaiHSLLSD25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704861", + "title": "Algebras for Deterministic Computation Are Inherently Incomplete", + "abstract": "Kleene Algebra with Tests (KAT) provides an elegant algebraic framework for describing non-deterministic finite-state computations. Using a small finite set of non-deterministic programming constructs (sequencing, non-deterministic choice, and iteration) it is able to express all non-deterministic finite state control flow over a finite set of primitives. It is natural to ask whether there exists a similar finite set of constructs that can capture all deterministic computation. We show that this is not the case. More precisely, the deterministic fragment of KAT is not generated by any finite set of regular control flow operations. This generalizes earlier results about the expressivity of the traditional control flow operations, i.e., sequential composition, if-then-else and while.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704861", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Balder ten", + "last_name": "Cate", + "institution": "Amsterdam University of the Arts" + }, + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "Leiden University" + } + ], + "dblp_key": "journals/pacmpl/CateK25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704873", + "title": "Linear and Non-linear Relational Analyses for Quantum Program Optimization", + "abstract": "The phase folding optimization is a circuit optimization used in many quantum compilers as a fast and effective way of reducing the number of high-cost gates in a quantum circuit. However, existing formulations of the optimization rely on an exact, linear algebraic representation of the circuit, restricting the optimization to being performed on straightline quantum circuits or basic blocks in a larger quantum program. We show that the phase folding optimization can be re-cast as an affine relation analysis , which allows the direct application of classical techniques for affine relations to extend phase folding to quantum programs with arbitrarily complicated classical control flow including nested loops and procedure calls. Through the lens of relational analysis, we show that the optimization can be powered-up by substituting other classical relational domains, particularly ones for non-linear relations which are useful in analyzing circuits involving classical arithmetic. To increase the precision of our analysis and infer non-linear relations from gate sets involving only linear operations – such as Clifford+ t – we show that the sum-over-paths technique can be used to extract precise symbolic transition relations for straightline circuits. Our experiments show that our methods are able to generate and use non-trivial loop invariants for quantum program optimization, as well as achieve some optimizations of common circuits which were previously attainable only by hand.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704873", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Amy", + "institution": "Simon Fraser University" + }, + { + "first_name": "Joseph", + "last_name": "Lunderville", + "institution": "Simon Fraser University" + } + ], + "dblp_key": "journals/pacmpl/AmyL25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704844", + "title": "BiSikkel: A Multimode Logical Framework in Agda", + "abstract": "Embedding Multimode Type Theory (MTT) as a library enables the usage of additional reasoning principles in off-the-shelf proof assistants without risking soundness or compatibility. Moreover, by interpreting embedded MTT terms in an internally constructed model of MTT, we can extract programs and proofs to the meta language and obtain interoperability between the embedded language and the metalanguage. The existing Sikkel library for Agda achieves this for Multimode Simple Type Theory (MSTT) with an internal presheaf model of dependent MTT. In this work, we add, on top of the simply-typed layer, a logical framework in which users can write multimode proofs about multimode Sikkel programs, still in an off-the-shelf proof assistant. To this end, we carve out of MTT a new multimode logical framework µLF over MSTT and implement it on top of Sikkel, interpreting both in the existing internal model. In the process, we further extend and improve the original codebase for each of the three layers (syntax, semantics and extraction) of Sikkel. We demonstrate the use of µLF by proving some properties about functions manipulating guarded streams and by implementing an example involving parametricity predicates.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704844", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joris", + "last_name": "Ceulemans", + "institution": "KU Leuven" + }, + { + "first_name": "Andreas", + "last_name": "Nuyts", + "institution": "KU Leuven" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/CeulemansND25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704848", + "title": "The Duality of λ-Abstraction", + "abstract": "In this paper, we develop and study the following perspective - just as higher-order functions give exponentials, higher-order continuations give coexponentials. From this, we design a language that combines exponentials and coexponentials, producing a duality of lambda abstraction. We formalise this language by giving an extension of a call-by-value simply-typed lambda-calculus with covalues, coabstraction, and coapplication. We develop the semantics of this language using the axiomatic structure of continuations, which we use to produce an equational theory, that gives a complete axiomatisation of control effects. We give a computational interpretation to this language using speculative execution and backtracking, and use this to derive the classical control operators and computational interpretation of classical logic, and encode common patterns of control flow using continuations. By dualising functional completeness, we further develop duals of first-order arrow languages using coexponentials. Finally, we discuss the implementation of this duality as control operators in programming, and develop some applications.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704848", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vikraman", + "last_name": "Choudhury", + "institution": "Centre Inria d'Université Côte d'Azur" + }, + { + "first_name": "Simon J.", + "last_name": "Gay", + "institution": "University of Glasgow" + } + ], + "dblp_key": "journals/pacmpl/ChoudhuryG25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704876", + "title": "A Quantitative Probabilistic Relational Hoare Logic", + "abstract": "We introduce eRHL , a program logic for reasoning about relational expectation properties of pairs of probabilistic programs. eRHL is quantitative, i.e., its pre- and post-conditions take values in the extended non-negative reals. Thanks to its quantitative assertions, eRHL overcomes randomness alignment restrictions from prior logics, including pRHL , a popular relational program logic used to reason about security of cryptographic constructions, and apRHL , a variant of pRHL for differential privacy. As a result, eRHL is the first relational probabilistic program logic to be supported by non-trivial soundness and completeness results for all almost surely terminating programs. We show that eRHL is sound and complete with respect to program equivalence, statistical distance, and differential privacy. We also show that every pRHL judgment is valid iff it is provable in eRHL . We showcase the practical benefits of eRHL with examples that are beyond reach of pRHL and apRHL .", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704876", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Avanzini", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Davide", + "last_name": "Davoli", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/AvanziniBDG25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704893", + "title": "Barendregt Convenes with Knaster and Tarski: Strong Rule Induction for Syntax with Bindings", + "abstract": "This paper is a contribution to the meta-theory of systems featuring syntax with bindings, such as λ-calculi and logics. It provides a general criterion that targets inductively defined rule-based systems , enabling for them inductive proofs that leverage Barendregt’s variable convention of keeping the bound and free variables disjoint. It improves on the state of the art by (1) achieving high generality in the style of Knaster-Tarski fixed point definitions (as opposed to imposing syntactic formats), (2) capturing systems of interest without modifications, and (3) accommodating infinitary syntax and non-equivariant predicates.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704893", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jan van", + "last_name": "Brügge", + "institution": "Heriot-Watt University" + }, + { + "first_name": "James", + "last_name": "McKinna", + "institution": "Heriot-Watt University" + }, + { + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "University of Sheffield" + }, + { + "first_name": "Dmitriy", + "last_name": "Traytel", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/BruggeMPT25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704868", + "title": "Verifying Quantum Circuits with Level-Synchronized Tree Automata", + "abstract": "We present a new method for the verification of quantum circuits based on a novel symbolic representation of sets of quantum states using level-synchronized tree automata (LSTAs). LSTAs extend classical tree automata by labeling each transition with a set of choices , which are then used to synchronize subtrees of an accepted tree. Compared to the traditional tree automata, LSTAs have an incomparable expressive power while maintaining important properties, such as closure under union and intersection, and decidable language emptiness and inclusion. We have developed an efficient and fully automated symbolic verification algorithm for quantum circuits based on LSTAs. The complexity of supported gate operations is at most quadratic, dramatically improving the exponential worst-case complexity of an earlier tree automata-based approach. Furthermore, we show that LSTAs are a promising model for parameterized verification , i.e., verifying the correctness of families of circuits with the same structure for any number of qubits involved, which principally lies beyond the capabilities of previous automated approaches.We implemented this method as a C++ tool and compared it with three symbolic quantum circuit verifiers and two simulators on several benchmark examples. The results show that our approach can solve problems with sizes orders of magnitude larger than the state of the art.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704868", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Y. C.", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "Yu‐Fang", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" + }, + { + "first_name": "Ondřej", + "last_name": "Lengál", + "institution": "Brno University of Technology" + }, + { + "first_name": "Jyun-Ao", + "last_name": "Lin", + "institution": "National Taipei University of Technology" + }, + { + "first_name": "Fang-Yi", + "last_name": "Lo", + "institution": "Academia Sinica" + }, + { + "first_name": "Wei-Lun", + "last_name": "Tsai", + "institution": "Academia Sinica" + } + ], + "dblp_key": "journals/pacmpl/AbdullaCCHLLLT25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704894", + "title": "Bluebell: An Alliance of Relational Lifting and Independence for Probabilistic Reasoning", + "abstract": "We present BlueBell , a program logic for reasoning about probabilistic programs where unary and relational styles of reasoning come together to create new reasoning tools. Unary-style reasoning is very expressive and is powered by foundational mechanisms to reason about probabilistic behavior like independence and conditioning . The relational style of reasoning, on the other hand, naturally shines when the properties of interest compare the behavior of similar programs (e.g. when proving differential privacy) managing to avoid having to characterize the output distributions of the individual programs. So far, the two styles of reasoning have largely remained separate in the many program logics designed for the deductive verification of probabilistic programs. In BlueBell , we unify these styles of reasoning through the introduction of a new modality called “joint conditioning” that can encode and illuminate the rich interaction between conditional independence and relational liftings ; the two powerhouses from the two styles of reasoning.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704894", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jialu", + "last_name": "Bao", + "institution": "Cornell University" + }, + { + "first_name": "Emanuele", + "last_name": "D’Osualdo", + "institution": "University of Konstanz" + }, + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/BaoDF25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704883", + "title": "Flexible Type-Based Resource Estimation in Quantum Circuit Description Languages", + "abstract": "We introduce a type system for the Quipper language designed to derive upper bounds on the size of the circuits produced by the typed program. This size can be measured according to various metrics, including width , depth and gate count , but also variations thereof obtained by considering only some wire types or some gate kinds. The key ingredients for achieving this level of flexibility are effects and refinement types, both relying on indices , that is, generic arithmetic expressions whose operators are interpreted differently depending on the target metric. The approach is shown to be correct through logical predicates, under reasonable assumptions about the chosen resource metric. This approach is empirically evaluated through the QuRA tool, showing that, in many cases, inferring tight bounds is possible in a fully automatic way.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704883", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Colledan", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/ColledanL25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704871", + "title": "Abstract Operational Methods for Call-by-Push-Value", + "abstract": "Levy’s call-by-push-value is a comprehensive programming paradigm that combines elements from functional and imperative programming, supports computational effects and subsumes both call-by-value and call-byname evaluation strategies. In the present work, we develop modular methods to reason about program equivalence in call-by-push-value, and in fine-grain call-by-value, which is a popular lightweight call-by-value sublanguage of the former. Our approach is based on the fundamental observation that presheaf categories of sorted sets are suitable universes to model call-by-(push)-value languages, and that natural, coalgebraic notions of program equivalence such as applicative similarity and logical relations can be developed within. Starting from this observation, we formalize fine-grain call-by-value and call-by-push-value in the higher-order abstract GSOS framework, reduce their key congruence properties to simple syntactic conditions by leveraging existing theory and argue that introducing changes to either language incurs minimal proof overhead.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704871", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sergey", + "last_name": "Goncharov", + "institution": "University of Birmingham" + }, + { + "first_name": "Stelios", + "last_name": "Tsampas", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Henning", + "last_name": "Urbat", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + } + ], + "dblp_key": "journals/pacmpl/GoncharovTU25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704854", + "title": "Program Analysis via Multiple Context Free Language Reachability", + "abstract": "Context-free language (CFL) reachability is a standard approach in static analyses, where the analysis question (e.g., is there a dataflow from x to y ?) is phrased as a language reachability problem on a graph G wrt a CFL L . However, CFLs lack the expressiveness needed for high analysis precision. On the other hand, common formalisms for context-sensitive languages are too expressive, in the sense that the corresponding reachability problem becomes undecidable. Are there useful context-sensitive language-reachability models for static analysis? In this paper, we introduce Multiple Context-Free Language (MCFL) reachability as an expressive yet tractable model for static program analysis. MCFLs form an infinite hierarchy of mildly context sensitive languages parameterized by a dimension d and a rank r . Larger d and r yield progressively more expressive MCFLs, offering tunable analysis precision. We showcase the utility of MCFL reachability by developing a family of MCFLs that approximate interleaved Dyck reachability, a common but undecidable static analysis problem. Given the increased expressiveness of MCFLs, one natural question pertains to their algorithmic complexity, i.e., how fast can MCFL reachability be computed ? We show that the problem takes O n 2 d + 1 time on a graph of n nodes when r = 1 , and O n d r + 1 time when r > 1 . Moreover, we show that when r = 1 , even the simpler membership problem has a lower bound of n 2 d based on the Strong Exponential Time Hypothesis, while reachability for d = 1 has a lower bound of n 3 based on the combinatorial Boolean Matrix Multiplication Hypothesis. Thus, for", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704854", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giovanna Kobus", + "last_name": "Conrado", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Adam Husted", + "last_name": "Kjelstrøm", + "institution": "Aarhus University" + }, + { + "first_name": "Jaco van de", + "last_name": "Pol", + "institution": "Aarhus University" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/ConradoKPP25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704852", + "title": "Calculational Design of Hyperlogics by Abstract Interpretation", + "abstract": "We design various logics for proving hyper properties of iterative programs by application of abstract interpretation principles. In part I, we design a generic, structural, fixpoint abstract interpreter parameterized by an algebraic abstract domain describing finite and infinite computations that can be instantiated for various operational, denotational, or relational program semantics. Considering semantics as program properties, we define a post algebraic transformer for execution properties (e.g. sets of traces) and a Post algebraic transformer for semantic (hyper) properties (e.g. sets of sets of traces), we provide corresponding calculuses as instances of the generic abstract interpreter, and we derive under and over approximation hyperlogics. In part II, we define exact and approximate semantic abstractions, and show that they preserve the mathematical structure of the algebraic semantics, the collecting semantics post, the hyper collecting semantics Post, and the hyperlogics. Since proofs by sound and complete hyperlogics require an exact characterization of the program semantics within the proof, we consider in part III abstractions of the (hyper) semantic properties that yield simplified proof rules. These abstractions include the join, the homomorphic, the elimination, the principal ideal, the order ideal, the frontier order ideal, and the chain limit algebraic abstractions, as well as their combinations, that lead to new algebraic generalizations of hyperlogics, including the ∀ ∃ * , ∀ ∀ * , and ∃ ∀ * hyperlogics.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704852", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" + }, + { + "first_name": "Jeffery", + "last_name": "Wang", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/CousotW25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704856", + "title": "Formal Foundations for Translational Separation Logic Verifiers", + "abstract": "Program verification tools are often implemented as front-end translations of an input program into an intermediate verification language (IVL) such as Boogie, GIL, Viper, or Why3. The resulting IVL program is then verified using an existing back-end verifier. A soundness proof for such a translational verifier needs to relate the input program and verification logic to the semantics of the IVL, which in turn needs to be connected with the verification logic implemented in the back-end verifiers. Performing such proofs is challenging due to the large semantic gap between the input and output programs and logics, especially for complex verification logics such as separation logic. This paper presents a formal framework for reasoning about translational separation logic verifiers. At its center is a generic core IVL that captures the essence of different separation logics. We define its operational semantics and formally connect it to two different back-end verifiers, which use symbolic execution and verification condition generation, resp. Crucially, this semantics uses angelic non-determinism to enable the application of different proof search algorithms and heuristics in the back-end verifiers. An axiomatic semantics for the core IVL simplifies reasoning about the front-end translation by performing essential proof steps once and for all in the equivalence proof with the operational semantics rather than for each concrete front-end translation. We illustrate the usefulness of our formal framework by instantiating our core IVL with elements of Viper and connecting it to two Viper back-ends as well as a front-end for concurrent separation logic. All our technical results have been formalized in Isabelle/HOL, including the core IVL and its semantics, the semantics of two back-ends for a subset of Viper, and all proofs.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704856", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thibault", + "last_name": "Dardinier", + "institution": "ETH Zurich" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "ETH Zurich" + }, + { + "first_name": "G.", + "last_name": "Parthasarathy", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "University of British Columbia" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/DardinierSPSM25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704889", + "title": "Coinductive Proofs for Temporal Hyperliveness", + "abstract": "Temporal logics for hyperproperties have recently emerged as an expressive specification technique for relational properties of reactive systems. While the model checking problem for such logics has been widely studied, there is a scarcity of deductive proof systems for temporal hyperproperties. In particular, hyperproperties with an alternation of universal and existential quantification over system executions are rarely supported. In this paper, we focus on hyperproperties of the form ∀ * ∃ * ψ , where ψ is a safety relation. We show that hyperproperties of this class - which includes many hyperliveness properties of interest - can always be approximated by coinductive relations. This enables intuitive proofs by coinduction. Based on this observation, we define HyCo ( Hy perproperties, Co inductively), a mechanized framework to reason about temporal hyperproperties within the Coq proof assistant. We detail the construction of HyCo, provide a proof of its soundness, and exemplify its use by applying it to the verification of reactive systems modeled as imperative programs with nondeterminism and I/O.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704889", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Correnson", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Bernd", + "last_name": "Finkbeiner", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "journals/pacmpl/CorrensonF25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704863", + "title": "Denotational Semantics of Gradual Typing using Synthetic Guarded Domain Theory", + "abstract": "Gradually typed programming languages, which allow for soundly mixing static and dynamically typed programming styles, present a strong challenge for metatheorists. Even the simplest sound gradually typed languages feature at least recursion and errors, with realistic languages featuring furthermore runtime allocation of memory locations and dynamic type tags. Further, the desired metatheoretic properties of gradually typed languages have become increasingly sophisticated: validity of type-based equational reasoning as well as the relational property known as graduality. Many recent works have tackled verifying these properties, but the resulting mathematical developments are highly repetitive and tedious, with few reusable theorems persisting across different developments. In this work, we present a new denotational semantics for gradual typing developed using guarded domain theory. Guarded domain theory combines the generality of step-indexed logical relations for modeling advanced programming features with the modularity and reusability of denotational semantics. We demonstrate the feasibility of this approach with a model of a simple gradually typed lambda calculus and prove the validity of beta-eta equality and the graduality theorem for the denotational model. This model should provide the basis for a reusable mathematical theory of gradually typed program semantics. Finally, we have mechanized most of the core theorems of our development in Guarded Cubical Agda, a recent extension of Agda with support for the guarded recursive constructions we use.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704863", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eric", + "last_name": "Giovannini", + "institution": "University of Michigan" + }, + { + "first_name": "Tingting", + "last_name": "Ding", + "institution": "University of Michigan" + }, + { + "first_name": "Max S.", + "last_name": "New", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/GiovanniniDN25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704859", + "title": "Data Race Freedom à la Mode", + "abstract": "We present DRFCaml, an extension of OCaml’s type system that guarantees data race freedom for multithreaded OCaml programs while retaining backward compatibility with existing sequential OCaml code. We build on recent work of Lorenzen et al., who extend OCaml with modes that keep track of locality, uniqueness, and affinity. We introduce two new mode axes, contention and portability , which record whether data has been shared or can be shared between multiple threads. Although this basic type-and-mode system has limited expressive power by itself, it does let us express APIs for capsules , regions of memory whose access is controlled by a unique ghost key, and reader-writer locks , which allow a thread to safely acquire partial or full ownership of a key. We show that this allows complex data structures (which may involve aliasing and mutable state) to be safely shared between threads. We formalize the complete system and establish its soundness by building a semantic model of it in the Iris program logic on top of the Rocq proof assistant.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704859", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aïna Linn", + "last_name": "Georges", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Benjamin", + "last_name": "Peters", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Laila", + "last_name": "Elbeheiry", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Leo", + "last_name": "White", + "institution": "" + }, + { + "first_name": "Stephen", + "last_name": "Dolan", + "institution": "" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "" + }, + { + "first_name": "Chris", + "last_name": "Casinghino", + "institution": "Jane Street (United States)" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/GeorgesPEWDECPD25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704906", + "title": "RELINCHE: Automatically Checking Linearizability under Relaxed Memory Consistency", + "abstract": "Concurrent libraries implement standard data structures, such as stacks and queues, in a thread-safe manner, typically providing an atomic interface to the data structure. They serve as building blocks for concurrent programs, and incorporate advanced synchronization mechanisms to achieve good performance. In this paper, we are concerned with the problem of verifying correctness of such libraries under weak memory consistency in a fully automated fashion. To this end, we develop R elinche , a model checker that verifies atomicity and functional correctness of a concurrent library implementation in any client program that invokes the library methods up to some bounded number of times. Our tool establishes refinement between the concurrent library implementation and its atomic specification in a fully parallel client, which it then strengthens to capture all possible other (more constrained) clients of the library. R elinche scales sufficiently to verify correctness of standard concurrent library benchmarks for all client programs with up to 7–9 library method invocations, and finds minimal counterexamples with 4-7 method calls of non-trivial linearizability bugs due to weak memory consistency.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704906", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Golovin", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "ETH Zurich" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/GolovinKV25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704867", + "title": "Do You Even Lift? Strengthening Compiler Security Guarantees against Spectre Attacks", + "abstract": "Mainstream compilers implement different countermeasures to prevent specific classes of speculative execution attacks. Unfortunately, these countermeasures either lack formal guarantees or come with proofs restricted to speculative semantics capturing only a subset of the speculation mechanisms supported by modern CPUs, thereby limiting their practical applicability. Ideally, these security proofs should target a speculative semantics capturing the effects of all speculation mechanisms implemented in modern CPUs. However, this is impractical and requires new secure compilation proofs to support additional speculation mechanisms. In this paper, we address this problem by proposing a novel secure compilation framework that allows lifting the security guarantees provided by Spectre countermeasures from weaker speculative semantics (ignoring some speculation mechanisms) to stronger ones (accounting for the omitted mechanisms) without requiring new secure compilation proofs. Using our lifting framework, we performed the most comprehensive security analysis of Spectre countermeasures implemented in mainstream compilers to date. Our analysis spans 9 different countermeasures against 5 classes of Spectre attacks, which we proved secure against a speculative semantics accounting for 5 different speculation mechanisms. Our analysis highlights that fence-based and retpoline-based countermeasures can be securely lifted to the strongest speculative semantics under study. In contrast, countermeasures based on speculative load hardening cannot be securely lifted to semantics supporting indirect jump speculation.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704867", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xaver", + "last_name": "Fabian", + "institution": "University of Trento" + }, + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "University of Trento" + }, + { + "first_name": "Marco", + "last_name": "Guarnieri", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Michael", + "last_name": "Backes", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "journals/pacmpl/FabianPGB25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704853", + "title": "Axe 'Em: Eliminating Spurious States with Induction Axioms", + "abstract": "First-order logic has proved to be a versatile and expressive tool as the basis of abstract modeling languages. Used to verify complex systems with unbounded domains, such as heap-manipulating programs and distributed protocols, first-order logic, and specifically uninterpreted functions and quantifiers, strike a balance between expressiveness and amenity to automation. However, first-order logic semantics may differ in important ways from the intended semantics of the modeled system, due to the inability to distinguish between finite and infinite first-order structures, for example, or the undefinability of well-founded relations in first-order logic. This semantic gap may give rise to spurious states and unreal behaviors, which only exist as an artifact of the first-order abstraction and impede the verification process. In this paper we take a step towards bridging this semantic gap. We present an approach for soundly refining the first-order abstraction according to either well-founded semantics or finite-domain semantics, utilizing induction axioms for an abstract order relation, a common primitive in verification. We first formalize sound axiom schemata for each of the aforementioned semantics, based on well-founded induction. Second, we show how to use spurious counter-models, which are necessarily infinite, to guide the instantiation of these axiom schemata. Finally, we present a sound and complete reduction of well-founded semantics and finite-domain semantics to standard semantics in the recently discovered Ordered Self-Cycle (OSC) fragment of first-order logic, and prove that satisfiability under these semantics is decidable in OSC. We implement a prototype tool to evaluate our approach, and test it on various examples where spurious models arise, from the domains of distributed protocols and heap-manipulating programs. Our tool quickly finds the necessary axioms to refine the semantics, and successfully completes the verification process, eliminating the spurious system states that blocked progress.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704853", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neta", + "last_name": "Elad", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/EladS25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704877", + "title": "Approximate Relational Reasoning for Higher-Order Probabilistic Programs", + "abstract": "Properties such as provable security and correctness for randomized programs are naturally expressed relationally as approximate equivalences. As a result, a number of relational program logics have been developed to reason about such approximate equivalences of probabilistic programs. However, existing approximate relational logics are mostly restricted to first-order programs without general state. In this paper we develop Approxis, a higher-order approximate relational separation logic for reasoning about approximate equivalence of programs written in an expressive ML-like language with discrete probabilistic sampling, higher-order functions, and higher-order state. The Approxis logic recasts the concept of error credits in the relational setting to reason about relational approximation, which allows for expressive notions of modularity and composition, a range of new approximate relational rules, and an internalization of a standard limiting argument for showing exact probabilistic equivalences by approximation. We also use Approxis to develop a logical relation model that quantifies over error credits, which can be used to prove exact contextual equivalence . We demonstrate the flexibility of our approach on a range of examples, including the PRP/PRF switching lemma, IND$-CPA security of an encryption scheme, and a collection of rejection samplers. All of the results have been mechanized in the Coq proof assistant and the Iris separation logic framework.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704877", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philipp G.", + "last_name": "Haselwarter", + "institution": "Aarhus University" + }, + { + "first_name": "Kwing Hei", + "last_name": "Li", + "institution": "Aarhus University" + }, + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "New York University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/HaselwarterLAGTB25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704888", + "title": "Translation of Temporal Logic for Efficient Infinite-State Reactive Synthesis", + "abstract": "Infinite-state reactive synthesis has attracted significant attention in recent years, which has led to the emergence of novel symbolic techniques for solving infinite-state games. Temporal logics featuring variables over infinite domains offer an expressive high-level specification language for infinite-state reactive systems. Currently, the only way to translate these temporal logics into symbolic games is by naively encoding the specification to use techniques designed for the Boolean case. An inherent limitation of this approach is that it results in games in which the semantic structure of the temporal and first-order constraints present in the formula is lost. There is a clear need for techniques that leverage this information in the translation process to speed up solving the generated games. In this work, we propose the first approach that addresses this gap. Our technique constructs a monitor incorporating first-order and temporal reasoning at the formula level, enriching the constructed game with semantic information that leads to more efficient solving. We demonstrate that thanks to this, our method outperforms the state-of-the-art techniques across a range of benchmarks.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704888", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philippe", + "last_name": "Heim", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Rayna", + "last_name": "Dimitrova", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "journals/pacmpl/HeimD25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704882", + "title": "The Best of Abstract Interpretations", + "abstract": "We study “ the best of abstract interpretations ”, that is, the best possible abstract interpretations of programs. Abstract interpretations are inductively defined by composing abstract transfer functions for the basic commands, such as assignments and Boolean guards. However, abstract interpretation is not compositional: even if the abstract transfer functions of the basic commands are the best possible ones on a given abstract domain A this does not imply that the whole inductive abstract interpretation of a program p is still the best in A . When this happens we are in the optimal scenario where the abstract interpretation of p coincides with the abstraction of the concrete interpretation of p . Our main contributions are threefold. Firstly, we investigate the computability properties of the class of programs having the best possible abstract interpretation on a fixed abstract domain A . We show that this class is, in general, not straightforward and not recursive. Secondly, we prove the impossibility of achieving the best possible abstract interpretation of any program p either by an effective compilation of p or by minimally refining or simplifying the abstract domain A . These results show that the program property of having the best possible abstract interpretation is not trivial and, in general, hard to achieve. We then show how to prove that the abstract interpretation of a program is indeed the best possible one. To this aim, we put forward a program logic parameterized on an abstract domain A which infers triples p r e ] A p p o s t ] A . These triples encode that the inductive abstract interpretation of p on A with abstract input p r e ∈ A gives p o s t ∈ A as abstract output and this is the best possible in A .", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704882", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Arizona" + }, + { + "first_name": "Francesco", + "last_name": "Ranzato", + "institution": "University of Padua" + } + ], + "dblp_key": "journals/pacmpl/GiacobazziR25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704866", + "title": "A Modal Deconstruction of Löb Induction", + "abstract": "We present a novel analysis of the fundamental Löb induction principle from guarded recursion. Taking advantage of recent work in modal type theory and univalent foundations, we derive Löb induction from a simpler and more conceptual set of primitives. We then capitalize on these insights to present Gatsby, the first guarded type theory capturing the rich modal structure of the topos of trees alongside Löb induction without immediately precluding canonicity or normalization. We show that Gatsby can recover many prior approaches to guarded recursion and use its additional power to improve on prior examples. We crucially rely on homotopical insights and Gatsby constitutes a new application of univalent foundations to the theory of programming languages.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704866", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Gratzer", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/Gratzer25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704842", + "title": "Qurts: Automatic Quantum Uncomputation by Affine Types with Lifetime", + "abstract": "Uncomputation is a feature in quantum programming that allows the programmer to discard a value without losing quantum information, and that allows the compiler to reuse resources. Whereas quantum information has to be treated linearly by the type system, automatic uncomputation enables the programmer to treat it affinely to some extent. Automatic uncomputation requires a substructural type system between linear and affine, a subtlety that has only been captured by existing languages in an ad hoc way. We extend the Rust type system to the quantum setting to give a uniform framework for automatic uncomputation called Qurts (pronounced quartz). Specifically, we parameterise types by lifetimes, permitting them to be affine during their lifetime, while being restricted to linear use outside their lifetime. We also provide two operational semantics: one based on classical simulation, and one that does not depend on any specific uncomputation strategy.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704842", + "conference_name": "POPL", + "authors": [ + { + "first_name": "K", + "last_name": "Hirata", + "institution": "Kyoto University" + }, + { + "first_name": "Chris", + "last_name": "Heunen", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/HirataH25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704851", + "title": "A Dependent Type Theory for Meta-programming with Intensional Analysis", + "abstract": "In this paper, we introduce DeLaM , a dependent layered modal type theory which enables meta-programming in Martin-Löf type theory (MLTT) with recursion principles on open code. DeLaM includes three layers: the layer of static syntax objects of MLTT without any computation, the layer of pure MLTT with the computational behaviors, and the meta-programming layer, which extends MLTT with support for quoting an open MLTT code object, composing, and analyzing open code using recursion. We can also execute a code object at the meta-programming layer. The expressive power strictly increases as we move up in a given layer. In particular, while code objects only describe static syntax, we allow computation at the MLTT and meta-programming layer. As a result, DeLaM provides a dependently typed foundation for meta-programming that supports both type-safe code generation and code analysis. We prove the weak normalization of DeLaM and the decidability of convertibility using Kripke logical relations.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704851", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jason Z. S.", + "last_name": "Hu", + "institution": "McGill University" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "journals/pacmpl/HuP25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704892", + "title": "Formalising Graph Algorithms with Coinduction", + "abstract": "Graphs and their algorithms are fundamental to computer science, but they can be difficult to formalise, especially in dependently-typed proof assistants. Part of the problem is that graphs aren’t as well-behaved as inductive data types like trees or lists; another problem is that graph algorithms (at least in standard presentations) often aren’t structurally recursive. Instead of trying to find a way to make graphs behave like other familiar inductive types, this paper builds a formal theory of graphs and their algorithms where graphs are treated as coinductive structures from the beginning. We formalise our theory in Agda. This approach has its own unique challenges: Agda is more comfortable with induction than coinduction. Additionally, our formalisation relies on quotient types, which tend to make coinduction even harder to deal with. Nonetheless, we develop reusable techniques to deal with these difficulties, and the simple graph representation at the heart of our work turns out to be flexible, powerful, and formalisable.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704892", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Donnacha Oisín", + "last_name": "Kidney", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/KidneyW25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704907", + "title": "Bidirectional Higher-Rank Polymorphism with Intersection and Union Types", + "abstract": "Modern mainstream programming languages, such as TypeScript, Flow, and Scala, have polymorphic type systems enriched with intersection and union types. These languages implement variants of bidirectional higher-rank polymorphic type inference, which was previously studied mostly in the context of functional programming. However, existing type inference implementations lack solid theoretical foundations when dealing with non-structural subtyping and intersection and union types, which were not studied before. In this paper, we study bidirectional higher-rank polymorphic type inference with explicit type applications, and intersection and union types and demonstrate that these features have non-trivial interactions. We first present a type system, described by a bidirectional specification, with good theoretical properties and a sound, complete, and decidable algorithm. This is helpful to identify a class of types that can always be inferred. We also explore variants incorporating practical features, such as handling records and inferring a larger class of types, which align better with real-world implementations. Though some variants no longer have a complete algorithm, they still enhance the expressiveness of the type system. To ensure rigor, all results are formalized in the Coq proof assistant.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704907", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shengyi", + "last_name": "Jiang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Chen", + "last_name": "Cui", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/JiangCO25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704875", + "title": "On Decidable and Undecidable Extensions of Simply Typed Lambda Calculus", + "abstract": "The decidability of the reachability problem for finitary PCF has been used as a theoretical basis for fully automated verification tools for functional programs. The reachability problem, however, often becomes undecidable for a slight extension of finitary PCF with side effects, such as exceptions, algebraic effects, and references, which hindered the extension of the above verification tools for supporting functional programs with side effects. In this paper, we first give simple proofs of the undecidability of four extensions of finitary PCF, which would help us understand and analyze the source of undecidability. We then focus on an extension with references, and give a decidable fragment using a type system. To our knowledge, this is the first non-trivial decidable fragment that features higher-order recursive functions containing reference cells.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704875", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "journals/pacmpl/Kobayashi25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704897", + "title": "VeriRT: An End-to-End Verification Framework for Real-Time Distributed Systems", + "abstract": "Safety-critical systems are often designed as real-time distributed systems. Despite the need for strong guarantees of safety and reliability in these systems, applying formal verification methods to real-time distributed systems at the implementation level has faced significant technical challenges. In this paper, we present VeriRT , an end-to-end formal verification framework that closes the formal gap between high-level abstract timed specifications and low-level implementations for real-time distributed systems.Within the framework, we establish a theoretical foundation for constructing formal timed operational semantics by integrating conventional operational semantics and low-level timing assumptions, along with principles for reasoning about their timed behaviors against abstract specifications. We leverage CompCert’s correctness proofs to guarantee the correctness of the assembly implementation of real-time distributed systems. We provide two case studies on realistic real-time systems. All the results are formalized in Coq.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704897", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Y. K.", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Sung-Hwan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Yonghyun", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/KimLKH25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704860", + "title": "A Verified Foreign Function Interface between Coq and C", + "abstract": "One can write dependently typed functional programs in Coq, and prove them correct in Coq; one can write low-level programs in C, and prove them correct with a C verification tool. We demonstrate how to write programs partly in Coq and partly in C, and interface the proofs together. The Verified Foreign Function Interface (VeriFFI) guarantees type safety and correctness of the combined program. It works by translating Coq function types (and constructor types) along with Coq functional models into VST function-specifications; if the user can prove in VST that the C functions satisfy those specs, then the C functions behave according to the user-specified functional models (even though the C implementation might be very different) and the proofs of Coq functions that call the C code can rely on that behavior. To achieve this translation, we employ a novel, hybrid deep/shallow description of Coq dependent types.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704860", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joomy", + "last_name": "Korkut", + "institution": "Bloomberg (United States)" + }, + { + "first_name": "Kathrin", + "last_name": "Stark", + "institution": "Heriot-Watt University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/KorkutSA25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704890", + "title": "Compositional Imprecise Probability: A Solution from Graded Monads and Markov Categories", + "abstract": "Imprecise probability is concerned with uncertainty about which probability distributions to use. It has applications in robust statistics and machine learning. We look at programming language models for imprecise probability. Our desiderata are that we would like our model to support all kinds of composition, categorical and monoidal; in other words, guided by dataflow diagrams. Another equivalent perspective is that we would like a model of synthetic probability in the sense of Markov categories. Imprecise probability can be modelled in various ways, with the leading monad-based approach using convex sets of probability distributions. This model is not fully compositional because the monad involved is not commutative, meaning it does not have a proper monoidal structure. In this work, we provide a new fully compositional account. The key idea is to name the non-deterministic choices. To manage the renamings and disjointness of names, we use graded monads. We show that the resulting compositional model is maximal and relate it with the earlier monadic approach, proving that we obtain tighter bounds on the uncertainty.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704890", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jack", + "last_name": "Liell-Cock", + "institution": "University of Oxford" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/LiellCockS25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704843", + "title": "Consistency of a Dependent Calculus of Indistinguishability", + "abstract": "The Dependent Calculus of Indistinguishability (DCOI) uses dependency tracking to identify irrelevant arguments and uses indistinguishability during type conversion to enable proof irrelevance, supporting run-time and compile-time irrelevance with the same uniform mechanism. DCOI also internalizes reasoning about indistinguishability through the use of a propositional equality type indexed by an observer level. As DCOI is a pure type system, prior work establishes only its syntactic type safety, justifying its use as the basis for a programming language with dependent types. However, it was not clear whether any instance of this system would be suitable for use as a type theory for theorem proving. Here, we identify a suitable instance DCOI ω , which has an infinite predicative universe hierarchy. We show that DCOI ω is logically consistent, normalizing, and that type conversion is decidable. We have mechanized all results using the Coq proof assistant.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704843", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yiyun", + "last_name": "Liu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jonathan", + "last_name": "Chan", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LiuCW25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704881", + "title": "Archmage and CompCertCast: End-to-End Verification Supporting Integer-Pointer Casting", + "abstract": "Although there have been many approaches for developing formal memory models that support integerpointer casts, previous approaches share the drawback that they are not designed for end-to-end verification ,failing to support some important source-level coding patterns, justify some backend optimizations, or lack a source-level logic for program verification. This paper presents Archmage, a framework for integer-pointer casting designed for end-to-end verification,supporting a wide range of source-level coding patterns, backend optimizations, and a formal notion of out-ofmemory. To facilitate end-to-end verification via Archmage, we also present two systems based on Archmage: CompCertCast, an extension of CompCert with Archmage to bring a full verified compilation chain to integer-pointer casting programs, and Archmage logic, a source-level logic for reasoning about integerpointer casts. We design CompCertCast such that the overhead from formally supporting integer-pointer casts is mitigated, and illustrate the effectiveness of Archmage logic by verifying an xor-based linked-list implementation, Together, our paper presents the first practical end-to-end verification chain for programs containing integer-pointer casts.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704881", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Y.-M.", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "J.", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Jinwoo", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Tae‐Hoon", + "last_name": "Yoon", + "institution": "Seoul National University" + }, + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/KimCLKYSH25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704899", + "title": "Sound and Complete Proof Rules for Probabilistic Termination", + "abstract": "Deciding termination is a fundamental problem in the analysis of probabilistic imperative programs. We consider the qualitative and quantitative probabilistic termination problems for an imperative programming model with discrete probabilistic choice and demonic bounded nondeterminism. The qualitative question asks if the program terminates almost-surely, no matter how nondeterminism is resolved. The quantitative question asks for a bound on the probability of termination. Despite a long and rich literature on the topic, no sound and relatively complete proof systems were known for these problems. In this paper, we provide sound and relatively complete proof rules for proving qualitative and quantitative termination in the assertion language of arithmetic. Our rules use variant functions as measures of distances to termination as well as supermartingales that restrain the growth of these variants almost-surely. Our completeness result shows how to construct suitable supermartingale and variant functions from an almost-surely terminating program. We also show that proofs of termination in many existing proof systems can be transformed to proofs in our system, pointing to its applicability in practice. As an application of our proof rule, we show an explicit proof of almost-sure termination for the two-dimensional random walker.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704899", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "V. R.", + "last_name": "Sathiyanarayana", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/MajumdarS25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704845", + "title": "Flo: A Semantic Foundation for Progressive Stream Processing", + "abstract": "Streaming systems are present throughout modern applications, processing continuous data in real-time. Existing streaming languages have a variety of semantic models and guarantees that are often incompatible. Yet all these languages are considered “streaming”–what do they have in common? In this paper, we identify two general yet precise semantic properties: streaming progress and eager execution. Together, they ensure that streaming outputs are deterministic and kept fresh with respect to streaming inputs. We formally define these properties in the context of Flo, a parameterized streaming language that abstracts over dataflow operators and the underlying structure of streams. It leverages a lightweight type system to distinguish bounded streams, which allow operators to block on termination, from unbounded ones. Furthermore, Flo provides constructs for dataflow composition and nested graphs with cycles. To demonstrate the generality of our properties, we show how key ideas from representative streaming and incremental computation systems—Flink, LVars, and DBSP—have semantics that can be modeled in Flo and guarantees that map to our properties.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704845", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shadaj", + "last_name": "Laddad", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Joseph M.", + "last_name": "Hellerstein", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mae", + "last_name": "Milano", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/LaddadCHM25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704840", + "title": "MimIR: An Extensible and Type-Safe Intermediate Representation for the DSL Age", + "abstract": "Traditional compilers, designed for optimizing low-level code, fall short when dealing with modern, computation-heavy applications like image processing, machine learning, or numerical simulations. Optimizations should understand the primitive operations of the specific application domain and thus happen on that level. Domain-specific languages (DSLs) fulfill these requirements. However, DSL compilers reinvent the wheel over and over again as standard optimizations, code generators, and general infrastructure & boilerplate code must be reimplemented for each DSL compiler. This paper presents MImIR, an extensible, higher-order intermediate representation. At its core, MImIR is a pure type system and, hence, a form of a typed lambda calculus. Developers can declare the signatures of new (domain-specific) operations, called axioms . An axiom can be the declaration of a function, a type constructor, or any other entity with a possibly polymorphic, polytypic, and/or dependent type. This way, developers can extend MImIR at any low or high level and bundle them in a plugin . Plugins extend the compiler and take care of optimizing and lowering the plugins' axioms. We show the expressiveness and effectiveness of MImIR in three case studies: Low-level plugins that operate at the same level of abstraction as LLVM, a regular-expression matching plugin, and plugins for linear algebra and automatic differentiation. We show that in all three studies, MImIR produces code that has state-of-the-art performance.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704840", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roland", + "last_name": "Leißa", + "institution": "University of Mannheim" + }, + { + "first_name": "Marcel", + "last_name": "Ullrich", + "institution": "Saarland University" + }, + { + "first_name": "Joachim", + "last_name": "Meyer", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "journals/pacmpl/LeissaUMH25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704885", + "title": "Generic Refinement Types", + "abstract": "We present Generic Refinement Types : a way to write modular higher-order specifications that abstract invariants over function contracts, while preserving automatic SMT-decidable verification. We show how generic refinements let us write a variety of modular higher-order specifications, including specifications for Rust’s traits which abstract over the concrete refinements that hold for different trait implementations. We formalize generic refinements in a core calculus and show how to synthesize the generic instantiations algorithmically at usage sites via a combination of syntactic unification and constraint solving. We give semantics to generic refinements via the intuition that they correspond to ghost parameters , and we formalize this intuition via a type-preserving translation into the polymorphic contract calculus to establish the soundness of generic refinements. Finally, we evaluate generic refinements by implementing them in F luk and using it for two case studies. First, we show how generic refinements let us write modular specifications for Rust’s vector indexing API that lets us statically verify the bounds safety of a variety of vector-manipulating benchmarks from the literature. Second, we use generic refinements to refine Rust’s diesel ORM library to track the semantics of the database queries issued by client applications, and hence, statically enforce data-dependent access-control policies in several database-backed web applications.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704885", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nico", + "last_name": "Lehmann", + "institution": "University of California San Diego" + }, + { + "first_name": "Cole", + "last_name": "Kurashige", + "institution": "University of California San Diego" + }, + { + "first_name": "Nikhil", + "last_name": "Akiti", + "institution": "University of California San Diego" + }, + { + "first_name": "Niroop", + "last_name": "Krishnakumar", + "institution": "University of California San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/LehmannKAKJ25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704911", + "title": "Model Checking C/C++ with Mixed-Size Accesses", + "abstract": "State-of-the-art model checkers employing dynamic partial order reduction (DPOR) can verify concurrent programs under a wide range of memory models such as sequential consistency (SC), total store order (TSO), release-acquire (RA), and the repaired C11 memory model (RC11) in an optimal and memory-efficient fashion. Unfortunately, these DPOR techniques cannot be applied in an optimal fashion to programs with mixed-sized accesses (MSA), where atomic instructions access different (sets of) bytes belonging to the same word. Such patterns naturally arise in real life code with C/C++ union types, and are even used in a concurrent setting. In this paper, we introduce Mixer , an optimal DPOR algorithm for MSA programs that allows (multi-byte) reads to be revisited by multiple writes together. We have implemented Mixer in the GenMC model checker, enabling (for the first time) the automatic verification of C/C++ code with mixed-size accesses. Our results also extend to the more general case of transactional programs provided that the set of read accesses performed by a transaction can be dynamically overapproximated at the beginning of the transaction.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704911", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Iason", + "last_name": "Marmanis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "ETH Zurich" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/MarmanisKV25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704862", + "title": "Simple Linear Loops: Algebraic Invariants and Applications", + "abstract": "The automatic generation of loop invariants is a fundamental challenge in software verification. While this task is undecidable in general, it is decidable for certain restricted classes of programs. This work focuses on invariant generation for (branching-free) loops with a single linear update. Our primary contribution is a polynomial-space algorithm that computes the strongest algebraic invariant for simple linear loops, generating all polynomial equations that hold among program variables across all reachable states. The key to achieving our complexity bounds lies in mitigating the blow-up associated with variable elimination and Gröbner basis computation, as seen in prior works. Our procedure runs in polynomial time when the number of program variables is fixed. We examine various applications of our results on invariant generation, focusing on invariant verification and loop synthesis. The invariant verification problem investigates whether a polynomial ideal defining an algebraic set serves as an invariant for a given linear loop. We show that this problem is coNP-complete and lies in PSPACE when the input ideal is given in dense or sparse representations, respectively. In the context of loop synthesis, we aim to construct a loop with an infinite set of reachable states that upholds a specified algebraic property as an invariant. The strong synthesis variant of this problem requires the construction of loops for which the given property is the strongest invariant. In terms of hardness, synthesising loops over integers (or rationals) is as hard as Hilbert’s Tenth problem (or its analogue over the rationals). When the constants of the output are constrained to bit-bounded rational numbers, we demonstrate that loop synthesis and its strong variant are both decidable in PSPACE, and in NP when the number of program variables is fixed.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704862", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rida Ait El", + "last_name": "Manssour", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "George", + "last_name": "Kenison", + "institution": "Liverpool John Moores University" + }, + { + "first_name": "Mahsa", + "last_name": "Shirmohammadi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Anton", + "last_name": "Varonka", + "institution": "TU Wien" + } + ], + "dblp_key": "journals/pacmpl/ManssourKSV25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704870", + "title": "The Decision Problem for Regular First Order Theories", + "abstract": "The Entscheidungsproblem , or the classical decision problem, asks whether a given formula of first-order logic is satisfiable. In this work, we consider an extension of this problem to regular first-order theories , i.e., (infinite) regular sets of formulae. Building on the elegant classification of syntactic classes as decidable or undecidable for the classical decision problem, we show that some classes (specifically, the EPR and Gurevich classes), which are decidable in the classical setting, become undecidable for regular theories. On the other hand, for each of these classes, we identify a subclass that remains decidable in our setting, leaving a complete classification as a challenge for future work. Finally, we observe that our problem generalises prior work on automata-theoretic verification of uninterpreted programs and propose a semantic class of existential formulae for which the problem is decidable.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704870", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + }, + { + "first_name": "David", + "last_name": "Mestel", + "institution": "Maastricht University" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MathurMV25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704849", + "title": "Finite-Choice Logic Programming", + "abstract": "Logic programming, as exemplified by datalog, defines the meaning of a program as its unique smallest model: the deductive closure of its inference rules. However, many problems call for an enumeration of models that vary along some set of choices while maintaining structural and logical constraints—there is no single canonical model. The notion of stable models for logic programs with negation has successfully captured programmer intuition about the set of valid solutions for such problems, giving rise to a family of programming languages and associated solvers known as answer set programming. Unfortunately, the definition of a stable model is frustratingly indirect, especially in the presence of rules containing free variables. We propose a new formalism, finite-choice logic programming, that uses choice, not negation, to admit multiple solutions. Finite-choice logic programming contains all the expressive power of the stable model semantics, gives meaning to a new and useful class of programs, and enjoys a least-fixed-point interpretation over a novel domain. We present an algorithm for exploring the solution space and prove it correct with respect to our semantics. Our implementation, the Dusa logic programming language, has performance that compares favorably with state-of-the-art answer set solvers and exhibits more predictable scaling with problem size.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704849", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chris", + "last_name": "Martens", + "institution": "Northeastern University" + }, + { + "first_name": "Robert J.", + "last_name": "Simmons", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Arntzenius", + "institution": "PDI (United States)" + } + ], + "dblp_key": "journals/pacmpl/MartensSA25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704908", + "title": "Relaxed Memory Concurrency Re-executed", + "abstract": "Defining a formal model for concurrency in programming languages that addresses conflicting requirements from programmers, compilers, and architectures has been a long-standing research question. It is widely believed that traditional axiomatic per-execution models that reason about individual executions do not suffice to address these conflicting requirements. Consequently, several multi-execution models were proposed that reason about multiple executions together. Although multi-execution models were major breakthroughs in satisfying several desired properties, these models are complicated, challenging to adapt to existing language specifications given in per-execution style, and they are typically not friendly to automated reasoning tools. In response, we propose a re-execution-based memory model (XMM). Debunking the beliefs around per-execution and multi-execution models, XMM is (almost) a per-execution model. XMM reasons about individual executions, but unlike traditional per-execution models, it relates executions by a re-execution principle. As such, the memory consistency axioms and the out-of-order re-execution mechanics are orthogonal in XMM, allowing to use it as a semantic framework parameterized by a given axiomatic memory model. We instantiated the XMM framework for the RC20 language model, and proved that the resulting model XC20 provides DRF guarantees and allows standard hardware mappings and compiler optimizations. Note-worthy, XC20 is the first model of its kind that also supports thread sequentialization optimization. Moreover, XC20 is also amenable to automated reasoning. To demonstrate this, we developed a sound model checker XMC and evaluated it on several concurrency benchmarks.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704908", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Evgenii", + "last_name": "Moiseenko", + "institution": "" + }, + { + "first_name": "Matteo", + "last_name": "Meluzzi", + "institution": "Delft University of Technology" + }, + { + "first_name": "Innokentii", + "last_name": "Meleshchenko", + "institution": "Neapolis University Pafos" + }, + { + "first_name": "Ivan", + "last_name": "Kabashnyi", + "institution": "Constructor University" + }, + { + "first_name": "Anton", + "last_name": "Podkopaev", + "institution": "Constructor University" + }, + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/MoiseenkoMMKPC25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704898", + "title": "Reachability Analysis of the Domain Name System", + "abstract": "The high complexity of DNS poses unique challenges for ensuring its security and reliability. Despite continuous advances in DNS testing, monitoring, and verification, protocol-level defects still give rise to numerous bugs and attacks. In this paper, we provide the first decision procedure for the DNS verification problem, establishing its complexity as 2ExpTime , which was previously unknown. We begin by formalizing the semantics of DNS as a system of recursive communicating processes extended with timers and an infinite message alphabet. We provide an algebraic abstraction of the alphabet with finitely many equivalence classes, using the subclass of semigroups that recognize positive prefix-testable languages. We then introduce a novel generalization of bisimulation for labelled transition systems, weaker than strong bisimulation, to show that our abstraction is sound and complete. Finally, using this abstraction, we reduce the DNS verification problem to the verification problem for pushdown systems. To show the expressiveness of our framework, we model two of the most prominent attack vectors on DNS, namely amplification attacks and rewrite blackholing.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704898", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Dhruv", + "last_name": "Nevatia", + "institution": "ETH Zurich" + }, + { + "first_name": "Si", + "last_name": "Liu", + "institution": "ETH Zurich" + }, + { + "first_name": "David", + "last_name": "Basin", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/NevatiaLB25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704839", + "title": "Maximal Simplification of Polyhedral Reductions", + "abstract": "Reductions combine collections of input values with an associative and often commutative operator to produce collections of results. When the same input value contributes to multiple outputs, there is an opportunity to reuse partial results, enabling reduction simplification . Simplification often produces a program with lower asymptotic complexity. Typical compiler optimizations yield, at best, a constant fold speedup, but a complexity improvement from, say, cubic to quadratic complexity yields unbounded speedup for sufficiently large problems. It is well known that reductions in polyhedral programs may be simplified automatically , but previous methods cannot exploit all available reuse. This paper resolves this long-standing open problem, thereby attaining minimal asymptotic complexity in the simplified program. We propose extensions to prior work on simplification to support any independent commutative reduction. At the heart of our approach is piece-wise simplification, the notion that we can split an arbitrary reduction into pieces and then independently simplify each piece. However, the difficulty of using such piece-wise transformations is that they typically involve an infinite number of choices. We give constructive proofs to deal with this and select a finite number of pieces for simplification.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704839", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Louis", + "last_name": "Narmour", + "institution": "Université de Rennes" + }, + { + "first_name": "Tomofumi", + "last_name": "Yuki", + "institution": "" + }, + { + "first_name": "Sanjay", + "last_name": "Rajopadhye", + "institution": "Colorado State University" + } + ], + "dblp_key": "journals/pacmpl/NarmourYR25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704880", + "title": "Preservation of Speculative Constant-Time by Compilation", + "abstract": "Compilers often weaken or even discard software-based countermeasures commonly used to protect programs against side-channel attacks; worse, they may also introduce vulnerabilities that attackers can exploit. The solution to this problemis to develop compilers that preserve such countermeasures. Prior work establishes that (a mildly modified version of) the CompCert and Jasmin formally verified compilers preserve constant-time, an information flow policy that ensures that programs are protected against timing side-channel attacks. However, nothing is known about preservation of speculative constant-time, a strengthening of the constant-time policythat ensures that programs are protected against Spectre-v1 attacks. We first show that preservation of speculative constant-time fails in practice by providing examples of secure programs whose compilation is not speculative constant-time using GCC (GCC -O0 and GCC -O1) and Jasmin. Then, we define a proof-of-concept compiler that distills some of the critical passes of the Jasmin compiler and use the C oq proof assistant to prove that it preserves speculative constant-time. Finally, we patch the Jasmin speculative constant-time type checker and demonstrate that all cryptographic implementations written in Jasmin can be fixed with minimal impact.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704880", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Santiago Arranz", + "last_name": "Olmos", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Lionel", + "last_name": "Blatter", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Vincent", + "last_name": "Laporte", + "institution": "Centre Inria de l'Université de Lorraine" + } + ], + "dblp_key": "journals/pacmpl/OlmosBBGL25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704896", + "title": "A Taxonomy of Hoare-Like Logics: Towards a Holistic View using Predicate Transformers and Kleene Algebras with Top and Tests", + "abstract": "We study Hoare-like logics, including partial and total correctness Hoare logic, incorrectness logic, Lisbon logic, and many others through the lens of predicate transformers à la Dijkstra and through the lens of Kleene algebra with top and tests (TopKAT). Our main goal is to give an overview – a taxonomy – of how these program logics relate, in particular under different assumptions like for example program termination, determinism, and reversibility. As a byproduct, we obtain a TopKAT characterization of Lisbon logic, which – to the best of our knowledge – is a novel result.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704896", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lena", + "last_name": "Verscht", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/VerschtK25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704864", + "title": "Pantograph: A Fluid and Typed Structure Editor", + "abstract": "Structure editors operate directly on a program’s syntactic tree structure. At first glance, this allows for the exciting possibility that such an editor could enforce correctness properties: programs could be well-formed and sometimes even well-typed by construction. Unfortunately, traditional approaches to structure editing that attempt to rigidly enforce these properties face a seemingly fundamental problem, known in the literature as viscosity. Making changes to existing programs often requires temporarily breaking program structure—but disallowing such changes makes it difficult to edit programs! In this paper, we present a scheme for structure editing which always maintains a valid program structure without sacrificing the fluidity necessary to freely edit programs. Two key pieces help solve this puzzle: first, we develop a novel generalization of selection for tree-based structures that properly generalizes text-based selection and editing, allowing users to freely rearrange pieces of code by cutting and pasting one-hole contexts; second, we type these one-hole contexts with a category of type diffs and explore the metatheory of the system that arises for maintaining well-typedness systematically. We implement our approach as an editor called Pantograph , and we conduct a study in which we successfully taught students to program with Pantograph and compare their performance against a traditional text editor.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704864", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Prinz", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Henry", + "last_name": "Blanchette", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/PrinzBL25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704858", + "title": "Progressful Interpreters for Efficient WebAssembly Mechanisation", + "abstract": "Mechanisations of programming language specifications are now increasingly common, providing machine-checked modelling of the specification and verification of desired properties such as type safety. However it is challenging to maintain these mechanisations, particularly in the face of an evolving specification. Existing mechanisations of the W3C WebAssembly (Wasm) standard have so far been able to keep pace as the standard evolves, helped enormously by the W3C Wasm standard’s choice to state the language’s semantics in terms of a fully formal specification. However a substantial incoming extension to Wasm, the 2.0 feature set, motivates the investigation of strategies for more efficient production of the core verification artefacts currently associated with the WasmCert-Coq mechanisation of Wasm. In the classic formalisation of a typed operational semantics as followed by the W3C Wasm standard, both the type system and runtime operational semantics are defined as inductive relations, with associated type soundness properties (progress and preservation) and an independent sound interpreter. We investigate two more efficient strategies for producing these artefacts, which are currently all separately defined by WasmCert-Coq. First, the approach of Kokke, Siek, and Wadler for deriving a sound interpreter from a constructive progress proof — we show that this approach scales to the W3C Wasm 1.0 standard, but results in an inefficient interpreter in our setting. Second, inspired by results from intrinsically-typed languages, we define a progressful interpreter which uses Coq’s dependent types to certify not only its own soundness, but also the progress property. We show that this interpreter can implement several performance optimisations while maintaining these certifications, which are fully erasable when the interpreter is extracted from Coq. Using this approach, we extend the WasmCert-Coq mechanisation to the significantly larger Wasm 2.0 feature set, discovering and correcting several errors in the expanded specification’s type system.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704858", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xiaojia", + "last_name": "Rao", + "institution": "Imperial College London" + }, + { + "first_name": "Stefan", + "last_name": "Radziuk", + "institution": "Imperial College London" + }, + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/RaoRWG25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704904", + "title": "A Primal-Dual Perspective on Program Verification Algorithms", + "abstract": "Many algorithms in verification and automated reasoning leverage some form of duality between proofs and refutations or counterexamples. In most cases, duality is only used as an intuition that helps in understanding the algorithms and is not formalized. In other cases, duality is used explicitly, but in a specially tailored way that does not generalize to other problems. In this paper we propose a unified primal-dual framework for designing verification algorithms that leverage duality. To that end, we generalize the concept of a Lagrangian that is commonly used in linear programming and optimization to capture the domains considered in verification problems, which are usually discrete, e.g., powersets of states, predicates, ranking functions, etc. A Lagrangian then induces a primal problem and a dual problem. We devise an abstract primal-dual procedure that simultaneously searches for a primal solution and a dual solution, where the two searches guide each other. We provide sufficient conditions that ensure that the procedure makes progress under certain monotonicity assumptions on the Lagrangian. We show that many existing algorithms in program analysis, verification, and automated reasoning can be derived from our algorithmic framework with a suitable choice of Lagrangian. The Lagrangian-based formulation sheds new light on various characteristics of these algorithms, such as the ingredients they use to ensure monotonicity and guarantee progress. We further use our framework to develop a new validity checking algorithm for fixpoint logic over quantified linear arithmetic. Our prototype achieves promising results and in some cases solves instances that are not solved by state-of-the-art techniques.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704904", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/TsukadaUPS25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704914", + "title": "Algebraic Temporal Effects: Temporal Verification of Recursively Typed Higher-Order Programs", + "abstract": "We present a general form of temporal effects for recursive types. Temporal effects have been adopted by effect systems to verify both linear-time temporal safety and liveness properties of higher-order programs with recursive functions. A challenge in a generalization to recursive types is that recursive types can easily cause unstructured loops, which obscure the regularity of the infinite behavior of computation and make it harder to statically verify liveness properties. To solve this problem, we introduce temporal effects with a later modality, which enable us to capture the behavior of non-terminating programs by stratifying obscure loops caused by recursive types. While temporal effects in the prior work are based on certain concrete formal forms, such as logical formulas and automata-based lattices, our temporal effects, which we call algebraic temporal effects , are more abstract, axiomatizing temporal effects in an algebraic manner and clarifying the requirements for temporal effects that can reason about programs soundly. We formulate algebraic temporal effects, formalize an effect system built on top of them, and prove two kinds of soundness of the effect system: safety and liveness soundness. We also introduce two instances of algebraic temporal effects: one is temporal regular effects , which are based on ω -regular expressions, and the other is temporal fixpoint effects , which are based on a first-order fixpoint logic. Their usefulness is demonstrated via examples including concurrent and object-oriented programs.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704914", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/SekiyamaU25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704884", + "title": "Modelling Recursion and Probabilistic Choice in Guarded Type Theory", + "abstract": "Constructive type theory combines logic and programming in one language. This is useful both for reasoning about programs written in type theory, as well as for reasoning about other programming languages inside type theory. It is well-known that it is challenging to extend these applications to languages with recursion and computational effects such as probabilistic choice, because these features are not easily represented in constructive type theory. We show how to define and reason about FPC ⊕ , a programming language with probabilistic choice and recursive types, in guarded type theory. We use higher inductive types to represent finite distributions and guarded recursion to model recursion. We define both operational and denotational semantics of FPC ⊕ , as well as a relation between the two. The relation can be used to prove adequacy, but we also show how to use it to reason about programs up to contextual equivalence.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704884", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Philipp Jan Andries", + "last_name": "Stassen", + "institution": "Aarhus University" + }, + { + "first_name": "Rasmus Ejlers", + "last_name": "Møgelberg", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Maaike", + "last_name": "Zwart", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/StassenMZAB25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704847", + "title": "Program Logics à la Carte", + "abstract": "Program logics have proven a successful strategy for verification of complex programs. By providing local reasoning and means of abstraction and composition, they allow reasoning principles for individual components of a program to be combined to prove guarantees about a whole program. Crucially, these components and their proofs can be reused . However, this reuse is only available once the program logic has been defined. It is a frustrating fact of the status quo that whoever defines a new program logic must establish every part, both semantics and proof rules, from scratch. In spite of programming languages and program logics typically sharing many core features, reuse is generally not available across languages. Even inside one language, if the same underlying operation appears in multiple language primitives, reuse is typically not possible when establishing proof rules for the program logic. To enable reuse across and inside languages when defining complex program logics (and proving them sound), we serve program logics à la carte by combining program logic fragments for the various effects of the language. Among other language features, the menu includes shared state, concurrency, and non-determinism as reusable, composable blocks that can be combined to define a program logic modularly. Our theory builds on ITrees as a framework to express language semantics and Iris as the underlying separation logic; the work has been mechanized in the Coq proof assistant.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704847", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Max", + "last_name": "Vistrup", + "institution": "ETH Zurich" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "ETH Zurich" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/VistrupSJ25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704872", + "title": "Top-Down or Bottom-Up? Complexity Analyses of Synchronous Multiparty Session Types", + "abstract": "Multiparty session types (MPST) provide a type discipline for ensuring communication safety, deadlockfreedom and liveness for multiple concurrently running participants. The original formulation of MPST takes the top-down approach, where a global type specifies a bird’s eye view of the intended interactions between participants, and each distributed process is locally type-checked against its end-point projection. A more recent one takes the bottom-up approach, where a desired property 𝜑 of a set of participants is ensured if the same property 𝜑 is true for an ensemble of end-point types (a typing context) inferred from each participant. This paper compares these two main procedures of MPST, giving their detailed complexity analyses. To this aim, we build several new algorithms missing from the bottom-up or top-down workflows by using graph representation of session types (type graphs). We first propose a subtyping system based on type graphs, offering more efficient (quadratic) subtype-checking than the existing (exponential) inductive algorithm by Ghilezan et al. Next for the top-down, we measure complexity of the four end-point projections in the literature. For the coinductive projection with full merging, we build a new sound and complete PSPACE-algorithm using type graphs. For bottom-up, we develop a novel type inference system from MPST processes which generates minimum type graphs, succinctly capturing covariance of internal choice and contravariance of external choice. For property-checking of typing contexts, we achieve PSPACE-hardness by reducing it from the quantified Boolean formula (QBF) problem, and build nondeterministic algorithms that search for counterexamples to prove membership in PSPACE. We also present deterministic analogues of these algorithms that run in exponential time. Finally, we calculate the total complexity of the top-down and the bottom-up approaches. Our analyses reveal that the top-down based on global types is more efficient than the bottom-up in many realistic cases; liveness checking for typing contexts in the bottom-up has the highest complexity; and the type inference costs exponential against the size of a process, which impacts the total complexity.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704872", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thien", + "last_name": "Udomsrirungruang", + "institution": "University of Oxford" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/UdomsrirungruangY25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704841", + "title": "Affect: An Affine Type and Effect System", + "abstract": "Effect handlers form a powerful construct that can express complex programming abstractions. They are a generalisation of exception handlers, but allow resumption of the continuation from where the effect was raised. Allowing continuations to be resumed at most once ( one-shot ) or an arbitrary number of times ( multi-shot ) has far-reaching consequences. In addition to performance considerations, multi-shot effects break key rules of reasoning and thus render certain standard transformation/optimisations unsound, especially in languages with mutable references (such as OCaml 5). It is therefore desirable to statically track whether continuations are used in a one-shot or multi-shot discipline, so that a compiler could use this information to efficiently implement effect handlers and to determine what optimizations it may perform. We address this problem by developing a type and effect system–called Affect –which uses affine types to track the usage of continuations. A challenge is to soundly deal with advanced programming features—such as references that store continuations and nested continuations—which are crucial to support challenging examples from the effects literature (such as control inversion and cooperative concurrency ). Another challenge is to support generic type signatures of polymorphic effectful functions. We address these challenges by using and extending Rust's Cell type and Wadler's use types . To prove soundness of Affect we model types and judgements semantically via a logical relation in the Iris separation logic framework in Coq.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704841", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Orpheas van", + "last_name": "Rooij", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/RooijK25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704837", + "title": "RE#: High Performance Derivative-Based Regex Matching with Intersection, Complement, and Restricted Lookarounds", + "abstract": "We present a tool and theory RE # for regular expression matching that is built on symbolic derivatives, does not use backtracking, and, in addition to the classical operators, also supports complement, intersection and restricted lookarounds. We develop the theory formally and show that the main matching algorithm has input-linear complexity both in theory as well as experimentally. We apply thorough evaluation on popular benchmarks that show that RE # is over 71% faster than the next fastest regex engine in Rust on the baseline, and outperforms all state-of-the-art engines on extensions of the benchmarks often by several orders of magnitude.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704837", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ian Erik", + "last_name": "Varatalu", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Juhan-Peep", + "last_name": "Ernits", + "institution": "Tallinn University of Technology" + } + ], + "dblp_key": "journals/pacmpl/VarataluVE25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704912", + "title": "All Your Base Are Belong to Us: Sort Polymorphism for Proof Assistants", + "abstract": "Proof assistants based on dependent type theory, such as Coq, Lean and Agda, use different universes to classify types, typically combining a predicative hierarchy of universes for computationally-relevant types, and an impredicative universe of proof-irrelevant propositions. In general, a universe is characterized by its sort, such as Type or Prop, and its level, in the case of a predicative sort. Recent research has also highlighted the potential of introducing more sorts in the type theory of the proof assistant as a structuring means to address the coexistence of different logical or computational principles, such as univalence, exceptions, or definitional proof irrelevance. This diversity raises concrete and subtle issues from both theoretical and practical perspectives. In particular, in order to avoid duplicating definitions to inhabit all (combinations of) universes, some sort of polymorphism is needed. Universe level polymorphism is well-known and effective to deal with hierarchies, but the handling of polymorphism between sorts is currently ad hoc and limited in all major proof assistants, hampering reuse and extensibility. This work develops sort polymorphism and its metatheory, studying in particular monomorphization, large elimination, and parametricity. We implement sort polymorphism in Coq and present examples from a new sort-polymorphic prelude of basic definitions and automation. Sort polymorphism is a natural solution that effectively addresses the limitations of current approaches and prepares the ground for future multi-sorted type theories.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704912", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Josselin", + "last_name": "Poiret", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gaëtan", + "last_name": "Gilbert", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Pierre-Marie", + "last_name": "Pédrot", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/PoiretGMPSTT25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704850", + "title": "On Extending Incorrectness Logic with Backwards Reasoning", + "abstract": "This paper studies an extension of O’Hearn’s incorrectness logic (IL) that allows backwards reasoning. IL in its current form does not generically permit backwards reasoning. We show t at this can be mitigated by extending IL with underspecification. The resulting logic combines underspecification (the result, or postcondition, only needs to formulate constraints over relevant variables) with underapproximation (it allows to focus on fewer than all the paths). We prove soundness of the proof system, as well as completeness for a defined subset of presumptions. We discuss proof strategies that allow one to derive a presumption from a given result. Notably, we show that the existing concept of loop summaries- closed-form symbolic representations that summarize the effects of executing an entire loop at once- is highly useful. The logic, the proof system and all theorems have been formalized in the Isabelle/HOL theorem prover.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704850", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Freek", + "last_name": "Verbeek", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Md. Syadus", + "last_name": "Sefat", + "institution": "Virginia Tech" + }, + { + "first_name": "Zhoulai", + "last_name": "Fu", + "institution": "SUNY Korea" + }, + { + "first_name": "Binoy", + "last_name": "Ravindran", + "institution": "Virginia Tech" + } + ], + "dblp_key": "journals/pacmpl/VerbeekSFR25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704838", + "title": "Symbolic Automata: Omega-Regularity Modulo Theories", + "abstract": "Symbolic automata are finite state automata that support potentially infinite alphabets, such as the set of rational numbers, generally applied to regular expressions and languages over finite words. In symbolic automata (or automata modulo 𝒜), an alphabet is represented by an effective Boolean algebra 𝒜, supported by a decision procedure for satisfiability. Regular languages over infinite words (so called ω -regular languages) have a rich history paralleling that of regular languages over finite words, with well known applications to model checking via Büchi automata and temporal logics. We generalize symbolic automata to support ω -regular languages via transition terms and symbolic derivatives , bringing together a variety of classic automata and logics in a unified framework that provides all the necessary ingredients to support symbolic model checking modulo 𝒜. In particular, we define: (1) alternating Büchi automata modulo 𝒜( AB W 𝒜 ) as well (non-alternating) nondeterministic Büchi automata modulo 𝒜( NB W 𝒜 );(2) an alternation elimination algorithm Æ that incrementally constructs an NB W 𝒜 from an AB W 𝒜 , and can also be used for constructing the product of two NB W 𝒜 ; (3) a definition of linear temporal logic modulo 𝒜, LTL ⟨𝒜⟩, that generalizes Vardi's construction of alternating Büchi automata from LTL, using (2) to go from LTL modulo 𝒜 to NB W 𝒜 via AB W 𝒜 . Finally, we present RLTL ⟨ 𝒜 ⟩, a combination of LTL ⟨ 𝒜 ⟩ with extended regular expressions modulo 𝒜 that generalizes the Property Specification Language (PSL). Our combination allows regex complement , that is not supported in PSL but can be supported naturally by using transition terms. We formalize the semantics of RLTL ⟨ 𝒜 ⟩ using the Lean proof assistant and formally establish correctness of the main derivation theorem.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704838", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Thomas S.", + "last_name": "Ball", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gabriel", + "last_name": "Ebner", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ekaterina", + "last_name": "Zhuchko", + "institution": "Tallinn University of Technology" + } + ], + "dblp_key": "journals/pacmpl/VeanesBEZ25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704887", + "title": "SNIP: Speculative Execution and Non-Interference Preservation for Compiler Transformations", + "abstract": "We address the problem of preserving non-interference across compiler transformations under speculative semantics . We develop a proof method that ensures the preservation uniformly across all source programs. The basis of our proof method is a new form of simulation relation. It operates over directives that model the attacker’s control over the micro-architectural state, and it accounts for the fact that the compiler transformation may change the influence of the micro-architectural state on the execution (and hence the directives). Using our proof method, we show the correctness of dead code elimination. When we tried to prove register allocation correct, we identified a previously unknown weakness that introduces violations to non-interference. We have confirmed the weakness for a mainstream compiler on code from the libsodium cryptographic library. To reclaim security once more, we develop a novel static analysis that operates on a product of source program and register-allocated program. Using the analysis, we present an automated fix to existing register allocation implementations. We prove the correctness of the fixed register allocations with our proof method.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704887", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sören van der", + "last_name": "Wall", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + } + ], + "dblp_key": "journals/pacmpl/WallM25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704910", + "title": "Biparsers: Exact Printing for Data Synchronisation", + "abstract": "Parsers and printers are vital for data synchronisation between different serialisation formats. As they are tightly related, much research has been devoted to showing that both can be derived from a single definition. It, however, turns out to be challenging to extend this work with exact-printing , which recovers the original source text for the parsed data. In this paper, we propose a new approach to tackling the challenge that considers a parser-printer pair as a mechanism to synchronize the input text string with the data, and formalizes them as a bidirectional program (lens). We propose the first biparser framework to support exact-printing with non-injective parsers, provide a library of combinators for common patterns, and demonstrate its usefulness with biparsers for subsets of JSON and YAML.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704910", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ruifeng", + "last_name": "Xie", + "institution": "Peking University" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/XieSH25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704869", + "title": "QuickSub: Efficient Iso-Recursive Subtyping", + "abstract": "Many programming languages need to check whether two recursive types are in a subtyping relation. Traditionally recursive types are modelled in two different ways: equi- or iso- recursive types. While efficient algorithms for subtyping equi-recursive types are well studied for simple type systems, efficient algorithms for iso-recursive subtyping remain understudied. In this paper we present QuickSub : an efficient and simple to implement algorithm for iso-recursive subtyping. QuickSub has the same expressive power as the well-known iso-recursive Amber rules. The worst case complexity of QuickSub is O ( nm ), where m is the size of the type and n is the number of recursive binders. However, in practice, the algorithm is nearly linear with the worst case being hard to reach. Consequently, in many common cases, QuickSub can be several times faster than alternative algorithms. We validate the efficiency of QuickSub with an empirical evaluation comparing it to existing equi-recursive and iso-recursive subtyping algorithms. We prove the correctness of the algorithm and formalize a simple calculus with recursive subtyping and records. For this calculus we also show how type soundness can be proved using QuickSub . All the results have been formalized and proved in the Coq proof assistant.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704869", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Litao", + "last_name": "Zhou", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/ZhouO25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704878", + "title": "Automating Equational Proofs in Dirac Notation", + "abstract": "Dirac notation is widely used in quantum physics and quantum programming languages to define, compute and reason about quantum states. This paper considers Dirac notation from the perspective of automated reasoning. We prove two main results: first, the first-order theory of Dirac notation is decidable, by a reduction to the theory of real closed fields and Tarski’s theorem. Then, we prove that validity of equations can be decided efficiently, using term-rewriting techniques. We implement our equivalence checking algorithm in Mathematica, and showcase its efficiency across more than 100 examples from the literature.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704878", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yingte", + "last_name": "Xu", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Li", + "last_name": "Zhou", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "journals/pacmpl/XuBZ25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704903", + "title": "Generically Automating Separation Logic by Functors, Homomorphisms, and Modules", + "abstract": "Foundational verification considers the functional correctness of programming languages with formalized semantics and uses proof assistants (e.g., Coq, Isabelle) to certify proofs. The need for verifying complex programs compels it to involve expressive Separation Logics (SLs) that exceed the scopes of well-studied automated proof theories, e.g., symbolic heap. Consequently, automation of SL in foundational verification relies heavily on ad-hoc heuristics that lack a systematic meta-theory and face scalability issues. To mitigate the gap, we propose a theory to specify SL predicates using abstract algebras including functors, homomorphisms, and modules over rings. Based on this theory, we develop a generic SL automation algorithm to reason about any data structures that can be characterized by these algebras. In addition, we also present algorithms for automatically instantiating the algebraic models to real data structures. The instantiation works compositionally, reusing the algebraic models of component structures and preserving their data abstractions. Case studies on formalized imperative semantics show our algorithm can instantiate the algebraic models automatically for a variety of complex data structures. Experimental results indicate the automatically instantiated reasoners from our generic theory show similar results to the state-of-the-art systems made of specifically crafted reasoning rules. The presented theories, proofs, and the verification framework are formalized in Isabelle/HOL.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704903", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Qiyuan", + "last_name": "Xu", + "institution": "Nanyang Technological University" + }, + { + "first_name": "David", + "last_name": "Sanán", + "institution": "Singapore Institute of Technology" + }, + { + "first_name": "Zhé", + "last_name": "Hóu", + "institution": "Griffith University" + }, + { + "first_name": "Xiaokun", + "last_name": "Luan", + "institution": "Peking University" + }, + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Yang", + "last_name": "Liu", + "institution": "Nanyang Technological University" + } + ], + "dblp_key": "journals/pacmpl/XuSHLWL25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704874", + "title": "Guaranteed Bounds on Posterior Distributions of Discrete Probabilistic Programs with Loops", + "abstract": "We study the problem of bounding the posterior distribution of discrete probabilistic programs with unbounded support, loops, and conditioning. Loops pose the main difficulty in this setting: even if exact Bayesian inference is possible, the state of the art requires user-provided loop invariant templates. By contrast, we aim to find guaranteed bounds , which sandwich the true distribution. They are fully automated, applicable to more programs and provide more provable guarantees than approximate sampling-based inference. Since lower bounds can be obtained by unrolling loops, the main challenge is upper bounds, and we attack it in two ways. The first is called residual mass semantics , which is a flat bound based on the residual probability mass of a loop. The approach is simple, efficient, and has provable guarantees. The main novelty of our work is the second approach, called geometric bound semantics . It operates on a novel family of distributions, called eventually geometric distributions (EGDs), and can bound the distribution of loops with a new form of loop invariants called contraction invariants . The invariant synthesis problem reduces to a system of polynomial inequality constraints, which is a decidable problem with automated solvers. If a solution exists, it yields an exponentially decreasing bound on the whole distribution, and can therefore bound moments and tail asymptotics as well, not just probabilities as in the first approach. Both semantics enjoy desirable theoretical properties. In particular, we prove soundness and convergence, i.e. the bounds converge to the exact posterior as loops are unrolled further. We also investigate sufficient and necessary conditions for the existence of geometric bounds. On the practical side, we describe Diabolo , a fully-automated implementation of both semantics, and evaluate them on a variety of benchmarks from the literature, demonstrating their general applicability and the utility of the resulting bounds.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704874", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Zaiser", + "institution": "University of Oxford" + }, + { + "first_name": "Andrzej S.", + "last_name": "Murawski", + "institution": "University of Oxford" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "Nanyang Technological University" + } + ], + "dblp_key": "journals/pacmpl/ZaiserMO25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704855", + "title": "A Demonic Outcome Logic for Randomized Nondeterminism", + "abstract": "Programs increasingly rely on randomization in applications such as cryptography and machine learning. Analyzing randomized programs has been a fruitful research direction, but there is a gap when programs also exploit nondeterminism(for concurrency, efficiency, or algorithmic design). In this paper, we introduce Demonic Outcome Logic for reasoning about programs that exploit both randomization and nondeterminism. The logic includes several novel features, such as reasoning about multiple executions in tandem and manipulating pre- and postconditions using familiar equational laws—including the distributive law of probabilistic choices over nondeterministic ones. We also give rules for loops that both establish termination and quantify the distribution of final outcomes from a single premise. We illustrate the reasoning capabilities of Demonic Outcome Logic through several case studies, including the Monty Hall problem, an adversarial protocol for simulating fair coins, and a heuristic based probabilistic SAT solver.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704855", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Noam", + "last_name": "Zilberstein", + "institution": "Cornell University" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/ZilbersteinKST25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704895", + "title": "Semantic Logical Relations for Timed Message-Passing Protocols", + "abstract": "Many of today’s message-passing systems not only require messages to be exchanged in a certain order but also to happen at a certain time or within a certain time window . Such correctness conditions are particularly prominent in Internet of Things (IoT) and real-time systems applications, which interface with hardware devices that come with inherent timing constraints. Verifying compliance of such systems with the intended timed protocol is challenged by their heterogeneity —ruling out any verification method that relies on the system to be implemented in one common language, let alone in a high-level and typed programming language. To address this challenge, this paper contributes a logical relation to verify that its inhabitants (the applications and hardware devices to be proved correct) comply with the given timed protocol. To cater to the systems’ heterogeneity, the logical relation is entirely semantic , lifting the requirement that its inhabitants are syntactically well-typed. A semantic approach enables two modes of use of the logical relation for program verification: (i) once-and-for-all verification of an arbitrary well-typed application, given a type system, and (ii) per-instance verification of a specific application / hardware device ( a.k.a ., foreign code). To facilitate mode (i) , the paper develops a refinement type system for expressing timed message-passing protocols and proves that any well-typed program inhabits the logical relation (fundamental theorem). A type checker for the refinement type system has been implemented in Rust, using an SMT solver to check satisfiability of timing constraints. Then, the paper demonstrates both modes of use based on a small case study of a smart home system for monitoring air quality, consisting of a controller application and various environment sensors.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704895", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yue", + "last_name": "Yao", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Grant", + "last_name": "Iraci", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Cheng-En", + "last_name": "Chuang", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Lukasz", + "last_name": "Ziarek", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "journals/pacmpl/YaoICBZ25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704857", + "title": "CF-GKAT: Efficient Validation of Control-Flow Transformations", + "abstract": "Guarded Kleene Algebra with Tests (GKAT) provides a sound and complete framework to reason about trace equivalence between simple imperative programs. However, there are still several notable limitations. First, GKAT is completely agnostic with respect to the meaning of primitives, to keep equivalence decidable. Second, GKAT excludes non-local control flow such as goto, break , and return . To overcome these limitations, we introduce Control-Flow GKAT (CF-GKAT) , a system that allows reasoning about programs that include non-local control flow as well as hardcoded values. CF-GKAT is able to soundly and completely verify trace equivalence of a larger class of programs, while preserving the nearly-linear efficiency of GKAT. This makes CF-GKAT suitable for the verification of control-flow manipulating procedures, such as decompilation and goto-elimination. To demonstrate CF-GKAT’s abilities, we validated the output of several highly non-trivial program transformations, such as Erosa and Hendren’s goto -elimination procedure and the output of Ghidra decompiler. CF-GKAT opens up the application of Kleene Algebra to a wider set of challenges, and provides an important verification tool that can be applied to the field of decompilation and control-flow transformation.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704857", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Cheng", + "last_name": "Zhang", + "institution": "University College London" + }, + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "Leiden University" + }, + { + "first_name": "David E.", + "last_name": "Narváez", + "institution": "Virginia Tech" + }, + { + "first_name": "Nico", + "last_name": "Naus", + "institution": "Open University of the Netherlands" + } + ], + "dblp_key": "journals/pacmpl/ZhangKNN25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704913", + "title": "Dis/Equality Graphs", + "abstract": "E-graphs are a data structure to compactly represent a program space and reason about equality of program terms. E-graphs have been successfully applied to a number of domains, including program optimization and automated theorem proving. In many applications, however, it is necessary to reason about disequality of terms as well as equality. While disequality reasoning can be encoded, direct support for disequalities increases performance and simplifies the metatheory. In this paper, we develop a framework independent of a specific implementation to formally reason about e-graphs. For the first time, we prove the equivalence of e-graphs to the reflexive, symmetric, transitive, and congruent closure of the equivalence relation they are expected to encode. We use these results to present the first formalization of an extension of e-graphs that directly supports disequalities and prove an analytical result about their superior efficiency compared to embedding techniques that are commonly used in SMT solvers and automated verifiers. We further profile an SMT solver and find that it spends a measurable amount of time handling disequalities. We implement our approach in an extension to egg, a popular e-graph Rust library. We evaluate our solution in an SMT solver and an automated theorem prover using standard benchmarks. The results indicate that direct support for disequalities outperforms other encodings based on equality embedding, confirming the results obtained analytically.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704913", + "conference_name": "POPL", + "authors": [ + { + "first_name": "George", + "last_name": "Zakhour", + "institution": "University of St.Gallen" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "University of St.Gallen" + }, + { + "first_name": "Jahrim Gabriele", + "last_name": "Cesario", + "institution": "University of St.Gallen" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "University of St.Gallen" + } + ], + "dblp_key": "journals/pacmpl/ZakhourWCS25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704900", + "title": "Unifying Compositional Verification and Certified Compilation with a Three-Dimensional Refinement Algebra", + "abstract": "Formal verification is a gold standard for building reliable computer systems. Certified systems in particular come with a formal specification, and a proof of correctness which can easily be checked by a third party. Unfortunately, verifying large-scale, heterogeneous systems remains out of reach of current techniques. Addressing this challenge will require the use of compositional methods capable of accommodating and interfacing a range of program verification and certified compilation techniques. In principle, compositional semantics could play a role in enabling this kind of flexibility, but in practice existing tools tend to rely on simple and specialized operational models which are difficult to interface with one another. To tackle this issue, we present a compositional semantics framework which can accommodate a broad range of verification techniques. Its core is a three-dimensional algebra of refinement which operates across program modules, levels of abstraction, and components of the system’s state. Our framework is mechanized in the Coq proof assistant and we showcase its capabilities with multiple use cases.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704900", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yu", + "last_name": "Zhang", + "institution": "Yale University" + }, + { + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Yuting", + "last_name": "Wang", + "institution": "Shanghai Jiao Tong University" + } + ], + "dblp_key": "journals/pacmpl/ZhangKSW25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704886", + "title": "Derivative-Guided Symbolic Execution", + "abstract": "We consider the formulation of a symbolic execution (SE) procedure for functional programs that interact with effectful, opaque libraries. Our procedure allows specifications of libraries and abstract data type (ADT) methods that are expressed in Linear Temporal Logic over Finite Traces (LTL f ), interpreting them as symbolic finite automata (SFAs) to enable intelligent specification-guided path exploration in this setting. We apply our technique to facilitate the falsification of complex data structure safety properties in terms of effectful operations made by ADT methods on underlying opaque representation type(s). Specifications naturally characterize admissible traces of temporally-ordered events that ADT methods (and the library methods they depend upon) are allowed to perform. We show how to use these specifications to construct feasible symbolic input states for the corresponding methods, as well as how to encode safety properties in terms of this formalism. More importantly, we incorporate the notion of symbolic derivatives , a mechanism that allows the SE procedure to intelligently underapproximate the set of precondition states it needs to explore, based on the automata structures latent in the provided specifications and the safety property that is to be falsified. Intuitively, derivatives enable symbolic execution to exploit temporal constraints defined by trace-based specifications to quickly prune unproductive paths and discover feasible error states. Experimental results on a wide-range of challenging ADT implementations demonstrate the effectiveness of our approach.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704886", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yongwei", + "last_name": "Yuan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Z.", + "last_name": "Zhou", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Julia", + "last_name": "Belyakova", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/YuanZBJ25", + "venue": "popl", + "year": 2025 + }, + { + "paper_id": "10.1145/3704901", + "title": "An Incremental Algorithm for Algebraic Program Analysis", + "abstract": "We propose a method for conducting algebraic program analysis (APA) incrementally in response to changes of the program under analysis. APA is a program analysis paradigm that consists of two distinct steps: computing a path expression that succinctly summarizes the set of program paths of interest, and interpreting the path expression using a properly-defined semantic algebra to obtain program properties of interest. In this context, the goal of an incremental algorithm is to reduce the analysis time by leveraging the intermediate results computed before the program changes. We have made two main contributions. First, we propose a data structure for efficiently representing path expression as a tree together with a tree-based interpreting method. Second, we propose techniques for efficiently updating the program properties in response to changes of the path expression. We have implemented our method and evaluated it on thirteen Java applications from the DaCapo benchmark suite. The experimental results show that both our method for incrementally computing path expression and our method for incrementally interpreting path expression are effective in speeding up the analysis. Compared to the baseline APA and two state-of-the-art APA methods, the speedup of our method ranges from 160× to 4761× depending on the types of program analyses performed.", + "date": "2025-01-07", + "link": "https://doi.org/10.1145/3704901", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chenyu", + "last_name": "Zhou", + "institution": "University of Southern California" + }, + { + "first_name": "Y.", + "last_name": "Fang", + "institution": "University of Southern California" + }, + { + "first_name": "Jingbo", + "last_name": "Wang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Chao", + "last_name": "Wang", + "institution": "University of Southern California" + } + ], + "dblp_key": "journals/pacmpl/ZhouFWW25", + "venue": "popl", + "year": 2025 + } +] \ No newline at end of file diff --git a/data/pl_conferences/popl/2026.json b/data/pl_conferences/popl/2026.json new file mode 100644 index 0000000..4fcdb8d --- /dev/null +++ b/data/pl_conferences/popl/2026.json @@ -0,0 +1,2868 @@ +[ + { + "paper_id": "10.1145/3776688", + "title": "U-Turn: Enhancing Incorrectness Analysis by Reversing Direction", + "abstract": "O'Hearn's Incorrectness Logic (IL) has sparked renewed interest in static analyses that aim to detect program errors rather than prove their absence, thereby avoiding false alarms—a critical factor for practical adoption in industrial settings. As new incorrectness logics emerge to capture diverse error-related properties, a key question arises: can combining correctness and incorrectness techniques enhance precision, expressiveness, automation, or scalability? Notable frameworks, such as outcome logic, UNTer, local completeness logic, and exact separation logic, unify multiple analyses within a single proof system. In this work, we adopt a complementary strategy. Rather than designing a unified logic, we combine IL, which identifies reachable error states, with Sufficient Incorrectness Logic (SIL), which finds input states potentially leading to those errors. As a result, we get a more informative and effective analysis than either logic in isolation. Rather than sequencing them, our key innovation is reusing heuristic choices from the first analysis to steer the second. In fact, both IL and SIL rely on under-approximation and thus their automation legitimizes heuristics that avoid exhaustive path enumeration (e.g., selective disjunct pruning, loop unrolling). Concretely, we instrument the proof rules of the second logic with derivations from the first to inductively guide rule selection and application. To our knowledge, this is the first rule format enabling such inter-analysis instrumentation. This combined analysis aids debugging and testing by revealing both reachable errors and their causes, and opens new avenues for embedding incorrectness insights into scalable, expressive, automated code contracts.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776688", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Flavio", + "last_name": "Ascari", + "institution": "University of Konstanz" + }, + { + "first_name": "Roberto", + "last_name": "Bruni", + "institution": "University of Pisa" + }, + { + "first_name": "Roberta", + "last_name": "Gori", + "institution": "University of Pisa" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/AscariBGR26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776701", + "title": "Zoo: A Framework for the Verification of Concurrent OCaml 5 Programs using Separation Logic", + "abstract": "The release of Ocaml 5, which introduced parallelism in the OCaml runtime, drove the need for safe and efficient concurrent data structures. New libraries like Saturn address this need. This is an opportunity to apply and further state-of-the-art program verification techniques. We present Zoo, a framework for verifying fine-grained concurrent OCaml 5 algorithms. Following a pragmatic approach, we defined a limited but sufficient fragment of the language to faithfully express these algorithms: ZooLang. We formalized its semantics carefully via a deep embedding in the Rocq proof assistant, uncovering subtle aspects of physical equality. We provide a tool to translate source OCaml programs into ZooLang syntax embedded inside Rocq, where they can be specified and verified using the Iris concurrent separation logic. To illustrate the applicability of Zoo, we verified a subset of the standard library and a collection of fined-grained concurrent data structures from the Saturn and Eio libraries. In the process, we also extended OCaml to more efficiently express certain concurrent programs.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776701", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Clément", + "last_name": "Allain", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/AllainS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776730", + "title": "Cryptis: Cryptographic Reasoning in Separation Logic", + "abstract": "We introduce Cryptis, an extension of the Iris separation logic for the symbolic model of cryptography. The combination of separation logic and cryptographic reasoning allows us to prove the correctness of a protocol and later reuse this result to verify larger systems that rely on the protocol. To make this integration possible, we propose novel specifications for authentication protocols that allow agents in a network to agree on the use of system resources. We evaluate our approach by verifying various authentication protocols and a key-value store server that uses these authentication protocols to connect to clients. Our results are formalized in Rocq.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776730", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/AmorimAG26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776710", + "title": "Formal Verification for JavaScript Regular Expressions: A Proven Mechanized Semantics and Its Applications", + "abstract": "We present the first mechanized, succinct, practical, complete, and proven-faithful semantics for a modern regular expression language with backtracking semantics. We ensure its faithfulness by proving it equivalent to a preexisting line-by-line embedding of the official ECMAScript specification of JavaScript regular expressions. We demonstrate its practicality by presenting two real-world applications. First, a new notion of contextual equivalence for modern regular expressions, which we use to prove or disprove rewrites drawn from previous work. Second, the first formal proof of the PikeVM algorithm used in many real-world engines. In contrast with the specification and other formalization work, our semantics captures not only the top-priority match, but a full backtracking tree recording all possible matches and their respective priority. All our definitions and results have been mechanized in the Rocq proof assistant.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776710", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aurèle", + "last_name": "Barrière", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Victor", + "last_name": "Deng", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/BarriereDP26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776692", + "title": "A Synthetic Reconstruction of Multiparty Session Types", + "abstract": "Multiparty session types (MPST) provide a rigorous foundation for verifying the safety and liveness of concurrent systems. However, existing approaches often force a difficult trade-off: classical, projection-based techniques are compositional but limited in expressiveness, while more recent techniques achieve higher expressiveness by relying on non-compositional, whole-system model checking, which scales poorly. This paper introduces a new approach to MPST that delivers both expressiveness and compositionality, called the synthetic approach. Our key innovation is a type system that verifies each process directly against a global protocol specification, represented as a labelled transition system (LTS) in general, with global types as a special case. This approach uniquely avoids the need for intermediate local types and projection. We demonstrate that our approach, while conceptually simpler, supports a benchmark of challenging protocols that were previously beyond the reach of compositional techniques in the MPST literature. We generalise our type system, showing that it can validate processes against any specification that constitutes a \"well-behaved\" LTS, supporting protocols not expressible with the standard global type syntax. The entire framework, including all theorems and many examples, has been formalised and mechanised in Agda, and we have developed a prototype implementation as an extension to VS Code.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776692", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David", + "last_name": "Castro", + "institution": "University of Kent" + }, + { + "first_name": "Francisco", + "last_name": "Ferreira", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Sung-Shik T. Q.", + "last_name": "Jongmans", + "institution": "University of Groningen" + } + ], + "dblp_key": "journals/pacmpl/CastroPerezFJ26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776683", + "title": "Arbitration-Free Consistency Is Available (and Vice Versa)", + "abstract": "The fundamental tension between availability and consistency shapes the design of distributed storage systems. Classical results capture extreme points of this trade-off: the CAP theorem shows that strong models like linearizability preclude availability under partitions, while weak models like causal consistency remain implementable without coordination. These theorems apply to simple read-write interfaces, leaving open a precise explanation of the combinations of object semantics and consistency models that admit available implementations. This paper develops a general semantic framework in which storage specifications combine operation semantics and consistency models. The framework encompasses a broad range of objects (key-value stores, counters, sets, CRDTs, and SQL databases) and consistency models (from causal consistency and sequential consistency to snapshot isolation and bounded staleness). Within this framework, we prove the Arbitration-Free Consistency (AFC) theorem, showing that an object specification within a consistency model admits an available implementation if and only if it is arbitration-free, that is, it does not require a total arbitration order to resolve visibility or read dependencies. The AFC theorem unifies and generalizes previous results, revealing arbitration-freedom as the fundamental property that delineates coordination-free consistency from inherently synchronized behavior.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776683", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hagit", + "last_name": "Attiya", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Enrique", + "last_name": "Román-Calvo", + "institution": "University of Freiburg" + } + ], + "dblp_key": "journals/pacmpl/AttiyaER26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776729", + "title": "Probabilistic Programming with Vectorized Programmable Inference", + "abstract": "We present GenJAX, a new language and compiler for vectorized programmable probabilistic inference. GenJAX integrates the vectorizing map (vmap) operation from array programming frameworks such as JAX into the programmable inference paradigm, enabling compositional vectorization of features such as probabilistic program traces, stochastic branching (for expressing mixture models), and programmable inference interfaces for writing custom probabilistic inference algorithms. We formalize vectorization as a source-to-source program transformation on a core calculus for probabilistic programming (λ GEN ), and prove that it correctly vectorizes both modeling and inference operations. We have implemented our approach in the GenJAX language and compiler, and have empirically evaluated this implementation on several benchmarks and case studies. Our results show that our implementation supports a wide and expressive set of programmable inference patterns and delivers performance comparable to hand-optimized JAX code.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776729", + "conference_name": "POPL", + "authors": [ + { + "first_name": "McCoy", + "last_name": "Becker", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Mathieu", + "last_name": "Huot", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "George", + "last_name": "Matheos", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Xiaoyan", + "last_name": "Wang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Karen", + "last_name": "Chung", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Colin", + "last_name": "Smith", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Sam", + "last_name": "Ritchie", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Rif A.", + "last_name": "Saurous", + "institution": "Google (United States)" + }, + { + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Yale University" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BeckerHMWCSRSLRM26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776675", + "title": "Tropical Mathematics and the Lambda-Calculus II: Tropical Geometry of Probabilistic Programming Languages", + "abstract": "In the last few years there has been a growing interest towards methods for statistical inference and learning based on computational geometry and, notably, tropical geometry, that is, the study of algebraic varieties over the min-plus semiring. At the same time, recent work has demonstrated the possibility of interpreting higher-order probabilistic programming languages in the framework of tropical mathematics, by exploiting algebraic and categorical tools coming from the semantics of linear logic. In this work we combine these two worlds, showing that tools and ideas from tropical geometry can be used to perform statistical inference over higher-order probabilistic programs. Notably, we first show that each such program can be associated with a degree and a n-dimensional polyhedron that encode its most likely runs. Then, we use these tools in order to design an intersection type system that estimates most likely runs in a compositional and efficient way.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776675", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Davide", + "last_name": "Barbarossa", + "institution": "University of Bath" + }, + { + "first_name": "Paolo", + "last_name": "Pistone", + "institution": "Université Claude Bernard Lyon 1" + } + ], + "dblp_key": "journals/pacmpl/BarbarossaP26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776664", + "title": "AdapTT: Functoriality for Dependent Type Casts", + "abstract": "The ability to cast values between related types is a leitmotiv of many flavors of dependent type theory, such as observational type theories, subtyping, or cast calculi for gradual typing. These casts all exhibit a common structural behavior that boils down to the pervasive functoriality of type formers. We propose and extensively study a type theory, called AdapTT, which makes systematic and precise this idea of functorial type formers, with respect to an abstract notion of adapters relating types. Leveraging descriptions for functorial inductive types in AdapTT, we derive structural laws for type casts on general inductive type formers.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776664", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Adjedj", + "institution": "École Normale Supérieure Paris-Saclay" + }, + { + "first_name": "Meven", + "last_name": "Lennon-Bertrand", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Thibaut", + "last_name": "Benjamin", + "institution": "École Normale Supérieure Paris-Saclay" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "École Centrale de Nantes" + } + ], + "dblp_key": "journals/pacmpl/AdjedjLBM26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776693", + "title": "A Modular Static Cost Analysis for GPU Warp-Level Parallelism", + "abstract": "Graphics Processing Units (GPUs) are the accelerator of choice for performance-critical applications, yet optimizing for performance requires mastery of the complex interactions between its memory architecture and its execution model. Existing static analysis tools for GPU kernels either identify performance bugs without quantifying costs or cannot handle thread-divergent control flow, leading to significant over-approximations. We present the first static relational-cost analysis for GPU warp-level parallelism that can give exact bounds even in the presence of thread divergence. Our analysis is general and flexible, as it is parametric on the resource metric (uncoalesced accesses, bank conflicts) and on the cost relation (=, ≤, ≥). We establish a soundness theorem for our technique, provide mechanized proofs in Rocq and implement our theory in a tool called Pico. In a reproducibility experiment, Pico produced the tightest bounds in every input, outperforming the state-of-the-art tool RaCUDA in 10 kernels (1.7×better), while RaCUDA produced 4 incorrect bounds and crashed on 2 kernels. In an experiment to measure the accuracy of Pico, we studied the impact of thread-divergence in control-flow in a dataset of 226 kernels. We found that at least 75.3% of conditionals and 85.4% of loops can be captured exactly, without introducing approximation.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776693", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gregory", + "last_name": "Blike", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Hannah", + "last_name": "Zicarelli", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Udaya", + "last_name": "Sathiyamoorthy", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Julien", + "last_name": "Lange", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Tiago", + "last_name": "Cogumbreiro", + "institution": "University of Massachusetts Boston" + } + ], + "dblp_key": "journals/pacmpl/BlikeZSLC26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776707", + "title": "A Logic for the Imprecision of Abstract Interpretations", + "abstract": "In numerical analysis, error propagation refers to how small inaccuracies in input data or intermediate computations accumulate and affect the final result, typically governed by the stability and sensitivity of the algorithm with respect to some perturbations. The definition of a similar concept in approximated program analysis is still a challenge. In abstract interpretation, inaccuracy arises from the abstraction itself, and the propagation of this error is dictated by the abstract interpreter. In most cases, such imprecision is inevitable. In this paper we introduce a logic for deriving (upper) bounds on the inaccuracy of an abstract interpretation. We are able to derive a function that bounds the imprecision of the result of an abstract interpreter from the imprecision of its input data. When this holds we have what we call partial local completeness of the abstract interpreter, a weaker form of completeness known in the literature. To this end, we introduce the notion of a generator for a property represented in the abstract domain. Generators allow us to restrict the search space when verifying whether the bounding function holds for a given program and input. We then introduce a program logic, called Error Propagation Logic ( EPL ), for propagating the error bounds produced by an abstract interpretation. This logic is a combination of correctness and incorrectness logics and a logic for program ω -continuity that is also introduced in this paper.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776707", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marco", + "last_name": "Campion", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Mila Dalla", + "last_name": "Preda", + "institution": "University of Verona" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Arizona" + }, + { + "first_name": "Caterina", + "last_name": "Urban", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/CampionPGU26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776680", + "title": "Parametrised Verification of Intel-x86 Programs", + "abstract": "We address the reachability problem for concurrent programs with an arbitrary number of threads running over the Intel x-86 architecture. We consider the formal model eTSO for Intel x-86 defined by Raad et al. in POPL 2022. This model takes into account multiple memory types and non-temporal writes, combining in a complex way features in the TSO and PSO weak memory models. In PLDI 2024, Abdulla et al. proved that this problem is undecidable for eTSO in general, but that it is decidable under k -alternation bounding when computations have, for some fixed bound k , at most k alternations of TSO segments (with TSO writes only) and PSO segments (with PSO writes only) for each thread. The proof of this result assumes that the number of threads is fixed, and relies crucially on referring to thread identities. In this paper, we prove the decidability of the k -alternation bounded reachability problem of eTSO in the parametrized setting when the number of threads is a parameter that can be arbitrarily high. The proof is nontrivial as it cannot refer to thread identities, their number being unbounded. We show that it is possible to overcome this difficulty using a novel and quite complex reduction to reachability in well-structured systems on domains that are BQOs (Better Quasi Orders). This is the first time that BQO-based well-structured systems are used to prove the decidability of verification of infinite state programs.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776680", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Université Paris Cité" + }, + { + "first_name": "K. Narayan", + "last_name": "Kumar", + "institution": "Chennai Mathematical Institute" + }, + { + "first_name": "Prakash", + "last_name": "Saivasan", + "institution": "Institute of Mathematical Sciences" + } + ], + "dblp_key": "journals/pacmpl/AbdullaABKS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776661", + "title": "General Decidability Results for Systems with Continuous Counters", + "abstract": "Counters that hold natural numbers are ubiquitous in modeling and verifying software systems; for example, they model dynamic creation and use of resources in concurrent programs. Unfortunately, such discrete counters often lead to extremely high complexity. Continuous counters are an efficient over-approximation of discrete counters. They are obtained by relaxing the original counters to hold values over the non-negative rational numbers. This work shows that continuous counters are extraordinarily well-behaved in terms of decidability. Our main result is that, despite continuous counters being infinite-state, the language of sequences of counter instructions that can arrive in a given target configuration, is regular. Moreover, a finite automaton for this language can be computed effectively. This implies that a wide variety of transition systems can be equipped with continuous counters, while maintaining decidability of reachability properties. Examples include higher-order recursion schemes, well-structured transition systems, and decidable extensions of discrete counter systems. We also prove a non-elementary lower bound for the size of the resulting finite automaton.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776661", + "conference_name": "POPL", + "authors": [ + { + "first_name": "A. R.", + "last_name": "Balasubramanian", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ramanathan S.", + "last_name": "Thinniyam", + "institution": "Uppsala University" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/BalasubramanianHMTZ26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776713", + "title": "A Verified High-Performance Composable Object Library for Remote Direct Memory Access", + "abstract": "Remote Direct Memory Access (RDMA) is a memory technology that allows remote devices to directly write to and read from each other's memory, bypassing components such as the CPU and operating system. This enables low-latency high-throughput networking, as required for many modern data centres, HPC applications and AI/ML workloads. However, baseline RDMA comprises a highly permissive weak memory model that is difficult to use in practice and has only recently been formalised. In this paper, we introduce the Library of Composable Objects (LOCO), a formally verified library for building multi-node objects on RDMA, filling the gap between shared memory and distributed system programming. LOCO objects are well-encapsulated and take advantage of the strong locality and the weak consistency characteristics of RDMA. They have performance comparable to custom RDMA systems (e.g. distributed maps), but with a far simpler programming model amenable to formal proofs of correctness. To support verification, we develop a novel modular declarative verification framework, called Mowgli, that is flexible enough to model multinode objects and is independent of a memory consistency model. We instantiate Mowgli with the RDMA memory model, and use it to verify correctness of LOCO libraries.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776713", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Ambal", + "institution": "Imperial College London" + }, + { + "first_name": "George", + "last_name": "Hodgkins", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Mark", + "last_name": "Madler", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Gregory", + "last_name": "Chockler", + "institution": "University of Surrey" + }, + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "University of Surrey" + }, + { + "first_name": "Joseph", + "last_name": "Izraelevitz", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/AmbalHMCDIRV26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776716", + "title": "Bounded Treewidth, Multiple Context-Free Grammars, and Downward Closures", + "abstract": "The reachability problem in multi-pushdown automata (MPDA), or equivalently, interleaved Dyck reachability, has many applications in static analysis of recursive programs. An example is safety verification of multi-threaded recursive programs with shared memory. Since these problems are undecidable, the literature contains many decidable (and efficient) underapproximations of MPDA. A uniform framework that captures many of these underapproximations is that of bounded treewidth : To each execution of the MPDA, we associate a graph; then we consider the subset of all graphs that have a treewidth at most k , for some constant k . In fact, bounding treewidth is a generic approach to obtain classes of systems with decidable reachability, even beyond MPDA underapproximations. The resulting systems are also called MSO-definable bounded-treewidth systems . While bounded treewidth is a powerful tool for reachability and similar types of analysis, the word languages (i.e. action sequences corresponding to executions) of these systems remain far from understood. For the slight restriction of bounded special treewidth , or “bounded-stw” (which is equivalent to bounded treewidth on MPDA, and even includes all bounded-treewidth systems studied in the literature), this work reveals a connection with multiple context-free languages (MCFL), a concept from computational linguistics. We show that the word languages of MSO-definable bounded-stw systems are exactly the MCFL. We exploit this connection to provide an optimal algorithm for computing downward closures for MSO-definable bounded-stw systems. Computing downward closures is a notoriously difficult task that has many applications in the verification of complex systems: As an example application, we show that in programs with dynamic spawning of MSO-definable bounded-stw processes, safety verification has the same complexity as in the case of processes with sequential recursive processes.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776716", + "conference_name": "POPL", + "authors": [ + { + "first_name": "C.", + "last_name": "Aiswarya", + "institution": "Chennai Mathematical Institute" + }, + { + "first_name": "Pascal", + "last_name": "Baumann", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Prakash", + "last_name": "Saivasan", + "institution": "Institute of Mathematical Sciences" + }, + { + "first_name": "Lia", + "last_name": "Schütze", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Georg", + "last_name": "Zetzsche", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/AiswaryaBSSZ26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776712", + "title": "Parameterized Verification of Quantum Circuits", + "abstract": "We present the first fully automatic framework for verifying relational properties of parameterized quantum programs , i.e., a program that, given an input size, generates a corresponding quantum circuit. We focus on verifying input-output correctness as well as equivalence. At the core of our approach is a new automata model, synchronized weighted tree automata (SWTAs), which compactly and precisely captures the infinite families of quantum states produced by parameterized programs. We introduce a class of transducers to model quantum gate semantics and develop composition algorithms for constructing transducers of parameterized circuits. Verification is reduced to functional inclusion or equivalence checking between SWTAs, for which we provide decision procedures. Our implementation demonstrates both the expressiveness and practical efficiency of the framework by verifying a diverse set of representative parameterized quantum programs with verification times ranging from milliseconds to seconds", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776712", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Y. C.", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "Michal", + "last_name": "Hečko", + "institution": "Brno University of Technology" + }, + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" + }, + { + "first_name": "Ondřej", + "last_name": "Lengál", + "institution": "Brno University of Technology" + }, + { + "first_name": "Jyun-Ao", + "last_name": "Lin", + "institution": "National Taipei University of Technology" + }, + { + "first_name": "Ramanathan S.", + "last_name": "Thinniyam", + "institution": "Uppsala University" + } + ], + "dblp_key": "journals/pacmpl/AbdullaCHHLLT26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776700", + "title": "Consistent Updates for Scalable Microservices", + "abstract": "Online services are commonly implemented with a scalable microservice architecture, where isomorphic workers process client requests, recording persistent state in a backend data store. To maintain service, modifications to service functionality must be made on the fly -- i.e., as the service continues to process client requests -- but doing so is challenging. The central difficulty is that of avoiding inconsistencies from mixed-mode operation, caused by workers of current and new versions interacting via the data store. Some update methods avoid mixed-mode altogether, but only at the cost of substantial inefficiency -- by doubling resources (memory and compute), or by halving throughput. The alternative is an uncontrolled \"rolling\" update, which runs the risk of serious service failures arising from inconsistent mixed-mode behavior. Ideally, it should appear to every client that a service update takes effect atomically; this ensures that a client is not exposed to inconsistent mixed-mode behavior. In this paper, we introduce a framework that formalizes this intuition and develop foundational theory for reasoning about update consistency. We apply this theory to derive the first algorithms that guarantee consistency for mixed-mode updates. The algorithms rely on semantic properties of service actions, such as commutativity. We show that this is unavoidable, by proving that any semantically oblivious mixed-mode update method must allow inconsistencies.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776700", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Devora", + "last_name": "Chait-Roth", + "institution": "New York University" + }, + { + "first_name": "Kedar S.", + "last_name": "Namjoshi", + "institution": "Nokia (United States)" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/ChaitRothNW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776695", + "title": "A Lazy, Concurrent Convertibility Checker", + "abstract": "Convertibility checking — determining whether two lambda-terms are equal up to reductions — is a crucial component of proof assistants and dependently-typed languages. Practical implementations often use heuristics to quickly conclude that two terms are convertible, or are not convertible, without reducing them to normal form. However, these heuristics can backfire, triggering huge amounts of unnecessary computation. This paper presents a novel convertibility-checking algorithm that relies crucially on laziness and concurrency. Laziness is used to share computations, while concurrency is used to explore multiple convertibility subproblems in parallel or via fair interleaving. Unlike heuristics-based approaches, our algorithm always finds an easy solution to the convertibility problem, if one exists. The paper describes the algorithm in process calculus style, discusses its complexity, and reports on its mechanized proof of partial correctness and its lightweight experimental evaluation.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776695", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nathanaëlle", + "last_name": "Courant", + "institution": "" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Université Paris Sciences et Lettres" + } + ], + "dblp_key": "journals/pacmpl/CourantL26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776714", + "title": "A Family of Sims with Diverging Interests", + "abstract": "Simulations are widely-used notions of program refinement. This paper discusses and compares several of them, in particular notions of simulation that are both weak and sensitive to divergence. Complex simulation proofs performed in proof assistants, for instance in a verified compilation setting, often rely on variants of normed simulation, which is not complete with respect to divergence-sensitive weak simulation. We propose to bridge this gap with µdiv-simulation, a novel notion of simulation that is equivalent to classical divergence-sensitive weak simulation, and designed to be as comfortable to use as modern characterizations of normed simulation. We then define a parameterized notion of simulation that covers strong simulation, weak simulation, µdiv-simulation, and 9 more notions of simulation, and jointly establish various \"up-to\" reasoning techniques for these 12 notions. Our results are formalized in Rocq and instantiated on two case studies: Choice Trees and a CompCert pass. Verified compilation is a major motivation for our study, but because we work with an abstract LTS setting, our results are also relevant to other fields that make use of divergence-sensitive weak simulation, such as model checking.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776714", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Chappe", + "institution": "Institut polytechnique de Grenoble" + } + ], + "dblp_key": "journals/pacmpl/Chappe26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776689", + "title": "The Simple Essence of Boolean-Algebraic Subtyping: Semantic Soundness for Algebraic Union, Intersection, Negation, and Equi-recursive Types", + "abstract": "Boolean-algebraic subtyping (BAS) is a powerful subtyping approach introduced in 2022 as the \"secret sauce\" enabling backtracking-free principal type inference in the MLstruct research language, a structurally-typed functional programming language with tagged records, tag and record subtyping, and tag-based pattern matching. By supporting distributive intersection, union, negation, and equi-recursive types, MLstruct can express powerful programming patterns, such as subtyped extensible variants, without needing row variables. But the use of atypical subtyping rules that violate some interpretations of intersection and union types, the mutual distributivity between these types, and the complexity of coinductive reasoning for equi-recursive types have collectively made the study of BAS difficult. The syntactic soundness proofs provided in the original work are dauntingly complicated and long-winded, obscuring the intuitions behind the correctness of BAS. In this paper, we distill the simple essence of Boolean-algebraic subtyping: we discover that BAS can be understood through five families of characteristic Boolean homomorphisms defined on types in context. Two of these map to power sets of simpler objects; the rest map back to types, but under an unguarded coinductive assumptions context. Together, these homomorphisms let us prove rather directly that BAS is sound, in that it does not relate constructors of incompatible runtime shapes. These homomorphisms are characteristic in the sense that they are sufficient to capture the meaning of subyping: we prove that if an inequality holds between two types under all these homomorphisms, then subtyping holds between the two types in the original context. This directly suggests a new subtyping decision procedure for BAS, which avoids some inefficiencies in the original algorithm, although it still has exponential worst-case time complexity. We prove that the subtyping problem is in fact co-NP-hard even without recursive types. Finally, we discover that BAS is already powerful enough to encode the removal of a field from a type. This allows us to support extensible records through one new term form and one new typing rule, but, perhaps surprisingly, no changes to subtyping at all. Our new approach to the semantics of BAS sheds some light on the core of MLstruct’s type system. It could be adapted to other languages with algebraic flavors of subtyping, such as Scala 3 and Ceylon, making their design and verification more approachable. Tellingly, all our subtyping soundness proofs fit inside the main body of this paper, with only some administrative lemmas relegated to the appendix.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776689", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chun Yin", + "last_name": "Chau", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ChauP26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776723", + "title": "Counting and Sampling Traces in Regular Languages", + "abstract": "In this work, we study the fundamental problems of counting and sampling traces that a regular language touches. Formally, one fixes the alphabet Σ and an independence relation I ⊆ Σ × Σ. The computational problems we address take as input a regular language L over Σ, presented as a finite automaton with m states, together with a natural number n (presented in unary). For the counting problem, the output is the number of Mazurkiewicz traces (induced by I) that intersect the n th slice L n = L ∩ Σ n of L , i.e., traces that have at least one linearization in L n . For the sampling problem, the output is a trace drawn from a distribution that is approximately uniform over all such traces. These problems are motivated by applications such as bounded model checking based on partial-order reduction, where an a priori estimate of the size of the state space can significantly improve usability, as well as testing approaches for concurrent programs that use partial-order-aware random sampling, where uniform exploration is desirable for effective bug detection. We first show that the counting problem is #P-hard even when the automaton accepting the language L is deterministic, which is in sharp contrast to the corresponding problem for counting the words of a DFA, which is solvable in polynomial time. We then show that the counting problem remains in the class #P for both NFAs and DFAs, independent of whether L is trace-closed. Finally, our main contributions are a fully polynomial-time randomized approximation scheme (FPRAS) that, with high probability, estimates the desired count within a specified accuracy parameter, and a fully polynomial-time almost uniform sampler (FPAUS) that generates traces while ensuring that the distribution induced on them is approximately uniform with high probability.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776723", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexis de", + "last_name": "Colnet", + "institution": "TU Wien" + }, + { + "first_name": "Kuldeep S.", + "last_name": "Meel", + "institution": "University of Toronto" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/ColnetMM26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776705", + "title": "DafnyMPI: A Dafny Library for Verifying Message-Passing Concurrent Programs", + "abstract": "The Message Passing Interface (MPI) is widely used in parallel, high-performance programming, yet writing bug-free software that uses MPI remains difficult. We introduce DafnyMPI, a novel, scalable approach to formally verifying MPI software. DafnyMPI allows proving deadlock freedom, termination, and functional equivalence with simpler sequential implementations. In contrast to existing specialized frameworks, DafnyMPI avoids custom concurrency logics and instead relies on Dafny, a verification-ready programming language used for sequential programs, extending it with concurrent reasoning abilities. DafnyMPI is implemented as a library that enables safe MPI programming by requiring users to specify the communication topology upfront and to verify that calls to communication primitives such as MPI_ISEND and MPI_WAIT meet their preconditions. We formalize DafnyMPI using a core calculus and prove that the preconditions suffice to guarantee deadlock freedom. Functional equivalence is proved via rely-guarantee reasoning over message payloads and a system that guarantees safe use of read and write buffers. Termination and the absence of runtime errors are proved using standard Dafny techniques. To further demonstrate the applicability of DafnyMPI, we verify numerical solutions to three canonical partial differential equations. We believe DafnyMPI demonstrates how to make formal verification viable for a broader class of programs and provides proof engineers with additional tools for software verification of parallel and concurrent systems.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776705", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Aleksandr", + "last_name": "Fedchin", + "institution": "Tufts University" + }, + { + "first_name": "Antero", + "last_name": "Mejr", + "institution": "Tufts University" + }, + { + "first_name": "HARI", + "last_name": "SUNDAR", + "institution": "Tufts University" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "Tufts University" + } + ], + "dblp_key": "journals/pacmpl/FedchinMSF26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776647", + "title": "Hadamard-Pi: Equational Quantum Programming", + "abstract": "Quantum computing offers advantages over classical computation, yet the precise features that set the two apart remain unclear. In the standard quantum circuit model, adding a 1-qubit basis-changing gate—commonly chosen to be the Hadamard gate—to a universal set of classical reversible gates yields computationally universal quantum computation. However, the computational behaviours enabled by this addition are not fully characterised. We give such a characterisation by introducing a small quantum programming language extending the universal classical reversible programming language Π with a single primitive corresponding to the Hadamard gate. The language comes equipped with a sound and complete categorical semantics that is specified by a purely equational theory. Completeness is shown by means of a novel finite presentation, and a corresponding synthesis algorithm, for the groups of orthogonal matrices with entries in the ring ℤ[1/√2].", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776647", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wang", + "last_name": "Fang", + "institution": "University of Edinburgh" + }, + { + "first_name": "Chris", + "last_name": "Heunen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Robin", + "last_name": "Kaarsgaard", + "institution": "University of Southern Denmark" + } + ], + "dblp_key": "journals/pacmpl/FangHK26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776673", + "title": "Abstraction Functions as Types: Modular Verification of Cost and Behavior in Dependent Type Theory", + "abstract": "Software development depends on the use of libraries whose public specifications inform client code and impose obligations on private implementations; it follows that verification at scale must also be modular, preserving such abstraction. Hoare's influential methodology uses abstraction functions to demonstrate the coherence between such concrete implementations and their abstract specifications. However, the Hoare methodology relies on a conventional separation between implementation and specification, providing no linguistic support for ensuring that this convention is obeyed. This paper proposes a synthetic account of Hoare's methodology within univalent dependent type theory by encoding the data of abstraction functions within types themselves. This is achieved via a phase distinction, which gives rise to a gluing construction that renders an abstraction function as a type and a pair of modalities that fracture a type into its concrete and abstract parts. A noninterference theorem governing the phase distinction characterizes the modularity guarantees provided by the theory. This approach scales to verification of cost, allowing the analysis of client cost relative to a cost-aware specification. A monadic sealing effect facilitates modularity of cost, permitting an implementation to be upper-bounded by its specification in cases where private details influence observable cost. The resulting theory supports modular development of programs and proofs in a manner that hides private details of no concern to clients while permitting precise specifications of both the cost and behavior of programs.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776673", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Harrison", + "last_name": "Grodin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Runming", + "last_name": "Li", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/GrodinLH26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776645", + "title": "Normalisation for First-Class Universe Levels", + "abstract": "Various mechanisms are available for managing universe levels in proof assistants based on type theory. The Agda proof assistant implements a strong form of universe polymorphism in which universe levels are internalised as a type, making levels first-class objects and permitting higher-rank quantification via ordinary Π-types. We prove normalisation and decidability of equality and type-checking for a type theory with first-class universe levels inspired by Agda. We also show that level primitives can safely be erased in extracted programs. Our development is formalised in Agda itself and builds upon previous work which uses logical relations on extrinsically typed syntax.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776645", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nils Anders", + "last_name": "Danielsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Naïm Camille", + "last_name": "Favier", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Ondřej", + "last_name": "Kubánek", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "journals/pacmpl/DanielssonFK26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776671", + "title": "Separating the Wheat from the Chaff: Understanding (In-)Completeness of Proof Mechanisms for Separation Logic with Inductive Definitions", + "abstract": "For over two decades Separation Logic has enjoyed its unique position as arguably the most popular framework for reasoning about heap-manipulating programs, as well as reasoning about shared resources and permissions. Separation Logic is often extended to include inductively-defined predicates, interpreted as least fixpoints, to form what is known as Separation Logic with Inductive Definitions (SLID). These inductive predicates are used to describe unbounded data-structures in the heap and to verify key properties thereof. Many theoretical and practical advances have been made in developing automated proof mechanisms for SLID, but by their very nature these mechanisms are imperfect, and a deeper understanding of their failures is desired. As expressive as Separation Logic is, it is not surprising that it is incomplete: there is no procedure that will provide a proof for all valid entailments in Separation Logic. In fact, at its very core, Separation Logic contains several sources of incompleteness that defy automated reasoning. In this paper we study these sources of incompleteness and how they relate to failures of proof mechanisms of SLID. We contextualize SLID within a larger, relaxed logic, that we call Weak Separation Logic (WSL). We prove that unlike SLID, WSL enjoys completeness for a non-trivial fragment of quantified entailments with background theories and inductive definitions, via a reduction to first-order logic (FOL). Moreover, we show that the ubiquitous fold/unfold proof mechanism, which is unsurprisingly incomplete for SLID, does constitute a sound and complete proof mechanism of WSL, for theory-free, quantifier-free entailments with inductive definitions. In some sense, this shows that WSL is the natural logic of such proof mechanisms. Through this contextualization of SLID within WSL, we understand proof failures as stemming from rogue, nonstandard models, that exist within the class of models considered by WSL, but do not adhere to the stricter requirements of SLID. These rogue models are typically infinite, and we use the recently proposed formalism of symbolic structures to represent and automatically find them. We present a prototype tool that implements the encoding of WSL to FOL and test it on an existing benchmark, which contains over 700 quantified entailment problems with inductive definitions, a third of which also contain background theories. Our tool is able to find counter-models to many of the examples, and we provide a partial taxonomy of the rogue models, shedding some light on real-world proof failures.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776671", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Neta", + "last_name": "Elad", + "institution": "Tel Aviv University" + }, + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/EladMS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776719", + "title": "Foundational Multi-Modal Program Verifiers", + "abstract": "Multi-modal program verification is a process of validating code against its specification using both dynamic and symbolic techniques, and proving its correctness by a combination of automated and interactive machine-assisted tools. In order to be trustworthy, such verification tools must themselves come with formal soundness proofs, establishing that any program verified in them against a certain specification does not violate the specification's statement when executed. Verification tools that are proven sound in a general-purpose proof assistant with a small trusted core are commonly referred to as foundational. We present a framework that facilitates and streamlines construction of program verifiers that are both foundational and multi-modal. Our approach adopts the well-known idea of monadic shallow embedding of an executable program semantics into the programming language of a theorem prover based on higher-order logic, in our case, the Lean proof assistant. We provide a library of monad transformers for such semantics, encoding a variety of computational effects, including state, divergence, exceptions, and non-determinism. The key theoretical innovation of our work are monad transformer algebras that enable automated derivation of the respective sound verification condition generators. We show that proofs of the resulting verification conditions enjoy automation using off-the-shelf SMT solvers and allow for an interactive proof mode when automation fails. To demonstrate versatility of our framework, we instantiated it to embed two foundational multi-modal verifiers into Lean for reasoning about (1) distributed protocol safety and (2) Dafny-style specifications of imperative programs, and used them to mechanically verify a number of non-trivial case studies.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776719", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Vladimir", + "last_name": "Gladshtein", + "institution": "National University of Singapore" + }, + { + "first_name": "George", + "last_name": "Pîrlea", + "institution": "National University of Singapore" + }, + { + "first_name": "Qiyuan", + "last_name": "Zhao", + "institution": "National University of Singapore" + }, + { + "first_name": "Vitaly", + "last_name": "Kurin", + "institution": "Neapolis University Pafos" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/GladshteinPZKS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776654", + "title": "JAX Autodiff from a Linear Logic Perspective", + "abstract": "JAX Autodiff refers to the core of the automatic differentiation (AD) systems developed in projects like JAX and Dex. JAX Autodiff has recently been formalised in a linear typed calculus by Radul et al in POPL 2023. Although this formalisation suffices to express the main program transformations of AD, the calculus is very specific to this task, and it is not clear whether the type system yields a substructural logic that has interest on its own. We propose an encoding of JAX Autodiff into a linear λ-calculus that enjoys a Curry-Howard correspondence with Girard’s linear logic. We prove that the encoding is sound both qualitatively (the encoded terms are extensionally equivalent to the original ones) and quantitatively (the encoding preserves the original work cost as described in Radul et al). As a byproduct, we show that unzipping, one of the transformations used to implement backpropagation in JAX Autodiff, is, in fact, optional.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776654", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Giulia", + "last_name": "Giusti", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "M.", + "last_name": "Pagani", + "institution": "Université Claude Bernard Lyon 1" + } + ], + "dblp_key": "journals/pacmpl/GiustiP26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776660", + "title": "ChiSA: Static Analysis for Lightweight Chisel Verification", + "abstract": "The growing demand for productivity in hardware development opens up new opportunities for applying programming language (PL) techniques to hardware description languages (HDLs). Chisel, a leading agile HDL, embraces this shift by leveraging modern PL features to enhance hardware design productivity. However, verification for Chisel remains a major productivity bottleneck, requiring substantial time and manual effort. To address this issue, we advocate the use of static analysis —a technique proven well-suited to agile development workflows in software—for lightweight Chisel verification. This work establishes a theoretical foundation for Chisel static analysis. At its core is λ C , a formal core calculus of ChAIR (a Chisel-specific intermediate representation for analysis). λ C is the first formalism that captures the essence of Chisel while being deliberately minimal to ease rigorous reasoning about static analysis built on λ C . We prove key properties of λ C that reflect real hardware characteristics, which in turn offer a form of retrospective validation for its design. On the basis of λ C , we define and formalize the hardware value flow analysis (HVFA) problem, which underpins our static analyses for critical Chisel verification tasks, including bug detection and security analysis. We then propose a synchronized fixed-point solution to the HVFA problem, featuring hardware-specific treatment of the synchronous behavior of clock-driven hardware registers—the essential feature of Chisel programs. We further prove key theorems establishing the guarantees and limitations of our solution. As a proof of concept, we develop ChiSA (30K+ LoC)—the first Chisel static analyzer that can analyze intricate hardware value flows to enable lightweight analyses for critical Chisel verification tasks such as bug detection and security analysis. To facilitate thorough evaluation of both ChiSA and future work, we provide ChiSABench (11M+ LoC), a comprehensive benchmark for Chisel static analysis. Our evaluation on ChiSABench demonstrates that ChiSA offers an effective and significantly more lightweight approach for critical Chisel verification tasks, especially on large and complex real-world designs. For example, ChiSA identified 69 violable developer-inserted assertions in large-scale Chisel designs (9.7M+ LoC) in under 200 seconds—eight of which were recognized by developers and scheduled for future fixes—and detected all 60 information-leak vulnerabilities in the well-known TrustHub benchmark (1.1M+ LoC) in just one second—outperforming state-of-the-art Chisel approaches like ChiselTest’s bounded model checking and ChiselFlow’s secure type system. These results underscore the high promise of static analysis for lightweight Chisel verification. To encourage continued research and innovation, we will fully open-source ChiSA (30K+ LoC) and ChiSABench (11M+ LoC).", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776660", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jiacai", + "last_name": "Cui", + "institution": "Nanjing University" + }, + { + "first_name": "Q. R.", + "last_name": "Chen", + "institution": "Nanjing University" + }, + { + "first_name": "Zhongsheng", + "last_name": "Zhan", + "institution": "Nanjing University" + }, + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "Nanjing University" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/CuiCZTL26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776669", + "title": "Security Reasoning via Substructural Dependency Tracking", + "abstract": "Substructural type systems provide the ability to speak about resources . By enforcing usage restrictions on inputs to computations they allow programmers to reify limited system units—such as memory—in types. We demonstrate a new form of resource reasoning founded on constraining outputs and explore its utility for practical programming. In particular, we identify a number of disparate programming features explored largely in the security literature as various fragments of our unified framework. These encompass capabilities, quantitative information leakage, sandboxing in the style of the Linux seccomp interface, authorization protocols, and more. We furthermore explore its connection to conventional input-based resource reasoning, casting it as an internal treatment of the constructive Kripke semantics of substructural logics. We verify the capability , quantity , and protocol safety of our system through a single logical relations argument. In doing so, we take the first steps towards obtaining the ultimate multitool for security reasoning.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776669", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hemant", + "last_name": "Gouni", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/GouniPA26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776687", + "title": "Recurrence Sets for Proving Fair Non-termination under Axiomatic Memory Consistency Models", + "abstract": "Recurrence sets characterize non-termination in sequential programs. We present a generalization of recurrence sets to concurrent programs that run on weak memory models. Sequential programs have operational semantics in terms of states and transitions, and classical recurrence sets are defined as sets of states that are existentially closed under transitions. Concurrent programs have axiomatic semantics in terms of executions, and our new recurrence sets are defined as sets of executions that are existentially closed under extensions. The semantics of concurrent programs is not only affected by the memory model, but also by fairness assumptions about its environment, be it the scheduler or the memory subsystems. Our new recurrence sets are formulated relative to such fairness assumptions. We show that our recurrence sets are sound for proving fair non-termination on all practical memory models, and even complete on many. To turn our theory into practice, we develop a new automated technique for proving fair non-termination in concurrent programs on weak memory models. At the heart of this technique is a finite representation of recurrence sets in terms of execution-based lassos. We implemented a lasso-finding algorithm in Dartagnan, and evaluated it on a number of programs running under CPU and GPU memory models.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776687", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Haas", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Hernán Ponce de", + "last_name": "León", + "institution": "Huawei German Research Center" + }, + { + "first_name": "Andrés Lomelí", + "last_name": "Garduño", + "institution": "Huawei German Research Center" + } + ], + "dblp_key": "journals/pacmpl/HaasMLG26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776691", + "title": "Verifying Almost-Sure Termination for Randomized Distributed Algorithms", + "abstract": "We present a technique for the verification of liveness properties of randomized distributed algorithms. Our technique gives SMT-based proofs for many common consensus algorithms, both for crash faults and for Byzantine faults. It is based on a sound proof rule for fair almost-sure termination of distributed systems that combines martingale-based techniques for almost-sure termination with reasoning about weak fairness. Our proof rule is able to handle parametrized protocols where the state grows unboundedly and every variant function is unbounded. These protocols were out of scope for previous approaches, which either relied on bounded variant functions or on reductions to (non-probabilistic) fairness. We have implemented our proof rules on top of Caesar, a program verifier for probabilistic programs. We use our proof rule to give SMT-based proofs for termination properties of randomized asynchronous consensus protocols, including Ben-Or's protocol and graded binary consensus, for both crash and Byzantine faults. These protocols have notoriously difficult proofs of termination but fall within the scope of our proof rule.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776691", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "École Polytechnique" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Harshit J.", + "last_name": "Motwani", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "V. R.", + "last_name": "Sathiyanarayana", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/EneaMMS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776665", + "title": "Quotient Polymorphism", + "abstract": "Quotient types increase the power of type systems by allowing types to include equational properties. However, two key practical issues arise: code being duplicated, and valid code being rejected. Specifically, function definitions often need to be repeated for each quotient of a type, and valid functions may be rejected if they include subterms that do not respect the quotient. This article addresses these reusability and expressivity issues by introducing a notion of quotient polymorphism that we call choice polymorphism . We give practical examples of its use, develop the underlying theory, and implement it in Quotient Haskell.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776665", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Brandon", + "last_name": "Hewer", + "institution": "University of Nottingham" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/HewerH26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776696", + "title": "Bayesian Separation Logic: A Logical Foundation and Axiomatic Semantics for Probabilistic Programming", + "abstract": "Bayesian probabilistic programming languages (BPPLs) let users denote statistical models as code while the interpreter infers the posterior distribution. The semantics of BPPLs are usually mathematically complex and unable to reason about desirable properties such as expected values and independence of random variables. To reason about these properties in a non-Bayesian setting, probabilistic separation logics such as PSL and Lilac interpret separating conjunction as probabilistic independence of random variables. However, no existing separation logic can handle Bayesian updating, which is the key distinguishing feature of BPPLs. To close this gap, we introduce Bayesian separation logic (BaSL), a probabilistic separation logic that gives semantics to BPPL. We prove an internal version of Bayes’ theorem using a result in measure theory known as the Rokhlin-Simmons disintegration theorem. Consequently, BaSL can model probabilistic programming concepts such as Bayesian updating, unnormalised distribution, conditional distribution, soft constraint, conjugate prior and improper prior while maintaining modularity via the frame rule. The model of BaSL is based on a novel instantiation of Kripke resource monoid via σ-finite measure spaces over the Hilbert cube, and the semantics of Hoare triple is compatible with an existing denotational semantics of BPPL based on the category of s -finite kernels. Using BaSL, we then prove properties of statistical models such as the expected value of Bayesian coin flip, correlation of random variables in the collider Bayesian network, the posterior distributions of the burglar alarm model, a parameter estimation algorithm, and the Gaussian mixture model.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776696", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shing Hin", + "last_name": "Ho", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/HoWR26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776731", + "title": "Quantum Circuits Are Just a Phase", + "abstract": "Quantum programs today are written at a low level of abstraction - quantum circuits akin to assembly languages - and the unitary parts of even advanced quantum programming languages essentially function as circuit description languages. This state of affairs impedes scalability, clarity, and support for higher-level reasoning. More abstract and expressive quantum programming constructs are needed. To this end, we introduce a simple syntax for generating unitaries from \"just a phase\"; we combine a (global) phase operation that captures phase shifts with a quantum analogue of the \"if let\" construct that captures subspace selection via pattern matching. This minimal language lifts the focus from gates to eigendecomposition, conjugation, and controlled unitaries; common building blocks in quantum algorithm design. We demonstrate several aspects of the expressive power of our language in several ways. Firstly, we establish that our representation is universal by deriving a universal quantum gate set. Secondly, we show that important quantum algorithms can be expressed naturally and concisely, including Grover's search algorithm, Hamiltonian simulation, Quantum Fourier Transform, Quantum Signal Processing, and the Quantum Eigenvalue Transformation. Furthermore, we give clean denotational semantics grounded in categorical quantum mechanics. Finally, we implement a prototype compiler that efficiently translates terms of our language to quantum circuits, and prove that it is sound with respect to these semantics. Collectively, these contributions show that this construct offers a principled and practical step toward more abstract and structured quantum programming.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776731", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Chris", + "last_name": "Heunen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Louis", + "last_name": "Lemonnier", + "institution": "University of Edinburgh" + }, + { + "first_name": "Christopher M.", + "last_name": "McNally", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Alex", + "last_name": "Rice", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/HeunenLMR26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3771762", + "title": "Corrigendum: Unrealizability Logic", + "abstract": "This is a corrigendum for the article \"Unrealizability Logic\" by Jinwoo Kim, Loris D’Antoni, and Thomas Reps, published in Proc. ACM Program. Lang. 7, POPL, Article 23 (January 2023), https://doi.org/10.1145/3571216. The authors, with the help of Shaan Nagy, discovered that there was an implicitly made assumption when stating soundness, and a flaw in the completeness proof of the original paper. This corrigendum clarifies the assumption made in the soundness statement and rectifies the completeness proof.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3771762", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jinwoo", + "last_name": "Kim", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/KimDR26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776733", + "title": "Coco: Corecursion with Compositional Heterogeneous Productivity", + "abstract": "Contemporary proof assistants impose restrictive syntactic guardedness conditions that reject many valid corecursive definitions. Existing approaches to overcome these restrictions present a fundamental trade-off between coverage and automation. We present Compositional Heterogeneous Productivity (CHP), a theoretical framework that unifies high automation with extensive coverage for corecursive definitions. CHP introduces heterogeneous productivity applicable to functions with diverse domain and codomain types, including non-coinductive types. Its key innovation is compositionality: the productivity of composite functions is systematically computed from their components, enabling modular reasoning about complex corecursive patterns. Building on CHP, we develop Coco, a corecursion library for Rocq that provides extensive automation for productivity computation and fixed-point generation.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776733", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jaewoo", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Yeonwoo", + "last_name": "Nam", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/KimNH26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776703", + "title": "Di- is for Directed: First-Order Directed Type Theory via Dinaturality", + "abstract": "We show how dinaturality plays a central role in the interpretation of directed type theory where types are given by (1-)categories and directed equality by hom-functors. We introduce a first-order directed type theory where types are semantically interpreted as categories, terms as functors, predicates as dipresheaves, and proof-relevant entailments as dinatural transformation. This type theory is equipped with an elimination principle for directed equality, motivated by dinaturality, which closely resembles the J-rule used in Martin-Löf type theory. This directed J-rule comes with a simple syntactic restriction which recovers all theorems about symmetric equality, except for symmetry. Dinaturality is used to prove properties about transitivity (composition), congruence (functoriality), and transport (coYoneda) in exactly the same way as in Martin-Löf type theory, and allows us to obtain an internal \"naturality for free\". We then argue that the quantifiers of directed type theory should be ends and coends, which dinaturality allows us to capture formally. Our type theory provides a formal treatment to (co)end calculus and Yoneda reductions, which we use to give distinctly logical proofs to the (co)Yoneda lemma, the adjointness property of Kan extensions via (co)ends, exponential objects of presheaves, and the Fubini rule for quantifier exchange. Our main theorems are formalized in Agda.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776703", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Laretto", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Fosco", + "last_name": "Loregiàn", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Niccolò", + "last_name": "Veltrì", + "institution": "Tallinn University of Technology" + } + ], + "dblp_key": "journals/pacmpl/LarettoLV26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776681", + "title": "Handling Scope Checks: A Comparative Framework for Dynamic Scope Extrusion Checks", + "abstract": "Metaprogramming and effect handlers interact in unexpected, and sometimes undesirable, ways. One example is scope extrusion: the generation of ill-scoped code. Scope extrusion can either be preemptively prevented, via static type systems, or retroactively detected, via dynamic checks. Static type systems exist in theory, but struggle with a range of implementation and usability problems in practice. In contrast, dynamic checks exist in practice (e.g. in MetaOCaml), but are understudied in theory. Designers of metalanguages are thus given little guidance regarding the design and implementation of checks. We present the first formal study of dynamic scope extrusion checks, introducing a calculus (λ ⟨⟨op⟩⟩ ) for describing and evaluating checks. Further, we introduce a novel dynamic check — the “Cause-for-Concern” check — which we prove correct, characterise without reference to its implementation, and argue combines the advantages of existing dynamic checks. Finally, we extend our framework with refined environment classifiers, which statically prevent scope extrusion, and compare their expressivity with the dynamic checks.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776681", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Lee", + "institution": "University of Cambridge" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Toronto" + }, + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "Tohoku University" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/LeeXKY26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776721", + "title": "Welterweight Go: Boxing, Structural Subtyping, and Generics", + "abstract": "Go’s unique combination of structural subtyping between generics and types with non-uniform runtime representations presents significant challenges for formalising the language. We introduce WG (Welterweight Go), a core model of Go that captures key features excluded by prior work, including underlying types, type constraints and type sets, and proposed new features, such as generic methods. We also develop LWG, a lower-level language that models Go’s runtime mechanisms, notably the distinction between raw struct values and interface values that carry runtime type information (RTTI). We give a type-directed compilation from WG to LWG that demonstrates how the proposed features can be implemented while observing important design and implementation goals for Go: compatibility with separate compilation, and no runtime code generation. Unlike existing approaches based on static monomorphisation, our compilation strategy uses runtime type conversions and adaptor methods to handle the complex interactions between structural subtyping, generics, and Go’s runtime infrastructure.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776721", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Julien", + "last_name": "Lange", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + }, + { + "first_name": "Robert", + "last_name": "Griesemer", + "institution": "Google (United States)" + }, + { + "first_name": "Keith H.", + "last_name": "Randall", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/HuLTWGR26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776699", + "title": "Domain-Theoretic Semantics for Functional Logic Programming", + "abstract": "Functional Logic Programming (FLP) is a paradigm that extends higher-order functional programming with nondeterministic choice, logical variables, and equational constraints. Starting from the observation that these constructs can be presented as algebraic effects, we rationally reconstruct a core calculus for FLP that is based on call-by-push-value, and supports higher-order functions and recursion. We show how to execute its programs through an abstract machine that implements narrowing. Finally, we present a domain-theoretic semantics based on the lower powerdomain, which we prove to be sound, adequate, and fully abstract with respect to the machine. This leads to an exploration of the limitations of domain theory in modelling FLP.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776699", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Eddie", + "last_name": "Jones", + "institution": "University of Bristol" + }, + { + "first_name": "Samson", + "last_name": "Main", + "institution": "University of Bristol" + }, + { + "first_name": "C.M.", + "last_name": "Li", + "institution": "University of Bristol" + }, + { + "first_name": "Jonathan", + "last_name": "Marriott", + "institution": "University of Bristol" + }, + { + "first_name": "G. A.", + "last_name": "Kavvos", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/JonesMLMK26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776706", + "title": "An Equational Axiomatization of Dynamic Threads via Algebraic Effects: Presheaves on Finite Relations, Labelled Posets, and Parameterized Algebraic Theories", + "abstract": "We use the theory of algebraic effects to give a complete equational axiomatization for dynamic threads. Our method is based on parameterized algebraic theories, which give a concrete syntax for strong monads on functor categories, and are a convenient framework for names and binding. Our programs are built from the key primitives 'fork' and 'wait'. 'Fork' creates a child thread and passes its name (thread ID) to the parent thread. 'Wait' allows us to wait for given child threads to finish. We provide a parameterized algebraic theory built from fork and wait, together with basic atomic actions and laws such as associativity of 'fork'. Our equational axiomatization is complete in two senses. First, for closed expressions, it completely captures equality of labelled posets (pomsets), an established model of concurrency: model complete. Second, any two open expressions are provably equal if they are equal under all closing substitutions: syntactically complete. The benefit of algebraic effects is that the semantic analysis can focus on the algebraic operations of fork and wait. We then extend the analysis to a simple concurrent programming language by giving operational and denotational semantics. The denotational semantics is built using the methods of parameterized algebraic theories and we show that it is sound, adequate, and fully abstract at first order for labelled-poset observations.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776706", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jack", + "last_name": "Liell-Cock", + "institution": "University of Oxford" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "Cristina", + "last_name": "Matache", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/KammarLLMS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776718", + "title": "Big-Stop Semantics: Small-Step Semantics in a Big-Step Judgment", + "abstract": "As is evident in the programming language literature, many practitioners favor specifying dynamic program behavior using big-step over small-step semantics. Unlike small-step semantics, which must dwell on every intermediate program state, big-step semantics conveniently jumps directly to the ever-important result of the computation. Big-step semantics also typically involves fewer inference rules than their small-step counterparts. However, in exchange for ergonomics, big-step semantics gives up power: Small-step semantics describes program behaviors that are outside the grasp of big-step semantics, notably divergence. This work presents a little-known extension of big-step semantics with inductive definitions that captures diverging computations without introducing error states. This big-stop semantics is illustrated for typed, untyped, and effectful variants of PCF. Big-stop semantics extends the standard big-step inference rules with a few additional rules to define an evaluation judgment that is equivalent to the reflexive-transitive closure of small-step transitions. This simple extension contrasts with other solutions in the literature that sacrifice ergonomics by introducing many additional inference rules, global state, and/or less-commonly-understood reasoning principles like coinduction. The ergonomics of big-stop semantics is exemplified via concise Agda proofs for some key results and compilation theorems.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776718", + "conference_name": "POPL", + "authors": [ + { + "first_name": "David M.", + "last_name": "Kahn", + "institution": "Denison University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Runming", + "last_name": "Li", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/KahnHL26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776685", + "title": "Canonicity for Indexed Inductive-Recursive Types", + "abstract": "We prove canonicity for a Martin-Löf type theory with a countable universe hierarchy where each universe supports indexed inductive-recursive (IIR) types. We proceed in two steps. First, we construct IIR types from inductive-recursive (IR) types and other basic type formers, in order to simplify the subsequent canonicity proof. The constructed IIR types support the same definitional computation rules that are available in Agda's native IIR implementation. Second, we give a canonicity proof for IR types, building on the established method of gluing along the global sections functor. The main idea is to encode the canonicity predicate for each IR type using a metatheoretic IIR type.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776685", + "conference_name": "POPL", + "authors": [ + { + "first_name": "András", + "last_name": "Kovács", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "journals/pacmpl/Kovacs26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776649", + "title": "Hyperfunctions: Communicating Continuations", + "abstract": "A hyperfunction is a continuation-like construction that can be used to implement communication in the context of concurrency. Though it has been reinvented many times, it remains somewhat obscure: since its definition by Launchbury et al., hyperfunctions have been used to implement certain algebraic effect handlers, coroutines, and breadth-first traversals; however, in each of these examples, the hyperfunction type went unrecognised. We identify the hyperfunctions hidden in all of these algorithms, and we exposit the common pattern between them, building a framework for working with and reasoning about hyperfunctions. We use this framework to solve a long-standing problem: giving a fully-abstract continuation-based semantics for a concurrent calculus, the Calculus of Communicating Systems. Finally, we use hyperfunctions to build a monadic Haskell library for efficient first-class coroutines.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776649", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Donnacha Oisín", + "last_name": "Kidney", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/KidneyW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776690", + "title": "Miri: Practical Undefined Behavior Detection for Rust", + "abstract": "The Rust programming language has two faces: on the one hand, it is a high-level language with a strong type system ensuring memory and thread safety. On the other hand, Rust crucially relies on unsafe code for cases where the compiler is unable to statically ensure basic safety properties. The challenges of writing unsafe Rust are similar to those of writing C or C++: a single mistake in the program can lead to Undefined Behavior, which means the program is no longer described by the language's Abstract Machine and can go wrong in arbitrary ways, often causing security issues. Ensuring the absence of Undefined Behavior bugs is therefore a high priority for unsafe Rust authors. In this paper we present Miri, the first tool that can find all de-facto Undefined Behavior in deterministic Rust programs. Some of the key non-trivial features of Miri include tracking of pointer provenance, validation of Rust type invariants, data-race detection, exploration of weak memory behaviors, and implementing enough basic OS APIs (such as file system access and concurrency primitives) to be able to run unchanged real-world Rust code. In an evaluation on more than 100 000 Rust libraries, Miri was able to successfully execute more than 70% of the tests across their combined test suites. Miri has found dozens of real-world bugs and has been integrated into the continuous integration of the Rust standard library and many prominent Rust libraries, preventing many more bugs from ever entering these codebases.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776690", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "ETH Zurich" + }, + { + "first_name": "Benjamin Joseph", + "last_name": "Kimock", + "institution": "National Labor College" + }, + { + "first_name": "Christian Rodrigo Aguilar", + "last_name": "Poveda", + "institution": "Institución Universitaria Colombo Americana" + }, + { + "first_name": "Eduardo Sánchez", + "last_name": "Muñoz", + "institution": "Universidad de Oviedo" + }, + { + "first_name": "Oli", + "last_name": "Scherer", + "institution": "Karlsruhe University of Applied Sciences" + }, + { + "first_name": "Qian", + "last_name": "Wang", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/JungKPMSW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776694", + "title": "Inductive Program Synthesis by Meta-Analysis-Guided Hole Filling", + "abstract": "A popular approach to inductive program synthesis is to construct a target program via top-down search, starting from an incomplete program with holes and gradually filling these holes until a solution is found. During the search, abstraction-based pruning is used to eliminate infeasible candidate programs, significantly reducing the search space. Because of this pruning, the order in which holes are filled can drastically affect search efficiency: a wise choice can prune large swaths of the search space early, while a poor choice might explore many dead-ends. However, the choice of hole-filling order is largely unattended in program synthesis literature. In this paper, we propose a novel hole-filling strategy that leverages abstract interpretation to guide the order of hole-filling in program synthesis. Our approach overapproximates the behavior of the underlying abstract interpreter for pruning, enabling it to predict the most promising hole to fill next. We instantiate our approach to the domains of bitvectors and strings, which are commonly used in program synthesis tasks. We evaluate our approach on a set of benchmarks from the prior work, including SyGuS benchmarks, and show that it significantly outperforms the state-of-the-art approaches in terms of efficiency thanks to the abstract abstract interpretation techniques.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776694", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Doyoon", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Woosuk", + "last_name": "Lee", + "institution": "Hanyang University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/LeeLY26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776727", + "title": "What Is a Monoid?", + "abstract": "In many situations one encounters an entity that resembles a monoid. It consists of a carrier and two operations that resemble a unit and a multiplication, subject to three equations that resemble associativity and left and right unital laws. The question then arises whether this entity is, in fact, a monoid in a suitable sense. Category theorists have answered this question by providing a notion of monoid in a monoidal category, or more generally in a multicategory. While these encompass many examples, there remain cases which do not fit into these frameworks, such as the notion of relative monad and the modelling of call-by-push-value sequencing. In each of these examples, the leftmost and/or the rightmost factor of a multiplication or associativity law seems to be distinguished. To include such examples, we generalize the multicategorical framework in two stages. Firstly, we move to the framework of a left-skew multicategory (due to Bourke and Lack), which generalizes both multicategory and left-skew monoidal category. The notion of monoid in this framework encompasses examples where only the leftmost factor is distinguished, such as the notion of relative monad. Secondly, we consider monoids in the novel framework of a bi-skew multicategory. This encompasses examples where both the leftmost and the rightmost factor are distinguished, such as the notion of a category on a span, and the modelling of call-by-push-value sequencing. In the bi-skew framework (which is the most general), we give a coherence result saying that a monoid corresponds to an unbiased monoid, i.e. a map from the terminal bi-skew multicategory.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776727", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paul Blain", + "last_name": "Levy", + "institution": "University of Birmingham" + }, + { + "first_name": "Morgan", + "last_name": "Rogers", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "journals/pacmpl/LevyR26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776724", + "title": "A Complementary Approach to Incorrectness Typing", + "abstract": "We introduce a new two-sided type system for verifying the correctness and incorrectness of functional programs with atoms and pattern matching. A key idea in the work is that types should range over sets of normal forms, rather than sets of values, and this allows us to define a complement operator on types that acts as a negation on typing formulas. We show that the complement allows us to derive a wide range of refutation principles within the system, including the type-theoretic analogue of co-implication, and we use them to certify that a number of Erlang-like programs go wrong. An expressive axiomatisation of the complement operator via subtyping is shown decidable, and the type system as a whole is shown to be not only sound, but also complete for normal forms.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776724", + "conference_name": "POPL", + "authors": [ + { + "first_name": "C.M.", + "last_name": "Li", + "institution": "University of Bristol" + }, + { + "first_name": "Sophie", + "last_name": "Pull", + "institution": "University of Bristol" + }, + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/LiPR26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776704", + "title": "Encode the Cake and Eat It Too: Controlling Computation in Type Theory, Locally", + "abstract": "Proof assistants based on dependent type theory such as Agda, Lean and Rocq identify objects up to computation during proof checking. This takes away some of the proof burden from the user and even provides a way to get very efficient automation. Recently, Agda and Rocq have been extended to support user-defined computation. While they already prove very useful, user-defined computation rules are *global*: once they are added, they are here to stay. Importing a development that makes use of those rules then means relying on them, whether we want it or not, which can lead to unwanted incompatibilities. We design LRTT, a type theory with support for *local* abstraction over user-defined computation rules. This takes the form of a prenex quantification at the definition level. This quantification is supplemented with the possibility to provide one or several instantiations that verify the equations definitionally. We show that a procedure inlining definitions abstracting over definitional equality is possible, in the style of monomorphisation or of C++ templates. In the process we get a conservativity result over more conventional Martin-Löf type theories. There are several benefits to such a system. First, it provides encapsulation for user-defined computation rules, which is important to avoid unwanted bad interactions and limits the scope in which invariants of type theory (such as termination, confluence, type preservation and consistency) are broken. Second, abstraction lets users factorise code that crucially relies on definitional equality, as well as hide implementation details that are irrelevant in some settings. Finally, it gives a way to encode certain features without paying the price of the encoding. We showcase such examples in a prototype implementation as an extension of the Rocq Prover. Additionally, all the results in this have been formalised in Rocq.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776704", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yann", + "last_name": "Leray", + "institution": "Centre Inria de l'Université de Rennes" + }, + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "Institut de Chimie des Substances Naturelles" + } + ], + "dblp_key": "journals/pacmpl/LerayW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776702", + "title": "The Relative Monadic Metalanguage", + "abstract": "Relative monads provide a controlled view of computation. We generalise the monadic metalanguage to a relative setting and give a complete semantics with strong relative monads. Adopting this perspective, we generalise two existing program calculi from the literature. We provide a linear-non-linear language for graded monads, LNL-RMM, along with a semantic proof that it is a conservative extension of the graded monadic metalanguage. Additionally, we provide a complete semantics for the arrow calculus, showing it is a restricted relative monadic metalanguage. This motivates the introduction of ARMM, a computational lambda calculus-style language for arrows that conservatively extends the arrow calculus.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776702", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jack", + "last_name": "Liell-Cock", + "institution": "University of Oxford" + }, + { + "first_name": "Zev", + "last_name": "Shirazi", + "institution": "University of Oxford" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/LiellCockSS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776672", + "title": "Algorithmic Conversion with Surjective Pairing: A Syntactic and Untyped Approach", + "abstract": "In a dependent type theory with β-equivalence as its equational theory, the confluence of untyped reduction and termination immediately give us a proof of the decidability of type conversion, where the decision procedure for convertibility simply checks the equality of the β-normal forms of its inputs. This technique is not available in the presence of surjective pairing (i.e. the η-law for pairs) because βη-reduction is not confluent. In this work, we show that by adopting established syntactic techniques, we can resolve the issue with confluence caused by surjective pairing, and recover a confluence-based proof of decidability of type conversion. Compared to existing proof developments, which rely on semantic tools such as Kripke-style logical relations, our proof modularly composes a minimal semantic proof of untyped normalization and a syntactic proof of decidability. This modularity enables us to explore algorithmic conversion through syntactic methods without modifying the minimal semantic proof. We have fully mechanized our results using the Rocq theorem prover.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776672", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yiyun", + "last_name": "Liu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LiuW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776726", + "title": "Parameterized Infinite-State Reactive Synthesis", + "abstract": "We propose a method to synthesize a parameterized infinite-state system that can be instantiated for different parameter values. The specification is given in a parameterized temporal logic that allows for data variables as well as parameters that encode properties of the environment. Our synthesis method runs in a counterexample-guided loop consisting of four steps: (1) we synthesize concrete systems for some small parameter instantiations using existing techniques. (2) We generalize the concrete systems into a parameterized program. (3) We create a proof candidate consisting of an invariant and a ranking function. (4) We check the proof candidate for consistency with the program. If the proof succeeds, the parameterized program is valid. Otherwise, we identify a parameter value for which it fails and add a new concrete instance to step one. To generalize programs and create proof candidates, we use a combination of anti-unification and syntax-guided synthesis to express the differences between the programs as a function of the parameters. We evaluate our approach on new examples and examples from the literature that are manually parameterized.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776726", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benedikt", + "last_name": "Maderbacher", + "institution": "Graz University of Technology" + }, + { + "first_name": "Roderick", + "last_name": "Bloem", + "institution": "Graz University of Technology" + } + ], + "dblp_key": "journals/pacmpl/MaderbacherB26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776698", + "title": "Determination Problems for Orbit Closures and Matrix Groups", + "abstract": "Computational problems concerning the orbit of a point under the action of a matrix group occur throughout computer science, including in program analysis, complexity theory, quantum computation, and automata theory. In many cases the focus extends beyond orbits proper to orbit closures under a suitable topology. Typically one starts from a group and a set of points and asks questions about the orbit closure of the set under the action of the group, e.g., whether two given orbit closures intersect. In this paper we consider a collection of what we call determination problems concerning matrix groups and orbit closures. These problems begin with a given variety and seek to understand whether and how it arises either as an algebraic matrix group or as an orbit closure. The how question asks whether the underlying group is s -generated, meaning it is topologically generated by s matrices for a given number s . Among other applications, problems of this type have recently been studied in the context of synthesising loops subject to certain specified invariants on program variables. Our main result is a polynomial-space procedure that inputs a variety and a number s and determines whether the given variety arises as an orbit closure of a point under an s -generated commutative algebraic matrix group. The main tools in our approach are structural properties of commutative algebraic matrix groups and module theory. We leave open the question of determining whether a variety is an orbit closure of a point under an s -generated algebraic matrix group (without the requirement of commutativity).", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776698", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rida Ait El", + "last_name": "Manssour", + "institution": "University of Oxford" + }, + { + "first_name": "George", + "last_name": "Kenison", + "institution": "Liverpool John Moores University" + }, + { + "first_name": "Mahsa", + "last_name": "Shirmohammadi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Anton", + "last_name": "Varonka", + "institution": "TU Wien" + }, + { + "first_name": "James", + "last_name": "Worrell", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/ManssourKSVW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776715", + "title": "Classical Notions of Computation and the Hasegawa-Thielecke Theorem", + "abstract": "In the spirit of the Curry-Howard correspondence between proofs and programs, we define and study a syntax and semantics for classical logic equipped with a computationally involutive negation, using a polarised effect calculus, the linear classical L-calculus. A main challenge in designing a denotational semantics for the calculus is to accommodate both call-by-value and call-by-name evaluation strategies, which leads to a failure of associativity of composition. In order to tackle this issue, we define a notion of adjunction between graph morphisms on non-associative categories, which we use to formulate polarized and non-associative notions of symmetric monoidal closed duploid and of dialogue duploid. We show that they provide a direct style counterpart to adjunction models: linear effect adjunctions for the (linear) call-by-push-value calculus and dialogue chiralities for linear continuations, respectively. In particular, we show that the syntax of the linear classical L-calculus can be interpreted in any dialogue duploid, and that it defines in fact a syntactic dialogue duploid. As an application, we establish, by semantic as well as syntactic means, the Hasegawa-Thielecke theorem, which states that the notions of central map and of thunkable map coincide in any dialogue duploid (in particular, for any double negation monad on a symmetric monoidal category).", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776715", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Éléonore", + "last_name": "Mangel", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Paul-André", + "last_name": "Melliès", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Guillaume", + "last_name": "Munch-Maccagnoni", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/MangelMM26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776648", + "title": "RapunSL: Untangling Quantum Computing with Separation, Linear Combination and Mixing", + "abstract": "Quantum Separation Logic (QSL) has been proposed as an effective tool to improve the scalability of deductive reasoning for quantum programs. In QSL, separation is interpreted as disentanglement, and the frame rule brings a notion of entanglement-local specification (one that only talks about the qubits entangled with those acted upon by the program). In this paper, we identify two notions of locality unique to the quantum domain, and we construct a novel quantum separation logic, RapunSL, which is able to soundly reduce reasoning about superposition states to reasoning about pure states (basis-locality), and reasoning about mixed states arising from measurement to reasoning about pure states (outcome-locality). To do so, we introduce two connectives, linear combination and mixing, which together with separation provide a dramatic improvement in the scalability of reasoning, as we demonstrate on a series of challenging case studies.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776648", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yusuke", + "last_name": "Matsushita", + "institution": "Kyoto University" + }, + { + "first_name": "K", + "last_name": "Hirata", + "institution": "Kyoto University" + }, + { + "first_name": "Ryo", + "last_name": "Wakizaka", + "institution": "Kyoto University" + }, + { + "first_name": "Emanuele", + "last_name": "D'Osualdo", + "institution": "University of Konstanz" + } + ], + "dblp_key": "journals/pacmpl/MatsushitaHWD26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776655", + "title": "TypeDis: A Type System for Disentanglement", + "abstract": "Disentanglement is a runtime property of parallel programs guaranteeing that parallel tasks remain oblivious to each other's allocations. As demonstrated in the MaPLe compiler and run-time system, disentanglement can be exploited for fast automatic memory management, especially task-local garbage collection with no synchronization between parallel tasks. However, as a low-level property, disentanglement can be difficult to reason about for programmers. The only means of statically verifying disentanglement so far has been DisLog, an Iris-fueled variant of separation logic, mechanized in the Rocq proof assistant. DisLog is a fully-featured program logic, allowing for proof of functional correctness as well as verification of disentanglement. Yet its employment requires significant expertise and per-program proof effort. This paper explores the route of automatic verification via a type system, ensuring that any well-typed program is disentangled and lifting the burden of carrying out manual proofs from the programmer. It contributes TypeDis, a type system inspired by region types, where each type is annotated with a timestamp, identifying the task that allocated it. TypeDis supports iso-recursive types as well as polymorphism over both types and timestamps. Crucially, timestamps are allowed to change during type-checking, at join points as well as via a form of subtyping, dubbed subtiming. The paper illustrates TypeDis and its features on a range of examples. The soundness of TypeDis and the examples are mechanized in the Rocq proof assistant, using an improved version of DisLog, dubbed DisLog2.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776655", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexandre", + "last_name": "Moine", + "institution": "New York University" + }, + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Alex", + "last_name": "Xu", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/MoineBXW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776717", + "title": "Oriented Metrics for Bottom-Up Enumerative Synthesis", + "abstract": "In syntax-guided synthesis, one of the challenges is to reduce the enormous size of the search space. We observe that most search spaces are not just flat sets of programs, but can be endowed with a structure that we call an oriented metric. Oriented metrics measure the distance between programs, like ordinary metrics do, but are designed for settings in which operations have an orientation. Our focus is on the string and the bitvector domains, where operations like concatenation and bitwise conjunction transform an input into an output in a way that is not symmetric. We develop several new oriented metrics for these domains. Oriented metrics are designed for search space reduction, and we present four techniques: (i) pruning the search space to a ball around the ground truth, (ii) factorizing the search space by an equivalence that is induced by the oriented metric, (iii) abstracting the oriented metric (and hence the equivalence) and refining it, and (iv) improving the enumeration order by learning from abstract information. We acknowledge that these techniques are inspired by developments in the literature. By understanding their roots in oriented metrics, we can substantially increase their applicability and efficiency. We have integrated these techniques into a new synthesis algorithm and implemented the algorithm in a new solver. Notably, our solver is generic in the oriented metric over which it computes. We conducted experiments in the string and the bitvector domains, and consistently improve the performance over the state-of-the-art by more than an order of magnitude.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776717", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Jakob", + "last_name": "Tepe", + "institution": "Technische Universität Braunschweig" + } + ], + "dblp_key": "journals/pacmpl/MeyerT26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776711", + "title": "Lazy Linearity for a Core Functional Language", + "abstract": "Traditionally, in linearly typed languages, consuming a linear resource is synonymous with its syntactic occurrence in the program. However, under the lens of non-strict evaluation, linearity can be further understood semantically, where a syntactic occurrence of a resource does not necessarily entail using that resource when the program is executed. While this distinction has been largely unexplored, it turns out to be inescapable in Haskell's optimising compiler, which heavily rewrites the source program in ways that break syntactic linearity but preserve the program's semantics. We introduce Linear Core, a novel system which accepts the lazy semantics of linearity statically and is suitable for lazy languages such as the Core intermediate language of the Glasgow Haskell Compiler. We prove that Linear Core is sound, guaranteeing linear resource usage, and that multiple optimising transformations preserve linearity in Linear Core while failing to do so in Core. We have implemented Linear Core as a compiler plugin to validate the system against linearity-heavy libraries, including linear-base.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776711", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rodrigo", + "last_name": "Mesquita", + "institution": "" + }, + { + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + } + ], + "dblp_key": "journals/pacmpl/MesquitaT26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776720", + "title": "Generating Compilers for Qubit Mapping and Routing", + "abstract": "To evaluate a quantum circuit on a quantum processor, one must find a mapping from circuit qubits to processor qubits and plan the instruction execution while satisfying the processor's constraints. This is known as the qubit mapping and routing (QMR) problem. High-quality QMR solutions are key to maximizing the utility of scarce quantum resources and minimizing the probability of logical errors affecting computation. The challenge is that the landscape of quantum processors is incredibly diverse and fast-evolving. Given this diversity, dozens of papers have addressed the QMR problem for different qubit hardware, connectivity constraints, and quantum error correction schemes by a developing a new algorithm for a particular context. We present an alternative approach: automatically generating qubit mapping and routing compilers for arbitrary quantum processors. Though each QMR problem is different, we identify a common core structure—device state machine—that we use to formulate an abstract QMR problem. Our formulation naturally leads to a compact domain-specific language for specifying QMR problems and a powerful parametric algorithm that can be instantiated for any QMR specification. Our thorough evaluation on case studies of important QMR problems shows that generated compilers are competitive with handwritten, specialized compilers in terms of runtime and solution quality.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776720", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Abtin", + "last_name": "Molavi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Amanda", + "last_name": "Xu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ethan", + "last_name": "Cecchetti", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Swamit", + "last_name": "Tannu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/MolaviXCTA26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776668", + "title": "All for One and One for All: Program Logics for Exploiting Internal Determinism in Parallel Programs", + "abstract": "Nondeterminism makes parallel programs challenging to write and reason about. To avoid these challenges, researchers have developed techniques for internally deterministic parallel programming, in which the steps of a parallel computation proceed in a deterministic way. Internal determinism is useful because it lets a programmer reason about a program as if it executed in a sequential order. However, no verification framework exists to exploit this property and simplify formal reasoning about internally deterministic programs. To capture the essence of why internally deterministic programs should be easier to reason about, this paper defines a property called schedule-independent safety. A program satisfies schedule-independent safety, if, to show that the program is safe across all orderings, it suffices to show that one terminating execution of the program is safe. We then present a separation logic called Musketeer for proving that a program satisfies schedule-independent safety. Once a parallel program has been shown to satisfy schedule-independent safety, we can verify it with a new logic called Angelic, which allows one to dynamically select and verify just one sequential ordering of the program. Using Musketeer, we prove the soundness of MiniDet, an affine type system for enforcing internal determinism. MiniDet supports several core algorithmic primitives for internally deterministic programming that have been identified in the research literature, including a deterministic version of a concurrent hash set. Because any syntactically well-typed MiniDet program satisfies schedule-independent safety, we can apply Angelic to verify such programs. All results in this paper have been verified in Rocq using the Iris separation logic framework.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776668", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Alexandre", + "last_name": "Moine", + "institution": "New York University" + }, + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "New York University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/MoineWT26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776708", + "title": "ChopChop: A Programmable Framework for Semantically Constraining the Output of Language Models", + "abstract": "Language models (LMs) can generate code but cannot guarantee its correctness—often producing outputs that violate type safety, program invariants, or other semantic properties. Constrained decoding offers a solution by restricting generation to only produce programs that satisfy user-defined properties. However, existing methods are either limited to syntactic constraints or rely on brittle, ad hoc encodings of semantic properties over token sequences rather than program structure. We present ChopChop, the first programmable framework for constraining the output of LMs with respect to semantic properties. ChopChop introduces a principled way to construct constrained decoders based on analyzing the space of programs a prefix represents. It formulates this analysis as a realizability problem which is solved via coinduction, connecting token-level generation with structural reasoning over programs. We demonstrate ChopChop's generality by using it to enforce (1) equivalence to a reference program and (2) type safety. Across a range of models and tasks, ChopChop improves success rates while maintaining practical decoding latency.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776708", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Shaan", + "last_name": "Nagy", + "institution": "University of California San Diego" + }, + { + "first_name": "Timothy", + "last_name": "Zhou", + "institution": "University of California San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/NagyZPD26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776722", + "title": "Nice to Meet You: Synthesizing Practical MLIR Abstract Transformers", + "abstract": "Static analyses play a fundamental role during compilation: they discover facts that are true in all executions of the code being compiled, and then these facts are used to justify optimizations and diagnostics. Each static analysis is based on a collection of abstract transformers that provide abstract semantics for the concrete instructions that make up a program. It can be challenging to implement abstract transformers that are sound, precise, and efficient—and in fact both LLVM and GCC have suffered from miscompilations caused by unsound abstract transformers. Moreover, even after more than 20 years of development, LLVM lacks abstract transformers for hundreds of instructions in its intermediate representation (IR). We developed NiceToMeetYou: a program synthesis framework for abstract transformers that are aimed at the kinds of non-relational integer abstract domains that are heavily used by today’s production compilers. It exploits a simple but novel technique for breaking the synthesis problem into parts: each of our transformers is the meet of a collection of simpler, sound transformers that are synthesized such that each new piece fills a gap in the precision of the final transformer. Our design point is bulk automation: no sketches are required. Transformers are verified by lowering to a previously-created SMT dialect of MLIR. Each of our synthesized transformers is provably sound and some (17 %) are more precise than those provided by LLVM.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776722", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xuanyu", + "last_name": "Peng", + "institution": "University of California San Diego" + }, + { + "first_name": "Dominic", + "last_name": "Kennedy", + "institution": "University of Utah" + }, + { + "first_name": "Yuyou", + "last_name": "Fan", + "institution": "University of Utah" + }, + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/PengKFGRD26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776646", + "title": "Qudit Quantum Programming with Projective Cliffords", + "abstract": "This paper introduces a novel abstraction for programming quantum operations, specifically projective Cliffords, as functions over the qudit Pauli group. Generalizing the idea behind Pauli tableaux, we introduce a type system and lambda calculus for projective Cliffords called LambdaPC that captures well-formed Clifford operations via a Curry-Howard correspondence with a particular encoding of the Clifford and Pauli groups. In LambdaPC, users write functions that encode projective Cliffords P ↦ U P U † , and such functions are compiled to circuits executable on modern quantum computers that transform quantum states |ϕ⟩ into U |ϕ⟩, up to a global phase. Importantly, the language captures not just qubit operations, but qudit operations for any dimension d . Throughout the paper we explore what it means to program with projective Cliffords through a number of examples and a case study focusing on stabilizer error correcting codes.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776646", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jennifer", + "last_name": "Paykin", + "institution": "University of Vermont" + }, + { + "first_name": "Sam", + "last_name": "Winnick", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/PaykinW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776725", + "title": "From Semantics to Syntax: A Type Theory for Comprehension Categories", + "abstract": "Recent models of intensional type theory have been constructed in algebraic weak factorization systems (AWFSs). AWFSs give rise to comprehension categories that feature non-trivial morphisms between types; these morphisms are not used in the standard interpretation of Martin-Löf type theory in comprehension categories. We develop a type theory that internalizes morphisms between types, reflecting this semantic feature back into syntax. Our type theory comes with Π-, Σ-, and identity types. We discuss how it can be viewed as an extension of Martin-Löf type theory with coercive subtyping, as sketched by Coraglia and Emmenegger. We furthermore define semantic structure that interprets our type theory and prove a soundness result. Finally, we exhibit many examples of the semantic structure, yielding a plethora of interpretations.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776725", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Niyousha", + "last_name": "Najmaei", + "institution": "École Polytechnique" + }, + { + "first_name": "Niels van der", + "last_name": "Weide", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Benedikt", + "last_name": "Ahrens", + "institution": "Delft University of Technology" + }, + { + "first_name": "Paige Randall", + "last_name": "North", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/pacmpl/NajmaeiWAN26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776682", + "title": "Endangered by the Language But Saved by the Compiler: Robust Safety via Semantic Back-Translation", + "abstract": "It is common for programmers to assemble their programs from a combination of trusted and untrusted components. In this context, a trusted program component is said to be robustly safe if it behaves safely when linked against arbitrary untrusted code. Prior work has shown how various encapsulation mechanisms (in both high- and low-level languages) can be used to protect code so that it is robustly safe, but none of the existing work has explored how robust safety can be achieved in a patently unsafe language like C. In this paper, we show how to bring robust safety to a simple yet representative C-like language we call Rec. Although Rec (like C) is inherently ”dangerous” and thus not robustly safe, we can ”save” Rec programs via compilation to Cap, a CHERI-like capability machine . To formalize the benefits of such a hardening compiler , we develop Reckon, a separation logic for verifying robust safety of Rec programs. Reckon is not sound under Rec’s unsafe, C-like semantics, but it is sound when Rec programs are hardened via compilation and linked against untrusted code running on Cap. As a crucial step in proving soundness of Reckon, we introduce a novel technique of semantic back-translation , which we formalize by building on the DimSum framework for multi-language semantics. All our results are mechanized in the Rocq prover.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776682", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Niklas", + "last_name": "Mück", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Aïna Linn", + "last_name": "Georges", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "journals/pacmpl/MuckGDGS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776663", + "title": "Optimising Density Computations in Probabilistic Programs via Automatic Loop Vectorisation", + "abstract": "Probabilistic programming languages (PPLs) are a popular tool for high-level modelling across many fields. They provide a range of algorithms for probabilistic inference, which analyse models by learning their parameters from a dataset or estimating their posterior distributions. However, probabilistic inference is known to be very costly. One of the bottlenecks of probabilistic inference stems from the iteration over entries of a large dataset or a long series of random samples. Vectorisation can mitigate this cost, but manual vectorisation is error-prone, and existing automatic techniques are often ad-hoc and limited, unable to handle general repetition structures, such as nested loops and loops with data-dependent control flow, without significant user intervention. To address this bottleneck, we propose a sound and effective method for automatically vectorising loops in probabilistic programs. Our method achieves high throughput using speculative parallel execution of loop iterations, while preserving the semantics of the original loop through a fixed-point check. We formalise our method as a translation from an imperative PPL into a lower-level target language with primitives geared towards vectorisation. We implemented our method for the Pyro PPL and evaluated it on a range of probabilistic models. Our experiments show significant performance gains against an existing vectorisation baseline, achieving 1.1–6× speedups and reducing GPU memory usage in many cases. Unlike the baseline, which is limited to a subset of models, our method effectively handled all the tested models.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776663", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sangho", + "last_name": "Lim", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Hyoung-Jin", + "last_name": "Lim", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/LimLLRY26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776667", + "title": "Towards Pen-and-Paper-Style Equational Reasoning in Interactive Theorem Provers by Equality Saturation", + "abstract": "Equations are ubiquitous in mathematical reasoning. Often, however, they only hold under certain conditions. As these conditions are usually clear from context, mathematicians regularly omit them when performing equational reasoning on paper. In contrast, interactive theorem provers pedantically insist on every detail to be convinced that a theorem holds, hindering equational reasoning at the more abstract level of pen-and-paper mathematics. In this paper, we address this issue by raising the level of equational reasoning to enable pen-and-paper style in interactive theorem provers. We achieve this by interpreting theorems as conditional rewrite rules, and use equality saturation to automatically derive equational proofs. Conditions that cannot be automatically proven may be surfaced as proof obligations. Concretely, we present how to interpret theorems as conditional rewrite rules for a significant class of theorems. Handling these theorems goes beyond simple syntactic rewriting, and deals with aspects like propositional conditions and type classes. We evaluate our approach by implementing it as a tactic in Lean, using the egg library for equality saturation with e-graphs. We show four use cases demonstrating the efficacy of this higher level of abstraction for equational reasoning.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776667", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Marcus", + "last_name": "Rossel", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Rudi", + "last_name": "Schneider", + "institution": "Technische Universität Berlin" + }, + { + "first_name": "Thomas", + "last_name": "Kœhler", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "Technische Universität Berlin" + }, + { + "first_name": "Andrés", + "last_name": "Goens", + "institution": "Technische Universität Darmstadt" + } + ], + "dblp_key": "journals/pacmpl/RosselSKSG26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776686", + "title": "Context-Free-Language Reachability for Almost-Commuting Transition Systems", + "abstract": "We extend the scope of context-free-language (CFL) reachability to a new class of infinite-state systems. Parikh’s Theorem is a useful tool for solving CFL-reachability problems for transition systems that consist of commuting transition relations. It implies that the image of a context-free language under a homomorphism into a commutative monoid is semi-linear, and that there is a linear-time algorithm for constructing a Presburger arithmetic formula that represents it. However, for many transition systems of interest, transitions do not commute. In this paper, we introduce almost-commuting transition systems, which pair finite-state control with commutative components, but which are in general not commutative. We extend Parikh’s theorem to show that the image of a context-free language under a homomorphism into an almost-commuting monoid is semi-linear and that there is a polynomial-time algorithm for constructing a Presburger arithmetic formula that represents it. This result yields a general framework for solving CFL-reachability problems over almost-commuting transition systems . We describe several examples of systems within this class. Finally, we examine closure properties of almost-commuting monoids that can be used to modularly compose almost-commuting transition systems while remaining in the class.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776686", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Pimpalkhare", + "institution": "Princeton University" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/PimpalkhareKR26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776732", + "title": "Bounded Sort Polymorphism with Elimination Constraints", + "abstract": "Proof assistants based on dependent type theory---such as Agda, Lean, and Rocq---employ different universes to classify types, typically combining a predicative tower for computationally relevant types with a possibly impredicative universe for proof-irrelevant propositions. Several other universes with specific logical and computational principles have been explored in the literature. In general, a universe is characterized by its sort (e.g., Type, Prop, or SProp) and, in the predicative case, by its level. To improve modularity and better avoid code duplication, sort polymorphism has recently been introduced and integrated in the Rocq prover. However, we observe that, due to its unbounded formulation, sort polymorphism is currently insufficiently expressive to abstract over valid definitions with a single polymorphic schema. Indeed, to ensure soundness of a multi-sorted type theory, the interaction between different sorts must be carefully controlled, as exemplified by the forbidden elimination of irrelevant terms to produce relevant ones. As a result, generic functions that eliminate values of inductive types from one sort to another cannot be made polymorphic; dually, polymorphic records that encapsulate attributes of different sorts cannot be defined. This lack of expressiveness also breaks the possibility to infer principal types, which is highly desirable for both metatheoretical and practical reasons. To address these issues, we extend sort polymorphism with bounds that reflect the required elimination constraints on sort variables. We present the metatheory of bounded sort polymorphism, paying particular attention to the consistency of the resulting constraint graph. We implement bounded sort polymorphism in Rocq and illustrate its benefits through concrete examples. Bounded sort polymorphism with elimination constraints is a natural and general solution that effectively addresses current limitations and fosters the development of, and practical experimentation with, multi-sorted type theories.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776732", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Johann", + "last_name": "Rosain", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Tomás", + "last_name": "Díaz", + "institution": "University of Chile" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/RosainDMSTTW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776684", + "title": "The Ghosts of Empires: Extracting Modularity from Interleaving-Based Proofs", + "abstract": "Implementation bugs threaten the soundness of algorithmic software verifiers. Generating correctness certificates for correct programs allows for efficient independent validation of verification results, and thus helps to reveal such bugs. Automatic generation of small, compact correctness proofs for concurrent programs is challenging, as the correctness arguments may depend on the particular interleaving, which can lead to exponential explosion. We present an approach that converts an interleaving-based correctness proof, as generated by many algorithmic verifiers, into a thread-modular correctness proof in the style of Owicki and Gries. We automatically synthesize ghost variables that capture the relevant interleaving information, and abstract away irrelevant details. Our evaluation shows that the approach is efficient in practice and generates compact proofs, compared to a baseline.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776684", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Frank", + "last_name": "Schüssele", + "institution": "University of Freiburg" + }, + { + "first_name": "Matthias", + "last_name": "Zumkeller", + "institution": "University of Freiburg" + }, + { + "first_name": "Miriam", + "last_name": "Lagunes-Rochin", + "institution": "University of Freiburg" + }, + { + "first_name": "Dominik", + "last_name": "Klumpp", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/SchusseleZLK26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776666", + "title": "On Circuit Description Languages, Indexed Monads, and Resource Analysis", + "abstract": "In this paper, a monad-based denotational model is introduced and shown adequate for the Proto-Quipper family of calculi, themselves being idealized versions of the Quipper programming language. The use of a monadic approach allows us to separate the value to which a term reduces from the circuit that the term itself produces as a side effect. In turn, this enables the denotational interpretation and validation of rich type systems in which the size of the produced circuit can be controlled. Notably, the proposed semantic framework, through the novel concept of circuit algebra, suggests forms of effect typing guaranteeing quantitative properties about the resulting circuit, even in presence of optimizations.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776666", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ken", + "last_name": "Sakayori", + "institution": "The University of Tokyo" + }, + { + "first_name": "Andrea", + "last_name": "Colledan", + "institution": "Université Côte d'Azur" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "Université Côte d'Azur" + } + ], + "dblp_key": "journals/pacmpl/SakayoriCL26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776652", + "title": "Characterizing Sets of Theories That Can Be Disjointly Combined", + "abstract": "We study properties that allow first-order theories to be disjointly combined, including stable infiniteness, shininess, strong politeness, and gentleness. Specifically, we describe a Galois connection between sets of decidable theories, which picks out the largest set of decidable theories that can be combined with a given set of decidable theories. Using this, we exactly characterize the sets of decidable theories that can be combined with those satisfying well-known theory combination properties. This strengthens previous results and answers in the negative several long-standing open questions about the possibility of improving existing theory combination methods to apply to larger sets of theories. Additionally, the Galois connection gives rise to a complete lattice of theory combination properties, which allows one to generate new theory combination methods by taking meets and joins of elements of this lattice. We provide examples of this process, introducing new combination theorems. We situate both new and old combination methods within this lattice.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776652", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Przybocki", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guilherme", + "last_name": "Toledo", + "institution": "Bar-Ilan University" + }, + { + "first_name": "Yoni", + "last_name": "Zohar", + "institution": "Bar-Ilan University" + } + ], + "dblp_key": "journals/pacmpl/PrzybockiTZ26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776643", + "title": "The Complexity of Testing Message-Passing Concurrency", + "abstract": "A key computational question underpinning the automated testing and verification of concurrent programs is the consistency question — given a partial execution history, can it be completed in a consistent manner? Due to its importance, consistency testing has been studied extensively for memory models, as well as for database isolation levels. A common theme in all these settings is the use of shared-memory as the primal mode of interthread communication. On the other hand, modern programming languages, such as Go, Rust and Kotlin, advocate a paradigm shift towards channel-based (i.e., message-passing) communication. However, the consistency question for channel-based concurrency is currently poorly understood. In this paper we lift the study of fundamental consistency problems to channels, taking into account various input parameters, such as the number of threads executing, the number of channels, and the channel capacities. We draw a rich complexity landscape, including upper bounds that become polynomial when certain input parameters are fixed, as well as hardness lower bounds. Our upper bounds are based on algorithms that can drive the verification of channel consistency in automated verification tools. Our lower bounds characterize minimal input parameters that are sufficient for hardness to arise, and thus shed light on the intricacies of testing channel-based concurrency. In combination, our upper and lower bounds characterize the boundary of tractability/intractability of verifying channel consistency, and imply that our algorithms are often (nearly) optimal. We have also implemented our main consistency checking algorithm and designed optimizations to enhance its performance. We evaluated the performance of our implementation over a set of 103 instances obtained from open source Go projects, and compared it against a constraint-solving based algorithm. Our experimental results demonstrate the power of our consistency-checking algorithm; it scales to around 1M events, and is significantly faster in running-time performance, compared to a constraint-solving approach.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776643", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Z. D.", + "last_name": "SHI", + "institution": "National University of Singapore" + }, + { + "first_name": "Lasse", + "last_name": "Møldrup", + "institution": "Aarhus University" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/ShiMMP26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776657", + "title": "Typing Strictness", + "abstract": "Strictness analysis is critical to efficient implementation of languages with non-strict evaluation, mitigating much of the performance overhead of laziness. However, reasoning about strictness at the source level can be challenging and unintuitive. We propose a new definition of strictness that refines the traditional one by describing variable usage more precisely. We lay type-theoretic foundations for this definition in both call-by-name and call-by-push-value settings, drawing inspiration from the literature on type systems tracking effects and coeffects. We prove via a logical relation that the strictness attributes computed by our type systems accurately describe the use of variables at runtime, and we offer a strictness-annotation-preserving translation from the call-by-name system to the call-by-push-value one. All our results are mechanized in Rocq.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776657", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Sainati", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Joseph W.", + "last_name": "Cutler", + "institution": "University of Pennsylvania" + }, + { + "first_name": "BENJAMIN C.", + "last_name": "PIERCE", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/SainatiCPW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776670", + "title": "Dependent Coeffects for Local Sensitivity Analysis", + "abstract": "Differential privacy is a formal definition of privacy that bounds the maximum acceptable information leakage when a query is performed on sensitive data. To ensure this property, a key technique involves bounding the query’s sensitivity (how much input variations affect the output) and adding noise to the result according to this quantity. While prior work like the Fuzz type system focuses on global sensitivity, many useful queries have infinite global sensitivity, restricting the scope of such approaches. This limitation can be addressed by considering a more fine-grained measure: local sensitivity, which quantifies output change for inputs adjacent to a specific dataset. In this article, we introduce Local Fuzz, a type system with dependent coeffects designed to bound the local sensitivity of programs written in a simple functional language. We provide a denotational semantics for this system in the category of extended premetric spaces, leveraging the recently introduced construction of a dependently graded comonad. Finally, we illustrate how Local Fuzz can lead to better differential privacy guarantees than Fuzz, both for mechanisms that rely on global sensitivity and for those that leverage local sensitivity, such as the Propose-Test-Release framework.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776670", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Victor", + "last_name": "Sannier", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Patrick", + "last_name": "Baillot", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/SannierB26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776658", + "title": "An Expressive Assertion Language for Quantum Programs", + "abstract": "In this paper, we define an assertion language designed for expectation-based reasoning about quantum programs. The key design idea is a representation of quantum predicates by quasi-probability distributions of generalized Pauli operators. Then we extend classical techniques such as Gödelization to prove that this language is expressive with respect to the quantum programs with loops—specifically, for any program S and any postcondition ψ formulated in the assertion language, the weakest precondition of S with respect to ψ can also be expressed as a formula in the assertion language. As an application, we present a sound and relatively complete quantum Hoare logic upon our expressive assertion language.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776658", + "conference_name": "POPL", + "authors": [ + { + "first_name": "B.", + "last_name": "Su", + "institution": "Tsinghua University" + }, + { + "first_name": "Yuan", + "last_name": "Feng", + "institution": "Tsinghua University" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Li", + "last_name": "Zhou", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "journals/pacmpl/SuFYZ26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776677", + "title": "Compiling to Linear Neurons", + "abstract": "We don’t program neural networks directly. Instead, we rely on an indirect style where learning algorithms, like gradient descent, determine a neural network’s function by learning from data. This indirect style is often a virtue; it empowers us to solve problems that were previously impossible. But it lacks discrete structure. We can’t compile most algorithms into a neural network—even if these algorithms could help the network learn. This limitation occurs because discrete algorithms are not obviously differentiable, making them incompatible with the gradient-based learning algorithms that determine a neural network’s function. To address this, we introduce Cajal: a typed, higher-order and linear programming language intended to be a minimal vehicle for exploring a direct style of programming neural networks. We prove Cajal programs compile to linear neurons, allowing discrete algorithms to be expressed in a differentiable form compatible with gradient-based learning. With our implementation of Cajal, we conduct several experiments where we link these linear neurons against other neural networks to determine part of their function prior to learning. Linking with these neurons allows networks to learn faster, with greater data-efficiency, and in a way that’s easier to debug. A key lesson is that linear programming languages provide a path towards directly programming neural networks, enabling a rich interplay between learning and the discrete structures of ordinary programming.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776677", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joey", + "last_name": "Velez‐Ginorio", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "Harvard University Press" + }, + { + "first_name": "Konrad P.", + "last_name": "Körding", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/VelezGinorioAKZ26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776697", + "title": "Higher-Order Behavioural Conformances via Fibrations", + "abstract": "Coinduction is a widely used technique for establishing behavioural equivalence of programs in higher-order languages. In recent years, the rise of languages with quantitative (e.g. probabilistic) features has led to extensions of coinductive methods to more refined types of behavioural conformances, most notably notions of behavioural distance. To guarantee soundness of coinductive reasoning, one needs to show that the behavioural conformance at hand forms a program congruence, i.e. it is suitably compatible with the operations of the language. This is usually achieved by a complex proof technique known as Howe’s method, which needs to be carefully adapted to both the specific language and the targeted notion of behavioural conformance. We develop a uniform categorical approach to Howe’s method that features two orthogonal dimensions of abstraction: (1) the underlying higher-order language is modelled by an abstract higher-order specification (AHOS), a novel and very general categorical account of operational semantics, and (2) notions of behavioural conformance (such as relations or metrics) are modelled via fibrations over the base category of an AHOS. Our main result is a fundamental congruence theorem at this level of generality: Under natural conditions on the categorical ingredients and the operational rules of a language modelled by an AHOS, the greatest behavioural (bi)conformance on its operational model forms a congruence. We illustrate our theory by deriving congruence of bisimilarity and behavioural pseudometrics for probabilistic higher-order languages.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776697", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Henning", + "last_name": "Urbat", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + } + ], + "dblp_key": "journals/pacmpl/Urbat26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776674", + "title": "Rows and Capabilities as Modal Effects", + "abstract": "Effect handlers allow programmers to model and compose computational effects modularly. Effect systems statically guarantee that all effects are handled. Several recent practical effect systems are based on either row polymorphism or capabilities. However, there remains a gap in understanding the precise relationship between effect systems with such disparate foundations. The main difficulty is that in both row-based and capability-based systems, effect tracking is typically entangled with other features such as functions. We propose a uniform framework for encoding, analysing, and comparing effect systems. Our framework exploits and generalises modal effect types, a recent novel effect system which decouples effect tracking from functions via modalities. Modalities offer fine-grained control over when and how effects are tracked, enabling us to express different strategies for effect tracking. We give encodings as macro translations from existing row-based and capability-based effect systems into our framework and show that these encodings preserve types and semantics. Our encodings reveal the essence of effect tracking mechanisms in different effect systems, enable a direct analysis on their differences, and provide practical insights on language design.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776674", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Wenhao", + "last_name": "Tang", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/TangL26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776662", + "title": "Extensible Data Types with Ad-Hoc Polymorphism", + "abstract": "This paper proposes a novel language design that combines extensible data types, implemented through row types and row polymorphism, with ad-hoc polymorphism, implemented through type classes. Our design introduces several new constructs and constraints useful for generic operations over rows. We formalize our design in a source calculus λ ρ ⇒ , which elaborates into a target calculus F ω ⊗⊕ . We prove that the target calculus is type-safe and that the elaboration is sound, thus establishing the soundness of λ ρ ⇒ . All proofs are mechanized in the Lean 4 proof assistant. Furthermore, we evaluate our type system using the Brown Benchmark for Table Types, demonstrating the utility of extensible rows with type classes for table types.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776662", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Toohey", + "institution": "University of Toronto" + }, + { + "first_name": "Yanning", + "last_name": "Chen", + "institution": "University of Toronto" + }, + { + "first_name": "Ara", + "last_name": "Jamalzadeh", + "institution": "University of Toronto" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/TooheyCJX26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776676", + "title": "A Relational Separation Logic for Effect Handlers", + "abstract": "Effect handlers offer a powerful and relatively simple mechanism for controlling a program's flow of execution. Since their introduction, an impressive array of verification tools for effect handlers has been developed. However, to this day, no framework can express and prove relational properties about programs that use effect handlers in languages such as OCaml and Links, where programming features like mutable state and concurrency are readily available. To this end, we introduce blaze, the first relational separation logic for effect handlers. We build blaze on top of the Rocq implementation of the Iris separation logic, thereby enjoying the rigour of a mechanised theory and all the reasoning properties of a modern fully-fledged concurrent separation logic, such as modular reasoning about stateful concurrent programs and the ability to introduce user-defined ghost state. In addition to familiar reasoning rules, such as the bind rule and the frame rule, blaze offers rules to reason modularly about programs that perform and handle effects. Significantly, when verifying that two programs are related, blaze does not require that effects and handlers from one program be in correspondence with effects and handlers from the other. To assess this flexibility, we conduct a number of case studies: most noticeably, we show how different implementations of an asynchronous-programming library using effects are related to truly concurrent implementations. As side contributions, we introduce two new, simple, and general reasoning rules for concurrent relational separation logic that are independent of effects: a logical-fork rule that allows one to reason about an arbitrary program phrase as if it had been spawned as a thread and a thread-swap rule that allows one to reason about how threads are scheduled.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776676", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paulo Emílio de", + "last_name": "Vilhena", + "institution": "Imperial College London" + }, + { + "first_name": "Simcha van", + "last_name": "Collem", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Ines", + "last_name": "Wright", + "institution": "Aarhus University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/VilhenaCWK26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776728", + "title": "Stateful Differential Operators for Incremental Computing", + "abstract": "Differential operators map input changes to output changes and form the building blocks of efficient incremental computations. For example, differential operators for relational algebra are used to perform live view maintenance in database systems. However, few differential operators are known and it is unclear how to develop and verify new efficient operators. In particular, we found that differential operators often need to use internal state to selectively cache relevant information, which is not supported by prior work. To this end, we designed a specification for stateful differential operators that allows custom state, yet places sufficient constraints to ensure correctness. We model our specification in Rocq and show that the specification not only guides the design of novel differential operators, but also can capture some of the most sophisticated existing differential operators: database join and Datalog aggregation. We show how to describe complex incremental computations in OCaml by composing stateful differential operators, which we have extracted from Rocq.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776728", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Runqing", + "last_name": "Xu", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Karlsruhe Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/XuE26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776650", + "title": "ArchSem: Reusable Rigorous Semantics of Relaxed Architectures", + "abstract": "The specifications of mainstream processor architectures, such as Arm, x86, and RISC-V, underlie modern computing, as the targets of compilers, operating systems, and hypervisors. However, despite extensive research and tooling for instruction-set architecture (ISA) and relaxed-memory semantics, recently including systems features, there still do not exist integrated mathematical models that suffice for foundational formal verification, of concurrent architecture properties or of systems software. Previous proof-assistant work has had to substantially simplify the ISA semantics, the concurrency model, or both. We present ArchSem, an architecture-generic framework for architecture semantics, modularly combining ISA and concurrency models along a tractable interface of instruction-semantics effects, that covers a range of systems aspects. To do so, one has to handle many issues that were previously unclear, about the architectures themselves, the interface, the proper definition of reusable models, and the Rocq and Isabelle idioms required to make it usable. We instantiate it to the Arm-A and RISC-V instruction-set architectures and multiple concurrency models. We demonstrate usability for proof, despite the scale, by establishing that the Arm architecture (in a particular configuration) provides a provable virtual memory abstraction, with a combination of Rocq, Isabelle, and paper proof. Previous work provides further confirmation of usability: the AxSL program logic for Arm relaxed concurrency was proved sound above an earlier version of ArchSem. This establishes a basis for future proofs of architecture properties and systems software, above production architecture specifications.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776650", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Thibaut", + "last_name": "Pérami", + "institution": "University of Cambridge" + }, + { + "first_name": "Thomas", + "last_name": "Bauereiß", + "institution": "University of Cambridge" + }, + { + "first_name": "B. K.", + "last_name": "Campbell", + "institution": "University of Edinburgh" + }, + { + "first_name": "Zongyuan", + "last_name": "Liu", + "institution": "Aarhus University" + }, + { + "first_name": "Nils", + "last_name": "Lauermann", + "institution": "University of Cambridge" + }, + { + "first_name": "Alasdair", + "last_name": "Armstrong", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/PeramiBCLLAS26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776656", + "title": "Network Change Validation with Relational NetKAT", + "abstract": "Relational NetKAT (RN) is a new specification language for network change validation. Engineers use RN to specify intended changes by providing a trace relation R , which maps existing packet traces in the pre-change network to intended packet traces in the post-change network. The intended set of traces may then be checked against the actual post-change traces to uncover errors in implementation. Trace relations are constructed compositionally from a language of combinators that include trace insertion, trace deletion, and packet transformation, as well as regular operators for concatenation, union, and iteration of relations. We provide algorithms for converting trace relations into a new form of NetKAT transducer and also for constructing an automaton that recognizes the image of a NetKAT automaton under a NetKAT transducer. These algorithms, together with existing decision procedures for NetKAT automaton equivalence, suffice for validating network changes. We provide a denotational semantics for our specification language, prove our compilation algorithms correct, implement a tool for network change validation, and evaluate it on a set of benchmarks drawn from a production network and Amazon’s Batfish toolkit.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776656", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Han", + "last_name": "Xu", + "institution": "Princeton University" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "Ratul", + "last_name": "Mahajan", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/XuKMW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776678", + "title": "Handling Higher-Order Effectful Operations with Judgemental Monadic Laws", + "abstract": "This paper studies the design of programming languages with handlers of higher-order effectful operations – effectful operations that may take in computations as arguments or return computations as output. We present and analyse a core calculus with higher-kinded impredicative polymorphism, handlers of higher-order effectful operations, and optionally general recursion. The distinctive design choice of this calculus is that handlers are carried by lawless raw monads, while the computation judgements still satisfy the monadic laws judgementally. We present the calculus with a logical framework and give denotational models of the calculus using realizability semantics. We prove closed-term canonicity and parametricity for the recursion-free fragment of the language using synthetic Tait computability and a novel form of the ⊤⊤-lifting technique.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776678", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhixuan", + "last_name": "Yang", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/YangW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776653", + "title": "Local Contextual Type Inference", + "abstract": "Type inference is essential for programming languages, yet complete and global inference quickly becomes undecidable in the presence of rich type systems like System F. Pierce and Turner proposed local type inference (LTI) as a scalable, partially annotated alternative by relying on information local to applications. While LTI has been widely adopted in practice, there are significant gaps between theory and practice, with its theory being underdeveloped and specifications for LTI being complex and restrictive. We propose Local Contextual Type Inference , a principled redesign of LTI grounded in contextual typing—a recent formalism which captures type information flow. We present Contextual System F (Fc), a variant of System F with implicit and first-class polymorphism. We formalize Fc using a declarative type system, prove soundness, completeness, and decidability, and introduce matching subtyping as a bridge between declarative and algorithmic inference. This work offers the first mechanized treatment of LTI, while at the same time removing important practical restrictions and also demonstrating the power of contextual typing in designing robust, extensible and simple to implement type inference algorithms.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776653", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Xu", + "last_name": "Xue", + "institution": "University of Hong Kong" + }, + { + "first_name": "Chen", + "last_name": "Cui", + "institution": "University of Hong Kong" + }, + { + "first_name": "Shengyi", + "last_name": "Jiang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/XueCJO26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776659", + "title": "Fuzzing Guided by Bayesian Program Analysis", + "abstract": "We propose a novel approach that leverages Bayesian program analysis to guide large-scale target-guided greybox fuzzing (LTGF). LTGF prioritizes program locations (targets) that are likely to contain bugs and applies directed mutation towards high-priority targets. However, existing LTGF approaches suffer from coarse and heuristic target prioritization strategies, and lack a systematic design to fully exploit feedback from the fuzzing process. We systematically define this prioritization process as the reachable fuzzing targets problem. Bayesian program analysis attaches probabilities to analysis rules and transforms the analysis results into a Bayesian model. By redefining the semantics of Bayesian program analysis, we enable the prediction of whether each target is reachable by the fuzzer, and dynamically adjust the predictions based on fuzzer feedback. On the one hand, Bayesian program analysis builds Bayesian models based on program semantics, enabling systematic and fine-grained prioritization. On the other hand, Bayesian program analysis systematically learns feedback from the fuzzing process, making its guidance adaptive. Moreover, this combination extends the application of Bayesian program analysis from alarm ranking to fully automated bug discovery. We implement our approach and evaluate it against several state-of-the-art fuzzers. On a suite of real-world programs, our approach discovers 3.25 × to 13 × more unique bugs compared to baselines. In addition, our approach identifies 39 previously unknown bugs in well-tested programs, 30 of which have been assigned CVEs.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776659", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Y. M.", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/ZhangZ26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776709", + "title": "Piecewise Analysis of Probabilistic Programs via 𝑘-Induction", + "abstract": "In probabilistic program analysis, quantitative analysis aims at deriving tight numerical bounds for probabilistic properties such as expectation and assertion probability. Most previous works consider numerical bounds over the whole program state space monolithically and do not consider piecewise bounds. Not surprisingly, monolithic bounds are either conservative, or not expressive and succinct enough in general. To derive better bounds, we propose a novel approach for synthesizing piecewise bounds over probabilistic programs. First, we show how to extract useful piecewise information from latticed k -induction operators, and combine the piecewise information with Optional Stopping Theorem to obtain a general approach to derive piecewise bounds over probabilistic programs. Second, we develop algorithms to synthesize piecewise polynomial bounds, and show that the synthesis can be reduced to bilinear programming in the linear case, and soundly relaxed to semidefinite programming in the polynomial case. Experimental results show that our approach generates tight piecewise bounds for a wide range of benchmarks when compared with the state of the art.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776709", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Tengshun", + "last_name": "Yang", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Shenghua", + "last_name": "Feng", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Naijun", + "last_name": "Zhan", + "institution": "Peking University" + }, + { + "first_name": "Jingyu", + "last_name": "Ke", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Shiyang", + "last_name": "Wu", + "institution": "Shanghai Jiao Tong University" + } + ], + "dblp_key": "journals/pacmpl/YangFFZKW26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776679", + "title": "Accelerating Syntax-Guided Program Synthesis by Optimizing Domain-Specific Languages", + "abstract": "Syntax-guided program synthesis relies on domain-specific languages (DSLs) to constrain the search space and improve efficiency. However, manually designing optimal DSLs is challenging and often results in suboptimal performance. In this paper, we propose AMaze, a novel framework that automatically optimizes DSLs to accelerate synthesis. AMaze iteratively refines a DSL by identifying key program fragments, termed feature components, whose enumeration ranks correlate with synthesis time. Using a dynamic-programming-based algorithm to calculate enumeration ranks of feature components and a machine learning model based on them, AMaze estimates synthesis cost instead of directly invoking the synthesizer, which is impractical due to high computational cost. We evaluate AMaze on state-of-the-art synthesizers, including DryadSynth, Duet, Polygen, and EUsolver, across multiple domains. Empirical results demonstrate that AMaze achieves up to 4.35X speedup, effectively reducing synthesis time while maintaining expressiveness.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776679", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Zhentao", + "last_name": "Ye", + "institution": "Peking University" + }, + { + "first_name": "Ruyi", + "last_name": "Ji", + "institution": "Peking University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/YeJXZ26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776644", + "title": "Let Generalization, Polymorphic Recursion, and Variable Minimization in Boolean-Kinded Type Systems", + "abstract": "Recent research has demonstrated the effectiveness of extending the Hindley-Milner (HM) type system with Boolean kinds to support type inference for a wide variety of features. However, the means to support classic type system provisions such as local let generalization and polymorphic recursion is either limited or unknown for such extensions. This paper contributes procedures for equational generalization and semiunification in arbitrary Boolean rings, enabling let generalization and polymorphic recursion in Boolean-kinded type inference. Additionally, methods to minimize the number of bound Boolean type variables are developed to keep types small in these systems. Boolean-kinded HM extensions are exemplified with nullable reference types , and how to use the developed procedures to support let generalization and polymorphic recursion is outlined.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776644", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Joseph A.", + "last_name": "Zullo", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/Zullo26", + "venue": "popl", + "year": 2026 + }, + { + "paper_id": "10.1145/3776651", + "title": "Probabilistic Concurrent Reasoning in Outcome Logic: Independence, Conditioning, and Invariants", + "abstract": "Although randomization has long been used in distributed computing, formal methods for reasoning about probabilistic concurrent programs have lagged behind. No existing program logics can express specifications about the full distributions of outcomes resulting from programs that are both probabilistic and concurrent. To address this, we introduce Probabilistic Concurrent Outcome Logic (pcOL), which incorporates ideas from concurrent and probabilistic separation logics into Outcome Logic to introduce new compositional reasoning principles. At its core, pcOL reinterprets the rules of Concurrent Separation Logic in a setting where separation models probabilistic independence, so as to compositionally describe joint distributions over variables in concurrent threads. Reasoning about outcomes also proves crucial, as case analysis is often necessary to derive precise information about threads that rely on randomized shared state. We demonstrate pcOL on a variety of examples, including to prove almost sure termination of unbounded loops.", + "date": "2026-01-08", + "link": "https://doi.org/10.1145/3776651", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Noam", + "last_name": "Zilberstein", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/ZilbersteinST26", + "venue": "popl", + "year": 2026 + } +] \ No newline at end of file From 49a729982f3646445f7559b0f0480375896627c6 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:18:08 +0200 Subject: [PATCH 07/34] feat: rate-limit DBLP and Semantic Scholar in PLConferenceHarvester DBLP returns 'Connection reset by peer' under concurrent load, and Semantic Scholar returns 429s. Cap DBLP at one in-flight request with a 1.5s minimum interval (process-global), Semantic Scholar at four concurrent. Bump retry budget to six attempts with a longer base backoff so transient resets don't fail a year. OpenAlex with mailto remains ungated. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 58 +++++++++++++++++++++----- 1 file changed, 48 insertions(+), 10 deletions(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index bc67f54..418a920 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -156,7 +156,9 @@ def _load_xml(self) -> str: url = f"https://dblp.org/db/conf/{self.venue.slug}/index.xml" logger.info("Fetching DBLP venue index %s", url) - resp = _request_with_retries(self._session, url, timeout=30) + with _DBLP_CONCURRENCY: + _pace_dblp() + resp = _request_with_retries(self._session, url, timeout=30) resp.raise_for_status() time.sleep(self.request_delay_s) @@ -284,6 +286,36 @@ def _parse_xml_attrs(attr_str: str) -> dict[str, str]: _USER_AGENT = "oversight/0.1 (https://github.com/charlielidbury/oversight)" _OPENALEX_MAILTO = "charlie.lidbury@icloud.com" +# Per-process semaphores so we never hammer a single host with the full +# pool. DBLP and Semantic Scholar are the two services known to reset +# connections under load; OpenAlex with ``mailto`` happily handles 100 +# concurrent requests so we leave it ungated. +# +# DBLP at concurrency=1 with a small inter-request delay sustains. At +# concurrency=2 it starts returning ``Connection reset by peer`` after a +# couple of seconds. +_DBLP_CONCURRENCY = threading.BoundedSemaphore(1) +_DBLP_MIN_INTERVAL_S = 1.5 +_DBLP_LAST_CALL_LOCK = threading.Lock() +_DBLP_LAST_CALL_AT = [0.0] +_SEMSCHOLAR_CONCURRENCY = threading.BoundedSemaphore(4) + + +def _pace_dblp() -> None: + """Block briefly so consecutive DBLP calls are at least + ``_DBLP_MIN_INTERVAL_S`` apart, regardless of which thread is calling. + """ + with _DBLP_LAST_CALL_LOCK: + now = time.monotonic() + delta = now - _DBLP_LAST_CALL_AT[0] + if delta < _DBLP_MIN_INTERVAL_S: + sleep_for = _DBLP_MIN_INTERVAL_S - delta + else: + sleep_for = 0.0 + _DBLP_LAST_CALL_AT[0] = now + sleep_for + if sleep_for: + time.sleep(sleep_for) + def _request_with_retries( session: requests.Session, @@ -291,11 +323,11 @@ def _request_with_retries( *, params: dict[str, Any] | None = None, timeout: int = 30, - max_attempts: int = 4, + max_attempts: int = 6, ) -> requests.Response: - """GET with exponential backoff on transient errors (429/503/connection).""" + """GET with exponential backoff on transient errors (429/5xx/connection).""" attempt = 0 - backoff = 2.0 + backoff = 3.0 while True: attempt += 1 try: @@ -314,7 +346,7 @@ def _request_with_retries( time.sleep(backoff) backoff *= 2 continue - if resp.status_code in (429, 502, 503, 504) and attempt < max_attempts: + if resp.status_code in (429, 500, 502, 503, 504) and attempt < max_attempts: retry_after = resp.headers.get("Retry-After") wait = float(retry_after) if retry_after else backoff logger.warning( @@ -548,9 +580,14 @@ def _fetch_dblp_toc_papers(self, toc: TOCEntry) -> Iterator[dict[str, Any]]: "h": 1000, "f": 0, } - resp = _request_with_retries(self._session, url, params=params, timeout=30) + with _DBLP_CONCURRENCY: + _pace_dblp() + resp = _request_with_retries( + self._thread_session(), url, params=params, timeout=30 + ) resp.raise_for_status() - time.sleep(self.request_delay_s) + if self.request_delay_s: + time.sleep(self.request_delay_s) payload = resp.json() self._cache_store(cache_key, payload) @@ -693,9 +730,10 @@ def _fetch_semantic_scholar(self, doi: str) -> dict[str, Any] | None: url = f"https://api.semanticscholar.org/graph/v1/paper/DOI:{doi}" params = {"fields": "abstract,authors,year"} try: - resp = _request_with_retries( - self._thread_session(), url, params=params, timeout=30 - ) + with _SEMSCHOLAR_CONCURRENCY: + resp = _request_with_retries( + self._thread_session(), url, params=params, timeout=30 + ) except requests.RequestException as exc: logger.warning("Semantic Scholar request failed for %s: %s", doi, exc) return None From aca71262f749d100fd85e970362123a8a7fb8b82 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:26:03 +0200 Subject: [PATCH 08/34] feat: ingest PLDI back-catalogue (1987-2025) 39 years of PLDI proceedings harvested via DBLP, OpenAlex, and Semantic Scholar fallback. PLDI did not run in 1986; DBLP has no entry for 2026 yet. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/pldi/1987.json | 493 +++++ data/pl_conferences/pldi/1988.json | 705 +++++++ data/pl_conferences/pldi/1989.json | 780 +++++++ data/pl_conferences/pldi/1990.json | 633 ++++++ data/pl_conferences/pldi/1991.json | 648 ++++++ data/pl_conferences/pldi/1992.json | 727 +++++++ data/pl_conferences/pldi/1993.json | 699 +++++++ data/pl_conferences/pldi/1994.json | 712 +++++++ data/pl_conferences/pldi/1995.json | 691 +++++++ data/pl_conferences/pldi/1996.json | 731 +++++++ data/pl_conferences/pldi/1997.json | 825 ++++++++ data/pl_conferences/pldi/1998.json | 835 ++++++++ data/pl_conferences/pldi/1999.json | 665 ++++++ data/pl_conferences/pldi/2000.json | 757 +++++++ data/pl_conferences/pldi/2001.json | 802 ++++++++ data/pl_conferences/pldi/2002.json | 876 ++++++++ data/pl_conferences/pldi/2003.json | 764 +++++++ data/pl_conferences/pldi/2004.json | 725 +++++++ data/pl_conferences/pldi/2005.json | 676 +++++++ data/pl_conferences/pldi/2006.json | 1049 ++++++++++ data/pl_conferences/pldi/2007.json | 1452 +++++++++++++ data/pl_conferences/pldi/2008.json | 939 +++++++++ data/pl_conferences/pldi/2009.json | 1295 ++++++++++++ data/pl_conferences/pldi/2010.json | 1268 ++++++++++++ data/pl_conferences/pldi/2011.json | 1612 +++++++++++++++ data/pl_conferences/pldi/2012.json | 1551 ++++++++++++++ data/pl_conferences/pldi/2013.json | 1531 ++++++++++++++ data/pl_conferences/pldi/2014.json | 1949 ++++++++++++++++++ data/pl_conferences/pldi/2015.json | 1769 ++++++++++++++++ data/pl_conferences/pldi/2016.json | 1546 ++++++++++++++ data/pl_conferences/pldi/2017.json | 1518 ++++++++++++++ data/pl_conferences/pldi/2018.json | 1912 +++++++++++++++++ data/pl_conferences/pldi/2019.json | 2620 ++++++++++++++++++++++++ data/pl_conferences/pldi/2020.json | 2673 ++++++++++++++++++++++++ data/pl_conferences/pldi/2021.json | 3038 ++++++++++++++++++++++++++++ data/pl_conferences/pldi/2022.json | 2351 +++++++++++++++++++++ data/pl_conferences/pldi/2023.json | 2791 +++++++++++++++++++++++++ data/pl_conferences/pldi/2024.json | 3009 +++++++++++++++++++++++++++ data/pl_conferences/pldi/2025.json | 2996 +++++++++++++++++++++++++++ 39 files changed, 52613 insertions(+) create mode 100644 data/pl_conferences/pldi/1987.json create mode 100644 data/pl_conferences/pldi/1988.json create mode 100644 data/pl_conferences/pldi/1989.json create mode 100644 data/pl_conferences/pldi/1990.json create mode 100644 data/pl_conferences/pldi/1991.json create mode 100644 data/pl_conferences/pldi/1992.json create mode 100644 data/pl_conferences/pldi/1993.json create mode 100644 data/pl_conferences/pldi/1994.json create mode 100644 data/pl_conferences/pldi/1995.json create mode 100644 data/pl_conferences/pldi/1996.json create mode 100644 data/pl_conferences/pldi/1997.json create mode 100644 data/pl_conferences/pldi/1998.json create mode 100644 data/pl_conferences/pldi/1999.json create mode 100644 data/pl_conferences/pldi/2000.json create mode 100644 data/pl_conferences/pldi/2001.json create mode 100644 data/pl_conferences/pldi/2002.json create mode 100644 data/pl_conferences/pldi/2003.json create mode 100644 data/pl_conferences/pldi/2004.json create mode 100644 data/pl_conferences/pldi/2005.json create mode 100644 data/pl_conferences/pldi/2006.json create mode 100644 data/pl_conferences/pldi/2007.json create mode 100644 data/pl_conferences/pldi/2008.json create mode 100644 data/pl_conferences/pldi/2009.json create mode 100644 data/pl_conferences/pldi/2010.json create mode 100644 data/pl_conferences/pldi/2011.json create mode 100644 data/pl_conferences/pldi/2012.json create mode 100644 data/pl_conferences/pldi/2013.json create mode 100644 data/pl_conferences/pldi/2014.json create mode 100644 data/pl_conferences/pldi/2015.json create mode 100644 data/pl_conferences/pldi/2016.json create mode 100644 data/pl_conferences/pldi/2017.json create mode 100644 data/pl_conferences/pldi/2018.json create mode 100644 data/pl_conferences/pldi/2019.json create mode 100644 data/pl_conferences/pldi/2020.json create mode 100644 data/pl_conferences/pldi/2021.json create mode 100644 data/pl_conferences/pldi/2022.json create mode 100644 data/pl_conferences/pldi/2023.json create mode 100644 data/pl_conferences/pldi/2024.json create mode 100644 data/pl_conferences/pldi/2025.json diff --git a/data/pl_conferences/pldi/1987.json b/data/pl_conferences/pldi/1987.json new file mode 100644 index 0000000..8efb958 --- /dev/null +++ b/data/pl_conferences/pldi/1987.json @@ -0,0 +1,493 @@ +[ + { + "paper_id": "10.1145/29650.29668", + "title": "GL-a denotational testbed with continuations and partial continuations as first-class objects", + "abstract": "In this paper we describe GL, a language designed to support interactive experimentation with denotational semantics of programming languages, and the novel features of its interpreter. GL is an expressional language that might best be described as an implementation of lambda calculus augmented with several useful basic data types including 1-values.A unique aspect of the GL environment is that it presents a visible, user-accessible implementation of the continuation semantics of GL. The user is expected to understand a denotational definition of GL, and to interact with the system in terms of that definition. In particular, if a computation is temporarily halted the expression continuation extant at that point can be interactively captured and later applied to other values and stores. The implementation of this feature is via a pair of routines called setjmpup and longjmpup that provide what might be called a partial continuation facility. A partial continuation is a function over stores or store/value pairs that represents execution of a partially executed program from its current state to some later state possibly before its half state. The semantics of partial continuations is interesting, and an extension of GL is presented that contains continuations and partial continuations as first-class objects.The GL environment is fairly complete; it has an experimental polymorphic type inference mechanism that supports self-application and report likely sources of user error in a robust manner, and it has a flexible breakpoint and trace facility that permits program execution to be observed and controlled at a variety of levels of granularity. Moreover, it has been used successfully to teach a graduate course in Theory of Programming Languages.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29668", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G. F.", + "last_name": "Johnson", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/Johnson87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29660", + "title": "A generator for language-specific debugging systems", + "abstract": "We present a system which generates interactive high-level debugging systems from formal language definitions. The language definer has to specify a denotational semantics augmented with a formal description of the language specific debugging facilities. The generated debugger offers the traditional features such as tracing programs, setting breakpoints, displaying variables etc; interaction with the user is always on language level rather than on machine level. The concept has been implemented as part of the PSG-Programming System Generator, and has successfully been used to generate debuggers for Pascal and Modula-2. The core of the implementation consists of an interpreter for a functional language, which has been extended with the language-independent mechanisms needed in order to allow interaction with the user during program execution.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29660", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "R.", + "last_name": "Bahlke", + "institution": "Darmstadt University of Applied Sciences" + }, + { + "first_name": "Brödel", + "last_name": "Moritz", + "institution": "Darmstadt University of Applied Sciences" + }, + { + "first_name": "G.", + "last_name": "Snelting", + "institution": "Darmstadt University of Applied Sciences" + } + ], + "dblp_key": "conf/pldi/BahlkeMS87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29672", + "title": "Interpreting ABF - a language for document construction", + "abstract": "This paper describes an interpreter for ABF, a language for constructing legal documents. The ABF language defines both commands to develop documents and commands to manipulate those documents. The language has typical programming constructs for sequence, selection, and repetition but also allows the user other capabilities to aid in document construction; the user can modify the program while it is running (change the document while it is being processed), type the variables during the initial processing of a document, and then change the type during later processing, enter commands that require a change of context during the processing of a document, output a document with variables still undefined. A document is constructed using conditional and repeat statements and incorporation of other documents by reference. Data types include documents, strings, numbers, dollar amounts and logical values. Arrays can be formed for all types except documents. There are three forms of subprograms: documents can be incorporated by reference in other documents at any point at which a variable name is permitted; rules (subprocedures) for computing values can be attached to any variable; and alternate questions can be attached to variables in a similar manner. The ABF system queries the user for any values needed to complete a document; questions are generated from variable names.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29672", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "H.", + "last_name": "Harr", + "institution": "DePaul University" + }, + { + "first_name": "M. W.", + "last_name": "Evens", + "institution": "Chicago Kent College of Law" + }, + { + "first_name": "J.", + "last_name": "Sprowl", + "institution": "Chicago Kent College of Law" + } + ], + "dblp_key": "conf/pldi/HarrES87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29664", + "title": "Efficient interpretation of Prolog programs", + "abstract": "The paper focuses on three ideas for solving problems with writing interpreters for the logic programming language Prolog in Prolog and how to combine these ideas to an interpreter for Prolog which is both simple and efficient. The resulting interpreter system can be incorporated into a Prolog based on Warren's Abstract Machine and built mostly from existing parts of it. The interpreter has been implemented and is used in a Prolog system developed at Uppsala University.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29664", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "J.", + "last_name": "Barklund", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/pldi/Barklund87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29662", + "title": "Selective interpretation as a technique for debugging computationally intensive programs", + "abstract": "As part of Rice University's project to build a programming environment for scientific software, we have built a facility for program execution that solves some of the problems inherent in debugging large, computationally intensive programs. By their very nature such programs do not lend themselves to full-scale interpretation. In moderation however, interpretation can be extremely useful during the debugging process. In addition to discussing the particular benefits that we expect from interpretation, this paper addresses how interpretive techniques can be effectively used in conjunction with the execution of compiled code. The same implementation technique that permits interpretation to be incorporated as part of execution will also permit the execution facility to be used for debugging parallel programs running on a remote machine.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29662", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "B. B.", + "last_name": "Chase", + "institution": "Rice University" + }, + { + "first_name": "Robert", + "last_name": "Hood", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/ChaseH87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29679", + "title": "Parallelism, persistence and meta-cleanliness in the symmetric Lisp interpreter", + "abstract": "Symmetric Lisp is a programming language designed around first-class environments, where an environment is a dictionary that associates names with definitions or values. In this paper we describe the logical structure of the Symmetric Lisp interpreter. In other interpreted languages, the interpreter is a virtual machine that evaluates user input on the basis of its own internal state. The Symmetric Lisp interpreter, on the other hand, is a simple finite-state machine with no internal state. Its role is to attach user input to whatever environment the user has specified; such environments are transparent objects created by, maintained by and fully accessible to the user. The interpreter's semantics are secondary to the semantics of environments in Symmetric Lisp: it is the environment-object to which an expression is attached, not the interpreter, that controls the evaluation of expressions.This arrangement has several consequences. Because environments in Symmetric Lisp are governed by a parallel evaluation rule, the Symmetric Lisp interpreter is a parallel interpreter. A Symmetric Lisp environment evaluates to another environment; a session with the interpreter therefore yields a well-defined environment object as its result. Users are free to write routines that manage these interpreter-created objects - routines that list the elements of a namespace, coalesce environments, maintain multiple name definitions and so on precisely because environment objects may be freely inspected and manipulated. Because a named environment may contain other named environments as elements, interpreter-created objects may be regarded as hierarchical file systems. Because of the parallel evaluation semantics of environments, the interpreter is well-suited as an interface to a concurrent, language-based computer system that uses Symmetric Lisp as its base language. We argue that - in short - a basic semantic simplification in Symmetric Lisp promises a correspondingly basic increase in power at the user-interpreter interface.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29679", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Gelernter", + "institution": "Yale University" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "T.B.", + "last_name": "London", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/GelernterJL87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29671", + "title": "Design of an interpretive environment for Turing", + "abstract": "This paper presents the design of an interpreter structure for modern programming languages such as Turing and Modula II that is modular and highly orthogonal while providing maximal flexibility and efficiency in implementation. At the outermost level, the structure consists of a front end, responsible for interaction with the user, and a back end, responsible for execution. The two are linked by a single database consisting of the tokenized statements of the user program. Interfaces between the major modules of each part are defined in such a way as to maximize reusability, and each interface can service a range of plug-compatible modules implementing radically different semantics. The design accommodates a wide spectrum of interpreter types ranging from batch-oriented compiler-simulators to statement-by-statement interactive execution, and provides for a range of program editing tools from simple line editors through to modern language-directed programming environments. It has served as the basis for several interpretive systems including the production Turing interpreter, the Turing Programming Environment, and the Turing Tool software maintenance tool.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29671", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James R.", + "last_name": "Cordy", + "institution": "Queen's University" + }, + { + "first_name": "T.C. Nicholas", + "last_name": "Graham", + "institution": "Queen's University" + } + ], + "dblp_key": "conf/pldi/CordyG87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29673", + "title": "Constructive real interpretation of numerical programs", + "abstract": "We explore the feasibility of providing exact real arithmetic for use in conventional numerical programs. We have built a prototype interpreter which replaces floating point operations with operations on constructive real numbers in the execution of conventional Fortran programs. Such a facility makes it unnecessary to concern oneself with issues of numerical stability in the solution of small problems. It also provides a useful tool for the development of larger numerical programs.We discuss the computability and algorithmic issues involved in the design of the interpreter, as well as some preliminary experiences and performance measurements.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29673", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/Boehm87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29667", + "title": "TOOLS: a unifying approach to object-oriented language interpretation", + "abstract": "The object-oriented paradigm is applied to the interpreting of programming languages. An intermediate representation of a program is created as a collection of objects representing various entities in the conceptual world of the source language. These objects cover both the static and the dynamic aspects of a program. As a major advantage of this approach, issues that are traditionally handled by very different techniques (like symbol table management and the generation and execution of intermediate code) can be treated in a unified manner. The specification language of an interpreter generator based on these principles is described.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29667", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "K.", + "last_name": "Koskimies", + "institution": "University of Helsinki" + }, + { + "first_name": "J.", + "last_name": "Paakki", + "institution": "University of Helsinki" + } + ], + "dblp_key": "conf/pldi/KoskimiesP87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29670", + "title": "Cint: a RISC interpreter for the C programming language", + "abstract": "Cint is an interpretation system for the C programming language. Like most interpretation systems, it provides \"load and go\" type execution as well as enhanced debugging and performance analysis tools. Cint consists of two phases--a translator and an interpreter. The translator compiles the source program into code for a virtual machine. The interpreter then loads and executes this code. While providing services similar to traditional interpreters, Cint differs from them in two important ways. First, the virtual machine languages used by many interpreters are quite large; machines with 100 to 200 operations are common. In contrast, Cint's virtual machine has only 63 operations. Second, to achieve acceptable execution speeds, interpreters are often implemented in the assembly language of the host machine. Cint, however, is written entirely in C and is therefore portable. In fact, it has been transported to four machines without modification. Despite the compact size of the virtual machine language and the high-level language implementation, Cint's execution speed is comparable to that of other interpreters. This paper describes the design of the virtual machine, the implementation of the interpreter, and the performance of the system.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29670", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jack W.", + "last_name": "Davidson", + "institution": "University of Virginia" + }, + { + "first_name": "J. V.", + "last_name": "Gresh", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/pldi/DavidsonG87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29674", + "title": "The JADE interpreter: a RISC interpreter for syntax directed editing", + "abstract": "This paper describes key features of an interpreter for a language-based editor. The interpreter unites in a RISC framework features which have been used in other domains. The paper examines each feature's integration into the RISC framework.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29674", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "C. F.", + "last_name": "Clark", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Clark87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29655", + "title": "Enhancement through extension: the extension interpreter", + "abstract": "The ability to extend programs dynamically has clear advantages. However, providing efficient yet sufficiently flexible support for such capabilities system-wide presents significant challenges. We describe a design and implementation of an extension mechanism that depends heavily on interpretive techniques, including call arbitration, dynamic linking, and multilanguage extensions. We discuss these mechanisms in the context of our Extension Interpreter, which embodies our ideas and provides a framework for discussing the efficiency and generality of the implementation. Our current implementation runs under BSD UNIX 4.2 and 4.3 on VAXes and SUN workstations. Extensions can be written in both C and in Icon, demonstrating our ability to address problems both of compiled and interpreted languages.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29655", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "D.", + "last_name": "Notkin", + "institution": "University of Washington" + }, + { + "first_name": "William G.", + "last_name": "Griswold", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/NotkinG87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29651", + "title": "Mimic: a fast system/370 simulator", + "abstract": "Software simulation of one computer on another tends to be slow. Traditional simulators typically execute about 100 instructions on the host machine per instruction simulated. Newer simulators reduce the expansion factor to about 10, by saving and reusing translations of individual instructions. This paper describes an experimental simulator which takes the progression one step further, translating groups of instructions as a unit. This approach, combined with flow analysis, reduces the expansion factor to about 4. The new simulator simulates System/370 on a RISC, namely the IBM RT PC.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29651", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "C.", + "last_name": "May", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/May87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29665", + "title": "A recursive interpreter for the Icon programming language", + "abstract": "The implementation of the Icon programming language is more interesting and difficult than the implementation of many other programming languages because an expression in Icon can generate a sequence of results. The implementation therefore must support control backtracking in expression evaluation. There also are several novel control structures related to generators. Because expression evaluation is limited lexically, a full coroutine mechanism is not needed and expression evaluation can be handled in a stack-like fashion.The implementation of Icon consists of a virtual machine with a stack-based architecture and an interpreter that executes the virtual machine instructions. There have been several different interpreters for Icon's virtual machine. This paper describes a new approach in which the interpreter is called recursively whenever the context for expression evaluation changes. This recursive interpreter has the advantage of being conceptually clear and flexible without sacrificing efficiency.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29665", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "J.", + "last_name": "O'Bagy", + "institution": "University of Arizona" + }, + { + "first_name": "Ralph E.", + "last_name": "Griswold", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/OBagyG87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29678", + "title": "Distributed garbage collection", + "abstract": "There are two basic approachs to the problem of storage reclamation, process- and processor-based, named for the view point used to recognize when a particular piece of storage can be reclaimed. Examples of the processor approach include mark/sweep and copying algorithms and their variants, while reference counting schemes use a process view of the collection. It is argued that the process approach is better suited for distributed computation where links between dynamically allocated objects may cross processor boundaries. In addition, the process approach allows the heap to be more conveniently shared with other processes in those cases when different processes might not have their own virtual address spaces. A new algorithm using the process approach is given. Its space requirement per object is better than that for reference counting. In addition, a restricted form of pointer replacement is supported which allows circular structures so constructed to be properly collected.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29678", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "J. D.", + "last_name": "Eckart", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "R. J.", + "last_name": "LeBlanc", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/pldi/EckartL87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29676", + "title": "Memory allocation and higher-order functions", + "abstract": "This paper presents a constant-time marking-collecting algorithm to efficiently implement recursion with a general heap memory rather than with a vectorial stack, in a context of frequent captures of continuations. It has been seen to reduce the 80% garbage collection overhead to less than 5% on average.The algorithm has been built into a virtual machine to efficiently implement at the assembly level the Actor language PLASMA, an Actor-oriented version of PROLOG and a variant of SCHEME, currently in use on 8086, 68000 and Vax.The rationale to use the heap memory is that continuations are available via a single pointer in a unified memory and can be shared optimally when recurrently captured, which is simply impossible using a strategy based on stack recopy. Further, non-captured continuations can be incrementally garbage collected on the fly.Part I describes the elementary recursive instructions of the virtual machine. Part II presents and proves the marking-collecting strategy. Part III safely generalizes the transformation \"call + return = branch\" in a way compatible with the possible capture of the current continuation. An appendix relates its integration in the Virtual Scheme Machine supporting Scheme 84.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29676", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/pldi/Danvy87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29652", + "title": "A block-and-actions generator as an alternative to a simulator for collecting architecture measurements", + "abstract": "To design a new processor or to modify an existing one, designers need to gather data to estimate the influence of specific architecture features on the performance of the proposed machine (PM). To obtain this data, it is necessary to measure on an existing machine (EM) the dynamic behavior of typical programs. Traditionally, simulators have been used to obtain measurements for PMs. Since several hundred EM instructions are required to decode, interpret, and measure each simulated (PM) instruction, the simulation time of typical programs is prohibitively large. Thus, designers tend to simulate only small programs and the results obtained might not be representative of a real system behavior. In this paper we present an alternative tool for collecting architecture measurements: the Block-and-Actions Generator (BKGEN). BKGEN produces a version of the program being measured which is directly executable by the EM. This executable version is obtained directly with the EM compiler or with the PM compiler and a assembly-to-assembly translator. The choice between these alternatives depends on the EM and PM compiler technology and the type of measurements to be obtained. BKGEN also collects the PM events to be measured (called actions). Each EM block of instructions is associated with a PM block of actions so that when the program is executed, it collects the measurements associated with the PM. The main advantage of BKGEN is that the execution time is substantially reduced compared to the execution time of a simulator while collecting similar data. Thus, large typical programs (compilers, assemblers, word processors, ...) can be used by the designer to obtain meaningful measurements.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29652", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "M.", + "last_name": "Huguet", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "T.", + "last_name": "Lang", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Y.", + "last_name": "Tamir", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/HuguetLT87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29666", + "title": "Two-level hybrid interpreter/native code execution for combined space-time program efficiency", + "abstract": "A two-level programming model permits the applications programmer to write programs that benefit both from the code density of interpreted virtual machines and from the speed of native code execution. A well-defined boundary between the native code and the virtual machine facilitates the development of translators to be used at both levels.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29666", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "T.", + "last_name": "Pittman", + "institution": "Kansas State University" + } + ], + "dblp_key": "conf/pldi/Pittman87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29680", + "title": "CCAL: An interpreted language for experimentation in concurrent control", + "abstract": "Concurrent Control Abstraction Language, CCAL, is an interpreted language which provides no particular control regime to the user. CCAL instead supports five primitive operations which manipulate an abstract model of inter-procedural control. This model is intrinsically concurrent, and the user is allowed to construct high-level concurrent control operations from the primitives (hence, control abstraction). The primary use of CCAL is as a vehicle by which rapid prototyping of application specific control forms may be done and as a tool for the construction and evaluation of novel control forms, especially control forms for highly concurrent and distributed systems. The CCAL interpreter is implemented as a distributed program on a network of Vaxen and Sun-3 workstations under 4.2bsd and 4.3bsd Unix1. CCAL programs appear as multi-process programs in a shared memory system. Both true and apparent concurrency are possible. This paper describes the control abstraction facilities offered by the CCAL interpreter, its use, and implementation strategies in the distributed environment.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29680", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Phil", + "last_name": "Kearns", + "institution": "Williams (United States)" + }, + { + "first_name": "Megan Culler", + "last_name": "Freeman", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/pldi/KearnsF87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29661", + "title": "DI: an interactive debugging interpreter for applicative languages", + "abstract": "The DI interpreter is both a debugger and interpreter of SISAL programs. Its use as a program interpreter is only a small part of its role; it is designed to be a tool for studying compilation techniques for applicative languages. DI interprets dataflow graphs expressed in the IF1 and IF2 languages, and is heavily instrumented to report the activity of dynamic storage activity, reference counting, copying and updating of structured data values. It also aids the SISAL language evaluation by providing an interim execution vehicle for SISAL programs. DI provides determinate, sequential interpretation of graph nodes for sequential and parallel operations in a canonical order. As a debugging aid, DI allows tracing, breakpointing, and interactive display of program data values. DI handles creation of SISAL and IF1 error values for each data type and propagates them according to a well-defined algebra. We have begun to implement IF1 optimizers and have measured the improvements with DI.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29661", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "S.", + "last_name": "Skedzielewski", + "institution": "Lawrence Livermore National Laboratory" + }, + { + "first_name": "Robert K.", + "last_name": "Yates", + "institution": "Lawrence Livermore National Laboratory" + }, + { + "first_name": "R. R.", + "last_name": "Oldehoeft", + "institution": "Colorado State University" + } + ], + "dblp_key": "conf/pldi/SkedzielewskiYO87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29658", + "title": "Efficient interpretation of synchronizable series expressions", + "abstract": "The benefits of programming in a functional style are well known. For example, algorithms which are expressed as compositions of functions operating on series/vectors/streams of data elements are much easier to understand and modify than equivalent algorithms expressed as loops. Unfortunately, many programmers hesitate to use series expressions because they are typically implemented very inefficiently-the prime source of inefficiency being the creation of intermediate series objects.A restricted class of series expressions, obviously synchronizable series expressions, is defined which can be evaluated very efficiently because they do not require the creation of any intermediate series objects. A Common Lisp macro package has been implemented which supports obviously synchronizable series expressions. Using this macro package, programmers can obtain the advantages of expressing computations as series expressions without incurring any runtime overhead. Obviously synchronizable series expressions could be straightforwardly supported in any programming language.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29658", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Richard C.", + "last_name": "Waters", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Waters87", + "venue": "pldi", + "year": 1987 + }, + { + "paper_id": "10.1145/29650.29656", + "title": "The type inference and coercion facilities in the scratchpad II interpreter", + "abstract": "The Scratchpad II system is an abstract datatype programming language, a compiler for the language, a library of packages of polymorphic functions and parametrized abstract datatypes, and an interpreter that provides sophisticated type inference and coercion facilities. Although originally designed for the implementation of symbolic mathematical algorithms, Scratchpad II is a general purpose programming language. This paper discusses aspects of the implementation of the interpreter and how it attempts to provide a user friendly and relatively weakly typed front end for the strongly typed programming language.", + "date": "1987-01-01", + "link": "https://doi.org/10.1145/29650.29656", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert S.", + "last_name": "Sutor", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Richard D.", + "last_name": "Jenks", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/SutorJ87", + "venue": "pldi", + "year": 1987 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1988.json b/data/pl_conferences/pldi/1988.json new file mode 100644 index 0000000..b97fe7e --- /dev/null +++ b/data/pl_conferences/pldi/1988.json @@ -0,0 +1,705 @@ +[ + { + "paper_id": "10.1145/53990.54012", + "title": "An Automatically Generated, Realistic Compiler for an Imperative Programming Language", + "abstract": "We describe the automatic generation of a complete, realistic compiler from formal specifications of the syntax and semantics of Sol/C, a nontrivial imperative language “sort of like C.” The compiler exhibits a three pass structure, is efficient, and produces object programs whose performance characteristics compare favorably with those produced by commercially available compilers. To our knowledge, this is the first time that this has been accomplished.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54012", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "U. F.", + "last_name": "Pleban", + "institution": "Tektronix (United States)" + }, + { + "first_name": "P.", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/PlebanL88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54020", + "title": "Unfold/Fold Transformations and Loop Optimization of Logic Programs", + "abstract": "Programs typically spend much of their execution time in loops. This makes the generation of efficient code for loops essential for good performance. Loop optimization of logic programming languages is complicated by the fact that such languages lack the iterative constructs of traditional languages, and instead use recursion to express loops. In this paper, we examine the application of unfold/fold transformations to three kinds of loop optimization for logic programming languages: recursion removal, loop fusion and code motion out of loops. We describe simple unfold/fold transformation sequences for these optimizations that can be automated relatively easily. In the process, we show that the properties of unification and logical variables can sometimes be used to generalize, from traditional languages, the conditions under which these optimizations may be carried out. Our experience suggests that such source-level transformations may be used as an effective tool for the optimization of logic programs.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54020", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "S.", + "last_name": "Debray", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/Debray88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54011", + "title": "Incremental Evaluation for a General Class of Circular Attribute Grammars", + "abstract": "article Free Access Share on Incremental evaluation for a general class of circular attribute grammars Authors: J. A. Walz Cornell Univ., Ithaca, NY Cornell Univ., Ithaca, NYView Profile , G. F. Johnson Univ. of Maryland, College Park, MD Univ. of Maryland, College Park, MDView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 23Issue 7July 1988 pp 209–221https://doi.org/10.1145/960116.54011Online:01 June 1988Publication History 6citation247DownloadsMetricsTotal Citations6Total Downloads247Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54011", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Janet A.", + "last_name": "Walz", + "institution": "Cornell University" + }, + { + "first_name": "Gregory F.", + "last_name": "Johnson", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/WalzJ88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54004", + "title": "A Mechanism for Efficient Debugging of Parallel Programs", + "abstract": "This paper addresses the design and implementation of an integrated debugging system for parallel programs running on shared memory multi-processors (SMMP). We describe the use of flowback analysis to provide information on causal relationships between events in a program's execution without re-executing the program for debugging. We introduce a mechanism called incremental tracing that, by using semantic analyses of the debugged program, makes the flowback analysis practical with only a small amount of trace generated during execution. We extend flowback analysis to apply to parallel programs and describe a method to detect race conditions in the interactions of the co-operating processes.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54004", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Barton P.", + "last_name": "Miller", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/MillerC88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54010", + "title": "Higher-Order Abstract Syntax", + "abstract": "We describe motivation, design, use, and implementation of higher-order abstract syntax as a central representation for programs, formulas, rules, and other syntactic objects in program manipulation and other formal systems where matching and substitution or unification are central operations. Higher-order abstract syntax incorporates name binding information in a uniform and language generic way. Thus it acts as a powerful link integrating diverse tools in such formal environments. We have implemented higher-order abstract syntax, a supporting matching and unification algorithm, and some clients in Common Lisp in the framework of the Ergo project at Carnegie Mellon University.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54010", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/PfenningE88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54009", + "title": "Grammatical Abstraction and Incremental Syntax Analysis in a Language-Based Editor", + "abstract": "Processors for programming languages and other formal languages typically use a concrete syntax to describe the user's view of a program and an abstract syntax to represent language structures internally. Grammatical abstraction is defined as a relationship between two context-free grammars. It formalizes the notion of one syntax being “more abstract” than another. Two variants of abstraction are presented. Weak grammatical abstraction supports (i) the construction during LR parsing of an internal representation that is closely related to the abstract syntax and (ii) incremental LR parsing using that internal representation as its base. Strong grammatical abstraction tightens the correspondence so that top-down construction of incrementally-parsable internal representations is possible. These results arise from an investigation into language-based editing systems, but apply to any program that transforms a linguistic object from a representation in its concrete syntax to a representation in its abstract syntax or vice versa.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54009", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert A.", + "last_name": "Ballance", + "institution": "University of California, Berkeley" + }, + { + "first_name": "J.", + "last_name": "Butcher", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Stuart L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/BallanceBG88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54001", + "title": "Design and Implementation of the UW Illustrated Compiler", + "abstract": "We have implemented an illustrated compiler for a simple block structured language. The compiler graphically displays its control and data structures, and so gives its viewers an intuitive understanding of compiler organization and operation. The illustrations were planned by hand and display information naturally and concisely.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54001", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "K.", + "last_name": "Andrews", + "institution": "University of Washington" + }, + { + "first_name": "R.R.", + "last_name": "Henry", + "institution": "University of Washington" + }, + { + "first_name": "W. K.", + "last_name": "Yamamoto", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/AndrewsHY88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.53992", + "title": "Real-Time Concurrent Collection on Stock Multiprocessors", + "abstract": "We've designed and implemented a copying garbage-collection algorithm that is efficient, real-time, concurrent, runs on commercial uniprocessors and shared-memory multiprocessors, and requires no change to compilers. The algorithm uses standard virtual-memory hardware to detect references to “from space” objects and to synchronize the collector and mutator threads. We've implemented and measured a prototype running on SRC's 5-processor Firefly. It will be straightforward to merge our techniques with generational collection. An incremental, non-concurrent version could be implemented easily on many versions of Unix.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.53992", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "J. R.", + "last_name": "Ellis", + "institution": "" + }, + { + "first_name": "K.", + "last_name": "Li", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/AppelEL88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.53997", + "title": "Register Windows versus Register Allocation", + "abstract": "A large register set can be exploited by keeping variables and constants in registers instead of in memory. Hardware register windows and compile-time or link-time global register allocation are ways to do this. A measure of the effectiveness of any of these register management schemes is how thoroughly they remove loads and stores. This measure must also count extra loads and stores executed because of window overflow or conflicts between procedures.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.53997", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "D. W.", + "last_name": "Wall", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Wall88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54016", + "title": "Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems", + "abstract": "This paper deals with the integration of an efficient asynchronous remote procedure call mechanism into a programming language. It describes a new data type called a promise that was designed to support asynchronous calls. Promises allow a caller to run in parallel with a call and to pick up the results of the call, including any exceptions it raises, in a convenient and type-safe manner. The paper also discusses efficient composition of sequences of asynchronous calls to different locations in a network.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54016", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "B.", + "last_name": "Liskov", + "institution": "" + }, + { + "first_name": "L.", + "last_name": "Shrira", + "institution": "" + } + ], + "dblp_key": "conf/pldi/LiskovS88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.53993", + "title": "Detecting Conflicts Between Structure Accesses", + "abstract": "Two references to a record structure conflict if they access the same field and at least one modifies the location. Because structures can be connected by pointers, deciding if two statements conflict requires knowledge of the possible aliases for the locations that they access.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.53993", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Paul", + "last_name": "Hilfinger", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/LarusH88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.53998", + "title": "Automatic Generation of Fast Optimizing Code Generators", + "abstract": "article Free Access Share on Automatic generation of fast optimizing code generators Authors: C. W. Fraser AT&T Bell Laboratories, Murray Hill, NJ AT&T Bell Laboratories, Murray Hill, NJView Profile , A. L. Wendt Univ. of Arizona, Tucson, AZ Univ. of Arizona, Tucson, AZView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 23Issue 7July 1988 pp 79–84https://doi.org/10.1145/960116.53998Online:01 June 1988Publication History 19citation463DownloadsMetricsTotal Citations19Total Downloads463Last 12 Months16Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.53998", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "AT&T (United States)" + }, + { + "first_name": "Alexander", + "last_name": "Wendt", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/FraserW88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.53996", + "title": "Interprocedural Side-Effect Analysis in Linear Time", + "abstract": "We present a new method for solving Banning's alias-free flow-insensitive side-effect analysis problem. The algorithm employs a new data structure, called the binding multi-graph, along with depth-first search to achieve a running time that is linear in the size of the call multi-graph of the program. This method can be extended to produce fast algorithms for data-flow problems with more complex lattice structures.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.53996", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/CooperK88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.53991", + "title": "Safety Considerations for Storage Allocation Optimizations", + "abstract": "Article Free Access Share on Safety consideration for storage allocation optimizations Author: D. R. Chase Olvetti Research Center, Menlo Park, CA Olvetti Research Center, Menlo Park, CAView Profile Authors Info & Claims PLDI '88: Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementationJune 1988 Pages 1–10https://doi.org/10.1145/53990.53991Published:01 June 1988Publication History 27citation666DownloadsMetricsTotal Citations27Total Downloads666Last 12 Months11Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.53991", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "D. R.", + "last_name": "Chase", + "institution": "Menlo School" + } + ], + "dblp_key": "conf/pldi/Chase88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.53995", + "title": "The Program Summary Graph and Flow-Sensitive InterproceduralData Flow Analysis", + "abstract": "article Free Access Share on The program summary graph and flow-sensitive interprocedual data flow analysis Author: D. Callahan Rice Univ., Houston, TX Rice Univ., Houston, TXView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 23Issue 7July 1988 pp 47–56https://doi.org/10.1145/960116.53995Published:01 June 1988Publication History 108citation1,084DownloadsMetricsTotal Citations108Total Downloads1,084Last 12 Months81Last 6 weeks22 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.53995", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "D.", + "last_name": "Callahan", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/Callahan88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54014", + "title": "Compiling C for Vectorization, Parallelization, and Inline Expansion", + "abstract": "Practical implementations of real languages are often an excellent way of testing the applicability of theoretical principles. Many stresses and strains arise from fitting practicalities, such as performance and standard compatibility, to theoretical models and methods. These stresses and strains are valuable sources of new research and insight, as well as an oft-needed check on the egos of theoreticians.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54014", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "R.", + "last_name": "Allen", + "institution": "Ardent Sound (United States)" + }, + { + "first_name": "Steven L.", + "last_name": "Johnson", + "institution": "Ardent Sound (United States)" + } + ], + "dblp_key": "conf/pldi/AllenJ88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54005", + "title": "Debugging Concurrent Processes: A Case Study", + "abstract": "We present a case study that illustrates a method of debugging concurrent processes in a parallel programming environment. It uses a new approach called speculative replay to reconstruct the behavior of a program from the histories of its individual processes. Known time dependencies between events in different processes are used to divide the histories into dependence blocks. A graphical representation called a concurrency map displays possibilities for concurrency among processes. The replay technique preserves the known dependencies and compares the process histories generated during replay with those that were logged during the original program execution. If a process generates a replay history that does not match its original history, replay backs up. An alternative ordering of events is created and tested to see if it produces process histories that match the original histories. Successively more controlled replay sequences are generated, by introducing additional dependencies. We describe ongoing work on tools that will control replay without reconstructing the entire space of possible event orderings.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54005", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Janice M.", + "last_name": "Stone", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/Stone88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54021", + "title": "Optimal Loop Parallelization", + "abstract": "Article Free Access Share on Optimal loop parallelization Authors: A. Aiken Cornell Univ., Itaca, NY Cornell Univ., Itaca, NYView Profile , A. Nicolau Cornell Univ., Ithaca, NY Cornell Univ., Ithaca, NYView Profile Authors Info & Claims PLDI '88: Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementationJune 1988Pages 308–317https://doi.org/10.1145/53990.54021Published:01 June 1988Publication History 190citation1,422DownloadsMetricsTotal Citations190Total Downloads1,422Last 12 Months97Last 6 weeks11 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54021", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Cornell University" + }, + { + "first_name": "A.", + "last_name": "Nicolau", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/AikenN88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54019", + "title": "A Piggy-back Compiler For Prolog", + "abstract": "Article A piggy-back compiler for Prolog Share on Authors: J. L. Weiner Univ. of New Hampshire Univ. of New HampshireView Profile , S. Ramakrishman Univ. of New Hampshire Univ. of New HampshireView Profile Authors Info & Claims PLDI '88: Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementationJune 1988 Pages 288–296https://doi.org/10.1145/53990.54019Published:01 June 1988 8citation271DownloadsMetricsTotal Citations8Total Downloads271Last 12 Months5Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54019", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "J. L.", + "last_name": "Weiner", + "institution": "University of New Hampshire at Manchester" + }, + { + "first_name": "S.", + "last_name": "Ramakrishman", + "institution": "University of New Hampshire at Manchester" + } + ], + "dblp_key": "conf/pldi/WeinerR88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54000", + "title": "Anatomy of a Hardware Compiler", + "abstract": "Programming-language compilers generate code targeted to machines with fixed architectures, either parallel or serial. Compiler techniques can also be used to generate the hardware on which these programming languages are executed. In this paper we demonstrate that many compilation techniques developed for programming languages are applicable to compilation of register-transfer hardware designs. Our approach uses a typical syntax-directed translation → global optimization → local optimization → code generation → peephole optimization method. In this paper we will describe ways in which we have both followed and diverged from traditional compiler approaches to these problems and compare our approach to other compiler oriented approaches to hardware compilation.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54000", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "K.", + "last_name": "Keutzer", + "institution": "AT&T (United States)" + }, + { + "first_name": "W.", + "last_name": "Wolf", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/KeutzerW88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.53999", + "title": "Minimizing Register Usage Penalty at Procedure Calls", + "abstract": "Inter-procedural register allocation can minimize the register usage penalty at procedure calls by reducing the saving and restoring of registers at procedure boundaries. A one-pass inter-procedural register allocation scheme based on processing the procedures in a depth-first traversal of the call graph is presented. This scheme can be overlaid on top of intra-procedural register allocation via a simple extension to the priority-based coloring algorithm. Using two different usage conventions for the registers, the scheme can distribute register saves/restores throughout the call graph even in the presence of recursion, indirect calls or separate compilation. A natural and efficient way to pass parameters emerges from this scheme. A separate technique uses data flow analysis to optimize the placement of the save/restore code for registers within individual procedures. The techniques described have been implemented in a production compiler suite. Measurements of the effects of these techniques on a set of practical programs are presented and the results analysed.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.53999", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fred", + "last_name": "Chow", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Chow88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54007", + "title": "Control-Flow Analysis in Scheme", + "abstract": "Traditional flow analysis techniques, such as the ones typically employed by optimizing Fortran compilers, do not work for Scheme-like languages. This paper presents a flow analysis technique — control flow analysis — which is applicable to Scheme-like languages. As a demonstration application, the information gathered by control flow analysis is used to perform a traditional flow analysis problem, induction variable elimination. Extensions and limitations are discussed.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54007", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/Shivers88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54013", + "title": "Semantic Analysis in a Concurrent Compiler", + "abstract": "Traditional compilers are usually sequential programs that serially process source programs through lexical analysis, syntax analysis, semantic analysis and code generation. The availability of multiprocessor computers has made it feasible to consider alternatives to this serial compilation process. The authors are currently engaged in a project to devise ways of structuring compilers so that they can take advantage of modern multiprocessor hardware. This paper is about the most difficult aspect of concurrent compilation: concurrent semantic analysis.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54013", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "V.", + "last_name": "Seshadri", + "institution": "University of Toronto" + }, + { + "first_name": "S.", + "last_name": "Weber", + "institution": "University of Toronto" + }, + { + "first_name": "D. B.", + "last_name": "Wortman", + "institution": "University of Toronto" + }, + { + "first_name": "CHENWEI", + "last_name": "YU", + "institution": "University of Toronto" + }, + { + "first_name": "I.", + "last_name": "Small", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/pldi/SeshadriWJWYS88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54003", + "title": "DOC: A Practical Approach to Source-Level Debugging of Globally Optimized Code", + "abstract": "As optimizing compilers become more sophisticated, the problem of debugging the source code of an application becomes more difficult. In order to investigate this problem, we implemented DOC, a prototype solution for Debugging Optimized Code. DOC is a modification of the existing C compiler and source-level symbolic debugger for the HP9000 Series 800. This paper describes our experiences in this effort. We show in an actual implementation that source-level debugging of globally optimized code is viable.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54003", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "D. S.", + "last_name": "Coutant", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "S.", + "last_name": "Meloy", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "M.", + "last_name": "Ruscetta", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/CoutantMR88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54022", + "title": "Software Pipelining: An Effective Scheduling Technique for VLIW Machines", + "abstract": "This paper shows that software pipelining is an effective and viable scheduling technique for VLIW processors. In software pipelining, iterations of a loop in the source program are continuously initiated at constant intervals, before the preceding iterations complete. The advantage of software pipelining is that optimal performance can be achieved with compact object code.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54022", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/Lam88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54023", + "title": "A Portable Global Optimizer and Linker", + "abstract": "To reduce complexity and simplify their implementation, most compilers are organized as a set of passes or phases. Each phase performs a particular piece of the compilation process. In an optimizing compiler, the assignment of function and order of application of the phases is a critical part of the design. A particularly difficult problem is the arrangement of the code generation and optimization phases so as to avoid phase ordering problems caused by the interaction of the phases. In this paper, we discuss the implementation of a compiler/linker that has been designed to avoid these problems. The key aspect of this design is that the synthesis phases of the compiler and the system linker share the same intermediate program representation. This results in two benefits. It permits the synthesis phases of the compiler to be performed in any order and repeatedly, thus eliminating potential phase ordering problems. Second, it permits code selection to be invoked at any point during the synthesis phases as well as at link time. The ability to perform code selection at link time presents many opportunities for additional optimizations. Measurements about the effectiveness of using this approach in a C compiler on two different machines are presented.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54023", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manuel E.", + "last_name": "Benitez", + "institution": "University of Virginia" + }, + { + "first_name": "Jack W.", + "last_name": "Davidson", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/pldi/BenitezD88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54017", + "title": "Multiprocessor Smalltalk: A Case Study of a Multiprocessor-Based Programming Environment", + "abstract": "We have adapted an interactive programming system (Smalltalk) to a multiprocessor (the Firefly). The task was not as difficult as might be expected, thanks to the application of three basic strategies: serialization, replication, and reorganization. Serialization of access to resources disallows concurrent access. Replication provides multiple instances of resources when they cannot or should not be serialized. Reorganization allows us to restructure part of the system when the other two strategies cannot be applied.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54017", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "J.", + "last_name": "Pallas", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/PallasU88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54015", + "title": "Synchronous Operations as First-Class Values", + "abstract": "Synchronous message passing via channels is an interprocess communication (IPC) mechanism found in several concurrent languages, such as CSP, occam, and Amber. Such languages provide a powerful selective I/O operation, which plays a vital role in managing communication with multiple processes. Because the channel IPC mechanism is \"operation-oriented,\" only procedural abstraction techniques can be used in structuring the communication/synchronization aspects of a system. This has the unfortunate effect of restricting the use of selective I/O, which in turn limits the communication structure. We propose a new, \"value-oriented\" approach to channel-based synchronization. We make synchronous operations first-class values, called events, in much the same way that functions are first-class values in functional programming languages. Our approach allows the use of data abstraction techniques for structuring IPC. We have incorporated events into PML, a concurrent functional programming language, and have implemented run-time support for them as part of the Pegasus system.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54015", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Reppy", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/Reppy88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54008", + "title": "An Optimizer for Ada - Design, Experiences and Results", + "abstract": "In this paper we describe the design of a global machine independent low level optimizer for the Karlsruhe Ada Compiler. We give a short overview on the optimizations and data structures used in the optimizer as well as some experiences with the optimizer. Detailed measurements are provided for a collection of benchmarks. The average improvement of code speed is 40%.", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54008", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "B.", + "last_name": "Schwarz", + "institution": "Karlsruhe University of Education" + }, + { + "first_name": "W.", + "last_name": "Kirchgässner", + "institution": "Karlsruhe University of Education" + }, + { + "first_name": "R.", + "last_name": "Landwehr", + "institution": "Karlsruhe University of Education" + } + ], + "dblp_key": "conf/pldi/SchwarzKL88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54018", + "title": "Refined Types: Highly Differentiated Type Systems and Their Use in the Design of Intermediate Langages", + "abstract": "Article Free Access Share on Refined types: highly differentiated type systems and their use in the design of intermediate languages Author: J. R. Rose Thinking Machines Corporation, Cambridge, MA Thinking Machines Corporation, Cambridge, MAView Profile Authors Info & Claims PLDI '88: Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementationJune 1988Pages 278–287https://doi.org/10.1145/53990.54018Published:01 June 1988Publication History 0citation312DownloadsMetricsTotal Citations0Total Downloads312Last 12 Months23Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54018", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "J. R.", + "last_name": "Rose", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Rose88", + "venue": "pldi", + "year": 1988 + }, + { + "paper_id": "10.1145/53990.54002", + "title": "INC: A Language for Incremental Computations", + "abstract": "article INC: a language for incremental computations Share on Authors: D. Yellin IBM T. J. Watson Research Center, Yorktown Heights, NY IBM T. J. Watson Research Center, Yorktown Heights, NYView Profile , R. Strom IBM T. J. Watson Research Center, Yorktown Heights, NY IBM T. J. Watson Research Center, Yorktown Heights, NYView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 23Issue 7July 1988 pp 115–124https://doi.org/10.1145/960116.54002Online:01 June 1988Publication History 16citation327DownloadsMetricsTotal Citations16Total Downloads327Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1988-06-01", + "link": "https://doi.org/10.1145/53990.54002", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel M.", + "last_name": "Yellin", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Rob", + "last_name": "Strom", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/YellinS88", + "venue": "pldi", + "year": 1988 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1989.json b/data/pl_conferences/pldi/1989.json new file mode 100644 index 0000000..ecdbcde --- /dev/null +++ b/data/pl_conferences/pldi/1989.json @@ -0,0 +1,780 @@ +[ + { + "paper_id": "10.1145/73141.74829", + "title": "A VHDL Compiler Based on Attribute Grammar Methodology", + "abstract": "This paper presents aspects of a compiler for a new hardware description language (VHDL) written using attribute grammar techniques. VHDL is introduced, along with the new compiler challenges brought by a language that extends an Ada subset for the purpose of describing hardware. Attribute grammar programming solutions are presented for some of the language challenges.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74829", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rodney", + "last_name": "Farrow", + "institution": "Bharat Petroleum (India)" + }, + { + "first_name": "Alec G.", + "last_name": "Stanculescu", + "institution": "Vantage Power (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/FarrowS89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74832", + "title": "An LR Substring Parser for Noncorrecting Syntax Error Recovery", + "abstract": "For a context-free grammar G, a construction is given to produce an LR parser that recognizes any substring of the language generated by G. The construction yields a conflict-free (deterministic) parser for the bounded context class of grammars (Floyd, 1964). The same construction yields either a left-to-right or right-to-left substring parser, as required to implement Non-correcting Syntax Error Recovery as proposed by Richter (1985). Experience in constructing a substring parser for Pascal is described.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74832", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gordon V.", + "last_name": "Cormack", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/pldi/Cormack89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74828", + "title": "A Fresh Look at Combinator Graph Reduction", + "abstract": "We present a new abstract machine for graph reduction called TIGRE. Benchmark results show that TIGRE's execution speed compares quite favorablywithprevious combiiator-graph reduction techniques on similar hardware. Furthermore, the mapping of TIGRE onto conventional hardware is simple and efficient. Mainframe implementations of TIGRE provide performance levels exceeding those previously available on custom graph reduction hardware.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74828", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pieter", + "last_name": "Koopman", + "institution": "" + }, + { + "first_name": "P.", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/KoopmanL89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74834", + "title": "Incremental Generation of Parsers", + "abstract": "An LR-based parser generator for arbitrary context-free grammars is described, which generates parsers by need and processes grammar modifications by updating already existing parsers. We motivate the need for these techniques in the context of interactive language definition environments, present all required algorithms, and give measurements comparing their performance with that of conventional techniques.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74834", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jan", + "last_name": "Heering", + "institution": "Scientific Computing & Modelling (Netherlands)" + }, + { + "first_name": "Paul", + "last_name": "Klint", + "institution": "University of Amsterdam" + }, + { + "first_name": "J.", + "last_name": "Rekers", + "institution": "Scientific Computing & Modelling (Netherlands)" + } + ], + "dblp_key": "conf/pldi/HeeringKR89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74822", + "title": "A Technique for Summarizing Data Access and Its Use in Parallelism Enhancing Transformations", + "abstract": "article A technique for summarizing data access and its use in parallelism enhancing transformations Share on Authors: V. Balasundaram Dept. of Computer Science, Rice University Dept. of Computer Science, Rice UniversityView Profile , K. Kennedy Dept. of Computer Science, Rice University Dept. of Computer Science, Rice UniversityView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 24Issue 7July 1989 pp 41–53https://doi.org/10.1145/74818.74822Published:21 June 1989 104citation512DownloadsMetricsTotal Citations104Total Downloads512Last 12 Months15Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74822", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vasanth", + "last_name": "Balasundaram", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/BalasundaramK89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74846", + "title": "Generational Reference Counting: A Reduced-Communication Distributed Storage Reclamation Scheme", + "abstract": "This paper describes generational reference counting, a new distributed storage reclamation scheme for loosely-coupled multiprocessors. It has a significantly lower communication overhead than distributed versions of conventional reference counting. Although generational reference counting has greater computational and space requirements than ordinary reference counting, it may provide a significant saving in overall execution time on machines in which message passing is expensive.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74846", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Goldberg", + "institution": "New York University" + } + ], + "dblp_key": "conf/pldi/Goldberg89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74821", + "title": "Dependence Analysis for Pointer Variables", + "abstract": "Our concern is how to determine data dependencies between program constructs in programming languages with pointer variables. We are particularly interested in computing data dependencies for languages that manipulate heap-allocated storage, such as Lisp and Pascal. We have defined a family of algorithms that compute safe approximations to the flow, output, and anti-dependencies of a program written in such a language. Our algorithms account for destructive updates to fields of a structure and thus are not limited to the cases where all structures are trees or acyclic graphs; they are applicable to programs that build cyclic structures.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74821", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Phil", + "last_name": "Pfeiffer", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/HorwitzPR89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74838", + "title": "BEG - A Generator for Efficient Back Ends", + "abstract": "This paper describes a system that generates compiler back ends from a strictly declarative specification of the code generation process. The generated back ends use tree pattern matching for code selection. Two methods for register allocation supporting a wide range of target architectures are provided. A general bottom-up pattern matching method avoids problems that occurred with previous systems using LR-parsing. The performance of compilers using generated back ends is comparable to very fast production compilers. Some figures are given about the results of using the system to generate the back end of a Modula-2 compiler.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74838", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "H.", + "last_name": "Emmelmann", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "F.-W.", + "last_name": "Schröer", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Rudolf", + "last_name": "Landwehr", + "institution": "Karlsruhe Institute of Technology" + } + ], + "dblp_key": "conf/pldi/EmmelmannSL89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74820", + "title": "The Semantics of Program Dependence", + "abstract": "Optimizing and parallelizing compilers for procedural languages rely on various forms of program dependence graphs (pdgs) to express the essential control and data dependencies among atomic program operations. In this paper, we provide a semantic justification for this practice by deriving two different forms of program dependence graph — the output pdg and the def-order pdg—and their semantic definitions from non-strict generalizations of the denotational semantics of the programming language. In the process, we demonstrate that both the output pdg and the def-order pdg (with minor technical modifications) are conventional data-flow programs. In addition, we show that the semantics of the def-order pdg dominates the semantics of the output pdg and that both of these semantics dominate—rather than preserve—the semantics of sequential execution.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74820", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Rice University" + }, + { + "first_name": "Mattias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/CartwrightF89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74841", + "title": "Spill Code Minimization Techniques for Optimizing Compilers", + "abstract": "Global register allocation and spilling is commonly performed by solving a graph coloring problem. In this paper we present a new coherent set of heuristic methods for reducing the amount of spill code generated. This results in more efficient (and shorter) compiled code. Our approach has been compared to both standard and priority-based coloring algorithms, universally outperforming them.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74841", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dennis S.", + "last_name": "Bernstein", + "institution": "" + }, + { + "first_name": "Martin Charles", + "last_name": "Golumbic", + "institution": "" + }, + { + "first_name": "Yishay", + "last_name": "Mansour", + "institution": "" + }, + { + "first_name": "Ron Y.", + "last_name": "Pinter", + "institution": "" + }, + { + "first_name": "Dina", + "last_name": "Goldin", + "institution": "" + }, + { + "first_name": "Harald", + "last_name": "Krawczyk", + "institution": "" + }, + { + "first_name": "I.", + "last_name": "Nahshon", + "institution": "" + } + ], + "dblp_key": "conf/pldi/BernsteinGGKMNP89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74839", + "title": "A Language for Writing Code Generators", + "abstract": "Article Free Access Share on A language for writing code generators Author: C. W. Fraser AT&T Bell Laboratories, Murray Hill, NJ AT&T Bell Laboratories, Murray Hill, NJView Profile Authors Info & Claims PLDI '89: Proceedings of the ACM SIGPLAN 1989 conference on Programming language design and implementationJune 1989 Pages 238–245https://doi.org/10.1145/73141.74839Published:21 June 1989Publication History 26citation545DownloadsMetricsTotal Citations26Total Downloads545Last 12 Months34Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74839", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/Fraser89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74843", + "title": "Coloring Heuristics for Register Allocation", + "abstract": "We describe an improvement to a heuristic introduced by Chaitin for use in graph coloring register allocation. Our modified heuristic produces better colorings, with less spill code. It has similar compile-time and implementation requirements. We present experimental data to compare the two methods.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74843", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Preston", + "last_name": "Briggs", + "institution": "Rice University" + }, + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + }, + { + "first_name": "Linda", + "last_name": "Torczon", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/BriggsCKT89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74836", + "title": "Type Reconstruction with First-Class Polymorphic Values", + "abstract": "We present the first type reconstruction system which combines the implicit typing of ML with the full power of the explicitly typed second-order polymorphic lambda calculus. The system will accept ML-style programs, explicitly typed programs, and programs that use explicit types for all first-class polymorphic values. We accomplish this flexibility by providing both generic and explicitly-quantified polymorphic types, as well as operators which convert between these two forms of polymorphism. This type reconstruction system is an integral part of the FX-89 programming language. We present a type reconstruction algorithm for the system. The type reconstruction algorithm is proven sound and complete with respect to the formal typing rules.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74836", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James W.", + "last_name": "O’Toole", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "David K.", + "last_name": "Gifford", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/OTooleG89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74849", + "title": "Unified Management of Registers and Cache Using Liveness and Cache Bypass", + "abstract": "In current computer memory system hierarchy, registers and cache are both used to bridge the reference delay gap between the fast processor(s) and the slow main memory. While registers are managed by the compiler using program flow analysis, cache is mainly controlled by hardware without any program understanding. Due to the lack of coordination in managing these two memory structures, significant loss of system performance results because:", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74849", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cheng", + "last_name": "Chi", + "institution": "Philips (Finland)" + }, + { + "first_name": "H. G.", + "last_name": "Dietz", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/ChiD89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74825", + "title": "Mul-T: A High-Performance Parallel Lisp", + "abstract": "Mul-T is a parallel Lisp system, based on Multilisp's future construct, that has been developed to run on an Encore Multimax multiprocessor. Mul-T is an extended version of the Yale T system and uses the T system's ORBIT compiler to achieve “production quality” performance on stock hardware — about 100 times faster than Multilisp. Mul-T shows that futures can be implemented cheaply enough to be useful in a production-quality system. Mul-T is fully operational, including a user interface that supports managing groups of parallel tasks.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74825", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Kranz", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Robert H.", + "last_name": "Halstead", + "institution": "" + }, + { + "first_name": "Eric", + "last_name": "Mohr", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/KranzHM89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74842", + "title": "Register Allocation via Clique Separators", + "abstract": "Although graph coloring is widely recognized as an effective technique for global register allocation, the overhead can be quite high, not only in execution time but also in memory, as the size of the interference graph needed in coloring can become quite large. In this paper, we present an algorithm based upon a result by R. Tarjan regarding the colorability of graphs which are decomposable using clique separators, that improves on the overhead of coloring. The algorithm first partitions program code into code segments using the notion of clique separators. The interference graphs for the code partitions are next constructed one at a time and colored independently. The colorings for the partitions are combined to obtain a register allocation for the program code. The technique presented is both efficient in space and time because the graph for only a single code segment needs to be constructed and colored at any given point in time. The partitioning of a graph using clique separators increases the likelihood of obtaining a coloring without spilling and hence an efficient allocation of registers for the program. For straight line code an optimal allocation for the entire program code can be obtained from optimal allocations for individual code segments. In the presence of branches, optimal allocation along one execution path and a near optimal allocation along alternative paths can be potentially obtained. Since the algorithm is highly efficient, it eliminates the need for a local register allocation phase.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74842", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "IPS Research (United States)" + }, + { + "first_name": "Mary Lou", + "last_name": "Soffa", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Thomas J.", + "last_name": "Steele", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/GuptaSS89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74847", + "title": "Experiences Creating a Portable Cedar", + "abstract": "Cedar is the name for both a language and an environment in use in the Computer Science Laboratory at Xerox PARC since 1980. The Cedar language is a superset of Mesa, the major additions being garbage collection and runtime types. Neither the language nor the environment was originally intended to be portable, and for many years ran only on D-machines at PARC and a few other locations in Xerox. We recently re-implemented the language to make it portable across many different architectures. Our strategy was, first, to use machine-dependent C code as an intermediate language, second, to create a language-independent layer known as the Portable Common Runtime, and third, to write a relatively large amount of Cedar-specific runtime code in a subset of Cedar itself. By treating C as an intermediate code we are able to achieve reasonably fast compilation, very good eventual machine code, and all with relatively small programmer effort. Because Cedar is a much richer language than C, there were numerous issues to resolve in performing an efficient translation and in providing reasonable debugging. These strategies will be of use to many other porters of high-level languages who may wish to use C as an assembler language without giving up either ease of debugging or high performance. We present a brief description of the Cedar language, our portability strategy for the compiler and runtime, our manner of making connections to other languages and the Unix* operating system, and some measures of the performance of our “Portable Cedar”.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74847", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Russell R.", + "last_name": "Atkinson", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Carl", + "last_name": "Hauser", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Christian", + "last_name": "Jacobi", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Peter B.", + "last_name": "Kessler", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Mark", + "last_name": "Weiser", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/pldi/AtkinsonDHJKW89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74823", + "title": "Automatic Generation of DAG Parallelism", + "abstract": "Article Free Access Share on Automatic generation of DAG parallelism Authors: R. Cytron IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NY IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NYView Profile , M. Hind Courant Institute, New York University, 251 Mercer St., New York, NY Courant Institute, New York University, 251 Mercer St., New York, NYView Profile , W. Hsieh Laboratory for Computer Science, Massachusetts Institute, Technology, Cambridge, MA Laboratory for Computer Science, Massachusetts Institute, Technology, Cambridge, MAView Profile Authors Info & Claims PLDI '89: Proceedings of the ACM SIGPLAN 1989 conference on Programming language design and implementationJune 1989 Pages 54–68https://doi.org/10.1145/73141.74823Published:21 June 1989Publication History 37citation653DownloadsMetricsTotal Citations37Total Downloads653Last 12 Months44Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74823", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ron K.", + "last_name": "Cytron", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Michael", + "last_name": "Hind", + "institution": "Courant Institute of Mathematical Sciences" + }, + { + "first_name": "Wilson C.", + "last_name": "Hsieh", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/CytronHH89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74831", + "title": "Customization: Optimizing Compiler Technology for SELF, A Dynamically-Typed Object-Oriented Programming Language", + "abstract": "Dynamically-typed object-oriented languages please programmers, but their lack of static type information penalizes performance. Our new implementation tech-niques extract static type information from declaration-free programs. Our system compiles several copies of a given procedure, each customized for one receiver type, so that the type of the receiver is bound at compile time. The compiler predicts types that are statically unknown but likely, and inserts run-time type tests to verify its predictions. It splits calls, compiling a copy on each control path, optimized to the specific types on that path. Coupling these new techniques with compile-time message lookup, aggressive procedure inlining, and traditional optimizations has doubled the performance of dynamically-typed object-oriented languages. 1.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74831", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/ChambersU89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74835", + "title": "Type Inference in the Presence of Type Abstraction", + "abstract": "A number of recent programming language designs incorporate a type checking system based on the Girard-Reynolds polymorphic λ-calculus. This allows the construction of general purpose, reusable software without sacrificing compile-time type checking. A major factor constraining the implementation of these languages is the difficulty of automatically inferring the lengthy type information that is otherwise required if full use is made of these languages. There is no known algorithm to solve any natural and fully general formulation of this “type inference” problem. One very reasonable formulation of the problem is known to be undecidable.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74835", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/Boehm89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74840", + "title": "Inline Function Expansion for Compiling C Programs", + "abstract": "Inline function expansion replaces a function call with the function body. With automatic inline function expansion, programs can be constructed with many small functions to handle complexity and then rely on the compilation to eliminate most of the function calls. Therefore, inline expansion serves a tool for satisfying two conflicting goals: minizing the complexity of the program development and minimizing the function call overhead of program execution. A simple inline expansion procedure is presented which uses profile information to address three critical issues: code expansion, stack expansion, and unavailable function bodies. Experiments show that a large percentage of function calls/returns (about 59%) can be eliminated with a modest code expansion cost (about 17%) for twelve UNIX* programs.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74840", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pohua P.", + "last_name": "Chang", + "institution": "University of Illinois at Springfield" + }, + { + "first_name": "Wen‐mei", + "last_name": "Hwu", + "institution": "University of Illinois at Springfield" + } + ], + "dblp_key": "conf/pldi/HwuC89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74826", + "title": "Parallel Compilation for a Parallel Machine", + "abstract": "An application for a parallel computer with multiple, independent processors often includes different programs (functions) for the individual processors; compilation of such functions can proceed independently. We implemented a compiler that exploits this parallelism by partitioning the input program for parallel translation. The host system for the parallel compiler is an Ethernet-based network of workstations, and different functions of the application program are compiled in parallel on different workstations. For typical programs in our environment, we observe a speedup ranging from 3 to 6 using not more than 9 processors. The paper includes detailed measurements for this parallel compiler; we report the system overhead, implementation overhead, as well as the speedup obtained when compared with sequential compilation.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74826", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "A.", + "last_name": "Sobel", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "M.", + "last_name": "Zolg", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/GrossZZ89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74827", + "title": "Experience with CST: Programming and Implementation", + "abstract": "CST is a programming language based on Smalltalk-802 that supports concurrency using locks, asynchronous messages, and distributed objects. In this paper, we describe CST: the language and its implementation. Example programs and initial programming experience with CST are described. Our implementation of CST generates native code for the J-machine, a fine-grained concurrent computer. Some compiler optimizations developed in conjunction with that implementation are also described.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74827", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Waldemar", + "last_name": "Horwat", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Andrew A.", + "last_name": "Chien", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "William J.", + "last_name": "Dally", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/HorwatCD89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74819", + "title": "A Framework for Construction and Evaluation of High-Level Specifications for Program Analysis Techniques", + "abstract": "Abstract interpretation introduced the notion of formal specification of program analyses. Denotational frameworks are convenient for reasoning about such specifications. However, implementation considerations make denotational specifications complex and hard to develop. We present a framework that facilitates the construction and understanding of denotational specifications for program analysis techniques. The framework is exemplified by specifications for program analysis techniques from the literature and from our own research. This approach allows program analysis techniques to be incorporated into automatically generated program synthesizers by including their specifications with the language definition.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74819", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G. A.", + "last_name": "Venkatesh", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/Venkatesh89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74824", + "title": "Process Decomposition Through Locality of Reference", + "abstract": "In the context of sequential computers, it is common practice to exploit temporal locality of reference through devices such as caches and virtual memory. In the context of multiprocessors, we believe that it is equally important to exploit spatial locality of reference. We are developing a system which, given a sequential program and its domain decomposition, performs process decomposition so as to enhance spatial locality of reference. We describe an application of this method - generating code from shared-memory programs for the (distributed memory) Intel iPSC/2.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74824", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "A.", + "last_name": "Rogers", + "institution": "Cornell University" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/RogersP89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74837", + "title": "Reasoning about Continuations with Control Effects", + "abstract": "We present a new static analysis method for first-class continuations that uses an effect system to classify the control domain behavior of expressions in a typed polymorphic language. We introduce two new control effects, goto and comefrom, that describe the control flow properties of expressions. An expression that does not have a goto effect is said to be continuation following because it will always call its passed return continuation. An expression that does not have a comefrom effect is said to be continuation discarding because it will never preserve its return continuation for later use. Unobservable control effects can be masked by the effect system. Control effect soundness theorems guarantee that the effects computed statically by the effect system are a conservative approximation of the dynamic behavior of an expression.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74837", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Jouvelot", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "David K.", + "last_name": "Gifford", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/JouvelotG89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74833", + "title": "Scannerless NSLR(1) Parsing of Programming Languages", + "abstract": "The disadvantages of traditional two-phase parsing (a scanner phase preprocessing input for a parser phase) are discussed. We present metalanguage enhancements for context-free grammars that allow the syntax of programming languages to be completely described in a single grammar. The enhancements consist of two new grammar rules, the exclusion rule, and the adjacency-restriction rule. We also present parser construction techniques for building parsers from these enhanced grammars, that eliminate the need for a scanner phase.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74833", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "D. J.", + "last_name": "Salomon", + "institution": "University of Waterloo" + }, + { + "first_name": "Gordon V.", + "last_name": "Cormack", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/pldi/SalomonC89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74830", + "title": "Higher-Order Attribute Grammars", + "abstract": "A new kind of attribute grammars, called higher order attribute grammars, is defined. In higher order attribute grammars the structure tree can be expanded as a result of attribute computation. A structure tree may be stored in an attribute. The term higher order is used because of the analogy with higher order functions, where a function can be the result or parameter of another function. A relatively simple method, using OAGs, is described to derive an evaluation order on the defining attribute occurrences which comprises all possible direct and indirect attribute dependencies. As in OAGs, visit-sequences are computed from which an efficient algorithm for attribute evaluation can be derived.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74830", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Harald", + "last_name": "Vogt", + "institution": "Utrecht University" + }, + { + "first_name": "S. Doaitse", + "last_name": "Swierstra", + "institution": "Utrecht University" + }, + { + "first_name": "M.F.", + "last_name": "Kuiper", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/pldi/VogtSK89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74844", + "title": "On-The-Fly Detection of Access Anomalies", + "abstract": "Access anomalies are a common class of bugs in shared-memory parallel programs. An access anomaly occurs when two concurrent execution threads both write (or one thread reads and the other writes) the same shared memory location without coordination. Approaches to the detection of access anomalies include static analysis, post-mortem trace analysis, and on-the-fly monitoring.A general on-the-fly algorithm for access anomaly detection is presented, which can be applied to programs with both nested fork-join and synchronization operations. The advantage of on-the-fly detection over post-mortem analysis is that the amount of storage used can be greatly reduced by data compression techniques and by discarding information as soon as it becomes obsolete. In the algorithm presented, the amount of storage required at any time depends only on the number V of shared variables being monitored and the number N of threads, not on the number of synchronizations. Data compression is achieved by the use of two techniques called merging and subtraction. Upper bounds on storage are shown to be V × N2 for merging and V × N for subtraction.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74844", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Schonberg", + "institution": "New York University" + } + ], + "dblp_key": "conf/pldi/Schonberg89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74845", + "title": "Determining Average Program Execution Times and their Variance", + "abstract": "This paper presents a general framework for determining average program execution times and their variance, based on the program's interval structure and control dependence graph. Average execution times and variance values are computed using frequency information from an optimized counter-based execution profile of the program.", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74845", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/Sarkar89", + "venue": "pldi", + "year": 1989 + }, + { + "paper_id": "10.1145/73141.74848", + "title": "Demonic Memories for Process Histories", + "abstract": "Demonic memory is a form of reconstructive memory for process histories. As a process executes, its states are regularly checkpointed, generating a history of the process at low time resolution. Following the initial generation, any prior state of the process can be reconstructed by starting from a checkpointed state and re-executing the process up through the desired state, thereby exploiting the redundancy between the states of a process and the description of that process (i.e., a computer program).", + "date": "1989-06-21", + "link": "https://doi.org/10.1145/73141.74848", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Paul R.", + "last_name": "Wilson", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Thomas G.", + "last_name": "Moher", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/pldi/WilsonM89", + "venue": "pldi", + "year": 1989 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1990.json b/data/pl_conferences/pldi/1990.json new file mode 100644 index 0000000..ebb9007 --- /dev/null +++ b/data/pl_conferences/pldi/1990.json @@ -0,0 +1,633 @@ +[ + { + "paper_id": "10.1145/93542.93574", + "title": "Identifying the Semantic and Textual Differences Between Two Versions of a Program", + "abstract": "Text-based file comparators (e.g., the Unix utility diff), are very general tools that can be applied to arbitrary files. However, using such tools to compare programs can be unsatisfactory because their only notion of change is based on program text rather than program behavior. This paper describes a technique for comparing two versions of a program, determining which program components represents changes, and classifying each changed component as representing either a semantic or a textual change.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93574", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/Horwitz90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93561", + "title": "Compilation of Haskell Array Comprehensions for Scientific Computing", + "abstract": "Monolithic approaches to functional language arrays, such as Haskell array comprehensions, define elements all at once, at the time the array is created, instead of incrementally. Although monolithic arrays are elegant, a naive implementation can be very inefficient. For example, if a compiler does not know whether an element has zero or many definitions, it must compile runtime tests. If a compiler does not know inter-element data dependencies, it must resort to pessimistic strategies such as compiling elements as thunks, or making unnecessary copies when updating an array.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93561", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven R.", + "last_name": "Anderson", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/AndersonH90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93565", + "title": "Generators and the Replicator Control Structures in the Parallel Environment of ALLOY", + "abstract": "The need for searching a space of solutions appears often. Many problems, such as iteration over a dynamically created domain, can be expressed most naturally using a generate-and-process style. Serial programming languages typically support solutions of these problems by providing some form of generators or backtracking.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93565", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thanasis", + "last_name": "Mitsolides", + "institution": "New York University" + }, + { + "first_name": "Malcolm C.", + "last_name": "Harrison", + "institution": "Courant Institute of Mathematical Sciences" + } + ], + "dblp_key": "conf/pldi/MitsolidesH90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93585", + "title": "Analysis of Pointers and Structures", + "abstract": "article Free Access Share on Analysis of pointers and structures Authors: David R. Chase View Profile , Mark Wegman IBM T. J. Watson Research Center, P.O. Box 704, Yorktown, Heights, NY IBM T. J. Watson Research Center, P.O. Box 704, Yorktown, Heights, NYView Profile , F. Kenneth Zadeck Computer Science Dept., P.O. Box 1910, Brown University, Providence Computer Science Dept., P.O. Box 1910, Brown University, ProvidenceView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 25Issue 6Jun. 1990 pp 296–310https://doi.org/10.1145/93548.93585Online:01 June 1990Publication History 431citation2,454DownloadsMetricsTotal Citations431Total Downloads2,454Last 12 Months69Last 6 weeks21 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93585", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Chase", + "institution": "" + }, + { + "first_name": "Mark N.", + "last_name": "Wegman", + "institution": "IBM (United States)" + }, + { + "first_name": "F. Kenneth", + "last_name": "Zadeck", + "institution": "Brown University" + } + ], + "dblp_key": "conf/pldi/ChaseWZ90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93558", + "title": "Optimizing Programs over the Constructive Reals", + "abstract": "The constructive reals provide programmers with a useful mechanism for prototyping numerical programs, and for experimenting with numerical algorithms. Unfortunately, the performance of current implementations is inadequate for some potential applications. In particular, these implementations tend to be space inefficient, in that they essentially require a complete computation history to be maintained.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93558", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vernon A.", + "last_name": "Lee", + "institution": "Rice University" + }, + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/LeeB90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93581", + "title": "A Fresh Look at Optimizing Array Bound Checking", + "abstract": "This paper describes techniques for optimizing range checks performed to detect array bound violations. In addition to the elimination of range checks, the optimizations discussed in this paper also reduce the overhead due to range checks that cannot be eliminated by compile-time analysis. The optimizations reduce the program execution time and the object code size through elimination of redundant checks, propagation of checks out of loops, and combination of multiple checks into a single check. A minimal control flow graph (MCFG) is constructed using which the minimal amount of data flow information required for range check optimizations is computed. The range check optimizations are performed using the MCFG rather the CFG for the entire program. This allows the global range check optimizations to be performed efficiently since the MCFG is significantly smaller than the CFG. Any array bound violation that is detected by a program with all range checks included, will also be detected by the program after range check optimization and vice versa. Even though the above optimizations may appear to be similar to traditional code optimizations, similar reduction in the number of range checks executed can not be achieved by a traditional code optimizer. Experimental results indicate that the number of range checks performed in executing a program is greatly reduced using the above techniques.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93581", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "Philips (United States)" + } + ], + "dblp_key": "conf/pldi/Gupta90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93557", + "title": "How to Read Floating-Point Numbers Accurately", + "abstract": "Consider the problem of converting decimal scientific notation for a number into the best binary floating point approximation to that number, for some fixed precision. This problem cannot be solved using arithmetic of any fixed precision. Hence the IEEE Standard for Binary Floating-Point Arithmetic does not require the result of such a conversion to be the best approximation.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93557", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Clinger", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Clinger90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93564", + "title": "Task Granularity Analysis in Logic Programs", + "abstract": "While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the “granularity” of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a separate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93564", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "University of Arizona" + }, + { + "first_name": "Nai-Wei", + "last_name": "Lin", + "institution": "University of Arizona" + }, + { + "first_name": "Manuel", + "last_name": "Hermnegildo", + "institution": "Balcones Technologies (United States)" + } + ], + "dblp_key": "conf/pldi/DebrayLH90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93560", + "title": "Type-Dependent Parameter Inference", + "abstract": "An algorithm is presented to infer the type and operation parameters of polymorphic functions. Operation parameters are named and typed at the function definition, but are selected from the set of overloaded definitions available wherever the function is used. These parameters are always implicit, implying that the complexity of using a function does not increase with the generality of its type.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93560", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gordon V.", + "last_name": "Cormack", + "institution": "University of Waterloo" + }, + { + "first_name": "Andrew K.", + "last_name": "Wright", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/CormackW90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93592", + "title": "Compact Representations for Control Dependence", + "abstract": "article Free Access Share on Compact representations for control dependence Authors: Ron Cytron IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NY IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NYView Profile , Jeanne Ferrante IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NY IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NYView Profile , V. Sarkar IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NY IBM Research Division, T. J. Watson Research Center, Yorktown Heights, NYView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 25Issue 6Jun. 1990 pp 337–351https://doi.org/10.1145/93548.93592Online:01 June 1990Publication History 33citation585DownloadsMetricsTotal Citations33Total Downloads585Last 12 Months14Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93592", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ron K.", + "last_name": "Cytron", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Jeanne", + "last_name": "Ferrante", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/CytronFS90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93554", + "title": "Representing Control in the Presence of First-Class Continuations", + "abstract": "Languages such as Scheme and Smalltalk that provide continuations as first-class data objects present a challenge to efficient implementation. Allocating activation records in a heap has proven unsatisfactory because of increased frame linkage costs, increased garbage collection overhead, and decreased locality of reference. However, simply allocating activation records on a stack and copying them when a continuation is created results in unbounded copying overhead. This paper describes a new approach based on stack allocation that does not require the stack to be copied when a continuation is created and that allows us to place a small upper bound on the amount copied when a continuation is reinstated. This new approach is faster than the naive stack allocation approach, and it does not suffer from the problems associated with unbounded copying. For continuation-intensive programs, our approach is at worst a constant factor slower than the heap allocation approach, and for typical programs, it is significantly faster. An important additional benefit is that recovery from stack overflow is handled gracefully and efficiently.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93554", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert", + "last_name": "Hieb", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Carl", + "last_name": "Bruggeman", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/pldi/HiebDB90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93562", + "title": "Iterative Type Analysis and Extended Message Splitting: Optimizing Dynamically-Typed Object-Oriented Programs", + "abstract": "Object-oriented languages have suffered from poor performance caused by frequent and slow dynamically-bound procedure calls. The best way to speed up a procedure call is to compile it out, but dynamic binding of object-oriented procedure calls without static receiver type information precludes inlining. Iterative type analysis and extended message splitting are new compilation techniques that extract much of the necessary type information and make it possible to hoist run-time type tests out of loops.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93562", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/ChambersU90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93571", + "title": "The University of Washington Illustrating Compiler", + "abstract": "The University of Washington illustrating compiler (UWPI) automatically illustrates the data structures used in simple programs written in a subset of Pascal2. A UWPI user submits a program to UWPI, and can then watch a graphical display show time varying illustrations of the data structures and program source code. UWPI uses the information latent in the program to determine how to illustrate the program. UWPI infers the abstract data types directly from the declarations and operations used in the source program, and then lays out the illustration in a natural way by instantiating well-known layouts for the abstracts types. UWPI solves program illustration using compile-time pattern matching and type inferencing to link anticipated execution events to display events, rather than relying on user assistance or specialized programming techniques. UWPI has been used to automatically illustrate didactic sorting and searching examples, and can be used to help teach basic data structures, or to help when debugging programs.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93571", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert R.", + "last_name": "Henry", + "institution": "" + }, + { + "first_name": "Kenneth M.", + "last_name": "Whaley", + "institution": "" + }, + { + "first_name": "Bruce", + "last_name": "Forstall", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/HenryWF90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93578", + "title": "The Program Dependence Web: A Representation Supporting Control, Data, and Demand-Driven Interpretation of Imperative Languages", + "abstract": "The Program Dependence Web (PDW) is a program representation that can be directly interpreted using control-, data-, or demand-driven models of execution. A PDW combines a single-assignment version of the program with explicit operators that manage the flow of data values. The PDW can be viewed as an augmented Program Dependence Graph. Translation to the PDW representation provides the basis for projects to compile Fortran onto dynamic dataflow architectures and simulators. A second application of the PDW is the construction of various compositional semantics for program dependence graphs.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93578", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Karl J.", + "last_name": "Ottenstein", + "institution": "Los Alamos National Laboratory" + }, + { + "first_name": "Robert A.", + "last_name": "Ballance", + "institution": "University of New Mexico" + }, + { + "first_name": "Arthur B.", + "last_name": "Maccabe", + "institution": "University of New Mexico" + } + ], + "dblp_key": "conf/pldi/BallanceMO90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93568", + "title": "Design, Implementation and Evaluation of the FNC-2 Attribute Grammar System", + "abstract": "FNC-2 is a new attribute grammar processing system aiming at expressive power, efficiency, ease of use and versatility. Its development at INRIA started in 1986, and a first running prototype is available since early 1989. Its most important features are: efficient exhaustive and incremental visit-sequence-based evaluation of strongly (absolutely) non-circular AGs; extensive space optimizations; a specially-designed AG-description language, with provisions for true modularity; portability and versatility of the generated evaluators; complete environment for application development. This paper briefly describes the design and implementation of FNC-2 and its peripherals. Then preliminary experience with the system is reported.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93568", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Jourdan", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Didier", + "last_name": "Parigot", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Catherine", + "last_name": "Julié", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Olivier", + "last_name": "Durin", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Carole Le", + "last_name": "Bellec", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/JourdanPJDB90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93576", + "title": "Dynamic Program Slicing", + "abstract": "Program slices are useful in debugging, testing, maintenance, and understanding of programs. The conventional notion of a program slice, the static slice, is the set of all statements that might affect the value of a given variable occurrence. In this paper, we investigate the concept of the dynamic slice consisting of all statements that actually affect the value of a variable occurrence for a given program input. The sensitivity of dynamic slicing to particular program inputs makes it more useful in program debugging and testing than static slicing. Several approaches for computing dynamic slices are examined. The notion of a Dynamic Dependence Graph and its use in computing dynamic slices is discussed. The Dynamic Dependence Graph may be unbounded in length; therefore, we introduce the economical concept of a Reduced Dynamic Dependence Graph, which is proportional in size to the number of dynamic slices arising during the program execution.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93576", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hiralal", + "last_name": "Agrawal", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "J.R.", + "last_name": "Horgan", + "institution": "Core Competence" + } + ], + "dblp_key": "conf/pldi/AgrawalH90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93553", + "title": "Improving Register Allocation for Subscripted Variables", + "abstract": "Most conventional compilers fail to allocate array elements to registers because standard data-flow analysis treats arrays like scalars, making it impossible to analyze the definitions and uses of individual array elements. This deficiency is particularly troublesome for floating-point registers, which are most often used as temporary repositories for subscripted variables.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93553", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Callahan", + "institution": "" + }, + { + "first_name": "Steve", + "last_name": "Carr", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/CallahanCK90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93583", + "title": "Automatic Recognition of Induction Variables and Recurrence Relations by Abstract Interpretation", + "abstract": "The recognition of recurrence relations is important in several ways to the compilation of programs. Induction variables, the simplest form of recurrence, are pivotal in loop optimizations and dependence testing. Many recurrence relations, although expressed sequentially by the programmer, lend themselves to efficient vector or parallel computation. Despite the importance of recurrences, vectorizing and parallelizing compilers to date have recognized them only in an ad-hoc fashion. In this paper we put forth a systematic method for recognizing recurrence relations automatically. Our method has two parts. First, abstract interpretation [CC77, CC79] is used to construct a map that associates each variable assigned in a loop with a symbolic form (expression) of its value. Second, the elements of this map are matched with patterns that describe recurrence relations. The scheme is easily extensible by the addition of templates, and is able to recognize nested recurrences by the propagation of the closed forms of recurrences from inner loops. We present some applications of this method and a proof of its correctness.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93583", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zahira", + "last_name": "Ammarguellat", + "institution": "National Center for Supercomputing Applications" + }, + { + "first_name": "Williams Ludwell", + "last_name": "Harrison", + "institution": "National Center for Supercomputing Applications" + } + ], + "dblp_key": "conf/pldi/AmmarguellatH90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93590", + "title": "Instruction Reordering for Fork-Join Parallelism", + "abstract": "article Free Access Share on Instruction reordering for fork-join parallelism Author: V. Sarkar IBM Research, Thomas. J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY IBM Research, Thomas. J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 25Issue 6Jun. 1990 pp 322–336https://doi.org/10.1145/93548.93590Published:01 June 1990Publication History 12citation555DownloadsMetricsTotal Citations12Total Downloads555Last 12 Months30Last 6 weeks7 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93590", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/Sarkar90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93556", + "title": "Two-Directional Record Layout for Multiple Inheritance", + "abstract": "Much recent work in polymorphic programming languages allows subtyping and multiple inheritance for records. In such systems, we would like to extract a field from a record with the same efficiency as if we were not making use of subtyping and multiple inheritance. Methods currently used make field extraction 3-5 times slower, which can produce a significant overall performance slowdown.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93556", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Pugh", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Grant", + "last_name": "Weddell", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/pldi/PughW90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93551", + "title": "Register Allocation Across Procedure and Module Boundaries", + "abstract": "This paper describes a method for compiling programs using interprocedural register allocation. A strategy for handling programs built from multiple modules is presented, as well as algorithms for global variable promotion and register spill code motion. These algorithms attempt to address some of the shortcomings of previous interprocedural register allocation strategies. Results are given for an implementation on a single register file RISC-based architecture.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93551", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vatsa", + "last_name": "Santhanam", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Daryl", + "last_name": "Odnert", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/SanthanamO90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93563", + "title": "Type Declarations as Subtype Constraints in Logic Programming", + "abstract": "This paper presents a type system for logic programs that supports parametric polymorphism and subtypes. This system follows most knowledge representation and object-oriented schemes in that subtyping is name-based, i.e., τ1 is considered to be a subtype of τ2 iff it is declared as such. We take this as a fundamental principle in the sense that type declarations have the form of subtype constraints. Types are assigned meaning by viewing such constraints as Horn clauses that, together with a few basic axioms, define a subtype predicate. This technique provides a (least) model for types and, at the same time, a sound and complete proof system for deriving subtypes. Using this proof system, we define well-typedness conditions which ensure that a logic program/query respects a set of predicate types. We prove that these conditions are consistent in the sense that every atom of every resolvent produced during the execution of a well-typed program is consistent with its type.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93563", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dean", + "last_name": "Jacobs", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/pldi/Jacobs90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93567", + "title": "Higher-Order Attribute Grammars and Editing Environments", + "abstract": "Article Free Access Share on Higher-order attribute grammars and editing environments Authors: Tim Teitelbaum Department of Computer Science, Cornell University, Ithaca, NY Department of Computer Science, Cornell University, Ithaca, NYView Profile , Richard Chapman Department of Computer Science, Cornell University, Ithaca, NY Department of Computer Science, Cornell University, Ithaca, NYView Profile Authors Info & Claims PLDI '90: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementationJune 1990 Pages 197–208https://doi.org/10.1145/93542.93567Published:01 June 1990Publication History 17citation435DownloadsMetricsTotal Citations17Total Downloads435Last 12 Months20Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93567", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tim", + "last_name": "Teitelbaum", + "institution": "Cornell University" + }, + { + "first_name": "Richard", + "last_name": "Chapman", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/TeitelbaumC90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93552", + "title": "Graph Coloring Register Allocation for Processors with Multi-Register Operands", + "abstract": "Though graph coloring algorithms have been shown to work well when applied to register allocation problems, the technique has not been generalized for processor architectures in which some instructions refer to individual operands that are comprised of multiple registers. This paper presents a suitable generalization.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93552", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brian", + "last_name": "Nickerson", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/Nickerson90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93587", + "title": "Compiling Programs for a Linear Systolic Array", + "abstract": "This paper describes an AL compiler for the Warp systolic array. AL is a programming language in which the user programs a systolic array as if it were a sequential computer and relies on the compiler to generate parallel code. This paper introduces the notion of data relations in compiling programs for systolic arrays. Unlike dependence relations among statements of a program, data relations define compatibility relations among data objects of a program. The AL compiler uses data relations to compute data compatibility classes, determine data distribution, and distribute loop iterations. The AL compiler can generate efficient parallel code almost identical to what the user would have written by hand. For example, the AL compiler generates parallel code for the LINPACK LU decomposition (SGEFA) and QR decomposition (SQRDC) routines with a nearly 8-fold speedup on the 10-cell Warp array for matrices of size 180 × 180.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93587", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ping-Sheng", + "last_name": "Tseng", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Tseng90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93550", + "title": "Profile Guided Code Positioning", + "abstract": "This paper presents the results of our investigation of code positioning techniques using execution profile data as input into the compilation process. The primary objective of the positioning is to reduce the overhead of the instruction memory hierarchy.", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93550", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Karl", + "last_name": "Pettis", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Robert C.", + "last_name": "Hansen", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/PettisH90", + "venue": "pldi", + "year": 1990 + }, + { + "paper_id": "10.1145/93542.93549", + "title": "Fast Code Generation Using Automatically-Generated Decision Trees", + "abstract": "article Free Access Share on Fast code generation using automatically-generated decision trees Author: Alan L. Wendt Department of Computer Science, Colorado State University, Fort Collins, Colorado Department of Computer Science, Colorado State University, Fort Collins, ColoradoView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 25Issue 6Jun. 1990 pp 9–15https://doi.org/10.1145/93548.93549Online:01 June 1990Publication History 1citation500DownloadsMetricsTotal Citations1Total Downloads500Last 12 Months8Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1990-01-01", + "link": "https://doi.org/10.1145/93542.93549", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alan L.", + "last_name": "Wendt", + "institution": "Colorado State University" + } + ], + "dblp_key": "conf/pldi/Wendt90", + "venue": "pldi", + "year": 1990 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1991.json b/data/pl_conferences/pldi/1991.json new file mode 100644 index 0000000..e8fa599 --- /dev/null +++ b/data/pl_conferences/pldi/1991.json @@ -0,0 +1,648 @@ +[ + { + "paper_id": "10.1145/113445.113448", + "title": "Practical Dependence Testing", + "abstract": "Precise and efficient dependence tests are essential to theeffectivermss ofaparallelizing compiler. This paper proposes a dependence testing scheme based on classifyingpairs ofsubscripted variable references. Exact yet fast dependence tests are presented for certain classes ofarray references, as well as empirical results showing that these references dominate scientific Fortran codes. These dependence tests are being implemented at Rice University in both PFC, aparallelizing compiler, and ParaScope, a parallel programming environment,", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113448", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gina", + "last_name": "Goff", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + }, + { + "first_name": "Chau‐Wen", + "last_name": "Tseng", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/GoffKT91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113474", + "title": "Monitoring Semantics: A Formal Framework for Specifying, Implementing, and Reasoning about Execution Monitors", + "abstract": "We introduce monitoring semantics, a non-standard model", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113474", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amir", + "last_name": "Kishon", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + }, + { + "first_name": "Charles", + "last_name": "Consel", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/KishonHC91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113457", + "title": "Size and Access Inference for Data-Parallel Programs", + "abstract": "Abstract: \"Data-parallel programming languages have many desirable features, such as single-thread semantics and the ability to express fine-grained parallelism. However, it is challenging to implement such languages efficiently on conventional MIMD multiprocessors, because these machines incur a high overhead for small grain sizes. This paper presents compile-time analysis techniques for data-parallel program graphs that reduce these overheads in two ways: by stepping up the grain size, and by relaxing the synchronous nature of the computation without altering the program semantics.The algorithms partition the program graph into clusters of nodes such that all nodes in a cluster have the same loop structure, and futher refine these clusters into epochs based on generation and consumption patterns of data vectors. This converts the fine-grain parallelism in the original program to medium-grain loop parallelism, which is better suited to MIMD machines. A compiler has been implemented based on these ideas. We present performance results for data-parallel kernels analyzed by the compiler and converted to single-program multiple-data (SPMD) code running on an Encore Multimax.\"", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113457", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Siddhartha", + "last_name": "Chatterjee", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Allan L.", + "last_name": "Fisher", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/ChatterjeeBF91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113455", + "title": "The Semantic Approach to Program Slicing", + "abstract": "Program slicing is a source-to-source transformation", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113455", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G. A.", + "last_name": "Venkatesh", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Venkatesh91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113463", + "title": "A Timed Petri-Net Model for Fine-Grain Loop Scheduling", + "abstract": "article Free Access Share on A timed Petri-net model for fine-grain loop scheduling Authors: Guang R. Gao School of Computer Science, McGill University, 3480 University, Montréal, Québec H3A 2A7 School of Computer Science, McGill University, 3480 University, Montréal, Québec H3A 2A7View Profile , Yue-Bong Wong School of Computer Science, McGill University, 3480 University, Montréal, Québec H3A 2A7 School of Computer Science, McGill University, 3480 University, Montréal, Québec H3A 2A7View Profile , Qi Ning School of Computer Science, McGill University, 3480 University, Montréal, Québec H3A 2A7 School of Computer Science, McGill University, 3480 University, Montréal, Québec H3A 2A7View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 6June 1991 pp 204–218https://doi.org/10.1145/113446.113463Published:01 May 1991Publication History 41citation490DownloadsMetricsTotal Citations41Total Downloads490Last 12 Months23Last 6 weeks5 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113463", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guang R.", + "last_name": "Gao", + "institution": "McGill University" + }, + { + "first_name": "Yue-Bong", + "last_name": "Wong", + "institution": "McGill University" + }, + { + "first_name": "Ning", + "last_name": "Qi", + "institution": "McGill University" + } + ], + "dblp_key": "conf/pldi/GaoWN91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113462", + "title": "Register Allocation via Hierarchical Graph Coloring", + "abstract": "We present a graph coloring register allocator de-signed to minimize the number of dynamic memory references. We cover the program with sets of blocks called tiles and group these tiles into a tree reflecting the program’s hierarchical control structure. Registers are allocated for each tile using standard graph coloring techniques and the local allocation and conflict information is passed around the tree in a two phase algorithm. This results in an allocation of reg-isters that is sensitive to local usage patterns while retaining a global perspective. Spill code is placed in less frequently executed portions of the program and the choice of variables to spill is based on usage pat-terns between the spills and the reloads rather than usage patterns over the entire program. 1", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113462", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Callahan", + "institution": "" + }, + { + "first_name": "Brian", + "last_name": "Koblenz", + "institution": "" + } + ], + "dblp_key": "conf/pldi/CallahanK91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113458", + "title": "Fortran at Ten Gigaflops: The Connection Machine Convolution Compiler", + "abstract": "We have implemented a prototype of a specialized compiler module and associated run-time support that allows a Fortran user to achieve sustained floatingpoint performance of over 10 gigaflops on the Connection Machine Model CM-2. This improves substantially over the previous record of 5.6 gigaflops, which was achieved by means of hand-crafted low-level coding techniques (on which this work has been based). Indeed, the same code that ran at 5.6 gigaflops in 1989 now runs at over 14 gigaflops.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113458", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark", + "last_name": "Bromley", + "institution": "" + }, + { + "first_name": "Steven", + "last_name": "Heller", + "institution": "" + }, + { + "first_name": "Tim", + "last_name": "McNerney", + "institution": "" + }, + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "" + } + ], + "dblp_key": "conf/pldi/BromleyHMS91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113470", + "title": "CML: A Higher-Order Concurrent Language", + "abstract": "article Free Access Share on CML: A higher concurrent language Author: John H. Reppy Cornell University Cornell UniversityView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 6June 1991pp 293–305https://doi.org/10.1145/113446.113470Published:01 May 1991Publication History 203citation1,330DownloadsMetricsTotal Citations203Total Downloads1,330Last 12 Months128Last 6 weeks21 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113470", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Reppy", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/Reppy91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113453", + "title": "Strictness and Binding-Time Analyses: Two for the Price of One", + "abstract": "article Free Access Share on Strictness and binding-time analyses: two for the price of one Author: John Launchbury University of Glasgow University of GlasgowView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 6June 1991 pp 80–91https://doi.org/10.1145/113446.113453Online:01 May 1991Publication History 9citation234DownloadsMetricsTotal Citations9Total Downloads234Last 12 Months8Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113453", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/pldi/Launchbury91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113468", + "title": "Refinement Types for ML", + "abstract": "T$'e describe a refinement of ML's type system allowing the specification of recursively defined subtypes of user-defined datatypes. The resulting system of rejirzemeni f,ypes preserves desirable properties of ML such as decidability of type inference, while at the same time allowing more errors to be detected at compile-time. The type system combines abstract interpretation with ideas from the intersection type discipline, but remains closely tied to ML in that refinement types are given only to programs which are already well-typed in ML.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113468", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tim", + "last_name": "Freeman", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/FreemanP91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113465", + "title": "The Marion System for Retargetable Instruction Scheduling", + "abstract": "article Free Access Share on The Marion system for retargetable instruction scheduling Authors: David G. Bradlee Department of Computer Science and Engineering, FR-35, University of Washington, Seattle, Washington Department of Computer Science and Engineering, FR-35, University of Washington, Seattle, WashingtonView Profile , Robert R. Henry Tera Computer, 400 N 34th Street, Seattle, WA and Department of Computer Science and Engineering, FR-35, University of Washington, Seattle, Washington Tera Computer, 400 N 34th Street, Seattle, WA and Department of Computer Science and Engineering, FR-35, University of Washington, Seattle, WashingtonView Profile , Susan J. Eggers Department of Computer Science and Engineering, FR-35, University of Washington, Seattle, Washington Department of Computer Science and Engineering, FR-35, University of Washington, Seattle, WashingtonView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 6June 1991 pp 229–240https://doi.org/10.1145/113446.113465Published:01 May 1991Publication History 36citation502DownloadsMetricsTotal Citations36Total Downloads502Last 12 Months28Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113465", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David G.", + "last_name": "Bradlee", + "institution": "University of Washington" + }, + { + "first_name": "Robert R.", + "last_name": "Henry", + "institution": "University of Washington" + }, + { + "first_name": "Susan J.", + "last_name": "Eggers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/BradleeHE91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113451", + "title": "Predicting Program Behavior Using Real or Estimated Profiles", + "abstract": "There is a growing interest in optimizations that depend on or benefit from an execution profile that tells where time is spent. How well does a profile from one run describe the behavior of a different run, and how does this compare with the behavior predicted statically by examining the program itself ? This paper defines two abstract measures of how well a profile predicts actual behavior. According to these measures, real profiles indeed do better than estimated profiles, usually. A perfect profile from an earlier run with the same data set, however, does better still, sometimes by a factor of two. Using such a profile is unrealistic, and can lead to inflated expectations of a profile-driven optimization. i 1. Introduction Many people have built or speculated on systems that use a run-time profile to guide code optimization. Applications include the selection of variables to promote to registers [7,8], placement of code sequences to improve cache behavior [3,6], and pre...", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113451", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David W.", + "last_name": "Wall", + "institution": "Digital Equipment (Germany)" + } + ], + "dblp_key": "conf/pldi/Wall91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113471", + "title": "A Methodology for Managing Hard Constraints in CLP Systems", + "abstract": "In constraint logic programming (CLP) systems, the standard technique for dealing with hard constraints is to delay solving them until additional constraints reduce them to a simpler form. For example, the CLP(R) system delays the solving of nonlinear equations until they become linear, when certain variables become ground. In a naive implementation, the overhead of delaying and awakening constraints could render a CLP system impractical. In this paper, a framework is developed for the specification of wakeup degrees which indicate how far a hard constraint is from being awoken. This framework is then used to specify a runtime structure for the delaying and awakening of hard constraints. The primary implementation problem is the timely awakening of delayed constraints in the context of temporal backtracking, which requires changes to internal data structures be reversible. This problem is resolved efficiently in our structure. 1 Introduction The Constraint Logic Programming scheme [7...", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113471", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joxan", + "last_name": "Jaffar", + "institution": "IBM (United States)" + }, + { + "first_name": "Spiro", + "last_name": "Michaylov", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Roland H. C.", + "last_name": "Yap", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/JaffarMY91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113449", + "title": "A Data Locality Optimizing Algorithm", + "abstract": "This paper proposes an algorithm that improves the locality of a loop nest by transforming the code via interchange, reversal, skewing and tiling.The loop transformation rrlgorithm is based on two concepts: a mathematical formulation of reuse and locality, and a loop transformation theory that unifies the various transforms as unimodular matrix tmnsfonnations.The algorithm haa been implemented in the SUIF (Stanford University Intermediate Format) compiler, and is successful in optimizing codes such as matrix multiplication, successive over-relaxation (SOR), LU decomposition without pivoting, and Givens QR factorization.Performance evaluation indicates that locatity optimization is especially crucial for scaling up the performance of parallel code.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113449", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael E.", + "last_name": "Wolf", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/WolfL91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113467", + "title": "Linear-Time, Optimal Code Scheduling for Delayed-Load Architectures", + "abstract": "Article Linear-time, optimal code scheduling for delayed-load architectures Share on Authors: Todd A. Proebsting University of Wisconsin-Madison, Dept. of Computer Sciences, 1210 W. Dayton St., Madison, WI University of Wisconsin-Madison, Dept. of Computer Sciences, 1210 W. Dayton St., Madison, WIView Profile , Charles N. Fischer University of Wisconsin-Madison, Dept. of Computer Sciences, 1210 W. Dayton St., Madison, WI University of Wisconsin-Madison, Dept. of Computer Sciences, 1210 W. Dayton St., Madison, WIView Profile Authors Info & Claims PLDI '91: Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementationMay 1991 Pages 256–267https://doi.org/10.1145/113445.113467Online:01 May 1991Publication History 28citation670DownloadsMetricsTotal Citations28Total Downloads670Last 12 Months11Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113467", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Charles N.", + "last_name": "Fischer", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/ProebstingF91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113459", + "title": "Mostly Parallel Garbage Collection", + "abstract": "We present a method for adapting garbage collectors designed to run sequentially with the client, so that they may run concurrently with it. We rely on virtual memory hardware to provide information about pages that have been updated or \"dirtied\" during a given period of time. This method has been used to construct a mostly parallel trace-and-sweep collector that exhibits very short pause times. Performance measurements are given.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113459", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Alan", + "last_name": "Demers", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Scott", + "last_name": "Shenker", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/pldi/BoehmDS91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113460", + "title": "Tag-Free Garbage Collection for Strongly Typed Programming Languages", + "abstract": "With the emergence of a number of strongly typed kmguages with very dynamic storage allocation, efficient methods of storage reclamation have become especially important, Even though no type tags are required for type checking programs written in these languages, current implementations douse tags to support run time garbage collection, This often inflicts a high time and space overhead on program execution. Since the early days of LISP (and Algo168 later on), there have been schemes for performing tag-free garbage collection, In this paper, we describe an improvement of existing methods that leads to more effective storage rechunation in the absence of tags. Garbage collection has also traditionally been viewed as being independent of the particular program being executed. This means that results of compile-time analyses which could increase the effectiveness of garbage collection cannot be incorporated easily into the garbage collection process. This paper describes a method for performing garbage collection 1) in the absence of tagged data, and 2) using compile-time information. This method relies on compiler-generated garbage collection routines specific to the program bekg executed and incurs no time overhead during execution other then the cost of the garbage collection process itself. We describe tag-free garbage collection methods for monomorphically typed and polymorphically typed languages, and suggest how they might be extended to support parallel languages.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113460", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Goldberg", + "institution": "Courant Institute of Mathematical Sciences" + } + ], + "dblp_key": "conf/pldi/Goldberg91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113473", + "title": "Occurences in Debugger Specifications", + "abstract": "We describe formal manipulations of programming language semantics that permit execution animation for interpreters. We first study the use of occurrences in the -calculus and we describe an implementation of the notion of residuals. We then describe applications in the development of interpreters for the lazy -calculus and the parallel language Occam. 1. Introduction Formal descriptions of programming language semantics have already been shown to yield executable specifications of interpreters for these languages [Mini-ML], [Esterel]. However, while the obtained interpreters have the clear advantage of being &quot;certified&quot; implementations, they lack a nice user interface for the very reason that the definition only deals with semantic values. An interpreter can be tranformed into a debugging tool by adding tracing, profiling, or control of execution functionalities. For us, an execution trace is a list of basic instruction calls that describes a history of execution, a profile is a list...", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113473", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yves", + "last_name": "Bertot", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/Bertot91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113452", + "title": "Procedure Merging with Instruction Caches", + "abstract": "This paper describes a method of determining which procedures to merge for machines with instruction caches. The method uses profile information, the structure of the program, the cache size, and the cache miss penalty to guide the choice. Optimization for the cache is assumed to follow procedure merging. The method weighs the benefit of removing calls with the increase in the instruction cache miss rate. Better performance is achieved than previous schemes that do not consider the cache. Merging always results in a savings, unlike simpler schemes that can make programs slower once cache effects are considered. The new method also has better performance even when parameters to simpler algorithms are varied to get the best performance. This report is a preprint of a paper that will be presented at the ACM SIGPLAN &apos;91 Conference on Programming Language Design and Implementation, Toronto, Ontario, Canada, June 26-28, 1991. Copyright 1990 ACM. i 1 Introduction This paper presents a ...", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113452", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Scott", + "last_name": "McFarling", + "institution": "" + } + ], + "dblp_key": "conf/pldi/McFarling91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113472", + "title": "Generalized Algorithmic Debugging and Testing", + "abstract": "This paper presents a method for semi-automatic bug localization, generalized algorithmic debugging, which has been integrated with the category partition method for functional testing. In this way the efficiency of the algorithmic debugging method for bug localization can be improved by using test specifications and test results. The long-range goal of this work is a semi-automatic debugging and testing system which can be used during large-scale program development of nontrivial programs. The method is generally applicable to procedural languages and is not dependent on any ad hoc assumptions regarding the subject program. The original form of algorithmic debugging, introduced by Shapiro, was however limited to small Prolog programs without side-effects, but has later been generalized to concurrent logic programming languages. Another drawback of the original method is the large number of interactions with the user during bug localization. To our knowledge, this is the first method which uses category partition testing to improve the bug localization properties of algorithmic debugging. The method can avoid irrelevant questions to the programmer by categorizing input parameters and then match these against test cases in the test database. Additionally, we use program slicing, a data flow analysis technique, to", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113472", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter", + "last_name": "Fritzson", + "institution": "Linköping University" + }, + { + "first_name": "Tibor", + "last_name": "Gyimóthy", + "institution": "Hungarian Academy of Sciences" + }, + { + "first_name": "Mariam", + "last_name": "Kamkar", + "institution": "Linköping University" + }, + { + "first_name": "Nahid", + "last_name": "Shahmehri", + "institution": "Linköping University" + } + ], + "dblp_key": "conf/pldi/FritzsonGKS91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113469", + "title": "Soft Typing", + "abstract": "of programs than ML. We have also developed an algorithm for frugally inserting run-time checks in programs that do not type check.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113469", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Rice University" + }, + { + "first_name": "Mike", + "last_name": "Fagan", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/CartwrightF91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113450", + "title": "CCG: A Prototype Coagulating Code Generator", + "abstract": "This paper describes the design and performance of CCG, a prototype code generator based on couguiation. Coagulation orders code generation using a run-time profile for the program being compiled. By treating busy parts of a program first and using the strategy of local optimality, CCG maximizes the benefit of careful instruction selection, register allocation and interprocedural optimization while avoiding unnecessary data movement in busy sections. Coagulation radically alters standard techniques for code generation, achieving highly efficient code without graph-coloring register allocation or peephole optimization. Experimental results showing an average 25% improvement over the GNU C compiler suggest, that compilation order is crucial and that coagulation can outperform current code generator technology.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113450", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "W. G.", + "last_name": "Morris", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Morris91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113466", + "title": "Global Instruction Scheduling for Superscalar Machines", + "abstract": "To improve the utilization of machine resources in superscalar processors, the instructions have to be carefully scheduled by the compiler.As internal parallelism and pipelining increases, it becomes evident that scheduling should be done beyond the basic block level.A scheme for global (intra-loop) scheduling is proposed, which uses the control and data dependence information summarized in a", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113466", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Bernstein", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Michael", + "last_name": "Rodeh", + "institution": "IBM Research - Haifa" + } + ], + "dblp_key": "conf/pldi/BernsteinR91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113454", + "title": "Parameterized Partial Evaluation", + "abstract": "article Free Access Share on Parameterized partial evaluation Authors: Charles Consel Yale University, Department of Computer Science, New Haven, CT Yale University, Department of Computer Science, New Haven, CTView Profile , Siau Cheng Khoo Yale University, Department of Computer Science, New Haven, CT Yale University, Department of Computer Science, New Haven, CTView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 6June 1991 pp 92–106https://doi.org/10.1145/113446.113454Online:01 May 1991Publication History 7citation244DownloadsMetricsTotal Citations7Total Downloads244Last 12 Months6Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113454", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Charles", + "last_name": "Consel", + "institution": "Yale University" + }, + { + "first_name": "Siau Cheng", + "last_name": "Khoo", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/ConselK91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113456", + "title": "Automatic Generation of Global Optimizers", + "abstract": "article Free Access Share on Automatic generation of global optimizers Authors: Deborah Whitfield Department of Computer Science, University of Pittsburgh, Pittsburgh, PA Department of Computer Science, University of Pittsburgh, Pittsburgh, PAView Profile , Mary Lou Soffa Department of Computer Science, University of Pittsburgh, Pittsburgh, PA Department of Computer Science, University of Pittsburgh, Pittsburgh, PAView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 6June 1991 pp 120–129https://doi.org/10.1145/113446.113456Published:01 May 1991Publication History 22citation315DownloadsMetricsTotal Citations22Total Downloads315Last 12 Months9Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113456", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Deborah", + "last_name": "Whitfield", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Mary Lou", + "last_name": "Soffa", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/pldi/WhitfieldS91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113461", + "title": "Effective "Static-Graph" Reorganization to Improve Locality in Garbage-Collected Systems", + "abstract": "Article Free Access Share on Effective \"static-graph\" reorganization to improve locality in garbage-collected systems Authors: Paul R. Wilson Electrical Engineering and Computer Science Dept., University of Illinois at Chicago, Box 4348 (m/c 154) Chicago, Illinois Electrical Engineering and Computer Science Dept., University of Illinois at Chicago, Box 4348 (m/c 154) Chicago, IllinoisView Profile , Michael S. Lam Electrical Engineering and Computer Science Dept., University of Illinois at Chicago, Box 4348 (m/c 154) Chicago, Illinois Electrical Engineering and Computer Science Dept., University of Illinois at Chicago, Box 4348 (m/c 154) Chicago, IllinoisView Profile , Thomas G. Moher Electrical Engineering and Computer Science Dept., University of Illinois at Chicago, Box 4348 (m/c 154) Chicago, Illinois Electrical Engineering and Computer Science Dept., University of Illinois at Chicago, Box 4348 (m/c 154) Chicago, IllinoisView Profile Authors Info & Claims PLDI '91: Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementationMay 1991 Pages 177–191https://doi.org/10.1145/113445.113461Published:01 May 1991Publication History 83citation592DownloadsMetricsTotal Citations83Total Downloads592Last 12 Months39Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113461", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Paul R.", + "last_name": "Wilson", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Michael S.", + "last_name": "Lam", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Thomas G.", + "last_name": "Moher", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/pldi/WilsonLM91", + "venue": "pldi", + "year": 1991 + }, + { + "paper_id": "10.1145/113445.113447", + "title": "Efficient and Exact Data Dependence Analysis", + "abstract": "Data dependence testing is the basic step in detecting loop level parallelism in numerical programs. The problem is equivalent to integer linear programming and thus in general cannot be solved efficiently. Current methods in use employ inexact methods that sacrifice potential parallelism in order to improve compiler efficiency. This paper shows that in practice, data dependence can be computed exactly and efficiently. There are three major ideas that lead to this result. First, we have developed and assembled a small set of efficient algorithms, each one exact for special case inputs. Combined with a moderately expensive backup test, they are exact for all the cases we have seen in practice. Second, we introduce a memorization technique to save results of previous tests, thus avoiding calling the data dependence routines multiple times on the same input. Third, we show that this approach can both be extended to compute distance and direction vectors and to use unknown symbolic terms without any loss of accuracy or efficiency, We have implemented our algorithm in the SUIF system, a general purpose compiler system developed at Stanford. We ran the algorithm on the PERFECT Club Benchmarks and our data dependence analyzer gave an exact solution in all cases efficiently.", + "date": "1991-01-01", + "link": "https://doi.org/10.1145/113445.113447", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dror", + "last_name": "Maydan", + "institution": "Stanford University" + }, + { + "first_name": "John L.", + "last_name": "Hennessy", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/MaydanHL91", + "venue": "pldi", + "year": 1991 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1992.json b/data/pl_conferences/pldi/1992.json new file mode 100644 index 0000000..89857da --- /dev/null +++ b/data/pl_conferences/pldi/1992.json @@ -0,0 +1,727 @@ +[ + { + "paper_id": "10.1145/143095.143142", + "title": "Probalistic Register Allocation", + "abstract": "A new global register allocation technique, probabilistic register allocation, is described. Probabilistic register allocation quantifies the costs and benefits of allocating variables to registers over live ranges so that excellent allocation choices can be made. Local allocation is done first, and then global allocation is done iteratively beginning in the most deeply nested loops. Because local allocation precedes global allocation, probabilistic allocation does not interfere with the use of well-known, high-quality local register allocation and instruction scheduling techniques.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143142", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Charles N.", + "last_name": "Fischer", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/ProebstingF92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143130", + "title": "Delinearization: An Efficient Way to Break Multiloop Dependence Equations", + "abstract": "Exact and efficient data dependence testing is a key to success of loop-parallelizing compiler for computationally intensive programs. A number of algorithms has been created to test array references contained in parameter loops for dependence but most of them are unable to answer the following question correctly: Are references C(i1 + 10j1) and C(i2 + 5), 0 ≤ i1, i2 ≤ 4, 0 ≤ j1,j2 ≤ 9 independent? The technique introduced in this paper recognizes that i1, i2 and j1, j2 make different order contributions to the subscript index, and breaks dependence equation i1 + 10j1 = i2 + 10j2 + 5 into two equations i1 = i2 and 10j1 = 10j2 which then can be solved independently. Since resulting equations contain less variables it is less expensive to solve them. We call this technique delinearization because it is reverse of the linearization much discussed in the literature.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143130", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "V.O.", + "last_name": "Maslov", + "institution": "Lomonosov Moscow State University" + } + ], + "dblp_key": "conf/pldi/Maslov92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143136", + "title": "Lazy Code Motion", + "abstract": "We present a bit-vector algorithm for the optimal and economical placement of computations within flow graphs, which is as efficient as standard uni-directional analyses. The point of our algorithm is the decomposition of the bi-directional structure of the known placement algorithms into a sequence of a backward and a forward analysis, which directly implies the efficiency result. Moreover, the new compositional structure opens the algorithm for modification: two further uni-directional analysis components exclude any unnecessary code motion. This laziness of our algorithm minimizes the register pressure, which has drastic effects on the run-time behaviour of the optimized programs in practice, where an economical use of registers is essential.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143136", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jens", + "last_name": "Knoop", + "institution": "University of Hagen" + }, + { + "first_name": "Oliver", + "last_name": "Rüthing", + "institution": "TU Dortmund University" + }, + { + "first_name": "Bernhard", + "last_name": "Steffen", + "institution": "TU Dortmund University" + } + ], + "dblp_key": "conf/pldi/KnoopRS92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143144", + "title": "Avoiding Unconditional Jumps by Code Replication", + "abstract": "This study evaluates a global optimization technique that avoids unconditional jumps by replicating code. When implemented in the back-end of an optimizing compiler, this technique can be generalized to work on almost all instances of unconditional jumps, including those generated from conditional statements and unstructured loops. The replication method is based on the idea of finding a replacement for each unconditional jump which minimizes the growth in code size. This is achieved by choosing the shortest sequence of instructions as a replacement. Measurements taken from a variety of programs showed that not only the number of executed instructions decreased, but also that the total cache work was reduced (except for small caches) despite increases in code size. Pipelined and superscalar machines may also benefit from an increase in the average basic block size.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143144", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Frank", + "last_name": "Mueller", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Whalley", + "institution": "" + } + ], + "dblp_key": "conf/pldi/MuellerW92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143127", + "title": "An Abstract Machine for CLP(R)", + "abstract": "An abstract machine is described for the CLP(ℜ) programming language. It is intended as a first step toward enabling CLP(ℜ) programs to be executed with efficiency approaching that of conventional languages. The core Constraint Logic Arithmetic Machine (CLAM) extends the Warren Abstract Machine (WAM) for compiling Prolog with facilities for handling real arithmetic constraints. The full CLAM includes facilities for taking advantage of information obtained from global program analysis.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143127", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joxan", + "last_name": "Jaffar", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Peter J.", + "last_name": "Stuckey", + "institution": "The University of Melbourne" + }, + { + "first_name": "Spiro", + "last_name": "Michaylov", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Roland H. C.", + "last_name": "Yap", + "institution": "" + } + ], + "dblp_key": "conf/pldi/JaffarMSY92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143138", + "title": "Abstractions for Recursive Pointer Data Structures: Improving the Analysis of Imperative Programs", + "abstract": "Even though impressive progress has been made in the area of optimizing and parallelizing programs with arrays, the application of similar techniques to programs with pointer data structures has remained difficult. In this paper we introduce a new approach that leads to improved analysis and transformation of programs with recursively-defined pointer data structures.We discuss how an abstract data structure description can improve program analysis by presenting an analysis approach that combines an alias analysis technique, path matrix, with information available from an ADDS declaration. Given this improved alias analysis technique, we provide a concrete example of applying a software pipelining transformation to loops involving pointer data structures.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143138", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + }, + { + "first_name": "Joseph", + "last_name": "Hummell", + "institution": "" + }, + { + "first_name": "Alexandru", + "last_name": "Nicolau", + "institution": "McGill University" + } + ], + "dblp_key": "conf/pldi/HendrenHN92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143122", + "title": "Prototyping Fortran-90 Compilers for Massively Parallel Machines", + "abstract": "Massively parallel architectures, and the languages used to program them, are among both the most difficult and the most rapidly-changing subjects for compilation. This has created a demand for new compiler prototyping technologies that allow novel styles of compilation and optimization to be tested in a reasonable amount of time. Using formal specification techniques, we have produced a data-parallel Fortran-90 subset compiler for Thinking Machines&apos; Connection Machine/2 and Connection Machine/5. The prototype produces code from initial Fortran-90 benchmarks demonstrating sustained performance superior to hand-coded *Lisp and competitive with Thinking Machines&apos; CM Fortran compiler. This paper presents some new specification techniques necessary to construct competitive, easily retargetable prototype compilers. 1 Introduction Existing compilers for massively parallel machines have generally been constructed using traditional methods, combining generation from specification for a few su...", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143122", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marina", + "last_name": "Chen", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Cowie", + "institution": "" + } + ], + "dblp_key": "conf/pldi/ChenC92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143143", + "title": "Rematerialization", + "abstract": "This paper examines a problem that arises during global register allocation – rematerialization. If a value cannot be kept in a register, the allocator should recognize when it is cheaper to recompute the value (rematerialize it) than to store and reload it. Chaitin's original graph-coloring allocator handled simple instance of this problem correctly. This paper details a general solution to the problem and presents experimental evidence that shows its importance.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143143", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Preston", + "last_name": "Briggs", + "institution": "Rice University" + }, + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + }, + { + "first_name": "Linda", + "last_name": "Torczon", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/BriggsCT92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143129", + "title": "Eliminating False Data Dependences using the Omega Test", + "abstract": "Array data dependence analysis methods currently in use generate false dependences that can prevent useful program transformations. These false dependences arise because the questions asked are conservative approximations to the questions we really should be asking. Unfortunately, the questions we really should be asking go beyond integer programming and require decision procedures for a sublcass of Presburger formulas. In this paper, we describe how to extend the Omega test so that it can answer these queries and allow us to eliminate these false data dependences. We have implemented the techniques described here and believe they are suitable for use in production compilers.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143129", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Pugh", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "David", + "last_name": "Wonnacott", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/PughW92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143120", + "title": "Sharlit - A Tool for Building Optimizers", + "abstract": "This paper presents Sharlit, a tool to support the construction of modular and extensible global optimizers. We will show how Sharlit helps in constructing data-flow analyzers and the transformations that use data-flow analysis information, both are major components of any optimizer. Sharlit is implemented in C++ and uses C++ in the same way that YACC uses C. Thus we assume the reader has some familiarity with C++ [9].", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143120", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven", + "last_name": "Tjiang", + "institution": "" + }, + { + "first_name": "John L.", + "last_name": "Hennessy", + "institution": "" + } + ], + "dblp_key": "conf/pldi/TjiangH92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143140", + "title": "Compiler Support for Garbage Collection in a Statically Typed Language", + "abstract": "We consider the problem of supporting compacting garbage collection in the presence of modern compiler optimizations. Since our collector may move any heap object, it must accurately locate, follow, and update all pointers and values derived from pointers. To assist the collector, we extend the compiler to emit tables describing live pointers, and values derived from pointers, at each program location where collection may occur. Significant results include identification of a number of problems posed by optimizations, solutions to those problems, a working compiler, and experimental data concerning table sizes, table compression, and time overhead of decoding tables during collection. While gc support can affect the code produced, our sample programs show no significant changes, the table sizes are a modest fraction of the size of the optimized code, and stack tracing is a small fraction of total gc time. Since the compiler enhancements are also modest, we conclude that the approach is practical.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143140", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "" + }, + { + "first_name": "Richard L.", + "last_name": "Hudson", + "institution": "" + } + ], + "dblp_key": "conf/pldi/DiwanMH92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143133", + "title": "Relaxing SIMD Control Flow Constraints using Loop Transformations", + "abstract": "Many loop nests in scientific codes contain a parallelizable outer loop but have an inner loop for which the number of iterations varies between different iterations of the outer loop. When running this kind of loop nest on a SIMD machine, the SIMD-inherent restriction to single program counter common to all processors will cause a performance degradation relative to comparable MIMD implementations. This problem is not due to limited parallelism or bad load balance, it is merely a problem of control flow.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143133", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Reinhard von", + "last_name": "Hanxleden", + "institution": "" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "" + } + ], + "dblp_key": "conf/pldi/HanxledenK92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143137", + "title": "A Safe Approximate Algorithm for Interprocedural Pointer Aliasing", + "abstract": "During execution, when two or more names exist for the same location at some program point, we call them aliases. In a language which allows arbitrary pointers, the problem of determining aliases at a program point is ρ-space-hard [Lan92]. We present an algorithm for the Conditional May Alias problem, which can be used to safely approximate Interprocedural May Alias in the presence of pointers. This algorithm is as precise as possible in the worst case and has been implemented in a prototype analysis tool for C programs. Preliminary speed and precision results are presented.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143137", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Landi", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/pldi/LandiR92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143146", + "title": "Eliminating Branches using a Superoptimizer and the GNU C Compiler", + "abstract": "this paper uses the RS/6000 for all its examples, the techniques described here are applicable to most machines", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143146", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Torbjörn", + "last_name": "Granlund", + "institution": "" + }, + { + "first_name": "Richard", + "last_name": "Kenner", + "institution": "" + } + ], + "dblp_key": "conf/pldi/GranlundK92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143134", + "title": "A Dynamic Scheduling Technique for Irregular Parallel Programs", + "abstract": "This paper develops a methodology for compiling and executing irregular parallel programs. Such programs implement parallel operations whose size and work distribution depend on input data. We show a fundamental relationship between three quantities that characterize an irregular parallel computation: the total available parallelism, the optimal grain size, and the statistical variance of execution times for individual tasks. This relationship yields a dynamic scheduling algorithm that substantially reduces the overhead of executing irregular parallel operations.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143134", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven", + "last_name": "Lucco", + "institution": "Berkeley College" + } + ], + "dblp_key": "conf/pldi/Lucco92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143135", + "title": "How to Analyze Large Programs Efficiently and Informatively", + "abstract": "Elimination of partial redundancies is a powerful optimization that has been implemented in at least three important production compilers and has inspired several similar optimizations. The global data flow analysis that supports this family of optimizations includes some bidirectional problems. (A bidirectional problem is one in which the global information at each basic block depends on both control flow predecessors and control flow successors.) This paper contributes two ways to simplify and expedite the analysis, especially for large programs. For each global data flow question, we examine only the places in the program where the question might have an answer different from a trivial default answer. In a large program, we may examine only a small fraction of the places conventional algorithms would examine. We reduce the relevant bidirectional problems to simpler unidirectional problems. These bidirectional problems can be solved by applying a quick correction to a unidirectional approximation.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143135", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dhananjay M.", + "last_name": "Dhamdhere", + "institution": "" + }, + { + "first_name": "Barry K.", + "last_name": "Rosen", + "institution": "" + }, + { + "first_name": "F. Kenneth", + "last_name": "Zadeck", + "institution": "" + } + ], + "dblp_key": "conf/pldi/DhamdhereRZ92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143108", + "title": "A New Approach to Debugging Optimized Code", + "abstract": "Debugging optimized code is a desirable capability not provided by most current debuggers. Users are forced to debug the unoptimized code when a bug occurs in the optimized version. Current research offers partial solutions for a small class of optimizations, but not a unified approach that handles a wide range of optimizations, such as the sophisticated optimizations performed by supercomputer compilers.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143108", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gary", + "last_name": "Brooks", + "institution": "" + }, + { + "first_name": "Gilbert J.", + "last_name": "Hansen", + "institution": "" + }, + { + "first_name": "Steve", + "last_name": "Simmons", + "institution": "" + } + ], + "dblp_key": "conf/pldi/BrooksHS92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143119", + "title": "A Customizable Substrate for Concurrent Languages", + "abstract": "We describe an approach to implementing a wide-range of concurrency paradigms in high-level (symbolic) programming languages. The focus of our discussion is STING, a dialect of Scheme, that supports lightweight threads of control and virtual processors as first-class objects. Given the significant degree to which the behavior of these objects may be customized, we can easily express a variety of concurrency paradigms and linguistic structures within a common framework without loss of efficiency.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143119", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "" + }, + { + "first_name": "Jim", + "last_name": "Philbin", + "institution": "" + } + ], + "dblp_key": "conf/pldi/JagannathanP92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143139", + "title": "Alphonse: Incremental Computation as a Programming Abstraction", + "abstract": "Alphonse is a program transformation system that uses dynamic dependency analysis and incremental computation techniques to automatically generate efficient dynamic implementations from simple exhaustive imperative program specifications.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143139", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Roger", + "last_name": "Hoover", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/Hoover92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143114", + "title": "Debugging Optimized Code with Dynamic Deoptimization", + "abstract": "SELF's debugging system provides complete source-level debugging (expected behavior) with globally optimized code. It shields the debugger from optimizations performed by the compiler by dynamically deoptimizing code on demand. Deoptimization only affects the procedure activations that are actively being debugged; all other code runs at full speed. Deoptimization requires the compiler to supply debugging information at discrete interrupt points; the compiler can still perform extensive optimizations between interrupt points without affecting debuggability. At the same time, the inability to interrupt between interrupt points is invisible to the user. Our debugging system also handles programming changes during debugging. Again, the system provides expected behavior: it is possible to change a running program and immediately observe the effects of the change. Dynamic deoptimization transforms old compiled code (which may contain inlined copies of the old version of the changed procedure) into new versions reflecting the current source-level state. To the best of our knowledge, SELF is the first practical system providing full expected behavior with globally optimized code.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143114", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Urs", + "last_name": "Hölzle", + "institution": "Stanford University" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "" + } + ], + "dblp_key": "conf/pldi/HolzleCU92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143125", + "title": "Escape Analysis on Lists", + "abstract": "Higher order functional programs constantly allocate objects dynamically. These objects are typically cons cells, closures, and records and are generally allocated in the heap and reclaimed later by some garbage collection process. This paper describes a compile time analysis, called escape analysis, for determining the lifetime of dynamically created objects in higher order functional programs, and describes optimizations that can be performed, based on the analysis, to improve storage allocation and reclamation of such objects. In particular, our analysis can be applied to programs manipulating lists, in which case optimizations can be performed to allow cons cells in spines of lists to be either reclaimed immediately or reused without incurring any garbage collection overhead. In a previous paper on escape analysis [10], we had left open the problem of performing escape analysis on lists.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143125", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Young Gil", + "last_name": "Park", + "institution": "New York University" + }, + { + "first_name": "Benjamin", + "last_name": "Goldberg", + "institution": "New York University" + } + ], + "dblp_key": "conf/pldi/ParkG92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143117", + "title": "The Design and Implementation of HoME", + "abstract": "HoME is a version of Smalltalk which can be efficiently executed on a multiprocessor and can be executed in parallel by combining a Smalltalk process with a Mach thread and executing the process on the thread. HoME is nearly the same as ordinary Smalltalk except that multiple processes may execute in parallel. Thus, almost all applications running on ordinary Smalltalk can be executed on HoME without changes in their code.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143117", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kazuhiro", + "last_name": "Ogata", + "institution": "Keio University" + }, + { + "first_name": "Satoshi", + "last_name": "Kurihara", + "institution": "" + }, + { + "first_name": "Mikio", + "last_name": "Inari", + "institution": "" + }, + { + "first_name": "Norihisa", + "last_name": "Doi", + "institution": "Keio University" + } + ], + "dblp_key": "conf/pldi/OgataKID92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143132", + "title": "A General Framework for Iteration-Reordering Loop Transformations", + "abstract": "This paper describes a general framework for representing iteration-reordering transformations. These transformations can be both matrix-based and non-matrix-based. Transformations are defined by rules for mapping dependence vectors, rules for mapping loop bound expressions, and rules for creating new initialization statements. The framework is extensible, and can be used to represent any iteration-reordering transformation. Mapping rules for several common transformations are included in the paper.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143132", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "" + }, + { + "first_name": "Radhika", + "last_name": "Thekkath", + "institution": "" + } + ], + "dblp_key": "conf/pldi/SarkarT92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143145", + "title": "Simple and Efficient BURS Table Generation", + "abstract": "A simple and efficient algorithm for generating bottom-up rewrite system (BURS) tables is described. A small prototype implementation produces tables 10 to 30 times more quickly than the best current techniques. The algorithm does not require novel data structures or complicated algorithmic techniques. Previously published methods for the on-the-fly elimination of states are generalized and simplified to create a new method, triangle trimming, that is employed in the algorithm.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143145", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/Proebsting92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143110", + "title": "Dynascope: A Tool for Program Directing", + "abstract": "This paper introduces program directing, a new way of program interaction. Directing enables one program, the director, to monitor and to control another program, the executor. One important application of program directing is human interaction with complex computer simulations.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143110", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rok", + "last_name": "Sosič", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/Sosic92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143141", + "title": "Register Allocation for Software Pipelined Loops", + "abstract": "Software pipelining is an important instruction scheduling technique for efficiently overlapping successive iterations of loops and executing them in parallel. This paper studies the task of register allocation for software pipelined loops, both with and without hardware features that are specifically aimed at supporting software pipelines. Register allocation for software pipelines presents certain novel problems leading to unconventional solutions, especially in the presence of hardware support. This paper formulates these novel problems and presents a number of alternative solution strategies. These alternatives are comprehensively tested against over one thousand loops to determine the best register allocation strategy, both with and without the hardware support for software pipelining.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143141", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "B. Ramakrishna", + "last_name": "Rau", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "M.", + "last_name": "Lee", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "P.", + "last_name": "Tirumalai", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Michael", + "last_name": "Schlansker", + "institution": "" + } + ], + "dblp_key": "conf/pldi/RauLTS92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143112", + "title": "A Retargetable Debugger", + "abstract": "We are developing techniques for building retargetable debuggers. Our prototype, 1db, debugs C programs compiled for the MIPS R3000, Motorola 68020, SPARC, and VAX architectures. It can use a network to connect to faulty processes and can do cross-architecture debugging. 1db's total code size is about 16,000 lines, but it needs only 250–550 lines of machine-dependent code for each target.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143112", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Princeton University" + }, + { + "first_name": "David R.", + "last_name": "Hanson", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/RamseyH92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.120025", + "title": "A Concurrent Compiler for Modula-2+", + "abstract": "In this paper we describe a collection of techniques for the design and implementation of concurrent compilers. We begin by describing a technique for dividing a source program into many streams so that each stream can be compiled concurrently. We discuss several compiler design issues unique to concurrent compilers including source program partitioning, symbol table management, compiler task scheduling and information flow constraints. The application of our techniques is illustrated by a complete design for a concurrent Modula-2+ compiler. After describing the structure of this compiler's performance that demonstrates that significant improvements in compilation time can be achieved through the use of concurrency.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.120025", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David B.", + "last_name": "Wortman", + "institution": "University of Toronto" + }, + { + "first_name": "Michael D.", + "last_name": "Junkin", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/pldi/WortmanJ92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143131", + "title": "Beyond Induction Variables", + "abstract": "Induction variable detection is usually closely tied to the strength reduction optimization. This paper studies induction variable analysis from a different perspective, that of finding induction variables for data dependence analysis. While classical induction variable analysis techniques have been used successfully up to now, we have found a simple algorithm based on the Static Single Assignment form of a program that finds all linear induction variables in a loop. Moreover, this algorithm is easily extended to find induction variables in multiple nested loops, to find nonlinear induction variables, and to classify other integer scalar assignments in loops, such as monotonic, periodic and wrap-around variables. Some of these other variables are now classified using ad hoc pattern recognition, while others are not analyzed by current compilers. Giving a unified approach improves the speed of compilers and allows a more general classification scheme. We also show how to use these variables in data dependence testing.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143131", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Wolfe", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Wolfe92", + "venue": "pldi", + "year": 1992 + }, + { + "paper_id": "10.1145/143095.143123", + "title": "Compiling Dataflow Analysis of Logic Programs", + "abstract": "Abstract interpretation is a technique extensively used for global dataflow analyses of logic programs. Existing implementations of abstract interpretation are slow due to interpretive or transforming overhead and the inefficiency in manipulation of global information. Since abstract interpretation mimics standard interpretation, it is a promising alternative to compile abstract interpretation into the framework of the WAM (Warren Abstract Machine) for better performance. In this paper, we show how this approach can be effectively implemented in a low-cost manner. To evaluate the possible benefits of this approach, a prototype dataflow analyzer has been implemented for inference of mode, type and variable aliasing information of logic programs. For a subset of benchmark programs in [15], it significantly improves the performance by a factor of over 150 on the average.", + "date": "1992-01-01", + "link": "https://doi.org/10.1145/143095.143123", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jichang", + "last_name": "Tan", + "institution": "National Taiwan University" + }, + { + "first_name": "I-Peng", + "last_name": "Lin", + "institution": "National Taiwan University" + } + ], + "dblp_key": "conf/pldi/TanL92", + "venue": "pldi", + "year": 1992 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1993.json b/data/pl_conferences/pldi/1993.json new file mode 100644 index 0000000..97fcf72 --- /dev/null +++ b/data/pl_conferences/pldi/1993.json @@ -0,0 +1,699 @@ +[ + { + "paper_id": "10.1145/155090.155109", + "title": "Space Efficient Conservative Garbage Collection", + "abstract": "We call a garbage collector conservative if it has only partial information about the location of pointers, and is thus forced to treat arbitrary bit patterns as though they might be pointers, in at least some cases. We show that some very inexpensive, but previously unused techniques can have dramatic impact on the effectiveness of conservative garbage collectors in reclaiming memory. Our most significant observation is that static data that appears to point to the heap should not result in misidentified references to the heap. The garbage collector has enough information to allocate around such references. We also observe that programming style has a significant impact on the amount of spuriously retained storage, typically even if the collector is not terribly conservative. Some fairly common C and C programming styles significantly decrease the effectiveness of any garbage collector. These observations suffice to explain some of the different assessments of conservative collection that have appeared in the literature.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155109", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hans‐Juergen", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/Boehm93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155095", + "title": "Abstract Debugging of Higher-Order Imperative Languages", + "abstract": "Abstract interpretation is a formal method that enables the static determination (i.e. at compile-time) of the dynamic properties (i.e. at run-time) of programs. We present an abstract interpretation-based method, called abstract debugging, which enables the static and formal debugging of programs, prior to their execution, by finding the origin of potential bugs as well as necessary conditions for these bugs not to occur at run-time. We show how invariant assertions and intermittent assertions, such as termination, can be used to formally debug programs. Finally, we show how abstract debugging can be effectively and efficiently applied to higher-order imperative programs with exceptions and jumps to non-local labels, and present the Syntox system that enables the abstract debugging of the Pascal language by the determination of the range of the scalar variables of programs.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155095", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "François", + "last_name": "Bourdoncle", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Bourdoncle93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155106", + "title": "Compiling Real-Time Programs into Schedulable Code", + "abstract": "We present a programming language with first-class timing constructs, whose semantics is based on timeconstrained relationships between observable events. Since a system specification postulates timing relationships between events, realizing the specification in a program becomes a more straightforward process. Using these constraints, as well as those imposed by data and control flow properties, our objective is to transform the code so that its worst-case execution time is consistent with its real-time requirements. To accomplish this goal we first translate an event-based source program into intermediate code, in which the timing constraints are imposed on the code itself, and then use a compilation technique which synthesizes feasible code from the original source program. 1 Overview The construction of a hard real-time system can, in practice, be a painful process. Many factors conspire to make this the case, among which are inflexible scheduling paradigms and the lack of high-le...", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155106", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Seongsoo", + "last_name": "Hong", + "institution": "" + }, + { + "first_name": "R.", + "last_name": "Gerber", + "institution": "" + } + ], + "dblp_key": "conf/pldi/HongG93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155092", + "title": "Detection and Recovery of Endangered Variables Caused by Instruction Scheduling", + "abstract": "Instruction scheduling re-orders and interleaves instruction sequences from different source statements. This impacts the task of a symbolic debugger, which attempts to present the user a picture of program execution that matches the source program. At a breakpoint B, if the value in the run-time location of a variable V may not correspond to the value the user expects V to have, then this variable is endangered at B. This paper describes an approach to detecting and recovering endangered variables caused by instruction scheduling. We measure the effects of instruction scheduling on a symbolic debugger's ability to recover source values at a breakpoint. This paper reports measurements for three C programs from the SPEC suite and a collection of programs from the Numerical Recipes, which have been compiled with a variant of a commercial C compiler.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155092", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/Adl-TabatabaiG93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155101", + "title": "Global Optimizations for Parallelism and Locality on Scalable Parallel Machines", + "abstract": "Data locality is critical to achieving high performance on large-scale parallel machines. Non-local data accesses result in communication that can greatly impact performance. Thus the mapping, or decomposition, of the computation and data onto the processors of a scalable parallel machine is a key issue in compiling programs for these architectures. This paper describes a compiler algorithm that automatically finds computation and data decompositions that optimize both parallelism and locality. This algorithm is designed for use with both distributed and shared address space machines. The scope of our algorithm is dense matrix computations where the array accesses are affine functions of the loop indices. Our algorithm can handle programs with general nestings of parallel and sequential loops. We present a mathematical framework that enables us to systematically derive the decompositions. Our algorithm can exploit parallelism in both fully parallelizable loops as well as loops that require explicit synchronization. The algorithm will trade off extra degrees of parallelism to eliminate communication. If communication is needed, the algorithm will try to introduce the least expensive forms of communication into those parts of the program that are least frequently executed. 1", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155101", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jennifer M.", + "last_name": "Anderson", + "institution": "" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "" + } + ], + "dblp_key": "conf/pldi/AndersonL93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155098", + "title": "Dependence-Based Program Analysis", + "abstract": "Program analysis and optimization can be speeded up through the use of the dependence flow graph (DFG), a representation of program dependences which generalizes def-use chains and static single assignment (SSA) form. In this paper, we give a simple graph-theoretic description of the DFG and show how the DFG for a program can be constructed in O(EV ) time. We then show how forward and backward dataflow analyses can be performed efficiently on the DFG, using constant propagation and elimination of partial redundancies as examples. These analyses can be framed as solutions of dataflow equations in the DFG. Our construction algorithm is of independent interest because it can be used to construct a program&apos;s control dependence graph in O(E) time and its SSA representation in O(EV ) time, which are improvements over existing algorithms. 1 Introduction Anumber of recent papers have focused attention on the problem of speeding up program optimization [FOW87, BMO90, CCF91, PBJ + 91, CFR +...", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155098", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Richard", + "last_name": "Johnson", + "institution": "Cornell University" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "" + } + ], + "dblp_key": "conf/pldi/JohnsonP93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155107", + "title": "Improving the Cache Locality of Memory Allocation", + "abstract": "The allocation and disposal of memory is a ubiquitous operation in most programs. Rarely do programmers concern themselves with details of memory allocators; most assume that memory allocators provided by the system perform well. This paper presents a performance evaluation of the reference locality of dynamic storage allocation algorithms based on trace-driven simualtion of five large allocation-intensive C programs. In this paper, we show how the design of a memory allocator can significantly affect the reference locality for various applications. Our measurements show that poor locality in sequential-fit allocation algorithms reduces program performance, both by increasing paging and cache miss rates. While increased paging can be debilitating on any architecture, cache misses rates are also important for modern computer architectures. We show that algorithms attempting to be space-efficient by coalescing adjacent free objects show poor reference locality, possibly negating the benefits of space efficiency. At the other extreme, algorithms can expend considerable effort to increase reference locality yet gain little in total execution performance. Our measurements suggest an allocator design that is both very fast and has good locality of reference.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155107", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dirk", + "last_name": "Grunwald", + "institution": "" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "" + }, + { + "first_name": "Robert", + "last_name": "Henderson", + "institution": "" + } + ], + "dblp_key": "conf/pldi/GrunwaldZH93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155097", + "title": "A Practical Data Flow Framework for Array Reference Analysis and its Use in Optimizations", + "abstract": "Data flow analysis techniques have traditionally been restricted to the analysis of scalar variables. This retriction, however, imposes a limitation on the kinds of optimizations that can be performed in loops containing array references. We present a data flow framework for array reference analysis that provides the information needed in various optimizations targeted at sequential or fine-grained parallel architectures. The framework extends the traditional scalar framework by incorporating iteration distance values into the analysis to qualify the computed data flow solution during the fixed point iteration. Analyses phrased in this framework are capable of discovering recurrent access patterns among array references that evolve during the execution of a loop. Applications of our framework are discussed for register allocation, load/store optimizations, and controlled loop unrolling.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155097", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Evelyn", + "last_name": "Duesterwald", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Mary Lou", + "last_name": "Soffa", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/pldi/DuesterwaldGS93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155103", + "title": "First-Class Data-Type Representations in SchemeXerox", + "abstract": "In most programming language implementations, the compiler has detailed knowledge of the representations of and operations on primitive data typed and data-type constructors. In SCHEMEXEROX, this knowledge is almost entirely external to the compiler, in ordinary, procedural user code. The primitive representations and operations are embodied in first-class “representation types” that are constructed and implemented in an abstract and high-level fashion. Despite this abstractness, a few generally-useful optimizing transformations are sufficient to allow the SCHEMEXEROX compiler to generate efficient code for the primitive operations, essentially as good as could be achieved using more contorted, traditional techniques.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155103", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Norman I.", + "last_name": "Adams", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Pavel", + "last_name": "Curtis", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Mike", + "last_name": "Spreitzer", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/pldi/AdamsCS93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155110", + "title": "Guardians in a Generation-Based Garbage Collector", + "abstract": "This paper describes a new language feature that allows dynamically allocated objects to be saved from deallocation by an automatic storage management system so that clean-up or other actions can be performed using the data stored within the objects. The program has full control over the timing of clean-up actions, which eliminates several potential problems and often eliminates the need for critical sections in code that interacts with clean-up actions. Our implementation is “generation-friendly” in the sense that the additional overhead within a generation-based garbage collector is proportional to the work already done there, and the overhead within the mutator is proportional to the number of clean-up actions actually performed.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155110", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "Carl", + "last_name": "Bruggeman", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "David", + "last_name": "Eby", + "institution": "Laboratoire d'Informatique de Paris-Nord" + } + ], + "dblp_key": "conf/pldi/DybvigBE93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155108", + "title": "Using Lifetime Predictors to Improve Memory Allocation Performance", + "abstract": "Dynamic storage allocation is used heavily in many application areas including interpreters, simulators, optimizers, and translators. We describe research that can improve all aspects of the performance of dynamic storage allocation by predicting the lifetimes of short-lived objects when they are allocated. Using five significant, allocation-intensive C programs, we show that a great fraction of all bytes allocated are short-lived (> 90% in all cases). Furthermore, we describe an algorithm for liftetime prediction that accurately predicts the lifetimes of 42–99% of all objects allocated. We describe and simulate a storage allocator that takes adavantage of lifetime prediction of short-lived objects and show that it can significantly improve a program's memory overhead and reference locality, and even, at times, improve CPU performance as well.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155108", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David A.", + "last_name": "Barrett", + "institution": "" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "" + } + ], + "dblp_key": "conf/pldi/BarrettZ93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155094", + "title": "Efficient Accomodation of May-Alias Information in SSA Form", + "abstract": "We present an algorithm for incrementally including may-alias information into Static Single Assignment form by computing a sequence of increasingly precise (and correspondingly larger) partial SSA forms. Our experiments show significant speedup of our method over exhaustive use of may-alias information, as optimization problems converge well before most may-aliases are needed.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155094", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ron K.", + "last_name": "Cytron", + "institution": "Oberlin College" + }, + { + "first_name": "Reid", + "last_name": "Gershbein", + "institution": "Oberlin College" + } + ], + "dblp_key": "conf/pldi/CytronG93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155093", + "title": "Isolation and Analysis of Optimization Errors", + "abstract": "This paper describes two related tools developed to support the isolation and analysis of optimization errors in the vpo optimizer.Both tools rely on vpo identifying sequences of changes, referred to as transformations,", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155093", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mickey R.", + "last_name": "Boyd", + "institution": "Florida State University" + }, + { + "first_name": "David", + "last_name": "Whalley", + "institution": "Florida State University" + } + ], + "dblp_key": "conf/pldi/BoydW93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155112", + "title": "Implementing Type Classes", + "abstract": "We describe the implementation of a type checker for the functional programming language Haskell that supports the use of type classes. This extends the type system of ML to support overloading (ad-hoc polymorphism) and can be used to implement features such as equality types and numeric overloading in a simple and general way.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155112", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Peterson", + "institution": "Yale University" + }, + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/PetersonJ93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155099", + "title": "Interprocedural Constant Propagation: A Study of Jump Function Implementations", + "abstract": "An implementation of interprocedural constant propagation must model the transmission of values through each procedure. In the framework proposed by Callahan, Cooper, Kennedy, and Torczon in 1986, this intraprocedural propagation is modeled with a jump function. While Callahan et al. propose several kinds of jump functions, they give no data to help choose between them. This paper reports on a comparative study of jump function implementations. It shows that different jump functions produce different numbers of useful constants; it suggests a particular function, called the pass-through parameter jump function, as the most cost-effective in practice.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155099", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dan", + "last_name": "Grove", + "institution": "Oracle (United States)" + }, + { + "first_name": "Linda", + "last_name": "Torczon", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/GroveT93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155113", + "title": "The Essence of Compiling with Continuations", + "abstract": "In order to simplify the compilation process, many compilers for higher-order languages use the continuation-passing style (CPS) transformation in a first phase to generate an intermediate representation of the source program. The salient aspect of this intermediate form is that all procedures take an argument that represents the rest of the computation (the “continuation”). Since the nai¨ve CPS transformation considerably increases the size of programs, CPS compilers perform reductions to produce a more compact intermediate representation. Although often implemented as a part of the CPS transformation, this step is conceptually a second phase. Finally, code generators for typical CPS compilers treat continuations specially in order to optimize the interpretation of continuation parameters.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155113", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University" + }, + { + "first_name": "Bruce F.", + "last_name": "Duba", + "institution": "Seattle University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "" + } + ], + "dblp_key": "conf/pldi/FlanaganSDF93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155116", + "title": "Load/Store Range Analysis for Global Register Allocation", + "abstract": "Live range splitting techniques divide the live ranges of variables into live range segments to improve global register allocation. We present a new technique for live range splitting called load/store range analysis. This analysis localizes the profits and the register requirements of every access to every variable to provide a fine granularity of candidates for register allocation. Load/Store range analysis is based on the data flow analysis algorithm for def-use chaining. Experiments on a small suite of C and FORTRAN benchmark programs show that a graph coloring register allocator operating on load/store ranges often provides better allocations than the same allocator operating on live ranges. Experimental results also show that the computational cost of using load/store ranges for register allocation is moderately more than the cost of using live ranges. 1 Introduction The goal of register allocation is to map variables in an intermediate language program to either registers or mem...", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155116", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Priyadarshan", + "last_name": "Kolte", + "institution": "" + }, + { + "first_name": "Mary Jean", + "last_name": "Harrold", + "institution": "" + } + ], + "dblp_key": "conf/pldi/KolteH93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155100", + "title": "Orchestrating Interactions Among Parallel Computations", + "abstract": "Many parallel programs contain multiple sub-computations, each with distinct communication and load balancing requirements. The traditional approach to compiling such programs is to impose a processor synchronization barrier between sub-computations, optimizing each as a separate entity. This paper develops a methodology for managing the interactions among sub-computations, avoiding strict synchronization where concurrent or pipelined relationships are possible.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155100", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "Berkeley College" + }, + { + "first_name": "Steven", + "last_name": "Lucco", + "institution": "Berkeley College" + }, + { + "first_name": "Oliver", + "last_name": "Sharp", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/GrahamLS93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155117", + "title": "Balanced Scheduling: Instruction Scheduling When Memory Latency is Uncertain", + "abstract": "Traditional list schedulers order instructions based on an optimistic estimate of the load delay imposed by the implementation. Therefore they cannot respond to variations in load latencies (due to cache hits or misses, congestion in the memory interconnect, etc.) and cannot easily be applied across different implementations. We have developed an alternative algorithm, known as balanced scheduling, that schedule instructions based on an estimate of the amount of instruction level parallelism in the program. Since scheduling decisions are program-rather than machine-based, balanced scheduling is unaffected by implementation changes. Since it is based on the amount of instruction level parallelism that a program can support, it can respond better to variations in load latencies. Performance improvements over a traditional list scheduler on a Fortran workload and simulating several different machine types (cache-based workstations, large parallel machines with a multipath interconnect and a combination, all with non-blocking processors) are quite good, averaging between 3% and 18%.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155117", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel R.", + "last_name": "Kerns", + "institution": "Mercer Island School District" + }, + { + "first_name": "Susan J.", + "last_name": "Eggers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/KernsE93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155115", + "title": "Lifetime-Sensitive Modulo Scheduling", + "abstract": "This paper shows how to software pipeline a loop for minimal register pressure without sacrificing the loop's minimum execution time. This novel bidirectional slack-scheduling method has been implemented in a FORTRAN compiler and tested on many scientific benchmarks. The empirical results—when measured against an absolute lower bound on execution time, and against a novel schedule-independent absolute lower bound on register pressure—indicate near-optimal performance.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155115", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Richard A.", + "last_name": "Huff", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/Huff93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155119", + "title": "Branch Prediction For Free", + "abstract": "Many compilers rely on branch prediction to improve program performance by identifying frequently executed regions and by aiding in scheduling instructions.Profile-based predictors require a time-consuming and inconvenient compile-profile-compile cycle in order to make predictions. We present a program-based branch predictor that performs well for a large and diverse set of programs written in C and Fortran. In addition to using natural loop analysis to predict branches that control the iteration of loops, we focus on heuristics for predicting non-loop branches, which dominate the dynamic branch count of many programs. The heuristics are simple and require little program analysis, yet they are effective in terms of coverage and miss rate. Although program-based prediction does not equal the accuracy of profile-based prediction, we believe it reaches a sufficiently high level to be useful. Additional type and semantic information available to a compiler would enhance our heuristics.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155119", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Nokia (United States)" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "" + } + ], + "dblp_key": "conf/pldi/BallL93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155096", + "title": "Interprocedural Side Effect Analysis With Pointer Aliasing", + "abstract": "We present a new interprocedural modification side effects algorithm for C programs, that can discern side effects through general-purpose pointer usage. Ours is the first complete design and implementation of such an algorithm. Preliminary performance findings support the practicality of the technique, which is based on our previous approximation algorithm for pointer aliases [LR92]. Each indirect store through a pointer variable is found, on average, to correspond to a store into 1.2 locations. This indicates that our program-point-specific pointer aliasing information is quite precise when used to determine the effects of these stores.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155096", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Landi", + "institution": "" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "" + }, + { + "first_name": "Sean X.", + "last_name": "Zhang", + "institution": "" + } + ], + "dblp_key": "conf/pldi/LandiRZ93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155102", + "title": "Communication Optimization and Code Generation for Distributed Memory Machines", + "abstract": "This paper presents several algorithms to solve code generation and optimization problems specific to machines with distributed address spaces. Given a description of how the computation is to be partitioned across the processors in a machine, our algorithms produce an SPMD (single program multiple data) program to be run on each processor. Our compiler generated the necessary receive and send instructions, optimizes the communication by eliminating redundant communication and aggregating small messages into large messages, allocates space locally on each processor, and translates global data addresses to local addresses.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155102", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/AmarasingheL93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155111", + "title": "Real-Time Replication Garbage Collection", + "abstract": "We have implemented the first copying garbage collector that permits continuous unimpeded mutator access to the original objects during copying. The garbage collector incrementally replicates all accessible objects and uses a mutation log to bring the replicas up-to-date with changes made by the mutator. An experimental implementation demonstrates that the costs of using our algorithm are small and that bounded pause times of 50 milliseconds can be readily achieved.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155111", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Scott", + "last_name": "Nettles", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "James W.", + "last_name": "O’Toole", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/NettlesO93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155091", + "title": "Practical Data Breakpoints: Design and Implementation", + "abstract": "A data breakpoint associates debugging actions with programmer-specified conditions on the memory state of an executing program. Data breakpoints provide a means for discovering program bugs that are tedious or impossible to isolate using control breakpoints alone. In practice, programmers rarely use data breakpoints, because they are either unimplemented or prohibitively slow in available debugging software. In this paper, we present the design and implementation of a practical data breakpoint facility.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155091", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert", + "last_name": "Wahbe", + "institution": "" + }, + { + "first_name": "Steven", + "last_name": "Lucco", + "institution": "" + }, + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "" + } + ], + "dblp_key": "conf/pldi/WahbeLG93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155104", + "title": "Handling Control", + "abstract": "Non-local control transfer and exception handling have a long tradition in higher-order programming languages such as Common Lisp, Scheme and ML. However, each language stops short of providing a full and complementary approach—control handling is provided only if the corresponding control operator is first-order. In this work, we describe handlers in a higher-order control setting. We invoke our earlier theoretical result that all denotational models of control languages invariably include capabilities that handle control. These capabilities, when incorporated into the language, form an elegant and powerful higher-order generalization of the first-order exception-handling mechanism.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155104", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dorai", + "last_name": "Sitaram", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Sitaram93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155105", + "title": "Programmable Syntax Macros", + "abstract": "Lisp has shown that a programmable syntax macro system acts as an adjunct to the compiler that gives the programmer important and powerful abstraction facilities not provided by the language. Unlike simple token substitution macros, such as are provided by CPP (the C preprocessor), syntax macros operate on Abstract Syntax Trees (ASTs). Programmable syntax macro systems have not yet been developed for syntactically rich languages such as C because rich concrete syntax requires the manual construction of syntactically valid program fragments, which is a tedious, difficult, and error prone process. Also, using two languages, one for writing the program, and one for writing macros, is another source of complexity. This research solves these problems by having the macro language be a minimal extension of the programming language, by introducing explicit code template operators into the macro language, and by using a type system to guarantee, at macro definition time, that all macros and macro functions only produce syntactically valid program fragments. The code template operators make the language context sensitive, which requires changes to the parser. The parser must perform type analysis in order to parse macro definitions, or to parse user code that invokes macros.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155105", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Weise", + "institution": "" + }, + { + "first_name": "Roger F.", + "last_name": "Crew", + "institution": "" + } + ], + "dblp_key": "conf/pldi/WeiseC93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155118", + "title": "Reverse If-Conversion", + "abstract": "In this paper we present a set of isomorphic control transformations that allow the compiler to apply local scheduling techniques to acyclic subgraphs of the control flow graph. Thus, the code motion complexities of global scheduling are eliminated. This approach relies on a new technique, Reverse If-Conversion (RIC), that transforms scheduled If-Converted code back to the control flow graph representation. This paper presents the predicate internal representation, the algorithms for RIC, and the correctness of RIC. In addition, the scheduling issues are addressed and an application to software pipelining is presented.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155118", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nancy J.", + "last_name": "Warter", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Wen‐mei", + "last_name": "Hwu", + "institution": "National Center for Supercomputing Applications" + }, + { + "first_name": "B. Ramakrishna", + "last_name": "Rau", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/WarterMHR93", + "venue": "pldi", + "year": 1993 + }, + { + "paper_id": "10.1145/155090.155114", + "title": "Register Allocation with Instruction Scheduling: A New Approach", + "abstract": "We present a new framework in which considerations of both register allocation and instruction scheduling can be applied uniformly and simultaneously. In this framework an optimal coloring of a graph, called the parallel interference graph, provides an optimal register allocation and preserves the property that no false dependences are introduced, thus all the options for parallelism are kept for the scheduler to handle. For this framework we provide heuristics for trading off parallel scheduling with register spilling.", + "date": "1993-06-01", + "link": "https://doi.org/10.1145/155090.155114", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shlomit S.", + "last_name": "Pinter", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Pinter93", + "venue": "pldi", + "year": 1993 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1994.json b/data/pl_conferences/pldi/1994.json new file mode 100644 index 0000000..1915f87 --- /dev/null +++ b/data/pl_conferences/pldi/1994.json @@ -0,0 +1,712 @@ +[ + { + "paper_id": "10.1145/178243.178263", + "title": "Interprocedural May-Alias Analysis for Pointers: Beyond k-limiting", + "abstract": "Existing methods for alias analysis of recursive pointer data structures are based on two approximation techniques: k-limiting, and store-based (or equivalently location or region-based) approximations, which blur distinction between elements of recursive data structures. Although notable progress in inter-procedural alias analysis has been recently accomplished, very little progress in the precision of analysis of recursive pointer data structures has been seen since the inception of these approximation techniques by Jones and Muchnick a decade ago. As a result, optimizing, verifying and parallelizing programs with pointers has remained difficult.We present a new parametric framework for analyzing recursive pointer data structures which can express a new natural class of alias information not accessible to existing methods. The key idea is to represent alias information by pairs of symbolic access paths which are qualified by symbolic descriptions of the positions for which the alias pair holds.Based on this result, we present an algorithm for interprocedural may-alias analysis with pointers which on numerous examples that occur in practice is much more precise than recently published algorithms [CWZ90, He90, LR92, CBC93].", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178263", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alain", + "last_name": "Deutsch", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/Deutsch94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178261", + "title": "Cache Performance of Garbage-Collected Programs", + "abstract": "As processor speeds continue to improve relative to main-memory access times, cache performance is becoming an increasingly important component of program performance. Prior work on the cache performance of garbage-collected programs either argues or assumes that conventional garbage-collection methods will yield poor performance, and has therefore concentrated on new collection algorithms designed specifically to improve cache-level reference locality.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178261", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark B.", + "last_name": "Reinhold", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Reinhold94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178262", + "title": "A General Data Dependence Test for Dynamic, Pointer-Based Data Structures", + "abstract": "Optimizing compilers require accurate dependence testing to enable numerous, performance-enhancing transformations. However, data dependence testing is a difficult problem, particularly in the presence of pointers. Though existing approaches work well for pointers to named memory locations (i.e. other variables), they are overly conservative in the case of pointers to unnamed memory locations. The latter occurs in the context of dynamic, pointer-based data structures, used in a variety of applications ranging from system software to computational geometry to N-body and circuit simulations.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178262", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Hummel", + "institution": "University of California, Irvine" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + }, + { + "first_name": "Alexandru", + "last_name": "Nicolau", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/pldi/HummelHN94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178252", + "title": "Improving Semi-static Branch Prediction by Code Replication", + "abstract": "Speculative execution on superscalar processors demands substantially better branch prediction than what has been previously available. In this paper we present code replication techniques that improve the accuracy of semi-static branch prediction to a level comparable to dynamic branch prediction schemes. Our technique uses profiling to collect information about the correlation between different branches and about the correlation between the subsequent outcomes of a single branch. Using this information and code replication the outcome of branches is represented in the program state. Our experiments have shown that the misprediction rate can almost be halved while the code size is increased by one third.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178252", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Krall", + "institution": "University of Applied Sciences Technikum Wien" + } + ], + "dblp_key": "conf/pldi/Krall94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178258", + "title": "The Program Structure Tree: Computing Control Regions in Linear Time", + "abstract": "In this paper, we describe the program structure tree (PST), a hierarchical representation of program structure based on single entry single exit (SESE) regions of the control flow graph. We give a linear-time algorithm for finding SESE regions and for building the PST of arbitrary control flow graphs (including irreducible ones). Next, we establish a connection between SESE regions and control dependence equivalence classes, and show how to use the algorithm to find control regions in linear time. Finally, we discuss some applications of the PST. Many control flow algorithms, such as construction of Static Single Assignment form, can be speeded up by applying the algorithms in a divide-and-conquer style to each SESE region on its own. The PST is also used to speed up data flow analysis by exploiting “sparsity”. Experimental results from the Perfect Club and SPEC89 benchmarks confirm that the PST approach finds and exploits program structure.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178258", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Richard", + "last_name": "Johnson", + "institution": "Cornell University" + }, + { + "first_name": "David", + "last_name": "Pearson", + "institution": "Cornell University" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/JohnsonPP94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178479", + "title": "Type Analysis of Prolog Using Type Graphs", + "abstract": "Type analysis of Prolog is of primary importance for high-performance compilers, since type information may lead to better indexing and to sophisticated specializations of unification and built-in predicates to name a few. However, these optimizations often require a sophisticated type inference system capable of inferring disjunctive and recursive types and hence expensive in computation time.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178479", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pascal Van", + "last_name": "Hentenryck", + "institution": "Brown University" + }, + { + "first_name": "Agostino", + "last_name": "Cortesi", + "institution": "Ca' Foscari University of Venice" + }, + { + "first_name": "Baudouin Le", + "last_name": "Charlier", + "institution": "University of Namur" + } + ], + "dblp_key": "conf/pldi/HentenryckCC94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178246", + "title": "Lazy Functional State Threads", + "abstract": "Some algorithms make critical internal use of updatable state, even though their external specification is purely functional. Based on earlier work on monads, we present a way of securely encapsulating stateful computations that manipulate multiple, named, mutable objects, in the context of a non-strict, purely-functional language.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178246", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "University of Glasgow" + }, + { + "first_name": "Simon", + "last_name": "Jones", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/pldi/LaunchburyJ94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178255", + "title": "Parallelizing Complex Scans and Reductions", + "abstract": "We present a method for automatically extracting parallel prefix programs from sequential loops, even in the presence of complicated conditional statements. Rather than searching for associative operators in the loop body directly, the method rests on the observation that functional composition itself is associative. Accordingly, we model the loop body as a multivalued function of multiple parameters, and look for a closed-form representation of arbitrary compositions of loop body instances. Careful analysis of conditionals allows this search to succeed in cases where existing automatic methods fail. The method has been implemented and used to generate code for the iWarp parallel computer.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178255", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Allan L.", + "last_name": "Fisher", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Anwar", + "last_name": "Ghuloum", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/FisherG94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178446", + "title": "Efficient Detection of All Pointer and Array Access Errors", + "abstract": "We present a pointer and array access checking technique that provides complete error coverage through a simple set of program transformations. Our technique, based on an extended safe pointer representation, has a number of novel aspects. Foremost, it is the first technique that detects all spatial and temporal access errors. Its use is not limited by the expressiveness of the language; that is, it can be applied successfully to compiled or interpreted languages with subscripted and mutable pointers, local references, and explicit and typeless dynamic storage management, e.g., C. Because it is a source level transformation, it is amenable to both compile- and run-time optimization. Finally, its performance, even without compile-time optimization, is quite good. We implemented a prototype translator for the C language and analyzed the checking overheads of six non-trivial, pointer intensive programs. Execution overheads range from 130% to 540%; with text and data size overheads typically below 100%.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178446", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Todd", + "last_name": "Austin", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Scott E.", + "last_name": "Breach", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Gurindar S.", + "last_name": "Sohi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/AustinBS94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178478", + "title": "Optimizing Dynamically-Dispatched Calls with Run-Time Type Feedback", + "abstract": "Object-oriented programs are difficult to optimize because they execute many dynamically-dispatched calls. These calls cannot easily be eliminated because the compiler does not know which callee will be invoked at runtime. We have developed a simple technique that feeds back type information from the runtime system to the compiler.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178478", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Urs", + "last_name": "Hölzle", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "" + } + ], + "dblp_key": "conf/pldi/HolzleU94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178247", + "title": "VLIW Compilation Techniques in a Superscalar Environment", + "abstract": "We describe techniques for converting the intermediate code representation of a given program, as generated by a modern compiler, to another representation which produces the same run-time results, but can run faster on a superscalar machine. The algorithms, based on novel parallelization techniques for Very Long Instruction Word (VLIW) architectures, find and place together independently executable operations that may be far apart in the original code. i.e., they may be separated by many conditional branches or belong to different iterations of a loop. As a result, the functional units in the superscalar are presented with more work that can proceed in parallel, thus achieving higher performance than the approach of using hardware instruction dispatch techniques alone.While general scheduling techniques improve performance by removing idle pipeline cycles, to further improve performance on a superscalar with only a few functional units requires a reduction in the pathlength. We have designed a set of new algorithms for reducing pathlength and removing stalls due to branches, namely speculative load-store motion out of loops, unspeculation, limited combining, basic block expansion, and prolog tailoring. These algorithms were implemented in a prototype version of the IBM RS/6000 xlc compiler and have shown significant improvement in SPEC integer benchmarks on the IBM POWER machines.Also, we describe a new technique to obtain profiling information with low overhead, and some applications of profiling directed feedback, including scheduling heuristics, code reordering and branch reversal.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178247", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kemal", + "last_name": "Ebci̇oğlu", + "institution": "IBM (United States)" + }, + { + "first_name": "Randy D.", + "last_name": "Groves", + "institution": "" + }, + { + "first_name": "Kichang", + "last_name": "Kim", + "institution": "IBM (United States)" + }, + { + "first_name": "Gabriel M.", + "last_name": "Silberman", + "institution": "IBM (United States)" + }, + { + "first_name": "Isaac", + "last_name": "Ziv", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/EbciogluGKSZ94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178259", + "title": "Memory Access Coalescing: A technique for Eliminating Redundant memory Accesses", + "abstract": "As microprocessor speeds increase, memory bandwidth is increasingly the performance bottleneck for microprocessors. This has occurred because innovation and technological improvements in processor design have outpaced advances in memory design. Most attempts at addressing this problem have involved hardware solutions. Unfortunately, these solutions do little to help the situation with respect to current microprocessors. In previous work, we developed, implemented, and evaluated an algorithm that exploited the ability of newer machines with wide-buses to load/store multiple floating-point operands in a single memory reference. This paper describes a general code improvement algorithm that transforms code to better exploit the available memory bandwidth on existing microprocessors as well as wide-bus machines. Where possible and advantageous, the algorithm coalesces narrow memory references into wide ones. An interesting characteristic of the algorithm is that some decisions about the applicability of the transformation are made at run time. This dynamic analysis significantly increases the probability of the transformation being applied. The code improvement transformation was implemented and added to the repertoire of code improvements of an existing retargetable optimizing back end. Using three current architectures as evaluation platforms, the effectiveness of the transformation was measured on a set of compute- and memory-intensive programs. Interestingly, the effectiveness of the transformation varied significantly with respect to the instruction-set architecture of the tested platform. For one of the tested architectures, improvements in execution speed ranging from 5 to 40 percent were observed. For another, the improvements in execution speed ranged from 5 to 20 percent, while for yet another, the transformation resulted in slower code for all programs.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178259", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jack W.", + "last_name": "Davidson", + "institution": "University of Virginia" + }, + { + "first_name": "Sanjay", + "last_name": "Jinturkar", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/pldi/DavidsonJ94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178456", + "title": "On Slicing Programs with Jump Statements", + "abstract": "Program slices have potential uses in many software engineering applications. Traditional slicing algorithms, however, do not work correctly on programs that contain explicit jump statements. Two similar algorithms were proposed recently to alleviate this problem. Both require the flowgraph and the program dependence graph of the program to be modified. In this paper, we propose an alternative algorithm that leaves these graphs intact and uses a separate graph to store the additional required information. We also show that this algorithm permits an extremely efficient, conservative adaptation for use with programs that contain only “structured” jump statements.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178456", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hiralal", + "last_name": "Agrawal", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Agrawal94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178245", + "title": "Separate Compilation for Standard ML", + "abstract": "Languages that support abstraction and modular structure, such as Standard ML, Modula, Ada, and (more or less) C++, may have deeply nested dependency hierarchies among source files. In ML the problem is particularly severe because ML's powerful parameterized module (functor) facility entails dependencies among implementation modules, not just among interfaces.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178245", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "MacQueen", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/AppelM94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178257", + "title": "Effective Partial Redundancy Elimination", + "abstract": "Partial redundancy elimination is a code optimization with a long history of literature and implementation. In practice, its effectiveness depends on issues of naming and code shape. This paper shows that a combination of global reassociation and global value numbering can increase the effectiveness of partial redundancy elimination. By imposing a discipline on the choice of names and the shape of expressions, we are able to expose more redundancies.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178257", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Preston", + "last_name": "Briggs", + "institution": "Rice University" + }, + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/BriggsC94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178253", + "title": "GIVE-N-TAKE - A Balanced Code Placement Framework", + "abstract": "GIVE-N-TAKE is a code placement framework which uses a general producer-consumer concept. An advantage of GIVE-N-TAKE over existing partial redundancy elimination techniques is its concept of production regions, instead of single locations, which can be beneficial for general latency hiding. GIVE-N-TAKE guaranteed balanced production, that is, each production will be started and stopped once. The framework can also take advantage of production coming “for free,” as induced by side effects, without disturbing balance. GIVE-N-TAKE can place production either before or after consumption, and it also provides the option to hoist code out of potentially zero-trip loop (nest) constructs. GIVE-N-TAKE uses a fast elimination method based on Tarjan intervals, with a complexity linear in the program size in most cases.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178253", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Reinhard von", + "last_name": "Hanxleden", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/HanxledenK94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178249", + "title": "Division by Invariant Integers using Multiplication", + "abstract": "Integer division remains expensive on today's processors as the cost of integer multiplication declines. We present code sequences for division by arbitrary nonzero integer constants and run-time invariants using integer multiplication. The algorithms assume a two's complement architecture. Most also require that the upper half of an integer product be quickly accessible. We treat unsigned division, signed division where the quotient rounds towards zero, signed division where the quotient rounds towards -∞, and division where the result is known a priori to be exact. We give some implementation results using the C compiler GCC.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178249", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Torbjörn", + "last_name": "Granlund", + "institution": "Cygnus (United States)" + }, + { + "first_name": "Peter L.", + "last_name": "Montgomery", + "institution": "" + } + ], + "dblp_key": "conf/pldi/GranlundM94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178264", + "title": "Context-Sensitive Interprocedural Points-to Analysis in the Presence of Function Pointers", + "abstract": "This paper reports on the design, implementation, and empirical results of a new method for dealing with the aliasing problem in C. The method is based on approximating the points-to relationships between accessible stack locations, and can be used to generate alias pairs, or used directly for other analyses and transformations. Our method provides context-sensitive interprocedural information based on analysis over invocation graphs that capture all calling contexts including recursive and mutually-recursive calling contexts. Furthermore, the method allows the smooth integration for handling general function pointers in C.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178264", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Maryam", + "last_name": "Emami", + "institution": "McGill University" + }, + { + "first_name": "Rakesh", + "last_name": "Ghiya", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/pldi/EmamiGH94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178488", + "title": "Backtracking without Trailing in CLP(RLin)", + "abstract": "Constraint logic programming (CLP) is a generalization of logic programming where unification is replaced by constraint solving as the basic operation of the language. The combination of constraint solving and nondeterminism (approximated by backtracking) makes these languages appealing for a variety of combinatorial search problems. Existing CLP languages support backtracking by generalizing traditional Prolog implementations: modifications to the constraint system are trailed and restored on backtracking. Although simple and efficient, trailing may be very demanding in memory space, since the constraint system may potentially be saved at each choice point. This paper proposes a fundamentally new implementation scheme for backtracking in CLP languages over linear (rational or real) arithmetic. The new scheme, called semantic backtracking, does not use trailing but rather exploits the semantics of the constraints to undo the effect of newly added constraints. Semantic backtracking reduces the space complexity by an order of magnitude compared to implementations based on trailing and makes space complexity essentially independent of the number of choice points. In addition, semantic backtracking introduces negligible space and time overhead on deterministic programs. The price for this improvement is an increase in backtracking time, although constraint-solving time may actually decrease. The scheme has been implemented as part of a complete CLP system CLP(RLin) and compared analytically and experimentally with an optimized trailing implementation. Experimental results indicate that semantic backtracking produces significant reduction in memory space, while keeping the time overhead reasonably small.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178488", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pascal Van", + "last_name": "Hentenryck", + "institution": "Butler Hospital" + }, + { + "first_name": "Viswanath", + "last_name": "Ramachandran", + "institution": "Butler Hospital" + } + ], + "dblp_key": "conf/pldi/HentenryckR94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178427", + "title": "register Allocation over the Program Dependence Graph", + "abstract": "This paper describes RAP, a Register Allocator that allocates registers over the Program Dependence Graph (PDG) representation of a program in a hierarchical manner. The PDG program representation has been used successfully for scalar optimizations, the detection and improvement of parallelism for vector machines, multiple processor machines, and machines that exhibit instruction level parallelism, as well as debugging, the integration of different versions of a program, and translation of imperative programs for data flow machines. By basing register allocation on the PDG, the register allocation phase may be more easily integrated and intertwined with other optimization analyses and transformations. In addition, the advantages of a hierarchical approach to global register allocation can be attained without constructing an additional structure used solely for register allocation. Our experimental results have shown that on average, code allocated registers via RAP executed 2.7% faster than code allocated registers via a standard global register allocator.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178427", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cindy", + "last_name": "Norris", + "institution": "University of Delaware" + }, + { + "first_name": "Lori", + "last_name": "Pollock", + "institution": "University of Delaware" + } + ], + "dblp_key": "conf/pldi/NorrisP94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178477", + "title": "Optimal Tracing and Incremental Reexecution for Debugging Long-Running Programs", + "abstract": "Debugging requires execution replay. Locations of bugs are rarely known in advance, so an execution must be repeated over and over to track down bugs. A problem arises with repeated reexecution for long-running programs and programs that have complex interactions with their environment. Replaying long-running programs from the start incurs too much delay. Replaying programs that interact with their environment requires the difficult (and sometimes impossible) task of exactly reproducing this environment (such as the connections over a one-day period to an X server). We solve these problems by incremental checkpointing and replay. By periodically checkpointing parts of the execution''s state, it can be restarted from intermediate points, bounding the delay to replay any part of the execution and allowing parts of the execution to be skipped. We present adaptive tracing strategies that provide bounded-time incremental replay and that are nearly optimal. Our techniques track reads and writes to memory using space-efficient two-level bitvectors. Our implementation on a Sparc 10 traces less than 15 kilobytes/sec for CPU-intensive programs and for interactive programs the slowdown is low enough that tracing can be left on all the time.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178477", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert H. B.", + "last_name": "Netzer", + "institution": "Brown University" + }, + { + "first_name": "Mark H.", + "last_name": "Weaver", + "institution": "Brown University" + } + ], + "dblp_key": "conf/pldi/NetzerW94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178256", + "title": "Partial Dead Code Elimination", + "abstract": "A new aggressive algorithm for the elimination of partially dead code is presented, i.e., of code which is only dead on some program paths. Besides being more powerful than the usual approaches to dead code elimination, this algorithm is optimal in the following sense: partially dead code remaining in the resulting program cannot be eliminated without changing the branching structure or the semantics of the program, or without impairing some program executions.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178256", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jens", + "last_name": "Knoop", + "institution": "University of Passau" + }, + { + "first_name": "Oliver", + "last_name": "Rüthing", + "institution": "" + }, + { + "first_name": "Bernhard", + "last_name": "Steffen", + "institution": "University of Passau" + } + ], + "dblp_key": "conf/pldi/KnoopRS94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178248", + "title": "Link-Time Optimization of Address Calculation on a 64-bit Architecture", + "abstract": "Compilers for new machines with 64-bit addresses must generate code that works when the memory used by the program is large. Procedures and global variables are accessed indirectly via global address tables, and calling conventions include code to establish the addressability of the appropriate tables. In the common case of a program that does not require a lot of memory, all of this can be simplified considerably, with a corresponding reduction in program size and execution time. We have used our link-time code modification system OM to perform program transformations related to global address use on the Alpha AXP. Though simple, many of these are whole-program optimizations that can be done only when we can see the entire program at once, so link-time is an ideal occasion to perform them. This paper describes the optimizations performed and shows their effects on program size and performance. Relatively modest transformations, possible without moving code, improve the p...", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178248", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amitabh", + "last_name": "Srivastava", + "institution": "" + }, + { + "first_name": "David W.", + "last_name": "Wall", + "institution": "" + } + ], + "dblp_key": "conf/pldi/SrivastavaW94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178420", + "title": "Zero-cost Range Splitting", + "abstract": "This paper presents a new optimization technique that uses empty delay slots to improve code scheduling. We are able to split live ranges for free, by inserting spill code into empty delay slots. Splitting a live range can reduce interferences with other live ranges and can sometimes free registers. Live ranges no longer interfering with the split live range can sometimes make use of the extra register.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178420", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven M.", + "last_name": "Kurlander", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Charles N.", + "last_name": "Fischer", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/KurlanderF94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178251", + "title": "Accurate Static Estimators for Program Optimization", + "abstract": "Determining the relative execution frequency of program regions is essential for many important optimization techniques, including register allocation, function inlining, and instruction scheduling. Estimates derived from profiling with sample inputs are generally regarded as the most accurate source of this information; static (compile-time) estimates are considered to be distinctly inferior. If static estimates were shown to be competitive, however, their convenience would outweigh minor gains from profiling, and they would provide a sound basis for optimization when profiling is impossible.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178251", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tim A.", + "last_name": "Wagner", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Vance", + "last_name": "Maverick", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Michael A.", + "last_name": "Harrison", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/WagnerMGH94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178260", + "title": "ATOM - A System for Building Customized Program Analysis Tools", + "abstract": "ATOM (Analysis Tools with OM) is a single framework for building a wide range of customized program analysis tools. It provides the common infrastructure present in all code-instrumenting tools; this is the difficult and time-consuming part. The user simply defines the tool-specific details in instrumentation and analysis routines. Building a basic block counting tool like Pixie with ATOM requires only a page of code.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178260", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amitabh", + "last_name": "Srivastava", + "institution": "" + }, + { + "first_name": "Alan", + "last_name": "Eustace", + "institution": "" + } + ], + "dblp_key": "conf/pldi/SrivastavaE94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178254", + "title": "Counting Solutions to Presburger Formulas: How and Why", + "abstract": "We describe methods that are able to count the number of integer solutions to selected free variables of a Presburger formula, or sum a polynomial over all integer solutions of selected free variables of a Presburger formula. This answer is given symbolically, in terms of symbolic constants (the remaining free variables in the Presburger formula).For example, we can create a Presburger formula who's solutions correspond to the iterations of a loop. By counting these, we obtain an estimate of the execution time of the loop.In more complicated applications, we can create Presburger formulas who's solutions correspond to the distinct memory locations or cache lines touched by a loop, the flops executed by a loop, or the array elements that need to be communicated at a particular point in a distributed computation. By counting the number of solutions, we can evaluate the computation/memory balance of a computation, determine if a loop is load balanced and evaluate message traffic and allocate message buffers.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178254", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Pugh", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/Pugh94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178430", + "title": "Debugging of Globally Optimized Programs Using Data Flow Analysis", + "abstract": "Advanced processor and machine architectures need optimizing compilers to be efficiently programmed in high level languages. Therefore the need for source level debuggers that can handle optimized programs is rising. One difficulty in debugging optimized code arises from the problem to determine the values of source code variables. To ensure correct debugger behaviour with optimized programs, the debugger not only has to determine the variable's storage location or associated register. It must also verify that the variable is current, i.e. the value determined from that location is really the value that the variable would have in unoptimized code. We will deduce requirements on algorithms for currentness determination and present an algorithm meeting this requirements that is more general than previous work. We will also give first experiences with an implementation. To our knowledge this is the first implementation of a currentness determination algorithm for globally optimized code.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178430", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Roland", + "last_name": "Wismüller", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Wismuller94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178244", + "title": "Is Continuation-Passing Useful for Data Flow Analysis?", + "abstract": "The widespread use of the continuation-passing style (CPS) transformation in compilers, optimizers, abstract interpreters, and partial evaluators reflects a common belief that the transformation has a positive effect on the analysis of programs. Investigations by Nielson [13] and Burn/Filho [5,6] support, to some degree, this belief with theoretical results. However, they do not pinpoint the source of increased abstract information and do not explain the observation of many people that continuation-passing confuses some conventional data flow analyses.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178244", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/SabryF94", + "venue": "pldi", + "year": 1994 + }, + { + "paper_id": "10.1145/178243.178250", + "title": "Precise Compile-Time Performance Prediction for Superscalar-Based Computers", + "abstract": "Optimizing compilers (particularly parallel compilers) are constrained by their ability to predict performance consequences of the transformations they apply. Many factors, such as unknowns in control structures, dynamic behavior of programs, and complexity of the underlying hardware, make it very difficult for compilers to estimate the performance of the transformations accurately and efficiently. In this paper, we present a performance prediction framework that combines several innovative approaches to solve this problem. First, the framework employs a detailed, architecture-specific, but portable, cost model that can be used to estimate the cost of straight line code efficiently. Second, aggregated costs of loops and conditional statements are computed and represented symbolically. This avoids unnecessary, premature guesses and preserves the precision of the prediction. Third, symbolic comparison allows compilers to choose the best transformation dynamically and systematically. Some methodologies for applying the framework to optimizing parallel compilers to support automatic, performance-guided program restructuring are discussed.", + "date": "1994-06-01", + "link": "https://doi.org/10.1145/178243.178250", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ko‐Yang", + "last_name": "Wang", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/Wang94", + "venue": "pldi", + "year": 1994 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1995.json b/data/pl_conferences/pldi/1995.json new file mode 100644 index 0000000..15c578f --- /dev/null +++ b/data/pl_conferences/pldi/1995.json @@ -0,0 +1,691 @@ +[ + { + "paper_id": "10.1145/207110.207150", + "title": "The Power of Assignment Motion", + "abstract": "Assignment motion (AM) and expression motion (EM) are the basis of powerful and at the first sight incomparable techniques for removing partially redundant code from a program. Whereas AM aims at the elimination of complete assignments, a transformation which is always desirable, the more flexible EM requires temporaries to remove partial redundancies. Based on the observation that a simple program transformation enhances AM to subsume EM, we develop an algorithm that for the first time captures all second order effects between AM and EM transformations. Under usual structural restrictions, the worst case time complexity of our algorithm is essentially quadratic, a fact which explains the promising experience with our implementation. Topics: data flow analysis, program optimization, partially redundant assignment and expression elimination, code motion, assignment motion, bit-vector data flow analyses. 1 Motivation A major source for improving the runtime efficiency of a program is...", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207150", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jens", + "last_name": "Knoop", + "institution": "University of Passau" + }, + { + "first_name": "Oliver", + "last_name": "Rüthing", + "institution": "Kiel University" + }, + { + "first_name": "Bernhard", + "last_name": "Steffen", + "institution": "University of Passau" + } + ], + "dblp_key": "conf/pldi/KnoopRS95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207119", + "title": "Selective Specialization for Object-Oriented Languages", + "abstract": "Dynamic dispatching is a major source of run-time overhead in object-oriented languages, due both to the direct cost of method lookup and to the indirect effect of preventing other optimizations. To reduce this overhead, optimizing compilers for object-oriented languages analyze the classes of objects stored in program variables, with the goal of bounding the possible classes of message receivers enough so that the compiler can uniquely determine the target of a message send at compile time and replace the message send with a direct procedure call. Specialization is one important technique for improving the precision of this static class information: by compiling multiple versions of a method, each applicable to a subset of the possible argument classes of the method, more precise static information about the classes of the method's arguments is obtained. Previous specialization strategies have not been selective about where this technique is applied, and therefore tended to significantly increase compile time and code space usage, particularly for large applications. In this paper, we present a more general framework for specialization in object-oriented languages and describe a goal directed specialization algorithm that makes selective decisions to apply specialization to those cases where it provides the highest benefit. Our results show that our algorithm improves the performance of a group of sizeable programs by 65% to 275% while increasing compiled code space requirements by only 4% to 10%. Moreover, when compared to the previous state-of-the-art specialization scheme, our algorithm improves performance by 11% to 67% while simultaneously reducing code space requirements by 65% to 73%.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207119", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeffrey A.", + "last_name": "Dean", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Grove", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/DeanCG95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207121", + "title": "Simple and Effective Link-Time Optimization of Modula-3 Programs", + "abstract": "Modula-3 supports development of modular programs by separating an object's interface from its implementation. This separation induces a runtime overhead in the implementation of objects, because it prevents the compiler from having complete information about a program's type hierarchy. This overhead can be reduced at link time, when the entire type hierarchy becomes available. We describe opportunities for link-time optimization of Modula-3, present two link-time optimizations that reduce the runtime costs of Modula-3's opaque types and methods, and show how link-time optimization could provide C++ which the benefits of opaques types at no additional runtime cost.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207121", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mary", + "last_name": "Fernández", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/Fernandez95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207164", + "title": "Garbage Collection Using a Dynamic Threatening Boundary", + "abstract": "Generational techniques have been very successful in reducing the impact of garbage collection algorithms upon the performance of programs. However, all generational algorithms occasionally promote objects that later become garbage, resulting in an accumulation of garbage in older generations. Reclaiming this tenured garbage without resorting to collecting the entire heap is a difficult problem. In this paper, we describe a mechanism that extends existing generational collection algorithms by allowing them to reclaim tenured garbage more effectively. In particular, our dynamic threatening boundary mechanism divides memory into two spaces, one for shortlived, and another for long-lived objects. Unlike previous work, our collection mechanism can dynamically adjust the boundary between these two spaces either forward or backward in time, essentially allowing data to become untenured. We describe an implementation of the dynamic threatening boundary mechanism and quantify its associated costs. We also describe a policy for setting the threatening boundary and evaluate its performance relative to existing generational collection algorithms. Our results show that a policy that uses the dynamic threatening boundary mechanism is effective at reclaiming tenured garbage.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207164", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David A.", + "last_name": "Barrett", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/pldi/BarrettZ95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207145", + "title": "Unifying Data and Control Transformations for Distributed Shared Memory Machines", + "abstract": "We present a unified approach to locality optimization that employs both data and control transformations. Data transformations include changing the array layout in memory. Control transformations involve changing the execution order of programs. We have developed new techniques for compiler optimizations for distributed shared-memory machines, although the same techniques can be used for sequential machines with a memory hierarchy.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207145", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michał", + "last_name": "Cierniak", + "institution": "University of Rochester" + }, + { + "first_name": "Wei", + "last_name": "Li", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/pldi/CierniakL95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207125", + "title": "Register Allocation Using Lazy Saves, Eager Restores, and Greedy Shuffling", + "abstract": "This paper presents a fast and effective linear intraprocedural register allocation strategy that optimizes register usage across procedure calls. It capitalizes on our observation that while procedures that do not contain calls (syntactic leaf routines) account for under one third of all procedure activations, procedures that actually make no calls (effective leaf routines) account for over two thirds of all procedure activations. Well-suited for both caller-and calle-save registers, our strategy employs a “lazy” save mechanism that avoids saves for all effective leaf routines, an “eager” restore mechanism that reduces the effect of memory latency, and a “greedy” register shuffling algorithm that does a remarkbly good job of minimizing the need for temporaries in setting up procedure calls.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207125", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert G.", + "last_name": "Burger", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Oscar", + "last_name": "Waddell", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/pldi/BurgerWD95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207157", + "title": "Interprocedural Partial Redundancy Elimination and its Application to Distributed Memory Compilation", + "abstract": "Partial Redundancy Elimination (PRE) is a general scheme for suppressing partial redundancies which encompasses traditional optimizations like loop invariant code motion and redundant code elimination. In this paper we address the problem of performing this optimization interprocedurally. We use interprocedural partial redundancy elimination for placement of communication and communication preprocessing statements while compiling for distributed memory parallel machines.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207157", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gagan", + "last_name": "Agrawal", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Joel", + "last_name": "Saltz", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Raja", + "last_name": "Das", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/AgrawalSD95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207165", + "title": "Stack Caching for Interpreters", + "abstract": "An interpreter can spend a significant part of its execution time on accessing arguments of virtual machine instructions. This paper explores two methods to reduce this overhead for virtual stack machines by caching top-of-stack values in (real machine) registers. The dynamic method is based on having, for every possible state of the cache, one specialized version of the whole interpreter; the execution of an instruction usually changes the state of the cache and the next instruction is executed in the version corresponding to the new state. In the static method a state machine that keeps track of the cache state is added to the compiler. Common instructions exist in specialized versions for several states, but it is not necessary to have a version of every instruction for every cache state. Stack manipulation instructions are optimized away.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207165", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "M. Anton", + "last_name": "Ertl", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/pldi/Ertl95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207113", + "title": "Flow-Sensitive Interprocedural Constant Propagation", + "abstract": "We present a flow-sensitive interprocedural constant propagation algorithm, which supports recursion while only performing one flow-sensitive analysis of each procedure. We present experimental results which show that this method finds substantially more constants than previous methods and is efficient in practice. We introduce new metrics for evaluating interprocedural constant propagation algorithms which measure the number of interprocedural constant values that are propagated. We use these metrics to provide further experimental results for our algorithm.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207113", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Paul", + "last_name": "Carini", + "institution": "IBM (United States)" + }, + { + "first_name": "Michael", + "last_name": "Hind", + "institution": "SUNY New Paltz" + } + ], + "dblp_key": "conf/pldi/CariniH95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207154", + "title": "Global Code Motion / Global Value Mumbering", + "abstract": "We believe that optimizing compilers should treat the machine-independent optimizations (e.g., conditional constant propagation, global value numbering) and code motion issues separately.’ Removing the code motion requirements from the machine-independent optimization allows stronger optimizations using simpler algorithms. Preserving a legal schedule is one of the prime sources of complexity in algorithms like PRE [18, 13] or global congruence finding [2, 20].", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207154", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cliff", + "last_name": "Click", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/Click95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207114", + "title": "APT: A Data Structure for Optimal Control Dependence Computation", + "abstract": "The control dependence relation is used extensively in restructuring compilers. This relation is usually represented using the control dependence graph; unfortunately, the size of this data structure can be quadratic in the size of the program, even for some structured programs. In this paper, we introduce a data structure called the augmented post-dominator tree (APT) which is constructed in space and time proportional to the size of the program, and which can answer control dependence queries in time proportional to the size of the output. Therefore, APT is an optimal representation of control dependence. We also show that using APT, we can compute SSA graphs, as well as sparse dataflow evaluator graphs, in time proportional to the size of the program. Finally, we put APT in perspective by showing that it can be viewed as a factored representation of control dependence graph in which filtered search is used to answer queries.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207114", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "Cornell University" + }, + { + "first_name": "Gianfranco", + "last_name": "Bilardi", + "institution": "University of Padua" + } + ], + "dblp_key": "conf/pldi/PingaliB95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207162", + "title": "Tile Size Selection Using Cache Organization and Data Layout", + "abstract": "When dense matrix computations are too large to fit in cache, previous research proposes tiling to reduce or eliminate capacity misses. This paper presents a new algorithm for choosing problem-size dependent tile sizes based on the cache size and cache line size for a direct-mapped cache. The algorithm eliminates both capacity and self-interference misses and reduces cross-interference misses. We measured simulated miss rates and execution times for our algorithm and two others on a variety of problem sizes and cache organizations. At higher set associativity, our algorithm does not always achieve the best performance. However on direct-mapped caches, our algorithm improves simulated miss rates and measured execution times when compared with previous work.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207162", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Coleman", + "institution": "" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/ColemanM95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207132", + "title": "Improving Balanced Scheduling with Compiler Optimizations that Increase Instruction-Level Parallelism", + "abstract": "Traditional list schedulers order instructions based on an optimistic estimate of the load latency imposed by the hardware and therefore cannot respond to variations in memory latency caused by cache hits and misses on non-blocking architectures. In contrast, balanced scheduling schedules instructions based on an estimate of the amount of instruction-level parallelism in the program. By scheduling independent instructions behind loads based on what the program can provide, rather than what the implementation stipulates in the best case (i.e., a cache hit), balanced scheduling can hide variations in memory latencies more effectively.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207132", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jack", + "last_name": "Lo", + "institution": "University of Washington" + }, + { + "first_name": "Susan J.", + "last_name": "Eggers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/LoE95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207160", + "title": "Elimination of Redundant Array Subscript Range Checks", + "abstract": "This paper presents a compiler optimization algorithm to reduce the run time overhead of array subscript range checks in programs without compromising safety. The algorithm is based on partial redundancy elimination and it incorporates previously developed algorithms for range check optimization. We implemented the algorithm in our research compiler, Nascent, and conducted experiments on a suite of 10 benchmark programs to obtain four results: (1) the execution overhead of naive range checking is high enough to merit optimization, (2) there are substantial differences between various optimizations, (3) loop-based optimizations that hoist checks out of loops are effective in eliminating about 98% of the range checks, and (4) more sophisticated analysis and optimization algorithms produce very marginal benefits.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207160", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Priyadarshan", + "last_name": "Kolte", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "Michael", + "last_name": "Wolfe", + "institution": "Oregon Museum of Science and Industry" + } + ], + "dblp_key": "conf/pldi/KolteW95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207134", + "title": "Implementation of the Data-Flow Synchronous Language SIGNAL", + "abstract": "This paper presents the techniques used for the compilation of the data-flow, synchronous language SIGNAL. The key feature of the compiler is that it performs formal calculus on systems of boolean equations. The originality of the implementation of the compiler lies in the use of a tree structure to solve the equations.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207134", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pascalin", + "last_name": "Amagbégnon", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Loïc", + "last_name": "Besnard", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Paul Le", + "last_name": "Guernic", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/AmagbegnonBG95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207128", + "title": "Scheduling and Mapping: Software Pipelining in the Presence of Structural Hazards", + "abstract": "Recently, software pipelining methods based on an ILP (Integer Linear Programming) framework have been successfully applied to derive rate-optimal schedules for architectures involving clean pipelines - pipelines without structural hazards. The problem for architectures beyond such clean pipelines remains open. One challenge is how, under a unified ILP framework, to simultaneously represent resource constraints for unclean pipelines, and the assignment or mapping of operations from a loop to those pipelines. In this paper we provide a framework which does exactly this, and in addition constructs rate-optimal software pipelined schedules. The proposed formulation and a solution method have been implemented and tested on a set of 1006 loops taken from various scientific and integer benchmark suites. The formulation found a rate-optimal schedule for 75% of the loops, and required a median time of only 2 seconds per loop on a Sparc 10/30.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207128", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Erik", + "last_name": "Altman", + "institution": "McGill University" + }, + { + "first_name": "R.", + "last_name": "Govindarajan", + "institution": "Memorial University of Newfoundland" + }, + { + "first_name": "Guang R.", + "last_name": "Gao", + "institution": "McGill University" + } + ], + "dblp_key": "conf/pldi/AltmanGG95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207137", + "title": "Better Static Memory Management: Improving Region-Based Analysis of Higher-Order Languages", + "abstract": "Static memory management replaces runtime garbage collection with compile-time annotations that make all memory allocation and deallocation explicit in a program. We improve upon the Tofte/Talpin region-based scheme for compile-time memory management[TT94]. In the Tofte/Talpin approach, all values, including closures, are stored in regions. Region lifetimes coincide with lexical scope, thus forming a runtime stack of regions and eliminating the need for garbage collection. We relax the requirement that region lifetimes be lexical. Rather, regions are allocated late and deallocated as early as possible by explicit memory operations. The placement of allocation and deallocation annotations is determined by solving a system of constraints that expresses all possible annotations. Experiments show that our approach reduces memory requirements significantly, in some cases asymptotically.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207137", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Raph", + "last_name": "Levien", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/AikenFL95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207118", + "title": "Corpus-Based Static Branch Prediction", + "abstract": "Correctly predicting the direction that branches will take is increasingly important in today's wide-issue computer architectures. The name program-based branch prediction is given to static branch prediction techniques that base their prediction on a program's structure. In this paper, we investigate a new approach to program-based branch prediction that uses a body of existing programs to predict the branch behavior in a new program. We call this approach to program-based branch prediction, evidence-based static prediction, or ESP. The main idea of ESP is that the behavior of a corpus of programs can be used to infer the behavior of new programs. In this paper, we use a neural network to map static features associated with each branch to the probability that the branch will be taken. ESP shows significant advantages over other prediction mechanisms. Specifically, it is a program-based technique, it is effective across a range of programming languages and programming styles, and it does not rely on the use of expert-defined heuristics.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207118", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brad", + "last_name": "Calder", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Dirk", + "last_name": "Grunwald", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Donald", + "last_name": "Lindsay", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "James", + "last_name": "Martin", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Michael C.", + "last_name": "Mozer", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/pldi/CalderGLMMZ95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207139", + "title": "Storage Assignment to Decrease Code Size", + "abstract": "DSP architectures typically provide indirect addressing modes with auto-increment and decrement. In addition, indexing mode is not available, and there are usually few, if any, general-purpose registers. Hence, it is necessary to use address registers and perform address arithmetic to access automatic variables. Subsuming the address arithmetic into auto-increment and auto-decrement modes improves the size of the generated code.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207139", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stan", + "last_name": "Liao", + "institution": "IIT@MIT" + }, + { + "first_name": "Srinivas", + "last_name": "Devadas", + "institution": "IIT@MIT" + }, + { + "first_name": "Kurt", + "last_name": "Keutzer", + "institution": "Synopsys (Switzerland)" + }, + { + "first_name": "Steve", + "last_name": "Tjiang", + "institution": "Synopsys (Switzerland)" + }, + { + "first_name": "Albert", + "last_name": "Wang", + "institution": "Synopsys (United States)" + } + ], + "dblp_key": "conf/pldi/LiaoDKTW95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207142", + "title": "Optimizing Parallel Programs with Explicit Synchronization", + "abstract": "We present compiler analyses and optimizations for explicitly parallel programs that communicate through a shared address space. Any type of code motion on explicitly parallel programs requires a new kind of analysis to ensure that operations reordered on one processor cannot be observed by another. The analysis, based on work by Shasha and Snir, checks for cycles among interfering accesses. We improve the accuracy of their analysis by using additional information from post-wait synchronization, barriers, and locks.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207142", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Arvind", + "last_name": "Krishnamurthy", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Katherine", + "last_name": "Yelick", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/KrishnamurthyY95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207111", + "title": "Efficient Context-Sensitive Pointer Analysis for C Programs", + "abstract": "This paper proposes an efficient technique for context-sensitive pointer analysis that is applicable to real C programs. For efficiency, we summarize the effects of procedures using partial transfer functions. A partial transfer function (PTF) describes the behavior of a procedure assuming that certain alias relationships hold when it is called. We can reuse a PTF in many calling contexts as long as the aliases among the inputs to the procedure are the same. Our empirical results demonstrate that this technique is successful—a single PTF per procedure is usually sufficient to obtain completely context-sensitive results. Because many C programs use features such as type casts and pointer arithmetic to circumvent the high-level type system, our algorithm is based on a low-level representation of memory locations that safely handles all the features of C. We have implemented our algorithm in the SUIF compiler system and we show that it runs efficiently for a set of C benchmarks.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207111", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert P.", + "last_name": "Wilson", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/WilsonL95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207117", + "title": "Accurate Static Branch Prediction by Value Range Propagation", + "abstract": "The ability to predict at compile time the likelihood of a particular branch being taken provides valuable information for several optimizations, including global instruction scheduling, code layout, function inlining, interprocedural register allocation and many high level optimizations. Previous attempts at static branch prediction have either used simple heuristics, which can be quite inaccurate, or put the burden onto the programmer by using execution profiling data or source code hints. This paper presents a new approach to static branch prediction called value range propagation. This method tracks the weighted value ranges of variables through a program, much like constant propagation. These value ranges may be either numeric or symbolic in nature. Branch prediction is then performed by simply consulting the value range of the appropriate variable. Heuristics are used as a fallback for cases where the value range of the variable cannot be determined statically. In the process, va...", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207117", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jason R. C.", + "last_name": "Patterson", + "institution": "Queensland University of Technology" + } + ], + "dblp_key": "conf/pldi/Patterson95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207112", + "title": "Context-Insensitive Alias Analysis Reconsidered", + "abstract": "Recent work on alias analysis in the presence of pointers has concentrated on context-sensitive interprocedural analyses, which treat multiple calls to a single procedure independently rather than constructing a single approximation to a procedure's effect on all of its callers. While context-sensitive modeling offers the potential for greater precision by considering only realizable call-return paths, its empirical benefits have yet to be measured.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207112", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Erik", + "last_name": "Ruf", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Ruf95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207123", + "title": "A Type-Based Compiler for Standard ML", + "abstract": "Compile-time type information should be valuable in efficient compilation of statically typed functional languages such as Standard ML. But how should type-directed compilation work in real compilers, and how much performance gain will type-based optimizations yield? In order to support more efficient data representations and gain more experience about type-directed compilation, we have implemented a new type-based middle end and back end for the Standard ML of New Jersey compiler. We describe the basic design of the new compiler, identify a number of practical issues, and then compare the performance of our new compiler with the old non-type-based compiler. Our measurement shows that a combination of several simple type-based optimizations reduces heap allocation by 36%; and improves the already-efficient code generated by the old non-type-based compiler by about 19% on a DECstation 500.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207123", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/ShaoA95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207163", + "title": "EEL: Machine-Independent Executable Editing", + "abstract": "EEL (Executable Editing Library) is a library for building tools to analyze and modify an executable (compiled) program. The systems and languages communities have built many tools for error detection, fault isolation, architecture translation, performance measurement, simulation, and optimization using this approach of modifying executables. Currently, however, tools of this sort are difficult and time-consuming to write and are usually closely tied to a particular machine and operating system. EEL supports a machine- and system-independent editing model that enables tool builders to modify an executable without being aware of the details of the underlying architecture or operating system or being concerned with the consequences of deleting instructions or adding foreign code.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207163", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Eric", + "last_name": "Schnarr", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/LarusS95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207116", + "title": "Avoiding Conditional Branches by Code Replication", + "abstract": "On-chip instruction caches are increasing in size. Compiler writers are exploiting this fact by applying a variety of optimization that improve the execution performance of a program at the expense of increasing its code size. This paper describes a new optimization that can be used to avoid conditional branches by replicating code. The central idea is to determine if there are paths where the result of a conditional branch will be known and to replicate code to exploit it. Algorithms are described for detecting when branches are avoidable, for restructuring the control flow to avoid these branches, and for positioning the replicated blocks in the restructured code. The results indicate that the optimization can be frequently applied with reductions in both the number of instructions executed and total instruction cache work.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207116", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Frank", + "last_name": "Mueller", + "institution": "Humboldt-Universität zu Berlin" + }, + { + "first_name": "David", + "last_name": "Whalley", + "institution": "Florida State University" + } + ], + "dblp_key": "conf/pldi/MuellerW95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207148", + "title": "The LRPD Test: Speculative Run-Time Parallelization of Loops with Privatization and Reduction Parallelization", + "abstract": "Current parallelizing compilers cannot identify a significant fraction of parallelizable loops because they have complex or statically insufficiently defined access patterns. As parallelizable loops arise frequently in practice, we advocate a novel framework for their identification: speculatively execute the loop as a doall, and apply a fully parallel data dependence test to determine if it had any cross-iteration dependences; if the test fails, then the loop is re-executed serially. Since, from our experience, a significant amount of the available parallelism in Fortran programs can be exploited by loops transformed through privatization and reduction parallelization, our methods can speculatively apply these transformations and then check their validity at run-time. Another important contribution of this paper is a novel method for reduction recognition which goes beyond syntactic pattern matching; it detects at run-time if the values stored in an array participate in a reduction operation, even if they are transferred through private variables and/or are affected by statically unpredictable control flow. We present experimental results on loops from the PERFECT Benchmarks which substantiate our claim that these techniques can yield significant speedups which are often superior to those obtainable by inspector/executor methods.", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207148", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lawrence", + "last_name": "Rauchwerger", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/RauchwergerP95", + "venue": "pldi", + "year": 1995 + }, + { + "paper_id": "10.1145/207110.207115", + "title": "Efficient Building and Placing of Gating Functions", + "abstract": "this paper, we present an almost linear time algorithm to construct the GSA. The new algorithm is more efficient and simpler than the existing algorithms for GSA construction [BMO90, Hav93]. Since SSA is a special case of GSA, it can also be used as an efficient alternative algorithm for SSA construction. The existing algorithms for building the GSA follow two steps. The first step is the same", + "date": "1995-06-01", + "link": "https://doi.org/10.1145/207110.207115", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peng", + "last_name": "Tu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/TuP95", + "venue": "pldi", + "year": 1995 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1996.json b/data/pl_conferences/pldi/1996.json new file mode 100644 index 0000000..45e98ae --- /dev/null +++ b/data/pl_conferences/pldi/1996.json @@ -0,0 +1,731 @@ +[ + { + "paper_id": "10.1145/231379.231389", + "title": "Static Detection of Dynamic Memory Errors", + "abstract": "Many important classes of bugs result from invalid assumptions about the results of functions and the values of parameters and global variables. Using traditional methods, these bugs cannot be detected efficiently at compile-time, since detailed cross-procedural analyses would be required to determine the relevant assumptions. In this work, we introduce annotations to make certain assumptions explicit at interface points. An efficient static checking tool that exploits these annotations can detect a broad class of errors including misuses of null pointers, uses of dead storage, memory leaks, and dangerous aliasing. This technique has been used successfully to fix memory management problems in a large program.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231389", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Evans", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Evans96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231435", + "title": "Generalized Dominance and Control Dependence", + "abstract": "We generalize the notion of dominance by defining a generalized dominance relation with respect to a set of paths in the control flow graph G = (V, E). This new definition leads to a generalized notion of control dependence, which includes standard control dependence and weak control dependence as special cases.If the set of paths underlying a generalized dominance relation satisfies some natural closure conditions, that dominance relation is tree-structured. Given this tree, the corresponding control dependence relation can be computed optimally by reduction to the Roman Chariots Problem, which we have developed previously for computing standard control dependence. More precisely, given linear preprocessing time and space, we can answer the (generalized version of the) so called cd, conds, and cdequiv queries in time proportional to the output of the query.To illustrate the utility of the framework, we show how weak control dependence can be computed optimally in O(|E|) preprocessing space and time. This improves the O(|V|3) time required by the best previous algorithm for this problem.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231435", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gianfranco", + "last_name": "Bilardi", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/BilardiP96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231399", + "title": "Practical Program Analysis Using General Purpose Logic Programming Systems - A Case Study", + "abstract": "Many analysis problems can be cast in the form of evaluating minimal models of a logic program. Although such formulations are appealing due to their simplicity and declarativeness, they have not been widely used in practice because, either existing logic programming systems do not guarantee completeness, or those that do have been viewed as too inefficient for integration into a compiler. The objective of this paper is to re-examine this issue in the context of recent advances in implementation technologies of logic programming systems.We find that such declarative formulations can indeed be used in practical systems, when combined with the appropriate tool for evaluation. We use existing formulations of analysis problems --- groundness analysis of logic programs, and strictness analysis of functional programs --- in this case study, and the XSB system, a table-based logic programming system, as the evaluation tool of choice. We give experimental evidence that the resultant groundness and strictness analysis systems are practical in terms of both time and space. In terms of implementation effort, the analyzers took less than 2 man-weeks (in total), to develop, optimize and evaluate. The analyzer itself consists of about 100 lines of tabled Prolog code and the entire system, including the components to read and preprocess input programs and to collect the analysis results, consists of about 500 lines of code.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231399", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven", + "last_name": "Dawson", + "institution": "SRI International" + }, + { + "first_name": "C. R.", + "last_name": "Ramakrishnan", + "institution": "Stony Brook University" + }, + { + "first_name": "David S.", + "last_name": "Warren", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/pldi/DawsonRW96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231388", + "title": "Source-Level Debugging of Scalar Optimized Code", + "abstract": "Although compiler optimizations play a crucial role in the performance of modern computer systems, debugger technology has lagged behind in its support of optimization. Yet debugging the unoptimized translation is often impossible or futile, so handling of code optimizations in the debugger is necessary. But compiler optimizations make it difficult to provide source-level debugger functionality: Global optimizations can cause the runtime value of a variable to be inconsistent with the source-level value expected at a breakpoint; such variables are called endangered variables. A debugger must detect and warn the user of endangered variables otherwise the user may draw incorrect conclusions about the program. This paper presents a new algorithm for detecting variables that are endangered due to global scalar optimization. Our approach provides more precise classifications of variables and is still simpler than past approaches. We have implemented and evaluated our techniques in the context of the cmcc optimizing C compiler. We describe the compiler extensions necessary to perform the required bookkeeping of compiler optimization. We present measurements of the effect of optimizations on a debugger's ability to present the expected values of variables to the user.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231388", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/Adl-TabatabaiG96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231391", + "title": "Global Communication Analysis and Optimization", + "abstract": "Reducing communication cost is crucial to achieving good performance on scalable parallel machines. This paper presents a new compiler algorithm for global analysis and optimization of communication in data-parallel programs. Our algorithm is distinct from existing approaches in that rather than handling loop-nests and array references one by one, it considers all communication in a procedure and their interactions under different placements before making a final decision on the placement of any communication. It exploits the flexibility resulting from this advanced analysis to eliminate redundancy, reduce the number of messages, and reduce contention for cache and communication buffers, all in a unified framework. In contrast, single loop-nest analysis often retains redundant communication, and more aggressive dataflow analysis on array sections can generate too many messages or cache and buffer contention. The algorithm has been implemented in the IBM pHPF compiler for High Performance Fortran. During compilation, the number of messages per processor goes down by as much as a factor of nine for some HPF programs. We present performance results for the IBM SP2 and a network of Sparc workstations (NOW) connected by a Myrinet switch. In many cases, the communication cost is reduced by a factor of two.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231391", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Soumen", + "last_name": "Chakrabarti", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Manish", + "last_name": "Gupta", + "institution": "IBM (United States)" + }, + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/ChakrabartiGC96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231419", + "title": "Realistic Compilation by Partial Evaluation", + "abstract": "Two key steps in the compilation of strict functional languages are the conversion of higher-order functions to data structures (closures) and the transformation to tail-recursive style. We show how to perform both steps at once by applying first-order offline partial evaluation to a suitable interpreter. The resulting code is easy to transliterate to low-level C or native code. We have implemented the compilation to C; it yields a performance comparable to that of other modern Scheme-to-C compilers. In addition, we have integrated various optimizations such as constant propagation, higher-order removal, and arity raising simply by modifying the underlying interpreter. Purely first-order methods suffice to achieve the transformations. Our approach is an instance of semantics-directed compiler generation.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231419", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Sperber", + "institution": "University of Tübingen" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/pldi/SperberT96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231397", + "title": "Printing Floating-Point Numbers Quickly and Accurately", + "abstract": "This paper presents a fast and accurate algorithm for printing floating-point numbers in both free- and fixed-format modes. In free-format mode, the algorithm generates the shortest, correctly rounded output string that converts to the same number when read back in, accommodating whatever rounding mode the reader uses. In fixed-format mode, the algorithm generates a correctly rounded output string using special # marks to denote insignificant trailing digits. For both modes, the algorithm employs a fast estimator to scale floating-point numbers efficiently.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231397", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert G.", + "last_name": "Burger", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/pldi/BurgerD96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231390", + "title": "Commutativity Analysis: A New Analysis Framework for Parallelizing Compilers", + "abstract": "This paper presents a new analysis technique, commutativity analysis, for automatically parallelizing computations that manipulate dynamic, pointer-based data structures. Commutativity analysis views the computation as composed of operations on objects. It then analyzes the program at this granularity to discover when operations commute (i.e. generate the same final result regardless of the order in which they execute). If all of the operations required to perform a given computation commute, the compiler can automatically generate parallel code.We have implemented a prototype compilation system that uses commutativity analysis as its primary analysis framework. We have used this system to automatically parallelize two complete scientific computations: the Barnes-Hut N-body solver and the Water code. This paper presents performance results for the generated parallel code running on the Stanford DASH machine. These results provide encouraging evidence that commutativity analysis can serve as the basis for a successful parallelizing compiler.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231390", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Pedro C.", + "last_name": "Diniz", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/pldi/RinardD96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231428", + "title": "Data Specialization", + "abstract": "Given a repeated computation, part of whose input context remains invariant across all repetitions, program staging improves performance by separating the computation into two phases. An early phase executes only once, performing computations depending only on invariant inputs, while a late phase repeatedly performs the remainder of the work given the varying inputs and the results of the early computations.Common staging techniques based on dynamic compilation statically construct an early phase that dynamically generates object code customized for a particular input context. In effect, the results of the invariant computations are encoded as the compiled code for the late phase.This paper describes an alternative approach in which the results of early computations are encoded as a data structure, allowing both the early and late phases to be generated statically. By avoiding dynamic code manipulation, we give up some optimization opportunities in exchange for significantly lower dynamic space/time overhead and reduced implementation complexity.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231428", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Todd B.", + "last_name": "Knoblock", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Erik", + "last_name": "Ruf", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/KnoblockR96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231385", + "title": "Software Pipelining Showdown: Optimal vs. Heuristic Methods in a Production Compiler", + "abstract": "This paper is a scientific comparison of two code generation techniques with identical goals --- generation of the best possible software pipelined code for computers with instruction level parallelism. Both are variants of modulo scheduling, a framework for generation of software pipelines pioneered by Rau and Glaser [RaG181], but are otherwise quite dissimilar.One technique was developed at Silicon Graphics and is used in the MIPSpro compiler. This is the production compiler for SGI's systems which are based on the MIPS R8000 processor [Hsu94]. It is essentially a branch--and--bound enumeration of possible schedules with extensive pruning. This method is heuristic because of the way it prunes and also because of the interaction between register allocation and scheduling.The second technique aims to produce optimal results by formulating the scheduling and register allocation problem as an integrated integer linear programming (ILP1) problem. This idea has received much recent exposure in the literature [AlGoGa95, Feautrier94, GoAlGa94a, GoAlGa94b, Eichenberger95], but to our knowledge all previous implementations have been too preliminary for detailed measurement and evaluation. In particular, we believe this to be the first published measurement of runtime performance for ILP based generation of software pipelines.A particularly valuable result of this study was evaluation of the heuristic pipelining technology in the SGI compiler. One of the motivations behind the McGill research was the hope that optimal software pipelining, while not in itself practical for use in production compilers, would be useful for their evaluation and validation. Our comparison has indeed provided a quantitative validation of the SGI compiler's pipeliner, leading us to increased confidence in both techniques.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231385", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John C.", + "last_name": "Ruttenberg", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Guang R.", + "last_name": "Gao", + "institution": "McGill University" + }, + { + "first_name": "Arthur", + "last_name": "Stoutchinin", + "institution": "McGill University" + }, + { + "first_name": "Woody", + "last_name": "Lichtenstein", + "institution": "Silicon Labs (United States)" + } + ], + "dblp_key": "conf/pldi/RuttenbergGLS96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231412", + "title": "Simple Objects for Standard ML", + "abstract": "We propose a new approach to adding objects to Standard ML (SML) based on explicit declarations of object types, object constructors, and subtyping relationships, with a generalization of the SML case statement to a \"typecase\" on object types. The language, called Object ML (OML), has a type system that conservatively extends the SML type system, preserves sound static typing, and permits type inference. The type system sacrifices some of the expressiveness found in recently proposed schemes, but has the virtue of simplicity. We give examples of how features found in other object-oriented languages can be emulated in OML, discuss the formal properties of OML, and describe some implementation issues.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231412", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Reppy", + "institution": "AT&T (United States)" + }, + { + "first_name": "Jon G.", + "last_name": "Riecke", + "institution": "Bell (Canada)" + } + ], + "dblp_key": "conf/pldi/ReppyR96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231409", + "title": "Fast, Effective Dynamic Compilation", + "abstract": "Dynamic compilation enables optimization based on the values of invariant data computed at run-time. Using the values of these run-time constants, a dynamic compiler can eliminate their memory loads, perform constant propagation and folding, remove branches they determine, and fully unroll loops they bound. However, the performance benefits of the more efficient, dynamically-compiled code are offset by the run-time cost of the dynamic compile. Our approach to dynamic compilation strives for both fast dynamic compilation and high-quality dynamically-compiled code: the programmer annotates regions of the programs that should be compiled dynamically; a static, optimizing compiler automatically produces pre-optimized machine-code templates, using a pair of dataflow analyses that identify which variables will be constant at run-time; and a simple, dynamic compiler copies the templates, patching in the computed values of the run-time constants, to produce optimized, executable code. Our work targets general- purpose, imperative programming languages, initially C. Initial experiments applying dynamic compilation to C programs have produced speedups ranging from 1.2 to 1.8.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231409", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joel", + "last_name": "Auslander", + "institution": "University of Washington" + }, + { + "first_name": "Matthai", + "last_name": "Philipose", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + }, + { + "first_name": "Susan J.", + "last_name": "Eggers", + "institution": "University of Washington" + }, + { + "first_name": "Brian N.", + "last_name": "Bershad", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/AuslanderPCEB96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231432", + "title": "Replay For Concurrent Non-Deterministic Shared Memory Applications", + "abstract": "Replay of shared-memory program execution is desirable in many domains including cyclic debugging, fault tolerance and performance monitoring. Past approaches to repeatable execution have focused on the problem of re-executing the shared-memory access patterns in parallel programs. With the proliferation of operating system supported threads and shared memory for uniprocessor programs, there is a clear need for efficient replay of concurrent applications. The solutions for parallel systems can be performance prohibitive when applied to the uniprocessor case. We present an algorithm, called the repeatable scheduling algorithm, combining scheduling and instruction counts to provide an invariant for efficient, language independent replay of concurrent shared-memory applications. The approach is shown to have trace overheads that are independent of the amount of sharing that takes place. An implementation for cyclic debugging on Mach 3.0 is evaluated and benchmarks show typical performance overheads of around 10%. The algorithm implemented is compared with optimal event-based tracing and shown to do better with respect to the number of events monitored or number of events logged, in most cases by several orders of magnitude.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231432", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark", + "last_name": "Russinovich", + "institution": "University of Oregon" + }, + { + "first_name": "Bryce", + "last_name": "Cogswell", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/pldi/RussinovichC96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231430", + "title": "Teapot: Language Support for Writing Memory Coherence Protocols", + "abstract": "Recent shared-memory parallel computer systems offer the exciting possibility of customizing memory coherence protocols to fit an application's semantics and sharing patterns. Custom protocols have been used to achieve message-passing performance---while retaining the convenient programming model of a global address space---and to implement high-level language constructs. Unfortunately, coherence protocols written in a conventional language such as C are difficult to write, debug, understand, or modify. This paper describes Teapot, a small, domain-specific language for writing coherence protocols. Teapot uses continuations to help reduce the complexity of writing protocols. Simple static analysis in the Teapot compiler eliminates much of the overhead of continuations and results in protocols that run nearly as fast as hand-written C code. A Teapot specification can be compiled both to an executable coherence protocol and to input for a model checking system, which permits the specification to be verified. We report our experiences coding and verifying several protocols written in Teapot, along with measurements of the overhead incurred by writing a protocol in a higher-level language.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231430", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Brad", + "last_name": "Richards", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/ChandraRL96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231386", + "title": "A Reduced Multipipeline Machine Description that Preserves Scheduling Constraints", + "abstract": "High performance compilers increasingly rely on accurate modeling of the machine resources to efficiently exploit the instruction level parallelism of an application. In this paper, we propose a reduced machine description that results in faster detection of resource contentions while preserving the scheduling constraints present in the original machine description. The proposed approach reduces a machine description in an automated, error-free, and efficient fashion, Moreover, it fully supports schedulers that backtrack and process operations in arbitrary order. Reduced descriptions for the DEC Alpha 21064, MIPS R3000/R3010, and Cydra 5 result in 4 to 7 times faster detection of resource contentions and require 22 to 90% of the memory storage used by the original machine descriptions. Precise measurement for the Cydra 5 indicates that reducing the machine description results in a 2.9 times faster contention query module.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231386", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alexandre E.", + "last_name": "Eichenberger", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Edward S.", + "last_name": "Davidson", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/EichenbergerD96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231395", + "title": "Representing Control in the Presence of One-Shot Continuations", + "abstract": "Traditional first-class continuation mechanisms allow a captured continuation to be invoked multiple times. Many continuations, however, are invoked only once. This paper introduces one-shot continuations, shows how they interact with traditional multi-shot continuations, and describes a stack-based implementation of control that handles both one-shot and multi-shot continuations. The implementation eliminates the copying overhead for one-shot continuations that is inherent in multi-shot continuations. 1 Introduction Scheme [5] and some implementations of ML [17] provide continuations as first-class data objects. Continuations can be used to implement, at the source level, a number of interesting control features, such as loops, nonlocal exits, nonblind backtracking [22], nondeterministic computations [10, 14], and coroutines [7]. Source-level implementations of thread systems [9, 15, 21], especially in the area of graphical user interfaces (GUIs) [12, 13, 20, 23], are an important ...", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231395", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Carl", + "last_name": "Bruggeman", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Oscar", + "last_name": "Waddell", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/pldi/BruggemanWD96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231402", + "title": "Efficient and Language-Independent Mobile Programs", + "abstract": "This paper evaluates the design and implementation of Omniware: a safe, efficient, and language-independent system for executing mobile program modules. Previous approaches to implementing mobile code rely on either language semantics or abstract machine interpretation to enforce safety. In the former case, the mobile code system sacrifices universality to gain safety by dictating a particular source language or type system. In the latter case, the mobile code system sacrifices performance to gain safety through abstract machine interpretation.Omniware uses software fault isolation, a technology developed to provide safe extension code for databases and operating systems, to achieve a unique combination of language-independence and excellent performance. Software fault isolation uses only the semantics of the underlying processor to determine whether a mobile code module can corrupt its execution environment. This separation of programming language implementation from program module safety enables our mobile code system to use a radically simplified virtual machine as its basis for portability. We measured the performance of Omniware using a suite of four SPEC92 programs on the Pentium, PowerPC, Mips, and Sparc processor architectures. Including the overhead for enforcing safety on all four processors, OmniVM executed the benchmark programs within 21% as fast as the optimized, unsafe code produced by the vendor-supplied compiler.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231402", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Geoff", + "last_name": "Langdale", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Steven", + "last_name": "Lucco", + "institution": "" + }, + { + "first_name": "Robert", + "last_name": "Wahbe", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Adl-TabatabaiLLW96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231417", + "title": "Flow-directed Inlining", + "abstract": "A flow-directed inlining strategy uses information derived from control-flow analysis to specialize and inline procedures for functional and object-oriented languages. Since it uses control-flow analysis to identify candidate call sites, flow-directed inlining can inline procedures whose relationships to their call sites are not apparent. For instance, procedures defined in other modules, passed as arguments, returned as values, or extracted from data structures can all be inlined. Flow-directed inlining specializes procedures for particular call sites, and can selectively inline a particular procedure at some call sites but not at others. Finally, flow-directed inlining encourages modular implementations: control-flow analysis, inlining, and post-inlining optimizations are all orthogonal components. Results from a prototype implementation indicate that this strategy effectively reduces procedure call overhead and leads to significant reduction in execution time.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231417", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Princeton University" + }, + { + "first_name": "Andrew K.", + "last_name": "Wright", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/JagannathanW96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231433", + "title": "Data Flow Frequency Analysis", + "abstract": "Conventional dataflow analysis computes information about what facts may or will not hold during the execution of a program. Sometimes it is useful, for program optimization, to know how often or with what probability a fact holds true during program execution. In this paper, we provide a precise formulation of this problem for a large class of dataflow problems --- the class of finite bi-distributive subset problems. We show how it can be reduced to a generalization of the standard dataflow analysis problem, one that requires a sum-over-all-paths quantity instead of the usual meet-overall -paths quantity. We show that Kildall&apos;s result expressing the meet-over-all-paths value as a maximal-fixed-point carries over to the generalized setting. We then outline ways to adapt the standard dataflow analysis algorithms to solve this generalized problem, both in the intraprocedural and the interprocedural case. 1 Introduction Conventional dataflow analysis computes information about what facts...", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231433", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/Ramalingam96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231387", + "title": "Static Debugging: Browsing the Web of Program Invariants", + "abstract": "MrSpidey is a user-friendly, interactive static debugger for Scheme. A static debugger supplements the standard debugger by analyzing the program and pinpointing those program operations that may cause run-time errors such as dereferencing the null pointer or applying non-functions. The program analysis of MrSpidey computes value set descriptions for each term in the program and constructs a value flow graph connecting the set descriptions. Using the set descriptions, MrSpidey can identify and highlight potentially erroneous program operations, whose cause the programmer can then explore by selectively exposing portions of the value flow graph.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231387", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "Rice University" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "Rice University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Rice University" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/FlanaganFKWF96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231411", + "title": "VCODE: a Retargetable, Extensible, Very Fast Dynamic Code Generation System", + "abstract": "Dynamic code generation is the creation of executable code at runtime. Such \"on-the-fly\" code generation is a powerful technique, enabling applications to use runtime information to improve performance by up to an order of magnitude [4, 8,20, 22, 23].Unfortunately, previous general-purpose dynamic code generation systems have been either inefficient or non-portable. We present VCODE, a retargetable, extensible, very fast dynamic code generation system. An important feature of VCODE is that it generates machine code \"in-place\" without the use of intermediate data structures. Eliminating the need to construct and consume an intermediate representation at runtime makes VCODE both efficient and extensible. VCODE dynamically generates code at an approximate cost of six to ten instructions per generated instruction, making it over an order of magnitude faster than the most efficient general-purpose code generation system in the literature [10].Dynamic code generation is relatively well known within the compiler community. However, due in large part to the lack of a publicly available dynamic code generation system, it has remained a curiosity rather than a widely used technique. A practical contribution of this work is the free, unrestricted distribution of the VCODE system, which currently runs on the MIPS, SPARC, and Alpha architectures.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231411", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dawson", + "last_name": "Engler", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Engler96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231431", + "title": "Target-Sensitive Construction of Diagnostic Programs for Procedure Calling Sequence Generators", + "abstract": "Building compilers that generate correct code is difficult. In this paper we present a compiler testing technique that closes the gap between actual compiler implementations and correct compilers. Using formal specifications of procedure calling conventions, we have built a target-sensitive test suite generator that builds test cases for a specific aspect of compiler code generators the procedure calling sequence generator. By exercising compilers with these target-specific test suites, our automated testing tool has exposed bugs in every compiler tested. These compilers include ones that have been in heavy use for many years. The detected bugs cause more than 14,000 test cases to fail.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231431", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark W.", + "last_name": "Bailey", + "institution": "University of Virginia" + }, + { + "first_name": "Jack W.", + "last_name": "Davidson", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/pldi/BaileyD96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231394", + "title": "Simple Garbage-Collector-Safety", + "abstract": "A conservative garbage collector can typically be used with conventionally compiled programs written in C or C++. But two safety issues must be considered. First, the source code must not hide pointers from the garbage collector. This primarily requires stricter adherence to existing restrictions in the language definition. Second, we must ensure that the compiler will not perform transformations that invalidate this requirement.We argue that the same technique can be used to address both issues. We present an algorithm for annotating source or intermediate code to either check the validity of pointer arithmetic in the source, or to guarantee that under minimal, clearly defined assumptions about the compiler, the optimizer cannot \"disguise\" pointers. We discuss an implementation based on a preprocessor for the GNU C compiler (gcc), and give some measurements of program slow down.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231394", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/pldi/Boehm96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231429", + "title": "Relocating Machine Instructions by Currying", + "abstract": "Relocation adjusts machine instructions to account for changes in the locations of the instructions themselves or of external symbols to which they refer. Standard linkers implement a finite set of relocation transformations, suitable for a single architecture. These transformations are enumerated, named, and engraved in a machine-dependent object-file format, and linkers must recognize them by name. These names and their associated transformations are an unnecessary source of machine-dependence. The New Jersey Machine-Code Toolkit is an application generator. It helps programmers create applications that manipulate machine code, including linkers. Guided by a short instruction-set specification, the toolkit generates the bit-manipulating code. Instructions are described by constructors, which denote functions mapping lists of operands to instructions&apos; binary representations. Any operand can be designated as &quot;relocatable,&quot; meaning that the operand&apos;s value need not be known at the time ...", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231429", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/Ramsey96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231414", + "title": "TIL: A Type-Directed Optimizing Compiler for ML", + "abstract": "article Free Access Share on TIL: a type-directed optimizing compiler for ML Authors: D. Tarditi School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PA School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PAView Profile , G. Morrisett School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PA School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PAView Profile , P. Cheng School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PA School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PAView Profile , C. Stone School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PA School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PAView Profile , R. Harper School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PA School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PAView Profile , P. Lee School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PA School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PAView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 31Issue 5May 1996 pp 181–192https://doi.org/10.1145/249069.231414Online:01 May 1996Publication History 212citation719DownloadsMetricsTotal Citations212Total Downloads719Last 12 Months39Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231414", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Tarditi", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Pau-Chen", + "last_name": "Cheng", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "C. Addison", + "last_name": "Stone", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "P.", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/TarditiMCSHL96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231407", + "title": "Optimizing ML with Run-Time Code Generation", + "abstract": "We describe the design and implementation of a compiler that automatically translates ordinary programs written in a subset of ML into code that generates native code at run time. Run-time code generation can make use of values and invariants that cannot be exploited at compile time, yielding code that is often superior to statically optimal code. But the cost of optimizing and generating code at run time can be prohibitive. We demonstrate how compile-time specialization can reduce the cost of run-time code generation by an order of magnitude without greatly affecting code quality. Several benchmark programs are examined, which exhibit an average cost of only six cycles per instruction generated at run time.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231407", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Mark P.", + "last_name": "Leone", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/LeeL96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231392", + "title": "GUM: A Portable Parallel Implementation of Haskell", + "abstract": "GUM is a portable, parallel implementation of the Haskell functional language. Despite sustained research interest in parallel functional programming, GUM is one of the first such systems to be made publicly available.GUM is message-based, and portability is facilitated by using the PVM communications harness that is available on many multi-processors. As a result, GUM is available for both shared-memory (Sun SPARCserver multiprocessors) and distributed-memory (networks of workstations) architectures. The high message-latency of distributed machines is ameliorated by sending messages asynchronously, and by sending large packets of related data in each message.Initial performance figures demonstrate absolute speedups relative to the best sequential compiler technology. To improve the performance of a parallel Haskell program GUM provides tools for monitoring and visualising the behaviour of threads and of processors during execution.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231392", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Phil", + "last_name": "Trinder", + "institution": "University of Glasgow" + }, + { + "first_name": "Kevin", + "last_name": "Hammond", + "institution": "University of Glasgow" + }, + { + "first_name": "J. S.", + "last_name": "Mattson", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Andrew", + "last_name": "Partridge", + "institution": "University of Tasmania" + }, + { + "first_name": "Simon", + "last_name": "Jones", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/pldi/TrinderHMPJ96", + "venue": "pldi", + "year": 1996 + }, + { + "paper_id": "10.1145/231379.231434", + "title": "A New Framework for Exhaustive and Incremental Data Flow Analysis Using DJ Graphs", + "abstract": "We present a new elimination-based framework for exhaustive and incremental data flow analysis using the DJ graph representation of a program. Unlike the previous approaches to elimination-based incremental data flow analysis, our approach can handle arbitrary non-structural and structural changes to program flowgraphs, including those causing irreducibility. We show how our approach is related to (iterated) dominance frontiers, and exploit this relationship to establish the complexity of our exhaustive analysis and to aid the design of our incremental analysis.", + "date": "1996-05-01", + "link": "https://doi.org/10.1145/231379.231434", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vugranam C.", + "last_name": "Sreedhar", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Guang R.", + "last_name": "Gao", + "institution": "McGill University" + }, + { + "first_name": "Yong-Fong", + "last_name": "Lee", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/SreedharGL96", + "venue": "pldi", + "year": 1996 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1997.json b/data/pl_conferences/pldi/1997.json new file mode 100644 index 0000000..740c381 --- /dev/null +++ b/data/pl_conferences/pldi/1997.json @@ -0,0 +1,825 @@ +[ + { + "paper_id": "10.1145/258915.258933", + "title": "Efficient Formulation for Optimal Modulo Schedulers", + "abstract": "Modulo scheduling algorithms based on optimal solvers have been proposed to investigate and tune the performance of modulo scheduling heuristics. While recent advances have broadened the scope for which the optimal approach is applicable, this approach increasingly suffers from large execution times. In this paper, we propose a more efficient formulation of the modulo scheduling space that significantly decreases the execution time of solvers based on integer linear programs. For example, the total execution time is reduced by a factor of 8.6 when 782 loops from the Perfect Club, SPEC, and Livermore Fortran Kernels are scheduled for minimum register requirements using the more efficient formulation instead of the traditional formulation. Experimental evidence further indicates that significantly larger loops can be scheduled under realistic machine constraints.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258933", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alexandre E.", + "last_name": "Eichenberger", + "institution": "North Carolina State University" + }, + { + "first_name": "Edward S.", + "last_name": "Davidson", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/EichenbergerD97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258926", + "title": "tcc: A System for Fast, Flexible, and High-level Dynamic Code Generation", + "abstract": "tcc is a compiler that provides efficient and high-level access to dynamic code generation. It implements the 'C (\"Tick-C\") programming language, an extension of ANSI C that supports dynamic code generation [15]. 'C gives power and flexibility in specifying dynamically generated code: whereas most other systems use annotations to denote run-time invariants. 'C allows the programmer to specify and compose arbitrary expressions and statements at run time. This degree of control is needed to efficiently implement some of the most important applications of dynamic code generation, such as \"just in time\" compilers [17] and efficient simulators [10, 48, 46].The paper focuses on the techniques that allow tcc to provide 'C's flexibility and expressiveness without sacrificing run-time code generation efficiency. These techniques include fast register allocation, efficient creation and composition of dynamic code specifications, and link-time analysis to reduce the size of dynamic code generators. tcc also implements two different dynamic code generation strategies, designed to address the tradeoff of dynamic compilation speed versus generated code quality. To characterize the effects of dynamic compilation, we present performance measurements for eleven programs compiled using tcc. On these applications, we measured performance improvements of up to one order of magnitude.To encourage further experimentation and use of dynamic code generation, we are making the tcc compiler available in the public domain. This is, to our knowledge, the first high-level dynamic compilation system to be made available.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258926", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Massimiliano", + "last_name": "Poletto", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Dawson", + "last_name": "Engler", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "M. Frans", + "last_name": "Kaashoek", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/PolettoEK97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258939", + "title": "Linear-time Subtransitive Control Flow Analysis", + "abstract": "We present a linear-time algorithm for bounded-type programs that builds a directed graph whose transitive closure gives exactly the results of the standard (cubic-time) Control-Flow Analysis (CFA) algorithm. Our algorithm can be used to list all functions calls from all call sites in (optimal) quadratic time. More importantly, it can be used to give linear-time algorithms for CFA-consuming applications such as:• effects analysis: find the side-effecting expressions in a program.• k-limited CFA: for each call-site, list the functions if there are only a few of them (≤ k) and otherwise output \"many\".• called-once analysis: identify all functions called from only one call-site.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258939", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nevin", + "last_name": "Heintze", + "institution": "Nokia (United States)" + }, + { + "first_name": "David", + "last_name": "McAllester", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/HeintzeM97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258924", + "title": "Exploiting Hardware Performance Counters with Flow and Context Sensitive Profiling", + "abstract": "A program profile attributes run-time costs to portions of a program's execution. Most profiling systems suffer from two major deficiencies: first, they only apportion simple metrics, such as execution frequency or elapsed time to static, syntactic units, such as procedures or statements; second, they aggressively reduce the volume of information collected and reported, although aggregation can hide striking differences in program behavior.This paper addresses both concerns by exploiting the hardware counters available in most modern processors and by incorporating two concepts from data flow analysis--flow and context sensitivity--to report more context for measurements. This paper extends our previous work on efficient path profiling to flow sensitive profiling, which associates hardware performance metrics with a path through a procedure. In addition, it describes a data structure, the calling context tree, that efficiently captures calling contexts for procedure-level measurements.Our measurements show that the SPEC95 benchmarks execute a small number (3--28) of hot paths that account for 9--98% of their L1 data cache misses. Moreover, these hot paths are concentrated in a few routines, which have complex dynamic behavior.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258924", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Glenn", + "last_name": "Ammons", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/AmmonsBL97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258943", + "title": "Register Promotion in C Programs", + "abstract": "The combination of pointers and pointer arithmetic in C makes the task of improving C programs somewhat more difficult than improving programs written in simpler languages like Fortran. While much work has been published that focuses on the analysis of pointers, little has appeared that uses the results of such analysis to improve the code compiled for C. This paper examines the problem of register promotion in C and presents experimental results showing that it can have dramatic effects on memory traffic.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258943", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Lu", + "institution": "Rice University" + }, + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/CooperL97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258930", + "title": "Partial Dead Code Elimination using Slicing Transformations", + "abstract": "We present an approach for optimizing programs that uncovers additional opportunities for optimization of a statement by predicating the statement. In this paper predication algorithms for achieving partial dead code elimination (PDE) are presented. The process of predication embeds a statement in a control flow structure such that the statement is executed only if the execution follows a path along which the value computed by the statement is live. The control flow restructuring performed to achieve predication is expressed through slicing transformations. This approach achieves PDE that is not realizable by existing algorithms. We prove that our algorithm never increases the operation count along any path, and that for acyclic code all partially dead statements are eliminated. The slicing transformation that achieves predication introduces into the program additional conditional branches. These branches are eliminated in a branch deletion step based upon code duplication. We also show how PDE can be used by acyclic schedulers for VLIW processors to reduce critical path lengths along frequently executed paths.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258930", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/pldi/BodikG97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258918", + "title": "Automatic Inline Allocation of Objects", + "abstract": "Object-oriented languages like Java and Smalltalk provide a uniform object model that simplifies programming by providing a consistent, abstract model of object behavior. But direct implementations introduce overhead, removal of which requires aggressive implementation techniques (e.g. type inference, function specialization); in this paper, we introduce object inlining, an optimization that automatically inline allocates objects within containers (as is done by hand in C++) within a uniform model. We present our technique, which includes novel program analyses that track how inlinable objects are used throughout the program. We evaluated object inlining on several object-oriented benchmarks. It produces performance up to three times as fast as a dynamic model without inlining and roughly equal to that of manually-inlined codes.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258918", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "Urbana University" + } + ], + "dblp_key": "conf/pldi/Dolby97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258947", + "title": "Code Compression", + "abstract": "Current research in compiler optimization counts mainly CPU time and perhaps the first cache level or two. This view has been important but is becoming myopic, at least from a system-wide viewpoint, as the ratio of network and disk speeds to CPU speeds grows exponentially.For example, we have seen the CPU idle for most of the time during paging, so compressing pages can increase total performance even though the CPU must decompress or interpret the page contents. Another profile shows that many functions are called just once, so reduced paging could pay for their interpretation overhead.This paper describes:• Measurements that show how code compression can save space and total time in some important real-world scenarios.• A compressed executable representation that is roughly the same size as gzipped x86 programs and can be interpreted without decompression. It can also be compiled to high-quality machine code at 2.5 megabytes per second on a 120MHz Pentium processor• A compressed \"wire\" representation that must be decompressed before execution but is, for example, roughly 21% the size of SPARC code when compressing gcc.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258947", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jens", + "last_name": "Ernst", + "institution": "University of Arizona" + }, + { + "first_name": "William", + "last_name": "Evans", + "institution": "University of Arizona" + }, + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "University of Arizona" + }, + { + "first_name": "Steven", + "last_name": "Lucco", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/ErnstEFLP97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258937", + "title": "Componential Set-Based Analysis", + "abstract": "Set based analysis is a constraint-based whole program analysis that is applicable to functional and object-oriented programming language. Unfortunately, the analysis is useless for large programs, since it generates descriptions of data flow relationships that grow quadratically in the size of the program.This paper presents componential set-based analysis, which is faster and handles larger programs without any loss of accuracy over set-based analysis. The design of the analysis exploits a number of theoretical results concerning constraint systems, including a completeness result and a decision algorithm concerning the observable equivalance of constraint systems. Experimental results validate the practically of the analysis.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258937", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/FlanaganF97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258936", + "title": "Automatic Verification of Pointer Programs using Monadic Second-Order Logic", + "abstract": "We present a technique for automatic verification of pointer programs based on a decision procedure for the monadic second-order logic on finite strings.We are concerned with a while-fragment of Pascal, which includes recursively-defined pointer structures but excludes pointer arithmetic.We define a logic of stores with interesting basic predicates such as pointer equality, tests for nil pointers, and garbage cells, as well as reachability along pointers.We present a complete decision procedure for Hoare triples based on this logic over loop-free code. Combined with explicit loop invariants, the decision procedure allows us to answer surprisingly detailed questions about small but non-trivial programs. If a program fails to satisfy a certain property, then we can automatically supply an initial store that provides a counterexample.Our technique had been fully and efficiently implemented for linear linked lists, and it extends in principle to tree structures. The resulting system can be used to verify extensive properties of smaller pointer programs and could be particularly useful in a teaching environment.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258936", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jakob L.", + "last_name": "Jensen", + "institution": "" + }, + { + "first_name": "Michael E.", + "last_name": "Jørgensen", + "institution": "" + }, + { + "first_name": "Michael I.", + "last_name": "Schwartzbach", + "institution": "" + }, + { + "first_name": "Nils", + "last_name": "Klarlund", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/JensenJKS97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258922", + "title": "Reverse Interpretation + Mutation Analysis = Automatic Retargeting", + "abstract": "There are three popular methods for constructing highly retargetable compilers: (1) the compiler emits abstract machine code which is interpreted at run-time, (2) the compiler emits C code which is subsequently compiled to machine code by the native C compiler, or (3) the compiler's code-generator is generated by a back-end generator from a formal machine description produced by the compiler writer.These methods incur high costs at run-time, compile-time, or compiler-construction time, respectively.In this paper we will describe a novel method which promises to significantly reduce the effort required to retarget a compiler to a new architecture, while at the same time producing fast and effective compilers. The basic idea is to use the native C compiler at compiler construction time to discover architectural features of the new architecture. From this information a formal machine description is produced. Given this machine description, a native code-generator can be generated by a back-end generator such as BEG or burg.A prototype Automatic Architecture Discovery Unit has been implemented. The current version is general enough to produce machine descriptions for the integer instruction sets of common RISC and CISC architectures such as the Sun SPARC, Digital Alpha, MIPS, DEC VAX, and Intel x86. The tool is completely automatic and requires minimal input from the user: principally, the user needs to provide the internet address of the target machine and the command-lines by which the C compiler, assembler, and linker are invoked.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258922", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christian", + "last_name": "Collberg", + "institution": "University of Auckland" + } + ], + "dblp_key": "conf/pldi/Collberg97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258940", + "title": "A New Algorithm for Partial Redundancy Elimination based on SSA Form", + "abstract": "A new algorithm, SSAPRE, for performing partial redundancy elimination based entirely on SSA form is presented. It achieves optimal code motion similar to lazy code motion [KRS94a, DS93], but is formulated independently and does not involve iterative data flow analysis and bit vectors in its solution. It not only exhibits the characteristics common to other sparse approaches, but also inherits the advantages shared by other SSA-based optimization techniques. SSAPRE also maintains its output in the same SSA form as its input. In describing the algorithm, we state theorems with proofs giving our claims about SSAPRE. We also give additional description about our practical implementation of SSAPRE, and analyze and compare its performance with a bit-vector-based implementation of PRE. We conclude with some discussion of the implications of this work.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258940", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fred", + "last_name": "Chow", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Sun", + "last_name": "Chan", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Robert E.", + "last_name": "Kennedy", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Shin-Ming", + "last_name": "Liu", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Raymond", + "last_name": "Lo", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Peng", + "last_name": "Tu", + "institution": "Silicon Labs (United States)" + } + ], + "dblp_key": "conf/pldi/ChowCKLLT97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258925", + "title": "Generational Garbage Collection and the Radioactive Decay Model", + "abstract": "If a fixed exponentially decreasing probability distribution function is used to model every object's lifetime, then the age of an object gives no information about its future life expectancy. This radioactive decay model implies there can be no rational basis for deciding which live objects should be promoted to another generation. Yet there remains a rational basis for deciding how many objects to promote, when to collect garbage, and which generations to collect.Analysis of the model leads to a new kind of generational garbage collector whose effectiveness does not depend upon heuristics that predict which objects will live longer than others.This result provides insight into the computational advantages of generational garbage collection, with implications for the management of objects whose life expectancies are difficult to predict.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258925", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Clinger", + "institution": "Universidad del Noreste" + }, + { + "first_name": "Lars T.", + "last_name": "Hansen", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/pldi/ClingerH97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258944", + "title": "Fine-grain Multithreading with Minimal Compiler Support - A Cost Effective Approach to Implementing Efficient Multithreading Languages", + "abstract": "It is difficult to map the execution model of multithreading languages (languages which support fine-grain dynamic thread creation) onto the single stack execution model of C. Consequently, previous work on efficient multithreading uses elaborate frame formats and allocation strategy, with compilers customized for them. This paper presents an alternative cost-effective implementation strategy for multithreading languages which can maximally exploit current sequential C compilers. We identify a set of primitives whereby efficient dynamic thread creation and switch can be achieved and clarify implementation issues and solutions which work under the stack frame layout and calling conventions of current C compilers. The primitives are implemented as a C library and named StackThreads. In StackThreads, a thread creation is done just by a C procedure call, maximizing thread creation performance. When a procedure suspends an execution, the context of the procedure, which is roughly a stack frame of the procedure, is saved into heap and resumed later. With StackThreads, the compiler writer can straightforwardly translate sequential constructs of the source language into corresponding C statements or expressions, while using StackThreads primitives as a blackbox mechanism which switches execution between C procedures.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258944", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kenjiro", + "last_name": "Taura", + "institution": "The University of Tokyo" + }, + { + "first_name": "Akinori", + "last_name": "Yonezawa", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/pldi/TauraY97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258945", + "title": "Data Distribution Support on Distributed Shared Memory Multiprocessors", + "abstract": "Cache-coherent multiprocessors with distributed shared memory are becoming increasingly popular for parallel computing. However, obtaining high performance on these machines mquires that an application execute with good data locality. In addition to making efiective use of caches, it is often necessary to distribute data structures across the local memories of the processing nodes, thereby reducing the latency of cache misses.We have designed a set of abstractions for performing data distribution in the context of explicitly parallel programs and implemented them within the SGI MIPSpro compiler system. Our system incorporates many unique features to enhance both programmability and performance. We address the former by providing a very simple programmming model with extensive support for error detection. Regarding performance, we carefully design the user abstractions with the underlying compiler optimizations in mind, we incorporate several optimization techniques to generate efficient code for accessing distributed data, and we provide a tight integration of these techniques with other optimizations within the compiler Our initial experience suggests that the directives are easy to use and can yield substantial performance gains, in some cases by as much as a factor of 3 over the same codes without distribution.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258945", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rohit", + "last_name": "Chandra", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Ding-Kai", + "last_name": "Chen", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Robert", + "last_name": "Cox", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Dror", + "last_name": "Maydan", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Nenad", + "last_name": "Nedeljković", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Jennifer M.", + "last_name": "Anderson", + "institution": "Western Digital (United States)" + } + ], + "dblp_key": "conf/pldi/ChandraCCMNA97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258928", + "title": "Aggressive Inlining", + "abstract": "Existing research understates the benefits that can be obtained from inlining and cloning, especially when guided by profile information. Our implementation of inlining and cloning yields excellent results on average and very rarely lowers performance. We believe our good results can be explained by a number of factors: inlining at the intermediate-code level removes most technical restrictions on what can be inlined; the ability to inline across files and incorporate profile information enables us to choose better inline candidates; a high-quality back end can exploit the scheduling and register allocation opportunities presented by larger subroutines; an aggressive processor architecture benefits from more predictable branch behavior; and a large instruction cache mitigates the impact of code expansion. We describe the often dramatic impact of our inlining and cloning on performance: for example, the implementations of our inlining and cloning algorithms in the HP-UX 10.20 compilers boost SPECint95 performance on a PA8000-based workstation by a factor of 1.32.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258928", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Ayers", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Richard", + "last_name": "Schooler", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Robert X.", + "last_name": "Gottlieb", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/AyersGS97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258923", + "title": "Dynamic Feedback: An Effective Technique for Adaptive Computing", + "abstract": "This paper presents dynamic feedback, a technique that enables computations to adapt dynamically to different execution environments. A compiler that uses dynamic feedback produces several different versions of the same source code; each version uses a different optimization policy. The generated code alternately performs sampling phases and production phases. Each sampling phase measures the overhead of each version in the current environment. Each production phase uses the version with the least overhead in the previous sampling phase. The computation periodically resamples to adjust dynamically to changes in the environment.We have implemented dynamic feedback in the context of a parallelizing compiler for object-based programs. The generated code uses dynamic feedback to automatically choose the best synchronization optimization policy. Our experimental results show that the synchronization optimization policy has a significant impact on the overall performance of the computation, that the best policy varies from program to program, that the compiler is unable to statically choose the best policy, and that dynamic feedback enables the generated code to exhibit performance that is comparable to that of code that has been manually tuned to use the best policy. We have also performed a theoretical analysis which provides, under certain assumptions, a guaranteed optimality bound for dynamic feedback relative to a hypothetical (and unrealizable) optimal algorithm that uses the best policy at every point during the execution.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258923", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pedro C.", + "last_name": "Diniz", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/pldi/DinizR97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258934", + "title": "Module-Sensitive Program Specialisation", + "abstract": "We present an approach for specialising large programs, such as programs consisting of several modules, or libraries. This approach is based on the idea of using a compiler generator (cogen) for creating generating extensions. Generating extensions are specialisers specialised with respect to some input program. When run on some input data the generating extension produces a specialised version of the input program. Here we use the cogen to tailor modules for specialisation. This happens once and for all, independently of all other modules. The resulting module can then be used as a building block for generating extensions for complete programs, in much the same way as the original modules can be put together into complete programs. The result of running the final generating extension is a collection of residual modules, with a module structure derived from the original program.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258934", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dirk", + "last_name": "Dussart", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Rogardt", + "last_name": "Heldal", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "" + } + ], + "dblp_key": "conf/pldi/DussartHH97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258921", + "title": "Flick: A Flexible, Optimizing IDL Compiler", + "abstract": "An interface definition language (IDL) is a nontraditional language for describing interfaces between software components. IDL compilers generate \"stubs\" that provide separate communicating processes with the abstraction of local object invocation or procedure call. High-quality stub generation is essential for applications to benefit from component-based designs, whether the components reside on a single computer or on multiple networked hosts. Typical IDL compilers, however, do little code optimization, incorrectly assuming that interprocess communication is always the primary bottleneck. More generally, typical IDL compilers are \"rigid\" and limited to supporting only a single IDL, a fixed mapping onto a target language, and a narrow range of data encodings and transport mechanisms.Flick, our new IDL compiler, is based on the insight that IDLs are true languages amenable to modern compilation techniques. Flick exploits concepts from traditional programming language compilers to bring both flexibility and optimization to the domain of IDL compilation. Through the use of carefully chosen intermediate representations, Flick supports multiple IDLs, diverse data encodings, multiple transport mechanisms, and applies numerous optimizations to all of the code it generates. Our experiments show that Flick-generated stubs marshal data between 2 and 17 times faster than stubs produced by traditional IDL compilers, and on today's generic operating systems, increase end-to-end throughput by factors between 1.2 and 3.7.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258921", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Eric", + "last_name": "Eide", + "institution": "University of Utah" + }, + { + "first_name": "Kevin", + "last_name": "Frei", + "institution": "University of Utah" + }, + { + "first_name": "Bryan", + "last_name": "Ford", + "institution": "University of Utah" + }, + { + "first_name": "Jay", + "last_name": "Lepreau", + "institution": "University of Utah" + }, + { + "first_name": "Gary", + "last_name": "Lindstrom", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/EideFFLL97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258929", + "title": "Interprocedural Conditional Branch Elimination", + "abstract": "The existence of statically detectable correlation among conditional branches enables their elimination, an optimization that has a number of benefits. This paper presents techniques to determine whether an interprocedural execution path leading to a conditional branch exists along which the branch outcome is known at compile time, and then to eliminate the branch along this path through code restructuring. The technique consists of a demand driven interprocedural analysis that determines whether a specific branch outcome is correlated with prior statements or branch outcomes. The optimization is performed using a code restructuring algorithm that replicates code to separate out the paths with correlation. When the correlated path is affected by a procedure call, the restructuring is based on procedure entry splitting and exit splitting. The entry splitting transformation creates multiple entries to a procedure, and the exit splitting transformation allows a procedure to return control to one of several return points in the caller. Our technique is efficient in that the correlation detection is demand driven, thus avoiding exhaustive analysis of the entire program, and the restructuring never increases the number of operations along a path through an interprocedural control flow graph. We describe the benefits of our interprocedural branch elimination optimization (ICBE). Our experimental results show that, for the same amount of code growth, the estimated reduction in executed conditional branches is about 2.5 times higher with the ICBE optimization than when only intraprocedural conditional branch elimination is applied.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258929", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Mary Lou", + "last_name": "Soffa", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/pldi/BodikGS97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258941", + "title": "Spill Code Minimization via Interference Region Spilling", + "abstract": "Many optimizing compilers perform global register allocation using a Chaitin-style graph coloring algorithm. Live ranges that cannot be allocated to registers are spilled to memory. The amount of code required to spill the live range depends on the spilling heuristic used. Chaitin&apos;s spilling heuristic offers some guidance in reducing the amount of spill code produced. However, this heuristic does not allow the partial spilling of live ranges and the reduction in spill code is limited to a local level. In this paper, we present a global technique called interference region spilling that improves the spilling granularity of any local spilling heuristic. Our technique works above the local spilling heuristic, limiting the normal insertion of spill code to a portion of each spilled live range. By partially spilling live ranges, we can achieve large reductions in dynamically executed spill code; up to 75% in some cases and an average of 33.6% across the benchmarks tested. 1 Introduction Gl...", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258941", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter", + "last_name": "Bergner", + "institution": "University of Rochester" + }, + { + "first_name": "Peter", + "last_name": "Dahl", + "institution": "Synthetic Genomics (United States)" + }, + { + "first_name": "David", + "last_name": "Engebretsen", + "institution": "University of Minnesota" + }, + { + "first_name": "Matthew", + "last_name": "O’Keefe", + "institution": "University of Minnesota" + } + ], + "dblp_key": "conf/pldi/BergnerDEO97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258927", + "title": "Interprocedural Dataflow Analysis in an Executable Optimizer", + "abstract": "Interprocedural dataflow information enables link-time and post-link-time optimizers to perform analyses and code transformations that are not possible in a traditional compiler. This paper describes the interprocedural dataflow analysis techniques used by Spike, a post-linktime optimizer for Alpha/NT executables. Spike uses dataflow analysis to summarize the register definitions, uses, and kills that occur external to each routine, allowing Spike to perform a variety of optimizations that require interprocedural dataflow information. Because Spike is designed to optimize large PC applications, the time required to perform interprocedural dataflow analysis could potentially be unacceptably long, limiting Spike's effectiveness and applicability. To decrease dataflow analysis time, Spike uses a compact representation of a program's intraprocedural and interprocedural control flow that efficiently summarizes the register definitions and uses that occur in the program. Experimental results are presented for the SPEC95 integer benchmarks and eight large PC applications. The results show that the compact representation allows Spike to compute interprocedural dataflow information in less than 2 seconds for each of the SPEC95 integer benchmarks. Even for the largest PC application containing over 1.7 million instructions in 340 thousand basic blocks, interprocedural dataflow analysis requires just 12 seconds.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258927", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Goodwin", + "institution": "Digital Equipment (Germany)" + } + ], + "dblp_key": "conf/pldi/Goodwin97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258917", + "title": "Simple Translation of Goal-Directed Evaluation", + "abstract": "This paper presents a simple, powerful and flexible technique for reasoning about and translating the goal-directed evaluation of programming language constructs that either succeed (and generate sequences of values) or fail. The technique generalizes the Byrd Box, a well-known device for describing Prolog backtracking.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258917", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/Proebsting97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258946", + "title": "Data-centric Multi-level Blocking", + "abstract": "We present a simple and novel framework for generating blocked codes for high-performance machines with a memory hierarchy.Unlike traditional compiler techniques like tiling, which are based on reasoning about the control flow of programs, our techniques are based on reasoning directly about the flow of data through the memory hierarchy. Our data-centric transformations permit a more direct solution to the problem of enhancing data locality than current control-centric techniques do, and generalize easily to multiple levels of memory hierarchy. We buttress these claims with performance numbers for standard benchmarks from the problem domain of dense numerical linear algebra. The simplicity and intuitive appeal of our approach should make it attractive to compiler writers as well as to library writers.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258946", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Induprakas", + "last_name": "Kodukula", + "institution": "Cornell University" + }, + { + "first_name": "Nawaaz", + "last_name": "Ahmed", + "institution": "Cornell University" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/KodukulaAP97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258919", + "title": "A Member Lookup Algorithm for C++", + "abstract": "The member lookup problem in C++ is the problem of resolving a specified member name in the context of a specified class. Member lookup in C++ is complicated by the presence of virtual inheritance and multiple inheritance. In this paper, we present an efficient algorithm for member lookup in C++. We also present a formalism for the multiple inheritance mechanism of C++, which we use as the basis for deriving our algorithm. The formalism may also be of use as a formal basis for deriving other C++ compiler algorithms.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258919", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM (United States)" + }, + { + "first_name": "Harini", + "last_name": "Srinivasan", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/RamalingamS97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258942", + "title": "Call-Cost Directed Register Allocation", + "abstract": "Choosing the right kind of register for a live range plays a major role in eliminating the register-allocation overhead when the compiled function is frequently executed or function tails are on the most frequently executed paths. Picking the wrong kind of register for a live range incurs a high penalty that may dominate the total overhead of register allocation. In this paper, we present three improvements, storage-class analysis, benefit-driven simplification, and preference decision that are effective in selecting the right kind of register for a live range. Then we compare an enhanced Chaitin-style register allocator (with these three improvements) with priority-based and optimistic coloring.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258942", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guei-Yuan", + "last_name": "Lueh", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Thomas", + "last_name": "Gross", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/LuehG97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258931", + "title": "Efficient Procedure Mapping Using Cache Line Coloring", + "abstract": "As the gap between memory and processor performance continues to widen, it becomes increasingly important to exploit cache memory effectively. Both hardware and software approaches can be explored to optimize cache performance. Hardware designers focus on cache organization issues, including replacement policy, associativity, block size and the resulting cache access time. Software writers use various optimization techniques, including software prefetching, data scheduling and code reordering. Our focus is on improving memory usage through code reordering compiler techniques. In this paper we present a link-time procedure mapping algorithm which can significantly improve the effectiveness of the instruction cache. Our algorithm produces an improved program layout by performing a color mapping of procedures to cache lines, taking into consideration the procedure size, cache size, cache line size, and call graph. We use cache line coloring to guide the procedure mapping, ind...", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258931", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amir H.", + "last_name": "Hashemi", + "institution": "Northeastern University" + }, + { + "first_name": "David", + "last_name": "Kaeli", + "institution": "Northeastern University" + }, + { + "first_name": "Brad", + "last_name": "Calder", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/HashemiKC97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258935", + "title": "Two for the Price of One: Composing Partial Evaluation and Compilation", + "abstract": "One of the flagship applications of partial evaluation is compilation and compiler generation. However, partial evaluation is usually expressed as a source-to-source transformation for high-level languages, whereas realistic compilers produce object code.We close this gap by composing a partial evaluator with a compiler by automatic means. Our work is a successful application of several meta-computation techniques to build the system, both in theory and in practice. The composition is an application of deforestation or fusion.The result is a run-time code generation system built from existing components. Its applications are numerous. For example, it allows the language designer to perform interpreter-based experiments with a source-to-source version of the partial evaluator before building a realistic compiler which generates object code automatically.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258935", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Sperber", + "institution": "University of Tübingen" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/pldi/SperberT97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258920", + "title": "Incremental Analysis of real Programming Languages", + "abstract": "A major research goal for compilers and environments is the automatic derivation of tools from formal specifications. However, the formal model of the language is often inadequate; in particular, LR(k) grammars are unable to describe the natural syntax of many languages, such as C++ and Fortran, which are inherently non-deterministic. Designers of batch compilers work around such limitations by combining generated components with ad hoc techniques (for instance, performing partial type and scope analysis in tandem with parsing). Unfortunately, the complexity of incremental systems precludes the use of batch solutions. The inability to generate incremental tools for important languages inhibits the widespread use of language-rich interactive environments.We address this problem by extending the language model itself, introducing a program representation based on parse dags that is suitable for both batch and incremental analysis. Ambiguities unresolved by one stage are retained in this representation until further stages can complete the analysis, even if the reaolution depends on further actions by the user. Representing ambiguity explicitly increases the number and variety of languages that can be analyzed incrementally using existing methods.To create this representation, we have developed an efficient incremental parser for general context-free grammars. Our algorithm combines Tomita's generalized LR parser with reuse of entire subtrees via state-matching. Disambiguation can occur statically, during or after parsing, or during semantic analysis (using existing incremental techniques); program errors that preclude disambiguation retsin multiple interpretations indefinitely. Our representation and analyses gain efficiency by exploiting the local nature of ambiguities: for the SPEC95 C programs, the explicit representation of ambiguity requires only 0.5% additional space and less than 1% additional time during reconstruction.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258920", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tim A.", + "last_name": "Wagner", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/WagnerG97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258938", + "title": "Program Analysis Using Binary Relations", + "abstract": "This paper presents a method called relational constraint for finding binary relations among the variables and constants of a program. The method constructs a table of binary relations and treats the program as a collection of constraints on tuples of relations in the table. An experimental optimizer called Thinner uses this method to analyze programs of size n in O(n2) time.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258938", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Adam Brooks", + "last_name": "Webber", + "institution": "Western Illinois University" + } + ], + "dblp_key": "conf/pldi/Webber97", + "venue": "pldi", + "year": 1997 + }, + { + "paper_id": "10.1145/258915.258932", + "title": "Near-optimal Intraprocedural Branch Alignment", + "abstract": "Branch alignment reorders the basic blocks of a program to minimize pipeline penalties due to control-transfer instructions. Prior work in branch alignment has produced useful heuristic methods. We present a branch alignment algorithm that usually achieves the minimum possible pipeline penalty and on our benchmarks averages within 0.3% of a provable optimum. We compare the control penalties and running times of our algorithm to an older, greedy approach and observe that both the greedy method and our method are close to the lower bound on control penalties, suggesting that greedy is good enough. Surprisingly, in actual execution our method produces programs that run noticeably faster than the greedy method. We also report results from training and testing on different data sets, validating that our results can be achieved in real-world usage. Training and testing on different data sets slightly reduced the benefits from both branch alignment algorithms, but the ranking of the algorithms does not change, and the bulk of the benefits remain.", + "date": "1997-05-01", + "link": "https://doi.org/10.1145/258915.258932", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cliff", + "last_name": "Young", + "institution": "Harvard University Press" + }, + { + "first_name": "David S.", + "last_name": "Johnson", + "institution": "AT&T (United States)" + }, + { + "first_name": "Michael D.", + "last_name": "Smith", + "institution": "Harvard University Press" + }, + { + "first_name": "David R.", + "last_name": "Karger", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/YoungJKS97", + "venue": "pldi", + "year": 1997 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1998.json b/data/pl_conferences/pldi/1998.json new file mode 100644 index 0000000..dbe89ed --- /dev/null +++ b/data/pl_conferences/pldi/1998.json @@ -0,0 +1,835 @@ +[ + { + "paper_id": "10.1145/277650.277665", + "title": "Improving Data-flow Analysis with Path Profiles", + "abstract": "Data-flow analysis computes its solutions over the paths in a control-flow graph. These paths---whether feasible or infeasible, heavily or rarely executed---contribute equally to a solution. However, programs execute only a small fraction of their potential paths and, moreover, programs' execution time and cost is concentrated in a far smaller subset of hot paths.This paper describes a new approach to analyzing and optimizing programs, which improves the precision of data flow analysis along hot paths. Our technique identifies and duplicates hot paths, creating a hot path graph in which these paths are isolated. After flow analysis, the graph is reduced to eliminate unnecessary duplicates of unprofitable paths. In experiments on SPEC95 benchmarks, path qualification identified 2--112 times more non-local constants (weighted dynamically) than the Wegman-Zadek conditional constant algorithm, which translated into 1--7% more dynamic instructions with constant results.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277665", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Glenn", + "last_name": "Ammons", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/AmmonsL98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277754", + "title": "Automatically Closing Open Reactive Programs", + "abstract": "We study in this paper the problem of analyzing implementations of open systems --- systems in which only some of the components are present. We present an algorithm for automatically closing an open concurrent reactive system with its most general environment, i.e., the environment that can provide any input at any time to the system. The result is a nondeterministic closed (i.e., self-executable) system which can exhibit all the possible reactive behaviors of the original open system. These behaviors can then be analyzed using VeriSoft, an existing tool for systematically exploring the state spaces of closed systems composed of multiple (possibly nondeterministic) processes executing arbitrary code. We have implemented the techniques introduced in this paper in a prototype tool for automatically closing open programs written in the C programming language. We discuss preliminary experimental results obtained with a large telephone-switching software application developed at Lucent Technologies.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277754", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Colby", + "institution": "Loyola University Chicago" + }, + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Lalita Jategaonkar", + "last_name": "Jagadeesan", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/pldi/ColbyGJ98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277734", + "title": "Thin Locks: Featherweight Synchronization for Java", + "abstract": "Language-supported synchronization is a source of serious performance problems in many Java programs. Even single-threaded applications may spend up to half their time performing useless synchronization due to the thread-safe nature of the Java libraries. We solve this performance problem with a new algorithm that allows lock and unlock operations to be performed with only a few machine instructions in the most common cases. Our locks only require a partial word per object, and were implemented without increasing object size. We present measurements from our implementation in the JDK 1.1.2 for AIX, demonstrating speedups of up to a factor of 5 in micro-benchmarks and up to a factor of 1.7 in real programs.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277734", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "Ravi", + "last_name": "Konuru", + "institution": "IBM (United States)" + }, + { + "first_name": "Chet", + "last_name": "Murthy", + "institution": "IBM (United States)" + }, + { + "first_name": "Maurício", + "last_name": "Serrano", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/BaconKMS98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277745", + "title": "Scalable Cross-Module Optimization", + "abstract": "Large applications are typically partitioned into separately compiled modules. Large performance gains in these applications are available by optimizing across module boundaries. One barrier to applying crossmodule optimization (CMO) to large applications is the potentially enormous amount of time and space consumed by the optimization process.We describe a framework for scalable CMO that provides large gains in performance on applications that contain millions of lines of code. Two major techniques are described. First, careful management of in-memory data structures results in sub-linear memory occupancy when compared to the number of lines of code being optimized. Second, profile data is used to focus optimization effort on the performance-critical portions of applications. We also present practical issues that arise in deploying this framework in a production environment. These issues include debuggability and compatibility with existing development tools, such as make. Our framework is deployed in Hewlett-Packard's (HP) UNIX compiler products and speeds up shipped independent software vendors' applications by as much as 71%.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277745", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Ayers", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Stuart de", + "last_name": "Jong", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "John", + "last_name": "Peyton", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Richard", + "last_name": "Schooler", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/AyersJPS98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277738", + "title": "Garbage Collection and Local Variable Type-Precision and Liveness in Java Virtual Machines", + "abstract": "Full precision in garbage collection implies retaining only those heap allocated objects that will actually be used in the future. Since full precision is not computable in general, garbage collectors use safe (i.e., conservative) approximations such as reachability from a set of root references. Ambiguous roots collectors (commonly called \"conservative\") can be overly conservative because they overestimate the root set, and thereby retain unexpectedly large amounts of garbage. We consider two more precise collection schemes for Java virtual machines (JVMs). One uses a type analysis to obtain a type-precise root set (only those variables that contain references); the other adds a live variable analysis to reduce the root set to only the live reference variables. Even with the Java programming language's strong typing, it turns out that the JVM specification has a feature that makes type-precise root sets difficult to compute. We explain the problem and ways in which it can be solved.Our experimental results include measurements of the costs of the type and liveness analyses at load time, of the incremental benefits at run time of the liveness analysis over the type analysis alone, and of various map sizes and counts. We find that the liveness analysis often produces little or no improvement in heap size, sometimes modest improvements, and occasionally the improvement is dramatic. While further study is in order, we conclude that the main benefit of the liveness analysis is preventing bad surprises.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277738", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ole", + "last_name": "Agesen", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Detlefs", + "institution": "" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/AgesenDM98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277668", + "title": "Using Static Single Assignment Form to Improve Flow-Insensitive Pointer Analysis", + "abstract": "A pointer-analysis algorithm can be either flow-sensitive or flow-insensitive. While flow-sensitive analysis usually provides more precise information, it is also usually considerably more costly in terms of time and space. The main contribution of this paper is the presentation of another option in the form of an algorithm that can be 'tuned' to provide a range of results that fall between the results of flow-insensitive and flow-sensitive analysis. The algorithm combines a flow-insensitive pointer analysis with static single assignment (SSA) form and uses an iterative process to obtain progressively better results.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277668", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rebecca", + "last_name": "Hasti", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/HastiH98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277721", + "title": "Using Integer Sets for Data-Parallel Program Analysis and Optimization", + "abstract": "In this paper, we describe our experience with using an abstract integer-set framework to develop the Rice dHPF compiler, a compiler for High Performance Fortran. We present simple, yet general formulations of the major computation partitioning and communication analysis tasks as well as a number of important optimizations in terms of abstract operations on sets of integer tuples. This approach has made it possible to implement a comprehensive collection of advanced optimizations in dHPF, and to do so in the context of a more general computation partitioning model than previous compilers. One potential limitation of the approach is that the underlying class of integer set problems is fundamentally unable to represent HPF data distributions on a symbolic number of processors. We describe how we extend the approach to compile codes for a symbolic number of processors, without requiring any changes to the set formulations for the above optimizations. We show experimentally that the set re...", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277721", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "Rice University" + }, + { + "first_name": "John", + "last_name": "Mellor‐Crummey", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/AdveM98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277730", + "title": "Units: Cool Modules for HOT Languages", + "abstract": "A module system ought to enable assembly-line programming using separate compilation and an expressive linking language. Separate compilation allows programmers to develop parts of a program independently. A linking language gives programmers precise control over the assembly of parts into a whole. This paper presents models of program units, MzScheme's module language for assembly-line programming. Units support separate compilation, independent module reuse, cyclic dependencies, hierarchical structuring, and dynamic linking. The models explain how to integrate units with untyped and typed languages such as Scheme and ML.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277730", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/FlattF98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277718", + "title": "Generational Stack Collection and Profile-Driven Pretenuring", + "abstract": "This paper presents two techniques for improving garbage collection performance: generational stack collection and profile-driven pretenuring. The first is applicable to stack-based implementations of functional languages while the second is useful for any generational collector. We have implemented both techniques in a generational collector used by the TIL compiler (Tarditi, Morrisett, Cheng, Stone, Harper, and Lee 1996), and have observed decreases in garbage collection times of as much as 70% and 30%, respectively.Functional languages encourage the use of recursion which can lead to a long chain of activation records. When a collection occurs, these activation records must be scanned for roots. We show that scanning many activation records can take so long as to become the dominant cost of garbage collection. However, most deep stacks unwind very infrequently, so most of the root information obtained from the stack remains unchanged across successive garbage collections. Generational stack collection greatly reduces the stack scan cost by reusing information from previous scans.Generational techniques have been successful in reducing the cost of garbage collection (Ungar 1984). Various complex heap arrangements and tenuring policies have been proposed to increase the effectiveness of generational techniques by reducing the cost and frequency of scanning and copying. In contrast, we show that by using profile information to make lifetime predictions, pretenuring can avoid copying data altogether. In essence, this technique uses a refinement of the generational hypothesis (most data die young) with a locality principle concerning the age of data: most allocations sites produce data that immediately dies, while a few allocation sites consistently produce data that survives many collections.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277718", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Perry", + "last_name": "Cheng", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Peter", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/ChengHL98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277743", + "title": "Optimizing Direct-threaded Code by Selective Inlining", + "abstract": "Achieving good performance in bytecoded language interpreters is difficult without sacrificing both simplicity and portability. This is due to the complexity of dynamic translation (\"just-in-time compilation\") of bytecodes into native code, which is the mechanism employed universally by high-performance interpreters.We demonstrate that a few simple techniques make it possible to create highly-portable dynamic translators that can attain as much as 70% the performance of optimized C for certain numerical computations. Translators based on such techniques can offer respectable performance without sacrificing either the simplicity or portability of much slower \"pure\" bytecode interpreters.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277743", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ian", + "last_name": "Piumarta", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Fabio", + "last_name": "Riccardi", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/PiumartaR98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277748", + "title": "Memory Management with Explicit Regions", + "abstract": "Much research has been devoted to studies of and algorithms for memory management based on garbage collection or explicit allocation and deallocation. An alternative approach, region-based memory management, has been known for decades, but has not been well-studied. In a region-based system each allocation specifies a region, and memory is reclaimed by destroying a region, freeing all the storage allocated therein. We show that on a suite of allocation-intensive C programs, regions are competitive with malloc/free and sometimes substantially faster. We also show that regions support safe memory management with low overhead. Experience with our benchmarks suggests that modifying many existing programs to use regions is not difficult.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277748", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Gay", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/GayA98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277670", + "title": "Type-Based Alias Analysis", + "abstract": "This paper evaluates three alias analyses based on programming language types. The first analysis uses type compatibility to determine aliases. The second extends the first by using additional high-level information such as field names. The third extends the second with a flow-insensitive analysis. Although other researchers suggests using types to disambiguate memory references, none evaluates its effectiveness. We perform both static and dynamic evaluations of type-based alias analyses for Modula-3, a statically-typed type-safe language. The static analysis reveals that type compatibility alone yields a very imprecise alias analysis, but the other two analyses significantly improve alias precision. We use redundant load elimination (RLE) to demonstrate the effectiveness of the three alias algorithms in terms of the opportunities for optimization, the impact on simulated execution times, and to compute an upper bound on what a perfect alias analysis would yield. We show modest dynamic improvements for (RLE), and more surprisingly, that on average our alias analysis is within 2.5% of a perfect alias analysis with respect to RLE on 8 Modula-3 programs. These results illustrate that to explore thoroughly the effectiveness of alias analyses, researchers need static, dynamic, and upper-bound analysis. In addition, we show that for type-safe languages like Modula-3 and Java, a fast and simple alias analysis may be sufficient for many applications.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277670", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "Stanford University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/DiwanMM98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277719", + "title": "Proper Tail Recursion and Space Efficiency", + "abstract": "The IEEE/ANSI standard for Scheme requires implementations to be properly tail recursive. This ensures that portable code can rely upon the space efficiency of continuation-passing style and other idioms. On its face, proper tail recursion concerns the efficiency of procedure calls that occur within a tail context. When examined closely, proper tail recursion also depends upon the fact that garbage collection can be asymptotically more space-efficient than Algol-like stack allocation.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277719", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Clinger", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/pldi/Clinger98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277656", + "title": "A New Algorithm for Scalar Register Promotion based on SSA Form", + "abstract": "We present a new register promotion algorithm based on Static Single Assignment (SSA) form. Register promotion is aimed at promoting program names from memory locations to registers. Our algorithm is profile-driven and is based on the scope of intervals. In cases where a complete promotion is not possible because of the presence of function calls or pointer references, the proposed algorithm is capable of eliminating loads and stores on frequently executed paths by placing loads and stores on less frequently executed paths. We also describe an efficient method to incrementally update SSA form when new definitions are cloned from an existing name during register promotion. On SPECInt95 benchmarks, our algorithm removes about ~12% of memory operations which access scalar variables.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277656", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "A. V. S.", + "last_name": "Sastry", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Roy Dz-Ching", + "last_name": "Ju", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/SastryJ98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277725", + "title": "The Implementation of the Cilk-5 Multithreaded Language", + "abstract": "The fifth release of the multithreaded language Cilk uses a provably good \"work-stealing\" scheduling algorithm similar to the first system, but the language has been completely redesigned and the runtime system completely reengineered. The efficiency of the new implementation was aided by a clear strategy that arose from a theoretical analysis of the scheduling algorithm: concentrate on minimizing overheads that contribute to the work, even at the expense of overheads that contribute to the critical path. Although it may seem counterintuitive to move overheads onto the critical path, this \"work-first\" principle has led to a portable Cilk-5 implementation in which the typical cost of spawning a parallel thread is only between 2 and 6 times the cost of a C function call on a variety of contemporary machines. Many Cilk programs run on one processor with virtually no degradation compared to equivalent C programs. This paper describes how the work-first principle was exploited in the design of Cilk-5's compiler and its runtime system. In particular, we present Cilk-5's novel \"two-clone\" compilation strategy and its Dijkstra-like mutual-exclusion protocol for implementing the ready deque in the work-stealing scheduler.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277725", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matteo", + "last_name": "Frigo", + "institution": "" + }, + { + "first_name": "Charles E.", + "last_name": "Leiserson", + "institution": "" + }, + { + "first_name": "Keith H.", + "last_name": "Randall", + "institution": "" + } + ], + "dblp_key": "conf/pldi/FrigoLR98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277653", + "title": "Complete Removal of Redundant Computations", + "abstract": "Partial redundancy elimination (PRE), the most important component of global optimizers, generalizes the removal of common subexpressions and loop-invariant computations. Because existing PRE implementations are based on code motion, they fail to completely remove the redundancies. In fact, we observed that 73% of loop-invariant statements cannot be eliminated from loops by code motion alone. In dynamic terms, traditional PRE eliminates only half of redundancies that are strictly partial. To achieve a complete PRE, control flow restructuring must be applied. However, the resulting code duplication may cause code size explosion.This paper focuses on achieving a complete PRE while incurring an acceptable code growth. First, we present an algorithm for complete removal of partial redundancies, based on the integration of code motion and control flow restructuring. In contrast to existing complete techniques, we resort to restructuring merely to remove obstacles to code motion, rather than to carry out the actual optimization.Guiding the optimization with a profile enables additional code growth reduction through selecting those duplications whose cost is justified by sufficient execution-time gains. The paper develops two methods for determining the optimization benefit of restructuring a program region, one based on path-profiles and the other on data-flow frequency analysis. Furthermore, the abstraction underlying the new PRE algorithm enables a simple formulation of speculative code motion guaranteed to have positive dynamic improvements. Finally, we show how to balance the three transformations (code motion, restructuring, and speculation) to achieve a near-complete PRE with very little code growth.We also present algorithms for efficiently computing dynamic benefits. In particular, using an elimination-style data-flow framework, we derive a demand-driven frequency analyzer whose cost can be controlled by permitting a bounded degree of conservative imprecision in the solution.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277653", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Mary Lou", + "last_name": "Soffa", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/pldi/BodikGS98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277659", + "title": "Register Promotion by Partial Redundancy Elimination of Loads and Stores", + "abstract": "An algorithm for register promotion is presented based on the observation that the circumstances for promoting a memory location’s value to register coincide with situations where the program exhibits partial redundancy between ac-cesses to the memory location. The recent SSAPRE al-gorithm for eliminating partial redundancy using a sparse SSA representation forms the foundation for the present al-gorithm to eliminate redundancy among memory accesses, enabling us to achieve both computational and live range op-timality in our register promotion results. We discuss how to effect speculative code motion in the SSAPRE framework. We present two different algorithms for performing specu-lative code motion: the conservative speculation algorithm used in the absence of profile data, and the the profile-driven", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277659", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Raymond", + "last_name": "Lo", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Fred", + "last_name": "Chow", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Robert E.", + "last_name": "Kennedy", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Shin-Ming", + "last_name": "Liu", + "institution": "Silicon Labs (United States)" + }, + { + "first_name": "Peng", + "last_name": "Tu", + "institution": "Silicon Labs (United States)" + } + ], + "dblp_key": "conf/pldi/ChowKLLT98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277667", + "title": "Partial Online Cycle Elimination in Inclusion Constraint Graphs", + "abstract": "Many program analyses are naturally formulated and implemented using inclusion constraints. We present new results on the scalable implementation of such analyses based on two insights: first, that online elimination of cyclic constraints yields orders-of-magnitude improvements in analysis time for large problems; second, that the choice of constraint representation affects the quality and efficiency of online cycle elimination. We present an analytical model that explains our design choices and show that the model's predictions match well with results from a substantial experiment.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277667", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/FahndrichFSA98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277740", + "title": "Fast, Effective Code Generation in a Just-In-Time Java Compiler", + "abstract": "A Just-In-Time (JIT) Java compiler produces native code from Java byte code instructions during program execution. As such, compilation speed is more important in a Java JIT compiler than in a traditional compiler, requiring optimization algorithms to be lightweight and effective. We present the structure of a Java JIT compiler for the Intel Architecture, describe the lightweight implementation of JIT compiler optimizations (e.g., common subexpression elimination, register allocation, and elimination of array bounds checking), and evaluate the performance benefits and tradeoffs of the optimizations. This JIT compiler has been shipped with version 2.5 of Intel's VTune for Java product.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277740", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Oracle (United States)" + }, + { + "first_name": "Michał", + "last_name": "Cierniak", + "institution": "Mission College" + }, + { + "first_name": "Guei-Yuan", + "last_name": "Lueh", + "institution": "Intel (United States)" + }, + { + "first_name": "Vishesh M.", + "last_name": "Parikh", + "institution": "Intel (United States)" + }, + { + "first_name": "James M.", + "last_name": "Stichnoth", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/Adl-TabatabaiCLPS98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277664", + "title": "Simplification of Array Access Patterns for Compiler Optimizations", + "abstract": "Existing array region representation techniques are sensitive to the complexity of array subscripts. In general, these techniques are very accurate and efficient for simple subscript expressions, but lose accuracy or require potentially expensive algorithms for complex subscripts. We found that in scientific applications, many access patterns are simple even when the subscript expressions are complex. In this work, we present a new, general array access representation and define operations for it. This allows us to aggregate and simplify the representation enough that precise region operations may be applied to enable compiler optimizations. Our experiments show that these techniques hold promise for speeding up applications.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277664", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yunheung", + "last_name": "Paek", + "institution": "New Jersey Institute of Technology" + }, + { + "first_name": "Jay", + "last_name": "Hoeflinger", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/PaekHP98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277663", + "title": "The Implementation and Evaluation of Fusion and Contraction in Array Languages", + "abstract": "Array languages such as Fortran 90, HPF and ZPL have many benefits in simplifying array-based computations and expressing data parallelism. However, they can suffer large performance penalties because they introduce intermediate arrays---both at the source level and during the compilation process---which increase memory usage and pollute the cache. Most compilers address this problem by simply scalarizing the array language and relying on a scalar language compiler to perform loop fusion and array contraction. We instead show that there are advantages to performing a form of loop fusion and array contraction at the array level. This paper describes this approach and explains its advantages. Experimental results show that our scheme typically yields runtime improvements of greater than 20% and sometimes up to 400%. In addition, it yields superior memory use when compared against commercial compilers and exhibits comparable memory use when compared with scalar languages. We also explore the interaction between these transformations and communication optimizations.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277663", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "E. Christopher", + "last_name": "Lewis", + "institution": "University of Washington" + }, + { + "first_name": "Calvin", + "last_name": "Lin", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Lawrence", + "last_name": "Snyder", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/LewisLS98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277752", + "title": "The Design and Implementation of a Certifying Compiler", + "abstract": "This paper presents the design and implementation of a compiler that translates programs written in a type-safe subset of the C programming language into highly optimized DEC Alpha assembly language programs, and a certifier that automatically checks the type safety and memory safety of any assembly language program produced by the compiler. The result of the certifier is either a formal proof of type safety or a counterexample pointing to a potential violation of the type system by the target program. The ensemble of the compiler and the certifier is called a certifying compiler.Several advantages of certifying compilation over previous approaches can be claimed. The notion of a certifying compiler is significantly easier to employ than a formal compiler verification, in part because it is generally easier to verify the correctness of the result of a computation than to prove the correctness of the computation itself. Also, the approach can be applied even to highly optimizing compilers, as demonstrated by the fact that our compiler generates target code, for a range of realistic C programs, which is competitive with both the cc and gcc compilers with all optimizations enabled. The certifier also drastically improves the effectiveness of compiler testing because, for each test case, it statically signals compilation errors that might otherwise require many executions to detect. Finally, this approach is a practical way to produce the safety proofs for a Proof-Carrying Code system, and thus may be useful in a system for safe mobile code.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277752", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Peter", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/NeculaL98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277715", + "title": "An Implementation for Complete, Asynchronous, Distributed Garbage Collection", + "abstract": "Most existing reference-based distributed object systems include some kind of acyclic garbage collection, but fail to provide acceptable collection of cyclic garbage. Those that do provide such GC currently suffer from one or more problems: synchronous operation, the need for expensive global consensus or termination algorithms, susceptibility to communication problems, or an algorithm that does not scale. We present a simple, complete, fault-tolerant, asynchronous extension to the (acyclic) cleanup protocol of the SSP Chains system. This extension is scalable, consumes few resources, and could easily be adapted to work in other reference-based distributed object systems---rendering them usable for very large-scale applications.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277715", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fabrice Le", + "last_name": "Fessant", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Ian", + "last_name": "Piumarta", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Marc", + "last_name": "Shapiro", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/FessantPS98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277661", + "title": "Data Transformations for Eliminating Conflict Misses", + "abstract": "Many cache misses in scientific programs are due to conflicts caused by limited set associativity. We examine two compile-time data-layout transformations for eliminating conflict misses, concentrating on misses occuring on every loop iteration. Inter-variable padding adjusts variable base addresses, while intra-variable padding modifies array dimension sizes. Two levels of precision are evaluated. PADLITE only uses array and column dimension sizes, relying on assumptions about common array reference patterns. PAD analyzes programs, detecting conflict misses by linearizing array references and calculating conflict distances between uniformly-generated references. The Euclidean algorithm for computing the gcd of two numbers is used to predict conflicts between different array columns for linear algebra codes. Experiments on a range of programs indicate PADLITE can eliminate conflicts for benchmarks, but PAD is more effective over a range of cache and problem sizes. Padding reduces cache miss rates by 16% on average for a 16K direct-mapped cache. Execution times are reduced by 6% on average, with some SPEC95 programs improving up to 15%.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277661", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Rivera", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Chau‐Wen", + "last_name": "Tseng", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/RiveraT98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277709", + "title": "Exploiting Idle Floating-Point Resources for Integer Execution", + "abstract": "In conventional superscalar microarchitectures with partitioned integer and floating-point resources, all floating-point resources are idle during execution of integer programs. Palacharla and Smith [26] addressed this drawback and proposed that the floating-point subsystem be augmented to support integer operations. The hardware changes required are expected to be fairly minimal.To exploit these idle floating resources, the compiler must identify integer code that can be profitably offloaded to the augmented floating-point subsystem. In this paper, we present two compiler algorithms to do this. The basic scheme offloads integer computation to the floating-point subsystem using existing program loads/stores for inter-partition communication. For the SPECINT95 benchmarks, we show that this scheme offloads from 5% to 29% of the total dynamic instructions to the floating-point subsystem. The advanced scheme inserts copy instructions and duplicates some instructions to further offload computation. We evaluate the effectiveness of the two schemes using timing simulation. We show that the advanced scheme can offload from 9% to 41% of the total dynamic instructions to the floating-point subsystem. In doing so, speedups from 3% to 23% are achieved over a conventional microarchitecture.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277709", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shiva", + "last_name": "Sastry", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Subbarao", + "last_name": "Palacharla", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "James E.", + "last_name": "Smith", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/SastryPS98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277714", + "title": "Quality and Speed in Linear-scan Register Allocation", + "abstract": "A linear-scan algorithm directs the global allocation of register candidates to registers based on a simple linear sweep over the program being compiled. This approach to register allocation makes sense for systems, such as those for dynamic compilation, where compilation speed is important. In contrast, most commercial and research optimizing compilers rely on a graph-coloring approach to global register allocation. In this paper, we compare the performance of a linear-scan method against a modern graph-coloring method. We implement both register allocators within the Machine SUIF extension of the Stanford SUIF compiler system. Experimental results show that linear scan is much faster than coloring on benchmarks with large numbers of register candidates. We also describe improvements to the linear-scan approach that do not change its linear character, but allow it to produce code of a quality near to that produced by graph coloring.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277714", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Omri", + "last_name": "Traub", + "institution": "Harvard University" + }, + { + "first_name": "Glenn", + "last_name": "Holloway", + "institution": "Harvard University" + }, + { + "first_name": "Michael D.", + "last_name": "Smith", + "institution": "Harvard University" + } + ], + "dblp_key": "conf/pldi/TraubHS98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277727", + "title": "Run-time Code Generation and Modal-ML", + "abstract": "This paper presents a typed programming language and compiler for run-time code generation. The language, called ML', extends ML with modal operators in the style of the Mini-ML'e language of Davies and Pfenning. ML' allows programmers to use types to specify precisely the stages of computation in a program. The types also guide the compiler in generating target code that exploits the staging information through the use of run-time code generation. The target machine is currently a version of the Categorical Abstract Machine, called the CCAM, which we have extended with facilities for run-time code generation.This approach allows the programmer to express the staging that he wants directly to the compiler. It also provides a typed framework in which to verify the correctness of his staging intentions, and to discuss his staging decisions with other programmers. Finally, it supports in a natural way multiple stages of run-time specialization, so that dynamically generated code can be used in the generation of yet further specialized code.This paper presents an overview of the language, with several examples of programs that illustrate key concepts and programming techniques. Then, it discusses the CCAM and the compilation of ML' programs into CCAM code. Finally, the results of some experiments are shown, to demonstrate the benefits of this style of run-time code generation for some applications.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277727", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Philip", + "last_name": "Wickline", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Peter", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/WicklineLP98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277750", + "title": "A Study of Dead Data Members in C++ Applications", + "abstract": "Object-oriented applications may contain data members that can be removed from the application without affecting program behavior. Such \"dead\" data members may occur due to unused functionality in class libraries, or due to the programmer losing track of member usage as the application changes over time. We present a simple and efficient algorithm for detecting dead data members in C++ applications. This algorithm has been implemented using a prototype version of the IBM VisualAge C++ compiler, and applied to a number of realistic benchmark programs ranging from 600 to 58,000 lines of code. For the non-trivial benchmarks, we found that up to 27.3% of the data members in the benchmarks are dead (average 12.5%), and that up to 11.6% of the object space of these applications may be occupied by dead data members at run-time (average 4.4%).", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277750", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter F.", + "last_name": "Sweeney", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/SweeneyT98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277723", + "title": "Communication Optimizations for Parallel C Programs", + "abstract": "This paper presents algorithms for reducing the communication overhead for parallel C programs that use dynamically-allocated data structures. The framework consists of an analysis phase called possible-placement analysis, and a transformation phase called communication selection.The fundamental idea of possible-placement analysis is to find all possible points for insertion of remote memory operations. Remote reads are propagated upwards, whereas remote writes are propagated downwards. Based on the results of the possible-placement analysis, the communication selection transformation selects the \"best\" place for inserting the communication, and determines if pipelining or blocking of communication should be performed.The framework has been implemented in the EARTH-McCAT optimizing/parallelizing C compiler, and experimental results are presented for five pointer-intensive benchmarks running on the EARTH-MANNA distributed-memory parallel architecture. These experiments show that the communication optimization can provide performance improvements of up to 16% over the unoptimized benchmarks.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277723", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yingchun", + "last_name": "Zhu", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/pldi/ZhuH98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277711", + "title": "Improving Performance by Branch Reordering", + "abstract": "The conditional branch has long been considered an expensive operation. The relative cost of conditional branches has increased as recently designed machines are now relying on deeper pipelines and higher multiple issue. Reducing the number of conditional branches executed can often result in a substantial performance benefit. This paper describes a code-improving transformation to reorder sequences of conditional branches. First, sequences of branches that can be reordered are detected in the control flow. Second, profiling information is collected to predict the probability that each branch will transfer control out of the sequence. Third, the cost of performing each conditional branch is estimated. Fourth, the most beneficial ordering of the branches based on the estimated probability and cost is selected. The most beneficial ordering often included the insertion of additional conditional branches that did not previously exist in the sequence. Finally, the control flow is restructured to refflect the new ordering. The results of applying the transformation were significant reductions in the dynamic number of instructions and branches, as well as decreases in execution time.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277711", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Minghui", + "last_name": "Yang", + "institution": "Florida State University" + }, + { + "first_name": "Gang‐Ryung", + "last_name": "Uh", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Whalley", + "institution": "Florida State University" + } + ], + "dblp_key": "conf/pldi/YangUW98", + "venue": "pldi", + "year": 1998 + }, + { + "paper_id": "10.1145/277650.277732", + "title": "Eliminating Array Bound Checking Through Dependent Types", + "abstract": "We present a type-based approach to eliminating array bound checking and list tag checking by conservatively extending Standard ML with a restricted form of dependent types. This enables the programmer to capture more invariants through types while type-checking remains decidable in theory and can still be performed efficiently in practice. We illustrate our approach through concrete examples and present the result of our preliminary experiments which support support the feasibility and effectiveness of our approach.", + "date": "1998-05-01", + "link": "https://doi.org/10.1145/277650.277732", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongwei", + "last_name": "Xi", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/XiP98", + "venue": "pldi", + "year": 1998 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/1999.json b/data/pl_conferences/pldi/1999.json new file mode 100644 index 0000000..8459c5b --- /dev/null +++ b/data/pl_conferences/pldi/1999.json @@ -0,0 +1,665 @@ +[ + { + "paper_id": "10.1145/301618.301655", + "title": "Enhanced Code Compression for Embedded RISC Processors", + "abstract": "This paper explores compiler techniques for reducing the memory needed to load and run program executables. In embedded systems, where economic incentives to reduce both ram and rom are strong, the size of compiled code is increasingly important. Similarly, in mobile and network computing, the need to transmit an executable before running it places a premium on code size. Our work focuses on reducing the size of a program&apos;s code segment, using pattern-matching techniques to identify and coalesce together repeated instruction sequences. In contrast to other methods, our framework preserves the ability to run program executables directly, without an intervening decompression stage. Our compression framework is integrated into an industrial-strength optimizing compiler, which allows us to explore the interaction between code compression and classical code optimization techniques, and requires that we contend with the difficulties of compressing previously optimized code. The specific contributions in this paper include a comprehensive experimental evaluation of code compression for a Risc-like architecture, a more powerful pattern-matching scheme for improved identification of repeated code fragments, and a new form of profile-driven code compression that reduces the speed penalty arising from compression.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301655", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + }, + { + "first_name": "Nathaniel", + "last_name": "McIntosh", + "institution": "Hewlett-Packard (Canada)" + } + ], + "dblp_key": "conf/pldi/CooperM99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301638", + "title": "The Design of a Class Mechanism for Moby", + "abstract": "Typical class-based languages, such as C++ and JAVA, provide complex class mechanisms but only weak module systems. In fact, classes in these languages incorporate many of the features found in richer module mechanisms. In this paper, we describe an alternative approach to designing a language that has both classes and modules. In our design, we rely on a rich ML-style module system to provide features such as visibility control and parameterization, while providing a minimal class mechanism that includes only those features needed to support inheritance. Programmers can then use the combination of modules and classes to implement the full range of class-based features and idioms. Our approach has the advantage that it provides a full-featured module system (useful in its own right), while keeping the class mechanism quite simple.We have incorporated this design in MOBY, which is an ML-style language that supports class-based object-oriented programming. In this paper, we describe our design via a series of simple examples, show how various class-based features and idioms are realized in MOBY, compare our design with others, and sketch its formal semantics.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301638", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "AT&T (United States)" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/pldi/FisherR99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301637", + "title": "A Semantics for Imprecise Exceptions", + "abstract": "Some modern superscalar microprocessors provide only imprecise exceptions. That is, they do not guarantee to report the same exception that would be encountered by a straightforward sequential execution of the program. In exchange, they offer increased performance or decreased chip area (which amount to much the same thing).This performance/precision tradeoff has not so far been much explored at the programming language level. In this paper we propose a design for imprecise exceptions in the lazy functional programming language Haskell. We discuss several designs, and conclude that imprecision is essential if the language is still to enjoy its current rich algebra of transformations. We sketch a precise semantics for the language extended with exceptions.The paper shows how to extend Haskell with exceptions without crippling the language or its compilers. We do not yet have enough experience of using the new mechanism to know whether it strikes an appropriate balance between expressiveness and performance.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301637", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Alastair", + "last_name": "Reid", + "institution": "Yale University" + }, + { + "first_name": "Fergus", + "last_name": "Henderson", + "institution": "University of Melbourne" + }, + { + "first_name": "Tony", + "last_name": "Hoare", + "institution": "Bridge University" + }, + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/JonesRHHM99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301665", + "title": "A Theory of Type Qualifiers", + "abstract": "We describe a framework for adding type qualifiers to a language. Type qualifiers encode a simple but highly useful form of subtyping. Our framework extends standard type rules to model the flow of qualifiers through a program, where each qualifier or set of qualifiers comes with additional rules that capture its semantics. Our framework allows types to be polymorphic in the type qualifiers. We present a const-inference system for C as an example application of the framework. We show that for a set of real C programs, many more consts can be used than are actually present in the original code.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301665", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/FosterFA99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301670", + "title": "Improving Cache Performance in Dynamic Applications through Data and Computation Reorganization at Run Time", + "abstract": "With the rapid improvement of processor speed, performance of the memory hierarchy has become the principal bottleneck for most applications. A number of compiler transformations have been developed to improve data reuse in cache and registers, thus reducing the total number of direct memory accesses in a program. Until now, however, most data reuse transformations have been static---applied only at compile time. As a result, these transformations cannot be used to optimize irregular and dynamic applications, in which the data layout and data access patterns remain unknown until run time and may even change during the computation.In this paper, we explore ways to achieve better data reuse in irregular and dynamic applications by building on the inspector-executor method used by Saltz for run-time parallelization. In particular, we present and evaluate a dynamic approach for improving both computation and data locality in irregular programs. Our results demonstrate that run-time program transformations can substantially improve computation and data locality and, despite the complexity and cost involved, a compiler can automate such transformations, eliminating much of the associated run-time overhead.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301670", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/DingK99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301635", + "title": "Cache-Conscious Structure Definition", + "abstract": "A program's cache performance can be improved by changing the organization and layout of its data---even complex, pointer-based data structures. Previous techniques improved the cache performance of these structures by arranging distinct instances to increase reference locality. These techniques produced significant performance improvements, but worked best for small structures that could be packed into a cache block.This paper extends that work by concentrating on the internal organization of fields in a data structure. It describes two techniques---structure splitting and field reordering---that improve the cache behavior of structures larger than a cache block. For structures comparable in size to a cache block, structure splitting can increase the number of hot fields that can be placed in a cache block. In five Java programs, structure splitting reduced cache miss rates 10--27% and improved performance 6--18% beyond the benefits of previously described cache-conscious reorganization techniques.For large structures, which span many cache blocks, reordering fields, to place those with high temporal affinity in the same cache block can also improve cache utilization. This paper describes bbcache, a tool that recommends C structure field reorderings. Preliminary measurements indicate that reordering fields in 5 active structures improves the performance of Microsoft SQL Server 7.0 2--3%.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301635", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Bob", + "last_name": "Davidson", + "institution": "Microsoft (United States)" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/ChilimbiDL99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301678", + "title": "Whole Program Paths", + "abstract": "Whole program paths (WPP) are a new approach to capturing and representing a program's dynamic---actually executed---control flow. Unlike other path profiling techniques, which record intraprocedural or acyclic paths, WPPs produce a single, compact description of a program's entire control flow, including loop iteration and interprocedural paths.This paper explains how to collect and represent WPPs. It also shows how to use WPPs to find hot subpaths, which are the heavily executed sequences of code that should be the focus of performance tuning and compiler optimization.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301678", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Larus99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301661", + "title": "A Fast Fourier Transform Compiler", + "abstract": "The FFTW library for computing the discrete Fourier transform (DFT) has gained a wide acceptance in both academia and industry, because it provides excellent performance on a variety of machines (even competitive with or faster than equivalent libraries supplied by vendors). In FFTW, most of the performance-critical code was generated automatically by a special-purpose compiler, called genfft, that outputs C code. Written in Objective Caml, genfft can produce DFT programs for any input length, and it can specialize the DFT program for the common case where the input data are real instead of complex. Unexpectedly, genfft \"discovered\" algorithms that were previously unknown, and it was able to reduce the arithmetic complexity of some other existing algorithms. This paper describes the internals of this special-purpose compiler in some detail, and it argues that a specialized compiler is a valuable tool.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301661", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matteo", + "last_name": "Frigo", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Frigo99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301648", + "title": "On Bounding Time and Space for Multiprocessor Garbage Collection", + "abstract": "This paper presents the first multiprocessor garbage collection algorithm with provable bounds on time and space. The algorithm is a real-time shared-memory copying collector. We prove that the algorithm requires at most 2(R(l + 2/k) + N + 5PD) memory locations, where P is the number of processors, R is the maximum reachable space during a computation (number of locations accessible from the root set), N is the maximum number of reachable objects, D is the maximum depth of any data object, and k is a parameter specifying how many locations are copied each time a location is allocated. Furthermore we show that client threads are never stopped for more than time proportional to k non-blocking machine instructions. The bounds are guaranteed even with arbitrary length arrays. The collector only requires write-barriers (reads are unaffected by the collector), makes few assumptions about the threads that are generating the garbage, and allows them to run mostly asynchronously.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301648", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "Perry", + "last_name": "Cheng", + "institution": "Laboratoire d'Informatique de Paris-Nord" + } + ], + "dblp_key": "conf/pldi/BlellochC99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301683", + "title": "An Evaluation of Staged Run-Time Optimizations in DyC", + "abstract": "Previous selective dynamic compilation systems have demonstrated that dynamic compilation can achieve performance improvements at low cost on small kernels, but they have had difficulty scaling to larger programs. To overcome this limitation, we developed DyC, a selective dynamic compilation system that includes more sophisticated and flexible analyses and transformations. DyC is able to achieve good performance improvements on programs that are much larger and more complex than the kernels. We analyze the individual optimizations of DyC and assess their impact on performance collectively and individually.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301683", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brian", + "last_name": "Grant", + "institution": "University of Washington" + }, + { + "first_name": "Matthai", + "last_name": "Philipose", + "institution": "University of Washington" + }, + { + "first_name": "Markus", + "last_name": "Mock", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + }, + { + "first_name": "Susan J.", + "last_name": "Eggers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/GrantPMCE99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301643", + "title": "Load-Reuse Analysis: Design and Evaluation", + "abstract": "Load-reuse analysis finds instructions that repeatedly access the same memory location. This location can be promoted to a register, eliminating redundant loads by reusing the results of prior memory accesses. This paper develops a load-reuse analysis and designs a method for evaluating its precision.In designing the analysis, we aspire for completeness---the goal of exposing all reuse that can be harvested by a subsequent program transformation. For register promotion, a suitable transformation is partial redundancy elimination (PRE). To approach the ideal goal of PRE-completeness, the load-reuse analysis is phrased as a data-flow problem on a program representation that is path-sensitive, as it detects reuse even when it originates in a different instruction along each control flow path. Furthermore, the analysis is comprehensive, as it treats scalar, array and pointer-based loads uniformly.In evaluating the analysis, we compare it with an ideal analysis. By observing the run-time stream of memory references, we collect all PRE-exploitable reuse and treat it as the ideal analysis performance. To compare the (static) load-reuse analysis with the (dynamic) ideal reuse, we use an estimator algorithm that computes, given a data-flow solution and a program profile, the dynamic amount of reuse detected by the analysis. We developed a family of estimators that differ in how well they bound the profiling error inherent in the edge profile. By bounding the error, the estimators offer a precise and practical method for determining the run-time optimization benefit.Our experiments show that about 55% of loads executed in Spec95 exhibit reuse. Of those, our analysis exposes about 80%.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301643", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Mary Lou", + "last_name": "Soffa", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/pldi/BodikGS99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301645", + "title": "Pointer Analysis for Multithreaded Programs", + "abstract": "This paper presents a novel interprocedural, flow-sensitive, and context-sensitive pointer analysis algorithm for multithreaded programs that may concurrently update shared pointers. For each pointer and each program point, the algorithm computes a conservative approximation of the memory locations to which that pointer may point. The algorithm correctly handles a full range of constructs in multithreaded programs, including recursive functions, function pointers, structures, arrays, nested structures and arrays, pointer arithmetic, casts between pointer variables of different types, heap and stack allocated memory, shared global variables, and thread-private global variables. We have implemented the algorithm in the SUIF compiler system and used the implementation to analyze a sizable set of multithreaded programs written in the Cilk multithreaded programming language. Our experimental results show that the analysis has good precision and converges quickly for our set of Cilk programs. 1", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301645", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Radu", + "last_name": "Rugina", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/RuginaR99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301633", + "title": "Cache-Conscious Structure Layout", + "abstract": "Hardware trends have produced an increasing disparity between processor speeds and memory access times. While a variety of techniques for tolerating or reducing memory latency have been proposed, these are rarely successful for pointer-manipulating programs.This paper explores a complementary approach that attacks the source (poor reference locality) of the problem rather than its manifestation (memory latency). It demonstrates that careful data organization and layout provides an essential mechanism to improve the cache locality of pointer-manipulating programs and consequently, their performance. It explores two placement techniques---clustering and coloring---that improve cache performance by increasing a pointer structure's spatial and temporal locality, and by reducing cache-conflicts.To reduce the cost of applying these techniques, this paper discusses two strategies---cache-conscious reorganization and cache-conscious allocation---and describes two semi-automatic tools---ccmorph and ccmalloc---that use these strategies to produce cache-conscious pointer structure layouts. ccmorph is a transparent tree reorganizer that utilizes topology information to cluster and color the structure. ccmalloc is a cache-conscious heap allocator that attempts to co-locate contemporaneously accessed data elements in the same physical cache block. Our evaluations, with microbenchmarks, several small benchmarks, and a couple of large real-world applications, demonstrate that the cache-conscious structure layouts produced by ccmorph and ccmalloc offer large performance benefits---in most cases, significantly outperforming state-of-the-art prefetching.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301633", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Mark D.", + "last_name": "Hill", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/ChilimbiHL99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301641", + "title": "What is a Recursive Module?", + "abstract": "A hierarchical module system is an effective tool for structuring large programs. Strictly hierarchical module systems impose an acyclic ordering on import dependencies among program units. This can impede modular programming by forcing mutually-dependent components to be consolidated into a single module. Recently there have been several proposals for module systems that admit cyclic dependencies, but it is not clear how these proposals relate to one another, nor how one might integrate them into an expressive module system such as that of ML.To address this question we provide a type-theoretic analysis of the notion of a recursive module in the context of a \"phase-distinction\" formalism for higher-order module systems. We extend this calculus with a recursive module mechanism and a new form of signature, called a recursively dependent signature, to support the definition of recursive modules. These extensions are justified by an interpretation in terms of more primitive language constructs. This interpretation may also serve as a guide for implementation.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301641", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sidd", + "last_name": "Puri", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/CraryHP99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301672", + "title": "Automatic Inference of Models for Statistical Code Compression", + "abstract": "This paper describes experiments that apply machine learning to compress computer programs, formalizing and automating decisions about instruction encoding that have traditionally been made by humans in a more ad hoc manner. A program accepts a large training set of program material in a conventional compiler intermediate representation (IR) and automatically infers a decision tree that separates IR code into streams that compress much better than the undifferentiated whole. Driving a conventional arithmetic compressor with this model yields code 30% smaller than the previous record for IR code compression, and 24% smaller than an ambitious optimizing compiler feeding an ambitious general-purpose data compressor.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301672", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Fraser99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301680", + "title": "Finite-Static Code Generation", + "abstract": "This paper describes gburg, which generates tiny, fast code generators based on finite-state machine pattern matching. The code generators translate postfix intermediate code into machine instructions in one pass (except, of course, for backpatching addresses) . A stack-based virtual machine---known as the Lean Virtual Machine (LVM)---tuned for fast code generation is also described. Gburg translates the two-page LVM-to-x86 specification into a code generator that fits entirely in an 8 KB I-cache and that emits x86 code at 3.6 MB/sec on a 266-MHz P6. Our just-in-time code generator translates and executes small benchmarks at speeds within a factor of two of executables derived from the conventional compile-time code generator on which it is based. 1 Introduction To execute virtual machine (VM) code on a client processor typically requires either a VM interpreter or a just-in-time (JIT) translator. Conventional wisdom dictates that the space/time tradeo# favors the interpreter approac...", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301680", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/FraserP99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301653", + "title": "Storage Assignment Optimizations to Generate Compact and Efficient Code on Embedded DSPs", + "abstract": "DSP architectures typically provide dedicated memory address generation units and indirect addressing modes with auto-increment and auto-decrement that subsume address arithmetic calculation. The heavy use of auto-increment and auto-decrement indirect addressing require DSP compilers to perform a careful placement of variables in storage to minimize address arithmetic instructions to generate compact and efficient DSP code. Liao et al. [11] formulated the problem of storage assignment as the simple o set assignment problem (SOA) and the general offset assignment problem (GOA), and proposed heuristic solutions. The storage allocation of variables critically depends on the sequence of variable accesses. In this paper we present techniques to optimize the access sequence of variables by applying algebraic transformations (such as commutativity and associativity) on expression trees to obtain the least cost offset assignment. We develop a new formulation of this problem as the least cost acces...", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301653", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amit", + "last_name": "Rao", + "institution": "Synopsys (United States)" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "University of Cincinnati" + } + ], + "dblp_key": "conf/pldi/RaoP99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301668", + "title": "New Tiling Techniques to Improve Cache Temporal Locality", + "abstract": "Tiling is a well-known loop transformation to improve temporal locality of nested loops. Current compiler algorithms for tiling are limited to loops which are perfectly nested or can be transformed, in trivial ways, into a perfect nest. This paper presents a number of program transformations to enable tiling for a class of nontrivial imperfectly-nested loops such that cache locality is improved. We define a program model for such loops and develop compiler algorithms for their tiling. We propose to adopt odd-even variable duplication to break anti- and output dependences without unduly increasing the working-set size, and to adopt speculative execution to enable tiling of loops which may terminate prematurely due to, e.g. convergence tests in iterative algorithms. We have implemented these techniques in a research compiler, Panorama. Initial experiments with several benchmark programs are performed on SGI workstations based on MIPS R5K and R10K processors. Overall, the transformed programs run faster by 9% to 164%.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301668", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yonghong", + "last_name": "Song", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Zhiyuan", + "last_name": "Li", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/SongL99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301681", + "title": "Efficient Incremental Run-Time Specialization for Free", + "abstract": "Availability of data in a program determines computation stages. Incremental partial evaluation exploit these stages for optimization: it allows further specialization to be performed as data become available at later stages. The fundamental advantage of incremental specialization is to factorize the specialization process. As a result, specializing a program at a given stage costs considerably less than specializing it once all the data are available.We present a realistic and flexible approach to achieve efficient incremental run-time specialization. Rather than developing specific techniques, as previously proposed, we are able to re-use existing technology by iterating a specialization process. Moreover, in doing so, we do not lose any specialization opportunities. This approach makes it possible to exploit nested quasi-invariants and to speed up the run-time specialization process.This approach has been implemented in Tempo, a specializer for C programs that is publicly available. A preliminary experiment confirm that incremental that incremental specialization can greatly speed up the specialization process.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301681", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Renaud", + "last_name": "Marlet", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Charles", + "last_name": "Consel", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Philippe", + "last_name": "Boinot", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + } + ], + "dblp_key": "conf/pldi/MarletCB99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301659", + "title": "Control CPR: A Branch Height Reduction Optimization for EPIC Architectures", + "abstract": "The challenge of exploiting high degrees of instruction-level parallelism is often hampered by frequent branching. Both exposed branch latency and low branch throughput can restrict parallelism. Control critical path reduction (control CPR) is a compilation technique to address these problems. Control CPR can reduce the dependence height of critical paths through branch operations as well as decrease the number of executed branches. In this paper, we present an approach to control CPR that recognizes sequences of branches using profiling statistics. The control CPR transformation is applied to the predominant path through this sequence. Our approach, its implementation, and experimental results are presented. This work demonstrates that control CPR enhances instruction-level parallelism for a variety of application programs and improves their performance across a range of processors.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301659", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Schlansker", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Richard", + "last_name": "Johnson", + "institution": "" + } + ], + "dblp_key": "conf/pldi/SchlanskerMJ99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301647", + "title": "Pointer Analysis for Programs with Structures and Casting", + "abstract": "Type casting allows a program to access an object as if it had a type different from its declared type. This complicates the design of a pointer-analysis algorithm that treats structure fields as separate objects; therefore, some previous pointer-analysis algorithms &quot;collapse&quot; a structure into a single variable. The disadvantage of this approach is that it can lead to very imprecise points-to information. Other algorithms treat each field as a separate object based on its offset and size. While this approach leads to more precise results, the results are not portable because the memory layout of structures is implementation dependent. This paper first describes the complications introduced by type casting, then presents a tunable pointer-analysis framework for handling structures in the presence of casting. Different instances of this framework produce algorithms with different levels of precision, portability, and efficiency. Experimental results from running our implementations of f...", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301647", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Suan Hsi", + "last_name": "Yong", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/YongHR99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301676", + "title": "Compressing Java Class Files", + "abstract": "Java class files are often distributed as jar files, which are collections of individually compressed class files (and possibility other files). Jar files are typically about 1/2 the size of the original class files due to compression. I have developed a wire-code format for collections of Java class files. This format is typically 1/2 to 1/5 of the size of the corresponding compressed jar file (1/4 to 1/10 the size of the original class files).", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301676", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Pugh", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/Pugh99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301667", + "title": "Static Single Assignment Form for machine Code", + "abstract": "Static Single Assignment (SSA) is an effective intermediate representation in optimizing compilers. However, traditional SSA form and optimizations are not applicable to programs represented as native machine instructions because the use of dedicated registers imposed by calling conventions, the runtime system, and target architecture must be made explicit. We present a simple scheme for converting between programs in machine code and in SSA, such that references to dedicated physical registers in machine code are preserved. Our scheme ignores all output- and anti-dependences imposed by physical registers while a program is in SSA form, but inserts compensation code during machine code reconstruction if any naming requirements have been violated. By resolving all mismatches between the two representations in separate phases, we are able to utilize existing SSA algorithms unaltered to perform machine code optimizations.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301667", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Allen", + "last_name": "Leung", + "institution": "New York University" + }, + { + "first_name": "Lal", + "last_name": "George", + "institution": "" + } + ], + "dblp_key": "conf/pldi/LeungG99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301652", + "title": "Support for Garbage Collection at Every Instruction in a Java Compiler", + "abstract": "A high-performance implementation of a Java Virtual Machine1 requires a compiler to translate Java bytecodes into native instructions, as well as an advanced garbage collector (e.g., copying or generational). When the Java heap is exhausted and the garbage collector executes, the compiler must report to the garbage collector all live object references contained in physical registers and stack locations. Typical compilers only allow certain instructions (e.g., call instructions and backward branches) to be GC-safe; if GC happens at some other instruction, the compiler may need to advance execution to the next GC-safe point. Until now, no one has ever attempted to make every compiler-generated instruction GC-safe, due to the perception that recording this information would require too much space. This kind of support could improve the GC performance in multithreaded applications. We show how to use simple compression techniques to reduce the size of the GC map to about 20% of the generated code size, a result that is competitive with the best previously published results. In addition, we extend the work of Agesen, Detlefs, and Moss, regarding the so-called \"JSR Problem\" (the single exception to Java's type safety property), in a way that eliminates the need for extra runtime overhead in the generated code.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301652", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James M.", + "last_name": "Stichnoth", + "institution": "Intel (United States)" + }, + { + "first_name": "Guei-Yuan", + "last_name": "Lueh", + "institution": "Mission College" + }, + { + "first_name": "Michał", + "last_name": "Cierniak", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/StichnothLC99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301663", + "title": "A New Framework for Debugging Globally Optimized Code", + "abstract": "With an increasing number of executable binaries generated by optimizing compilers today, providing a clear and correct source-level debugger for programmers to debug optimized code has become a necessity. In this paper, a new framework for debugging globally optimized code is proposed. This framework consists of a new code location mapping scheme, a data location tracking scheme, and an emulation-based forward recovery model. By taking over the control early and emulating instructions selectively, the debugger can preserve and gather the required program state for the recovery of expected variable values at source breakpoints. The framework has been prototyped in the IMPACT compiler and GDB-4.16. Preliminary experiments conducted on several SPEC95 integer programs have yielded encouraging results. The extra time needed for the debugger to calculate the limits of the emulated region and to emulate instructions is hardly noticeable, while the increase in executable file size due to the extra debug information is on average 76% of that of the executable file with no debug information.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301663", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Le-Chun", + "last_name": "Wu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Rajiv", + "last_name": "Mirani", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Harish", + "last_name": "Patil", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Bruce S.", + "last_name": "Olsen", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Wen‐mei", + "last_name": "Hwu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/WuMPOH99", + "venue": "pldi", + "year": 1999 + }, + { + "paper_id": "10.1145/301618.301657", + "title": "Using Node Merging to Enhance Graph Coloring", + "abstract": "A Chaitin-style register allocator often blocks during its simplification phase because no node in the interference graph has a degree that is sufficiently small. Typically, this is handled by node-splitting, or by optimistically continuing---and hoping that a legal N-coloring will still be found. We observe that the merging of two nodes in a graph causes a reduction in the degree of any node that had been adjacent to both. We have enhanced Chaitin's coloring algorithm so that it attempts node-merging during graph simplification; this often allows simplification to continue, while still guaranteeing a coloring for the graph. We have tested this algorithm using Appel's database of register-coloring graphs, and have compared it with Chaitin's algorithm. The merge-enhanced algorithm yields a better coloring about 8% of the time, and a worse coloring less than 0.1% of the time.", + "date": "1999-05-01", + "link": "https://doi.org/10.1145/301618.301657", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven R.", + "last_name": "Vegdahl", + "institution": "University of Portland" + } + ], + "dblp_key": "conf/pldi/Vegdahl99", + "venue": "pldi", + "year": 1999 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2000.json b/data/pl_conferences/pldi/2000.json new file mode 100644 index 0000000..1f09405 --- /dev/null +++ b/data/pl_conferences/pldi/2000.json @@ -0,0 +1,757 @@ +[ + { + "paper_id": "10.1145/349299.349330", + "title": "On loops, dominators, and dominance frontier", + "abstract": "Article On loops, dominators, and dominance frontier Share on Author: G. Ramalingam IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile Authors Info & Claims PLDI '00: Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementationAugust 2000 Pages 233–241https://doi.org/10.1145/349299.349330Published:01 May 2000 18citation836DownloadsMetricsTotal Citations18Total Downloads836Last 12 Months6Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349330", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/Ramalingam00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349320", + "title": "Exploiting superword level parallelism with multimedia instruction sets", + "abstract": "Increasing focus on multimedia applications has prompted the addition of multimedia extensions to most existing general purpose microprocessors. This added functionality comes primarily with the addition of short SIMD instructions. Unfortunately, access to these instructions is limited to in-line assembly and library calls. Generally, it has been assumed that vector compilers provide the most promising means of exploiting multimedia instructions. Although vectorization technology is well understood, it is inherently complex and fragile. In addition, it is incapable of locating SIMD-style parallelism within a basic block.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349320", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "S.", + "last_name": "Larsen", + "institution": "" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "" + } + ], + "dblp_key": "conf/pldi/LarsenA00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349303", + "title": "Dynamo: a transparent dynamic optimization system", + "abstract": "We describe the design and implementation of Dynamo, a software dynamic optimization system that is capable of transparently improving the performance of a native instruction stream as it executes on the processor. The input native instruction stream to Dynamo can be dynamically generated (by a JIT for example), or it can come from the execution of a statically compiled native binary. This paper evaluates the Dynamo system in the latter, more challenging situation, in order to emphasize the limits, rather than the potential, of the system. Our experiments demonstrate that even statically optimized native binaries can be accelerated Dynamo, and often by a significant degree. For example, the average performance of -O optimized SpecInt95 benchmark binaries created by the HP product C compiler is improved to a level comparable to their -O4 optimized version running without Dynamo. Dynamo achieves this by focusing its efforts on optimization opportunities that tend to manifest only at runtime, and hence opportunities that might be difficult for a static compiler to exploit. Dynamo's operation is transparent in the sense that it does not depend on any user annotations or binary instrumentation, and does not require multiple runs, or any special compiler, operating system or hardware support. The Dynamo prototype presented here is a realistic implementation running on an HP PA-8000 workstation under the HPUX 10.20 operating system.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349303", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vasanth", + "last_name": "Bala", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Evelyn", + "last_name": "Duesterwald", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Sanjeev", + "last_name": "Banerjia", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/BalaDB00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349343", + "title": "Field analysis: getting useful and low-cost interprocedural information", + "abstract": "We present a new limited form of interprocedural analysis called field analysis that can be used by a compiler to reduce the costs of modern language features such as object-oriented programming, automatic memory management, and run-time checks required for type safety. Unlike many previous interprocedural analyses, our analysis is cheap, and does not require access to the entire program. Field analysis exploits the declared access restrictions placed on fields in a modular language (e.g. field access modifiers in Java) in order to determine useful properties of fields of an object. We describe our implementation of field analysis in the Swift optimizing compiler for Java, as well a set of optimizations that exploit the results of field analysis. These optimizations include removal of run-time tests, compile-time resolution of method calls, object inlining, removal of unnecessary synchronization, and stack allocation. Our results demonstrate that field analysis is efficient and effective. Speedups average 7% on a wide range of applications, with some times reduced by up to 27%. Compile time overhead of field analysis is about 10%.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349343", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sanjay", + "last_name": "Ghemawat", + "institution": "Google (United States)" + }, + { + "first_name": "Keith H.", + "last_name": "Randall", + "institution": "" + }, + { + "first_name": "Daniel J.", + "last_name": "Scales", + "institution": "" + } + ], + "dblp_key": "conf/pldi/GhemawatRS00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349306", + "title": "Practicing JUDO: Java under dynamic optimizations", + "abstract": "A high-performance implementation of a Java Virtual Machine (JVM) consists of efficient implementation of Just-In-Time (JIT) compilation, exception handling, synchronization mechanism, and garbage collection (GC). These components are tightly coupled to achieve high performance. In this paper, we present some static anddynamic techniques implemented in the JIT compilation and exception handling of the Microprocessor Research Lab Virtual Machine (MRL VM), i.e., lazy exceptions, lazy GC mapping, dynamic patching, and bounds checking elimination. Our experiments used IA-32 as the hardware platform, but the optimizations can be generalized to other architectures.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349306", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michał", + "last_name": "Cierniak", + "institution": "Intel (United States)" + }, + { + "first_name": "Guei-Yuan", + "last_name": "Lueh", + "institution": "Mission College" + }, + { + "first_name": "James M.", + "last_name": "Stichnoth", + "institution": "" + } + ], + "dblp_key": "conf/pldi/CierniakLS00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349322", + "title": "Compiler analysis of irregular memory accesses", + "abstract": "Irregular array accesses are array accesses whose array subscripts do not have closed-form expressions in terms of loop indices. Traditional array analysis and loop transformation techniques cannot handle irregular array accesses. In this paper, we study two kinds of simple and common cases of irregular array accesses: single-indexed access and indirect array access. We present techniques to analyze these two cases at compile-time, and we provide experimental results showing the effectiveness of these techniques in finding more implicit loop parallelism at compile-time and improved speedups.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349322", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuan", + "last_name": "Lin", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/LinP00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349317", + "title": "Bitwidth analysis with application to silicon compilation", + "abstract": "This paper introduces Bitwise, a compiler that minimizes the bitwidth the number of bits used to represent each operand for both integers and pointers in a program. By propagating 70 static information both forward and backward in the program dataflow graph, Bitwise frees the programmer from declaring bitwidth invariants in cases where the compiler can determine bitwidths automatically. Because loop instructions comprise the bulk of dynamically executed instructions, Bitwise incorporates sophisticated loop analysis techniques for identifying bitwidths. We find a rich opportunity for bitwidth reduction in modern multimedia and streaming application workloads. For new architectures that support sub-word data-types, we expect that our bitwidth reductions will save power and increase processor performance.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349317", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark W.", + "last_name": "Stephenson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jonathan", + "last_name": "Babb", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/StephensonBA00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349307", + "title": "Split-stream dictionary program compression", + "abstract": "This paper describes split-stream dictionary (SSD) compression, a new technique for transforming programs into a compact, interpretable form. We define a compressed program as interpretable when it can be decompressed at basic-block granularity with reasonable efficiency. The granularity requirement enables interpreters or just-in-time (JIT) translators to decompress basic blocks incrementally during program execution. Our previous approach to interpretable compression, the Byte-coded RISC (BRISC) program format [1], achieved unprecedented decompression speed in excess of 5 megabytes per second on a 450MHz Pentium II while compressing benchmark programs to an average of three-fifths the size of their optimized x86 representation. SSD compression combines the key idea behind BRISC with new observations about instruction re-use frequencies to yield four advantages over BRISC and other competing techniques. First, SSD is simple, requiring only a few pages of code for an effective implementation. Second, SSD compresses programs more effectively than any interpretable program compression scheme known to us. For example, SSD compressed a set of programs including the spec95 benchmarks and Microsoft Word97 to less than half the size, on average, of their optimized x86 representation. Third, SSD exceeds BRISC's decompression and JIT translation rates by over 50%. Finally, SSD's two-phased approach to JIT translation enables a virtual machine to provide graceful degradation of program execution time in the face of increasing RAM constraints. For example, using SSD, we ran Word97 using a JIT-translation buffer one-third the size of Word97's optimized x86 code, yet incurred only 27% execution time overhead.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349307", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven", + "last_name": "Lucco", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Lucco00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349331", + "title": "Functional reactive programming from first principles", + "abstract": "Functional Reactive Programming, or FRP, is a general framework for programming hybrid systems in a high-level, declarative manner. The key ideas in FRP are its notions of behaviors and events. Behaviors are time-varying, reactive values, while events are time-ordered sequences of discrete-time event occurrences. FRP is the essence of Fran, a domain-specific language embedded in Haskell for programming reactive animations, but FRP is now also being used in vision, robotics and other control systems applications.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349331", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhanyong", + "last_name": "Wan", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/WanH00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349327", + "title": "Effective synchronization removal for Java", + "abstract": "We present a new technique for removing unnecessary synchronization operations from statically compiled Java programs. Our approach improves upon current efforts based on escape analysis, as it can eliminate synchronization operations even on objects that escape their allocating threads. It makes use of a compact, equivalence-class-based representation that eliminates the need for fixed point operations during the analysis.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349327", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Erik", + "last_name": "Ruf", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Ruf00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349336", + "title": "A generational on-the-fly garbage collector for Java", + "abstract": "An on-the-fly garbage collector does not stop the program threads to perform the collection. Instead, the collector executes in a separate thread (or process) in parallel to the program. On-the-fly collectors are useful for multi-threaded applications running on multiprocessor servers, where it is important to fully utilize all processors and provide even response time, especially for systems for which stopping the threads is a costly operation.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349336", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tamar", + "last_name": "Domani", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Elliot K.", + "last_name": "Kolodner", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/DomaniKP00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349309", + "title": "Unification-based pointer analysis with directional assignments", + "abstract": "This paper describes a new algorithm for flow and context insensitive pointer analysis of C programs. Our studies show that the most common use of pointers in C programs is in passing the addresses of composite objects or updateable values as arguments to procedures. Therefore, we have designed a low-cost algorithm that handles this common case accurately. In terms of both precision and running time, this algorithm lies between Steensgaard's algorithm, which treats assignments bi-directionally using unification, and Andersen's algorithm, which treats assignments directionally using subtyping. Our “one level flow” algorithm uses a restricted form of subtyping to avoid unification of symbols at the top levels of pointer chains in the points-to graph, while using unification elsewhere in the graph. The method scales easily to large programs. For instance, we are able to analyze a 1.4 MLOC (million lines of code) program in two minutes, using less than 200MB of memory. At the same time, the precision of our algorithm is very close to that of Andersen's algorithm. On all of the integer benchmark programs from SPEC95, the one level flow algorithm and Andersen's algorithm produce either identical or essentially identical points-to information. Therefore, we claim that our algorithm provides a method for obtaining precise flow-insensitive points-to information for large C programs.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349309", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manuvir", + "last_name": "Das", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Das00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349311", + "title": "Modular interprocedural pointer analysis using access paths: design, implementation, and evaluation", + "abstract": "In this paper we present a modular interprocedural pointer analysis algorithm based on access-paths for C programs. We argue that access paths can reduce the overhead of representing context-sensitive transfer functions and effectively distinguish non-recursive heap objects. And when the modular analysis paradigm is used together with other techniques to handle type casts and function pointers, we are able to handle significant programs like those in the SPECcint92 and SPECcint95 suites. We have implemented the algorithm and tested it on a Pentium II 450 PC running Linux. The observed resource consumption and performance improvement are very encouraging.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349311", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben-Chung", + "last_name": "Cheng", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Wen‐mei", + "last_name": "Hwu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/ChengH00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349314", + "title": "Translation validation for an optimizing compiler", + "abstract": "We describe a translation validation infrastructure for the GNU C compiler. During the compilation the infrastructure compares the intermediate form of the program before and after each compiler pass and verifies the preservation of semantics. We discuss a general framework that the optimizer can use to communicate to the validator what transformations were performed. Our implementation however does not rely on help from the optimizer and it is quite successful by using instead a few heuristics to detect the transformations that take place.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349314", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/Necula00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349339", + "title": "Efficient algorithms for bidirectional debugging", + "abstract": "This paper discusses our research into algorithms for creating an efficient bidirectional debugger in which all traditional forward movement commands can be performed with equal ease in the reverse direction. We expect that adding these backwards movement capabilities to a debugger will greatly increase its efficacy as a programming tool.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349339", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bob", + "last_name": "Boothe", + "institution": "University of Southern Maine" + } + ], + "dblp_key": "conf/pldi/Boothe00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349325", + "title": "Symbolic bounds analysis of pointers, array indices, and accessed memory regions", + "abstract": "This paper presents a novel framework for the symbolic bounds analysis of pointers, array indices, and accessed memory regions. Our framework formulates each analysis problem as a system of inequality constraints between symbolic bound polynomials. It then reduces the constraint system to a linear program. The solution to the linear program provides symbolic lower and upper bounds for the values of pointer and array index variables and for the regions of memory that each statement and procedure accesses. This approach eliminates fundamental problems associated with applying standard fixed-point approaches to symbolic analysis problems. Experimental results from our implemented compiler show that the analysis can solve several important problems, including static race detection, automatic parallelization, static detection of array bounds violations, elimination of array bounds checks, and reduction of the number of bits used to store computed values.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349325", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Radu", + "last_name": "Rugina", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/RuginaR00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349328", + "title": "Type-based race detection for Java", + "abstract": "This paper presents a static race detection analysis for multithreaded Java programs. Our analysis is based on a formal type system that is capable of capturing many common synchronization patterns. These patterns include classes with internal synchronization, classes thatrequire client-side synchronization, and thread-local classes. Experience checking over 40,000 lines of Java code with the type system demonstrates that it is an effective approach for eliminating races conditions. On large examples, fewer than 20 additional type annotations per 1000 lines of code were required by the type checker, and we found a number of races in the standard Java libraries and other test programs.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349328", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/FlanaganF00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349332", + "title": "Scalable context-sensitive flow analysis using instantiation constraints", + "abstract": "This paper shows that a type graph (obtained via polymorphic type inference) harbors explicit directional flow paths between functions. These flow paths arise from the instantiations of polymorphic types and correspond to call-return sequences in first-order programs. We show that flow information can be computed efficiently while considering only paths with well matched call-return sequences, even in the higher-order case. Furthermore, we present a practical algorithm for inferring type instantiation graphs and provide empirical evidence to the scalability of the presented techniques by applying them in the context of points-to analysis for C programs.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349332", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Manuvir", + "last_name": "Das", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/FahndrichRD00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349334", + "title": "Contaminated garbage collection", + "abstract": "We describe a new method for determining when an object can be garbage collected. The method does not require marking live objects. Instead, each object X is dynamically associated with a stack frame M, such that Xis collectable when M pops. Because X could have been dead earlier, our method is conservative. Our results demonstrate that the method nonetheless identifies a large percentage of collectable objects. The method has been implemented in Sun's Java Virtual Machine interpreter, and results are presented based on this implementation", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349334", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dante J.", + "last_name": "Cannarozzi", + "institution": "Ophthalmology Consultants" + }, + { + "first_name": "Michael P.", + "last_name": "Plezbert", + "institution": "Ophthalmology Consultants" + }, + { + "first_name": "Ron K.", + "last_name": "Cytron", + "institution": "Ophthalmology Consultants" + } + ], + "dblp_key": "conf/pldi/CannarozziPC00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349342", + "title": "ABCD: eliminating array bounds checks on demand", + "abstract": "To guarantee typesafe execution, Java and other strongly typed languages require bounds checking of array accesses. Because array-bounds checks may raise exceptions, they block code motion of instructions with side effects, thus preventing many useful code optimizations, such as partial redundancy elimination or instruction scheduling of memory operations. Furthermore, because it is not expressible at bytecode level, the elimination of bounds checks can only be performed at run time, after the bytecode program is loaded. Using existing powerful bounds-check optimizers at run time is not feasible, however, because they are too heavyweight for the dynamic compilation setting.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349342", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Arizona" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/BodikGS00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349337", + "title": "A single intermediate language that supports multiple implementations of exceptions", + "abstract": "We present mechanisms that enable our compiler-target language, C--, to express four of the best known techniques for implementing exceptions, all within a single, uniform framework. We define the mechanisms precisely, using a formal operational semantics. We also show that exceptions need not require special treatment in the optimizer; by introducing extra dataflow edges, we make standard optimization techniques work even on programs that use exceptions. Our approach clarifies the design space of exception-handling techniques, and it allows a single optimizer to handle a variety of implementation techniques. Our ultimate goal is to allow a source-language compiler the freedom to choose its exception-handling policy, while encapsulating the architecture-dependent mechanisms and their optimization in an implementation of C--that can be used by compilers for many source languages.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349337", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Harvard University Press" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/RamseyJ00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349315", + "title": "A certifying compiler for Java", + "abstract": "This paper presents the initial results of a project to determine if the techniques of proof-carrying code and certifying compilers can be applied to programming languages of realistic size and complexity. The experiment shows that: (1) it is possible to implement a certifying native-code compiler for a large subset of the Java programming language; (2) the compiler is freely able to apply many standard local and global optimizations; and (3) the PCC binaries it produces are of reasonable size and can be rapidly checked for type safety by a small proof-checker. This paper also presents further evidence that PCC provides several advantages for compiler development. In particular, generating proofs of the target code helps to identify compiler bugs, many of which would have been dicult to discover by testing.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349315", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Colby", + "institution": "" + }, + { + "first_name": "Peter", + "last_name": "Lee", + "institution": "" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "" + }, + { + "first_name": "Fred", + "last_name": "Blau", + "institution": "" + }, + { + "first_name": "M.", + "last_name": "Pleško", + "institution": "" + }, + { + "first_name": "Kenneth", + "last_name": "Cline", + "institution": "" + } + ], + "dblp_key": "conf/pldi/ColbyLNBPC00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349341", + "title": "Caching function calls using precise dependencies", + "abstract": "This paper describes the implementation of a purely functional programming language for building software systems. In this language, external tools like compilers and linkers are invoked by function calls. Because some function calls are extremely expensive, it is obviously important to reuse the results of previous function calls whenever possible. Caching a function call requires the language interpreter to record all values on which the function call depends. For optimal caching, it is important to record precise dependencies that are both dynamic and fine-grained. The paper sketches how we compute such dependencies, describes the implementation of an e#cient function cache, and evaluates our implementation&apos;s performance. 1 Introduction We consider the problem of implementing a pure functional language in which some function calls are expected to be extremely costly. This problem arises in the context of the Vesta software configuration management system, a system for managing and...", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349341", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Allan", + "last_name": "Heydon", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Roy", + "last_name": "Levin", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Yuan", + "last_name": "Yu", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/pldi/HeydonLY00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349344", + "title": "An automatic object inlining optimization and its evaluation", + "abstract": "Automatic object inlining [19, 20] transforms heap data structures by fusing parent and child objects together. It can improve runtime by reducing object allocation and pointer dereference costs. We report continuing work studying object inlining optimizations. In particular, we present a new semantic derivation of the correctness conditions for object inlining, and program analysis which extends our previous work. And we present an object inlining transformation, focusing on a new algorithm which optimizes class field layout to minimize code expansion. Finally, we detail a fuller evaluation on eleven programs and libraries (including Xpdf, the 25,000 line Portable Document Format (PDF) le browser) that utilizes hardware measures of impact on the memory system. We show that our analysis scales effectively to large programs, nding many inlinable elds (45 in xpdf) at acceptable cost, and we show that, on some programs, it finds nearly all fields for which object inlining is correct, and a...", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349344", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Andrew A.", + "last_name": "Chien", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/DolbyC00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349310", + "title": "Off-line variable substitution for scaling points-to analysis", + "abstract": "Most compiler optimizations and software productivity tools rely on information about the effects of pointer dereferences in a program. The purpose of points-to analysis is to compute this information safely, and as accurately as is practical. Unfortunately, accurate points-to information is difficult to obtain for large programs, because the time and space requirements of the analysis become prohibitive.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349310", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "Rutgers Sexual and Reproductive Health and Rights" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/pldi/RouhtevC00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349313", + "title": "Safety checking of machine code", + "abstract": ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iii Contents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iv List of Figures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .viii 1 Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1 1.1 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.2 Organization of Dissertation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2 Related Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11 2.1 Safety Checking . . . . . . . . . . . . . . . . . . . . . . . . . . . ....", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349313", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhichen", + "last_name": "Xu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Barton P.", + "last_name": "Miller", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/XuMR00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349318", + "title": "Optimal instruction scheduling using integer programming", + "abstract": "This paper presents a new approach to local instruction scheduling based on integer programming that produces optimal instruction schedules in a reasonable time, even for very large basic blocks. The new approach first uses a set of graph transformations to simplify the data-dependency graph while preserving the optimality of the final schedule. The simplified graph results in a simplified integer program which can be solved much faster. A new integer-programming formulation is then applied to the simplified graph. Various techniques are used to simplify the formulation, resulting in fewer integer-program variables, fewer integer-program constraints and fewer terms in some of the remaining constraints, thus reducing integer-program solution time. The new formulation also uses certain adaptively added constraints (cuts) to reduce solution time. The proposed optimal instruction scheduler is built within the Gnu Compiler Collection (GCC) and is evaluated experimentally using the SPEC95 floating point benchmarks. Although optimal scheduling for the target processor is considered intractable, all of the benchmarks' basic blocks are optimally scheduled, including blocks with up to 1000 instructions, while total compile time increases by only 14%.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349318", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kent", + "last_name": "Wilken", + "institution": "University of California, Davis" + }, + { + "first_name": "Jack", + "last_name": "Liu", + "institution": "University of California, Davis" + }, + { + "first_name": "Mark", + "last_name": "Heffernan", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/WilkenLH00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349319", + "title": "Improved spill code generation for software pipelined loops", + "abstract": "Software pipelining is a loop scheduling technique that extracts parallelism out of loops by overlapping the execution of several consecutive iterations. Due to the overlapping of iterations, schedules impose high register requirements during their execution. A schedule is valid if it requires at most the number of registers available in the target architecture. If not, its register requirements have to be reduced either by decreasing the iteration overlapping or by spilling registers to memory. In this paper we describe a set of heuristics to increase the quality of register-constrained modulo schedules. The heuristics decide between the two previous alternatives and define criteria for effectively selecting spilling candidates. The heuristics proposed for reducing the register pressure can be applied to any software pipelining technique. The proposals are evaluated using a register-conscious software pipeliner on a workbench composed of a large set of loops from the Perfect Club benchmark and a set of processor configurations. Proposals in this paper are compared against a previous proposal already described in the literature. For one of these processor configurations and the set of loops that do not fit in the available registers (32), a speed-up of 1.68 and a reduction of the memory traffic by a factor of 0.57 are achieved with an affordable increase in compilation time. For all the loops, this represents a speed-up of 1.38 and a reduction of the memory traffic by a factor of 0.7.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349319", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Javier", + "last_name": "Zalamea", + "institution": "Universitat Politècnica de Catalunya" + }, + { + "first_name": "Josep", + "last_name": "Llosa", + "institution": "Universitat Politècnica de Catalunya" + }, + { + "first_name": "Eduard", + "last_name": "Ayguadé", + "institution": "Universitat Politècnica de Catalunya" + }, + { + "first_name": "Mateo", + "last_name": "Valero", + "institution": "Universitat Politècnica de Catalunya" + } + ], + "dblp_key": "conf/pldi/ZalameaLAV00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349323", + "title": "Transforming loops to recursion for multi-level memory hierarchies", + "abstract": "Recently, there have been several experimental and theoretical results showing significant performance benefits of recursive algorithms on both multi-level memory hierarchies and on shared-memory systems. In particular, such algorithms have the data reuse characteristics of a blocked algorithm that is simultaneously blocked at many different levels. Most existing applications, however, are written using ordinary loops. We present a new compiler transformation that can be used to convert loop nests into recursive form automatically. We show that the algorithm is fast and effective, handling loop nests with arbitrary nesting and control flow. The transformation achieves substantial performance improvements for several linear algebra codes even on a current system with a two level cache hierarchy. As a side-effect of this work, we also develop an improved algorithm for transitive dependence analysis (a powerful technique used in the recursion transformation and other loop transformations)that is much faster than the best previously known algorithm in practice.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349323", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qing", + "last_name": "Yi", + "institution": "Rice University" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/YiAK00", + "venue": "pldi", + "year": 2000 + }, + { + "paper_id": "10.1145/349299.349326", + "title": "A framework for interprocedural optimization in the presence of dynamic class loading", + "abstract": "Dynamic class loading during program execution in the Java Programming Language is an impediment for generating code that is as efficient as code generated using static whole-program analysis and optimization. Whole-program analysis and optimization is possible for languages, such as C++, that do not allow new classes and/or methods to be loaded during program execution. One solution for performing whole-program analysis and avoiding incorrect execution after a new class is loaded is to invalidate and recompile affected methods. Runtime invalidation and recompilation mechanisms can be expensive in both space and time, and, therefore, generally restrict optimization.", + "date": "2000-05-01", + "link": "https://doi.org/10.1145/349299.349326", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vugranam C.", + "last_name": "Sreedhar", + "institution": "IBM (United States)" + }, + { + "first_name": "Michael", + "last_name": "Burke", + "institution": "IBM (United States)" + }, + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/SreedharBC00", + "venue": "pldi", + "year": 2000 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2001.json b/data/pl_conferences/pldi/2001.json new file mode 100644 index 0000000..5d3fe1e --- /dev/null +++ b/data/pl_conferences/pldi/2001.json @@ -0,0 +1,802 @@ +[ + { + "paper_id": "10.1145/378795.378815", + "title": "Language Support for Regions", + "abstract": "Region-based memory management systems structure memory by grouping objects in regions under program control. Memory is reclaimed by deleting regions, freeing all objects stored therein. Our compiler for C with regions, RC, prevents unsafe region deletions by keeping a count of references to each region. Using type annotations that make the structure of a program's regions more explicit, we reduce the overhead of reference counting from a maximum of 27% to a maximum of 11% on a suite of realistic benchmarks. We generalise these annotations in a region type system whose main novelty is the use of existentially quantified abstract regions to represent pointers to objects whose region is partially or totally unknown. A distribution of RC is available at http://www.cs.berkeley.edu/~dgay/rc.tar.gz.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378815", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Gay", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/GayA01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378854", + "title": "Optimal Spilling for CISC Machines with Few Registers", + "abstract": "Many graph-coloring register-allocation algorithms don't work well for machines with few registers. Heuristics for live-range splitting are complex or suboptimal; heuristics for register assignment rarely factor the presence of fancy addressing modes; these problems are more severe the fewer registers there are to work with. We show how to optimally split live ranges and optimally use addressing modes, where the optimality condition measures dynamically weighted loads and stores but not register-register moves. Our algorithm uses integer linear programming but is much more efficient than previous ILP-based approaches to register allocation. We then show a variant of Park and Moon's optimistic coalescing algorithm that does a very good (though not provably optimal) job of removing the register-register moves. The result is Pentium code that is 9.5% faster than code generated by SSA-based splitting with iterated register coalescing.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378854", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "Lal", + "last_name": "George", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/pldi/AppelG01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378855", + "title": "Ultra-fast Aliasing Analysis using CLA: A Million Lines of C Code in a Second", + "abstract": "We describe the design and implementation of a system for very fast points-to analysis. On code bases of about million lines of unpreprocessed C code, our system performs field-based Andersen-style points-to analysis in less than a second and uses less than 10MB of memory. Our two main contributions are a database-centric analysis architecture called compile-link-analyze (CLA), and a new algorithm for implementing dynamic transitive closure. Our points-to analysis system is built into a forward data-dependence analysis tool that is deployed within Lucent to help with consistent type modifications to large legacy C code bases.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378855", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nevin", + "last_name": "Heintze", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Olivier", + "last_name": "Tardieu", + "institution": "École Nationale Supérieure des Mines de Paris" + } + ], + "dblp_key": "conf/pldi/HeintzeT01a", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378857", + "title": "Dynamic Variables", + "abstract": "Most programming languages use static scope rules for associating uses of identifiers with their declarations. Static scope helps catch errors at compile time, and it can be implemented efficiently. Some popular languages—Perl, Tel, TeX, and Postscript—offer dynamic scope, because dynamic scope works well for variables that “customize” the execution environment, for example. Programmers must simulate dynamic scope to implement this kind of usage in statically scoped languages. This paper describes the design and implementation of imperative language constructs for introducing and referencing dynamically scoped variables—dynamic variables for short. The design is a minimalist one, because dynamic variables are best used sparingly, much like exceptions. The facility does, however, cater to the typical uses for dynamic scope, and it provides a cleaner mechanism for so-called thread-local variables. A particularly simple implementation suffices for languages without exception handling. For languages with exception handling, a more efficient implementation builds on existing compiler infrastructure. Exception handling can be viewed as a control construct with dynamic scope. Likewise, dynamic variables are a data construct with dynamic scope.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378857", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David R.", + "last_name": "Hanson", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd A.", + "last_name": "Proebsting", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/HansonP01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378846", + "title": "Automatic Predicate Abstraction of C Programs", + "abstract": "Model checking has been widely successful in validating and debugging designs in the hardware and protocol domains. However, state-space explosion limits the applicability of model checking tools, so model checkers typically operate on abstractions of systems.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378846", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of Washington" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/BallMMR01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378862", + "title": "ESP: A Language for Programmable Devices", + "abstract": "This paper presents the design and implementation of Event-driven State-machines Programming (ESP)—a language for programmable devices. In traditional languages, like C, using event-driven state-machine forces a tradeoff that requires giving up ease of development and reliability to achieve high performance. ESP is designed to provide all of these three properties simultaneously.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378862", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sanjeev", + "last_name": "Kumar", + "institution": "Princeton University" + }, + { + "first_name": "Yitzhak", + "last_name": "Mandelbaum", + "institution": "Princeton University" + }, + { + "first_name": "Xiang", + "last_name": "Yu", + "institution": "Princeton University" + }, + { + "first_name": "Kai", + "last_name": "Li", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/KumarMYL01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378823", + "title": "A Parallel, Real-Time Garbage Collector", + "abstract": "A&apos;(=$B#127$C7D-7E&quot;#%9F&lt;\\t&gt;$7&apos;(-7:;&lt;&lt;&quot;G$&amp;%-\\t12-*#)+1+)H7IJ-&gt;0&quot; ;&lt;&lt;&quot;:&apos;(%-\\t1+687)29:K*,&lt;\\tB&gt;0&quot;$%L.M.D.&amp;%&lt;1+12%&amp;%7&lt;\\t&apos;K)2$&quot;#=$)2;\\t&gt;%&quot;ON5&lt;&apos;.$D-\\t&apos;(=&quot;P6 9F%9:&lt;\\t&apos;(IF9?B127)+/#&apos;(&lt;&amp;=%$$&lt;\\t&apos;($C-&gt;0&quot;Q)2$A*0-$%&quot;R&lt;&gt;S-\\t&gt;S%-\\t&apos;1+)2(&apos;C&amp;%&lt;1+12%&amp;%7&lt;\\t&apos; -12;&lt;&apos;)27D09UT VW84X.D)2&amp;YDG/&apos;(&lt;Z)2&quot;#%&quot;R[@%&quot;R*,&lt;B#&gt;&quot;$\\\\&lt;\\t&gt;]7D0C7)29FC-\\t&gt;I 7D&apos;(%-&quot;R9CB0$7./-\\tB$\\\\N5&lt;\\t&apos;K&amp;=&lt;\\t1+12%&amp;%7)2&lt;&gt;^LE_\\\\&lt;X.=Z3&apos;4$)+&gt;&amp;%`&lt;\\tB&apos;E%-\\t&apos;1+)23&apos; -12;&lt;&apos;)27D09aX.-$&quot;#%$)2;&gt;0=&quot;bN5&lt;&apos;K$)29c/12c-&gt;0-12I$)2$%40)27.D0-&quot;R$&lt;9Fd)29c6 /&apos;(-&amp;=7)2&amp;%-\\t1.Ne%-7B&apos;(%$%L`M.D#)2$C/0-/,3&apos;C/&apos;(%$3&gt;7$`7D0`%@73&gt;$)2&lt;\\t&gt;$c&gt;%&amp;36 =$$-\\t&apos;(IfNe&lt;\\t&apos;G-!/#&apos;(-&amp;%7)2&amp;%-\\t1`)29c/12%9:3&gt;7-7)2&lt;\\t&gt;hgi&apos;(%&quot;B0&amp;()+&gt;0;j%@&amp;=%$$)2Z )+&gt;7(&apos;12%-Z)+&gt;0;4kD-\\t&gt;&quot;1+)+&gt;0;!$7-&amp;l$\\\\-&gt;0&quot;!;\\t12&lt;*0-1Z\\t-&apos;)2-\\t*12%$%4^&apos;(%&quot;B&amp;3)+&gt;0; &quot;&lt;\\tB*12O-1+12&lt;&amp;%-7)2&lt;&gt;^4-&gt;0&quot;G$/,=&amp;3)2-\\t17&apos;(%-79F3&gt;7C&lt;\\tN12-&apos;(;:-&gt;0&quot;!$9:-\\t1+1 &lt;*m%&amp;%7$%LonK&gt;i)29c/12%9:3&gt;7-7)2&lt;\\t&gt;o*-$%&quot;j&lt;&gt;p7D0G9:&lt;&quot;)+[%&quot;q-12;&lt;6 &apos;)27D9r)2$G%Z-\\t1+B-7%&quot;p&lt;\\t&gt;p-J$=7R&lt;\\tNQstvuPwGxq*y3&gt;0&amp;D9:-\\t&apos;l$G&lt;&gt;pu B&gt;Jz&gt;73&apos;/&apos;)2$bs={{{{#4|-O}~\\t68X.-IGd127&apos;(-u/-\\t&apos;(&amp;(6K9?B127)+/&apos;(&lt;&amp;%%$6 $&lt;&apos;L!M&lt;G7D0:*,%$7`&lt;\\tNE&lt;B#&apos;:l&gt;&lt;X.12%&quot;#;4.7D)2$c)2$:7D:[#&apos;($7`)29c/#12(6 9F3&gt;7-7)2&lt;&gt;J&lt;N-c/-\\t&apos;(-1+123154^&apos;(%-1+67)29Fc;-\\t&apos;*-;`&amp;%&lt;1+12%&amp;%7&lt;\\t&apos;L M.Dc-Z(&apos;(-;Q&amp;%&lt;1+12%&amp;%7&lt;&apos;:$/,=%&quot;PB/J)2$FPL t:-7CO/&apos;(&lt;&amp;%%$$&lt;&apos;($c-&gt;0&quot; sPL -7FVb/&apos;(&lt;&amp;%%$$&lt;&apos;($%LjwG-@)29CB09r/-\\tB$G7)29:%$:&apos;(-\\t&gt;;RN&apos;(&lt;9 j9F$7&lt;ti9:$%Lr&gt;o&amp;%&lt;&gt;7&apos;(-$7%4:-i&gt;&lt;\\t&gt;65)+&gt;0&amp;(&apos;(%9:3&gt;7-1G&amp;%&lt;1+12%&amp;%7&lt;\\t&apos; X.D%7D3&apos;G;3&gt;0(&apos;(-7)2&lt;\\t&gt;-\\t1&lt;\\t&apos;R&gt;&lt;7(:...", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378823", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Perry", + "last_name": "Cheng", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Laboratoire d'Informatique de Paris-Nord" + } + ], + "dblp_key": "conf/pldi/ChengB01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378806", + "title": "On the Importance of Points-to Analysis and Other Memory Disambiguation Methods for C Programs", + "abstract": "In this paper, we evaluate the benefits achievable from pointer analysis and other memory disambiguation techniques for C/C++ programs, using the framework of the production compiler for the Intel ® Itanium TM processor. Most of the prior work on memory disambiguation has primarily focused on pointer analysis, and either presents only static estimates of the accuracy of the analysis (such as average points-to set size), or provides performance data in the context of certain individual optiraizations. In contrast, our study is based on a complete memory disambiguation framework that uses a whole set of techniques including pointer analysis. Further, it presents how various compiler analyses and optimizations interact with the memory disambiguator, evaluates how much they benefit from disambiguation, and measures the eventual impact on the performance of the program. The paper also analyzes the types of disambiguation queries that are typically received by the disambiguator, which disambiguation techniques prove most effective in resolving them, and what type of queries prove difficult to be resolved. The study is based on empirical data collected for the SPEC CINT2000 C/C++ programs, running on the Itanium processor. 1.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378806", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rakesh", + "last_name": "Ghiya", + "institution": "Intel (United States)" + }, + { + "first_name": "Daniel J.", + "last_name": "Lavery", + "institution": "Mission College" + }, + { + "first_name": "David", + "last_name": "Sehr", + "institution": "Mission College" + } + ], + "dblp_key": "conf/pldi/GhiyaLS01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378851", + "title": "The Pointer Assertion Logic Engine", + "abstract": "We present a new framework for verifying partial specifications of programs in order to catch type and memory errors and check data structure invariants. Our technique can verify a large class of data structures, namely all those that can be expressed as graph types. Earlier versions were restricted to simple special cases such as lists or trees. Even so, our current implementation is as fast as the previous specialized tools. Programs are annotated with partial specifications expressed in Pointer Assertion Logic, a new notation for expressing properties of the program store. We work in the logical tradition by encoding the programs and partial specifications as formulas in monadic second-order logic. Validity of these formulas is checked by the MONA tool, which also can provide explicit counterexamples to invalid formulas. To make verification decidable, the technique requires explicit loop and function call invariants. In return, the technique is highly modular: every statement of a given program is analyzed only once. The main target applications are safety-critical data-type algorithms, where the cost of annotating a program with invariants is justified by the value of being able to automatically verify complex properties of the program.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378851", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Michael I.", + "last_name": "Schwartzbach", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/pldi/MollerS01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378819", + "title": "Java without the Coffee Breaks: A Nonintrusive Multiprocessor Garbage Collector", + "abstract": "The deployment of Java as a concurrent programming language has created a critical need for high-performance, concurrent, and incremental multiprocessor garbage collection. We present the Recycler, a fully concurrent pure reference counting garbage collector that we have implemented in the Jalapeno Java virtual machine running on shared memory multiprocessors.While a variety of multiprocessor collectors have been proposed and some have been implemented, experimental data is limited and there is little quantitative basis for comparison between different algorithms. We present measurements of the Recycler and compare it against a non-concurrent but parallel load-balancing mark-and-sweep collector (that we also implemented in Jalapeno), and evaluate the classical tradeoff between response time and throughput.When processor or memory resources are limited, the Recycler runs at about 90% of the speed of the mark-and-sweep collector. However, with an extra processor to run collection and with a moderate amount of memory headroom, the Recycler is able to operate without ever blocking the mutators and achieves a maximum measured mutator delay of only 2.6 milliseconds for our benchmarks. End-to-end execution time is usually within 5%.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378819", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "C. R.", + "last_name": "Attanasio", + "institution": "IBM (United States)" + }, + { + "first_name": "Han B.", + "last_name": "Lee", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "V. T.", + "last_name": "Rajan", + "institution": "IBM (United States)" + }, + { + "first_name": "Stephen", + "last_name": "Smith", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/BaconALRS01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378831", + "title": "Using Annotation to Reduce Dynamic Optimization Time", + "abstract": "Dynamic compilation and optimization are widely used in heterogenous computing environments, in which an intermediate form of the code is compiled to native code during execution. An important trade off exists between the amount of time spent dynamically optimizing the program and the running time of the program. The time to perform dynamic optimizations can cause significant delays during execution and also prohibit performance gains that result from more complex optimization.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378831", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chandra", + "last_name": "Krintz", + "institution": "University of California, San Diego" + }, + { + "first_name": "Brad", + "last_name": "Calder", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/KrintzC01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378840", + "title": "Efficient Representations and Abstractions for Quantifying and Exploiting Data Reference Locality", + "abstract": "With the growing processor-memory performance gap, understanding and optimizing a program's reference locality, and consequently, its cache performance, is becoming increasingly important. Unfortunately, current reference locality optimizations rely on heuristics and are fairly ad-hoc. In addition, while optimization technology for improving instruction cache performance is fairly mature (though heuristic-based), data cache optimizations are still at an early stage. We believe the primary reason for this imbalance is the lack of a suitable representation of a program's dynamic data reference behavior and a quantitative basis for understanding this behavior.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378840", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Chilimbi01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378821", + "title": "Composing High-Performance Memory Allocators", + "abstract": "Current general-purpose memory allocators do not provide sufficient speed or flexibility for modern high-performance applications. Highly-tuned general purpose allocators have per-operation costs around one hundred cycles, while the cost of an operation in a custom memory allocator can be just a handful of cycles. To achieve high performance, programmers often write custom memory allocators from scratch -- a difficult and error-prone process. In this paper, we present a flexible and efficient infrastructure for building memory allocators that is based on C++ templates and inheritance. This novel approach allows programmers to build custom and general-purpose allocators as &quot;heap layers&quot; that can be composed without incurring any additional runtime overhead or additional programming cost. We show that this infrastructure simplifies allocator construction and results in allocators that either match or improve the performance of heavily-tuned allocators written in C, including the Kingsley allocator and the GNU obstack library. We further show this infrastructure can be used to rapidly build a general-purpose allocator that has performance comparable to the Lea allocator, one of the best uniprocessor allocators available. We thus demonstrate a clean, easy-to-use allocator interface that seamlessly combines the power and efficiency of any number of general and custom allocators within a single application. 1.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378821", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/BergerZM01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378802", + "title": "Demand-Driven Pointer Analysis", + "abstract": "Known algorithms for pointer analysis are “global” in the sense that they perform an exhaustive analysis of a program or program component. In this paper we introduce a demand-driven approach for pointer analysis. Specifically, we describe a demand-driven flow-insensitive, subset-based, con text-insensitive points-to analysis. Given a list of pointer variables (a query), our analysis performs just enough computation to determine the points-to sets for these query variables. Using deductive reachability formulations of both the exhaustive and the demand-driven analyses, we prove that our algorithm is correct. We also show that our analysis is optimal in the sense that it does not do more work than necessary. We illustrate the feasibility and efficiency of our analysis with an implementation of demand-driven points-to analysis for computing the call-graphs of C programs with function pointers. The performance of our system varies substantially across benchmarks - the main factor is how much of the points-to graph must be computed to determine the call-graph. For some benchmarks, only a small part of the points-to graph is needed (e.g pouray emacs and gcc), and here we see more than a 10x speedup. For other benchmarks (e.g. burlap and gimp), we need to compute most (> 95%) of the points-to graph, and here the demand-driven algorithm is considerably slower, because using the demand-driven algorithm is a slow method of computing the full points-to graph.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378802", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nevin", + "last_name": "Heintze", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Olivier", + "last_name": "Tardieu", + "institution": "École Nationale Supérieure des Mines de Paris" + } + ], + "dblp_key": "conf/pldi/HeintzeT01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378827", + "title": "Bytecode Compression via Profiled Grammar Rewriting", + "abstract": "This paper describes the design and implementation of a method for producing compact, bytecoded instruction sets and interpreters for them. It accepts a grammar for programs written using a simple bytecoded stack-based instruction set, as well as a training set of sample programs. The system transforms the grammar, creating an expanded grammar that represents the same language as the original grammar, but permits a shorter derivation of the sample programs and others like them. A program&apos;s derivation under the expanded grammar forms the compressed bytecode representation of the program. The interpreter for this bytecode is automatically generated from the original bytecode interpreter and the expanded grammar. Programs expressed using compressed bytecode can be substantially smaller than their original bytecode representation and even their machine code representation. For example, compression cuts the bytecode for lcc from 199KB to 58KB but increases the size of the interpreter by just over 11KB. Categories and Subject Descriptors D.3.3 [Programming Languages]: Processors---optimization, run-time environments. General Terms Algorithms, Performance, Design, Economics, Experimentation, Languages, Theory. Keywords Program compression, bytecode interpretation, variable-to-fixed length codes, context-free grammars. 1.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378827", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Evans", + "institution": "University of British Columbia" + }, + { + "first_name": "Christopher W.", + "last_name": "Fraser", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/EvansF01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378798", + "title": "Dynamic Software Updating", + "abstract": "Many important applications must run continuously and without interruption, yet must be changed to fix bugs or upgrade functionality. No prior general-purpose methodology for dynamic updating achieves a practical balance between flexibility, robustness, low overhead, and ease of use.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378798", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jonathan T.", + "last_name": "Moore", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Scott", + "last_name": "Nettles", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/HicksMN01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378832", + "title": "A Framework for Reducing the Cost of Instrumented Code", + "abstract": "Instrumenting code to collect profiling information can cause substantial execution overhead. This overhead makes instrumentation difficult to perform at runtime, often preventing many known offline feedback-directed optimizations from being used in online systems. This paper presents a general framework for performing instrumentation sampling to reduce the overhead of previously expensive instrumentation. The framework is simple and effective, using code-duplication and counter-based sampling to allow switching between instrumented and non-instrumented code.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378832", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/pldi/ArnoldR01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378797", + "title": "Design and Implementation of Generics for the .NET Common Language Runtime", + "abstract": "The Microsoft.NET Common Language Runtime provides a shared type system, intermediate language and dynamic execution environment for the implementation and inter-operation of multiple source languages. In this paper we extend it with direct support for parametric polymorphism (also known as generics), describing the design through examples written in an extended version of the C# programming language, and explaining aspects of implementation by reference to a prototype extension to the runtime.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378797", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Don", + "last_name": "Syme", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/KennedyS01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378859", + "title": "Exact Analysis of the Cache Behavior of Nested Loops", + "abstract": "We develop from first principles an exact model of the behavior of loop nests executing in a memory hicrarchy, by using a nontraditional classification of misses that has the key property of composability. We use Presburger formulas to express various kinds of misses as well as the state of the cache at the end of the loop nest. We use existing tools to simplify these formulas and to count cache misses. The model is powerful enough to handle imperfect loop nests and various flavors of non-linear array layouts based on bit interleaving of array indices. We also indicate how to handle modest levels of associativity, and how to perform limited symbolic analysis of cache behavior. The complexity of the formulas relates to the static structure of the loop nest rather than to its dynamic trip count, allowing our model to gain efficiency in counting cache misses by exploiting repetitive patterns of cache behavior. Validation against cache simulation confirms the exactness of our formulation. Our method can serve as the basis for a static performance predictor to guide program and data transformations to improve performance.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378859", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Siddhartha", + "last_name": "Chatterjee", + "institution": "University of North Carolina at Chapel Hill" + }, + { + "first_name": "Erin", + "last_name": "Parker", + "institution": "University of North Carolina at Chapel Hill" + }, + { + "first_name": "Philip J.", + "last_name": "Hanlon", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Alvin R.", + "last_name": "Lebeck", + "institution": "Duke University" + } + ], + "dblp_key": "conf/pldi/ChatterjeePHL01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378825", + "title": "SafeTSA: A Type Safe and Referentially Secure Mobile-Code Representation Based on Static Single Assignment Form", + "abstract": "Article Share on SafeTSA: a type safe and referentially secure mobile-code representation based on static single assignment form Authors: Wolfram Amme Department of Information and Computer Science, University of California, Irvine, CA Department of Information and Computer Science, University of California, Irvine, CAView Profile , Niall Dalton Department of Information and Computer Science, University of California, Irvine, CA Department of Information and Computer Science, University of California, Irvine, CAView Profile , Jeffery von Ronne Department of Information and Computer Science, University of California, Irvine, CA Department of Information and Computer Science, University of California, Irvine, CAView Profile , Michael Franz Department of Information and Computer Science, University of California, Irvine, CA Department of Information and Computer Science, University of California, Irvine, CAView Profile Authors Info & Claims PLDI '01: Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementationJune 2001 Pages 137–147https://doi.org/10.1145/378795.378825Online:01 May 2001Publication History 54citation815DownloadsMetricsTotal Citations54Total Downloads815Last 12 Months13Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378825", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wolfram", + "last_name": "Amme", + "institution": "University of California, Irvine" + }, + { + "first_name": "Niall", + "last_name": "Dalton", + "institution": "University of California, Irvine" + }, + { + "first_name": "Jeffery von", + "last_name": "Ronne", + "institution": "University of California, Irvine" + }, + { + "first_name": "Michael", + "last_name": "Franz", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/pldi/AmmeDFR01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378850", + "title": "Related Field Analysis", + "abstract": "We present an extension of field analysis (sec [4]) called related field analysis which is a general technique for proving relationships between two or more fields of an object. We demonstrate the feasibility and applicability of related field analysis by applying it to the problem of removing array bounds checks. For array bounds check removal, we define a pair of related fields to be an integer field and an array field for which the integer field has a known relationship to the length of the array. This related field information can then be used to remove array bounds checks from accesses to the array field. Our results show that related field analysis can remove an average of 50% of the dynamic array bounds checks on a wide range of applications.We describe the implementation of related field analysis in the Swift optimizing compiler for Java, as well as the optimizations that exploit the results of related field analysis.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378850", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aneesh", + "last_name": "Aggarwal", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Keith H.", + "last_name": "Randall", + "institution": "" + } + ], + "dblp_key": "conf/pldi/AggarwalR01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378811", + "title": "Enforcing High-Level Protocols in Low-Level Software", + "abstract": "The reliability of infrastructure software, such as operating sys-tems and web servers, is often hampered by the mismanagement of resources, such as memory and network connections. The Vault programming language allows a programmer to describe resource management protocols that the compiler can statically enforce. Such a protocol can specify that operations must be performed in a certain order and that certain operations must be performed before accessing a given data object. Furthermore, Vault enforces stati-cally that resources cannot be leaked. We validate the utility of our approach by enforcing protocols present in the interface between the Windows 2000 kernel and its device drivers. 1.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378811", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert", + "last_name": "DeLine", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/DeLineF01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378820", + "title": "Heap Profiling for Space-Efficient Java", + "abstract": "We present a heap-profiling tool for exploring the potential for space savings in Java programs. The output of the tool is used to direct rewriting of application source code in a way that allows more timely garbage collection (GC) of objects, thus saving space. The rewriting can also avoid allocating some objects that are never used.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378820", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ran", + "last_name": "Shaham", + "institution": "Tel Aviv University" + }, + { + "first_name": "Elliot K.", + "last_name": "Kolodner", + "institution": "IBM (United States)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/ShahamKS01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378858", + "title": "Asynchronous Exceptions in Haskell", + "abstract": "Asynchronous exceptions, such as timeouts are important for robust, modular programs, but are extremely difficult to program with — so much so that most programming languages either heavily restrict them or ban them altogether. We extend our earlier work, in which we added synchronous exceptions to Haskell, to support asynchronous exceptions too. Our design introduces scoped combinators for blocking and unblocking asynchronous interrupts, along with a somewhat surprising semantics for operations that can suspend. Uniquely, we also give a formal semantics for our system.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378858", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andrew", + "last_name": "Moran", + "institution": "Oregon Research Institute" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/pldi/MarlowJMR01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378864", + "title": "Facile: A Language and Compiler for High-Performance Processor Simulators", + "abstract": "Architectural simulators are essential tools for computer architecture and systems research and development. Simulators, however, are becoming frustratingly slow, because they must now model increasingly complex micro-architectures running realistic workloads. Previously, we developed a technique called fast-forwarding, which applied partial evaluation and mermoization to improve the performance of detailed architectural simulations by as much as an order of magnitude [14].", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378864", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Eric", + "last_name": "Schnarr", + "institution": "" + }, + { + "first_name": "Mark D.", + "last_name": "Hill", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/SchnarrHL01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378817", + "title": "Principled Scavenging", + "abstract": "Proof-carrying code and typed assembly languages aim to minimize the trusted computing base by directly certifying the actual machine code. Unfortunately, these systems cannot get rid of the dependency on a trusted garbage collector. Indeed, constructing a provably type-safe garbage collector is one of the major open problems in the area of certifying compilation.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378817", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Monnier", + "institution": "Yale University" + }, + { + "first_name": "Bratin", + "last_name": "Saha", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/MonnierSS01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378852", + "title": "A Unified Framework for Schedule and Storage Optimization", + "abstract": "We present a unified mathematical framework for analyzing the tradeoffs between parallelism and storage allocation within a parallelizing compiler. Using this framework, we show how to find a good storage mapping for a given schedule, a good schedule for a given storage mapping, and a good storage mapping that is valid for all legal schedules. We consider storage mappings that collapse one dimension of a multi-dimensional array, and programs that are in a single assignment form with a one-dimensional schedule. Our technique combines affine scheduling techniques with occupancy vector analysis and incorporates general affine dependences across statements and loop nests. We formulate the constraints imposed by the data dependences and storage mappings as a set of linear inequalities, and apply numerical programming techniques to efficiently solve for the shortest occupancy vector. We consider our method to be a first step towards automating a procedure that finds the optimal tradeoff between parallelism and storage space.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378852", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William", + "last_name": "Thies", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Frédéric", + "last_name": "Vivien", + "institution": "" + }, + { + "first_name": "Jeffrey", + "last_name": "Sheldon", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ThiesVSA01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378835", + "title": "Timestamped Whole Program Path Representation and its Applications", + "abstract": "A whole program path (WPP) is a complete control flow trace of a program's execution. Recently Larus [18] showed that although WPP is expected to be very large (100's of MBytes), it can be greatly compressed (to 10's of MBytes) and therefore saved for future analysis. While the compression algorithm proposed by Larus is highly effective, the compression is accompanied with a loss in the ease with which subsets of information can be accessed. In particular, path traces pertaining to a particular function cannot generally be obtained without examining the entire compressed WPP representation. To solve this problem we advocate the application of compaction techniques aimed at providing easy access to path traces on a per function basis.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378835", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Youtao", + "last_name": "Zhang", + "institution": "University of Arizona" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/ZhangG01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378804", + "title": "Incrementalized Pointer and Escape Analysis", + "abstract": "We present a new pointer and escape analysis. Instead of analyzing the whole program, the algorithm incrementally analyzes only those parts of the program that may deliver useful results. An analysis policy monitors the analysis results to direct the incremental investment of analysis resources to those parts of the program that offer the highest expected optimization return.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378804", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Frédéric", + "last_name": "Vivien", + "institution": "Université de Strasbourg" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/VivienR01", + "venue": "pldi", + "year": 2001 + }, + { + "paper_id": "10.1145/378795.378860", + "title": "SPL: A Language and Compiler for DSP Algorithms", + "abstract": "We discuss the design and implementation of a compiler that translates formulas representing signal processing transforms into efficient C or Fortran programs. The formulas are represented in a language that we call SPL, an acronym from Signal Processing Language. The compiler is a component of the SPIRAL system which makes use of formula transformations and intelligent search strategies to automatically generate optimized digital signal processing (DSP) libraries. After a discussion of the translation and optimization techniques implemented in the compiler, we use SPL formulations of the fast Fourier transform (FFT) to evaluate the compiler. Our results show that SPIRAL, which can be used to implement many classes of algorithms, produces programs that perform as well as “hard-wired” systems like FFTW.", + "date": "2001-05-01", + "link": "https://doi.org/10.1145/378795.378860", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jianxin", + "last_name": "Xiong", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Jeremy", + "last_name": "Johnson", + "institution": "" + }, + { + "first_name": "Robert", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/XiongJJP01", + "venue": "pldi", + "year": 2001 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2002.json b/data/pl_conferences/pldi/2002.json new file mode 100644 index 0000000..bb4ccf9 --- /dev/null +++ b/data/pl_conferences/pldi/2002.json @@ -0,0 +1,876 @@ +[ + { + "paper_id": "10.1145/512529.512567", + "title": "The Embedded Machine: Predictable, Portable Real-Time Code", + "abstract": "The Embedded Machine is a virtual machine that mediates in real time the interaction between software processes and physical processes. It separates the compilation of embedded programs into two phases. The first, platform-independent compiler phase generates E code (code executed by the Embedded Machine), which supervises the timing ---not the scheduling--- of application tasks relative to external events, such as clock ticks and sensor interrupts. E~code is portable and exhibits, given an input behavior, predictable (i.e., deterministic) timing and output behavior. The second, platform-dependent compiler phase checks the time safety of the E code, that is, whether platform performance (determined by the hardware) and platform utilization (determined by the scheduler of the operating system) enable its timely execution. We have used the Embedded Machine to compile and execute high-performance control applications written in Giotto, such as the flight control system of an autonomous model helicopter.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512567", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Christoph", + "last_name": "Kirsch", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/HenzingerK02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512536", + "title": "A Sparse Algorithm for Predicated Global Value Numbering", + "abstract": "This paper presents a new algorithm for performing global value numbering on a routine in static single assignment form. Our algorithm has all the strengths of the most powerful existing practical methods of global value numbering; it unifies optimistic value numbering with constant folding, algebraic simplification and unreachable code elimination. It goes beyond existing methods by unifying optimistic value numbering with further analyses: it canonicalizes the structure of expressions in order to expose more congruences by performing global reassociation, it exploits the congruences induced by the predicates of conditional jumps (predicate inference and value inference), and it associates the arguments of acyclic ø functions with the predicates controlling their arrival (ø predication), thus enabling congruence finding on conditional control structures. Finally, it implements an efficient sparse formulation and offers a range of tradeoffs between compilation time and optimization strength. We describe an implementation of the algorithm and present measurements of its strength and efficiency collected when optimizing the SPEC CINT2000 C benchmarks.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512536", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Karthik", + "last_name": "Gargi", + "institution": "Hewlett-Packard (India)" + } + ], + "dblp_key": "conf/pldi/Gargi02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512564", + "title": "MaJIC: Compiling MATLAB for Speed and Responsiveness", + "abstract": "This paper presents and evaluates techniques to improve the execution performance of MATLAB. Previous efforts concentrated on source to source translation and batch compilation; MaJIC provides an interactive frontend that looks like MATLAB and compiles/optimizes code behind the scenes in real time, employing a combination of just-in-time and speculative ahead-of-time compilation. Performance results show that the proper mixture of these two techniques can yield near-zero response time as well as performance gains previously achieved only by batch compilers.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512564", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "George", + "last_name": "Almási", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/AlmasiP02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512531", + "title": "Flow-Sensitive Type Qualifiers", + "abstract": "We present a system for extending standard type systems with flow-sensitive type qualifiers. Users annotate their programs with type qualifiers, and inference checks that the annotations are correct. In our system only the type qualifiers are modeled flow-sensitively---the underlying standard types are unchanged, which allows us to obtain an efficient constraint-based inference algorithm that integrates flow-insensitive alias analysis, effect inference, and ideas from linear type systems to support strong updates. We demonstrate the usefulness of flow-sensitive type qualifiers by finding a number of new locking bugs in the Linux kernel.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512531", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/FosterTA02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512538", + "title": "ESP: Path-Sensitive Program Verification in Polynomial Time", + "abstract": "In this paper, we present a new algorithm for partial program verification that runs in polynomial time and space. We are interested in checking that a program satisfies a given temporal safety property. Our insight is that by accurately modeling only those branches in a program for which the property-related behavior differs along the arms of the branch, we can design an algorithm that is accurate enough to verify the program with respect to the given property, without paying the potentially exponential cost of full path-sensitive analysis.We have implemented this \"property simulation\" algorithm as part of a partial verification tool called ESP. We present the results of applying ESP to the problem of verifying the file I/O behavior of a version of the GNU C compiler (gcc, 140,000 LOC). We are able to prove that all of the 646 calls to .fprintf in the source code of gcc are guaranteed to print to valid, open files. Our results show that property simulation scales to large programs and is accurate enough to verify meaningful properties.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512538", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manuvir", + "last_name": "Das", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of Washington" + }, + { + "first_name": "Mark", + "last_name": "Seigle", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/DasLS02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512558", + "title": "Extended Static Checking for Java", + "abstract": "Software development and maintenance are costly endeavors. The cost can be reduced if more software defects are detected earlier in the development cycle. This paper introduces the Extended Static Checker for Java (ESC/Java), an experimental compile-time program checker that finds common programming errors. The checker is powered by verification-condition generation and automatic theorem-proving techniques. It provides programmers with a simple annotation language with which programmer design decisions can be expressed formally. ESC/Java examines the annotated software and warns of inconsistencies between the design decisions recorded in the annotations and the actual code, and also warns of potential runtime errors in the code. This paper gives an overview of the checker architecture and annotation language and describes our experience applying the checker to tens of thousands of lines of Java programs.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512558", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "K. Rustan M.", + "last_name": "Leino", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Mark", + "last_name": "Lillibridge", + "institution": "" + }, + { + "first_name": "Greg", + "last_name": "Nelson", + "institution": "" + }, + { + "first_name": "James B.", + "last_name": "Saxe", + "institution": "" + }, + { + "first_name": "Raymie", + "last_name": "Stata", + "institution": "" + } + ], + "dblp_key": "conf/pldi/FlanaganLLNSS02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512556", + "title": "Static Load Classification for Improving the Value Predictability of Data-Cache Misses", + "abstract": "While caches are effective at avoiding most main-memory accesses, the few remaining memory references are still expensive. Even one cache miss per one hundred accesses can double a program's execution time. To better tolerate the data-cache miss latency, architects have proposed various speculation mechanisms, including load-value prediction. A load-value predictor guesses the result of a load so that the dependent instructions can immediately proceed without having to wait for the memory access to complete. To use the prediction resources most effectively, speculation should be restricted to loads that are likely to miss in the cache and that are likely to be predicted correctly. Prior work has considered hardware- and profile-based methods to make these decisions. Our work focuses on making these decisions at compile time. We show that a simple compiler classification is effective at separating the loads that should be speculated from the loads that should not. We present results for a number of C and Java programs and demonstrate that our results are consistent across programming languages and across program inputs.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512556", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Burtscher", + "institution": "Cornell University" + }, + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Colorado System" + }, + { + "first_name": "Matthias", + "last_name": "Hauswirth", + "institution": "University of Colorado System" + } + ], + "dblp_key": "conf/pldi/BurtscherDH02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512560", + "title": "Efficient and Precise Datarace Detection for Multithreaded Object-Oriented Programs", + "abstract": "We present a novel approach to dynamic datarace detection for multithreaded object-oriented programs. Past techniques for on-the-fly datarace detection either sacrificed precision for performance, leading to many false positive datarace reports, or maintained precision but incurred significant overheads in the range of 3x to 30x. In contrast, our approach results in very few false positives and runtime overhead in the 13% to 42% range, making it both efficient and precise. This performance improvement is the result of a unique combination of complementary static and dynamic optimization techniques.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512560", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "" + }, + { + "first_name": "Keun‐Woo", + "last_name": "Lee", + "institution": "University of Washington" + }, + { + "first_name": "А. А.", + "last_name": "Логинов", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Robert", + "last_name": "O'Callahan", + "institution": "" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "Moscow Institute of Thermal Technology" + } + ], + "dblp_key": "conf/pldi/ChoiLLOSS02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512548", + "title": "Beltway: Getting Around Garbage Collection Gridlock", + "abstract": "We present the design and implementation of a new garbage collection framework that significantly generalizes existing copying collectors. The Beltway framework exploits and separates object age and incrementality. It groups objects in one or more increments on queues called belts, collects belts independently, and collects increments on a belt in first-in-first-out order. We show that Beltway configurations, selected by command line options, act and perform the same as semi-space, generational, and older-first collectors, and encompass all previous copying collectors of which we are aware. The increasing reliance on garbage collected languages such as Java requires that the collector perform well. We show that the generality of Beltway enables us to design and implement new collectors that are robust to variations in heap size and improve total execution time over the best generational copying collectors of which we are aware by up to 40%, and on average by 5 to 10%, for small to moderate heap sizes. New garbage collection algorithms are rare, and yet we define not just one, but a new family of collectors that subsumes previous work. This generality enables us to explore a larger design space and build better collectors.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512548", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Richard", + "last_name": "Jones", + "institution": "University of Kent" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/BlackburnJMM02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512552", + "title": "Effective Sign Extension Elimination", + "abstract": "Computer designs are shifting from 32-bit architectures to 64-bit architectures, while most of the programs available today are still designed for 32-bit architectures. Java™, for example, specifies the frequently used int\" as a 32-bit data type. If such Java programs are executed on a 64-bit architecture, many 32-bit values must be sign-extended to 64-bit values for integer operations. This causes serious performance overhead. In this paper, we present a fast and effective algorithm for eliminating sign extensions. We implemented this algorithm in the IBM Java Just-in-Time (JIT) compiler for IA-64™. Our experimental results show that our algorithm effectively eliminates the majority of sign extensions. They also show that it significantly improves performance, while it increases JIT compilation time by only 0.11%. We implemented our algorithm for programs in Java, but it can be applied to any language requiring sign extensions.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512552", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Motohiro", + "last_name": "Kawahito", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/pldi/KawahitoKN02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512534", + "title": "Fast Copy Coalescing and Live-Range Identification", + "abstract": "This paper presents a fast new algorithm for modeling and reasoning about interferences for variables in a program without constructing an interference graph. It then describes how to use this information to minimize copy insertion for φ-node instantiation during the conversion of the static single assignment (SSA) form into the control-flow graph (CFG), effectively yielding a new, very fast copy coalescing and live-range identification algorithm. This paper proves some properties of the SSA form that enable construction of data structures to compute interference information for variables that are considered for folding. The asymptotic complexity of our SSA-to-CFG conversion algorithm is O(nα(n)), where n is the number of instructions in the program. Performing copy folding during the SSA-to-CFG conversion eliminates the need for a separate coalescing phase while simplifying the intermediate code. This may make graph-coloring register allocation more practical in just in time (JIT) and other time-critical compilers For example, Sun’s Hotspot Server Compiler already employs a graph-coloring register allocator[10]. This paper also presents an improvement to the classical interference-graph based coalescing optimization that shows a decrease in memory usage of up to three orders of magnitude and a decrease of a factor of two in compilation time, while providing the exact same results. We present experimental results that demonstrate that our algorithm is almost as precise (within one percent on average) as the improved interference-graph-based coalescing algorithm, while requiring three times less compilation time.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512534", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zoran", + "last_name": "Budimlić", + "institution": "Rice University" + }, + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + }, + { + "first_name": "Timothy J.", + "last_name": "Harvey", + "institution": "Rice University" + }, + { + "first_name": "Ken", + "last_name": "Kennedy", + "institution": "Rice University" + }, + { + "first_name": "Timothy S.", + "last_name": "Oberg", + "institution": "Rice University" + }, + { + "first_name": "Steven W.", + "last_name": "Reeves", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/BudimlicCHKOR02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512551", + "title": "Space-Time Trade-Off Optimization for a Class of Electronic Structure Calculations", + "abstract": "The accurate modeling of the electronic structure of atoms and molecules is very computationally intensive. Many models of electronic structure, such as the Coupled Cluster approach, involve collections of tensor contractions. There are usually a large number of alternative ways of implementing the tensor contractions, representing different trade-offs between the space required for temporary intermediates and the total number of arithmetic operations. In this paper, we present an algorithm that starts with an operation-minimal form of the computation and systematically explores the possible space-time trade-offs to identify the form with lowest cost that fits within a specified memory limit. Its utility is demonstrated by applying it to a computation representative of a component in the CCSD(T) formulation in the NWChem quantum chemistry suite from Pacific Northwest National Laboratory.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512551", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Cociorva", + "institution": "The Ohio State University" + }, + { + "first_name": "Gerald", + "last_name": "Baumgartner", + "institution": "The Ohio State University" + }, + { + "first_name": "Chi‐Chung", + "last_name": "Lam", + "institution": "The Ohio State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + }, + { + "first_name": "J.", + "last_name": "Ramanujam", + "institution": "Louisiana State University" + }, + { + "first_name": "Marcel", + "last_name": "Nooijen", + "institution": "Princeton University" + }, + { + "first_name": "David E.", + "last_name": "Bernholdt", + "institution": "Oak Ridge National Laboratory" + }, + { + "first_name": "Robert J.", + "last_name": "Harrison", + "institution": "Pacific Northwest National Laboratory" + } + ], + "dblp_key": "conf/pldi/CociorvaBLSRNBH02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512542", + "title": "Profile-Guided Code Compression", + "abstract": "As computers are increasingly used in contexts where the amount of available memory is limited, it becomes important to devise techniques that reduce the memory footprint of application programs while leaving them in an executable form. This paper describes an approach to applying data compression techniques to reduce the size of infrequently executed portions of a program. The compressed code is decompressed dynamically (via software) if needed, prior to execution. The use of data compression techniques increases the amount of code size reduction that can be achieved; their application to infrequently executed code limits the runtime overhead due to dynamic decompression; and the use of software decompression renders the approach generally applicable, without requiring specialized hardware. The code size reductions obtained depend on the threshold used to determine what code is \"infrequently executed\" and hence should be compressed: for low thresholds, we see size reductions of 13.7% to 18.8%, on average, for a set of embedded applications, without excessive runtime overhead.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512542", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "University of Arizona" + }, + { + "first_name": "William", + "last_name": "Evans", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/pldi/DebrayE02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512554", + "title": "Dynamic Hot Data Stream Prefetching for General-Purpose Programs", + "abstract": "Prefetching data ahead of use has the potential to tolerate the growing processor-memory performance gap by overlapping long latency memory accesses with useful computation. While sophisticated prefetching techniques have been automated for limited domains, such as scientific codes that access dense arrays in loop nests, a similar level of success has eluded general-purpose programs, especially pointer-chasing codes written in languages such as C and C++. We address this problem by describing, implementing and evaluating a dynamic prefetching scheme. Our technique runs on stock hardware, is completely automatic, and works for generalpurpose programs, including pointer-chasing codes written in weakly-typed languages, such as C and C++. It operates in three phases. First, the profiling phase gathers a temporal data reference profile from a running program with low-overhead. Next, the profiling is turned off and a fast analysis algorithm extracts hot data streams, which are data reference sequences that frequently repeat in the same order, from the temporal profile. Then, the system dynamically injects code at appropriate program points to detect and prefetch these hot data streams. Finally, the process enters the hibernation phase where no profiling or analysis is performed, and the program continues to execute with the added prefetch instructions. At the end of the hibernation phase, the program is deoptimized to remove the inserted checks and prefetch instructions, and control returns to the profiling phase. For long-running programs, this profile, analyze and optimize, hibernate, cycle will repeat multiple times. Our initial results from applying dynamic prefetching are promising, indicating overall execution time improvements of 5–19 % for several memory-performance-limited SPECint2000 benchmarks running their largest (ref) inputs.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512554", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/pldi/ChilimbiH02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512532", + "title": "Adoption and Focus: Practical Linear Types for Imperative Programming", + "abstract": "A type system with linearity is useful for checking software protocols andresource management at compile time. Linearity provides powerful reasoning about state changes, but at the price of restrictions on aliasing. The hard division between linear and nonlinear types forces the programmer to make a trade-off between checking a protocol on an object and aliasing the object. Most onerous is the restriction that any type with a linear component must itself be linear. Because of this, checking a protocol on an object imposes aliasing restrictions on any data structure that directly or indirectly points to the object. We propose a new type system that reduces these restrictions with the adoption and focus constructs. Adoption safely allows a programmer to alias objects on which she is checking protocols, and focus allows the reverse. A programmer can alias data structures that point to linear objects and use focus for safe access to those objects. We discuss how we implemented these ideas in the Vault programming language.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512532", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Robert", + "last_name": "DeLine", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/FahndrichD02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512562", + "title": "Maya: Multiple-Dispatch Syntax Extension in Java", + "abstract": "We have designed and implemented Maya, a version of Java that allows programmers to extend and reinterpret its syntax. Maya generalizes macro systems by treating grammar productions as generic functions, and semantic actions on productions as multimethods on the corresponding generic functions. Programmers can write new generic functions (i.e., grammar productions) and new multimethods (i.e., semantic actions), through which they can extend the grammar of the language and change the semantics of its syntactic constructs, respectively. Maya's multimethods are compile-time metaprograms that transform abstract syntax: they execute at program compile-time, because they are semantic actions executed by the parser. Maya's multimethods can be dispatched on the syntactic structure of the input, as well as the static, source-level types of expressions in the input. In this paper we describe what Maya can do and how it works. We describe how its novel parsing techniques work and how Maya can statically detect certain kinds of errors, such as code that generates references to free variables. Finally, to demonstrate Maya's expressiveness, we describe how Maya can be used to implement the MultiJava language, which was described by Clifton et al. at OOPSLA 2000.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512562", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jason D.", + "last_name": "Baker", + "institution": "University of Utah" + }, + { + "first_name": "Wilson C.", + "last_name": "Hsieh", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/BakerH02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512563", + "title": "Region-Based Memory Management in Cyclone", + "abstract": "Cyclone is a type-safe programming language derived from C. The primary design goal of Cyclone is to let programmers control data representation and memory management without sacrificing type-safety. In this paper, we focus on the region-based memory management of Cyclone and its static typing discipline. The design incorporates several advancements, including support for region subtyping and a coherent integration with stack allocation and a garbage collector. To support separate compilation, Cyclone requires programmers to write some explicit region annotations, but a combination of default annotations, local type inference, and a novel treatment of region effects reduces this burden. As a result, we integrate C idioms in a region-based framework. In our experience, porting legacy C to Cyclone has required altering about 8% of the code; of the changes, only 6% (of the 8%) were region annotations.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512563", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "Cornell University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + }, + { + "first_name": "Trevor", + "last_name": "Jim", + "institution": "AT&T (United States)" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "Cornell University" + }, + { + "first_name": "Yanling", + "last_name": "Wang", + "institution": "Cornell University" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/GrossmanMJHWC02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512566", + "title": "Denali: A Goal-directed Superoptimizer", + "abstract": "This paper provides a preliminary report on a new research project that aims to construct a code generator that uses an automatic theorem prover to produce very high-quality (in fact, nearly mathematically optimal) machine code for modern architectures. The code generator is not intended for use in an ordinary compiler, but is intended to be used for inner loops and critical subroutines in those cases where peak performance is required, no available compiler generates adequately efficient code, and where current engineering practice is to use hand-coded machine language. The paper describes the design of the superoptimizer, and presents some encouraging preliminary results.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512566", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rajeev", + "last_name": "Joshi", + "institution": "" + }, + { + "first_name": "Greg", + "last_name": "Nelson", + "institution": "" + }, + { + "first_name": "Keith H.", + "last_name": "Randall", + "institution": "" + } + ], + "dblp_key": "conf/pldi/JoshiNR02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512547", + "title": "Combining Region Inference and Garbage Collection", + "abstract": "This paper describes a memory discipline that combines region-based memory management and copying garbage collection by extending Cheney&apos;s copying garbage collection algorithm to work with regions. The paper presents empirical evidence that region inference very significantly reduces the number of garbage collections; and evidence that the fastest execution is obtained by using regions alone, without garbage collection.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512547", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Niels", + "last_name": "Hallenberg", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Mads", + "last_name": "Tofte", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/pldi/HallenbergET02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512535", + "title": "Preference-Directed Graph Coloring", + "abstract": "This paper describes a new framework of register allocation based on Chaitin-style coloring. Our focus is on maximizing the chances for live ranges to be allocated to the most preferred registers while not destroying the colorability obtained by graph simplification. Our coloring algorithm uses a graph representation of preferences called a Register Preference Graph, which helps find a good register selection. We then try to relax the register selection order created by the graph simplification. The relaxed order is defined as a partial order, represented using a graph called a Coloring Precedence Graph. Our algorithm utilizes such a partial order for the register selection instead of using the traditional simplification-driven order so that the chances of honoring the preferences are effectively increased. Experimental results show that our coloring algorithm is powerful to simultaneously handle spill decisions, register coalescing, and preference resolutions.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512535", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Akira", + "last_name": "Koseki", + "institution": "IBM (United States)" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/pldi/KosekiKN02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512539", + "title": "A System and Language for Building System-Specific, Static Analyses", + "abstract": "This paper presents a novel approach to bug-finding analysis and an implementation of that approach. Our goal is to find as many serious bugs as possible. To do so, we designed a flexible, easy-to-use extension language for specifying analyses and an efficent algorithm for executing these extensions. The language, metal, allows the users of our system to specify a broad class of analyses in terms that resemble the intuitive description of the rules that they check. The system, xgcc, executes these analyses efficiently using a context-sensitive, interprocedural analysis. Our prior work has shown that the approach described in this paper is effective: it has successfully found thousands of bugs in real systems code. This paper describes the underlying system used to achieve these results. We believe that our system is an effective framework for deploying new bug-finding analyses quickly and easily.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512539", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Seth", + "last_name": "Hallem", + "institution": "Stanford University" + }, + { + "first_name": "Benjamin", + "last_name": "Chelf", + "institution": "Stanford University" + }, + { + "first_name": "Yichen", + "last_name": "Xie", + "institution": "Stanford University" + }, + { + "first_name": "Dawson", + "last_name": "Engler", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/HallemCXE02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512544", + "title": "Post-Pass Binary Adaptation for Software-Based Speculative Precomputation", + "abstract": "Recently, a number of thread-based prefetching techniques have been proposed. These techniques aim at improving the latency of single-threaded applications by leveraging multithreading resources to perform memory prefetching via speculative prefetch threads. Software-based speculative precomputation (SSP) is one such technique, proposed for multithreaded Itanium models. SSP does not require expensive hardware support-instead it relies on the compiler to adapt binaries to perform prefetching on otherwise idle hardware thread contexts at run time. This paper presents a post-pass compilation tool for generating SSP-enhanced binaries. The tool is able to: (1) analyze a single-threaded application to generate prefetch threads; (2) identify and embed trigger points in the original binary; and (3) produce a new binary that has the prefetch threads attached. The execution of the new binary spawns the speculative prefetch threads, which are executed concurrently with the main thread. Our results indicate that for a set of pointer-intensive benchmarks, the prefetching performed by the speculative threads achieves an average of 87% speedup on an in-order processor and 5% speedup on an out-of-order processor.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512544", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steve S.W.", + "last_name": "Liao", + "institution": "Intel (United States)" + }, + { + "first_name": "Perry H.", + "last_name": "Wang", + "institution": "Intel (United States)" + }, + { + "first_name": "Hong", + "last_name": "Wang", + "institution": "Intel (United States)" + }, + { + "first_name": "Gerolf F.", + "last_name": "Hoflehner", + "institution": "Intel (United States)" + }, + { + "first_name": "Daniel J.", + "last_name": "Lavery", + "institution": "Intel (United States)" + }, + { + "first_name": "John Paul", + "last_name": "Shen", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/LiaoWWSHL02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512546", + "title": "A Parallel, Incremental and Concurrent GC for Servers", + "abstract": "Multithreaded applications with multi-gigabyte heaps running on modern servers provide new challenges for garbage collection (GC). The challenges for \"server-oriented\" GC include: ensuring short pause times on a multi-gigabyte heap, while minimizing throughput penalty, good scaling on multiprocessor hardware, and keeping the number of expensive multi-cycle fence instructions required by weak ordering to a minimum. We designed and implemented a fully parallel, incremental, mostly concurrent collector, which employs several novel techniques to meet these challenges. First, it combines incremental GC to ensure short pause times with concurrent low-priority background GC threads to take advantage of processor idle time. Second, it employs a low-overhead work packet mechanism to enable full parallelism among the incremental and concurrent collecting threads and ensure load balancing. Third, it reduces memory fence instructions by using batching techniques: one fence for each block of small objects allocated, one fence for each group of objects marked, and no fence at all in the write barrier. When compared to the mature well-optimized parallel stop-the-world mark-sweep collector already in the IBM JVM, our collector prototype reduces the maximum pause time from 284 ms to 101 ms, and the average pause time from 266 ms to 66 ms while only losing 10% throughput when running the SPECjbb2000 benchmark on a 256 MB heap on a 4-way 550 MHz Pentium multiprocessor.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512546", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yoav", + "last_name": "Ossia", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Ori", + "last_name": "Ben-Yitzhak", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Irit", + "last_name": "Goft", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Elliot K.", + "last_name": "Kolodner", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Victor", + "last_name": "Leikehman", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Avi", + "last_name": "Owshanko", + "institution": "IBM Research - Haifa" + } + ], + "dblp_key": "conf/pldi/OssiaBGKLO02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512540", + "title": "Deriving Specialized Program Analyses for Certifying Component-Client Conformance", + "abstract": "We are concerned with the problem of statically certifying (verifying) whether the client of a software component conforms to the component's constraints for correct usage. We show how conformance certification can be efficiently carried out in a staged fashion for certain classes of first-order safety (FOS) specifications, which can express relationship requirements among potentially unbounded collections of runtime objects. In the first stage of the certification process, we systematically derive an abstraction that is used to model the component state during analysis of arbitrary clients. In general, the derived abstraction will utilize first-order predicates, rather than the propositions often used by model checkers. In the second stage, the generated abstraction is incorporated into a static analysis engine to produce a certifier. In the final stage, the resulting certifier is applied to a client to conservatively determine whether the client violates the component's constraints. Unlike verification approaches that analyze a specification and client code together, our technique can take advantage of computationally-intensive symbolic techniques during the abstraction generation phase, without affecting the performance of client analysis. Using as a running example the Concurrent Modification Problem (CMP), which arises when certain classes defined by the Java Collections Framework are misused, we describe several different classes of certifiers with varying time/space/precision tradeoffs. Of particular note are precise, polynomial-time, flow- and context-sensitive certifiers for certain classes of FOS specifications and client programs. Finally, we evaluate a prototype implementation of a certifier for CMP on a variety of test programs. The results of the evaluation show that our approach, though conservative, yields very few \"false alarms,\" with acceptable performance.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512540", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Alex", + "last_name": "Warshavsky", + "institution": "Tel Aviv University" + }, + { + "first_name": "John K.", + "last_name": "Field", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Deepak", + "last_name": "Goyal", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/RamalingamWFGS02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512559", + "title": "Using Data Groups to Specify and Check Side Effects", + "abstract": "Reasoning precisely about the side effects of procedure calls is important to many program analyses. This paper introduces a technique for specifying and statically checking the side effects of methods in an object-oriented language. The technique uses data groups, which abstract over variables that are not in scope, and limits program behavior by two alias-confining restrictions, pivot uniqueness and owner exclusion. The technique is shown to achieve modular soundness and is simpler than previous attempts at solving this problem.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512559", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "K. Rustan M.", + "last_name": "Leino", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arnd", + "last_name": "Poetzsch‐Heffter", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Yunhong", + "last_name": "Zhou", + "institution": "" + } + ], + "dblp_key": "conf/pldi/LeinoPZ02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512550", + "title": "A Compiler Approach to Fast Hardware Design Space Exploration in FPGA-based Systems", + "abstract": "The current practice of mapping computations to custom hardware implementations requires programmers to assume the role of hardware designers. In tuning the performance of their hardware implementation, designers manually apply loop transformations such as loop unrolling. designers manually apply loop transformations. For example, loop unrolling is used to expose instruction-level parallelism at the expense of more hardware resources for concurrent operator evaluation. Because unrolling also increases the amount of data a computation requires, too much unrolling can lead to a memory bound implementation where resources are idle. To negotiate inherent hardware space-time trade-offs, designers must engage in an iterative refinement cycle, at each step manually applying transformations and evaluating their impact. This process is not only error-prone and tedious but also prohibitively expensive given the large search spaces and with long synthesis times. This paper describes an automated approach to hardware design space exploration, through a collaboration between parallelizing compiler technology and high-level synthesis tools. We present a compiler algorithm that automatically explores the large design spaces resulting from the application of several program transformations commonly used in application-specific hardware designs. Our approach uses synthesis estimation techniques to quantitatively evaluate alternate designs for a loop nest computation. We have implemented this design space exploration algorithm in the context of a compilation and synthesis system called DEFACTO, and present results of this implementation on five multimedia kernels. Our algorithm derives an implementation that closely matches the performance of the fastest design in the design space, and among implementations with comparable performance, selects the smallest design. We search on average only 0.3% of the design space. This technology thus significantly raises the level of abstraction for hardware design and explores a design space much larger than is feasible for a human designer.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512550", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Byoungro", + "last_name": "So", + "institution": "University of Southern California" + }, + { + "first_name": "Mary", + "last_name": "Hall", + "institution": "Marina Del Rey Hospital" + }, + { + "first_name": "Pedro C.", + "last_name": "Diniz", + "institution": "Marina Del Rey Hospital" + } + ], + "dblp_key": "conf/pldi/SoHD02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512555", + "title": "Efficient Discovery of Regular Stride Patterns in Irregular Programs", + "abstract": "Irregular data references are difficult to prefetch, as the future memory address of a load instruction is hard to anticipate by a compiler. However, recent studies as well as our experience indicate that some important load instructions in irregular programs contain stride access patterns. Although the load instructions with stride patterns are difficult to identify with static compiler techniques, we developed an efficient profiling method to discover these load instructions. The new profiling method integrates the profiling for stride information and the traditional profiling for edge frequency into a single profiling pass. The integrated profiling pass runs only 17% slower than the frequency profiling alone. The collected stride information helps the compiler to identify load instructions with stride patterns that can be prefetched efficiently and beneficially. We implemented the new profiling and prefetching techniques in a research compiler for Itanium Processor Family (IPF), and obtained significant performance improvement for the SPECINT2000 programs running on Itanium machines. For example, we achieved a 1.59x speedup for 181.mcf, 1.14x for 254.gap, and 1.08x for 197.parser. We also showed that the performance gain is stable across input data sets. These benefits make the new profiling and prefetching techniques suitable for production compilers.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512555", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Youfeng", + "last_name": "Wu", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/Wu02", + "venue": "pldi", + "year": 2002 + }, + { + "paper_id": "10.1145/512529.512543", + "title": "Profile-Directed Optimization of Event-Based Programs", + "abstract": "Event-based systems provide a simple way to create flexible, extensible, and customizable system architectures and give a &quot;user-driven&quot; feel to the system. However, the indirect coupling between the raising and handling of events introduces a number of overheads into the system. Such overheads can be surprisingly large,and are especially significant in small mobile systems. This paper describes a framework for profile-guided optimization of event-based systems. Experiments using our approach on two different event-based systems, Cactus and X-windows, indicates that it can achieve significant reductions in event handling overheads and lead to considerable improvements in overall system performance.", + "date": "2002-05-17", + "link": "https://doi.org/10.1145/512529.512543", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mohan", + "last_name": "Rajagopalan", + "institution": "University of Arizona" + }, + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "University of Arizona" + }, + { + "first_name": "Matti", + "last_name": "Hiltunen", + "institution": "AT&T (United States)" + }, + { + "first_name": "Richard D.", + "last_name": "Schlichting", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/pldi/RajagopalanDHS02", + "venue": "pldi", + "year": 2002 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2003.json b/data/pl_conferences/pldi/2003.json new file mode 100644 index 0000000..f0e7242 --- /dev/null +++ b/data/pl_conferences/pldi/2003.json @@ -0,0 +1,764 @@ +[ + { + "paper_id": "10.1145/781131.781161", + "title": "Stride prefetching by dynamically inspecting objects", + "abstract": "Software prefetching is a promising technique to hide cache miss latencies, but it remains challenging to effectively prefetch pointer-based data structures because obtaining the memory address to be prefetched requires pointer dereferences. The recently proposed stride prefetching overcomes this problem, but it only exploits inter-iteration stride patterns and relies on an off-line profiling method.We propose a new algorithm for stride prefetching which is intended for use in a dynamic compiler. We exploit both inter- and intra-iteration stride patterns, which we discover using an ultra-lightweight profiling technique, called object inspection. This is a kind of partial interpretation that only a dynamic compiler can perform. During the compilation of a method, the dynamic compiler gathers the profile information by partially interpreting the method using the actual values of parameters and causing no side effects.We evaluated an implementation of our prefetching algorithm in a production-level Java just-in time compiler. The results show that the algorithm achieved up to an 18.9% and 25.1% speedup in industry-standard benchmarks on the Pentium 4 and the Athlon MP, respectively, while it increased the compilation time by less than 3.0%.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781161", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tatsushi", + "last_name": "Inagaki", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Tamiya", + "last_name": "Onodera", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/pldi/InagakiOKN03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781165", + "title": "Region-based hierarchical operation partitioning for multicluster processors", + "abstract": "Clustered architectures are a solution to the bottleneck of centralized register files in superscalar and VLIW processors. The main challenge associated with clustered architectures is compiler support to effectively partition operations across the available resources on each cluster. In this work, we present a novel technique for clustering operations based on graph partitioning methods. Our approach incorporates new methods of assigning weights to nodes and edges within the dataflow graph to guide the partitioner. Nodes are assigned weights to reflect their resource usage within a cluster, while a slack distribution method intelligently assigns weights to edges to reflect the cost of inserting moves across clusters. A multilevel graph partitioning algorithm, which globally divides a dataflow graph into multiple parts in a hierarchical manner, uses these weights to efficiently generate estimates for the quality of partitions. We found that our algorithm was able to achieve an average of 20% improvement in DSP kernels and 5% improvement in SPECint2000 for a four-cluster architecture.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781165", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Chu", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Kevin", + "last_name": "Fan", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/ChuFM03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781160", + "title": "Static array storage optimization in MATLAB", + "abstract": "Static array storage optimization in MATLAB.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781160", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pramod G.", + "last_name": "Joisha", + "institution": "Northwestern University" + }, + { + "first_name": "Prithviraj", + "last_name": "Banerjee", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/pldi/JoishaB03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781134", + "title": "Linear analysis and optimization of stream programs", + "abstract": "As more complex DSP algorithms are realized in practice, there is an increasing need for high-level stream abstractions that can be compiled without sacrificing efficiency. Toward this end, we present a set of aggressive optimizations that target linear sections of a stream program. Our input language is StreamIt, which represents programs as a hierarchical graph of autonomous filters. A filter is linear if each of its outputs can be represented as an affine combination of its inputs. Linearity is common in DSP components; examples include FIR filters, expanders, compressors, FFTs and DCTs.We demonstrate that several algorithmic transformations, traditionally hand-tuned by DSP experts, can be completely automated by the compiler. First, we present a linear extraction analysis that automatically detects linear filters from the C-like code in their work function. Then, we give a procedure for combining adjacent linear filters into a single filter, as well as for translating a linear filter to operate in the frequency domain. We also present an optimization selection algorithm, which finds the sequence of combination and frequency transformations that will give the maximal benefit.We have completed a fully-automatic implementation of the above techniques as part of the StreamIt compiler, and we demonstrate a 450% performance improvement over our benchmark suite.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781134", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew A.", + "last_name": "Lamb", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "William", + "last_name": "Thies", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/LambTA03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781162", + "title": "Optimizing indirect branch prediction accuracy in virtual machine interpreters", + "abstract": "Interpreters designed for efficiency execute a huge number of indirect branches and can spend more than half of the execution time in indirect branch mispredictions. Branch target buffers are the best widely available form of indirect branch prediction; however, their prediction accuracy for existing interpreters is only 2%--50%. In this paper we investigate two methods for improving the prediction accuracy of BTBs for interpreters: replicating virtual machine (VM) instructions and combining sequences of VM instructions into superinstructions. We investigate static (interpreter build-time) and dynamic (interpreter run-time) variants of these techniques and compare them and several combinations of these techniques. These techniques can eliminate nearly all of the dispatch branch mispredictions, and have other benefits, resulting in speedups by a factor of up to 3.17 over efficient threaded-code interpreters, and speedups by a factor of up to 1.3 over techniques relying on superinstructions alone.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781162", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "M. Anton", + "last_name": "Ertl", + "institution": "TU Wien" + }, + { + "first_name": "David", + "last_name": "Gregg", + "institution": "Trinity College Dublin" + } + ], + "dblp_key": "conf/pldi/ErtlG03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781155", + "title": "A provably sound TAL for back-end optimization", + "abstract": "Typed assembly languages provide a way to generate machine-checkable safety proofs for machine-language programs. But the soundness proofs of most existing typed assembly languages are hand-written and cannot be machine-checked, which is worrisome for such large calculi. We have designed and implemented a low-level typed assembly language (LTAL) with a semantic model and established its soundness from the model. Compared to existing typed assembly languages, LTAL is more scalable and more secure; it has no macro instructions that hinder low-level optimizations such as instruction scheduling; its type constructors are expressive enough to capture dataflow information, support the compiler's choice of data representations and permit typed position-independent code; and its type-checking algorithm is completely syntax-directed.We have built a prototype system, based on Standard ML of New Jersey, that compiles most of core ML to Sparc code. We explain how we were able to make the untyped back end in SML/NJ preserve types during instruction selection and register allocation, without restricting low-level optimizations and without knowledge of any type system pervading the instruction selector and register allocator.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781155", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Princeton University" + }, + { + "first_name": "Dinghao", + "last_name": "Wu", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "Hai", + "last_name": "Fang", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/ChenWAF03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781135", + "title": "Taming the IXP network processor", + "abstract": "We compile Nova, a new language designed for writing network processing applications, using a back end based on integer-linear programming (ILP) for register allocation, optimal bank assignment, and spills. The compiler's optimizer employs CPS as its intermediate representation; some of the invariants that this IR guarantees are essential for the formulation of a practical ILP model.Appel and George used a similar ILP-based technique for the IA32 to decide which variables reside in registers but deferred the actual assignment of colors to a later phase. We demonstrate how to carry over their idea to an architecture with many more banks, register aggregates, variables with multiple simultaneous register assignments, and, very importantly, one where bank- and register-assignment cannot be done in isolation from each other. Our approach performs well in practise---without causing an explosion in size or solve time of the generated integer linear programs.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781135", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lal", + "last_name": "George", + "institution": "Network Technologies (United States)" + }, + { + "first_name": "M.", + "last_name": "Blume", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/pldi/GeorgeB03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781145", + "title": "Static conflict analysis for multi-threaded object-oriented programs", + "abstract": "A compiler for multi-threaded object-oriented programs needs information about the sharing of objects for a variety of reasons: to implement optimizations, to issue warnings, to add instrumentation to detect access violations that occur at runtime. An Object Use Graph (OUG) statically captures accesses from different threads to objects. An OUG extends the Heap Shape Graph (HSG), which is a compile-time abstraction for runtime objects (nodes) and their reference relations (edges). An OUG specifies for a specific node in the HSG a partial order of events relevant to the corresponding runtime object(s). Relevant events include read and write access, object escape, thread start and join.OUGs have been implemented in a Java compiler. Initial experience shows that OUGs are effective to identify object accesses that potentially conflict at runtime and isolate accesses that never cause a problem at runtime. The capabilities of OUGs are compared with an advanced program analysis that has been used for lock elimination. For the set of benchmarks investigated here, OUGs report only a fraction of shared objects as conflicting and reduce the number of compile-time reports in terms of allocation sites of conflicting objects by 28--92% (average 64%). For benchmarks of up to 30 KLOC, the time taken to construct OUGs is, with one exception, in the order of seconds.The information collected in the OUG has been used to instrument Java programs with checks for object races. OUGs provide precise information about object sharing and static protection, so runtime instrumentation that checks those cases that cannot be disambiguated at compile-time is sparse, and the total runtime overhead of checking for object races is only 3--86% (average 47%).", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781145", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christoph von", + "last_name": "Praun", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas", + "last_name": "Groß", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/PraunG03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781146", + "title": "Checking and inferring local non-aliasing", + "abstract": "In prior work [15] we studied a language construct restrict that allows programmers to specify that certain pointers are not aliased to other pointers used within a lexical scope. Among other applications, programming with these constructs helps program analysis tools locally recover strong updates, which can improve the tracking of state in flow-sensitive analyses. In this paper we continue the study of restrict and introduce the construct confine. We present a type and effect system for checking the correctness of these annotations, and we develop efficient constraint-based algorithms implementing these type checking systems. To make it easier to use restrict and confine in practice, we show how to automatically infer such annotations without programmer assistance. In experiments on locking in 589 Linux device drivers, confine inference can automatically recover strong updates to eliminate 95% of the type errors resulting from weak updates.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781146", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "John", + "last_name": "Kodumal", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/AikenFKT03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781148", + "title": "Bug isolation via remote program sampling", + "abstract": "We propose a low-overhead sampling infrastructure for gathering information from the executions experienced by a program's user community. Several example applications illustrate ways to use sampled instrumentation to isolate bugs. Assertion-dense code can be transformed to share the cost of assertions among many users. Lacking assertions, broad guesses can be made about predicates that predict program errors and a process of elimination used to whittle these down to the true bug. Finally, even for non-deterministic bugs such as memory corruption, statistical modeling based on logistic regression allows us to identify program behaviors that are strongly correlated with failure and are therefore likely places to look for the error.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781148", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alice X.", + "last_name": "Zheng", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Michael I.", + "last_name": "Jordan", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/LiblitAZJ03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781159", + "title": "Predicting whole-program locality through reuse distance analysis", + "abstract": "Profiling can accurately analyze program behavior for select data inputs. We show that profiling can also predict program locality for inputs other than profiled ones. Here locality is defined by the distance of data reuse. Studying whole-program data reuse may reveal global patterns not apparent in short-distance reuses or local control flow. However, the analysis must meet two requirements to be useful. The first is efficiency. It needs to analyze all accesses to all data elements in full-size benchmarks and to measure distance of any length and in any required precision. The second is predication. Based on a few training runs, it needs to classify patterns as regular and irregular and, for regular ones, it should predict their (changing) behavior for other inputs. In this paper, we show that these goals are attainable through three techniques: approximate analysis of reuse distance (originally called LRU stack distance), pattern recognition, and distance-based sampling. When tested on 15 integer and floating-point programs from SPEC and other benchmark suites, our techniques predict with on average 94% accuracy for data inputs up to hundreds times larger than the training inputs. Based on these results, the paper discusses possible uses of this analysis.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781159", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + }, + { + "first_name": "Yutao", + "last_name": "Zhong", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/pldi/DingZ03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781144", + "title": "Points-to analysis using BDDs", + "abstract": "This paper reports on a new approach to solving a subset-based points-to analysis for Java using Binary Decision Diagrams (BDDs). In the model checking community, BDDs have been shown very effective for representing large sets and solving very large verification problems. Our work shows that BDDs can also be very effective for developing a points-to analysis that is simple to implement and that scales well, in both space and time, to large programs.The paper first introduces BDDs and operations on BDDs using some simple points-to examples. Then, a complete subset-based points-to algorithm is presented, expressed completely using BDDs and BDD operations. This algorithm is then refined by finding appropriate variable orderings and by making the algorithm propagate sets incrementally, in order to arrive at a very efficient algorithm. Experimental results are given to justify the choice of variable ordering, to demonstrate the improvement due to incrementalization, and to compare the performance of the BDD-based solver to an efficient hand-coded graph-based solver. Finally, based on the results of the BDD-based solver, a variety of BDD-based queries are presented, including the points-to query.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781144", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marc", + "last_name": "Berndl", + "institution": "McGill University" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "McGill University" + }, + { + "first_name": "Feng", + "last_name": "Qian", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + }, + { + "first_name": "Navindra", + "last_name": "Umanee", + "institution": "McGill University" + } + ], + "dblp_key": "conf/pldi/BerndlLQHU03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781169", + "title": "A type and effect system for atomicity", + "abstract": "Ensuring the correctness of multithreaded programs is difficult, due to the potential for unexpected and nondeterministic interactions between threads. Previous work addressed this problem by devising tools for detecting race conditions, a situation where two threads simultaneously access the same data variable, and at least one of the accesses is a write. However, verifying the absence of such simultaneous-access race conditions is neither necessary nor sufficient to ensure the absence of errors due to unexpected thread interactions.We propose that a stronger non-interference property is required, namely atomicity. Atomic methods can be assumed to execute serially, without interleaved steps of other threads. Thus, atomic methods are amenable to sequential reasoning techniques, which significantly simplifies both formal and informal reasoning about program correctness.This paper presents a type system for specifying and verifying the atomicity of methods in multithreaded Java programs. The atomic type system is a synthesis of Lipton's theory of reduction and type systems for race detection.We have implemented this atomic type system for Java and used it to check a variety of standard Java library classes. The type checker uncovered subtle atomicity violations in classes such as java.lang.String and java.lang.String-Buffer that cause crashes under certain thread interleavings.This paper proposes that a stronger non-interference property is required, namely atomicity, and presents a type system for verifying the atomicity of methods in multithreaded Java programs. Methods in a class can be annotated with the keyword atomic. Clients of a well-typed class can then assume that each atomic method is executed in one step, thus significantly simplifying both formal and informal reasoning about the client's correctness.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781169", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/FlanaganQ03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781157", + "title": "CCured in the real world", + "abstract": "CCured is a program transformation system that adds memory safety guarantees to C programs by verifying statically that memory errors cannot occur and by inserting run-time checks where static verification is insufficient.This paper addresses major usability issues in a previous version of CCured, in which many type casts required the use of pointers whose representation was expensive and incompatible with precompiled libraries. We have extended the CCured type inference algorithm to recognize and verify statically a large number of type casts; this goal is achieved by using physical subtyping and pointers with run-time type information to allow parametric and subtype polymorphism. In addition, we present a new instrumentation scheme that splits CCured's metadata into a separate data structure whose shape mirrors that of the original user data. This scheme allows instrumented programs to invoke external functions directly on the program's data without the use of a wrapper function.With these extensions we were able to use CCured on real-world security-critical network daemons and to produce instrumented versions without memory-safety vulnerabilities.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781157", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Condit", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Matthew", + "last_name": "Harren", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Scott", + "last_name": "McPeak", + "institution": "University of California, Berkeley" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Westley", + "last_name": "Weimer", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/ConditHMNW03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781168", + "title": "Ownership types for safe region-based memory management in real-time Java", + "abstract": "The Real Time Specification for Java (RTSJ) allows a program to create real-time threads with hard real-time constraints. Real-time threads use region-based memory management to avoid unbounded pauses caused by interference from the garbage collector. The RTSJ uses runtime checks to ensure that deleting a region does not create dangling references and that real-time threads do not access references to objects allocated in the garbage-collected heap. This paper presents a static type system that guarantees that these runtime checks will never fail for well-typed programs. Our type system therefore 1) provides an important safety guarantee for real-time programs and 2) makes it possible to eliminate the runtime checks and their associated overhead.Our system also makes several contributions over previous work on region types. For object-oriented programs, it combines the benefits of region types and ownership types in a unified type system framework. For multithreaded programs, it allows long-lived threads to share objects without using the heap and without memory leaks. For real-time programs, it ensures that real-time threads do not interfere with the garbage collector. Our experience indicates that our type system is sufficiently expressive and requires little programming overhead, and that eliminating the RTSJ runtime checks using a static type system can significantly decrease the execution time of real-time programs.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781168", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chandrasekhar", + "last_name": "Boyapati", + "institution": "" + }, + { + "first_name": "Alexandru", + "last_name": "Sălcianu", + "institution": "" + }, + { + "first_name": "William S.", + "last_name": "Beebee", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "" + } + ], + "dblp_key": "conf/pldi/BoyapatiSBR03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781137", + "title": "The design, implementation, and evaluation of a compiler algorithm for CPU energy reduction", + "abstract": "This paper presents the design and implementation of a compiler algorithm that effectively optimizes programs for energy usage using dynamic voltage scaling (DVS). The algorithm identifies program regions where the CPU can be slowed down with negligible performance loss. It is implemented as a source-to-source level transformation using the SUIF2 compiler infrastructure. Physical measurements on a high-performance laptop show that total system (i.e., laptop) energy savings of up to 28% can be achieved with performance degradation of less than 5% for the SPECfp95 benchmarks. On average, the system energy and energy-delay product are reduced by 11% and 9%, respectively, with a performance slowdown of 2%. It was also discovered that the energy usage of the programs using our DVS algorithm is within 6% from the theoretical lower bound. To the best of our knowledge, this is one of the first work that evaluates DVS algorithms by physical measurements.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781137", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chung‐Hsing", + "last_name": "Hsu", + "institution": "" + }, + { + "first_name": "Ulrich", + "last_name": "Kremer", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/pldi/HsuK03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781133", + "title": "The nesC language: A holistic approach to networked embedded systems", + "abstract": "We present nesC, a programming language for networked embedded systems that represent a new design space for application developers. An example of a networked embedded system is a sensor network, which consists of (potentially) thousands of tiny, low-power \"motes,\" each of which execute concurrent, reactive programs that must operate with severe memory and power constraints.nesC's contribution is to support the special needs of this domain by exposing a programming model that incorporates event-driven execution, a flexible concurrency model, and component-oriented application design. Restrictions on the programming model allow the nesC compiler to perform whole-program analyses, including data-race detection (which improves reliability) and aggressive function inlining (which reduces resource consumption).nesC has been used to implement TinyOS, a small operating system for sensor networks, as well as several significant sensor applications. nesC and TinyOS have been adopted by a large number of sensor network research groups, and our experience and evaluation of the language shows that it is effective at supporting the complex, concurrent programming style demanded by this new class of deeply networked systems.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781133", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Gay", + "institution": "Intel (United States)" + }, + { + "first_name": "Philip", + "last_name": "Levis", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Robert von", + "last_name": "Behren", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Matt", + "last_name": "Welsh", + "institution": "Intel (United States)" + }, + { + "first_name": "Eric", + "last_name": "Brewer", + "institution": "University of California, Berkeley" + }, + { + "first_name": "David", + "last_name": "Culler", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/GayLBWBC03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781152", + "title": "Debugging temporal specifications with concept analysis", + "abstract": "Program verification tools (such as model checkers and static analyzers) can find many errors in programs. These tools need formal specifications of correct program behavior, but writing a correct specification is difficult, just as writing a correct program is difficult. Thus, just as we need methods for debugging programs, we need methods for debugging specifications.This paper describes a novel method for debugging formal, temporal specifications. Our method exploits the short program execution traces that program verification tools generate from specification violations and that specification miners extract from programs. Manually examining these traces is a straightforward way to debug a specification, but this method is tedious and error-prone because there may be hundreds or thousands of traces to inspect. Our method uses concept analysis to automatically group the traces into highly similar clusters. By examining clusters instead of individual traces, a person can debug a specification with less work.To test our method, we implemented a tool, Cable, for debugging specifications. We have used Cable to debug specifications produced by Strauss, our specification miner. We found that using Cable to debug these specifications requires, on average, less than one third as many user decisions as debugging by examining all traces requires. In one case, using Cable required only 28 decisions, while debugging by examining all traces required 224.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781152", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Glenn", + "last_name": "Ammons", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "David", + "last_name": "Mandelin", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/AmmonsMBL03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781153", + "title": "A static analyzer for large safety-critical software", + "abstract": "We show that abstract interpretation-based static program analysis can be made efficient and precise enough to formally verify a class of properties for a family of large programs with few or no false alarms. This is achieved by refinement of a general purpose static analyzer and later adaptation to particular programs of the family by the end-user through parametrization. This is applied to the proof of soundness of data manipulation operations at the machine level for periodic synchronous safety critical embedded software.The main novelties are the design principle of static analyzers by refinement and adaptation through parametrization (Sect. 3 and 7), the symbolic manipulation of expressions to improve the precision of abstract transfer functions (Sect. 6.3), the octagon (Sect. 6.2.2), ellipsoid (Sect. 6.2.3), and decision tree (Sect. 6.2.4) abstract domains, all with sound handling of rounding errors in oating point computations, widening strategies (with thresholds: Sect. 7.1.2, delayed: Sect. 7.1.3) and the automatic determination of the parameters (parametrized packing: Sect. 7.2).", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781153", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bruno", + "last_name": "Blanchet", + "institution": "École Normale Supérieure" + }, + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "École Normale Supérieure" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "Centre National pour la Recherche Scientifique et Technique (CNRST)" + }, + { + "first_name": "Jérôme", + "last_name": "Ferêt", + "institution": "École Normale Supérieure" + }, + { + "first_name": "Laurent", + "last_name": "Mauborgne", + "institution": "École Normale Supérieure" + }, + { + "first_name": "Antoine", + "last_name": "Miné", + "institution": "École Normale Supérieure" + }, + { + "first_name": "David", + "last_name": "Monniaux", + "institution": "Centre National pour la Recherche Scientifique et Technique (CNRST)" + }, + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "École Normale Supérieure" + } + ], + "dblp_key": "conf/pldi/BlanchetCCFMMMR03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781150", + "title": "A practical flow-sensitive and context-sensitive C and C++ memory leak detector", + "abstract": "This paper presents a static analysis tool that can automatically find memory leaks and deletions of dangling pointers in large C and C++ applications.We have developed a type system to formalize a practical ownership model of memory management. In this model, every object is pointed to by one and only one owning pointer, which holds the exclusive right and obligation to either delete the object or to transfer the right to another owning pointer. In addition, a pointer-typed class member field is required to either always or never own its pointee at public method boundaries. Programs satisfying this model do not leak memory or delete the same object more than once.We have also developed a flow-sensitive and context-sensitive algorithm to automatically infer the likely ownership interfaces of methods in a program. It identifies statements inconsistent with the model as sources of potential leaks or double deletes. The algorithm is sound with respect to a large subset of the C and C++ language in that it will report all possible errors. It is also practical and useful as it identifies those warnings likely to correspond to errors and helps the user understand the reported errors by showing them the assumed method interfaces.Our techniques are validated with an implementation of a tool we call Clouseau. We applied Clouseau to a suite of applications: two web servers, a chat client, secure shell tools, executable object manipulation tools, and a compiler. The tool found a total of 134 serious memory errors in these applications. The tool analyzes over 50K lines of C++ code in about 9 minutes on a 2 GHz Pentium 4 machine and over 70K lines of C code in just over a minute.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781150", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "D.", + "last_name": "Heine", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/HeineL03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781140", + "title": "A comparison of empirical and model-driven optimization", + "abstract": "Empirical program optimizers estimate the values of key optimization parameters by generating different program versions and running them on the actual hardware to determine which values give the best performance. In contrast, conventional compilers use models of programs and machines to choose these parameters. It is widely believed that model-driven optimization does not compete with empirical optimization, but few quantitative comparisons have been done to date. To make such a comparison, we replaced the empirical optimization engine in ATLAS (a system for generating a dense numerical linear algebra library called the BLAS) with a model-driven optimization engine that used detailed models to estimate values for optimization parameters, and then measured the relative performance of the two systems on three different hardware platforms. Our experiments show that model-driven optimization can be surprisingly effective, and can generate code whose performance is comparable to that of code generated by empirical optimizers for the BLAS.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781140", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kamen", + "last_name": "Yotov", + "institution": "Cornell University" + }, + { + "first_name": "Xiaoming", + "last_name": "Li", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gang", + "last_name": "Ren", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Michael", + "last_name": "Cibulskis", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gerald", + "last_name": "DeJong", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "María Jesús", + "last_name": "Garzarán", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "Cornell University" + }, + { + "first_name": "Paul", + "last_name": "Stodghill", + "institution": "Cornell University" + }, + { + "first_name": "Peng", + "last_name": "Wu", + "institution": "" + } + ], + "dblp_key": "conf/pldi/YotovLRCDGPPSW03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781141", + "title": "Meta optimization: improving compiler heuristics with machine learning", + "abstract": "Compiler writers have crafted many heuristics over the years to approximately solve NP-hard problems efficiently. Finding a heuristic that performs well on a broad range of applications is a tedious and difficult process. This paper introduces Meta Optimization, a methodology for automatically fine-tuning compiler heuristics. Meta Optimization uses machine-learning techniques to automatically search the space of compiler heuristics. Our techniques reduce compiler design complexity by relieving compiler writers of the tedium of heuristic tuning. Our machine-learning system uses an evolutionary algorithm to automatically find effective compiler heuristics. We present promising experimental results. In one mode of operation Meta Optimization creates application-specific heuristics which often result in impressive speedups. For hyperblock formation, one optimization we present in this paper, we obtain an average speedup of 23% (up to 73%) for the applications in our suite. Furthermore, by evolving a compiler's heuristic over several benchmarks, we can create effective, general-purpose heuristics. The best general-purpose heuristic our system found for hyperblock formation improved performance by an average of 25% on our training set, and 9% on a completely unrelated test set. We demonstrate the efficacy of our techniques on three different optimizations in this paper: hyperblock formation, register allocation, and data prefetching.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781141", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark W.", + "last_name": "Stephenson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martín", + "last_name": "Martín", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Una-May", + "last_name": "O’Reilly", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/StephensonAMO03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781156", + "title": "Automatically proving the correctness of compiler optimizations", + "abstract": "We describe a technique for automatically proving compiler optimizations sound, meaning that their transformations are always semantics-preserving. We first present a domain-specific language, called Cobalt, for implementing optimizations as guarded rewrite rules. Cobalt optimizations operate over a C-like intermediate representation including unstructured control flow, pointers to local variables and dynamically allocated memory, and recursive procedures. Then we describe a technique for automatically proving the soundness of Cobalt optimizations. Our technique requires an automatic theorem prover to discharge a small set of simple, optimization-specific proof obligations for each optimization. We have written a variety of forward and backward intraprocedural dataflow optimizations in Cobalt, including constant propagation and folding, branch folding, full and partial redundancy elimination, full and partial dead assignment elimination, and simple forms of points-to analysis. We implemented our soundness-checking strategy using the Simplify automatic theorem prover, and we have used this implementation to automatically prove our optimizations correct. Our checker found many subtle bugs during the course of developing our optimizations. We also implemented an execution engine for Cobalt optimizations as part of the Whirlwind compiler infrastructure.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781156", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of Washington" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/LernerMC03", + "venue": "pldi", + "year": 2003 + }, + { + "paper_id": "10.1145/781131.781166", + "title": "A region-based compilation technique for a Java just-in-time compiler", + "abstract": "Method inlining and data flow analysis are two major optimization components for effective program transformations, however they often suffer from the existence of rarely or never executed code contained in the target method. One major problem lies in the assumption that the compilation unit is partitioned at method boundaries. This paper describes the design and implementation of a region-based compilation technique in our dynamic compilation system, in which the compiled regions are selected as code portions without rarely executed code. The key part of this technique is the region selection, partial inlining, and region exit handling. For region selection, we employ both static heuristics and dynamic profiles to identify rare sections of code. The region selection process and method inlining decision are interwoven, so that method inlining exposes other targets for region selection, while the region selection in the inline target conserves the inlining budget, leading to more method inlining. Thus the inlining process can be performed for parts of a method, not for the entire body of the method. When the program attempts to exit from a region boundary, we trigger recompilation and then rely on on-stack replacement to continue the execution from the corresponding entry point in the recompiled code. We have implemented these techniques in our Java JIT compiler, and conducted a comprehensive evaluation. The experimental results show that the approach of region-based compilation achieves approximately 5% performance improvement on average, while reducing the compilation overhead by 20 to 30%, in comparison to the traditional function-based compilation techniques.", + "date": "2003-05-09", + "link": "https://doi.org/10.1145/781131.781166", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Toshio", + "last_name": "Suganuma", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Toshiaki", + "last_name": "Yasue", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/pldi/SuganumaYN03", + "venue": "pldi", + "year": 2003 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2004.json b/data/pl_conferences/pldi/2004.json new file mode 100644 index 0000000..a274a4a --- /dev/null +++ b/data/pl_conferences/pldi/2004.json @@ -0,0 +1,725 @@ +[ + { + "paper_id": "10.1145/996841.996846", + "title": "Verifying safety properties using separation and heterogeneous abstractions", + "abstract": "In this paper, we show how separation (decomposing a verification problem into a collection of verification subproblems) can be used to improve the efficiency and precision of verification of safety properties. We present a simple language for specifying separation strategies for decomposing a single verification problem into a set of subproblems. (The strategy specification is distinct from the safety property specification and is specified separately.) We present a general framework of heterogeneous abstraction that allows different parts of the heap to be abstracted using different degrees of precision at different points during the analysis. We show how the goals of separation (i.e., more efficient verification) can be realized by first using a separation strategy to transform (instrument) a verification problem instance (consisting of a safety property specification and an input program), and by then utilizing heterogeneous abstraction during the verification of the transformed verification problem.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996846", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/YahavR04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996872", + "title": "Array regrouping and structure splitting using whole-program reference affinity", + "abstract": "While the memory of most machines is organized as a hierarchy, program data are laid out in a uniform address space. This paper defines a model of reference affinity, which measures how close a group of data are accessed together in a reference trace. It proves that the model gives a hierarchical partition of program data. At the top is the set of all data with the weakest affinity. At the bottom is each data element with the strongest affinity. Based on the theoretical model, the paper presents k-distance analysis, a practical test for the hierarchical affinity of source-level data. When used for array regrouping and structure splitting, k-distance analysis consistently outperforms data organizations given by the programmer, compiler analysis, frequency profiling, statistical clustering, and all other methods we have tried.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996872", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yutao", + "last_name": "Zhong", + "institution": "University of Rochester" + }, + { + "first_name": "Maksim", + "last_name": "Orlovich", + "institution": "University of Rochester" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "University of Rochester" + }, + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/pldi/ZhongOSD04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996875", + "title": "A generalized algorithm for graph-coloring register allocation", + "abstract": "Graph-coloring register allocation is an elegant and extremely popular optimization for modern machines. But as currently formulated, it does not handle two characteristics commonly found in commercial architectures. First, a single register name may appear in multiple register classes, where a class is a set of register names that are interchangeable in a particular role. Second, multiple register names may be aliases for a single hardware register. We present a generalization of graph-coloring register allocation that handles these problematic characteristics while preserving the elegance and practicality of traditional graph coloring. Our generalization adapts easily to a new target machine, requiring only the sets of names in the register classes and a map of the register aliases. It also drops easily into a well-known graph-coloring allocator, is efficient at compile time, and produces high-quality code. Categories and subject descriptors D.3.4 [Programming Languages]: Processors—code generation, compilers, optimization, retargetable compilers; G.2.2 [Discrete", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996875", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Smith", + "institution": "Harvard University Press" + }, + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Harvard University Press" + }, + { + "first_name": "Glenn", + "last_name": "Holloway", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/pldi/SmithRH04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996871", + "title": "Region inference for an object-oriented language", + "abstract": "Region-based memory management offers several important potential advantages over garbage collection, including real-time performance, better data locality, and more efficient use of limited memory. Researchers have advocated the use of regions for functional, imperative, and object-oriented languages. Lexically scoped regions are now a core feature of the Real-Time Specification for Java (RTSJ)[5].Recent research in region-based programming for Java has focused on region checking, which requires manual effort to augment the program with region annotations. In this paper, we propose an automatic region inference system for a core subset of Java. To provide an inference method that is both precise and practical, we support classes and methods that are region-polymorphic, with region-polymorphic recursion for methods. One challenging aspect is to ensure region safety in the presence of features such as class subtyping, method overriding, and downcast operations. Our region inference rules can handle these object-oriented features safely without creating dangling references.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996871", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + }, + { + "first_name": "Florin", + "last_name": "Crăciun", + "institution": "National University of Singapore" + }, + { + "first_name": "Shengchao", + "last_name": "Qin", + "institution": "Singapore-MIT Alliance for Research and Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ChinCQR04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996864", + "title": "Inducing heuristics to decide whether to schedule", + "abstract": "Instruction scheduling is a compiler optimization that can improve program speed, sometimes by 10% or more, but it can also be expensive. Furthermore, time spent optimizing is more important in a Java just-in-time (JIT) compiler than in a traditional one because a JIT compiles code at run time, adding to the running time of the program. We found that, on any given block of code, instruction scheduling often does not produce significant benefit and sometimes degrades speed. Thus, we hoped that we could focus scheduling effort on those blocks that benefit from it.Using supervised learning we induced heuristics to predict which blocks benefit from scheduling. The induced function chooses, for each block, between list scheduling and not scheduling the block at all. Using the induced function we obtained over 90% of the improvement of scheduling every block but with less than 25% of the scheduling effort. When used in combination with profile-based adaptive optimization, the induced function remains effective but gives a smaller reduction in scheduling effort. Deciding when to optimize, and which optimization(s) to apply, is an important open problem area in compiler research. We show that supervised learning solves one of these problems well.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996864", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Cavazos", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/CavazosEM04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996873", + "title": "Prefetch inection based on hardware monitoring and object metadata", + "abstract": "Cache miss stalls hurt performance because of the large gap between memory and processor speeds - for example, the popular server benchmark SPEC JBB2000 spends 45% of its cycles stalled waiting for memory requests on the Itanium® 2 processor. Traversing linked data structures causes a large portion of these stalls. Prefetching for linked data structures remains a major challenge because serial data dependencies between elements in a linked data structure preclude the timely materialization of prefetch addresses. This paper presents Mississippi Delta (MS Delta), a novel technique for prefetching linked data structures that closely integrates the hardware performance monitor (HPM), the garbage collector's global view of heap and object layout, the type-level metadata inherent in type-safe programs, and JIT compiler analysis. The garbage collector uses the HPM's data cache miss information to identify cache miss intensive traversal paths through linked data structures, and then discovers regular distances (deltas) between these linked objects. JIT compiler analysis injects prefetch instructions using deltas to materialize prefetch addresses.We have implemented MS Delta in a fully dynamic profile-guided optimization system: the StarJIT dynamic compiler [1] and the ORP Java virtual machine [9]. We demonstrate a 28-29% reduction in stall cycles attributable to the high-latency cache misses targeted by MS Delta and a speedup of 11-14% on the cache miss intensive SPEC JBB2000 benchmark.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996873", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Intel (United States)" + }, + { + "first_name": "Richard L.", + "last_name": "Hudson", + "institution": "Intel (United States)" + }, + { + "first_name": "Maurício", + "last_name": "Serrano", + "institution": "Intel (United States)" + }, + { + "first_name": "Sreenivas", + "last_name": "Subramoney", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/Adl-TabatabaiHSS04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996849", + "title": "Kill-safe synchronization abstractions", + "abstract": "When an individual task can be forcefully terminated at any time, cooperating tasks must communicate carefully. For example, if two tasks share an object, and if one task is terminated while it manipulates the object, the object may remain in an inconsistent or frozen state that incapacitates the other task. To support communication among terminable tasks, language run-time systems (and operating systems) provide kill-safe abstractions for inter-task communication. No kill-safe guarantee is available, however, for abstractions that are implemented outside the run-time system.In this paper, we show how a run-time system can support new kill-safe abstractions without requiring modification to the run-time system, and without requiring the run-time system to trust any new code. Our design frees the run-time implementor to provide only a modest set of synchronization primitives in the trusted computing base, while still allowing tasks to communicate using sophisticated abstractions.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996849", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/pldi/FlattF04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996876", + "title": "Balancing register allocation across threads for a multithreaded network processor", + "abstract": "Modern network processors employ multi-threading to allow concurrency amongst multiple packet processing tasks. We studied the properties of applications running on the network processors and observed that their imbalanced register requirements across different threads at different program points could lead to poor performance. Many times application needs demand some threads to be more performance critical than others and thus by controlling the register allocation across threads one could impact the performance of the threads and get the desired performance properties for concurrent threads. This prompts our work.Our register allocator aims to distribute available registers to different threads according to their needs. The compiler analyzes the register needs of each thread both at the point of a context switch as well as internally. Compiler then designates some registers as shared and some as private to each thread. Shared registers are allocated across all threads explicitly by the compiler. Values that are live across a context switch can not be kept in shared registers due to safety reasons; thus, only those live ranges that are internal to the context switch can be safely allocated to shared registers. Spill can cause a context switch. and thus, the problems of context switch and allocation are closely coupled and we propose a solution to this problem. The proposed interference graphs (GIG,BIG,IIG) distinguish variables that must use a thread's private registers from those that can use shared registers. We first estimate the register requirement bounds, then reduce from the upper bound gradually to achieve a good register balance among threads. To reduce the register needs, move insertions are inserted at program points that split the live ranges or the nodes on the interference graph. We show that the lower bound is reachable via live range splitting and is adequate for our benchmark programs for simultaneously assigning them on different threads. As our objective, the number of move instructions is minimized.Empirical results show that the compiler is able to effectively control the register allocation across threads by maximizing the number of shared registers. Speed-up for performance critical threads ranges from 18 to 24% whereas degradation for performance of non-critical threads ranges only from 1 to 4%.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996876", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiaotong", + "last_name": "Zhuang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ZhuangP04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996861", + "title": "Jedd: a BDD-based relational extension of Java", + "abstract": "In this paper we present Jedd, a language extension to Java that supports a convenient way of programming with Binary Decision Diagrams (BDDs). The Jedd language abstracts BDDs as database-style relations and operations on relations, and provides static type rules to ensure that relational operations are used correctly.The paper provides a description of the Jedd language and reports on the design and implementation of the Jedd translator and associated runtime system. Of particular interest is the approach to assigning attributes from the high-level relations to physical domains in the underlying BDDs, which is done by expressing the constraints as a SAT problem and using a modern SAT solver to compute the solution. Further, a runtime system is defined that handles memory management issues and supports a browsable profiling tool for tuning the key BDD operations.The motivation for designing Jedd was to support the development of whole program analyses based on BDDs, and we have used Jedd to express five key interrelated whole program analyses in our Soot compiler framework. We provide some examples of this application and discuss our experiences using Jedd.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996861", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/pldi/LhotakH04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996845", + "title": "KISS: keep it simple and sequential", + "abstract": "The design of concurrent programs is error-prone due to the interaction between concurrently executing threads. Traditional automated techniques for finding errors in concurrent programs, such as model checking, explore all possible thread interleavings. Since the number of thread interleavings increases exponentially with the number of threads, such analyses have high computational complexity. In this paper, we present a novel analysis technique for concurrent programs that avoids this exponential complexity. Our analysis transforms a concurrent program into a sequential program that simulates the execution of a large subset of the behaviors of the concurrent program. The sequential program is then analyzed by a tool that only needs to understand the semantics of sequential execution. Our technique never reports false errors but may miss errors. We have implemented the technique in KISS, an automated checker for multithreaded C programs, and obtained promising initial results by using KISS to detect race conditions in Windows device drivers.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996845", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dinghao", + "last_name": "Wu", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/QadeerW04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996865", + "title": "The liberty structural specification language: a high-level modeling language for component reuse", + "abstract": "Rapid exploration of the design space with simulation models is essential for quality hardware systems research and development. Despite striking commonalities across hardware systems, designers routinely fail to achieve high levels of reuse across models constructed in existing general-purpose and domain-specific languages. This lack of reuse adversely impacts hardware system design by slowing the rate at which ideas are evaluated. This paper presents an examination of existing languages to reveal their fundamental limitations regarding reuse in hardware modeling. With this understanding, a solution is described in the context of the design and implementation of the Liberty Structural Specification Language (LSS), the input language for a publicly available high-level digital-hardware modeling tool called the Liberty Simulation Environment. LSS is the first language to enable low-overhead reuse by simultaneously supporting static inference based on hardware structure and flexibility via parameterizable structure. Through LSS, this paper also introduces a new type inference algorithm and a new programming language technique, called use-based specialization, which, in a manner analogous to type inference, customizes reusable components by statically inferring structural properties that otherwise would have had to have been specified manually.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996865", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manish", + "last_name": "Vachharajani", + "institution": "Princeton University" + }, + { + "first_name": "Neil", + "last_name": "Vachharajani", + "institution": "Princeton University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/VachharajaniVA04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996856", + "title": "Dynamic path-based software watermarking", + "abstract": "Software watermarking is a tool used to combat software piracy by embedding identifying information into a program. Most existing proposals for software watermarking have the shortcoming that the mark can be destroyed via fairly straightforward semantics-preserving code transformations. This paper introduces path-based watermarking, a new approach to software watermarking based on the dynamic branching behavior of programs. The advantage of this technique is that error-correcting and tamper-proofing techniques can be used to make path-based watermarks resilient against a wide variety of attacks. Experimental results, using both Java bytecode and IA-32 native code, indicate that even relatively large watermarks can be embedded into programs at modest cost.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996856", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christian", + "last_name": "Collberg", + "institution": "University of Arizona" + }, + { + "first_name": "E.", + "last_name": "Carter", + "institution": "University of Arizona" + }, + { + "first_name": "S.", + "last_name": "Debray", + "institution": "University of Arizona" + }, + { + "first_name": "A.", + "last_name": "Huntwork", + "institution": "University of Arizona" + }, + { + "first_name": "John", + "last_name": "Kececioglu", + "institution": "University of Arizona" + }, + { + "first_name": "Cullen", + "last_name": "Linn", + "institution": "University of Arizona" + }, + { + "first_name": "Michael", + "last_name": "Stepp", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/CollbergCDHKLS04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996842", + "title": "Social processes and proofs of theorems and programs, revisited", + "abstract": "Language-based security is a protection mechanism that allows software components to interact in a shared address space, such that each component is guaranteed to respect its interfaces and not steal or corrupt internal data of other components. This protection mechanism is complicated to implement correctly, so we might want a formal verification of it.But we know by a famous result of DeMillo, Lipton, and Perlis (POPL 1978) that formal verification (1) is not what mathematicians do, (2) can never be practical, and (3) cannot tell us anything truly useful. Is this still true 25 years later?The question is, then, how can we carefully skirt the legitimate objections of DeMillo et al. and successfully use formal verification in a context where it can do some good. I'll talk about Foundational Proof-Carrying Code, a machine-checked soundness proof for a protection mechanism usable in Java-like virtual machines.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996842", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/Appel04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996851", + "title": "Min-cut program decomposition for thread-level speculation", + "abstract": "With billion-transistor chips on the horizon, single-chip multiprocessors (CMPs) are likely to become commodity components. Speculative CMPs use hardware to enforce dependence, allowing the compiler to improve performance by speculating on ambiguous dependences without absolute guarantees of independence. The compiler is responsible for decomposing a sequential program into speculatively parallel threads, while considering multiple performance overheads related to data dependence, load imbalance, and thread prediction. Although the decomposition problem lends itself to a min-cut-based approach, the overheads depend on the thread size, requiring the edge weights to be changed as the algorithm progresses. The changing weights make our approach di#erent from graph-theoretic solutions to the general problem of task scheduling. One recent work uses a set of heuristics, each targeting a specific overhead in isolation, and gives precedence to thread prediction, without comparing the performance of the threads resulting from each heuristic. By contrast, our method uses a sequence of balanced min-cuts that give equal consideration to all the overheads, and adjusts the edge weights after every cut. This method achieves an (geometric) average speedup of 74% for floating-point programs and 23% for integer programs on a four-processor chip, improving on the 52% and 13% achieved by the previous heuristics.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996851", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Troy A.", + "last_name": "Johnson", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Rudolf", + "last_name": "Eigenmann", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "T. N.", + "last_name": "Vijaykumar", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/JohnsonEV04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996863", + "title": "Fast searches for effective optimization phase sequences", + "abstract": "It has long been known that a fixed ordering of optimization phases will not produce the best code for every application. One approach for addressing this phase ordering problem is to use an evolutionary algorithm to search for a specific sequence of phases for each module or function. While such searches have been shown to produce more efficient code, the approach can be extremely slow because the application is compiled and executed to evaluate each sequence's effectiveness. Consequently, evolutionary or iterative compilation schemes have been promoted for compilation systems targeting embedded applications where longer compilation times may be tolerated in the final stage of development. In this paper we describe two complementary general approaches for achieving faster searches for effective optimization sequences when using a genetic algorithm. The first approach reduces the search time by avoiding unnecessary executions of the application when possible. Results indicate search time reductions of 65% on average, often reducing searches from hours to minutes. The second approach modifies the search so fewer generations are required to achieve the same results. Measurements show that the average number of required generations decreased by 68%. These improvements have the potential for making evolutionary compilation a viable choice for tuning embedded applications.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996863", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Prasad A.", + "last_name": "Kulkarni", + "institution": "Florida State University" + }, + { + "first_name": "Stephen", + "last_name": "Hines", + "institution": "Florida State University" + }, + { + "first_name": "Jason D.", + "last_name": "Hiser", + "institution": "University of Virginia" + }, + { + "first_name": "David", + "last_name": "Whalley", + "institution": "Florida State University" + }, + { + "first_name": "Jack W.", + "last_name": "Davidson", + "institution": "University of Virginia" + }, + { + "first_name": "Douglas L.", + "last_name": "Jones", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/KulkarniHHWDJ04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996857", + "title": "Parametric analysis for adaptive computation offloading", + "abstract": "Many programs can be invoked under different execution options, input parameters and data files. Such different execution contexts may lead to strikingly different execution instances. The optimal code generation may be sensitive to the execution instances. In this paper, we show how to use parametric program analysis to deal with this issue for the optimization problem of computation offloading.Computation offloading has been shown to be an effective way to improve performance and energy saving on mobile devices. Optimal program partitioning for computation offloading depends on the tradeoff between the computation workload and the communication cost. The computation workload and communication requirement may change with different execution instances. Optimal decisions on program partitioning must be made at run time when sufficient information about workload and communication requirement becomes available.Our cost analysis obtains program computation workload and communication cost expressed as functions of run-time parameters, and our parametric partitioning algorithm finds the optimal program partitioning corresponding to different ranges of run-time parameters. At run time, the transformed program self-schedules its tasks on either the mobile device or the server, based on the optimal program partitioning that corresponds to the current values of run-time parameters. Experimental results on an HP IPAQ handheld device show that different run-time parameters can lead to quite different program partitioning decisions.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996857", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cheng", + "last_name": "Wang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Zhiyuan", + "last_name": "Li", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/WangL04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996848", + "title": "Scalable lock-free dynamic memory allocation", + "abstract": "Dynamic memory allocators (malloc/free) rely on mutual exclusion locks for protecting the consistency of their shared data structures under multithreading. The use of locking has many disadvantages with respect to performance, availability, robustness, and programming flexibility. A lock-free memory allocator guarantees progress regardless of whether some threads are delayed or even killed and regardless of scheduling policies. This paper presents a completely lock-free memory allocator. It uses only widely-available operating system support and hardware atomic instructions. It offers guaranteed availability even under arbitrary thread termination and crash-failure, and it is immune to deadlock regardless of scheduling policies, and hence it can be used even in interrupt handlers and real-time applications without requiring special scheduler support. Also, by leveraging some high-level structures from Hoard, our allocator is highly scalable, limits space blowup to a constant factor, and is capable of avoiding false sharing. In addition, our allocator allows finer concurrency and much lower latency than Hoard. We use PowerPC shared memory multiprocessor systems to compare the performance of our allocator with the default AIX 5.1 libc malloc, and two widely-used multithread allocators, Hoard and Ptmalloc. Our allocator outperforms the other allocators in virtually all cases and often by substantial margins, under various levels of parallelism and allocation patterns. Furthermore, our allocator also offers the lowest contention-free latency among the allocators by significant margins.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996848", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Maged M.", + "last_name": "Michael", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/Michael04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996853", + "title": "Vectorization for SIMD architectures with alignment constraints", + "abstract": "When vectorizing for SIMD architectures that are commonly employed by today's multimedia extensions, one of the new challenges that arise is the handling of memory alignment. Prior research has focused primarily on vectorizing loops where all memory references are properly aligned. An important aspect of this problem, namely, how to vectorize misaligned memory references, still remains unaddressed.This paper presents a compilation scheme that systematically vectorizes loops in the presence of misaligned memory references. The core of our technique is to automatically reorganize data in registers to satisfy the alignment requirement imposed by the hardware. To reduce the data reorganization overhead, we propose several techniques to minimize the number of data reorganization operations generated. During the code generation, our algorithm also exploits temporal reuse when aligning references that access contiguous memory across loop iterations. Our code generation scheme guarantees to never load the same data associated with a single static access twice. Experimental results indicate near peak speedup factors, e.g., 3.71 for 4 data per vector and 6.06 for 8 data per vector, respectively, for a set of loops where 75% or more of the static memory references are misaligned.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996853", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alexandre E.", + "last_name": "Eichenberger", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Peng", + "last_name": "Wu", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Kevin", + "last_name": "O’Brien", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/EichenbergerWO04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996867", + "title": "The set constraint/CFL reachability connection in practice", + "abstract": "Many program analyses can be reduced to graph reachability problems involving a limited form of context-free language reachability called Dyck-CFL reachability. We show a new reduction from Dyck-CFL reachability to set constraints that can be used in practice to solve these problems. Our reduction is much simpler than the general reduction from context-free language reachability to set constraints. We have implemented our reduction on top of a set constraints toolkit and tested its performance on a substantial polymorphic flow analysis application.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996867", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Kodumal", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/KodumalA04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996868", + "title": "Parametric regular path queries", + "abstract": "Regular path queries are a way of declaratively expressing queries on graphs as regular-expression-like patterns that are matched against paths in the graph. There are two kinds of queries: existential queries, which specify properties about individual paths, and universal queries, which specify properties about all paths. They provide a simple and convenient framework for expressing program analyses as queries on graph representations of programs, for expressing verification (model-checking) problems as queries on transition systems, for querying semi-structured data, etc. Parametric regular path queries extend the patterns with variables, called parameters, which significantly increase the expressiveness by allowing additional information along single or multiple paths to be captured and relate.This paper shows how a variety of program analysis and model-checking problems can be expressed easily and succinctly using parametric regular path queries. The paper describes the specification, design, analysis, and implementation of algorithms and data structures for efficiently solving existential and universal parametric regular path queries. Major contributions include the first complete algorithms and data structures for directly and efficiently solving existential and universal parametric regular path queries, detailed complexity analysis of the algorithms, detailed analytical and experimental performance comparison of variations of the algorithms and data structures, and investigation of efficiency tradeoffs between different formulations of queries.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996868", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yanhong A.", + "last_name": "Liu", + "institution": "State University of New York" + }, + { + "first_name": "Tom", + "last_name": "Rothamel", + "institution": "State University of New York" + }, + { + "first_name": "Fuxiang", + "last_name": "Yu", + "institution": "State University of New York" + }, + { + "first_name": "Scott D.", + "last_name": "Stoller", + "institution": "State University of New York" + }, + { + "first_name": "Nanjun", + "last_name": "Hu", + "institution": "State University of New York" + } + ], + "dblp_key": "conf/pldi/LiuRYSH04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996869", + "title": "Precise and efficient static array bound checking for large embedded C programs", + "abstract": "In this paper we describe the design and implementation of a static array-bound checker for a family of embedded programs: the flight control software of recent Mars missions. These codes are large (up to 280 KLOC), pointer intensive, heavily multithreaded and written in an object-oriented style, which makes their analysis very challenging. We designed a tool called C Global Surveyor (CGS) that can analyze the largest code in a couple of hours with a precision of 80%. The scalability and precision of the analyzer are achieved by using an incremental framework in which a pointer analysis and a numerical analysis of array indices mutually refine each other. CGS has been designed so that it can distribute the analysis over several processors in a cluster of machines. To the best of our knowledge this is the first distributed implementation of static analysis algorithms. Throughout the paper we will discuss the scalability setbacks that we encountered during the construction of the tool and their impact on the initial design decisions.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996869", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Arnaud", + "last_name": "Venet", + "institution": "Ames Research Center" + }, + { + "first_name": "Guillaume", + "last_name": "Brat", + "institution": "Ames Research Center" + } + ], + "dblp_key": "conf/pldi/VenetB04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996844", + "title": "Race checking by context inference", + "abstract": "Software model checking has been successful for sequential programs, where predicate abstraction offers suitable models, and counterexample-guided abstraction refinement permits the automatic inference of models. When checking concurrent programs, we need to abstract threads as well as the contexts in which they execute. Stateless context models, such as predicates on global variables, prove insufficient for showing the absence of race conditions in many examples. We therefore use richer context models, which combine (1) predicates for abstracting data state, (2) control flow quotients for abstracting control state, and (3) counters for abstracting an unbounded number of threads. We infer suitable context models automatically by a combination of counterexample-guided abstraction refinement, bisimulation minimization, circular assume-guarantee reasoning, and parametric reasoning about an unbounded number of threads. This algorithm, called CIRC, has been implemented in BLAST and succeeds in checking many examples of NESC code for data races. In particular, BLAST proves the absence of races in several cases where previous race checkers give false positives.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996844", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Berkeley College" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "Berkeley College" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "UtopiaCompression (United States)" + } + ], + "dblp_key": "conf/pldi/HenzingerJM04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996852", + "title": "A cost-driven compilation framework for speculative parallelization of sequential programs", + "abstract": "The emerging hardware support for thread-level speculation opens new opportunities to parallelize sequential programs beyond the traditional limits. By speculating that many data dependences are unlikely during runtime, consecutive iterations of a sequential loop can be executed speculatively in parallel. Runtime parallelism is obtained when the speculation is correct. To take full advantage of this new execution model, a program needs to be programmed or compiled in such a way that it exhibits high degree of speculative thread-level parallelism. We propose a comprehensive cost-driven compilation framework to perform speculative parallelization. Based on a misspeculation cost model, the compiler aggressively transforms loops into optimal speculative parallel loops and selects only those loops whose speculative parallel execution is likely to improve program", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996852", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhao-Hui", + "last_name": "Du", + "institution": "Intel (United States)" + }, + { + "first_name": "Chu-Cheow", + "last_name": "Lim", + "institution": "Intel (United States)" + }, + { + "first_name": "Xiaofeng", + "last_name": "Li", + "institution": "Intel (United States)" + }, + { + "first_name": "Yang", + "last_name": "Chen", + "institution": "Intel (United States)" + }, + { + "first_name": "Qingyu", + "last_name": "Zhao", + "institution": "Intel (United States)" + }, + { + "first_name": "Tin‐Fook", + "last_name": "Ngai", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/DuLLYZN04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996855", + "title": "Cost effective dynamic program slicing", + "abstract": "Although dynamic program slicing was first introduced to aid in user level debugging, applications aimed at improving software quality, reliability, security, and performance have since been identified as candidates for using dynamic slicing. However, the dynamic dependence graph constructed to compute dynamic slices can easily cause slicing algorithms to run out of memory for realistic program runs. In this paper we present the design and evaluation of a cost effective dynamic program slicing algorithm. This algorithm is based upon a dynamic dependence graph representation that is highly compact and rapidly traversable. Thus, the graph can be held in memory and dynamic slices can be quickly computed. A compact representation is derived by recognizing that all dynamic dependences (data and control) need not be individually represented. We identify sets of dynamic dependence edges between a pair of statements that can share a single representative edge. We further show that the dependence graph can be transformed in a manner that increases sharing and sharing can be performed even in the presence of aliasing. Experiments show that transformed dynamic dependence graphs explicitly represent only 6% of the dependence edges present in the full dynamic dependence graph. When the full graph sizes range from 0.84 to 1.95 Gigabytes in size, our compacted graphs range from 20 to 210 Megabytes in size. Average slicing times for our algorithm range from 1.74 to 36.25 seconds across several benchmarks from SPECInt2000/95.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996855", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "University of Arizona" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/ZhangG04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996859", + "title": "Cloning-based context-sensitive pointer alias analysis using binary decision diagrams", + "abstract": "This paper presents the first scalable context-sensitive, inclusion-based pointer alias analysis for Java programs. Our approach to context sensitivity is to create a clone of a method for every context of interest, and run a context-insensitive algorithm over the expanded call graph to get context-sensitive results. For precision, we generate a clone for every acyclic path through a program&apos;s call graph, treating methods in a strongly connected component as a single node. Normally, this formulation is hopelessly intractable as a call graph often has 10 acyclic paths or more. We show that these exponential relations can be computed efficiently using binary decision diagrams (BDDs). Key to the scalability of the technique is a context numbering scheme that exposes the commonalities across contexts. We applied our algorithm to the most popular applications available on Sourceforge, and found that the largest programs, with hundreds of thousands of Java bytecodes, can be analyzed in under 20 minutes. This paper shows that...", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996859", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Whaley", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/WhaleyL04", + "venue": "pldi", + "year": 2004 + }, + { + "paper_id": "10.1145/996841.996860", + "title": "Symbolic pointer analysis revisited", + "abstract": "Pointer analysis is a critical problem in optimizing compiler, parallelizing compiler, software engineering and most recently, hardware synthesis. While recent efforts have suggested symbolic method, which uses Bryant's Binary Decision Diagram as an alternative to capture the point-to relation, no speed advantage has been demonstrated for context-insensitive analysis, and results for context-sensitive analysis are only preliminary.In this paper, we refine the concept of symbolic transfer function proposed earlier and establish a common framework for both context-insensitive and context-sensitive pointer analysis. With this framework, our transfer function of a procedure can abstract away the impact of its callers and callees, and represent its point-to information completely, compactly and canonically. In addition, we propose a symbolic representation of the invocation graph, which can otherwise be exponentially large. In contrast to the classical frameworks where context-sensitive point-to information of a procedure has to be obtained by the application of its transfer function exponentially many times, our method can obtain point-to information of all contexts in a single application. Our experimental evaluation on a wide range of C benchmarks indicates that our context-sensitive pointer analysis can be made almost as fast as its context-insensitive counterpart.", + "date": "2004-06-09", + "link": "https://doi.org/10.1145/996841.996860", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jianwen", + "last_name": "Zhu", + "institution": "University of Toronto" + }, + { + "first_name": "Silvian", + "last_name": "Calman", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/pldi/ZhuC04", + "venue": "pldi", + "year": 2004 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2005.json b/data/pl_conferences/pldi/2005.json new file mode 100644 index 0000000..12ada95 --- /dev/null +++ b/data/pl_conferences/pldi/2005.json @@ -0,0 +1,676 @@ +[ + { + "paper_id": "10.1145/1065010.1065038", + "title": "Shangri-La: achieving high performance from compiled network applications while enabling ease of programming", + "abstract": "Programming network processors is challenging. To sustain high line rates, network processors have extremely tight memory access and instruction budgets. Achieving desired performance has traditionally required hand-coded assembly. Researchers have recently proposed high-level programming languages for packet processing, but the challenges of compiling these languages into code that is competitive with hand-tuned assembly remain unanswered.This paper describes the Shangri-La compiler, which accepts a packet program written in a C-like high-level language and applies scalar and specialized optimizations to generate a highly optimized binary. Hot code paths identified by profiling are mapped across processing elements to maximize processor utilization. Since our compilation target has no hardware caches, software-controlled caches are generated for frequently accessed application data structures. Packet handling optimizations significantly reduce per-packet memory access and instruction counts. Finally, a custom stack model maps stack frames to the fastest levels of the target processor's heterogeneous memory hierarchy.Binaries generated by the compiler were evaluated on the Intel IXP2400 network processor with eight packet processing cores and eight threads per core. Our results show the importance of both traditional and specialized optimization techniques for achieving the maximum forwarding rates on three network applications, L3-Switch, MPLS and Firewall.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065038", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael K.", + "last_name": "Chen", + "institution": "Intel (United States)" + }, + { + "first_name": "Xiaofeng", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Ruiqi", + "last_name": "Lian", + "institution": "Beijing Academy of Social Sciences" + }, + { + "first_name": "Jason H.", + "last_name": "Lin", + "institution": "" + }, + { + "first_name": "Lixia", + "last_name": "Liu", + "institution": "" + }, + { + "first_name": "Tao", + "last_name": "Liu", + "institution": "Beijing Academy of Social Sciences" + }, + { + "first_name": "Roy Dz-Ching", + "last_name": "Ju", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/ChenLLLLLJ05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065046", + "title": "PADS: a domain-specific language for processing ad hoc data", + "abstract": "PADS is a declarative data description language that allows data analysts to describe both the physical layout of ad hoc data sources and semantic properties of that data. From such descriptions, the PADS compiler generates libraries and tools for manipulating the data, including parsing routines, statistical profiling tools, translation programs to produce well-behaved formats such as Xml or those required for loading relational databases, and tools for running XQueries over raw PADS data sources. The descriptions are concise enough to serve as \"living\" documentation while flexible enough to describe most of the ASCII, binary, and Cobol formats that we have seen in practice. The generated parsing library provides for robust, application-specific error handling.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065046", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "AT&T (United States)" + }, + { + "first_name": "Robert", + "last_name": "Gruber", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/pldi/FisherG05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065022", + "title": "Semantic type qualifiers", + "abstract": "We present a new approach for supporting user-defined type refinements, which augment existing types to specify and check additional invariants of interest to programmers. We provide an expressive language in which users define new refinements and associated type rules. These rules are automatically incorporated by an extensible typechecker during static typechecking of programs. Separately, a soundness checkerautomatically proves that each refinement's type rules ensure the intended invariant, for all possible programs. We have formalized our approach and have instantiated it as a framework for adding new type qualifiers to C programs. We have used this framework to define and automatically prove sound a host of type qualifiers of different sorts, including pos and neg for integers, tainted and untainted for strings, and nonnull and unique for pointers, and we have applied our qualifiers to ensure important invariants on open-source C programs.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065022", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brian", + "last_name": "Chin", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Shane", + "last_name": "Markstrum", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/ChinMM05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065047", + "title": "Composing security policies with polymer", + "abstract": "We introduce a language and system that supports definition and composition of complex run-time security policies for Java applications. Our policies are comprised of two sorts of methods. The first is query methods that are called whenever an untrusted application tries to execute a security-sensitive action. A query method returns a suggestion indicating how the security-sensitive action should be handled. The second sort of methods are those that perform state updates as the policy's suggestions are followed.The structure of our policies facilitates composition, as policies can query other policies for suggestions. In order to give programmers control over policy composition, we have designed the system so that policies, suggestions, and application events are all first-class objects that a higher-order policy may manipulate. We show how to use these programming features by developing a library of policy combinators.Our system is fully implemented, and we have defined a formal semantics for an idealized subset of the language containing all of the key features. We demonstrate the effectiveness of our system by implementing a large-scale security policy for an email client.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065047", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lujo", + "last_name": "Bauer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jay", + "last_name": "Ligatti", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/BauerLW05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065014", + "title": "Scalable statistical bug isolation", + "abstract": "We present a statistical debugging algorithm that isolates bugs in programs containing multiple undiagnosed bugs. Earlier statistical algorithms that focus solely on identifying predictors that correlate with program failure perform poorly when there are multiple bugs. Our new technique separates the effects of different bugs and identifies predictors that are associated with individual bugs. These predictors reveal both the circumstances under which bugs occur as well as the frequencies of failure modes, making it easier to prioritize debugging efforts. Our algorithm is validated using several case studies, including examples in which the algorithm identified previously unknown, significant crashing bugs in widely used systems.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065014", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Stanford University" + }, + { + "first_name": "Alice X.", + "last_name": "Zheng", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Michael I.", + "last_name": "Jordan", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/LiblitNZAJ05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065011", + "title": "The transactional manifesto: software engineering and non-blocking synchronization", + "abstract": "Computer architecture is about to undergo, if not another revolution, then a vigorous shaking-up. The major chip manufacturers have, for the time being, simply given up trying to make processors run faster. Instead, they have recently started shipping \"multicore\" architectures, in which multiple processors (cores) communicate directly through shared hardware caches, providing increased concurrency instead of increased clock speed.As a result, system designers and software engineers can no longer rely on increasing clock speed to hide software bloat. Instead, they must somehow learn to make effective use of increasing parallelism. This adaptation will not be easy. Conventional synchronization techniques based on locks and conditions are unlikely to be effective in such a demanding environment. Coarse-grained locks, which protect relatively large amounts of data, do not scale, and fine-grained locks introduce substantial software engineering problems.Transactional memory is a computational model in which threads synchronize by optimistic, lock-free transactions. This synchronization model promises to alleviate many (perhaps not all) of the problems associated with locking, and there is a growing community of researchers working on both software and hardware support for this approach. This talk will survey the area, with a focus on open research problems.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065011", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Maurice", + "last_name": "Herlihy", + "institution": "Brown University" + } + ], + "dblp_key": "conf/pldi/Herlihy05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065042", + "title": "Threads cannot be implemented as a library", + "abstract": "In many environments, multi-threaded code is written in a language that was originally designed without thread support (e.g. C), to which a library of threading primitives was subsequently added. There appears to be a general understanding that this is not the right approach. We provide specific arguments that a pure library approach, in which the compiler is designed independently of threading issues, cannot guarantee correctness of the resulting code.We first review why the approach almost works, and then examine some of the surprising behavior it may entail. We further illustrate that there are very simple cases in which a pure library-based approach seems incapable of expressing an efficient parallel algorithm.Our discussion takes place in the context of C with Pthreads, since it is commonly used, reasonably well specified, and does not attempt to ensure type-safety, which would entail even stronger constraints. The issues we raise are not specific to that context.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065042", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/pldi/Boehm05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065039", + "title": "Automatically partitioning packet processing applications for pipelined architectures", + "abstract": "Modern network processors employs parallel processing engines (PEs) to keep up with explosive internet packet processing demands. Most network processors further allow processing engines to be organized in a pipelined fashion to enable higher processing throughput and flexibility. In this paper, we present a novel program transformation technique to exploit parallel and pipelined computing power of modern network processors. Our proposed method automatically partitions a sequential packet processing application into coordinated pipelined parallel subtasks which can be naturally mapped to contemporary high-performance network processors. Our transformation technique ensures that packet processing tasks are balanced among pipeline stages and that data transmission between pipeline stages is minimized. We have implemented the proposed transformation method in an auto-partitioning C compiler product for Intel Network Processors. Experimental results show that our method provides impressive speed up for the commonly used NPF IPv4 forwarding and IP forwarding benchmarks. For a 9-stage pipeline, our auto-partitioning C compiler obtained more than 4X speedup for the IPv4 forwarding PPS and the IP forwarding PPS (for both the IPv4 traffic and IPv6 traffic).", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065039", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jinquan", + "last_name": "Dai", + "institution": "" + }, + { + "first_name": "Bo", + "last_name": "Huang", + "institution": "" + }, + { + "first_name": "Long", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Luddy", + "last_name": "Harrison", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/DaiHLH05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065048", + "title": "Formal loop merging for signal transforms", + "abstract": "A critical optimization in the domain of linear signal transforms, such as the discrete Fourier transform (DFT), is loop merging, which increases data locality and reuse and thus performance. In particular, this includes the conversion of shuffle operations into array reindexings. To date, loop merging is well understood only for the DFT, and only for Cooley-Tukey FFT based algorithms, which excludes DFT sizes divisible by large primes. In this paper, we present a formal loop merging framework for general signal transforms and its implementation within the SPIRAL code generator. The framework consists of Ε-SPL, a mathematical language to express loops and index mappings; a rewriting system to merge loops in Ε-SPL and a compiler that translates Ε-SPL into code. We apply the framework to DFT sizes that cannot be handled using only the Cooley-Tukey FFT and compare our method to FFTW 3.0.1 and the vendor library Intel MKL 7.2.1. Compared to FFTW our generated code is a factor of 2--4 faster under equal implementation conditions (same algorithms, same unrolling threshold). For some sizes we show a speed-up of a factor of 9 using Bluestein's algorithm. Further, we give a detailed comparison against the Intel vendor library MKL; our generated code is between 2 times faster and 4.5 times slower.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065048", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Franz", + "last_name": "Franchetti", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yevgen", + "last_name": "Voronenko", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Markus", + "last_name": "Püschel", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/FranchettiVP05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065034", + "title": "Pin: building customized program analysis tools with dynamic instrumentation", + "abstract": "Robust and powerful software instrumentation tools are essential for program analysis tasks such as profiling, performance evaluation, and bug detection. To meet this need, we have developed a new instrumentation system called Pin. Our goals are to provide easy-to-use, portable, transparent, and efficient instrumentation. Instrumentation tools (called Pintools) are written in C/C++ using Pin's rich API. Pin follows the model of ATOM, allowing the tool writer to analyze an application at the instruction level without the need for detailed knowledge of the underlying instruction set. The API is designed to be architecture independent whenever possible, making Pintools source compatible across different architectures. However, a Pintool can access architecture-specific details when necessary. Instrumentation with Pin is mostly transparent as the application and Pintool observe the application's original, uninstrumented behavior. Pin uses dynamic compilation to instrument executables while they are running. For efficiency, Pin uses several techniques, including inlining, register re-allocation, liveness analysis, and instruction scheduling to optimize instrumentation. This fully automated approach delivers significantly better instrumentation performance than similar tools. For example, Pin is 3.3x faster than Valgrind and 2x faster than DynamoRIO for basic-block counting. To illustrate Pin's versatility, we describe two Pintools in daily use to analyze production software. Pin is publicly available for Linux platforms on four architectures: IA32 (32-bit x86), EM64T (64-bit x86), Itanium®, and ARM. In the ten months since Pin 2 was released in July 2004, there have been over 3000 downloads from its website.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065034", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chi-Keung", + "last_name": "Luk", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "Robert", + "last_name": "Cohn", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "Robert", + "last_name": "Muth", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "Harish", + "last_name": "Patil", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "Artur", + "last_name": "Klauser", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "Geoff", + "last_name": "Lowney", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "Steven", + "last_name": "Wallace", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "Vijay Janapa", + "last_name": "Reddi", + "institution": "University of Colorado System" + }, + { + "first_name": "Kim", + "last_name": "Hazelwood", + "institution": "Intel (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/LukCMPKLWRH05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065023", + "title": "Permission-based ownership: encapsulating state in higher-order typed languages", + "abstract": "Today's module systems do not effectively support information hiding in the presence of shared mutable objects, causing serious problems in the development and evolution of large software systems. Ownership types have been proposed as a solution to this problem, but current systems have ad-hoc access restrictions and are limited to Java-like languages.In this paper, we describe System Fown, an extension of System F with references and ownership. Our design shows both how ownership fits into standard type theory and the encapsulation benefits it can provide in languages with first-class functions, abstract data types, and parametric polymorphism. By looking at ownership in the setting of SystemF, we were able to develop a design that is more principled and flexible than previous ownership type systems, while also providing stronger encapsulation guarantees.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065023", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/KrishnaswamiA05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065016", + "title": "Path slicing", + "abstract": "We present a new technique, path slicing, that takes as input a possibly infeasible path to a target location, and eliminates all the operations that are irrelevant towards the reachability of the target location. A path slice is a subsequence of the original path whose infeasibility guarantees the infeasibility of the original path, and whose feasibility guarantees the existence of some feasible variant of the given path that reaches the target location even though the given path may itself be infeasible. Our method combines the ability of program slicing to look at several program paths, with the precision that dynamic slicing enjoys by focusing on a single path. We have implemented Path Slicing to analyze possible counterexamples returned by the software model checker Blast. We show its effectiveness in drastically reducing the size of the counterexamples to less than 1% of their original size. This enables the precise verification of application programs (upto 100KLOC), by allowing the analysis to focus on the part of the counterexample that is relevant to the property being checked.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065016", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/JhalaM05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065025", + "title": "Code placement for improving dynamic branch prediction accuracy", + "abstract": "Code placement techniques have traditionally improved instruction fetch bandwidth by increasing instruction locality and decreasing the number of taken branches. However, traditional code placement techniques have less benefit in the presence of a trace cache that alters the placement of instructions in the instruction cache. Moreover, as pipelines have become deeper to accommodate increasing clock rates, branch misprediction penalties have become a significant impediment to performance. We evaluate pattern history table partitioning, a feedback directed code placement technique that explicitly places conditional branches so that they are less likely to interfere destructively with one another in branch prediction tables. On SPEC CPU benchmarks running on an Intel Pentium 4, branch mispredictions are reduced by up to 22% and 3.5% on average. This reduction yields a speedup of up to 16.0% and 4.5% on average. By contrast, branch alignment, a previous code placement technique, yields only up to a 4.7% speedup and less than 1% on average.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065025", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel A.", + "last_name": "Jiménez", + "institution": "Universitat Politècnica de Catalunya" + } + ], + "dblp_key": "conf/pldi/Jimenez05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065035", + "title": "TraceBack: first fault diagnosis by reconstruction of distributed control flow", + "abstract": "Faults that occur in production systems are the most important faults to fix, but most production systems lack the debugging facilities present in development environments. TraceBack provides debugging information for production systems by providing execution history data about program problems (such as crashes, hangs, and exceptions). TraceBack supports features commonly found in production environments such as multiple threads, dynamically loaded modules, multiple source languages (e.g., Java applications running with JNI modules written in C++), and distributed execution across multiple computers. TraceBack supports first fault diagnosis-discovering what went wrong the first time a fault is encountered. The user can see how the program reached the fault state without having to re-run the computation; in effect enabling a limited form of a debugger in production code.TraceBack uses static, binary program analysis to inject low-overhead runtime instrumentation at control-flow block granularity. Post-facto reconstruction of the records written by the instrumentation code produces a source-statement trace for user diagnosis. The trace shows the dynamic instruction sequence leading up to the fault state, even when the program took exceptions or terminated abruptly (e.g., kill -9).We have implemented TraceBack on a variety of architectures and operating systems, and present examples from a variety of platforms. Performance overhead is variable, from 5% for Apache running SPECweb99, to 16%-25% for the Java SPECJbb benchmark, to 60% average for SPECint2000. We show examples of TraceBack's cross-language and cross-machine abilities, and report its use in diagnosing problems in production software.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065035", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Ayers", + "institution": "Microsoft (Finland)" + }, + { + "first_name": "Richard", + "last_name": "Schooler", + "institution": "Microsoft (Finland)" + }, + { + "first_name": "Chris", + "last_name": "Metcalf", + "institution": "Bureau Veritas (France)" + }, + { + "first_name": "Anant", + "last_name": "Agarwal", + "institution": "Bureau Veritas (France)" + }, + { + "first_name": "Junghwan", + "last_name": "Rhee", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Emmett", + "last_name": "Witchel", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/AyersSMARW05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065032", + "title": "Demystifying on-the-fly spill code", + "abstract": "Modulo scheduling is an effective code generation technique that exploits the parallelism in program loops by overlapping iterations. One drawback of this optimization is that register requirements increase significantly because values across different loop iterations can be live concurrently. One possible solution to reduce register pressure is to insert spill code to release registers. Spill code stores values to memory between the producer and consumer instructions.Spilling heuristics can be divided into two classes: 1) a posteriori approaches (spill code is inserted after scheduling the loop) or 2) on-the-fly approaches (spill code is inserted during loop scheduling). Recent studies have reported obtaining better results for spilling on-the-fly. In this work, we study both approaches and propose two new techniques, one for each approach. Our new algorithms try to address the drawbacks observed in previous proposals. We show that the new algorithms outperform previous techniques and, at the same time, reduce compilation time. We also show that, much to our surprise, a posteriori spilling can be in fact slitghtly more effective than on-the-fly spilling.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065032", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alex", + "last_name": "Aletà", + "institution": "Universitat Politècnica de Catalunya" + }, + { + "first_name": "Josep", + "last_name": "Codina", + "institution": "Intel (United States)" + }, + { + "first_name": "Antonio", + "last_name": "González", + "institution": "Intel (United States)" + }, + { + "first_name": "David", + "last_name": "Kaeli", + "institution": "" + } + ], + "dblp_key": "conf/pldi/AletaCGK05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065013", + "title": "A serializability violation detector for shared-memory server programs", + "abstract": "We aim to improve reliability of multithreaded programs by proposing a dynamic detector that detects potentially erroneous program executions and their causes. We design and evaluate a Serializability Violation Detector (SVD) that has two unique goals: (I) triggering automatic recovery from erroneous executions using backward error recovery (BER), or simply alerting users that a software error may have occurred; and (II) helping debug programs by revealing causes of error symptoms.Two properties of SVD help in achieving these goals. First, to detect only erroneous executions, SVD checks serializability of atomic regions, which are code regions that need to be executed atomically. Second, to improve usability, SVD does not require a priori annotations of atomic regions; instead, SVD approximates them using a heuristic. Experimental results on three widely-used multithreaded server programs show that SVD finds real bugs and reports modest false positives. The goal of this paper is to develop a detector suitable for (I) BER-based avoidance of erroneous program executions; and (II) alerting users as software errors occur. We argue that such a detector should have the following two properties.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065013", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Min", + "last_name": "Xu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mark D.", + "last_name": "Hill", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/XuBH05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065015", + "title": "VYRD: verifYing concurrent programs by runtime refinement-violation detection", + "abstract": "We present a runtime technique for checking that a concurrently-accessed data structure implementation, such as a file system or the storage management module of a database, conforms to an executable specification that contains an atomic method per data structure operation. The specification can be provided separately or a non-concurrent, \"atomized\" interpretation of the implementation can serve as the specification. The technique consists of two phases. In the first phase, the implementation is instrumented in order to record information into a log during execution. In the second, a separate verification thread uses the logged information to drive an instance of the specification and to check whether the logged execution conforms to it. We paid special attention to the general applicability and scalability of the techniques and to minimizing their concurrency and performance impact. The result is a lightweight verification method that provides a significant improvement over testing for concurrent programs.We formalize conformance to a specification using the notion of refinement: Each trace of the implementation must be equivalent to some trace of the specification. Among the novel features of our work are two variations on the definition of refinement appropriate for runtime checking: I/O and \"view\" refinement. These definitions were motivated by our experience with two industrial-scale concurrent data structure implementations: the Boxwood project, a B-link tree data structure built on a novel storage infrastructure [10] and the Scan file system [9]. I/O and view refinement checking were implemented as a verification tool named VRYD (VerifYing concurrent programs by Runtime Refinement-violation Detection). VYRD was applied to the verification of Boxwood, Java class libraries, and, previously, to the Scan filesystem. It was able to detect previously unnoticed subtle concurrency bugs in Boxwood and the Scan file system, and the known bugs in the Java class libraries and manually constructed examples. Experimental results indicate that our techniques have modest computational cost.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065015", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tayfun", + "last_name": "Elmas", + "institution": "Koç University" + }, + { + "first_name": "Serdar", + "last_name": "Taşiran", + "institution": "Koç University" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/ElmasTQ05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065019", + "title": "Checking type safety of foreign function calls", + "abstract": "We present a multi-lingual type inference system for checking type safety across a foreign function interface. The goal of our system is to prevent foreign function calls from introducing type and memory safety violations into an otherwise safe language. Our system targets OCaml's FFI to C, which is relatively lightweight and illustrates some interesting challenges in multi-lingual type inference. The type language in our system embeds OCaml types in C types and vice-versa, which allows us to track type information accurately even through the foreign language, where the original types are lost. Our system uses representational types that can model multiple OCaml types, because C programs can observe that many OCaml types have the same physical representation. Furthermore, because C has a low-level view of OCaml data, our inference system includes a dataflow analysis to track memory offsets and tag information. Finally, our type system includes garbage collection information to ensure that pointers from the FFI to the OCaml heap are tracked properly. We have implemented our inference system and applied it to a small set of benchmarks. Our results show that programmers do misuse these interfaces, and our implementation has found several bugs and questionable coding practices in our benchmarks.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065019", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Furr", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/FurrF05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065021", + "title": "Essential language support for generic programming", + "abstract": "Concepts are an essential language feature for generic programming in the large. Concepts allow for succinct expression of constraints on type parameters of generic algorithms, enable systematic organization of problem domain abstractions, and make generic algorithms easier to use. In this paper we present the design of a type system and semantics for concepts that is suitable for non-type-inferencing languages. Our design shares much in common with the type classes of Haskell, though our primary influence is from best practices in the C++ community, where concepts are used to document type requirements for templates in generic libraries. Concepts include a novel combination of associated types and same-type constraints that do not appear in type classes, but that are similar to nested types and type sharing in ML.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065021", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Andrew", + "last_name": "Lumsdaine", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/pldi/SiekL05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065036", + "title": "DART: directed automated random testing", + "abstract": "We present a new tool, named DART, for automatically testing software that combines three main techniques: (1) automated extraction of the interface of a program with its external environment using static source-code parsing; (2) automatic generation of a test driver for this interface that performs random testing to simulate the most general environment the program can operate in; and (3) dynamic analysis of how the program behaves under random testing and automatic generation of new test inputs to direct systematically the execution along alternative program paths. Together, these three techniques constitute Directed Automated Random Testing, or DART for short. The main strength of DART is thus that testing can be performed completely automatically on any program that compiles -- there is no need to write any test driver or harness code. During testing, DART detects standard errors such as program crashes, assertion violations, and non-termination. Preliminary experiments to unit test several examples of C programs are very encouraging.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065036", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Nils", + "last_name": "Klarlund", + "institution": "Alcatel Lucent (Germany)" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/GodefroidKS05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065018", + "title": "Jungloid mining: helping to navigate the API jungle", + "abstract": "Reuse of existing code from class libraries and frameworks is often difficult because APIs are complex and the client code required to use the APIs can be hard to write. We observed that a common scenario is that the programmer knows what type of object he needs, but does not know how to write the code to get the object.In order to help programmers write API client code more easily, we developed techniques for synthesizing jungloid code fragments automatically given a simple query that describes that desired code in terms of input and output types. A jungloid is simply a unary expression; jungloids are simple, enabling synthesis, but are also versatile, covering many coding problems, and composable, combining to form more complex code fragments. We synthesize jungloids using both API method signatures and jungloids mined from a corpus of sample client programs.We implemented a tool, prospector, based on these techniques. prospector is integrated with the Eclipse IDE code assistance feature, and it infers queries from context so there is no need for the programmer to write queries. We tested prospector on a set of real programming problems involving APIs; prospector found the desired solution for 18 of 20 problems. We also evaluated prospector in a user study, finding that programmers solved programming problems more quickly and with more reuse when using prospector than without prospector.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065018", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Mandelin", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Lin", + "last_name": "Xu", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Doug", + "last_name": "Kimelman", + "institution": "" + } + ], + "dblp_key": "conf/pldi/MandelinXBK05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065027", + "title": "Automatic pool allocation: improving performance by controlling data structure layout in the heap", + "abstract": "This paper describes Automatic Pool Allocation, a transformation framework that segregates distinct instances of heap-based data structures into seperate memory pools and allows heuristics to be used to partially control the internal layout of those data structures. The primary goal of this work is performance improvement, not automatic memory management, and the paper makes several new contributions. The key contribution is a new compiler algorithm for partitioning heap objects in imperative programs based on a context-sensitive pointer analysis, including a novel strategy for correct handling of indirect (and potentially unsafe) function calls. The transformation does not require type safe programs and works for the full generality of C and C++. Second, the paper describes several optimizations that exploit data structure partitioning to further improve program performance. Third, the paper evaluates how memory hierarchy behavior and overall program performance are impacted by the new transformations. Using a number of benchmarks and a few applications, we find that compilation times are extremely low, and overall running times for heap intensive programs speed up by 10-25% in many cases, about 2x in two cases, and more than 10x in two small benchmarks. Overall, we believe this work provides a new framework for optimizing pointer intensive programs by segregating and controlling the layout of heap-based data structures.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065027", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chris", + "last_name": "Lattner", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/LattnerA05", + "venue": "pldi", + "year": 2005 + }, + { + "paper_id": "10.1145/1065010.1065030", + "title": "Register allocation for software pipelined multi-dimensional loops", + "abstract": "Software pipelining of a multi-dimensional loop is an important optimization that overlaps the execution of successive outermost loop iterations to explore instruction-level parallelism from the entire n-dimensional iteration space. This paper investigates register allocation for software pipelined multi-dimensional loops.For single loop software pipelining, the lifetime instances of a loop variant in successive iterations of the loop form a repetitive pattern. An effective register allocation method is to represent the pattern as a vector of lifetimes (or a vector lifetime using Rau's terminology) and map it to rotating registers. Unfortunately, the software pipelined schedule of a multi-dimensional loop is considerably more complex, and so are the vector lifetimes in it.In this paper, we develop a way to normalize and represent vector lifetimes in multi-dimensional loop software pipelining, which capture their complexity, while exposing their regularity that enables us to develop a simple, yet powerful solution. Our algorithm is based on the development of a metric, called distance, that quantitatively determines the degree of potential overlapping (conflicts) between two vector lifetimes. We show how to calculate and use the distance, conservatively or aggressively, to guide the register allocation of the vector lifetimes under a bin-packing algorithm framework. The classical register allocation for software pipelined single loops is subsumed by our method as a special case.The method has been implemented in the ORC compiler and produced code for the Itanium architecture. We report the effectiveness of our method on 134 loop nests with 348 loop levels. Several strategies for register allocation are compared and analyzed.", + "date": "2005-06-12", + "link": "https://doi.org/10.1145/1065010.1065030", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongbo", + "last_name": "Rong", + "institution": "University of Delaware" + }, + { + "first_name": "Alban", + "last_name": "Douillet", + "institution": "University of Delaware" + }, + { + "first_name": "Guang R.", + "last_name": "Gao", + "institution": "University of Delaware" + } + ], + "dblp_key": "conf/pldi/RongDG05", + "venue": "pldi", + "year": 2005 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2006.json b/data/pl_conferences/pldi/2006.json new file mode 100644 index 0000000..fc398b9 --- /dev/null +++ b/data/pl_conferences/pldi/2006.json @@ -0,0 +1,1049 @@ +[ + { + "paper_id": "10.1145/1133981.1134014", + "title": "Algorithm specialization in generic programming: challenges of constrained generics in C++", + "abstract": "Generic programming has recently emerged as a paradigm for developing highly reusable software libraries, most notably in C++. We have designed and implemented a constrained generics extension for C++ to support modular type checking of generic algorithms and to address other issues associated with unconstrained generics. To be as broadly applicable as possible, generic algorithms are defined with minimal requirements on their inputs. At the same time, to achieve a high degree of efficiency, generic algorithms may have multiple implementations that exploit features of specific classes of inputs. This process of algorithm specialization relies on non-local type information and conflicts directly with the local nature of modular type checking. In this paper, we review the design and implementation of our extensions for generic programming in C++, describe the issues of algorithm specialization and modular type checking in detail, and discuss the important design tradeoffs in trying to accomplish both.We present the particular design that we chose for our implementation, with the goal of hitting the sweet spot in this interesting design space.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134014", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jaakko", + "last_name": "Järvi", + "institution": "" + }, + { + "first_name": "Douglas", + "last_name": "Gregor", + "institution": "Indiana University" + }, + { + "first_name": "Jeremiah", + "last_name": "Willcock", + "institution": "Indiana University" + }, + { + "first_name": "Andrew", + "last_name": "Lumsdaine", + "institution": "Indiana University" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/JarviGWLS06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134002", + "title": "Pruning dynamic slices with confidence", + "abstract": "Given an incorrect value produced during a failed program run (e.g., a wrong output value or a value that causes the program to crash), the backward dynamic slice of the value very frequently captures the faulty code responsible for producing the incorrect value. Although the dynamic slice often contains only a small percentage of the statements executed during the failed program run, the dynamic slice can still be large and thus considerable effort may be required by the programmer to locate the faulty code.In this paper we develop a strategy for pruning the dynamic slice to identify a subset of statements in the dynamic slice that are likely responsible for producing the incorrect value. We observe that some of the statements used in computing the incorrect value may also have been involved in computing correct values (e.g., a value produced by a statement in the dynamic slice of the incorrect value may also have been used in computing a correct output value prior to the incorrect value). For each such executed statement in the dynamic slice, using the value profiles of the executed statements, we compute a confidence value ranging from 0 to 1 - a higher confidence value corresponds to greater likelihood that the execution of the statement produced a correct value. Given a failed run involving execution of a single error, we demonstrate that the pruning of a dynamic slice by excluding only the statements with the confidence value of 1 is highly effective in reducing the size of the dynamic slice while retaining the faulty code in the slice. Our experiments show that the number of distinct statements in a pruned dynamic slice are 1.79 to 190.57 times less than the full dynamic slice. Confidence values also prioritize the statements in the dynamic slice according to the likelihood of them being faulty. We show that examining the statements in the order of increasing confidence values is an effective strategy for reducing the effort of fault location.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134002", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "University of Arizona" + }, + { + "first_name": "Neelam", + "last_name": "Gupta", + "institution": "University of Arizona" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/ZhangGG06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134023", + "title": "The Compressor: concurrent, incremental, and parallel compaction", + "abstract": "The widely used Mark-and-Sweep garbage collector has a drawback in that it does not move objects during collection. As a result, large long-running realistic applications, such as Web application servers, frequently face the fragmentation problem. To eliminate fragmentation, a heap compaction is run periodically. However, compaction typically imposes very long undesirable pauses in the application. While efficient concurrent collectors are ubiquitous in production runtime systems (such as JVMs), an efficient non-intrusive compactor is still missing.In this paper we present the Compressor, a novel compaction algorithm that is concurrent, parallel, and incremental. The Compressor compacts the entire heap to a single condensed area, while preserving the objects' order, but reduces pause times significantly, thereby allowing acceptable runs on large heaps. Furthermore, the Compressor is the first compactor that requires only a single heap pass. As such, it is the most efficient compactors known today, even when run in a parallel Stop-the-World manner (i.e., when the program threads are halted). Thus, to the best of our knowledge, the Compressor is the most efficient compactor known today. The Compressor was implemented on a Jikes Research RVM and we provide measurements demonstrating its qualities.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134023", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Haim", + "last_name": "Kermany", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/KermanyP06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133992", + "title": "Artemis: practical runtime monitoring of applications for execution anomalies", + "abstract": "A number of hardware and software techniques have been proposed to detect dynamic program behaviors that may indicate a bug in a program. Because these techniques suffer from high overheads they are useful in finding bugs in programs before they are released, but are significantly less useful in finding bugs in long-running programs on production systems -- the same bugs that are the most difficult to find using traditional techniques. In this paper we propose the Artemis1 is the Greek goddess of the hunt and wild animals. Our framework guides the hunt for wild bugs. compiler-based instrumentation framework that complements many pre-existing runtime monitoring techniques. The Artemis framework guides baseline monitoring techniques toward regions of the program where bugs are likely to occur, yielding a low asymptotic monitoring overhead. Artemis also facilitates system-load aware runtime monitoring that allows the monitoring coverage to be dynamically scaled up to take advantage of extra cycles when the system load is low, and dynamically scaled down to monitor only the most suspicious regions when the system load is high. Our experiments show that Artemis' asymptotic overhead can outperform the performance floor overhead of random sampling for many tools, and that Artemis can effectively guide a monitoring tool to the buggy regions of a program. Our experimental results show that Artemis applied to a hardware-based PC-invariance monitoring scheme and a value-based invariance detection and checking scheme significantly improves their runtime monitoring overhead (by up to 4.6 times) with moderate impact on their bug-detecting capabilities.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133992", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fei", + "last_name": "Long", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Samuel P.", + "last_name": "Midkiff", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/FeiM06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133984", + "title": "Optimizing memory transactions", + "abstract": "Atomic blocks allow programmers to delimit sections of code as 'atomic', leaving the language's implementation to enforce atomicity. Existing work has shown how to implement atomic blocks over word-based transactional memory that provides scalable multi-processor performance without requiring changes to the basic structure of objects in the heap. However, these implementations perform poorly because they interpose on all accesses to shared memory in the atomic block, redirecting updates to a thread-private log which must be searched by reads in the block and later reconciled with the heap when leaving the block.This paper takes a four-pronged approach to improving performance: (1) we introduce a new 'direct access' implementation that avoids searching thread-private logs, (2) we develop compiler optimizations to reduce the amount of logging (e.g. when a thread accesses the same data repeatedly in an atomic block), (3) we use runtime filtering to detect duplicate log entries that are missed statically, and (4) we present a series of GC-time techniques to compact the logs generated by long-running atomic blocks.Our implementation supports short-running scalable concurrent benchmarks with less than 50\\% overhead over a non-thread-safe baseline. We support long atomic blocks containing millions of shared memory accesses with a 2.5-4.5x slowdown.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133984", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tim", + "last_name": "Harris", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "M.", + "last_name": "Pleško", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Avraham", + "last_name": "Shinnar", + "institution": "Harvard University Press" + }, + { + "first_name": "David", + "last_name": "Tarditi", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/HarrisPST06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134026", + "title": "Combining abstract interpreters", + "abstract": "We present a methodology for automatically combining abstract interpreters over given lattices to construct an abstract interpreter for the combination of those lattices. This lends modularity to the process of design and implementation of abstract interpreters.We define the notion of logical product of lattices. This kind of combination is more precise than the reduced product combination. We give algorithms to obtain the join operator and the existential quantification operator for the combined lattice from the corresponding operators of the individual lattices. We also give a bound on the number of steps required to reach a fixed point across loops during analysis over the combined lattice in terms of the corresponding bounds for the individual lattices. We prove that our combination methodology yields the most precise abstract interpretation operators over the logical product of lattices when the individual lattices are over theories that are convex, stably infinite, and disjoint.We also present an interesting application of logical product wherein some lattices can be reduced to combination of other (unrelated) lattices with known abstract interpreters.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134026", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "SRI International" + } + ], + "dblp_key": "conf/pldi/GulwaniT06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133988", + "title": "Fast and flexible instruction selection with on-demand tree-parsing automata", + "abstract": "Tree parsing as supported by code generator generators like BEG, burg, iburg, lburg and ml-burg is a popular instruction selection method. There are two existing approaches for implementing tree parsing: dynamic programming, and tree-parsing automata; each approach has its advantages and disadvantages. We propose a new implementation approach that combines the advantages of both existing approaches: we start out with dynamic programming at compile time, but at every step we generate a state for a tree-parsing automaton, which is used the next time a tree matching the state is found, turning the instruction selector into a fast tree-parsing automaton. We have implemented this approach in the Gforth code generator. The implementation required little effort and reduced the startup time of Gforth by up to a factor of 2.5.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133988", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "M. Anton", + "last_name": "Ertl", + "institution": "TU Wien" + }, + { + "first_name": "Kevin", + "last_name": "Casey", + "institution": "Trinity College Dublin" + }, + { + "first_name": "David", + "last_name": "Gregg", + "institution": "Trinity College Dublin" + } + ], + "dblp_key": "conf/pldi/ErtlCG06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134019", + "title": "LOCKSMITH: context-sensitive correlation analysis for race detection", + "abstract": "One common technique for preventing data races in multi-threaded programs is to ensure that all accesses to shared locations are consistently protected by a lock. We present a tool called LOCKSMITH for detecting data races in C programs by looking for violations of this pattern. We call the relationship between locks and the locations they protect consistent correlation, and the core of our technique is a novel constraint-based analysis that infers consistent correlation context-sensitively, using the results to check that locations are properly guarded by locks. We present the core of our algorithm for a simple formal language λ> which we have proven sound, and discuss how we scale it up to an algorithm that aims to be sound for all of C. We develop several techniques to improve the precision and performance of the analysis, including a sharing analysis for inferring thread locality; existential quantification for modeling locks in data structures; and heuristics for modeling unsafe features of C such as type casts. When applied to several benchmarks, including multi-threaded servers and Linux device drivers, LOCKSMITH found several races while producing a modest number of false alarm.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134019", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Polyvios", + "last_name": "Pratikakis", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/PratikakisFH06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133999", + "title": "SAFECode: enforcing alias analysis for weakly typed languages", + "abstract": "Static analysis of programs in weakly typed languages such as C and C++ is generally not sound because of possible memory errors due to dangling pointer references, uninitialized pointers, and array bounds overflow. We describe a compilation strategy for standard C programs that guarantees that aggressive interprocedural pointer analysis (or less precise ones), a call graph, and type information for a subset of memory, are never invalidated by any possible memory errors. We formalize our approach as a new type system with the necessary run-time checks in operational semantics and prove the correctness of our approach for a subset of C. Our semantics provide the foundation for other sophisticated static analyses to be applied to C programs with a guarantee of soundness. Our work builds on a previously published transformation called Automatic Pool Allocation to ensure that hard-to-detect memory errors (dangling pointer references and certain array bounds errors) cannot invalidate the call graph, points-to information or type information. The key insight behind our approach is that pool allocation can be used to create a run-time partitioning of memory that matches the compile-time memory partitioning in a points-to graph, and efficient checks can be used to isolate the run-time partitions. Furthermore, we show that the sound analysis information enables static checking techniques that eliminate many run-time checks. Our approach requires no source code changes, allows memory to be managedexplicitly, and does not use meta-data on pointers or individual tag bits for memory. Using several benchmark s and system codes, we show experimentally that the run-time overheads are low (less than 10% in nearly all cases and 30% in the worst case we have seen).We also show the effectiveness of static analyses in eliminating run-time checks.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133999", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dinakar", + "last_name": "Dhurjati", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Sumant", + "last_name": "Kowshik", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/DhurjatiKA06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134021", + "title": "Profile-guided proactive garbage collection for locality optimization", + "abstract": "Many applications written in garbage collected languages have large dynamic working sets and poor data locality. We present a new system for continuously improving program data locality at run time with low overhead. Our system proactively reorganizes the heap by leveraging the garbage collector and uses profile information collected through a low-overhead mechanism to guide the reorganization at run time. The key contributions include making a case that garbage collection should be viewed as a proactive technique for improving data locality by triggering garbage collection for locality optimization independently of normal garbage collection for space, combining page and cache locality optimization in the same system, and demonstrating that sampling provides sufficiently detailed data access information to guide both page and cache locality optimization with low runtime overhead. We present experimental results obtained by modifying a commercial, state-of-the-art garbage collector to support our claims. Independently triggering garbage collection for locality optimization significantly improved optimizations benefits. Combining page and cache locality optimizations in the same system provided larger average execution time improvements (17%) than either alone (page 8%, cache 7%). Finally, using sampling limited profiling overhead to less than 3%, on average.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134021", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wen-ke", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sanjay", + "last_name": "Bhansali", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Xiaofeng", + "last_name": "Gao", + "institution": "University of California San Diego" + }, + { + "first_name": "Weihaw", + "last_name": "Chuang", + "institution": "University of California San Diego" + } + ], + "dblp_key": "conf/pldi/ChenBCGC06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134008", + "title": "Automatic instruction scheduler retargeting by reverse-engineering", + "abstract": "In order to generate high-quality code for modern processors, a compiler must aggressively schedule instructions, maximizing resource utilization for execution efficiency. For a compiler to produce such code, it must avoid structural hazards by being aware of the processor's available resources and of how these resources are utilized by each instruction. Unfortunately, the most prevalent approach to constructing such a scheduler, manually discovering and specifying this information, is both tedious and error-prone. This paper presents a new approach which, when given a processor or processor model, automatically determines this information. After establishing that the problem of perfectly determining a processor's structural hazards through probing is not solvable, this paper proposes a heuristic algorithm that discovers most of this information in practice. This can be used either to alleviate the problems associated with manual creation or to verify an existing specification. Scheduling with these automatically derived structural hazards yields almost all of the performance gain achieved using perfect hazard information.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134008", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew J.", + "last_name": "Bridges", + "institution": "Princeton University" + }, + { + "first_name": "Neil", + "last_name": "Vachharajani", + "institution": "Princeton University" + }, + { + "first_name": "Guilherme", + "last_name": "Ottoni", + "institution": "Princeton University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/BridgesVOA06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133993", + "title": "An experimental analysis of self-adjusting computation", + "abstract": "Dependence graphs and memoization can be used to efficiently update the output of a program as the input changes dynamically. Recent work has studied techniques for combining these approaches to effectively dynamize a wide range of applications. Toward this end various theoretical results were given. In this paper we describe the implementation of a library based on these ideas, and present experimental results on the efficiency of this library on a variety of applications. The results of the experiments indicate that the approach is effective in practice, often requiring orders of magnitude less time than recomputing the output from scratch. We believe this is the first experimental evidence that incremental computation of any type is effective in practice for a reasonably broad set of applications.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133993", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Toyota Technological Institute" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "M.", + "last_name": "Blume", + "institution": "Toyota Technological Institute" + }, + { + "first_name": "Kanat", + "last_name": "Tangwongsan", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/AcarBBT06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134003", + "title": "Context-sensitive domain-independent algorithm composition and selection", + "abstract": "Progressing beyond the productivity of present-day languages appears to require using domain-specific knowledge. Domain-specific languages and libraries (DSLs) proliferate, but most optimizations and language features have limited portability because each language's semantics are related closely to its domain. We explain how any DSL compiler can use a domain-independent AI planner to implement algorithm composition as a language feature. Our notion of composition addresses a common DSL problem: good library designers tend to minimize redundancy by including only fundamental procedures that users must chain together into call sequences. Novice users are confounded by not knowing an appropriate sequence to achieve their goal. Composition allows the programmer to define and call an abstract algorithm (AA) like a procedure. The compiler replaces an AA call with a sequence of library calls, while considering the calling context. Because AI planners compute a sequence of operations to reach a goal state, the compiler can implement composition by analyzing the calling context to provide the planner's initial state. Nevertheless, mapping composition onto planning is not straightforward because applying planning to software requires extensions to classical planning, and procedure specifications may be incomplete when expressed in a planning language. Compositions may not be provably correct, so our approach mitigates semantic incompleteness with unobtrusive programmer-compiler interaction. This tradeoff is key to making composition a practical and natural feature of otherwise imperative languages, whose users eschew complex logical specifications. Compositions satisfying an AA may not be equal in performance, memory usage, or precision and require selection of a preferred solution. We examine language design and implementation issues, and we perform a case study on the BioPerl bioinformatics library.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134003", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Troy A.", + "last_name": "Johnson", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Rudolf", + "last_name": "Eigenmann", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/JohnsonE06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133987", + "title": "Better extensibility through modular syntax", + "abstract": "We explore how to make the benefits of modularity available for syntactic specifications and present Rats!, a parser generator for Java that supports easily extensible syntax. Our parser generator builds on recent research on parsing expression grammars (PEGs), which, by being closed under composition, prioritizing choices, supporting unlimited lookahead, and integrating lexing and parsing, offer an attractive alternative to context-free grammars. PEGs are implemented by so-called packrat parsers, which are recursive descent parsers that memoize all intermediate results (hence their name). Memoization ensures linear-time performance in the presence of unlimited lookahead, but also results in an essentially lazy, functional parsing technique. In this paper, we explore how to leverage PEGs and packrat parsers as the foundation for extensible syntax. In particular, we show how make packrat parsing more widely applicable by implementing this lazy, functional technique in a strict, imperative language, while also generating better performing parsers through aggressive optimizations. Next, we develop a module system for organizing, modifying, and composing large-scale syntactic specifications. Finally, we describe a new technique for managing (global) parsing state in functional parsers. Our experimental evaluation demonstrates that the resulting parser generator succeeds at providing extensible syntax. In particular, Rats! enables other grammar writers to realize real-world language extensions in little time and code, and it generates parsers that consistently out-perform parsers created by two GLR parser generators.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133987", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robert", + "last_name": "Grimm", + "institution": "New York University" + } + ], + "dblp_key": "conf/pldi/Grimm06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134018", + "title": "Effective static race detection for Java", + "abstract": "We present a novel technique for static race detection in Java programs, comprised of a series of stages that employ a combination of static analyses to successively reduce the pairs of memory accesses potentially involved in a race. We have implemented our technique and applied it to a suite of multi-threaded Java programs. Our experiments show that it is precise, scalable, and useful, reporting tens to hundreds of serious and previously unknown concurrency bugs in large, widely-used programs with few false alarms.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134018", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "John", + "last_name": "Whaley", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/NaikAW06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134028", + "title": "Modular verification of assembly code with stack-based control abstractions", + "abstract": "Runtime stacks are critical components of any modern software--they are used to implement powerful control structures such as function call/return, stack cutting and unwinding, coroutines, and thread context switch. Stack operations, however, are very hard to reason about: there are no known formal specifications for certifying C-style setjmp/longjmp, stack cutting and unwinding, or weak continuations (in C--). In many proof-carrying code (PCC) systems, return code pointers and exception handlers are treated as general first-class functions (as in continuation-passing style) even though both should have more limited scopes.In this paper we show that stack-based control abstractions follow a much simpler pattern than general first-class code pointers. We present a simple but flexible Hoare-style framework for modular verification of assembly code with all kinds of stackbased control abstractions, including function call/return, tail call, setjmp/longjmp, weak continuation, stack cutting, stack unwinding, multi-return function call, coroutines, and thread context switch. Instead of presenting a specific logic for each control structure, we develop all reasoning systems as instances of a generic framework. This allows program modules and their proofs developed in different PCC systems to be linked together. Our system is fully mechanized. We give the complete soundness proof and a full verification of several examples in the Coq proof assistant.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134028", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "" + }, + { + "first_name": "Alexander", + "last_name": "Vaynberg", + "institution": "" + }, + { + "first_name": "Sen", + "last_name": "Xiang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Zhaozhong", + "last_name": "Ni", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/FengSVXN06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134004", + "title": "Reducing NoC energy consumption through compiler-directed channel voltage scaling", + "abstract": "While scalable NoC (Network-on-Chip) based communication architectures have clear advantages over long point-to-point communication channels, their power consumption can be very high. In contrast to most of the existing hardware-based efforts on NoC power optimization, this paper proposes a compiler-directed approach where the compiler decides the appropriate voltage/frequency levels to be used for each communication channel in the NoC. Our approach builds and operates on a novel graph based representation of a parallel program and has been implemented within an optimizing compiler and tested using 12 embedded benchmarks. Our experiments indicate that the proposed approach behaves better - from both performance and power perspectives - than a hardwarebased scheme and the energy savings it achieves are very close to the savings that could be obtained from an optimal, but hypothetical voltage/frequency scaling scheme.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134004", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guangyu", + "last_name": "Chen", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Feihui", + "last_name": "Li", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "M.J.", + "last_name": "Irwin", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/pldi/ChenLKI06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134000", + "title": "DieHard: probabilistic memory safety for unsafe languages", + "abstract": "Applications written in unsafe languages like C and C++ are vulnerable to memory errors such as buffer overflows, dangling pointers, and reads of uninitialized data. Such errors can lead to program crashes, security vulnerabilities, and unpredictable behavior. We present DieHard, a runtime system that tolerates these errors while probabilistically maintaining soundness. DieHard uses randomization and replication to achieve probabilistic memory safety by approximating an infinite-sized heap. DieHard's memory manager randomizes the location of objects in a heap that is at least twice as large as required. This algorithm prevents heap corruption and provides a probabilistic guarantee of avoiding memory errors. For additional safety, DieHard can operate in a replicated mode where multiple replicas of the same application are run simultaneously. By initializing each replica with a different random seed and requiring agreement on output, the replicated version of Die-Hard increases the likelihood of correct execution because errors are unlikely to have the same effect across all replicas. We present analytical and experimental results that show DieHard's resilience to a wide range of memory errors, including a heap-based buffer overflow in an actual application.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134000", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/BergerZ06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133997", + "title": "Auto-vectorization of interleaved data for SIMD", + "abstract": "Most implementations of the Single Instruction Multiple Data (SIMD) model available today require that data elements be packed in vector registers. Operations on disjoint vector elements are not supported directly and require explicit data reorganization manipulations. Computations on non-contiguous and especially interleaved data appear in important applications, which can greatly benefit from SIMD instructions once the data is reorganized properly. Vectorizing such computations efficiently is therefore an ambitious challenge for both programmers and vectorizing compilers. We demonstrate an automatic compilation scheme that supports effective vectorization in the presence of interleaved data with constant strides that are powers of 2, facilitating data reorganization. We demonstrate how our vectorization scheme applies to dominant SIMD architectures, and present experimental results on a wide range of key kernels, showing speedups in execution time up to 3.7 for interleaving levels (stride) as high as 8.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133997", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dorit", + "last_name": "Nuzman", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Ira", + "last_name": "Rosen", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Ayal", + "last_name": "Zaks", + "institution": "IBM Research - Haifa" + } + ], + "dblp_key": "conf/pldi/NuzmanRZ06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134029", + "title": "Termination proofs for systems code", + "abstract": "Program termination is central to the process of ensuring that systems code can always react. We describe a new program termination prover that performs a path-sensitive and context-sensitive program analysis and provides capacity for large program fragments (i.e. more than 20,000 lines of code) together with support for programming language features such as arbitrarily nested loops, pointers, function-pointers, side-effects, etc.We also present experimental results on device driver dispatch routines from theWindows operating system. The most distinguishing aspect of our tool is how it shifts the balance between the two tasks of constructing and respectively checking the termination argument. Checking becomes the hard step. In this paper we show how we solve the corresponding challenge of checking with binary reachability analysis.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134029", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "Max Planck Institute for Informatics" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Max Planck Institute for Informatics" + } + ], + "dblp_key": "conf/pldi/CookPR06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134012", + "title": "Accurate, efficient, and adaptive calling context profiling", + "abstract": "Calling context profiles are used in many inter-procedural code optimizations and in overall program understanding. Unfortunately, the collection of profile information is highly intrusive due to the high frequency of method calls in most applications. Previously proposed calling-context profiling mechanisms consequently suffer from either low accuracy, high overhead, or both. We have developed a new approach for building the calling context tree at runtime, called adaptive bursting. By selectively inhibiting redundant profiling, this approach dramatically reduces overhead while preserving profile accuracy. We first demonstrate the drawbacks of previously proposed calling context profiling mechanisms. We show that a low-overhead solution using sampled stack-walking alone is less than 50% accurate, based on degree of overlap with a complete calling-context tree. We also show that a static bursting approach collects a highly accurate profile, but causes an unacceptable application slowdown. Our adaptive solution achieves 85% degree of overlap and provides an 88% hot-edge coverage when using a 0.1 hot-edge threshold, while dramatically reducing overhead compared to the static bursting approach.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134012", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiaotong", + "last_name": "Zhuang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Maurício", + "last_name": "Serrano", + "institution": "" + }, + { + "first_name": "Harold W.", + "last_name": "Cain", + "institution": "" + }, + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "" + } + ], + "dblp_key": "conf/pldi/ZhuangSCC06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134010", + "title": "Online performance auditing: using hot optimizations without getting burned", + "abstract": "As hardware complexity increases and virtualization is added at more layers of the execution stack, predicting the performance impact of optimizations becomes increasingly difficult. Production compilers and virtual machines invest substantial development effort in performance tuning to achieve good performance for a range of benchmarks. Although optimizations typically perform well on average, they often have unpredictable impact on running time, sometimes degrading performance significantly. Today's VMs perform sophisticated feedback-directed optimizations, but these techniques do not address performance degradations, and they actually make the situation worse by making the system more unpredictable.This paper presents an online framework for evaluating the effectiveness of optimizations, enabling an online system to automatically identify and correct performance anomalies that occur at runtime. This work opens the door for a fundamental shift in the way optimizations are developed and tuned for online systems, and may allow the body of work in offline empirical optimization search to be applied automatically at runtime. We present our implementation and evaluation of this system in a product Java VM.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134010", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Lau", + "institution": "University of California, San Diego" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Hind", + "institution": "" + }, + { + "first_name": "Brad", + "last_name": "Calder", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/LauAHC06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134024", + "title": "Free-Me: a static analysis for automatic individual object reclamation", + "abstract": "Garbage collection has proven benefits, including fewer memory related errors and reduced programmer effort. Garbage collection, however, trades space for time. It reclaims memory only when it is invoked: invoking it more frequently reclaims memory quickly, but incurs a significant cost; invoking it less frequently fills memory with dead objects. In contrast, explicit memory management provides prompt low cost reclamation, but at the expense of programmer effort.This work comes closer to the best of both worlds by adding novel compiler and runtime support for compiler inserted frees to a garbage-collected system. The compiler's free-me analysis identifies when objects become unreachable and inserts calls to free. It combines a lightweight pointer analysis with liveness information that detects when short-lived objects die. Our approach differs from stack and region allocation in two crucial ways. First, it frees objects incrementally exactly when they become unreachable, instead of based on program scope. Second, our system does not require allocation-site lifetime homogeneity, and thus frees objects on some paths and not on others. It also handles common patterns: it can free objects in loops and objects created by factory methods.We evaluate free() variations for free-list and bump-pointer allocators. Explicit freeing improves performance by promptly reclaiming objects and reducing collection load. Compared to marksweep alone, free-me cuts total time by 22% on average, collector time by 50% to 70%, and allows programs to run in 17% less memory. This combination retains the software engineering benefits of garbage collection while increasing space efficiency and improving performance, and thus is especially appealing for real-time and space constrained systems.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134024", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "Tufts University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Daniel", + "last_name": "Frampton", + "institution": "Australian National University" + } + ], + "dblp_key": "conf/pldi/GuyerMF06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134011", + "title": "Cache-conscious coallocation of hot data streams", + "abstract": "The memory system performance of many programs can be improved by coallocating contemporaneously accessed heap objects in the same cache block. We present a novel profile-based analysis for producing such a layout. The analysis achieves cacheconscious coallocation of a hot data stream H (i.e., a regular data access pattern that frequently repeats) by isolating and combining allocation sites of object instances that appear in H such that intervening allocations coming from other sites are separated. The coallocation solution produced by the analysis is enforced by an automatic tool, cminstr, that redirects a program's heap allocations to a run-time coallocation library comalloc. We also extend the analysis to coallocation at object field granularity. The resulting field coallocation solution generalizes common data restructuring techniques, such as field reordering, object splitting, and object merging, and allows their combination. Furthermore, it provides insight into object restructuring by breaking down the coallocation benefit on a per-technique basis, which provides the opportunity to pick the \"sweet spot\" for each program. Experimental results using a set of memory-performance-limited benchmarks, including a few SPECInt2000 programs, and Microsoft VisualFoxPro, indicate that programs possess significant coallocation opportunities. Automatic object coallocation improves execution time by 13% on average in the presence of hardware prefetching. Hand-implemented field coallocation solutions for two of the benchmarks produced additional improvements (12% and 22%) but the effort involved suggests implementing an automated version for type-safe languages, such as Java and C#.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134011", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ran", + "last_name": "Shaham", + "institution": "" + } + ], + "dblp_key": "conf/pldi/ChilimbiS06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133983", + "title": "The Atomos transactional programming language", + "abstract": "Atomos is the first programming language with implicit transactions, strong atomicity, and a scalable multiprocessor implementation. Atomos is derived from Java, but replaces its synchronization and conditional waiting constructs with simpler transactional alternatives.The Atomos watch statement allows programmers to specify fine-grained watch sets used with the Atomos retry conditional waiting statement for efficient transactional conflict-driven wakeup even in transactional memory systems with a limited number of transactional contexts. Atomos supports open-nested transactions, which are necessary for building both scalable application programs and virtual machine implementations.The implementation of the Atomos scheduler demonstrates the use of open nesting within the virtual machine and introduces the concept of transactional memory violation handlers that allow programs to recover from data dependency violations without rolling back.Atomos programming examples are given to demonstrate the usefulness of transactional programming primitives. Atomos and Java are compared through the use of several benchmarks. The results demonstrate both the improvements in parallel programming ease and parallel program performance provided by Atomos.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133983", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brian D.", + "last_name": "Carlstrom", + "institution": "Stanford University" + }, + { + "first_name": "Austen", + "last_name": "McDonald", + "institution": "Stanford University" + }, + { + "first_name": "Hassan", + "last_name": "Chafi", + "institution": "Stanford University" + }, + { + "first_name": "JaeWoong", + "last_name": "Chung", + "institution": "Stanford University" + }, + { + "first_name": "Chi Cao", + "last_name": "Minh", + "institution": "Stanford University" + }, + { + "first_name": "Christos", + "last_name": "Kozyrakis", + "institution": "Stanford University" + }, + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/CarlstromMCCMKO06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133985", + "title": "Compiler and runtime support for efficient software transactional memory", + "abstract": "Programmers have traditionally used locks to synchronize concurrent access to shared data. Lock-based synchronization, however, has well-known pitfalls: using locks for fine-grain synchronization and composing code that already uses locks are both difficult and prone to deadlock. Transactional memory provides an alternate concurrency control mechanism that avoids these pitfalls and significantly eases concurrent programming. Transactional memory language constructs have recently been proposed as extensions to existing languages or included in new concurrent language specifications, opening the door for new compiler optimizations that target the overheads of transactional memory.This paper presents compiler and runtime optimizations for transactional memory language constructs. We present a high-performance software transactional memory system (STM) integrated into a managed runtime environment. Our system efficiently implements nested transactions that support both composition of transactions and partial roll back. Our JIT compiler is the first to optimize the overheads of STM, and we show novel techniques for enabling JIT optimizations on STM operations. We measure the performance of our optimizations on a 16-way SMP running multi-threaded transactional workloads. Our results show that these techniques enable transactional memory's performance to compete with that of well-tuned synchronization.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133985", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Intel (United States)" + }, + { + "first_name": "Brian T. R.", + "last_name": "Lewis", + "institution": "Intel (United States)" + }, + { + "first_name": "Vijay", + "last_name": "Menon", + "institution": "Intel (United States)" + }, + { + "first_name": "Brian", + "last_name": "Murphy", + "institution": "" + }, + { + "first_name": "Bratin", + "last_name": "Saha", + "institution": "Intel (United States)" + }, + { + "first_name": "Tatiana", + "last_name": "Shpeisman", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/Adl-TabatabaiLMMSS06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133995", + "title": "Shared memory programming for large scale machines", + "abstract": "This paper describes the design and implementation of a scalable run-time system and an optimizing compiler for Unified Parallel C (UPC). An experimental evaluation on BlueGene/L®, a distributed-memory machine, demonstrates that the combination of the compiler with the runtime system produces programs with performance comparable to that of efficient MPI programs and good performance scalability up to hundreds of thousands of processors.Our runtime system design solves the problem of maintaining shared object consistency efficiently in a distributed memory machine. Our compiler infrastructure simplifies the code generated for parallel loops in UPC through the elimination of affinity tests, eliminates several levels of indirection for accesses to segments of shared arrays that the compiler can prove to be local, and implements remote update operations through a lower-cost asynchronous message. The performance evaluation uses three well-known benchmarks --- HPC RandomAccess, HPC STREAM and NAS CG --- to obtain scaling and absolute performance numbers for these benchmarks on up to 131072 processors, the full BlueGene/L machine. These results were used to win the HPC Challenge Competition at SC05 in Seattle WA, demonstrating that PGAS languages support both productivity and performance.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133995", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Barton", + "institution": "University of Alberta" + }, + { + "first_name": "Călin", + "last_name": "Caşcaval", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "George", + "last_name": "Almási", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Yili", + "last_name": "Zheng", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Montse", + "last_name": "Farreras", + "institution": "Universitat Politècnica de Catalunya" + }, + { + "first_name": "Siddhartha", + "last_name": "Chatterje", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "José Nelson", + "last_name": "Amaral", + "institution": "University of Alberta" + } + ], + "dblp_key": "conf/pldi/BartonCAZFCA06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134006", + "title": "A global progressive register allocator", + "abstract": "This paper describes a global progressive register allocator, a register allocator that uses an expressive model of the register allocation problem to quickly find a good allocation and then progressively find better allocations until a provably optimal solution is found or a preset time limit is reached. The key contributions of this paper are an expressive model of global register allocation based on multicommodity network flows that explicitly represents spill code optimization, register preferences, copy insertion, and constant rematerialization; two fast, but effective, heuristic allocators based on this model; and a more elaborate progressive allocator that uses Lagrangian relaxation to compute the optimality of its allocations. Our progressive allocator demonstrates code size improvements as large as 16.75% compared to a traditional graph allocator. On average, we observe an initial improvement of 3.47%, which increases progressively to 6.84% as more time is permitted for compilation.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134006", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David Ryan", + "last_name": "Koes", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Seth Copen", + "last_name": "Goldstein", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/KoesG06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134007", + "title": "Profile-based global live-range splitting", + "abstract": "Live-range splitting is a technique to split the live range of a given variable into multiple subranges, each of which can be assigned to a different register or spilled out to memory in order to improve results of coloring register allocation. Previous techniques, such as aggressive live-range splitting, tend to produce extra spill code in the frequently executed (called hot) regions of the code, since they don't distinguish hot regions from others. We propose a new live-range splitting algorithm, which can reduce the amount of spill code in hot regions by coalescing the live ranges based on profile information after splitting the live ranges at every join and fork point in the control-flow graph. Our experimental results have shown that our new algorithm improved the performance of SPECjvm98 by up to 33% over aggressive live-range splitting and 7% over the base coloring algorithm without any live-range splitting.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134007", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Takuya", + "last_name": "Nakaike", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Tatsushi", + "last_name": "Inagaki", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/pldi/NakaikeIKN06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134016", + "title": "Continuations and transducer composition", + "abstract": "On-line transducers are an important class of computational agent; we construct and compose together many software systems using them, such as stream processors, layered network protocols, DSP networks and graphics pipelines. We show an interesting use of continuations, that, when taken in a CPS setting, exposes the control flow of these systems. This enables a CPS-based compiler to optimise systems composed of these transducers, using only standard, known analyses and optimisations. Critically, the analysis permits optimisation across the composition of these transducers, allowing efficient construction of systems in a hierarchical way.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134016", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ShiversM06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134015", + "title": "Eventrons: a safe programming construct for high-frequency hard real-time applications", + "abstract": "While real-time garbage collection has achieved worst-case latencies on the order of a millisecond, this technology is approaching its practical limits. For tasks requiring extremely low latency, and especially periodic tasks with frequencies above 1 KHz, Java programmers must currently resort to the NoHeapRealtimeThread construct of the Real-Time Specification for Java. This technique requires expensive run-time checks, can result in unpredictable low-level exceptions, and inhibits communication with the rest of the garbage-collected application. We present Eventrons, a programming construct that can arbitrarily preempt the garbage collector, yet guarantees safety and allows its data to be visible to the garbage-collected heap. Eventrons are a strict subset of Java, and require no run-time memory access checks. Safety is enforced using a data-sensitive analysis and simple run-time support with extremely low overhead. We have implemented Eventrons in IBM's J9 Java virtual machine, and present experimental results in which we ran Eventrons at frequencies up to 22 KHz (a 45 μs period). Across 10 million periods, 99.997% of the executions ran within 10 μss of their deadline, compared to 99.999% of the executions of the equivalent program written in C.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134015", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Spoonhower", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Joshua", + "last_name": "Auerbach", + "institution": "" + }, + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "" + }, + { + "first_name": "Perry", + "last_name": "Cheng", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Grove", + "institution": "" + } + ], + "dblp_key": "conf/pldi/SpoonhowerABCG06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133991", + "title": "Practical dynamic software updating for C", + "abstract": "Software updates typically require stopping and restarting an application, but many systems cannot afford to halt service, or would prefer not to. Dynamic software updating (DSU) addresses this difficulty by permitting programs to be updated while they run. DSU is appealing compared to other approaches for on-line upgrades because it is quite general and requires no redundant hardware. The challenge is in making DSU practical: it should be flexible, and yet safe, efficient, and easy to use.In this paper, we present Ginseng, a DSU implementation for C that aims to meet this challenge. We compile programs specially so that they can be dynamically patched, and generate most of a dynamic patch automatically. Ginseng performs a series of analyses that when combined with some simple runtime support ensure that an update will not violate type-safety while guaranteeing that data is kept up-to-date. We have used Ginseng to construct and dynamically apply patches to three substantial open-source server programs---Very Secure FTP daemon, OpenSSH sshd daemon, and GNU Zebra. In total, we dynamically patched each program with three years' worth of releases. Though the programs changed substantially, the majority of updates were easy to generate. Performance experiments show that all patches could be applied in less than 5 ms, and that the overhead on application throughput due to updating support ranged from 0 to at most 32%.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133991", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Gareth", + "last_name": "Stoyle", + "institution": "University of Cambridge" + }, + { + "first_name": "Manuel", + "last_name": "Oriol", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/NeamtiuHSO06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1134022", + "title": "Correctness-preserving derivation of concurrent garbage collection algorithms", + "abstract": "Constructing correct concurrent garbage collection algorithms is notoriously hard. Numerous such algorithms have been proposed, implemented, and deployed - and yet the relationship among them in terms of speed and precision is poorly understood, and the validation of one algorithm does not carry over to others.As programs with low latency requirements written in garbagecollected languages become part of society's mission-critical infrastructure, it is imperative that we raise the level of confidence in the correctness of the underlying system, and that we understand the trade-offs inherent in our algorithmic choice.In this paper we present correctness-preserving transformations that can be applied to an initial abstract concurrent garbage collection algorithm which is simpler, more precise, and easier to prove correct than algorithms used in practice--but also more expensive and with less concurrency. We then show how both pre-existing and new algorithms can be synthesized from the abstract algorithm by a series of our transformations. We relate the algorithms formally using a new definition of precision, and informally with respect to overhead and concurrency.This provides many insights about the nature of concurrent collection, allows the direct synthesis of new and useful algorithms, reduces the burden of proof to a single simple algorithm, and lays the groundwork for the automated synthesis of correct concurrent collectors.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1134022", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "University of Cambridge" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "" + }, + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "" + } + ], + "dblp_key": "conf/pldi/VechevYB06", + "venue": "pldi", + "year": 2006 + }, + { + "paper_id": "10.1145/1133981.1133989", + "title": "A framework for unrestricted whole-program optimization", + "abstract": "Procedures have long been the basic units of compilation in conventional optimization frameworks. However, procedures are typically formed to serve software engineering rather than optimization goals, arbitrarily constraining code transformations. Techniques, such as aggressive inlining and interprocedural optimization, have been developed to alleviate this problem, but, due to code growth and compile time issues, these can be applied only sparingly.This paper introduces the Procedure Boundary Elimination (PBE) compilation framework, which allows unrestricted whole-program optimization. PBE allows all intra-procedural optimizations and analyses to operate on arbitrary subgraphs of the program, regardless of the original procedure boundaries and without resorting to inlining. In order to control compilation time, PBE also introduces novel extensions of region formation and encapsulation. PBE enables targeted code specialization, which recovers the specialization benefits of inlining while keeping code growth in check. This paper shows that PBE attains better performance than inlining with half the code growth.", + "date": "2006-06-11", + "link": "https://doi.org/10.1145/1133981.1133989", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Spyridon", + "last_name": "Triantafyllis", + "institution": "Princeton University" + }, + { + "first_name": "Matthew J.", + "last_name": "Bridges", + "institution": "Princeton University" + }, + { + "first_name": "Easwaran", + "last_name": "Raman", + "institution": "Princeton University" + }, + { + "first_name": "Guilherme", + "last_name": "Ottoni", + "institution": "Princeton University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/TriantafyllisBROA06", + "venue": "pldi", + "year": 2006 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2007.json b/data/pl_conferences/pldi/2007.json new file mode 100644 index 0000000..2bd93c2 --- /dev/null +++ b/data/pl_conferences/pldi/2007.json @@ -0,0 +1,1452 @@ +[ + { + "paper_id": "10.1145/1250734.1250761", + "title": "Effective automatic parallelization of stencil computations", + "abstract": "Performance optimization of stencil computations has been widely studied in the literature, since they occur in many computationally intensive scientific and engineering applications. Compiler frameworks have also been developed that can transform sequential stencil codes for optimization of data locality and parallelism. However, loop skewing is typically required in order to tile stencil codes along the time dimension, resulting in load imbalance in pipelined parallel execution of the tiles. In this paper, we develop an approach for automatic parallelization of stencil codes, that explicitly addresses the issue of load-balanced execution of tiles. Experimental results are provided that demonstrate the effectiveness of the approach.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250761", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "The Ohio State University" + }, + { + "first_name": "Muthu Manikandan", + "last_name": "Baskaran", + "institution": "The Ohio State University" + }, + { + "first_name": "Uday", + "last_name": "Bondhugula", + "institution": "The Ohio State University" + }, + { + "first_name": "J.", + "last_name": "Ramanujam", + "institution": "" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/KrishnamoorthyBBRRS07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250747", + "title": "Improved error reporting for software that uses black-box components", + "abstract": "An error occurs when software cannot complete a requested action as a result of some problem with its input, configuration, or environment. A high-quality error report allows a user to understand and correct the problem. Unfortunately, the quality of error reports has been decreasing as software becomes more complex and layered. End-users take the cryptic error messages given to them by programsand struggle to fix their problems using search engines and support websites. Developers cannot improve their error messages when they receive an ambiguous or otherwise insufficient error indicator from a black-box software component.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250747", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jung-Woo", + "last_name": "Ha", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Christopher J.", + "last_name": "Rossbach", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Jason V.", + "last_name": "Davis", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Indrajit", + "last_name": "Roy", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Hany E.", + "last_name": "Ramadan", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Donald E.", + "last_name": "Porter", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "David L.", + "last_name": "Chen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Emmett", + "last_name": "Witchel", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/HaRDRRPCW07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250773", + "title": "Efficient static analysis of XML paths and types", + "abstract": "We present an algorithm to solve XPath decision problems under regular tree type constraints and show its use to statically type-check XPath queries. To this end, we prove the decidability of a logic with converse for finite ordered trees whose time complexity is a simple exponential of the size of a formula. The logic corresponds to the alternation free modal μ-calculus without greatest fixpoint, restricted to finite trees, and where formulas are cycle-free.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250773", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Genevès", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Nabil", + "last_name": "Layaïda", + "institution": "Centre Inria de l'Université Grenoble Alpes" + }, + { + "first_name": "Alan", + "last_name": "Schmitt", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/GenevesLS07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250741", + "title": "Fault-tolerant typed assembly language", + "abstract": "A transient hardware fault occurs when an energetic particle strikes a transistor, causing it to change state. Although transient faults do not permanently damage the hardware, they may corrupt computations by altering stored values and signal transfers. In this paper, we propose a new scheme for provably safe and reliable computing in the presence of transient hardware faults. In our scheme, software computations are replicated to provide redundancy while special instructions compare the independently computed results to detect errors before writing critical data. In stark contrast to any previous efforts in this area, we have analyzed our fault tolerance scheme from a formal, theoretical perspective. To be specific, first, we provide an operational semantics for our assembly language, which includes a precise formal definition of our fault model. Second, we develop an assembly-level type system designed to detect reliability problems in compiled code. Third, we provide a formal specification for program fault tolerance under the given fault model and prove that all well-typed programs are indeed fault tolerant. In addition to the formal analysis, we evaluate our detection scheme and show that it only takes 34% longer to execute than the unreliable version.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250741", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Frances", + "last_name": "Perry", + "institution": "Princeton University" + }, + { + "first_name": "Lester", + "last_name": "Mackey", + "institution": "Princeton University" + }, + { + "first_name": "George A.", + "last_name": "Reis", + "institution": "Princeton University" + }, + { + "first_name": "Jay", + "last_name": "Ligatti", + "institution": "University of South Florida" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/PerryMRLAW07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250779", + "title": "Profile-driven energy reduction in network-on-chips", + "abstract": "Reducing energy consumption of a Network-on-Chip (NoC) is a critical design goal, especially for power-constrained embedded systems.In response, prior research has proposed several circuit/architectural level mechanisms to reduce NoC power consumption. This paper considers the problem from a different perspective and demonstrates that compiler analysis can be very helpful for enhancing the effectiveness of a hardware-based link power management mechanism by increasing the duration of communication links' idle periods. The proposed profile-based approach achieves its goal by maximizing the communication link reuse through compiler-directed, static message re-routing. That is, it clusters the required data communications into a small set of communication links at any given time, which increases the idle periods for the remaining communication links in the network. This helps hardware shut down more communication links and their corresponding buffers to reduce leakage power. The current experimental evaluation, with twelve data-intensive embedded applications, shows that the proposed profile-driven compiler approach reduces leakage energy by more than 35% (on average) as compared to a pure hardware-based link power management scheme.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250779", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Feihui", + "last_name": "Li", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Guangyu", + "last_name": "Chen", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "I.", + "last_name": "Kolcu", + "institution": "University of Manchester" + } + ], + "dblp_key": "conf/pldi/LiCKK07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250742", + "title": "A certified type-preserving compiler from lambda calculus to assembly language", + "abstract": "We present a certified compiler from the simply-typed lambda calculus to assembly language. The compiler is certified in the sense that it comes with a machine-checked proof of semantics preservation, performed with the Coq proof assistant. The compiler and the terms of its several intermediate languages are given dependent types that guarantee that only well-typed programs are representable. Thus, type preservation for each compiler pass follows without any significant \"proofs\" of the usual kind. Semantics preservation is proved based on denotational semantics assigned to the intermediate languages. We demonstrate how working with a type-preserving compiler enables type-directed proof search to discharge large parts of our proof obligations automatically.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250742", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/Chlipala07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250755", + "title": "Mace: language support for building distributed systems", + "abstract": "Building distributed systems is particularly difficult because of the asynchronous, heterogeneous, and failure-prone environment where these systemsmust run. Tools for building distributed systems must strike a compromise between reducing programmer effort and increasing system efficiency. We present Mace, a C++ language extension and source-to-source compiler that translates a concise but expressive distributed system specification into a C++ implementation. Mace overcomes the limitations of low-level languages by providing a unified framework for networking and event handling, and the limitations of high-level languages by allowing programmers to write program components in a controlled and structured manner in C++. By imposing structure and restrictions on how applications can be written, Mace supports debugging at a higher level, including support for efficient model checking and causal-path debugging. Because Mace programs compile to C++, programmers can use existing C++ tools, including optimizers, profilers, and debuggers to analyze their systems.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250755", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Charles", + "last_name": "Killian", + "institution": "University of California, San Diego" + }, + { + "first_name": "James W.", + "last_name": "Anderson", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ryan", + "last_name": "Braud", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Amin", + "last_name": "Vahdat", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/KillianABJV07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250771", + "title": "Proving thread termination", + "abstract": "Concurrent programs are often designed such that certain functions executing within critical threads must terminate. Examples of such cases can be found in operating systems, web servers, e-mail clients, etc. Unfortunately, no known automatic program termination prover supports a practical method of proving the termination of threads. In this paper we describe such a procedure. The procedure's scalability is achieved through the use of environment models that abstract away the surrounding threads. The procedure's accuracy is due to a novel method of incrementally constructing environment abstractions. Our method finds the conditions that a thread requires of its environment in order to establish termination by looking at the conditions necessary to prove that certain paths through the thread represent well-founded relations if executed in isolation of the other threads. The paper gives a description of experimental results using an implementation of our procedureon Windows device drivers and adescription of a previously unknown bug found withthe tool.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250771", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/CookPR07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250780", + "title": "Parameterized tiled loops for free", + "abstract": "Parameterized tiled loops-where the tile sizes are not fixed at compile time, but remain symbolic parameters until later--are quite useful for iterative compilers and \"auto-tuners\" that produce highly optimized libraries and codes. Tile size parameterization could also enable optimizations such as register tiling to become dynamic optimizations. Although it is easy to generate such loops for (hyper) rectangular iteration spaces tiled with (hyper) rectangular tiles, many important computations do not fall into this restricted domain. Parameterized tile code generation for the general case of convex iteration spaces being tiled by (hyper) rectangular tiles has in the past been solved with bounding box approaches or symbolic Fourier Motzkin approaches. However, both approaches have less than ideal code generation efficiency and resulting code quality. We present the theoretical foundations, implementation, and experimental validation of a simple, unified technique for generating parameterized tiled code. Our code generation efficiency is comparable to all existing code generation techniques including those for fixed tile sizes, and the resulting code is as efficient as, if not more than, all previous techniques. Thus the technique provides parameterized tiled loops for free! Our \"one-size-fits-all\" solution, which is available as open source software can be adapted for use in production compilers.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250780", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lakshminarayanan", + "last_name": "Renganarayanan", + "institution": "Colorado State University" + }, + { + "first_name": "DaeGon", + "last_name": "Kim", + "institution": "Colorado State University" + }, + { + "first_name": "Sanjay", + "last_name": "Rajopadhye", + "institution": "Colorado State University" + }, + { + "first_name": "Michelle Mills", + "last_name": "Strout", + "institution": "Colorado State University" + } + ], + "dblp_key": "conf/pldi/RenganarayananKRS07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250783", + "title": "Searching for type-error messages", + "abstract": "Advanced type systems often need some form of type inference to reduce the burden of explicit typing, but type inference often leads to poor error messages for ill-typed programs. This work pursues a new approach to constructing compilers and presenting type-error messages in which the type-checker itself does not produce the messages. Instead, it is an oracle for a search procedure that finds similar programs that do type-check. Our two-fold goal is to improve error messages while simplifying compiler construction. Our primary implementation and evaluation is for Caml, a language with full type inference. We also present a prototype for C++ template functions, where type instantiation is implicit. A key extension is making our approach robust even when the program has multiple independent type errors.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250783", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benjamin S.", + "last_name": "Lerner", + "institution": "University of Washington" + }, + { + "first_name": "Matthew", + "last_name": "Flower", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/LernerFGC07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250754", + "title": "Sketching stencils", + "abstract": "Performance of stencil computations can be significantly improved through smart implementations that improve memory locality, computation reuse, or parallelize the computation. Unfortunately, efficient implementations are hard to obtain because they often involve non-traditional transformations, which means that they cannot be produced by optimizing the reference stencil with a compiler. In fact, many stencils are produced by code generators that were tediously handcrafted.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250754", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Berkeley College" + }, + { + "first_name": "Gilad", + "last_name": "Arnold", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Liviu", + "last_name": "Tancau", + "institution": "Berkeley College" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Vijay", + "last_name": "Saraswat", + "institution": "IBM (United States)" + }, + { + "first_name": "Sanjit A.", + "last_name": "Seshia", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/Solar-LezamaATBSS07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250777", + "title": "Online optimizations driven by hardware performance monitoring", + "abstract": "Hardware performance monitors provide detailed direct feedback about application behavior and are an additional source of infor-mation that a compiler may use for optimization. A JIT compiler is in a good position to make use of such information because it is running on the same platform as the user applications. As hardware platforms become more and more complex, it becomes more and more difficult to model their behavior. Profile information that captures general program properties (like execution frequency of methods or basic blocks) may be useful, but does not capture sufficient information about the execution platform. Machine-level performance data obtained from a hardware performance monitor can not only direct the compiler to those parts of the program that deserve its attention but also determine if an optimization step actually improved the performance of the application.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250777", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Florian", + "last_name": "Schneider", + "institution": "ETH Zurich" + }, + { + "first_name": "Mathias", + "last_name": "Payer", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/SchneiderPG07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250778", + "title": "UCC: update-conscious compilation for energy efficiency in wireless sensor networks", + "abstract": "Wireless sensor networks (WSN), composed of a large number of low-cost, battery-powered sensors, have recently emerged as promising computing platforms for many non-traditional applications. The preloaded code on remote sensors often needs to be updated after deployment in order for the WSN to adapt to the changing demands from the users. Post-deployment code dissemination is challenging as the data are transmitted via battery-powered wireless communication. Recent studies show that the energy for sending a single bit is about the same as executing 1000 instructions in aWSN. Therefore it is important to achieve energy efficiency in code dissemination.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250778", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Weijia", + "last_name": "Li", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Youtao", + "last_name": "Zhang", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Jun", + "last_name": "Yang", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Zheng", + "last_name": "Jiang", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/pldi/LiZYZ07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250789", + "title": "Practical memory leak detection using guarded value-flow analysis", + "abstract": "This paper presents a practical inter-procedural analysis algorithm for detecting memory leaks in C programs. Our algorithm tracks the flow of values from allocation points to deallocation points using a sparse representation of the program consisting of a value flow graph that captures def-use relations and value flows via program assignments. Edges in the graph are annotated with guards that describe branch conditions in the program. The memory leak analysis is reduced to a reachability problem over the guarded value flowgraph. Our implemented tool has been effective at detecting more than 60 memory leaks in the SPEC2000 benchmarks and in two open-source applications, bash and sshd, while keeping the false positive rate below 20%. The sparse program representation makes the tool efficient in practice, and allows it to report concise error messages.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250789", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sigmund", + "last_name": "Cherem", + "institution": "Cornell University" + }, + { + "first_name": "Lonnie", + "last_name": "Princehouse", + "institution": "Cornell University" + }, + { + "first_name": "Radu", + "last_name": "Rugina", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/CheremPR07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250737", + "title": "CheckFence: checking consistency of concurrent data types on relaxed memory models", + "abstract": "Concurrency libraries can facilitate the development of multi-threaded programs by providing concurrent implementations of familiar data types such as queues or sets. There exist many optimized algorithms that can achieve superior performance on multiprocessors by allowing concurrent data accesses without using locks. Unfortunately, such algorithms can harbor subtle concurrency bugs. Moreover, they requirememory ordering fences to function correctly on relaxed memory models.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250737", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Milo M. K.", + "last_name": "Martin", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/BurckhardtAM07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250775", + "title": "The ExoVM system for automatic VM and application reduction", + "abstract": "Embedded systems pose unique challenges to Java application developers and virtual machine designers. Chief among these challenges is the memory footprint of both the virtual machine and the applications that run within it. With the rapidly increasing set of features provided by the Java language, virtual machine designers are often forced to build custom implementations that make various tradeoffs between the footprint of the virtual machine and the subset of the Java language and class libraries that are supported. In this paper, we present the ExoVM, a system in which an application is initialized in a fully featured virtual machine, and then the code, data, and virtual machine features necessary to execute it are packaged into a binary image. Key to this process is feature analysis, a technique for computing the reachable code and data of a Java program and its implementation inside the VM simultaneously. The ExoVM reduces the need to develop customized embedded virtual machines by reusing a single VM infrastructure and automatically eliding the implementation of unused Java features on a per-program basis. We present a constraint-based instantiation of the analysis technique, an implementation in IBM's J9 Java VM, experiments evaluating our technique for the EEMBC benchmark suite, and some discussion of the individual costs of some of Java's features. Our evaluation shows that our system can reduce the non-heap memory allocation of the virtual machine by as much as 75%. We discuss VM and language design decisions that our work shows are important in targeting embedded systems, supporting the long-term goal of a common VM infrastructure spanning from motes to large servers.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250775", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben L.", + "last_name": "Titzer", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Joshua", + "last_name": "Auerbach", + "institution": "IBM (United States)" + }, + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/TitzerABP07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250750", + "title": "Automatic inference of optimizer flow functions from semantic meanings", + "abstract": "Previous work presented a language called Rhodium for writing program analyses and transformations, in the form of declarative flow functions that propagate instances of user-defined dataflow fact schemas. Each dataflow fact schema specifies a semantic meaning, which allows the Rhodium system to automatically verify the correctness of the user's flow functions. In this work, we have reversed the roles of the flow functions and semantic meanings: rather than checking the correctness of the user-written flow functions using the facts' semantic meanings, we automatically infer correct flow functions solely from the meanings of the dataflow fact schemas. We have implemented our algorithm for inferring flow functions from fact schemas in the context of the Whirlwind compiler, and have used this implementation to infer flow functions for a variety of fact schemas. The automatically generated flow functions cover most of the situations covered by an earlier suite of handwritten rules.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250750", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Erika Rice", + "last_name": "Scherpelz", + "institution": "Google (United States)" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/ScherpelzLC07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250736", + "title": "Exterminator: automatically correcting memory errors with high probability", + "abstract": "Programs written in C and C++ are susceptible to memory errors, including buffer overflows and dangling pointers. These errors, whichcan lead to crashes, erroneous execution, and security vulnerabilities, are notoriously costly to repair. Tracking down their location in the source code is difficult, even when the full memory state of the program is available. Once the errors are finally found, fixing them remains challenging: even for critical security-sensitive bugs, the average time between initial reports and the issuance of a patch is nearly one month.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250736", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gene", + "last_name": "Novark", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/NovarkBZ07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250766", + "title": "Making context-sensitive points-to analysis with heap cloning practical for the real world", + "abstract": "Context-sensitive pointer analysis algorithms with full “heap cloning ” are powerful but are widely considered to be too expensive to include in production compilers. This paper shows, for the first time, that a context-sensitive, field-sensitive algorithm with full heap cloning (by acyclic call paths) can indeed be both scalable and extremely fast in practice. Overall, the algorithm is able to analyze programs in the range of 100K-200K lines of C code in 1-3 seconds, takes less than 5 % of the time it takes for GCC to compile the code (which includes no whole-program analysis), and scales well across five orders of magnitude of code size. It is also able to analyze the Linux kernel (about 355K lines of code) in 3.1 seconds. The paper describes the major algorithmic and engineering design choices that are required to achieve these results, including (a) using flow-insensitive and unification-based analysis, which", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250766", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chris", + "last_name": "Lattner", + "institution": "Apple (Israel)" + }, + { + "first_name": "Andrew", + "last_name": "Lenharth", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/LattnerLA07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250762", + "title": "Goldilocks: a race and transaction-aware java runtime", + "abstract": "Data races often result in unexpected and erroneous behavior. In addition to causing data corruption and leading programs to crash, the presence of data races complicates the semantics of an execution which might no longer be sequentially consistent. Motivated by these observations, we have designed and implemented a Java runtime system that monitors program executions and throws a DataRaceException when a data race is about to occur. Analogous to other runtime exceptions, the DataRaceException provides two key benefits. First, accesses causing race conditions are interruptedand handled before they cause errors that may be difficult to diagnose later. Second, if no DataRaceException is thrown in an execution, it is guaranteed to be sequentially consistent. This strong guarantee helps to rule out many concurrency-related possibilities as the cause of erroneous behavior. When a DataRaceException is caught, the operation, thread, or program causing it can be terminated gracefully. Alternatively, the DataRaceException can serve as a conflict-detection mechanism inoptimistic uses of concurrency.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250762", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tayfun", + "last_name": "Elmas", + "institution": "Koç University" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Serdar", + "last_name": "Taşiran", + "institution": "Koç University" + } + ], + "dblp_key": "conf/pldi/ElmasQT07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250760", + "title": "Software behavior oriented parallelization", + "abstract": "Many sequential applications are difficult to parallelize because of unpredictable control flow, indirect data access, and input-dependent parallelism. These difficulties led us to build a software system for behavior oriented parallelization (BOP), which allows a program to be parallelized based on partial information about program behavior, for example, a user reading just part of the source code, or a profiling tool examining merely one or few executions.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250760", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "Williams (United States)" + }, + { + "first_name": "Kirk", + "last_name": "Kelsey", + "institution": "University of Rochester" + }, + { + "first_name": "Chris", + "last_name": "Tice", + "institution": "University of Rochester" + }, + { + "first_name": "Ruke", + "last_name": "Huang", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Chengliang", + "last_name": "Zhang", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/pldi/DingSKTHZ07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250752", + "title": "Automatic inversion generates divide-and-conquer parallel programs", + "abstract": "Divide-and-conquer algorithms are suitable for modern parallel machines, tending to have large amounts of inherent parallelism and working well with caches and deep memory hierarchies. Among others, list homomorphisms are a class of recursive functions on lists, which match very well with the divide-and-conquer paradigm. However, direct programming with list homomorphisms is a challenge for many programmers. In this paper, we propose and implement a novel systemthat can automatically derive cost-optimal list homomorphisms from a pair of sequential programs, based on the third homomorphism theorem. Our idea is to reduce extraction of list homomorphisms to derivation of weak right inverses. We show that a weak right inverse always exists and can be automatically generated from a wide class of sequential programs. We demonstrate our system with several nontrivial examples, including the maximum prefix sum problem, the prefix sum computation, the maximum segment sum problem, and the line-of-sight problem. The experimental results show practical efficiency of our automatic parallelization algorithm and good speedups of the generated parallel programs.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250752", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kazutaka", + "last_name": "Morita", + "institution": "The University of Tokyo" + }, + { + "first_name": "Akimasa", + "last_name": "Morihata", + "institution": "The University of Tokyo" + }, + { + "first_name": "Kiminori", + "last_name": "Matsuzaki", + "institution": "The University of Tokyo" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "The University of Tokyo" + }, + { + "first_name": "Masato", + "last_name": "Takeichi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/pldi/MoritaMMHT07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250765", + "title": "Thread-modular shape analysis", + "abstract": "We present the first shape analysis for multithreaded programs that avoids the explicit enumeration of execution-interleavings. Our approach is to automatically infer a resource invariant associated with each lock that describes the part of the heap protected by the lock. This allows us to use a sequential shape analysis on each thread. We show that resource invariants of a certain class can be characterized as least fixed points and computed via repeated applications of shape analysis only on each individual thread. Based on this approach, we have implemented a thread-modular shape analysis tool and applied it to concurrent heap-manipulating code from Windows device drivers.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250765", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "University of Cambridge" + }, + { + "first_name": "Josh", + "last_name": "Berdine", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/GotsmanBCS07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250784", + "title": "Static error detection using semantic inconsistency inference", + "abstract": "Inconsistency checking is a method for detecting software errors that relies only on examining multiple uses of a value. We propose that inconsistency inference is best understood as a variant of the older and better understood problem of type inference. Using this insight, we describe a precise and formal framework for discovering inconsistency errors. Unlike previous approaches to the problem, our technique for finding inconsistency errors is purely semantic and can deal with complex aliasing and path-sensitive conditions. We have built a nullde reference analysis of C programs based on semantic inconsistency inference and have used it to find hundreds of previously unknown null dereference errors in widely used C programs.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250784", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/DilligDA07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250757", + "title": "Reliable and efficient programming abstractions for wireless sensor networks", + "abstract": "It is currently difficult to build practical and reliable programming systems out of distributed and resource-constrained sensor devices. The state of the art in today's sensornet programming is centered around a component-based language called nesC. nesC is a node-level language-a program is written for an individual node in the network-and nesC programs use the services of an operating system called TinyOS. We are pursuing an approach to programming sensor networks that significantly raises the level of abstraction over this practice. The critical change is one of perspective: rather than writing programs from the point of view of an individual node, programmers implement a central program that conceptually has access to the entire network. This approach pushes to the compiler the task of producing node-level programs that implement the desired behavio.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250757", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nupur", + "last_name": "Kothari", + "institution": "LAC+USC Medical Center" + }, + { + "first_name": "Ramakrishna", + "last_name": "Gummadi", + "institution": "LAC+USC Medical Center" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "UCLA Health" + }, + { + "first_name": "Ramesh", + "last_name": "Govindan", + "institution": "LAC+USC Medical Center" + } + ], + "dblp_key": "conf/pldi/KothariGMG07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250744", + "title": "Enforcing isolation and ordering in STM", + "abstract": "Transactional memory provides a new concurrency control mechanism that avoids many of the pitfalls of lock-based synchronization. High-performance software transactional memory (STM) implementations thus far provide weak atomicity: Accessing shared data both inside and outside a transaction can result in unexpected, implementation-dependent behavior. To guarantee isolation and consistent ordering in such a system, programmers are expected to enclose all shared-memory accesses inside transactions.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250744", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tatiana", + "last_name": "Shpeisman", + "institution": "Intel (United States)" + }, + { + "first_name": "Vijay", + "last_name": "Menon", + "institution": "Intel (United States)" + }, + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Intel (United States)" + }, + { + "first_name": "Steven", + "last_name": "Balensiefer", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Richard L.", + "last_name": "Hudson", + "institution": "Intel (United States)" + }, + { + "first_name": "Katherine F.", + "last_name": "Moore", + "institution": "University of Washington" + }, + { + "first_name": "Bratin", + "last_name": "Saha", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/ShpeismanMABGHMS07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250785", + "title": "Iterative context bounding for systematic testing of multithreaded programs", + "abstract": "Multithreaded programs are difficult to get right because of unexpected interaction between concurrently executing threads. Traditional testing methods are inadequate for catching subtle concurrency errors which manifest themselves late in the development cycle and post-deployment. Model checking or systematic exploration of program behavior is a promising alternative to traditional testing methods. However, it is difficult to perform systematic search on large programs as the number of possible program behaviors grows exponentially with the program size. Confronted with this state-explosion problem, traditional model checkers perform iterative depth-bounded search. Although effective for message-passing software, iterative depth-bounding is inadequate for multithreaded software.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250785", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/MusuvathiQ07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250746", + "title": "Valgrind: a framework for heavyweight dynamic binary instrumentation", + "abstract": "Dynamic binary instrumentation (DBI) frameworks make it easy to build dynamic binary analysis (DBA) tools such as checkers and profilers. Much of the focus on DBI frameworks has been on performance; little attention has been paid to their capabilities. As a result, we believe the potential of DBI has not been fully exploited.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250746", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nicholas", + "last_name": "Nethercote", + "institution": "Data61" + }, + { + "first_name": "Julian", + "last_name": "Seward", + "institution": "Open Group" + } + ], + "dblp_key": "conf/pldi/NethercoteS07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250776", + "title": "Offline compression for on-chip ram", + "abstract": "We present offline RAM compression, an automated source-to-source transformation that reduces a program's data size. Statically allocated scalars, pointers, structures, and arrays are encoded and packed based on the results of a whole-program analysis in the value set and pointer set domains. We target embedded software written in C that relies heavily on static memory allocation and runs on Harvard-architecture microcontrollers supporting just a few KB of on-chip RAM. On a collection of embedded applications for AVR microcontrollers, our transformation reduces RAM usage by an average of 12%, in addition to a 10% reduction through a dead-data elimination pass that is also driven by our whole-program analysis, for a total RAM savings of 22%. We also developeda technique for giving developers access to a flexible spectrum of tradeoffs between RAM consumption, ROM consumption, and CPU efficiency. This technique is based on a model for estimating the cost/benefit ratio of compressing each variable and then selectively compressing only those variables that present a good value proposition in terms of the desired tradeoffs.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250776", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nathan", + "last_name": "Cooprider", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/CoopriderR07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250743", + "title": "Certified self-modifying code", + "abstract": "Self-modifying code (SMC), in this paper, broadly refers to anyprogram that loads, generates, or mutates code at runtime. It is widely used in many of the world's critical software systems tosupport runtime code generation and optimization, dynamic loading and linking, OS boot loader, just-in-time compilation, binary translation,or dynamic code encryption and obfuscation. Unfortunately, SMC is alsoextremely difficult to reason about: existing formal verification techniques-including Hoare logic and type system-consistentlyassume that program code stored in memory is fixedand immutable; this severely limits their applicability and power.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250743", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongxu", + "last_name": "Cai", + "institution": "Tsinghua University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Alexander", + "last_name": "Vaynberg", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/CaiSV07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250748", + "title": "Thin slicing", + "abstract": "Program slicing systematically identifies parts of a program relevant to a seed statement. Unfortunately, slices of modern programs often grow too large for human consumption. We argue that unwieldy slices arise primarily from an overly broad definition of relevance, rather than from analysis imprecision. While a traditional slice includes all statements that may affect a point of interest, not all such statements appear equally relevant to a human.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250748", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Stephen J.", + "last_name": "Fink", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/SridharanFB07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250756", + "title": "Combining events and threads for scalable network services implementation and evaluation of monadic, application-level concurrency primitives", + "abstract": "This paper proposes to combine two seemingly opposed programming models for building massively concurrent network services: the event-driven model and the multithreaded model. The result is a hybrid design that offers the best of both worlds--the ease of use and expressiveness of threads and the flexibility and performance of events.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250756", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peng", + "last_name": "Li", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/LiZ07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250759", + "title": "Optimistic parallelism requires abstractions", + "abstract": "Irregular applications, which manipulate large, pointer-based data structures like graphs, are difficult to parallelize manually. Automatic tools and techniques such as restructuring compilers and run-time speculative execution have failed to uncover much parallelism in these applications, in spite of a lot of effort by the research community. These difficulties have even led some researchers to wonder if there is any coarse-grain parallelism worth exploiting in irregular applications.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250759", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Bruce", + "last_name": "Walter", + "institution": "Cornell University" + }, + { + "first_name": "Ganesh", + "last_name": "Ramanarayanan", + "institution": "Cornell University" + }, + { + "first_name": "Kavita", + "last_name": "Bala", + "institution": "Cornell University" + }, + { + "first_name": "L. Paul", + "last_name": "Chew", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/KulkarniPWRBC07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250767", + "title": "The ant and the grasshopper: fast and accurate pointer analysis for millions of lines of code", + "abstract": "Pointer information is a prerequisite for most program analyses, and the quality of this information can greatly affect their precision and performance. Inclusion-based (i.e. Andersen-style) pointer analysis is an important point in the space of pointer analyses, offering a potential sweet-spot in the trade-off between precision and performance. However, current techniques for inclusion-based pointer analysis can have difficulties delivering on this potential.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250767", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben", + "last_name": "Hardekopf", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Calvin", + "last_name": "Lin", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/HardekopfL07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250788", + "title": "A general framework for certifying garbage collectors and their mutators", + "abstract": "Garbage-collected languages such as Java and C# are becoming more and more widely used in both high-end software and real-time embedded applications. The correctness of the GC implementation is essential to the reliability and security of a large portion of the world's mission-critical software. Unfortunately, garbage collectors--especially incremental and concurrent ones--are extremely hard to implement correctly. In this paper, we present a new uniform approach to verifying the safety of both a mutator and its garbage collector in Hoare-style logic. We define a formal garbage collector interface general enough to reason about a variety of algorithms while allowing the mutator to ignore implementation-specific details of the collector. Our approach supports collectors that require read and write barriers. We have used our approach to mechanically verify assembly implementations of mark-sweep, copying and incremental copying GCs in Coq, as well as sample mutator programs that can be linked with any of the GCs to produce a fully-verified garbage-collected program. Our work provides a foundation for reasoning about complex mutator-collector interaction and makes an important advance toward building fully certified production-quality GCs.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250788", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew", + "last_name": "McCreight", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Chunxiao", + "last_name": "Lin", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Long", + "last_name": "Li", + "institution": "University of Science and Technology of China" + } + ], + "dblp_key": "conf/pldi/McCreightSLL07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250738", + "title": "Automatically classifying benign and harmful data racesallusing replay analysis", + "abstract": "Many concurrency bugs in multi-threaded programs are due to dataraces. There have been many efforts to develop static and dynamic mechanisms to automatically find the data races. Most of the prior work has focused on finding the data races and eliminating the false positives.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250738", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of California, San Diego" + }, + { + "first_name": "Zhenghao", + "last_name": "Wang", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jordan", + "last_name": "Tigani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Andrew J.", + "last_name": "Edwards", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Brad", + "last_name": "Calder", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/NarayanasamyWTEC07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250769", + "title": "Path invariants", + "abstract": "The success of software verification depends on the ability to find a suitable abstraction of a program automatically. We propose a method for automated abstraction refinement which overcomes some limitations of current predicate discovery schemes. In current schemes, the cause of a false alarm is identified as an infeasible error path, and the abstraction is refined in order to remove that path. By contrast, we view the cause of a false alarm -the spurious counterexample- as a full-fledged program, namely, a fragment of the original program whose control-flow graph may contain loops and represent unbounded computations. There are two advantages to using such path programs as counterexamples for abstraction refinement. First, we can bring the whole machinery of program analysis to bear on path programs, which are typically small compared to the original program. Specifically, we use constraint-based invariant generation to automatically infer invariants of path programs-so-called path invariants. Second, we use path invariants for abstraction refinement in order to remove not one infeasibility at a time, but at once all (possibly infinitely many) infeasible error computations that are represented by a path program. Unlike previous predicate discovery schemes, our method handles loops without unrolling them; it infers abstractions that involve universal quantification and naturally incorporates disjunctive reasoning.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250769", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dirk", + "last_name": "Beyer", + "institution": "Simon Fraser University" + }, + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/BeyerHMR07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250764", + "title": "Shape analysis with inductive recursion synthesis", + "abstract": "Separation logic with recursively defined predicates allows for concise yet precise description of the shapes of data structures. However, most uses of separation logic for program analysis rely on pre-defined recursive predicates, limiting the class of programs analyzable to those that manipulate only a priori data structures. This paper describes a general algorithm based on inductive program synthesis that automatically infers recursive shape invariants, yielding a shape analysis based on separation logic that can be applied to any program.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250764", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bolei", + "last_name": "Guo", + "institution": "Princeton University" + }, + { + "first_name": "Neil", + "last_name": "Vachharajani", + "institution": "Princeton University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/GuoVA07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250772", + "title": "Regularly annotated set constraints", + "abstract": "A general class of program analyses area combination of context-free and regular language reachability. We define regularly annotated set constraints, a constraint formalism that captures this class. Our results extend the class of reachability problems expressible naturally in a single constraint formalism, including such diverse applications as interprocedural dataflow analysis, precise type-based flow analysis, and pushdown model checking.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250772", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Kodumal", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/KodumalA07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250770", + "title": "DITTO: automatic incrementalization of data structure invariant checks (in Java)", + "abstract": "We present DITTO, an automatic incrementalizer for dynamic, side-effect-free data structure invariant checks. Incrementalization speeds up the execution of a check by reusing its previous executions, checking the invariant anew only the changed parts of the data structure. DITTO exploits properties specific to the domain of invariant checks to automate and simplify the process without restricting what mutations the program can perform. Our incrementalizer works for modern imperative languages such as Java and C#. It can incrementalize,for example, verification of red-black tree properties and the consistency of the hash code in a hash table bucket. Our source-to-source implementation for Java is automatic, portable, and efficient. DITTO provides speedups on data structures with as few as 100 elements; on larger data structures, its speedups are characteristic of non-automatic incrementalizers: roughly 5-fold at 5,000 elements,and growing linearly with data structure size.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250770", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ajeet", + "last_name": "Shankar", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Berkeley College" + } + ], + "dblp_key": "conf/pldi/ShankarB07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250787", + "title": "CGCExplorer: a semi-automated search procedure for provably correct concurrent collectors", + "abstract": "Concurrent garbage collectors are notoriously hard to design, implement, and verify. We present a framework for the automatic exploration of a space of concurrent mark-and-sweep collectors. In our framework, the designer specifies a set of \"building blocks\" from which algorithms can be constructed. These blocks reflect the designer's insights about the coordination between the collector and the mutator. Given a set of building blocks, our framework automatically explores a space of algorithms, using model checking with abstraction to verify algorithms in the space.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250787", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "University of Cambridge" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "IBM (United States)" + }, + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/VechevYBR07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250749", + "title": "Static specification inference using predicate mining", + "abstract": "The reliability and correctness of complex software systems can be significantly enhanced through well-defined specifications that dictate the use of various units of abstraction (e.g., modules, or procedures). Often times, however, specifications are either missing, imprecise, or simply too complex to encode within a signature, necessitating specification inference. The process of inferring specifications from complex software systems forms the focus of this paper. We describe a static inference mechanism for identifying the preconditions that must hold whenever a procedure is called. These preconditions may reflect both data flow properties (e.g., whenever p is called, variable x must be non-null) as well as control-flow properties (e.g., every call to p must bepreceded by a call to q). We derive these preconditions using a ninter-procedural path-sensitive dataflow analysis that gathers predicates at each program point. We apply mining techniques to these predicates to make specification inference robust to errors. This technique also allows us to derive higher-level specifications that abstract structural similarities among predicates (e.g., procedure p is called immediately after a conditional test that checks whether some variable v is non-null.) We describe an implementation of these techniques, and validate the effectiveness of the approach on a number of large open-source benchmarks. Experimental results confirm that our mining algorithms are efficient, and that the specifications derived are both precise and useful-the implementation discovers several critical, yet previously, undocumented preconditions for well-tested libraries.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250749", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Murali", + "last_name": "Ramanathan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Ananth", + "last_name": "Grama", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/RamanathanGJ07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250753", + "title": "EXOCHI: architecture and programming environment for a heterogeneous multi-core multithreaded system", + "abstract": "Future mainstream microprocessors will likely integrate specialized accelerators, such as GPUs, onto a single die to achieve better performance and power efficiency. However, it remains a keen challenge to program such a heterogeneous multicore platform, since these specialized accelerators feature ISAs and functionality that are significantly different from the general purpose CPU cores. In this paper, we present EXOCHI: (1) Exoskeleton Sequencer(EXO), an architecture to represent heterogeneous acceleratorsas ISA-based MIMD architecture resources, and a shared virtual memory heterogeneous multithreaded program execution model that tightly couples specialized accelerator cores with generalpurpose CPU cores, and (2) C for Heterogeneous Integration(CHI), an integrated C/C++ programming environment that supports accelerator-specific inline assembly and domain-specific languages. The CHI compiler extends the OpenMP pragma for heterogeneous multithreading programming, and produces a single fat binary with code sections corresponding to different instruction sets. The runtime can judiciously spread parallel computation across the heterogeneous cores to optimize performance and power.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250753", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Perry H.", + "last_name": "Wang", + "institution": "Intel (United States)" + }, + { + "first_name": "Jamison D.", + "last_name": "Collins", + "institution": "Intel (United States)" + }, + { + "first_name": "Gautham N.", + "last_name": "Chinya", + "institution": "Intel (United States)" + }, + { + "first_name": "Hong", + "last_name": "Jiang", + "institution": "Intel (United States)" + }, + { + "first_name": "Xinmin", + "last_name": "Tian", + "institution": "Intel (United States)" + }, + { + "first_name": "Milind", + "last_name": "Girkar", + "institution": "Intel (United States)" + }, + { + "first_name": "Nick Y.", + "last_name": "Yang", + "institution": "Intel (United States)" + }, + { + "first_name": "Guei-Yuan", + "last_name": "Lueh", + "institution": "Intel (United States)" + }, + { + "first_name": "Hong", + "last_name": "Wang", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/WangCCJTGYLW07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250739", + "title": "Sound and precise analysis of web applications for injection vulnerabilities", + "abstract": "Web applications are popular targets of security attacks. One common type of such attacks is SQL injection, where an attacker exploits faulty application code to execute maliciously crafted database queries. Bothstatic and dynamic approaches have been proposed to detect or prevent SQL injections; while dynamic approaches provide protection for deployed software, static approaches can detect potential vulnerabilities before software deployment. Previous static approaches are mostly based on tainted information flow tracking and have at least some of the following limitations: (1) they do not model the precise semantics of input sanitization routines; (2) they require manually written specifications, either for each query or for bug patterns; or (3) they are not fully automated and may require user intervention at various points in the analysis. In this paper, we address these limitations by proposing a precise, sound, and fully automated analysis technique for SQL injection. Our technique avoids the need for specifications by consideringas attacks those queries for which user input changes the intended syntactic structure of the generated query. It checks conformance to this policy byconservatively characterizing the values a string variable may assume with a context free grammar, tracking the nonterminals that represent user-modifiable data, and modeling string operations precisely as language transducers. We have implemented the proposed technique for PHP, the most widely-used web scripting language. Our tool successfully discovered previously unknown and sometimes subtle vulnerabilities in real-world programs, has a low false positive rate, and scales to large programs (with approx. 100K loc).", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250739", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gary", + "last_name": "Wassermann", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/WassermannS07", + "venue": "pldi", + "year": 2007 + }, + { + "paper_id": "10.1145/1250734.1250782", + "title": "Towards locating execution omission errors", + "abstract": "Execution omission errors are known to be difficult to locate using dynamic analysis. These errors lead to a failure at runtime because of the omission of execution of some statements that would have been executed if the program had no errors. Since dynamic analysis is typically designed to focus on dynamic information arising from executed statements, and statements whose execution is omitted do not produce dynamic information, detection of execution omission errors becomes a challenging task. For example, while dynamic slices are very effective in capturing faulty code for other types of errors, they fail to capture faulty code in presence of execution omission errors. To address this issue relevant slices have been defined to consider certain static dependences (called potential dependences) in addition to dynamic dependences. However, due to the conservative nature of static analysis, overly large slices are produced. In this paper, we propose a fully dynamic solution to locating execution omission errors using dynamic slices. We introduce the notion of implicit dependences which are dependences that are normally invisible to dynamic slicing due to the omission of execution of some statements. We design a dynamic method that forces the execution of the omitted code by switching outcomes of relevant predicates such that those implicit dependences are exposed and become available for dynamic slicing. Dynamic slices can be computed and effectively pruned to produce fault candidate sets containing the execution omission errors. We solve two main problems: verifying the existence of a single implicit dependence through predicate switching, and recovering the implicit dependences in a demand driven manner such that a small number of verifications are required before the root cause is captured. Our experiments show that the proposed technique is highly effective in capturing execution omission errors.", + "date": "2007-06-10", + "link": "https://doi.org/10.1145/1250734.1250782", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Sriraman", + "last_name": "Tallam", + "institution": "" + }, + { + "first_name": "Neelam", + "last_name": "Gupta", + "institution": "University of Arizona" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/ZhangTGG07", + "venue": "pldi", + "year": 2007 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2008.json b/data/pl_conferences/pldi/2008.json new file mode 100644 index 0000000..9a94935 --- /dev/null +++ b/data/pl_conferences/pldi/2008.json @@ -0,0 +1,939 @@ +[ + { + "paper_id": "10.1145/1375581.1375592", + "title": "Expressive and safe static reflection with MorphJ", + "abstract": "Recently, language extensions have been proposed for Java and C# to support pattern-based reflective declaration. These extensions introduce a disciplined form of meta-programming and aspect-oriented programming to mainstream languages: They allow members of a class (i.e., fields and methods) to be declared by statically iterating over and pattern-matching on members of other classes. Such techniques, however, have been unable to safely express simple, but common, idioms such as declaring getter and setter methods for fields.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375592", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shan", + "last_name": "Huang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/pldi/HuangS08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375586", + "title": "Immix: a mark-region garbage collector with space efficiency, fast collection, and mutator performance", + "abstract": "Programmers are increasingly choosing managed languages for modern applications, which tend to allocate many short-to-medium lived small objects. The garbage collector therefore directly determines program performance by making a classic space-time tradeoff that seeks to provide space efficiency, fast reclamation, and mutator performance. The three canonical tracing garbage collectors: semi-space, mark-sweep, and mark-compact each sacrifice one objective. This paper describes a collector family, called mark-region, and introduces opportunistic defragmentation, which mixes copying and marking in a single pass. Combining both, we implement immix, a novel high performance garbage collector that achieves all three performance objectives. The key insight is to allocate and reclaim memory in contiguous regions, at a coarse block grain when possible and otherwise in groups of finer grain lines. We show that immix outperforms existing canonical algorithms, improving total application performance by 7 to 25% on average across 20 benchmarks. As the mature space in a generational collector, immix matches or beats a highly tuned generational collector, e.g. it improves jbb2000 by 5%. These innovations and the identification of a new family of collectors open new opportunities for garbage collector design.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375586", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/BlackburnM08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375584", + "title": "Race directed random testing of concurrent programs", + "abstract": "Bugs in multi-threaded programs often arise due to data races. Numerous static and dynamic program analysis techniques have been proposed to detect data races. We propose a novel randomized dynamic analysis technique that utilizes potential data race information obtained from an existing analysis tool to separate real races from false races without any need for manual inspection. Specifically, we use potential data race information obtained from an existing dynamic analysis technique to control a random scheduler of threads so that real race conditions get created with very high probability and those races get resolved randomly at runtime. Our approach has several advantages over existing dynamic analysis tools. First, we can create a real race condition and resolve the race randomly to see if an error can occur due to the race. Second, we can replay a race revealing execution efficiently by simply using the same seed for random number generation--we do not need to record the execution. Third, our approach has very low overhead compared to other precise dynamic race detection techniques because we only track all synchronization operations and a single pair of memory access statements that are reported to be in a potential race by an existing analysis. We have implemented the technique in a prototype tool for Java and have experimented on a number of large multi-threaded Java programs. We report a number of previously known and unknown bugs and real races in these Java programs.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375584", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/Sen08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375607", + "title": "Grammar-based whitebox fuzzing", + "abstract": "Whitebox fuzzing is a form of automatic dynamic test generation, based on symbolic execution and constraint solving, designed for security testing of large applications. Unfortunately, the current effectiveness of whitebox fuzzing is limited when testing applications with highly-structured inputs, such as compilers and interpreters. These applications process their inputs in stages, such as lexing, parsing and evaluation. Due to the enormous number of control paths in early processing stages, whitebox fuzzing rarely reaches parts of the application beyond those first stages.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375607", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Adam", + "last_name": "Kieżun", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael Y.", + "last_name": "Levin", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/GodefroidKL08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375590", + "title": "Automatic volume management for programmable microfluidics", + "abstract": "Microfluidics has enabled lab-on-a-chip technology to miniaturize and integrate biological and chemical analyses to a single chip comprising channels, valves, mixers, heaters, separators, and sensors. Recent papers have proposed programmable labs-on-a-chip as an alternative to traditional application-specific chips to reduce design effort, time, and cost. While these previous papers provide the basic support for programmability, this paper identifies and addresses a practical issue, namely, fluid volume management. Volume management addresses the problem that the use of a fluid depletes it and unless the given volume of a fluid is distributed carefully among all its uses, execution may run out of the fluid before all its uses are complete. Additionally, fluid volumes should not overflow (i.e., exceed hardware capacity) or underflow (i.e., fall below hardware resolution). We show that the problem can be formulated as a linear programming problem (LP). Because LP's complexity and slow execution times in practice may be a concern, we propose another approach, called DAGSolve, which over-constrains the problem to achieve linear complexity while maintaining good solution quality. We also propose two optimizations, called cascading and static replication, to handle cases involving extreme mix ratios and numerous fluid uses which may defeat both LP and DAGSolve. Using some real-world assays, we show that our techniques produce good solutions while being faster than LP.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375590", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ahmed M.", + "last_name": "Amin", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Mithuna", + "last_name": "Thottethodi", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "T. N.", + "last_name": "Vijaykumar", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Steven T.", + "last_name": "Wereley", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Stephen C.", + "last_name": "Jacobson", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/pldi/AminTVWJ08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375610", + "title": "Copy coalescing by graph recoloring", + "abstract": "Register allocation is always a trade-off between live-range splitting and coalescing. Live-range splitting generally leads to less spilling at the cost of inserting shuffle code. Coalescing removes shuffle code while potentially raising the register demand and causing spilling.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375610", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Gerhard", + "last_name": "Goos", + "institution": "Karlsruhe University of Education" + } + ], + "dblp_key": "conf/pldi/HackG08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375588", + "title": "Conditional correlation analysis for safe region-based memory management", + "abstract": "Region-based memory management is a popular scheme in systems software for better organization and performance. In the scheme, a developer constructs a hierarchy of regions of different lifetimes and allocates objects in regions. When the developer deletes a region, the runtime will recursively delete all its subregions and simultaneously reclaim objects in the regions. The developer must construct a consistent placement of objects in regions; otherwise, if a region that contains pointers to other regions is not always deleted before pointees, an inconsistency will surface and cause dangling pointers, which may lead to either crashes or leaks.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375588", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xi", + "last_name": "Wang", + "institution": "Tsinghua University" + }, + { + "first_name": "Zhilei", + "last_name": "Xu", + "institution": "Tsinghua University" + }, + { + "first_name": "Xuezheng", + "last_name": "Liu", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Zhenyu", + "last_name": "Guo", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Xiaoge", + "last_name": "Wang", + "institution": "Tsinghua University" + }, + { + "first_name": "Zheng", + "last_name": "Zhang", + "institution": "Microsoft Research Asia (China)" + } + ], + "dblp_key": "conf/pldi/WangXLGWZ08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375609", + "title": "Register allocation by puzzle solving", + "abstract": "We show that register allocation can be viewed as solving a collection of puzzles. We model the register file as a puzzle board and the program variables as puzzle pieces; pre-coloring and register aliasing fit in naturally. For architectures such as PowerPC, x86, and StrongARM, we can solve the puzzles in polynomial time, and we have augmented the puzzle solver with a simple heuristic for spilling. For SPEC CPU2000, the compilation time of our implementation is as fast as that of the extended version of linear scan used by LLVM, which is the JIT compiler in the openGL stack of Mac OS 10.5. Our implementation produces x86 code that is of similar quality to the code produced by the slower, state-of-the-art iterated register coalescing of George and Appel with the extensions proposed by Smith, Ramsey, and Holloway in 2004.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375609", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/PereiraP08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375600", + "title": "SharC: checking data sharing strategies for multithreaded C", + "abstract": "Unintended or unmediated data sharing is a frequent cause of insidious bugs in multithreaded programs. We present a tool called SharC (short for Sharing Checker) that allows a user to write lightweight annotations to declare how they believe objects are being shared between threads in their program. SharC uses a combination of static and dynamic analyses to check that the program conforms to this specification.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375600", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Anderson", + "institution": "University of California, Berkeley" + }, + { + "first_name": "David", + "last_name": "Gay", + "institution": "Intel (United States)" + }, + { + "first_name": "Rob", + "last_name": "Ennals", + "institution": "Intel (United States)" + }, + { + "first_name": "Eric", + "last_name": "Brewer", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/AndersonGEB08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375591", + "title": "Foundations of the C++ concurrency memory model", + "abstract": "Currently multi-threaded C or C++ programs combine a single-threaded programming language with a separate threads library. This is not entirely sound [7].", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375591", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Sarita V.", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/BoehmA08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375594", + "title": "Iterative optimization in the polyhedral model: part ii, multidimensional time", + "abstract": "High-level loop optimizations are necessary to achieve good performance over a wide variety of processors. Their performance impact can be significant because they involve in-depth program transformations that aim to sustain a balanced workload over the computational, storage, and communication resources of the target architecture. Therefore, it is mandatory that the compiler accurately models the target architecture as well as the effects of complex code restructuring.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375594", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Inria Saclay - Île de France" + }, + { + "first_name": "Cédric", + "last_name": "Bastoul", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Inria Saclay - Île de France" + }, + { + "first_name": "John", + "last_name": "Cavazos", + "institution": "University of Delaware" + } + ], + "dblp_key": "conf/pldi/PouchetBCC08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375620", + "title": "Dataflow analysis for concurrent programs using datarace detection", + "abstract": "Dataflow analyses for concurrent programs differ from their single-threaded counterparts in that they must account for shared memory locations being overwritten by concurrent threads. Existing dataflow analysis techniques for concurrent programs typically fall at either end of a spectrum: at one end, the analysis conservatively kills facts about all data that might possibly be shared by multiple threads; at the other end, a precise thread-interleaving analysis determines which data may be shared, and thus which dataflow facts must be invalidated. The former approach can suffer from imprecision, whereas the latter does not scale.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375620", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of California, San Diego" + }, + { + "first_name": "Jan W.", + "last_name": "Voung", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/ChughVJL08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375595", + "title": "A practical automatic polyhedral parallelizer and locality optimizer", + "abstract": "We present the design and implementation of an automatic polyhedral source-to-source transformation framework that can optimize regular programs (sequences of possibly imperfectly nested loops) for parallelism and locality simultaneously. Through this work, we show the practicality of analytical model-driven automatic transformation in the polyhedral model -- far beyond what is possible by current production compilers. Unlike previous works, our approach is an end-to-end fully automatic one driven by an integer linear optimization framework that takes an explicit view of finding good ways of tiling for parallelism and locality using affine transformations. The framework has been implemented into a tool to automatically generate OpenMP parallel code from C program sections. Experimental results from the tool show very high speedups for local and parallel execution on multi-cores over state-of-the-art compiler frameworks from the research community as well as the best native production compilers. The system also enables the easy use of powerful empirical/iterative optimization for general arbitrarily nested loop sequences.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375595", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Uday", + "last_name": "Bondhugula", + "institution": "The Ohio State University" + }, + { + "first_name": "Albert", + "last_name": "Hartono", + "institution": "The Ohio State University" + }, + { + "first_name": "J.", + "last_name": "Ramanujam", + "institution": "Louisiana State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/BondhugulaHRS08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375615", + "title": "Sound, complete and scalable path-sensitive analysis", + "abstract": "We present a new, precise technique for fully path- and context-sensitive program analysis. Our technique exploits two observations: First, using quantified, recursive formulas, path- and context-sensitive conditions for many program properties can be expressed exactly. To compute a closed form solution to such recursive constraints, we differentiate between observable and unobservable variables, the latter of which are existentially quantified in our approach. Using the insight that unobservable variables can be eliminated outside a certain scope, our technique computes satisfiability-and validity-preserving closed-form solutions to the original recursive constraints. We prove the solution is as precise as the original system for answering may and must queries as well as being small in practice, allowing our technique to scale to the entire Linux kernel, a program with over 6 million lines of code. Copyright © 2008 ACM.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375615", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/DilligDA08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375614", + "title": "Explaining failures of program analyses", + "abstract": "With programs getting larger and often more complex with each new release, programmers need all the help they can get in understanding and transforming programs. Fortunately, modern development environments, such as Eclipse, incorporate tools for understanding, navigating, and transforming programs. These tools typically use program analyses to extract relevant properties of programs.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375614", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel von", + "last_name": "Dincklage", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/pldi/DincklageD08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375625", + "title": "Fair stateless model checking", + "abstract": "Stateless model checking is a useful state-space exploration technique for systematically testing complex real-world software. Existing stateless model checkers are limited to the verification of safety properties on terminating programs. However, realistic concurrent programs are nonterminating, a property that significantly reduces the efficacy of stateless model checking in testing them. Moreover, existing stateless model checkers are unable to verify that a nonterminating program satisfies the important liveness property of livelock-freedom, a property that requires the program to make continuous progress for any input.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375625", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/MusuvathiQ08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375599", + "title": "Sketching concurrent data structures", + "abstract": "We describe PSketch, a program synthesizer that helps programmers implement concurrent data structures. The system is based on the concept of sketching, a form of synthesis that allows programmers to express their insight about an implementation as a partial program: a sketch. The synthesizer automatically completes the sketch to produce an implementation that matches a given correctness criteria.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375599", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Christopher Grant", + "last_name": "Jones", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Berkeley College" + } + ], + "dblp_key": "conf/pldi/Solar-LezamaJB08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375603", + "title": "Certifying low-level programs with hardware interrupts and preemptive threads", + "abstract": "Hardware interrupts are widely used in the world's critical software systems to support preemptive threads, device drivers, operating system kernels, and hypervisors. Handling interrupts properly is an essential component of low-level system programming. Unfortunately, interrupts are also extremely hard to reason about: they dramatically alter the program control flow and complicate the invariants in low-level concurrent code (e.g., implementation of synchronization primitives). Existing formal verification techniques---including Hoare logic, typed assembly language, concurrent separation logic, and the assume-guarantee method---have consistently ignored the issues of interrupts; this severely limits the applicability and power of today's program verification systems.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375603", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Yuan", + "last_name": "Dong", + "institution": "Tsinghua University" + }, + { + "first_name": "Yu", + "last_name": "Guo", + "institution": "University of Science and Technology of China" + } + ], + "dblp_key": "conf/pldi/FengSDG08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375596", + "title": "Orchestrating the execution of stream programs on multicore platforms", + "abstract": "While multicore hardware has become ubiquitous, explicitly parallel programming models and compiler techniques for exploiting parallelism on these systems have noticeably lagged behind. Stream programming is one model that has wide applicability in the multimedia, graphics, and signal processing domains. Streaming models execute as a set of independent actors that explicitly communicate data through channels. This paper presents a compiler technique for planning and orchestrating the execution of streaming applications on multicore platforms. An integrated unfolding and partitioning step based on integer linear programming is presented that unfolds data parallel actors as needed and maximally packs actors onto cores. Next, the actors are assigned to pipeline stages in such a way that all communication is maximally overlapped with computation on the cores. To facilitate experimentation, a generalized code generation template for mapping the software pipeline onto the Cell architecture is presented. For a range of streaming applications, a geometric mean speedup of 14.7x is achieved on a 16-core Cell platform compared to a single core.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375596", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manjunath", + "last_name": "Kudlur", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/KudlurM08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375613", + "title": "Bootstrapping: a technique for scalable flow and context-sensitive pointer alias analysis", + "abstract": "We propose a framework for improving both the scalability as well as the accuracy of pointer alias analysis, irrespective of its flow or context-sensitivities, by leveraging a three-pronged strategy that effectively combines divide and conquer, parallelization and function summarization. A key step in our approach is to first identify small subsets of pointers such that the problem of computing aliases of any pointer can be reduced to computing them in these small subsets instead of the entire program. In order to identify these subsets, we first apply a series of increasingly accurate but highly scalable (context and flow-insensitive) alias analyses in a cascaded fashion such that each analysis Ai works on the subsets generated by the previous one Ai-1. Restricting the application of Ai to subsets generated by Ai-1, instead of the entire program, improves it scalability, i.e., Ai is bootstrapped by Ai-1. Once these small subsets have been computed, in order to make our overall analysis accurate, we employ our new summarization-based flow and context-sensitive alias analysis. The small size of each subset offsets the higher computational complexity of the context-sensitive analysis. An important feature of our framework is that the analysis for each of the subsets can be carried out independently of others thereby allowing us to leverage parallelization further improving scalability.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375613", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vineet", + "last_name": "Kahlon", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/Kahlon08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375618", + "title": "Velodrome: a sound and complete dynamic atomicity checker for multithreaded programs", + "abstract": "Atomicity is a fundamental correctness property in multithreaded programs, both because atomic code blocks are amenable to sequential reasoning (which significantly simplifies correctness arguments), and because atomicity violations often reveal defects in a program's synchronization structure. Unfortunately, all atomicity analyses developed to date are incomplete in that they may yield false alarms on correctly synchronized programs, which limits their usefulness.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375618", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "Williams College" + }, + { + "first_name": "Jaeheon", + "last_name": "Yi", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/pldi/FlanaganFY08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375623", + "title": "Discovering properties about arrays in simple programs", + "abstract": "Array bound checking and array dependency analysis (for parallelization) have been widely studied. However, there are much less results about analyzing properties of array contents. In this paper, we propose a way of using abstract interpretation for discovering properties about array contents in some restricted cases: one-dimensional arrays, traversed by simple \"for\" loops. The basic idea, borrowed from [GRS05], consists in partitioning arrays into symbolic intervals (e.g., [1,i -- 1], [i,i], [i + 1,n]), and in associating with each such interval I and each array A an abstract variable AI; the new idea is to consider relational abstract properties ψ(AI, BI, ...) about these abstract variables, and to interpret such a property pointwise on the interval I: ∀l ∈ I, ψ(A[l], B[l],...). The abstract semantics of our simple programs according to these abstract properties has been defined and implemented in a prototype tool. The method is able, for instance, to discover that the result of an insertion sort is a sorted array, or that, in an array traversal guarded by a \"sentinel\", the index stays within the bounds.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375623", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Halbwachs", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Mathias", + "last_name": "Péron", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/pldi/HalbwachsP08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375619", + "title": "Inferring locks for atomic sections", + "abstract": "Atomic sections are a recent and popular idiom to support the development of concurrent programs. Updates performed within an atomic section should not be visible to other threads until the atomic section has been executed entirely. Traditionally, atomic sections are supported through the use of optimistic concurrency, either using a transactional memory hardware, or an equivalent software emulation (STM).", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375619", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sigmund", + "last_name": "Cherem", + "institution": "Cornell University" + }, + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/CheremCG08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375604", + "title": "Type-preserving compilation for large-scale optimizing object-oriented compilers", + "abstract": "Type-preserving compilers translate well-typed source code, such as Java or C#, into verifiable target code, such as typed assembly language or proof-carrying code. This paper presents the implementation of type-preserving compilation in a complex, large-scale optimizing compiler. Compared to prior work, this implementation supports extensive optimizations, and it verifies a large portion of the interface between the compiler and the runtime system. This paper demonstrates the practicality of type-preserving compilation in complex optimizing compilers: the generated typed assembly language is only 2.3% slower than the base compiler's generated untyped assembly language, and the type-preserving compiler is 82.8% slower than the base compiler.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375604", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Frances", + "last_name": "Perry", + "institution": "Princeton University" + }, + { + "first_name": "Mike", + "last_name": "Emmi", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jeremy", + "last_name": "Condit", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Derrick", + "last_name": "Coetzee", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Polyvios", + "last_name": "Pratikaki", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/ChenHPECCP08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375626", + "title": "Model checking transactional memories", + "abstract": "Model checking software transactional memories (STMs) is difficult because of the unbounded number, length, and delay of concurrent transactions and the unbounded size of the memory. We show that, under certain conditions, the verification problem can be reduced to a finite-state problem, and we illustrate the use of the method by proving the correctness of several STMs, including two-phase locking, DSTM, TL2, and optimistic concurrency control. The safety properties we consider include strict serializability and opacity; the liveness properties include obstruction freedom, livelock freedom, and wait freedom.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375626", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Barbara", + "last_name": "Jobstmann", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Vasu", + "last_name": "Singh", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/GuerraouiHJS08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375606", + "title": "Quantitative information flow as network flow capacity", + "abstract": "Abstract We present a new technique for determining how much informationabout a program&apos;s secret inputs is revealed by its public outputs. In", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375606", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stephen", + "last_name": "McCamant", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/McCamantE08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375616", + "title": "Program analysis as constraint solving", + "abstract": "A constraint-based approach to invariant generation in programs translates a program into constraints that are solved using off-the-shelf constraint solvers to yield desired program invariants.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375616", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Saurabh", + "last_name": "Srivastava", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Ramarathnam", + "last_name": "Venkatesan", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/GulwaniSV08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375587", + "title": "A study of concurrent real-time garbage collectors", + "abstract": "Concurrent garbage collection is highly attractive for real-time systems, because offloading the collection effort from the executing threads allows faster response, allowing for extremely short deadlines at the microseconds level. Concurrent collectors also offer much better scalability over incremental collectors. The main problem with concurrent real-time collectors is their complexity. The first concurrent real-time garbage collector that can support fine synchronization, STOPLESS, has recently been presented by Pizlo et al. In this paper, we propose two additional (and different) algorithms for concurrent real-time garbage collection: CLOVER and CHICKEN. Both collectors obtain reduced complexity over the first collector STOPLESS, but need to trade a benefit for it. We study the algorithmic strengths and weaknesses of CLOVER and CHICKEN and compare them to STOPLESS. Finally, we have implemented all three collectors on the Bartok compiler and runtime for C# and we present measurements to compare their efficiency and responsiveness.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375587", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Filip", + "last_name": "Pizlo", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Bjarne", + "last_name": "Steensgaard", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/PizloPS08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375598", + "title": "Deriving linearizable fine-grained concurrent objects", + "abstract": "Practical and efficient algorithms for concurrent data structures are difficult to construct and modify. Algorithms in the literature are often optimized for a specific setting, making it hard to separate the algorithmic insights from implementation details. The goal of this work is to systematically construct algorithms for a concurrent data structure starting from its sequential implementation. Towards that goal, we follow a construction process that combines manual steps corresponding to high-level insights with automatic exploration of implementation details. To assist us in this process, we built a new tool called Paraglider. The tool quickly explores large spaces of algorithms and uses bounded model checking to check linearizability of algorithms.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375598", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "IBM (United States)" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/VechevY08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375602", + "title": "Liquid types", + "abstract": "We present Logically Qualified Data Types, abbreviated to Liquid Types, a system that combines Hindley-Milner type inference with Predicate Abstraction to automatically infer dependent types precise enough to prove a variety of safety properties. Liquid types allow programmers to reap many of the benefits of dependent types, namely static verification of critical properties and the elimination of expensive run-time checks, without the heavy price of manual annotation. We have implemented liquid type inference in DSOLVE, which takes as input an OCAML program and a set of logical qualifiers and infers dependent types for the expressions in the OCAML program. To demonstrate the utility of our approach, we describe experiments using DSOLVE to statically verify the safety of array accesses on a set of OCAML benchmarks that were previously annotated with dependent types as part of the DML project. We show that when used in conjunction with a fixed set of array bounds checking qualifiers, DSOLVE reduces the amount of manual annotation required for proving safety from 31% of program text to under 1%.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375602", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Patrick M.", + "last_name": "Rondon", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ming", + "last_name": "Kawaguci", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/RondonKJ08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375583", + "title": "Checking race freedom via linear programming", + "abstract": "We present a new static analysis for race freedom and race detection. The analysis checks race freedom by reducing the problem to (rational) linear programming. Unlike conventional static analyses for race freedom or race detection, our analysis avoids explicit computation of locksets and lock linearity/must-aliasness. Our analysis can handle a variety of synchronization idioms that more conventional approaches often have difficulties with, such as thread joining, semaphores, and signals. We achieve efficiency by utilizing modern linear programming solvers that can quickly solve large linear programming instances. This paper reports on the formal properties of the analysis and the experience with applying an implementation to real world C programs.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375583", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/pldi/Terauchi08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375621", + "title": "XMem: type-safe, transparent, shared memory for cross-runtime communication and coordination", + "abstract": "Developers commonly build contemporary enterprise applications using type-safe, component-based platforms, such as J2EE, and architect them to comprise multiple tiers, such as a web container, application server, and database engine. Administrators increasingly execute each tier in its own managed runtime environment (MRE) to improve reliability and to manage system complexity through the fault containment and modularity offered by isolated MRE instances. Such isolation, however, necessitates expensive cross-tier communication based on protocols such as object serialization and remote procedure calls. Administrators commonly co-locate communicating MREs on a single host to reduce communication overhead and to better exploit increasing numbers of available processing cores. However, state-of-the-art MREs offer no support for more efficient communication between co-located MREs, while fast inter-process communication mechanisms, such as shared memory, are widely available as a standard operating system service on most modern platforms.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375621", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michał", + "last_name": "Węgiel", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Chandra", + "last_name": "Krintz", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/pldi/WegielK08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375611", + "title": "Efficient program execution indexing", + "abstract": "Execution indexing uniquely identifies a point in an execution. Desirable execution indices reveal correlations between points in an execution and establish correspondence between points across multiple executions. Therefore, execution indexing is essential for a wide variety of dynamic program analyses, for example, it can be used to organize program profiles; it can precisely identify the point in a re-execution that corresponds to a given point in an original execution and thus facilitate debugging or dynamic instrumentation. In this paper, we formally define the concept of execution index and propose an indexing scheme based on execution structure and program state. We present a highly optimized online implementation of the technique. We also perform a client study, which targets producing a failure inducing schedule for a data race by verifying the two alternative happens-before orderings of a racing pair. Indexing is used to precisely locate corresponding points across multiple executions in the presence of non-determinism so that no heavyweight tracing/replay system is needed.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375611", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bin", + "last_name": "Xin", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "William N.", + "last_name": "Sumner", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/XinSZ08", + "venue": "pldi", + "year": 2008 + }, + { + "paper_id": "10.1145/1375581.1375624", + "title": "Full functional verification of linked data structures", + "abstract": "We present the first verification of full functional correctness for a range of linked data structure implementations, including mutable lists, trees, graphs, and hash tables. Specifically, we present the use of the Jahob verification system to verify formal specifications, written in classical higher-order logic, that completely capture the desired behavior of the Java data structure implementations (with the exception of properties involving execution time and/or memory consumption). Given that the desired correctness properties include intractable constructs such as quantifiers, transitive closure, and lambda abstraction, it is a challenge to successfully prove the generated verification conditions.", + "date": "2008-06-07", + "link": "https://doi.org/10.1145/1375581.1375624", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Karen", + "last_name": "Zee", + "institution": "IIT@MIT" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "IIT@MIT" + } + ], + "dblp_key": "conf/pldi/ZeeKR08", + "venue": "pldi", + "year": 2008 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2009.json b/data/pl_conferences/pldi/2009.json new file mode 100644 index 0000000..75f28b1 --- /dev/null +++ b/data/pl_conferences/pldi/2009.json @@ -0,0 +1,1295 @@ +[ + { + "paper_id": "10.1145/1542476.1542478", + "title": "Dynamic software updates: a VM-centric approach", + "abstract": "Software evolves to fix bugs and add features. Stopping and restarting programs to apply changes is inconvenient and often costly. Dynamic software updating (DSU) addresses this problem by updating programs while they execute, but existing DSU systems for managed languages do not support many updates that occur in practice and are inefficient. This paper presents the design and implementation of Jvolve, a DSU-enhanced Java VM. Updated programs may add, delete, and replace fields and methods anywhere within the class hierarchy. Jvolve implements these updates by adding to and coordinating VM classloading, just-in-time compilation, scheduling, return barriers, on-stack replacement, and garbage collection. Jvolve, is safe: its use of bytecode verification and VM thread synchronization ensures that an update will always produce type-correct executions. Jvolve is flexible: it can support 20 of 22 updates to three open-source programs--Jetty web server, JavaEmailServer, and CrossFTP server--based on actual releases occurring over 1 to 2 years. Jvolve is efficient: performance experiments show that incurs no overhead during steady-state execution. These results demonstrate that this work is a significant step towards practical support for dynamic updates in virtual machines for managed languages.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542478", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Suriya", + "last_name": "Subramanian", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/SubramanianHM09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542516", + "title": "Automatic generation of library bindings using static analysis", + "abstract": "High-level languages are growing in popularity. However, decades of C software development have produced large libraries of fast, time-tested, meritorious code that are impractical to recreate from scratch. Cross-language bindings can expose low-level C code to high-level languages. Unfortunately, writing bindings by hand is tedious and error-prone, while mainstream binding generators require extensive manual annotation or fail to offer the language features that users of modern languages have come to expect.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542516", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tristan", + "last_name": "Ravitch", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Steve T.", + "last_name": "Jackson", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Eric", + "last_name": "Aderhold", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/RavitchJAL09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542489", + "title": "A randomized dynamic program analysis technique for detecting real deadlocks", + "abstract": "We present a novel dynamic analysis technique that finds real deadlocks in multi-threaded programs. Our technique runs in two stages. In the first stage, we use an imprecise dynamic analysis technique to find potential deadlocks in a multi-threaded program by observing an execution of the program. In the second stage, we control a random thread scheduler to create the potential deadlocks with high probability. Unlike other dynamic analysis techniques, our approach has the advantage that it does not give any false warnings. We have implemented the technique in a prototype tool for Java, and have experimented on a number of large multi-threaded Java programs. We report a number of previously known and unknown real deadlocks that were found in these benchmarks.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542489", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pallavi", + "last_name": "Joshi", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Chang‐Seo", + "last_name": "Park", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/JoshiPSN09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542494", + "title": "Stretching transactional memory", + "abstract": "Transactional memory (TM) is an appealing abstraction for programming multi-core systems. Potential target applications for TM, such as business software and video games, are likely to involve complex data structures and large transactions, requiring specific software solutions (STM). So far, however, STMs have been mainly evaluated and optimized for smaller scale benchmarks.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542494", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Dragojević", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Michał", + "last_name": "Kapałka", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/DragojevicGK09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542488", + "title": "Lightweight annotations for controlling sharing in concurrent data structures", + "abstract": "SharC is a recently developed system for checking data-sharing in multithreaded programs. Programmers specify sharing rules (read-only, protected by a lock, etc.) for individual objects, and the SharC compiler enforces these rules using static and dynamic checks. Violations of these rules indicate unintended data sharing, which is the underlying cause of harmful data-races. Additionally, SharC allows programmers to change the sharing rules for a specific object using a sharing cast, to capture the fact that sharing rules for an object often change during the object's lifetime. SharC was successfully applied to a number of multi-threaded C programs.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542488", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zachary R.", + "last_name": "Anderson", + "institution": "University of California, Berkeley" + }, + { + "first_name": "David", + "last_name": "Gay", + "institution": "Intel (United States)" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/AndersonGN09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542508", + "title": "Sharing classes between families", + "abstract": "Class sharing is a new language mechanism for building extensible software systems. Recent work has separately explored two different kinds of extensibility: first, family inheritance, in which an entire family of related classes can be inherited, and second, adaptation, in which existing objects are extended in place with new behavior and state. Class sharing integrates these two kinds of extensibility mechanisms. With little programmer effort, objects of one family can be used as members of another, while preserving relationships among objects. Therefore, a family of classes can be adapted in place with new functionality spanning multiple classes. Object graphs can evolve from one family to another, adding or removing functionality even at run time.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542508", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xin", + "last_name": "Qi", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/QiM09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542479", + "title": "Safe and timely updates to multi-threaded programs", + "abstract": "Many dynamic updating systems have been developed that enable a program to be patched while it runs, to fix bugs or add new features. This paper explores techniques for supporting dynamic updates to multi-threaded programs, focusing on the problem of applying an update in a timely fashion while still producing correct behavior. Past work has shown that this tension of safety versus timeliness can be balanced for single-threaded programs. For multi-threaded programs, the task is more difficult because myriad thread interactions complicate understanding the possible program states to which a patch could be applied. Our approach allows the programmer to specify a few program points (e.g., one per thread) at which a patch may be applied, which simplifies reasoning about safety. To improve timeliness, a combination of static analysis and run-time support automatically expands these few points to many more that produce behavior equivalent to the originals. Experiments with thirteen realistic updates to three multi-threaded servers show that we can safely perform a dynamic update within milliseconds when more straightforward alternatives would delay some updates indefinitely.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542479", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "University of California, Riverside" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/NeamtiuH09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542483", + "title": "Staged information flow for javascript", + "abstract": "Modern websites are powered by JavaScript, a flexible dynamic scripting language that executes in client browsers. A common paradigm in such websites is to include third-party JavaScript code in the form of libraries or advertisements. If this code were malicious, it could read sensitive information from the page or write to the location bar, thus redirecting the user to a malicious page, from which the entire machine could be compromised. We present an information-flow based approach for inferring the effects that a piece of JavaScript has on the website in order to ensure that key security properties are not violated. To handle dynamically loaded and generated JavaScript, we propose a framework for staging information flow properties. Our framework propagates information flow through the currently known code in order to compute a minimal set of syntactic residual checks that are performed on the remaining code when it is dynamically loaded. We have implemented a prototype framework for staging information flow. We describe our techniques for handling some difficult features of JavaScript and evaluate our system's performance on a variety of large real-world websites. Our experiments show that static information flow is feasible and efficient for JavaScript, and that our technique allows the enforcement of information-flow policies with almost no run-time overhead.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542483", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of California, San Diego" + }, + { + "first_name": "Jeffrey A.", + "last_name": "Meister", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/ChughMJL09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542480", + "title": "CEAL: a C-based language for self-adjusting computation", + "abstract": "Self-adjusting computation offers a language-centric approach to writing programs that can automatically respond to modifications to their data (e.g., inputs). Except for several domain-specific implementations, however, all previous implementations of self-adjusting computation assume mostly functional, higher-order languages such as Standard ML. Prior to this work, it was not known if self-adjusting computation can be made to work with low-level, imperative languages such as C without placing undue burden on the programmer.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542480", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Yan", + "last_name": "Chen", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/pldi/HammerAC09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542495", + "title": "Parallelizing sequential applications on commodity hardware using a low-cost software transactional memory", + "abstract": "Multicore designs have emerged as the mainstream design paradigm for the microprocessor industry. Unfortunately, providing multiple cores does not directly translate into performance for most appli-cations. The industry has already fallen short of the decades-old performance trend of doubling performance every 18 months. An attractive approach for exploiting multiple cores is to rely on tools, both compilers and runtime optimizers, to automatically extract threads from sequential applications. However, despite decades of research on automatic parallelization, most techniques are only ef-fective in the scientific and data parallel domains where array dom-inated codes can be precisely analyzed by the compiler. Thread-level speculation offers the opportunity to expand parallelization to general-purpose programs, but at the cost of expensive hard-ware support. In this paper, we focus on providing low-overhead software support for exploiting speculative parallelism. We pro-pose STMlite, a light-weight software transactional memory model that is customized to facilitate profile-guided automatic loop paral-lelization. STMlite eliminates a considerable amount of checking and locking overhead in conventional software transactional mem-ory models by decoupling the commit phase from main transac-tion execution. Further, strong atomicity requirements for generic transactional memories are unnecessary within a stylized automatic parallelization framework. STMlite enables sequential applications to extract meaningful performance gains on commodity multicore hardware.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542495", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mojtaba", + "last_name": "Mehrara", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Jeff", + "last_name": "Hao", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Po‐Chun", + "last_name": "Hsu", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/MehraraHHM09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542520", + "title": "A study of memory management for web-based applications on multicore processors", + "abstract": "More and more server workloads are becoming Web-based. In these Web-based workloads, most of the memory objects are used only during one transaction. We study the effect of the memory management approaches on the performance of such Web-based applications on two modern multicore processors. In particular, using six PHP applications, we compare a general-purpose allocator (the default allocator of the PHP runtime) and a region-based allocator, which can reduce the cost of memory management by not supporting per-object free. The region-based allocator achieves better performance for all workloads on one processor core due to its smaller memory management cost. However, when using eight cores, the region-based allocator suffers from hidden costs of increased bus traffics and the performance is reduced for many workloads by as much as 27.2% compared to the default allocator. This is because the memory bandwidth tends to become a bottleneck in systems with multicore processors.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542520", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hiroshi", + "last_name": "Inoue", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/InoueKN09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542490", + "title": "FastTrack: efficient and precise dynamic race detection", + "abstract": "\\begin{abstract}", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542490", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "Williams College" + } + ], + "dblp_key": "conf/pldi/FlanaganF09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542491", + "title": "LiteRace: effective sampling for lightweight data-race detection", + "abstract": "Data races are one of the most common and subtle causes of pernicious concurrency bugs. Static techniques for preventing data races are overly conservative and do not scale well to large programs. Past research has produced several dynamic data race detectors that can be applied to large programs. They are precise in the sense that they only report actual data races. However, dynamic data race detectors incur a high performance overhead, slowing down a program's execution by an order of magnitude.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542491", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Marino", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/MarinoMN09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542518", + "title": "Control-flow refinement and progress invariants for bound analysis", + "abstract": "Symbolic complexity bounds help programmers understand the performance characteristics of their implementations. Existing work provides techniques for statically determining bounds of procedures with simple control-flow. However, procedures with nested loops or multiple paths through a single loop are challenging.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542518", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sagar", + "last_name": "Jain", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/pldi/GulwaniJK09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542517", + "title": "Snugglebug: a powerful approach to weakest preconditions", + "abstract": "Symbolic analysis shows promise as a foundation for bug-finding, specification inference, verification, and test generation. This paper addresses demand-driven symbolic analysis for object-oriented programs and frameworks. Many such codes comprise large, partial programs with highly dynamic behaviors--polymorphism, reflection, and so on--posing significant scalability challenges for any static analysis.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542517", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "IBM (United States)" + }, + { + "first_name": "Stephen J.", + "last_name": "Fink", + "institution": "IBM (United States)" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/ChandraFS09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542504", + "title": "SoftBound: highly compatible and complete spatial memory safety for c", + "abstract": "The serious bugs and security vulnerabilities facilitated by C/C++'s lack of bounds checking are well known, yet C and C++ remain in widespread use. Unfortunately, C's arbitrary pointer arithmetic, conflation of pointers and arrays, and programmer-visible memory layout make retrofitting C/C++ with spatial safety guarantees extremely challenging. Existing approaches suffer from incompleteness, have high runtime overhead, or require non-trivial changes to the C source code. Thus far, these deficiencies have prevented widespread adoption of such techniques.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542504", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yun", + "last_name": "Zhao", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Milo M. K.", + "last_name": "Martin", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/NagarakatteZMZ09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542525", + "title": "Programming model for a heterogeneous x86 platform", + "abstract": "The client computing platform is moving towards a heterogeneous architecture consisting of a combination of cores focused on scalar performance, and a set of throughput-oriented cores. The throughput oriented cores (e.g. a GPU) may be connected over both coherent and non-coherent interconnects, and have different ISAs. This paper describes a programming model for such heterogeneous platforms. We discuss the language constructs, runtime implementation, and the memory model for such a programming environment. We implemented this programming environment in a x86 heterogeneous platform simulator. We ported a number of workloads to our programming environment, and present the performance of our programming environment on these workloads.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542525", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bratin", + "last_name": "Saha", + "institution": "Intel (United States)" + }, + { + "first_name": "Xiaocheng", + "last_name": "Zhou", + "institution": "" + }, + { + "first_name": "Hu", + "last_name": "Chen", + "institution": "" + }, + { + "first_name": "Ying", + "last_name": "Gao", + "institution": "" + }, + { + "first_name": "Shoumeng", + "last_name": "Yan", + "institution": "" + }, + { + "first_name": "Mohan", + "last_name": "Rajagopalan", + "institution": "Intel (United States)" + }, + { + "first_name": "Jesse", + "last_name": "Fang", + "institution": "Intel (United States)" + }, + { + "first_name": "Peinan", + "last_name": "Zhang", + "institution": "Intel (United States)" + }, + { + "first_name": "Ronny", + "last_name": "Ronen", + "institution": "Israel Electric (Israel)" + }, + { + "first_name": "Avi", + "last_name": "Mendelson", + "institution": "Microsoft (Israel)" + } + ], + "dblp_key": "conf/pldi/SahaZCGYRFZRM09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542493", + "title": "Progress guarantee for parallel programs via bounded lock-freedom", + "abstract": "Parallel platforms are becoming ubiquitous with modern computing systems. Many parallel applications attempt to avoid locks in order to achieve high responsiveness, aid scalability, and avoid deadlocks and livelocks. However, avoiding the use of system locks does not guarantee that no locks are actually used, because progress inhibitors may occur in subtle ways through various program structures. Notions of progress guarantee such as lock-freedom, wait-freedom, and obstruction-freedom have been proposed in the literature to provide various levels of progress guarantees.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542493", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Bjarne", + "last_name": "Steesngaard", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/PetrankMS09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542498", + "title": "A decision procedure for subset constraints over regular languages", + "abstract": "Reasoning about string variables, in particular program inputs, is an important aspect of many program analyses and testing frameworks. Program inputs invariably arrive as strings, and are often manipulated using high-level string operations such as equality checks, regular expression matching, and string concatenation. It is difficult to reason about these operations because they are not well-integrated into current constraint solvers.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542498", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pieter", + "last_name": "Hooimeijer", + "institution": "University of Virginia" + }, + { + "first_name": "Westley", + "last_name": "Weimer", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/pldi/HooimeijerW09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542503", + "title": "GC assertions: using the garbage collector to check heap properties", + "abstract": "This paper introduces GC assertions, a system interface that programmers can use to check for errors, such as data structure invariant violations, and to diagnose performance problems, such as memory leaks. GC assertions are checked by the garbage collector, which is in a unique position to gather information and answer questions about the lifetime and connectivity of objects in the heap. By piggybacking on existing garbage collector computations, our system is able to check heap properties with very low overhead -- around 3% of total execution time -- low enough for use in a deployed setting.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542503", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Edward", + "last_name": "Aftandilian", + "institution": "Tufts University" + }, + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/pldi/AftandilianG09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542526", + "title": "Binary analysis for measurement and attribution of program performance", + "abstract": "Modern programs frequently employ sophisticated modular designs. As a result, performance problems cannot be identified from costs attributed to routines in isolation; understanding code performance requires information about a routine's calling context. Existing performance tools fall short in this respect. Prior strategies for attributing context-sensitive performance at the source level either compromise measurement accuracy, remain too close to the binary, or require custom compilers. To understand the performance of fully optimized modular code, we developed two novel binary analysis techniques: 1) on-the-fly analysis of optimized machine code to enable minimally intrusive and accurate attribution of costs to dynamic calling contexts; and 2) post-mortem analysis of optimized machine code and its debugging sections to recover its program structure and reconstruct a mapping back to its source code. By combining the recovered static program structure with dynamic calling context information, we can accurately attribute performance metrics to calling contexts, procedures, loops, and inlined instances of procedures. We demonstrate that the fusion of this information provides unique insight into the performance of complex modular codes. This work is implemented in the HPCToolkit performance tools (http://hpctoolkit.org).", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542526", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nathan R.", + "last_name": "Tallent", + "institution": "Rice University" + }, + { + "first_name": "John", + "last_name": "Mellor‐Crummey", + "institution": "Rice University" + }, + { + "first_name": "Michael", + "last_name": "Fagan", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/TallentMF09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542484", + "title": "Laminar: practical fine-grained decentralized information flow control", + "abstract": "Decentralized information flow control (DIFC) is a promising model for writing programs with powerful, end-to-end security guarantees. Current DIFC systems that run on commodity hardware can be broadly categorized into two types: language-level and operating system-level DIFC. Language level solutions provide no guarantees against security violations on system resources, like files and sockets. Operating system solutions can mediate accesses to system resources, but are inefficient at monitoring the flow of information through fine-grained program data structures.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542484", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Indrajit", + "last_name": "Roy", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Donald E.", + "last_name": "Porter", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Emmett", + "last_name": "Witchel", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/RoyPBMW09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542510", + "title": "Type-based data structure verification", + "abstract": "We present a refinement type-based approach for the static verification of complex data structure invariants. Our approach is based on the observation that complex data structures are typically fashioned from two elements: recursion (e.g., lists and trees), and maps (e.g., arrays and hash tables). We introduce two novel type-based mechanisms targeted towards these elements: recursive refinements and polymorphic refinements. These mechanisms automate the challenging work of generalizing and instantiating rich universal invariants by piggybacking simple refinement predicates on top of types, and carefully dividing the labor of analysis between the type system and an SMT solver. Further, the mechanisms permit the use of the abstract interpretation framework of liquid type inference to automatically synthesize complex invariants from simple logical qualifiers, thereby almost completely automating the verification. We have implemented our approach in dsolve, which uses liquid types to verify ocaml programs. We present experiments that show that our type-based approach reduces the manual annotation required to verify complex properties like sortedness, balancedness, binary-search-ordering, and acyclicity by more than an order of magnitude.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542510", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ming", + "last_name": "Kawaguchi", + "institution": "University of California, San Diego" + }, + { + "first_name": "Patrick M.", + "last_name": "Rondon", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/KawaguchiRJ09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542527", + "title": "Semantics-aware trace analysis", + "abstract": "As computer systems continue to become more powerful and complex, so do programs. High-level abstractions introduced to deal with complexity in large programs, while simplifying human reasoning, can often obfuscate salient program properties gleaned from automated source-level analysis through subtle (often non-local) interactions. Consequently, understanding the effects of program changes and whether these changes violate intended protocols become difficult to infer. Refactorings, and feature additions, modifications, or removals can introduce hard-to-catch bugs that often go undetected until many revisions later.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542527", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Hoffman", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/HoffmanEJ09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542505", + "title": "Implementation of the memory-safe full ANSI-C compiler", + "abstract": "This paper describes a completely memory-safe compiler for C language programs that is fully compatible with the ANSI C specification.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542505", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yutaka", + "last_name": "Oiwa", + "institution": "National Institute of Advanced Industrial Science and Technology" + } + ], + "dblp_key": "conf/pldi/Oiwa09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542513", + "title": "Proving optimizations correct using parameterized program equivalence", + "abstract": "Translation validation is a technique for checking that, after an optimization has run, the input and output of the optimization are equivalent. Traditionally, translation validation has been used to prove concrete, fully specified programs equivalent. In this paper we present Parameterized Equivalence Checking (PEC), a generalization of translation validation that can prove the equivalence of parameterized programs. A parameterized program is a partially specified program that can represent multiple concrete programs. For example, a parameterized program may contain a section of code whose only known property is that it does not modify certain variables. By proving parameterized programs equivalent, PEC can prove the correctness of transformation rules that represent complex optimizations once and for all, before they are ever run. We implemented our PEC technique in a tool that can establish the equivalence of two parameterized programs. To highlight the power of PEC, we designed a language for implementing complex optimizations using many-to-many rewrite rules, and used this language to implement a variety of optimizations including software pipelining, loop unrolling, loop unswitching, loop interchange, and loop fusion. Finally, to demonstrate the effectiveness of PEC, we used our PEC implementation to verify that all the optimizations we implemented in our language preserve program behavior.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542513", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "S.", + "last_name": "Kundu", + "institution": "University of California, San Diego" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/KunduTL09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542485", + "title": "Merlin: specification inference for explicit information flow problems", + "abstract": "The last several years have seen a proliferation of static and runtime analysis tools for finding security violations that are caused by explicit information flow in programs. Much of this interest has been caused by the increase in the number of vulnerabilities such as cross-site scripting and SQL injection. In fact, these explicit information flow vulnerabilities commonly found in Web applications now outnumber vulnerabilities such as buffer overruns common in type-unsafe languages such as C and C++. Tools checking for these vulnerabilities require a specification to operate. In most cases the task of providing such a specification is delegated to the user. Moreover, the efficacy of these tools is only as good as the specification. Unfortunately, writing a comprehensive specification presents a major challenge: parts of the specification are easy to miss, leading to missed vulnerabilities; similarly, incorrect specifications may lead to false positives.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542485", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/pldi/LivshitsNRB09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542528", + "title": "Trace-based just-in-time type specialization for dynamic languages", + "abstract": "Dynamic languages such as JavaScript are more difficult to compile than statically typed ones. Since no concrete type information is available, traditional compilers need to emit generic code that can handle all possible type combinations at runtime. We present an alternative compilation technique for dynamically-typed languages that identifies frequently executed loop traces at run-time and then generates machine code on the fly that is specialized for the actual dynamic types occurring on each path through the loop. Our method provides cheap inter-procedural type specialization, and an elegant and efficient way of incrementally compiling lazily discovered alternative paths through nested loops. We have implemented a dynamic compiler for JavaScript based on our technique and we have measured speedups of 10x and more for certain benchmark programs.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542528", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Gal", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Brendan", + "last_name": "Eich", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Mike", + "last_name": "Shaver", + "institution": "Mozilla Foundation" + }, + { + "first_name": "David F.", + "last_name": "Anderson", + "institution": "Mozilla Foundation" + }, + { + "first_name": "David", + "last_name": "Mandelin", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Mohammad R.", + "last_name": "Haghighat", + "institution": "Intel (United States)" + }, + { + "first_name": "Blake", + "last_name": "Kaplan", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Graydon", + "last_name": "Hoare", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Boris", + "last_name": "Zbarsky", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Jason", + "last_name": "Orendorff", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Jesse", + "last_name": "Ruderman", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Edwin", + "last_name": "Smith", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Rick", + "last_name": "Reitmaier", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Michael", + "last_name": "Bebenita", + "institution": "University of California, Irvine" + }, + { + "first_name": "Mason", + "last_name": "Chang", + "institution": "University of California, Irvine" + }, + { + "first_name": "Michael", + "last_name": "Franz", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/pldi/GalESAMHKHZORSRBCF09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542481", + "title": "PetaBricks: a language and compiler for algorithmic choice", + "abstract": "It is often impossible to obtain a one-size-fits-all solution for high performance algorithms when considering different choices for data distributions, parallelism, transformations, and blocking. The best solution to these choices is often tightly coupled to different architectures, problem sizes, data, and available system resources. In some cases, completely different algorithms may provide the best performance. Current compiler and programming language techniques are able to change some of these parameters, but today there is no simple way for the programmer to express or the compiler to choose different algorithms to handle different parts of the data. Existing solutions normally can handle only coarse-grained, library level selections or hand coded cutoffs between base cases and recursive cases.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542481", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jason", + "last_name": "Ansel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Cy", + "last_name": "Chan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Yee Lok", + "last_name": "Wong", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Marek", + "last_name": "Olszewski", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Qin", + "last_name": "Zhao", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Alan", + "last_name": "Edelman", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/AnselCWOZEA09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542506", + "title": "Error propagation analysis for file systems", + "abstract": "Unchecked errors are especially pernicious in operating system file management code. Transient or permanent hardware failures are inevitable, and error-management bugs at the file system layer can cause silent, unrecoverable data corruption. We propose an interprocedural static analysis that tracks errors as they propagate through file system code. Our implementation detects overwritten, out-of-scope, and unsaved unchecked errors. Analysis of four widely-used Linux file system implementations (CIFS, ext3, IBM JFS and ReiserFS), a relatively new file system implementation (ext4), and shared virtual file system (VFS) code uncovers 312 error propagation bugs. Our flow- and context-sensitive approach produces more precise results than related techniques while providing better diagnostic information, including possible execution paths that demonstrate each bug found.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542506", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cindy", + "last_name": "Rubio-González", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Haryadi S.", + "last_name": "Gunawi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Remzi H.", + "last_name": "Arpaci-Dusseau", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Andrea C.", + "last_name": "Arpaci-Dusseau", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/Rubio-GonzalezGLAA09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542521", + "title": "Efficiently and precisely locating memory leaks and bloat", + "abstract": "Inefficient use of memory, including leaks and bloat, remain a significant challenge for C and C++ developers. Applications with these problems become slower over time as their working set grows and can become unresponsive. At the same time, memory leaks and bloat remain notoriously difficult to debug, and comprise a large number of reported bugs in mature applications. Previous tools for diagnosing memory inefficiencies-based on garbage collection, binary rewriting, or code sampling-impose high overheads (up to 100X) or generate many false alarms.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542521", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gene", + "last_name": "Novark", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/NovarkBZ09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542501", + "title": "Program verification using templates over predicate abstraction", + "abstract": "We address the problem of automatically generating invariants with quantified and boolean structure for proving the validity of given assertions or generating pre-conditions under which the assertions are valid. We present three novel algorithms, having different strengths, that combine template and predicate abstraction based formalisms to discover required sophisticated program invariants using SMT solvers.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542501", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Saurabh", + "last_name": "Srivastava", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/SrivastavaG09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542509", + "title": "Typed self-representation", + "abstract": "Self-representation -- the ability to represent programs in their own language -- has important applications in reflective languages and many other domains of programming language design. Although approaches to designing typed program representations for sublanguages of some base language have become quite popular recently, the question whether a fully metacircular typed self-representation is possible is still open. This paper makes a big step towards this aim by defining the Fω* calculus, an extension of the higher-order polymorphic lambda calculus Fω that allows typed self-representations. While the usability of these representations for metaprogramming is still limited, we believe that our approach makes a significant step towards a new generation of reflective languages that are both safe and efficient.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542509", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tillmann", + "last_name": "Rendel", + "institution": "Aarhus University" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Aarhus University" + }, + { + "first_name": "Christian", + "last_name": "Hofer", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/pldi/RendelOH09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542499", + "title": "Verifiable composition of deterministic grammars", + "abstract": "There is an increasing interest in extensible languages,", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542499", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "August", + "last_name": "Schwerdfeger", + "institution": "University of Minnesota" + }, + { + "first_name": "Eric R. Van", + "last_name": "Wyk", + "institution": "University of Minnesota" + } + ], + "dblp_key": "conf/pldi/SchwerdfegerW09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542523", + "title": "Go with the flow: profiling copies to find runtime bloat", + "abstract": "Many large-scale Java applications suffer from runtime bloat. They execute large volumes of methods, and create many temporary objects, all to execute relatively simple operations. There are large opportunities for performance optimizations in these applications, but most are being missed by existing optimization and tooling technology. While JIT optimizations struggle for a few percent, performance experts analyze deployed applications and regularly find gains of 2x or more.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542523", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "The Ohio State University" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Nick", + "last_name": "Mitchell", + "institution": "IBM (United States)" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + }, + { + "first_name": "Gary", + "last_name": "Sevitsky", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/XuAMRS09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542514", + "title": "An integrated proof language for imperative programs", + "abstract": "We present an integrated proof language for guiding the actions of multiple reasoning systems as they work together to prove complex correctness properties of imperative programs. The language operates in the context of a program verification system that uses multiple reasoning systems to discharge generated proof obligations. It is designed to 1) enable developers to resolve key choice points in complex program correctness proofs, thereby enabling automated reasoning systems to successfully prove the desired correctness properties; 2) allow developers to identify key lemmas for the reasoning systems to prove, thereby guiding the reasoning systems to find an effective proof decomposition; 3) enable multiple reasoning systems to work together productively to prove a single correctness property by providing a mechanism that developers can use to divide the property into lemmas, each of which is suitable for a different reasoning system; and 4) enable developers to identify specific lemmas that the reasoning systems should use when attempting to prove other lemmas or correctness properties, thereby appropriately confining the search space so that the reasoning systems can find a proof in an acceptable amount of time.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542514", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Karen", + "last_name": "Zee", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ZeeKR09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542496", + "title": "Towards a holistic approach to auto-parallelization: integrating profile-driven parallelism detection and machine-learning based mapping", + "abstract": "Compiler-based auto-parallelization is a much studied area, yet has still not found wide-spread application. This is largely due to the poor exploitation of application parallelism, subsequently resulting in performance levels far below those which a skilled expert programmer could achieve. We have identified two weaknesses in traditional parallelizing compilers and propose a novel, integrated approach, resulting in significant performance improvements of the generated parallel code. Using profile-driven parallelism detection we overcome the limitations of static analysis, enabling us to identify more application parallelism and only rely on the user for final approval. In addition, we replace the traditional target-specific and inflexible mapping heuristics with a machine-learning based prediction mechanism, resulting in better mapping decisions while providing more scope for adaptation to different target architectures. We have evaluated our parallelization strategy against the NAS and SPEC OMP benchmarks and two different multi-core platforms (dual quad-core Intel Xeon SMP and dual-socket QS20 Cell blade). We demonstrate that our approach not only yields significant improvements when compared with state-of-the-art parallelizing compilers, but comes close to and sometimes exceeds the performance of manually parallelized codes. On average, our methodology achieves 96% of the performance of the hand-tuned OpenMP NAS and SPEC parallel benchmarks on the Intel Xeon platform and gains a significant speedup for the IBM Cell platform, demonstrating the potential of profile-guided and machine-learning based parallelization for complex multi-core platforms.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542496", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Georgios", + "last_name": "Tournavitis", + "institution": "University of Edinburgh" + }, + { + "first_name": "Zheng", + "last_name": "Wang", + "institution": "University of Edinburgh" + }, + { + "first_name": "Björn", + "last_name": "Franke", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/TournavitisWFO09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542512", + "title": "Verified validation of lazy code motion", + "abstract": "Translation validation establishes a posteriori the correctness of a run of a compilation pass or other program transformation. In this paper, we develop an efficient translation validation algorithm for the Lazy Code Motion (LCM) optimization. LCM is an interesting challenge for validation because it is a global optimization that moves code across loops. Consequently, care must be taken not to move computations that may fail before loops that may not terminate. Our validator includes a specific check for anticipability to rule out such incorrect moves. We present a mechanically-checked proof of correctness of the validation algorithm, using the Coq proof assistant. Combining our validator with an unverified implementation of LCM, we obtain a LCM pass that is provably semantics-preserving and was integrated in the CompCert formally verified compiler.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542512", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jean-Baptiste", + "last_name": "Tristan", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/TristanL09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542522", + "title": "Chameleon: adaptive selection of collections", + "abstract": "Languages such as Java and C#, as well as scripting languages like Python, and Ruby, make extensive use of Collection classes. A collection implementation represents a fixed choice in the dimensions of operation time, space utilization, and synchronization. Using the collection in a manner not consistent with this fixed choice can cause significant performance degradation. In this paper, we present CHAMELEON, a low-overhead automatic tool that assists the programmer in choosing the appropriate collection implementation for her application. During program execution, CHAMELEON computes elaborate trace and heap-based metrics on collection behavior. These metrics are consumed on-thefly by a rules engine which outputs a list of suggested collection adaptation strategies. The tool can apply these corrective strategies automatically or present them to the programmer. We have implemented CHAMELEON on top of a IBM's J9 production JVM, and evaluated it over a small set of benchmarks. We show that for some applications, using CHAMELEON leads to a significant improvement of the memory footprint of the application.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542522", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ohad", + "last_name": "Shacham", + "institution": "Tel Aviv University" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "IBM (United States)" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/ShachamVY09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542486", + "title": "TAJ: effective taint analysis of web applications", + "abstract": "Taint analysis, a form of information-flow analysis, establishes whether values from untrusted methods and parameters may flow into security-sensitive operations. Taint analysis can detect many common vulnerabilities in Web applications, and so has attracted much attention from both the research community and industry. However, most static taint-analysis tools do not address critical requirements for an industrial-strength tool. Specifically, an industrial-strength tool must scale to large industrial Web applications, model essential Web-application code artifacts, and generate consumable reports for a wide range of attack vectors.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542486", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "IBM (United States)" + }, + { + "first_name": "Marco", + "last_name": "Pistoia", + "institution": "IBM (United States)" + }, + { + "first_name": "Stephen J.", + "last_name": "Fink", + "institution": "IBM (United States)" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "IBM (United States)" + }, + { + "first_name": "Omri", + "last_name": "Weisman", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/TrippPFSW09", + "venue": "pldi", + "year": 2009 + }, + { + "paper_id": "10.1145/1542476.1542500", + "title": "Analyzing recursive programs using a fixed-point calculus", + "abstract": "We show that recursive programs where variables range over finite domains can be effectively and efficiently analyzed by describing the analysis algorithm using a formula in a fixed-point calculus. In contrast with programming in traditional languages, a fixed-point calculus serves as a high-level programming language to easily, correctly, and succinctly describe model-checking algorithms While there have been declarative high-level formalisms that have been proposed earlier for analysis problems (e.g., Datalog the fixed-point calculus we propose has the salient feature that it also allows algorithmic aspects to be specified.", + "date": "2009-06-15", + "link": "https://doi.org/10.1145/1542476.1542500", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Salvatore La", + "last_name": "Torre", + "institution": "University of Salerno" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gennaro", + "last_name": "Parlato", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/TorreMP09", + "venue": "pldi", + "year": 2009 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2010.json b/data/pl_conferences/pldi/2010.json new file mode 100644 index 0000000..5fb20b5 --- /dev/null +++ b/data/pl_conferences/pldi/2010.json @@ -0,0 +1,1268 @@ +[ + { + "paper_id": "10.1145/1806596.1806603", + "title": "Safe programmable speculative parallelism", + "abstract": "Execution order constraints imposed by dependences can serialize computation, preventing parallelization of code and algorithms. Speculating on the value(s) carried by dependences is one way to break such critical dependences. Value speculation has been used effectively at a low level, by compilers and hardware. In this paper, we focus on the use of speculation by programmers as an algorithmic paradigm to parallelize seemingly sequential code.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806603", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Prakash", + "last_name": "Prabhu", + "institution": "Princeton University" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Kapil", + "last_name": "Vaswani", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/pldi/PrabhuRV10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806631", + "title": "Resolving and exploiting the k-CFA paradox: illuminating functional vs. object-oriented program analysis", + "abstract": "Low-level program analysis is a fundamental problem, taking the shape of \"flow analysis\" in functional languages and \"points-to\" analysis in imperative and object-oriented languages. Despite the similarities, the vocabulary and results in the two communities remain largely distinct, with limited cross-understanding. One of the few links is Shivers's k-CFA work, which has advanced the concept of \"context-sensitive analysis\" and is widely known in both communities.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806631", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/MightSH10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806647", + "title": "Evaluating iterative optimization across 1000 datasets", + "abstract": "While iterative optimization has become a popular compiler optimization approach, it is based on a premise which has never been truly evaluated: that it is possible to learn the best compiler optimizations across data sets. Up to now, most iterative optimization studies find the best optimizations through repeated runs on the same data set. Only a handful of studies have attempted to exercise iterative optimization on a few tens of data sets.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806647", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chen", + "last_name": "Yang", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Yuanjie", + "last_name": "Huang", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University" + }, + { + "first_name": "Grigori", + "last_name": "Fursin", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Liang", + "last_name": "Peng", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Olivier", + "last_name": "Temam", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Chengyong", + "last_name": "Wu", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "conf/pldi/ChenHEFPTW10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806623", + "title": "Printing floating-point numbers quickly and accurately with integers", + "abstract": "We present algorithms for accurately converting floating-point numbers to decimal representation. They are fast (up to 4 times faster than commonly used algorithms that use high-precision integers) and correct: any printed number will evaluate to the same number, when read again.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806623", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Florian", + "last_name": "Loitsch", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/Loitsch10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806634", + "title": "Line-up: a complete and automatic linearizability checker", + "abstract": "Modular development of concurrent applications requires thread-safe components that behave correctly when called concurrently by multiple client threads. This paper focuses on linearizability, a specific formalization of thread safety, where all operations of a concurrent component appear to take effect instantaneously at some point between their call and return. The key insight of this paper is that if a component is intended to be deterministic, then it is possible to build an automatic linearizability checker by systematically enumerating the sequential behaviors of the component and then checking if each its concurrent behavior is equivalent to some sequential behavior.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806634", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Chris", + "last_name": "Dern", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Roy Patrick", + "last_name": "Tan", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/BurckhardtDMT10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806627", + "title": "Lock elision for read-only critical sections in Java", + "abstract": "It is not uncommon in parallel workloads to encounter shared data structures with read-mostly access patterns, where operations that update data are infrequent and most operations are read-only. Typically, data consistency is guaranteed using mutual exclusion or read-write locks. The cost of atomic update of lock variables result in high overheads and high cache coherence traffic under active sharing, thus slowing down single thread performance and limiting scalability.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806627", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Takuya", + "last_name": "Nakaike", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Maged M.", + "last_name": "Michael", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/NakaikeM10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806605", + "title": "Cache topology aware computation mapping for multicores", + "abstract": "The main contribution of this paper is a compiler based, cache topology aware code optimization scheme for emerging multicore systems. This scheme distributes the iterations of a loop to be executed in parallel across the cores of a target multicore machine and schedules the iterations assigned to each core. Our goal is to improve the utilization of the on-chip multi-layer cache hierarchy and to maximize overall application performance. We evaluate our cache topology aware approach using a set of twelve applications and three different commercial multicore machines. In addition, to study some of our experimental parameters in detail and to explore future multicore machines (with higher core counts and deeper on-chip cache hierarchies), we also conduct a simulation based study. The results collected from our experiments with three Intel multicore machines show that the proposed compiler-based approach is very effective in enhancing performance. In addition, our simulation results indicate that optimizing for the on-chip cache hierarchy will be even more important in future multicores with increasing numbers of cores and cache levels.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806605", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Taylan", + "last_name": "Yemliha", + "institution": "Syracuse University" + }, + { + "first_name": "SaiPrashanth", + "last_name": "Muralidhara", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Shekhar", + "last_name": "Srikantaiah", + "institution": "Pennsylvania State University" + }, + { + "first_name": "M.J.", + "last_name": "Irwin", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Yuanrui", + "last_name": "Zhnag", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/pldi/KandemirYMSIZ10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806620", + "title": "Green: a framework for supporting energy-conscious programming using controlled approximation", + "abstract": "Energy-efficient computing is important in several systems ranging from embedded devices to large scale data centers. Several application domains offer the opportunity to tradeoff quality of service/solution (QoS) for improvements in performance and reduction in energy consumption. Programmers sometimes take advantage of such opportunities, albeit in an ad-hoc manner and often without providing any QoS guarantees.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806620", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Woongki", + "last_name": "Baek", + "institution": "Stanford University" + }, + { + "first_name": "Trishul", + "last_name": "Chilimbi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/BaekC10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806638", + "title": "FlumeJava: easy, efficient data-parallel pipelines", + "abstract": "MapReduce and similar systems significantly ease the task of writing data-parallel code. However, many real-world computations require a pipeline of MapReduces, and programming and managing such pipelines can be difficult. We present FlumeJava, a Java library that makes it easy to develop, test, and run efficient data-parallel pipelines. At the core of the FlumeJava library are a couple of classes that represent immutable parallel collections, each supporting a modest number of operations for processing them in parallel. Parallel collections and their operations present a simple, high-level, uniform abstraction over different data representations and execution strategies. To enable parallel operations to run efficiently, FlumeJava defers their evaluation, instead internally constructing an execution plan dataflow graph. When the final results of the parallel operations are eventually needed, FlumeJava first optimizes the execution plan, and then executes the optimized operations on appropriate underlying primitives (e.g., MapReduces). The combination of high-level abstractions for parallel data and computation, deferred evaluation and optimization, and efficient parallel primitives yields an easy-to-use system that approaches the efficiency of hand-optimized pipelines. FlumeJava is in active use by hundreds of pipeline developers within Google.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806638", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "Google (United States)" + }, + { + "first_name": "Ashish", + "last_name": "Raniwala", + "institution": "Google (United States)" + }, + { + "first_name": "Frances", + "last_name": "Perry", + "institution": "Google (United States)" + }, + { + "first_name": "Stephen", + "last_name": "Adams", + "institution": "Google (United States)" + }, + { + "first_name": "Robert R.", + "last_name": "Henry", + "institution": "Google (United States)" + }, + { + "first_name": "Robert", + "last_name": "Bradshaw", + "institution": "Google (United States)" + }, + { + "first_name": "Nathan", + "last_name": "Weizenbaum", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/pldi/ChambersRPAHBW10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806599", + "title": "Breadcrumbs: efficient context sensitivity for dynamic bug detection analyses", + "abstract": "Calling context--the set of active methods on the stack--is critical for understanding the dynamic behavior of large programs. Dynamic program analysis tools, however, are almost exclusively context insensitive because of the prohibitive cost of representing calling contexts at run time. Deployable dynamic analyses, in particular, have been limited to reporting only static program locations.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806599", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Graham Z.", + "last_name": "Baker", + "institution": "MIT Lincoln Laboratory" + }, + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/pldi/BondBG10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806611", + "title": "Bringing extensibility to verified compilers", + "abstract": "Verified compilers, such as Leroy's CompCert, are accompanied by a fully checked correctness proof. Both the compiler and proof are often constructed with an interactive proof assistant. This technique provides a strong, end-to-end correctness guarantee on top of a small trusted computing base. Unfortunately, these compilers are also challenging to extend since each additional transformation must be proven correct in full formal detail.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806611", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/TatlockL10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806644", + "title": "Inferable object-oriented typed assembly language", + "abstract": "A certifying compiler preserves type information through compilation to assembly language programs, producing typed assembly language (TAL) programs that can be verified for safety independently so that the compiler does not need to be trusted. There are two challenges for adopting certifying compilation in practice. First, requiring every compiler transformation and optimization to preserve types is a large burden on compilers, especially when adopting certifying compilation into existing optimizing non-certifying compilers. Second, type annotations significantly increase the size of assembly language programs.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806644", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "University of California, San Diego" + }, + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/TateCH10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806601", + "title": "Jinn: synthesizing dynamic bug detectors for foreign language interfaces", + "abstract": "Programming language specifications mandate static and dynamic analyses to preclude syntactic and semantic errors. Although individual languages are usually well-specified, composing languages is not, and this poor specification is a source of many errors in multilingual programs. For example, virtually all Java programs compose Java and C using the Java Native Interface (JNI). Since JNI is informally specified, developers have difficulty using it correctly, and current Java compilers and virtual machines (VMs) inconsistently check only a subset of JNI constraints.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806601", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Byeongcheol", + "last_name": "Lee", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ben", + "last_name": "Wiedermann", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "IBM (United States)" + }, + { + "first_name": "Robert", + "last_name": "Grimm", + "institution": "New York University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/LeeWHGM10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806612", + "title": "Ur: statically-typed metaprogramming with type-level record computation", + "abstract": "Dependent types provide a strong foundation for specifying and verifying rich properties of programs through type-checking. The earliest implementations combined dependency, which allows types to mention program variables; with type-level computation, which facilitates expressive specifications that compute with recursive functions over types. While many recent applications of dependent types omit the latter facility, we argue in this paper that it deserves more attention, even when implemented without dependency.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806612", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Chlipala10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806621", + "title": "GUESSTIMATE: a programming model for collaborative distributed systems", + "abstract": "We present a new programming model GUEESSTIMATE for developing collaborative distributed systems. The model allows atomic, isolated operations that transform a system from consistent state to consistent state, and provides a shared transactional store for a collection of such operations executed by various machines in a distributed system. In addition to \"committed state\" which is identical in all machines in the distributed system, GUESSTIMATE allows each machine to have a replicated local copy of the state (called \"guesstimated state\") so that operations on shared state can be executed locally without any blocking, while also guaranteeing that eventually all machines agree on the sequences of operations executed. Thus, each operation is executed multiple times, once at the time of issue when it updates the guesstimated state of the issuing machine, once when the operation is committed (atomically) to the committed state of all machines, and several times in between as the guesstimated state converges toward the committed state. While we expect the results of these executions of the operation to be identical most of the time in the class of applications we study, it is possible for an operation to succeed the first time when it is executed on the guesstimated state, and fail when it is committed. GUESSTIMATE provides facilities that allow the programmer to deal with this potential discrepancy. This paper presents our programming model, its operational semantics, its realization as an API in C#, and our experience building collaborative distributed applications with this model.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806621", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kaushik Sunder", + "last_name": "Rajan", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Shashank", + "last_name": "Yaduvanshi", + "institution": "Indian Institute of Technology Delhi" + } + ], + "dblp_key": "conf/pldi/RajanRY10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806618", + "title": "Evaluating the accuracy of Java profilers", + "abstract": "Performance analysts profile their programs to find methods that are worth optimizing: the \"hot\" methods. This paper shows that four commonly-used Java profilers (xprof , hprof , jprofile, and yourkit) often disagree on the identity of the hot methods. If two profilers disagree, at least one must be incorrect. Thus, there is a good chance that a profiler will mislead a performance analyst into wasting time optimizing a cold method with little or no performance improvement.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806618", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Matthias", + "last_name": "Hauswirth", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Peter F.", + "last_name": "Sweeney", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/MytkowiczDHS10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806645", + "title": "Mixing type checking and symbolic execution", + "abstract": "Static analysis designers must carefully balance precision and efficiency. In our experience, many static analysis tools are built around an elegant, core algorithm, but that algorithm is then extensively tweaked to add just enough precision for the coding idioms seen in practice, without sacrificing too much efficiency. There are several downsides to adding precision in this way: the tool's implementation becomes much more complicated; it can be hard for an end-user to interpret the tool's results; and as software systems vary tremendously in their coding styles, it may require significant algorithmic engineering to enhance a tool to perform well in a particular software domain.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806645", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yit Phang", + "last_name": "Khoo", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/KhooCF10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806608", + "title": "2010 Athena lecture", + "abstract": "Susan Eggers, a Professor of Computer Science and Engineering at the University of Washington, joined her department in 1989. She received a B.A. in 1965 from Connecticut College and a Ph.D. in 1989 from the University of California, Berkeley. Her research interests are in computer architecture and back-end compiler optimization, with an emphasis on experimental performance analysis. With her colleague Hank Levy and their students, she developed the first commercially viable multithreaded architecture, Simultaneous Multithreading, adopted by Intel (as Hyperthreading), IBM, Sun and others. Her current research is in the areas of distributed dataflow machines, FPGAs and chip multiprocessors. In 1989 Professor Eggers was awarded an IBM Faculty Development Award, in 1990 an NSF Presidential Young Investigator Award, in 1994 the Microsoft Professorship in Computer Science and Engineering, and in 2009 the ACM-W Athena Lecturer. She is a Fellow of the ACM and IEEE, a Fellow of the AAAS, and a member of the National Academy of Engineering.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806608", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Susan J.", + "last_name": "Eggers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/Eggers10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806626", + "title": "PACER: proportional detection of data races", + "abstract": "Data races indicate serious concurrency bugs such as order, atomicity, and sequential consistency violations. Races are difficult to find and fix, often manifesting only after deployment. The frequency and unpredictability of these bugs will only increase as software adds parallelism to exploit multicore hardware. Unfortunately, sound and precise race detectors slow programs by factors of eight or more and do not scale to large numbers of threads.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806626", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Katherine E.", + "last_name": "Coons", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/BondCM10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806625", + "title": "Adversarial memory for detecting destructive races", + "abstract": "Multithreaded programs are notoriously prone to race conditions, a problem exacerbated by the widespread adoption of multi-core processors with complex memory models and cache coherence protocols. Much prior work has focused on static and dynamic analyses for race detection, but these algorithms typically are unable to distinguish destructive races that cause erroneous behavior from benign races that do not. Performing this classification manually is difficult, time consuming, and error prone.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806625", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "Williams College" + } + ], + "dblp_key": "conf/pldi/FlanaganF10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806613", + "title": "Parameterized verification of transactional memories", + "abstract": "We describe an automatic verification method to check whether transactional memories ensure strict serializability a key property assumed of the transactional interface. Our main contribution is a technique for effectively verifying parameterized systems. The technique merges ideas from parameterized hardware and protocol verification--verification by invisible invariants and symmetry reduction--with ideas from software verification--template-based invariant generation and satisfiability checking for quantified formulæ (modulo theories). The combination enables us to precisely model and analyze unbounded systems while taming state explosion.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806613", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Roman", + "last_name": "Manevich", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/EmmiMM10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806639", + "title": "Composing parallel software efficiently with lithe", + "abstract": "Applications composed of multiple parallel libraries perform poorly when those libraries interfere with one another by obliviously using the same physical cores, leading to destructive resource oversubscription. This paper presents the design and implementation of Lithe, a low-level substrate that provides the basic primitives and a standard interface for composing parallel codes efficiently. Lithe can be inserted underneath the runtimes of legacy parallel libraries to provide bolt-on composability without needing to change existing application code. Lithe can also serve as the foundation for building new parallel abstractions and libraries that automatically interoperate with one another.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806639", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Heidi", + "last_name": "Pan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Benjamin", + "last_name": "Hindman", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Krste", + "last_name": "Asanović", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/PanHA10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806636", + "title": "DRFX: a simple and efficient memory model for concurrent programming languages", + "abstract": "The most intuitive memory model for shared-memory multithreaded programming is sequential consistency(SC), but it disallows the use of many compiler and hardware optimizations thereby impacting performance. Data-race-free (DRF) models, such as the proposed C++0x memory model, guarantee SC execution for datarace-free programs. But these models provide no guarantee at all for racy programs, compromising the safety and debuggability of such programs. To address the safety issue, the Java memory model, which is also based on the DRF model, provides a weak semantics for racy executions. However, this semantics is subtle and complex, making it difficult for programmers to reason about their programs and for compiler writers to ensure the correctness of compiler optimizations.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806636", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Marino", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Abhayendra", + "last_name": "Singh", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/MarinoSMMN10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806648", + "title": "Software data spreading: leveraging distributed caches to improve single thread performance", + "abstract": "Single thread performance remains an important consideration even for multicore, multiprocessor systems. As a result, techniques for improving single thread performance using multiple cores have received considerable attention. This work describes a technique, software data spreading, that leverages the cache capacity of extra cores and extra sockets rather than their computational resources. Software data spreading is a software-only technique that uses compiler-directed thread migration to aggregate cache capacity across cores and chips and improve performance. This paper describes an automated scheme that applies data spreading to various types of loops. Experiments with a set of SPEC2000, SPEC2006, NAS, and microbenchmark workloads show that data spreading can provide speedup of over 2, averaging 17% for the SPEC and NAS applications on two systems. In addition, despite using more cores for the same computation, data spreading actually saves power since it reduces access to DRAM.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806648", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Md", + "last_name": "Kamruzzaman", + "institution": "University of California, San Diego" + }, + { + "first_name": "Steven", + "last_name": "Swanson", + "institution": "University of California, San Diego" + }, + { + "first_name": "Dean M.", + "last_name": "Tullsen", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/KamruzzamanST10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806650", + "title": "Traceable data types for self-adjusting computation", + "abstract": "Self-adjusting computation provides an evaluation model where computations can respond automatically to modifications to their data by using a mechanism for propagating modifications through the computation. Current approaches to self-adjusting computation guarantee correctness by recording dependencies in a trace at the granularity of individual memory operations. Tracing at the granularity of memory operations, however, has some limitations: it can be asymptotically inefficient (\\eg, compared to optimal solutions) because it cannot take advantage of problem-specific structure, it requires keeping a large computation trace (often proportional to the runtime of the program on the current input), and it introduces moderately large constant factors in practice.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806650", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ruy", + "last_name": "Ley-Wild", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kanat", + "last_name": "Tangwongsan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Duru", + "last_name": "Türkoğlu", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/pldi/AcarBLTT10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806632", + "title": "Complete functional synthesis", + "abstract": "Synthesis of program fragments from specifications can make programs easier to write and easier to reason about. To integrate synthesis into programming languages, synthesis algorithms should behave in a predictable way - they should succeed for a well-defined class of specifications. They should also support unbounded data types such as numbers and data structures. We propose to generalize decision procedures into predictable and complete synthesis procedures. Such procedures are guaranteed to find code that satisfies the specification if such code exists. Moreover, we identify conditions under which synthesis will statically decide whether the solution is guaranteed to exist, and whether it is unique. We demonstrate our approach by starting from decision procedures for linear arithmetic and data structures and transforming them into synthesis procedures. We establish results on the size and the efficiency of the synthesized code. We show that such procedures are useful as a language extension with implicit value definitions, and we show how to extend a compiler to support such definitions. Our constructs provide the benefits of synthesis to programmers, without requiring them to learn new concepts or give up a deterministic execution model.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806632", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Mikaël", + "last_name": "Mayer", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Philippe", + "last_name": "Suter", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/KuncakMPS10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806600", + "title": "Decoupled lifeguards: enabling path optimizations for dynamic correctness checking tools", + "abstract": "Dynamic correctness checking tools (a.k.a. lifeguards) can detect a wide array of correctness issues, such as memory, security, and concurrency misbehavior, in unmodified executables at run time. However, lifeguards that are implemented using dynamic binary instrumentation (DBI) often slow down the monitored application by 10-50X, while proposals that replace DBI with hardware still see 3-8X slowdowns. The remaining overhead is the cost of performing the lifeguard analysis itself. In this paper, we explore compiler optimization techniques to reduce this overhead.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806600", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Olatunji", + "last_name": "Ruwase", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Shimin", + "last_name": "Chen", + "institution": "Intel (United States)" + }, + { + "first_name": "Phillip B.", + "last_name": "Gibbons", + "institution": "Intel (United States)" + }, + { + "first_name": "Todd C.", + "last_name": "Mowry", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/RuwaseCGM10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806630", + "title": "The reachability-bound problem", + "abstract": "We define the reachability-bound problem to be the problem of finding a symbolic worst-case bound on the number of times a given control location inside a procedure is visited in terms of the inputs to that procedure. This has applications in bounding resources consumed by a program such as time, memory, network-traffic, power, as well as estimating quantitative properties (as opposed to boolean properties) of data in programs, such as information leakage or uncertainty propagation. Our approach to solving the reachability-bound problem brings together two different techniques for reasoning about loops in an effective manner. One of these techniques is an abstract-interpretation based iterative technique for computing precise disjunctive invariants (to summarize nested loops). The other technique is a non-iterative proof-rules based technique (for loop bound computation) that takes over the role of doing inductive reasoning, while deriving its power from the use of SMT solvers to reason about abstract loop-free fragments.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806630", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Florian", + "last_name": "Zuleger", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/pldi/GulwaniZ10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806629", + "title": "Smooth interpretation", + "abstract": "We present smooth interpretation, a method to systematically approximate numerical imperative programs by smooth mathematical functions. This approximation facilitates the use of numerical search techniques like gradient descent for program analysis and synthesis. The method extends to programs the notion of Gaussian smoothing, a popular signal-processing technique that filters out noise and discontinuities from a signal by taking its convolution with a Gaussian function.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806629", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "IIT@MIT" + } + ], + "dblp_key": "conf/pldi/ChaudhuriS10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806643", + "title": "Type-preserving compilation of end-to-end verification of security enforcement", + "abstract": "A number of programming languages use rich type systems to verify security properties of code. Some of these languages are meant for source programming, but programs written in these languages are compiled without explicit security proofs, limiting their utility in settings where proofs are necessary, e.g., proof-carrying authorization. Others languages do include explicit proofs, but these are generally lambda calculi not intended for source programming, that must be further compiled to an executable form. A language suitable for source programming backed by a compiler that enables end-to-end verification is missing.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806643", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of California, San Diego" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/ChenCS10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806617", + "title": "Finding low-utility data structures", + "abstract": "Many opportunities for easy, big-win, program optimizations are missed by compilers. This is especially true in highly layered Java applications. Often at the heart of these missed optimization opportunities lie computations that, with great expense, produce data values that have little impact on the program's final output. Constructing a new date formatter to format every date, or populating a large set full of expensively constructed structures only to check its size: these involve costs that are out of line with the benefits gained. This disparity between the formation costs and accrued benefits of data structures is at the heart of much runtime bloat.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806617", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "The Ohio State University" + }, + { + "first_name": "Nick", + "last_name": "Mitchell", + "institution": "IBM (United States)" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + }, + { + "first_name": "Edith", + "last_name": "Schonberg", + "institution": "IBM (United States)" + }, + { + "first_name": "Gary", + "last_name": "Sevitsky", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/XuMARSS10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806615", + "title": "Schism: fragmentation-tolerant real-time garbage collection", + "abstract": "Managed languages such as Java and C# are being considered for use in hard real-time systems. A hurdle to their widespread adoption is the lack of garbage collection algorithms that offer predictable space-and-time performance in the face of fragmentation. We introduce SCHISM/CMR, a new concurrent and real-time garbage collector that is fragmentation tolerant and guarantees time-and-space worst-case bounds while providing good throughput. SCHISM/CMR combines mark-region collection of fragmented objects and arrays (arraylets) with separate replication-copying collection of immutable arraylet spines, so as to cope with external fragmentation when running in small heaps. We present an implementation of SCHISM/CMR in the Fiji VM, a high-performance Java virtual machine for mission-critical systems, along with a thorough experimental evaluation on a wide variety of architectures, including server-class and embedded systems. The results show that SCHISM/CMR tolerates fragmentation better than previous schemes, with a much more acceptable throughput penalty.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806615", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Filip", + "last_name": "Pizlo", + "institution": "University of Fiji" + }, + { + "first_name": "Lukasz", + "last_name": "Ziarek", + "institution": "University of Fiji" + }, + { + "first_name": "Petr", + "last_name": "Maj", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Antony L.", + "last_name": "Hosking", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Ethan", + "last_name": "Blanton", + "institution": "Fiji Systems (United States)" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/PizloZMHBV10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806635", + "title": "MemSAT: checking axiomatic specifications of memory models", + "abstract": "Memory models are hard to reason about due to their complexity, which stems from the need to strike a balance between ease-of-programming and allowing compiler and hardware optimizations. In this paper, we present an automated tool, MemSAT, that helps in debugging and reasoning about memory models. Given an axiomatic specification of a memory model and a multi-threaded test program containing assertions, MemSAT outputs a trace of the program in which both the assertions and the memory model axioms are satisfied, if one can be found. The tool is fully automatic and is based on a SAT solver. If it cannot find a trace, it outputs a minimal subset of the memory model and program constraints that are unsatisfiable. We used MemSAT to check several existing memory models against their published test cases, including the current Java Memory Model by Manson et al. and a revised version of it by Sevcik and Aspinall. We found subtle discrepancies between what was expected and the actual results of test programs.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806635", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "IBM (United States)" + }, + { + "first_name": "Mandana", + "last_name": "Vaziri", + "institution": "IBM (United States)" + }, + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/TorlakVD10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806642", + "title": "Mint: Java multi-stage programming using weak separability", + "abstract": "Multi-stage programming (MSP) provides a disciplined approach to run-time code generation. In the purely functional setting, it has been shown how MSP can be used to reduce the overhead of abstractions, allowing clean, maintainable code without paying performance penalties. Unfortunately, MSP is difficult to combine with imperative features, which are prevalent in mainstream languages. The central difficulty is scope extrusion, wherein free variables can inadvertently be moved outside the scopes of their binders. This paper proposes a new approach to combining MSP with imperative features that occupies a \"sweet spot\" in the design space in terms of how well useful MSP applications can be expressed and how easy it is for programmers to understand. The key insight is that escapes (or \"anti-quotes\") must be weakly separable from the rest of the code, i.e. the computational effects occurring inside an escape that are visible outside the escape are guaranteed to not contain code. To demonstrate the feasibility of this approach, we formalize a type system based on Lightweight Java which we prove sound, and we also provide an implementation, called Mint, to validate both the expressivity of the type system and the effect of staging on the performance of Java programs.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806642", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Edwin M.", + "last_name": "Westbrook", + "institution": "Rice University" + }, + { + "first_name": "Mathias", + "last_name": "Ricken", + "institution": "Rice University" + }, + { + "first_name": "Jun", + "last_name": "Inoue", + "institution": "Rice University" + }, + { + "first_name": "Yilong", + "last_name": "Yao", + "institution": "Rice University" + }, + { + "first_name": "Tamer", + "last_name": "Abdelatif", + "institution": "Ain Shams University" + }, + { + "first_name": "Walid", + "last_name": "Taha", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/WestbrookRIYAT10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806616", + "title": "Detecting inefficiently-used containers to avoid bloat", + "abstract": "Runtime bloat degrades significantly the performance and scalability of software systems. An important source of bloat is the inefficient use of containers. It is expensive to create inefficiently-used containers and to invoke their associated methods, as this may ultimately execute large volumes of code, with call stacks dozens deep, and allocate many temporary objects.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806616", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "The Ohio State University" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/XuR10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806640", + "title": "Bamboo: a data-centric, object-oriented approach to many-core software", + "abstract": "Traditional data-oriented programming languages such as dataflow languages and stream languages provide a natural abstraction for parallel programming. In these languages, a developer focuses on the flow of data through the computation and these systems free the developer from the complexities of low-level, thread-oriented concurrency primitives. This simplification comes at a cost --- traditional data-oriented approaches restrict the mutation of state and, in practice, the types of data structures a program can effectively use. Bamboo borrows from work in typestate and software transactions to relax the traditional restrictions of data-oriented programming models to support mutation of arbitrary data structures.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806640", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jin", + "last_name": "Zhou", + "institution": "University of California, Irvine" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/pldi/ZhouD10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806649", + "title": "Z-rays: divide arrays and conquer speed and flexibility", + "abstract": "Arrays are the ubiquitous organization for indexed data. Throughout programming language evolution, implementations have laid out arrays contiguously in memory. This layout is problematic in space and time. It causes heap fragmentation, garbage collection pauses in proportion to array size, and wasted memory for sparse and over-provisioned arrays. Because of array virtualization in managed languages, an array layout that consists of indirection pointers to fixed-size discontiguous memory blocks can mitigate these problems transparently. This design however incurs significant overhead, but is justified when real-time deadlines and space constraints trump performance.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806649", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jennifer B.", + "last_name": "Sartor", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Daniel", + "last_name": "Frampton", + "institution": "Australian National University" + }, + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "IBM (United States)" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/SartorBFHM10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806610", + "title": "Safe to the last instruction: automated verification of a type-safe operating system", + "abstract": "Typed assembly language (TAL) and Hoare logic can verify the absence of many kinds of errors in low-level code. We use TAL and Hoare logic to achieve highly automated, static verification of the safety of a new operating system called Verve. Our techniques and tools mechanically verify the safety of every assembly language instruction in the operating system, run-time system, drivers, and applications (in fact, every part of the system software except the boot loader). Verve consists of a \"Nucleus\" that provides primitive access to hardware and memory, a kernel that builds services on top of the Nucleus, and applications that run on top of the kernel. The Nucleus, written in verified assembly language, implements allocation, garbage collection, multiple stacks, interrupt handling, and device access. The kernel, written in C# and compiled to TAL, builds higher-level services, such as preemptive threads, on top of the Nucleus. A TAL checker verifies the safety of the kernel and applications. A Hoare-style verifier with an automated theorem prover verifies both the safety and correctness of the Nucleus. Verve is, to the best of our knowledge, the first operating system mechanically verified to guarantee both type and memory safety. More generally, Verve's approach demonstrates a practical way to mix high-level typed code with low-level untyped code in a verifiably safe manner.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806610", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jean", + "last_name": "Yang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/YangH10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806598", + "title": "An analysis of the dynamic behavior of JavaScript programs", + "abstract": "The JavaScript programming language is widely used for web programming and, increasingly, for general purpose computing. As such, improving the correctness, security and performance of JavaScript applications has been the driving force for research in type systems, static analysis and compiler techniques for this language. Many of these techniques aim to reign in some of the most dynamic features of the language, yet little seems to be known about how programmers actually utilize the language or these features. In this paper we perform an empirical study of the dynamic behavior of a corpus of widely-used JavaScript programs, and analyze how and why the dynamic features are used. We report on the degree of dynamism that is exhibited by these JavaScript programs and compare that with assumptions commonly made in the literature and accepted industry benchmark suites.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806598", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gregor", + "last_name": "Richards", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Sylvain", + "last_name": "Lebresne", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Brian R.", + "last_name": "Burg", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/RichardsLBV10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806622", + "title": "A context-free markup language for semi-structured text", + "abstract": "An ad hoc data format is any nonstandard, semi-structured data format for which robust data processing tools are not easily available. In this paper, we present ANNE, a new kind of markup language designed to help users generate documentation and data processing tools for ad hoc text data. More specifically, given a new ad hoc data source, an ANNE programmer edits the document to add a number of simple annotations, which serve to specify its syntactic structure. Annotations include elements that specify constants, optional data, alternatives, enumerations, sequences, tabular data, and recursive patterns. The ANNE system uses a combination of user annotations and the raw data itself to extract a context-free grammar from the document. This context-free grammar can then be used to parse the data and transform it into an XML parse tree, which may be viewed through a browser for analysis or debugging purposes. In addition, the ANNE system generates a PADS/ML description, which may be saved as lasting documentation of the data format or compiled into a host of useful data processing tools.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806622", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qian", + "last_name": "Xi", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/XiW10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806604", + "title": "Supporting speculative parallelization in the presence of dynamic data structures", + "abstract": "The availability of multicore processors has led to significant interest in compiler techniques for speculative parallelization of sequential programs. Isolation of speculative state from non-speculative state forms the basis of such speculative techniques as this separation enables recovery from misspeculations. In our prior work on CorD [35,36] we showed that for array and scalar variable based programs copying of data between speculative and non-speculative memory can be highly optimized to support state separation that yields significant speedups on multicore machines available today. However, we observe that in context of heap-intensive programs that operate on linked dynamic data structures, state separation based speculative parallelization poses many challenges. The copying of data structures from non-speculative to speculative state (copy-in operation) can be very expensive due to the large sizes of dynamic data structures. The copying of updated data structures from speculative state to non-speculative state (copy-out operation) is made complex due to the changes in the shape and size of the dynamic data structure made by the speculative computation. In addition, we must contend with the need to translate pointers internal to dynamic data structures between their non-speculative and speculative memory addresses. In this paper we develop an augmented design for the representation of dynamic data structures such that all of the above operations can be performed efficiently. Our experiments demonstrate significant speedups on a real machine for a set of programs that make extensive use of heap based dynamic data structures.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806604", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chen", + "last_name": "Tian", + "institution": "University of California, Riverside" + }, + { + "first_name": "Min", + "last_name": "Feng", + "institution": "University of California, Riverside" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/pldi/TianFG10", + "venue": "pldi", + "year": 2010 + }, + { + "paper_id": "10.1145/1806596.1806606", + "title": "A GPGPU compiler for memory optimization and parallelism management", + "abstract": "This paper presents a novel optimizing compiler for general purpose computation on graphics processing units (GPGPU). It addresses two major challenges of developing high performance GPGPU programs: effective utilization of GPU memory hierarchy and judicious management of parallelism.", + "date": "2010-06-05", + "link": "https://doi.org/10.1145/1806596.1806606", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yi", + "last_name": "Yang", + "institution": "North Carolina State University" + }, + { + "first_name": "Ping", + "last_name": "Xiang", + "institution": "University of Central Florida" + }, + { + "first_name": "Jingfei", + "last_name": "Kong", + "institution": "University of Central Florida" + }, + { + "first_name": "Huiyang", + "last_name": "Zhou", + "institution": "North Carolina State University" + } + ], + "dblp_key": "conf/pldi/YangXKZ10", + "venue": "pldi", + "year": 2010 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2011.json b/data/pl_conferences/pldi/2011.json new file mode 100644 index 0000000..daa03e8 --- /dev/null +++ b/data/pl_conferences/pldi/2011.json @@ -0,0 +1,1612 @@ +[ + { + "paper_id": "10.1145/1993498.1993563", + "title": "Separation logic + superposition calculus = heap theorem prover", + "abstract": "Program analysis and verification tools crucially depend on the ability to symbolically describe and reason about sets of program behaviors. Separation logic provides a promising foundation for dealing with heap manipulating programs, while the development of practical automated deduction/satisfiability checking tools for separation logic is a challenging problem. In this paper, we present an efficient, sound and complete automated theorem prover for checking validity of entailments between separation logic formulas with list segment predicates. Our theorem prover integrates separation logic inference rules that deal with list segments and a superposition calculus to deal with equality/aliasing between memory locations. The integration follows a modular combination approach that allows one to directly incorporate existing advanced techniques for first-order reasoning with equality, as well as account for additional theories, e.g., linear arithmetic, using extensions of superposition. An experimental evaluation of our entailment prover indicates speedups of several orders of magnitude with respect to the available state-of-the-art tools.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993563", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Juan Antonio", + "last_name": "Pérez-Ortiz", + "institution": "Technical University of Munich" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/pldi/PerezR11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993543", + "title": "Isolating and understanding concurrency errors using reconstructed execution fragments", + "abstract": "In this paper we propose Recon, a new general approach to concurrency debugging. Recon goes beyond just detecting bugs, it also presents to the programmer short fragments of buggy execution schedules that illustrate how and why bugs happened. These fragments, called reconstructions, are inferred from inter-thread communication surrounding the root cause of a bug and significantly simplify the process of understanding bugs.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993543", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "University of Washington" + }, + { + "first_name": "Benjamin P.", + "last_name": "Wood", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/LuciaWC11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993504", + "title": "Data representation synthesis", + "abstract": "We consider the problem of specifying combinations of data structures with complex sharing in a manner that is both declarative and results in provably correct code. In our approach, abstract data types are specified using relational algebra and functional dependencies. We describe a language of decompositions that permit the user to specify different concrete representations for relations, and show that operations on concrete representations soundly implement their relational specification. It is easy to incorporate data representations synthesized by our compiler into existing systems, leading to code that is simpler, correct by construction, and comparable in performance to the code it replaces.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993504", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter", + "last_name": "Hawkins", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/HawkinsAFRS11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993553", + "title": "Kremlin: rethinking and rebooting gprof for the multicore age", + "abstract": "Many recent parallelization tools lower the barrier for parallelizing a program, but overlook one of the first questions that a programmer needs to answer: which parts of the program should I spend time parallelizing?", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993553", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Saturnino", + "last_name": "Garcia", + "institution": "University of California, San Diego" + }, + { + "first_name": "Dong‐Hwan", + "last_name": "Jeon", + "institution": "University of California, San Diego" + }, + { + "first_name": "Christopher", + "last_name": "Louie", + "institution": "University of California, San Diego" + }, + { + "first_name": "Michael", + "last_name": "Taylor", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/GarciaJLT11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993566", + "title": "On inter-procedural analysis of programs with lists and data", + "abstract": "We address the problem of automatic synthesis of assertions on sequential programs with singly-linked lists containing data over infinite domains such as integers or reals. Our approach is based on an accurate abstract inter-procedural analysis. Program configurations are represented by graphs where nodes represent list segments without sharing. The data in these list segments are characterized by constraints in abstract domains. We consider a domain where constraints are in a universally quantified fragment of the first-order logic over sequences, as well as a domain constraining the multisets of data in sequences.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993566", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Cezara", + "last_name": "Drăgoi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Mihaela", + "last_name": "Sighireanu", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/pldi/BouajjaniDES11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993502", + "title": "Parallelism orchestration using DoPE: the degree of parallelism executive", + "abstract": "In writing parallel programs, programmers expose parallelism and optimize it to meet a particular performance goal on a single platform under an assumed set of workload characteristics. In the field, changing workload characteristics, new parallel platforms, and deployments with different performance goals make the programmer's development-time choices suboptimal. To address this problem, this paper presents the Degree of Parallelism Executive (DoPE), an API and run-time system that separates the concern of exposing parallelism from that of optimizing it. Using the DoPE API, the application developer expresses parallelism options. During program execution, DoPE's run-time system uses this information to dynamically optimize the parallelism options in response to the facts on the ground. We easily port several emerging parallel applications to DoPE's API and demonstrate the DoPE run-time system's effectiveness in dynamically optimizing the parallelism for a variety of performance goals.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993502", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Arun", + "last_name": "Raman", + "institution": "Princeton University" + }, + { + "first_name": "Hanjun", + "last_name": "Kim", + "institution": "Princeton University" + }, + { + "first_name": "Taewook", + "last_name": "Oh", + "institution": "Princeton University" + }, + { + "first_name": "Jae W.", + "last_name": "Lee", + "institution": "" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/RamanKOLA11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993526", + "title": "Mostly-automated verification of low-level programs in computational separation logic", + "abstract": "Several recent projects have shown the feasibility of verifying low-level systems software. Verifications based on automated theorem-proving have omitted reasoning about first-class code pointers, which is critical for tasks like certifying implementations of threads and processes. Conversely, verifications that deal with first-class code pointers have featured long, complex, manual proofs. In this paper, we introduce the Bedrock framework, which supports mostly-automated proofs about programs with the full range of features needed to implement, e.g., language runtime systems.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993526", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/pldi/Chlipala11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993550", + "title": "Cause clue clauses: error localization using maximum satisfiability", + "abstract": "Much effort is spent by programmers everyday in trying to reduce long, failing execution traces to the cause of the error. We present an algorithm for error cause localization based on a reduction to the maximal satisfiability problem (MAX-SAT), which asks what is the maximum number of clauses of a Boolean formula that can be simultaneously satisfied by an assignment. At an intuitive level, our algorithm takes as input a program and a failing test, and comprises the following three steps. First, using bounded model checking, and a bound obtained from the execution of the test, we encode the semantics of a bounded unrolling of the program as a Boolean trace formula. Second, for a failing program execution (e.g., one that violates an assertion or a post-condition), we construct an unsatisfiable formula by taking the formula and additionally asserting that the input is the failing test and that the assertion condition does hold at the end. Third, using MAX-SAT, we find a maximal set of clauses in this formula that can be satisfied together, and output the complement set as a potential cause of the error.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993550", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manu", + "last_name": "Jose", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/JoseM11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993512", + "title": "Caisson: a hardware description language for secure information flow", + "abstract": "Information flow is an important security property that must be incorporated from the ground up, including at hardware design time, to provide a formal basis for a system's root of trust. We incorporate insights and techniques from designing information-flow secure programming languages to provide a new perspective on designing secure hardware. We describe a new hardware description language, Caisson, that combines domain-specific abstractions common to hardware design with insights from type-based techniques used in secure programming languages. The proper combination of these elements allows for an expressive, provably-secure HDL that operates at a familiar level of abstraction to the target audience of the language, hardware architects.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993512", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xun", + "last_name": "Li", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Mohit", + "last_name": "Tiwari", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Jason", + "last_name": "Oberg", + "institution": "University of California, San Diego" + }, + { + "first_name": "Vineeth", + "last_name": "Kashyap", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Frederic T.", + "last_name": "Chong", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Timothy", + "last_name": "Sherwood", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Ben", + "last_name": "Hardekopf", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/pldi/LiTOKCSH11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993528", + "title": "Toward generating reducible replay logs", + "abstract": "Logging and replay is important to reproducing software failures and recovering from failures. Replaying a long execution is time consuming, especially when replay is further integrated with runtime techniques that require expensive instrumentation, such as dependence detection. In this paper, we propose a technique to reduce a replay log while retaining its ability to reproduce a failure. While traditional logging records only system calls and signals, our technique leverages the compiler to selectively collect additional information on the fly. Upon a failure, the log can be reduced by analyzing itself. The collection is highly optimized. The additional runtime overhead of our technique, compared to a plain logging tool, is trivial (2.61% average) and the size of additional log is comparable to the original log. Substantial reduction can be cost-effectively achieved through a search based algorithm. The reduced log is guaranteed to reproduce the failure.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993528", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kyu Hyoung", + "last_name": "Lee", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yunhui", + "last_name": "Zheng", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "William N.", + "last_name": "Sumner", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/LeeZSZ11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993559", + "title": "Mining hot calling contexts in small space", + "abstract": "Calling context trees (CCTs) associate performance metrics with paths through a program's call graph, providing valuable information for program understanding and performance analysis. Although CCTs are typically much smaller than call trees, in real applications they might easily consist of tens of millions of distinct calling contexts: this sheer size makes them difficult to analyze and might hurt execution times due to poor access locality. For performance analysis, accurately collecting information about hot calling contexts may be more useful than constructing an entire CCT that includes millions of uninteresting paths. As we show for a variety of prominent Linux applications, the distribution of calling context frequencies is typically very skewed. In this paper we show how to exploit this property to reduce the CCT size considerably. We introduce a novel run-time data structure, called Hot Calling Context Tree (HCCT), that offers an additional intermediate point in the spectrum of data structures for representing interprocedural control flow. The HCCT is a subtree of the CCT that includes only hot nodes and their ancestors. We show how to compute the HCCT without storing the exact frequency of all calling contexts, by using fast and space-efficient algorithms for mining frequent items in data streams. With this approach, we can distinguish between hot and cold contexts on the fly, while obtaining very accurate frequency counts. We show both theoretically and experimentally that the HCCT achieves a similar precision as the CCT in a much smaller space, roughly proportional to the number of distinct hot contexts: this is typically several orders of magnitude smaller than the total number of calling contexts encountered during a program's execution. Our space-efficient approach can be effectively combined with previous context-sensitive profiling techniques, such as sampling and bursting.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993559", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniele Cono", + "last_name": "D’Elia", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Camil", + "last_name": "Demetrescu", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Irene", + "last_name": "Finocchi", + "institution": "Sapienza University of Rome" + } + ], + "dblp_key": "conf/pldi/DEliaDF11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993520", + "title": "Understanding POWER multiprocessors", + "abstract": "International audience", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993520", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Jade", + "last_name": "Alglave", + "institution": "University of Oxford" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Derek", + "last_name": "Williams", + "institution": "IBM Research - Austin" + } + ], + "dblp_key": "conf/pldi/SarkarSAMW11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993500", + "title": "Commutative set: a language extension for implicit parallel programming", + "abstract": "Sequential programming models express a total program order, of which a partial order must be respected. This inhibits parallelizing tools from extracting scalable performance. Programmer written semantic commutativity assertions provide a natural way of relaxing this partial order, thereby exposing parallelism implicitly in a program. Existing implicit parallel programming models based on semantic commutativity either require additional programming extensions, or have limited expressiveness. This paper presents a generalized semantic commutativity based programming extension, called Commutative Set (COMMSET), and associated compiler technology that enables multiple forms of parallelism. COMMSET expressions are syntactically succinct and enable the programmer to specify commutativity relations between groups of arbitrary structured code blocks. Using only this construct, serializing constraints that inhibit parallelization can be relaxed, independent of any particular parallelization strategy or concurrency control mechanism. COMMSET enables well performing parallelizations in cases where they were inapplicable or non-performing before. By extending eight sequential programs with only 8 annotations per program on average, COMMSET and the associated compiler technology produced a geomean speedup of 5.7x on eight cores compared to 1.5x for the best non-COMMSET parallelization.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993500", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Prakash", + "last_name": "Prabhu", + "institution": "Princeton University" + }, + { + "first_name": "Soumyadeep", + "last_name": "Ghosh", + "institution": "Princeton University" + }, + { + "first_name": "Yun", + "last_name": "Zhang", + "institution": "Princeton University" + }, + { + "first_name": "Nick", + "last_name": "Johnson", + "institution": "Princeton University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/PrabhuGZJA11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993501", + "title": "The tao of parallelism in algorithms", + "abstract": "For more than thirty years, the parallel programming community has used the dependence graph as the main abstraction for reasoning about and exploiting parallelism in \"regular\" algorithms that use dense arrays, such as finite-differences and FFTs. In this paper, we argue that the dependence graph is not a suitable abstraction for algorithms in new application areas like machine learning and network analysis in which the key data structures are \"irregular\" data structures like graphs, trees, and sets.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993501", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Donald", + "last_name": "Nguyen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Martin", + "last_name": "Burtscher", + "institution": "Texas State University" + }, + { + "first_name": "M. Amber", + "last_name": "Hassaan", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Rashid", + "last_name": "Kaleem", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Tsung‐Hsien", + "last_name": "Lee", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Andrew", + "last_name": "Lenharth", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Roman", + "last_name": "Manevich", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Mario", + "last_name": "Méndez-Lojo", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Dimitrios", + "last_name": "Prountzos", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Xin", + "last_name": "Sui", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/PingaliNKBHKLLMMPS11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993544", + "title": "Automated atomicity-violation fixing", + "abstract": "Fixing software bugs has always been an important and time-consuming process in software development. Fixing concurrency bugs has become especially critical in the multicore era. However, fixing concurrency bugs is challenging, in part due to non-deterministic failures and tricky parallel reasoning. Beyond correctly fixing the original problem in the software, a good patch should also avoid introducing new bugs, degrading performance unnecessarily, or damaging software readability. Existing tools cannot automate the whole fixing process and provide good-quality patches.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993544", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guoliang", + "last_name": "Jin", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Linhai", + "last_name": "Song", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Wei", + "last_name": "Zhang", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/JinSZLL11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993516", + "title": "Automatic CPU-GPU communication management and optimization", + "abstract": "The performance benefits of GPU parallelism can be enormous, but unlocking this performance potential is challenging. The applicability and performance of GPU parallelizations is limited by the complexities of CPU-GPU communication. To address these communications problems, this paper presents the first fully automatic system for managing and optimizing CPU-GPU communcation. This system, called the CPU-GPU Communication Manager (CGCM), consists of a run-time library and a set of compiler transformations that work together to manage and optimize CPU-GPU communication without depending on the strength of static compile-time analyses or on programmer-supplied annotations. CGCM eases manual GPU parallelizations and improves the applicability and performance of automatic GPU parallelizations. For 24 programs, CGCM-enabled automatic GPU parallelization yields a whole program geomean speedup of 5.36x over the best sequential CPU-only execution.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993516", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas B.", + "last_name": "Jablin", + "institution": "Princeton University" + }, + { + "first_name": "Prakash", + "last_name": "Prabhu", + "institution": "Princeton University" + }, + { + "first_name": "James A.", + "last_name": "Jablin", + "institution": "Brown University" + }, + { + "first_name": "Nick", + "last_name": "Johnson", + "institution": "Princeton University" + }, + { + "first_name": "Stephen R.", + "last_name": "Beard", + "institution": "Princeton University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/JablinPJJBA11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993554", + "title": "Automatic parallelization via matrix multiplication", + "abstract": "Existing work that deals with parallelization of complicated reductions and scans focuses only on formalism and hardly dealt with implementation. To bridge the gap between formalism and implementation, we have integrated parallelization via matrix multiplication into compiler construction. Our framework can deal with complicated loops that existing techniques in compilers cannot parallelize. Moreover, we have sophisticated our framework by developing two sets of techniques. One enhances its capability for parallelization by extracting max-operators automatically, and the other improves the performance of parallelized programs by eliminating redundancy. We have also implemented our framework and techniques as a parallelizer in a compiler. Experiments on examples that existing compilers cannot parallelize have demonstrated the scalability of programs parallelized by our implementation.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993554", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shigeyuki", + "last_name": "Sato", + "institution": "University of Electro-Communications" + }, + { + "first_name": "Hideya", + "last_name": "Iwasaki", + "institution": "University of Electro-Communications" + } + ], + "dblp_key": "conf/pldi/SatoI11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993505", + "title": "Synthesizing geometry constructions", + "abstract": "In this paper, we study the problem of automatically solving ruler/compass based geometry construction problems. We first introduce a logic and a programming language for describing such constructions and then phrase the automation problem as a program synthesis problem. We then describe a new program synthesis technique based on three key insights: (i) reduction of symbolic reasoning to concrete reasoning (based on a deep theoretical result that reduces verification to random testing), (ii) extending the instruction set of the programming language with higher level primitives (representing basic constructions found in textbook chapters, inspired by how humans use their experience and knowledge gained from chapters to perform complicated constructions), and (iii) pruning the forward exhaustive search using a goal-directed heuristic (simulating backward reasoning performed by humans). Our tool can successfully synthesize constructions for various geometry problems picked up from high-school textbooks and examination papers in a reasonable amount of time. This opens up an amazing set of possibilities in the context of making classroom teaching interactive.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993505", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vijay Anand", + "last_name": "Korthikanti", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "SRI International" + } + ], + "dblp_key": "conf/pldi/GulwaniKT11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993508", + "title": "Generalized just-in-time trace compilation using a parallel task farm in a dynamic binary translator", + "abstract": "Dynamic Binary Translation (DBT) is the key technology behind cross-platform virtualization and allows software compiled for one Instruction Set Architecture (ISA) to be executed on a processor supporting a different ISA. Under the hood, DBT is typically implemented using Just-In-Time (JIT) compilation of frequently executed program regions, also called traces. The main challenge is translating frequently executed program regions as fast as possible into highly efficient native code. As time for JIT compilation adds to the overall execution time, the JIT compiler is often decoupled and operates in a separate thread independent from the main simulation loop to reduce the overhead of JIT compilation. In this paper we present two innovative contributions. The first contribution is a generalized trace compilation approach that considers all frequently executed paths in a program for JIT compilation, as opposed to previous approaches where trace compilation is restricted to paths through loops. The second contribution reduces JIT compilation cost by compiling several hot traces in a concurrent task farm. Altogether we combine generalized light-weight tracing, large translation units, parallel JIT compilation and dynamic work scheduling to ensure timely and efficient processing of hot traces. We have evaluated our industry-strength, LLVM-based parallel DBT implementing the ARCompact ISA against three benchmark suites (EEMBC, BioPerf and SPEC CPU2006) and demonstrate speedups of up to 2.08 on a standard quad-core Intel Xeon machine. Across short- and long-running benchmarks our scheme is robust and never results in a slowdown. In fact, using four processors total execution time can be reduced by on average 11.5% over state-of-the-art decoupled, parallel (or asynchronous) JIT compilation.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993508", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Igor", + "last_name": "Böhm", + "institution": "University of Edinburgh" + }, + { + "first_name": "Tobias J.K. Edler von", + "last_name": "Koch", + "institution": "University of Edinburgh" + }, + { + "first_name": "Stephen", + "last_name": "Kyle", + "institution": "University of Edinburgh" + }, + { + "first_name": "Björn", + "last_name": "Franke", + "institution": "University of Edinburgh" + }, + { + "first_name": "Nigel", + "last_name": "Topham", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/BohmKKFT11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993524", + "title": "Probabilistic, modular and scalable inference of typestate specifications", + "abstract": "Static analysis tools aim to find bugs in software that correspond to violations of specifications. Unfortunately, for large and complex software, these specifications are usually either unavailable or sophisticated, and hard to write.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993524", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nels E.", + "last_name": "Beckman", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/pldi/BeckmanN11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993517", + "title": "Automatic compilation of MATLAB programs for synergistic execution on heterogeneous processors", + "abstract": "MATLAB is an array language, initially popular for rapid prototyping, but is now being increasingly used to develop production code for numerical and scientific applications. Typical MATLAB programs have abundant data parallelism. These programs also have control flow dominated scalar regions that have an impact on the program's execution time. Today's computer systems have tremendous computing power in the form of traditional CPU cores and throughput oriented accelerators such as graphics processing units(GPUs). Thus, an approach that maps the control flow dominated regions to the CPU and the data parallel regions to the GPU can significantly improve program performance.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993517", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ashwin", + "last_name": "Prasad", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Jayvant", + "last_name": "Anantpur", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "R.", + "last_name": "Govindarajan", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/pldi/PrasadAG11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993536", + "title": "Spreadsheet table transformations from examples", + "abstract": "Every day, millions of computer end-users need to perform tasks over large, tabular data, yet lack the programming knowledge to do such tasks automatically. In this work, we present an automatic technique that takes from a user an example of how the user needs to transform a table of data, and provides to the user a program that implements the transformation described by the example. In particular, we present a language of programs TableProg that can describe transformations that real users require.We then present an algorithm ProgFromEx that takes an example input and output table, and infers a program in TableProg that implements the transformation described by the example. When the program is applied to the example input, it reproduces the example output. When the program is applied to another, potentially larger, table with a 'similar' layout as the example input table, then the program produces a corresponding table with a layout that is similar to the example output table. A user can apply ProgFromEx interactively, providing multiple small examples to obtain a program that implements the transformation that the user desires. Moreover, ProgFromEx can help identify 'noisy' examples that contain errors.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993536", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William R.", + "last_name": "Harris", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/HarrisG11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993540", + "title": "Language-independent sandboxing of just-in-time compilation and self-modifying code", + "abstract": "When dealing with dynamic, untrusted content, such as on the Web, software behavior must be sandboxed, typically through use of a language like JavaScript. However, even for such specially-designed languages, it is difficult to ensure the safety of highly-optimized, dynamic language runtimes which, for efficiency, rely on advanced techniques such as Just-In-Time (JIT) compilation, large libraries of native-code support routines, and intricate mechanisms for multi-threading and garbage collection. Each new runtime provides a new potential attack surface and this security risk raises a barrier to the adoption of new languages for creating untrusted content.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993540", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jason", + "last_name": "Ansel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Petr", + "last_name": "Marchenko", + "institution": "University College London" + }, + { + "first_name": "Úlfar", + "last_name": "Erlingsson", + "institution": "Google (United States)" + }, + { + "first_name": "Elijah", + "last_name": "Taylor", + "institution": "Google (United States)" + }, + { + "first_name": "Brad", + "last_name": "Chen", + "institution": "Google (United States)" + }, + { + "first_name": "Derek L.", + "last_name": "Schuff", + "institution": "Google (United States)" + }, + { + "first_name": "David", + "last_name": "Sehr", + "institution": "Google (United States)" + }, + { + "first_name": "Cliff L.", + "last_name": "Biffle", + "institution": "Google (United States)" + }, + { + "first_name": "Bennet", + "last_name": "Yee", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/pldi/AnselMETCSSBY11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993514", + "title": "Languages as libraries", + "abstract": "Programming language design benefits from constructs for extending the syntax and semantics of a host language. While C's string-based macros empower programmers to introduce notational shorthands, the parser-level macros of Lisp encourage experimentation with domain-specific languages. The Scheme programming language improves on Lisp with macros that respect lexical scope.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993514", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Northeastern University" + }, + { + "first_name": "Vincent", + "last_name": "St-Amour", + "institution": "Northeastern University" + }, + { + "first_name": "Ryan", + "last_name": "Culpepper", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/Tobin-HochstadtSCFF11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993567", + "title": "Scaling abstraction refinement via pruning", + "abstract": "Many static analyses do not scale as they are made more precise. For example, increasing the amount of context sensitivity in a k-limited pointer analysis causes the number of contexts to grow exponentially with k. Iterative refinement techniques can mitigate this growth by starting with a coarse abstraction and only refining parts of the abstraction that are deemed relevant with respect to a given client.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993567", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Percy", + "last_name": "Liang", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/LiangN11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993529", + "title": "Higher-order test generation", + "abstract": "Symbolic reasoning about large programs is bound to be imprecise. How to deal with this imprecision is a fundamental problem in program analysis. Imprecision forces approximation. Traditional static program verification builds \"may\" over-approximations of the program behaviors to check universal \"for-all-paths\" properties, while automatic test generation requires \"must\" under-approximations to check existential \"for-some-path\" properties.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993529", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Godefroid11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993548", + "title": "LL(*): the foundation of the ANTLR parser generator", + "abstract": "Despite the power of Parser Expression Grammars (PEGs) and GLR, parsing is not a solved problem. Adding nondeterminism (parser speculation) to traditional LL and LR parsers can lead to unexpected parse-time behavior and introduces practical issues with error handling, single-step debugging, and side-effecting embedded grammar actions. This paper introduces the LL(*) parsing strategy and an associated grammar analysis algorithm that constructs LL(*) parsing decisions from ANTLR grammars. At parse-time, decisions gracefully throttle up from conventional fixed k>=1 lookahead to arbitrary lookahead and, finally, fail over to backtracking depending on the complexity of the parsing decision and the input symbols. LL(*) parsing strength reaches into the context-sensitive languages, in some cases beyond what GLR and PEGs can express. By statically removing as much speculation as possible, LL(*) provides the expressivity of PEGs while retaining LL's good error handling and unrestricted grammar actions. Widespread use of ANTLR (over 70,000 downloads/year) shows that it is effective for a wide variety of applications.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993548", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Terence", + "last_name": "Parr", + "institution": "University of San Francisco" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/pldi/ParrF11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993513", + "title": "Steno: automatic optimization of declarative queries", + "abstract": "Declarative queries enable programmers to write data manipulation code without being aware of the underlying data structure implementation. By increasing the level of abstraction over imperative code, they improve program readability and, crucially, create opportunities for automatic parallelization and optimization. For example, the Language Integrated Query (LINQ) extensions to C# allow the same declarative query to process in-memory collections, and datasets that are distributed across a compute cluster. However, our experiments show that the serial performance of declarative code is several times slower than the equivalent hand-optimized code, because it is implemented using run-time abstractions---such as iterators---that incur overhead due to virtual function calls and superfluous instructions.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993513", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Derek G.", + "last_name": "Murray", + "institution": "University of Cambridge" + }, + { + "first_name": "Michael", + "last_name": "Isard", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Yuan", + "last_name": "Yu", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/MurrayIY11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993565", + "title": "Precise and compact modular procedure summaries for heap manipulating programs", + "abstract": "We present a strictly bottom-up, summary-based, and precise heap analysis targeted for program verification that performs strong updates to heap locations at call sites. We first present a theory of heap decompositions that forms the basis of our approach; we then describe a full analysis algorithm that is fully symbolic and efficient. We demonstrate the precision and scalability of our approach for verification of real C and C++ programs.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993565", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/DilligDAS11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993551", + "title": "kb-anonymity: a model for anonymized behaviour-preserving test and debugging data", + "abstract": "It is often very expensive and practically infeasible to generate test cases that can exercise all possible program states in a program. This is especially true for a medium or large industrial system. In practice, industrial clients of the system often have a set of input data collected either before the system is built or after the deployment of a previous version of the system. Such data are highly valuable as they represent the operations that matter in a client's daily business and may be used to extensively test the system. However, such data often carries sensitive information and cannot be released to third-party development houses. For example, a healthcare provider may have a set of patient records that are strictly confidential and cannot be used by any third party. Simply masking sensitive values alone may not be sufficient, as the correlation among fields in the data can reveal the masked information. Also, masked data may exhibit different behavior in the system and become less useful than the original data for testing and debugging.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993551", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aditya", + "last_name": "Budi", + "institution": "Singapore Management University" + }, + { + "first_name": "David", + "last_name": "Lo", + "institution": "Singapore Management University" + }, + { + "first_name": "Lingxiao", + "last_name": "Jiang", + "institution": "Singapore Management University" + }, + { + "first_name": "Lucia", + "last_name": "", + "institution": "Singapore Management University" + } + ], + "dblp_key": "conf/pldi/BudiLJL11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993573", + "title": "Synchronization via scheduling: techniques for efficiently managing shared state", + "abstract": "Shared state access conflicts are one of the greatest sources of error for fine grained parallelism in any domain. Notoriously hard to debug, these conflicts reduce reliability and increase development time. The standard task graph model dictates that tasks with potential conflicting accesses to shared state must be linked by a dependency, even if there is no explicit logical ordering on their execution. In cases where it is difficult to understand if such implicit dependencies exist, the programmer often creates more dependencies than needed, which results in constrained graphs with large monolithic tasks and limited parallelism.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993573", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Micah J.", + "last_name": "Best", + "institution": "University of British Columbia" + }, + { + "first_name": "Shane", + "last_name": "Mottishaw", + "institution": "Simon Fraser University" + }, + { + "first_name": "Craig", + "last_name": "Mustard", + "institution": "Simon Fraser University" + }, + { + "first_name": "Mark A.", + "last_name": "Roth", + "institution": "Simon Fraser University" + }, + { + "first_name": "Alexandra", + "last_name": "Fedorova", + "institution": "Simon Fraser University" + }, + { + "first_name": "Andrew", + "last_name": "Brownsword", + "institution": "Electronic Arts (Canada)" + } + ], + "dblp_key": "conf/pldi/BestMMRFB11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993521", + "title": "Partial-coherence abstractions for relaxed memory models", + "abstract": "We present an approach for automatic verification and fence inference in concurrent programs running under relaxed memory models. Verification under relaxed memory models is a hard problem. Given a finite state program and a safety specification, verifying that the program satisfies the specification under a sufficiently relaxed memory model is undecidable. For stronger models, the problem is decidable but has non-primitive recursive complexity.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993521", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Kuperstein", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "IBM (United States)" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/KupersteinVY11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993509", + "title": "Brainy: effective selection of data structures", + "abstract": "Data structure selection is one of the most critical aspects of developing effective applications. By analyzing data structures' behavior and their interaction with the rest of the application on the underlying architecture, tools can make suggestions for alternative data structures better suited for the program input on which the application runs. Consequently, developers can optimize their data structure usage to make the application conscious of an underlying architecture and a particular program input.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993509", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Changhee", + "last_name": "Jung", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Silvius", + "last_name": "Rus", + "institution": "Google (United States)" + }, + { + "first_name": "Brian P.", + "last_name": "Railing", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Nathan", + "last_name": "Clark", + "institution": "" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/pldi/JungRRCP11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993525", + "title": "Predicate abstraction and CEGAR for higher-order model checking", + "abstract": "Higher-order model checking (more precisely, the model checking of higher-order recursion schemes) has been extensively studied recently, which can automatically decide properties of programs written in the simply-typed λ-calculus with recursion and finite data domains. This paper formalizes predicate abstraction and counterexample-guided abstraction refinement (CEGAR) for higher-order model checking, enabling automatic verification of programs that use infinite data domains such as integers. A prototype verifier for higher-order functional programs based on the formalization has been implemented and tested for several programs.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993525", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "Tohoku University" + }, + { + "first_name": "Ryosuke", + "last_name": "Sato", + "institution": "Tohoku University" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/pldi/KobayashiSU11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993561", + "title": "Verification of semantic commutativity conditions and inverse operations on linked data structures", + "abstract": "We present a new technique for verifying commutativity conditions, which are logical formulas that characterize when operations commute. Because our technique reasons with the abstract state of verified linked data structure implementations, it can verify commuting operations that produce semantically equivalent (but not necessarily identical) data structure states in different execution orders. We have used this technique to verify sound and complete commutativity conditions for all pairs of operations on a collection of linked data structure implementations, including data structures that export a set interface (ListSet and HashSet) as well as data structures that export a map interface (AssociationList, HashTable, and ArrayList). This effort involved the specification and verification of 765 commutativity conditions.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993561", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Deokhwan", + "last_name": "Kim", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/KimR11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993545", + "title": "NDSeq: runtime checking for nondeterministic sequential specifications of parallel correctness", + "abstract": "We propose to specify the correctness of a program's parallelism using a sequential version of the program with controlled nondeterminism. Such a nondeterministic sequential specification allows (1) the correctness of parallel interference to be verified independently of the program's functional correctness, and (2) the functional correctness of a program to be understood and verified on a sequential version of the program, one with controlled nondeterminism but no interleaving of parallel threads.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993545", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Burnim", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Tayfun", + "last_name": "Elmas", + "institution": "University of California, Berkeley" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/BurnimENS11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993569", + "title": "Taming the wildcards: combining definition- and use-site variance", + "abstract": "Variance allows the safe integration of parametric and subtype polymorphism. Two flavors of variance, definition-site versus use-site variance, have been studied and have had their merits hotly debated. Definition-site variance (as in Scala and C#) offers simple type-instantiation rules, but causes fractured definitions of naturally invariant classes; Use-site variance (as in Java) offers simplicity in class definitions, yet complex type-instantiation rules that elude most programmers.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993569", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Altidor", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Shan", + "last_name": "Huang", + "institution": "" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/AltidorHS11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993522", + "title": "A case for an SC-preserving compiler", + "abstract": "The most intuitive memory consistency model for shared-memory multi-threaded programming is sequential consistency (SC). However, current concurrent programming languages support a relaxed model, as such relaxations are deemed necessary for enabling important optimizations. This paper demonstrates that an SC-preserving compiler, one that ensures that every SC behavior of a compiler-generated binary is an SC behavior of the source program, retains most of the performance benefits of an optimizing compiler. The key observation is that a large class of optimizations crucial for performance are either already SC-preserving or can be modified to preserve SC while retaining much of their effectiveness. An SC-preserving compiler, obtained by restricting the optimization phases in LLVM, a state-of-the-art C/C++ compiler, incurs an average slowdown of 3.8% and a maximum slowdown of 34% on a set of 30 programs from the SPLASH-2, PARSEC, and SPEC CINT2006 benchmark suites.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993522", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Marino", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Abhayendra", + "last_name": "Singh", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/MarinoSMMN11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993506", + "title": "Synthesis of loop-free programs", + "abstract": "We consider the problem of synthesizing loop-free programs that implement a desired functionality using components from a given library. Specifications of the desired functionality and the library components are provided as logical relations between their respective input and output variables. The library components can be used at most once, and hence the library is required to contain a reasonable overapproximation of the multiset of the components required.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993506", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Susmit", + "last_name": "Jha", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "SRI International" + }, + { + "first_name": "Ramarathnam", + "last_name": "Venkatesan", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/GulwaniJTV11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993532", + "title": "Finding and understanding bugs in C compilers", + "abstract": "Compilers should be correct. To improve the quality of C compilers, we created Csmith, a randomized test-case generation tool, and spent three years using it to find compiler bugs. During this period we reported more than 325 previously unknown bugs to compiler developers. Every compiler we tested was found to crash and also to silently generate wrong code when presented with valid input. In this paper we present our compiler-testing tool and the results of our bug-hunting study. Our first contribution is to advance the state of the art in compiler testing. Unlike previous tools, Csmith generates programs that cover a large subset of C while avoiding the undefined and unspecified behaviors that would destroy its ability to automatically find wrong-code bugs. Our second contribution is a collection of qualitative and quantitative results about the bugs we have found in open-source C compilers.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993532", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xuejun", + "last_name": "Yang", + "institution": "University of Utah" + }, + { + "first_name": "Yang", + "last_name": "Chen", + "institution": "University of Utah" + }, + { + "first_name": "Eric", + "last_name": "Eide", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/YangCER11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993537", + "title": "Systematic editing: generating program transformations from an example", + "abstract": "Software modifications are often systematic ---they consist of similar, but not identical, program changes to multiple contexts. Existing tools for systematic program transformation are limited because they require programmers to manually prescribe edits or only suggest a location to edit with a related example. This paper presents the design and implementation of a program transformation tool called SYDIT. Given an example edit, SYDIT generates a context-aware, abstract edit script, and then applies the edit script to new program locations. To correctly encode a relative position of the edits in a new location, the derived edit script includes unchanged statements on which the edits are control and data dependent. Furthermore, to make the edit script applicable to a new context using different identifier names, the derived edit script abstracts variable, method, and type names. The evaluation uses 56 systematic edit pairs from five large software projects as an oracle. SYDIT has high coverage and accuracy. For 82% of the edits (46/56), SYDIT matches the context and applies an edit, producing code that is 96% similar to the oracle. Overall, SYDIT mimics human programmers correctly on 70% (39/56) of the edits. Generation of edit scripts seeks to improve programmer productivity by relieving developers from tedious, error-prone, manual code updates. It also has the potential to guide automated program repair by creating program transformations applicable to similar contexts.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993537", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Na", + "last_name": "Meng", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Miryung", + "last_name": "Kim", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/MengKM11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993570", + "title": "Taming wildcards in Java's type system", + "abstract": "Wildcards have become an important part of Java's type system since their introduction 7 years ago. Yet there are still many open problems with Java's wildcards. For example, there are no known sound and complete algorithms for subtyping (and consequently type checking) Java wildcards, and in fact subtyping is suspected to be undecidable because wildcards are a form of bounded existential types. Furthermore, some Java types with wildcards have no joins, making inference of type arguments for generic methods particularly difficult. Although there has been progress on these fronts, we have identified significant shortcomings of the current state of the art, along with new problems that have not been addressed.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993570", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "University of California, San Diego" + }, + { + "first_name": "Alan", + "last_name": "Leung", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/TateLL11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993518", + "title": "EnerJ: approximate data types for safe and general low-power computation", + "abstract": "Energy is increasingly a first-order concern in computer systems. Exploiting energy-accuracy trade-offs is an attractive choice in applications that can tolerate inaccuracies. Recent work has explored exposing this trade-off in programming models. A key challenge, though, is how to isolate parts of the program that must be precise from those that can be approximated so that a program functions correctly even as quality of service degrades.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993518", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "University of Washington" + }, + { + "first_name": "Werner", + "last_name": "Dietl", + "institution": "University of Washington" + }, + { + "first_name": "Emily", + "last_name": "Fortuna", + "institution": "University of Washington" + }, + { + "first_name": "Danushen", + "last_name": "Gnanapragasam", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/SampsonDFGCG11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993530", + "title": "LeakChaser: helping programmers narrow down causes of memory leaks", + "abstract": "In large programs written in managed languages such as Java and C#, holding unnecessary references often results in memory leaks and bloat, degrading significantly their run-time performance and scalability. Despite the existence of many leak detectors for such languages, these detectors often target low-level objects; as a result, their reports contain many false warnings and lack sufficient semantic information to help diagnose problems. This paper introduces a specification-based technique called LeakChaser that can not only capture precisely the unnecessary references leading to leaks, but also explain, with high-level semantics, why these references become unnecessary.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993530", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Feng", + "last_name": "Qin", + "institution": "The Ohio State University" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/XuBQR11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993539", + "title": "A security policy oracle: detecting security holes using multiple API implementations", + "abstract": "Even experienced developers struggle to implement security policies correctly. For example, despite 15 years of development, standard Java libraries still suffer from missing and incorrectly applied permission checks, which enable untrusted applications to execute native calls or modify private class variables without authorization. Previous techniques for static verification of authorization enforcement rely on manually specified policies or attempt to infer the policy by code-mining. Neither approach guarantees that the policy used for verification is correct.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993539", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Varun", + "last_name": "Srivastava", + "institution": "Yahoo (United States)" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Vitaly", + "last_name": "Shmatikov", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/SrivastavaBMS11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993534", + "title": "Safe optimisations for shared-memory concurrent programs", + "abstract": "Current proposals for concurrent shared-memory languages, including C++ and C, provide sequential consistency only for programs without data races (the DRF guarantee). While the implications of such a contract for hardware optimisations are relatively well-understood, the correctness of compiler optimisations under the DRF guarantee is less clear, and experience with Java shows that this area is error-prone.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993534", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jaroslav", + "last_name": "Ševčík", + "institution": "MathWorks (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/Sevcik11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993572", + "title": "Composable asynchronous events", + "abstract": "Although asynchronous communication is an important feature of many concurrent systems, building composable abstractions that leverage asynchrony is challenging. This is because an asynchronous operation necessarily involves two distinct threads of control -- the thread that initiates the operation, and the thread that discharges it. Existing attempts to marry composability with asynchrony either entail sacrificing performance (by limiting the degree of asynchrony permitted), or modularity (by forcing natural abstraction boundaries to be broken).", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993572", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lukasz", + "last_name": "Ziarek", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/ZiarekSJ11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993533", + "title": "Evaluating value-graph translation validation for LLVM", + "abstract": "Translation validators are static analyzers that attempt to verify that program transformations preserve semantics. Normalizing translation validators do so by trying to match the value-graphs of an original function and its transformed counterpart. In this paper, we present the design of such a validator for LLVM's intra-procedural optimizations, a design that does not require any instrumentation of the optimizer, nor any rewriting of the source code to compile, and needs to run only once to validate a pipeline of optimizations. We present the results of our preliminary experiments on a set of benchmarks that include GCC, a perl interpreter, SQLite3, and other C programs.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993533", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jean-Baptiste", + "last_name": "Tristan", + "institution": "Harvard University Press" + }, + { + "first_name": "Paul", + "last_name": "Govereau", + "institution": "Harvard University Press" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/pldi/TristanGM11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993510", + "title": "An SSA-based algorithm for optimal speculative code motion under an execution profile", + "abstract": "To derive maximum optimization benefits from partial redundancy elimination (PRE),it is necessary to go beyond its safety constraint. Algorithms for optimal speculative code motion have been developed based on the application of minimum cut to flow networks formed out of the control flow graph. These previous techniques did not take advantage of the SSA form, which is a popular program representation widely used in modern-day compilers. We have developed the MC-SSAPRE algorithm that enables an SSA-based compiler to take full advantage of SSA to perform optimal speculative code motion efficiently when an execution profile is available. Our work shows that it is possible to form flow networks out of SSA graphs, and the min-cut technique can be applied equally well on these flow networks to find the optimal code placement. We provide proofs of the correctness and computational and lifetime optimality of MC-SSAPRE. We analyze its time complexity to show its efficiency advantage. We have implemented MC-SSAPRE in the open-sourced Path64 compiler. Our experimental data based on the full SPEC CPU2006 Benchmark Suite show that MC-SSAPRE can further improve program performance over traditional SSAPRE, and that our sparse approach to the problem does result in smaller problem sizes.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993510", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hucheng", + "last_name": "Zhou", + "institution": "Tsinghua University" + }, + { + "first_name": "Wenguang", + "last_name": "Chen", + "institution": "Tsinghua University" + }, + { + "first_name": "Fred", + "last_name": "Chow", + "institution": "" + } + ], + "dblp_key": "conf/pldi/ZhouCC11", + "venue": "pldi", + "year": 2011 + }, + { + "paper_id": "10.1145/1993498.1993555", + "title": "ALTER: exploiting breakable dependences for parallelization", + "abstract": "For decades, compilers have relied on dependence analysis to determine the legality of their transformations. While this conservative approach has enabled many robust optimizations, when it comes to parallelization there are many opportunities that can only be exploited by changing or re-ordering the dependences in the program.", + "date": "2011-06-04", + "link": "https://doi.org/10.1145/1993498.1993555", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Abhishek", + "last_name": "Udupa", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Kaushik Sunder", + "last_name": "Rajan", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "William", + "last_name": "Thies", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/pldi/UdupaRT11", + "venue": "pldi", + "year": 2011 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2012.json b/data/pl_conferences/pldi/2012.json new file mode 100644 index 0000000..fed84d8 --- /dev/null +++ b/data/pl_conferences/pldi/2012.json @@ -0,0 +1,1551 @@ +[ + { + "paper_id": "10.1145/2254064.2254099", + "title": "Self-stabilizing Java", + "abstract": "Self-stabilizing programs automatically recover from state corruption caused by software bugs and other sources to reach the correct state. A number of applications are inherently self-stabilizing---such programs typically overwrite all non-constant data with new input data. We present a type system and static analyses that together check whether a program is self-stabilizing. We combine this with a code generation strategy that ensures that a program continues executing long enough to self-stabilize. Our experience using SJava indicates that (1) SJava annotations are easy to write once one understands a program and (2) SJava successfully checked that several benchmarks were self-stabilizing.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254099", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yong hun", + "last_name": "Eom", + "institution": "University of California, Irvine" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/pldi/EomD12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254070", + "title": "The implicit calculus: a new foundation for generic programming", + "abstract": "Generic programming (GP) is an increasingly important trend in programming languages. Well-known GP mechanisms, such as type classes and the C++0x concepts proposal, usually combine two features: 1) a special type of interfaces; and 2) implicit instantiation of implementations of those interfaces.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254070", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "Seoul National University" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "Ghent University" + }, + { + "first_name": "Wontae", + "last_name": "Choi", + "institution": "Seoul National University" + }, + { + "first_name": "Wonchan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/pldi/OliveiraSCLY12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254100", + "title": "Type-directed automatic incrementalization", + "abstract": "Application data often changes slowly or incrementally over time. Since incremental changes to input often result in only small changes in output, it is often feasible to respond to such changes asymptotically more efficiently than by re-running the whole computation. Traditionally, realizing such asymptotic efficiency improvements requires designing problem-specific algorithms known as dynamic or incremental algorithms, which are often significantly more complicated than conventional algorithms to design, analyze, implement, and use. A long-standing open problem is to develop techniques that automatically transform conventional programs so that they correctly and efficiently respond to incremental changes.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254100", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yan", + "last_name": "Chen", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/ChenDA12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254124", + "title": "Logical inference techniques for loop parallelization", + "abstract": "This paper presents a fully automatic approach to loop parallelization that integrates the use of static and run-time analysis and thus overcomes many known difficulties such as nonlinear and indirect array indexing and complex control flow. Our hybrid analysis framework validates the parallelization transformation by verifying the independence of the loop's memory references. To this end it represents array references using the USR (uniform set representation) language and expresses the independence condition as an equation, S=0, where S is a set expression representing array indexes. Using a language instead of an array-abstraction representation for S results in a smaller number of conservative approximations but exhibits a potentially-high runtime cost. To alleviate this cost we introduce a language translation F from the USR set-expression language to an equally rich language of predicates (F(S) ==> S = 0). Loop parallelization is then validated using a novel logic inference algorithm that factorizes the obtained complex predicates (F(S)) into a sequence of sufficient independence conditions that are evaluated first statically and, when needed, dynamically, in increasing order of their estimated complexities. We evaluate our automated solution on 26 benchmarks from PERFECT-Club and SPEC suites and show that our approach is effective in parallelizing large, complex loops and obtains much better full program speedups than the Intel and IBM Fortran compilers.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254124", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cosmin E.", + "last_name": "Oancea", + "institution": "University of Copenhagen" + }, + { + "first_name": "Lawrence", + "last_name": "Rauchwerger", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/pldi/OanceaR12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254110", + "title": "Verifying GPU kernels by test amplification", + "abstract": "We present a novel technique for verifying properties of data parallel GPU programs via test amplification. The key insight behind our work is that we can use the technique of static information flow to amplify the result of a single test execution over the set of all inputs and interleavings that affect the property being verified. We empirically demonstrate the effectiveness of test amplification for verifying race-freedom and determinism over a large number of standard GPU kernels, by showing that the result of verifying a single dynamic execution can be amplified over the massive space of possible data inputs and thread interleavings.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254110", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alan", + "last_name": "Leung", + "institution": "University of California, San Diego" + }, + { + "first_name": "Manish", + "last_name": "Gupta", + "institution": "University of California, San Diego" + }, + { + "first_name": "Yuvraj", + "last_name": "Agarwal", + "institution": "University of California, San Diego" + }, + { + "first_name": "Rajesh K.", + "last_name": "Gupta", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/LeungGAGJL12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254072", + "title": "Speculative linearizability", + "abstract": "Linearizability is a key design methodology for reasoning about implementations of concurrent abstract data types in both shared memory and message passing systems. It provides the illusion that operations execute sequentially and fault-free, despite the asynchrony and faults inherent to a concurrent system, especially a distributed one. A key property of linearizability is inter-object composability: a system composed of linearizable objects is itself linearizable. However, devising linearizable objects is very difficult, requiring complex algorithms to work correctly under general circumstances, and often resulting in bad average-case behavior. Concurrent algorithm designers therefore resort to speculation: optimizing algorithms to handle common scenarios more efficiently. The outcome are even more complex protocols, for which it is no longer tractable to prove their correctness.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254072", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Giuliano", + "last_name": "Losa", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/GuerraouiKL12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254086", + "title": "Proving acceptability properties of relaxed nondeterministic approximate programs", + "abstract": "Approximate program transformations such as skipping tasks [29, 30], loop perforation [21, 22, 35], reduction sampling [38], multiple selectable implementations [3, 4, 16, 38], dynamic knobs [16], synchronization elimination [20, 32], approximate function memoization [11],and approximate data types [34] produce programs that can execute at a variety of points in an underlying performance versus accuracy tradeoff space. These transformed programs have the ability to trade accuracy of their results for increased performance by dynamically and nondeterministically modifying variables that control their execution.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254086", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Deokhwan", + "last_name": "Kim", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/CarbinKMR12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254094", + "title": "Fast and precise hybrid type inference for JavaScript", + "abstract": "JavaScript performance is often bound by its dynamically typed nature. Compilers do not have access to static type information, making generation of efficient, type-specialized machine code difficult. We seek to solve this problem by inferring types. In this paper we present a hybrid type inference algorithm for JavaScript based on points-to analysis. Our algorithm is fast, in that it pays for itself in the optimizations it enables. Our algorithm is also precise, generating information that closely reflects the program's actual behavior even when analyzing polymorphic code, by augmenting static analysis with run-time type barriers.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254094", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brian", + "last_name": "Hackett", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Shuyu", + "last_name": "Guo", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/HackettG12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254067", + "title": "Adaptive input-aware compilation for graphics engines", + "abstract": "While graphics processing units (GPUs) provide low-cost and efficient platforms for accelerating high performance computations, the tedious process of performance tuning required to optimize applications is an obstacle to wider adoption of GPUs. In addition to the programmability challenges posed by GPU's complex memory hierarchy and parallelism model, a well-known application design problem is target portability across different GPUs. However, even for a single GPU target, changing a program's input characteristics can make an already-optimized implementation of a program perform poorly. In this work, we propose Adaptic, an adaptive input-aware compilation system to tackle this important, yet overlooked, input portability problem. Using this system, programmers develop their applications in a high-level streaming language and let Adaptic undertake the difficult task of input portable optimizations and code generation. Several input-aware optimizations are introduced to make efficient use of the memory hierarchy and customize thread composition. At runtime, a properly optimized version of the application is executed based on the actual program input. We perform a head-to-head comparison between the Adaptic generated and hand-optimized CUDA programs. The results show that Adaptic is capable of generating codes that can perform on par with their hand-optimized counterparts over certain input ranges and outperform them when the input falls out of the hand-optimized programs' \"comfort zone\". Furthermore, we show that input-aware results are sustainable across different GPU targets making it possible to write and optimize applications once and run them anywhere.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254067", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mehrzad", + "last_name": "Samadi", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Amir", + "last_name": "Hormati", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Mojtaba", + "last_name": "Mehrara", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Janghaeng", + "last_name": "Lee", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/SamadiHMLM12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254120", + "title": "Static analysis and compiler design for idempotent processing", + "abstract": "Recovery functionality has many applications in computing systems, from speculation recovery in modern microprocessors to fault recovery in high-reliability systems. Modern systems commonly recover using checkpoints. However, checkpoints introduce overheads, add complexity, and often save more state than necessary.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254120", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marc A. de", + "last_name": "Kruijf", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Karthikeyan", + "last_name": "Sankaralingam", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Somesh", + "last_name": "Jha", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/KruijfSJ12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254075", + "title": "Understanding and detecting real-world performance bugs", + "abstract": "Developers frequently use inefficient code sequences that could be fixed by simple patches. These inefficient code sequences can cause significant performance degradation and resource waste, referred to as performance bugs. Meager increases in single threaded performance in the multi-core era and increasing emphasis on energy efficiency call for more effort in tackling performance bugs.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254075", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guoliang", + "last_name": "Jin", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Linhai", + "last_name": "Song", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Xiaoming", + "last_name": "Shi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Joel", + "last_name": "Scherpelz", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/JinSSSL12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254114", + "title": "Concurrent data representation synthesis", + "abstract": "We describe an approach for synthesizing data representations for concurrent programs. Our compiler takes as input a program written using concurrent relations and synthesizes a representation of the relations as sets of cooperating data structures as well as the placement and acquisition of locks to synchronize concurrent access to those data structures. The resulting code is correct by construction: individual relational operations are implemented correctly and the aggregate set of operations is serializable and deadlock free. The relational specification also permits a high-level optimizer to choose the best performing of many possible legal data representations and locking strategies, which we demonstrate with an experiment autotuning a graph benchmark.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254114", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter", + "last_name": "Hawkins", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/HawkinsAFRS12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254111", + "title": "RockSalt: better, faster, stronger SFI for the x86", + "abstract": "Software-based fault isolation (SFI), as used in Google's Native Client (NaCl), relies upon a conceptually simple machine-code analysis to enforce a security policy. But for complicated architectures such as the x86, it is all too easy to get the details of the analysis wrong. We have built a new checker that is smaller, faster, and has a much reduced trusted computing base when compared to Google's original analysis. The key to our approach is automatically generating the bulk of the analysis from a declarative description which we relate to a formal model of a subset of the x86 instruction set architecture. The x86 model, developed in Coq, is of independent interest and should be usable for a wide range of machine-level verification tasks.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254111", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Lehigh University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "Harvard University Press" + }, + { + "first_name": "Jean-Baptiste", + "last_name": "Tristan", + "institution": "Harvard University Press" + }, + { + "first_name": "Edward", + "last_name": "Gan", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/pldi/MorrisettTTTG12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254088", + "title": "Efficient state merging in symbolic execution", + "abstract": "Symbolic execution has proven to be a practical technique for building automated test case generation and bug finding tools. Nevertheless, due to state explosion, these tools still struggle to achieve scalability. Given a program, one way to reduce the number of states that the tools need to explore is to merge states obtained on different paths. Alas, doing so increases the size of symbolic path conditions (thereby stressing the underlying constraint solver) and interferes with optimizations of the exploration process (also referred to as search strategies). The net effect is that state merging may actually lower performance rather than increase it.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254088", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Volodymyr", + "last_name": "Kuznetsov", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Johannes", + "last_name": "Kinder", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ștefan", + "last_name": "Bucur", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "George", + "last_name": "Candea", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/KuznetsovKBC12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254071", + "title": "Deterministic parallelism via liquid effects", + "abstract": "Shared memory multithreading is a popular approach to parallel programming, but also fiendishly hard to get right. We present Liquid Effects, a type-and-effect system based on refinement types which allows for fine-grained, low-level, shared memory multi-threading while statically guaranteeing that a program is deterministic. Liquid Effects records the effect of an expression as a for- mula in first-order logic, making our type-and-effect system highly expressive. Further, effects like Read and Write are recorded in Liquid Effects as ordinary uninterpreted predicates, leaving the effect system open to extension by the user. By building our system as an extension to an existing dependent refinement type system, our system gains precise value- and branch-sensitive reasoning about effects. Finally, our system exploits the Liquid Types refinement type inference technique to automatically infer refinement types and effects. We have implemented our type-and-effect checking techniques in CSOLVE, a refinement type inference system for C programs. We demonstrate how CSOLVE uses Liquid Effects to prove the determinism of a variety of benchmarks.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254071", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ming", + "last_name": "Kawaguchi", + "institution": "University of California, San Diego" + }, + { + "first_name": "Patrick M.", + "last_name": "Rondon", + "institution": "University of California, San Diego" + }, + { + "first_name": "Alexander", + "last_name": "Bakst", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/KawaguchiRBJ12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254066", + "title": "Compiling a high-level language for GPUs: (via language support for architectures and compilers)", + "abstract": "Languages such as OpenCL and CUDA offer a standard interface for general-purpose programming of GPUs. However, with these languages, programmers must explicitly manage numerous low-level details involving communication and synchronization. This burden makes programming GPUs difficult and error-prone, rendering these powerful devices inaccessible to most programmers.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254066", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christophe", + "last_name": "Dubach", + "institution": "IBM (United States)" + }, + { + "first_name": "Perry", + "last_name": "Cheng", + "institution": "IBM (United States)" + }, + { + "first_name": "Rodric", + "last_name": "Rabbah", + "institution": "IBM (United States)" + }, + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "Stephen J.", + "last_name": "Fink", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/DubachCRBF12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254079", + "title": "Diderot: a parallel DSL for image analysis and visualization", + "abstract": "Research scientists and medical professionals use imaging technology, such as computed tomography (CT) and magnetic resonance imaging (MRI) to measure a wide variety of biological and physical objects. The increasing sophistication of imaging technology creates demand for equally sophisticated computational techniques to analyze and visualize the image data. Analysis and visualization codes are often crafted for a specific experiment or set of images, thus imaging scientists need support for quickly developing codes that are reliable, robust, and efficient.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254079", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Charisee", + "last_name": "Chiw", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Gordon", + "last_name": "Kindlmann", + "institution": "University of Chicago" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Lamont", + "last_name": "Samuels", + "institution": "University of Chicago" + }, + { + "first_name": "Nick", + "last_name": "Seltzer", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/pldi/ChiwKRSS12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254080", + "title": "Synthesising graphics card programs from DSLs", + "abstract": "Over the last five years, graphics cards have become a tempting target for scientific computing, thanks to unrivaled peak performance, often producing a runtime speed-up of x10 to x25 over comparable CPU solutions.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254080", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Luke", + "last_name": "Cartey", + "institution": "University of Oxford" + }, + { + "first_name": "Rune B.", + "last_name": "Lyngsø", + "institution": "University of Oxford" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/pldi/CarteyLM12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254123", + "title": "Polyhedra scanning revisited", + "abstract": "This paper presents a new polyhedra scanning system called CodeGen+ to address the challenge of generating high-performance code for complex iteration spaces resulting from compiler optimization and autotuning systems. The strength of our approach lies in two new algorithms. First, a loop overhead removal algorithm provides precise control of trade-offs between loop overhead and code size based on actual loop nesting depth. Second, an if-statement simplification algorithm further reduces the number of comparisons in the code. These algorithms combined with the expressive power of Presburger arithmetic enable CodeGen+ to support complex optimization strategies expressed in iteration spaces. We compare with the state-of-the-art polyhedra scanning tool CLooG on five loop nest computations, demonstrating that CodeGen+ generates code that is simpler and up to 1.15x faster.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254123", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chun", + "last_name": "Chen", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/Chen12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254122", + "title": "Effective parallelization of loops in the presence of I/O operations", + "abstract": "Software-based thread-level parallelization has been widely studied for exploiting data parallelism in purely computational loops to improve program performance on multiprocessors. However, none of the previous efforts deal with efficient parallelization of hybrid loops, i.e., loops that contain a mix of computation and I/O operations. In this paper, we propose a set of techniques for efficiently parallelizing hybrid loops. Our techniques apply DOALL parallelism to hybrid loops by breaking the cross-iteration dependences caused by I/O operations. We also support speculative execution of I/O operations to enable speculative parallelization of hybrid loops. Helper threading is used to reduce the I/O bus contention caused by the improved parallelism. We provide an easy-to-use programming model for exploiting parallelism in loops with I/O operations. Parallelizing hybrid loops using our model requires few modifications to the code. We have developed a prototype implementation of our programming model. We have evaluated our implementation on a 24-core machine using eight applications, including a widely-used genomic sequence assembler and a multi-player game server, and others from PARSEC and SPEC CPU2000 benchmark suites. The hybrid loops in these applications take 23%-99% of the total execution time on our 24-core machine. The parallelized applications achieve speedups of 3.0x-12.8x with hybrid loop parallelization over the sequential versions of the same applications. Compared to the versions of applications where only computation loops are parallelized, hybrid loop parallelization improves the application performance by 68% on average.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254122", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Min", + "last_name": "Feng", + "institution": "University of California, Riverside" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of California, Riverside" + }, + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/pldi/FengGN12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254126", + "title": "Fully automatic and precise detection of thread safety violations", + "abstract": "Concurrent, object-oriented programs often use thread-safe library classes. Existing techniques for testing a thread-safe class either rely on tests using the class, on formal specifications, or on both. Unfortunately, these techniques often are not fully automatic as they involve the user in analyzing the output. This paper presents an automatic testing technique that reveals concurrency bugs in supposedly thread-safe classes. The analysis requires as input only the class under test and reports only true positives. The key idea is to generate tests in which multiple threads call methods on a shared instance of the tested class. If a concurrent test exhibits an exception or a deadlock that cannot be triggered in any linearized execution of the test, the analysis reports a thread safety violation. The approach is easily applicable, because it is independent of hand-written tests and explicit specifications. The analysis finds 15 concurrency bugs in popular Java libraries, including two previously unknown bugs in the Java standard library.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254126", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/PradelG12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254087", + "title": "Automated error diagnosis using abductive inference", + "abstract": "When program verification tools fail to verify a program, either the program is buggy or the report is a false alarm. In this situation, the burden is on the user to manually classify the report, but this task is time-consuming, error-prone, and does not utilize facts already proven by the analysis. We present a new technique for assisting users in classifying error reports. Our technique computes small, relevant queries presented to a user that capture exactly the information the analysis is missing to either discharge or validate the error. Our insight is that identifying these missing facts is an instance of the abductive inference problem in logic, and we present a new algorithm for computing the smallest and most general abductions in this setting. We perform the first user study to rigorously evaluate the accuracy and effort involved in manual classification of error reports. Our study demonstrates that our new technique is very useful for improving both the speed and accuracy of error report classification. Specifically, our approach improves classification accuracy from 33% to 90% and reduces the time programmers take to classify error reports from approximately 5 minutes to under 1 minute.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254087", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "Williams (United States)" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "William & Mary" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/DilligDA12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254076", + "title": "Input-sensitive profiling", + "abstract": "In this paper we present a profiling methodology and toolkit for helping developers discover hidden asymptotic inefficiencies in the code. From one or more runs of a program, our profiler automatically measures how the performance of individual routines scales as a function of the input size, yielding clues to their growth rate. The output of the profiler is, for each executed routine of the program, a set of tuples that aggregate performance costs by input size. The collected profiles can be used to produce performance plots and derive trend functions by statistical curve fitting or bounding techniques. A key feature of our method is the ability to automatically measure the size of the input given to a generic code fragment: to this aim, we propose an effective metric for estimating the input size of a routine and show how to compute it efficiently. We discuss several case studies, showing that our approach can reveal asymptotic bottlenecks that other profilers may fail to detect and characterize the workload and behavior of individual routines in the context of real applications. To prove the feasibility of our techniques, we implemented a Valgrind tool called aprof and performed an extensive experimental evaluation on the SPEC CPU2006 benchmarks. Our experiments show that aprof delivers comparable performance to other prominent Valgrind tools, and can generate informative plots even from single runs on typical workloads for most algorithmically-critical routines.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254076", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Emilio", + "last_name": "Coppa", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Camil", + "last_name": "Demetrescu", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Irene", + "last_name": "Finocchi", + "institution": "Sapienza University of Rome" + } + ], + "dblp_key": "conf/pldi/CoppaDF12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254112", + "title": "Synthesizing software verifiers from proof rules", + "abstract": "Automatically generated tools can significantly improve programmer productivity. For example, parsers and dataflow analyzers can be automatically generated from declarative specifications in the form of grammars, which tremendously simplifies the task of implementing a compiler. In this paper, we present a method for the automatic synthesis of software verification tools. Our synthesis procedure takes as input a description of the employed proof rule, e.g., program safety checking via inductive invariants, and produces a tool that automatically discovers the auxiliary assertions required by the proof rule, e.g., inductive loop invariants and procedure summaries. We rely on a (standard) representation of proof rules using recursive equations over the auxiliary assertions. The discovery of auxiliary assertions, i.e., solving the equations, is based on an iterative process that extrapolates solutions obtained for finitary unrollings of equations. We show how our method synthesizes automatic safety and liveness verifiers for programs with procedures, multi-threaded programs, and functional programs. Our experimental comparison of the resulting verifiers with existing state-of-the-art verification tools confirms the practicality of the approach.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254112", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sergey", + "last_name": "Grebenshchikov", + "institution": "Technical University of Munich" + }, + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Corneliu", + "last_name": "Popeea", + "institution": "Technical University of Munich" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/pldi/GrebenshchikovLPR12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254068", + "title": "And then there were none: a stall-free real-time garbage collector for reconfigurable hardware", + "abstract": "Programmers are turning to radical architectures such as reconfigurable hardware (FPGAs) to achieve performance. But such systems, programmed at a very low level in languages with impoverished abstractions, are orders of magnitude more complex to use than conventional CPUs. The continued exponential increase in transistors, combined with the desire to implement ever more sophisticated algorithms, makes it imperative that such systems be programmed at much higher levels of abstraction. One of the fundamental high-level language features is automatic memory management in the form of garbage collection.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254068", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "Perry", + "last_name": "Cheng", + "institution": "IBM (United States)" + }, + { + "first_name": "Sunil", + "last_name": "Shukla", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/BaconCS12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254091", + "title": "Parallelizing top-down interprocedural analyses", + "abstract": "Modularity is a central theme in any scalable program analysis. The core idea in a modular analysis is to build summaries at procedure boundaries, and use the summary of a procedure to analyze the effect of calling it at its calling context. There are two ways to perform a modular program analysis: (1) top-down and (2) bottomup. A bottom-up analysis proceeds upwards from the leaves of the call graph, and analyzes each procedure in the most general calling context and builds its summary. In contrast, a top-down analysis starts from the root of the call graph, and proceeds downward, analyzing each procedure in its calling context. Top-down analyses have several applications in verification and software model checking. However, traditionally, bottom-up analyses have been easier to scale and parallelize than top-down analyses.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254091", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Toronto" + }, + { + "first_name": "Rahul", + "last_name": "Kumar", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/pldi/AlbarghouthiKNR12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254119", + "title": "Chimera: hybrid program analysis for determinism", + "abstract": "Chimera uses a new hybrid program analysis to provide deterministic replay for commodity multiprocessor systems. Chimera leverages the insight that it is easy to provide deterministic multiprocessor replay for data-race-free programs (one can just record non-deterministic inputs and the order of synchronization operations), so if we can somehow transform an arbitrary program to be data-race-free, then we can provide deterministic replay cheaply for that program. To perform this transformation, Chimera uses a sound static data-race detector to find all potential data-races. It then instruments pairs of potentially racing instructions with a weak-lock, which provides sufficient guarantees to allow deterministic replay but does not guarantee mutual exclusion.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254119", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dongyoon", + "last_name": "Lee", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Peter M.", + "last_name": "Chen", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Jason", + "last_name": "Flinn", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/LeeCFN12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254106", + "title": "A compiler framework for extracting superword level parallelism", + "abstract": "SIMD (single-instruction multiple-data) instruction set extensions are quite common today in both high performance and embedded microprocessors, and enable the exploitation of a specific type of data parallelism called SLP (Superword Level Parallelism). While prior research shows that significant performance savings are possible when SLP is exploited, placing SIMD instructions in an application code manually can be very difficult and error prone. In this paper, we propose a novel automated compiler framework for improving superword level parallelism exploitation. The key part of our framework consists of two stages: superword statement generation and data layout optimization. The first stage is our main contribution and has two phases, statement grouping and statement scheduling, of which the primary goals are to increase SIMD parallelism and, more importantly, capture more superword reuses among the superword statements through global data access and reuse pattern analysis. Further, as a complementary optimization, our data layout optimization organizes data in memory space such that the price of memory operations for SLP is minimized. The results from our compiler implementation and tests on two systems indicate performance improvements as high as 15.2% over a state-of-the-art SLP optimization algorithm.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254106", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jun", + "last_name": "Liu", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Yuanrui", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Ohyoung", + "last_name": "Jang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "W.", + "last_name": "Ding", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/pldi/LiuZJDK12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254116", + "title": "Automated synthesis of symbolic instruction encodings from I/O samples", + "abstract": "Symbolic execution is a key component of precise binary program analysis tools. We discuss how to automatically boot-strap the construction of a symbolic execution engine for a processor instruction set such as x86, x64 or ARM. We show how to automatically synthesize symbolic representations of individual processor instructions from input/output examples and express them as bit-vector constraints. We present and compare various synthesis algorithms and instruction sampling strategies. We introduce a new synthesis algorithm based on smart sampling which we show is one to two orders of magnitude faster than previous synthesis algorithms in our context. With this new algorithm, we can automatically synthesize bit-vector circuits for over 500 x86 instructions (8/16/32-bits, outputs, EFLAGS) using only 6 synthesis templates and in less than two hours using the Z3 SMT solver on a regular machine. During this work, we also discovered several inconsistencies across x86 processors, errors in the x86 Intel spec, and several bugs in previous manually-written x86 instruction handlers.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254116", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Patrice", + "last_name": "Godefroid", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ankur", + "last_name": "Taly", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/GodefroidT12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254118", + "title": "A dynamic program analysis to find floating-point accuracy problems", + "abstract": "Programs using floating-point arithmetic are prone to accuracy problems caused by rounding and catastrophic cancellation. These phenomena provoke bugs that are notoriously hard to track down: the program does not necessarily crash and the results are not necessarily obviously wrong, but often subtly inaccurate. Further use of these values can lead to catastrophic errors.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254118", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Florian", + "last_name": "Benz", + "institution": "Saarland University" + }, + { + "first_name": "Andreas", + "last_name": "Hildebrandt", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/pldi/BenzHH12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254108", + "title": "Dynamic trace-based analysis of vectorization potential of applications", + "abstract": "Recent hardware trends with GPUs and the increasing vector lengths of SSE-like ISA extensions for multicore CPUs imply that effective exploitation of SIMD parallelism is critical for achieving high performance on emerging and future architectures. A vast majority of existing applications were developed without any attention by their developers towards effective vectorizability of the codes. While developers of production compilers such as GNU gcc, Intel icc, PGI pgcc, and IBM xlc have invested considerable effort and made significant advances in enhancing automatic vectorization capabilities, these compilers still cannot effectively vectorize many existing scientific and engineering codes. It is therefore of considerable interest to analyze existing applications to assess the inherent latent potential for SIMD parallelism, exploitable through further compiler advances and/or via manual code changes.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254108", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Justin", + "last_name": "Holewinski", + "institution": "The Ohio State University" + }, + { + "first_name": "Ragavendar", + "last_name": "Ramamurthi", + "institution": "The Ohio State University" + }, + { + "first_name": "M.", + "last_name": "Ravishankar", + "institution": "The Ohio State University" + }, + { + "first_name": "Naznin", + "last_name": "Fauzia", + "institution": "The Ohio State University" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "The Ohio State University" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/HolewinskiRRFPRS12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254096", + "title": "Engage: a deployment management system", + "abstract": "Many modern applications are built by combining independently developed packages and services that are distributed over many machines with complex inter-dependencies. The assembly, installation, and management of such applications is hard, and usually performed either manually or by writing customized scripts. We present Engage, a system for configuring, installing, and managing complex application stacks. Engage consists of three components: a domain-specific model to describe component metadata and inter-component dependencies; a constraint-based algorithm that takes a partial installation specification and computes a full installation plan; and a runtime system that co-ordinates the deployment of the application across multiple machines and manages the deployed system. By explicitly modeling configuration metadata and inter-component dependencies, Engage enables static checking of application configurations and automated, constraint-driven, generation of installation plans across multiple machines. This reduces the tedious manual process of application configuration, installation, and management.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254096", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeffrey", + "last_name": "Fischer", + "institution": "" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Shahram", + "last_name": "Esmaeilsabzali", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/FischerME12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254103", + "title": "SuperC: parsing all of C by taming the preprocessor", + "abstract": "C tools, such as source browsers, bug finders, and automated refactorings, need to process two languages: C itself and the preprocessor. The latter improves expressivity through file includes, macros, and static conditionals. But it operates only on tokens, making it hard to even parse both languages. This paper presents a complete, performant solution to this problem. First, a configuration-preserving preprocessor resolves includes and macros yet leaves static conditionals intact, thus preserving a program's variability. To ensure completeness, we analyze all interactions between preprocessor features and identify techniques for correctly handling them. Second, a configuration-preserving parser generates a well-formed AST with static choice nodes for conditionals. It forks new subparsers when encountering static conditionals and merges them again after the conditionals. To ensure performance, we present a simple algorithm for table-driven Fork-Merge LR parsing and four novel optimizations. We demonstrate the effectiveness of our approach on the x86 Linux kernel.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254103", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Paul", + "last_name": "Gazzillo", + "institution": "New York University" + }, + { + "first_name": "Robert", + "last_name": "Grimm", + "institution": "New York University" + } + ], + "dblp_key": "conf/pldi/GazzilloG12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254107", + "title": "Speculative separation for privatization and reductions", + "abstract": "Automatic parallelization is a promising strategy to improve application performance in the multicore era. However, common programming practices such as the reuse of data structures introduce artificial constraints that obstruct automatic parallelization. Privatization relieves these constraints by replicating data structures, thus enabling scalable parallelization. Prior privatization schemes are limited to arrays and scalar variables because they are sensitive to the layout of dynamic data structures. This work presents Privateer, the first fully automatic privatization system to handle dynamic and recursive data structures, even in languages with unrestricted pointers. To reduce sensitivity to memory layout, Privateer speculatively separates memory objects. Privateer's lightweight runtime system validates speculative separation and speculative privatization to ensure correct parallel execution. Privateer enables automatic parallelization of general-purpose C/C++ applications, yielding a geomean whole-program speedup of 11.4x over best sequential execution on 24 cores, while non-speculative parallelization yields only 0.93x.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254107", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nick", + "last_name": "Johnson", + "institution": "Princeton University" + }, + { + "first_name": "Hanjun", + "last_name": "Kim", + "institution": "Princeton University" + }, + { + "first_name": "Prakash", + "last_name": "Prabhu", + "institution": "Princeton University" + }, + { + "first_name": "Ayal", + "last_name": "Zaks", + "institution": "Israel Electric (Israel)" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/JohnsonKPZA12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254128", + "title": "Multicore acceleration of priority-based schedulers for concurrency bug detection", + "abstract": "Testing multithreaded programs is difficult as threads can interleave in a nondeterministic fashion. Untested interleavings can cause failures, but testing all interleavings is infeasible. Many interleaving exploration strategies for bug detection have been proposed, but their relative effectiveness and performance remains unclear as they often lack publicly available implementations and have not been evaluated using common benchmarks. We describe NeedlePoint, an open-source framework that allows selection and comparison of a wide range of interleaving exploration policies for bug detection proposed by prior work.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254128", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Milo M. K.", + "last_name": "Martin", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/NagarakatteBMM12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254095", + "title": "Race detection for web applications", + "abstract": "Modern web pages are becoming increasingly full-featured, and this additional functionality often requires greater use of asynchrony. Unfortunately, this asynchrony can trigger unexpected concurrency errors, even though web page scripts are executed sequentially.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254095", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Boris", + "last_name": "Petrov", + "institution": "Sofia University \"St. Kliment Ohridski\"" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "IBM (United States)" + }, + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/PetrovVSD12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254078", + "title": "Language-based control and mitigation of timing channels", + "abstract": "We propose a new language-based approach to mitigating timing channels. In this language, well-typed programs provably leak only a bounded amount of information over time through external timing channels. By incorporating mechanisms for predictive mitigation of timing channels, this approach also permits a more expressive programming model. Timing channels arising from interaction with underlying hardware features such as instruction caches are controlled. Assumptions about the underlying hardware are explicitly formalized, supporting the design of hardware that efficiently controls timing channels. One such hardware design is modeled and used to show that timing channels can be controlled in some simple programs of real-world significance.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254078", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Cornell University" + }, + { + "first_name": "Aslan", + "last_name": "Askarov", + "institution": "Harvard University Press" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/ZhangAM12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254104", + "title": "Test-case reduction for C compiler bugs", + "abstract": "To report a compiler bug, one must often find a small test case that triggers the bug. The existing approach to automated test-case reduction, delta debugging, works by removing substrings of the original input; the result is a concatenation of substrings that delta cannot remove. We have found this approach less than ideal for reducing C programs because it typically yields test cases that are too large or even invalid (relying on undefined behavior). To obtain small and valid test cases consistently, we designed and implemented three new, domain-specific test-case reducers. The best of these is based on a novel framework in which a generic fixpoint computation invokes modular transformations that perform reduction operations. This reducer produces outputs that are, on average, more than 25 times smaller than those produced by our other reducers or by the existing reducer that is most commonly used by compiler developers. We conclude that effective program reduction requires more than straightforward delta debugging.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254104", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + }, + { + "first_name": "Yang", + "last_name": "Chen", + "institution": "University of Utah" + }, + { + "first_name": "Pascal", + "last_name": "Cuoq", + "institution": "Laboratoire d'Intégration des Systèmes et des Technologies" + }, + { + "first_name": "Eric", + "last_name": "Eide", + "institution": "University of Utah" + }, + { + "first_name": "Chucky", + "last_name": "Ellison", + "institution": "University of Illinois System" + }, + { + "first_name": "Xuejun", + "last_name": "Yang", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/RegehrCCEEY12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254082", + "title": "Parcae: a system for flexible parallel execution", + "abstract": "Workload, platform, and available resources constitute a parallel program's execution environment. Most parallelization efforts statically target an anticipated range of environments, but performance generally degrades outside that range. Existing approaches address this problem with dynamic tuning but do not optimize a multiprogrammed system holistically. Further, they either require manual programming effort or are limited to array-based data-parallel programs.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254082", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Arun", + "last_name": "Raman", + "institution": "Intel (United States)" + }, + { + "first_name": "Ayal", + "last_name": "Zaks", + "institution": "Israel Electric (Israel)" + }, + { + "first_name": "Jae W.", + "last_name": "Lee", + "institution": "Sungkyunkwan University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/RamanZLA12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254092", + "title": "Design and implementation of sparse global analyses for C-like languages", + "abstract": "In this article we present a general method for achieving global static analyzers that are precise, sound, yet also scalable. Our method generalizes the sparse analysis techniques on top of the abstract interpretation framework to support relational as well as non-relational semantics properties for C-like languages. We first use the abstract interpretation framework to have a global static analyzer whose scalability is unattended. Upon this underlying sound static analyzer, we add our generalized sparse analysis techniques to improve its scalability while preserving the precision of the underlying analysis. Our framework determines what to prove to guarantee that the resulting sparse version should preserve the precision of the underlying analyzer.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254092", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Seoul National University" + }, + { + "first_name": "Kihong", + "last_name": "Heo", + "institution": "Seoul National University" + }, + { + "first_name": "Wonchan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Woosuk", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/pldi/OhHLLY12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254115", + "title": "Dynamic synthesis for relaxed memory models", + "abstract": "Modern architectures implement relaxed memory models which may reorder memory operations or execute them non-atomically. Special instructions called memory fences are provided, allowing control of this behavior.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254115", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Feng", + "last_name": "Liu", + "institution": "Princeton University" + }, + { + "first_name": "Nayden", + "last_name": "Nedev", + "institution": "Princeton University" + }, + { + "first_name": "Nedyalko", + "last_name": "Prisadnikov", + "institution": "Sofia University \"St. Kliment Ohridski\"" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/LiuNPVY12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254074", + "title": "Algorithmic profiling", + "abstract": "Traditional profilers identify where a program spends most of its resources. They do not provide information about why the program spends those resources or about how resource consumption would change for different program inputs. In this paper we introduce the idea of algorithmic profiling. While a traditional profiler determines a set of measured cost values, an algorithmic profiler determines a cost function. It does that by automatically determining the \"inputs\" of a program, by measuring the program's \"cost\" for any given input, and by inferring an empirical cost function.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254074", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dmitrijs", + "last_name": "Zaparanuks", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Matthias", + "last_name": "Hauswirth", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/pldi/ZaparanuksH12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254102", + "title": "Synchronising C/C++ and POWER", + "abstract": "Shared memory concurrency relies on synchronisation primitives: compare-and-swap, load-reserve/store-conditional (aka LL/SC), language-level mutexes, and so on. In a sequentially consistent setting, or even in the TSO setting of x86 and Sparc, these have well-understood semantics. But in the very relaxed settings of IBM®, POWER®, ARM, or C/C++, it remains surprisingly unclear exactly what the programmer can depend on.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254102", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of Cambridge" + }, + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Cambridge" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jade", + "last_name": "Alglave", + "institution": "University of Oxford" + }, + { + "first_name": "Derek", + "last_name": "Williams", + "institution": "IBM Research - Austin" + } + ], + "dblp_key": "conf/pldi/SarkarMOBSMAW12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254083", + "title": "JANUS: exploiting parallelism via hindsight", + "abstract": "This paper addresses the problem of reducing unnecessary conflicts in optimistic synchronization. Optimistic synchronization must ensure that any two concurrently executing transactions that commit are properly synchronized. Conflict detection is an approximate check for this condition. For efficiency, the traditional approach to conflict detection conservatively checks that the memory locations mutually accessed by two concurrent transactions are accessed only for reading.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254083", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "Tel Aviv University" + }, + { + "first_name": "Roman", + "last_name": "Manevich", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "John K.", + "last_name": "Field", + "institution": "Google (United States)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/TrippMFS12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254084", + "title": "Reagents: expressing and composing fine-grained concurrency", + "abstract": "Efficient communication and synchronization is crucial for fine grained parallelism. Libraries providing such features, while indispensable, are difficult to write, and often cannot be tailored or composed to meet the needs of specific users. We introduce reagents, a set of combinators for concisely expressing concurrency algorithms. Reagents scale as well as their hand-coded counterparts, while providing the composability existing libraries lack.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254084", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/Turon12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254127", + "title": "Scalable and precise dynamic datarace detection for structured parallelism", + "abstract": "Existing dynamic race detectors suffer from at least one of the following three limitations:", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254127", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Raghavan", + "last_name": "Raman", + "institution": "Rice University" + }, + { + "first_name": "Jisheng", + "last_name": "Zhao", + "institution": "Rice University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/RamanZSVY12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254098", + "title": "Type-directed completion of partial expressions", + "abstract": "Modern programming frameworks provide enormous libraries arranged in complex structures, so much so that a large part of modern programming is searching for APIs that surely exist\" somewhere in an unfamiliar part of the framework. We present a novel way of phrasing a search for an unknown API: the programmer simply writes an expression leaving holes for the parts they do not know. We call these expressions partial expressions. We present an efficient algorithm that produces likely completions ordered by a ranking scheme based primarily on the similarity of the types of the APIs suggested to the types of the known expressions. This gives a powerful language for both API discovery and code completion with a small impedance mismatch from writing code. In an automated experiment on mature C# projects, we show our algorithm can place the intended expression in the top 10 choices over 80% of the time.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254098", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Perelman", + "institution": "University of Washington" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/PerelmanGBG12", + "venue": "pldi", + "year": 2012 + }, + { + "paper_id": "10.1145/2254064.2254090", + "title": "Sound and precise analysis of parallel programs through schedule specialization", + "abstract": "Parallel programs are known to be difficult to analyze. A key reason is that they typically have an enormous number of execution interleavings, or schedules. Static analysis over all schedules requires over-approximations, resulting in poor precision; dynamic analysis rarely covers more than a tiny fraction of all schedules. We propose an approach called schedule specialization to analyze a parallel program over only a small set of schedules for precision, and then enforce these schedules at runtime for soundness of the static analysis results. We build a schedule specialization framework for C/C++ multithreaded programs that use Pthreads. Our framework avoids the need to modify every analysis to be schedule-aware by specializing a program into a simpler program based on a schedule, so that the resultant program can be analyzed with stock analyses for improved precision. Moreover, our framework provides a precise schedule-aware def-use analysis on memory locations, enabling us to build three highly precise analyses: an alias analyzer, a data-race detector, and a path slicer. Evaluation on 17 programs, including 2 real-world programs and 15 popular benchmarks, shows that analyses using our framework reduced may-aliases by 61.9%, false race reports by 69%, and path slices by 48.7%; and detected 7 unknown bugs in well-checked programs.", + "date": "2012-06-11", + "link": "https://doi.org/10.1145/2254064.2254090", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jingyue", + "last_name": "Wu", + "institution": "Columbia University" + }, + { + "first_name": "Yang", + "last_name": "Tang", + "institution": "Columbia University" + }, + { + "first_name": "Gang", + "last_name": "Hu", + "institution": "Columbia University" + }, + { + "first_name": "Heming", + "last_name": "Cui", + "institution": "Columbia University" + }, + { + "first_name": "Junfeng", + "last_name": "Yang", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/pldi/WuTHCY12", + "venue": "pldi", + "year": 2012 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2013.json b/data/pl_conferences/pldi/2013.json new file mode 100644 index 0000000..3d8aeb3 --- /dev/null +++ b/data/pl_conferences/pldi/2013.json @@ -0,0 +1,1531 @@ +[ + { + "paper_id": "10.1145/2491956.2462196", + "title": "Fast RMWs for TSO: semantics and implementation", + "abstract": "Read-Modify-Write (RMW) instructions are widely used as the building blocks of a variety of higher level synchronization constructs, including locks, barriers, and lock-free data structures. Unfortunately, they are expensive in architectures such as x86 and SPARC which enforce (variants of) Total-Store-Order (TSO). A key reason is that RMWs in these architectures are ordered like a memory barrier, incurring the cost of a write-buffer drain in the critical path. Such strong ordering semantics are dictated by the requirements of the strict atomicity definition (type-1) that existing TSO RMWs use. Programmers often do not need such strong semantics. Besides, weakening the atomicity definition of TSO RMWs, would also weaken their ordering -- thereby leading to more efficient hardware implementations.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462196", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bharghava", + "last_name": "Rajaram", + "institution": "University of Edinburgh" + }, + { + "first_name": "Vijay", + "last_name": "Nagarajan", + "institution": "University of Edinburgh" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of St Andrews" + }, + { + "first_name": "Marco", + "last_name": "Elver", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/RajaramNSE13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462175", + "title": "AutoSynch: an automatic-signal monitor based on predicate tagging", + "abstract": "Most programming languages use monitors with explicit signals for synchronization in shared-memory programs. Requiring programmers to signal threads explicitly results in many concurrency bugs due to missed notifications, or notifications on wrong condition variables. In this paper, we describe an implementation of an automatic signaling monitor in Java called AutoSynch that eliminates such concurrency bugs by removing the burden of signaling from the programmer. We show that the belief that automatic signaling monitors are prohibitively expensive is wrong. For most problems, programs based on AutoSynch are almost as fast as those based on explicit signaling. For some, AutoSynch is even faster than explicit signaling because it never uses signalAll, whereas the programmers end up using signalAll with the explicit signal mechanism.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462175", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wei-Lun", + "last_name": "Hung", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Vijay K.", + "last_name": "Garg", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/HungG13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462167", + "title": "CLAP: recording local executions to reproduce concurrency failures", + "abstract": "We present CLAP, a new technique to reproduce concurrency bugs. CLAP has two key steps. First, it logs thread local execution paths at runtime. Second, offline, it computes memory dependencies that accord with the logged execution and are able to reproduce the observed bug. The second step works by combining constraints from the thread paths and constraints based on a memory model, and computing an execution with a constraint solver.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462167", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/pldi/HuangZD13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462181", + "title": "SMAT: an input adaptive auto-tuner for sparse matrix-vector multiplication", + "abstract": "Sparse Matrix Vector multiplication (SpMV) is an important kernel in both traditional high performance computing and emerging data-intensive applications. By far, SpMV libraries are optimized by either application-specific or architecture-specific approaches, making the libraries become too complicated to be used extensively in real applications. In this work we develop a Sparse Matrix-vector multiplication Auto-Tuning system (SMAT) to bridge the gap between specific optimizations and general-purpose usage. SMAT provides users with a unified programming interface in compressed sparse row (CSR) format and automatically determines the optimal format and implementation for any input sparse matrix at runtime. For this purpose, SMAT leverages a learning model, which is generated in an off-line stage by a machine learning method with a training set of more than 2000 matrices from the UF sparse matrix collection, to quickly predict the best combination of the matrix feature parameters. Our experiments show that SMAT achieves impressive performance of up to 51GFLOPS in single-precision and 37GFLOPS in double-precision on mainstream x86 multi-core processors, which are both more than 3 times faster than the Intel MKL library. We also demonstrate its adaptability in an algebraic multigrid solver from Hypre library with above 20% performance improvement reported.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462181", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jiajia", + "last_name": "Li", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Guangming", + "last_name": "Tan", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Mingyu", + "last_name": "Chen", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Ninghui", + "last_name": "Sun", + "institution": "Institute of Computing Technology" + } + ], + "dblp_key": "conf/pldi/LiTCS13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462170", + "title": "It's alive! continuous feedback in UI programming", + "abstract": "Live programming allows programmers to edit the code of a running program and immediately see the effect of the code changes. This tightening of the traditional edit-compile-run cycle reduces the cognitive gap between program code and execution, improving the learning experience of beginning programmers while boosting the productivity of seasoned ones. Unfortunately, live programming is difficult to realize in practice as imperative languages lack well-defined abstraction boundaries that make live programming responsive or its feedback comprehensible.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462170", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Peli de", + "last_name": "Halleux", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sean", + "last_name": "McDirmid", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Michał", + "last_name": "Moskal", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nikolai", + "last_name": "Tillmann", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jun", + "last_name": "Kato", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/pldi/BurckhardtFHMMTK13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462192", + "title": "Complete completion using types and weights", + "abstract": "Developing modern software typically involves composing functionality from existing libraries. This task is difficult because libraries may expose many methods to the developer. To help developers in such scenarios, we present a technique that synthesizes and suggests valid expressions of a given type at a given program point. As the basis of our technique we use type inhabitation for lambda calculus terms in long normal form. We introduce a succinct representation for type judgements that merges types into equivalence classes to reduce the search space, then reconstructs any desired number of solutions on demand. Furthermore, we introduce a method to rank solutions based on weights derived from a corpus of code. We implemented the algorithm and deployed it as a plugin for the Eclipse IDE for Scala. We show that the techniques we incorporated greatly increase the effectiveness of the approach. Our evaluation benchmarks are code examples from programming practice; we make them available for future comparisons.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462192", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tihomir", + "last_name": "Gvero", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ivan", + "last_name": "Kuraj", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/GveroKKP13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462172", + "title": "Concurrent libraries with foresight", + "abstract": "Linearizable libraries provide operations that appear to execute atomically. Clients, however, may need to execute a sequence of operations (a composite operation) atomically. We consider the problem of extending a linearizable library to support arbitrary atomic composite operations by clients. We introduce a novel approach in which the concurrent library ensures atomicity of composite operations by exploiting information (foresight) provided by its clients. We use a correctness condition, based on a notion of dynamic right-movers, that guarantees that composite operations execute atomically without deadlocks, and without using rollbacks.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462172", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guy", + "last_name": "Golan-Gueta", + "institution": "Tel Aviv University" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Golan-GuetaRSY13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2491976", + "title": "SPLLIFT: statically analyzing software product lines in minutes instead of years", + "abstract": "A software product line (SPL) encodes a potentially large variety of software products as variants of some common code base. Up until now, re-using traditional static analyses for SPLs was virtually intractable, as it required programmers to generate and analyze all products individually. In this work, however, we show how an important class of existing inter-procedural static analyses can be transparently lifted to SPLs. Without requiring programmers to change a single line of code, our approach SPLLIFT automatically converts any analysis formulated for traditional programs within the popular IFDS framework for inter-procedural, finite, distributive, subset problems to an SPL-aware analysis formulated in the IDE framework, a well-known extension to IFDS. Using a full implementation based on Heros, Soot, CIDE and JavaBDD, we show that with SPLLIFT one can reuse IFDS-based analyses without changing a single line of code. Through experiments using three static analyses applied to four Java-based product lines, we were able to show that our approach produces correct results and outperforms the traditional approach by several orders of magnitude.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2491976", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Társis", + "last_name": "Tolêdo", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Márcio", + "last_name": "Ribeiro", + "institution": "Universidade Federal de Alagoas" + }, + { + "first_name": "Claus", + "last_name": "Brabrand", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Paulo", + "last_name": "Borba", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/pldi/BoddenTRBBM13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462157", + "title": "Look up!: your future is in the cloud", + "abstract": "The \"Cloud\" is a wonderfully expansive phrase used to denote computation and data storage centralized in a large datacenter and elastically accessed across a network. The concept is not new; web sites and business servers have run in datacenters for a long time. These, however, were specialized applications, outside of the mainstream of desktop programs. The past few years has seen enormous change as the mainstream shifts from a single computer to mobile devices and clusters of computers. Three factors are driving this change. 1) Mobile computing, where apps run on a size- and power-constrained device and would be far less interesting without backend systems to augment computation and storage capacity. 2) Big data, which uses clusters of computers to extract valuable information from vast amounts of unstructured data. 3) Inexpensive, elastic computing, pioneered by Amazon Web Services, which enables everyone to rapidly obtain and use many servers.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462157", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Larus13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462173", + "title": "Taming compiler fuzzers", + "abstract": "Aggressive random testing tools (\"fuzzers\") are impressively effective at finding compiler bugs. For example, a single test-case generator has resulted in more than 1,700 bugs reported for a single JavaScript engine. However, fuzzers can be frustrating to use: they indiscriminately and repeatedly find bugs that may not be severe enough to fix right away. Currently, users filter out undesirable test cases using ad hoc methods such as disallowing problematic features in tests and grepping test results. This paper formulates and addresses the fuzzer taming problem: given a potentially large number of random test cases that trigger failures, order them such that diverse, interesting test cases are highly ranked. Our evaluation shows our ability to solve the fuzzer taming problem for 3,799 test cases triggering 46 bugs in a C compiler and 2,603 test cases triggering 28 bugs in a JavaScript engine.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462173", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yang", + "last_name": "Chen", + "institution": "University of Utah" + }, + { + "first_name": "Alex", + "last_name": "Groce", + "institution": "Oregon State University" + }, + { + "first_name": "Chaoqiang", + "last_name": "Zhang", + "institution": "Oregon State University" + }, + { + "first_name": "W. Eric", + "last_name": "Wong", + "institution": "Oregon State University" + }, + { + "first_name": "Xiaoli Z.", + "last_name": "Fern", + "institution": "Oregon State University" + }, + { + "first_name": "Eric", + "last_name": "Eide", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/ChenGZWFER13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2491967", + "title": "Compiler testing via a theory of sound optimisations in the C11/C++11 memory model", + "abstract": "Compilers sometimes generate correct sequential code but break the concurrency memory model of the programming language: these subtle compiler bugs are observable only when the miscompiled functions interact with concurrent contexts, making them particularly hard to detect. In this work we design a strategy to reduce the hard problem of hunting concurrency compiler bugs to differential testing of sequential code and build a tool that puts this strategy to work. Our first contribution is a theory of sound optimisations in the C11/C++11 memory model, covering most of the optimisations we have observed in real compilers and validating the claim that common compiler optimisations are sound in the C11/C++11 memory model. Our second contribution is to show how, building on this theory, concurrency compiler bugs can be identified by comparing the memory trace of compiled code against a reference memory trace for the source code. Our tool identified several mistaken write introductions and other unexpected behaviours in the latest release of the gcc compiler.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2491967", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Robin", + "last_name": "Morisset", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Pankaj", + "last_name": "Pawan", + "institution": "Chhatrapati Shahu Ji Maharaj University" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/MorissetPN13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462162", + "title": "CONCURRIT: a domain specific language for reproducing concurrency bugs", + "abstract": "We present CONCURRIT, a domain-specific language (DSL) for reproducing concurrency bugs. Given some partial information about the nature of a bug in an application, a programmer can write a CONCURRIT script to formally and concisely specify a set of thread schedules to explore in order to find a schedule exhibiting the bug. Further, the programmer can specify how these thread schedules should be searched to find a schedule that reproduces the bug. We implemented CONCURRIT as an embedded DSL in C++, which uses manual or automatic source instrumentation to partially control the scheduling of the software under test. Using CONCURRIT, we were able to write concise tests to reproduce concurrency bugs in a variety of benchmarks, including the Mozilla's SpiderMonkey JavaScript engine, Memcached, Apache's HTTP server, and MySQL.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462162", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tayfun", + "last_name": "Elmas", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Jacob", + "last_name": "Burnim", + "institution": "University of California, Berkeley" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/ElmasBNS13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462187", + "title": "When polyhedral transformations meet SIMD code generation", + "abstract": "Data locality and parallelism are critical optimization objectives for performance on modern multi-core machines. Both coarse-grain parallelism (e.g., multi-core) and fine-grain parallelism (e.g., vector SIMD) must be effectively exploited, but despite decades of progress at both ends, current compiler optimization schemes that attempt to address data locality and both kinds of parallelism often fail at one of the three objectives.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462187", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Kong", + "institution": "The Ohio State University" + }, + { + "first_name": "Richard", + "last_name": "Veras", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kevin", + "last_name": "Stock", + "institution": "The Ohio State University" + }, + { + "first_name": "Franz", + "last_name": "Franchetti", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/KongVSFPS13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462184", + "title": "P: safe asynchronous event-driven programming", + "abstract": "We describe the design and implementation of P, a domain-specific language to write asynchronous event driven code. P allows the programmer to specify the system as a collection of interacting state machines, which communicate with each other using events. P unifies modeling and programming into one activity for the programmer. Not only can a P program be compiled into executable code, but it can also be tested using model checking techniques. P allows the programmer to specify the environment, used to \"close\" the system during testing, as nondeterministic ghost machines. Ghost machines are erased during compilation to executable code; a type system ensures that the erasure is semantics preserving.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462184", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ankush", + "last_name": "Desai", + "institution": "Microsoft (India)" + }, + { + "first_name": "Vivek", + "last_name": "Gupta", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ethan K.", + "last_name": "Jackson", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Damien", + "last_name": "Zufferey", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "conf/pldi/DesaiGJQRZ13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462161", + "title": "Asynchronous functional reactive programming for GUIs", + "abstract": "Graphical user interfaces (GUIs) mediate many of our interactions with computers. Functional Reactive Programming (FRP) is a promising approach to GUI design, providing high-level, declarative, compositional abstractions to describe user interactions and time-dependent computations. We present Elm, a practical FRP language focused on easy creation of responsive GUIs. Elm has two major features: simple declarative support for Asynchronous FRP; and purely functional graphical layout.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462161", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Evan", + "last_name": "Czaplicki", + "institution": "Harvard University Press" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/pldi/CzaplickiC13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462180", + "title": "Optimizing database-backed applications with query synthesis", + "abstract": "Object-relational mapping libraries are a popular way for applications to interact with databases because they provide transparent access to the database using the same language as the application. Unfortunately, using such frameworks often leads to poor performance, as modularity concerns encourage developers to implement relational operations in application code. Such application code does not take advantage of the optimized relational implementations that database systems provide, such as efficient implementations of joins or push down of selection predicates. In this paper we present QBS, a system that automatically transforms fragments of application logic into SQL queries. QBS differs from traditional compiler optimizations as it relies on synthesis technology to generate invariants and postconditions for a code fragment. The postconditions and invariants are expressed using a new theory of ordered relations that allows us to reason precisely about both the contents and order of the records produced complex code fragments that compute joins and aggregates. The theory is close in expressiveness to SQL, so the synthesized postconditions can be readily translated to SQL queries. Using 75 code fragments automatically extracted from over 120k lines of open-source code written using the Java Hibernate ORM, we demonstrate that our approach can convert a variety of imperative constructs into relational specifications and significantly improve application performance asymptotically by orders of magnitude.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462180", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "" + }, + { + "first_name": "Samuel", + "last_name": "Madden", + "institution": "" + } + ], + "dblp_key": "conf/pldi/CheungSM13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462188", + "title": "Almost-correct specifications: a modular semantic framework for assigning confidence to warnings", + "abstract": "Modular assertion checkers are plagued with false alarms due to the need for precise environment specifications (preconditions and callee postconditions). Even the fully precise checkers report assertion failures under the most demonic environments allowed by unconstrained or partial specifications. The inability to preclude overly adversarial environments makes such checkers less attractive to developers and severely limits the adoption of such tools in the development cycle.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462188", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sam", + "last_name": "Blackshear", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/BlackshearL13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462171", + "title": "Using managed runtime systems to tolerate holes in wearable memories", + "abstract": "New memory technologies, such as phase-change memory (PCM), promise denser and cheaper main memory, and are expected to displace DRAM. However, many of them experience permanent failures far more quickly than DRAM. DRAM mechanisms that handle permanent failures rely on very low failure rates and, if directly applied to PCM, are extremely inefficient: Discarding a page when the first line fails wastes 98% of the memory.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462171", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tiejun", + "last_name": "Gao", + "institution": "Australian National University" + }, + { + "first_name": "Karin", + "last_name": "Strauß", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Doug", + "last_name": "Burger", + "institution": "Microsoft (United States)" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/GaoSBMBL13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462158", + "title": "Programming languages in security: keynote", + "abstract": "No abstract available.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462158", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fred B.", + "last_name": "Schneider", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/Schneider13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462193", + "title": "Steal Tree: low-overhead tracing of work stealing schedulers", + "abstract": "Work stealing is a popular approach to scheduling task-parallel programs. The flexibility inherent in work stealing when dealing with load imbalance results in seemingly irregular computation structures, complicating the study of its runtime behavior. In this paper, we present an approach to efficiently trace async-finish parallel programs scheduled using work stealing. We identify key properties that allow us to trace the execution of tasks with low time and space overheads. We also study the usefulness of the proposed schemes in supporting algorithms for data-race detection and retentive stealing presented in the literature. We demonstrate that the perturbation due to tracing is within the variation in the execution time with 99% confidence and the traces are concise, amounting to a few tens of kilobytes per thread in most cases. We also demonstrate that the traces enable significant reductions in the cost of detecting data races and result in low, stable space overheads in supporting retentive stealing for async-finish programs.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462193", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Lifflander", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "Laxmikant V.", + "last_name": "Kalé", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/LifflanderKK13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462160", + "title": "Rely-guarantee references for refinement types over aliased mutable data", + "abstract": "Reasoning about side effects and aliasing is the heart of verifying imperative programs. Unrestricted side effects through one reference can invalidate assumptions about an alias. We present a new type system approach to reasoning about safe assumptions in the presence of aliasing and side effects, unifying ideas from reference immutability type systems and rely-guarantee program logics. Our approach, rely-guarantee references, treats multiple references to shared objects similarly to multiple threads in rely-guarantee program logics. We propose statically associating rely and guarantee conditions with individual references to shared objects. Multiple aliases to a given object may coexist only if the guarantee condition of each alias implies the rely condition for all other aliases. We demonstrate that existing reference immutability type systems are special cases of rely-guarantee references.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462160", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "University of Washington" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/GordonEG13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462190", + "title": "How to combine widening and narrowing for non-monotonic systems of equations", + "abstract": "Non-trivial analysis problems require complete lattices with infinite ascending and descending chains. In order to compute reasonably precise post-fixpoints of the resulting systems of equations, Cousot and Cousot have suggested accelerated fixpoint iteration by means of widening and narrowing.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462190", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kalmer", + "last_name": "Apinis", + "institution": "" + }, + { + "first_name": "Helmut", + "last_name": "Seidl", + "institution": "" + }, + { + "first_name": "Vesal", + "last_name": "Vojdani", + "institution": "" + } + ], + "dblp_key": "conf/pldi/ApinisSV13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462189", + "title": "Modular verification of linearizability with non-fixed linearization points", + "abstract": "Locating linearization points (LPs) is an intuitive approach for proving linearizability, but it is difficult to apply the idea in Hoare-style logic for formal program verification, especially for verifying algorithms whose LPs cannot be statically located in the code. In this paper, we propose a program logic with a lightweight instrumentation mechanism which can verify algorithms with non-fixed LPs, including the most challenging ones that use the helping mechanism to achieve lock-freedom (as in HSY elimination-based stack), or have LPs depending on unpredictable future executions (as in the lazy set algorithm), or involve both features. We also develop a thread-local simulation as the meta-theory of our logic, and show it implies contextual refinement, which is equivalent to linearizability. Using our logic we have successfully verified various classic algorithms, some of which are used in the java.util.concurrent package.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462189", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "University of Science and Technology of China" + } + ], + "dblp_key": "conf/pldi/LiangF13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462165", + "title": "Scalable variable and data type detection in a binary rewriter", + "abstract": "We present scalable static analyses to recover variables, data types, and function prototypes from stripped x86 executables (without symbol or debug information) and obtain a functional intermediate representation (IR) for analysis and rewriting purposes. Our techniques on average run 352X faster than current techniques and still have the same precision. This enables analyzing executables as large as millions of instructions in minutes which is not possible using existing techniques. Our techniques can recover variables allocated to the floating point stack unlike current techniques. We have integrated our techniques to obtain a compiler level IR that works correctly if recompiled and produces the same output as the input executable. We demonstrate scalability, precision and correctness of our proposed techniques by evaluating them on the complete SPEC2006 benchmarks suite.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462165", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Khaled", + "last_name": "ElWazeer", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Kapil", + "last_name": "Anand", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Aparna", + "last_name": "Kotha", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Matthew", + "last_name": "Smithson", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Rajeev", + "last_name": "Barua", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/ElwazeerAKSB13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462194", + "title": "Reconciling exhaustive pattern matching with objects", + "abstract": "Pattern matching, an important feature of functional languages, is in conflict with data abstraction and extensibility, which are central to object-oriented languages. Modal abstraction offers an integration of deep pattern matching and convenient iteration abstractions into an object-oriented setting; however, because of data abstraction, it is challenging for a compiler to statically verify properties such as exhaustiveness. In this work, we extend modal abstraction in the JMatch language to support static, modular reasoning about exhaustiveness and redundancy. New matching specifications allow these properties to be checked using an SMT solver. We also introduce expressive pattern-matching constructs. Our evaluation shows that these new features enable more concise code and that the performance of checking exhaustiveness and redundancy is acceptable.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462194", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chinawat", + "last_name": "Isradisaikul", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/IsradisaikulM13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462186", + "title": "Thresher: precise refutations for heap reachability", + "abstract": "We present a precise, path-sensitive static analysis for reasoning about heap reachability, that is, whether an object can be reached from another variable or object via pointer dereferences. Precise reachability information is useful for a number of clients, including static detection of a class of Android memory leaks. For this client, we found the heap reachability information computed by a state-of-the-art points-to analysis was too imprecise, leading to numerous false-positive leak reports. Our analysis combines a symbolic execution capable of path-sensitivity and strong updates with abstract heap information computed by an initial flow-insensitive points-to analysis. This novel mixed representation allows us to achieve both precision and scalability by leveraging the pre-computed points-to facts to guide execution and prune infeasible paths. We have evaluated our techniques in the Thresher tool, which we used to find several developer-confirmed leaks in Android applications.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462186", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sam", + "last_name": "Blackshear", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/pldi/BlackshearCS13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2491960", + "title": "Fast condensation of the program dependence graph", + "abstract": "Aggressive compiler optimizations are formulated around the Program Dependence Graph (PDG). Many techniques, including loop fission and parallelization are concerned primarily with dependence cycles in the PDG. The Directed Acyclic Graph of Strongly Connected Components (DAGSCC) represents these cycles directly. The naive method to construct the DAGSCC first computes the full PDG. This approach limits adoption of aggressive optimizations because the number of analysis queries grows quadratically with program size, making DAGSCC construction expensive. Consequently, compilers optimize small scopes with weaker but faster analyses.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2491960", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nick", + "last_name": "Johnson", + "institution": "Princeton University" + }, + { + "first_name": "Taewook", + "last_name": "Oh", + "institution": "Princeton University" + }, + { + "first_name": "Ayal", + "last_name": "Zaks", + "institution": "Intel (Israel)" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/JohnsonOZA13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2491973", + "title": "Limitations of partial compaction: towards practical bounds", + "abstract": "Compaction of a managed heap is considered a costly operation, and is avoided as much as possible in commercial runtimes. Instead, partial compaction is often used to defragment parts of the heap and avoid space blow up. Previous study of compaction limitation provided some initial asymptotic bounds but no implications for practical systems. In this work, we extend the theory to obtain better bounds and make them strong enough to become meaningful for modern systems.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2491973", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nachshon", + "last_name": "Cohen", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/CohenP13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462179", + "title": "Static analysis for probabilistic programs: inferring whole program properties from finitely many paths", + "abstract": "We propose an approach for the static analysis of probabilistic programs that sense, manipulate, and control based on uncertain data. Examples include programs used in risk analysis, medical decision making and cyber-physical systems. Correctness properties of such programs take the form of queries that seek the probabilities of assertions over program variables. We present a static analysis approach that provides guaranteed interval bounds on the values (assertion probabilities) of such queries. First, we observe that for probabilistic programs, it is possible to conclude facts about the behavior of the entire program by choosing a finite, adequate set of its paths. We provide strategies for choosing such a set of paths and verifying its adequacy. The queries are evaluated over each path by a combination of symbolic execution and probabilistic volume-bound computations. Each path yields interval bounds that can be summed up with a \"coverage\" bound to yield an interval that encloses the probability of assertion for the program as a whole. We demonstrate promising results on a suite of benchmarks from many different sources including robotic manipulators and medical decision making programs.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462179", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sriram", + "last_name": "Sankaranarayanan", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Aleksandar", + "last_name": "Chakarov", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/SankaranarayananCG13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462169", + "title": "Natural proofs for structure, data, and separation", + "abstract": "We propose natural proofs for reasoning with programs that manipulate data-structures against specifications that describe the structure of the heap, the data stored within it, and separation and framing of sub-structures. Natural proofs are a subclass of proofs that are amenable to completely automated reasoning, that provide sound but incomplete procedures, and that capture common reasoning tactics in program verification. We develop a dialect of separation logic over heaps, called Dryad, with recursive definitions that avoids explicit quantification. We develop ways to reason with heaplets using classical logic over the theory of sets, and develop natural proofs for reasoning using proof tactics involving disciplined unfoldings and formula abstractions. Natural proofs are encoded into decidable theories of first-order logic so as to be discharged using SMT solvers.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462169", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Pranav", + "last_name": "Garg", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Andrei", + "last_name": "Ștefănescu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/Qiu0SM13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462166", + "title": "Terra: a multi-stage language for high-performance computing", + "abstract": "High-performance computing applications, such as auto-tuners and domain-specific languages, rely on generative programming techniques to achieve high performance and portability. However, these systems are often implemented in multiple disparate languages and perform code generation in a separate process from program execution, making certain optimizations difficult to engineer. We leverage a popular scripting language, Lua, to stage the execution of a novel low-level language, Terra. Users can implement optimizations in the high-level language, and use built-in constructs to generate and execute high-performance Terra code. To simplify meta-programming, Lua and Terra share the same lexical environment, but, to ensure performance, Terra code can execute independently of Lua's runtime. We evaluate our design by reimplementing existing multi-language systems entirely in Terra. Our Terra-based auto-tuner for BLAS routines performs within 20% of ATLAS, and our DSL for stencil computations runs 2.3x faster than hand-written C.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462166", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zachary", + "last_name": "DeVito", + "institution": "Stanford University" + }, + { + "first_name": "James", + "last_name": "Hegarty", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Pat", + "last_name": "Hanrahan", + "institution": "Stanford University" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/DeVitoHAHV13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462191", + "title": "Hybrid context-sensitivity for points-to analysis", + "abstract": "Context-sensitive points-to analysis is valuable for achieving high precision with good performance. The standard flavors of context-sensitivity are call-site-sensitivity (kCFA) and object-sensitivity. Combining both flavors of context-sensitivity increases precision but at an infeasibly high cost. We show that a selective combination of call-site- and object-sensitivity for Java points-to analysis is highly profitable. Namely, by keeping a combined context only when analyzing selected language features, we can closely approximate the precision of an analysis that keeps both contexts at all times. In terms of speed, the selective combination of both kinds of context not only vastly outperforms non-selective combinations but is also faster than a mere object-sensitive analysis. This result holds for a large array of analyses (e.g., 1-object-sensitive, 2-object-sensitive with a context-sensitive heap, type-sensitive) establishing a new set of performance/precision sweet spots.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462191", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "George", + "last_name": "Kastrinis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/pldi/KastrinisS13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2491969", + "title": "Reasoning about nondeterminism in programs", + "abstract": "Branching-time temporal logics (e.g. CTL, CTL*, modal mu-calculus) allow us to ask sophisticated questions about the nondeterminism that appears in systems. Applications of this type of reasoning include planning, games, security analysis, disproving, precondition synthesis, environment synthesis, etc. Unfortunately, existing automatic branching-time verification tools have limitations that have traditionally restricted their applicability (e.g. push-down systems only, universal path quantifiers only, etc).", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2491969", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "New York University" + } + ], + "dblp_key": "conf/pldi/CookK13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462163", + "title": "A general constraint-centric scheduling framework for spatial architectures", + "abstract": "Specialized execution using spatial architectures provides energy efficient computation, but requires effective algorithms for spatially scheduling the computation. Generally, this has been solved with architecture-specific heuristics, an approach which suffers from poor compiler/architect productivity, lack of insight on optimality, and inhibits migration of techniques between architectures.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462163", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tony", + "last_name": "Nowatzki", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Michael", + "last_name": "Sartin-Tarm", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Lorenzo De", + "last_name": "Carli", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Karthikeyan", + "last_name": "Sankaralingam", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Cristian", + "last_name": "Estan", + "institution": "Broadcom (United States)" + }, + { + "first_name": "Behnam", + "last_name": "Robatmili", + "institution": "Qualcomm (United States)" + } + ], + "dblp_key": "conf/pldi/NowatzkiSCSER13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462178", + "title": "Machine-verified network controllers", + "abstract": "In many areas of computing, techniques ranging from testing to formal modeling to full-blown verification have been successfully used to help programmers build reliable systems. But although networks are critical infrastructure, they have largely resisted analysis using formal techniques. Software-defined networking (SDN) is a new network architecture that has the potential to provide a foundation for network reasoning, by standardizing the interfaces used to express network programs and giving them a precise semantics.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462178", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "Cornell University" + }, + { + "first_name": "Mark", + "last_name": "Reitblatt", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/GuhaRF13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462177", + "title": "Quipper: a scalable quantum programming language", + "abstract": "The field of quantum algorithms is vibrant. Still, there is currently a lack of programming languages for describing quantum computation on a practical scale, i.e., not just at the level of toy problems. We address this issue by introducing Quipper, a scalable, expressive, functional, higher-order quantum programming language. Quipper has been used to program a diverse set of non-trivial quantum algorithms, and can generate quantum gate representations using trillions of gates. It is geared towards a model of computation that uses a classical computer to control a quantum device, but is not dependent on any particular model of quantum hardware. Quipper has proven effective and easy to use, and opens the door towards using formal methods to analyze quantum algorithms.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462177", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alexander S.", + "last_name": "Green", + "institution": "Dalhousie University" + }, + { + "first_name": "Peter LeFanu", + "last_name": "Lumsdaine", + "institution": "Institute for Advanced Study" + }, + { + "first_name": "Neil J.", + "last_name": "Ross", + "institution": "Dalhousie University" + }, + { + "first_name": "Peter", + "last_name": "Selinger", + "institution": "Dalhousie University" + }, + { + "first_name": "Benoît", + "last_name": "Valiron", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/GreenLRSV13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462176", + "title": "Halide: a language and compiler for optimizing parallelism, locality, and recomputation in image processing pipelines", + "abstract": "Image processing pipelines combine the challenges of stencil computations and stream programs. They are composed of large graphs of different stencil stages, as well as complex reductions, and stages with global or data-dependent access patterns. Because of their complex structure, the performance difference between a naive implementation of a pipeline and an optimized one is often an order of magnitude. Efficient implementations require optimization of both parallelism and locality, but due to the nature of stencils, there is a fundamental tension between parallelism, locality, and introducing redundant recomputation of shared values.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462176", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Connelly", + "last_name": "Barnes", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Andrew", + "last_name": "Adams", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Sylvain", + "last_name": "Paris", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Frédo", + "last_name": "Durand", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Ragan-KelleyBAPDA13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462174", + "title": "TRANSIT: specifying protocols with concolic snippets", + "abstract": "With the maturing of technology for model checking and constraint solving, there is an emerging opportunity to develop programming tools that can transform the way systems are specified. In this paper, we propose a new way to program distributed protocols using concolic snippets. Concolic snippets are sample execution fragments that contain both concrete and symbolic values. The proposed approach allows the programmer to describe the desired system partially using the traditional model of communicating extended finite-state-machines (EFSM), along with high-level invariants and concrete execution fragments. Our synthesis engine completes an EFSM skeleton by inferring guards and updates from the given fragments which is then automatically analyzed using a model checker with respect to the desired invariants. The counterexamples produced by the model checker can then be used by the programmer to add new concrete execution fragments that describe the correct behavior in the specific scenario corresponding to the counterexample.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462174", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Abhishek", + "last_name": "Udupa", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Arun", + "last_name": "Raghavan", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jyotirmoy V.", + "last_name": "Deshmukh", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Sela", + "last_name": "Mador-Haim", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Milo M. K.", + "last_name": "Martin", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/UdupaRDMMA13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462168", + "title": "Dynamic determinacy analysis", + "abstract": "We present an analysis for identifying determinate variables and expressions that always have the same value at a given program point. This information can be exploited by client analyses and tools to, e.g., identify dead code or specialize uses of dynamic language constructs such as eval, replacing them with equivalent static constructs. Our analysis is completely dynamic and only needs to observe a single execution of the program, yet the determinacy facts it infers hold for any execution. We present a formal soundness proof of the analysis for a simple imperative language, and a prototype implementation that handles full JavaScript. Finally, we report on two case studies that explored how static analysis for JavaScript could leverage the information gathered by dynamic determinacy analysis. We found that in some cases scalability of static pointer analysis was improved dramatically, and that many uses of runtime code generation could be eliminated.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462168", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Max", + "last_name": "Schäfer", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "IBM (United States)" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/pldi/SchaferSDT13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462182", + "title": "General data structure expansion for multi-threading", + "abstract": "Among techniques for parallelizing sequential codes, privatization is a common and significant transformation performed by both compilers and runtime parallelizing systems. Without privatization, repetitive updates to the same data structures often introduce spurious data dependencies that hide the inherent parallelism. Unfortunately, it remains a significant challenge to compilers to automatically privatize dynamic and recursive data structures which appear frequently in real applications written in languages such as C/C++. This is because such languages lack a naming mechanism to define the address range of a pointer-based data structure, in contrast to arrays with explicitly declared bounds. In this paper we present a novel solution to this difficult problem by expanding general data structures such that memory accesses issued from different threads to contentious data structures are directed to different data fields. Based on compile-time type checking and a data dependence graph, this aggressive extension to the traditional scalar and array expansion isolates the address ranges among different threads, without struggling with privatization based on thread-private stacks, such that the targeted loop can be effectively parallelized. With this method fully implemented in GCC, experiments are conducted on a set of programs from well-known benchmark suites such as Mibench, MediaBench II and SPECint. Results show that the new approach can lead to a high speedup when executing the transformed code on multiple cores.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462182", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongtao", + "last_name": "Yu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Hou-Jen", + "last_name": "Ko", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Zhiyuan", + "last_name": "Li", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/YuKL13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2491979", + "title": "Monadic abstract interpreters", + "abstract": "Recent developments in the systematic construction of abstract interpreters hinted at the possibility of a broad unification of concepts in static analysis. We deliver that unification by showing context-sensitivity, polyvariance, flow-sensitivity, reachability-pruning, heap-cloning and cardinality-bounding to be independent of any particular semantics. Monads become the unifying agent between these concepts and between semantics. For instance, by plugging the same \"context-insensitivity monad\" into a monadically-parameterized semantics for Java or for the lambda calculus, it yields the expected context-insensitive analysis.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2491979", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "IMDEA Software" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "Jan", + "last_name": "Midtgaard", + "institution": "Aarhus University" + }, + { + "first_name": "David", + "last_name": "Darais", + "institution": "Harvard University Press" + }, + { + "first_name": "Dave", + "last_name": "Clarke", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/pldi/SergeyDMMDCP13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2491962", + "title": "Harmonizing classes, functions, tuples, and type parameters in virgil iii", + "abstract": "Languages are becoming increasingly multi-paradigm. Subtype polymorphism in statically-typed object-oriented languages is being supplemented with parametric polymorphism in the form of generics. Features like first-class functions and lambdas are appearing everywhere. Yet existing languages like Java, C#, C++, D, and Scala seem to accrete ever more complexity when they reach beyond their original paradigm into another; inevitably older features have some rough edges that lead to nonuniformity and pitfalls. Given a fresh start, a new language designer is faced with a daunting array of potential features. Where to start? What is important to get right first, and what can be added later? What features must work together, and what features are orthogonal? We report on our experience with Virgil III, a practical language with a careful balance of classes, functions, tuples and type parameters. Virgil intentionally lacks many advanced features, yet we find its core feature set enables new species of design patterns that bridge multiple paradigms and emulate features not directly supported such as interfaces, abstract data types, ad hoc polymorphism, and variant types. Surprisingly, we find variance for function types and tuple types often replaces the need for other kinds of type variance when libraries are designed in a more functional style.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2491962", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben L.", + "last_name": "Titzer", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/pldi/Titzer13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462183", + "title": "Translation validation for a verified OS kernel", + "abstract": "We extend the existing formal verification of the seL4 operating system microkernel from 9500 lines of C source code to the binary level. We handle all functions that were part of the previous verification. Like the original verification, we currently omit the assembly routines and volatile accesses used to control system hardware.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462183", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Sewell", + "institution": "Data61" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "University of Cambridge" + }, + { + "first_name": "Gerwin", + "last_name": "Klein", + "institution": "Data61" + } + ], + "dblp_key": "conf/pldi/SewellMK13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462159", + "title": "Fast algorithms for Dyck-CFL-reachability with applications to alias analysis", + "abstract": "The context-free language (CFL) reachability problem is a well-known fundamental formulation in program analysis. In practice, many program analyses, especially pointer analyses, adopt a restricted version of CFL-reachability, Dyck-CFL-reachability, and compute on edge-labeled bidirected graphs. Solving the all-pairs Dyck-CFL-reachability on such bidirected graphs is expensive. For a bidirected graph with n nodes and m edges, the traditional dynamic programming style algorithm exhibits a subcubic time complexity for the Dyck language with k kinds of parentheses. When the underlying graphs are restricted to bidirected trees, an algorithm with O(n log n log k) time complexity was proposed recently. This paper studies the Dyck-CFL-reachability problems on bidirected trees and graphs. In particular, it presents two fast algorithms with O(n) and O(n + m log m) time complexities on trees and graphs respectively. We have implemented and evaluated our algorithms on a state-of-the-art alias analysis for Java. Results on standard benchmarks show that our algorithms achieve orders of magnitude speedup and consume less memory.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462159", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Michael R.", + "last_name": "Lyu", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Hao", + "last_name": "Yuan", + "institution": "" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/ZhangLYS13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462195", + "title": "Automated feedback generation for introductory programming assignments", + "abstract": "We present a new method for automatically providing feedback for introductory programming problems. In order to use this method, we need a reference implementation of the assignment, and an error model consisting of potential corrections to errors that students might make. Using this information, the system automatically derives minimal corrections to student's incorrect solutions, providing them with a measure of exactly how incorrect a given solution was, as well as feedback about what they did wrong.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462195", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/SinghGS13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462164", + "title": "Formal verification of SSA-based optimizations for LLVM", + "abstract": "Modern compilers, such as LLVM and GCC, use a static single assignment(SSA) intermediate representation (IR) to simplify and enable many advanced optimizations. However, formally verifying the correctness of SSA-based optimizations is challenging because SSA properties depend on a function's entire control-flow graph.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462164", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yun", + "last_name": "Zhao", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Milo M. K.", + "last_name": "Martin", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/ZhaoNMZ13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2462185", + "title": "Finding optimum abstractions in parametric dataflow analysis", + "abstract": "We propose a technique to efficiently search a large family of abstractions in order to prove a query using a parametric dataflow analysis. Our technique either finds the cheapest such abstraction or shows that none exists. It is based on counterexample-guided abstraction refinement but applies a novel meta-analysis on abstract counterexample traces to efficiently find abstractions that are incapable of proving the query. We formalize the technique in a generic framework and apply it to two analyses: a type-state analysis and a thread-escape analysis. We demonstrate the effectiveness of the technique on a suite of Java benchmark programs.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2462185", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/pldi/ZhangNY13", + "venue": "pldi", + "year": 2013 + }, + { + "paper_id": "10.1145/2491956.2491978", + "title": "Verifying higher-order programs with the dijkstra monad", + "abstract": "Modern programming languages, ranging from Haskell and ML, to JavaScript, C# and Java, all make extensive use of higher-order state. This paper advocates a new verification methodology for higher-order stateful programs, based on a new monad of predicate transformers called the Dijkstra monad.", + "date": "2013-06-11", + "link": "https://doi.org/10.1145/2491956.2491978", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Joel", + "last_name": "Weinberger", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Cole", + "last_name": "Schlesinger", + "institution": "Princeton University" + }, + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/SwamyWSCL13", + "venue": "pldi", + "year": 2013 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2014.json b/data/pl_conferences/pldi/2014.json new file mode 100644 index 0000000..10bce06 --- /dev/null +++ b/data/pl_conferences/pldi/2014.json @@ -0,0 +1,1949 @@ +[ + { + "paper_id": "10.1145/2594291.2594334", + "title": "Compiler validation via equivalence modulo inputs", + "abstract": "We introduce equivalence modulo inputs (EMI), a simple, widely applicable methodology for validating optimizing compilers. Our key insight is to exploit the close interplay between (1) dynamically executing a program on some test inputs and (2) statically compiling the program to work on all possible inputs. Indeed, the test inputs induce a natural collection of the original program's EMI variants, which can help differentially test any compiler and specifically target the difficult-to-find miscompilations.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594334", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vu", + "last_name": "Le", + "institution": "University of California, Davis" + }, + { + "first_name": "Mehrdad", + "last_name": "Afshari", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/LeAS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594338", + "title": "Automating formal proofs for reactive systems", + "abstract": "Implementing systems in proof assistants like Coq and proving their correctness in full formal detail has consistently demonstrated promise for making extremely strong guarantees about critical software, ranging from compilers and operating systems to databases and web browsers. Unfortunately, these verifications demand such heroic manual proof effort, even for a single system, that the approach has not been widely adopted.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594338", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Ricketts", + "institution": "University of California, San Diego" + }, + { + "first_name": "Valentin", + "last_name": "Robert", + "institution": "University of California, San Diego" + }, + { + "first_name": "Dongseok", + "last_name": "Jang", + "institution": "University of California, San Diego" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/RickettsRJTL14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594295", + "title": "Modular control-flow integrity", + "abstract": "Control-Flow Integrity (CFI) is a software-hardening technique. It inlines checks into a program so that its execution always follows a predetermined Control-Flow Graph (CFG). As a result, CFI is effective at preventing control-flow hijacking attacks. However, past fine-grained CFI implementations do not support separate compilation, which hinders its adoption.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594295", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben", + "last_name": "Niu", + "institution": "Lehigh University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Lehigh University" + } + ], + "dblp_key": "conf/pldi/NiuT14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594301", + "title": "End-to-end verification of stack-space bounds for C programs", + "abstract": "Verified compilers guarantee the preservation of semantic properties and thus enable formal verification of programs at the source level. However, important quantitative properties such as memory and time usage still have to be verified at the machine level where interactive proofs tend to be more tedious and automation is more challenging.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594301", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Quentin", + "last_name": "Carbonneaux", + "institution": "Yale University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Yale University" + }, + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/Carbonneaux0RS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594323", + "title": "DoubleChecker: efficient sound and precise atomicity checking", + "abstract": "Atomicity is a key correctness property that allows programmers to reason about code regions in isolation. However, programs often fail to enforce atomicity correctly, leading to atomicity violations that are difficult to detect. Dynamic program analysis can detect atomicity violations based on an atomicity specification, but existing approaches slow programs substantially.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594323", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Swarnendu", + "last_name": "Biswas", + "institution": "The Ohio State University" + }, + { + "first_name": "Jipeng", + "last_name": "Huang", + "institution": "The Ohio State University" + }, + { + "first_name": "Aritra", + "last_name": "Sengupta", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/BiswasHSB14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594345", + "title": "Specialization slicing", + "abstract": "In this paper, we investigate opportunities to be gained from broadening the definition of program slicing. A major inspiration for our work comes from the field of partial evaluation, in which a wide repertoire of techniques have been developed for specializing programs. While slicing can also be harnessed for specializing programs, the kind of specialization obtainable via slicing has heretofore been quite restricted, compared to the kind of specialization allowed in partial evaluation. In particular, most slicing algorithms are what the partial-evaluation community calls monovariant: each program element of the original program generates at most one element in the answer. In contrast, partial-evaluation algorithms can be polyvariant, i.e., one program element in the original program may correspond to more than one element in the specialized program.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594345", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Min", + "last_name": "Aung", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Susan", + "last_name": "Horwitz", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Rich", + "last_name": "Joiner", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "" + } + ], + "dblp_key": "conf/pldi/AungHJR14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594318", + "title": "Selective context-sensitivity guided by impact pre-analysis", + "abstract": "We present a method for selectively applying context-sensitivity during interprocedural program analysis. Our method applies context-sensitivity only when and where doing so is likely to improve the precision that matters for resolving given queries. The idea is to use a pre-analysis to estimate the impact of context-sensitivity on the main analysis's precision, and to use this information to find out when and where the main analysis should turn on or off its context-sensitivity. We formalize this approach and prove that the analysis always benefits from the pre-analysis-guided context-sensitivity. We implemented this selective method for an existing industrial-strength interval analyzer for full C. The method reduced the number of (false) alarms by 24.4%, while increasing the analysis cost by 27.8% on average.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594318", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Seoul National University" + }, + { + "first_name": "Wonchan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Kihong", + "last_name": "Heo", + "institution": "Seoul National University" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/pldi/OhLHYY14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594336", + "title": "Accurate application progress analysis for large-scale parallel debugging", + "abstract": "Debugging large-scale parallel applications is challenging. In most HPC applications, parallel tasks progress in a coordinated fashion, and thus a fault in one task can quickly propagate to other tasks, making it difficult to debug. Finding the least-progressed tasks can significantly reduce the effort to identify the task where the fault originated. However, existing approaches for detecting them suffer low accuracy and large overheads; either they use imprecise static analysis or are unable to infer progress dependence inside loops. We present a loop-aware progress-dependence analysis tool, Prodometer, which determines relative progress among parallel tasks via dynamic analysis. Our fault-injection experiments suggest that its accuracy and precision are over 90% for most cases and that it scales well up to 16,384 MPI tasks. Further, our case study shows that it significantly helped diagnosing a perplexing error in MPI, which only manifested at large scale.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594336", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Subrata", + "last_name": "Mitra", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Ignacio", + "last_name": "Laguna", + "institution": "Lawrence Livermore National Laboratory" + }, + { + "first_name": "Dong H.", + "last_name": "Ahn", + "institution": "Lawrence Livermore National Laboratory" + }, + { + "first_name": "Saurabh", + "last_name": "Bagchi", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Martin", + "last_name": "Schulz", + "institution": "Lawrence Livermore National Laboratory" + }, + { + "first_name": "Todd", + "last_name": "Gamblin", + "institution": "Lawrence Livermore National Laboratory" + } + ], + "dblp_key": "conf/pldi/MitraLABSG14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594308", + "title": "Getting F-bounded polymorphism into shape", + "abstract": "We present a way to restrict recursive inheritance without sacrificing the benefits of F-bounded polymorphism. In particular, we distinguish two new concepts, materials and shapes, and demonstrate through a survey of 13.5 million lines of open-source generic-Java code that these two concepts never actually overlap in practice. With this Material-Shape Separation, we prove that even naïve type-checking algorithms are sound and complete, some of which address problems that were unsolvable even under the existing proposals for restricting inheritance. We illustrate how the simplicity of our design reflects the design intuitions employed by programmers and potentially enables new features coming into demand for upcoming programming languages.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594308", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Cornell University" + }, + { + "first_name": "Fabian", + "last_name": "Muehlboeck", + "institution": "Cornell University" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/GreenmanMT14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594296", + "title": "Don't sweat the small stuff: formal verification of C code without the pain", + "abstract": "We present an approach for automatically generating provably correct abstractions from C source code that are useful for practical implementation verification. The abstractions are easier for a human verification engineer to reason about than the implementation and increase the productivity of interactive code proof. We guarantee soundness by automatically generating proofs that the abstractions are correct.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594296", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Greenaway", + "institution": "Data61" + }, + { + "first_name": "Japheth", + "last_name": "Lim", + "institution": "UNSW Sydney" + }, + { + "first_name": "June", + "last_name": "Andronick", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gerwin", + "last_name": "Klein", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/pldi/GreenawayLAK14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594307", + "title": "First-class runtime generation of high-performance types using exotypes", + "abstract": "We introduce exotypes, user-defined types that combine the flexibility of meta-object protocols in dynamically-typed languages with the performance control of low-level languages. Like objects in dynamic languages, exotypes are defined programmatically at run-time, allowing behavior based on external data such as a database schema. To achieve high performance, we use staged programming to define the behavior of an exotype during a runtime compilation step and implement exotypes in Terra, a low-level staged programming language.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594307", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zachary", + "last_name": "DeVito", + "institution": "Stanford University" + }, + { + "first_name": "Daniel", + "last_name": "Ritchie", + "institution": "Stanford University" + }, + { + "first_name": "M.", + "last_name": "Fisher", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Pat", + "last_name": "Hanrahan", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/DeVitoRFAH14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594317", + "title": "VeriCon: towards verifying controller programs in software-defined networks", + "abstract": "Software-defined networking (SDN) is a new paradigm for operating and managing computer networks. SDN enables logically-centralized control over network devices through a \"controller\" software that operates independently from the network hardware, and can be viewed as the network operating system. Network operators can run both inhouse and third-party SDN programs (often called applications) on top of the controller, e.g., to specify routing and access control policies. SDN opens up the possibility of applying formal methods to prove the correctness of computer networks. Indeed, recently much effort has been invested in applying finite state model checking to check that SDN programs behave correctly. However, in general, scaling these methods to large networks is challenging and, moreover, they cannot guarantee the absence of errors.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594317", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Nikolaj", + "last_name": "Bjørner", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Aaron", + "last_name": "Gember-Jacobson", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Aleksandr", + "last_name": "Karbyshev", + "institution": "Technical University of Munich" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Michael", + "last_name": "Schapira", + "institution": "Hebrew College" + }, + { + "first_name": "Asaf", + "last_name": "Valadarsky", + "institution": "Hebrew College" + } + ], + "dblp_key": "conf/pldi/BallBGIKSSV14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594311", + "title": "Race detection for Android applications", + "abstract": "Programming environments for smartphones expose a concurrency model that combines multi-threading and asynchronous event-based dispatch. While this enables the development of efficient and feature-rich applications, unforeseen thread interleavings coupled with non-deterministic reorderings of asynchronous tasks can lead to subtle concurrency errors in the applications.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594311", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pallavi", + "last_name": "Maiya", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Aditya", + "last_name": "Kanade", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/MaiyaKM14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594346", + "title": "Atomicity refinement for verified compilation", + "abstract": "We consider the verified compilation of high-level managed languages like Java or C# whose intermediate representations provide support for shared-memory synchronization and automatic memory management. In this environment, the interactions between application threads and the language runtime (e.g., the garbage collector) are regulated by compiler-injected code snippets. Example of snippets include allocation fast paths among others. In our TOPLAS paper we propose a refinement-based proof methodology that precisely relates concurrent code expressed at different abstraction levels, cognizant throughout of the relaxed memory semantics of the underlying processor. Our technique allows the compiler writer to reason compositionally about the atomicity of low-level concurrent code used to implement managed services. We illustrate our approach with examples taken from the verification of a concurrent garbage collector.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594346", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Vincent", + "last_name": "Laporte", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Gustavo", + "last_name": "Petri", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/JagannathanPVPL14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594347", + "title": "Herding cats: modelling, simulation, testing, and data-mining for weak memory", + "abstract": "There is a joke where a physicist and a mathematician are asked to herd cats. The physicist starts with an infinitely large pen which he reduces until it is of reasonable diameter yet contains all the cats. The mathematician builds a fence around himself and declares the outside to be the inside. Defining memory models is akin to herding cats: both the physicist's or mathematician's attitudes are tempting, but neither can go without the other.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594347", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jade", + "last_name": "Alglave", + "institution": "UCL Australia" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Michael", + "last_name": "Tautschnig", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/pldi/AlglaveMT14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594339", + "title": "Chlorophyll: synthesis-aided compiler for low-power spatial architectures", + "abstract": "We developed Chlorophyll, a synthesis-aided programming model and compiler for the GreenArrays GA144, an extremely minimalist low-power spatial architecture that requires partitioning the program into fragments of no more than 256 instructions and 64 words of data. This processor is 100-times more energy efficient than its competitors, but currently can only be programmed using a low-level stack-based language.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594339", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Phitchaya Mangpo", + "last_name": "Phothilimthana", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Tikhon", + "last_name": "Jelvis", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rohin", + "last_name": "Shah", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Nishant", + "last_name": "Totla", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/PhothilimthanaJSTCB14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594326", + "title": "Verification modulo versions: towards usable verification", + "abstract": "We introduce Verification Modulo Versions (VMV), a new static analysis technique for reducing the number of alarms reported by static verifiers while providing sound semantic guarantees. First, VMV extracts semantic environment conditions from a base program P. Environmental conditions can either be sufficient conditions (implying the safety of P) or necessary conditions (implied by the safety of P). Then, VMV instruments a new version of the program, P', with the inferred conditions. We prove that we can use (i) sufficient conditions to identify abstract regressions of P' w.r.t. P; and (ii) necessary conditions to prove the relative correctness of P' w.r.t. P. We show that the extraction of environmental conditions can be performed at a hierarchy of abstraction levels (history, state, or call conditions) with each subsequent level requiring a less sophisticated matching of the syntactic changes between P' and P. Call conditions are particularly useful because they only require the syntactic matching of entry points and callee names across program versions. We have implemented VMV in a widely used static analysis and verification tool. We report our experience on two large code bases and demonstrate a substantial reduction in alarms while additionally providing relative correctness guarantees.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594326", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sam", + "last_name": "Blackshear", + "institution": "University of Colorado System" + } + ], + "dblp_key": "conf/pldi/LogozzoLFB14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594312", + "title": "Taming the parallel effect zoo: extensible deterministic parallelism with LVish", + "abstract": "A fundamental challenge of parallel programming is to ensure that the observable outcome of a program remains deterministic in spite of parallel execution. Language-level enforcement of determinism is possible, but existing deterministic-by-construction parallel programming models tend to lack features that would make them applicable to a broad range of problems. Moreover, they lack extensibility: it is difficult to add or change language features without breaking the determinism guarantee.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594312", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "Indiana University" + }, + { + "first_name": "Aaron", + "last_name": "Todd", + "institution": "Indiana University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/pldi/KuperTTN14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594297", + "title": "Test-driven synthesis", + "abstract": "Programming-by-example technologies empower end-users to create simple programs merely by providing input/output examples. Existing systems are designed around solvers specialized for a specific set of data types or domain-specific language (DSL). We present a program synthesizer which can be parameterized by an arbitrary DSL that may contain conditionals and loops and therefore is able to synthesize programs in any domain. In order to use our synthesizer, the user provides a sequence of increasingly sophisticated input/output examples along with an expert-written DSL definition. These two inputs correspond to the two key ideas that allow our synthesizer to work in arbitrary domains. First, we developed a novel iterative synthesis technique inspired by test-driven development---which also gives our technique the name of test-driven synthesis---where the input/output examples are consumed one at a time as the program is refined. Second, the DSL allows our system to take an efficient component-based approach to enumerating possible programs. We present applications of our synthesis methodology to end-user programming for transformations over strings, XML, and table layouts. We compare our synthesizer on these applications to state-of-the-art DSL-specific synthesizers as well to the general purpose synthesizer Sketch.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594297", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Perelman", + "institution": "University of Washington" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Peter", + "last_name": "Provost", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/PerelmanGGP14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594324", + "title": "Adapton: composable, demand-driven incremental computation", + "abstract": "Many researchers have proposed programming languages that support incremental computation (IC), which allows programs to be efficiently re-executed after a small change to the input. However, existing implementations of such languages have two important drawbacks. First, recomputation is oblivious to specific demands on the program output; that is, if a program input changes, all dependencies will be recomputed, even if an observer no longer requires certain outputs. Second, programs are made incremental as a unit, with little or no support for reusing results outside of their original context, e.g., when reordered.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594324", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Khoo Yit", + "last_name": "Phang", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/HammerKHF14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594306", + "title": "Globally precise-restartable execution of parallel programs", + "abstract": "Emerging trends in computer design and use are likely to make exceptions, once rare, the norm, especially as the system size grows. Due to exceptions, arising from hardware faults, approximate computing, dynamic resource management, etc., successful and error-free execution of programs may no longer be assured. Yet, designers will want to tolerate the exceptions so that the programs execute completely, efficiently and without external intervention.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594306", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gagan Raj", + "last_name": "Gupta", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "S.", + "last_name": "Sridharan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Gurindar S.", + "last_name": "Sohi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/GuptaSS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594313", + "title": "Optimal inference of fields in row-polymorphic records", + "abstract": "Flexible records are a powerful concept in type systems that form the basis of, for instance, objects in dynamically typed languages. One caveat of using flexible records is that a program may try to access a record field that does not exist. We present a type inference algorithm that checks for these runtime errors. The novelty of our algorithm is that it satisfies a clear notion of completeness: The inferred types are optimal in the sense that type annotations cannot increase the set of typeable programs. Under certain assumptions, our algorithm guarantees the following stronger property: it rejects a program if and only if it contains a path from an empty record to a field access on which the field has not been added. We derive this optimal algorithm by abstracting a semantics to types. The derived inference rules use a novel combination of type terms and Boolean functions that retains the simplicity of unification-based type inference but adds the ability of Boolean functions to express implications, thereby addressing the challenge of combining implications and types. By following our derivation method, we show how various operations such as record concatenation and branching if a field exists lead to Boolean satisfiability problems of different complexity. Analogously, we show that more expressive type systems give rise to SMT problems. On the practical side, we present an implementation of the select and update operations and give practical evidence that these are sufficient in real-world applications.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594313", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Axel", + "last_name": "Simon", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/pldi/Simon14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594294", + "title": "Expressing and verifying probabilistic assertions", + "abstract": "Traditional assertions express correctness properties that must hold on every program execution. However, many applications have probabilistic outcomes and consequently their correctness properties are also probabilistic (e.g., they identify faces in images, consume sensor data, or run on unreliable hardware). Traditional assertions do not capture these correctness properties. This paper proposes that programmers express probabilistic correctness properties with probabilistic assertions and describes a new probabilistic evaluation approach to efficiently verify these assertions. Probabilistic assertions are Boolean expressions that express the probability that a property will be true in a given execution rather than asserting that the property must always be true. Given either specific inputs or distributions on the input space, probabilistic evaluation verifies probabilistic assertions by first performing distribution extraction to represent the program as a Bayesian network. Probabilistic evaluation then uses statistical properties to simplify this representation to efficiently compute assertion probabilities directly or with sampling. Our approach is a mix of both static and dynamic analysis: distribution extraction statically builds and optimizes the Bayesian network representation and sampling dynamically interprets this representation. We implement our approach in a tool called Mayhap for C and C++ programs. We evaluate expressiveness, correctness, and performance of Mayhap on programs that use sensors, perform approximate computation, and obfuscate data for privacy. Our case studies demonstrate that probabilistic assertions describe useful correctness properties and that Mayhap efficiently verifies them.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594294", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "University of Washington" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Washington" + }, + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/SampsonPMMGC14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594321", + "title": "Code completion with statistical language models", + "abstract": "We address the problem of synthesizing code completions for programs using APIs. Given a program with holes, we synthesize completions for holes with the most likely sequences of method calls.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594321", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/RaychevVY14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2604001", + "title": "What exactly is inexact computation good for?", + "abstract": "Our willingness to deliberately trade accuracy of computing systems for significant resource savings, notably energy consumption, got a boost from two directions. First, energy (or power, the more popularly used measure) consumption started emerging as a serious hurdle to our ability to continue scaling the complexity of processors, and thus enable ever richer computing applications. This \"energy hurdle\" spanned the gamut from large data-centers to portable embedded computing systems. Second, many believed that an engine of growth that supported scaling, captured by Gordon Moore's remarkable prophecy (Moore's law), was headed towards an irrevocable cliff edge - when this happens, our ability to produce computing systems whose hardware would support precise or exact computing would diminish greatly. In this talk which emphasizes the physical and hardware layers of abstraction where all of these troubles start (after all energy is rooted in thermodynamics), I will first review reasons that compelled and encouraged us to consider trading accuracy for energy savings deliberately resulting in inexact computing.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2604001", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Krishna V.", + "last_name": "Palem", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/Palem14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594315", + "title": "Maximal sound predictive race detection with control flow abstraction", + "abstract": "Despite the numerous static and dynamic program analysis techniques in the literature, data races remain one of the most common bugs in modern concurrent software. Further, the techniques that do exist either have limited detection capability or are unsound, meaning that they report false positives. We present a sound race detection technique that achieves a provably higher detection capability than existing sound techniques. A key insight of our technique is the inclusion of abstracted control flow information into the execution model, which increases the space of the causal model permitted by classical happens-before or causally-precedes based detectors. By encoding the control flow and a minimal set of feasibility constraints as a group of first-order logic formulae, we formulate race detection as a constraint solving problem. Moreover, we formally prove that our formulation achieves the maximal possible detection capability for any sound dynamic race detector with respect to the same input trace under the sequential consistency memory model. We demonstrate via extensive experimentation that our technique detects more races than the other state-of-the-art sound race detection techniques, and that it is scalable to executions of real world concurrent applications with tens of millions of critical events. These experiments also revealed several previously unknown races in real systems (e.g., Eclipse) that have been confirmed or fixed by the developers. Our tool is also adopted by Eclipse developers.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594315", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Patrick", + "last_name": "Meredith", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/HuangMR14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594343", + "title": "Tracelet-based code search in executables", + "abstract": "We address the problem of code search in executables. Given a function in binary form and a large code base, our goal is to statically find similar functions in the code base. Towards this end, we present a novel technique for computing similarity between functions. Our notion of similarity is based on decomposition of functions into tracelets: continuous, short, partial traces of an execution. To establish tracelet similarity in the face of low-level compiler transformations, we employ a simple rewriting engine. This engine uses constraint solving over alignment constraints and data dependencies to match registers and memory addresses between tracelets, bridging the gap between tracelets that are otherwise similar. We have implemented our approach and applied it to find matches in over a million binary functions. We compare tracelet matching to approaches based on n-grams and graphlets and show that tracelet matching obtains dramatically better precision and recall.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594343", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yaniv", + "last_name": "David", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/DavidY14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594322", + "title": "Commutativity race detection", + "abstract": "This paper introduces the concept of a commutativity race. A commutativity race occurs in a given execution when two library method invocations can happen concurrently yet they do not commute. Commutativity races are an elegant concept enabling reasoning about concurrent interaction at the library interface.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594322", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dimitar", + "last_name": "Dimitrov", + "institution": "ETH Zurich" + }, + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "New York University" + } + ], + "dblp_key": "conf/pldi/DimitrovRVK14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594304", + "title": "A theory of changes for higher-order languages: incrementalizing λ-calculi by static differentiation", + "abstract": "If the result of an expensive computation is invalidated by a small change to the input, the old result should be updated incrementally instead of reexecuting the whole computation. We incrementalize programs through their derivative. A derivative maps changes in the program's input directly to changes in the program's output, without reexecuting the original program. We present a program transformation taking programs to their derivatives, which is fully static and automatic, supports first-class functions, and produces derivatives amenable to standard optimization.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594304", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yufei", + "last_name": "Cai", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Paolo G.", + "last_name": "Giarrusso", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Tillmann", + "last_name": "Rendel", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Philipps University of Marburg" + } + ], + "dblp_key": "conf/pldi/CaiGRO14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594319", + "title": "Resugaring: lifting evaluation sequences through syntactic sugar", + "abstract": "Syntactic sugar is pervasive in language technology. It is used to shrink the size of a core language; to define domain-specific languages; and even to let programmers extend their language. Unfortunately, syntactic sugar is eliminated by transformation, so the resulting programs become unfamiliar to authors. Thus, it comes at a price: it obscures the relationship between the user's source program and the program being evaluated.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594319", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Justin", + "last_name": "Pombrio", + "institution": "John Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/pldi/PombrioK14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594303", + "title": "Slicing probabilistic programs", + "abstract": "Probabilistic programs use familiar notation of programming languages to specify probabilistic models. Suppose we are interested in estimating the distribution of the return expression r of a probabilistic program P. We are interested in slicing the probabilistic program P and obtaining a simpler program Sli(P) which retains only those parts of P that are relevant to estimating r, and elides those parts of P that are not relevant to estimating r. We desire that the Sli transformation be both correct and efficient. By correct, we mean that P and Sli(P) have identical estimates on r. By efficient, we mean that estimation over Sli(P) be as fast as possible.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594303", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Selva", + "last_name": "Samuel", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/HurNRS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2604003", + "title": "A personal perspective on concurrency", + "abstract": "This talk will describe a view of concurrency, the author's own, as it has evolved since the late 1970s. Early notions of concurrency were intimately tied with physical hardware and speeding up of computations, which proved to be an impediment to the development of a logical theory of concurrency. In collaboration with K. Mani Chandy, the author developed a theory called UNITY that combined a programming notation with a verification logic to describe a large class of fundamental concurrent algorithms arising in operating systems, communication protocols and distributed systems. Several model checkers, including Murphi, developed by David Dill, are based on UNITY.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2604003", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jayadev", + "last_name": "Misra", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/Misra14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594329", + "title": "Compositional solution space quantification for probabilistic software analysis", + "abstract": "Probabilistic software analysis aims at quantifying how likely a target event is to occur during program execution. Current approaches rely on symbolic execution to identify the conditions to reach the target event and try to quantify the fraction of the input domain satisfying these conditions. Precise quantification is usually limited to linear constraints, while only approximate solutions can be provided in general through statistical approaches. However, statistical approaches may fail to converge to an acceptable accuracy within a reasonable time.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594329", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mateus", + "last_name": "Borges", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Antonio", + "last_name": "Filieri", + "institution": "University of Stuttgart" + }, + { + "first_name": "Marcelo", + "last_name": "d’Amorim", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Corina S.", + "last_name": "Păsăreanu", + "institution": "Ames Research Center" + }, + { + "first_name": "Willem", + "last_name": "Visser", + "institution": "Stellenbosch University" + } + ], + "dblp_key": "conf/pldi/BorgesFdPV14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594332", + "title": "Improving JavaScript performance by deconstructing the type system", + "abstract": "Increased focus on JavaScript performance has resulted in vast performance improvements for many benchmarks. However, for actual code used in websites, the attained improvements often lag far behind those for popular benchmarks.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594332", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wonsun", + "last_name": "Ahn", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Jiho", + "last_name": "Choi", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Thomas", + "last_name": "Shull", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "María Jesús", + "last_name": "Garzarán", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Josep", + "last_name": "Torrellas", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/AhnCSGT14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594325", + "title": "Natural proofs for data structure manipulation in C using separation logic", + "abstract": "The natural proof technique for heap verification developed by Qiu et al. [32] provides a platform for powerful sound reasoning for specifications written in a dialect of separation logic called Dryad. Natural proofs are proof tactics that enable automated reasoning exploiting recursion, mimicking common patterns found in human proofs. However, these proofs are known to work only for a simple toy language [32].", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594325", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Edgar", + "last_name": "Pek", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/PekQM14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2604002", + "title": "Laws of concurrent programming", + "abstract": "The talk extends the Laws of Programming [1] by four laws governing concurrent composition of programs. This operator is associative and commutative and distributive through union; and it has the same unit (do nothing) as sequential composition. Furthermore, sequential and concurrent composition distribute through each other, in accordance with an exchange law; this permits an implementation of concurrency by partial interleaving.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2604002", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tony", + "last_name": "Hoare", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/Hoare14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594331", + "title": "A model counter for constraints over unbounded strings", + "abstract": "Model counting is the problem of determining the number of solutions that satisfy a given set of constraints. Model counting has numerous applications in the quantitative analyses of program execution time, information flow, combinatorial circuit designs as well as probabilistic reasoning. We present a new approach to model counting for structured data types, specifically strings in this work. The key ingredient is a new technique that leverages generating functions as a basic primitive for combinatorial counting. Our tool SMC which embodies this approach can model count for constraints specified in an expressive string language efficiently and precisely, thereby outperforming previous finite-size analysis tools. SMC is expressive enough to model constraints arising in real-world JavaScript applications and UNIX C utilities. We demonstrate the practical feasibility of performing quantitative analyses arising in security applications, such as determining the comparative strengths of password strength meters and determining the information leakage via side channels.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594331", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Loi", + "last_name": "Luu", + "institution": "National University of Singapore" + }, + { + "first_name": "Shweta", + "last_name": "Shinde", + "institution": "National University of Singapore" + }, + { + "first_name": "Prateek", + "last_name": "Saxena", + "institution": "National University of Singapore" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/pldi/LuuSSD14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594333", + "title": "FlashExtract: a framework for data extraction by examples", + "abstract": "Various document types that combine model and view (e.g., text files, webpages, spreadsheets) make it easy to organize (possibly hierarchical) data, but make it difficult to extract raw data for any further manipulation or querying. We present a general framework FlashExtract to extract relevant data from semi-structured documents using examples. It includes: (a) an interaction model that allows end-users to give examples to extract various fields and to relate them in a hierarchical organization using structure and sequence constructs. (b) an inductive synthesis algorithm to synthesize the intended program from few examples in any underlying domain-specific language for data extraction that has been built using our specified algebra of few core operators (map, filter, merge, and pair). We describe instantiation of our framework to three different domains: text files, webpages, and spreadsheets. On our benchmark comprising 75 documents, FlashExtract is able to extract intended data using an average of 2.36 examples in 0.84 seconds per field.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594333", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vu", + "last_name": "Le", + "institution": "University of California, Davis" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/LeG14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594309", + "title": "Fast: a transducer-based language for tree manipulation", + "abstract": "Tree automata and tree transducers are used in a wide range of applications in software engineering, from XML processing to language type-checking. While these formalisms are of immense practical use, they can only model finite alphabets, and since many real-world applications operate over infinite domains such as integers, this is often a limitation. To overcome this problem we augment tree automata and transducers with symbolic alphabets represented as parametric theories. Admitting infinite alphabets makes these models more general and succinct than their classical counterparts. Despite this, we show how the main operations, such as composition and language equivalence, remain computable given a decision procedure for the alphabet theory.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594309", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dávid", + "last_name": "Molnár", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/DAntoniVLM14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594320", + "title": "Introspective analysis: context-sensitivity, across the board", + "abstract": "Context-sensitivity is the primary approach for adding more precision to a points-to analysis, while hopefully also maintaining scalability. An oft-reported problem with context-sensitive analyses, however, is that they are bi-modal: either the analysis is precise enough that it manipulates only manageable sets of data, and thus scales impressively well, or the analysis gets quickly derailed at the first sign of imprecision and becomes orders-of-magnitude more expensive than would be expected given the program's size. There is currently no approach that makes precise context-sensitive analyses (of any flavor: call-site-, object-, or type-sensitive) scale across the board at a level comparable to that of a context-insensitive analysis. To address this issue, we propose introspective analysis: a technique for uniformly scaling context-sensitive analysis by eliminating its performance-detrimental behavior, at a small precision expense. Introspective analysis consists of a common adaptivity pattern: first perform a context-insensitive analysis, then use the results to selectively refine (i.e., analyze context-sensitively) program elements that will not cause explosion in the running time or space. The technical challenge is to appropriately identify such program elements. We show that a simple but principled approach can be remarkably effective, achieving scalability (often with dramatic speedup) for benchmarks previously completely out-of-reach for deep context-sensitive analyses.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594320", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "George", + "last_name": "Kastrinis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "George", + "last_name": "Balatsouras", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/pldi/SmaragdakisKB14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594300", + "title": "Dynamic enforcement of determinism in a parallel scripting language", + "abstract": "Determinism is an appealing property for parallel programs, as it simplifies understanding, reasoning and debugging. It is particularly appealing in dynamic (scripting) languages, where ease of programming is a dominant design goal. Some existing parallel languages use the type system to enforce determinism statically, but this is not generally practical for dynamic languages. In this paper, we describe how determinism can be obtained---and dynamically enforced/verified---for appropriate extensions to a parallel scripting language. Specifically, we introduce the constructs of Deterministic Parallel Ruby (DPR), together with a run-time system (Tardis) that verifies properties required for determinism, including correct usage of reductions and commutative operators, and the mutual independence (data-race freedom) of concurrent tasks. Experimental results confirm that DPR can provide scalable performance on multicore machines and that the overhead of Tardis is low enough for practical testing. In particular, Tardis significantly outperforms alternative data-race detectors with comparable functionality. We conclude with a discussion of future directions in the dynamic enforcement of determinism.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594300", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lü", + "last_name": "Li", + "institution": "University of Rochester" + }, + { + "first_name": "Weixing", + "last_name": "Ji", + "institution": "Beijing Institute of Technology" + }, + { + "first_name": "Michael L.", + "last_name": "Scott", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/pldi/LuJS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594337", + "title": "Automatic runtime error repair and containment via recovery shepherding", + "abstract": "We present a system, RCV, for enabling software applications to survive divide-by-zero and null-dereference errors. RCV operates directly on off-the-shelf, production, stripped x86 binary executables. RCV implements recovery shepherding, which attaches to the application process when an error occurs, repairs the execution, tracks the repair effects as the execution continues, contains the repair effects within the application process, and detaches from the process after all repair effects are flushed from the process state. RCV therefore incurs negligible overhead during the normal execution of the application.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594337", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fan", + "last_name": "Long", + "institution": "" + }, + { + "first_name": "Stelios", + "last_name": "Sidiroglou-Douskos", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "" + } + ], + "dblp_key": "conf/pldi/LongSR14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594310", + "title": "SCCharts: sequentially constructive statecharts for safety-critical applications: HW/SW-synthesis for a conservative extension of synchronous statecharts", + "abstract": "We present a new visual language, SCCharts, designed for specifying safety-critical reactive systems. SCCharts use a statechart notation and provide determinate concurrency based on a synchronous model of computation (MoC), without restrictions common to previous synchronous MoCs. Specifically, we lift earlier limitations on sequential accesses to shared variables, by leveraging the sequentially constructive MoC. The semantics and key features of SCCharts are defined by a very small set of elements, the Core SCCharts, consisting of state machines plus fork/join concurrency. We also present a compilation chain that allows efficient synthesis of software and hardware.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594310", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Reinhard von", + "last_name": "Hanxleden", + "institution": "Kiel University" + }, + { + "first_name": "Björn", + "last_name": "Duderstadt", + "institution": "Kiel University" + }, + { + "first_name": "Christian", + "last_name": "Motika", + "institution": "Kiel University" + }, + { + "first_name": "Steven", + "last_name": "Smyth", + "institution": "Kiel University" + }, + { + "first_name": "Michael", + "last_name": "Mendler", + "institution": "University of Bamberg" + }, + { + "first_name": "Joaquín", + "last_name": "Aguado", + "institution": "University of Bamberg" + }, + { + "first_name": "Stephen", + "last_name": "Mercer", + "institution": "National Instruments (United States)" + }, + { + "first_name": "Owen", + "last_name": "O'Brien", + "institution": "National Instruments (United States)" + } + ], + "dblp_key": "conf/pldi/HanxledenDMSMAMO14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594330", + "title": "Race detection for event-driven mobile applications", + "abstract": "Mobile systems commonly support an event-based model of concurrent programming. This model, used in popular platforms such as Android, naturally supports mobile devices that have a rich array of sensors and user input modalities. Unfortunately, most existing tools for detecting concurrency errors of parallel programs focus on a thread-based model of concurrency. If one applies such tools directly to an event-based program, they work poorly because they infer false dependencies between unrelated events handled sequentially by the same thread.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594330", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chun-Hung", + "last_name": "Hsiao", + "institution": "University of Michigan" + }, + { + "first_name": "Jie", + "last_name": "Yu", + "institution": "Twitter (United States)" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan" + }, + { + "first_name": "Ziyun", + "last_name": "Kong", + "institution": "University of Michigan" + }, + { + "first_name": "Cristiano", + "last_name": "Pereira", + "institution": "Intel (United States)" + }, + { + "first_name": "Gilles", + "last_name": "Pokam", + "institution": "Intel (United States)" + }, + { + "first_name": "Peter M.", + "last_name": "Chen", + "institution": "University of Michigan" + }, + { + "first_name": "Jason", + "last_name": "Flinn", + "institution": "University of Michigan" + } + ], + "dblp_key": "conf/pldi/HsiaoPYPNCKF14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594299", + "title": "FlowDroid: precise context, flow, field, object-sensitive and lifecycle-aware taint analysis for Android apps", + "abstract": "Today's smartphones are a ubiquitous source of private and confidential data. At the same time, smartphone users are plagued by carelessly programmed apps that leak important data by accident, and by malicious apps that exploit their given privileges to copy such data intentionally. While existing static taint-analysis approaches have the potential of detecting such data leaks ahead of time, all approaches for Android use a number of coarse-grain approximations that can yield high numbers of missed leaks and false alarms.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594299", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven", + "last_name": "Arzt", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Siegfried", + "last_name": "Rasthofer", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Christian", + "last_name": "Fritz", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Alexandre", + "last_name": "Bartel", + "institution": "University of Luxembourg" + }, + { + "first_name": "Jacques", + "last_name": "Klein", + "institution": "University of Luxembourg" + }, + { + "first_name": "Yves Le", + "last_name": "Traon", + "institution": "University of Luxembourg" + }, + { + "first_name": "Damien", + "last_name": "Octeau", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Patrick", + "last_name": "McDaniel", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/pldi/ArztRFBBKTOM14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594316", + "title": "Surgical precision JIT compilers", + "abstract": "Just-in-time (JIT) compilation of running programs provides more optimization opportunities than offline compilation. Modern JIT compilers, such as those in virtual machines like Oracle's HotSpot for Java or Google's V8 for JavaScript, rely on dynamic profiling as their key mechanism to guide optimizations. While these JIT compilers offer good average performance, their behavior is a black box and the achieved performance is highly unpredictable.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594316", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Oracle (United States)" + }, + { + "first_name": "Arvind K.", + "last_name": "Sujeeth", + "institution": "Stanford University" + }, + { + "first_name": "Kevin", + "last_name": "Brown", + "institution": "Stanford University" + }, + { + "first_name": "HyoukJoong", + "last_name": "Lee", + "institution": "Stanford University" + }, + { + "first_name": "Hassan", + "last_name": "Chafi", + "institution": "Oracle (United States)" + }, + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/RompfSBLCO14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594314", + "title": "Persistent pointer information", + "abstract": "Pointer information, indispensable for static analysis tools, is expensive to compute and query. We provide a query-efficient persistence technique, Pestrie, to mitigate the costly computation and slow querying of precise pointer information. Leveraging equivalence and hub properties, Pestrie can compress pointer information and answers pointer related queries very efficiently. The experiment shows that Pestrie produces 10.5X and 17.5X smaller persistent files than the traditional bitmap and BDD encodings. Meanwhile, Pestrie is 2.9X to 123.6X faster than traditional demand-driven approaches for serving points-to related queries.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594314", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiao", + "last_name": "Xiao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Jinguo", + "last_name": "Zhou", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/pldi/XiaoZZZ14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594340", + "title": "A lightweight symbolic virtual machine for solver-aided host languages", + "abstract": "Solver-aided domain-specific languages (SDSLs) are an emerging class of computer-aided programming systems. They ease the construction of programs by using satisfiability solvers to automate tasks such as verification, debugging, synthesis, and non-deterministic execution. But reducing programming tasks to satisfiability problems involves translating programs to logical constraints, which is an engineering challenge even for domain-specific languages.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594340", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/TorlakB14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594302", + "title": "Stochastic optimization of floating-point programs with tunable precision", + "abstract": "The aggressive optimization of floating-point computations is an important problem in high-performance computing. Unfortunately, floating-point instruction sets have complicated semantics that often force compilers to preserve programs as written. We present a method that treats floating-point optimization as a stochastic search problem. We demonstrate the ability to generate reduced precision implementations of Intel's handwritten C numeric library which are up to 6 times faster than the original code, and achieve end-to-end speedups of over 30% on a direct numeric simulation and a ray tracer by optimizing kernels that can tolerate a loss of precision while still remaining correct. Because these optimizations are mostly not amenable to formal verification using the current state of the art, we present a stochastic search technique for characterizing maximum error. The technique comes with an asymptotic guarantee and provides strong evidence of correctness.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594302", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Eric", + "last_name": "Schkufza", + "institution": "Stanford University" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/Schkufza0A14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594298", + "title": "Compiler-assisted detection of transient memory errors", + "abstract": "The probability of bit flips in hardware memory systems is projected to increase significantly as memory systems continue to scale in size and complexity. Effective hardware-based error detection and correction require that the complete data path, involving all parts of the memory system, be protected with sufficient redundancy. First, this may be costly to employ on commodity computing platforms, and second, even on high-end systems, protection against multi-bit errors may be lacking. Therefore, augmenting hardware error detection schemes with software techniques is of considerable interest.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594298", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sanket", + "last_name": "Tavarageri", + "institution": "The Ohio State University" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/TavarageriKS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594335", + "title": "Test-driven repair of data races in structured parallel programs", + "abstract": "A common workflow for developing parallel software is as follows: 1) start with a sequential program, 2) identify subcomputations that should be converted to parallel tasks, 3) insert synchronization to achieve the same semantics as the sequential program, and repeat steps 2) and 3) as needed to improve performance. Though this is not the only approach to developing parallel software, it is sufficiently common to warrant special attention as parallel programming becomes ubiquitous. This paper focuses on automating step 3), which is usually the hardest step for developers who lack expertise in parallel programming.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594335", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rishi", + "last_name": "Surendran", + "institution": "Rice University" + }, + { + "first_name": "Raghavan", + "last_name": "Raman", + "institution": "" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + }, + { + "first_name": "John", + "last_name": "Mellor‐Crummey", + "institution": "Rice University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/SurendranRCMS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594342", + "title": "A framework for enhancing data reuse via associative reordering", + "abstract": "The freedom to reorder computations involving associative operators has been widely recognized and exploited in designing parallel algorithms and to a more limited extent in optimizing compilers.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594342", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Stock", + "institution": "The Ohio State University" + }, + { + "first_name": "Martin", + "last_name": "Kong", + "institution": "The Ohio State University" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "École Normale Supérieure" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "" + }, + { + "first_name": "J.", + "last_name": "Ramanujam", + "institution": "Louisiana State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/StockKGPRRS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594344", + "title": "Æminium: a permission based concurrent-by-default programming language approach", + "abstract": "The aim of ÆMINIUM is to study the implications of having a concurrent-by-default programming language. This includes language design, runtime system, performance and software engineering considerations.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594344", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sven", + "last_name": "Stork", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Karl", + "last_name": "Naden", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Joshua", + "last_name": "Sunshine", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Manual", + "last_name": "Mohr", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Alcides", + "last_name": "Fonseca", + "institution": "University of Coimbra" + }, + { + "first_name": "Paulo", + "last_name": "Marques", + "institution": "University of Coimbra" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/StorkNSMFMA14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594292", + "title": "Adaptive, efficient, parallel execution of parallel programs", + "abstract": "Future multicore processors will be heterogeneous, be increasingly less reliable, and operate in dynamically changing operating conditions. Such environments will result in a constantly varying pool of hardware resources which can greatly complicate the task of efficiently exposing a program's parallelism onto these resources. Coupled with this uncertainty is the diverse set of efficiency metrics that users may desire. This paper proposes Varuna, a system that dynamically, continuously, rapidly and transparently adapts a program's parallelism to best match the instantaneous capabilities of the hardware resources while satisfying different efficiency metrics. Varuna is applicable to both multithreaded and task-based programs and can be seamlessly inserted between the program and the operating system without needing to change the source code of either.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594292", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "S.", + "last_name": "Sridharan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Gagan Raj", + "last_name": "Gupta", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Gurindar S.", + "last_name": "Sohi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/SridharanGS14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594305", + "title": "Consolidation of queries with user-defined functions", + "abstract": "Motivated by streaming and data analytics scenarios where many queries operate on the same data and perform similar computations, we propose program consolidation for merging multiple user-defined functions (UDFs) that operate on the same input. Program consolidation exploits common computations between UDFs to generate an equivalent optimized function whose execution cost is often much smaller (and never greater) than the sum of the costs of executing each function individually. We present a sound consolidation calculus and an effective algorithm for consolidating multiple UDFs. Our approach is purely static and uses symbolic SMT-based techniques to identify shared or redundant computations. We have implemented the proposed technique on top of the Naiad data processing system. Our experiments show that our algorithm dramatically improves overall job completion time when executing user-defined filters that operate on the same data and perform similar computations.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594305", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marcelo", + "last_name": "Sousa", + "institution": "University of Oxford" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Christos", + "last_name": "Gkantsidis", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/SousaDVDG14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594328", + "title": "Hybrid top-down and bottom-up interprocedural analysis", + "abstract": "Interprocedural static analyses are broadly classified into top-down and bottom-up, depending upon how they compute, instantiate, and reuse procedure summaries. Both kinds of analyses are challenging to scale: top-down analyses are hindered by ineffective reuse of summaries whereas bottom-up analyses are hindered by inefficient computation and instantiation of summaries. This paper presents a hybrid approach Swift that combines top-down and bottom-up analyses in a manner that gains their benefits without suffering their drawbacks. Swift is general in that it is parametrized by the top-down and bottom-up analyses it combines. We show an instantiation of Swift on a type-state analysis and evaluate it on a suite of 12 Java programs of size 60-250 KLOC each. Swift outperforms both conventional approaches, finishing on all the programs while both of those approaches fail on the larger programs.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594328", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Ravi", + "last_name": "Mangal", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/pldi/ZhangMNY14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594341", + "title": "Dynamic space limits for Haskell", + "abstract": "We describe the semantics and implementation of a space limits system for Haskell, which allows programmers to create resource containers that enforce bounded resident memory usage at runtime. Our system is distinguished by a clear allocator-pays semantics drawn from previous experience with profiling in Haskell and an implementation strategy which uses a block-structured heap to organize containers, allowing us to enforce limits with high accuracy. To deal with the problem of deallocating data in a garbage collected heap, we propose a novel taint-based mechanism that unifies the existing practices of revocable pointers and killing threads in order to reclaim memory. Our system is implemented in GHC, a production-strength compiler for Haskell.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594341", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Edward Z.", + "last_name": "Yang", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Mazières", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/YangM14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594293", + "title": "Doppio: breaking the browser language barrier", + "abstract": "Web browsers have become a de facto universal operating system, and JavaScript its instruction set. Unfortunately, running other languages in the browser is not generally possible. Translation to JavaScript is not enough because browsers are a hostile environment for other languages. Previous approaches are either non-portable or require extensive modifications for programs to work in a browser.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594293", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Vilk", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/VilkB14", + "venue": "pldi", + "year": 2014 + }, + { + "paper_id": "10.1145/2594291.2594327", + "title": "On abstraction refinement for program analyses in Datalog", + "abstract": "A central task for a program analysis concerns how to efficiently find a program abstraction that keeps only information relevant for proving properties of interest. We present a new approach for finding such abstractions for program analyses written in Datalog. Our approach is based on counterexample-guided abstraction refinement: when a Datalog analysis run fails using an abstraction, it seeks to generalize the cause of the failure to other abstractions, and pick a new abstraction that avoids a similar failure. Our solution uses a boolean satisfiability formulation that is general, complete, and optimal: it is independent of the Datalog solver, it generalizes the failure of an abstraction to as many other abstractions as possible, and it identifies the cheapest refined abstraction to try next. We show the performance of our approach on a pointer analysis and a typestate analysis, on eight real-world Java benchmark programs.", + "date": "2014-05-13", + "link": "https://doi.org/10.1145/2594291.2594327", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Ravi", + "last_name": "Mangal", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Radu", + "last_name": "Grigore", + "institution": "University of Oxford" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/pldi/ZhangMGNY14", + "venue": "pldi", + "year": 2014 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2015.json b/data/pl_conferences/pldi/2015.json new file mode 100644 index 0000000..d54a010 --- /dev/null +++ b/data/pl_conferences/pldi/2015.json @@ -0,0 +1,1769 @@ +[ + { + "paper_id": "10.1145/2737924.2737971", + "title": "Relatively complete counterexamples for higher-order programs", + "abstract": "In this paper, we study the problem of generating inputs to a higher-order program causing it to error. We first approach the problem in the setting of PCF, a typed, core functional language and contribute the first relatively complete method for constructing counterexamples for PCF programs. The method is relatively complete with respect to a first-order solver over the base types of PCF. In practice, this means an SMT solver can be used for the effective, automated generation of higher-order counterexamples for a large class of programs. We achieve this result by employing a novel form of symbolic execution for higher-order programs. The remarkable aspect of this symbolic execution is that even though symbolic higher-order inputs and values are considered, the path condition remains a first-order formula. Our handling of symbolic function application enables the reconstruction of higher-order counterexamples from this first-order formula. After establishing our main theoretical results, we sketch how to apply the approach to untyped, higher-order, stateful languages with first-class contracts and show how counterexample generation can be used to detect contract violations in this setting. To validate our approach, we implement a tool generating counterexamples for erroneous modules written in Racket.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737971", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Phúc C.", + "last_name": "Nguyễn", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/NguyenH15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737953", + "title": "Synthesizing parallel graph programs via automated planning", + "abstract": "We describe a system that uses automated planning to synthesize correct and efficient parallel graph programs from high-level algorithmic specifications. Automated planning allows us to use constraints to declaratively encode program transformations such as scheduling, implementation selection, and insertion of synchronization. Each plan emitted by the planner satisfies all constraints simultaneously, and corresponds to a composition of these transformations. In this way, we obtain an integrated compilation approach for a very challenging problem domain. We have used this system to synthesize parallel programs for four graph problems: triangle counting, maximal independent set computation, preflow-push maxflow, and connected components. Experiments on a variety of inputs show that the synthesized implementations perform competitively with hand-written, highly-tuned code.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737953", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dimitrios", + "last_name": "Prountzos", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Roman", + "last_name": "Manevich", + "institution": "Ben-Gurion University of the Negev" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/PrountzosMP15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738005", + "title": "A formal C memory model supporting integer-pointer casts", + "abstract": "The ISO C standard does not specify the semantics of many valid programs that use non-portable idioms such as integer-pointer casts. Recent efforts at formal definitions and verified implementation of the C language inherit this feature. By adopting high-level abstract memory models, they validate common optimizations. On the other hand, this prevents reasoning about much low-level code relying on the behavior of common implementations, where formal verification has many applications. We present the first formal memory model that allows many common optimizations and fully supports operations on the representation of pointers. All arithmetic operations are well-defined for pointers that have been cast to integers. Crucially, our model is also simple to understand and program with. All our results are fully formalized in Coq.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738005", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "William", + "last_name": "Mansky", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Dmitri", + "last_name": "Garbuzov", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/KangHMGZV15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737974", + "title": "Helium: lifting high-performance stencil kernels from stripped x86 binaries to halide DSL code", + "abstract": "Highly optimized programs are prone to bit rot, where performance quickly becomes suboptimal in the face of new hardware and compiler techniques. In this paper we show how to automatically lift performance-critical stencil kernels from a stripped x86 binary and generate the corresponding code in the high-level domain-specific language Halide. Using Halide’s state-of-the-art optimizations targeting current hardware, we show that new optimized versions of these kernels can replace the originals to rejuvenate the application for newer hardware. The original optimized code for kernels in stripped binaries is nearly impossible to analyze statically. Instead, we rely on dynamic traces to regenerate the kernels. We perform buffer structure reconstruction to identify input, intermediate and output buffer shapes. We abstract from a forest of concrete dependency trees which contain absolute memory addresses to symbolic trees suitable for high-level code generation. This is done by canonicalizing trees, clustering them based on structure, inferring higher-dimensional buffer accesses and finally by solving a set of linear equations based on buffer accesses to lift them up to simple, high-level expressions. Helium can handle highly optimized, complex stencil kernels with input-dependent conditionals. We lift seven kernels from Adobe Photoshop giving a 75% performance improvement, four kernels from IrfanView, leading to 4.97× performance, and one stencil from the miniGMG multigrid benchmark netting a 4.25× improvement in performance. We manually rejuvenated Photoshop by replacing eleven of Photoshop’s filters with our lifted implementations, giving 1.12× speedup without affecting the user experience.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737974", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jeffrey", + "last_name": "Bosboom", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Kevin", + "last_name": "Wu", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Shoaib", + "last_name": "Kamil", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Stanford University" + }, + { + "first_name": "Sylvain", + "last_name": "Paris", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Qin", + "last_name": "Zhao", + "institution": "Google (United States)" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/MendisBWKRPZA15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737973", + "title": "Concurrency debugging with differential schedule projections", + "abstract": "We present Symbiosis: a concurrency debugging technique based on novel differential schedule projections (DSPs). A DSP shows the small set of memory operations and data-flows responsible for a failure, as well as a reordering of those elements that avoids the failure. To build a DSP, Symbiosis first generates a full, failing, multithreaded schedule via thread path profiling and symbolic constraint solving. Symbiosis selectively reorders events in the failing schedule to produce a non-failing, alternate schedule. A DSP reports the ordering and data-flow differences between the failing and non-failing schedules. Our evaluation on buggy real-world software and benchmarks shows that, in practical time, Symbiosis generates DSPs that both isolate the small fraction of event orders and data-flows responsible for the failure, and show which event reorderings prevent failing. In our experiments, DSPs contain 81% fewer events and 96% less data-flows than the full failure-inducing schedules. Moreover, by allowing developers to focus on only a few events, DSPs reduce the amount of time required to find a valid fix.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737973", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nuno", + "last_name": "Machado", + "institution": "University of Lisbon" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Luı́s", + "last_name": "Rodrigues", + "institution": "University of Lisbon" + } + ], + "dblp_key": "conf/pldi/MachadoLR15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737997", + "title": "Peer-to-peer affine commitment using bitcoin", + "abstract": "The power of linear and affine logic lies in their ability to model state change. However, in a trustless, peer-to-peer setting, it is difficult to force principals to commit to state changes. We show how to solve the peer-to-peer affine commitment problem using a generalization of Bitcoin in which transactions deal in types rather than numbers. This has applications to proof-carrying authorization and mechanically executable contracts. Importantly, our system can be---and is---implemented on top of the existing Bitcoin network, so there is no need to recruit computing power to a new protocol.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737997", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Michael J.", + "last_name": "Sullivan", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/CraryS15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737984", + "title": "Automatic induction proofs of data-structures in imperative programs", + "abstract": "We consider the problem of automated reasoning about dynamically manipulated data structures. Essential properties are encoded as predicates whose definitions are formalized via user-defined recursive rules. Traditionally, proving relationships between such properties is limited to the unfold-and-match (U+M) paradigm which employs systematic transformation steps of folding/unfolding the rules. A proof, using U+M, succeeds when we find a sequence of transformations that produces a final formula which is obviously provable by simply matching terms. Our contribution here is the addition of the fundamental principle of induction to this automated process. We first show that some proof obligations that are dynamically generated in the process can be used as induction hypotheses in the future, and then we show how to use these hypotheses in an induction step which generates a new proof obligation aside from those obtained by using the fold/unfold operations. While the adding of induction is an obvious need in general, no automated method has managed to include this in a systematic and general way. The main reason for this is the problem of avoiding circular reasoning. We overcome this with a novel checking condition. In summary, our contribution is a proof method which – beyond U+M – performs automatic formula re-writing by treating previously encountered obligations in each proof path as possible induction hypotheses. In the practical evaluation part of this paper, we show how the commonly used technique of using unproven lemmas can be avoided, using realistic benchmarks. This not only removes the current burden of coming up with the appropriate lemmas, but also significantly boosts up the verification process, since lemma applications, coupled with unfolding, often induce a large search space. In the end, our method can automatically reason about a new class of formulas arising from practical program verification.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737984", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Duc-Hiep", + "last_name": "Chu", + "institution": "National University of Singapore" + }, + { + "first_name": "Joxan", + "last_name": "Jaffar", + "institution": "National University of Singapore" + }, + { + "first_name": "Minh-Thai", + "last_name": "Trinh", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/pldi/ChuJT15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737955", + "title": "Compositional certified resource bounds", + "abstract": "This paper presents a new approach for automatically deriving worst-case resource bounds for C programs. The described technique combines ideas from amortized analysis and abstract interpretation in a unified framework to address four challenges for state-of-the-art techniques: compositionality, user interaction, generation of proof certificates, and scalability. Compositionality is achieved by incorporating the potential method of amortized analysis. It enables the derivation of global whole-program bounds with local derivation rules by naturally tracking size changes of variables in sequenced loops and function calls. The resource consumption of functions is described abstractly and a function call can be analyzed without access to the function body. User interaction is supported with a new mechanism that clearly separates qualitative and quantitative verification. A user can guide the analysis to derive complex non-linear bounds by using auxiliary variables and assertions. The assertions are separately proved using established qualitative techniques such as abstract interpretation or Hoare logic. Proof certificates are automatically generated from the local derivation rules. A soundness proof of the derivation system with respect to a formal cost semantics guarantees the validity of the certificates. Scalability is attained by an efficient reduction of bound inference to a linear optimization problem that can be solved by off-the-shelf LP solvers. The analysis framework is implemented in the publicly-available tool C4B. An experimental evaluation demonstrates the advantages of the new technique with a comparison of C4B with existing tools on challenging micro benchmarks and the analysis of more than 2900 lines of C code from the cBench benchmark suite.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737955", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Quentin", + "last_name": "Carbonneaux", + "institution": "Yale University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/Carbonneaux0S15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738004", + "title": "Efficient execution of recursive programs on commodity vector hardware", + "abstract": "The pursuit of computational efficiency has led to the proliferation of throughput-oriented hardware, from GPUs to increasingly wide vector units on commodity processors and accelerators. This hardware is designed to efficiently execute data-parallel computations in a vectorized manner. However, many algorithms are more naturally expressed as divide-and-conquer, recursive, task-parallel computations. In the absence of data parallelism, it seems that such algorithms are not well suited to throughput-oriented architectures. This paper presents a set of novel code transformations that expose the data parallelism latent in recursive, task-parallel programs. These transformations facilitate straightforward vectorization of task-parallel programs on commodity hardware. We also present scheduling policies that maintain high utilization of vector resources while limiting space usage. Across several task-parallel benchmarks, we demonstrate both efficient vector resource utilization and substantial speedup on chips using Intel’s SSE4.2 vector units, as well as accelerators using Intel’s AVX512 units.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738004", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bin", + "last_name": "Ren", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "Youngjoon", + "last_name": "Jo", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "Kunal", + "last_name": "Agrawal", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/RenJKAK15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737957", + "title": "Exploring and enforcing security guarantees via program dependence graphs", + "abstract": "We present PIDGIN, a program analysis and understanding tool that enables the specification and enforcement of precise application-specific information security guarantees. PIDGIN also allows developers to interactively explore the information flows in their applications to develop policies and investigate counter-examples. PIDGIN combines program dependence graphs (PDGs), which precisely capture the information flows in a whole application, with a custom PDG query language. Queries express properties about the paths in the PDG; because paths in the PDG correspond to information flows in the application, queries can be used to specify global security policies. PIDGIN is scalable. Generating a PDG for a 330k line Java application takes 90 seconds, and checking a policy on that PDG takes under 14 seconds. The query language is expressive, supporting a large class of precise, application-specific security guarantees. Policies are separate from the code and do not interfere with testing or development, and can be used for security regression testing. We describe the design and implementation of PIDGIN and report on using it: (1) to explore information security guarantees in legacy programs; (2) to develop and modify security policies concurrently with application development; and (3) to develop policies based on known vulnerabilities.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737957", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Johnson", + "institution": "MIT Lincoln Laboratory" + }, + { + "first_name": "Lucas", + "last_name": "Waye", + "institution": "Harvard University Press" + }, + { + "first_name": "Scott", + "last_name": "Moore", + "institution": "Harvard University Press" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/pldi/JohnsonWMC15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737964", + "title": "Mechanized verification of fine-grained concurrent programs", + "abstract": "Efficient concurrent programs and data structures rarely employ coarse-grained synchronization mechanisms (i.e., locks); instead, they implement custom synchronization patterns via fine-grained primitives, such as compare-and-swap. Due to sophisticated interference scenarios between threads, reasoning about such programs is challenging and error-prone, and can benefit from mechanization. In this paper, we present the first completely formalized framework for mechanized verification of full functional correctness of fine-grained concurrent programs. Our tool is based on the recently proposed program logic FCSL. It is implemented as an embedded DSL in the dependently-typed language of the Coq proof assistant, and is powerful enough to reason about programming features such as higher-order functions and local thread spawning. By incorporating a uniform concurrency model, based on state-transition systems and partial commutative monoids, FCSL makes it possible to build proofs about concurrent libraries in a thread-local, compositional way, thus facilitating scalability and reuse: libraries are verified just once, and their specifications are used ubiquitously in client-side reasoning. We illustrate the proof layout in FCSL by example, outline its infrastructure, and report on our experience of using FCSL to verify a number of concurrent algorithms and data structures.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737964", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "IMDEA Software" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/pldi/SergeyNB15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738002", + "title": "Interactive parser synthesis by example", + "abstract": "Despite decades of research on parsing, the construction of parsers remains a painstaking, manual process prone to subtle bugs and pitfalls. We present a programming-by-example framework called Parsify that is able to synthesize a parser from input/output examples. The user does not write a single line of code. To achieve this, Parsify provides: (a) an iterative algorithm for synthesizing and refining a grammar one example at a time, (b) an interface that provides immediate visual feedback in response to changes in the grammar being refined, and (c) a graphical mechanism for specifying example parse trees using only textual selections. We empirically demonstrate the viability of our approach by using Parsify to construct parsers for source code drawn from Verilog, SQL, Apache, and Tiger.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738002", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alan", + "last_name": "Leung", + "institution": "University of California, San Diego" + }, + { + "first_name": "John", + "last_name": "Sarracino", + "institution": "University of California, San Diego" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/LeungSL15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737995", + "title": "The Push/Pull model of transactions", + "abstract": "We present a general theory of serializability, unifying a wide range of transactional algorithms, including some that are yet to come. To this end, we provide a compact semantics in which concurrent transactions PUSH their effects into the shared view (or UNPUSH to recall effects) and PULL the effects of potentially uncommitted concurrent transactions into their local view (or UNPULL to detangle). Each operation comes with simple criteria given in terms of commutativity (Lipton's left-movers and right-movers). The benefit of this model is that most of the elaborate reasoning (coinduction, simulation, subtle invariants, etc.) necessary for proving the serializability of a transactional algorithm is already proved within the semantic model. Thus, proving serializability (or opacity) amounts simply to mapping the algorithm on to our rules, and showing that it satisfies the rules' criteria.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737995", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/KoskinenP15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737975", + "title": "Stateless model checking concurrent programs with maximal causality reduction", + "abstract": "We present maximal causality reduction (MCR), a new technique for stateless model checking. MCR systematically explores the state-space of concurrent programs with a provably minimal number of executions. Each execution corresponds to a distinct maximal causal model extracted from a given execution trace, which captures the largest possible set of causally equivalent executions. Moreover, MCR is embarrassingly parallel by shifting the runtime exploration cost to offline analysis. We have designed and implemented MCR using a constraint-based approach and compared with iterative context bounding (ICB) and dynamic partial order reduction (DPOR) on both benchmarks and real-world programs. MCR reduces the number of executions explored by ICB and ICB+DPOR by orders of magnitude, and significantly improves the scalability, efficiency, and effectiveness of the state-of-the-art for both state-space exploration and bug finding. In our experiments, MCR has also revealed several new data races and null pointer dereference errors in frequently studied real-world programs.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737975", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/pldi/Huang15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737976", + "title": "Synthesis of ranking functions using extremal counterexamples", + "abstract": "We present a complete method for synthesizing lexicographic linear ranking functions, supported by inductive invariants, in the case where the transition relation includes disjunctions and existentials (large block encoding of complex control flow). Previous work would expand the transition relation into disjunctive normal form, or equivalently would expand the block transition into (exponentially many) elementary transitions, prior to computing the rank-ing function, resulting in a very large global constraint system. In contrast, our algorithm sees elementary transitions only as needed, and builds a global constraint system lazily.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737976", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Laure", + "last_name": "Gonnord", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "David", + "last_name": "Monniaux", + "institution": "Verimag" + }, + { + "first_name": "Gabriel", + "last_name": "Radanne", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "conf/pldi/GonnordMR15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737965", + "title": "Provably correct peephole optimizations with alive", + "abstract": "Compilers should not miscompile. Our work addresses problems in developing peephole optimizations that perform local rewriting to improve the efficiency of LLVM code. These optimizations are individually difficult to get right, particularly in the presence of undefined behavior; taken together they represent a persistent source of bugs. This paper presents Alive, a domain-specific language for writing optimizations and for automatically either proving them correct or else generating counterexamples. Furthermore, Alive can be automatically translated into C++ code that is suitable for inclusion in an LLVM optimization pass. Alive is based on an attempt to balance usability and formal methods; for example, it captures---but largely hides---the detailed semantics of three different kinds of undefined behavior in LLVM. We have translated more than 300 LLVM optimizations into Alive and, in the process, found that eight of them were wrong.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737965", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "David", + "last_name": "Menendez", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/LopesMNR15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737966", + "title": "Static detection of asymptotic performance bugs in collection traversals", + "abstract": "This paper identifies and formalizes a prevalent class of asymptotic performance bugs called redundant traversal bugs and presents a novel static analysis for automatically detecting them. We evaluate our technique by implementing it in a tool called CLARITY and applying it to widely-used software packages such as the Google Core Collections Library, the Apache Common Collections, and the Apache Ant build tool. Across 1.6M lines of Java code, CLARITY finds 92 instances of redundant traversal bugs, including 72 that have never been previously reported, with just 5 false positives. To evaluate the performance impact of these bugs, we manually repair these programs and find that for an input size of 50,000, all repaired programs are at least 2.45 faster than their original code.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737966", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Oswaldo", + "last_name": "Olivo", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Calvin", + "last_name": "Lin", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/OlivoDL15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737990", + "title": "Profile-guided meta-programming", + "abstract": "Contemporary compiler systems such as GCC, .NET, and LLVM incorporate profile-guided optimizations (PGOs) on low-level intermediate code and basic blocks, with impressive results over purely static heuristics. Recent work shows that profile information is also useful for performing source-to-source optimizations via meta-programming. For example, using profiling information to inform decisions about data structures and algorithms can potentially lead to asymptotic improvements in performance. We present a design for profile-guided meta-programming in a general-purpose meta-programming system. Our design is parametric over the particular profiler and meta-programming system. We implement this design in two different meta-programming systems---the syntactic extensions systems of Chez Scheme and Racket---and provide several profile-guided meta-programs as usability case studies.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737990", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "Northeastern University" + }, + { + "first_name": "Swaha", + "last_name": "Miller", + "institution": "Cisco Systems (United States)" + }, + { + "first_name": "Vincent", + "last_name": "St-Amour", + "institution": "Northeastern University" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Cisco Systems (United States)" + } + ], + "dblp_key": "conf/pldi/BowmanMSD15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737991", + "title": "KJS: a complete formal semantics of JavaScript", + "abstract": "This paper presents KJS, the most complete and throughly tested formal semantics of JavaScript to date. Being executable, KJS has been tested against the ECMAScript 5.1 conformance test suite, and passes all 2,782 core language tests. Among the existing implementations of JavaScript, only Chrome V8's passes all the tests, and no other semantics passes more than 90%. In addition to a reference implementation for JavaScript, KJS also yields a simple coverage metric for a test suite: the set of semantic rules it exercises. Our semantics revealed that the ECMAScript 5.1 conformance test suite fails to cover several semantic rules. Guided by the semantics, we wrote tests to exercise those rules. The new tests revealed bugs both in production JavaScript engines (Chrome V8, Safari WebKit, Firefox SpiderMonkey) and in other semantics. KJS is symbolically executable, thus it can be used for formal analysis and verification of JavaScript programs. We verified non-trivial programs and found a known security vulnerability.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737991", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daejun", + "last_name": "Park", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Andrei", + "last_name": "Ștefănescu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/ParkSR15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737963", + "title": "Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises", + "abstract": "Runtime metaprogramming enables many useful applications and is often a convenient solution to solve problems in a generic way, which makes it widely used in frameworks, middleware, and domain-specific languages. However, powerful metaobject protocols are rarely supported and even common concepts such as reflective method invocation or dynamic proxies are not optimized. Solutions proposed in literature either restrict the metaprogramming capabilities or require application or library developers to apply performance improving techniques. For overhead-free runtime metaprogramming, we demonstrate that dispatch chains, a generalized form of polymorphic inline caches common to self-optimizing interpreters, are a simple optimization at the language-implementation level. Our evaluation with self-optimizing interpreters shows that unrestricted metaobject protocols can be realized for the first time without runtime overhead, and that this optimization is applicable for just-in-time compilation of interpreters based on meta-tracing as well as partial evaluation. In this context, we also demonstrate that optimizing common reflective operations can lead to significant performance improvements for existing applications.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737963", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Marr", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Chris", + "last_name": "Seaton", + "institution": "University of Manchester" + }, + { + "first_name": "Sté́phane", + "last_name": "Ducasse", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/MarrSD15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737999", + "title": "Celebrating diversity: a mixture of experts approach for runtime mapping in dynamic environments", + "abstract": "Matching program parallelism to platform parallelism using thread selection is difficult when the environment and available resources dynamically change. Existing compiler or runtime approaches are typically based on a one-size fits all policy. There is little ability to either evaluate or adapt the policy when encountering new external workloads or hardware resources. This paper focuses on selecting the best number of threads for a parallel application in dynamic environments. It develops a new scheme based on a mixture of experts approach. It learns online which, of a number of existing policies, or experts, is best suited for a particular environment without having to try out each policy. It does this by using a novel environment predictor as a proxy for the quality of an expert thread selection policy. Additional expert policies can easily be added and are selected only when appropriate. We evaluate our scheme in environments with varying external workloads and hardware resources.We then consider the case when workloads use affinity scheduling or are themselves adaptive and show that our approach, in all cases, outperforms existing schemes and surprisingly improves workload performance. On average, we improve 1.66x over OpenMP default, 1.34x over an online scheme, 1.25x over an offline policy and 1.2x over a state-of-art analytic model. Determining the right number and type of experts is an open problem and our initial analysis shows that adding more experts improves accuracy and performance.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737999", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Murali", + "last_name": "Emani", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/EmaniO15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737969", + "title": "Autotuning algorithmic choice for input sensitivity", + "abstract": "A daunting challenge faced by program performance autotuning is input sensitivity, where the best autotuned configuration may vary with different input sets. This paper presents a novel two-level input learning algorithm to tackle the challenge for an important class of autotuning problems, algorithmic autotuning. The new approach uses a two-level input clustering method to automatically refine input grouping, feature selection, and classifier construction. Its design solves a series of open issues that are particularly essential to algorithmic autotuning, including the enormous optimization space, complex influence by deep input features, high cost in feature extraction, and variable accuracy of algorithmic choices. Experimental results show that the new solution yields up to a 3x speedup over using a single configuration for all inputs, and a 34x speedup over a traditional one-level method for addressing input sensitivity in program optimizations.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737969", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yufei", + "last_name": "Ding", + "institution": "North Carolina State University" + }, + { + "first_name": "Jason", + "last_name": "Ansel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Kalyan", + "last_name": "Veeramachaneni", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + }, + { + "first_name": "Una-May", + "last_name": "O’Reilly", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/DingAVSOA15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738003", + "title": "Loop and data transformations for sparse matrix code", + "abstract": "This paper introduces three new compiler transformations for representing and transforming sparse matrix computations and their data representations. In cooperation with run-time inspection, our compiler derives transformed matrix representations and associated transformed code to implement a variety of representations targeting different architecture platforms. This systematic approach to combining code and data transformations on sparse computations, which extends a polyhedral transformation and code generation framework, permits the compiler to compose these transformations with other transformations to generate code that is on average within 5% and often exceeds manually-tuned, high-performance sparse matrix libraries CUSP and OSKI. Additionally, the compiler-generated inspector codes are on average 1.5 faster than OSKI and perform comparably to CUSP, respectively.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738003", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anand", + "last_name": "Venkat", + "institution": "University of Utah" + }, + { + "first_name": "Mary", + "last_name": "Hall", + "institution": "University of Utah" + }, + { + "first_name": "Michelle Mills", + "last_name": "Strout", + "institution": "Colorado State University" + } + ], + "dblp_key": "conf/pldi/VenkatHS15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737977", + "title": "Synthesizing data structure transformations from input-output examples", + "abstract": "We present a method for example-guided synthesis of functional programs over recursive data structures. Given a set of input-output examples, our method synthesizes a program in a functional language with higher-order combinators like map and fold. The synthesized program is guaranteed to be the simplest program in the language to fit the examples. Our approach combines three technical ideas: inductive generalization, deduction, and enumerative search. First, we generalize the input-output examples into hypotheses about the structure of the target program. For each hypothesis, we use deduction to infer new input/output examples for the missing subexpressions. This leads to a new subproblem where the goal is to synthesize expressions within each hypothesis. Since not every hypothesis can be realized into a program that fits the examples, we use a combination of best-first enumeration and deduction to search for a hypothesis that meets our needs. We have implemented our method in a tool called λ2, and we evaluate this tool on a large set of synthesis problems involving lists, trees, and nested data structures. The experiments demonstrate the scalability and broad scope of λ2. A highlight is the synthesis of a program believed to be the world's earliest functional pearl.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737977", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Feser", + "institution": "Rice University" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/FeserCD15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737952", + "title": "FlashRelate: extracting relational data from semi-structured spreadsheets using examples", + "abstract": "With hundreds of millions of users, spreadsheets are one of the most important end-user applications. Spreadsheets are easy to use and allow users great flexibility in storing data. This flexibility comes at a price: users often treat spreadsheets as a poor man's database, leading to creative solutions for storing high-dimensional data. The trouble arises when users need to answer queries with their data. Data manipulation tools make strong assumptions about data layouts and cannot read these ad-hoc databases. Converting data into the appropriate layout requires programming skills or a major investment in manual reformatting. The effect is that a vast amount of real-world data is \"locked-in\" to a proliferation of one-off formats. We introduce FlashRelate, a synthesis engine that lets ordinary users extract structured relational data from spreadsheets without programming. Instead, users extract data by supplying examples of output relational tuples. FlashRelate uses these examples to synthesize a program in Flare. Flare is a novel extraction language that extends regular expressions with geometric constructs. An interactive user interface on top of FlashRelate lets end users extract data by point-and-click. We demonstrate that correct Flare programs can be synthesized in seconds from a small set of examples for 43 real-world scenarios. Finally, our case study demonstrates FlashRelate's usefulness addressing the widespread problem of data trapped in corporate and government formats.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737952", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel W.", + "last_name": "Barowy", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ted", + "last_name": "Hart", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/BarowyGHZ15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737968", + "title": "Blame and coercion: together again for the first time", + "abstract": "C#, Dart, Pyret, Racket, TypeScript, VB: many recent languages integrate dynamic and static types via gradual typing. We systematically develop three calculi for gradual typing and the relations between them, building on and strengthening previous work. The calculi are: λB, based on the blame calculus of Wadler and Findler (2009); λC, inspired by the coercion calculus of Henglein (1994); λS inspired by the space-efficient calculus of Herman, Tomb, and Flanagan (2006) and the threesome calculus of Siek and Wadler (2010). While λB is little changed from previous work, λC and λS are new. Together, λB, λC, and λS provide a coherent foundation for design, implementation, and optimisation of gradual types. We define translations from λB to λC and from λC to λS. Much previous work lacked proofs of correctness or had weak correctness criteria; here we demonstrate the strongest correctness criterion one could hope for, that each of the translations is fully abstract. Each of the calculi reinforces the design of the others: λC has a particularly simple definition, and the subtle definition of blame safety for λB is justified by the simple definition of blame safety for λC. Our calculus λS is implementation-ready: the first space-efficient calculus that is both straightforward to implement and easy to understand. We give two applications: first, using full abstraction from λC to λS to validate the challenging part of full abstraction between λB and λC; and, second, using full abstraction from λB to λS to easily establish the Fundamental Property of Casts, which required a custom bisimulation and six lemmas in earlier work.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737968", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/SiekTW15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738007", + "title": "Type-and-example-directed program synthesis", + "abstract": "This paper presents an algorithm for synthesizing recursive functions that process algebraic datatypes. It is founded on proof-theoretic techniques that exploit both type information and input–output examples to prune the search space. The algorithm uses refinement trees, a data structure that succinctly represents constraints on the shape of generated code. We evaluate the algorithm by using a prototype implementation to synthesize more than 40 benchmarks and several non-trivial larger examples. Our results demonstrate that the approach meets or outperforms the state-of-the-art for this domain, in terms of synthesis time or attainable size of the generated programs.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738007", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter-Michael", + "last_name": "Osera", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/OseraZ15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737978", + "title": "A simpler, safer programming and execution model for intermittent systems", + "abstract": "Energy harvesting enables novel devices and applications without batteries, but intermittent operation under energy harvesting poses new challenges to memory consistency that threaten to leave applications in failed states not reachable in continuous execution. This paper presents analytical models that aid in reasoning about intermittence. Using these, we develop DINO (Death Is Not an Option), a programming and execution model that simplifies programming for intermittent systems and ensures volatile and nonvolatile data consistency despite near-constant interruptions. DINO is the first system to address these consistency problems in the context of intermittent execution. We evaluate DINO on three energy-harvesting hardware platforms running different applications. The applications fail and exhibit error without DINO, but run correctly with DINO’s modest 1.8–2.7× run-time overhead. DINO also dramatically simplifies programming, reducing the set of possible failure- related control transfers by 5–9×.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737978", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Benjamin", + "last_name": "Ransford", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/LuciaR15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737967", + "title": "Preventing glitches and short circuits in high-level self-timed chip specifications", + "abstract": "Self-timed chip designs are commonly specified in a high-level message-passing language called CHP. This language is closely related to Hoare's CSP except it admits erroneous behavior due to the necessary limitations of efficient hardware implementations. For example, two processes sending on the same channel at the same time causes glitches and short circuits in the physical chip implementation. If a CHP program maintains certain invariants, such as only one process is sending on any given channel at a time, it can guarantee an error-free execution that behaves much like a CSP program would. In this paper, we present an inferable effect system for ensuring that these invariants hold, drawing from model-checking methodologies while exploiting language-usage patterns and domain-specific specializations to achieve efficiency. This analysis is sound, and is even complete for the common subset of CHP programs without data-sensitive synchronization. We have implemented the analysis and demonstrated that it scales to validate even microprocessors.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737967", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Longfield", + "institution": "Cornell University" + }, + { + "first_name": "Brittany", + "last_name": "Nkounkou", + "institution": "Cornell University" + }, + { + "first_name": "Rajit", + "last_name": "Manohar", + "institution": "Cornell University" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/LongfieldNMT15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737993", + "title": "Termination and non-termination specification inference", + "abstract": "Techniques for proving termination and non-termination of imperative programs are usually considered as orthogonal mechanisms. In this paper, we propose a novel mechanism that analyzes and proves both program termination and non-termination at the same time. We first introduce the concept of second-order termination constraints and accumulate a set of relational assumptions on them via a Hoare-style verification. We then solve these assumptions with case analysis to determine the (conditional) termination and non- termination scenarios expressed in some specification logic form. In contrast to current approaches, our technique can construct a summary of terminating and non-terminating behaviors for each method. This enables modularity and reuse for our termination and non-termination proving processes. We have tested our tool on sample programs from a recent termination competition, and compared favorably against state-of-the-art termination analyzers.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737993", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ton Chanh", + "last_name": "Le", + "institution": "National University of Singapore" + }, + { + "first_name": "Shengchao", + "last_name": "Qin", + "institution": "Teesside University" + }, + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/pldi/LeQC15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737983", + "title": "Monitoring refinement via symbolic reasoning", + "abstract": "Efficient implementations of concurrent objects such as semaphores, locks, and atomic collections are essential to modern computing. Programming such objects is error prone: in minimizing the synchronization overhead between concurrent object invocations, one risks the conformance to reference implementations — or in formal terms, one risks violating observational refinement. Precisely testing this refinement even within a single execution is intractable, limiting existing approaches to executions with very few object invocations. We develop scalable and effective algorithms for detecting refinement violations. Our algorithms are founded on incremental, symbolic reasoning, and exploit foundational insights into the refinement-checking problem. Our approach is sound, in that we detect only actual violations, and scales far beyond existing violation-detection algorithms. Empirically, we find that our approach is practically complete, in that we detect the violations arising in actual executions.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737983", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Université Paris Cité" + }, + { + "first_name": "Jad", + "last_name": "Hamza", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "conf/pldi/EmmiEH15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2774972", + "title": "Verification of a cryptographic primitive: SHA-256 (abstract)", + "abstract": "A full formal machine-checked verification of a C program: the OpenSSL implementation of SHA-256. This is an interactive proof of functional correctness in the Coq proof assistant, using the Verifiable C program logic. Verifiable C is a separation logic for the C language, proved sound w.r.t. the operational semantics for C, connected to the CompCert verified optimizing C compiler.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2774972", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/Appel15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737981", + "title": "Declarative programming over eventually consistent data stores", + "abstract": "User-facing online services utilize geo-distributed data stores to minimize latency and tolerate partial failures, with the intention of providing a fast, always-on experience. However, geo-distribution does not come for free; application developers have to contend with weak consistency behaviors, and the lack of abstractions to composably construct high-level replicated data types, necessitating the need for complex application logic and invariably exposing inconsistencies to the user. Some commercial distributed data stores and several academic proposals provide a lattice of consistency levels, with stronger consistency guarantees incurring increased latency and throughput costs. However, correctly assigning the right consistency level for an operation requires subtle reasoning and is often an error-prone task. In this paper, we present QUELEA, a declarative programming model for eventually consistent data stores (ECDS), equipped with a contract language, capable of specifying fine-grained application - level consistency properties. A contract enforcement system analyses contracts, and automatically generates the appropriate consistency protocol for the method protected by the contract. We describe an implementation of QUELEA on top of an off-the-shelf ECDS that provides support for coordination-free transactions. Several benchmarks including two large web applications, illustrate the effectiveness of our approach.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737981", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "University of Cambridge" + }, + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/Sivaramakrishnan15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737962", + "title": "Verification of producer-consumer synchronization in GPU programs", + "abstract": "Previous efforts to formally verify code written for GPUs have focused solely on kernels written within the traditional data-parallel GPU programming model. No previous work has considered the higher performance, but more complex, warp-specialized kernels based on producer-consumer named barriers available on current hardware. In this work we present the first formal operational semantics for named barriers and define what it means for a warp-specialized kernel to be correct. We give algorithms for verifying the correctness of warp-specialized kernels and prove that they are both sound and complete for the most common class of warp-specialized programs. We also present WEFT, a verification tool for checking warp-specialized code. Using WEFT, we discover several non-trivial bugs in production warp-specialized kernels.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737962", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Michael", + "last_name": "Bauer", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/SharmaBA15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737987", + "title": "DAG inlining: a decision procedure for reachability-modulo-theories in hierarchical programs", + "abstract": "A hierarchical program is one with multiple procedures but no loops or recursion. This paper studies the problem of deciding reachability queries in hierarchical programs where individual statements can be encoded in a decidable logic (say in SMT). This problem is fundamental to verification and most directly applicable to doing bounded reachability in programs, i.e., reachability under a bound on the number of loop iterations and recursive calls. The usual method of deciding reachability in hierarchical programs is to first inline all procedures and then do reachability on the resulting single-procedure program. Such inlining unfolds the call graph of the program to a tree and may lead to an exponential increase in the size of the program. We design and evaluate a method called DAG inlining that unfolds the call graph to a directed acyclic graph (DAG) instead of a tree by sharing the bodies of procedures at certain points during inlining. DAG inlining can produce much more compact representations than tree inlining. Empirically, we show that it leads to significant improvements in the running time of a state-of-the-art verifier.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737987", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/LalQ15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737961", + "title": "Finding counterexamples from parsing conflicts", + "abstract": "Writing a parser remains remarkably painful. Automatic parser generators offer a powerful and systematic way to parse complex grammars, but debugging conflicts in grammars can be time-consuming even for experienced language designers. Better tools for diagnosing parsing conflicts will alleviate this difficulty. This paper proposes a practical algorithm that generates compact, helpful counterexamples for LALR grammars. For each parsing conflict in a grammar, a counterexample demonstrating the conflict is constructed. When the grammar in question is ambiguous, the algorithm usually generates a compact counterexample illustrating the ambiguity. This algorithm has been implemented as an extension to the CUP parser generator. The results from applying this implementation to a diverse collection of faulty grammars show that the algorithm is practical, effective, and suitable for inclusion in other LALR parser generators.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737961", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chinawat", + "last_name": "Isradisaikul", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/IsradisaikulM15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737959", + "title": "Automatically improving accuracy for floating point expressions", + "abstract": "Scientific and engineering applications depend on floating point arithmetic to approximate real arithmetic. This approximation introduces rounding error, which can accumulate to produce unacceptable results. While the numerical methods literature provides techniques to mitigate rounding error, applying these techniques requires manually rearranging expressions and understanding the finer details of floating point arithmetic. We introduce Herbie, a tool which automatically discovers the rewrites experts perform to improve accuracy. Herbie's heuristic search estimates and localizes rounding error using sampled points (rather than static error analysis), applies a database of rules to generate improvements, takes series expansions, and combines improvements for different input regions. We evaluated Herbie on examples from a classic numerical methods textbook, and found that Herbie was able to improve accuracy on each example, some by up to 60 bits, while imposing a median performance overhead of 40%. Colleagues in machine learning have used Herbie to significantly improve the results of a clustering algorithm, and a mathematical library has accepted two patches generated using Herbie.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737959", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Washington" + }, + { + "first_name": "Alex", + "last_name": "Sanchez-Stern", + "institution": "University of Washington" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/PanchekhaSWT15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737989", + "title": "Optimizing off-chip accesses in multicores", + "abstract": "In a network-on-chip (NoC) based manycore architecture, an off-chip data access (main memory access) needs to travel through the on-chip network, spending considerable amount of time within the chip (in addition to the memory access latency). In addition, it contends with on-chip (cache) accesses as both use the same NoC resources. In this paper, focusing on data-parallel, multithreaded applications, we propose a compiler-based off-chip data access localization strategy, which places data elements in the memory space such that an off-chip access traverses a minimum number of links (hops) to reach the memory controller that handles this access. This brings three main benefits. First, the network latency of off-chip accesses gets reduced; second, the network latency of on-chip accesses gets reduced; and finally, the memory latency of off-chip accesses improves, due to reduced queue latencies. We present an experimental evaluation of our optimization strategy using a set of 13 multithreaded application programs under both private and shared last-level caches. The results collected emphasize the importance of optimizing the off-chip data accesses.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737989", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "W.", + "last_name": "Ding", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Xulong", + "last_name": "Tang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Yuanrui", + "last_name": "Zhang", + "institution": "Intel (United States)" + }, + { + "first_name": "Emre", + "last_name": "Kültürsay", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/pldi/DingTKZK15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737954", + "title": "Improving compiler scalability: optimizing large programs at small price", + "abstract": "Compiler scalability is a well known problem: reasoning about the application of useful optimizations over large program scopes consumes too much time and memory during compilation. This problem is exacerbated in polyhedral compilers that use powerful yet costly integer programming algorithms to compose loop optimizations. As a result, the benefits that a polyhedral compiler has to offer to programs such as real scientific applications that contain sequences of loop nests, remain impractical for the common users. In this work, we address this scalability problem in polyhedral compilers. We identify three causes of unscalability, each of which stems from large number of statements and dependences in the program scope. We propose a one-shot solution to the problem by reducing the effective number of statements and dependences as seen by the compiler. We achieve this by representing a sequence of statements in a program by a single super-statement. This set of super-statements exposes the minimum sufficient constraints to the Integer Linear Programming (ILP) solver for finding correct optimizations. We implement our approach in the PLuTo polyhedral compiler and find that it condenses the program statements and program dependences by factors of 4.7x and 6.4x, respectively, averaged over 9 hot regions (ranging from 48 to 121 statements) in 5 real applications. As a result, the improvements in time and memory requirement for compilation are 268x and 20x, respectively, over the latest version of the PLuTo compiler. The final compile times are comparable to the Intel compiler while the performance is 1.92x better on average due to the latter’s conservative approach to loop optimization.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737954", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sanyam", + "last_name": "Mehta", + "institution": "University of Minnesota" + }, + { + "first_name": "Pen-Chung", + "last_name": "Yew", + "institution": "University of Minnesota" + } + ], + "dblp_key": "conf/pldi/MehtaY15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737985", + "title": "Algorithmic debugging of real-world haskell programs: deriving dependencies from the cost centre stack", + "abstract": "Existing algorithmic debuggers for Haskell require a transformation of all modules in a program, even libraries that the user does not want to debug and which may use language features not supported by the debugger. This is a pity, because a promising approach to debugging is therefore not applicable to many real-world programs. We use the cost centre stack from the Glasgow Haskell Compiler profiling environment together with runtime value observations as provided by the Haskell Object Observation Debugger (HOOD) to collect enough information for algorithmic debugging. Program annotations are in suspected modules only. With this technique algorithmic debugging is applicable to a much larger set of Haskell programs. This demonstrates that for functional languages in general a simple stack trace extension is useful to support tasks such as profiling and debugging.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737985", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Maarten", + "last_name": "Faddegon", + "institution": "University of Kent" + }, + { + "first_name": "Olaf", + "last_name": "Chitil", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/pldi/FaddegonC15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738000", + "title": "Making numerical program analysis fast", + "abstract": "Numerical abstract domains are a fundamental component in modern static program analysis and are used in a wide range of scenarios (e.g. computing array bounds, disjointness, etc). However, analysis with these domains can be very expensive, deeply affecting the scalability and practical applicability of the static analysis. Hence, it is critical to ensure that these domains are made highly efficient. In this work, we present a complete approach for optimizing the performance of the Octagon numerical abstract domain, a domain shown to be particularly effective in practice. Our optimization approach is based on two key insights: i) the ability to perform online decomposition of the octagons leading to a massive reduction in operation counts, and ii) leveraging classic performance optimizations from linear algebra such as vectorization, locality of reference, scalar replacement and others, for improving the key bottlenecks of the domain. Applying these ideas, we designed new algorithms for the core Octagon operators with better asymptotic runtime than prior work and combined them with the optimization techniques to achieve high actual performance. We implemented our approach in the Octagon operators exported by the popular APRON C library, thus enabling existing static analyzers using APRON to immediately benefit from our work. To demonstrate the performance benefits of our approach, we evaluated our framework on three published static analyzers showing massive speed-ups for the time spent in Octagon analysis (e.g., up to 146x) as well as significant end-to-end program analysis speed-ups (up to 18.7x). Based on these results, we believe that our framework can serve as a new basis for static analysis with the Octagon numerical domain.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738000", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "ETH Zurich" + }, + { + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/SinghPV15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737982", + "title": "Efficient synthesis of probabilistic programs", + "abstract": "We show how to automatically synthesize probabilistic programs from real-world datasets. Such a synthesis is feasible due to a combination of two techniques: (1) We borrow the idea of ``sketching'' from synthesis of deterministic programs, and allow the programmer to write a skeleton program with ``holes''. Sketches enable the programmer to communicate domain-specific intuition about the structure of the desired program and prune the search space, and (2) we design an efficient Markov Chain Monte Carlo (MCMC) based synthesis algorithm to instantiate the holes in the sketch with program fragments. Our algorithm efficiently synthesizes a probabilistic program that is most consistent with the data. A core difficulty in synthesizing probabilistic programs is computing the likelihood L(P | D) of a candidate program P generating data D. We propose an approximate method to compute likelihoods using mixtures of Gaussian distributions, thereby avoiding expensive computation of integrals. The use of such approximations enables us to speed up evaluation of the likelihood of candidate programs by a factor of 1000, and makes Markov Chain Monte Carlo based search feasible. We have implemented our algorithm in a tool called PSKETCH, and our results are encouraging PSKETCH is able to automatically synthesize 16 non-trivial real-world probabilistic programs.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737982", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Sherjil", + "last_name": "Ozair", + "institution": "Indian Institute of Technology Delhi" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Deepak", + "last_name": "Vijaykeerthy", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/pldi/NoriORV15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737994", + "title": "LaminarIR: compile-time queues for structured streams", + "abstract": "Stream programming languages employ FIFO (first-in, first-out) semantics to model data channels between producers and consumers. A FIFO data channel stores tokens in a buffer that is accessed indirectly via read- and write-pointers. This indirect token-access decouples a producer’s write-operations from the read-operations of the consumer, thereby making dataflow implicit. For a compiler, indirect token-access obscures data-dependencies, which renders standard optimizations ineffective and impacts stream program performance negatively. In this paper we propose a transformation for structured stream programming languages such as StreamIt that shifts FIFO buffer management from run-time to compile-time and eliminates splitters and joiners, whose task is to distribute and merge streams. To show the effectiveness of our lowering transformation, we have implemented a StreamIt to C compilation framework. We have developed our own intermediate representation (IR) called LaminarIR, which facilitates the transformation. We report on the enabling effect of the LaminarIR on LLVM’s optimizations, which required the conversion of several standard StreamIt benchmarks from static to randomized input, to prevent computation of partial results at compile-time. We conducted our experimental evaluation on the Intel i7-2600K, AMD Opteron 6378, Intel Xeon Phi 3120A and ARM Cortex-A15 platforms. Our LaminarIR reduces data-communication on average by 35.9% and achieves platform-specific speedups between 3.73x and 4.98x over StreamIt. We reduce memory accesses by more than 60% and achieve energy savings of up to 93.6% on the Intel i7-2600K.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737994", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yousun", + "last_name": "Ko", + "institution": "Yonsei University" + }, + { + "first_name": "Bernd", + "last_name": "Burgstaller", + "institution": "Yonsei University" + }, + { + "first_name": "Bernhard", + "last_name": "Scholz", + "institution": "University of Sydney" + } + ], + "dblp_key": "conf/pldi/KoBS15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737996", + "title": "Asynchronous programming, analysis and testing with state machines", + "abstract": "Programming efficient asynchronous systems is challenging because it can often be hard to express the design declaratively, or to defend against data races and interleaving-dependent assertion violations. Previous work has only addressed these challenges in isolation, by either designing a new declarative language, a new data race detection tool or a new testing technique. We present P#, a language for high-reliability asynchronous programming co-designed with a static data race analysis and systematic concurrency testing infrastructure. We describe our experience using P# to write several distributed protocols and port an industrial-scale system internal to Microsoft, showing that the combined techniques, by leveraging the design of P#, are effective in finding bugs.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737996", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pantazis", + "last_name": "Deligiannis", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Jeroen", + "last_name": "Ketema", + "institution": "Imperial College London" + }, + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Paul", + "last_name": "Thomson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/pldi/DeligiannisDKLT15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737960", + "title": "Synthesis of machine code from semantics", + "abstract": "In this paper, we present a technique to synthesize machine-code instructions from a semantic specification, given as a Quantifier-Free Bit-Vector (QFBV) logic formula. Our technique uses an instantiation of the Counter-Example Guided Inductive Synthesis (CEGIS) framework, in combination with search-space pruning heuristics to synthesize instruction-sequences. To counter the exponential cost inherent in enumerative synthesis, our technique uses a divide-and-conquer strategy to break the input QFBV formula into independent sub-formulas, and synthesize instructions for the sub-formulas. Synthesizers created by our technique could be used to create semantics-based binary rewriting tools such as optimizers, partial evaluators, program obfuscators/de-obfuscators, etc. Our experiments for Intel's IA-32 instruction set show that, in comparison to our baseline algorithm, our search-space pruning heuristics reduce the synthesis time by a factor of 473, and our divide-and-conquer strategy reduces the synthesis time by a further 3 to 5 orders of magnitude.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737960", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Venkatesh", + "last_name": "Srinivasan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/SrinivasanR15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737998", + "title": "Synthesizing racy tests", + "abstract": "Subtle concurrency errors in multithreaded libraries that arise because of incorrect or inadequate synchronization are often difficult to pinpoint precisely using only static techniques. On the other hand, the effectiveness of dynamic race detectors is critically dependent on multithreaded test suites whose execution can be used to identify and trigger races. Usually, such multithreaded tests need to invoke a specific combination of methods with objects involved in the invocations being shared appropriately to expose a race. Without a priori knowledge of the race, construction of such tests can be challenging. In this paper, we present a lightweight and scalable technique for synthesizing precisely these kinds of tests. Given a multithreaded library and a sequential test suite, we describe a fully automated analysis that examines sequential execution traces, and produces as its output a concurrent client program that drives shared objects via library method calls to states conducive for triggering a race. Experimental results on a variety of well-tested Java libraries yield 101 synthesized multithreaded tests in less than four minutes. Analyzing the execution of these tests using an off-the-shelf race detector reveals 187 harmful races, including several previously unreported ones. Our implementation, named NARADA, and the results of our experiments are available at http://www.csa.iisc.ernet.in/~sss/tools/narada.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737998", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Malavika", + "last_name": "Samak", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Murali", + "last_name": "Ramanathan", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/SamakRJ15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737980", + "title": "Efficient synthesis of network updates", + "abstract": "Software-defined networking (SDN) is revolutionizing the networking industry, but current SDN programming platforms do not provide automated mechanisms for updating global configurations on the fly. Implementing updates by hand is challenging for SDN programmers because networks are distributed systems with hundreds or thousands of interacting nodes. Even if initial and final configurations are correct, naively updating individual nodes can lead to incorrect transient behaviors, including loops, black holes, and access control violations. This paper presents an approach for automatically synthesizing updates that are guaranteed to preserve specified properties. We formalize network updates as a distributed programming problem and develop a synthesis algorithm based on counterexample-guided search and incremental model checking. We describe a prototype implementation, and present results from experiments on real-world topologies and properties demonstrating that our tool scales to updates involving over one-thousand nodes.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737980", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jedidiah", + "last_name": "McClurg", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Hossein", + "last_name": "Hojjat", + "institution": "Cornell University" + }, + { + "first_name": "Pavol", + "last_name": "Černý", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/McClurgHCF15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738006", + "title": "Relaxing safely: verified on-the-fly garbage collection for x86-TSO", + "abstract": "We report on a machine-checked verification of safety for a state-of-the-art, on-the-fly, concurrent, mark-sweep garbage collector that is designed for multi-core architectures with weak memory consistency. The proof explicitly incorporates the relaxed memory semantics of x86 multiprocessors. To our knowledge, this is the first fully machine-checked proof of safety for such a garbage collector. We couch the proof in a framework that system implementers will find appealing, with the fundamental components of the system specified in a simple and intuitive programming language. The abstract model is detailed enough for its correspondence with an assembly language implementation to be straightforward.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738006", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter", + "last_name": "Gammie", + "institution": "Data61" + }, + { + "first_name": "Antony L.", + "last_name": "Hosking", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kai", + "last_name": "Engelhardt", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/pldi/GammieHE15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737986", + "title": "Many-core compiler fuzzing", + "abstract": "We address the compiler correctness problem for many-core systems through novel applications of fuzz testing to OpenCL compilers. Focusing on two methods from prior work, random differential testing and testing via equivalence modulo inputs (EMI), we present several strategies for random generation of deterministic, communicating OpenCL kernels, and an injection mechanism that allows EMI testing to be applied to kernels that otherwise exhibit little or no dynamically-dead code. We use these methods to conduct a large, controlled testing campaign with respect to 21 OpenCL (device, compiler) configurations, covering a range of CPU, GPU, accelerator, FPGA and emulator implementations. Our study provides independent validation of claims in prior work related to the effectiveness of random differential testing and EMI testing, proposes novel methods for lifting these techniques to the many-core setting and reveals a significant number of OpenCL compiler bugs in commercial implementations.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737986", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Lidbury", + "institution": "Imperial College London" + }, + { + "first_name": "Andrei", + "last_name": "Lascu", + "institution": "Imperial College London" + }, + { + "first_name": "Nathan", + "last_name": "Chong", + "institution": "University College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/pldi/LidburyLCD15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737979", + "title": "Defining the undefinedness of C", + "abstract": "We present a ``negative'' semantics of the C11 language---a semantics that does not just give meaning to correct programs, but also rejects undefined programs. We investigate undefined behavior in C and discuss the techniques and special considerations needed for formally specifying it. We have used these techniques to modify and extend a semantics of C into one that captures undefined behavior. The amount of semantic infrastructure and effort required to achieve this was unexpectedly high, in the end nearly doubling the size of the original semantics. From our semantics, we have automatically extracted an undefinedness checker, which we evaluate against other popular analysis tools, using our own test suite in addition to a third-party test suite. Our checker is capable of detecting examples of all 77 categories of core language undefinedness appearing in the C11 standard, more than any other tool we considered. Based on this evaluation, we argue that our work is the most comprehensive and complete semantic treatment of undefined behavior in C, and thus of the C language itself.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737979", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chris", + "last_name": "Hathhorn", + "institution": "University of Missouri" + }, + { + "first_name": "Chucky", + "last_name": "Ellison", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/HathhornER15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738001", + "title": "Light: replay via tightly bounded recording", + "abstract": "Reproducing concurrency bugs is a prominent challenge. Existing techniques either rely on recording very fine grained execution information and hence have high runtime overhead, or strive to log as little information as possible but provide no guarantee in reproducing a bug. We present Light, a technique that features much lower overhead compared to techniques based on fine grained recording, and that guarantees to reproduce concurrent bugs. We leverage and formally prove that recording flow dependences is the necessary and sufficient condition to reproduce a concurrent bug. The flow dependences, together with the thread local orders that can be automatically inferred (and hence not logged), are encoded as scheduling constraints. An SMT solver is used to derive a replay schedule, which is guaranteed to exist even though it may be different from the original schedule. Our experiments show that Light has only 44% logging overhead, almost one order of magnitude lower than the state of the art techniques relying on logging memory accesses. Its space overhead is only 10% of those techniques. Light can also reproduce all the bugs we have collected whereas existing techniques miss some of them.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738001", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peng", + "last_name": "Liu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Yunhui", + "last_name": "Zheng", + "institution": "IBM Research - Austin" + } + ], + "dblp_key": "conf/pldi/0010ZTZ15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737958", + "title": "Verdi: a framework for implementing and formally verifying distributed systems", + "abstract": "Distributed systems are difficult to implement correctly because they must handle both concurrency and failures: machines may crash at arbitrary points and networks may reorder, drop, or duplicate packets. Further, their behavior is often too complex to permit exhaustive testing. Bugs in these systems have led to the loss of critical data and unacceptable service outages. We present Verdi, a framework for implementing and formally verifying distributed systems in Coq. Verdi formalizes various network semantics with different faults, and the developer chooses the most appropriate fault model when verifying their implementation. Furthermore, Verdi eases the verification burden by enabling the developer to first verify their system under an idealized fault model, then transfer the resulting correctness guarantees to a more realistic fault model without any additional proof burden. To demonstrate Verdi's utility, we present the first mechanically checked proof of linearizability of the Raft state machine replication algorithm, as well as verified implementations of a primary-backup replication system and a key-value store. These verified systems provide similar performance to unverified equivalents.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737958", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "University of Washington" + }, + { + "first_name": "Doug", + "last_name": "Woos", + "institution": "University of Washington" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Xi", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + }, + { + "first_name": "Thomas E.", + "last_name": "Anderson", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/WilcoxWPTWEA15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737988", + "title": "Automatic error elimination by horizontal code transfer across multiple applications", + "abstract": "We present Code Phage (CP), a system for automatically transferring correct code from donor applications into recipient applications that process the same inputs to successfully eliminate errors in the recipient. Experimental results using seven donor applications to eliminate ten errors in seven recipient applications highlight the ability of CP to transfer code across applications to eliminate out of bounds access, integer overflow, and divide by zero errors. Because CP works with binary donors with no need for source code or symbolic information, it supports a wide range of use cases. To the best of our knowledge, CP is the first system to automatically transfer code across multiple applications.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737988", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stelios", + "last_name": "Sidiroglou-Douskos", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Eric", + "last_name": "Lahtinen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Fan", + "last_name": "Long", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Sidiroglou-Douskos15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737992", + "title": "Verifying read-copy-update in a logic for weak memory", + "abstract": "Read-Copy-Update (RCU) is a technique for letting multiple readers safely access a data structure while a writer concurrently modifies it. It is used heavily in the Linux kernel in situations where fast reads are important and writes are infrequent. Optimized implementations rely only on the weaker memory orderings provided by modern hardware, avoiding the need for expensive synchronization instructions (such as memory barriers) as much as possible. Using GPS, a recently developed program logic for the C/C++11 memory model, we verify an implementation of RCU for a singly-linked list assuming \"release-acquire\" semantics. Although release-acquire synchronization is stronger than what is required by real RCU implementations, it is nonetheless significantly weaker than the assumption of sequential consistency made in prior work on RCU verification. Ours is the first formal proof of correctness for an implementation of RCU under a weak memory model.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737992", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/TassarottiDV15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738008", + "title": "Lightweight, flexible object-oriented generics", + "abstract": "The support for generic programming in modern object-oriented programming languages is awkward and lacks desirable expressive power. We introduce an expressive genericity mechanism that adds expressive power and strengthens static checking, while remaining lightweight and simple in common use cases. Like type classes and concepts, the mechanism allows existing types to model type constraints retroactively. For expressive power, we expose models as named constructs that can be defined and selected explicitly to witness constraints; in common uses of genericity, however, types implicitly witness constraints without additional programmer effort. Models are integrated into the object-oriented style, with features like model generics, model-dependent types, model enrichment, model multimethods, constraint entailment, model inheritance, and existential quantification further extending expressive power in an object-oriented setting. We introduce the new genericity features and show that common generic programming idioms, including current generic libraries, can be expressed more precisely and concisely. The static semantics of the mechanism and a proof of a key decidability property can be found in an associated technical report.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738008", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "Cornell University" + }, + { + "first_name": "Matthew C.", + "last_name": "Loring", + "institution": "Cornell University" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/ZhangLSLM15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737956", + "title": "Dynamic partial order reduction for relaxed memory models", + "abstract": "Under a relaxed memory model such as TSO or PSO, a concurrent program running on a shared-memory multiprocessor may observe two types of nondeterminism: the nondeterminism in thread scheduling and the nondeterminism in store buffering. Although there is a large body of work on mitigating the scheduling nondeterminism during runtime verification, methods for soundly mitigating the store buffering nondeterminism are lacking. We propose a new dynamic partial order reduction (POR) algorithm for verifying concurrent programs under TSO and PSO. Our method relies on modeling both types of nondeterminism in a unified framework, which allows us to extend existing POR techniques to TSO and PSO without overhauling the verification algorithm. In addition to sound POR, we also propose a buffer-bounding method for more aggressively reducing the state space. We have implemented our new methods in a stateless model checking tool and demonstrated their effectiveness on a set of multithreaded C benchmarks.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737956", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Naling", + "last_name": "Zhang", + "institution": "Virginia Tech" + }, + { + "first_name": "Markus", + "last_name": "Kusano", + "institution": "Virginia Tech" + }, + { + "first_name": "Chao", + "last_name": "Wang", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/pldi/ZhangKW15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737970", + "title": "Composing concurrency control", + "abstract": "Concurrency control poses significant challenges when composing computations over multiple data-structures (objects) with different concurrency-control implementations. We formalize the usually desired requirements (serializability, abort-safety, deadlock-safety, and opacity) as well as stronger versions of these properties that enable composition. We show how to compose protocols satisfying these properties so that the resulting combined protocol also satisfies these properties. Our approach generalizes well-known protocols (such as two-phase-locking and two-phase-commit) and leads to new protocols. We apply this theory to show how we can safely compose optimistic and pessimistic concurrency control. For example, we show how we can execute a transaction that accesses two objects, one controlled by an STM and another by locking.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737970", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ofri", + "last_name": "Ziv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Guy", + "last_name": "Golan-Gueta", + "institution": "Tel Aviv University" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/ZivAGRS15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2738009", + "title": "Diagnosing type errors with class", + "abstract": "Type inference engines often give terrible error messages, and the more sophisticated the type system the worse the problem. We show that even with the highly expressive type system implemented by the Glasgow Haskell Compiler (GHC)--including type classes, GADTs, and type families--it is possible to identify the most likely source of the type error, rather than the first source that the inference engine trips over. To determine which are the likely error sources, we apply a simple Bayesian model to a graph representation of the typing constraints; the satisfiability or unsatisfiability of paths within the graph provides evidence for or against possible explanations. While we build on prior work on error diagnosis for simpler type systems, inference in the richer type system of Haskell requires extending the graph with new nodes. The augmentation of the graph creates challenges both for Bayesian reasoning and for ensuring termination. Using a large corpus of Haskell programs, we show that this error localization technique is practical and significantly improves accuracy over the state of the art.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2738009", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon", + "last_name": "Peyton-Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/ZhangMVJ15", + "venue": "pldi", + "year": 2015 + }, + { + "paper_id": "10.1145/2737924.2737972", + "title": "Tree dependence analysis", + "abstract": "We develop a new framework for analyzing recursive methods that perform traversals over trees, called tree dependence analysis. This analysis translates dependence analysis techniques for regular programs to the irregular space, identifying the structure of dependences within a recursive method that traverses trees. We develop a dependence test that exploits the dependence structure of such programs, and can prove that several locality- and parallelism- enhancing transformations are legal. In addition, we extend our analysis with a novel path-dependent, conditional analysis to refine the dependence test and prove the legality of transformations for a wider range of algorithms. We then use these analyses to show that several common algorithms that manipulate trees recursively are amenable to several locality- and parallelism-enhancing transformations. This work shows that classical dependence analysis techniques, which have largely been confined to nested loops over array data structures, can be extended and translated to work for complex, recursive programs that operate over pointer-based data structures.", + "date": "2015-06-03", + "link": "https://doi.org/10.1145/2737924.2737972", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yusheng", + "last_name": "Weijiang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Shruthi", + "last_name": "Balakrishna", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jianqiao", + "last_name": "Liu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/WeijiangBLK15", + "venue": "pldi", + "year": 2015 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2016.json b/data/pl_conferences/pldi/2016.json new file mode 100644 index 0000000..bce0471 --- /dev/null +++ b/data/pl_conferences/pldi/2016.json @@ -0,0 +1,1546 @@ +[ + { + "paper_id": "10.1145/2908080.2908096", + "title": "From Datalog to flix: a declarative language for fixed points on lattices", + "abstract": "We present Flix, a declarative programming language for specifying and solving least fixed point problems, particularly static program analyses. Flix is inspired by Datalog and extends it with lattices and monotone functions. Using Flix, implementors of static analyses can express a broader range of analyses than is currently possible in pure Datalog, while retaining its familiar rule-based syntax. We define a model-theoretic semantics of Flix as a natural extension of the Datalog semantics. This semantics captures the declarative meaning of Flix programs without imposing any specific evaluation strategy. An efficient strategy is semi-naive evaluation which we adapt for Flix. We have implemented a compiler and runtime for Flix, and used it to express several well-known static analyses, including the IFDS and IDE algorithms. The declarative nature of Flix clearly exposes the similarity between these two algorithms.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908096", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "University of Waterloo" + }, + { + "first_name": "Ming‐Ho", + "last_name": "Yee", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/pldi/MadsenYL16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908102", + "title": "MapReduce program synthesis", + "abstract": "By abstracting away the complexity of distributed systems, large-scale data processing platforms—MapReduce, Hadoop, Spark, Dryad, etc.—have provided developers with simple means for harnessing the power of the cloud. In this paper, we ask whether we can automatically synthesize MapReduce-style distributed programs from input–output examples. Our ultimate goal is to enable end users to specify large-scale data analyses through the simple interface of examples. We thus present a new algorithm and tool for synthesizing programs composed of efficient data-parallel operations that can execute on cloud computing infrastructure. We evaluate our tool on a range of real-world big-data analysis tasks and general computations. Our results demonstrate the efficiency of our approach and the small number of examples it requires to synthesize correct, scalable programs.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908102", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Calvin", + "last_name": "Smith", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/SmithA16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908122", + "title": "Fast synthesis of fast collections", + "abstract": "Many applications require specialized data structures not found in the standard libraries, but implementing new data structures by hand is tedious and error-prone. This paper presents a novel approach for synthesizing efficient implementations of complex collection data structures from high-level specifications that describe the desired retrieval operations. Our approach handles a wider range of data structures than previous work, including structures that maintain an order among their elements or have complex retrieval methods. We have prototyped our approach in a data structure synthesizer called Cozy. Four large, real-world case studies compare structures generated by Cozy against handwritten implementations in terms of correctness and performance. Structures synthesized by Cozy match the performance of handwritten data structures while avoiding human error.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908122", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Calvin", + "last_name": "Loncaric", + "institution": "University of Washington" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/LoncaricTE16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908123", + "title": "Effective padding of multidimensional arrays to avoid cache conflict misses", + "abstract": "Caches are used to significantly improve performance. Even with high degrees of set associativity, the number of accessed data elements mapping to the same set in a cache can easily exceed the degree of associativity. This can cause conflict misses and lower performance, even if the working set is much smaller than cache capacity. Array padding (increasing the size of array dimensions) is a well-known optimization technique that can reduce conflict misses. In this paper, we develop the first algorithms for optimal padding of arrays aimed at a set-associative cache for arbitrary tile sizes. In addition, we develop the first solution to padding for nested tiles and multi-level caches. Experimental results with multiple benchmarks demonstrate a significant performance improvement from padding.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908123", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Changwan", + "last_name": "Hong", + "institution": "The Ohio State University" + }, + { + "first_name": "Wenlei", + "last_name": "Bao", + "institution": "The Ohio State University" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "The Ohio State University" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "J.", + "last_name": "Ramanujam", + "institution": "Louisiana State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/HongB0KPRRS16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908101", + "title": "Toward compositional verification of interruptible OS kernels and device drivers", + "abstract": "An operating system (OS) kernel forms the lowest level of any system software stack. The correctness of the OS kernel is the basis for the correctness of the entire system. Recent efforts have demonstrated the feasibility of building formally verified general-purpose kernels, but it is unclear how to extend their work to verify the functional correctness of device drivers, due to the non-local effects of interrupts. In this paper, we present a novel compositional framework for building certified interruptible OS kernels with device drivers. We provide a general device model that can be instantiated with various hardware devices, and a realistic formal model of interrupts, which can be used to reason about interruptible code. We have realized this framework in the Coq proof assistant. To demonstrate the effectiveness of our new approach, we have successfully extended an existing verified non-interruptible kernel with our framework and turned it into an interruptible kernel with verified device drivers. To the best of our knowledge, this is the first verified interruptible operating system with device drivers.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908101", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hao", + "last_name": "Chen", + "institution": "Yale University" + }, + { + "first_name": "Xiongnan", + "last_name": "Wu", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Joshua", + "last_name": "Lockerman", + "institution": "Yale University" + }, + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/ChenWSLG16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908106", + "title": "Idle time garbage collection scheduling", + "abstract": "Efficient garbage collection is increasingly important in today's managed language runtime systems that demand low latency, low memory consumption, and high throughput. Garbage collection may pause the application for many milliseconds to identify live memory, free unused memory, and compact fragmented regions of memory, even when employing concurrent garbage collection. In animation-based applications that require 60 frames per second, these pause times may be observable, degrading user experience. This paper introduces idle time garbage collection scheduling to increase the responsiveness of applications by hiding expensive garbage collection operations inside of small, otherwise unused idle portions of the application's execution, resulting in smoother animations. Additionally we take advantage of idleness to reduce memory consumption while allowing higher memory use when high throughput is required. We implemented idle time garbage collection scheduling in V8, an open-source, production JavaScript virtual machine running within Chrome. We present performance results on various benchmarks running popular webpages and show that idle time garbage collection scheduling can significantly improve latency and memory consumption. Furthermore, we introduce a new metric called frame time discrepancy to quantify the quality of the user experience and precisely measure the improvements that idle time garbage collection provides for a WebGL-based game benchmark. Idle time garbage collection is shipped and enabled by default in Chrome.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908106", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ulan", + "last_name": "Degenbaev", + "institution": "" + }, + { + "first_name": "Jochen", + "last_name": "Eisinger", + "institution": "" + }, + { + "first_name": "Manfred", + "last_name": "Ernst", + "institution": "Google (United States)" + }, + { + "first_name": "Ross", + "last_name": "McIlroy", + "institution": "Google (United Kingdom)" + }, + { + "first_name": "Hannes", + "last_name": "Payer", + "institution": "" + } + ], + "dblp_key": "conf/pldi/DegenbaevEEMP16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908111", + "title": "FlexVec: auto-vectorization for irregular loops", + "abstract": "Traditional vectorization techniques build a dependence graph with distance and direction information to determine whether a loop is vectorizable. Since vectorization reorders the execution of instructions across iterations, in general instructions involved in a strongly connected component (SCC) are deemed not vectorizable unless the SCC can be eliminated using techniques such as scalar expansion or privatization. Therefore, traditional vectorization techniques are limited in their ability to efficiently handle loops with dynamic cross-iteration dependencies or complex control flow interweaved within the dependence cycles. When potential dependencies do not occur very often, the end-result is under utilization of the SIMD hardware. In this paper, we propose FlexVec architecture that combines new vector instructions with novel code generation techniques to dynamically adjusts vector length for loop statements affected by cross-iteration dependencies that happen at runtime. We have designed and implemented FlexVec's new ISA as extensions to the recently released AVX-512 ISA. We have evaluated the performance improvements enabled by FlexVec vectorization for 11 C/C++ SPEC 2006 benchmarks and 7 real applications with AVX-512 vectorization as baseline. We show that FlexVec vectorization technique produces a Geomean speedup of 9% for SPEC 2006 and a Geomean speedup of 11% for 7 real applications.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908111", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sara S.", + "last_name": "Baghsorkhi", + "institution": "Intel (United States)" + }, + { + "first_name": "Nalini", + "last_name": "Vasudevan", + "institution": "Google (United States)" + }, + { + "first_name": "Youfeng", + "last_name": "Wu", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/BaghsorkhiVW16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908127", + "title": "Just-in-time static type checking for dynamic languages", + "abstract": "Dynamic languages such as Ruby, Python, and JavaScript have many compelling benefits, but the lack of static types means subtle errors can remain latent in code for a long time. While many researchers have developed various systems to bring some of the benefits of static types to dynamic languages, prior approaches have trouble dealing with metaprogramming, which generates code as the program executes. In this paper, we propose Hummingbird, a new system that uses a novel technique, just-in-time static type checking, to type check Ruby code even in the presence of metaprogramming. In Hummingbird, method type signatures are gathered dynamically at run-time, as those methods are created. When a method is called, Hummingbird statically type checks the method body against current type signatures. Thus, Hummingbird provides thorough static checks on a per-method basis, while also allowing arbitrarily complex metaprogramming. For performance, Hummingbird memoizes the static type checking pass, invalidating cached checks only if necessary. We formalize Hummingbird using a core, Ruby-like language and prove it sound. To evaluate Hummingbird, we applied it to six apps, including three that use Ruby on Rails, a powerful framework that relies heavily on metaprogramming. We found that all apps typecheck successfully using Hummingbird, and that Hummingbird's performance overhead is reasonable. We applied Hummingbird to earlier versions of one Rails app and found several type errors that had been introduced and then fixed. Lastly, we demonstrate using Hummingbird in Rails development mode to typecheck an app as live updates are applied to it.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908127", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brianna M.", + "last_name": "Ren", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/RenF16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908109", + "title": "Verified peephole optimizations for CompCert", + "abstract": "Transformations over assembly code are common in many compilers. These transformations are also some of the most bug-dense compiler components. Such bugs could be elim- inated by formally verifying the compiler, but state-of-the- art formally verified compilers like CompCert do not sup- port assembly-level program transformations. This paper presents Peek, a framework for expressing, verifying, and running meaning-preserving assembly-level program trans- formations in CompCert. Peek contributes four new com- ponents: a lower level semantics for CompCert x86 syntax, a liveness analysis, a library for expressing and verifying peephole optimizations, and a verified peephole optimiza- tion pass built into CompCert. Each of these is accompanied by a correctness proof in Coq against realistic assumptions about the calling convention and the system memory alloca- tor. Verifying peephole optimizations in Peek requires prov- ing only a set of local properties, which we have proved are sufficient to ensure global transformation correctness. We have proven these local properties for 28 peephole transfor- mations from the literature. We discuss the development of our new assembly semantics, liveness analysis, representa- tion of program transformations, and execution engine; de- scribe the verification challenges of each component; and detail techniques we applied to mitigate the proof burden.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908109", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Eric", + "last_name": "Mullen", + "institution": "University of Washington" + }, + { + "first_name": "Daryl", + "last_name": "Zuniga", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/MullenZTG16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908090", + "title": "Remix: online detection and repair of cache contention for the JVM", + "abstract": "As ever more computation shifts onto multicore architectures, it is increasingly critical to find effective ways of dealing with multithreaded performance bugs like true and false sharing. Previous approaches to fixing false sharing in unmanaged languages have employed highly-invasive runtime program modifications. We observe that managed language runtimes, with garbage collection and JIT code compilation, present unique opportunities to repair such bugs directly, mirroring the techniques used in manual repairs. We present Remix, a modified version of the Oracle HotSpot JVM which can detect cache contention bugs and repair false sharing at runtime. Remix's detection mechanism leverages recent performance counter improvements on Intel platforms, which allow for precise, unobtrusive monitoring of cache contention at the hardware level. Remix can detect and repair known false sharing issues in the LMAX Disruptor high-performance inter-thread messaging library and the Spring Reactor event-processing framework, automatically providing 1.5-2x speedups over unoptimized code and matching the performance of hand-optimization. Remix also finds a new false sharing bug in SPECjvm2008, and uncovers a true sharing bug in the HotSpot JVM that, when fixed, improves the performance of three NAS Parallel Benchmarks by 7-25x. Remix incurs no statistically-significant performance overhead on other benchmarks that do not exhibit cache contention, making Remix practical for always-on use.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908090", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ariel", + "last_name": "Eizenberg", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Shiliang", + "last_name": "Hu", + "institution": "Intel (United States)" + }, + { + "first_name": "Gilles", + "last_name": "Pokam", + "institution": "Intel (United States)" + }, + { + "first_name": "Joseph", + "last_name": "Devietti", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/EizenbergHPD16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908095", + "title": "Coverage-directed differential testing of JVM implementations", + "abstract": "Java virtual machine (JVM) is a core technology, whose reliability is critical. Testing JVM implementations requires painstaking effort in designing test classfiles (*.class) along with their test oracles. An alternative is to employ binary fuzzing to differentially test JVMs by blindly mutating seeding classfiles and then executing the resulting mutants on different JVM binaries for revealing inconsistent behaviors. However, this blind approach is not cost effective in practice because most of the mutants are invalid and redundant. This paper tackles this challenge by introducing classfuzz, a coverage-directed fuzzing approach that focuses on representative classfiles for differential testing of JVMs’ startup processes. Our core insight is to (1) mutate seeding classfiles using a set of predefined mutation operators (mutators) and employ Markov Chain Monte Carlo (MCMC) sampling to guide mutator selection, and (2) execute the mutants on a reference JVM implementation and use coverage uniqueness as a discipline for accepting representative ones. The accepted classfiles are used as inputs to differentially test different JVM implementations and find defects. We have implemented classfuzz and conducted an extensive evaluation of it against existing fuzz testing algorithms. Our evaluation results show that classfuzz can enhance the ratio of discrepancy-triggering classfiles from 1.7% to 11.9%. We have also reported 62 JVM discrepancies, along with the test classfiles, to JVM developers. Many of our reported issues have already been confirmed as JVM defects, and some even match recent clarifications and changes to the Java SE 8 edition of the JVM specification.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908095", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuting", + "last_name": "Chen", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Ting", + "last_name": "Su", + "institution": "East China Normal University" + }, + { + "first_name": "C. P.", + "last_name": "Sun", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + }, + { + "first_name": "Jianjun", + "last_name": "Zhao", + "institution": "Kyushu University" + } + ], + "dblp_key": "conf/pldi/ChenSSSZ16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908129", + "title": "Cardinalities and universal quantifiers for verifying parameterized systems", + "abstract": "Parallel and distributed systems rely on intricate protocols to manage shared resources and synchronize, i.e., to manage how many processes are in a particular state. Effective verification of such systems requires universally quantification to reason about parameterized state and cardinalities tracking sets of processes, messages, failures to adequately capture protocol logic. In this paper we present Tool, an automatic invariant synthesis method that integrates cardinality-based reasoning and universal quantification. The resulting increase of expressiveness allows Tool to verify, for the first time, a representative collection of intricate parameterized protocols.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908129", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Klaus von", + "last_name": "Gleissenthall", + "institution": "" + }, + { + "first_name": "Nikolaj", + "last_name": "Bjørner", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Andrey", + "last_name": "Rybalchenko", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/GleissenthallBR16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908081", + "title": "Into the depths of C: elaborating the de facto standards", + "abstract": "C remains central to our computing infrastructure. It is notionally defined by ISO standards, but in reality the properties of C assumed by systems code and those implemented by compilers have diverged, both from the ISO standards and from each other, and none of these are clearly understood.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908081", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Justus", + "last_name": "Matthiesen", + "institution": "University of Cambridge" + }, + { + "first_name": "James", + "last_name": "Lingard", + "institution": "University of Cambridge" + }, + { + "first_name": "Kyndylan", + "last_name": "Nienhuis", + "institution": "University of Cambridge" + }, + { + "first_name": "David", + "last_name": "Chisnall", + "institution": "University of Cambridge" + }, + { + "first_name": "Robert N. M.", + "last_name": "Watson", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/pldi/MemarianMLNCWS16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908121", + "title": "Stratified synthesis: automatically learning the x86-64 instruction set", + "abstract": "The x86-64 ISA sits at the bottom of the software stack of most desktop and server software. Because of its importance, many software analysis and verification tools depend, either explicitly or implicitly, on correct modeling of the semantics of x86-64 instructions. However, formal semantics for the x86-64 ISA are difficult to obtain and often written manually through great effort. We describe an automatically synthesized formal semantics of the input/output behavior for a large fraction of the x86-64 Haswell ISA’s many thousands of instruction variants. The key to our results is stratified synthesis, where we use a set of instructions whose semantics are known to synthesize the semantics of additional instructions whose semantics are unknown. As the set of formally described instructions increases, the synthesis vocabulary expands, making it possible to synthesize the semantics of increasingly complex instructions. Using this technique we automatically synthesized formal semantics for 1,795 instruction variants of the x86-64 Haswell ISA. We evaluate the learned semantics against manually written semantics (where available) and find that they are formally equivalent with the exception of 50 instructions, where the manually written semantics contain an error. We further find the learned formulas to be largely as precise as manually written ones and of similar size.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908121", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Heule", + "institution": "Stanford University" + }, + { + "first_name": "Eric", + "last_name": "Schkufza", + "institution": "Kitware (United States)" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/HeuleS0A16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908116", + "title": "Configuration synthesis for programmable analog devices with Arco", + "abstract": "Programmable analog devices have emerged as a powerful computing substrate for performing complex neuromorphic and cytomorphic computations. We present Arco, a new solver that, given a dynamical system specification in the form of a set of differential equations, generates physically realizable configurations for programmable analog devices that are algebraically equivalent to the specified system. On a set of benchmarks from the biological domain, Arco generates configurations with 35 to 534 connections and 28 to 326 components in 1 to 54 minutes.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908116", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sara", + "last_name": "Achour", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Rahul", + "last_name": "Sarpeshkar", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/AchourSR16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908114", + "title": "Exposing errors related to weak memory in GPU applications", + "abstract": "We present the systematic design of a testing environment that uses stressing and fuzzing to reveal errors in GPU applications that arise due to weak memory effects. We evaluate our approach on seven GPUs spanning three Nvidia architectures, across ten CUDA applications that use fine-grained concurrency. Our results show that applications that rarely or never exhibit errors related to weak memory when executed natively can readily exhibit these errors when executed in our testing environment. Our testing environment also provides a means to help identify the root causes of such errors, and automatically suggests how to insert fences that harden an application against weak memory bugs. To understand the cost of GPU fences, we benchmark applications with fences provided by the hardening strategy as well as a more conservative, sound fencing strategy.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908114", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/pldi/SorensenD16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908089", + "title": "Higher-order and tuple-based massively-parallel prefix sums", + "abstract": "Prefix sums are an important parallel primitive, especially in massively-parallel programs. This paper discusses two orthogonal generalizations thereof, which we call higher-order and tuple-based prefix sums. Moreover, it describes and evaluates SAM, a GPU-friendly algorithm for computing prefix sums and other scans that directly supports higher orders and tuple values. Its templated CUDA implementation unifies all of these computations in a single 100-statement kernel. SAM is communication-efficient in the sense that it minimizes main-memory accesses. When computing prefix sums of a million or more values, it outperforms Thrust and CUDPP on both a Titan X and a K40 GPU. On the Titan X, SAM reaches memory-copy speeds for large input sizes, which cannot be surpassed. SAM outperforms CUB, the currently fastest conventional prefix sum implementation, by up to a factor of 2.9 on eighth-order prefix sums and by up to a factor of 2.6 on eight-tuple prefix sums.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908089", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sepideh", + "last_name": "Maleki", + "institution": "Texas State University" + }, + { + "first_name": "Annie", + "last_name": "Yang", + "institution": "Texas State University" + }, + { + "first_name": "Martin", + "last_name": "Burtscher", + "institution": "Texas State University" + } + ], + "dblp_key": "conf/pldi/MalekiYB16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908104", + "title": "Lightweight computation tree tracing for lazy functional languages", + "abstract": "A computation tree of a program execution describes computations of functions and their dependencies. A computation tree describes how a program works and is at the heart of algorithmic debugging. To generate a computation tree, existing algorithmic debuggers either use a complex implementation or yield a less informative approximation. We present a method for lazy functional languages that requires only a simple tracing library to generate a detailed computation tree. With our algorithmic debugger a programmer can debug any Haskell program by only importing our library and annotating suspected functions.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908104", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Maarten", + "last_name": "Faddegon", + "institution": "University of Kent" + }, + { + "first_name": "Olaf", + "last_name": "Chitil", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/pldi/FaddegonC16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908103", + "title": "Programmatic and direct manipulation, together at last", + "abstract": "Direct manipulation interfaces and programmatic systems have distinct and complementary strengths. The former provide intuitive, immediate visual feedback and enable rapid prototyping, whereas the latter enable complex, reusable abstractions. Unfortunately, existing systems typically force users into just one of these two interaction modes. We present a system called Sketch-n-Sketch that integrates programmatic and direct manipulation for the particular domain of Scalable Vector Graphics (SVG). In Sketch-n-Sketch, the user writes a program to generate an output SVG canvas. Then the user may directly manipulate the canvas while the system immediately infers a program update in order to match the changes to the output, a workflow we call live synchronization. To achieve this, we propose (i) a technique called trace-based program synthesis that takes program execution history into account in order to constrain the search space and (ii) heuristics for dealing with ambiguities. Based on our experience with examples spanning 2,000 lines of code and from the results of a preliminary user study, we believe that Sketch-n-Sketch provides a novel workflow that can augment traditional programming systems. Our approach may serve as the basis for live synchronization in other application domains, as well as a starting point for yet more ambitious ways of combining programmatic and direct manipulation.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908103", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of Chicago" + }, + { + "first_name": "Brian", + "last_name": "Hempel", + "institution": "University of Chicago" + }, + { + "first_name": "Mitchell", + "last_name": "Spradlin", + "institution": "University of Chicago" + }, + { + "first_name": "Jacob", + "last_name": "Albers", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/pldi/ChughHSA16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908094", + "title": "A distributed OpenCL framework using redundant computation and data replication", + "abstract": "Applications written solely in OpenCL or CUDA cannot execute on a cluster as a whole. Most previous approaches that extend these programming models to clusters are based on a common idea: designating a centralized host node and coordinating the other nodes with the host for computation. However, the centralized host node is a serious performance bottleneck when the number of nodes is large. In this paper, we propose a scalable and distributed OpenCL framework called SnuCL-D for large-scale clusters. SnuCL-D's remote device virtualization provides an OpenCL application with an illusion that all compute devices in a cluster are confined in a single node. To reduce the amount of control-message and data communication between nodes, SnuCL-D replicates the OpenCL host program execution and data in each node. We also propose a new OpenCL host API function and a queueing optimization technique that significantly reduce the overhead incurred by the previous centralized approaches. To show the effectiveness of SnuCL-D, we evaluate SnuCL-D with a microbenchmark and eleven benchmark applications on a large-scale CPU cluster and a medium-scale GPU cluster.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908094", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jung-Hyun", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Gangwon", + "last_name": "Jo", + "institution": "Seoul National University" + }, + { + "first_name": "Jaehoon", + "last_name": "Jung", + "institution": "Seoul National University" + }, + { + "first_name": "Jungwon", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Jaejin", + "last_name": "Lee", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/pldi/KimJJKL16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908115", + "title": "Types from data: making structured data first-class citizens in F#", + "abstract": "Most modern applications interact with external services and access data in structured formats such as XML, JSON and CSV. Static type systems do not understand such formats, often making data access more cumbersome. Should we give up and leave the messy world of external data to dynamic typing and runtime checks? Of course, not! We present F# Data, a library that integrates external structured data into F#. As most real-world data does not come with an explicit schema, we develop a shape inference algorithm that infers a shape from representative sample documents. We then integrate the inferred shape into the F# type system using type providers. We formalize the process and prove a relative type soundness theorem. Our library significantly reduces the amount of data access code and it provides additional safety guarantees when contrasted with the widely used weakly typed techniques.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908115", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tomas", + "last_name": "Petricek", + "institution": "University of Cambridge" + }, + { + "first_name": "Gustavo", + "last_name": "Guerra", + "institution": "Microsoft (United Kingdom)" + }, + { + "first_name": "Don", + "last_name": "Syme", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/PetricekGS16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908120", + "title": "Assessing the limits of program-specific garbage collection performance", + "abstract": "We consider the ultimate limits of program-specific garbage collector performance for real programs. We first characterize the GC schedule optimization problem using Markov Decision Processes (MDPs). Based on this characterization, we develop a method of determining, for a given program run and heap size, an optimal schedule of collections for a non-generational collector. We further explore the limits of performance of a generational collector, where it is not feasible to search the space of schedules to prove optimality. Still, we show significant improvements with Least Squares Policy Iteration, a reinforcement learning technique for solving MDPs. We demonstrate that there is considerable promise to reduce garbage collection costs by developing program-specific collection policies.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908120", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nicholas", + "last_name": "Jacek", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Meng‐Chieh", + "last_name": "Chiu", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Benjamin M.", + "last_name": "Marlin", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/JacekCMM16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908091", + "title": "Occurrence typing modulo theories", + "abstract": "We present a new type system combining occurrence typing---a technique previously used to type check programs in dynamically-typed languages such as Racket, Clojure, and JavaScript---with dependent refinement types. We demonstrate that the addition of refinement types allows the integration of arbitrary solver-backed reasoning about logical propositions from external theories. By building on occurrence typing, we can add our enriched type system as a natural extension of Typed Racket, reusing its core while increasing its expressiveness. The result is a well-tested type system with a conservative, decidable core in which types may depend on a small but extensible set of program terms. In addition to describing our design, we present the following: a formal model and proof of correctness; a strategy for integrating new theories, with specific examples including linear arithmetic and bitvectors; and an evaluation in the context of the full Typed Racket implementation. Specifically, we take safe vector operations as a case study, examining all vector accesses in a 56,000 line corpus of Typed Racket programs. Our system is able to prove that 50% of these are safe with no new annotations, and with a few annotations and modifications we capture more than 70%.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908091", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrew M.", + "last_name": "Kent", + "institution": "Indiana University" + }, + { + "first_name": "David", + "last_name": "Kempe", + "institution": "Indiana University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/pldi/KentKT16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908113", + "title": "A design and verification methodology for secure isolated regions", + "abstract": "Hardware support for isolated execution (such as Intel SGX) enables development of applications that keep their code and data confidential even while running in a hostile or compromised host. However, automatically verifying that such applications satisfy confidentiality remains challenging. We present a methodology for designing such applications in a way that enables certifying their confidentiality. Our methodology consists of forcing the application to communicate with the external world through a narrow interface, compiling it with runtime checks that aid verification, and linking it with a small runtime that implements the narrow interface. The runtime includes services such as secure communication channels and memory management. We formalize this restriction on the application as Information Release Confinement (IRC), and we show that it allows us to decompose the task of proving confidentiality into (a) one-time, human-assisted functional verification of the runtime to ensure that it does not leak secrets, (b) automatic verification of the application's machine code to ensure that it satisfies IRC and does not directly read or corrupt the runtime's internal state. We present /CONFIDENTIAL: a verifier for IRC that is modular, automatic, and keeps our compiler out of the trusted computing base. Our evaluation suggests that the methodology scales to real-world applications.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908113", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rohit", + "last_name": "Sinha", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Manuel", + "last_name": "Costa", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Sanjit A.", + "last_name": "Seshia", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Kapil", + "last_name": "Vaswani", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/0001CLLRSV16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908119", + "title": "Polymorphic type inference for machine code", + "abstract": "For many compiled languages, source-level types are erased very early in the compilation process. As a result, further compiler passes may convert type-safe source into type-unsafe machine code. Type-unsafe idioms in the original source and type-unsafe optimizations mean that type information in a stripped binary is essentially nonexistent. The problem of recovering high-level types by performing type inference over stripped machine code is called type reconstruction, and offers a useful capability in support of reverse engineering and decompilation. In this paper, we motivate and develop a novel type system and algorithm for machine-code type inference. The features of this type system were developed by surveying a wide collection of common source- and machine-code idioms, building a catalog of challenging cases for type reconstruction. We found that these idioms place a sophisticated set of requirements on the type system, inducing features such as recursively-constrained polymorphic types. Many of the features we identify are often seen only in expressive and powerful type systems used by high-level functional languages. Using these type-system features as a guideline, we have developed Retypd: a novel static type-inference algorithm for machine code that supports recursive types, polymorphism, and subtyping. Retypd yields more accurate inferred types than existing algorithms, while also enabling new capabilities such as reconstruction of pointer const annotations with 98% recall. Retypd can operate on weaker program representations than the current state of the art, removing the need for high-quality points-to information that may be impractical to compute.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908119", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matt", + "last_name": "Noonan", + "institution": "GrammaTech (United States)" + }, + { + "first_name": "А. А.", + "last_name": "Логинов", + "institution": "GrammaTech (United States)" + }, + { + "first_name": "David R.", + "last_name": "Cok", + "institution": "GrammaTech (United States)" + } + ], + "dblp_key": "conf/pldi/NoonanLC16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908093", + "title": "Program synthesis from polymorphic refinement types", + "abstract": "We present a method for synthesizing recursive functions that provably satisfy a given specification in the form of a polymorphic refinement type. We observe that such specifications are particularly suitable for program synthesis for two reasons. First, they offer a unique combination of expressive power and decidability, which enables automatic verification—and hence synthesis—of nontrivial programs. Second, a type-based specification for a program can often be effectively decomposed into independent specifications for its components, causing the synthesizer to consider fewer component combinations and leading to a combinatorial reduction in the size of the search space. At the core of our synthesis procedure is a newalgorithm for refinement type checking, which supports specification decomposition. We have evaluated our prototype implementation on a large set of synthesis problems and found that it exceeds the state of the art in terms of both scalability and usability. The tool was able to synthesize more complex programs than those reported in prior work (several sorting algorithms and operations on balanced search trees), as well as most of the benchmarks tackled by existing synthesizers, often starting from a more concise and intuitive user input.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908093", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ivan", + "last_name": "Kuraj", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/PolikarpovaKS16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908118", + "title": "Ivy: safety verification by interactive generalization", + "abstract": "Despite several decades of research, the problem of formal verification of infinite-state systems has resisted effective automation. We describe a system --- Ivy --- for interactively verifying safety of infinite-state systems. Ivy's key principle is that whenever verification fails, Ivy graphically displays a concrete counterexample to induction. The user then interactively guides generalization from this counterexample. This process continues until an inductive invariant is found. Ivy searches for universally quantified invariants, and uses a restricted modeling language. This ensures that all verification conditions can be checked algorithmically. All user interactions are performed using graphical models, easing the user's task. We describe our initial experience with verifying several distributed protocols.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908118", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Tel Aviv University" + }, + { + "first_name": "Kenneth L.", + "last_name": "McMillan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aurojit", + "last_name": "Panda", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/PadonMPSS16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908107", + "title": "Verifying bit-manipulations of floating-point", + "abstract": "Reasoning about floating-point is difficult and becomes only more so if there is an interplay between floating-point and bit-level operations. Even though real-world floating-point libraries use implementations that have such mixed computations, no systematic technique to verify the correctness of the implementations of such computations is known. In this paper, we present the first general technique for verifying the correctness of mixed binaries, which combines abstraction, analytical optimization, and testing. The technique provides a method to compute an error bound of a given implementation with respect to its mathematical specification. We apply our technique to Intel's implementations of transcendental functions and prove formal error bounds for these widely used routines.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908107", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Stanford University" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/LeeSA16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908128", + "title": "On the complexity and performance of parsing with derivatives", + "abstract": "Current algorithms for context-free parsing inflict a trade-off between ease of understanding, ease of implementation, theoretical complexity, and practical performance. No algorithm achieves all of these properties simultaneously. Might et al. introduced parsing with derivatives, which handles arbitrary context-free grammars while being both easy to understand and simple to implement. Despite much initial enthusiasm and a multitude of independent implementations, its worst-case complexity has never been proven to be better than exponential. In fact, high-level arguments claiming it is fundamentally exponential have been advanced and even accepted as part of the folklore. Performance ended up being sluggish in practice, and this sluggishness was taken as informal evidence of exponentiality. In this paper, we reexamine the performance of parsing with derivatives. We have discovered that it is not exponential but, in fact, cubic. Moreover, simple (though perhaps not obvious) modifications to the implementation by Might et al. lead to an implementation that is not only easy to understand but also highly performant in practice.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908128", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "University of Utah" + }, + { + "first_name": "Celeste", + "last_name": "Hollenbeck", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/0001HM16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908100", + "title": "End-to-end verification of information-flow security for C and assembly programs", + "abstract": "Protecting the confidentiality of information manipulated by a computing system is one of the most important challenges facing today's cybersecurity community. A promising step toward conquering this challenge is to formally verify that the end-to-end behavior of the computing system really satisfies various information-flow policies. Unfortunately, because today's system software still consists of both C and assembly programs, the end-to-end verification necessarily requires that we not only prove the security properties of individual components, but also carefully preserve these properties through compilation and cross-language linking. In this paper, we present a novel methodology for formally verifying end-to-end security of a software system that consists of both C and assembly programs. We introduce a general definition of observation function that unifies the concepts of policy specification, state indistinguishability, and whole-execution behaviors. We show how to use different observation functions for different levels of abstraction, and how to link different security proofs across abstraction levels using a special kind of simulation that is guaranteed to preserve state indistinguishability. To demonstrate the effectiveness of our new methodology, we have successfully constructed an end-to-end security proof, fully formalized in the Coq proof assistant, of a nontrivial operating system kernel (running on an extended CompCert x86 assembly machine model). Some parts of the kernel are written in C and some are written in assembly; we verify all of the code, regardless of language.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908100", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Costanzo", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/CostanzoSG16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908097", + "title": "Event-driven network programming", + "abstract": "Software-defined networking (SDN) programs must simultaneously describe static forwarding behavior and dynamic updates in response to events. Event-driven updates are critical to get right, but difficult to implement correctly due to the high degree of concurrency in networks. Existing SDN platforms offer weak guarantees that can break application invariants, leading to problems such as dropped packets, degraded performance, security violations, etc. This paper introduces event-driven consistent updates that are guaranteed to preserve well-defined behaviors when transitioning between configurations in response to events. We propose network event structures (NESs) to model constraints on updates, such as which events can be enabled simultaneously and causal dependencies between events. We define an extension of the NetKAT language with mutable state, give semantics to stateful programs using NESs, and discuss provably-correct strategies for implementing NESs in SDNs. Finally, we evaluate our approach empirically, demonstrating that it gives well-defined consistency guarantees while avoiding expensive synchronization and packet buffering.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908097", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jedidiah", + "last_name": "McClurg", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Hossein", + "last_name": "Hojjat", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Pavol", + "last_name": "Černý", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/pldi/McClurgHFC16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908108", + "title": "Temporal NetKAT", + "abstract": "Over the past 5-10 years, the rise of software-defined networking (SDN) has inspired a wide range of new systems, libraries, hypervisors and languages for programming, monitoring, and debugging network behavior. Oftentimes, these systems are disjoint—one language for programming and another for verification, and yet another for run-time monitoring and debugging. In this paper, we present a new, unified framework, called Temporal NetKAT, capable of facilitating all of these tasks at once. As its name suggests, Temporal NetKAT is the synthesis of two formal theories: past-time (finite trace) linear temporal logic and (network) Kleene Algebra with Tests. Temporal predicates allow programmers to write down concise properties of a packet’s path through the network and to make dynamic packet-forwarding, access control or debugging decisions on that basis. In addition to being useful for programming, the combined equational theory of LTL and NetKAT facilitates proofs of path-based correctness properties. Using new, general, proof techniques, we show that the equational semantics is sound with respect to the denotational semantics, and, for a class of programs we call network-wide programs, complete. We have also implemented a compiler for temporal NetKAT, evaluated its performance on a range of benchmarks, and studied the effectiveness of several optimizations.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908108", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Beckett", + "institution": "Princeton University" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Pomona College" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/BeckettGW16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908087", + "title": "Input responsiveness: using canary inputs to dynamically steer approximation", + "abstract": "This paper introduces Input Responsive Approximation (IRA), an approach that uses a canary input — a small program input carefully constructed to capture the intrinsic properties of the original input — to automatically control how program approximation is applied on an input-by-input basis. Motivating this approach is the observation that many of the prior techniques focusing on choosing how to approximate arrive at conservative decisions by discounting substantial differences between inputs when applying approximation. The main challenges in overcoming this limitation lie in making the choice of how to approximate both effectively (e.g., the fastest approximation that meets a particular accuracy target) and rapidly for every input. With IRA, each time the approximate program is run, a canary input is constructed and used dynamically to quickly test a spectrum of approximation alternatives. Based on these runtime tests, the approximation that best fits the desired accuracy constraints is selected and applied to the full input to produce an approximate result. We use IRA to select and parameterize mixes of four approximation techniques from the literature for a range of 13 image processing, machine learning, and data mining applications. Our results demonstrate that IRA significantly outperforms prior approaches, delivering an average of 10.2× speedup over exact execution while minimizing accuracy losses in program outputs.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908087", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael A.", + "last_name": "Laurenzano", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Parker", + "last_name": "Hill", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Mehrzad", + "last_name": "Samadi", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Jason", + "last_name": "Mars", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Lingjia", + "last_name": "Tang", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/LaurenzanoHSMMT16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908084", + "title": "Living on the edge: rapid-toggling probes with cross-modification on x86", + "abstract": "Dynamic probe injection is now a widely used method to debug performance in production. Current techniques for dynamic probing of native code, however, rely on an expensive stop-the-world approach: binary changes are made within a safe state of the program---typically in which all the program threads are halted---to ensure that another thread executing the modified code region doesn't step into a partially-modified code. Stop-the-world patching is not scalable. In contrast, low overhead, scalable probes that can be rapidly toggled on and off in-place would open up new use cases for statistical profilers and language implementations, even traditional ahead-of-time, native-code compilers. In this paper we introduce safe cross-modification protocols that mutate x86 code between threads but do not require quiescing threads, resulting in radically lower overheads than existing solutions. A key problem is handling instructions that straddle cache lines. We empirically evaluate existing x86 architectures to derive a safe policy given current processor behavior, and we argue that future architectures should clarify the semantics of instruction fetching to make cheap cross-modification easier and future proof.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908084", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Buddhika", + "last_name": "Chamith", + "institution": "Indiana University" + }, + { + "first_name": "Bo Joel", + "last_name": "Svensson", + "institution": "Indiana University" + }, + { + "first_name": "Luke", + "last_name": "Dalessandro", + "institution": "Indiana University" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/pldi/ChamithSDN16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908126", + "title": "Statistical similarity of binaries", + "abstract": "We address the problem of finding similar procedures in stripped binaries. We present a new statistical approach for measuring the similarity between two procedures. Our notion of similarity allows us to find similar code even when it has been compiled using different compilers, or has been modified. The main idea is to use similarity by composition: decompose the code into smaller comparable fragments, define semantic similarity between fragments, and use statistical reasoning to lift fragment similarity into similarity between procedures. We have implemented our approach in a tool called Esh, and applied it to find various prominent vulnerabilities across compilers and versions, including Heartbleed, Shellshock and Venom. We show that Esh produces high accuracy results, with few to no false positives -- a crucial factor in the scenario of vulnerability search in stripped binaries.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908126", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yaniv", + "last_name": "David", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Nimrod", + "last_name": "Partush", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/DavidPY16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908124", + "title": "SDNRacer: concurrency analysis for software-defined networks", + "abstract": "Concurrency violations are an important source of bugs in Software-Defined Networks (SDN), often leading to policy or invariant violations. Unfortunately, concurrency violations are also notoriously difficult to avoid, detect and debug. This paper presents a novel approach and a tool, SDNRacer, for detecting concurrency violations of SDNs. Our approach is enabled by three key ingredients: (i) a precise happens- before model for SDNs that captures when events can happen concurrently; (ii) a set of sound, domain-specific filters that reduce reported violations by orders of magnitude, and; (iii) a sound and complete dynamic analyzer, based on the above, that can ensure the network is free of harmful errors such as data races and per-packet incoherence. We evaluated SDNRacer on several real-world OpenFlow controllers, running both reactive and proactive applications in large networks. We show that SDNRacer is practically effective: it quickly pinpoints harmful concurrency violations without overwhelming the user with false positives.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908124", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "El-Hassany", + "institution": "ETH Zurich" + }, + { + "first_name": "Jeremie", + "last_name": "Miserez", + "institution": "ETH Zurich" + }, + { + "first_name": "Pavol", + "last_name": "Bielik", + "institution": "ETH Zurich" + }, + { + "first_name": "Laurent", + "last_name": "Vanbever", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/El-HassanyMBVV16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908117", + "title": "Verified lifting of stencil computations", + "abstract": "This paper demonstrates a novel combination of program synthesis and verification to lift stencil computations from low-level Fortran code to a high-level summary expressed using a predicate language. The technique is sound and mostly automated, and leverages counter-example guided inductive synthesis (CEGIS) to find provably correct translations. Lifting existing code to a high-performance description language has a number of benefits, including maintainability and performance portability. For example, our experiments show that the lifted summaries can enable domain specific compilers to do a better job of parallelization as compared to an off-the-shelf compiler working on the original code, and can even support fully automatic migration to hardware accelerators such as GPUs. We have implemented verified lifting in a system called STNG and have evaluated it using microbenchmarks, mini-apps, and real-world applications. We demonstrate the benefits of verified lifting by first automatically summarizing Fortran source code into a high-level predicate language, and subsequently translating the lifted summaries into Halide, with the translated code achieving median performance speedups of 4.1X and up to 24X for non-trivial stencils as compared to the original implementation.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908117", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shoaib", + "last_name": "Kamil", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of Washington" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/KamilCIS16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908083", + "title": "Rehearsal: a configuration verification tool for puppet", + "abstract": "Large-scale data centers and cloud computing have turned system configuration into a challenging problem. Several widely-publicized outages have been blamed not on software bugs, but on configuration bugs. To cope, thousands of organizations use system configuration languages to manage their computing infrastructure. Of these, Puppet is the most widely used with thousands of paying customers and many more open-source users. The heart of Puppet is a domain-specific language that describes the state of a system. Puppet already performs some basic static checks, but they only prevent a narrow range of errors. Furthermore, testing is ineffective because many errors are only triggered under specific machine states that are difficult to predict and reproduce. With several examples, we show that a key problem with Puppet is that configurations can be non-deterministic. This paper presents Rehearsal, a verification tool for Puppet configurations. Rehearsal implements a sound, complete, and scalable determinacy analysis for Puppet. To develop it, we (1) present a formal semantics for Puppet, (2) use several analyses to shrink our models to a tractable size, and (3) frame determinism-checking as decidable formulas for an SMT solver. Rehearsal then leverages the determinacy analysis to check other important properties, such as idempotency. Finally, we apply Rehearsal to several real-world Puppet configurations.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908083", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rian", + "last_name": "Shambaugh", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Aaron", + "last_name": "Weiss", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/ShambaughWG16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908099", + "title": "Data-driven precondition inference with learned features", + "abstract": "We extend the data-driven approach to inferring preconditions for code from a set of test executions. Prior work requires a fixed set of features, atomic predicates that define the search space of possible preconditions, to be specified in advance. In contrast, we introduce a technique for on-demand feature learning, which automatically expands the search space of candidate preconditions in a targeted manner as necessary. We have instantiated our approach in a tool called PIE. In addition to making precondition inference more expressive, we show how to apply our feature-learning technique to the setting of data-driven loop invariant inference. We evaluate our approach by using PIE to infer rich preconditions for black-box OCaml library functions and using our loop-invariant inference algorithm as part of an automatic program verifier for C++ programs.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908099", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Saswat", + "last_name": "Padhi", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/PadhiSM16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908098", + "title": "Precise, dynamic information flow for database-backed applications", + "abstract": "We present an approach for dynamic information flow control across the application and database. Our approach reduces the amount of policy code required, yields formal guarantees across the application and database, works with existing relational database implementations, and scales for realistic applications. In this paper, we present a programming model that factors out information flow policies from application code and database queries, a dynamic semantics for the underlying $^JDB$ core language, and proofs of termination-insensitive non-interference and policy compliance for the semantics. We implement these ideas in Jacqueline, a Python web framework, and demonstrate feasibility through three application case studies: a course manager, a health record system, and a conference management system used to run an academic workshop. We show that in comparison to traditional applications with hand-coded policy checks, Jacqueline applications have 1) a smaller trusted computing base, 2) fewer lines of policy code, and 2) reasonable, often negligible, additional overheads.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908098", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jean", + "last_name": "Yang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Travis", + "last_name": "Hance", + "institution": "" + }, + { + "first_name": "Thomas H.", + "last_name": "Austin", + "institution": "San Jose State University" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/pldi/YangHASFC16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908112", + "title": "Transactional data structure libraries", + "abstract": "We introduce transactions into libraries of concurrent data structures; such transactions can be used to ensure atomicity of sequences of data structure operations. By focusing on transactional access to a well-defined set of data structure operations, we strike a balance between the ease-of-programming of transactions and the efficiency of custom-tailored data structures. We exemplify this concept by designing and implementing a library supporting transactions on any number of maps, sets (implemented as skiplists), and queues. Our library offers efficient and scalable transactions, which are an order of magnitude faster than state-of-the-art transactional memory toolkits. Moreover, our approach treats stand-alone data structure operations (like put and enqueue) as first class citizens, and allows them to execute with virtually no overhead, at the speed of the original data structure library.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908112", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Spiegelman", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Guy", + "last_name": "Golan-Gueta", + "institution": "" + }, + { + "first_name": "Idit", + "last_name": "Keidar", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/SpiegelmanGK16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908092", + "title": "Cartesian hoare logic for verifying k-safety properties", + "abstract": "Unlike safety properties which require the absence of a “bad” program trace, k-safety properties stipulate the absence of a “bad” interaction between k traces. Examples of k-safety properties include transitivity, associativity, anti-symmetry, and monotonicity. This paper presents a sound and relatively complete calculus, called Cartesian Hoare Logic (CHL), for verifying k-safety properties. We also present an automated verification algorithm based on CHL and implement it in a tool called DESCARTES. We use DESCARTES to analyze user-defined relational operators in Java and demonstrate that DESCARTES is effective at verifying (or finding violations of) multiple k-safety properties.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908092", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marcelo", + "last_name": "Sousa", + "institution": "University of Oxford" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/SousaD16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908110", + "title": "Refinement types for TypeScript", + "abstract": "We present Refined TypeScript (RSC), a lightweight refinement type system for TypeScript, that enables static verification of higher-order, imperative programs. We develop a formal system for RSC that delineates the interaction between refinement types and mutability, and enables flow-sensitive reasoning by translating input programs to an equivalent intermediate SSA form. By establishing type safety for the intermediate form, we prove safety for the input programs. Next, we extend the core to account for imperative and dynamic features of TypeScript, including overloading, type reflection, ad hoc type hierarchies and object initialization. Finally, we evaluate RSC on a set of real-world benchmarks, including parts of the Octane benchmarks, D3, Transducers, and the TypeScript compiler. We show how RSC successfully establishes a number of value dependent properties, such as the safety of array accesses and downcasts, while incurring a modest overhead in type annotations and code restructuring.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908110", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Panagiotis", + "last_name": "Vekris", + "institution": "University of California, San Diego" + }, + { + "first_name": "Benjamin", + "last_name": "Cosman", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/VekrisCJ16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908125", + "title": "Automatically learning shape specifications", + "abstract": "This paper presents a novel automated procedure for discovering expressive shape specifications for sophisticated functional data structures. Our approach extracts potential shape predicates based on the definition of constructors of arbitrary user-defined inductive data types, and combines these predicates within an expressive first-order specification language using a lightweight data-driven learning procedure. Notably, this technique requires no programmer annotations, and is equipped with a type-based decision procedure to verify the correctness of discovered specifications. Experimental results indicate that our implementation is both efficient and effective, capable of automatically synthesizing sophisticated shape specifications over a range of complex data types, going well beyond the scope of existing solutions.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908125", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "He", + "last_name": "Zhu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Gustavo", + "last_name": "Petri", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/ZhuPJ16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908105", + "title": "Latte: a language, compiler, and runtime for elegant and efficient deep neural networks", + "abstract": "Deep neural networks (DNNs) have undergone a surge in popularity with consistent advances in the state of the art for tasks including image recognition, natural language processing, and speech recognition. The computationally expensive nature of these networks has led to the proliferation of implementations that sacrifice abstraction for high performance. In this paper, we present Latte, a domain-specific language for DNNs that provides a natural abstraction for specifying new layers without sacrificing performance. Users of Latte express DNNs as ensembles of neurons with connections between them. The Latte compiler synthesizes a program based on the user specification, applies a suite of domain-specific and general optimizations, and emits efficient machine code for heterogeneous architectures. Latte also includes a communication runtime for distributed memory data-parallelism. Using networks described using Latte, we demonstrate 3-6x speedup over Caffe (C++/MKL) on the three state-of-the-art ImageNet models executing on an Intel Xeon E5-2699 v3 x86 CPU.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908105", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Leonard", + "last_name": "Truong", + "institution": "Intel (United States)" + }, + { + "first_name": "Rajkishore", + "last_name": "Barik", + "institution": "Intel (United States)" + }, + { + "first_name": "Ehsan", + "last_name": "Totoni", + "institution": "Intel (United States)" + }, + { + "first_name": "Hai", + "last_name": "Liu", + "institution": "Intel (United States)" + }, + { + "first_name": "Chick", + "last_name": "Markley", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Armando", + "last_name": "Fox", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Tatiana", + "last_name": "Shpeisman", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/TruongBTLMFS16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908088", + "title": "Synthesizing transformations on hierarchically structured data", + "abstract": "This paper presents a new approach for synthesizing transformations on tree-structured data, such as Unix directories and XML documents. We consider a general abstraction for such data, called hierarchical data trees (HDTs) and present a novel example-driven synthesis algorithm for HDT transformations. Our central insight is to reduce the problem of synthesizing tree transformers to the synthesis of list transformations that are applied to the paths of the tree. The synthesis problem over lists is solved using a new algorithm that combines SMT solving and decision tree learning. We have implemented our technique in a system called HADES and show that HADES can automatically synthesize a variety of interesting transformations collected from online forums.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908088", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Navid", + "last_name": "Yaghmazadeh", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Christian", + "last_name": "Klinger", + "institution": "University of Freiburg" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/YaghmazadehKDC16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908086", + "title": "Accepting blame for safe tunneled exceptions", + "abstract": "Unhandled exceptions crash programs, so a compile-time check that exceptions are handled should in principle make software more reliable. But designers of some recent languages have argued that the benefits of statically checked exceptions are not worth the costs. We introduce a new statically checked exception mechanism that addresses the problems with existing checked-exception mechanisms. In particular, it interacts well with higher-order functions and other design patterns. The key insight is that whether an exception should be treated as a \"checked\" exception is not a property of its type but rather of the context in which the exception propagates. Statically checked exceptions can \"tunnel\" through code that is oblivious to their presence, but the type system nevertheless checks that these exceptions are handled. Further, exceptions can be tunneled without being accidentally caught, by expanding the space of exception identifiers to identify the exception-handling context. The resulting mechanism is expressive and syntactically light, and can be implemented efficiently. We demonstrate the expressiveness of the mechanism using significant codebases and evaluate its performance. We have implemented this new exception mechanism as part of the new Genus programming language, but the mechanism could equally well be applied to other programming languages.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908086", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "Cornell University" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Quinn", + "last_name": "Beightol", + "institution": "Cornell University" + }, + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/ZhangSBLM16", + "venue": "pldi", + "year": 2016 + }, + { + "paper_id": "10.1145/2908080.2908082", + "title": "GreenWeb: language extensions for energy-efficient mobile web computing", + "abstract": "Web computing is gradually shifting toward mobile devices, in which the energy budget is severely constrained. As a result, Web developers must be conscious of energy efficiency. However, current Web languages provide developers little control over energy consumption. In this paper, we take a first step toward language-level research to enable energy-efficient Web computing. Our key motivation is that mobile systems can wisely budget energy usage if informed with user quality-of-service (QoS) constraints. To do this, programmers need new abstractions. We propose two language abstractions, QoS type and QoS target, to capture two fundamental aspects of user QoS experience. We then present GreenWeb, a set of language extensions that empower developers to easily express the QoS abstractions as program annotations. As a proof of concept, we develop a GreenWeb runtime, which intelligently determines how to deliver specified user QoS expectation while minimizing energy consumption. Overall, GreenWeb shows significant energy savings (29.2% ∼ 66.0%) over Android’s default Interactive governor with few QoS violations. Our work demonstrates a promising first step toward language innovations for energy-efficient Web computing.", + "date": "2016-06-02", + "link": "https://doi.org/10.1145/2908080.2908082", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuhao", + "last_name": "Zhu", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Vijay Janapa", + "last_name": "Reddi", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/ZhuR16", + "venue": "pldi", + "year": 2016 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2017.json b/data/pl_conferences/pldi/2017.json new file mode 100644 index 0000000..2668cc3 --- /dev/null +++ b/data/pl_conferences/pldi/2017.json @@ -0,0 +1,1518 @@ +[ + { + "paper_id": "10.1145/3062341.3062377", + "title": "Generalizations of the theory and deployment of triangular inequality for compiler-based strength reduction", + "abstract": "Triangular Inequality (TI) has been used in many manual algorithm designs to achieve good efficiency in solving some distance calculation-based problems. This paper presents our generalization of the idea into a compiler optimization technique, named TI-based strength reduction. The generalization consists of three parts. The first is the establishment of the theoretic foundation of this new optimization via the development of a new form of TI named Angular Triangular Inequality, along with several fundamental theorems. The second is the revealing of the properties of the new forms of TI and the proposal of guided TI adaptation, a systematic method to address the difficulties in effective deployments of TI optimizations. The third is an integration of the new optimization technique in an open-source compiler. Experiments on a set of data mining and machine learning algorithms show that the new technique can speed up the standard implementations by as much as 134X and 46X on average for distance-related problems, outperforming previous TI-based optimizations by 2.35X on average. It also extends the applicability of TI-based optimizations to vector related problems, producing tens of times of speedup.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062377", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yufei", + "last_name": "Ding", + "institution": "North Carolina State University" + }, + { + "first_name": "Lin", + "last_name": "Ning", + "institution": "North Carolina State University" + }, + { + "first_name": "Hui", + "last_name": "Guan", + "institution": "North Carolina State University" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + } + ], + "dblp_key": "conf/pldi/DingNGS17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062353", + "title": "Synthesizing memory models from framework sketches and Litmus tests", + "abstract": "A memory consistency model specifies which writes to shared memory a given read may see. Ambiguities or errors in these specifications can lead to bugs in both compilers and applications. Yet architectures usually define their memory models with prose and litmus tests—small concurrent programs that demonstrate allowed and forbidden outcomes. Recent work has formalized the memory models of common architectures through substantial manual effort, but as new architectures emerge, there is a growing need for tools to aid these efforts.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062353", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "James", + "last_name": "Bornholt", + "institution": "University of Washington" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/BornholtT17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062366", + "title": "Low-synchronization, mostly lock-free, elastic scheduling for streaming runtimes", + "abstract": "We present the scalable, elastic operator scheduler in IBM Streams 4.2. Streams is a distributed stream processing system used in production at many companies in a wide range of industries. The programming language for Streams, SPL, presents operators, tuples and streams as the primary abstractions. A fundamental SPL optimization is operator fusion, where multiple operators execute in the same process. Streams 4.2 introduces automatic submission-time fusion to simplify application development and deployment. However, potentially thousands of operators could then execute in the same process, with no user guidance for thread placement. We needed a way to automatically figure out how many threads to use, with arbitrarily sized applications on a wide variety of hardware, and without any input from programmers. Our solution has two components. The first is a scalable operator scheduler that minimizes synchronization, locks and global data, while allowing threads to execute any operator and dynamically come and go. The second is an elastic algorithm to dynamically adjust the number of threads to optimize performance, using the principles of trusted measurements to establish trends. We demonstrate our scheduler's ability to scale to over a hundred threads, and our elasticity algorithm's ability to adapt to different workloads on an Intel Xeon system with 176 logical cores, and an IBM Power8 system with 184 logical cores.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062366", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Scott", + "last_name": "Schneider", + "institution": "" + }, + { + "first_name": "Kun‐Lung", + "last_name": "Wu", + "institution": "" + } + ], + "dblp_key": "conf/pldi/0001W17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062371", + "title": "Low overhead dynamic binary translation on ARM", + "abstract": "The ARMv8 architecture introduced AArch64, a 64-bit execution mode with a new instruction set, while retaining binary compatibility with previous versions of the ARM architecture through AArch32, a 32-bit execution mode. Most hardware implementations of ARMv8 processors support both AArch32 and AArch64, which comes at a cost in hardware complexity.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062371", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amanieu", + "last_name": "d'Antras", + "institution": "University of Manchester" + }, + { + "first_name": "Cosmin", + "last_name": "Gorgovan", + "institution": "University of Manchester" + }, + { + "first_name": "Jim", + "last_name": "Garside", + "institution": "University of Manchester" + }, + { + "first_name": "Mikel", + "last_name": "Luján", + "institution": "University of Manchester" + } + ], + "dblp_key": "conf/pldi/DAntrasGGL17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062385", + "title": "Cache locality optimization for recursive programs", + "abstract": "We present an approach to optimize the cache locality for recursive programs by dynamically splicing---recursively interleaving---the execution of distinct function invocations. By utilizing data effect annotations, we identify concurrency and data reuse opportunities across function invocations and interleave them to reduce reuse distance. We present algorithms that efficiently track effects in recursive programs, detect interference and dependencies, and interleave execution of function invocations using user-level (non-kernel) lightweight threads. To enable multi-core execution, a program is parallelized using a nested fork/join programming model. Our cache optimization strategy is designed to work in the context of a random work stealing scheduler. We present an implementation using the MIT Cilk framework that demonstrates significant improvements in sequential and parallel performance, competitive with a state-of-the-art compile-time optimizer for loop programs and a domain-specific optimizer for stencil programs.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062385", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Lifflander", + "institution": "Sandia National Laboratories" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + } + ], + "dblp_key": "conf/pldi/LifflanderK17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062388", + "title": "Rigorous analysis of software countermeasures against cache attacks", + "abstract": "CPU caches introduce variations into the execution time of programs that can be exploited by adversaries to recover private information about users or cryptographic keys.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062388", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Goran", + "last_name": "Doychev", + "institution": "IMDEA Software" + }, + { + "first_name": "Boris", + "last_name": "Köpf", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/pldi/DoychevK17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062344", + "title": "Instruction punning: lightweight instrumentation for x86-64", + "abstract": "Existing techniques for injecting probes into running applications are limited;", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062344", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Buddhika", + "last_name": "Chamith", + "institution": "Indiana University" + }, + { + "first_name": "Bo Joel", + "last_name": "Svensson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Luke", + "last_name": "Dalessandro", + "institution": "Indiana University" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/pldi/ChamithSDN17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062356", + "title": "Proactive and adaptive energy-aware programming with mixed typechecking", + "abstract": "Application-level energy management is an important dimension of energy optimization. In this paper, we introduce ENT, a novel programming language for enabling *proactive* and *adaptive* mode-based energy management at the application level. The proactive design allows programmers to apply their application knowledge to energy management, by characterizing the energy behavior of different program fragments with modes. The adaptive design allows such characterization to be delayed until run time, useful for capturing dynamic program behavior dependent on program states, configuration settings, external battery levels, or CPU temperatures. The key insight is both proactiveness and adaptiveness can be unified under a type system combined with static typing and dynamic typing. ENT has been implemented as an extension to Java, and successfully ported to three energy-conscious platforms: an Intel-based laptop, a Raspberry Pi, and an Android phone. Evaluation shows ENT improves the programmability, debuggability, and energy efficiency of battery-aware and temperature-aware programs.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062356", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anthony", + "last_name": "Canino", + "institution": "Binghamton University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + } + ], + "dblp_key": "conf/pldi/CaninoL17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062347", + "title": "FunTAL: reasonably mixing a functional language with assembly", + "abstract": "We present FunTAL, the first multi-language system to formalize safe interoperability between a high-level functional language and low-level assembly code while supporting compositional reasoning about the mix. A central challenge in developing such a multi-language is bridging the gap between assembly, which is staged into jumps to continuations, and high-level code, where subterms return a result. We present a compositional stack-based typed assembly language that supports components, comprised of one or more basic blocks, that may be embedded in high-level contexts. We also present a logical relation for FunTAL that supports reasoning about equivalence of high-level components and their assembly replacements, mixed-language programs with callbacks between languages, and assembly components comprised of different numbers of basic blocks.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062347", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Patterson", + "institution": "Northeastern University" + }, + { + "first_name": "Jamie", + "last_name": "Perconti", + "institution": "Northeastern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Harvard University Press" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/PattersonPDA17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062375", + "title": "Compiling Markov chain Monte Carlo algorithms for probabilistic modeling", + "abstract": "The problem of probabilistic modeling and inference, at a high-level, can be viewed as constructing a (model, query, inference) tuple, where an inference algorithm implements a query on a model. Notably, the derivation of inference algorithms can be a difficult and error-prone task. Hence, researchers have explored how ideas from probabilistic programming can be applied. In the context of constructing these tuples, probabilistic programming can be seen as taking a language-based approach to probabilistic modeling and inference. For instance, by using (1) appropriate languages for expressing models and queries and (2) devising inference techniques that operate on encodings of models (and queries) as program expressions, the task of inference can be automated.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062375", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Huang", + "institution": "Harvard University Press" + }, + { + "first_name": "Jean-Baptiste", + "last_name": "Tristan", + "institution": "Oracle (United States)" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/HuangTM17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062387", + "title": "Similarity of binaries through re-optimization", + "abstract": "We present a scalable approach for establishing similarity between stripped binaries (with no debug information). The main challenge in binary similarity, is to establish similarity even when the code has been compiled using different compilers, with different optimization levels, or targeting different architectures. Overcoming this challenge, while avoiding false positives, is invaluable to the process of reverse engineering and the process of locating vulnerable code.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062387", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yaniv", + "last_name": "David", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Nimrod", + "last_name": "Partush", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/DavidPY17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062384", + "title": "Flatten and conquer: a framework for efficient analysis of string constraints", + "abstract": "We describe a uniform and efficient framework for checking the satisfiability of a large class of string constraints. The framework is based on the observation that both satisfiability and unsatisfiability of common constraints can be demonstrated through witnesses with simple patterns. These patterns are captured using flat automata each of which consists of a sequence of simple loops. We build a Counter-Example Guided Abstraction Refinement (CEGAR) framework which contains both an under- and an over-approximation module. The flow of information between the modules allows to increase the precision in an automatic manner. We have implemented the framework as a tool and performed extensive experimentation that demonstrates both the generality and efficiency of our method.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062384", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Yu‐Fang", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "Bui Phi", + "last_name": "Diep", + "institution": "Uppsala University" + }, + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" + }, + { + "first_name": "Ahmed", + "last_name": "Rezine", + "institution": "Linköping University" + }, + { + "first_name": "Philipp", + "last_name": "Rümmer", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/pldi/AbdullaACDHRR17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062363", + "title": "Bringing the web up to speed with WebAssembly", + "abstract": "The maturation of the Web platform has given rise to sophisticated and demanding Web applications such as interactive 3D visualization, audio and video software, and games. With that, efficiency and security of code on the Web has become more important than ever. Yet JavaScript as the only built-in language of the Web is not well-equipped to meet these requirements, especially as a compilation target.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062363", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Haas", + "institution": "" + }, + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "" + }, + { + "first_name": "Derek L.", + "last_name": "Schuff", + "institution": "Google (United States)" + }, + { + "first_name": "Ben L.", + "last_name": "Titzer", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Holman", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dan", + "last_name": "Gohman", + "institution": "" + }, + { + "first_name": "Luke", + "last_name": "Wagner", + "institution": "" + }, + { + "first_name": "Alon", + "last_name": "Zakai", + "institution": "" + }, + { + "first_name": "JF", + "last_name": "Bastien", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/pldi/HaasRSTHGWZB17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062383", + "title": "Achieving high coverage for floating-point code via unconstrained programming", + "abstract": "Achieving high code coverage is essential in testing, which gives us confidence in code quality. Testing floating-point code usually requires painstaking efforts in handling floating-point constraints, e.g., in symbolic execution. This paper turns the challenge of testing floating-point code into the opportunity of applying unconstrained programming --- the mathematical solution for calculating function minimum points over the entire search space. Our core insight is to derive a representing function from the floating-point program, any of whose minimum points is a test input guaranteed to exercise a new branch of the tested program. This guarantee allows us to achieve high coverage of the floating-point program by repeatedly minimizing the representing function.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062383", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhoulai", + "last_name": "Fu", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/FuS17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062348", + "title": "HoTTSQL: proving query rewrites with univalent SQL semantics", + "abstract": "Every database system contains a query optimizer that performs query rewrites. Unfortunately, developing query optimizers remains a highly challenging task. Part of the challenges comes from the intricacies and rich features of query languages, which makes reasoning about rewrite rules difficult. In this paper, we propose a machine-checkable denotational semantics for SQL, the de facto language for relational database, for rigorously validating rewrite rules. Unlike previously proposed semantics that are either non-mechanized or only cover a small amount of SQL language features, our semantics covers all major features of SQL, including bags, correlated subqueries, aggregation, and indexes. Our mechanized semantics, called HoTT SQL, is based on K-Relations and homotopy type theory, where we denote relations as mathematical functions from tuples to univalent types. We have implemented HoTTSQL in Coq, which takes only fewer than 300 lines of code and have proved a wide range of SQL rewrite rules, including those from database research literature (e.g., magic set rewrites) and real-world query optimizers (e.g., subquery elimination). Several of these rewrite rules have never been previously proven correct. In addition, while query equivalence is generally undecidable, we have implemented an automated decision procedure using HoTTSQL for conjunctive queries: a well studied decidable fragment of SQL that encompasses many real-world queries.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062348", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shumo", + "last_name": "Chu", + "institution": "University of Washington" + }, + { + "first_name": "Konstantin", + "last_name": "Weitz", + "institution": "University of Washington" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Suciu", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/ChuWCS17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062367", + "title": "Network configuration synthesis with abstract topologies", + "abstract": "We develop Propane/AT, a system to synthesize provably-correct BGP (border gateway protocol) configurations for large, evolving networks from high-level specifications of topology, routing policy, and fault-tolerance requirements. Propane/AT is based on new abstractions for capturing parameterized network topologies and their evolution, and algorithms to analyze the impact of topology and routing policy on fault tolerance. Our algorithms operate entirely on abstract topologies. We prove that the properties established by our analyses hold for every concrete instantiation of the given abstract topology. Propane/AT also guarantees that only incremental changes to existing device configurations are required when the network evolves to add or remove devices and links. Our experiments with real-world topologies and policies show that our abstractions and algorithms are effective, and that, for large networks, Propane/AT synthesizes configurations two orders of magnitude faster than systems that operate on concrete topologies.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062367", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Beckett", + "institution": "Princeton University" + }, + { + "first_name": "Ratul", + "last_name": "Mahajan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jitendra", + "last_name": "Padhye", + "institution": "Microsoft (United States)" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/BeckettMMPW17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062378", + "title": "Decomposition instead of self-composition for proving the absence of timing channels", + "abstract": "We present a novel approach to proving the absence of timing channels. The idea is to partition the program's execution traces in such a way that each partition component is checked for timing attack resilience by a time complexity analysis and that per-component resilience implies the resilience of the whole program. We construct a partition by splitting the program traces at secret-independent branches. This ensures that any pair of traces with the same public input has a component containing both traces. Crucially, the per-component checks can be normal safety properties expressed in terms of a single execution. Our approach is thus in contrast to prior approaches, such as self-composition, that aim to reason about multiple (k≥ 2) executions at once.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062378", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Timos", + "last_name": "Antonopoulos", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Gazzillo", + "institution": "Yale University" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Yale University" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Japan Advanced Institute of Science and Technology" + }, + { + "first_name": "Shiyi", + "last_name": "Wei", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/AntonopoulosGHK17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062345", + "title": "Automatic program inversion using symbolic transducers", + "abstract": "We propose a fully-automated technique for inverting functional programs that operate over lists such as string encoders and decoders. We consider programs that can be modeled using symbolic extended finite transducers (), an expressive model that can describe complex list-manipulating programs while retaining several decidable properties. Concretely, given a program P expressed as an , we propose techniques for: (1) checking whether P is injective and, if that is the case, (2) building an P-1 describing its inverse. We first show that it is undecidable to check whether an is injective and propose an algorithm for checking injectivity for a restricted, but a practical class of . We then propose an algorithm for inverting based on the following idea: if an is injective, inverting it amounts to inverting all its individual transitions. We leverage recent advances program synthesis and show that the transition inversion problem can be expressed as an instance of the syntax-guided synthesis framework. Finally, we implement the proposed techniques in a tool called and show that can invert 13 out 14 real complex string encoders and decoders, producing inverse programs that are substantially identical to manually written ones.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062345", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qinheping", + "last_name": "Hu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/HuD17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062342", + "title": "BARRACUDA: binary-level analysis of runtime RAces in CUDA programs", + "abstract": "GPU programming models enable and encourage massively parallel programming with over a million threads, requiring extreme parallelism to achieve good performance. Massive parallelism brings significant correctness challenges by increasing the possibility for bugs as the number of thread interleavings balloons. Conventional dynamic safety analyses struggle to run at this scale.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062342", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ariel", + "last_name": "Eizenberg", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Yuanfeng", + "last_name": "Peng", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Toma", + "last_name": "Pigli", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "William", + "last_name": "Mansky", + "institution": "Princeton University" + }, + { + "first_name": "Joseph", + "last_name": "Devietti", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/EizenbergPPMD17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062349", + "title": "Synthesizing program input grammars", + "abstract": "We present an algorithm for synthesizing a context-free grammar encoding the language of valid program inputs from a set of input examples and blackbox access to the program. Our algorithm addresses shortcomings of existing grammar inference algorithms, which both severely overgeneralize and are prohibitively slow. Our implementation, GLADE, leverages the grammar synthesized by our algorithm to fuzz test programs with structured inputs. We show that GLADE substantially increases the incremental coverage on valid inputs compared to two baseline fuzzers.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062349", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "Stanford University" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Percy", + "last_name": "Liang", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/Bastani0AL17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062352", + "title": "Repairing sequential consistency in C/C++11", + "abstract": "The C/C++11 memory model defines the semantics of concurrent memory accesses in C/C++, and in particular supports racy \"atomic\" accesses at a range of different consistency levels, from very weak consistency (\"relaxed\") to strong, sequential consistency (\"SC\"). Unfortunately, as we observe in this paper, the semantics of SC atomic accesses in C/C++11, as well as in all proposed strengthenings of the semantics, is flawed, in that (contrary to previously published results) both suggested compilation schemes to the Power architecture are unsound. We propose a model, called RC11 (for Repaired C11), with a better semantics for SC accesses that restores the soundness of the compilation schemes to Power, maintains the DRF-SC guarantee, and provides stronger, more useful, guarantees to SC fences. In addition, we formally prove, for the first time, the correctness of the proposed stronger compilation schemes to Power that preserve load-to-store ordering and avoid \"out-of-thin-air\" reads.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062352", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/LahavVKHD17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062374", + "title": "Dynamic race prediction in linear time", + "abstract": "Writing reliable concurrent software remains a huge challenge for today's programmers. Programmers rarely reason about their code by explicitly considering different possible inter-leavings of its execution. We consider the problem of detecting data races from individual executions in a sound manner. The classical approach to solving this problem has been to use Lamport's happens-before (HB) relation. Until now HB remains the only approach that runs in linear time. Previous efforts in improving over HB such as causally-precedes (CP) and maximal causal models fall short due to the fact that they are not implementable efficiently and hence have to compromise on their race detecting ability by limiting their techniques to bounded sized fragments of the execution. We present a new relation weak-causally-precedes (WCP) that is provably better than CP in terms of being able to detect more races, while still remaining sound. Moreover, it admits a linear time algorithm which works on the entire execution without having to fragment it.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062374", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dileep", + "last_name": "Kini", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/KiniM017", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062358", + "title": "A formally verified compiler for Lustre", + "abstract": "The correct compilation of block diagram languages like Lustre, Scade, and a discrete subset of Simulink is important since they are used to program critical embedded control software. We describe the specification and verification in an Interactive Theorem Prover of a compilation chain that treats the key aspects of Lustre: sampling, nodes, and delays. Building on CompCert, we show that repeated execution of the generated assembly code faithfully implements the dataflow semantics of source programs.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062358", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Timothy", + "last_name": "Bourke", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Lélio", + "last_name": "Brun", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Pierre-Évariste", + "last_name": "Dagand", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Marc", + "last_name": "Pouzet", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Lionel", + "last_name": "Rieg", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/BourkeBDLPR17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062355", + "title": "Synthesis of divide and conquer parallelism for loops", + "abstract": "Divide-and-conquer is a common parallel programming skeleton supported by many cross-platform multithreaded libraries, and most commonly used by programmers for parallelization. The challenges of producing (manually or automatically) a correct divide-and-conquer parallel program from a given sequential code are two-fold: (1) assuming that a good solution exists where individual worker threads execute a code identical to the sequential one, the programmer has to provide the extra code for dividing the tasks and combining the partial results (i.e. joins), and (2) the sequential code may not be suitable for divide-and-conquer parallelization as is, and may need to be modified to become a part of a good solution. We address both challenges in this paper. We present an automated synthesis technique to synthesize correct joins and an algorithm for modifying the sequential code to make it suitable for parallelization when necessary. This paper focuses on class of loops that traverse a read-only collection and compute a scalar function over that collection. We present theoretical results for when the necessary modifications to sequential code are possible, theoretical guarantees for the algorithmic solutions presented here, and experimental evaluation of the approach's success in practice and the quality of the produced parallel programs.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062355", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Victor", + "last_name": "Nicolet", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/pldi/FarzanN17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062357", + "title": "Levity polymorphism", + "abstract": "Parametric polymorphism is one of the linchpins of modern typed programming, but it comes with a real performance penalty. We describe this penalty; offer a principled way to reason about it (kinds as calling conventions); and propose levity polymorphism. This new form of polymorphism allows abstractions over calling conventions; we detail and verify restrictions that are necessary in order to compile levity-polymorphic functions. Levity polymorphism has created new opportunities in Haskell, including the ability to generalize nearly half of the type classes in GHC's standard library.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062357", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/EisenbergJ17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062369", + "title": "StreamQRE: modular specification and efficient evaluation of quantitative queries over streaming data", + "abstract": "Real-time decision making in emerging IoT applications typically relies on computing quantitative summaries of large data streams in an efficient and incremental manner. To simplify the task of programming the desired logic, we propose StreamQRE, which provides natural and high-level constructs for processing streaming data. Our language has a novel integration of linguistic constructs from two distinct programming paradigms: streaming extensions of relational query languages and quantitative extensions of regular expressions. The former allows the programmer to employ relational constructs to partition the input data by keys and to integrate data streams from different sources, while the latter can be used to exploit the logical hierarchy in the input stream for modular specifications. We first present the core language with a small set of combinators, formal semantics, and a decidable type system. We then show how to express a number of common patterns with illustrative examples. Our compilation algorithm translates the high-level query into a streaming algorithm with precise complexity bounds on per-item processing time and total memory footprint. We also show how to integrate approximation algorithms into our framework. We report on an implementation in Java, and evaluate it with respect to existing high-performance engines for processing streaming data. Our experimental evaluation shows that (1) StreamQRE allows more natural and succinct specification of queries compared to existing frameworks, (2) the throughput of our implementation is higher than comparable systems (for example, two-to-four times greater than RxJava), and (3) the approximation algorithms supported by our implementation can lead to substantial memory savings.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062369", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Zachary G.", + "last_name": "Ives", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Sanjeev", + "last_name": "Khanna", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/MamourasRAIK17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062354", + "title": "Futhark: purely functional GPU-programming with nested parallelism and in-place array updates", + "abstract": "Futhark is a purely functional data-parallel array language that offers a machine-neutral programming model and an optimising compiler that generates OpenCL code for GPUs.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062354", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Troels", + "last_name": "Henriksen", + "institution": "University of Copenhagen" + }, + { + "first_name": "Niels G. W.", + "last_name": "Serup", + "institution": "University of Copenhagen" + }, + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" + }, + { + "first_name": "Fritz", + "last_name": "Henglein", + "institution": "University of Copenhagen" + }, + { + "first_name": "Cosmin E.", + "last_name": "Oancea", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/pldi/HenriksenSEHO17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062351", + "title": "Component-based synthesis of table consolidation and transformation tasks from examples", + "abstract": "This paper presents a novel component-based synthesis algorithm that marries the power of type-directed search with lightweight SMT-based deduction and partial evaluation. Given a set of components together with their over-approximate first-order specifications, our method first generates a program sketch over a subset of the components and checks its feasibility using an SMT solver. Since a program sketch typically represents many concrete programs, the use of SMT-based deduction greatly increases the scalability of the algorithm. Once a feasible program sketch is found, our algorithm completes the sketch in a bottom-up fashion, using partial evaluation to further increase the power of deduction for rejecting partially-filled program sketches. We apply the proposed synthesis methodology for automating a large class of data preparation tasks that commonly arise in data science. We have evaluated our synthesis algorithm on dozens of data wrangling and consolidation tasks obtained from on-line forums, and we show that our approach can automatically solve a large class of problems encountered by R users.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062351", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ruben", + "last_name": "Martins", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Jacob Van", + "last_name": "Geffen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/FengMGDC17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062382", + "title": "Gradual synthesis for static parallelization of single-pass array-processing programs", + "abstract": "Parallelizing of software improves its effectiveness and productivity. To guarantee correctness, the parallel and serial versions of the same code must be formally verified to be equivalent. We present a novel approach, called GRASSP, that automatically synthesizes parallel single-pass array-processing programs by treating the given serial versions as specifications. Given arbitrary segmentation of the input array, GRASSP synthesizes a code to determine a new segmentation of the array that allows computing partial results for each segment and merging them. In contrast to other parallelizers, GRASSP gradually considers several parallelization scenarios and certifies the results using constrained Horn solving. For several classes of programs, we show that such parallelization can be performed efficiently. The C++ translations of the GRASSP solutions sped performance by up to 5X relative to serial code on an 8-thread machine and Hadoop translations by up to 10X on a 10-node Amazon EMR cluster.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062382", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Grigory", + "last_name": "Fedyukovich", + "institution": "University of Washington" + }, + { + "first_name": "M", + "last_name": "Ahmad", + "institution": "University of Washington" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/FedyukovichAB17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062364", + "title": "Systematic black-box analysis of collaborative web applications", + "abstract": "Web applications, such as collaborative editors that allow multiple clients to concurrently interact on a shared resource, are difficult to implement correctly. Existing techniques for analyzing concurrent software do not scale to such complex systems or do not consider multiple interacting clients. This paper presents Simian, the first fully automated technique for systematically analyzing multi-client web applications.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062364", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marina", + "last_name": "Billes", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/pldi/BillesMP17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062373", + "title": "Compositional recurrence analysis revisited", + "abstract": "Compositional recurrence analysis (CRA) is a static-analysis method based on a combination of symbolic analysis and abstract interpretation. This paper addresses the problem of creating a context-sensitive interprocedural version of CRA that handles recursive procedures. The problem is non-trivial because there is an \"impedance mismatch\" between CRA, which relies on analysis techniques based on regular languages (i.e., Tarjan's path-expression method), and the context-free-language underpinnings of context-sensitive analysis.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062373", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "Jason", + "last_name": "Breck", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ashkan Forouhi", + "last_name": "Boroujeni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "GrammaTech (United States)" + } + ], + "dblp_key": "conf/pldi/KincaidBBR17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062376", + "title": "Simple, fast, and safe manual memory management", + "abstract": "Safe programming languages are readily available, but many applications continue to be written in unsafe languages because of efficiency. As a consequence, many applications continue to have exploitable memory safety bugs. Since garbage collection is a major source of inefficiency in the implementation of safe languages, replacing it with safe manual memory management would be an important step towards solving this problem.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062376", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Piyus", + "last_name": "Kedia", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Manuel", + "last_name": "Costa", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Kapil", + "last_name": "Vaswani", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Aaron", + "last_name": "Blankstein", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/KediaCPVVB17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062343", + "title": "Taming undefined behavior in LLVM", + "abstract": "A central concern for an optimizing compiler is the design of its intermediate representation (IR) for code. The IR should make it easy to perform transformations, and should also afford efficient and precise static analysis. In this paper we study an aspect of IR design that has received little attention: the role of undefined behavior. The IR for every optimizing compiler we have looked at, including GCC, LLVM, Intel's, and Microsoft's, supports one or more forms of undefined behavior (UB), not only to reflect the semantics of UB-heavy programming languages such as C and C++, but also to model inherently unsafe low-level operations such as memory stores and to avoid over-constraining IR semantics to the point that desirable transformations become illegal. The current semantics of LLVM's IR fails to justify some cases of loop unswitching, global value numbering, and other important \"textbook\" optimizations, causing long-standing bugs. We present solutions to the problems we have identified in LLVM's IR and show that most optimizations currently in LLVM remain sound, and that some desirable new transformations become permissible. Our solutions do not degrade compile time or performance of generated code.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062343", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Juneyoung", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Yoonseung", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Sanjoy", + "last_name": "Das", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Majnemer", + "institution": "Google (United States)" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + }, + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/LeeKSHDMRL17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062380", + "title": "Compiling without continuations", + "abstract": "Many fields of study in compilers give rise to the concept of a join point—a place where different execution paths come together. Join points are often treated as functions or continuations, but we believe it is time to study them in their own right. We show that adding join points to a direct-style functional intermediate language is a simple but powerful change that allows new optimizations to be performed, including a significant improvement to list fusion. Finally, we report on recent work on adding join points to the intermediate language of the Glasgow Haskell Compiler.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062380", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Luke", + "last_name": "Maurer", + "institution": "University of Oregon" + }, + { + "first_name": "Paul", + "last_name": "Downen", + "institution": "University of Oregon" + }, + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "University of Oregon" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/MaurerDAJ17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062361", + "title": "Static deadlock detection for asynchronous C# programs", + "abstract": "Asynchronous programming is a standard approach for designing responsive applications. Modern languages such as C# provide async/await primitives for the disciplined use of asynchrony. In spite of this, programs can deadlock because of incorrect use of blocking operations along with non-blocking (asynchronous) operations. While developers are aware of this problem, there is no automated technique to detect deadlocks in asynchronous programs.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062361", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anirudh", + "last_name": "Santhiar", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Aditya", + "last_name": "Kanade", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/pldi/SanthiarK17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062362", + "title": "Fusing effectful comprehensions", + "abstract": "List comprehensions provide a powerful abstraction mechanism for expressing computations over ordered collections of data declaratively without having to use explicit iteration constructs. This paper puts forth effectful comprehensions as an elegant way to describe list comprehensions that incorporate loop-carried state. This is motivated by operations such as compression/decompression and serialization/deserialization that are common in log/data processing pipelines and require loop-carried state when processing an input stream of data.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062362", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Olli", + "last_name": "Saarikivi", + "institution": "Helsinki Institute for Information Technology" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Madan", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/SaarikiviVMM17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062368", + "title": "Control-flow recovery from partial failure reports", + "abstract": "Debugging is difficult. When software fails in production, debugging is even harder, as failure reports usually provide only an incomplete picture of the failing execution. We present a system that answers control-flow queries posed by developers as formal languages, indicating whether the query expresses control flow that is possible or impossible for a given failure report. We consider three separate approaches that trade off precision, expressiveness for failure constraints, and scalability. We also introduce a new subclass of regular languages, the unreliable trace languages, which are particularly suited to answering control-flow queries in polynomial time. Our system answers queries remarkably efficiently when we encode failure constraints and user queries entirely as unreliable trace languages.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062368", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peter", + "last_name": "Ohmann", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Alexander", + "last_name": "Brooks", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/OhmannBDL17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062365", + "title": "Synthesizing highly expressive SQL queries from input-output examples", + "abstract": "SQL is the de facto language for manipulating relational data. Though powerful, many users find it difficult to write SQL queries due to highly expressive constructs.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062365", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chenglong", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of Washington" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/WangCB17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062370", + "title": "Responsive parallel computation: bridging competitive and cooperative threading", + "abstract": "Competitive and cooperative threading are widely used abstractions in computing. In competitive threading, threads are scheduled preemptively with the goal of minimizing response time, usually of interactive applications. In cooperative threading, threads are scheduled non-preemptively with the goal of maximizing throughput or minimizing the completion time, usually in compute-intensive applications, e.g. scientific computing, machine learning and AI.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062370", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/MullerA017", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062360", + "title": "Efficient and precise points-to analysis: modeling the heap by merging equivalent automata", + "abstract": "Mainstream points-to analysis techniques for object-oriented languages rely predominantly on the allocation-site abstraction to model heap objects. We present MAHJONG, a novel heap abstraction that is specifically developed to address the needs of an important class of type-dependent clients, such as call graph construction, devirtualization and may-fail casting. By merging equivalent automata representing type-consistent objects that are created by the allocation-site abstraction, MAHJONG enables an allocation-site-based points-to analysis to run significantly faster while achieving nearly the same precision for type-dependent clients.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062360", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "UNSW Sydney" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/pldi/TanLX17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062359", + "title": "Context transformations for pointer analysis", + "abstract": "Points-to analysis for Java benefits greatly from context sensitivity. CFL-reachability and k-limited context strings are two approaches to obtaining context sensitivity with different advantages: CFL-reachability allows local reasoning about data-value flow and thus is suitable for demand-driven analyses, whereas k-limited analyses allow object sensitivity which is a superior calling context abstraction for object-oriented languages. We combine the advantages of both approaches to obtain a context-sensitive analysis that is as precise as k-limited context strings, but is more efficient to compute. Our key insight is based on a novel abstraction of contexts adapted from CFL-reachability that represents a relation between two calling contexts as a composition of transformations over contexts.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062359", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rei", + "last_name": "Thiessen", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/pldi/ThiessenL17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062372", + "title": "Alive-Infer: data-driven precondition inference for peephole optimizations in LLVM", + "abstract": "Peephole optimizations are a common source of compiler bugs. Compiler developers typically transform an incorrect peephole optimization into a valid one by strengthening the precondition. This process is challenging and tedious. This paper proposes ALIVE-INFER, a data-driven approach that infers preconditions for peephole optimizations expressed in Alive. ALIVE-INFER generates positive and negative examples for an optimization, enumerates predicates ondemand, and learns a set of predicates that separate the positive and negative examples. ALIVE-INFER repeats this process until it finds a precondition that ensures the validity of the optimization. ALIVE-INFER reports both a weakest precondition and a set of succinct partial preconditions to the developer. Our prototype generates preconditions that are weaker than LLVM's preconditions for 73 optimizations in the Alive suite. We also demonstrate the applicability of this technique to generalize 54 optimization patterns generated by Souper, an LLVM IR-based superoptimizer.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062372", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Menendez", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/pldi/MenendezN17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062346", + "title": "Miniphases: compilation using modular and efficient tree transformations", + "abstract": "Production compilers commonly perform dozens of transformations on an intermediate representation. Running those transformations in separate passes harms performance. One approach to recover performance is to combine transformations by hand in order to reduce number of passes. Such an approach harms modularity, and thus makes it hard to maintain and evolve a compiler over the long term, and makes reasoning about performance harder. This paper describes a methodology that allows a compiler writer to define multiple transformations separately, but fuse them into a single traversal of the intermediate representation when the compiler runs. This approach has been implemented in a compiler for the Scala language. Our performance evaluation indicates that this approach reduces the running time of tree transformations by 35% and shows that this is due to improved cache friendliness. At the same time, the approach improves total memory consumption by reducing the object tenuring rate by 50%. This approach enables compiler writers to write transformations that are both modular and fast at the same time.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062346", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dmitry", + "last_name": "Petrashko", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/PetrashkoLO17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062379", + "title": "Skeletal program enumeration for rigorous compiler testing", + "abstract": "A program can be viewed as a syntactic structure P (syntactic skeleton) parameterized by a collection of identifiers V (variable names). This paper introduces the skeletal program enumeration (SPE) problem: Given a syntactic skeleton P and a set of variables V , enumerate a set of programs P exhibiting all possible variable usage patterns within P. It proposes an effective realization of SPE for systematic, rigorous compiler testing by leveraging three important observations: (1) Programs with different variable usage patterns exhibit diverse control- and data-dependence, and help exploit different compiler optimizations; (2) most real compiler bugs were revealed by small tests (i.e., small-sized P) — this “small-scope” observation opens up SPE for practical compiler validation; and (3) SPE is exhaustive w.r.t. a given syntactic skeleton and variable set, offering a level of guarantee absent from all existing compiler testing techniques.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062379", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "University of California, Davis" + }, + { + "first_name": "C. P.", + "last_name": "Sun", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/ZhangSS17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062381", + "title": "Practical partial evaluation for high-performance dynamic language runtimes", + "abstract": "Most high-performance dynamic language virtual machines duplicate language semantics in the interpreter, compiler, and runtime system. This violates the principle to not repeat yourself. In contrast, we define languages solely by writing an interpreter. The interpreter performs specializations, e.g., augments the interpreted program with type information and profiling information. Compiled code is derived automatically using partial evaluation while incorporating these specializations. This makes partial evaluation practical in the context of dynamic languages: It reduces the size of the compiled code while still compiling all parts of an operation that are relevant for a particular program. When a speculation fails, execution transfers back to the interpreter, the program re-specializes in the interpreter, and later partial evaluation again transforms the new state of the interpreter to compiled code. We evaluate our approach by comparing our implementations of JavaScript, Ruby, and R with best-in-class specialized production implementations. Our general-purpose compilation system is competitive with production systems even when they have been heavily optimized for the one language they support. For our set of benchmarks, our speedup relative to the V8 JavaScript VM is 0.83x, relative to JRuby is 3.8x, and relative to GNU R is 5x.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062381", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Würthinger", + "institution": "" + }, + { + "first_name": "Christian", + "last_name": "Wimmer", + "institution": "Oracle (United States)" + }, + { + "first_name": "Christian", + "last_name": "Humer", + "institution": "" + }, + { + "first_name": "Andreas", + "last_name": "Wöß", + "institution": "" + }, + { + "first_name": "Lukas", + "last_name": "Stadler", + "institution": "" + }, + { + "first_name": "Chris", + "last_name": "Seaton", + "institution": "Oracle (United Kingdom)" + }, + { + "first_name": "Gilles", + "last_name": "Duboscq", + "institution": "" + }, + { + "first_name": "Doug", + "last_name": "Simon", + "institution": "" + }, + { + "first_name": "Matthias", + "last_name": "Grimmer", + "institution": "" + } + ], + "dblp_key": "conf/pldi/WurthingerWHWSS17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062350", + "title": "BigFoot: static check placement for dynamic race detection", + "abstract": "Precise dynamic data race detectors provide strong correctness guarantees but have high overheads because they generally keep analysis state in a separate shadow location for each heap memory location, and they check (and potentially update) the corresponding shadow location on each heap access. The BigFoot dynamic data race detector uses a combination of static and dynamic analysis techniques to coalesce checks and compress shadow locations. With BigFoot, multiple accesses to an object or array often induce a single coalesced check that manipulates a single compressed shadow location, resulting in a performance improvement over FastTrack of 61%.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062350", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dustin", + "last_name": "Rhodes", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "Williams College" + } + ], + "dblp_key": "conf/pldi/RhodesFF17", + "venue": "pldi", + "year": 2017 + }, + { + "paper_id": "10.1145/3062341.3062386", + "title": "DemoMatch: API discovery from demonstrations", + "abstract": "We introduce DemoMatch, a tool for API discovery that allows the user to discover how to implement functionality using a software framework by demonstrating the functionality in existing applications built with the same framework. DemoMatch matches the demonstrations against a database of execution traces called Semeru and generates code snippets explaining how to use the functionality. We evaluated DemoMatch on several case studies involving Java Swing and Eclipse RCP.", + "date": "2017-06-14", + "link": "https://doi.org/10.1145/3062341.3062386", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kuat", + "last_name": "Yessenov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ivan", + "last_name": "Kuraj", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/YessenovKS17", + "venue": "pldi", + "year": 2017 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2018.json b/data/pl_conferences/pldi/2018.json new file mode 100644 index 0000000..4892e82 --- /dev/null +++ b/data/pl_conferences/pldi/2018.json @@ -0,0 +1,1912 @@ +[ + { + "paper_id": "10.1145/3192366.3192418", + "title": "Pinpoint: fast and precise sparse value flow analysis for million lines of code", + "abstract": "When dealing with millions of lines of code, we still cannot have the cake and eat it: sparse value-flow analysis is powerful in checking source-sink problems, but existing work cannot escape from the “pointer trap” – a precise points-to analysis limits its scalability and an imprecise one seriously undermines its precision. We present Pinpoint, a holistic approach that decomposes the cost of high-precision points-to analysis by precisely discovering local data dependence and delaying the expensive inter-procedural analysis through memorization. Such memorization enables the on-demand slicing of only the necessary inter-procedural data dependence and path feasibility queries, which are then solved by a costly SMT solver. Experiments show that Pinpoint can check programs such as MySQL (around 2 million lines of code) within 1.5 hours. The overall false positive rate is also very low (14.3% - 23.6%). Pinpoint has discovered over forty real bugs in mature and extensively checked open source systems. And the implementation of Pinpoint and all experimental results are freely available.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192418", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qingkai", + "last_name": "Shi", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Xiao", + "last_name": "Xiao", + "institution": "" + }, + { + "first_name": "Rongxin", + "last_name": "Wu", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Jinguo", + "last_name": "Zhou", + "institution": "" + }, + { + "first_name": "Gang", + "last_name": "Fan", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/pldi/ShiXWZFZ18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192413", + "title": "Partial control-flow linearization", + "abstract": "If-conversion is a fundamental technique for vectorization. It accounts for the fact that in a SIMD program, several targets of a branch might be executed because of divergence. Especially for irregular data-parallel workloads, it is crucial to avoid if-converting non-divergent branches to increase SIMD utilization. In this paper, we present partial linearization, a simple and efficient if-conversion algorithm that overcomes several limitations of existing if-conversion techniques. In contrast to prior work, it has provable guarantees on which non-divergent branches are retained and will never duplicate code or insert additional branches. We show how our algorithm can be used in a classic loop vectorizer as well as to implement data-parallel languages such as ISPC or OpenCL. Furthermore, we implement prior vectorizer optimizations on top of partial linearization in a more general way. We evaluate the implementation of our algorithm in LLVM on a range of irregular data analytics kernels, a neutronics simulation benchmark and NAB, a molecular dynamics benchmark from SPEC2017 on AVX2, AVX512, and ARM Advanced SIMD machines and report speedups of up to 146 % over ICC, GCC and Clang O3.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192413", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Simon", + "last_name": "Moll", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/pldi/MollH18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192400", + "title": "Bayonet: probabilistic inference for networks", + "abstract": "Network operators often need to ensure that important probabilistic properties are met, such as that the probability of network congestion is below a certain threshold. Ensuring such properties is challenging and requires both a suitable language for probabilistic networks and an automated procedure for answering probabilistic inference queries.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192400", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Petar", + "last_name": "Tsankov", + "institution": "ETH Zurich" + }, + { + "first_name": "Laurent", + "last_name": "Vanbever", + "institution": "ETH Zurich" + }, + { + "first_name": "Pascal", + "last_name": "Wiesmann", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/GehrMTVWV18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192405", + "title": "Advanced automata-based algorithms for program termination checking", + "abstract": "In 2014, Heizmann et al. proposed a novel framework for program termination analysis. The analysis starts with a termination proof of a sample path. The path is generalized to a Büchi automaton (BA) whose language (by construction) represents a set of terminating paths. All these paths can be safely removed from the program. The removal of paths is done using automata difference, implemented via BA complementation and intersection. The analysis constructs in this way a set of BAs that jointly \"cover\" the behavior of the program, thus proving its termination. An implementation of the approach in Ultimate Automizer won the 1st place in the Termination category of SV-COMP 2017.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192405", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yu‐Fang", + "last_name": "Chen", + "institution": "National Taipei University" + }, + { + "first_name": "Matthias", + "last_name": "Heizmann", + "institution": "University of Freiburg" + }, + { + "first_name": "Ondřej", + "last_name": "Lengál", + "institution": "Brno University of Technology" + }, + { + "first_name": "Yong", + "last_name": "Li", + "institution": "Institute of Software" + }, + { + "first_name": "Ming-Hsien", + "last_name": "Tsai", + "institution": "Academia Sinica" + }, + { + "first_name": "Andrea", + "last_name": "Turrini", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Lijun", + "last_name": "Zhang", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "conf/pldi/ChenHLLTTZ18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192397", + "title": "GPU code optimization using abstract kernel emulation and sensitivity analysis", + "abstract": "In this paper, we develop an approach to GPU kernel optimization by focusing on identification of bottleneck resources and determining optimization parameters that can alleviate the bottleneck. Performance modeling for GPUs is done by abstract kernel emulation along with latency/gap modeling of resources. Sensitivity analysis with respect to resource latency/gap parameters is used to predict the bottleneck resource for a given kernel's execution. The utility of the bottleneck analysis is demonstrated in two contexts: 1) Coupling the new bottleneck-driven optimization strategy with the OpenTuner auto-tuner: experimental results on all kernels from the Rodinia suite and GPU tensor contraction kernels from the NWChem computational chemistry suite demonstrate effectiveness. 2) Manual code optimization: two case studies illustrate the use of the bottleneck analysis to iteratively improve the performance of code from state-of-the-art domain-specific code generators.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192397", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Changwan", + "last_name": "Hong", + "institution": "The Ohio State University" + }, + { + "first_name": "Aravind", + "last_name": "Sukumaran-Rajam", + "institution": "The Ohio State University" + }, + { + "first_name": "Jinsung", + "last_name": "Kim", + "institution": "The Ohio State University" + }, + { + "first_name": "Prashant Singh", + "last_name": "Rawat", + "institution": "The Ohio State University" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Colorado State University" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Université Grenoble Alpes" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/HongSKRKPRS18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192374", + "title": "HHVM JIT: a profile-guided, region-based compiler for PHP and Hack", + "abstract": "Dynamic languages such as PHP, JavaScript, Python, and Ruby have been gaining popularity over the last two decades. A very popular domain for these languages is web development, including server-side development of large-scale websites. As a result, improving the performance of these languages has become more important. Efficiently compiling programs in these languages is challenging, and many popular dynamic languages still lack efficient production-quality implementations. This paper describes the design of the second generation of the HHVM JIT and how it addresses the challenges to efficiently execute PHP and Hack programs. This new design uses profiling to build an aggressive region-based JIT compiler. We discuss the benefits of this approach compared to the more popular method-based and trace-based approaches to compile dynamic languages. Our evaluation running a very large PHP-based code base, the Facebook website, demonstrates the effectiveness of the new JIT design.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192374", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guilherme", + "last_name": "Ottoni", + "institution": "Meta (United States)" + } + ], + "dblp_key": "conf/pldi/Ottoni18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192410", + "title": "Accelerating search-based program synthesis using learned probabilistic models", + "abstract": "A key challenge in program synthesis concerns how to efficiently search for the desired program in the space of possible programs. We propose a general approach to accelerate search-based program synthesis by biasing the search towards likely programs. Our approach targets a standard formulation, syntax-guided synthesis (SyGuS), by extending the grammar of possible programs with a probabilistic model dictating the likelihood of each program. We develop a weighted search algorithm to efficiently enumerate programs in order of their likelihood. We also propose a method based on transfer learning that enables to effectively learn a powerful model, called probabilistic higher-order grammar, from known solutions in a domain. We have implemented our approach in a tool called Euphony and evaluate it on SyGuS benchmark problems from a variety of domains. We show that Euphony can learn good models using easily obtainable solutions, and achieves significant performance gains over existing general-purpose as well as domain-specific synthesizers.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192410", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Woosuk", + "last_name": "Lee", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Kihong", + "last_name": "Heo", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/LeeHAN18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192421", + "title": "Bounding data races in space and time", + "abstract": "We propose a new semantics for shared-memory parallel programs that gives strong guarantees even in the presence of data races. Our local data race freedom property guarantees that all data-race-free portions of programs exhibit sequential semantics. We provide a straightforward operational semantics and an equivalent axiomatic model, and evaluate an implementation for the OCaml programming language. Our evaluation demonstrates that it is possible to balance a comprehensible memory model with a reasonable (no overhead on x86, ~0.6% on ARM) sequential performance trade-off in a mainstream programming language.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192421", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stephen K.", + "last_name": "Dolan", + "institution": "University of Cambridge" + }, + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "University of Cambridge" + }, + { + "first_name": "Anil", + "last_name": "Madhavapeddy", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/pldi/DolanSM18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192402", + "title": "Locality analysis through static parallel sampling", + "abstract": "Locality analysis is important since accessing memory is much slower than computing. Compile-time locality analysis can provide detailed program-level feedback for compilers or runtime systems faster than trace-based locality analysis.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192402", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dong", + "last_name": "Chen", + "institution": "University of Rochester" + }, + { + "first_name": "Fangzhou", + "last_name": "Liu", + "institution": "University of Rochester" + }, + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + }, + { + "first_name": "Sreepathi", + "last_name": "Pai", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/pldi/ChenLDP18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192395", + "title": "Symbolic reasoning for automatic signal placement", + "abstract": "Explicit signaling between threads is a perennial cause of bugs in concurrent programs. While there are several run-time techniques to automatically notify threads upon the availability of some shared resource, such techniques are not widely-adopted due to their run-time overhead. This paper proposes a new solution based on static analysis for automatically generating a performant explicit-signal program from its corresponding implicit-signal implementation. The key idea is to generate verification conditions that allow us to minimize the number of required signals and unnecessary context switches, while guaranteeing semantic equivalence between the source and target programs. We have implemented our method in a tool called Expresso and evaluate it on challenging benchmarks from prior papers and open-source software. Expresso-generated code significantly outperforms past automatic signaling mechanisms (avg. 1.56x speedup) and closely matches the performance of hand-optimized explicit-signal code.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192395", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kostas", + "last_name": "Ferles", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Jacob Van", + "last_name": "Geffen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/pldi/FerlesGDS18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192407", + "title": "Verifying that web pages have accessible layout", + "abstract": "Usability and accessibility guidelines aim to make graphical user interfaces accessible to all users, by, say, requiring that text is sufficiently large, interactive controls are visible, and heading size corresponds to importance. These guidelines must hold on the infinitely many possible renderings of a web page generated by differing screen sizes, fonts, and other user preferences. Today, these guidelines are tested by manual inspection of a few renderings, because 1) the guidelines are not expressed in a formal language, 2) the semantics of browser rendering are not well understood, and 3) no tools exist to check all possible renderings of a web page. VizAssert solves these problems. First, it introduces visual logic to precisely specify accessibility properties. Second, it formalizes a large fragment of the browser rendering algorithm using novel finitization reductions. Third, it provides a sound, automated tool for verifying assertions in visual logic.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192407", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Washington" + }, + { + "first_name": "Adam T.", + "last_name": "Geller", + "institution": "University of Washington" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Shoaib", + "last_name": "Kamil", + "institution": "Adobe Systems (United States)" + } + ], + "dblp_key": "conf/pldi/PanchekhaGETK18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192394", + "title": "Bounded expectations: resource analysis for probabilistic programs", + "abstract": "This paper presents a new static analysis for deriving upper bounds on the expected resource consumption of probabilistic programs. The analysis is fully automatic and derives symbolic bounds that are multivariate polynomials in the inputs. The new technique combines manual state-of-the-art reasoning techniques for probabilistic programs with an effective method for automatic resource-bound analysis of deterministic programs. It can be seen as both, an extension of automatic amortized resource analysis (AARA) to probabilistic programs and an automation of manual reasoning for probabilistic programs that is based on weakest preconditions. An advantage of the technique is that it combines the clarity and compositionality of a weakest-precondition calculus with the efficient automation of AARA. As a result, bound inference can be reduced to off-the-shelf LP solving in many cases and automatically-derived bounds can be interactively extended with standard program logics if the automation fails. Building on existing work, the soundness of the analysis is proved with respect to an operational semantics that is based on Markov decision processes. The effectiveness of the technique is demonstrated with a prototype implementation that is used to automatically analyze 39 challenging probabilistic programs and randomized algorithms. Experiments indicate that the derived constant factors in the bounds are very precise and even optimal for some programs.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192394", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Van Chan", + "last_name": "Ngo", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Quentin", + "last_name": "Carbonneaux", + "institution": "Yale University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/NgoC018", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192381", + "title": "Certified concurrent abstraction layers", + "abstract": "Concurrent abstraction layers are ubiquitous in modern computer systems because of the pervasiveness of multithreaded programming and multicore hardware. Abstraction layers are used to hide the implementation details (e.g., fine-grained synchronization) and reduce the complex dependencies among components at different levels of abstraction. Despite their obvious importance, concurrent abstraction layers have not been treated formally. This severely limits the applicability of layer-based techniques and makes it difficult to scale verification across multiple concurrent layers.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192381", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Jieung", + "last_name": "Kim", + "institution": "Yale University" + }, + { + "first_name": "Xiongnan", + "last_name": "Wu", + "institution": "Yale University" + }, + { + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" + }, + { + "first_name": "Vilhelm", + "last_name": "Sjöberg", + "institution": "Yale University" + }, + { + "first_name": "Hao", + "last_name": "Chen", + "institution": "Yale University" + }, + { + "first_name": "David", + "last_name": "Costanzo", + "institution": "Yale University" + }, + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/GuSKWKS0CR18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192415", + "title": "Static serializability analysis for causal consistency", + "abstract": "Many distributed databases provide only weak consistency guarantees to reduce synchronization overhead and remain available under network partitions. However, this leads to behaviors not possible under stronger guarantees. Such behaviors can easily defy programmer intuition and lead to errors that are notoriously hard to detect.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192415", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lucas", + "last_name": "Brutschy", + "institution": "ETH Zurich" + }, + { + "first_name": "Dimitar", + "last_name": "Dimitrov", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/BrutschyD0V18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192391", + "title": "Heartbeat scheduling: provable efficiency for nested parallelism", + "abstract": "A classic problem in parallel computing is to take a high-level parallel program written, for example, in nested-parallel style with fork-join constructs and run it efficiently on a real machine. The problem could be considered solved in theory, but not in practice, because the overheads of creating and managing parallel threads can overwhelm their benefits. Developing efficient parallel codes therefore usually requires extensive tuning and optimizations to reduce parallelism just to a point where the overheads become acceptable.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192391", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Université de Strasbourg" + }, + { + "first_name": "Adrien", + "last_name": "Guatto", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/pldi/AcarCGRS18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192380", + "title": "iReplayer: in-situ and identical record-and-replay for multithreaded applications", + "abstract": "Reproducing executions of multithreaded programs is very challenging due to many intrinsic and external non-deterministic factors. Existing RnR systems achieve significant progress in terms of performance overhead, but none targets the in-situ setting, in which replay occurs within the same process as the recording process. Also, most existing work cannot achieve identical replay, which may prevent the reproduction of some errors.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192380", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongyu", + "last_name": "Liu", + "institution": "The University of Texas at San Antonio" + }, + { + "first_name": "Sam", + "last_name": "Silvestro", + "institution": "The University of Texas at San Antonio" + }, + { + "first_name": "Wei", + "last_name": "Wang", + "institution": "The University of Texas at San Antonio" + }, + { + "first_name": "Chen", + "last_name": "Tian", + "institution": "Huawei Technologies (United States)" + }, + { + "first_name": "Tongping", + "last_name": "Liu", + "institution": "The University of Texas at San Antonio" + } + ], + "dblp_key": "conf/pldi/LiuSWTL18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192399", + "title": "Incremental inference for probabilistic programs", + "abstract": "We present a novel approach for approximate sampling in probabilistic programs based on incremental inference. The key idea is to adapt the samples for a program P into samples for a program Q, thereby avoiding the expensive sampling computation for program Q. To enable incremental inference in probabilistic programming, our work: (i) introduces the concept of a trace translator which adapts samples from P into samples of Q, (ii) phrases this translation approach in the context of sequential Monte Carlo (SMC), which gives theoretical guarantees that the adapted samples converge to the distribution induced by Q, and (iii) shows how to obtain a concrete trace translator by establishing a correspondence between the random choices of the two probabilistic programs. We implemented our approach in two different probabilistic programming systems and showed that, compared to methods that sample the program Q from scratch, incremental inference can lead to orders of magnitude increase in efficiency, depending on how closely related P and Q are.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192399", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marco", + "last_name": "Cusumano-Towner", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Benjamin", + "last_name": "Bichsel", + "institution": "ETH Zurich" + }, + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Cusumano-Towner18a", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192379", + "title": "Spatial: a language and compiler for application accelerators", + "abstract": "Industry is increasingly turning to reconfigurable architectures like FPGAs and CGRAs for improved performance and energy efficiency. Unfortunately, adoption of these architectures has been limited by their programming models. HDLs lack abstractions for productivity and are difficult to target from higher level languages. HLS tools are more productive, but offer an ad-hoc mix of software and hardware abstractions which make performance optimizations difficult.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192379", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Koeplinger", + "institution": "Stanford University" + }, + { + "first_name": "Matthew", + "last_name": "Feldman", + "institution": "Stanford University" + }, + { + "first_name": "Raghu", + "last_name": "Prabhakar", + "institution": "Stanford University" + }, + { + "first_name": "Yaqi", + "last_name": "Zhang", + "institution": "Stanford University" + }, + { + "first_name": "Stefan", + "last_name": "Hadjis", + "institution": "Stanford University" + }, + { + "first_name": "Ruben", + "last_name": "Fiszel", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tian", + "last_name": "Zhao", + "institution": "Stanford University" + }, + { + "first_name": "Luigi", + "last_name": "Nardi", + "institution": "Stanford University" + }, + { + "first_name": "Ardavan", + "last_name": "Pedram", + "institution": "Stanford University" + }, + { + "first_name": "Christos", + "last_name": "Kozyrakis", + "institution": "Stanford University" + }, + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/KoeplingerFPZHF18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192367", + "title": "Persistency for synchronization-free regions", + "abstract": "Nascent persistent memory (PM) technologies promise the performance of DRAM with the durability of disk, but how best to integrate them into programming systems remains an open question. Recent work extends language memory models with a persistency model prescribing semantics for updates to PM. These semantics enable programmers to design data structures in PM that are accessed like memory and yet are recoverable upon crash or failure. Alas, we find the semantics and performance of existing approaches unsatisfying. Existing approaches require high-overhead mechanisms, are restricted to certain synchronization constructs, provide incomplete semantics, and/or may recover to state that cannot arise in fault-free execution.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192367", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vaibhav", + "last_name": "Gogte", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Stephan", + "last_name": "Diestelhorst", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "William", + "last_name": "Wang", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Peter M.", + "last_name": "Chen", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Thomas F.", + "last_name": "Wenisch", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/GogteDWNCW18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192388", + "title": "EffectiveSan: type and memory error detection using dynamically typed C/C++", + "abstract": "Low-level programming languages with weak/static type systems, such as C and C++, are vulnerable to errors relating to the misuse of memory at runtime, such as (sub-)object bounds overflows, (re)use-after-free, and type confusion. Such errors account for many security and other undefined behavior bugs for programs written in these languages. In this paper, we introduce the notion of dynamically typed C/C++, which aims to detect such errors by dynamically checking the \"effective type\" of each object before use at runtime. We also present an implementation of dynamically typed C/C++ in the form of the Effective Type Sanitizer (EffectiveSan). EffectiveSan enforces type and memory safety using a combination of low-fat pointers, type meta data and type/bounds check instrumentation. We evaluate EffectiveSan against the SPEC2006 benchmark suite and the Firefox web browser, and detect several new type and memory errors. We also show that EffectiveSan achieves high compatibility and reasonable overheads for the given error coverage. Finally, we highlight that EffectiveSan is one of only a few tools that can detect sub-object bounds errors, and uses a novel approach (dynamic type checking) to do so.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192388", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gregory J.", + "last_name": "Duck", + "institution": "National University of Singapore" + }, + { + "first_name": "Roland H. C.", + "last_name": "Yap", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/pldi/DuckY18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192396", + "title": "On-stack replacement, distilled", + "abstract": "On-stack replacement (OSR) is essential technology for adaptive optimization, allowing changes to code actively executing in a managed runtime. The engineering aspects of OSR are well-known among VM architects, with several implementations available to date. However, OSR is yet to be explored as a general means to transfer execution between related program versions, which can pave the road to unprecedented applications that stretch beyond VMs. We aim at filling this gap with a constructive and provably correct OSR framework, allowing a class of general-purpose transformation functions to yield a special-purpose replacement. We describe and evaluate an implementation of our technique in LLVM. As a novel application of OSR, we present a feasibility study on debugging of optimized code, showing how our techniques can be used to fix variables holding incorrect values at breakpoints due to optimizations.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192396", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniele Cono", + "last_name": "D’Elia", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Camil", + "last_name": "Demetrescu", + "institution": "Sapienza University of Rome" + } + ], + "dblp_key": "conf/pldi/DEliaD18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192378", + "title": "Calling-to-reference context translation via constraint-guided CFL-reachability", + "abstract": "A calling context is an important piece of information used widely to help developers understand program executions (e.g., for debugging). While calling contexts offer useful control information, information regarding data involved in a bug (e.g., what data structure holds a leaking object), in many cases, can bring developers closer to the bug's root cause. Such data information, often exhibited as heap reference paths, has already been needed by many tools.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192378", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cheng", + "last_name": "Cai", + "institution": "University of California, Irvine" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhiqiang", + "last_name": "Zuo", + "institution": "Nanjing University" + }, + { + "first_name": "Khanh", + "last_name": "Nguyen", + "institution": "University of California, Irvine" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Irvine" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/CaiZZNXS18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192368", + "title": "CURD: a dynamic CUDA race detector", + "abstract": "As GPUs have become an integral part of nearly every pro- cessor, GPU programming has become increasingly popular. GPU programming requires a combination of extreme levels of parallelism and low-level programming, making it easy for concurrency bugs such as data races to arise. These con- currency bugs can be extremely subtle and di cult to debug due to the massive numbers of threads running concurrently on a modern GPU. While some tools exist to detect data races in GPU pro- grams, they are often prohibitively slow or focused only on a small class of data races in shared memory. Compared to prior work, our race detector, CURD, can detect data races precisely on both shared and global memory, selects an appropriate race detection algorithm based on the synchronization used in a program, and utilizes efficient compiler instrumentation to reduce performance overheads. Across 53 benchmarks, we find that using CURD incurs an aver- age slowdown of just 2.88x over native execution. CURD is 2.1x faster than Nvidia’s CUDA-Racecheck race detector, de- spite detecting a much broader class of races. CURD finds 35 races across our benchmarks, including bugs in established benchmark suites and in sample programs from Nvidia.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192368", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuanfeng", + "last_name": "Peng", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Vinod", + "last_name": "Grover", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Joseph", + "last_name": "Devietti", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/PengGD18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192403", + "title": "Inferring crypto API rules from code changes", + "abstract": "Creating and maintaining an up-to-date set of security rules that match misuses of crypto APIs is challenging, as crypto APIs constantly evolve over time with new cryptographic primitives and settings, making existing ones obsolete.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192403", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rumen", + "last_name": "Paletov", + "institution": "ETH Zurich" + }, + { + "first_name": "Petar", + "last_name": "Tsankov", + "institution": "ETH Zurich" + }, + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/PaletovTRV18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192375", + "title": "MixT: a language for mixing consistency in geodistributed transactions", + "abstract": "Programming concurrent, distributed systems is hard—especially when these systems mutate shared, persistent state replicated at geographic scale. To enable high availability and scalability, a new class of weakly consistent data stores has become popular. However, some data needs strong consistency. To manipulate both weakly and strongly consistent data in a single transaction, we introduce a new abstraction: mixed-consistency transactions, embodied in a new embedded language, MixT. Programmers explicitly associate consistency models with remote storage sites; each atomic, isolated transaction can access a mixture of data with different consistency models. Compile-time information-flow checking, applied to consistency models, ensures that these models are mixed safely and enables the compiler to automatically partition transactions. New run-time mechanisms ensure that consistency models can also be mixed safely, even when the data used by a transaction resides on separate, mutually unaware stores. Performance measurements show that despite their stronger guarantees, mixed-consistency transactions retain much of the speed of weak consistency, significantly outperforming traditional serializable transactions.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192375", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mae", + "last_name": "Milano", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/MilanoM18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192390", + "title": "D4: fast concurrency debugging with parallel differential analysis", + "abstract": "We present D4, a fast concurrency analysis framework that detects concurrency bugs (e.g., data races and deadlocks) interactively in the programming phase. As developers add, modify, and remove statements, the code changes are sent to D4 to detect concurrency bugs in real time, which in turn provides immediate feedback to the developer of the new bugs. The cornerstone of D4 includes a novel system design and two novel parallel differential algorithms that embrace both change and parallelization for fundamental static analyses of concurrent programs. Both algorithms react to program changes by memoizing the analysis results and only recomputing the impact of a change in parallel. Our evaluation on an extensive collection of large real-world applications shows that D4 efficiently pinpoints concurrency bugs within 100ms on average after a code change, several orders of magnitude faster than both the exhaustive analysis and the state-of-the-art incremental techniques.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192390", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bozhen", + "last_name": "Liu", + "institution": "Texas A&M University" + }, + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/pldi/LiuH18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192373", + "title": "The semantics of transactions and weak memory in x86, Power, ARM, and C++", + "abstract": "Weak memory models provide a complex, system-centric semantics for concurrent programs, while transactional memory (TM) provides a simpler, programmer-centric semantics. Both have been studied in detail, but their combined semantics is not well understood. This is problematic because such widely-used architectures and languages as x86, Power, and C++ all support TM, and all have weak memory models.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192373", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nathan", + "last_name": "Chong", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "Imperial College London" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/pldi/ChongSW18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192392", + "title": "Write-rationing garbage collection for hybrid memories", + "abstract": "Emerging Non-Volatile Memory (NVM) technologies offer high capacity and energy efficiency compared to DRAM, but suffer from limited write endurance and longer latencies. Prior work seeks the best of both technologies by combining DRAM and NVM in hybrid memories to attain low latency, high capacity, energy efficiency, and durability. Coarsegrained hardware and OS optimizations then spread writes out (wear-leveling) and place highly mutated pages in DRAM to extend NVM lifetimes. Unfortunately even with these coarse-grained methods, popular Java applications exact impractical NVM lifetimes of 4 years or less. This paper shows how to make hybrid memories practical, without changing the programming model, by enhancing garbage collection in managed language runtimes. We find object write behaviors offer two opportunities: (1) 70% of writes occur to newly allocated objects, and (2) 2% of objects capture 81% of writes to mature objects. We introduce writerationing garbage collectors that exploit these fine-grained behaviors. They extend NVM lifetimes by placing highly mutated objects in DRAM and read-mostly objects in NVM. We implement two such systems. (1) Kingsguard-nursery places new allocation in DRAM and survivors in NVM, reducing NVM writes by 5× versus NVM only with wear-leveling. (2) Kingsguard-writers (KG-W) places nursery objects in DRAM and survivors in a DRAM observer space. It monitors all mature object writes and moves unwritten mature objects from DRAM to NVM. Because most mature objects are unwritten, KG-W exploits NVM capacity while increasing NVM lifetimes by 11×. It reduces the energy-delay product by 32% over DRAM-only and 29% over NVM-only. This work opens up new avenues for making hybrid memories practical.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192392", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shoaib", + "last_name": "Akram", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Jennifer B.", + "last_name": "Sartor", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Google (United States)" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University Hospital" + } + ], + "dblp_key": "conf/pldi/AkramSME18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192412", + "title": "A general path-based representation for predicting program properties", + "abstract": "Predicting program properties such as names or expression types has a wide range of applications. It can ease the task of programming, and increase programmer productivity. A major challenge when learning from programs is how to represent programs in a way that facilitates effective learning.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192412", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Uri", + "last_name": "Alon", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Meital", + "last_name": "Zilberstein", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Omer", + "last_name": "Levy", + "institution": "University of Washington" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/0002ZLY18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192377", + "title": "Crellvm: verified credible compilation for LLVM", + "abstract": "Production compilers such as GCC and LLVM are large complex software systems, for which achieving a high level of reliability is hard. Although testing is an effective method for finding bugs, it alone cannot guarantee a high level of reliability. To provide a higher level of reliability, many approaches that examine compilers' internal logics have been proposed. However, none of them have been successfully applied to major optimizations of production compilers.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192377", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Seoul National University" + }, + { + "first_name": "Yoonseung", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Seoul National University" + }, + { + "first_name": "Juneyoung", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Sanghoon", + "last_name": "Park", + "institution": "Seoul National University" + }, + { + "first_name": "Mark Dongyeon", + "last_name": "Shin", + "institution": "Seoul National University" + }, + { + "first_name": "Yonghyun", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Sungkeun", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Joonwon", + "last_name": "Choi", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/pldi/KangKSLPSKCCHY18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192387", + "title": "Automated clustering and program repair for introductory programming assignments", + "abstract": "Providing feedback on programming assignments is a tedious task for the instructor, and even impossible in large Massive Open Online Courses with thousands of students. Previous research has suggested that program repair techniques can be used to generate feedback in programming education. In this paper, we present a novel fully automated program repair algorithm for introductory programming assignments. The key idea of the technique, which enables automation and scalability, is to use the existing correct student solutions to repair the incorrect attempts. We evaluate the approach in two experiments: (I) We evaluate the number, size and quality of the generated repairs on 4,293 incorrect student attempts from an existing MOOC. We find that our approach can repair 97% of student attempts, while 81% of those are small repairs of good quality. (II) We conduct a preliminary user study on performance and repair usefulness in an interactive teaching setting. We obtain promising initial results (the average usefulness grade 3.4 on a scale from 1 to 5), and conclude that our approach can be used in an interactive setting.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192387", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ivan", + "last_name": "Radiček", + "institution": "TU Wien" + }, + { + "first_name": "Florian", + "last_name": "Zuleger", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/pldi/GulwaniRZ18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192372", + "title": "Typed closure conversion for the calculus of constructions", + "abstract": "Dependently typed languages such as Coq are used to specify and verify the full functional correctness of source programs. Type-preserving compilation can be used to preserve these specifications and proofs of correctness through compilation into the generated target-language programs. Unfortunately, type-preserving compilation of dependent types is hard. In essence, the problem is that dependent type systems are designed around high-level compositional abstractions to decide type checking, but compilation interferes with the type-system rules for reasoning about run-time terms.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192372", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/BowmanA18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192406", + "title": "VeriPhy: verified controller executables from verified cyber-physical system models", + "abstract": "We present VeriPhy, a verified pipeline which automatically transforms verified high-level models of safety-critical cyber-physical systems (CPSs) in differential dynamic logic (dL) to verified controller executables. VeriPhy proves that all safety results are preserved end-to-end as it bridges abstraction gaps, including: i) the gap between mathematical reals in physical models and machine arithmetic in the implementation, ii) the gap between real physics and its differential-equation models, and iii) the gap between nondeterministic controller models and machine code. VeriPhy reduces CPS safety to the faithfulness of the physical environment, which is checked at runtime by synthesized, verified monitors. We use three provers in this effort: KeYmaera X, HOL4, and Isabelle/HOL. To minimize the trusted base, we cross-verify KeYmaeraX in Isabelle/HOL. We evaluate the resulting controller and monitors on commodity robotics hardware.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192406", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rose", + "last_name": "Bohrer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yong Kiam", + "last_name": "Tan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stefan", + "last_name": "Mitsch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "André", + "last_name": "Platzer", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/BohrerTMMP18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192386", + "title": "Enhancing computation-to-core assignment with physical location information", + "abstract": "Going beyond a certain number of cores in modern architectures requires an on-chip network more scalable than conventional buses. However, employing an on-chip network in a manycore system (to improve scalability) makes the latencies of the data accesses issued by a core non-uniform. This non-uniformity can play a significant role in shaping the overall application performance. This work presents a novel compiler strategy which involves exposing architecture information to the compiler to enable an optimized computation-to-core mapping. Specifically, we propose a compiler-guided scheme that takes into account the relative positions of (and distances between) cores, last-level caches (LLCs) and memory controllers (MCs) in a manycore system, and generates a mapping of computations to cores with the goal of minimizing the on-chip network traffic. The experimental data collected using a set of 21 multi-threaded applications reveal that, on an average, our approach reduces the on-chip network latency in a 6×6 manycore system by 38.4% in the case of private LLCs, and 43.8% in the case of shared LLCs. These improvements translate to the corresponding execution time improvements of 10.9% and 12.7% for the private LLC and shared LLC based systems, respectively.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192386", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Orhan", + "last_name": "Kislal", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Jagadish", + "last_name": "Kotra", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Xulong", + "last_name": "Tang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Myoungsoo", + "last_name": "Jung", + "institution": "Yonsei University" + } + ], + "dblp_key": "conf/pldi/KislalKTKJ18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192419", + "title": "CUBA: interprocedural Context-UnBounded Analysis of concurrent programs", + "abstract": "A classical result by Ramalingam about synchronization-sensitive interprocedural program analysis implies that reachability for concurrent threads running recursive procedures is undecidable. A technique proposed by Qadeer and Rehof, to bound the number of context switches allowed between the threads, leads to an incomplete solution that is, however, believed to catch “most bugs” in practice. The question whether the technique can also prove the absence of bugs at least in some cases has remained largely open.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192419", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peizun", + "last_name": "Liu", + "institution": "Northeastern University" + }, + { + "first_name": "Thomas", + "last_name": "Wahl", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/LiuW18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192409", + "title": "Probabilistic programming with programmable inference", + "abstract": "We introduce inference metaprogramming for probabilistic programming languages, including new language constructs, a formalism, and the rst demonstration of e ectiveness in practice. Instead of relying on rigid black-box inference algorithms hard-coded into the language implementation as in previous probabilistic programming languages, infer- ence metaprogramming enables developers to 1) dynamically decompose inference problems into subproblems, 2) apply in- ference tactics to subproblems, 3) alternate between incorpo- rating new data and performing inference over existing data, and 4) explore multiple execution traces of the probabilis- tic program at once. Implemented tactics include gradient- based optimization, Markov chain Monte Carlo, variational inference, and sequental Monte Carlo techniques. Inference metaprogramming enables the concise expression of proba- bilistic models and inference algorithms across diverse elds, such as computer vision, data science, and robotics, within a single probabilistic programming language.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192409", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ulrich", + "last_name": "Schaechtle", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Shivam", + "last_name": "Handa", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Alexey", + "last_name": "Radul", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Yutian", + "last_name": "Chen", + "institution": "Google (United Kingdom)" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/MansinghkaSHRCR18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192370", + "title": "Putting in all the stops: execution control for JavaScript", + "abstract": "Scores of compilers produce JavaScript, enabling programmers to use many languages on the Web, reuse existing code, and even use Web IDEs. Unfortunately, most compilers inherit the browser's compromised execution model, so long-running programs freeze the browser tab, infinite loops crash IDEs, and so on. The few compilers that avoid these problems suffer poor performance and are difficult to engineer.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192370", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "S.", + "last_name": "Baxter", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Rachit", + "last_name": "Nigam", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Joe Gibbs", + "last_name": "Politz", + "institution": "University of California, San Diego" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "John Brown University" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/BaxterNPKG18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192369", + "title": "Ryū: fast float-to-string conversion", + "abstract": "We present Ryū, a new routine to convert binary floating point numbers to their decimal representations using only fixed-size integer operations, and prove its correctness. Ryū is simpler and approximately three times faster than the previously fastest implementation.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192369", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ulf", + "last_name": "Adams", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Adams18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192383", + "title": "Active learning of points-to specifications", + "abstract": "When analyzing programs, large libraries pose significant challenges to static points-to analysis. A popular solution is to have a human analyst provide points-to specifications that summarize relevant behaviors of library code, which can substantially improve precision and handle missing code such as native code. We propose Atlas, a tool that automatically infers points-to specifications. Atlas synthesizes unit tests that exercise the library code, and then infers points-to specifications based on observations from these executions. Atlas automatically infers specifications for the Java standard library, and produces better results for a client static information flow analysis on a benchmark of 46 Android apps compared to using existing handwritten specifications.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192383", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "Stanford University" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Percy", + "last_name": "Liang", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/Bastani0AL18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192382", + "title": "Program synthesis using conflict-driven learning", + "abstract": "We propose a new conflict-driven program synthesis technique that is capable of learning from past mistakes. Given a spurious program that violates the desired specification, our synthesis algorithm identifies the root cause of the conflict and learns new lemmas that can prevent similar mistakes in the future. Specifically, we introduce the notion of equivalence modulo conflict and show how this idea can be used to learn useful lemmas that allow the synthesizer to prune large parts of the search space. We have implemented a general-purpose CDCL-style program synthesizer called Neo and evaluate it in two different application domains, namely data wrangling in R and functional programming over lists. Our experiments demonstrate the substantial benefits of conflict-driven learning and show that Neo outperforms two state-of-the-art synthesis tools, Morpheus and Deepcoder, that target these respective domains.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192382", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ruben", + "last_name": "Martins", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/FengMBD18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192404", + "title": "Gluon: a communication-optimizing substrate for distributed heterogeneous graph analytics", + "abstract": "This paper introduces a new approach to building distributed-memory graph analytics systems that exploits heterogeneity in processor types (CPU and GPU), partitioning policies, and programming models. The key to this approach is Gluon, a communication-optimizing substrate.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192404", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Roshan", + "last_name": "Dathathri", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Gurbinder", + "last_name": "Gill", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Loc", + "last_name": "Hoang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Hoang-Vu", + "last_name": "Dang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Alex", + "last_name": "Brooks", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Nikoli", + "last_name": "Dryden", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Marc", + "last_name": "Snir", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/DathathriGHDBDS18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192401", + "title": "Polyhedral auto-transformation with no integer linear programming", + "abstract": "State-of-the-art algorithms used in automatic polyhedral transformation for parallelization and locality optimization typically rely on Integer Linear Programming (ILP). This poses a scalability issue when scaling to tens or hundreds of statements, and may be disconcerting in production compiler settings. In this work, we consider relaxing integrality in the ILP formulation of the Pluto algorithm, a popular algorithm used to find good affine transformations. We show that the rational solutions obtained from the relaxed LP formulation can easily be scaled to valid integral ones to obtain desired solutions, although with some caveats. We first present formal results connecting the solution of the relaxed LP to the original Pluto ILP. We then show that there are difficulties in realizing the above theoretical results in practice, and propose an alternate approach to overcome those while still leveraging linear programming. Our new approach obtains dramatic compile-time speedups for a range of large benchmarks. While achieving these compile-time improvements, we show that the performance of the transformed code is not sacrificed. Our approach to automatic transformation provides a mean compilation time improvement of 5.6× over state-of-the-art on relevant challenging benchmarks from the NAS PB, SPEC CPU 2006, and PolyBench suites. We also came across situations where prior frameworks failed to find a transformation in a reasonable amount of time, while our new approach did so instantaneously.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192401", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aravind", + "last_name": "Acharya", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Uday", + "last_name": "Bondhugula", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/AcharyaB018", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192385", + "title": "High-coverage, unbounded sound predictive race detection", + "abstract": "Dynamic program analysis can predict data races knowable from an observed execution, but existing predictive analyses either miss races or cannot analyze full program executions. This paper presents Vindicator, a novel, sound (no false races) predictive approach that finds more data races than existing predictive approaches. Vindicator achieves high coverage by using a new, efficient analysis that finds all possible predictable races but may detect false races. Vindicator ensures soundness using a novel algorithm that checks each potential race to determine whether it is a true predictable race. An evaluation using large Java programs shows that Vindicator finds hard-to-detect predictable races that existing sound predictive analyses miss, at a comparable performance cost.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192385", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jake", + "last_name": "Roemer", + "institution": "The Ohio State University" + }, + { + "first_name": "Kaan", + "last_name": "Genç", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/RoemerGB18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192417", + "title": "User-guided program reasoning using Bayesian inference", + "abstract": "Program analyses necessarily make approximations that often lead them to report true alarms interspersed with many false alarms. We propose a new approach to leverage user feedback to guide program analyses towards true alarms and away from false alarms. Our approach associates each alarm with a confidence value by performing Bayesian inference on a probabilistic model derived from the analysis rules. In each iteration, the user inspects the alarm with the highest confidence and labels its ground truth, and the approach recomputes the confidences of the remaining alarms given this feedback. It thereby maximizes the return on the effort by the user in inspecting each alarm. We have implemented our approach in a tool named Bingo for program analyses expressed in Datalog. Experiments with real users and two sophisticated analyses---a static datarace analysis for Java programs and a static taint analysis for Android apps---show significant improvements on a range of metrics, including false alarm rates and number of bugs found.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192417", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Sulekha", + "last_name": "Kulkarni", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Kihong", + "last_name": "Heo", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/RaghothamanKHN18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192411", + "title": "Finding root causes of floating point error", + "abstract": "Floating-point arithmetic plays a central role in science, engineering, and finance by enabling developers to approximate real arithmetic. To address numerical issues in large floating-point applications, developers must identify root causes, which is difficult because floating-point errors are generally non-local, non-compositional, and non-uniform.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192411", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alex", + "last_name": "Sanchez-Stern", + "institution": "University of California, San Diego" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Washington" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/Sanchez-SternPL18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192371", + "title": "Mapping spiking neural networks onto a manycore neuromorphic architecture", + "abstract": "We present a compiler for Loihi, a novel manycore neuromorphic processor that features a programmable, on-chip learning engine for training and executing spiking neural networks (SNNs). An SNN is distinguished from other neural networks in that (1) its independent computing units, or \"neurons\", communicate with others only through spike messages; and (2) each neuron evaluates local learning rules, which are functions of spike arrival and departure timings, to modify its local state. The collective neuronal state dynamics of an SNN form a nonlinear dynamical system that can be cast as an unconventional model of computation. To realize such an SNN on Loihi requires each constituent neuron to locally store and independently update its own spike timing information. However, each Loihi core has limited resources for this purpose and these must be shared by neurons assigned to the same core. In this work, we present a compiler for Loihi that maps the neurons of an SNN onto and across Loihi's cores efficiently. We show that a poor neuron-to-core mapping can incur significant energy costs and address this with a greedy algorithm that compiles SNNs onto Loihi in a power-efficient manner. In so doing, we highlight the need for further development of compilers for this new, emerging class of architectures.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192371", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chit-Kwan", + "last_name": "Lin", + "institution": "Intel (United States)" + }, + { + "first_name": "Andreas", + "last_name": "Wild", + "institution": "Intel (United States)" + }, + { + "first_name": "Gautham N.", + "last_name": "Chinya", + "institution": "Intel (United States)" + }, + { + "first_name": "Tsung-Han", + "last_name": "Lin", + "institution": "Intel (United States)" + }, + { + "first_name": "Mike", + "last_name": "Davies", + "institution": "Intel (United States)" + }, + { + "first_name": "Hong", + "last_name": "Wang", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/LinWCLDW18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192389", + "title": "Guarded impredicative polymorphism", + "abstract": "The design space for type systems that support impredicative instantiation is extremely complicated. One needs to strike a balance between expressiveness, simplicity for both the end programmer and the type system implementor, and how easily the system can be integrated with other advanced type system concepts. In this paper, we propose a new point in the design space, which we call guarded impredicativity. Its key idea is that impredicative instantiation in an application is allowed for type variables that occur under a type constructor. The resulting type system has a clean declarative specification — making it easy for programmers to predict what will type and what will not —, allows for a smooth integration with GHC’s OutsideIn(X) constraint solving framework, while giving up very little in terms of expressiveness compared to systems like HMF, HML, FPH and MLF. We give a sound and complete inference algorithm, and prove a principal type property for our system.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192389", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Serrano", + "institution": "Utrecht University" + }, + { + "first_name": "Jurriaan", + "last_name": "Hage", + "institution": "Utrecht University" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/SerranoHVJ18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192398", + "title": "Inferring type rules for syntactic sugar", + "abstract": "Type systems and syntactic sugar are both valuable to programmers, but sometimes at odds. While sugar is a valuable mechanism for implementing realistic languages, the expansion process obscures program source structure. As a result, type errors can reference terms the programmers did not write (and even constructs they do not know), baffling them. The language developer must also manually construct type rules for the sugars, to give a typed account of the surface language. We address these problems by presenting a process for automatically reconstructing type rules for the surface language using rules for the core. We have implemented this theory, and show several interesting case studies.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192398", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Justin", + "last_name": "Pombrio", + "institution": "John Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/pldi/PombrioK18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192408", + "title": "PMAF: an algebraic framework for static analysis of probabilistic programs", + "abstract": "Automatically establishing that a probabilistic program satisfies some property ϕ is a challenging problem. While a sampling-based approach—which involves running the program repeatedly—can suggest that ϕ holds, to establish that the program satisfies ϕ, analysis techniques must be used. Despite recent successes, probabilistic static analyses are still more difficult to design and implement than their deterministic counterparts. This paper presents a framework, called PMAF, for designing, implementing, and proving the correctness of static analyses of probabilistic programs with challenging features such as recursion, unstructured control-flow, divergence, nondeterminism, and continuous distributions. PMAF introduces pre-Markov algebras to factor out common parts of different analyses. To perform interprocedural analysis and to create procedure summaries, PMAF extends ideas from non-probabilistic interprocedural dataflow analysis to the probabilistic setting. One novelty is that PMAF is based on a semantics formulated in terms of a control-flow hyper-graph for each procedure, rather than a standard control-flow graph. To evaluate its effectiveness, PMAF has been used to reformulate and implement existing intraprocedural analyses for Bayesian-inference and the Markov decision problem, by creating corresponding interprocedural analyses. Additionally, PMAF has been used to implement a new interprocedural linear expectation-invariant analysis. Experiments with benchmark programs for the three analyses demonstrate that the approach is practical.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192408", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "GrammaTech (United States)" + } + ], + "dblp_key": "conf/pldi/WangHR18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192376", + "title": "BLeak: automatically debugging memory leaks in web applications", + "abstract": "Despite the presence of garbage collection in managed languages like JavaScript, memory leaks remain a serious problem. In the context of web applications, these leaks are especially pervasive and difficult to debug. Web application memory leaks can take many forms, including failing to dispose of unneeded event listeners, repeatedly injecting iframes and CSS files, and failing to call cleanup routines in third-party libraries. Leaks degrade responsiveness by increasing GC frequency and overhead, and can even lead to browser tab crashes by exhausting available memory. Because previous leak detection approaches designed for conventional C, C++ or Java applications are ineffective in the browser environment, tracking down leaks currently requires intensive manual effort by web developers.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192376", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John", + "last_name": "Vilk", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/VilkB18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192416", + "title": "A data-driven CHC solver", + "abstract": "We present a data-driven technique to solve Constrained Horn Clauses (CHCs) that encode verification conditions of programs containing unconstrained loops and recursions. Our CHC solver neither constrains the search space from which a predicate's components are inferred (e.g., by constraining the number of variables or the values of coefficients used to specify an invariant), nor fixes the shape of the predicate itself (e.g., by bounding the number and kind of logical connectives). Instead, our approach is based on a novel machine learning-inspired tool chain that synthesizes CHC solutions in terms of arbitrary Boolean combinations of unrestricted atomic predicates. A CEGAR-based verification loop inside the solver progressively samples representative positive and negative data from recursive CHCs, which is fed to the machine learning tool chain. Our solver is implemented as an LLVM pass in the SeaHorn verification framework and has been used to successfully verify a large number of nontrivial and challenging C programs from the literature and well-known benchmark suites (e.g., SV-COMP).", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192416", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "He", + "last_name": "Zhu", + "institution": "Galois (United States)" + }, + { + "first_name": "S.", + "last_name": "Magill", + "institution": "Galois (United States)" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/ZhuMJ18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192384", + "title": "Search, align, and repair: data-driven feedback generation for introductory programming exercises", + "abstract": "This paper introduces the “Search, Align, and Repair” data-driven program repair framework to automate feedback generation for introductory programming exercises. Distinct from existing techniques, our goal is to develop an efficient, fully automated, and problem-agnostic technique for large or MOOC-scale introductory programming courses. We leverage the large amount of available student submissions in such settings and develop new algorithms for identifying similar programs, aligning correct and incorrect programs, and repairing incorrect programs by finding minimal fixes. We have implemented our technique in the Sarfgen system and evaluated it on thousands of real student attempts from the Microsoft-DEV204.1x edX course and the Microsoft CodeHunt platform. Our results show that Sarfgen can, within two seconds on average, generate concise, useful feedback for 89.7% of the incorrect student submissions. It has been integrated with the Microsoft-DEV204.1X edX class and deployed for production use.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192384", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "University of California, Davis" + }, + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/WangSS18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192414", + "title": "Modularity for decidability of deductive verification with applications to distributed systems", + "abstract": "Proof automation can substantially increase productivity in formal verification of complex systems. However, unpredictablility of automated provers in handling quantified formulas presents a major hurdle to usability of these tools. We propose to solve this problem not by improving the provers, but by using a modular proof methodology that allows us to produce decidable verification conditions. Decidability greatly improves predictability of proof automation, resulting in a more practical verification approach. We apply this methodology to develop verified implementations of distributed protocols, demonstrating its effectiveness.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192414", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marcelo", + "last_name": "Taube", + "institution": "Tel Aviv University" + }, + { + "first_name": "Giuliano", + "last_name": "Losa", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Kenneth L.", + "last_name": "McMillan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "University of Washington" + }, + { + "first_name": "Doug", + "last_name": "Woos", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/TaubeLMPSSWW18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192420", + "title": "To-many or to-one? all-in-one! efficient purely functional multi-maps with type-heterogeneous hash-tries", + "abstract": "An immutable multi-map is a many-to-many map data structure with expected fast insert and lookup operations. This data structure is used for applications processing graphs or many-to-many relations as applied in compilers, runtimes of programming languages, or in static analysis of object-oriented systems. Collection data structures are assumed to carefully balance execution time of operations with memory consumption characteristics and need to scale gracefully from a few elements to multiple gigabytes at least. When processing larger in-memory data sets the overhead of the data structure encoding itself becomes a memory usage bottleneck, dominating the overall performance.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192420", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael J.", + "last_name": "Steindorfer", + "institution": "Delft University of Technology" + }, + { + "first_name": "Jurgen", + "last_name": "Vinju", + "institution": "Eindhoven University of Technology" + } + ], + "dblp_key": "conf/pldi/SteindorferV18", + "venue": "pldi", + "year": 2018 + }, + { + "paper_id": "10.1145/3192366.3192393", + "title": "SWOOP: software-hardware co-design for non-speculative, execute-ahead, in-order cores", + "abstract": "Increasing demands for energy efficiency constrain emerging hardware. These new hardware trends challenge the established assumptions in code generation and force us to rethink existing software optimization techniques. We propose a cross-layer redesign of the way compilers and the underlying microarchitecture are built and interact, to achieve both performance and high energy efficiency.", + "date": "2018-06-11", + "link": "https://doi.org/10.1145/3192366.3192393", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kim-Anh", + "last_name": "Tran", + "institution": "Uppsala University" + }, + { + "first_name": "Alexandra", + "last_name": "Jimborean", + "institution": "Uppsala University" + }, + { + "first_name": "Trevor E.", + "last_name": "Carlson", + "institution": "National University of Singapore" + }, + { + "first_name": "Konstantinos", + "last_name": "Koukos", + "institution": "Uppsala University" + }, + { + "first_name": "Magnus", + "last_name": "Själander", + "institution": "NTNU Samfunnsforskning" + }, + { + "first_name": "Stefanos", + "last_name": "Kaxiras", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/pldi/TranJCKSK18", + "venue": "pldi", + "year": 2018 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2019.json b/data/pl_conferences/pldi/2019.json new file mode 100644 index 0000000..ad529fd --- /dev/null +++ b/data/pl_conferences/pldi/2019.json @@ -0,0 +1,2620 @@ +[ + { + "paper_id": "10.1145/3314221.3314648", + "title": "Scalable taint specification inference with big code", + "abstract": "We present a new scalable, semi-supervised method for inferring taint analysis specifications by learning from a large dataset of programs. Taint specifications capture the role of library APIs (source, sink, sanitizer) and are a critical ingredient of any taint analyzer that aims to detect security violations based on information flow.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314648", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Victor", + "last_name": "Chibotaru", + "institution": "" + }, + { + "first_name": "Benjamin", + "last_name": "Bichsel", + "institution": "ETH Zurich" + }, + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/ChibotaruBRV19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314645", + "title": "Sound regular expression semantics for dynamic symbolic execution of JavaScript", + "abstract": "Support for regular expressions in symbolic execution-based tools for test generation and bug finding is insufficient. Common aspects of mainstream regular expression engines, such as backreferences or greedy matching, are ignored or imprecisely approximated, leading to poor test coverage or missed bugs. In this paper, we present a model for the complete regular expression language of ECMAScript 2015 (ES6), which is sound for dynamic symbolic execution of the test and exec functions. We model regular expression operations using string constraints and classical regular expressions and use a refinement scheme to address the problem of matching precedence and greediness. We implemented our model in ExpoSE, a dynamic symbolic execution engine for JavaScript, and evaluated it on over 1,000 Node.js packages containing regular expressions, demonstrating that the strategy is effective and can significantly increase the number of successful regular expression queries and therefore boost coverage.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314645", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Blake", + "last_name": "Loring", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Duncan", + "last_name": "Mitchell", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Johannes", + "last_name": "Kinder", + "institution": "Universität der Bundeswehr München" + } + ], + "dblp_key": "conf/pldi/LoringMK19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314616", + "title": "Continuously reasoning about programs using differential Bayesian inference", + "abstract": "Programs often evolve by continuously integrating changes from multiple programmers. The effective adoption of program analysis tools in this continuous integration setting is hindered by the need to only report alarms relevant to a particular program change. We present a probabilistic framework, Drake, to apply program analyses to continuously evolving programs. Drake is applicable to a broad range of analyses that are based on deductive reasoning. The key insight underlying Drake is to compute a graph that concisely and precisely captures differences between the derivations of alarms produced by the given analysis on the program before and after the change. Performing Bayesian inference on the graph thereby enables to rank alarms by likelihood of relevance to the change. We evaluate Drake using Sparrow—a static analyzer that targets buffer-overrun, format-string, and integer-overflow errors—on a suite of ten widely-used C programs each comprising 13k–112k lines of code. Drake enables to discover all true bugs by inspecting only 30 alarms per benchmark on average, compared to 85 (3× more) alarms by the same ranking approach in batch mode, and 118 (4× more) alarms by a differential approach based on syntactic masking of alarms which also misses 4 of the 26 bugs overall.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314616", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kihong", + "last_name": "Heo", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Xujie", + "last_name": "Si", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/HeoRSN19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314632", + "title": "Effective floating-point analysis via weak-distance minimization", + "abstract": "This work studies the connection between the problem of analyzing floating-point code and that of function minimization. It formalizes this connection as a reduction theory, where the semantics of a floating-point program is measured as a generalized metric, called weak distance, which faithfully captures any given analysis objective. It is theoretically guaranteed that minimizing the weak distance (e.g., via mathematical optimization) solves the underlying problem. This reduction theory provides a general framework for analyzing numerical code. Two important separate analyses from the literature, branch-coverage-based testing and quantifier-free floating-point satisfiability, are its instances.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314632", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhoulai", + "last_name": "Fu", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/FuS19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314642", + "title": "Gen: a general-purpose probabilistic programming system with programmable inference", + "abstract": "Although probabilistic programming is widely used for some restricted classes of statistical models, existing systems lack the flexibility and efficiency needed for practical use with more challenging models arising in fields like computer vision and robotics. This paper introduces Gen, a general-purpose probabilistic programming system that achieves modeling flexibility and inference efficiency via several novel language constructs: (i) the generative function interface for encapsulating probabilistic models; (ii) interoperable modeling languages that strike different flexibility/efficiency trade-offs; (iii) combinators that exploit common patterns of conditional independence; and (iv) an inference library that empowers users to implement efficient inference algorithms at a high level of abstraction. We show that Gen outperforms state-of-the-art probabilistic programming systems, sometimes by multiple orders of magnitude, on diverse problems including object tracking, estimating 3D body pose from a depth image, and inferring the structure of a time series.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314642", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marco", + "last_name": "Cusumano-Towner", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Cusumano-Towner19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314630", + "title": "Type-level computations for Ruby libraries", + "abstract": "Many researchers have explored ways to bring static typing to dynamic languages. However, to date, such systems are not precise enough when types depend on values, which often arises when using certain Ruby libraries. For example, the type safety of a database query in Ruby on Rails depends on the table and column names used in the query. To address this issue, we introduce CompRDL, a type system for Ruby that allows library method type signatures to include type-level computations (or comp types for short). Combined with singleton types for table and column names, comp types let us give database query methods type signatures that compute a table’s schema to yield very precise type information. Comp types for hash, array, and string libraries can also increase precision and thereby reduce the need for type casts. We formalize CompRDL and prove its type system sound. Rather than type check the bodies of library methods with comp types—those methods may include native code or be complex—CompRDL inserts run-time checks to ensure library methods abide by their computed types. We evaluated CompRDL by writing annotations with type-level computations for several Ruby core libraries and database query APIs. We then used those annotations to type check two popular Ruby libraries and four Ruby on Rails web apps. We found the annotations were relatively compact and could successfully type check 132 methods across our subject programs. Moreover, the use of type-level computations allowed us to check more expressive properties, with fewer manually inserted casts, than was possible without type-level computations. In the process, we found two type errors and a documentation error that were confirmed by the developers. Thus, we believe CompRDL is an important step forward in bringing precise static type checking to dynamic languages.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314630", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Milod", + "last_name": "Kazerounian", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Sankha Narayan", + "last_name": "Guria", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Food" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "Tufts University" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/KazerounianGVFH19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314590", + "title": "Simple and precise static analysis of untrusted Linux kernel extensions", + "abstract": "Extended Berkeley Packet Filter (eBPF) is a Linux subsystem that allows safely executing untrusted user-defined extensions inside the kernel. It relies on static analysis to protect the kernel against buggy and malicious extensions. As the eBPF ecosystem evolves to support more complex and diverse extensions, the limitations of its current verifier, including high rate of false positives, poor scalability, and lack of support for loops, have become a major barrier for developers.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314590", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Elazar", + "last_name": "Gershuni", + "institution": "Tel Aviv University" + }, + { + "first_name": "Nadav", + "last_name": "Amit", + "institution": "Kitware (United States)" + }, + { + "first_name": "Arie", + "last_name": "Gurfinkel", + "institution": "University of Waterloo" + }, + { + "first_name": "Nina", + "last_name": "Narodytska", + "institution": "Kitware (United States)" + }, + { + "first_name": "Jorge A.", + "last_name": "Navas", + "institution": "SRI International" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Leonid", + "last_name": "Ryzhyk", + "institution": "Kitware (United States)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/GershuniAGNNRRS19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314598", + "title": "Low-latency graph streaming using compressed purely-functional trees", + "abstract": "There has been a growing interest in the graph-streaming setting where a continuous stream of graph updates is mixed with graph queries. In principle, purely-functional trees are an ideal fit for this setting as they enable safe parallelism, lightweight snapshots, and strict serializability for queries. However, directly using them for graph processing leads to significant space overhead and poor cache locality.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314598", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Laxman", + "last_name": "Dhulipala", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Julian", + "last_name": "Shun", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/DhulipalaBS19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314614", + "title": "Optimization and abstraction: a synergistic approach for analyzing neural network robustness", + "abstract": "In recent years, the notion of local robustness (or robustness for short) has emerged as a desirable property of deep neural networks. Intuitively, robustness means that small perturbations to an input do not cause the network to perform misclassifications. In this paper, we present a novel algorithm for verifying robustness properties of neural networks. Our method synergistically combines gradient-based optimization methods for counterexample search with abstraction-based proof search to obtain a sound and (δ -)complete decision procedure. Our method also employs a data-driven approach to learn a verification policy that guides abstract interpretation during proof search. We have implemented the proposed approach in a tool called Charon and experimentally evaluated it on hundreds of benchmarks. Our experiments show that the proposed approach significantly outperforms three state-of-the-art tools, namely AI^2, Reluplex, and Reluval.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314614", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Greg", + "last_name": "Anderson", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/AndersonPDC19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314613", + "title": "Supporting peripherals in intermittent systems with just-in-time checkpoints", + "abstract": "Batteryless energy-harvesting devices have the potential to be the foundation of applications for which batteries are infeasible. Just-In-Time checkpointing supports intermittent execution on energy-harvesting devices by checkpointing processor state right before a power failure. While effective for software execution, Just-In-Time checkpointing remains vulnerable to unrecoverable failures involving peripherals(e.g., sensors and accelerators) because checkpointing during a peripheral operation may lead to inconsistency between peripheral and program state. Additionally, a peripheral operation that uses more energy than a device can buffer never completes, causing non-termination.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314613", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kiwan", + "last_name": "Maeng", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/MaengL19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314627", + "title": "Toward efficient gradual typing for structural types via coercions", + "abstract": "Gradual typing combines static and dynamic typing in the same program. Siek et al. (2015) describe five criteria for gradually typed languages, including type soundness and the gradual guarantee. A significant number of languages have been developed in academia and industry that support some of these criteria (TypeScript, Typed Racket, Safe TypeScript, Transient Reticulated Python, Thorn, etc.) but relatively few support all the criteria (Nom, Gradualtalk, Guarded Reticulated Python). Of those that do, only Nom does so efficiently. The Nom experiment shows that one can achieve efficient gradual typing in languages with only nominal types, but many languages have structural types: function types, tuples, record and object types, generics, etc.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314627", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andre", + "last_name": "Kuhlenschmidt", + "institution": "Indiana University" + }, + { + "first_name": "Deyaaeldeen", + "last_name": "Almahallawi", + "institution": "Indiana University" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/pldi/KuhlenschmidtAS19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3322485", + "title": "Synthesis and machine learning for heterogeneous extraction", + "abstract": "We present a way to combine techniques from the program synthesis and machine learning communities to extract structured information from heterogeneous data. Such problems arise in several situations such as extracting attributes from web pages, machine-generated emails, or from data obtained from multiple sources. Our goal is to extract a set of structured attributes from such data.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3322485", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Arun", + "last_name": "Iyer", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Manohar", + "last_name": "Jonnalagedda", + "institution": "" + }, + { + "first_name": "Suresh", + "last_name": "Parthasarathy", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/pldi/IyerJPRR19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314596", + "title": "Semantic program alignment for equivalence checking", + "abstract": "We introduce a robust semantics-driven technique for program equivalence checking. Given two functions we find a trace alignment over a set of concrete executions of both programs and construct a product program particularly amenable to checking equivalence.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314596", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Berkeley", + "last_name": "Churchill", + "institution": "Stanford University" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Stanford University" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/ChurchillP0A19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314603", + "title": "Bidirectional type checking for relational properties", + "abstract": "Relational type systems have been designed for several applications including information flow, differential privacy, and cost analysis. In order to achieve the best results, these systems often use relational refinements and relational effects to maximally exploit the similarity in the structure of the two programs being compared. Relational type systems are appealing for relational properties because they deliver simpler and more precise verification than what could be derived from typing the two programs separately. However, relational type systems do not yet achieve the practical appeal of their non-relational counterpart, in part because of the lack of a general foundation for implementing them.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314603", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ezgi", + "last_name": "Çiçek", + "institution": "Meta (United States)" + }, + { + "first_name": "Weihao", + "last_name": "Qu", + "institution": "Buffalo State University" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/CicekQBG019", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314593", + "title": "Programming support for autonomizing software", + "abstract": "Most traditional software systems are not built with the artificial intelligence support (AI) in mind. Among them, some may require human interventions to operate, e.g., the manual specification of the parameters in the data processing programs, or otherwise, would behave poorly. We propose a novel framework called Autonomizer to autonomize these systems by installing the AI into the traditional programs. Autonomizeris general so it can be applied to many real-world applications. We provide the primitives and the run-time support, where the primitives abstract common tasks of autonomization and the runtime support realizes them transparently. With the support of Autonomizer, the users can gain the AI support with little engineering efforts. Like many other AI applications, the challenge lies in the feature selection, which we address by proposing multiple automated strategies based on the program analysis. Our experiment results on nine real-world applications show that the autonomization only requires adding a few lines to the source code.Besides, for the data-processing programs, Autonomizer improves the output quality by 161% on average over the default settings. For the interactive programs such as game/driving,Autonomizer achieves higher success rate with lower training time than existing autonomized programs.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314593", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wen‐Chuan", + "last_name": "Lee", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Peng", + "last_name": "Liu", + "institution": "IBM (United States)" + }, + { + "first_name": "Yingqi", + "last_name": "Liu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Shiqing", + "last_name": "Ma", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/LeeLLMZ19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314606", + "title": "A fast analytical model of fully associative caches", + "abstract": "While the cost of computation is an easy to understand local property, the cost of data movement on cached architectures depends on global state, does not compose, and is hard to predict. As a result, programmers often fail to consider the cost of data movement. Existing cache models and simulators provide the missing information but are computationally expensive. We present a lightweight cache model for fully associative caches with least recently used (LRU) replacement policy that gives fast and accurate results. We count the cache misses without explicit enumeration of all memory accesses by using symbolic counting techniques twice: 1) to derive the stack distance for each memory access and 2) to count the memory accesses with stack distance larger than the cache size. While this technique seems infeasible in theory, due to non-linearities after the first round of counting, we show that the counting problems are sufficiently linear in practice. Our cache model often computes the results within seconds and contrary to simulation the execution time is mostly problem size independent. Our evaluation measures modeling errors below 0.6% on real hardware. By providing accurate data placement information we enable memory hierarchy aware software development.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314606", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tobias", + "last_name": "Gysi", + "institution": "ETH Zurich" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "ETH Zurich" + }, + { + "first_name": "Laurin", + "last_name": "Brandner", + "institution": "ETH Zurich" + }, + { + "first_name": "Torsten", + "last_name": "Hoefler", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/GysiGBH19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314635", + "title": "Sparse record and replay with controlled scheduling", + "abstract": "Modern applications include many sources of nondeterminism, e.g. due to concurrency, signals, and system calls that interact with the external environment. Finding and reproducing bugs in the presence of this nondeterminism has been the subject of much prior work in three main areas: (1) controlled concurrency-testing, where a custom scheduler replaces the OS scheduler to find subtle bugs; (2) record and replay, where sources of nondeterminism are captured and logged so that a failing execution can be replayed for debugging purposes; and (3) dynamic analysis for the detection of data races. We present a dynamic analysis tool for C++ applications, tsan11rec, which brings these strands of work together by integrating controlled concurrency testing and record and replay into the tsan11 framework for C++11 data race detection. Our novel twist on record and replay is a sparse approach, where the sources of nondeterminism to record can be configured per application. We show that our approach is effective at finding subtle concurrency bugs in small applications; is competitive in terms of performance with the state-of-the-art record and replay tool rr on larger applications; succeeds (due to our sparse approach) in replaying the I/O-intensive Zandronum and QuakeSpasm video games, which are out of scope for rr; but (due to limitations of our sparse approach) cannot faithfully replay applications where memory layout nondeterminism significantly affects application behaviour.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314635", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Lidbury", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/pldi/LidburyD19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314653", + "title": "Model-driven transformations for multi- and many-core CPUs", + "abstract": "Modern polyhedral compilers excel at aggressively optimizing codes with static control parts, but the state-of-practice to find high-performance polyhedral transformations especially for different hardware targets still largely involves auto-tuning. In this work we propose a novel customizable polyhedral scheduling technique, with the aim of delivering high performance for several hardware targets. We design constraints and objectives that model several crucial aspects of performance such as stride optimization or the trade-off between parallelism and reuse, while considering important architectural features of the target machine. We evaluate our work using the PolyBench/C benchmark suite and experimentally validate it against large optimization spaces generated with the Pluto compiler on 3 representative architectures: an IBM Power9, an Intel Xeon Phi and an Intel Core-i9. Our results show we can achieve comparable or superior performance to Pluto on the majority of benchmarks, without implementing tiling in the source code nor using experimental autotuning.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314653", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Kong", + "institution": "Brookhaven National Laboratory" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Colorado State University" + } + ], + "dblp_key": "conf/pldi/KongP19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314628", + "title": "CHET: an optimizing compiler for fully-homomorphic neural-network inferencing", + "abstract": "Fully Homomorphic Encryption (FHE) refers to a set of encryption schemes that allow computations on encrypted data without requiring a secret key. Recent cryptographic advances have pushed FHE into the realm of practical applications. However, programming these applications remains a huge challenge, as it requires cryptographic domain expertise to ensure correctness, security, and performance.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314628", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Roshan", + "last_name": "Dathathri", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Olli", + "last_name": "Saarikivi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Hao", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Kim", + "last_name": "Laine", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Kristin", + "last_name": "Lauter", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Saeed", + "last_name": "Maleki", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/DathathriS0LLMM19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314633", + "title": "Scenic: a language for scenario specification and scene generation", + "abstract": "We propose a new probabilistic programming language for the design and analysis of perception systems, especially those based on machine learning. Specifically, we consider the problems of training a perception system to handle rare events, testing its performance under different conditions, and debugging failures. We show how a probabilistic programming language can help address these problems by specifying distributions encoding interesting types of inputs and sampling these to generate specialized training and test sets. More generally, such languages can be used for cyber-physical systems and robotics to write environment models, an essential prerequisite to any formal analysis. In this paper, we focus on systems like autonomous cars and robots, whose environment is a scene, a configuration of physical objects and agents. We design a domain-specific language, Scenic, for describing scenarios that are distributions over scenes. As a probabilistic programming language, Scenic allows assigning distributions to features of the scene, as well as declaratively imposing hard and soft constraints over the scene. We develop specialized techniques for sampling from the resulting distribution, taking advantage of the structure provided by Scenic's domain-specific syntax. Finally, we apply Scenic in a case study on a convolutional neural network designed to detect cars in road images, improving its performance beyond that achieved by state-of-the-art synthetic data generation methods.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314633", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel J.", + "last_name": "Fremont", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Tommaso", + "last_name": "Dreossi", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Shromona", + "last_name": "Ghosh", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Xiangyu", + "last_name": "Yue", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alberto L.", + "last_name": "Sangiovanni-Vincentelli", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sanjit A.", + "last_name": "Seshia", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/pldi/FremontDGYSS19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314615", + "title": "Generating piecewise-regular code from irregular structures", + "abstract": "Irregular data structures, as exemplified with sparse matrices, have proved to be essential in modern computing. Numerous sparse formats have been investigated to improve the overall performance of Sparse Matrix-Vector multiply (SpMV). But in this work we propose instead to take a fundamentally different approach: to automatically build sets of regular sub-computations by mining for regular sub-regions in the irregular data structure. Our approach leads to code that is specialized to the sparsity structure of the input matrix, but which does not need anymore any indirection array, thereby improving SIMD vectorizability. We particularly focus on small sparse structures (below 10M nonzeros), and demonstrate substantial performance improvements and compaction capabilities compared to a classical CSR implementation and Intel MKL IE's SpMV implementation, evaluating on 200+ different matrices from the SuiteSparse repository.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314615", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Travis", + "last_name": "Augustine", + "institution": "Colorado State University" + }, + { + "first_name": "Janarthanan", + "last_name": "Sarma", + "institution": "Colorado State University" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Colorado State University" + }, + { + "first_name": "Gabriel", + "last_name": "Rodríguez", + "institution": "Universidade da Coruña" + } + ], + "dblp_key": "conf/pldi/AugustineSP019", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314588", + "title": "Synthesizing database programs for schema refactoring", + "abstract": "Many programs that interact with a database need to undergo schema refactoring several times during their life cycle. Since this process typically requires making significant changes to the program's implementation, schema refactoring is often non-trivial and error-prone. Motivated by this problem, we propose a new technique for automatically synthesizing a new version of a database program given its original version and the source and target schemas. Our method does not require manual user guidance and ensures that the synthesized program is equivalent to the original one. Furthermore, our method is quite efficient and can synthesize new versions of database programs (containing up to 263 functions) that are extracted from real-world web applications with an average synthesis time of 69.4 seconds.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314588", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "James", + "last_name": "Dong", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Rushi", + "last_name": "Shah", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/0001DSD19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314620", + "title": "DFix: automatically fixing timing bugs in distributed systems", + "abstract": "Distributed systems nowadays are the backbone of computing society, and are expected to have high availability. Unfortunately, distributed timing bugs, a type of bugs triggered by non-deterministic timing of messages and node crashes, widely exist. They lead to many production-run failures, and are difficult to reason about and patch. Although recently proposed techniques can automatically detect these bugs, how to automatically and correctly fix them still remains as an open problem. This paper presents DFix, a tool that automatically processes distributed timing bug reports, statically analyzes the buggy system, and produces patches. Our evaluation shows that DFix is effective in fixing real-world distributed timing bugs.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314620", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guangpu", + "last_name": "Li", + "institution": "University of Chicago" + }, + { + "first_name": "Haopeng", + "last_name": "Liu", + "institution": "University of Chicago" + }, + { + "first_name": "Xianglan", + "last_name": "Chen", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Haryadi S.", + "last_name": "Gunawi", + "institution": "University of Chicago" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/pldi/LiLCGL19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314602", + "title": "Resource-guided program synthesis", + "abstract": "This article presents resource-guided synthesis, a technique for synthesizing recursive programs that satisfy both a functional specification and a symbolic resource bound. The technique is type-directed and rests upon a novel type system that combines polymorphic refinement types with potential annotations of automatic amortized resource analysis. The type system enables efficient constraint-based type checking and can express precise refinement-based resource bounds. The proof of type soundness shows that synthesized programs are correct by construction. By tightly integrating program exploration and type checking, the synthesizer can leverage the user-provided resource bound to guide the search, eagerly rejecting incomplete programs that consume too many resources. An implementation in the resource-guided synthesizer ReSyn is used to evaluate the technique on a range of recursive data structure manipulations. The experiments show that ReSyn synthesizes programs that are asymptotically more efficient than those generated by a resource-agnostic synthesizer. Moreover, synthesis with ReSyn is faster than a naive combination of synthesis and resource analysis. ReSyn is also able to generate implementations that have a constant resource consumption for fixed input sizes, which can be used to mitigate side-channel attacks.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314602", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tristan", + "last_name": "Knoth", + "institution": "University of California San Diego" + }, + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/KnothWP019", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314652", + "title": "Wootz: a compiler-based framework for fast CNN pruning via composability", + "abstract": "Convolutional Neural Networks (CNN) are widely used for Deep Learning tasks. CNN pruning is an important method to adapt a large CNN model trained on general datasets to fit a more specialized task or a smaller device. The key challenge is on deciding which filters to remove in order to maximize the quality of the pruned networks while satisfying the constraints. It is time-consuming due to the enormous configuration space and the slowness of CNN training.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314652", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hui", + "last_name": "Guan", + "institution": "North Carolina State University" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + }, + { + "first_name": "Seung–Hwan", + "last_name": "Lim", + "institution": "Oak Ridge National Laboratory" + } + ], + "dblp_key": "conf/pldi/GuanSL19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314605", + "title": "FaCT: a DSL for timing-sensitive computation", + "abstract": "Real-world cryptographic code is often written in a subset of C intended to execute in constant-time, thereby avoiding timing side channel vulnerabilities. This C subset eschews structured programming as we know it: if-statements, looping constructs, and procedural abstractions can leak timing information when handling sensitive data. The resulting obfuscation has led to subtle bugs, even in widely-used high-profile libraries like OpenSSL.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314605", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sunjay", + "last_name": "Cauligi", + "institution": "University of California, San Diego" + }, + { + "first_name": "Gary", + "last_name": "Soeller", + "institution": "University of California, San Diego" + }, + { + "first_name": "Brian", + "last_name": "Johannesmeyer", + "institution": "University of California, San Diego" + }, + { + "first_name": "Fraser", + "last_name": "Brown", + "institution": "Stanford University" + }, + { + "first_name": "Riad S.", + "last_name": "Wahby", + "institution": "Stanford University" + }, + { + "first_name": "John W.", + "last_name": "Renner", + "institution": "University of California, San Diego" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/CauligiSJBWRGBJ19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314594", + "title": "Genie: a generator of natural language semantic parsers for virtual assistant commands", + "abstract": "To understand diverse natural language commands, virtual assistants today are trained with numerous labor-intensive, manually annotated sentences. This paper presents a methodology and the Genie toolkit that can handle new compound commands with significantly less manual effort. We advocate formalizing the capability of virtual assistants with a Virtual Assistant Programming Language (VAPL) and using a neural semantic parser to translate natural language into VAPL code. Genie needs only a small realistic set of input sentences for validating the neural model. Developers write templates to synthesize data; Genie uses crowdsourced paraphrases and data augmentation, along with the synthesized data, to train a semantic parser. We also propose design principles that make VAPL languages amenable to natural language translation. We apply these principles to revise ThingTalk, the language used by the Almond virtual assistant. We use Genie to build the first semantic parser that can support compound virtual assistants commands with unquoted free-form parameters. Genie achieves a 62% accuracy on realistic user inputs. We demonstrate Genie’s generality by showing a 19% and 31% improvement over the previous state of the art on a music skill, aggregate functions, and access control.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314594", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Giovanni", + "last_name": "Campagna", + "institution": "Stanford University" + }, + { + "first_name": "Silei", + "last_name": "Xu", + "institution": "Stanford University" + }, + { + "first_name": "Mehrad", + "last_name": "Moradshahi", + "institution": "Stanford University" + }, + { + "first_name": "Richard", + "last_name": "Socher", + "institution": "Salesforce (United States)" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/CampagnaXMSL19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314601", + "title": "A complete formal semantics of x86-64 user-level instruction set architecture", + "abstract": "We present the most complete and thoroughly tested formal semantics of x86-64 to date. Our semantics faithfully formalizes all the non-deprecated, sequential user-level instructions of the x86-64 Haswell instruction set architecture. This totals 3155 instruction variants, corresponding to 774 mnemonics. The semantics is fully executable and has been tested against more than 7,000 instruction-level test cases and the GCC torture test suite. This extensive testing paid off, revealing bugs in both the x86-64 reference manual and other existing semantics. We also illustrate potential applications of our semantics in different formal analyses, and discuss how it can be useful for processor verification.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314601", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sandeep", + "last_name": "Dasgupta", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Daejun", + "last_name": "Park", + "institution": "Runtime Verification (United States)" + }, + { + "first_name": "Theodoros", + "last_name": "Kasampalis", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "Runtime Verification (United States)" + } + ], + "dblp_key": "conf/pldi/Dasgupta0KAR19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314641", + "title": "Learning stateful preconditions modulo a test generator", + "abstract": "In this paper, we present a novel learning framework for inferring stateful preconditions (i.e., preconditions constraining not only primitive-type inputs but also non-primitive-type object states) modulo a test generator, where the quality of the preconditions is based on their safety and maximality with respect to the test generator. We instantiate the learning framework with a specific learner and test generator to realize a precondition synthesis tool for C#. We use an extensive evaluation to show that the tool is highly effective in synthesizing preconditions for avoiding exceptions as well as synthesizing conditions under which methods commute.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314641", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Angello", + "last_name": "Astorga", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Shambwaditya", + "last_name": "Saha", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Shiyu", + "last_name": "Wang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Tao", + "last_name": "Xie", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/AstorgaMSWX19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314595", + "title": "Towards certified separate compilation for concurrent programs", + "abstract": "Certified separate compilation is important for establishing end-to-end guarantees for certified systems consisting of multiple program modules. There has been much work building certified compilers for sequential programs. In this paper, we propose a language-independent framework consisting of the key semantics components and lemmas that bridge the verification gap between the compilers for sequential programs and those for (race-free) concurrent programs, so that the existing verification work for the former can be reused. One of the key contributions of the framework is a novel footprint-preserving compositional simulation as the compilation correctness criterion. The framework also provides a new mechanism to support confined benign races which are usually found in efficient implementations of synchronization primitives.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314595", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hanru", + "last_name": "Jiang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "Nanjing University" + }, + { + "first_name": "Siyang", + "last_name": "Xiao", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Junpeng", + "last_name": "Zha", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Nanjing University" + } + ], + "dblp_key": "conf/pldi/JiangLXZF19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314612", + "title": "Modular divide-and-conquer parallelization of nested loops", + "abstract": "We propose a methodology for automatic generation of divide-and-conquer parallel implementations of sequential nested loops. We focus on a class of loops that traverse read-only multidimensional collections (lists or arrays) and compute a function over these collections. Our approach is modular, in that, the inner loop nest is abstracted away to produce a simpler loop nest for parallelization. The summarized version of the loop nest is then parallelized. The main challenge addressed by this paper is that to perform the code transformations necessary in each step, the loop nest may have to be augmented (automatically) with extra computation to make possible the abstraction and/or the parallelization tasks. We present theoretical results to justify the correctness of our modular approach, and algorithmic solutions for automation. Experimental results demonstrate that our approach can parallelize highly non-trivial loop nests efficiently.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314612", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Victor", + "last_name": "Nicolet", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/pldi/FarzanN19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314591", + "title": "Using active learning to synthesize models of applications that access databases", + "abstract": "We present Konure, a new system that uses active learning to infer models of applications that access relational databases. Konure comprises a domain-specific language (each model is a program in this language) and associated inference algorithm that infers models of applications whose behavior can be expressed in this language. The inference algorithm generates inputs and database configurations, runs the application, then observes the resulting database traffic and outputs to progressively refine its current model hypothesis. Because the technique works with only externally observable inputs, outputs, and database configurations, it can infer the behavior of applications written in arbitrary languages using arbitrary coding styles (as long as the behavior of the application is expressible in the domain-specific language). Konure also implements a regenerator that produces a translated Python implementation of the application that systematically includes relevant security and error checks.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314591", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jiasi", + "last_name": "Shen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/0001R19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314585", + "title": "Argosy: verifying layered storage systems with recovery refinement", + "abstract": "Storage systems make persistence guarantees even if the system crashes at any time, which they achieve using recovery procedures that run after a crash. We present Argosy, a framework for machine-checked proofs of storage systems that supports layered recovery implementations with modular proofs. Reasoning about layered recovery procedures is especially challenging because the system can crash in the middle of a more abstract layer’s recovery procedure and must start over with the lowest-level recovery procedure.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314585", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tej", + "last_name": "Chajed", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "M. Frans", + "last_name": "Kaashoek", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Nickolai", + "last_name": "Zeldovich", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ChajedTKZ19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314610", + "title": "Computing summaries of string loops in C for better testing and refactoring", + "abstract": "Analysing and comprehending C programs that use strings is hard: using standard library functions for manipulating strings is not enforced and programs often use complex loops for the same purpose. We introduce the notion of memoryless loops that capture some of these string loops and present a counterexample-guided synthesis approach to summarise memoryless loops using C standard library functions, which has applications to testing, optimisation and refactoring.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314610", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Timotej", + "last_name": "Kapus", + "institution": "Imperial College London" + }, + { + "first_name": "Oren", + "last_name": "Ish-Shalom", + "institution": "Tel Aviv University" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Cristian", + "last_name": "Cadar", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/pldi/KapusIIRC19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314587", + "title": "Reusable inline caching for JavaScript performance", + "abstract": "JavaScript performance is paramount to a user’s browsing experience. Browser vendors have gone to great lengths to improve JavaScript’s steady-state performance. This has led to sophisticated web applications. However, as users increasingly expect instantaneous page load times, another important goal for JavaScript engines is to attain minimal startup times.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314587", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jiho", + "last_name": "Choi", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Thomas", + "last_name": "Shull", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Josep", + "last_name": "Torrellas", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/ChoiST19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314649", + "title": "Verification of programs under the release-acquire semantics", + "abstract": "We address the verification of concurrent programs running under the release-acquire (RA) semantics. We show that the reachability problem is undecidable even in the case where the input program is finite-state. Given this undecidability, we follow the spirit of the work on context-bounded analysis for detecting bugs in programs under the classical SC model, and propose an under-approximate reachability analysis for the case of RA. To this end, we propose a novel notion, called view-switching, and provide a code-to-code translation from an input program under RA to a program under SC. This leads to a reduction, in polynomial time, of the bounded view-switching reachability problem under RA to the bounded context-switching problem under SC. We have implemented a prototype tool VBMC and tested it on a set of benchmarks, demonstrating that many bugs in programs can be found using a small number of view switches.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314649", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Jatin", + "last_name": "Arora", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Shankara Narayanan", + "last_name": "Krishna", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "conf/pldi/AbdullaAAK19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314597", + "title": "Compiling KB-sized machine learning models to tiny IoT devices", + "abstract": "Recent advances in machine learning (ML) have produced KiloByte-size models that can directly run on constrained IoT devices. This approach avoids expensive communication between IoT devices and the cloud, thereby enabling energy-efficient real-time analytics. However, ML models are expressed typically in floating-point, and IoT hardware typically does not support floating-point. Therefore, running these models on IoT devices requires simulating IEEE-754 floating-point using software, which is very inefficient.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314597", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sridhar", + "last_name": "Gopinath", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nikhil Pratap", + "last_name": "Ghanathe", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Vivek", + "last_name": "Seshadri", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/pldi/GopinathGSS19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314607", + "title": "ILC: a calculus for composable, computational cryptography", + "abstract": "The universal composability (UC) framework is the established standard for analyzing cryptographic protocols in a modular way, such that security is preserved under concurrent composition with arbitrary other protocols. However, although UC is widely used for on-paper proofs, prior attempts at systemizing it have fallen short, either by using a symbolic model (thereby ruling out computational reduction proofs), or by limiting its expressiveness. In this paper, we lay the groundwork for building a concrete, executable implementation of the UC framework. Our main contribution is a process calculus, dubbed the Interactive Lambda Calculus (ILC). ILC faithfully captures the computational model underlying UC—interactive Turing machines (ITMs)—by adapting ITMs to a subset of the π-calculus through an affine typing discipline. In other words, well-typed ILC programs are expressible as ITMs. In turn, ILC’s strong confluence property enables reasoning about cryptographic security reductions. We use ILC to develop a simplified implementation of UC called SaUCy.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314607", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Liao", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "" + }, + { + "first_name": "Andrew", + "last_name": "Miller", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/LiaoHM19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314618", + "title": "Lazy counterfactual symbolic execution", + "abstract": "We present counterfactual symbolic execution, a new approach that produces counterexamples that localize the causes of failure of static verification. First, we develop a notion of symbolic weak head normal form and use it to define lazy symbolic execution reduction rules for non-strict languages like Haskell. Second, we introduce counterfactual branching, a new method to identify places where verification fails due to imprecise specifications (as opposed to incorrect code). Third, we show how to use counterfactual symbolic execution to localize refinement type errors, by translating refinement types into assertions. We implement our approach in a new Haskell symbolic execution engine, G2, and evaluate it on a corpus of 7550 errors gathered from users of the LiquidHaskell refinement type system. We show that for 97.7% of these errors, G2 is able to quickly find counterexamples that show how the code or specifications must be fixed to enable verification.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314618", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William T.", + "last_name": "Hallahan", + "institution": "Yale University" + }, + { + "first_name": "Anton", + "last_name": "Xue", + "institution": "Yale University" + }, + { + "first_name": "Maxwell", + "last_name": "Bland", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/HallahanXBJP19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314640", + "title": "Unsupervised learning of API aliasing specifications", + "abstract": "Real world applications make heavy use of powerful libraries and frameworks, posing a significant challenge for static analysis as the library implementation may be very complex or unavailable. Thus, obtaining specifications that summarize the behaviors of the library is important as it enables static analyzers to precisely track the effects of APIs on the client program, without requiring the actual API implementation.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314640", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jan", + "last_name": "Eberhardt", + "institution": "" + }, + { + "first_name": "Samuel", + "last_name": "Steffen", + "institution": "ETH Zurich" + }, + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/EberhardtSRV19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314609", + "title": "Model checking for weakly consistent libraries", + "abstract": "We present GenMC, a model checking algorithm for concurrent programs that is parametric in the choice of memory model and can be used for verifying clients of concurrent libraries. Subject to a few basic conditions about the memory model, our algorithm is sound, complete and optimal, in that it explores each consistent execution of the program according to the model exactly once, and does not explore inconsistent executions or embark on futile exploration paths. We implement GenMC as a tool for verifying C programs. Despite the generality of the algorithm, its performance is comparable to the state-of-art specialized model checkers for specific memory models, and in certain cases exponentially faster thanks to its coarse partitioning of executions.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314609", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/Kokologiannakis19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314644", + "title": "Huron: hybrid false sharing detection and repair", + "abstract": "Writing efficient multithreaded code that can leverage the full parallelism of underlying hardware is difficult. A key impediment is insidious cache contention issues, such as false sharing. False sharing occurs when multiple threads from different cores access disjoint portions of the same cache line, causing it to go back and forth between the caches of different cores and leading to substantial slowdown.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314644", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tanvir Ahmed", + "last_name": "Khan", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Yifan", + "last_name": "Zhao", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Gilles", + "last_name": "Pokam", + "institution": "Intel (United States)" + }, + { + "first_name": "Barzan", + "last_name": "Mozafari", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Baris", + "last_name": "Kasikci", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/KhanZPMK19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314634", + "title": "SLING: using dynamic analysis to infer program invariants in separation logic", + "abstract": "We introduce a new dynamic analysis technique to discover invariants in separation logic for heap-manipulating programs. First, we use a debugger to obtain rich program execution traces at locations of interest on sample inputs. These traces consist of heap and stack information of variables that point to dynamically allocated data structures. Next, we iteratively analyze separate memory regions related to each pointer variable and search for a formula over predefined heap predicates in separation logic to model these regions. Finally, we combine the computed formulae into an invariant that describes the shape of explored memory regions.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314634", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ton Chanh", + "last_name": "Le", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Guolong", + "last_name": "Zheng", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "ThanhVu", + "last_name": "Nguyen", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "conf/pldi/LeZN19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314582", + "title": "Mesh: compacting memory management for C/C++ applications", + "abstract": "Programs written in C/C++ can suffer from serious memory fragmentation, leading to low utilization of memory, degraded performance, and application failure due to memory exhaustion. This paper introduces Mesh, a plug-in replacement for malloc that, for the first time, eliminates fragmentation in unmodified C/C++ applications. Mesh combines novel randomized algorithms with widely-supported virtual memory operations to provably reduce fragmentation, breaking the classical Robson bounds with high probability. Mesh generally matches the runtime performance of state-of-the-art memory allocators while reducing memory consumption; in particular, it reduces the memory of consumption of Firefox by 16% and Redis by 39%.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314582", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bobby", + "last_name": "Powers", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "David", + "last_name": "Tench", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Andrew", + "last_name": "McGregor", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/pldi/PowersTB019", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314622", + "title": "Verified compilation on a verified processor", + "abstract": "Developing technology for building verified stacks, i.e., computer systems with comprehensive proofs of correctness, is one way the science of programming languages furthers the computing discipline. While there have been successful projects verifying complex, realistic system components, including compilers (software) and processors (hardware), to date these verification efforts have not been compatible to the point of enabling a single end-to-end correctness theorem about running a verified compiler on a verified processor.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314622", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Lööw", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Ramana", + "last_name": "Kumar", + "institution": "Google DeepMind (United Kingdom)" + }, + { + "first_name": "Yong Kiam", + "last_name": "Tan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Michael", + "last_name": "Norrish", + "institution": "Australian National University" + }, + { + "first_name": "Oskar", + "last_name": "Abrahamsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Anthony", + "last_name": "Fox", + "institution": "ARM (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/LoowKTMNAF19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314611", + "title": "Accelerating sequential consistency for Java with speculative compilation", + "abstract": "A memory consistency model (or simply a memory model) specifies the granularity and the order in which memory accesses by one thread become visible to other threads in the program. We previously proposed the volatile-by-default (VBD) memory model as a natural form of sequential consistency (SC) for Java. VBD is significantly stronger than the Java memory model (JMM) and incurs relatively modest overheads in a modified HotSpot JVM running on Intel x86 hardware. However, the x86 memory model is already quite close to SC. It is expected that the cost of VBD will be much higher on the other widely used hardware platform today, namely ARM, whose memory model is very weak.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314611", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lun", + "last_name": "Liu", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/LiuMM19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314629", + "title": "SemCluster: clustering of imperative programming assignments based on quantitative semantic features", + "abstract": "A fundamental challenge in automated reasoning about programming assignments at scale is clustering student submissions based on their underlying algorithms. State-of-the-art clustering techniques are sensitive to control structure variations, cannot cluster buggy solutions with similar correct solutions, and either require expensive pair-wise program analyses or training efforts. We propose a novel technique that can cluster small imperative programs based on their algorithmic essence: (A) how the input space is partitioned into equivalence classes and (B) how the problem is uniquely addressed within individual equivalence classes. We capture these algorithmic aspects as two quantitative semantic program features that are merged into a program's vector representation. Programs are then clustered using their vector representations. The computation of our first semantic feature leverages model counting to identify the number of inputs belonging to an input equivalence class. The computation of our second semantic feature abstracts the program's data flow by tracking the number of occurrences of a unique pair of consecutive values of a variable during its lifetime. The comprehensive evaluation of our tool SemCluster on benchmarks drawn from solutions to small programming assignments shows that SemCluster (1) generates far fewer clusters than other clustering techniques, (2) precisely identifies distinct solution strategies, and (3) boosts the performance of clustering-based program repair, all within a reasonable amount of time.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314629", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David Mitchel", + "last_name": "Perry", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Dohyeong", + "last_name": "Kim", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/PerryKSZ19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314624", + "title": "Promising-ARM/RISC-V: a simpler and faster operational concurrency model", + "abstract": "For ARMv8 and RISC-V, there are concurrency models in two styles, extensionally equivalent: axiomatic models, expressing the concurrency semantics in terms of global properties of complete executions; and operational models, that compute incrementally. The latter are in an abstract microarchitectural style: they execute each instruction in multiple steps, out-of-order and with explicit branch speculation. This similarity to hardware implementations has been important in developing the models and in establishing confidence, but involves complexity that, for programming and model-checking, one would prefer to avoid.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314624", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "University of Cambridge" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sung-Hwan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/pldi/PultePKLH19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314636", + "title": "Usuba: high-throughput and constant-time ciphers, by construction", + "abstract": "International audience", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314636", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Darius", + "last_name": "Mercadier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Pierre-Évariste", + "last_name": "Dagand", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "conf/pldi/MercadierD19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314625", + "title": "A typed, algebraic approach to parsing", + "abstract": "In this paper, we recall the definition of the context-free expressions (or µ-regular expressions), an algebraic presentation of the context-free languages. Then, we define a core type system for the context-free expressions which gives a compositional criterion for identifying those context-free expressions which can be parsed unambiguously by predictive algorithms in the style of recursive descent or LL(1).", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314625", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/pldi/KrishnaswamiY19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314580", + "title": "Data-trace types for distributed stream processing systems", + "abstract": "model generalizes both acyclic synchronous data-flow and relational query processors, and can specify computations over data streams with a rich variety of partial ordering and synchronization characteristics. We then describe a set of programming templates for data-trace transductions: abstractions corresponding to common stream processing tasks. Our system automatically maps these high-level programs to a given topology on the distributed implementation platform Apache Storm while preserving the semantics. Our experimental evaluation shows that (1) while automatic parallelization deployed by existing systems may not preserve semantics, particularly when the computation is sensitive to the ordering of data items, our programming abstractions allow a natural specification of the query that contains a mix of ordering constraints while guaranteeing correct deployment, and (2) the throughput of the automatically compiled distributed code is comparable to that of hand-crafted distributed implementations.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314580", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + }, + { + "first_name": "Caleb", + "last_name": "Stanford", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Zachary G.", + "last_name": "Ives", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Val", + "last_name": "Tannen", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/MamourasSAIT19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314639", + "title": "Scalable verification of probabilistic networks", + "abstract": "This paper presents McNetKAT, a scalable tool for verifying probabilistic network programs. McNetKAT is based on a new semantics for the guarded and history-free fragment of Probabilistic NetKAT in terms of finite-state, absorbing Markov chains. This view allows the semantics of all programs to be computed exactly, enabling construction of an automatic verification tool. Domain-specific optimizations and a parallelizing backend enable McNetKAT to analyze networks with thousands of nodes, automatically reasoning about general properties such as probabilistic program equivalence and refinement, as well as networking properties such as resilience to failures. We evaluate McNetKAT's scalability using real-world topologies, compare its performance against state-of-the-art tools, and develop an extended case study on a recently proposed data center network design.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314639", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steffen", + "last_name": "Smolka", + "institution": "Cornell University" + }, + { + "first_name": "Praveen", + "last_name": "Kumar", + "institution": "Cornell University" + }, + { + "first_name": "David M.", + "last_name": "Kahn", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "University College London" + } + ], + "dblp_key": "conf/pldi/SmolkaKKFHK019", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314583", + "title": "Transactional concurrency control for intermittent, energy-harvesting computing systems", + "abstract": "Batteryless energy-harvesting devices are computing platforms that operate in environments where batteries are not viable for energy storage. Energy-harvesting devices operate intermittently, only as energy is available. Prior work developed software execution models robust to intermittent power failures but no existing intermittent execution model allows interrupts to update global persistent state without allowing incorrect behavior or requiring complex programming. We present Coati, a system that supports event-driven concurrency via interrupts in an intermittent software execution model. Coati exposes a task-based interface for synchronous computations and an event interface for asynchronous interrupts. Coati supports synchronizing tasks and events using transactions, which allow for multi-task atomic regions that extend across multiple power failures. This work explores two different models for serializing events and tasks that both safely provide intuitive semantics for event-driven intermittent programs. We implement a prototype of Coati as C language extensions and a runtime library. Using energy-harvesting hardware, we evaluate Coati on benchmarks adapted from prior work. We show that Coati prevents failures when interrupts are introduced, while the baseline fails in just seconds. Moreover, Coati operates with a reasonable run time overhead that is often comparable to an idealized baseline.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314583", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Emily", + "last_name": "Ruppel", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/RuppelL19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314626", + "title": "Sound, fine-grained traversal fusion for heterogeneous trees", + "abstract": "Applications in many domains are based on a series of traversals of tree structures, and fusing these traversals together to reduce the total number of passes over the tree is a common, important optimization technique. In applications such as compilers and render trees, these trees are heterogeneous: different nodes of the tree have different types. Unfortunately, prior work for fusing traversals falls short in different ways: they do not handle heterogeneity; they require using domain-specific languages to express an application; they rely on the programmer to aver that fusing traversals is safe, without any soundness guarantee; or they can only perform coarse-grain fusion, leading to missed fusion opportunities. This paper addresses these shortcomings to build a framework for fusing traversals of heterogeneous trees that is automatic, sound, and fine-grained. We show across several case studies that our approach is able to allow programmers to write simple, intuitive traversals, and then automatically fuse them to substantially improve performance.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314626", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Laith", + "last_name": "Sakka", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kirshanthan", + "last_name": "Sundararajah", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/SakkaSN019", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314586", + "title": "Ignis: scaling distribution-oblivious systems with light-touch distribution", + "abstract": "Distributed systems offer notable benefits over their centralized counterparts. Reaping these benefits, however, requires burdensome developer effort to identify and rewrite bottlenecked components. Light-touch distribution is a new approach that converts a legacy system into a distributed one using automated transformations. Transformations operate at the boundaries of bottlenecked modules and are parametrizable by light distribution recipes that guide the intended semantics of the resulting distribution. Transformations and recipes operate at runtime, adapting to load by scaling out only saturated components. Our Ignis prototype shows substantial speedups, attractive elasticity characteristics, and memory gains over full replication, achieved by small and backward-compatible code changes.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314586", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nikos", + "last_name": "Vasilakis", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Ben", + "last_name": "Karel", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Yash", + "last_name": "Palkhiwala", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "John", + "last_name": "Sonchack", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "André", + "last_name": "DeHon", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Jonathan M.", + "last_name": "Smith", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/pldi/VasilakisKPSDS19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314599", + "title": "Co-optimizing memory-level parallelism and cache-level parallelism", + "abstract": "Minimizing cache misses has been the traditional goal in optimizing cache performance using compiler based techniques. However, continuously increasing dataset sizes combined with large numbers of cache banks and memory banks connected using on-chip networks in emerging manycores/accelerators makes cache hit–miss latency optimization as important as cache miss rate minimization. In this paper, we propose compiler support that optimizes both the latencies of last-level cache (LLC) hits and the latencies of LLC misses. Our approach tries to achieve this goal by improving the parallelism exhibited by LLC hits and LLC misses. More specifically, it tries to maximize both cache-level parallelism (CLP) and memory-level parallelism (MLP). This paper presents different incarnations of our approach, and evaluates them using a set of 12 multithreaded applications. Our results indicate that (i) optimizing MLP first and CLP later brings, on average, 11.31% performance improvement over an approach that already minimizes the number of LLC misses, and (ii) optimizing CLP first and MLP later brings 9.43% performance improvement. In comparison, balancing MLP and CLP brings 17.32% performance improvement on average.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314599", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xulong", + "last_name": "Tang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mustafa", + "last_name": "Karaköy", + "institution": "TOBB University of Economics and Technology" + }, + { + "first_name": "Meenakshi", + "last_name": "Arunachalam", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/pldi/TangKKA19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314592", + "title": "Composable, sound transformations of nested recursion and loops", + "abstract": "Scheduling transformations reorder a program’s operations to improve locality and/or parallelism. The polyhedral model is a general framework for composing and applying instance-wise scheduling transformations for loop-based programs, but there is no analogous framework for recursive programs. This paper presents an approach for composing and applying scheduling transformations—like inlining, interchange, and code motion—to nested recursive programs. This paper describes the phases of the approach—representing dynamic instances, composing and applying transformations, reasoning about correctness—and shows that these techniques can verify the soundness of composed transformations.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314592", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kirshanthan", + "last_name": "Sundararajah", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/Sundararajah019", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314637", + "title": "Renaissance: benchmarking suite for parallel applications on the JVM", + "abstract": "Established benchmark suites for the Java Virtual Machine (JVM), such as DaCapo, ScalaBench, and SPECjvm2008, lack workloads that take advantage of the parallel programming abstractions and concurrency primitives offered by the JVM and the Java Class Library. However, such workloads are fundamental for understanding the way in which modern applications and data-processing frameworks use the JVM's concurrency features, and for validating new just-in-time (JIT) compiler optimizations that enable more efficient execution of such workloads. We present Renaissance, a new benchmark suite composed of modern, real-world, concurrent, and object-oriented workloads that exercise various concurrency primitives of the JVM. We show that the use of concurrency primitives in these workloads reveals optimization opportunities that were not visible with the existing workloads. We use Renaissance to compare performance of two state-of-the-art, production-quality JIT compilers (HotSpot C2 and Graal), and show that the performance differences are more significant than on existing suites such as DaCapo and SPECjvm2008. We also use Renaissance to expose four new compiler optimizations, and we analyze the behavior of several existing ones. We use Renaissance to compare performance of two state-of-the-art, production-quality JIT compilers (HotSpot C2 and Graal), and show that the performance differences are more significant than on existing suites such as DaCapo and SPECjvm2008. We also use Renaissance to expose four new compiler optimizations, and we analyze the behavior of several existing ones.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314637", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Prokopec", + "institution": "" + }, + { + "first_name": "Andrea", + "last_name": "Rosà", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "David", + "last_name": "Leopoldseder", + "institution": "" + }, + { + "first_name": "Gilles", + "last_name": "Duboscq", + "institution": "" + }, + { + "first_name": "Petr", + "last_name": "Tůma", + "institution": "Charles University" + }, + { + "first_name": "Martin", + "last_name": "Studener", + "institution": "" + }, + { + "first_name": "Lubomír", + "last_name": "Bulej", + "institution": "Charles University" + }, + { + "first_name": "Yudi", + "last_name": "Zheng", + "institution": "" + }, + { + "first_name": "Alex", + "last_name": "Villazón", + "institution": "Universidad Privada Boliviana" + }, + { + "first_name": "Doug", + "last_name": "Simon", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "Würthinger", + "institution": "" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/pldi/ProkopecRLD0SBZ19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314589", + "title": "Lightweight multi-language syntax transformation with parser parser combinators", + "abstract": "Automatically transforming programs is hard, yet critical for automated program refactoring, rewriting, and repair. Multi-language syntax transformation is especially hard due to heterogeneous representations in syntax, parse trees, and abstract syntax trees (ASTs). Our insight is that the problem can be decomposed such that (1) a common grammar expresses the central context-free language (CFL) properties shared by many contemporary languages and (2) open extension points in the grammar allow customizing syntax (e.g., for balanced delimiters) and hooks in smaller parsers to handle language-specific syntax (e.g., for comments). Our key contribution operationalizes this decomposition using a Parser Parser combinator (PPC), a mechanism that generates parsers for matching syntactic fragments in source code by parsing declarative user-supplied templates. This allows our approach to detach from translating input programs to any particular abstract syntax tree representation, and lifts syntax rewriting to a modularly-defined parsing problem. A notable effect is that we skirt the complexity and burden of defining additional translation layers between concrete user input templates and an underlying abstract syntax representation. We demonstrate that these ideas admit efficient and declarative rewrite templates across 12 languages, and validate effectiveness of our approach by producing correct and desirable lightweight transformations on popular real-world projects (over 50 syntactic changes produced by our approach have been merged into 40+). Our declarative rewrite patterns require an order of magnitude less code compared to analog implementations in existing, language-specific tools.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314589", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rijnard van", + "last_name": "Tonder", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Claire Le", + "last_name": "Goues", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/TonderG19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314617", + "title": "Replication-aware linearizability", + "abstract": "Distributed systems often replicate data at multiple locations to achieve availability despite network partitions. These systems accept updates at any replica and propagate them asynchronously to every other replica. Conflict-Free Replicated Data Types (CRDTs) provide a principled approach to the problem of ensuring that replicas are eventually consistent despite the asynchronous delivery of updates.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314617", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chao", + "last_name": "Wang", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Université Paris Cité" + }, + { + "first_name": "Süha Orhun", + "last_name": "Mutluergil", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Gustavo", + "last_name": "Petri", + "institution": "ARM (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/WangEMP19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314623", + "title": "Incremental precision-preserving symbolic inference for probabilistic programs", + "abstract": "We present ISymb an incremental symbolic inference framework for probabilistic programs in situations when some loop-manipulated array data, upon which their probabilistic models are conditioned, undergoes small changes. To tackle the path explosion challenge, ISymb is intra-procedurally path-sensitive except that it conducts a “meet-over-all-paths” analysis within an iteration of a loop (conditioned on some observed array data). By recomputing only the probability distributions for the paths affected, ISymb avoids expensive symbolic inference from scratch while also being precision-preserving. Our evaluation with a set of existing benchmarks shows that ISymb can lead to orders of magnitude performance improvements compared to its non-incremental counterpart (under small changes in observed array data).", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314623", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jieyuan", + "last_name": "Zhang", + "institution": "UNSW Sydney" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/pldi/ZhangX19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314646", + "title": "Sparse computation data dependence simplification for efficient compiler-generated inspectors", + "abstract": "This paper presents a combined compile-time and runtime loop-carried dependence analysis of sparse matrix codes and evaluates its performance in the context of wavefront parallellism. Sparse computations incorporate indirect memory accesses such as x[col[j]] whose memory locations cannot be determined until runtime. The key contributions of this paper are two compile-time techniques for significantly reducing the overhead of runtime dependence testing: (1) identifying new equality constraints that result in more efficient runtime inspectors, and (2) identifying subset relations between dependence constraints such that one dependence test subsumes another one that is therefore eliminated. New equality constraints discovery is enabled by taking advantage of domain-specific knowledge about index arrays, such as col[j]. These simplifications lead to automatically-generated inspectors that make it practical to parallelize such computations. We analyze our simplification methods for a collection of seven sparse computations. The evaluation shows our methods reduce the complexity of the runtime inspectors significantly. Experimental results for a collection of five large matrices show parallel speedups ranging from 2x to more than 8x running on a 8-core CPU.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314646", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mahdi Soltan", + "last_name": "Mohammadi", + "institution": "University of Arizona" + }, + { + "first_name": "Tomofumi", + "last_name": "Yuki", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Kazem", + "last_name": "Cheshmi", + "institution": "Concordia University" + }, + { + "first_name": "Eddie C.", + "last_name": "Davis", + "institution": "Boise State University" + }, + { + "first_name": "Mary", + "last_name": "Hall", + "institution": "University of Utah" + }, + { + "first_name": "Maryam Mehri", + "last_name": "Dehnavi", + "institution": "University of Toronto" + }, + { + "first_name": "Payal", + "last_name": "Nandy", + "institution": "University of Utah" + }, + { + "first_name": "Catherine", + "last_name": "Olschanowsky", + "institution": "Boise State University" + }, + { + "first_name": "Anand", + "last_name": "Venkat", + "institution": "Intel (United States)" + }, + { + "first_name": "Michelle Mills", + "last_name": "Strout", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/pldi/MohammadiYCDHDN19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314647", + "title": "Abstract interpretation under speculative execution", + "abstract": "Analyzing the behavior of a program running on a processor that supports speculative execution is crucial for applications such as execution time estimation and side channel detection. Unfortunately, existing static analysis techniques based on abstract interpretation do not model speculative execution since they focus on functional properties of a program while speculative execution does not change the functionality. To fill the gap, we propose a method to make abstract interpretation sound under speculative execution. There are two contributions. First, we introduce the notion of virtual control flow to augment instructions that may be speculatively executed and thus affect subsequent instructions. Second, to make the analysis efficient, we propose optimizations to handle merges and loops and to safely bound the speculative execution depth. We have implemented and evaluated the proposed method in a static cache analysis for execution time estimation and side channel detection. Our experiments show that the new method, while guaranteed to be sound under speculative execution, outperforms state-of-the-art abstract interpretation techniques that may be unsound.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314647", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Meng", + "last_name": "Wu", + "institution": "Virginia Tech" + }, + { + "first_name": "Chao", + "last_name": "Wang", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/pldi/Wu019", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314643", + "title": "Size-change termination as a contract: dynamically and statically enforcing termination for higher-order programs", + "abstract": "Termination is an important but undecidable program property, which has led to a large body of work on static methods for conservatively predicting or enforcing termination. One such method is the size-change termination approach of Lee, Jones, and Ben-Amram, which operates in two phases: (1) abstract programs into “size-change graphs,” and (2) check these graphs for the size-change property: the existence of paths that lead to infinite decreasing sequences.", + "date": "2019-01-01", + "link": "https://doi.org/10.1145/3314221.3314643", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Phúc C.", + "last_name": "Nguyễn", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Thomas", + "last_name": "Gilray", + "institution": "University of Alabama at Birmingham" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/NguyenGTH19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314608", + "title": "AutoPersist: an easy-to-use Java NVM framework based on reachability", + "abstract": "Byte-addressable, non-volatile memory (NVM) is emerging as a revolutionary memory technology that provides persistency, near-DRAM performance, and scalable capacity. To facilitate its use, many NVM programming models have been proposed. However, most models require programmers to explicitly specify the data structures or objects that should reside in NVM. Such requirement increases the burden on programmers, complicates software development, and introduces opportunities for correctness and performance bugs.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314608", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Shull", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Jian", + "last_name": "Huang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Josep", + "last_name": "Torrellas", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/ShullHT19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314621", + "title": "Parallelism-centric what-if and differential analyses", + "abstract": "This paper proposes TaskProf2, a parallelism profiler and an adviser for task parallel programs. As a parallelism profiler, TaskProf2 pinpoints regions with serialization bottlenecks, scheduling overheads, and secondary effects of execution. As an adviser, TaskProf2 identifies regions that matter in improving parallelism. To accomplish these objectives, it uses a performance model that captures series-parallel relationships between various dynamic execution fragments of tasks and includes fine-grained measurement of computation in those fragments. Using this performance model, TaskProf2’s what-if analyses identify regions that improve the parallelism of the program while considering tasking overheads. Its differential analyses perform fine-grained differencing of an oracle and the observed performance model to identify static regions experiencing secondary effects. We have used TaskProf2 to identify regions with serialization bottlenecks and secondary effects in many applications.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314621", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Adarsh", + "last_name": "Yoga", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/pldi/YogaN19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314650", + "title": "Panthera: holistic memory management for big data processing over hybrid memories", + "abstract": "Modern data-parallel systems such as Spark rely increasingly on in-memory computing that can significantly improve the efficiency of iterative algorithms. To process real-world datasets, modern data-parallel systems often require extremely large amounts of memory, which are both costly and energy-inefficient. Emerging non-volatile memory (NVM) technologies offers high capacity compared to DRAM and low energy compared to SSDs. Hence, NVMs have the potential to fundamentally change the dichotomy between DRAM and durable storage in Big Data processing. However, most Big Data applications are written in managed languages (e.g., Scala and Java) and executed on top of a managed runtime (e.g., the Java Virtual Machine) that already performs various dimensions of memory management. Supporting hybrid physical memories adds in a new dimension, creating unique challenges in data replacement and migration.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314650", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chenxi", + "last_name": "Wang", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Huimin", + "last_name": "Cui", + "institution": "University of Chinese Academy of Sciences" + }, + { + "first_name": "Ting", + "last_name": "Cao", + "institution": "Microsoft (United States)" + }, + { + "first_name": "John", + "last_name": "Zigman", + "institution": "University of Sydney" + }, + { + "first_name": "Haris", + "last_name": "Volos", + "institution": "Google (United States)" + }, + { + "first_name": "Onur", + "last_name": "Mutlu", + "institution": "ETH Zurich" + }, + { + "first_name": "Fang", + "last_name": "Lv", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Xiaobing", + "last_name": "Feng", + "institution": "University of Chinese Academy of Sciences" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/WangCCZVML0X19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314600", + "title": "Characterising renaming within OCaml's module system: theory and implementation", + "abstract": "We present an abstract, set-theoretic denotational semantics for a significant subset of OCaml and its module system, allowing to reason about the correctness of renaming value bindings. Our semantics captures information about the binding structure of programs, as well as about which declarations are related by the use of different language constructs (e.g. functors, module types and module constraints). Correct renamings are precisely those that preserve this structure. We show that our abstract semantics is sound with respect to a (domain-theoretic) denotational model of the operational behaviour of programs, and that it allows us to prove various high-level, intuitive properties of renamings. This formal framework has been implemented in a prototype refactoring tool for OCaml that performs renaming.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314600", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Reuben N. S.", + "last_name": "Rowe", + "institution": "University of Kent" + }, + { + "first_name": "Hugo", + "last_name": "Férée", + "institution": "University of Kent" + }, + { + "first_name": "Simon", + "last_name": "Thompson", + "institution": "University of Kent" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/pldi/RoweFTO19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314631", + "title": "LoCal: a language for programs operating on serialized data", + "abstract": "In a typical data-processing program, the representation of data in memory is distinct from its representation in a serialized form on disk. The former has pointers and arbitrary, sparse layout, facilitating easy manipulation by a program, while the latter is packed contiguously, facilitating easy I/O. We propose a language, LoCal, to unify in-memory and serialized formats. LoCal extends a region calculus into a location calculus, employing a type system that tracks the byte-addressed layout of all heap values. We formalize LoCal and prove type safety, and show how LoCal programs can be inferred from unannotated source terms.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314631", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Vollmer", + "institution": "Indiana University" + }, + { + "first_name": "Chaitanya", + "last_name": "Koparkar", + "institution": "Indiana University" + }, + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "Indiana University" + }, + { + "first_name": "Laith", + "last_name": "Sakka", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/pldi/VollmerKRS0N19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314619", + "title": "Proving differential privacy with shadow execution", + "abstract": "Recent work on formal verification of differential privacy shows a trend toward usability and expressiveness -- generating a correctness proof of sophisticated algorithm while minimizing the annotation burden on programmers. Sometimes, combining those two requires substantial changes to program logics: one recent paper is able to verify Report Noisy Max automatically, but it involves a complex verification system using customized program logics and verifiers.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314619", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuxin", + "last_name": "Wang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Zeyu", + "last_name": "Ding", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Guanhong", + "last_name": "Wang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Daniel", + "last_name": "Kifer", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/pldi/WangDWKZ19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3322484", + "title": "Verifying message-passing programs with dependent behavioural types", + "abstract": "Concurrent and distributed programming is notoriously hard. Modern languages and toolkits ease this difficulty by offering message-passing abstractions, such as actors (e.g., Erlang, Akka, Orleans) or processes (e.g., Go): they allow for simpler reasoning w.r.t. shared-memory concurrency, but do not ensure that a program implements a given specification.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3322484", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "Aston University" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + }, + { + "first_name": "Elias", + "last_name": "Benussi", + "institution": "Faculty (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/ScalasYB19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314581", + "title": "Cost analysis of nondeterministic probabilistic programs", + "abstract": "We consider the problem of expected cost analysis over nondeterministic probabilistic programs, which aims at automated methods for analyzing the resource-usage of such programs. Previous approaches for this problem could only handle nonnegative bounded costs. However, in many scenarios, such as queuing networks or analysis of cryptocurrency protocols, both positive and negative costs are necessary and the costs are unbounded as well.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314581", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peixin", + "last_name": "Wang", + "institution": "East China Normal University" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Xudong", + "last_name": "Qin", + "institution": "East China Normal University" + }, + { + "first_name": "Wenjun", + "last_name": "Shi", + "institution": "East China Normal University" + } + ], + "dblp_key": "conf/pldi/Wang0GCQS19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314651", + "title": "Parser-directed fuzzing", + "abstract": "To be effective, software test generation needs to well cover the space of possible inputs. Traditional fuzzing generates large numbers of random inputs, which however are unlikely to contain keywords and other specific inputs of non-trivial input languages. Constraint-based test generation solves conditions of paths leading to uncovered code, but fails on programs with complex input conditions because of path explosion. In this paper, we present a test generation technique specifically directed at input parsers. We systematically produce inputs for the parser and track comparisons made; after every rejection, we satisfy the comparisons leading to rejection. This approach effectively covers the input space: Evaluated on five subjects, from CSV files to JavaScript, our pFuzzer prototype covers more tokens than both random-based and constraint-based approaches, while requiring no symbolic analysis and far fewer tests than random fuzzers.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314651", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Björn", + "last_name": "Mathis", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Rahul", + "last_name": "Gopinath", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Michaël", + "last_name": "Mera", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Alexander", + "last_name": "Kampmann", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Matthias", + "last_name": "Höschele", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Andreas", + "last_name": "Zeller", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "conf/pldi/MathisGMKHZ19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314604", + "title": "Robustness against release/acquire semantics", + "abstract": "We present an algorithm for automatically checking robustness of concurrent programs against C/C++11 release/acquire semantics, namely verifying that all program behaviors under release/acquire are allowed by sequential consistency. Our approach reduces robustness verification to a reachability problem under (instrumented) sequential consistency. We have implemented our algorithm in a prototype tool called Rocker and applied it to several challenging concurrent algorithms. To the best of our knowledge, this is the first precise method for verifying robustness against a high-level programming language weak memory semantics.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314604", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Roy", + "last_name": "Margalit", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/LahavM19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314584", + "title": "An applied quantum Hoare logic", + "abstract": "We derive a variant of quantum Hoare logic (QHL), called applied quantum Hoare logic (aQHL for short), by: 1. restricting QHL to a special class of preconditions and postconditions, namely projections, which can significantly simplify verification of quantum programs and are much more convenient when used in debugging and testing; and 2. adding several rules for reasoning about robustness of quantum programs, i.e. error bounds of outputs. The effectiveness of aQHL is shown by its applications to verify two sophisticated quantum algorithms: HHL (Harrow-Hassidim-Lloyd) for solving systems of linear equations and qPCA (quantum Principal Component Analysis).", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314584", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Li", + "last_name": "Zhou", + "institution": "Tsinghua University" + }, + { + "first_name": "Nengkun", + "last_name": "Yu", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Institute of Software" + } + ], + "dblp_key": "conf/pldi/ZhouYY19", + "venue": "pldi", + "year": 2019 + }, + { + "paper_id": "10.1145/3314221.3314638", + "title": "An inductive synthesis framework for verifiable reinforcement learning", + "abstract": "Despite the tremendous advances that have been made in the last decade on developing useful machine-learning applications, their wider adoption has been hindered by the lack of strong assurance guarantees that can be made about their behavior. In this paper, we consider how formal verification techniques developed for traditional software systems can be repurposed for verification of reinforcement learning-enabled ones, a particularly important class of machine learning systems. Rather than enforcing safety by examining and altering the structure of a complex neural network implementation, our technique uses blackbox methods to synthesizes deterministic programs, simpler, more interpretable, approximations of the network that can nonetheless guarantee desired safety properties are preserved, even when the network is deployed in unanticipated or previously unobserved environments. Our methodology frames the problem of neural network verification in terms of a counterexample and syntax-guided inductive synthesis procedure over these programs. The synthesis procedure searches for both a deterministic program and an inductive invariant over an infinite state transition system that represents a specification of an application's control logic. Additional specifications defining environment-based constraints can also be provided to further refine the search space. Synthesized programs deployed in conjunction with a neural network implementation dynamically enforce safety conditions by monitoring and preventing potentially unsafe actions proposed by neural policies. Experimental results over a wide range of cyber-physical applications demonstrate that software-inspired formal verification techniques can be used to realize trustworthy reinforcement learning systems with low overhead.", + "date": "2019-06-07", + "link": "https://doi.org/10.1145/3314221.3314638", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "He", + "last_name": "Zhu", + "institution": "Galois (United States)" + }, + { + "first_name": "Zikang", + "last_name": "Xiong", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Stephen", + "last_name": "Magill", + "institution": "Galois (United States)" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/ZhuXMJ19", + "venue": "pldi", + "year": 2019 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2020.json b/data/pl_conferences/pldi/2020.json new file mode 100644 index 0000000..76d9b19 --- /dev/null +++ b/data/pl_conferences/pldi/2020.json @@ -0,0 +1,2673 @@ +[ + { + "paper_id": "10.1145/3385412.3386007", + "title": "Silq: a high-level quantum language with safe uncomputation and intuitive semantics", + "abstract": "Existing quantum languages force the programmer to work at a low level of abstraction leading to unintuitive and cluttered code. A fundamental reason is that dropping temporary values from the program state requires explicitly applying quantum operations that safely uncompute these values.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386007", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Bichsel", + "institution": "ETH Zurich" + }, + { + "first_name": "Maximilian", + "last_name": "Baader", + "institution": "ETH Zurich" + }, + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/BichselBGV20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385990", + "title": "Ethainter: a smart contract security analyzer for composite vulnerabilities", + "abstract": "Smart contracts on permissionless blockchains are exposed to inherent security risks due to interactions with untrusted entities. Static analyzers are essential for identifying security risks and avoiding millions of dollars worth of damage.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385990", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lexi", + "last_name": "Brent", + "institution": "International Computer Science Institute" + }, + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Sifis", + "last_name": "Lagouvardos", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Bernhard", + "last_name": "Scholz", + "institution": "University of Sydney" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/pldi/BrentGLSS20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386026", + "title": "Static analysis of Java enterprise applications: frameworks and caches, the elephants in the room", + "abstract": "Enterprise applications are a major success domain of Java, and Java is the default setting for much modern static analysis research. It would stand to reason that high-quality static analysis of Java enterprise applications would be commonplace, but this is far from true. Major analysis frameworks feature virtually no support for enterprise applications and offer analyses that are woefully incomplete and vastly imprecise, when at all scalable.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386026", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anastasios", + "last_name": "Antoniadis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Nikos", + "last_name": "Filippakis", + "institution": "European Organization for Nuclear Research" + }, + { + "first_name": "Paddy", + "last_name": "Krishnan", + "institution": "" + }, + { + "first_name": "Raghavendra", + "last_name": "Ramesh", + "institution": "" + }, + { + "first_name": "Nicholas", + "last_name": "Allen", + "institution": "" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/pldi/AntoniadisFKRAS20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385984", + "title": "HipHop.js: (A)Synchronous reactive web programming", + "abstract": "International audience", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385984", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gérard", + "last_name": "Berry", + "institution": "Collège de France" + }, + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/pldi/BerryS20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386037", + "title": "Towards an API for the real numbers", + "abstract": "The real numbers are pervasive, both in daily life, and in mathematics. Students spend much time studying their properties. Yet computers and programming languages generally provide only an approximation geared towards performance, at the expense of many of the nice properties we were taught in high school.", + "date": "2020-06-11", + "link": "https://doi.org/10.1145/3385412.3386037", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/pldi/Boehm20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385999", + "title": "Blended, precise semantic program embeddings", + "abstract": "Learning neural program embeddings is key to utilizing deep neural networks in program languages research --- precise and efficient program representations enable the application of deep models to a wide range of program analysis tasks. Existing approaches predominately learn to embed programs from their source code, and, as a result, they do not capture deep, precise program semantics. On the other hand, models learned from runtime information critically depend on the quality of program executions, thus leading to trained models with highly variant quality. This paper tackles these inherent weaknesses of prior approaches by introducing a new deep neural network, Liger, which learns program representations from a mixture of symbolic and concrete execution traces. We have evaluated Liger on two tasks: method name prediction and semantics classification. Results show that Liger is significantly more accurate than the state-of-the-art static model code2seq in predicting method names, and requires on average around 10x fewer executions covering nearly 4x fewer paths than the state-of-the-art dynamic model DYPRO in both tasks. Liger offers a new, interesting design point in the space of neural program embeddings and opens up this new direction for exploration.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385999", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "Visa (United States)" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/0022S20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385997", + "title": "Typilus: neural type hints", + "abstract": "Type inference over partial contexts in dynamically typed languages is challenging. In this work, we present a graph neural network model that predicts types by probabilistically reasoning over a program’s structure, names, and patterns. The network uses deep similarity learning to learn a TypeSpace — a continuous relaxation of the discrete space of types — and how to embed the type properties of a symbol (i.e. identifier) into it. Importantly, our model can employ one-shot learning to predict an open vocabulary of types, including rare and user-defined ones. We realise our approach in Typilus for Python that combines the TypeSpace with an optional type checker. We show that Typilus accurately predicts types. Typilus confidently predicts types for 70% of all annotatable symbols; when it predicts a type, that type optionally type checks 95% of the time. Typilus can also find incorrect type annotations; two important and popular open source libraries, fairseq and allennlp, accepted our pull requests that fixed the annotation errors Typilus discovered.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385997", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Miltiadis", + "last_name": "Allamanis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Earl T.", + "last_name": "Barr", + "institution": "University College London" + }, + { + "first_name": "Soline", + "last_name": "Ducousso", + "institution": "École Nationale Supérieure de Techniques Avancées" + }, + { + "first_name": "Zheng", + "last_name": "Gao", + "institution": "University College London" + } + ], + "dblp_key": "conf/pldi/AllamanisBDG20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386034", + "title": "Efficient handling of string-number conversion", + "abstract": "String-number conversion is an important class of constraints needed for the symbolic execution of string-manipulating programs. In particular solving string constraints with string-number conversion is necessary for the analysis of scripting languages such as JavaScript and Python, where string-number conversion is a part of the definition of the core semantics of these languages. However, solving this type of constraint is very challenging for the state-of-the-art solvers. We propose in this paper an approach that can efficiently support both string-number conversion and other common types of string constraints. Experimental results show that it significantly outperforms other state-of-the-art tools on benchmarks that involves string-number conversion.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386034", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Yu‐Fang", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "Bui Phi", + "last_name": "Diep", + "institution": "Uppsala University" + }, + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "" + }, + { + "first_name": "Petr", + "last_name": "Janků", + "institution": "Brno University of Technology" + }, + { + "first_name": "Hsin‐Hung", + "last_name": "Lin", + "institution": "Academia Sinica" + }, + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" + }, + { + "first_name": "Wei-Cheng", + "last_name": "Wu", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/pldi/AbdullaACDDJLHW20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386009", + "title": "Reactive probabilistic programming", + "abstract": "Synchronous modeling is at the heart of programming languages like Lustre, Esterel, or Scade used routinely for implementing safety critical control software, e.g., fly-by-wire and engine control in planes. However, to date these languages have had limited modern support for modeling uncertainty --- probabilistic aspects of the software's environment or behavior --- even though modeling uncertainty is a primary activity when designing a control system.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386009", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Baudart", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Louis", + "last_name": "Mandel", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Eric", + "last_name": "Atkinson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Benjamin", + "last_name": "Sherman", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Marc", + "last_name": "Pouzet", + "institution": "École Normale Supérieure - PSL" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/BaudartMASPC20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386015", + "title": "A study of the learnability of relational properties: model counting meets machine learning (MCML)", + "abstract": "This paper introduces the MCML approach for empirically studying the learnability of relational properties that can be expressed in the well-known software design language Alloy. A key novelty of MCML is quantification of the performance of and semantic differences among trained machine learning (ML) models, specifically decision trees, with respect to entire (bounded) input spaces, and not just for given training and test datasets (as is the common practice). MCML reduces the quantification problems to the classic complexity theory problem of model counting, and employs state-of-the-art model counters. The results show that relatively simple ML models can achieve surprisingly high performance (accuracy and F1-score) when evaluated in the common setting of using training and test datasets - even when the training dataset is much smaller than the test dataset - indicating the seeming simplicity of learning relational properties. However, MCML metrics based on model counting show that the performance can degrade substantially when tested against the entire (bounded) input space, indicating the high complexity of precisely learning these properties, and the usefulness of model counting in quantifying the true performance.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386015", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Muhammad", + "last_name": "Usman", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Wenxi", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Marko", + "last_name": "Vasic", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kaiyuan", + "last_name": "Wang", + "institution": "Google (United States)" + }, + { + "first_name": "Haris", + "last_name": "Vikalo", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/0024WVWVK20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386035", + "title": "Templates and recurrences: better together", + "abstract": "This paper is the confluence of two streams of ideas in the literature on generating numerical invariants, namely: (1) template-based methods, and (2) recurrence-based methods.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386035", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jason", + "last_name": "Breck", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "John", + "last_name": "Cyphert", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/BreckCKR20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385968", + "title": "Towards a verified range analysis for JavaScript JITs", + "abstract": "We present VeRA, a system for verifying the range analysis pass in browser just-in-time (JIT) compilers. Browser developers write range analysis routines in a subset of C++, and verification developers write infrastructure to verify custom analysis properties. Then, VeRA automatically verifies the range analysis routines, which browser developers can integrate directly into the JIT. We use VeRA to translate and verify Firefox range analysis routines, and it detects a new, confirmed bug that has existed in the browser for six years.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385968", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fraser", + "last_name": "Brown", + "institution": "Stanford University" + }, + { + "first_name": "John W.", + "last_name": "Renner", + "institution": "University of California, San Diego" + }, + { + "first_name": "Andres", + "last_name": "Nötzli", + "institution": "Stanford University" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + }, + { + "first_name": "Hovav", + "last_name": "Shacham", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/BrownRNLSS20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385965", + "title": "The essence of Bluespec: a core language for rule-based hardware design", + "abstract": "The Bluespec hardware-description language presents a significantly higher-level view than hardware engineers are used to, exposing a simpler concurrency model that promotes formal proof, without compromising on performance of compiled circuits. Unfortunately, the cost model of Bluespec has been unclear, with performance details depending on a mix of user hints and opaque static analysis of potential concurrency conflicts within a design. In this paper we present Koika, a derivative of Bluespec that preserves its desirable properties and yet gives direct control over the scheduling decisions that determine performance. Koika has a novel and deterministic operational semantics that uses dynamic analysis to avoid concurrency anomalies. Our implementation includes Coq definitions of syntax, semantics, key metatheorems, and a verified compiler to circuits. We argue that most of the extra circuitry required for dynamic analysis can be eliminated by compile-time BSV-style static analysis.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385965", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Bourgeat", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Arvind", + "last_name": "Arvind", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/BourgeatPCA20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385995", + "title": "PMEvo: portable inference of port mappings for out-of-order processors by evolutionary optimization", + "abstract": "Achieving peak performance in a computer system requires optimizations in every layer of the system, be it hardware or software. A detailed understanding of the underlying hardware, and especially the processor, is crucial to optimize software. One key criterion for the performance of a processor is its ability to exploit instruction-level parallelism. This ability is determined by the port mapping of the processor, which describes the execution units of the processor for each instruction.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385995", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Ritter", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/pldi/0002H20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386022", + "title": "Behavioral simulation for smart contracts", + "abstract": "While smart contracts have the potential to revolutionize many important applications like banking, trade, and supply-chain, their reliable deployment begs for rigorous formal verification. Since most smart contracts are not annotated with formal specifications, general verification of functional properties is impeded.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386022", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sidi Mohamed", + "last_name": "Beillahi", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Gabriela", + "last_name": "Ciocarlie", + "institution": "SRI International" + }, + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "SRI International" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/pldi/BeillahiCEE20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386028", + "title": "SCAF: a speculation-aware collaborative dependence analysis framework", + "abstract": "Program analysis determines the potential dataflow and control flow relationships among instructions so that compiler optimizations can respect these relationships to transform code correctly. Since many of these relationships rarely or never occur, speculative optimizations assert they do not exist while optimizing the code. To preserve correctness, speculative optimizations add validation checks to activate recovery code when these assertions prove untrue. This approach results in many missed opportunities because program analysis and thus other optimizations remain unaware of the full impact of these dynamically-enforced speculative assertions. To address this problem, this paper presents SCAF, a Speculation-aware Collaborative dependence Analysis Framework. SCAF learns of available speculative assertions via profiling, computes their full impact on memory dependence analysis, and makes this resulting information available for all code optimizations. SCAF is modular (adding new analysis modules is easy) and collaborative (modules cooperate to produce a result more precise than the confluence of all individual results). Relative to the best prior speculation-aware dependence analysis technique, by computing the full impact of speculation on memory dependence analysis, SCAF dramatically reduces the need for expensive-to-validate memory speculation in the hot loops of all 16 evaluated C/C++ SPEC benchmarks.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386028", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sotiris", + "last_name": "Apostolakis", + "institution": "Princeton University" + }, + { + "first_name": "Ziyang", + "last_name": "Xu", + "institution": "Princeton University" + }, + { + "first_name": "Zujun", + "last_name": "Tan", + "institution": "Princeton University" + }, + { + "first_name": "Greg", + "last_name": "Chan", + "institution": "Princeton University" + }, + { + "first_name": "Simone", + "last_name": "Campanoni", + "institution": "Northwestern University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/ApostolakisXTCC20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385970", + "title": "Constant-time foundations for the new spectre era", + "abstract": "The constant-time discipline is a software-based countermeasure used for protecting high assurance cryptographic implementations against timing side-channel attacks. Constant-time is effective (it protects against many known attacks), rigorous (it can be formalized using program semantics), and amenable to automated verification. Yet, the advent of micro-architectural attacks makes constant-time as it exists today far less useful.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385970", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sunjay", + "last_name": "Cauligi", + "institution": "University of California, San Diego" + }, + { + "first_name": "Craig", + "last_name": "Disselkoen", + "institution": "University of California, San Diego" + }, + { + "first_name": "Klaus von", + "last_name": "Gleissenthall", + "institution": "University of California, San Diego" + }, + { + "first_name": "Dean M.", + "last_name": "Tullsen", + "institution": "University of California, San Diego" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California, San Diego" + }, + { + "first_name": "Tamara", + "last_name": "Rezk", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + } + ], + "dblp_key": "conf/pldi/CauligiDGTSRB20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385988", + "title": "Multi-modal synthesis of regular expressions", + "abstract": "In this paper, we propose a multi-modal synthesis technique for automatically constructing regular expressions (regexes) from a combination of examples and natural language. Using multiple modalities is useful in this context because natural language alone is often highly ambiguous, whereas examples in isolation are often not sufficient for conveying user intent. Our proposed technique first parses the English description into a so-called hierarchical sketch that guides our programming-by-example (PBE) engine. Since the hierarchical sketch captures crucial hints, the PBE engine can leverage this information to both prioritize the search as well as make useful deductions for pruning the search space.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385988", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qiaochu", + "last_name": "Chen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Xi", + "last_name": "Ye", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Greg", + "last_name": "Durrett", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/Chen0YDD20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385969", + "title": "Polynomial invariant generation for non-deterministic recursive programs", + "abstract": "We consider the classical problem of invariant generation for programs with polynomial assignments and focus on synthesizing invariants that are a conjunction of strict polynomial inequalities. We present a sound and semi-complete method based on positivstellensaetze, i.e. theorems in semi-algebraic geometry that characterize positive polynomials over a semi-algebraic set.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385969", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Ehsan Kafshdar", + "last_name": "Goharshady", + "institution": "Ferdowsi University of Mashhad" + } + ], + "dblp_key": "conf/pldi/Chatterjee0GG20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386002", + "title": "Proving almost-sure termination by omega-regular decomposition", + "abstract": "Almost-sure termination is the most basic liveness property of probabilistic programs. We present a novel decomposition-based approach for proving almost-sure termination of probabilistic programs with complex control-flow structure and non-determinism. Our approach automatically decomposes the runs of the probabilistic program into a finite union of ω-regular subsets and then proves almost-sure termination of each subset based on the notion of localized ranking supermartingales. Compared to the lexicographic methods and the compositional methods, our approach does not require a lexicographic order over the ranking supermartingales as well as the so-called unaffecting condition. Thus it has high generality. We present the algorithm of our approach and prove its soundness, as well as its relative completeness. We show that our approach can be applied to some hard cases and the evaluation on the benchmarks of previous works shows the significant efficiency of our approach.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386002", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jianhui", + "last_name": "Chen", + "institution": "Tsinghua University" + }, + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + } + ], + "dblp_key": "conf/pldi/ChenH20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385963", + "title": "Automatic generation of efficient sparse tensor format conversion routines", + "abstract": "This paper shows how to generate code that efficiently converts sparse tensors between disparate storage formats (data layouts) such as CSR, DIA, ELL, and many others. We decompose sparse tensor conversion into three logical phases: coordinate remapping, analysis, and assembly. We then develop a language that precisely describes how different formats group together and order a tensor’s nonzeros in memory. This lets a compiler emit code that performs complex remappings of nonzeros when converting between formats. We also develop a query language that can extract statistics about sparse tensors, and we show how to emit efficient analysis code that computes such queries. Finally, we define an abstract interface that captures how data structures for storing a tensor can be efficiently assembled given specific statistics about the tensor. Disparate formats can implement this common interface, thus letting a compiler emit optimized sparse tensor conversion code for arbitrary combinations of many formats without hard-coding for any specific combination.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385963", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stephen Y.", + "last_name": "Chou", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ChouKA20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386004", + "title": "Debugging and detecting numerical errors in computation with posits", + "abstract": "Posit is a recently proposed alternative to the floating point representation (FP). It provides tapered accuracy. Given a fixed number of bits, the posit representation can provide better precision for some numbers compared to FP, which has generated significant interest in numerous domains. Being a representation with tapered accuracy, it can introduce high rounding errors for numbers outside the above golden zone. Programmers currently lack tools to detect and debug errors while programming with posits.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386004", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sangeeta", + "last_name": "Chowdhary", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Jay P.", + "last_name": "Lim", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/pldi/ChowdharyLN20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386023", + "title": "EVA: an encrypted vector arithmetic language and compiler for efficient homomorphic computation", + "abstract": "Fully-Homomorphic Encryption (FHE) offers powerful capabilities by enabling secure offloading of both storage and computation, and recent innovations in schemes and implementations have made it all the more attractive. At the same time, FHE is notoriously hard to use with a very constrained programming model, a very unusual performance profile, and many cryptographic constraints. Existing compilers for FHE either target simpler but less efficient FHE schemes or only support specific domains where they can rely on expert-provided high-level runtimes to hide complications.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386023", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Roshan", + "last_name": "Dathathri", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Blagovesta", + "last_name": "Kostova", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Olli", + "last_name": "Saarikivi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wei", + "last_name": "Dai", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Kim", + "last_name": "Laine", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Madan", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/DathathriKSDLM20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385981", + "title": "Compiler and runtime support for continuation marks", + "abstract": "Continuation marks enable dynamic binding and context inspection in a language with proper handling of tail calls and first-class, multi-prompt, delimited continuations. The simplest and most direct use of continuation marks is to implement dynamically scoped variables, such as the current output stream or the current exception handler. Other uses include stack inspection for debugging or security checks, serialization of an in-progress computation, and run-time elision of redundant checks. By exposing continuation marks to users of a programming language, more kinds of language extensions can be implemented as libraries without further changes to the compiler. At the same time, the compiler and runtime system must provide an efficient implementation of continuation marks to ensure that library-implemented language extensions are as effective as changing the compiler. Our implementation of continuation marks for Chez Scheme (in support of Racket) makes dynamic binding and lookup constant-time and fast, preserves the performance of Chez Scheme's first-class continuations, and imposes negligible overhead on program fragments that do not use first-class continuations or marks.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385981", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Cisco Systems (United States)" + } + ], + "dblp_key": "conf/pldi/FlattD20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386031", + "title": "NVTraverse: in NVRAM data structures, the destination is more important than the journey", + "abstract": "The recent availability of fast, dense, byte-addressable non-volatile memory has led to increasing interest in the problem of designing durable data structures that can recover from system crashes. However, designing durable concurrent data structures that are correct and efficient has proven to be very difficult, leading to many inefficient or incorrect algorithms. In this paper, we present a general transformation that takes a lock-free data structure from a general class called traversal data structure (that we formally define) and automatically transforms it into an implementation of the data structure for the NVRAM setting that is provably durably linearizable and highly efficient. The transformation hinges on the observation that many data structure operations begin with a traversal phase that does not need to be persisted, and thus we only begin persisting when the traversal reaches its destination. We demonstrate the transformation's efficiency through extensive measurements on a system with Intel's recently released Optane DC persistent memory, showing that it can outperform competitors on many workloads.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386031", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michal", + "last_name": "Friedman", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Naama", + "last_name": "Ben-David", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yuanhao", + "last_name": "Wei", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/pldi/FriedmanBWBP20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385972", + "title": "Binary rewriting without control flow recovery", + "abstract": "Static binary rewriting has many important applications in software security and systems, such as hardening, repair, patching, instrumentation, and debugging. While many different static binary rewriting tools have been proposed, most rely on recovering control flow information from the input binary. The recovery step is necessary since the rewriting process may move instructions, meaning that the set of jump targets in the rewritten binary needs to be adjusted accordingly. Since the static recovery of control flow information is a hard problem in general, most tools rely on a set of simplifying heuristics or assumptions, such as specific compilers, specific source languages, or binary file meta information. However, the reliance on assumptions or heuristics tends to scale poorly in practice, and most state-of-the-art static binary rewriting tools cannot handle very large/complex programs such as web browsers.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385972", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gregory J.", + "last_name": "Duck", + "institution": "National University of Singapore" + }, + { + "first_name": "Xiang", + "last_name": "Gao", + "institution": "National University of Singapore" + }, + { + "first_name": "Abhik", + "last_name": "Roychoudhury", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/pldi/DuckGR20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385992", + "title": "Zippy LL(1) parsing with derivatives", + "abstract": "In this paper, we present an efficient, functional, and formally verified parsing algorithm for LL(1) context-free expressions based on the concept of derivatives of formal languages. Parsing with derivatives is an elegant parsing technique, which, in the general case, suffers from cubic worst-case time complexity and slow performance in practice. We specialise the parsing with derivatives algorithm to LL(1) context-free expressions, where alternatives can be chosen given a single token of lookahead. We formalise the notion of LL(1) expressions and show how to efficiently check the LL(1) property. Next, we present a novel linear-time parsing with derivatives algorithm for LL(1) expressions operating on a zipper-inspired data structure. We prove the algorithm correct in Coq and present an implementation as a part of Scallion, a parser combinators framework in Scala with enumeration and pretty printing capabilities.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385992", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Romain", + "last_name": "Edelmann", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Jad", + "last_name": "Hamza", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/pldi/EdelmannHK20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386006", + "title": "λPSI: exact inference for higher-order probabilistic programs", + "abstract": "We present λPSI, the first probabilistic programming language and system that supports higher-order exact inference for probabilistic programs with first-class functions, nested inference and discrete, continuous and mixed random variables. λPSI’s solver is based on symbolic reasoning and computes the exact distribution represented by a program.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386006", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Samuel", + "last_name": "Steffen", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/GehrSV20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385975", + "title": "Proving data-poisoning robustness in decision trees", + "abstract": "Machine learning models are brittle, and small changes in the training data can result in different predictions. We study the problem of proving that a prediction is robust to data poisoning, where an attacker can inject a number of malicious elements into the training set to influence the learned model. We target decision-tree models, a popular and simple class of machine learning models that underlies many complex learning techniques. We present a sound verification technique based on abstract interpretation and implement it in a tool called Antidote. Antidote abstractly trains decision trees for an intractably large space of possible poisoned datasets. Due to the soundness of our abstraction, Antidote can produce proofs that, for a given input, the corresponding prediction would not have changed had the training set been tampered with or not. We demonstrate the effectiveness of Antidote on a number of popular datasets.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385975", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Samuel", + "last_name": "Drews", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/DrewsAD20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385964", + "title": "Scalable validation of binary lifters", + "abstract": "Validating the correctness of binary lifters is pivotal to gain trust in binary analysis, especially when used in scenarios where correctness is important. Existing approaches focus on validating the correctness of lifting instructions or basic blocks in isolation and do not scale to full programs. In this work, we show that formal translation validation of single instructions for a complex ISA like x86-64 is not only practical, but can be used as a building block for scalable full-program validation. Our work is the first to do translation validation of single instructions on an architecture as extensive as x86-64, uses the most precise formal semantics available, and has the widest coverage in terms of the number of instructions tested for correctness. Next, we develop a novel technique that uses validated instructions to enable program-level validation, without resorting to performance-heavy semantic equivalence checking. Specifically, we compose the validated IR sequences using a tool we develop called Compositional Lifter to create a reference standard. The semantic equivalence check between the reference and the lifter output is then reduced to a graph-isomorphism check through the use of semantic preserving transformations. The translation validation of instructions in isolation revealed 29 new bugs in McSema – a mature open-source lifter from x86-64 to LLVM IR. Towards the validation of full programs, our approach was able to prove the translational correctness of 2254/2348 functions taken from LLVM’s single-source benchmark test-suite.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385964", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sandeep", + "last_name": "Dasgupta", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "S.", + "last_name": "Dinesh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Deepan", + "last_name": "Venkatesh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Christopher W.", + "last_name": "Fletcher", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/pldi/DasguptaDVAF20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385994", + "title": "From folklore to fact: comparing implementations of stacks and continuations", + "abstract": "The efficient implementation of function calls and non-local control transfers is a critical part of modern language implementations and is important in the implementation of everything from recursion, higher-order functions, concurrency and coroutines, to task-based parallelism. In a compiler, these features can be supported by a variety of mechanisms, including call stacks, segmented stacks, and heap-allocated continuation closures.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385994", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kavon", + "last_name": "Farvardin", + "institution": "University of Chicago" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/pldi/FarvardinR20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385983", + "title": "Type-directed scheduling of streaming accelerators", + "abstract": "Designing efficient, application-specialized hardware accelerators requires assessing trade-offs between a hardware module’s performance and resource requirements. To facilitate hardware design space exploration, we describe Aetherling, a system for automatically compiling data-parallel programs into statically scheduled, streaming hardware circuits. Aetherling contributes a space- and time-aware intermediate language featuring data-parallel operators that represent parallel or sequential hardware modules, and sequence data types that encode a module’s throughput by specifying when sequence elements are produced or consumed. As a result, well-typed operator composition in the space-time language corresponds to connecting hardware modules via statically scheduled, streaming interfaces.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385983", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Durst", + "institution": "Stanford University" + }, + { + "first_name": "Matthew", + "last_name": "Feldman", + "institution": "Stanford University" + }, + { + "first_name": "Dillon", + "last_name": "Huff", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Akeley", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Ross", + "last_name": "Daly", + "institution": "Stanford University" + }, + { + "first_name": "Gilbert", + "last_name": "Bernstein", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "Stanford University" + }, + { + "first_name": "Kayvon", + "last_name": "Fatahalian", + "institution": "Stanford University" + }, + { + "first_name": "Pat", + "last_name": "Hanrahan", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/DurstFHADBPFH20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386003", + "title": "FreezeML: complete and easy type inference for first-class polymorphism", + "abstract": "ML is remarkable in providing statically typed polymorphism without the programmer ever having to write any type annotations. The cost of this parsimony is that the programmer is limited to a form of polymorphism in which quantifiers can occur only at the outermost level of a type and type variables can be instantiated only with monomorphic types.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386003", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Frank", + "last_name": "Emrich", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "Imperial College London" + }, + { + "first_name": "Jan", + "last_name": "Stolarek", + "institution": "Lodz University of Technology" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jonathan", + "last_name": "Coates", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/EmrichLSCC20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386019", + "title": "NV: an intermediate language for verification of network control planes", + "abstract": "Network misconfiguration has caused a raft of high-profile outages over the past decade, spurring researchers to develop a variety of network analysis and verification tools. Unfortunately, developing and maintaining such tools is an enormous challenge due to the complexity of network configuration languages. Inspired by work on intermediate languages for verification such as Boogie and Why3, we develop NV, an intermediate language for verification of network control planes. NV carefully walks the line between expressiveness and tractability, making it possible to build models for a practical subset of real protocols and their configurations, and also facilitate rapid development of tools that outperform state-of-the-art simulators (seconds vs minutes) and verifiers (often 10x faster). Furthermore, we show that it is possible to develop novel analyses just by writing new NV programs. In particular, we implement a new fault-tolerance analysis that scales to far larger networks than existing tools.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386019", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nick", + "last_name": "Giannarakis", + "institution": "Princeton University" + }, + { + "first_name": "Devon", + "last_name": "Loehr", + "institution": "Princeton University" + }, + { + "first_name": "Ryan", + "last_name": "Beckett", + "institution": "Microsoft (United States)" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/GiannarakisLBW20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385991", + "title": "Crafty: efficient, HTM-compatible persistent transactions", + "abstract": "Byte-addressable persistent memory, such as Intel/Micron 3D XPoint, is an emerging technology that bridges the gap between volatile memory and persistent storage. Data in persistent memory survives crashes and restarts; however, it is challenging to ensure that this data is consistent after failures. Existing approaches incur significant performance costs to ensure crash consistency.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385991", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kaan", + "last_name": "Genç", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/GencBX20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386016", + "title": "Learning fast and precise numerical analysis", + "abstract": "Numerical abstract domains are a key component of modern static analyzers. Despite recent advances, precise analysis with highly expressive domains remains too costly for many real-world programs. To address this challenge, we introduce a new data-driven method, called LAIT, that produces a faster and more scalable numerical analysis without significant loss of precision. Our approach is based on the key insight that sequences of abstract elements produced by the analyzer contain redundancy which can be exploited to increase performance without compromising precision significantly. Concretely, we present an iterative learning algorithm that learns a neural policy that identifies and removes redundant constraints at various points in the sequence. We believe that our method is generic and can be applied to various numerical domains.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386016", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jingxuan", + "last_name": "He", + "institution": "ETH Zurich" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "ETH Zurich" + }, + { + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/HeSPV20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385979", + "title": "Exact and approximate methods for proving unrealizability of syntax-guided synthesis problems", + "abstract": "We consider the problem of automatically establishing that a given syntax-guided-synthesis (SyGuS) problem is unrealizable (i.e., has no solution). We formulate the problem of proving that a SyGuS problem is unrealizable over a finite set of examples as one of solving a set of equations: the solution yields an overapproximation of the set of possible outputs that any term in the search space can produce on the given examples. If none of the possible outputs agrees with all of the examples, our technique has proven that the given SyGuS problem is unrealizable. We then present an algorithm for exactly solving the set of equations that result from SyGuS problems over linear integer arithmetic (LIA) and LIA with conditionals (CLIA), thereby showing that LIA and CLIA SyGuS problems over finitely many examples are decidable. We implement the proposed technique and algorithms in a tool called Nay. Nay can prove unrealizability for 70/132 existing SyGuS benchmarks, with running times comparable to those of the state-of-the-art tool Nope. Moreover, Nay can solve 11 benchmarks that Nope cannot solve.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385979", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qinheping", + "last_name": "Hu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "John", + "last_name": "Cyphert", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D'Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/HuCDR20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386032", + "title": "Faster general parsing through context-free memoization", + "abstract": "We present a novel parsing algorithm for all context-free languages. The algorithm features a clean mathematical formulation: parsing is expressed as a series of standard operations on regular languages and relations. Parsing complexity w.r.t. input length matches the state of the art: it is worst-case cubic, quadratic for unambiguous grammars, and linear for LR-regular grammars. What distinguishes our approach is that parsing can be implemented using only immutable, acyclic data structures. We also propose a parsing optimization technique called context-free memoization. It allows handling an overwhelming majority of input symbols using a simple stack and a lookup table, similarly to the operation of a deterministic LR(1) parser. This allows our proof-of-concept implementation to outperform the best current implementations of common generalized parsing algorithms (Earley, GLR, and GLL). Tested on a large Java source corpus, parsing is 3–5 times faster, while recognition—35 times faster.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386032", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Grzegorz", + "last_name": "Herman", + "institution": "Jagiellonian University" + } + ], + "dblp_key": "conf/pldi/Herman20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385982", + "title": "Securing smart contract with runtime validation", + "abstract": "We present Solythesis, a source to source Solidity compiler which takes a smart contract code and a user specified invariant as the input and produces an instrumented contract that rejects all transactions that violate the invariant. The design of Solythesis is driven by our observation that the consensus protocol and the storage layer are the primary and the secondary performance bottlenecks of Ethereum, respectively. Solythesis operates with our novel delta update and delta check techniques to minimize the overhead caused by the instrumented storage access statements. Our experimental results validate our hypothesis that the overhead of runtime validation, which is often too expensive for other domains, is in fact negligible for smart contracts. The CPU overhead of Solythesis is only 0.1% on average for our 23 benchmark contracts.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385982", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ao", + "last_name": "Li", + "institution": "University of Toronto" + }, + { + "first_name": "Jemin Andrew", + "last_name": "Choi", + "institution": "University of Toronto" + }, + { + "first_name": "Fan", + "last_name": "Long", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/pldi/LiCL20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385978", + "title": "A marriage of pointer- and epoch-based reclamation", + "abstract": "All pointer-based nonblocking concurrent data structures should deal with the problem of safe memory reclamation: before reclaiming a memory block, a thread should ensure no other threads hold a local pointer to the block that may later be dereferenced. Various safe memory reclamation schemes have been proposed in the literature, but none of them satisfy the following desired properties at the same time: (i) robust: a non-cooperative thread does not prevent the other threads from reclaiming an unbounded number of blocks; (ii) fast: it does not incur significant time overhead; (iii) compact: it does not incur significant space overhead; (iv) self-contained: it neither relies on special hardware/OS supports nor intrusively affects execution environments; and (v) widely applicable: it supports many data structures.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385978", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "JaeHwang", + "last_name": "Jung", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "conf/pldi/KangJ20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386020", + "title": "Debug information validation for optimized code", + "abstract": "Almost all modern production software is compiled with optimization. Debugging optimized code is a desirable functionality. For example, developers usually perform post-mortem debugging on the coredumps produced by software crashes. Designing reliable debugging techniques for optimized code has been well-studied in the past. However, little is known about the correctness of the debug information generated by optimizing compilers when debugging optimized code.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386020", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuanbo", + "last_name": "Li", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Shuo", + "last_name": "Ding", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Davide", + "last_name": "Italiano", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/pldi/LiDZI20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386027", + "title": "Reconciling enumerative and deductive program synthesis", + "abstract": "Syntax-guided synthesis (SyGuS) aims to find a program satisfying semantic specification as well as user-provided structural hypotheses. There are two main synthesis approaches: enumerative synthesis, which repeatedly enumerates possible candidate programs and checks their correctness, and deductive synthesis, which leverages a symbolic procedure to construct implementations from specifications. Neither approach is strictly better than the other: automated deductive synthesis is usually very efficient but only works for special grammars or applications; enumerative synthesis is very generally applicable but limited in scalability.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386027", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kangjing", + "last_name": "Huang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Peiyuan", + "last_name": "Shen", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yanjun", + "last_name": "Wang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/HuangQSW20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385966", + "title": "Decidable verification under a causally consistent shared memory", + "abstract": "Causal consistency is one of the most fundamental and widely used consistency models weaker than sequential consistency. In this paper, we study the verification of safety properties for finite-state concurrent programs running under a causally consistent shared memory model. We establish the decidability of this problem for a standard model of causal consistency (called also \"Causal Convergence\" and \"Strong-Release-Acquire\"). Our proof proceeds by developing an alternative operational semantics, based on the notion of a thread potential, that is equivalent to the existing declarative semantics and constitutes a well-structured transition system. In particular, our result allows for the verification of a large family of programs in the Release/Acquire fragment of C/C++11 (RA). Indeed, while verification under RA was recently shown to be undecidable for general programs, since RA coincides with the model we study here for write/write-race-free programs, the decidability of verification under RA for this widely used class of programs follows from our result. The novel operational semantics may also be of independent use in the investigation of weakly consistent shared memory models and their verification.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385966", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Udi", + "last_name": "Boker", + "institution": "Reichman University" + } + ], + "dblp_key": "conf/pldi/LahavB20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386018", + "title": "First-order quantified separators", + "abstract": "Quantified first-order formulas, often with quantifier alternations, are increasingly used in the verification of complex systems. While automated theorem provers for first-order logic are becoming more robust, invariant inference tools that handle quantifiers are currently restricted to purely universal formulas. We define and analyze first-order quantified separators and their application to inferring quantified invariants with alternations. A separator for a given set of positively and negatively labeled structures is a formula that is true on positive structures and false on negative structures. We investigate the problem of finding a separator from the class of formulas in prenex normal form with a bounded number of quantifiers and show this problem is NP-complete by reduction to and from SAT. We also give a practical separation algorithm, which we use to demonstrate the first invariant inference procedure able to infer invariants with quantifier alternations.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386018", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jason R.", + "last_name": "Koenig", + "institution": "Stanford University" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Stanford University" + }, + { + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/KoenigPIA20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386025", + "title": "Question selection for interactive program synthesis", + "abstract": "Interactive program synthesis aims to solve the ambiguity in specifications, and selecting the proper question to minimize the rounds of interactions is critical to the performance of interactive program synthesis. In this paper we address this question selection problem and propose two algorithms. SampleSy approximates a state-of-the-art strategy proposed for optimal decision tree and has a short response time to enable interaction. EpsSy further reduces the rounds of interactions by approximating SampleSy with a bounded error rate. To implement the two algorithms, we further propose VSampler, an approach to sampling programs from a probabilistic context-free grammar based on version space algebra. The evaluation shows the effectiveness of both algorithms.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386025", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ruyi", + "last_name": "Ji", + "institution": "Peking University" + }, + { + "first_name": "Jingjing", + "last_name": "Liang", + "institution": "Peking University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Lu", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "conf/pldi/JiLXZH20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386029", + "title": "Verifying concurrent search structure templates", + "abstract": "Concurrent separation logics have had great success reasoning about concurrent data structures. This success stems from their application of modularity on multiple levels, leading to proofs that are decomposed according to program structure, program state, and individual threads. Despite these advances, it remains difficult to achieve proof reuse across different data structure implementations. For the large class of search structures, we demonstrate how one can achieve further proof modularity by decoupling the proof of thread safety from the proof of structural integrity. We base our work on the template algorithms of Shasha and Goodman that dictate how threads interact but abstract from the concrete layout of nodes in memory. Building on the recently proposed flow framework of compositional abstractions and the separation logic Iris, we show how to prove correctness of template algorithms, and how to instantiate them to obtain multiple verified implementations.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386029", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Siddharth", + "last_name": "Krishna", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Nisarg", + "last_name": "Patel", + "institution": "New York University" + }, + { + "first_name": "Dennis", + "last_name": "Shasha", + "institution": "New York University" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "conf/pldi/KrishnaPSW20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385980", + "title": "Inductive sequentialization of asynchronous programs", + "abstract": "Asynchronous programs are notoriously difficult to reason about because they spawn computation tasks which take effect asynchronously in a nondeterministic way. Devising inductive invariants for such programs requires understanding and stating complex relationships between an unbounded number of computation tasks in arbitrarily long executions. In this paper, we introduce inductive sequentialization, a new proof rule that sidesteps this complexity via a sequential reduction, a sequential program that captures every behavior of the original program up to reordering of coarse-grained commutative actions. A sequential reduction of a concurrent program is easy to reason about since it corresponds to a simple execution of the program in an idealized synchronous environment, where processes act in a fixed order and at the same speed. We have implemented and integrated our proof rule in the CIVL verifier, allowing us to provably derive fine-grained implementations of asynchronous programs. We have successfully applied our proof rule to a diverse set of message-passing protocols, including leader election protocols, two-phase commit, and Paxos.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385980", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bernhard", + "last_name": "Kragl", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Süha Orhun", + "last_name": "Mutluergil", + "institution": "Institut de Recherche en Informatique Fondamentale" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "California Institute for Biomedical Research" + } + ], + "dblp_key": "conf/pldi/KraglEHMQ20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386010", + "title": "Promising 2.0: global optimizations in relaxed memory concurrency", + "abstract": "For more than fifteen years, researchers have tried to support global optimizations in a usable semantics for a concurrent programming language, yet this task has been proven to be very difficult because of (1) the infamous “out of thin air” problem, and (2) the subtle interaction between global and thread-local optimizations.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386010", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sung-Hwan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Anton", + "last_name": "Podkopaev", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Indian Institute of Technology Delhi" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/LeeCPCHLV20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386033", + "title": "Compiler-directed soft error resilience for lightweight GPU register file protection", + "abstract": "This paper presents Penny, a compiler-directed resilience scheme for protecting GPU register files (RF) against soft errors. Penny replaces the conventional error correction code (ECC) based RF protection by using less expensive error detection code (EDC) along with idempotence based recovery. Compared to the ECC protection, Penny can achieve either the same level of RF resilience yet with significantly lower hardware costs or stronger resilience using the same ECC due to its ability to detect multi-bit errors when it is used solely for detection. In particular, to address the lack of store buffers in GPUs, which causes both checkpoint storage overwriting and the high cost of checkpointing stores, Penny provides several compiler optimizations such as storage coloring and checkpoint pruning. Across 25 benchmarks, Penny causes only ≈3% run-time overhead on average.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386033", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongjune", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Jianping", + "last_name": "Zeng", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Qingrui", + "last_name": "Liu", + "institution": "" + }, + { + "first_name": "Mohammad", + "last_name": "Abdel-Majeed", + "institution": "University of Jordan" + }, + { + "first_name": "Jaejin", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Changhee", + "last_name": "Jung", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/KimZLALJ20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385996", + "title": "Optimizing homomorphic evaluation circuits by program synthesis and term rewriting", + "abstract": "We present a new and general method for optimizing homomorphic evaluation circuits. Although fully homomorphic encryption (FHE) holds the promise of enabling safe and secure third party computation, building FHE applications has been challenging due to their high computational costs. Domain-specific optimizations require a great deal of expertise on the underlying FHE schemes, and FHE compilers that aims to lower the hurdle, generate outcomes that are typically sub-optimal as they rely on manually-developed optimization rules. In this paper, based on the prior work of FHE compilers, we propose a method for automatically learning and using optimization rules for FHE circuits. Our method focuses on reducing the maximum multiplicative depth, the decisive performance bottleneck, of FHE circuits by combining program synthesis and term rewriting. It first uses program synthesis to learn equivalences of small circuits as rewrite rules from a set of training circuits. Then, we perform term rewriting on the input circuit to obtain a new circuit that has lower multiplicative depth. Our rewriting method maximally generalizes the learned rules based on the equational matching and its soundness and termination properties are formally proven. Experimental results show that our method generates circuits that can be homomorphically evaluated 1.18x – 3.71x faster (with the geometric mean of 2.05x) than the state-of-the-art method. Our method is also orthogonal to existing domain-specific optimizations.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385996", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dong-Kwon", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Woosuk", + "last_name": "Lee", + "institution": "Hanyang University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/pldi/LeeLOY20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386021", + "title": "Fast graph simplification for interleaved Dyck-reachability", + "abstract": "Many program-analysis problems can be formulated as graph-reachability problems. Interleaved Dyck language reachability. Interleaved Dyck language reachability (InterDyck-reachability) is a fundamental framework to express a wide variety of program-analysis problems over edge-labeled graphs. The InterDyck language represents an intersection of multiple matched-parenthesis languages (i.e., Dyck languages). In practice, program analyses typically leverage one Dyck language to achieve context-sensitivity, and other Dyck languages to model data dependences, such as field-sensitivity and pointer references/dereferences. In the ideal case, an InterDyck-reachability framework should model multiple Dyck languages simultaneously.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386021", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuanbo", + "last_name": "Li", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/LiZR20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386012", + "title": "Synthesizing structured CAD models with equality saturation and inverse transformations", + "abstract": "Recent program synthesis techniques help users customize CAD models(e.g., for 3D printing) by decompiling low-level triangle meshes to Constructive Solid Geometry (CSG) expressions. Without loops or functions, editing CSG can require many coordinated changes, and existing mesh decompilers use heuristics that can obfuscate high-level structure.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386012", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chandrakana", + "last_name": "Nandi", + "institution": "University of Washington" + }, + { + "first_name": "Max", + "last_name": "Willsey", + "institution": "University of Washington" + }, + { + "first_name": "Adam", + "last_name": "Anderson", + "institution": "University of Washington" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "" + }, + { + "first_name": "Eva", + "last_name": "Darulova", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/NandiWAWDGT20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385971", + "title": "Armada: low-effort verification of high-performance concurrent programs", + "abstract": "Safely writing high-performance concurrent programs is notoriously difficult. To aid developers, we introduce Armada, a language and tool designed to formally verify such programs with relatively little effort. Via a C-like language and a small-step, state-machine-based semantics, Armada gives developers the flexibility to choose arbitrary memory layout and synchronization primitives so they are never constrained in their pursuit of performance. To reduce developer effort, Armada leverages SMT-powered automation and a library of powerful reasoning techniques, including rely-guarantee, TSO elimination, reduction, and alias analysis. All these techniques are proven sound, and Armada can be soundly extended with additional strategies over time. Using Armada, we verify four concurrent case studies and show that we can achieve performance equivalent to that of unverified code.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385971", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jacob R.", + "last_name": "Lorch", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Yixuan", + "last_name": "Chen", + "institution": "University of Michigan" + }, + { + "first_name": "Manos", + "last_name": "Kapritsos", + "institution": "University of Michigan" + }, + { + "first_name": "Bryan", + "last_name": "Parno", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "California Institute for Biomedical Research" + }, + { + "first_name": "Upamanyu", + "last_name": "Sharma", + "institution": "University of Michigan" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "" + }, + { + "first_name": "Xueyuan", + "last_name": "Zhao", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/LorchCKPQSWZ20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385998", + "title": "Adaptive low-overhead scheduling for periodic and reactive intermittent execution", + "abstract": "Batteryless energy-harvesting devices eliminate the need in batteries for deployed sensor systems, enabling longer lifetime and easier maintenance. However, such devices cannot support an event-driven execution model (e.g., periodic or reactive execution), restricting the use cases and hampering real-world deployment. Without knowing exactly how much energy can be harvested in the future, robustly scheduling periodic and reactive workloads is challenging. We introduce CatNap, an event-driven energy-harvesting system with a new programming model that asks the programmer to express a subset of the code that is time-critical. CatNap isolates and reserves energy for the time-critical code, reliably executing it on schedule while deferring execution of the rest of the code. CatNap degrades execution quality when a decrease in the incoming power renders it impossible to maintain its schedule. Our evaluation on a real energy-harvesting setup shows that CatNap works well with end-to-end, real-world deployment settings. CatNap reliably runs periodic events when a prior system misses the deadline by 7.3x and supports reactive applications with a 100% success rate when a prior work shows less than a 2% success rate.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385998", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kiwan", + "last_name": "Maeng", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/MaengL20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386036", + "title": "Understanding memory and thread safety practices and issues in real-world Rust programs", + "abstract": "Rust is a young programming language designed for systems software development. It aims to provide safety guarantees like high-level languages and performance efficiency like low-level languages. The core design of Rust is a set of strict safety rules enforced by compile-time checking. To support more low-level controls, Rust allows programmers to bypass these compiler checks to write unsafe code.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386036", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Boqin", + "last_name": "Qin", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Yilun", + "last_name": "Chen", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Zeming", + "last_name": "Yu", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Linhai", + "last_name": "Song", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Yiying", + "last_name": "Zhang", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/QinCYSZ20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385993", + "title": "SmartTrack: efficient predictive race detection", + "abstract": "Widely used data race detectors, including the state-of-the-art FastTrack algorithm, incur performance costs that are acceptable for regular in-house testing, but miss races detectable from the analyzed execution. Predictive analyses detect more data races in an analyzed execution than FastTrack detects, but at significantly higher performance cost.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385993", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jake", + "last_name": "Roemer", + "institution": "The Ohio State University" + }, + { + "first_name": "Kaan", + "last_name": "Genç", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/pldi/RoemerGB20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386013", + "title": "Responsive parallelism with futures and state", + "abstract": "Motivated by the increasing shift to multicore computers, recent work has developed language support for responsive parallel applications that mix compute-intensive tasks with latency-sensitive, usually interactive, tasks. These developments include calculi that allow assigning priorities to threads, type systems that can rule out priority inversions, and accompanying cost models for predicting responsiveness. These advances share one important limitation: all of this work assumes purely functional programming. This is a significant restriction, because many realistic interactive applications, from games to robots to web servers, use mutable state, e.g., for communication between threads.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386013", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kyle", + "last_name": "Singer", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Noah", + "last_name": "Goldstein", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kunal", + "last_name": "Agrawal", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "I-Ting Angelina", + "last_name": "Lee", + "institution": "Washington University in St. Louis" + } + ], + "dblp_key": "conf/pldi/MullerSGAAL20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385967", + "title": "Data-driven inference of representation invariants", + "abstract": "A representation invariant is a property that holds of all values of abstract type produced by a module. Representation invariants play important roles in software engineering and program verification. In this paper, we develop a counterexample-driven algorithm for inferring a representation invariant that is sufficient to imply a desired specification for a module. The key novelty is a type-directed notion of visible inductiveness, which ensures that the algorithm makes progress toward its goal as it alternates between weakening and strengthening candidate invariants. The algorithm is parameterized by an example-based synthesis engine and a verifier, and we prove that it is sound and complete for first-order modules over finite types, assuming that the synthesizer and verifier are as well. We implement these ideas in a tool called Hanoi, which synthesizes representation invariants for recursive data types. Hanoi not only handles invariants for first-order code, but higher-order code as well. In its back end, Hanoi uses an enumerative synthesizer called Myth and an enumerative testing tool as a verifier. Because Hanoi uses testing for verification, it is not sound, though our empirical evaluation shows that it is successful on the benchmarks we investigated.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385967", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anders", + "last_name": "Miltner", + "institution": "Princeton University" + }, + { + "first_name": "Saswat", + "last_name": "Padhi", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/MiltnerPMW20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385989", + "title": "Automated derivation of parametric data movement lower bounds for affine programs", + "abstract": "Researchers and practitioners have for long worked on improving the computational complexity of algorithms, focusing on reducing the number of operations needed to perform a computation. However the hardware trend nowadays clearly shows a higher performance and energy cost for data movements than computations: quality algorithms have to minimize data movements as much as possible.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385989", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Auguste", + "last_name": "Olivry", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Julien", + "last_name": "Langou", + "institution": "University of Colorado Denver" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Colorado State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "University of Utah" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut polytechnique de Grenoble" + } + ], + "dblp_key": "conf/pldi/OlivryLPSR20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385974", + "title": "Predictable accelerator design with time-sensitive affine types", + "abstract": "Field-programmable gate arrays (FPGAs) provide an opportunity to co-design applications with hardware accelerators, yet they remain difficult to program. High-level synthesis (HLS) tools promise to raise the level of abstraction by compiling C or C++ to accelerator designs. Repurposing legacy software languages, however, requires complex heuristics to map imperative code onto hardware structures. We find that the black-box heuristics in HLS can be unpredictable: changing parameters in the program that should improve performance can counterintuitively yield slower and larger designs. This paper proposes a type system that restricts HLS to programs that can predictably compile to hardware accelerators. The key idea is to model consumable hardware resources with a time-sensitive affine type system that prevents simultaneous uses of the same hardware structure. We implement the type system in Dahlia, a language that compiles to HLS C++, and show that it can reduce the size of HLS parameter spaces while accepting Pareto-optimal designs.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385974", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rachit", + "last_name": "Nigam", + "institution": "Cornell University" + }, + { + "first_name": "Sachille", + "last_name": "Atapattu", + "institution": "Cornell University" + }, + { + "first_name": "Samuel", + "last_name": "Thomas", + "institution": "Cornell University" + }, + { + "first_name": "Zhijing", + "last_name": "Li", + "institution": "Cornell University" + }, + { + "first_name": "T.H.", + "last_name": "Bauer", + "institution": "Cornell University" + }, + { + "first_name": "Yuwei", + "last_name": "Ye", + "institution": "Cornell University" + }, + { + "first_name": "Apurva", + "last_name": "Koti", + "institution": "Cornell University" + }, + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "Cornell University" + }, + { + "first_name": "Zhiru", + "last_name": "Zhang", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/NigamATLBYKSZ20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385962", + "title": "OOElala: order-of-evaluation based alias analysis for compiler optimization", + "abstract": "In C, the order of evaluation of expressions is unspecified; further for expressions that do not involve function calls, C semantics ensure that there cannot be a data race between two evaluations that can proceed in either order (or concurrently). We explore the optimization opportunity enabled by these non-deterministic expression evaluation semantics in C, and provide a sound compile-time alias analysis to realize the same. Our algorithm is implemented as a part of the Clang/LLVM infrastructure, in a tool called OOElala. Our experimental results demonstrate that the untapped optimization opportunity is significant: code patterns that enable such optimizations are common; the enabled transformations can range from vectorization to improved instruction selection and register allocation; and the resulting speedups can be as high as 2.6x on already-optimized code.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385962", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ankush", + "last_name": "Phulia", + "institution": "Indian Institute of Technology Delhi" + }, + { + "first_name": "Vaibhav", + "last_name": "Bhagee", + "institution": "Indian Institute of Technology Delhi" + }, + { + "first_name": "Sorav", + "last_name": "Bansal", + "institution": "Indian Institute of Technology Delhi" + } + ], + "dblp_key": "conf/pldi/PhuliaBB20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386017", + "title": "BlankIt library debloating: getting what you want instead of cutting what you don't", + "abstract": "Modern software systems make extensive use of libraries derived from C and C++. Because of the lack of memory safety in these languages, however, the libraries may suffer from vulnerabilities, which can expose the applications to potential attacks. For example, a very large number of return-oriented programming gadgets exist in glibc that allow stitching together semantically valid but malicious Turing-complete and -incomplete programs. While CVEs get discovered and often patched and remedied, such gadgets serve as building blocks of future undiscovered attacks, opening an ever-growing set of possibilities for generating malicious programs. Thus, significant reduction in the quantity and expressiveness (utility) of such gadgets for libraries is an important problem.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386017", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chris", + "last_name": "Porter", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Girish", + "last_name": "Mururu", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Prithayan", + "last_name": "Barua", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/pldi/PorterMBP20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386001", + "title": "Semantic code search via equational reasoning", + "abstract": "We present a new approach to semantic code search based on equational reasoning, and the Yogo tool implementing this approach. Our approach works by considering not only the dataflow graph of a function, but also the dataflow graphs of all equivalent functions reachable via a set of rewrite rules. In doing so, it can recognize an operation even if it uses alternate APIs, is in a different but mathematically-equivalent form, is split apart with temporary variables, or is interleaved with other code. Furthermore, it can recognize when code is an instance of some higher-level concept such as iterating through a file. Because of this, from a single query, Yogo can find equivalent code in multiple languages. Our evaluation further shows the utility of Yogo beyond code search: encoding a buggy pattern as a Yogo query, we found a bug in Oracle’s Graal compiler which had been missed by a hand-written static analyzer designed for that exact kind of bug. Yogo is built on the Cubix multi-language infrastructure, and currently supports Java and Python.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386001", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Varot", + "last_name": "Premtoon", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "James", + "last_name": "Koppel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/PremtoonKS20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386030", + "title": "Effective function merging in the SSA form", + "abstract": "Function merging is an important optimization for reducing code size. This technique eliminates redundant code across functions by merging them into a single function. While initially limited to identical or trivially similar functions, the most recent approach can identify all merging opportunities in arbitrary pairs of functions. However, this approach has a serious limitation which prevents it from reaching its full potential. Because it cannot handle phi-nodes, the state-of-the-art applies register demotion to eliminate them before applying its core algorithm. While a superficially minor workaround, this has a three-fold negative effect: by artificially lengthening the instruction sequences to be aligned, it hinders the identification of mergeable instruction; it prevents a vast number of functions from being profitably merged; it increases compilation overheads, both in terms of compile-time and memory usage.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386030", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rodrigo C. O.", + "last_name": "Rocha", + "institution": "University of Edinburgh" + }, + { + "first_name": "Pavlos", + "last_name": "Petoumenos", + "institution": "University of Manchester" + }, + { + "first_name": "Zheng", + "last_name": "Wang", + "institution": "University of Leeds" + }, + { + "first_name": "Murray", + "last_name": "Cole", + "institution": "University of Edinburgh" + }, + { + "first_name": "Hugh", + "last_name": "Leather", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/RochaP0CL20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386005", + "title": "Type error feedback via analytic program repair", + "abstract": "We introduce Analytic Program Repair, a data-driven strategy for providing feedback for type-errors via repairs for the erroneous program. Our strategy is based on insight that similar errors have similar repairs. Thus, we show how to use a training dataset of pairs of ill-typed programs and their fixed versions to: (1) learn a collection of candidate repair templates by abstracting and partitioning the edits made in the training set into a representative set of templates; (2) predict the appropriate template from a given error, by training multi-class classifiers on the repair templates used in the training set; (3) synthesize a concrete repair from the template by enumerating and ranking correct (e.g. well-typed) terms matching the predicted template. We have implemented our approach in Rite: a type error reporting tool for OCaml programs. We present an evaluation of the accuracy and efficiency of Rite on a corpus of 4,500 ill-typed Ocaml programs drawn from two instances of an introductory programming course, and a user-study of the quality of the generated error messages that shows the locations and final repair quality to be better than the state-of-the-art tool in a statistically-significant manner.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386005", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Georgios K.", + "last_name": "Sakkas", + "institution": "University of California, San Diego" + }, + { + "first_name": "Madeline", + "last_name": "Endres", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Benjamin", + "last_name": "Cosman", + "institution": "University of California, San Diego" + }, + { + "first_name": "Westley", + "last_name": "Weimer", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/SakkasECWJ20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386024", + "title": "LLHD: a multi-level intermediate representation for hardware description languages", + "abstract": "Modern Hardware Description Languages (HDLs) such as SystemVerilog or VHDL are, due to their sheer complexity, insufficient to transport designs through modern circuit design flows. Instead, each design automation tool lowers HDLs to its own Intermediate Representation (IR). These tools are monolithic and mostly proprietary, disagree in their implementation of HDLs, and while many redundant IRs exists, no IR today can be used through the entire circuit design flow. To solve this problem, we propose the LLHD multi-level IR. LLHD is designed as simple, unambiguous reference description of a digital circuit, yet fully captures existing HDLs. We show this with our reference compiler on designs as complex as full CPU cores. LLHD comes with lowering passes to a hardware-near structural IR, which readily integrates with existing tools. LLHD establishes the basis for innovation in HDLs and tools without redundant compilers or disjoint IRs. For instance, we implement an LLHD simulator that runs up to 2.4× faster than commercial simulators but produces equivalent, cycle-accurate results. An initial vertically-integrated research prototype is capable of representing all levels of the IR, implements lowering from the behavioural to the structural IR, and covers a sufficient subset of SystemVerilog to support a full CPU design.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386024", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Schuiki", + "institution": "ETH Zurich" + }, + { + "first_name": "Andreas", + "last_name": "Kurth", + "institution": "ETH Zurich" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "ETH Zurich" + }, + { + "first_name": "Luca", + "last_name": "Benini", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/SchuikiKGB20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386014", + "title": "Gillian, part i: a multi-language platform for symbolic execution", + "abstract": "We introduce Gillian, a platform for developing symbolic analysis tools for programming languages. Here, we focus on the symbolic execution engine at the heart of Gillian, which is parametric on the memory model of the target language. We give a formal description of the symbolic analysis and a modular implementation that closely follows this description. We prove a parametric soundness result, introducing restriction on abstract states, which generalises path conditions used in classical symbolic execution. We instantiate to obtain trusted symbolic testing tools for JavaScript and C, and use these tools to find bugs in real-world code, thus demonstrating the viability of our parametric approach.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386014", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "José Fragoso", + "last_name": "Santos", + "institution": "Imperial College London" + }, + { + "first_name": "Petar", + "last_name": "Maksimović", + "institution": "Imperial College London" + }, + { + "first_name": "Sacha-Élie", + "last_name": "Ayoun", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/pldi/SantosMAG20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385977", + "title": "Improving program locality in the GC using hotness", + "abstract": "The hierarchical memory system with increasingly small and increasingly fast memory closer to the CPU has for long been at the heart of hiding, or mitigating the performance gap between memories and processors. To utilise this hardware, programs must be written to exhibit good object locality. In languages like C/C++, programmers can carefully plan how objects should be laid out (albeit time consuming and error-prone); for managed languages, especially ones with moving garbage collectors, a manually created optimal layout may be destroyed in the process of object relocation. For managed languages that present an abstract view of memory, the solution lies in making the garbage collector aware of object locality, and strive to achieve and maintain good locality, even in the face of multi-phased programs that exhibit different behaviour across different phases.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385977", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Albert Mingkun", + "last_name": "Yang", + "institution": "Uppsala University" + }, + { + "first_name": "Erik", + "last_name": "Österlund", + "institution": "" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/pldi/YangOW20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385976", + "title": "Detecting network load violations for distributed control planes", + "abstract": "One of the major challenges faced by network operators pertains to whether their network can meet input traffic demand, avoid overload, and satisfy service-level agreements. Automatically verifying if no network links are overloaded is complicated---requires modeling frequent network failures, complex routing and load-balancing technologies, and evolving traffic requirements. We present QARC, a distributed control plane abstraction that can automatically verify whether a control plane may cause link-load violations under failures. QARC is fully automatic and can help operators program networks that are more resilient to failures and upgrade the network to avoid violations. We apply QARC to real datacenter and ISP networks and find interesting cases of load violations. QARC can detect violations in under an hour.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385976", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kausik", + "last_name": "Subramanian", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Anubhavnidhi", + "last_name": "Abhashkumar", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aditya", + "last_name": "Akella", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/pldi/SubramanianADA20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385987", + "title": "CARAT: a case for virtual memory through compiler- and runtime-based address translation", + "abstract": "Virtual memory is a critical abstraction in modern computer systems. Its common model, paging, is currently seeing considerable innovation, yet its implementations continue to be co-designs between power-hungry/latency-adding hardware (e.g., TLBs, pagewalk caches, pagewalkers, etc) and software (the OS kernel). We make a case for a new model for virtual memory, compiler- and runtime-based address translation (CARAT), which instead is a co-design between the compiler and the OS kernel. CARAT can operate without any hardware support, although it could also be retrofitted into a traditional paging model, and could leverage simpler hardware support. CARAT uses compile-time transformations and optimizations combined with tightly-coupled runtime/kernel interaction to generate programs that run efficiently in a physical address space, but nonetheless allow the kernel to maintain protection and dynamically manage physical memory similar to what is possible using traditional virtual memory. We argue for the feasibility of CARAT through an empirical study of application characteristics and kernel behavior, as well as through the design, implementation, and performance evaluation of a CARAT prototype. Because our prototype works at the IR level (in particular, via LLVM bitcode), it can be applied to most C and C++ programs with minimal or no restrictions.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385987", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Brian", + "last_name": "Suchy", + "institution": "Northwestern University" + }, + { + "first_name": "Simone", + "last_name": "Campanoni", + "institution": "Northwestern University" + }, + { + "first_name": "Nikos", + "last_name": "Hardavellas", + "institution": "Northwestern University" + }, + { + "first_name": "Peter A.", + "last_name": "Dinda", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/pldi/SuchyCHD20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386008", + "title": "CacheQuery: learning replacement policies from hardware caches", + "abstract": "We show how to infer deterministic cache replacement policies using off-the-shelf automata learning and program synthesis techniques. For this, we construct and chain two abstractions that expose the cache replacement policy of any set in the cache hierarchy as a membership oracle to the learning algorithm, based on timing measurements on a silicon CPU. Our experiments demonstrate an advantage in scope and scalability over prior art and uncover two previously undocumented cache replacement policies.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386008", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Pepe", + "last_name": "Vila", + "institution": "Universidad Politécnica de Madrid" + }, + { + "first_name": "Pierre", + "last_name": "Ganty", + "institution": "IMDEA Software" + }, + { + "first_name": "Marco", + "last_name": "Guarnieri", + "institution": "IMDEA Software" + }, + { + "first_name": "Boris", + "last_name": "Köpf", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/VilaGGK20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386000", + "title": "PMThreads: persistent memory threads harnessing versioned shadow copies", + "abstract": "Byte-addressable non-volatile memory (NVM) makes it possible to perform fast in-memory accesses to persistent data using standard load/store processor instructions. Some approaches for NVM are based on durable memory transactions and provide a persistent programming paradigm. However, they cannot be applied to existing multi-threaded applications without extensive source code modifications. Durable transactions typically rely on logging to enforce failure-atomic commits that include additional writes to NVM and considerable ordering overheads.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386000", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhenwei", + "last_name": "Wu", + "institution": "University of Manchester" + }, + { + "first_name": "Kai", + "last_name": "Lü", + "institution": "National University of Defense Technology" + }, + { + "first_name": "A.", + "last_name": "Nisbet", + "institution": "University of Manchester" + }, + { + "first_name": "Wenzhe", + "last_name": "Zhang", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Mikel", + "last_name": "Luján", + "institution": "University of Manchester" + } + ], + "dblp_key": "conf/pldi/WuLNZL20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385973", + "title": "Repairing and mechanising the JavaScript relaxed memory model", + "abstract": "Modern JavaScript includes the SharedArrayBuffer feature, which provides access to true shared memory concurrency. SharedArrayBuffers are simple linear buffers of bytes, and the JavaScript specification defines an axiomatic relaxed memory model to describe their behaviour. While this model is heavily based on the C/C++11 model, it diverges in some key areas. JavaScript chooses to give a well-defined semantics to data-races, unlike the \"undefined behaviour\" of C/C++11. Moreover, the JavaScript model is mixed-size. This means that its accesses are not to discrete locations, but to (possibly overlapping) ranges of bytes.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385973", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "University of Cambridge" + }, + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Anton", + "last_name": "Podkopaev", + "institution": "National Research University Higher School of Economics" + }, + { + "first_name": "Guillaume", + "last_name": "Barbier", + "institution": "École Normale Supérieure de Rennes" + }, + { + "first_name": "Stephen K.", + "last_name": "Dolan", + "institution": "University of Cambridge" + }, + { + "first_name": "Shaked", + "last_name": "Flur", + "institution": "University of Cambridge" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "University of Cambridge" + }, + { + "first_name": "Shuyu", + "last_name": "Guo", + "institution": "Bloomberg (United States)" + } + ], + "dblp_key": "conf/pldi/WattPPBDFPG20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385985", + "title": "Validating SMT solvers via semantic fusion", + "abstract": "We introduce Semantic Fusion, a general, effective methodology for validating Satisfiability Modulo Theory (SMT) solvers. Our key idea is to fuse two existing equisatisfiable (i.e., both satisfiable or unsatisfiable) formulas into a new formula that combines the structures of its ancestors in a novel manner and preserves the satisfiability by construction. This fused formula is then used for validating SMT solvers.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385985", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dominik", + "last_name": "Winterer", + "institution": "ETH Zurich" + }, + { + "first_name": "Chengyu", + "last_name": "Zhang", + "institution": "East China Normal University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/WintererZS20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385986", + "title": "Learning nonlinear loop invariants with gated continuous logic networks", + "abstract": "Verifying real-world programs often requires inferring loop invariants with nonlinear constraints. This is especially true in programs that perform many numerical operations, such as control systems for avionics or industrial plants. Recently, data-driven methods for loop invariant inference have shown promise, especially on linear invariants. However, applying data-driven inference to nonlinear loop invariants is challenging due to the large numbers of and magnitudes of high-order terms, the potential for overfitting on a small number of samples, and the large space of possible inequality bounds. In this paper, we introduce a new neural architecture for general SMT learning, the Gated Continuous Logic Network (G-CLN), and apply it to nonlinear loop invariant learning. G-CLNs extend the Continuous Logic Network (CLN) architecture with gating units and dropout, which allow the model to robustly learn general invariants over large numbers of terms. To address overfitting that arises from finite program sampling, we introduce fractional sampling---a sound relaxation of loop semantics to continuous functions that facilitates unbounded sampling on real domain. We additionally design a new CLN activation function, the Piecewise Biased Quadratic Unit (PBQU), for naturally learning tight inequality bounds. We incorporate these methods into a nonlinear loop invariant inference system that can learn general nonlinear loop invariants. We evaluate our system on a benchmark of nonlinear loop invariants and show it solves 26 out of 27 problems, 3 more than prior work, with an average runtime of 53.3 seconds. We further demonstrate the generic learning ability of G-CLNs by solving all 124 problems in the linear Code2Inv benchmark. We also perform a quantitative stability evaluation and show G-CLNs have a convergence rate of $97.5\\%$ on quadratic problems, a $39.2\\%$ improvement over CLN models.", + "date": "2020-03-17", + "link": "https://doi.org/10.1145/3385412.3385986", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yao,", + "last_name": "Jianan", + "institution": "" + }, + { + "first_name": "Ryan,", + "last_name": "Gabriel", + "institution": "" + }, + { + "first_name": "Wong,", + "last_name": "Justin", + "institution": "" + }, + { + "first_name": "Jana,", + "last_name": "Suman", + "institution": "" + }, + { + "first_name": "Gu,", + "last_name": "Ronghui", + "institution": "" + } + ], + "dblp_key": "conf/pldi/YaoRWJG20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3386011", + "title": "On the principles of differentiable quantum programming languages", + "abstract": "Variational Quantum Circuits (VQCs), or the so-called quantum neural-networks, are predicted to be one of the most important near-term quantum applications, not only because of their similar promises as classical neural-networks, but also because of their feasibility on near-term noisy intermediate-size quantum (NISQ) machines. The need for gradient information in the training procedure of VQC applications has stimulated the development of auto-differentiation techniques for quantum circuits. We propose the first formalization of this technique, not only in the context of quantum circuits but also for imperative quantum programs (e.g., with controls), inspired by the success of differentiable programming languages in classical machine learning. In particular, we overcome a few unique difficulties caused by exotic quantum features (such as quantum no-cloning) and provide a rigorous formulation of differentiation applied to bounded-loop imperative quantum programs, its code-transformation rules, as well as a sound logic to reason about their correctness. Moreover, we have implemented our code transformation in OCaml and demonstrated the resource-efficiency of our scheme both analytically and empirically. We also conduct a case study of training a VQC instance with controls, which shows the advantage of our scheme over existing auto-differentiation for quantum circuits without controls.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3386011", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shaopeng", + "last_name": "Zhu", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Shih-Han", + "last_name": "Hung", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Shouvanik", + "last_name": "Chakrabarti", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/ZhuHCW20", + "venue": "pldi", + "year": 2020 + }, + { + "paper_id": "10.1145/3385412.3385961", + "title": "SympleGraph: distributed graph processing with precise loop-carried dependency guarantee", + "abstract": "Graph analytics is an important way to understand relationships in real-world applications. At the age of big data, graphs have grown to billions of edges. This motivates distributed graph processing. Graph processing frameworks ask programmers to specify graph computations in user- defined functions (UDFs) of graph-oriented programming model. Due to the nature of distributed execution, current frameworks cannot precisely enforce the semantics of UDFs, leading to unnecessary computation and communication. In essence, there exists a gap between programming model and runtime execution. This paper proposes SympleGraph, a novel distributed graph processing framework that precisely enforces loop-carried dependency, i.e., when a condition is satisfied by a neighbor, all following neighbors can be skipped. SympleGraph instruments the UDFs to express the loop-carried dependency, then the distributed execution framework enforces the precise semantics by performing dependency propagation dynamically. Enforcing loop-carried dependency requires the sequential processing of the neighbors of each vertex distributed in different nodes. Therefore, the major challenge is to enable sufficient parallelism to achieve high performance. We propose to use circulant scheduling in the framework to allow different machines to process disjoint sets of edges/vertices in parallel while satisfying the sequential requirement. It achieves a good trade-off between precise semantics and parallelism. The significant speedups in most graphs and algorithms indicate that the benefits of eliminating unnecessary computation and communication overshadow the reduced parallelism. Communication efficiency is further optimized by 1) selectively propagating dependency for large-degree vertices to increase net benefits; 2) double buffering to hide communication latency. In a 16-node cluster, SympleGraph outperforms the state-of-the-art system Gemini and D-Galois on average by 1.42× and 3.30×, and up to 2.30× and 7.76×, respectively. The communication reduction compared to Gemini is 40.95% on average and up to 67.48%.", + "date": "2020-06-07", + "link": "https://doi.org/10.1145/3385412.3385961", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Youwei", + "last_name": "Zhuo", + "institution": "University of Southern California" + }, + { + "first_name": "Jingji", + "last_name": "Chen", + "institution": "University of Southern California" + }, + { + "first_name": "Qinyi", + "last_name": "Luo", + "institution": "University of Southern California" + }, + { + "first_name": "Yanzhi", + "last_name": "Wang", + "institution": "Northeastern University" + }, + { + "first_name": "Hailong", + "last_name": "Yang", + "institution": "Beihang University" + }, + { + "first_name": "Depei", + "last_name": "Qian", + "institution": "Beihang University" + }, + { + "first_name": "Xuehai", + "last_name": "Qian", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/pldi/ZhuoCLWYQQ20", + "venue": "pldi", + "year": 2020 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2021.json b/data/pl_conferences/pldi/2021.json new file mode 100644 index 0000000..b016ac2 --- /dev/null +++ b/data/pl_conferences/pldi/2021.json @@ -0,0 +1,3038 @@ +[ + { + "paper_id": "10.1145/3453483.3454090", + "title": "Snapshot-free, transparent, and robust memory reclamation for lock-free data structures", + "abstract": "We present a family of safe memory reclamation schemes, Hyaline, which are fast, scalable, and transparent to the underlying lock-free data structures. Hyaline is based on reference counting -- considered impractical for memory reclamation in the past due to high overheads. Hyaline uses reference counters only during reclamation, but not while accessing individual objects, which reduces overheads for object accesses. Since with reference counters, an arbitrary thread ends up freeing memory, Hyaline's reclamation workload is (almost) balanced across all threads, unlike most prior reclamation schemes such as epoch-based reclamation (EBR) or hazard pointers (HP). Hyaline often yields (excellent) EBR-grade performance with (good) HP-grade memory efficiency, which is a challenging trade-off with all existing schemes.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454090", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ruslan", + "last_name": "Nikolaev", + "institution": "Virginia Tech" + }, + { + "first_name": "Binoy", + "last_name": "Ravindran", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/pldi/0001R21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454110", + "title": "Termination analysis without the tears", + "abstract": "Determining whether a given program terminates is the quintessential undecidable problem. Algorithms for termination analysis may be classified into two groups: (1) algorithms with strong behavioral guarantees that work in limited circumstances (e.g., complete synthesis of linear ranking functions for polyhedral loops), and (2) algorithms that are widely applicable, but have weak behavioral guarantees (e.g., Terminator). This paper investigates the space in between: how can we design practical termination analyzers with useful behavioral guarantees?", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454110", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shaowei", + "last_name": "Zhu", + "institution": "Princeton University" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/pldi/0001K21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454034", + "title": "Compiler-assisted object inlining with value fields", + "abstract": "Object Oriented Programming has flourished in many areas ranging from web-oriented microservices, data processing, to databases. However, while representing domain entities as objects is appealing to developers, it leads to data fragmentation, resulting in high memory footprint and poor locality.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454034", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rodrigo", + "last_name": "Bruno", + "institution": "" + }, + { + "first_name": "Vojin", + "last_name": "Jovanović", + "institution": "" + }, + { + "first_name": "Christian", + "last_name": "Wimmer", + "institution": "Oracle (United States)" + }, + { + "first_name": "Gustavo", + "last_name": "Alonso", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/BrunoJWA21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454044", + "title": "Demanded abstract interpretation", + "abstract": "We consider the problem of making expressive static analyzers interactive. Formal static analysis is seeing increasingly widespread adoption as a tool for verification and bug-finding, but even with powerful cloud infrastructure it can take minutes or hours to get batch analysis results after a code change. While existing techniques offer some demand-driven or incremental aspects for certain classes of analysis, the fundamental challenge we tackle is doing both for arbitrary abstract interpreters. Our technique, demanded abstract interpretation, lifts program syntax and analysis state to a dynamically evolving graph structure, in which program edits, client-issued queries, and evaluation of abstract semantics are all treated uniformly. The key difficulty addressed by our approach is the application of general incremental computation techniques to the complex, cyclic dependency structure induced by abstract interpretation of loops with widening operators. We prove that desirable abstract interpretation meta-properties, including soundness and termination, are preserved in our approach, and that demanded analysis results are equal to those computed by a batch abstract interpretation. Experimental results suggest promise for a prototype demanded abstract interpretation framework: by combining incremental and demand-driven techniques, our framework consistently delivers analysis results at interactive speeds, answering 95% of queries within 1.2 seconds.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454044", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benno", + "last_name": "Stein", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "Amazon (United States)" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/pldi/0002CS21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454076", + "title": "Polynomial reachability witnesses via Stellensätze", + "abstract": "We consider the fundamental problem of reachability analysis over imperative programs with real variables. Previous works that tackle reachability are either unable to handle programs consisting of general loops (e.g. symbolic execution), or lack completeness guarantees (e.g. abstract interpretation), or are not automated (e.g. incorrectness logic). In contrast, we propose a novel approach for reachability analysis that can handle general and complex loops, is complete, and can be entirely automated for a wide family of programs. Through the notion of Inductive Reachability Witnesses (IRWs), our approach extends ideas from both invariant generation and termination to reachability analysis.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454076", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ali Al", + "last_name": "Asadi", + "institution": "Sharif University of Technology" + }, + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Mohammad", + "last_name": "Mahdavi", + "institution": "Sharif University of Technology" + } + ], + "dblp_key": "conf/pldi/AsadiC0GM21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454041", + "title": "Zooid: a DSL for certified multiparty computation: from mechanised metatheory to certified multiparty processes", + "abstract": "We design and implement Zooid, a domain specific language for certified multiparty communication, embedded in Coq and implemented atop our mechanisation framework of asynchronous multiparty session types (the first of its kind). Zooid provides a fully mechanised metatheory for the semantics of global and local types, and a fully verified end-point process language that faithfully reflects the type-level behaviours and thus inherits the global types properties such as deadlock freedom, protocol compliance, and liveness guarantees.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454041", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "David", + "last_name": "Castro", + "institution": "University of Kent" + }, + { + "first_name": "Francisco", + "last_name": "Ferreira", + "institution": "Imperial College London" + }, + { + "first_name": "Lorenzo", + "last_name": "Gheri", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/pldi/Castro-Perez0GY21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454037", + "title": "Wire sorts: a language abstraction for safe hardware composition", + "abstract": "Effective digital hardware design fundamentally requires decomposing a design into a set of interconnected modules, each a distinct unit of computation and state. However, naively connecting hardware modules leads to real-world pathological cases which are surprisingly far from obvious when looking at the interfaces alone and which are very difficult to debug after synthesis. We show for the first time that it is possible to soundly abstract even complex combinational dependencies of arbitrary hardware modules through the assignment of IO ports to one of four new sorts which we call: to-sync, to-port, from-sync, and from-port. This new taxonomy, and the reasoning it enables, facilitates modularity by escalating problematic aspects of module input/output interaction to the language-level interface specification. We formalize and prove the soundness of our new wire sorts, implement them in a practical hardware description language, and demonstrate they can be applied and even inferred automatically at scale. Through an examination of the BaseJump STL, the OpenPiton manycore research platform, and a complete RISC-V implementation, we find that even on our biggest design containing 1.5 million primitive gates, analysis takes less than 31 seconds; that across 172 unique modules analyzed, the inferred sorts are widely distributed across our taxonomy; and that by using wire sorts, our tool is 2.6–33.9x faster at finding loops than standard synthesis-time cycle detection.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454037", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Christensen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Timothy", + "last_name": "Sherwood", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Jonathan", + "last_name": "Balkind", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Ben", + "last_name": "Hardekopf", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/pldi/0001SBH21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454056", + "title": "Fast and precise certification of transformers", + "abstract": "We present DeepT, a novel method for certifying Transformer networks based on abstract interpretation. The key idea behind DeepT is our new Multi-norm Zonotope abstract domain, an extension of the classical Zonotope designed to handle ℓ1 and ℓ2-norm bound perturbations. We introduce all Multi-norm Zonotope abstract transformers necessary to handle these complex networks, including the challenging softmax function and dot product. Our evaluation shows that DeepT can certify average robustness radii that are 28× larger than the state-of-the-art, while scaling favorably. Further, for the first time, we certify Transformers against synonym attacks on long sequences of words, where each word can be replaced by any synonym. DeepT achieves a high certification success rate on sequences of words where enumeration-based verification would take 2 to 3 orders of magnitude more time.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454056", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gregory", + "last_name": "Bonaert", + "institution": "ETH Zurich" + }, + { + "first_name": "Dimitar I.", + "last_name": "Dimitrov", + "institution": "ETH Zurich" + }, + { + "first_name": "Maximilian", + "last_name": "Baader", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/BonaertDBV21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454099", + "title": "Canary: practical static detection of inter-thread value-flow bugs", + "abstract": "Concurrent programs are still prone to bugs arising from the subtle interleavings of threads. Traditional static analysis for concurrent programs, such as data-flow analysis and symbolic execution, has to explicitly explore redundant control states, leading to prohibitive computational complexity.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454099", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuandao", + "last_name": "Cai", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Peisen", + "last_name": "Yao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/pldi/CaiYZ21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454107", + "title": "Frequent background polling on a shared thread, using light-weight compiler interrupts", + "abstract": "Recent work in networking, storage and multi-threading has demonstrated improved performance and scalability by replacing kernel-mode interrupts with high-rate user-space polling. Typically, such polling is performed by a dedicated core. Compiler Interrupts (CIs) instead enable efficient, automatic high-rate polling on a shared thread, which performs other work between polls. CIs are instrumentation-based and light-weight, allowing frequent interrupts with little performance impact. For example, when targeting a 5,000 cycle interval, the median overhead of our fastest CI design is 4% vs. 800% for hardware interrupts, across programs in the SPLASH-2, Phoenix and Parsec benchmark suites running with 32 threads. We evaluate CIs on three systems-level applications: (a) kernel bypass networking with mTCP, (b) joint kernel bypass networking and CPU scheduling with Shenango, and (c) delegation, a message-passing alternative to locking, with FFWD. For each application, we find that CIs offer compelling qualitative and quantitative improvements over the current state of the art. For example, CI-based mTCP achieves ≈2× stock mTCP throughput on a sample HTTP application.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454107", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nilanjana", + "last_name": "Basu", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Claudio", + "last_name": "Montanari", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Jakob", + "last_name": "Eriksson", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/pldi/BasuME21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454060", + "title": "Concurrent deferred reference counting with constant-time overhead", + "abstract": "We present a safe automatic memory reclamation approach for concurrent programs, and show that it is both theoretically and practically efficient. Our approach combines ideas from referencing counting and hazard pointers in a novel way to implement concurrent reference counting with wait-free, constant-time overhead. It overcomes the limitations of previous approaches by significantly reducing modifications to, and hence contention on, the reference counts. Furthermore, it is safer and easier to use than manual approaches. Our technique involves using a novel generalization of hazard pointers to defer reference-count decrements until no other process can be incrementing them, and to defer or elide reference-count increments for short-lived references.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454060", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Anderson", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yuanhao", + "last_name": "Wei", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/AndersonBW21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454058", + "title": "Compiling Stan to generative probabilistic languages and extension to deep probabilistic programming", + "abstract": "Stan is a probabilistic programming language that is popular in the statistics community, with a high-level syntax for expressing probabilistic models. Stan differs by nature from generative probabilistic programming languages like Church, Anglican, or Pyro. This paper presents a comprehensive compilation scheme to compile any Stan model to a generative language and proves its correctness. We use our compilation scheme to build two new backends for the Stanc3 compiler targeting Pyro and NumPyro. Experimental results show that the NumPyro backend yields a 2.3x speedup compared to Stan in geometric mean over 26 benchmarks. Building on Pyro we extend Stan with support for explicit variational inference guides and deep probabilistic models. That way, users familiar with Stan get access to new features without having to learn a fundamentally new language.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454058", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Baudart", + "institution": "Université Paris Sciences et Lettres" + }, + { + "first_name": "Javier", + "last_name": "Burroni", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Louis", + "last_name": "Mandel", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Avraham", + "last_name": "Shinnar", + "institution": "IBM Research - Austin" + } + ], + "dblp_key": "conf/pldi/BaudartBHMS21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454074", + "title": "Viaduct: an extensible, optimizing compiler for secure distributed programs", + "abstract": "Modern distributed systems involve interactions between principals with limited trust, so cryptographic mechanisms are needed to protect confidentiality and integrity. At the same time, most developers lack the training to securely employ cryptography. We present Viaduct, a compiler that transforms high-level programs into secure, efficient distributed realizations. Viaduct's source language allows developers to declaratively specify security policies by annotating their programs with information flow labels. The compiler uses these labels to synthesize distributed programs that use cryptography efficiently while still defending the source-level security policy. The Viaduct approach is general, and can be easily extended with new security mechanisms.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454074", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Coşku", + "last_name": "Acay", + "institution": "Cornell University" + }, + { + "first_name": "Rolph", + "last_name": "Recto", + "institution": "Cornell University" + }, + { + "first_name": "Joshua", + "last_name": "Gancher", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + }, + { + "first_name": "Elaine", + "last_name": "Shi", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/AcayRGMS21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454085", + "title": "Chianina: an evolving graph system for flow- and context-sensitive analyses of million lines of C code", + "abstract": "Sophisticated static analysis techniques often have complicated implementations, much of which provides logic for tuning and scaling rather than basic analysis functionalities. This tight coupling of basic algorithms with special treatments for scalability makes an analysis implementation hard to (1) make correct, (2) understand/work with, and (3) reuse for other clients. This paper presents Chianina, a graph system we developed for fully context- and flow-sensitive analysis of large C programs. Chianina overcomes these challenges by allowing the developer to provide only the basic algorithm of an analysis and pushing the tuning/scaling work to the underlying system. Key to the success of Chianina is (1) an evolving graph formulation of flow sensitivity and (2) the leverage of out-of-core, disk support to deal with memory blowup resulting from context sensitivity. We implemented three context- and flow-sensitive analyses on top of Chianina and scaled them to large C programs like Linux (17M LoC) on a single commodity PC.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454085", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhiqiang", + "last_name": "Zuo", + "institution": "Nanjing University" + }, + { + "first_name": "Yiyu", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Qiuhong", + "last_name": "Pan", + "institution": "Nanjing University" + }, + { + "first_name": "Shenming", + "last_name": "Lu", + "institution": "Nanjing University" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/0002ZPLLWLX21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454096", + "title": "JPortal: precise and efficient control-flow tracing for JVM programs with Intel processor trace", + "abstract": "Hardware tracing modules such as Intel Processor Trace perform continuous control-flow tracing of an end-to-end program execution with an ultra-low overhead. PT has been used in a variety of contexts to support applications such as testing, debugging, and performance diagnosis. However, these hardware modules have so far been used only to trace native programs, which are directly compiled down to machine code. As high-level languages (HLL) such as Java and Go become increasingly popular, there is a pressing need to extend these benefits to the HLL community. This paper presents JPortal, a JVM-based profiling tool that bridges the gap between HLL applications and low-level hardware traces by using a set of algorithms to precisely recover an HLL program’s control flow from PT traces. An evaluation of JPortal with the DaCapo benchmark shows that JPortal achieves an overall 80% accuracy for end-to-end control flow profiling with only a 4-16% runtime overhead.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454096", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhiqiang", + "last_name": "Zuo", + "institution": "Nanjing University" + }, + { + "first_name": "Kai", + "last_name": "Ji", + "institution": "Nanjing University" + }, + { + "first_name": "Yi-Fei", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Tao", + "last_name": "Wei", + "institution": "Nanjing University" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/0002JWTWLX21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454111", + "title": "On probabilistic termination of functional programs with continuous distributions", + "abstract": "We study termination of higher-order probabilistic functional programs with recursion, stochastic conditioning and sampling from continuous distributions. Reasoning about the termination probability of programs with continuous distributions is hard, because the enumeration of terminating executions cannot provide any non-trivial bounds. We present a new operational semantics based on traces of intervals, which is sound and complete with respect to the standard sampling-based semantics, in which (countable) enumeration can provide arbitrarily tight lower bounds. Consequently we obtain the first proof that deciding almost-sure termination (AST) for programs with continuous distributions is Π20-complete (for CbN). We also provide a compositional representation of our semantics in terms of an intersection type system. In the second part, we present a method of proving AST for non-affine programs, i.e., recursive programs that can, during the evaluation of the recursive body, make multiple recursive calls (of a first-order function) from distinct call sites. Unlike in a deterministic language, the number of recursion call sites has direct consequences on the termination probability. Our framework supports a proof system that can verify AST for programs that are well beyond the scope of existing methods. We have constructed prototype implementations of our methods for computing lower bounds on the termination probability, and AST verification.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454111", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Raven", + "last_name": "Beutner", + "institution": "University of Oxford" + }, + { + "first_name": "Luke", + "last_name": "Ong", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/pldi/BeutnerO21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454047", + "title": "Web question answering with neurosymbolic program synthesis", + "abstract": "In this paper, we propose a new technique based on program synthesis for extracting information from webpages. Given a natural language query and a few labeled webpages, our method synthesizes a program that can be used to extract similar types of information from other unlabeled webpages. To handle websites with diverse structure, our approach employs a neurosymbolic DSL that incorporates both neural NLP models as well as standard language constructs for tree navigation and string manipulation. We also propose an optimal synthesis algorithm that generates all DSL programs that achieve optimal F1 score on the training examples. Our synthesis technique is compositional, prunes the search space by exploiting a monotonicity property of the DSL, and uses transductive learning to select programs with good generalization power. We have implemented these ideas in a new tool called WebQA and evaluate it on 25 different tasks across multiple domains. Our experiments show that WebQA significantly outperforms existing tools such as state-of-the-art question answering models and wrapper induction systems.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454047", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qiaochu", + "last_name": "Chen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Aaron", + "last_name": "Lamoreaux", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Greg", + "last_name": "Durrett", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/ChenL0DBD21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454093", + "title": "Proving non-termination by program reversal", + "abstract": "We present a new approach to proving non-termination of non-deterministic integer programs. Our technique is rather simple but efficient. It relies on a purely syntactic reversal of the program's transition system followed by a constraint-based invariant synthesis with constraints coming from both the original and the reversed transition system. The latter task is performed by a simple call to an off-the-shelf SMT-solver, which allows us to leverage the latest advances in SMT-solving. Moreover, our method offers a combination of features not present (as a whole) in previous approaches: it handles programs with non-determinism, provides relative completeness guarantees and supports programs with polynomial arithmetic. The experiments performed with our prototype tool RevTerm show that our approach, despite its simplicity and stronger theoretical guarantees, is at least on par with the state-of-the-art tools, often achieving a non-trivial improvement under a proper configuration of its parameters.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454093", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Ehsan Kafshdar", + "last_name": "Goharshady", + "institution": "Ferdowsi University of Mashhad" + }, + { + "first_name": "Petr", + "last_name": "Novotný", + "institution": "Masaryk University" + }, + { + "first_name": "Đorđe", + "last_name": "Žikelić", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "conf/pldi/ChatterjeeG0Z21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454082", + "title": "Modular data-race-freedom guarantees in the promising semantics", + "abstract": "Local data-race-freedom guarantees, ensuring strong semantics for locations accessed by non-racy instructions, provide a fruitful methodology for modular reasoning in relaxed memory concurrency. We observe that standard compiler optimizations are in inherent conflict with such guarantees in general fully-relaxed memory models. Nevertheless, for a certain strengthening of the promising model by Lee et al. that only excludes relaxed RMW-store reorderings, we establish multiple useful local data-racefreedom guarantees that enhance the programmability aspect of the model.We also demonstrate that the performance price of forbidding these reorderings is insignificant. To the best of our knowledge, these results are the first to identify a model that includes the standard concurrency constructs, supports the efficient mapping of relaxed reads and writes to plain hardware loads and stores, and yet validates several local data-race-freedom guarantees. To gain confidence, our results are fully mechanized in Coq.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454082", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Sung-Hwan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/ChoLHL21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454052", + "title": "Concise, type-safe, and efficient structural diffing", + "abstract": "A structural diffing algorithm compares two pieces of tree-shaped data and computes their difference. Existing structural diffing algorithms either produce concise patches or ensure type safety, but never both. We present a new structural diffing algorithm called truediff that achieves both properties by treating subtrees as mutable, yet linearly typed resources. Mutation is required to derive concise patches that only mention changed nodes, but, in contrast to prior work, truediff guarantees all intermediate trees are well-typed. We formalize type safety, prove truediff has linear run time, and evaluate its performance and the conciseness of the derived patches empirically for real-world Python documents. While truediff ensures type safety, the size of its patches is on par with Gumtree, a popular untyped diffing implementation. Regardless, truediff outperforms Gumtree and a typed diffing implementation by an order of magnitude.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454052", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "" + }, + { + "first_name": "Tamás", + "last_name": "Szabó", + "institution": "" + }, + { + "first_name": "André", + "last_name": "Pacak", + "institution": "" + } + ], + "dblp_key": "conf/pldi/ErdwegSP21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454089", + "title": "Phased synthesis of divide and conquer programs", + "abstract": "We propose a fully automated method that takes as input an iterative or recursive reference implementation and produces divide-and-conquer implementations that are functionally equivalent to the input. Three interdependent components have to be synthesized: a function that divides the original problem instance, a function that solves each sub-instance, and a function that combines the results of sub-computations. We propose a methodology that splits the synthesis problem into three successive phases, each with a substantially reduced state space compared to the original monolithic task, and therefore substantially more tractable. Our methodology is implemented as an addition to the existing synthesis tool Parsynt, and we demonstrate the efficacy of it by synthesizing highly nontrivial divide-and-conquer implementations of a set of benchmarks fully automatically.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454089", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Victor", + "last_name": "Nicolet", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/pldi/FarzanN21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454105", + "title": "Mirror: making lock-free data structures persistent", + "abstract": "With the recent launch of the Intel Optane memory platform, non-volatile main memory in the form of fast, dense, byte-addressable non-volatile memory has now become available. Nevertheless, designing crash-resilient algorithms and data structures is complex and error-prone as caches and machine registers are still volatile and the data residing in memory after a crash might not reflect a consistent view of the program state. This complex setting has often led to durable data structures being inefficient or incorrect, especially in the concurrent setting.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454105", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michal", + "last_name": "Friedman", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Pedro", + "last_name": "Ramalhete", + "institution": "" + } + ], + "dblp_key": "conf/pldi/FriedmanPR21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454070", + "title": "An efficient interpreter for Datalog by de-specializing relations", + "abstract": "Datalog is becoming increasingly popular as a standard tool for a variety of use cases. Modern Datalog engines can achieve high performance by specializing data structures for relational operations. For example, the Datalog engine Soufflé achieves high performance with a synthesizer that specializes data structures for relations. However, the synthesizer cannot always be deployed, and a fast interpreter is required.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454070", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiaowen", + "last_name": "Hu", + "institution": "The University of Sydney" + }, + { + "first_name": "David", + "last_name": "Zhao", + "institution": "The University of Sydney" + }, + { + "first_name": "Herbert", + "last_name": "Jordan", + "institution": "Universität Innsbruck" + }, + { + "first_name": "Bernhard", + "last_name": "Scholz", + "institution": "The University of Sydney" + } + ], + "dblp_key": "conf/pldi/HuZJS21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454080", + "title": "DreamCoder: bootstrapping inductive program synthesis with wake-sleep library learning", + "abstract": "We present a system for inductive program synthesis called DreamCoder, which inputs a corpus of synthesis problems each specified by one or a few examples, and automatically derives a library of program components and a neural search policy that can be used to efficiently solve other similar synthesis problems. The library and search policy bootstrap each other iteratively through a variant of \"wake-sleep\" approximate Bayesian learning. A new refactoring algorithm based on E-graph matching identifies common sub-components across synthesized programs, building a progressively deepening library of abstractions capturing the structure of the input domain. We evaluate on eight domains including classic program synthesis areas and AI tasks such as planning, inverse graphics, and equation discovery. We show that jointly learning the library and neural search policy leads to solving more problems, and solving them more quickly.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454080", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Ellis", + "institution": "Cornell University" + }, + { + "first_name": "Catherine", + "last_name": "Wong", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Maxwell", + "last_name": "Nye", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Mathias", + "last_name": "Sablé-Meyer", + "institution": "Collège de France" + }, + { + "first_name": "Lucas", + "last_name": "Morales", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Luke", + "last_name": "Hewitt", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Luc", + "last_name": "Cary", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Joshua B.", + "last_name": "Tenenbaum", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/EllisWNSMHCST21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454027", + "title": "Revamping hardware persistency models: view-based and axiomatic persistency models for Intel-x86 and Armv8", + "abstract": "Non-volatile memory (NVM) is a cutting-edge storage technology that promises the performance of DRAM with the durability of SSD. Recent work has proposed several persistency models for mainstream architectures such as Intel-x86 and Armv8, describing the order in which writes are propagated to NVM. However, these models have several limitations; most notably, they either lack operational models or do not support persistent synchronization patterns.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454027", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kyeongmin", + "last_name": "Cho", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sung-Hwan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "conf/pldi/ChoLRK21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454050", + "title": "Porcupine: a synthesizing compiler for vectorized homomorphic encryption", + "abstract": "Homomorphic encryption (HE) is a privacy-preserving technique that enables computation directly on encrypted data. Despite its promise, HE has seen limited use due to performance overheads and compilation challenges. Recent work has made significant advances to address the performance overheads but automatic compilation of efficient HE kernels remains relatively unexplored.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454050", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Meghan", + "last_name": "Cowan", + "institution": "Meta (Israel)" + }, + { + "first_name": "Deeksha", + "last_name": "Dangwal", + "institution": "Meta (Israel)" + }, + { + "first_name": "Armin", + "last_name": "Alaghi", + "institution": "Meta (Israel)" + }, + { + "first_name": "Caroline", + "last_name": "Trippel", + "institution": "Stanford University" + }, + { + "first_name": "Vincent T.", + "last_name": "Lee", + "institution": "Meta (Israel)" + }, + { + "first_name": "Brandon", + "last_name": "Reagen", + "institution": "Supélec" + } + ], + "dblp_key": "conf/pldi/CowanDATLR21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454108", + "title": "Satisfiability modulo ordering consistency theory for multi-threaded program verification", + "abstract": "Analyzing multi-threaded programs is hard due to the number of thread interleavings. Partial orders can be used for modeling and analyzing multi-threaded programs. However, there is no dedicated decision procedure for solving partial-order constraints. In this paper, we propose a novel ordering consistency theory for multi-threaded program verification under sequential consistency, and we elaborate its theory solver, which realizes incremental consistency checking, minimal conflict clause generation, and specialized theory propagation to improve the efficiency of SMT solving. We conducted extensive experiments on credible benchmarks; the results show significant promotion of our approach.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454108", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + }, + { + "first_name": "Zhihang", + "last_name": "Sun", + "institution": "Tsinghua University" + }, + { + "first_name": "Hongyu", + "last_name": "Fan", + "institution": "Tsinghua University" + } + ], + "dblp_key": "conf/pldi/HeSF21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454065", + "title": "Integration verification across software and hardware for a simple embedded system", + "abstract": "The interfaces between layers of a system are susceptible to bugs if developers of adjacent layers proceed under subtly different assumptions. Formal verification of two layers against the same formal model of the interface between them can be used to shake out these bugs. Doing so for every interface in the system can, in principle, yield unparalleled assurance of the correctness and security of the system as a whole. However, there have been remarkably few efforts that carry out this exercise, and all of them have simplified the task by restricting interactivity of the application, inventing new simplified instruction sets, and using unrealistic input and output mechanisms. We report on the first verification of a realistic embedded system, with its application software, device drivers, compiler, and RISC-V processor represented inside the Coq proof assistant as one mathematical object, with a machine-checked proof of functional correctness. A key challenge is structuring the proof modularly, so that further refinement of the components or expansion of the system can proceed without revisiting the rest of the system.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454065", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andres", + "last_name": "Erbsen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Samuel", + "last_name": "Gruetter", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Joonwon", + "last_name": "Choi", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Clark", + "last_name": "Wood", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ErbsenGCWC21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454092", + "title": "Test-case reduction and deduplication almost for free with transformation-based compiler testing", + "abstract": "Recent transformation-based approaches to compiler testing look for mismatches between the results of pairs of equivalent programs, where one program is derived from the other by randomly applying semantics-preserving transformations. We present a formulation of transformation-based compiler testing that provides effective test-case reduction almost for free: if transformations are designed to be as small and independent as possible, standard delta debugging can be used to shrink a bug-inducing transformation sequence to a smaller subsequence that still triggers the bug. The bug can then be reported as a delta between an original and minimally-transformed program. Minimized transformation sequences can also be used to heuristically deduplicate a set of bug-inducing tests, recommending manual investigation of those that involve disparate types of transformations and thus may have different root causes. We demonstrate the effectiveness of our approach via a new tool, spirv-fuzz, the first compiler-testing tool for the SPIR-V intermediate representation that underpins the Vulkan GPU programming model.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454092", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Paul", + "last_name": "Thomson", + "institution": "Google (United Kingdom)" + }, + { + "first_name": "Vasyl", + "last_name": "Teliman", + "institution": "Central Ukrainian National Technical University" + }, + { + "first_name": "Stefano", + "last_name": "Milizia", + "institution": "Imperial College London" + }, + { + "first_name": "André Perez", + "last_name": "Maselco", + "institution": "Universidade Federal do ABC" + }, + { + "first_name": "Antoni", + "last_name": "Karpiński", + "institution": "Warsaw University of Technology" + } + ], + "dblp_key": "conf/pldi/DonaldsonTTMMK21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454048", + "title": "RbSyn: type- and effect-guided program synthesis", + "abstract": "In recent years, researchers have explored component-based synthesis, which aims to automatically construct programs that operate by composing calls to existing APIs. However, prior work has not considered efficient synthesis of methods with side effects, e.g., web app methods that update a database. In this paper, we introduce RbSyn, a novel type- and effect-guided synthesis tool for Ruby. An RbSyn synthesis goal is specified as the type for the target method and a series of test cases it must pass. RbSyn works by recursively generating well-typed candidate method bodies whose write effects match the read effects of the test case assertions. After finding a set of candidates that separately satisfy each test, RbSyn synthesizes a solution that branches to execute the correct candidate code under the appropriate conditions. We formalize RbSyn on a core, object-oriented language λsyn and describe how the key ideas of the model are scaled-up in our implementation for Ruby. We evaluated RbSyn on 19 benchmarks, 12 of which come from popular, open-source Ruby apps. We found that RbSyn synthesizes correct solutions for all benchmarks, with 15 benchmarks synthesizing in under 9 seconds, while the slowest benchmark takes 83 seconds. Using observed reads to guide synthesize is effective: using type-guidance alone times out on 10 of 12 app benchmarks. We also found that using less precise effect annotations leads to worse synthesis performance. In summary, we believe type- and effect-guided synthesis is an important step forward in synthesis of effectful methods from test cases.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454048", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sankha Narayan", + "last_name": "Guria", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "Tufts University" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/GuriaFH21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454046", + "title": "DIY assistant: a multi-modal end-user programmable virtual assistant", + "abstract": "While Alexa can perform over 100,000 skills, its capability covers only a fraction of what is possible on the web. Individuals need and want to automate a long tail of web-based tasks which often involve visiting different websites and require programming concepts such as function composition, conditional, and iterative evaluation. This paper presents DIYA (Do-It-Yourself Assistant), a new system that empowers users to create personalized web-based virtual assistant skills that require the full generality of composable control constructs, without having to learn a formal programming language.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454046", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Fischer", + "institution": "Stanford University" + }, + { + "first_name": "Giovanni", + "last_name": "Campagna", + "institution": "Stanford University" + }, + { + "first_name": "Euirim", + "last_name": "Choi", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/FischerCCL21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454045", + "title": "Learning to find naming issues with big code and small supervision", + "abstract": "We introduce a new approach for finding and fixing naming issues in source code. The method is based on a careful combination of unsupervised and supervised procedures: (i) unsupervised mining of patterns from Big Code that express common naming idioms. Program fragments violating such idioms indicates likely naming issues, and (ii) supervised learning of a classifier on a small labeled dataset which filters potential false positives from the violations.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454045", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jingxuan", + "last_name": "He", + "institution": "ETH Zurich" + }, + { + "first_name": "Cheng-Chun", + "last_name": "Lee", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/HeLRV21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454097", + "title": "CompCertO: compiling certified open C components", + "abstract": "Since the introduction of CompCert, researchers have been refining its language semantics and correctness theorem, and used them as components in software verification efforts. Meanwhile, artifacts ranging from CPU designs to network protocols have been successfully verified, and there is interest in making them interoperable to tackle end-to-end verification at an even larger scale.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454097", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/KoenigS21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454038", + "title": "DeepCuts: a deep learning optimization framework for versatile GPU workloads", + "abstract": "Widely used Deep Learning (DL) frameworks, such as TensorFlow, PyTorch, and MXNet, heavily rely on the NVIDIA cuDNN for performance. However, using cuDNN does not always give the best performance. One reason is that it is hard to handle every case of versatile DNN models and GPU architectures with a library that has a fixed implementation. Another reason is that cuDNN lacks kernel fusion functionality that gives a lot of chances to improve performance. In this paper, we propose a DL optimization framework for versatile GPU workloads, called DeepCuts. It considers both kernel implementation parameters and GPU architectures. It analyzes the DL workload, groups multiple DL operations into a single GPU kernel, and generates optimized GPU kernels considering kernel implementation parameters and GPU architecture parameters. The evaluation result with various DL workloads for inference and training indicates that DeepCuts outperforms cuDNN/cuBLAS-based implementations and the state-of-the-art DL optimization frameworks, such as TVM, TensorFlow XLA, and TensorRT.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454038", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wookeun", + "last_name": "Jung", + "institution": "Seoul National University" + }, + { + "first_name": "Thanh Tuan", + "last_name": "Dao", + "institution": "Seoul National University" + }, + { + "first_name": "Jaejin", + "last_name": "Lee", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/pldi/JungDL21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454071", + "title": "Adaptive restarts for stochastic synthesis", + "abstract": "We consider the problem of program synthesis from input-output examples via stochastic search. We identify a robust feature of stochastic synthesis: The search often progresses through a series of discrete plateaus. We observe that the distribution of synthesis times is often heavy-tailed and analyze how these distributions arise. Based on these insights, we present an algorithm that speeds up synthesis by an order of magnitude over the naive algorithm currently used in practice. Our experimental results are obtained in part using a new program synthesis benchmark for superoptimization distilled from widely used production code.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454071", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jason R.", + "last_name": "Koenig", + "institution": "Stanford University" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/KoenigPA21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454087", + "title": "Cyclic program synthesis", + "abstract": "We describe the first approach to automatically synthesizing heap-manipulating programs with auxiliary recursive procedures. Such procedures occur routinely in data structure transformations (e.g., flattening a tree into a list) or traversals of composite structures (e.g., n-ary trees). Our approach, dubbed cyclic program synthesis, enhances deductive program synthesis with a novel application of cyclic proofs. Specifically, we observe that the machinery used to form cycles in cyclic proofs can be reused to systematically and efficiently abduce recursive auxiliary procedures.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454087", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Hila", + "last_name": "Peleg", + "institution": "University of California, San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California, San Diego" + }, + { + "first_name": "Reuben N. S.", + "last_name": "Rowe", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/pldi/ItzhakyPPRS21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454069", + "title": "Distance-in-time versus distance-in-space", + "abstract": "Cache behavior is one of the major factors that influence the performance of applications. Most of the existing compiler techniques that target cache memories focus exclusively on reducing data reuse distances in time (DIT). However, current manycore systems employ distributed on-chip caches that are connected using an on-chip network. As a result, a reused data element/block needs to travel over this on-chip network, and the distance to be traveled -- reuse distance in space (DIS) -- can be as influential in dictating application performance as reuse DIT. This paper represents the first attempt at defining a compiler framework that accommodates both DIT and DIS. Specifically, it first classifies data reuses into four groups: G1: (low DIT, low DIS), G2: (high DIT, low DIS), G3: (low DIT, high DIS), and G4: (high DIT, high DIS). Then, observing that reuses in G1 represent the ideal case and there is nothing much to be done in computations in G4, it proposes a \"reuse transfer\" strategy that transfers select reuses between G2 and G3, eventually, transforming each reuse to either G1 or G4. Finally, it evaluates the proposed strategy using a set of 10 multithreaded applications. The collected results reveal that the proposed strategy reduces parallel execution times of the tested applications between 19.3% and 33.3%.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454069", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Xulong", + "last_name": "Tang", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Hui", + "last_name": "Zhao", + "institution": "University of North Texas" + }, + { + "first_name": "Jihyun", + "last_name": "Ryoo", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mustafa", + "last_name": "Karaköy", + "institution": "TUBITAK BILGEM" + } + ], + "dblp_key": "conf/pldi/KandemirT0RK21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454091", + "title": "Logical bytecode reduction", + "abstract": "Reducing a failure-inducing input to a smaller one is challenging for input with internal dependencies because most sub-inputs are invalid. Kalhauge and Palsberg made progress on this problem by mapping the task to a reduction problem for dependency graphs that avoids invalid inputs entirely. Their tool J-Reduce efficiently reduces Java bytecode to 24 percent of its original size, which made it the most effective tool until now. However, the output from their tool is often too large to be helpful in a bug report. In this paper, we show that more fine-grained modeling of dependencies leads to much more reduction. Specifically, we use propositional logic for specifying dependencies and we show how this works for Java bytecode. Once we have a propositional formula that specifies all valid sub-inputs, we run an algorithm that finds a small, valid, failure-inducing input. Our algorithm interleaves runs of the buggy program and calls to a procedure that finds a minimal satisfying assignment. Our experiments show that we can reduce Java bytecode to 4.6 percent of its original size, which is 5.3 times better than the 24.3 percent achieved by J-Reduce. The much smaller output is more suitable for bug reports.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454091", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christian Gram", + "last_name": "Kalhauge", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/KalhaugeP21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454042", + "title": "Fluid: a framework for approximate concurrency via controlled dependency relaxation", + "abstract": "In this work, we introduce the Fluid framework, a set of language, compiler and runtime extensions that allow for the expression of regions within which dataflow dependencies can be approximated in a disciplined manner. Our framework allows the eager execution of dependent tasks before their inputs have finalized in order to capitalize on situations where an eagerly-consumed input has a high probability of sufficiently resembling the value or structure of the final value that would have been produced in a conservative/precise execution schedule. We introduce controlled access to the early consumption of intermediate values and provide hooks for user-specified quality assurance mechanisms that can automatically enforce re-execution of eagerly-executed tasks if their output values do not meet heuristic expectations. Our experimental analysis indicates that the fluidized versions of the applications bring 22.2% average execution time improvements, over their original counterparts, under the default values of our fluidization parameters. The Fluid approach is largely orthogonal to approaches that aim to reduce the task effort itself and we show that utilizing the Fluid framework can yield benefits for both originally precise and originally approximate versions of computation.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454042", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Huaipan", + "last_name": "Jiang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Haibo", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Xulong", + "last_name": "Tang", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Vineetha", + "last_name": "Govindaraj", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Jack", + "last_name": "Sampson", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/pldi/Jiang0TGSKZ21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454088", + "title": "Hashing modulo alpha-equivalence", + "abstract": "In many applications one wants to identify identical subtrees of a program syntax tree. This identification should ideally be robust to alpha-renaming of the program, but no existing technique has been shown to achieve this with good efficiency (better than O(n2) in expression size). We present a new, asymptotically efficient way to hash modulo alpha-equivalence. A key insight of our method is to use a weak (commutative) hash combiner at exactly one point in the construction, which admits an algorithm with O(n (logn)2) time complexity. We prove that the use of the commutative combiner nevertheless yields a strong hash with low collision probability. Numerical benchmarks attest to the asymptotic behaviour of the method.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454088", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Krzysztof", + "last_name": "Maziarz", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "T. M. R.", + "last_name": "Ellis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Alan", + "last_name": "Lawrence", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andrew", + "last_name": "Fitzgibbon", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/MaziarzELFJ21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454053", + "title": "CoStar: a verified ALL(*) parser", + "abstract": "Parsers are security-critical components of many software systems, and verified parsing therefore has a key role to play in secure software design. However, existing verified parsers for context-free grammars are limited in their expressiveness, termination properties, or performance characteristics. They are only compatible with a restricted class of grammars, they are not guaranteed to terminate on all inputs, or they are not designed to be performant on grammars for real-world programming languages and data formats.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454053", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sam", + "last_name": "Lasser", + "institution": "Tufts University" + }, + { + "first_name": "Chris", + "last_name": "Casinghino", + "institution": "Draper Laboratory" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "Cody", + "last_name": "Roux", + "institution": "Draper Laboratory" + } + ], + "dblp_key": "conf/pldi/LasserCFR21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454067", + "title": "Abstraction for conflict-free replicated data types", + "abstract": "Strong eventual consistency (SEC) has been used as a classic notion of correctness for Conflict-Free Replicated Data Types (CRDTs). However, it does not give proper abstractions of functionality, thus is not helpful for modular verification of client programs using CRDTs. We propose a new correctness formulation for CRDTs, called Abstract Converging Consistency (ACC), to specify both data consistency and functional correctness. ACC gives abstract atomic specifications (as an abstraction) to CRDT operations, and establishes consistency between the concrete execution traces and the execution using the abstract atomic operations. The abstraction allows us to verify the CRDT implementation and its client programs separately, resulting in more modular and elegant proofs than monolithic approaches for whole program verification. We give a generic proof method to verify ACC of CRDT implementations, and a rely-guarantee style program logic to verify client programs. Our Abstraction theorem shows that ACC is equivalent to contextual refinement, linking the verification of CRDT implementations and clients together to derive functional correctness of whole programs.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454067", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "Nanjing University" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Nanjing University" + } + ], + "dblp_key": "conf/pldi/LiangF21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454030", + "title": "Alive2: bounded translation validation for LLVM", + "abstract": "We designed, implemented, and deployed Alive2: a bounded translation validation tool for the LLVM compiler’s intermediate representation (IR). It limits resource consumption by, for example, unrolling loops up to some bound, which means there are circumstances in which it misses bugs. Alive2 is designed to avoid false alarms, is fully automatic through the use of an SMT solver, and requires no changes to LLVM. By running Alive2 over LLVM’s unit test suite, we discovered and reported 47 new bugs, 28 of which have been fixed already. Moreover, our work has led to eight patches to the LLVM Language Reference—the definitive description of the semantics of its IR—and we have participated in numerous discussions with the goal of clarifying ambiguities and fixing errors in these semantics. Alive2 is open source and we also made it available on the web, where it has active users from the LLVM community.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454030", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Juneyoung", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Zhengyang", + "last_name": "Liu", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/LopesLHLR21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454055", + "title": "Beyond the elementary representations of program invariants over algebraic data types", + "abstract": "First-order logic is a natural way of expressing properties of computation. It is traditionally used in various program logics for expressing the correctness properties and certificates. Although such representations are expressive for some theories, they fail to express many interesting properties of algebraic data types (ADTs). In this paper, we explore three different approaches to represent program invariants of ADT-manipulating programs: tree automata, and first-order formulas with or without size constraints. We compare the expressive power of these representations and prove the negative definability of both first-order representations using the pumping lemmas. We present an approach to automatically infer program invariants of ADT-manipulating programs by a reduction to a finite model finder. The implementation called RInGen has been evaluated against state-of-the-art invariant synthesizers and has been experimentally shown to be competitive. In particular, program invariants represented by automata are capable of expressing more complex properties of computation and their automatic construction is often less expensive.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454055", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yurii", + "last_name": "Kostyukov", + "institution": "St Petersburg University" + }, + { + "first_name": "Dmitry", + "last_name": "Mordvinov", + "institution": "" + }, + { + "first_name": "Grigory", + "last_name": "Fedyukovich", + "institution": "Florida State University" + } + ], + "dblp_key": "conf/pldi/KostyukovMF21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454073", + "title": "When threads meet events: efficient and precise static race detection with origins", + "abstract": "Data races are among the worst bugs in software in that they exhibit non-deterministic symptoms and are notoriously difficult to detect. The problem is exacerbated by interactions between threads and events in real-world applications. We present a novel static analysis technique, O2, to detect data races in large complex multithreaded and event-driven software. O2 is powered by “origins”, an abstraction that unifies threads and events by treating them as entry points of code paths attributed with data pointers. Origins in most cases are inferred automatically, but can also be specified by developers. More importantly, origins provide an efficient way to precisely reason about shared memory and pointer aliases.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454073", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bozhen", + "last_name": "Liu", + "institution": "Texas A&M University" + }, + { + "first_name": "Pei-Ming", + "last_name": "Liu", + "institution": "Texas A&M University" + }, + { + "first_name": "Yanze", + "last_name": "Li", + "institution": "Texas A&M University" + }, + { + "first_name": "Chia-Che", + "last_name": "Tsai", + "institution": "Texas A&M University" + }, + { + "first_name": "Dilma Da", + "last_name": "Silva", + "institution": "Texas A&M University" + }, + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/pldi/LiuLLTS021", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454094", + "title": "Vectorized secure evaluation of decision forests", + "abstract": "As the demand for machine learning–based inference increases in tandem with concerns about privacy, there is a growing recognition of the need for secure machine learning, in which secret models can be used to classify private data without the model or data being leaked. Fully Homomorphic Encryption (FHE) allows arbitrary computation to be done over encrypted data, providing an attractive approach to providing such secure inference. While such computation is often orders of magnitude slower than its plaintext counterpart, the ability of FHE cryptosystems to do ciphertext packing—that is, encrypting an entire vector of plaintexts such that operations are evaluated elementwise on the vector—helps ameliorate this overhead, effectively creating a SIMD architecture where computation can be vectorized for more efficient evaluation. Most recent research in this area has targeted regular, easily vectorizable neural network models. Applying similar techniques to irregular ML models such as decision forests remains unexplored, due to their complex, hard-to-vectorize structures.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454094", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Raghav", + "last_name": "Malik", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Vidush", + "last_name": "Singhal", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Gottfried", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/MalikSG021", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454049", + "title": "High performance correctly rounded math libraries for 32-bit floating point representations", + "abstract": "This paper proposes a set of techniques to develop correctly rounded math libraries for 32-bit float and posit types. It enhances our RLIBM approach that frames the problem of generating correctly rounded libraries as a linear programming problem in the context of 16-bit types to scale to 32-bit types. Specifically, this paper proposes new algorithms to (1) generate polynomials that produce correctly rounded outputs for all inputs using counterexample guided polynomial generation, (2) generate efficient piecewise polynomials with bit-pattern based domain splitting, and (3) deduce the amount of freedom available to produce correct results when range reduction involves multiple elementary functions. The resultant math library for the 32-bit float type is faster than state-of-the-art math libraries while producing the correct output for all inputs. We have also developed a set of correctly rounded elementary functions for 32-bit posits.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454049", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jay P.", + "last_name": "Lim", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/pldi/LimN21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454100", + "title": "Robustness certification with generative models", + "abstract": "Generative neural networks are powerful models capable of learning a wide range of rich semantic image transformations such as altering person's age, head orientation, adding mustache, changing the hair color and many more. At a high level, a generative model effectively produces new and previously unseen images with the desired properties, which can then be used to improve the accuracy of existing models. In this work, we advance the state-of-the-art in verification by bridging the gap between (i) the well studied but limited norm-based and geometric transformations, and (ii) the rich set of semantic transformations used in practice. This problem is especially hard since the images are generated from a highly non-convex image manifold, preventing the use of most existing verifiers, which often rely on convex relaxations. We present a new verifier, called GenProve, which is capable of certifying the rich set of semantic transformations of generative models. GenProve can provide both sound deterministic and probabilistic guarantees, by capturing infinite non-convex sets of activation vectors and distributions over them, while scaling to realistic networks.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454100", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Mirman", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander", + "last_name": "Hägele", + "institution": "ETH Zurich" + }, + { + "first_name": "Pavol", + "last_name": "Bielik", + "institution": "ETH Zurich" + }, + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/MirmanHBGV21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454057", + "title": "Trace-based control-flow analysis", + "abstract": "We define a small-step semantics for the untyped λ-calculus, that traces the β-reductions that occur during evaluation. By abstracting the computation traces, we reconstruct k-CFA using abstract interpretation, and justify constraint-based k-CFA in a semantic way. The abstract interpretation of the trace semantics also paves the way for introducing widening operators in CFA that go beyond existing analyses, that are all based on exploring a finite state space. We define ∇CFA, a widening-based analysis that limits the cycles in call stacks, and can achieve better precision than k-CFA at a similar cost.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454057", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benoît", + "last_name": "Montagu", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Thomas Wiben", + "last_name": "Jensen", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/pldi/MontaguJ21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454079", + "title": "Reverse engineering for reduction parallelization via semiring polynomials", + "abstract": "Parallel reduction, which summarizes a given dataset, e.g., the total, average, and maximum, plays a crucial role in parallel programming. This paper presents a new approach, reverse engineering, to automatically discovering nontrivial parallel reductions in sequential programs. The body of the sequential reduction loop is regarded as a black box, and its input-output behaviors are sampled. If the behaviors correspond to a set of linear polynomials over a semiring, a divide-and-conquer parallel reduction is generated. Auxiliary reverse-engineering methods enable a long and nested loop body to be decomposed, which makes our parallelization scheme applicable to various types of reduction loops. This approach is not only simple and efficient but also agnostic to the details of the input program. Its potential is demonstrated through several use case scenarios. A proof-of-concept implementation successfully inferred linear polynomials for nearly all of the 74 benchmarks exhaustively collected from the literature. These characteristics and experimental results demonstrate the promise of the proposed approach, despite its inherent unsoundness.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454079", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Akimasa", + "last_name": "Morihata", + "institution": "The University of Tokyo" + }, + { + "first_name": "Shigeyuki", + "last_name": "Sato", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/pldi/MorihataS21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454059", + "title": "Filling typed holes with live GUIs", + "abstract": "Text editing is powerful, but some types of expressions are more naturally represented and manipulated graphically. Examples include expressions that compute colors, music, animations, tabular data, plots, diagrams, and other domain-specific data structures. This paper introduces live literals, or livelits, which allow clients to fill holes of types like these by directly manipulating a user-defined GUI embedded persistently into code. Uniquely, livelits are compositional: a livelit GUI can itself embed spliced expressions, which are typed, lexically scoped, and can in turn embed other livelits. Livelits are also uniquely live: a livelit can provide continuous feedback about the run-time implications of the client’s choices even when splices mention bound variables, because the system continuously gathers closures associated with the hole that the livelit is filling. We integrate livelits into Hazel, a live hole-driven programming environment, and describe case studies that exercise these novel capabilities. We then define a simply typed livelit calculus, which specifies how livelits operate as live graphical macros. The metatheory of macro expansion has been mechanized in Agda.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454059", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" + }, + { + "first_name": "David A.", + "last_name": "Moon", + "institution": "University of Michigan" + }, + { + "first_name": "Andrew", + "last_name": "Blinn", + "institution": "University of Michigan" + }, + { + "first_name": "Ian", + "last_name": "Voysey", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Nick", + "last_name": "Collins", + "institution": "University of Chicago" + }, + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/pldi/OmarMBVCC21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454083", + "title": "DNNFusion: accelerating deep neural networks execution with advanced operator fusion", + "abstract": "Deep Neural Networks (DNNs) have emerged as the core enabler of many major applications on mobile devices. To achieve high accuracy, DNN models have become increasingly deep with hundreds or even thousands of operator layers, leading to high memory and computational requirements for inference. Operator fusion (or kernel/layer fusion) is key optimization in many state-of-the-art DNN execution frameworks, such as TensorFlow, TVM, and MNN, that aim to improve the efficiency of the DNN inference. However, these frameworks usually adopt fusion approaches based on certain patterns that are too restrictive to cover the diversity of operators and layer connections, especially those seen in many extremely deep models. Polyhedral-based loop fusion techniques, on the other hand, work on a low-level view of the computation without operator-level information, and can also miss potential fusion opportunities. To address this challenge, this paper proposes a novel and extensive loop fusion framework called DNNFusion. The basic idea of this work is to work at an operator view of DNNs, but expand fusion opportunities by developing a classification of both individual operators and their combinations. In addition, DNNFusion includes 1) a novel mathematical-property-based graph rewriting framework to reduce evaluation costs and facilitate subsequent operator fusion, 2) an integrated fusion plan generation that leverages the high-level analysis and accurate light-weight profiling, and 3) additional optimizations during fusion code generation. DNNFusion is extensively evaluated on 15 DNN models with varied types of tasks, model sizes, and layer counts. The evaluation results demonstrate that DNNFusion finds up to 8.8 × higher fusion opportunities, outperforms four state-of-the-art DNN execution frameworks with 9.3× speedup. The memory requirement reduction and speedups can enable the execution of many of the target models on mobile devices and even make them part of a real-time application.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454083", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wei", + "last_name": "Niu", + "institution": "William & Mary" + }, + { + "first_name": "Jiexiong", + "last_name": "Guan", + "institution": "William & Mary" + }, + { + "first_name": "Yanzhi", + "last_name": "Wang", + "institution": "Northeastern University" + }, + { + "first_name": "Gagan", + "last_name": "Agrawal", + "institution": "Augusta University" + }, + { + "first_name": "Bin", + "last_name": "Ren", + "institution": "William & Mary" + } + ], + "dblp_key": "conf/pldi/NiuGWAR21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454063", + "title": "Synthesizing data structure refinements from integrity constraints", + "abstract": "Implementations of many data structures use several correlated fields to improve their performance; however, inconsistencies between these fields can be a source of serious program errors. To address this problem, we propose a new technique for automatically refining data structures from integrity constraints. In particular, consider a data structure D with fields F and methods M, as well as a new set of auxiliary fields F′ that should be added to D. Given this input and an integrity constraint Φ relating F and F′, our method automatically generates a refinement of D that satisfies the provided integrity constraint. Our method is based on a modular instantiation of the CEGIS paradigm and uses a novel inductive synthesizer that augments top-down search with three key ideas. First, it computes necessary preconditions of partial programs to dramatically prune its search space. Second, it augments the grammar with promising new productions by leveraging the computed preconditions. Third, it guides top-down search using a probabilistic context-free grammar obtained by statically analyzing the integrity checking function and the original code base. We evaluated our method on 25 data structures from popular Java projects and show that our method can successfully refine 23 of them. We also compare our method against two state-of-the-art synthesis tools and perform an ablation study to justify our design choices. Our evaluation shows that (1) our method is successful at refining many data structure implementations in the wild, (2) it advances the state-of-the-art in synthesis, and (3) our proposed ideas are crucial for making this technique practical.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454063", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/pldi/Pailoor00D21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454043", + "title": "Developer and user-transparent compiler optimization for interactive applications", + "abstract": "Traditional offline optimization frameworks rely on representative hardware, software, and inputs to compare different optimization decisions on. With application-specific optimization for mobile systems though, the idea of a representative test bench is unrealistic while creating offline inputs is non-trivial. Online approaches partially overcome these problems but they might expose users to suboptimal or even erroneously optimized code. As a result, our mobile code is poorly optimized and this results in wasted performance, wasted energy, and user frustration. In this paper, we introduce a novel compiler optimization approach designed for mobile applications. It requires no developer effort, it tunes applications for the user’s device and usage patterns, and has no negative impact on the user experience. It is based on a lightweight capture and replay mechanism. In its online stage, it captures the state accessed by any targeted code region. By re-purposing existing OS capabilities, it keeps the overhead low. In its offline stage, it replays the code region but under different optimization decisions to enable sound comparisons of different optimizations under realistic conditions. Coupled with a search heuristic for the compiler optimization space, it allows us to discover optimization decisions that improve performance without testing these decisions directly on the user. We implemented a prototype system in Android based on LLVM combined with a genetic search engine. We evaluated it on both benchmarks and real Android applications. Online captures are infrequent and each one introduces an overhead of less than 15ms on average. For this negligible effect on user experience, we achieve speedups of 44% on average over the Android compiler and 35% over LLVM -O3.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454043", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Paschalis", + "last_name": "Mpeis", + "institution": "University of Edinburgh" + }, + { + "first_name": "Pavlos", + "last_name": "Petoumenos", + "institution": "University of Manchester" + }, + { + "first_name": "Kim", + "last_name": "Hazelwood", + "institution": "Meta (United States)" + }, + { + "first_name": "Hugh", + "last_name": "Leather", + "institution": "Meta (United States)" + } + ], + "dblp_key": "conf/pldi/MpeisPHL21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454103", + "title": "IOOpt: automatic derivation of I/O complexity bounds for affine programs", + "abstract": "Evaluating the complexity of an algorithm is an important step when developing applications, as it impacts both its time and energy performance. Computational complexity, which is the number of dynamic operations regardless of the execution order, is easy to characterize for affine programs. Data movement (or, I/O) complexity is more complex to evaluate as it refers, when considering all possible valid schedules, to the minimum required number of I/O between a slow (e.g. main memory) and a fast (e.g. local scratchpad) storage location.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454103", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Auguste", + "last_name": "Olivry", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Guillaume", + "last_name": "Iooss", + "institution": "Université Grenoble Alpes" + }, + { + "first_name": "Nicolas", + "last_name": "Tollenaere", + "institution": "Centre Inria de l'Université Grenoble Alpes" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "University of Utah" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Université Grenoble Alpes" + } + ], + "dblp_key": "conf/pldi/OlivryITRSR21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454040", + "title": "Unqomp: synthesizing uncomputation in Quantum circuits", + "abstract": "A key challenge when writing quantum programs is the need for uncomputation: temporary values produced during the computation must be reset to zero before they can be safely discarded. Unfortunately, most existing quantum languages require tedious manual uncomputation, often leading to inefficient and error-prone programs. We present Unqomp, the first procedure to automatically synthesize uncomputation in a given quantum circuit. Unqomp can be readily integrated into popular quantum languages, allowing the programmer to allocate and use temporary values analogously to classical computation, knowing they will be uncomputed by Unqomp. Our evaluation shows that programs leveraging Unqomp are not only shorter (-19% on average), but also generate more efficient circuits (-71% gates and -19% qubits on average).", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454040", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anouk", + "last_name": "Paradis", + "institution": "ETH Zurich" + }, + { + "first_name": "Benjamin", + "last_name": "Bichsel", + "institution": "ETH Zurich" + }, + { + "first_name": "Samuel", + "last_name": "Steffen", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/pldi/ParadisBSV21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454028", + "title": "Repairing serializability bugs in distributed database programs via automated schema refactoring", + "abstract": "Serializability is a well-understood concurrency control mechanism that eases reasoning about highly-concurrent database programs. Unfortunately, enforcing serializability has a high performance cost, especially on geographically distributed database clusters. Consequently, many databases allow programmers to choose when a transaction must be executed under serializability, with the expectation that transactions would only be so marked when necessary to avoid serious concurrency bugs. However, this is a significant burden to impose on developers, requiring them to (a) reason about subtle concurrent interactions among potentially interfering transactions, (b) determine when such interactions would violate desired invariants, and (c) then identify the minimum number of transactions whose executions should be serialized to prevent these violations. To mitigate this burden, this paper presents a sound fully-automated schema refactoring procedure that refactors a program’s data layout – rather than its concurrency control logic – to eliminate statically identified concurrency bugs, allowing more transactions to be safely executed under weaker and more performant database guarantees. Experimental results over a range of realistic database benchmarks indicate that our approach is highly effective in eliminating concurrency bugs, with safe refactored programs showing an average of 120% higher throughput and 45% lower latency compared to a serialized baseline.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454028", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kia", + "last_name": "Rahmani", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kartik", + "last_name": "Nagar", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/pldi/RahmaniNDJ21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454072", + "title": "Scooter & Sidecar: a domain-specific approach to writing secure database migrations", + "abstract": "Web applications often handle large amounts of sensitive user data. Modern secure web frameworks protect this data by (1) using declarative languages to specify security policies alongside database schemas and (2) automatically enforcing these policies at runtime. Unfortunately, these frameworks do not handle the very common situation in which the schemas or the policies need to evolve over time---and updates to schemas and policies need to be performed in a carefully coordinated way. Mistakes during schema or policy migrations can unintentionally leak sensitive data or introduce privilege escalation bugs. In this work, we present a domain-specific language (Scooter) for expressing schema and policy migrations, and an associated SMT-based verifier (Sidecar) which ensures that migrations are secure as the application evolves. We describe the design of Scooter and Sidecar and show that our framework can be used to express realistic schemas, policies, and migrations, without giving up on runtime or verification performance.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454072", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John W.", + "last_name": "Renner", + "institution": "University of California, San Diego" + }, + { + "first_name": "Alex", + "last_name": "Sanchez-Stern", + "institution": "University of California, San Diego" + }, + { + "first_name": "Fraser", + "last_name": "Brown", + "institution": "Stanford University" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California, San Diego" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/RennerSBLS21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454112", + "title": "Practical smart contract sharding with ownership and commutativity analysis", + "abstract": "Sharding is a popular way to achieve scalability in blockchain protocols, increasing their throughput by partitioning the set of transaction validators into a number of smaller committees, splitting the workload. Existing approaches for blockchain sharding, however, do not scale well when concurrent transactions alter the same replicated state component—a common scenario in Ethereum-style smart contracts.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454112", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "George", + "last_name": "Pîrlea", + "institution": "National University of Singapore" + }, + { + "first_name": "Amrit", + "last_name": "Kumar", + "institution": "" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "Yale-NUS College" + } + ], + "dblp_key": "conf/pldi/Pirlea0S21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454032", + "title": "Perceus: garbage free reference counting with reuse", + "abstract": "We introduce Perceus, an algorithm for precise reference counting with reuse and specialization. Starting from a functional core language with explicit control-flow, Perceus emits precise reference counting instructions such that (cycle-free) programs are _garbage free_, where only live references are retained. This enables further optimizations, like reuse analysis that allows for guaranteed in-place updates at runtime. This in turn enables a novel programming paradigm that we call _functional but in-place_ (FBIP). Much like tail-call optimization enables writing loops with regular function calls, reuse analysis enables writing in-place mutating algorithms in a purely functional way. We give a novel formalization of reference counting in a linear resource calculus, and prove that Perceus is sound and garbage free. We show evidence that Perceus, as implemented in Koka, has good performance and is competitive with other state-of-the-art memory collectors.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454032", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alex", + "last_name": "Reinking", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" + }, + { + "first_name": "Leonardo de", + "last_name": "Moura", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/ReinkingXML21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3460969", + "title": "Task parallel assembly language for uncompromising parallelism", + "abstract": "Achieving parallel performance and scalability involves making compromises between parallel and sequential computation. If not contained, the overheads of parallelism can easily outweigh its benefits, sometimes by orders of magnitude. Today, we expect programmers to implement this compromise by optimizing their code manually. This process is labor intensive, requires deep expertise, and reduces code quality. Recent work on heartbeat scheduling shows a promising approach that manifests the potentially vast amounts of available, latent parallelism, at a regular rate, based on even beats in time. The idea is to amortize the overheads of parallelism over the useful work performed between the beats. Heartbeat scheduling is promising in theory, but the reality is complicated: it has no known practical implementation.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3460969", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Meta (United States)" + }, + { + "first_name": "Kyle C.", + "last_name": "Hale", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Nikos", + "last_name": "Hardavellas", + "institution": "Northwestern University" + }, + { + "first_name": "Simone", + "last_name": "Campanoni", + "institution": "Northwestern University" + }, + { + "first_name": "Peter A.", + "last_name": "Dinda", + "institution": "Northwestern University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/RaineyNHHCDA21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454035", + "title": "Unleashing the hidden power of compiler optimization on binary code difference: an empirical study", + "abstract": "Hunting binary code difference without source code (i.e., binary diffing) has compelling applications in software security. Due to the high variability of binary code, existing solutions have been driven towards measuring semantic similarities from syntactically different code. Since compiler optimization is the most common source contributing to binary code differences in syntax, testing the resilience against the changes caused by different compiler optimization settings has become a standard evaluation step for most binary diffing approaches. For example, 47 top-venue papers in the last 12 years compared different program versions compiled by default optimization levels (e.g., -Ox in GCC and LLVM). Although many of them claim they are immune to compiler transformations, it is yet unclear about their resistance to non-default optimization settings. Especially, we have observed that adversaries explored non-default compiler settings to amplify malware differences.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454035", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiaolei", + "last_name": "Ren", + "institution": "The University of Texas at Arlington" + }, + { + "first_name": "Michael", + "last_name": "Ho", + "institution": "The University of Texas at Arlington" + }, + { + "first_name": "Jiang", + "last_name": "Ming", + "institution": "The University of Texas at Arlington" + }, + { + "first_name": "Yu", + "last_name": "Lei", + "institution": "The University of Texas at Arlington" + }, + { + "first_name": "Li", + "last_name": "Li", + "institution": "Monash University" + } + ], + "dblp_key": "conf/pldi/RenHMLL21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454033", + "title": "Proof repair across type equivalences", + "abstract": "We describe a new approach to automatically repairing broken proofs in the Coq proof assistant in response to changes in types. Our approach combines a configurable proof term transformation with a decompiler from proof terms to suggested tactic scripts. The proof term transformation implements transport across equivalences in a way that removes references to the old version of the changed type and does not rely on axioms beyond those Coq assumes.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454033", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Talia", + "last_name": "Ringer", + "institution": "University of Washington" + }, + { + "first_name": "RanDair", + "last_name": "Porter", + "institution": "University of Washington" + }, + { + "first_name": "Nathaniel", + "last_name": "Yazdani", + "institution": "Northeastern University" + }, + { + "first_name": "John", + "last_name": "Leo", + "institution": "" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/RingerPYLG21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454104", + "title": "Specification synthesis with constrained Horn clauses", + "abstract": "The problem of synthesizing specifications of undefined procedures has a broad range of applications, but the usefulness of the generated specifications depends on their quality. In this paper, we propose a technique for finding maximal and non-vacuous specifications. Maximality allows for more choices for implementations of undefined procedures, and non-vacuity ensures that safety assertions are reachable. To handle programs with complex control flow, our technique discovers not only specifications but also inductive invariants. Our iterative algorithm lazily generalizes non-vacuous specifications in a counterexample-guided loop. The key component of our technique is an effective non-vacuous specification synthesis algorithm. We have implemented the approach in a tool called HornSpec, taking as input systems of constrained Horn clauses. We have experimentally demonstrated the tool's effectiveness, efficiency, and the quality of generated specifications on a range of benchmarks.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454104", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sumanth", + "last_name": "Prabhu", + "institution": "Tata Consultancy Services (India)" + }, + { + "first_name": "Grigory", + "last_name": "Fedyukovich", + "institution": "Florida State University" + }, + { + "first_name": "Kumar", + "last_name": "Madhukar", + "institution": "Tata Consultancy Services (India)" + }, + { + "first_name": "Deepak", + "last_name": "D’Souza", + "institution": "" + } + ], + "dblp_key": "conf/pldi/SFMD21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454109", + "title": "Bliss: auto-tuning complex applications using a pool of diverse lightweight learning models", + "abstract": "As parallel applications become more complex, auto-tuning becomes more desirable, challenging, and time-consuming. We propose, Bliss, a novel solution for auto-tuning parallel applications without requiring apriori information about applications, domain-specific knowledge, or instrumentation. Bliss demonstrates how to leverage a pool of Bayesian Optimization models to find the near-optimal parameter setting 1.64× faster than the state-of-the-art approaches.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454109", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rohan Basu", + "last_name": "Roy", + "institution": "Northeastern University" + }, + { + "first_name": "Tirthak", + "last_name": "Patel", + "institution": "Northeastern University" + }, + { + "first_name": "Vijay", + "last_name": "Gadepally", + "institution": "MIT Lincoln Laboratory" + }, + { + "first_name": "Devesh", + "last_name": "Tiwari", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/RoyPGT21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454078", + "title": "SPPL: probabilistic programming with fast exact symbolic inference", + "abstract": "We present the Sum-Product Probabilistic Language (SPPL), a new probabilistic programming language that automatically delivers exact solutions to a broad range of probabilistic inference queries. SPPL translates probabilistic programs into sum-product expressions, a new symbolic representation and associated semantic domain that extends standard sum-product networks to support mixed-type distributions, numeric transformations, logical formulas, and pointwise and set-valued constraints. We formalize SPPL via a novel translation strategy from probabilistic programs to sum-product expressions and give sound exact algorithms for conditioning on and computing probabilities of events. SPPL imposes a collection of restrictions on probabilistic programs to ensure they can be translated into sum-product expressions, which allow the system to leverage new techniques for improving the scalability of translation and inference by automatically exploiting probabilistic structure. We implement a prototype of SPPL with a modular architecture and evaluate it on benchmarks the system targets, showing that it obtains up to 3500x speedups over state-of-the-art symbolic systems on tasks such as verifying the fairness of decision tree classifiers, smoothing hidden Markov models, conditioning transformed random variables, and computing rare event probabilities.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454078", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/SaadRM21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454036", + "title": "RefinedC: automating the foundational verification of C code with refined ownership types", + "abstract": "Given the central role that C continues to play in systems software, and the difficulty of writing safe and correct C code, it remains a grand challenge to develop effective formal methods for verifying C programs. In this paper, we propose a new approach to this problem: a type system we call RefinedC, which combines ownership types (for modular reasoning about shared state and concurrency) with refinement types (for encoding precise invariants on C data types and Hoare-style specifications for C functions).", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454036", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rodolphe", + "last_name": "Lepigre", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/SammlerLKMD021", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454084", + "title": "SyRust: automatic testing of Rust libraries with semantic-aware program synthesis", + "abstract": "Rust’s type system ensures the safety of Rust programs; however, programmers can side-step some of the strict typing rules by using the unsafe keyword. A common use of unsafe Rust is by libraries. Bugs in these libraries undermine the safety of the entire Rust program. Therefore, it is crucial to thoroughly test library APIs to rule out bugs. Unfortunately, such testing relies on programmers to manually construct test cases, which is an inefficient and ineffective process.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454084", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yoshiki", + "last_name": "Takashima", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ruben", + "last_name": "Martins", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Corina S.", + "last_name": "Păsăreanu", + "institution": "Ames Research Center" + } + ], + "dblp_key": "conf/pldi/TakashimaM0P21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454064", + "title": "Provable repair of deep neural networks", + "abstract": "Deep Neural Networks (DNNs) have grown in popularity over the past decade and are now being used in safety-critical domains such as aircraft collision avoidance. This has motivated a large number of techniques for finding unsafe behavior in DNNs. In contrast, this paper tackles the problem of correcting a DNN once unsafe behavior is found. We introduce the provable repair problem, which is the problem of repairing a network N to construct a new network N′ that satisfies a given specification. If the safety specification is over a finite set of points, our Provable Point Repair algorithm can find a provably minimal repair satisfying the specification, regardless of the activation functions used. For safety specifications addressing convex polytopes containing infinitely many points, our Provable Polytope Repair algorithm can find a provably minimal repair satisfying the specification for DNNs using piecewise-linear activation functions. The key insight behind both of these algorithms is the introduction of a Decoupled DNN architecture, which allows us to reduce provable repair to a linear programming problem. Our experimental results demonstrate the efficiency and effectiveness of our Provable Repair algorithms on a variety of challenging tasks.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454064", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Sotoudeh", + "institution": "University of California, Davis" + }, + { + "first_name": "Aditya", + "last_name": "Thakur", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/pldi/SotoudehT21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454039", + "title": "Retrofitting effect handlers onto OCaml", + "abstract": "Effect handlers have been gathering momentum as a mechanism for modular programming with user-defined effects. Effect handlers allow for non-local control flow mechanisms such as generators, async/await, lightweight threads and coroutines to be composably expressed. We present a design and evaluate a full-fledged efficient implementation of effect handlers for OCaml, an industrial-strength multi-paradigm programming language. Our implementation strives to maintain the backwards compatibility and performance profile of existing OCaml code. Retrofitting effect handlers onto OCaml is challenging since OCaml does not currently have any non-local control flow mechanisms other than exceptions. Our implementation of effect handlers for OCaml: (i) imposes a mean 1% overhead on a comprehensive macro benchmark suite that does not use effect handlers; (ii) remains compatible with program analysis tools that inspect the stack; and (iii) is efficient for new code that makes use of effect handlers.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454039", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Stephen", + "last_name": "Dolan", + "institution": "" + }, + { + "first_name": "Leo", + "last_name": "White", + "institution": "" + }, + { + "first_name": "Tom", + "last_name": "Kelly", + "institution": "" + }, + { + "first_name": "Sadiq", + "last_name": "Jaffer", + "institution": "" + }, + { + "first_name": "Anil", + "last_name": "Madhavapeddy", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/pldi/Sivaramakrishnan21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454051", + "title": "Concolic program repair", + "abstract": "Automated program repair reduces the manual effort in fixing program errors. However, existing repair techniques modify a buggy program such that it passes given tests. Such repair techniques do not discriminate between correct patches and patches that overfit the available tests (breaking untested but desired functionality). We propose an integrated approach for detecting and discarding overfitting patches via systematic co-exploration of the patch space and input space. We leverage concolic path exploration to systematically traverse the input space (and generate inputs), while ruling out significant parts of the patch space. Given a long enough time budget, this approach allows a significant reduction in the pool of patch candidates, as shown by our experiments. We implemented our technique in the form of a tool called 'CPR' and evaluated its efficacy in reducing the patch space by discarding overfitting patches from a pool of plausible patches. We evaluated our approach for fixing real-world software vulnerabilities and defects, for fixing functionality errors in programs drawn from SV-COMP benchmarks used in software verification, as well as for test-suite guided repair. In our experiments, we observed a patch space reduction due to our concolic exploration of up to 74% for fixing software vulnerabilities and up to 63% for SV-COMP programs. Our technique presents the viewpoint of gradual correctness - repair run over longer time leads to less overfitting fixes.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454051", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ridwan", + "last_name": "Shariffdeen", + "institution": "National University of Singapore" + }, + { + "first_name": "Yannic", + "last_name": "Noller", + "institution": "National University of Singapore" + }, + { + "first_name": "Lars", + "last_name": "Grunske", + "institution": "Humboldt-Universität zu Berlin" + }, + { + "first_name": "Abhik", + "last_name": "Roychoudhury", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/pldi/ShariffdeenNGR21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454086", + "title": "Path-sensitive sparse analysis without path conditions", + "abstract": "Sparse program analysis is fast as it propagates data flow facts via data dependence, skipping unnecessary control flows. However, when path-sensitively checking millions of lines of code, it is still prohibitively expensive because a huge number of path conditions have to be computed and solved via an SMT solver. This paper presents Fusion, a fused approach to inter-procedurally path-sensitive sparse analysis. In Fusion, the SMT solver does not work as a standalone tool on path conditions but directly on the program together with the sparse analysis. Such a fused design allows us to determine the path feasibility without explicitly computing path conditions, not only saving the cost of computing path conditions but also providing an opportunity to enhance the SMT solving algorithm. To the best of our knowledge, Fusion, for the first time, enables whole program bug detection on millions of lines of code in a common personal computer, with the precision of inter-procedural path-sensitivity. Compared to two state-of-the-art tools, Fusion is 10× faster but consumes only 10% of memory on average. Fusion has detected over a hundred bugs in mature open-source software, some of which have even been assigned CVE identifiers due to their security impact.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454086", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qingkai", + "last_name": "Shi", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Peisen", + "last_name": "Yao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Rongxin", + "last_name": "Wu", + "institution": "Xiamen University" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/pldi/ShiYWZ21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454031", + "title": "Transfinite Iris: resolving an existential dilemma of step-indexed separation logic", + "abstract": "Step-indexed separation logic has proven to be a powerful tool for modular reasoning about higher-order stateful programs. However, it has only been used to reason about safety properties, never liveness properties. In this paper, we observe that the inability of step-indexed separation logic to support liveness properties stems fundamentally from its failure to validate the existential property, connecting the meaning of existential quantification inside and outside the logic. We show how to validate the existential property—and thus enable liveness reasoning—by moving from finite step-indices (natural numbers) to transfinite step-indices (ordinals). Concretely, we transform the Coq-based step-indexed logic Iris to Transfinite Iris, and demonstrate its effectiveness in proving termination and termination-preserving refinement for higher-order stateful programs.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454031", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Simon", + "last_name": "Spies", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lennard", + "last_name": "Gäher", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Daniel", + "last_name": "Gratzer", + "institution": "Aarhus University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "Boston College" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/pldi/SpiesGGTKDB21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454066", + "title": "Symbolic Boolean derivatives for efficiently solving extended regular expression constraints", + "abstract": "The manipulation of raw string data is ubiquitous in security-critical software, and verification of such software relies on efficiently solving string and regular expression constraints via SMT. However, the typical case of Boolean combinations of regular expression constraints exposes blowup in existing techniques. To address solvability of such constraints, we propose a new theory of derivatives of symbolic extended regular expressions (extended meaning that complement and intersection are incorporated), and show how to apply this theory to obtain more efficient decision procedures. Our implementation of these ideas, built on top of Z3, matches or outperforms state-of-the-art solvers on standard and handwritten benchmarks, showing particular benefits on examples with Boolean combinations.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454066", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Caleb", + "last_name": "Stanford", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nikolaj", + "last_name": "Bjørner", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/StanfordVB21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454081", + "title": "Automatically enforcing fresh and consistent inputs in intermittent systems", + "abstract": "Intermittently powered energy-harvesting devices enable new applications in inaccessible environments. Program executions must be robust to unpredictable power failures, introducing new challenges in programmability and correctness. One hard problem is that input operations have implicit constraints, embedded in the behavior of continuously powered executions, on when input values can be collected and used. This paper aims to develop a formal framework for enforcing these constraints. We identify two key properties---freshness (i.e., uses of inputs must satisfy the same time constraints as in continuous executions) and temporal consistency (i.e., the collection of a set of inputs must satisfy the same time constraints as in continuous executions). We formalize these properties and show that they can be enforced using atomic regions. We develop Ocelot, an LLVM-based analysis and transformation tool targeting Rust, to enforce these properties automatically. Ocelot provides the programmer with annotations to express these constraints and infers atomic region placement in a program to satisfy them. We then formalize Ocelot's design and show that Ocelot generates correct programs with little performance cost or code changes.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454081", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Milijana", + "last_name": "Surbatovich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/Surbatovich0L21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454026", + "title": "Incremental whole-program analysis in Datalog with lattices", + "abstract": "Incremental static analyses provide up-to-date analysis results in time proportional to the size of a code change, not the entire code base. This promises fast feedback to programmers in IDEs and when checking in commits. However, existing incremental analysis frameworks fail to deliver on this promise for whole-program lattice-based data-flow analyses. In particular, prior Datalog-based frameworks yield good incremental performance only for intra-procedural analyses.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454026", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tamás", + "last_name": "Szabó", + "institution": "" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "" + }, + { + "first_name": "Gábor", + "last_name": "Bergmann", + "institution": "Budapest University of Technology and Economics" + } + ], + "dblp_key": "conf/pldi/SzaboEB21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454029", + "title": "Gleipnir: toward practical error analysis for Quantum programs", + "abstract": "Practical error analysis is essential for the design, optimization, and evaluation of Noisy Intermediate-Scale Quantum(NISQ) computing. However, bounding errors in quantum programs is a grand challenge, because the effects of quantum errors depend on exponentially large quantum states. In this work, we present Gleipnir, a novel methodology toward practically computing verified error bounds in quantum programs. Gleipnir introduces the (ρ,δ)-diamond norm, an error metric constrained by a quantum predicate consisting of the approximate state ρ and its distance δ to the ideal state ρ. This predicate (ρ,δ) can be computed adaptively using tensor networks based on the Matrix Product States. Gleipnir features a lightweight logic for reasoning about error bounds in noisy quantum programs, based on the (ρ,δ)-diamond norm metric. Our experimental results show that Gleipnir is able to efficiently generate tight error bounds for real-world quantum programs with 10 to 100 qubits, and can be used to evaluate the error mitigation performance of quantum compiler transformations.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454029", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Runzhou", + "last_name": "Tao", + "institution": "Columbia University" + }, + { + "first_name": "Yunong", + "last_name": "Shi", + "institution": "University of Chicago" + }, + { + "first_name": "Jianan", + "last_name": "Yao", + "institution": "Columbia University" + }, + { + "first_name": "John", + "last_name": "Hui", + "institution": "Columbia University" + }, + { + "first_name": "Frederic T.", + "last_name": "Chong", + "institution": "University of Chicago" + }, + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/pldi/TaoSYHCG21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454098", + "title": "Example-guided synthesis of relational queries", + "abstract": "Program synthesis tasks are commonly specified via input-output examples. Existing enumerative techniques for such tasks are primarily guided by program syntax and only make indirect use of the examples. We identify a class of synthesis algorithms for programming-by-examples, which we call Example-Guided Synthesis (EGS), that exploits latent structure in the provided examples while generating candidate programs. We present an instance of EGS for the synthesis of relational queries and evaluate it on 86 tasks from three application domains: knowledge discovery, program analysis, and database querying. Our evaluation shows that EGS outperforms state-of-the-art synthesizers based on enumerative search, constraint solving, and hybrid techniques in terms of synthesis time, quality of synthesized programs, and ability to prove unrealizability.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454098", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aalok", + "last_name": "Thakkar", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Aaditya", + "last_name": "Naik", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Nathaniel", + "last_name": "Sands", + "institution": "University of Southern California" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/pldi/ThakkarNSANR21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454062", + "title": "Central moment analysis for cost accumulators in probabilistic programs", + "abstract": "For probabilistic programs, it is usually not possible to automatically derive exact information about their properties, such as the distribution of states at a given program point. Instead, one can attempt to derive approximations, such as upper bounds on tail probabilities. Such bounds can be obtained via concentration inequalities, which rely on the moments of a distribution, such as the expectation (the first raw moment) or the variance (the second central moment). Tail bounds obtained using central moments are often tighter than the ones obtained using raw moments, but automatically analyzing central moments is more challenging.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454062", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Wang0R21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454075", + "title": "Reticle: a virtual machine for programming modern FPGAs", + "abstract": "Modern field-programmable gate arrays (FPGAs) have recently powered high-profile efficiency gains in systems from datacenters to embedded devices by offering ensembles of heterogeneous, reconfigurable hardware units. Programming stacks for FPGAs, however, are stuck in the past—they are based on traditional hardware languages, which were appropriate when FPGAs were simple, homogeneous fabrics of basic programmable primitives. We describe Reticle, a new low-level abstraction for FPGA programming that, unlike existing languages, explicitly represents the special-purpose units available on a particular FPGA device. Reticle has two levels: a portable intermediate language and a target-specific assembly language. We show how to use a standard instruction selection approach to lower intermediate programs to assembly programs, which can be both faster and more effective than the complex metaheuristics that existing FPGA toolchains use. We use Reticle to implement linear algebra operators and coroutines and find that Reticle compilation runs up to 100 times faster than current approaches while producing comparable or better run-time and utilization.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454075", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Luis", + "last_name": "Vega", + "institution": "University of Washington" + }, + { + "first_name": "Joseph", + "last_name": "McMahan", + "institution": "University of Washington" + }, + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "Cornell University" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/pldi/VegaMSGC21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454102", + "title": "Quantitative analysis of assertion violations in probabilistic programs", + "abstract": "We consider the fundamental problem of deriving quantitative bounds on the probability that a given assertion is violated in a probabilistic program. We provide automated algorithms that obtain both lower and upper bounds on the assertion violation probability. The main novelty of our approach is that we prove new and dedicated fixed-point theorems which serve as the theoretical basis of our algorithms and enable us to reason about assertion violation bounds in terms of pre and post fixed-point functions. To synthesize such fixed-points, we devise algorithms that utilize a wide range of mathematical tools, including repulsing ranking supermartingales, Hoeffding's lemma, Minkowski decompositions, Jensen's inequality, and convex optimization. On the theoretical side, we provide (i) the first automated algorithm for lower-bounds on assertion violation probabilities, (ii) the first complete algorithm for upper-bounds of exponential form in affine programs, and (iii) provably and significantly tighter upper-bounds than the previous approaches. On the practical side, we show our algorithms can handle a wide variety of programs from the literature and synthesize bounds that are remarkably tighter than previous results, in some cases by thousands of orders of magnitude.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454102", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jinyi", + "last_name": "Wang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Yican", + "last_name": "Sun", + "institution": "Peking University" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/pldi/WangS0CG21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454068", + "title": "Boosting SMT solver performance on mixed-bitwise-arithmetic expressions", + "abstract": "Satisfiability Modulo Theories (SMT) solvers have been widely applied in automated software analysis to reason about the queries that encode the essence of program semantics, relieving the heavy burden of manual analysis. Many SMT solving techniques rely on solving Boolean satisfiability problem (SAT), which is an NP-complete problem, so they use heuristic search strategies to seek possible solutions, especially when no known theorem can efficiently reduce the problem. An emerging challenge, named Mixed-Bitwise-Arithmetic (MBA) obfuscation, impedes SMT solving by constructing identity equations with both bitwise operations (and, or, negate) and arithmetic computation (add, minus, multiply). Common math theorems for bitwise or arithmetic computation are inapplicable to simplifying MBA equations, leading to performance bottlenecks in SMT solving.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454068", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dongpeng", + "last_name": "Xu", + "institution": "University of New Hampshire" + }, + { + "first_name": "Binbin", + "last_name": "Liu", + "institution": "University of New Hampshire" + }, + { + "first_name": "Weijie", + "last_name": "Feng", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Jiang", + "last_name": "Ming", + "institution": "The University of Texas at Arlington" + }, + { + "first_name": "Qilong", + "last_name": "Zheng", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Jing", + "last_name": "Li", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Qiaoyan", + "last_name": "Yu", + "institution": "University of New Hampshire at Manchester" + } + ], + "dblp_key": "conf/pldi/XuLFMZLY21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454054", + "title": "Automated conformance testing for JavaScript engines via deep compiler fuzzing", + "abstract": "JavaScript (JS) is a popular, platform-independent programming language. To ensure the interoperability of JS programs across different platforms, the implementation of a JS engine should conform to the ECMAScript standard. However, doing so is challenging as there are many subtle definitions of API behaviors, and the definitions keep evolving.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454054", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guixin", + "last_name": "Ye", + "institution": "Northwest University" + }, + { + "first_name": "Zhanyong", + "last_name": "Tang", + "institution": "Northwest University" + }, + { + "first_name": "Shin Hwei", + "last_name": "Tan", + "institution": "Southern University of Science and Technology" + }, + { + "first_name": "Songfang", + "last_name": "Huang", + "institution": "Alibaba Group (China)" + }, + { + "first_name": "Dingyi", + "last_name": "Fang", + "institution": "Northwest University" + }, + { + "first_name": "Xiaoyang", + "last_name": "Sun", + "institution": "University of Leeds" + }, + { + "first_name": "Lizhong", + "last_name": "Bian", + "institution": "Alibaba Group (China)" + }, + { + "first_name": "Haibo", + "last_name": "Wang", + "institution": "University of Leeds" + }, + { + "first_name": "Zheng", + "last_name": "Wang", + "institution": "University of Leeds" + } + ], + "dblp_key": "conf/pldi/YeTTHFSBW021", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454077", + "title": "Sound probabilistic inference via guide types", + "abstract": "Probabilistic programming languages aim to describe and automate Bayesian modeling and inference. Modern languages support programmable inference, which allows users to customize inference algorithms by incorporating guide programs to improve inference performance. For Bayesian inference to be sound, guide programs must be compatible with model programs. One pervasive but challenging condition for model-guide compatibility is absolute continuity, which requires that the model and guide programs define probability distributions with the same support.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454077", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "" + } + ], + "dblp_key": "conf/pldi/Wang0R21a", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454061", + "title": "Quantum abstract interpretation", + "abstract": "In quantum computing, the basic unit of information is a qubit. Simulation of a general quantum program takes exponential time in the number of qubits, which makes simulation infeasible beyond 50 qubits on current supercomputers. So, for the understanding of larger programs, we turn to static techniques. In this paper, we present an abstract interpretation of quantum programs and we use it to automatically verify assertions in polynomial time. Our key insight is to let an abstract state be a tuple of projections. For such domains, we present abstraction and concretization functions that form a Galois connection and we use them to define abstract operations. Our experiments on a laptop have verified assertions about the Bernstein-Vazirani, GHZ, and Grover benchmarks with 300 qubits.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454061", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nengkun", + "last_name": "Yu", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/YuP21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454106", + "title": "AKG: automatic kernel generation for neural processing units using polyhedral transformations", + "abstract": "Existing tensor compilers have proven their effectiveness in deploying deep neural networks on general-purpose hardware like CPU and GPU, but optimizing for neural processing units (NPUs) is still challenging due to the heterogeneous compute units and complicated memory hierarchy.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454106", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jie", + "last_name": "Zhao", + "institution": "" + }, + { + "first_name": "Bojie", + "last_name": "Li", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Wang", + "last_name": "Nie", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Zhen", + "last_name": "Geng", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Renwei", + "last_name": "Zhang", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Xiong", + "last_name": "Gao", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Bin", + "last_name": "Cheng", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Chen", + "last_name": "Wu", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Yun", + "last_name": "Cheng", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Zheng", + "last_name": "Li", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Peng", + "last_name": "Di", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Kun", + "last_name": "Zhang", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Xuefeng", + "last_name": "Jin", + "institution": "Huawei Technologies (China)" + } + ], + "dblp_key": "conf/pldi/ZhaoLNGZGCWCLDZ21", + "venue": "pldi", + "year": 2021 + }, + { + "paper_id": "10.1145/3453483.3454101", + "title": "Execution reconstruction: harnessing failure reoccurrences for failure reproduction", + "abstract": "Reproducing production failures is crucial for software reliability. Alas, existing bug reproduction approaches are not suitable for production systems because they are not simultaneously efficient, effective, and accurate. In this work, we survey prior techniques and show that existing approaches over-prioritize a subset of these properties, and sacrifice the remaining ones. As a result, existing tools do not enable the plethora of proposed failure reproduction use-cases (e.g., debugging, security forensics, fuzzing) for production failures.", + "date": "2021-06-18", + "link": "https://doi.org/10.1145/3453483.3454101", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gefei", + "last_name": "Zuo", + "institution": "University of Michigan" + }, + { + "first_name": "Jiacheng", + "last_name": "Ma", + "institution": "University of Michigan" + }, + { + "first_name": "Andrew", + "last_name": "Quinn", + "institution": "University of Michigan" + }, + { + "first_name": "Pramod", + "last_name": "Bhatotia", + "institution": "" + }, + { + "first_name": "Pedro", + "last_name": "Fonseca", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Baris", + "last_name": "Kasikci", + "institution": "University of Michigan" + } + ], + "dblp_key": "conf/pldi/ZuoM0B0K21", + "venue": "pldi", + "year": 2021 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2022.json b/data/pl_conferences/pldi/2022.json new file mode 100644 index 0000000..e695486 --- /dev/null +++ b/data/pl_conferences/pldi/2022.json @@ -0,0 +1,2351 @@ +[ + { + "paper_id": "10.1145/3519939.3523452", + "title": "Choosing mathematical function implementations for speed and accuracy", + "abstract": "Standard implementations of functions like sin and exp optimize for accuracy, not speed, because they are intended for general-purpose use. But just like many applications tolerate inaccuracy from cancellation, rounding error, and singularities, many application could also tolerate less-accurate function implementations. This raises an intriguing possibility: speeding up numerical code by using different function implementations.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523452", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ian", + "last_name": "Briggs", + "institution": "University of Utah" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/pldi/BriggsP22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523720", + "title": "A study of real-world data races in Golang", + "abstract": "The concurrent programming literature is rich with tools and techniques for data race detection. Less, however, has been known about real-world, industry-scale deployment, experience, and insights about data races. Golang (Go for short) is a modern programming language that makes concurrency a first-class citizen. Go offers both message passing and shared memory for communicating among concurrent threads. Go is gaining popularity in modern microservice-based systems. Data races in Go stand in the face of its emerging popularity.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523720", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Milind", + "last_name": "Chabbi", + "institution": "Uber AI (United States)" + }, + { + "first_name": "Murali", + "last_name": "Ramanathan", + "institution": "Uber AI (United States)" + } + ], + "dblp_key": "conf/pldi/ChabbiR22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523703", + "title": "Semantic soundness for language interoperability", + "abstract": "Programs are rarely implemented in a single language, and thus questions of type soundness should address not only the semantics of a single language, but how it interacts with others. Even between type-safe languages, disparate features can frustrate interoperability, as invariants from one language can easily be violated in the other. In their seminal 2007 paper, Matthews and Findler proposed a multi-language construction that augments the interoperating languages with a pair of boundaries that allow code from one language to be embedded in the other. While this technique has been widely applied, their syntactic source-level interoperability doesn’t reflect practical implementations, where the behavior of interaction is only defined after compilation to a common target, and any safety must be ensured by target invariants or inserted target-level “glue code.”", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523703", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Patterson", + "institution": "Northeastern University" + }, + { + "first_name": "Noble", + "last_name": "Mushtak", + "institution": "Northeastern University" + }, + { + "first_name": "Andrew", + "last_name": "Wagner", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/0001MWA22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523438", + "title": "PyLSE: a pulse-transfer level language for superconductor electronics", + "abstract": "Superconductor electronics (SCE) run at hundreds of GHz and consume only a fraction of the dynamic power of CMOS, but are naturally pulse-based, and operate on impulses with picosecond widths. The transiency of these operations necessitates using logic cells that are inherently stateful. Adopting stateful gates, however, implies an entire reconstruction of the design, simulation, and verification stack. Though challenging, this unique opportunity allows us to build a design framework from the ground up using fundamental principles of programming language design. To this end, we propose PyLSE, an embedded pulse-transfer level language for superconductor electronics. We define PyLSE through formal semantics based on transition systems, and build a framework around them to simulate and analyze SCE cells digitally. To demonstrate its features, we verify its results by model checking in UPPAAL, and compare its complexity and timing against a set of cells designed as analog circuit schematics and simulated in Cadence.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523438", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Christensen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Georgios", + "last_name": "Tzimpragos", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Harlan", + "last_name": "Kringen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Jennifer", + "last_name": "Volk", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Timothy", + "last_name": "Sherwood", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Ben", + "last_name": "Hardekopf", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/pldi/0001TKVSH22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523436", + "title": "Efficient approximations for cache-conscious data placement", + "abstract": "There is a huge and growing gap between the speed of accesses to data stored in main memory vs cache. Thus, cache misses account for a significant portion of runtime overhead in virtually every program and minimizing them has been an active research topic for decades. The primary and most classical formal model for this problem is that of Cache-conscious Data Placement (CDP): given a commutative cache with constant capacity k and a sequence Σ of accesses to data elements, the goal is to map each data element to a cache line such that the total number of cache misses over Σ is minimized. Note that we are considering an offline single-threaded setting in which Σ is known a priori. CDP has been widely studied since the 1990s. In POPL 2002, Petrank and Rawitz proved a notoriously strong hardness result: They showed that for every k ≥ 3, CDP is not only NP-hard but also hard-to-approximate within any non-trivial factor unless P=NP. As such, all subsequent works gave up on theoretical improvements and instead focused on heuristic algorithms with no theoretical guarantees.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523436", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ali", + "last_name": "Ahmadi", + "institution": "Sharif University of Technology" + }, + { + "first_name": "Majid", + "last_name": "Daliri", + "institution": "University of Tehran" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/pldi/AhmadiDGP22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523722", + "title": "Kleene algebra modulo theories: a framework for concrete KATs", + "abstract": "Kleene algebras with tests (KATs) offer sound, complete, and decidable equational reasoning about regularly structured programs. Interest in KATs has increased greatly since NetKAT demonstrated how well extensions of KATs with domain-specific primitives and extra axioms apply to computer networks. Unfortunately, extending a KAT to a new domain by adding custom primitives, proving its equational theory sound and complete, and coming up with an efficient implementation is still an expert’s task. Abstruse metatheory is holding back KAT’s potential.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523722", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Ryan", + "last_name": "Beckett", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Eric Hayden", + "last_name": "Campbell", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/0002BC22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523716", + "title": ""Synthesizing input grammars": a replication study", + "abstract": "When producing test inputs for a program, test generators (\"fuzzers\") can greatly profit from grammars that formally describe the language of expected inputs. In recent years, researchers thus have studied means to recover input grammars from programs and their executions. The GLADE algorithm by Bastani et al., published at PLDI 2017, was the first black-box approach to claim context-free approximation of input specification for non-trivial languages such as XML, Lisp, URLs, and more.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523716", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bachir", + "last_name": "Bendrissou", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Rahul", + "last_name": "Gopinath", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Andreas", + "last_name": "Zeller", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "conf/pldi/BendrissouGZ22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523442", + "title": "Autoscheduling for sparse tensor algebra with an asymptotic cost model", + "abstract": "While loop reordering and fusion can make big impacts on the constant-factor performance of dense tensor programs, the effects on sparse tensor programs are asymptotic, often leading to orders of magnitude performance differences in practice. Sparse tensors also introduce a choice of compressed storage formats that can have asymptotic effects. Research into sparse tensor compilers has led to simplified languages that express these tradeoffs, but the user is expected to provide a schedule that makes the decisions. This is challenging because schedulers must anticipate the interaction between sparse formats, loop structure, potential sparsity patterns, and the compiler itself. Automating this decision making process stands to finally make sparse tensor compilers accessible to end users.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523442", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Willow", + "last_name": "Ahrens", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/AhrensKA22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523701", + "title": "All you need is superword-level parallelism: systematic control-flow vectorization with SLP", + "abstract": "Superword-level parallelism (SLP) vectorization is a proven technique for vectorizing straight-line code. It works by replacing independent, isomorphic instructions with equivalent vector instructions. Larsen and Amarasinghe originally proposed using SLP vectorization (together with loop unrolling) as a simpler, more flexible alternative to traditional loop vectorization. However, this vision of replacing traditional loop vectorization has not been realized because SLP vectorization cannot directly reason with control flow.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523701", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yishen", + "last_name": "Chen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/ChenMA22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523449", + "title": "Finding the dwarf: recovering precise types from WebAssembly binaries", + "abstract": "The increasing popularity of WebAssembly creates a demand for understanding and reverse engineering WebAssembly binaries. Recovering high-level function types is an important part of this process. One method to recover types is data-flow analysis, but it is complex to implement and may require manual heuristics when logical constraints fall short. In contrast, this paper presents SnowWhite, a learning-based approach for recovering precise, high-level parameter and return types for WebAssembly functions. It improves over prior work on learning-based type recovery by representing the types-to-predict in an expressive type language, which can describe a large number of complex types, instead of the fixed, and usually small type vocabulary used previously. Thus, recovery of a single type is no longer a classification task but sequence prediction, for which we build on the success of neural sequence-to-sequence models. We evaluate SnowWhite on a new, large-scale dataset of 6.3 million type samples extracted from 300,905 WebAssembly object files. The results show the type language is expressive, precisely describing 1,225 types instead the 7 to 35 types considered in previous learning-based approaches. Despite this expressiveness, our type recovery has high accuracy, exactly matching 44.5% (75.2%) of all parameter types and 57.7% (80.5%) of all return types within the top-1 (top-5) predictions.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523449", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Lehmann", + "institution": "University of Stuttgart" + }, + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "University of Stuttgart" + } + ], + "dblp_key": "conf/pldi/0002P22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523453", + "title": "Abstract interpretation repair", + "abstract": "Abstract interpretation is a sound-by-construction method for program verification: any erroneous program will raise some alarm. However, the verification of correct programs may yield false-alarms, namely it may be incomplete. Ideally, one would like to perform the analysis on the most abstract domain that is precise enough to avoid false-alarms. We show how to exploit a weaker notion of completeness, called local completeness, to optimally refine abstract domains and thus enhance the precision of program verification. Our main result establishes necessary and sufficient conditions for the existence of an optimal, locally complete refinement, called pointed shell. On top of this, we define two repair strategies to remove all false-alarms along a given abstract computation: the first proceeds forward, along with the concrete computation, while the second moves backward within the abstract computation. Our results pave the way for a novel modus operandi for automating program verification that we call Abstract Interpretation Repair (AIR): instead of choosing beforehand the right abstract domain, we can start in any abstract domain and progressively repair its local incompleteness as needed. In this regard, AIR is for abstract interpretation what CEGAR is for abstract model checking.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523453", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Roberto", + "last_name": "Bruni", + "institution": "University of Pisa" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Verona" + }, + { + "first_name": "Roberta", + "last_name": "Gori", + "institution": "University of Pisa" + }, + { + "first_name": "Francesco", + "last_name": "Ranzato", + "institution": "University of Padua" + } + ], + "dblp_key": "conf/pldi/BruniGGR22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523447", + "title": "Progressive polynomial approximations for fast correctly rounded math libraries", + "abstract": "This paper presents a novel method for generating a single polynomial approximation that produces correctly rounded results for all inputs of an elementary function for multiple representations. The generated polynomial approximation has the nice property that the first few lower degree terms produce correctly rounded results for specific representations of smaller bitwidths, which we call progressive performance. To generate such progressive polynomial approximations, we approximate the correctly rounded result and formulate the computation of correctly rounded polynomial approximations as a linear program similar to our prior work on the RLIBM project. To enable the use of resulting polynomial approximations in mainstream libraries, we want to avoid piecewise polynomials with large lookup tables. We observe that the problem of computing polynomial approximations for elementary functions is a linear programming problem in low dimensions, i.e., with a small number of unknowns. We design a fast randomized algorithm for computing polynomial approximations with progressive performance. Our method produces correct and fast polynomials that require a small amount of storage. A few polynomial approximations from our prototype have already been incorporated into LLVM’s math library.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523447", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mridul", + "last_name": "Aanjaneya", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Jay P.", + "last_name": "Lim", + "institution": "Yale University" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/pldi/AanjaneyaLN22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523709", + "title": "Visualization question answering using introspective program synthesis", + "abstract": "While data visualization plays a crucial role in gaining insights from data, generating answers over complex visualizations from natural language questions is far from an easy task. Mainstream approaches reduce data visualization queries to a semantic parsing problem, which either relies on expensive-to-annotate supervised training data that pairs natural language questions with logical forms, or weakly supervised models that incorporate a larger corpus but fail on long-tailed queries without explanations. This paper aims to answer data visualization queries by automatically synthesizing the corresponding program from natural language. At the core of our technique is an abstract synthesis engine that is bootstrapped by an off-the-shelf weakly supervised model and an optimal synthesis algorithm guided by triangle alignment constraints, which represent consistency among natural language, visualization, and the synthesized program.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523709", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yanju", + "last_name": "Chen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Xifeng", + "last_name": "Yan", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/pldi/ChenY022", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523721", + "title": "Guaranteed bounds for posterior inference in universal probabilistic programming", + "abstract": "We propose a new method to approximate the posterior distribution of probabilistic programs by means of computing guaranteed bounds. The starting point of our work is an interval-based trace semantics for a recursive, higher-order probabilistic programming language with continuous distributions. Taking the form of (super-/subadditive) measures, these lower/upper bounds are non-stochastic and provably correct: using the semantics, we prove that the actual posterior of a given program is sandwiched between the lower and upper bounds (soundness); moreover, the bounds converge to the posterior (completeness). As a practical and sound approximation, we introduce a weight-aware interval type system, which automatically infers interval bounds on not just the return value but also the weight of program executions, simultaneously. We have built a tool implementation, called GuBPI, which automatically computes these posterior lower/upper bounds. Our evaluation on examples from the literature shows that the bounds are useful, and can even be used to recognise wrong outputs from stochastic posterior inference procedures.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523721", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Raven", + "last_name": "Beutner", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + }, + { + "first_name": "Fabian", + "last_name": "Zaiser", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/pldi/BeutnerOZ22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523730", + "title": "Turning manual concurrent memory reclamation into automatic reference counting", + "abstract": "Safe memory reclamation (SMR) schemes are an essential tool for lock-free data structures and concurrent programming. However, manual SMR schemes are notoriously difficult to apply correctly, and automatic schemes, such as reference counting, have been argued for over a decade to be too slow for practical purposes. A recent wave of work has disproved this long-held notion and shown that reference counting can be as scalable as hazard pointers, one of the most common manual techniques. Despite these tremendous improvements, there remains a gap of up to 2x or more in performance between these schemes and faster manual techniques such as epoch-based reclamation (EBR).", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523730", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Anderson", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yuanhao", + "last_name": "Wei", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/AndersonBW22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523427", + "title": "Finding typing compiler bugs", + "abstract": "We propose a testing framework for validating static typing procedures in compilers. Our core component is a program generator suitably crafted for producing programs that are likely to trigger typing compiler bugs. One of our main contributions is that our program generator gives rise to transformation-based compiler testing for finding typing bugs. We present two novel approaches (type erasure mutation and type overwriting mutation) that apply targeted transformations to an input program to reveal type inference and soundness compiler bugs respectively. Both approaches are guided by an intra-procedural type inference analysis used to capture type information flow.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523427", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stefanos", + "last_name": "Chaliasos", + "institution": "Imperial College London" + }, + { + "first_name": "Thodoris", + "last_name": "Sotiropoulos", + "institution": "Athens University of Economics and Business" + }, + { + "first_name": "Diomidis", + "last_name": "Spinellis", + "institution": "Delft University of Technology" + }, + { + "first_name": "Arthur", + "last_name": "Gervais", + "institution": "Imperial College London" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Imperial College London" + }, + { + "first_name": "Dimitris", + "last_name": "Mitropoulos", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/pldi/ChaliasosSSGLM22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523429", + "title": "Can reactive synthesis and syntax-guided synthesis be friends?", + "abstract": "While reactive synthesis and syntax-guided synthesis (SyGuS) have seen enormous progress in recent years, combining the two approaches has remained a challenge. In this work, we present the synthesis of reactive programs from Temporal Stream Logic modulo theories (TSL-MT), a framework that unites the two approaches to synthesize a single program. In our approach, reactive synthesis and SyGuS collaborate in the synthesis process, and generate executable code that implements both reactive and data-level properties.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523429", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wonhyuk", + "last_name": "Choi", + "institution": "Columbia University" + }, + { + "first_name": "Bernd", + "last_name": "Finkbeiner", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + }, + { + "first_name": "Mark", + "last_name": "Santolucito", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/pldi/ChoiFPS22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523718", + "title": "Sequential reasoning for optimizing compilers under weak memory concurrency", + "abstract": "We formally show that sequential reasoning is adequate and sufficient for establishing soundness of various compiler optimizations under weakly consistent shared-memory concurrency. Concretely, we introduce a sequential model and show that behavioral refinement in that model entails contextual refinement in the Promising Semantics model, extended with non-atomic accesses for non-racy code. This is the first work to achieve such result for a full-fledged model with a variety of C11-style concurrency features. Central to our model is the lifting of the common data-race-freedom assumption, which allows us to validate irrelevant load introduction, a transformation that is commonly performed by compilers. As a proof of concept, we develop an optimizer for a toy concurrent language, and certify it (in Coq) while relying solely on the sequential model. We believe that the proposed approach provides useful means for compiler developers and validators, as well as a solid foundation for the development of certified optimizing compilers for weakly consistent shared-memory concurrency.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523718", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Sung-Hwan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Dongjae", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/pldi/ChoLLHL22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523733", + "title": "PaC-trees: supporting parallel and compressed purely-functional collections", + "abstract": "Many modern programming languages are shifting toward a functional style for collection interfaces such as sets, maps, and sequences. Functional interfaces offer many advantages, including being safe for parallelism and providing simple and lightweight snapshots. However, existing high-performance functional interfaces such as PAM, which are based on balanced purely-functional trees, incur large space overheads for large-scale data analysis due to storing every element in a separate node in a tree.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523733", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Laxman", + "last_name": "Dhulipala", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yan", + "last_name": "Gu", + "institution": "University of California, Riverside" + }, + { + "first_name": "Yihan", + "last_name": "Sun", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/pldi/DhulipalaB0022", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523727", + "title": "Sound sequentialization for concurrent program verification", + "abstract": "We present a systematic investigation and experimental evaluation of a large space of algorithms for the verification of concurrent programs. The algorithms are based on sequentialization. In the analysis of concurrent programs, the general idea of sequentialization is to select a subset of interleavings, represent this subset as a sequential program, and apply a generic analysis for sequential programs. For the purpose of verification, the sequentialization has to be sound (meaning that the proof for the sequential program entails the correctness of the concurrent program). We use the concept of a preference order to define which interleavings the sequentialization is to select (\"the most preferred ones\"). A verification algorithm based on sound sequentialization that is parametrized in a preference order allows us to directly evaluate the impact of the selection of the subset of interleavings on the performance of the algorithm. Our experiments indicate the practical potential of sound sequentialization for concurrent program verification.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523727", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Dominik", + "last_name": "Klumpp", + "institution": "University of Freiburg" + }, + { + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/pldi/FarzanKP22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523445", + "title": "Modular information flow through ownership", + "abstract": "Statically analyzing information flow, or how data influences other data within a program, is a challenging task in imperative languages. Analyzing pointers and mutations requires access to a program's complete source. However, programs often use pre-compiled dependencies where only type signatures are available. We demonstrate that ownership types can be used to soundly and precisely analyze information flow through function calls given only their type signature. From this insight, we built Flowistry, a system for analyzing information flow in Rust, an ownership-based language. We prove the system's soundness as a form of noninterference using the Oxide formal model of Rust. Then we empirically evaluate the precision of Flowistry, showing that modular flows are identical to whole-program flows in 94% of cases drawn from large Rust codebases. We illustrate the applicability of Flowistry by using it to implement prototypes of a program slicer and an information flow control system.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523445", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Will", + "last_name": "Crichton", + "institution": "Stanford University" + }, + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "University of Trento" + }, + { + "first_name": "Maneesh", + "last_name": "Agrawala", + "institution": "Stanford University" + }, + { + "first_name": "Pat", + "last_name": "Hanrahan", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/CrichtonPAH22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523729", + "title": "Deoptless: speculation with dispatched on-stack replacement and specialized continuations", + "abstract": "Just-in-time compilation provides significant performance improvements for programs written in dynamic languages. These benefits come from the ability of the compiler to speculate about likely cases and generate optimized code for these. Unavoidably, speculations sometimes fail and the optimizations must be reverted. In some pathological cases, this can leave the program stuck with suboptimal code. In this paper we propose deoptless, a technique that replaces deoptimization points with dispatched specialized continuations. The goal of deoptless is to take a step towards providing users with a more transparent performance model in which mysterious slowdowns are less frequent and grave.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523729", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Flückiger", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Ječmen", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Sebastián", + "last_name": "Krynski", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/pldi/FluckigerJKV22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523430", + "title": "Deep and shallow types for gradual languages", + "abstract": "Sound gradual types come in many forms and offer varying levels of soundness. Two extremes are deep types and shallow types. Deep types offer compositional guarantees but depend on expensive higher-order contracts. Shallow types enforce only local properties, but can be implemented with first-order checks. This paper presents a language design that supports both deep and shallow types to utilize their complementary strengths.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523430", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/pldi/Greenman22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523725", + "title": "ANOSY: approximated knowledge synthesis with refinement types for declassification", + "abstract": "Non-interference is a popular way to enforce confidentiality of sensitive data. However, declassification of sensitive information is often needed in realistic applications but breaks non-interference. We present ANOSY, an approximate knowledge synthesizer for quantitative declassification policies. ANOSY uses refinement types to automatically construct machine checked over- and under-approximations of attacker knowledge for boolean queries on multi-integer secrets. It also provides an AnosyT monad to track the attacker knowledge over multiple declassification queries and checks for violations against user-specified policies in information flow control applications. We implement a prototype of ANOSY and show that it is precise and permissive: up to 14 declassification queries are permitted before a policy violation occurs using the powerset of intervals domain.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523725", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sankha Narayan", + "last_name": "Guria", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software" + }, + { + "first_name": "Marco", + "last_name": "Guarnieri", + "institution": "IMDEA Software" + }, + { + "first_name": "James", + "last_name": "Parker", + "institution": "Galois (United States)" + } + ], + "dblp_key": "conf/pldi/GuriaVGP22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523715", + "title": "Leapfrog: certified equivalence for protocol parsers", + "abstract": "We present Leapfrog, a Coq-based framework for verifying equivalence of network protocol parsers. Our approach is based on an automata model of P4 parsers, and an algorithm for symbolically computing a compact representation of a bisimulation, using \"leaps.\" Proofs are powered by a certified compilation chain from first-order entailments to low-level bitvector verification conditions, which are discharged using off-the-shelf SMT solvers. As a result, parser equivalence proofs in Leapfrog are fully automatic and push-button. We mechanically prove the core metatheory that underpins our approach, including the key transformations and several optimizations. We evaluate Leapfrog on a range of practical case studies, all of which require minimal configuration and no manual proof. Our largest case study uses Leapfrog to perform translation validation for a third-party compiler from automata to hardware pipelines. Overall, Leapfrog represents a step towards a world where all parsers for critical network infrastructure are verified. It also suggests directions for follow-on efforts, such as verifying relational properties involving security.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523715", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Doenges", + "institution": "Cornell University" + }, + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "University of Amsterdam" + }, + { + "first_name": "John", + "last_name": "Sarracino", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/DoengesKSFM22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523711", + "title": "WebRobot: web robotic process automation using interactive programming-by-demonstration", + "abstract": "It is imperative to democratize robotic process automation (RPA), as RPA has become a main driver of the digital transformation but is still technically very demanding to construct, especially for non-experts. In this paper, we study how to automate an important class of RPA tasks, dubbed web RPA, which are concerned with constructing software bots that automate interactions across data and a web browser. Our main contributions are twofold. First, we develop a formal foundation which allows semantically reasoning about web RPA programs and formulate its synthesis problem in a principled manner. Second, we propose a web RPA program synthesis algorithm based on a new idea called speculative rewriting. This leads to a novel speculate-and-validate methodology in the context of rewrite-based program synthesis, which has also shown to be both theoretically simple and practically efficient for synthesizing programs from demonstrations. We have built these ideas in a new interactive synthesizer called WebRobot and evaluate it on 76 web RPA benchmarks. Our results show that WebRobot automated a majority of them effectively. Furthermore, we show that WebRobot compares favorably with a conventional rewrite-based synthesis baseline implemented using egg. Finally, we conduct a small user study demonstrating WebRobot is also usable.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523711", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rui", + "last_name": "Dong", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Zhicheng", + "last_name": "Huang", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Ian Iong", + "last_name": "Lam", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Yan", + "last_name": "Chen", + "institution": "University of Toronto" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/pldi/DongHLCW22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523726", + "title": "Recursion synthesis with unrealizability witnesses", + "abstract": "We propose SE2GIS, a novel inductive recursion synthesis approach with the ability to both synthesize code and declare a problem unsolvable. SE2GIS combines a symbolic variant of counterexample-guided inductive synthesis (CEGIS) with a new dual inductive procedure, which focuses on proving a synthesis problem unsolvable rather than finding a solution for it. A vital component of this procedure is a new algorithm that produces a witness, a set of concrete assignments to relevant variables, as a proof that the synthesis instance is not solvable. Witnesses in the dual inductive procedure play the same role that solutions do in classic CEGIS; that is, they ensure progress. Given a reference function, invariants on the input recursive data types, and a target family of recursive functions, SE2GIS synthesizes an implementation in this family that is equivalent to the reference implementation, or declares the problem unsolvable and produces a witness for it. We demonstrate that SE2GIS is effective in both cases; that is, for interesting data types with complex invariants, it can synthesize non-trivial recursive functions or output witnesses that contain useful feedback for the user.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523726", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Danya", + "last_name": "Lette", + "institution": "University of Toronto" + }, + { + "first_name": "Victor", + "last_name": "Nicolet", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/pldi/FarzanLN22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523700", + "title": "IRDL: an IR definition language for SSA compilers", + "abstract": "Designing compiler intermediate representations (IRs) is often a manual process that makes exploration and innovation in this space costly. Developers typically use general-purpose programming languages to design IRs. As a result, IR implementations are verbose, manual modifications are expensive, and designing tooling for the inspection or generation of IRs is impractical. While compilers relied historically on a few slowly evolving IRs, domain-specific optimizations and specialized hardware motivate compilers to use and evolve many IRs. We facilitate the implementation of SSA-based IRs by introducing IRDL, a domain-specific language to define IRs. We analyze all 28 domain-specific IRs developed as part of LLVM's MLIR project over the last two years and demonstrate how to express these IRs exclusively in IRDL while only rarely falling back to IRDL's support for generic C++ extensions. By enabling the concise and explicit specification of IRs, we provide foundations for developing effective tooling to automate the compiler construction process.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523700", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mathieu", + "last_name": "Fehr", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jeff", + "last_name": "Niu", + "institution": "University of Waterloo" + }, + { + "first_name": "River", + "last_name": "Riddle", + "institution": "Modular Genetics (United States)" + }, + { + "first_name": "Mehdi", + "last_name": "Amini", + "institution": "Google (United States)" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/FehrNRA0G22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523717", + "title": "P4BID: information flow control in p4", + "abstract": "Modern programmable network switches can implement custom applications using efficient packet processing hardware, and the programming language P4 provides high-level constructs to program such switches. The increase in speed and programmability has inspired research in dataplane programming, where many complex functionalities, e.g., key-value stores and load balancers, can be implemented entirely in network switches. However, dataplane programs may suffer from novel security errors that are not traditionally found in network switches.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523717", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Karuna", + "last_name": "Grewal", + "institution": "Cornell University" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/GrewalDH22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523451", + "title": "Compass: strong and compositional library specifications in relaxed memory separation logic", + "abstract": "Several functional correctness criteria have been proposed for relaxed-memory consistency libraries, but most lack support for modular client reasoning. Mével and Jourdan recently showed that logical atomicity can be used to give strong modular Hoare-style specifications for relaxed libraries, but only for a limited instance in the Multicore OCaml memory model. It has remained unclear if their approach scales to weaker implementations in weaker memory models.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523451", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hoang-Hai", + "last_name": "Dang", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "JaeHwang", + "last_name": "Jung", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jaemin", + "last_name": "Choi", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Duc-Than", + "last_name": "Nguyen", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "William", + "last_name": "Mansky", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/DangJCNMKD22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523450", + "title": "Type-directed program synthesis for RESTful APIs", + "abstract": "With the rise of software-as-a-service and microservice architectures, RESTful APIs are now ubiquitous in mobile and web applications. A service can have tens or hundreds of API methods, making it a challenge for programmers to find the right combination of methods to solve their task.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523450", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zheng", + "last_name": "Guo", + "institution": "University of California, San Diego" + }, + { + "first_name": "David", + "last_name": "Cao", + "institution": "University of California, San Diego" + }, + { + "first_name": "Davin", + "last_name": "Tjong", + "institution": "University of California, San Diego" + }, + { + "first_name": "Jean", + "last_name": "Yang", + "institution": "" + }, + { + "first_name": "Cole", + "last_name": "Schlesinger", + "institution": "" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/pldi/GuoCT0SP22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523723", + "title": "Checking robustness to weak persistency models", + "abstract": "Persistent memory (PM) technologies offer performance close to DRAM with persistence. Persistent memory enables programs to directly modify persistent data through normal load and store instructions bypassing heavyweight OS system calls for persistency. However, these stores are not made immediately made persistent, the developer must manually flush the corresponding cache lines to force the data to be written to persistent memory. While state-of-the-art testing tools can help developers find and fix persistency bugs, prior studies have shown fixing persistency bugs on average takes a couple of weeks for PM developers. The developer has to manually inspect the execution to identify the root cause of the problem. In addition, most of the existing state-of-the-art testing tools require heavy user annotations to detect bugs without visible symptoms such as a segmentation fault.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523723", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hamed", + "last_name": "Gorjiara", + "institution": "University of California, Irvine" + }, + { + "first_name": "Weiyu", + "last_name": "Luo", + "institution": "University of California, Irvine" + }, + { + "first_name": "Alex Pui‐Wai", + "last_name": "Lee", + "institution": "University of California, Irvine" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/pldi/GorjiaraLLXD22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523444", + "title": "Adore: atomic distributed objects with certified reconfiguration", + "abstract": "Finding the right abstraction is critical for reasoning about complex systems such as distributed protocols like Paxos and Raft. Despite a recent abundance of impressive verification work in this area, we claim the ways that past efforts model distributed state are not ideal for protocol-level reasoning: they either hide important details, or leak too much complexity from the network. As evidence we observe that nearly all of them avoid the complex, but important issue of reconfiguration. Reconfiguration's primary challenge lies in how it interacts with a protocol's core safety invariants. To handle this increased complexity, we introduce the Adore model, whose novel abstract state hides network-level communications while capturing dependencies between committed and uncommitted states, as well as metadata like election quorums. It includes first-class support for a generic reconfiguration command that can be instantiated with a variety of implementations. Under this model, the subtle interactions between reconfiguration and the core protocol become clear, and with this insight we completed the first mechanized proof of safety of a reconfigurable consensus protocol.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523444", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wolf", + "last_name": "Honoré", + "institution": "Yale University" + }, + { + "first_name": "Ji-Yong", + "last_name": "Shin", + "institution": "Northeastern University" + }, + { + "first_name": "Jieung", + "last_name": "Kim", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/pldi/HonoreSKS22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523426", + "title": "Hamband: RDMA replicated data types", + "abstract": "Data centers are increasingly equipped with RDMAs. These network interfaces mark the advent of a new distributed system model where a node can directly access the remote memory of another. They have enabled microsecond-scale replicated services. The underlying replication protocols of these systems execute all operations under strong consistency. However, strong consistency can hinder response time and availability, and recent replication models have turned to a hybrid of strong and relaxed consistency. This paper presents RDMA well-coordinated replicated data types, the first hybrid replicated data types for the RDMA network model. It presents a novel operational semantics for these data types that considers three distinct categories of methods and captures their required coordination, and formally proves that they preserve convergence and integrity. It implements these semantics in a system called Hamband that leverages direct remote accesses to efficiently implement the required coordination protocols. The empirical evaluation shows that Hamband outperforms the throughput of existing message-based and strongly consistent implementations by more than 17x and 2.7x respectively.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523426", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Farzin", + "last_name": "Houshmand", + "institution": "University of California, Riverside" + }, + { + "first_name": "Javad", + "last_name": "Saberlatibari", + "institution": "University of California, Riverside" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/pldi/HoushmandSL22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523454", + "title": "WARio: efficient code generation for intermittent computing", + "abstract": "Intermittently operating embedded computing platforms powered by energy harvesting require software frameworks to protect from errors caused by Write After Read (WAR) dependencies. A powerful method of code protection for systems with non-volatile main memory utilizes compiler analysis to insert a checkpoint inside each WAR violation in the code. However, such software frameworks are oblivious to the code structure---and therefore, inefficient---when many consecutive WAR violations exist. Our insight is that by transforming the input code, i.e., moving individual write operations from unique WARs close to each other, we can significantly reduce the number of checkpoints. This idea is the foundation for WARio: a set of compiler transformations for efficient code generation for intermittent computing. WARio, on average, reduces checkpoint overhead by 58%, and up to 88%, compared to the state of the art across various benchmarks.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523454", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vito", + "last_name": "Kortbeek", + "institution": "Delft University of Technology" + }, + { + "first_name": "Souradip", + "last_name": "Ghosh", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Josiah", + "last_name": "Hester", + "institution": "Northwestern University" + }, + { + "first_name": "Simone", + "last_name": "Campanoni", + "institution": "Northwestern University" + }, + { + "first_name": "Przemysław", + "last_name": "Pawełczak", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/pldi/KortbeekGHCP22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523731", + "title": "CycleQ: an efficient basis for cyclic equational reasoning", + "abstract": "We propose a new cyclic proof system for automated, equational reasoning about the behaviour of pure functional programs. The key to the system is the way in which cyclic proofs and equational reasoning are mediated by the use of contextual substitution as a cut rule. We show that our system, although simple, already subsumes several of the approaches to implicit induction variously known as “inductionless induction”, “rewriting induction”, and “proof by consistency”. By restricting the form of the traces, we show that global correctness in our system can be verified incrementally, taking advantage of the well-known size-change principle, which leads to an efficient implementation of proof search. Our CycleQ tool, implemented as a GHC plugin, shows promising results on a number of standard benchmarks.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523731", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Eddie", + "last_name": "Jones", + "institution": "University of Bristol" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + }, + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Bristol" + } + ], + "dblp_key": "conf/pldi/JonesOR22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523446", + "title": "Exocompilation for productive programming of hardware accelerators", + "abstract": "High-performance kernel libraries are critical to exploiting accelerators and specialized instructions in many applications. Because compilers are difficult to extend to support diverse and rapidly-evolving hardware targets, and automatic optimization is often insufficient to guarantee state-of-the-art performance, these libraries are commonly still coded and optimized by hand, at great expense, in low-level C and assembly. To better support development of high-performance libraries for specialized hardware, we propose a new programming language, Exo, based on the principle of exocompilation: externalizing target-specific code generation support and optimization policies to user-level code. Exo allows custom hardware instructions, specialized memories, and accelerator configuration state to be defined in user libraries. It builds on the idea of user scheduling to externalize hardware mapping and optimization decisions. Schedules are defined as composable rewrites within the language, and we develop a set of effect analyses which guarantee program equivalence and memory safety through these transformations. We show that Exo enables rapid development of state-of-the-art matrix-matrix multiply and convolutional neural network kernels, for both an embedded neural accelerator and x86 with AVX-512 extensions, in a few dozen lines of code each.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523446", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuka", + "last_name": "Ikarashi", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Gilbert", + "last_name": "Bernstein", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Reinking", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Hasan", + "last_name": "Genc", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/IkarashiBRGR22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523724", + "title": "RunTime-assisted convergence in replicated data types", + "abstract": "We propose a runtime-assisted approach to enforce convergence in distributed executions of replicated data types. The key distinguishing aspect of our approach is that it guarantees convergence unconditionally – without requiring data type operations to satisfy algebraic laws such as commutativity and idempotence. Consequently, programmers are no longer obligated to prove convergence on a per-type basis. Moreover, our approach lets sequential data types be reused in a distributed setting by extending their implementations rather than refactoring them. The novel component of our approach is a distributed runtime that orchestrates well-formed executions that are guaranteed to converge. Despite the utilization of a runtime, our approach comes at no additional cost of latency and availability. Instead, we introduce a novel tradeoff against a metric called staleness, which roughly corresponds to the time taken for replicas to converge. We implement our approach in a system called Quark and conduct a thorough evaluation of its tradeoffs.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523724", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Prasanth", + "last_name": "Prahladan", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Nicholas V.", + "last_name": "Lewchenko", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/pldi/KakiPL22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523456", + "title": "Software-hardware codesign for efficient in-memory regular pattern matching", + "abstract": "Regular pattern matching is used in numerous application domains, including text processing, bioinformatics, and network security. Patterns are typically expressed with an extended syntax of regular expressions. This syntax includes the computationally challenging construct of bounded repetition or counting, which describes the repetition of a pattern a fixed number of times. We develop a specialized in-memory hardware architecture that integrates counter and bit vector modules into a state-of-the-art in-memory NFA accelerator. The design is inspired by the theoretical model of nondeterministic counter automata (NCA). A key feature of our approach is that we statically analyze regular expressions to determine bounds on the amount of memory needed for the occurrences of bounded repetition. The results of this analysis are used by a regex-to-hardware compiler in order to make an appropriate selection of counter or bit vector modules. We evaluate our hardware implementation using a simulator based on circuit parameters collected by SPICE simulation in TSMC 28nm CMOS process. We find that the use of counter and bit vector modules outperforms unfolding solutions by orders of magnitude. Experiments concerning realistic workloads show up to 76% energy reduction and 58% area reduction in comparison to CAMA, a recently proposed in-memory NFA accelerator.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523456", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lingkun", + "last_name": "Kong", + "institution": "Rice University" + }, + { + "first_name": "Qixuan", + "last_name": "Yu", + "institution": "Rice University" + }, + { + "first_name": "Agnishom", + "last_name": "Chattopadhyay", + "institution": "Rice University" + }, + { + "first_name": "Alexis Le", + "last_name": "Glaunec", + "institution": "Rice University" + }, + { + "first_name": "Yi", + "last_name": "Huang", + "institution": "Rice University" + }, + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + }, + { + "first_name": "Kaiyuan", + "last_name": "Yang", + "institution": "Rice University" + } + ], + "dblp_key": "conf/pldi/KongYCGHM022", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523707", + "title": "Computing correctly with inductive relations", + "abstract": "Inductive relations are the predominant way of writing specifications in mechanized proof developments. Compared to purely functional specifications, they enjoy increased expressive power and facilitate more compositional reasoning. However, inductive relations also come with a significant drawback: they can’t be used for computation.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523707", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Northeastern University" + }, + { + "first_name": "Aaron", + "last_name": "Eline", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/Paraskevopoulou22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523728", + "title": "Quickstrom: property-based acceptance testing with LTL specifications", + "abstract": "We present Quickstrom, a property-based testing system for acceptance testing of interactive applications. Using Quickstrom, programmers can specify the behaviour of web applications as properties in our testing-oriented dialect of Linear Temporal Logic (LTL) called QuickLTL, and then automatically test their application against the given specification with hundreds of automatically generated interactions. QuickLTL extends existing finite variants of LTL for the testing use-case, determining likely outcomes from partial traces whose minimum length is itself determined by the LTL formula. This temporal logic is embedded in our specification language, Specstrom, which is designed to be approachable to web programmers, expressive for writing specifications, and easy to analyse. Because Quickstrom tests only user-facing behaviour, it is agnostic to the implementation language of the system under test. We therefore formally specify and test many implementations of the popular TodoMVC benchmark, used for evaluation and comparison across various web frontend frameworks and languages. Our tests uncovered bugs in almost half of the available implementations.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523728", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Liam", + "last_name": "O’Connor", + "institution": "University of Edinburgh" + }, + { + "first_name": "Oskar", + "last_name": "Wickström", + "institution": "" + } + ], + "dblp_key": "conf/pldi/OConnorW22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523441", + "title": "Mako: a low-pause, high-throughput evacuating collector for memory-disaggregated datacenters", + "abstract": "Resource disaggregation has gained much traction as an emerging datacenter architecture, as it improves resource utilization and simplifies hardware adoption. Under resource disaggregation, different types of resources (memory, CPUs, etc.) are disaggregated into dedicated servers connected by high-speed network fabrics. Memory disaggregation brings efficiency challenges to concurrent garbage collection (GC), which is widely used for latency-sensitive cloud applications, because GC and mutator threads simultaneously run and constantly compete for memory and swap resources.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523441", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Haoran", + "last_name": "Ma", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Shi", + "last_name": "Liu", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Chenxi", + "last_name": "Wang", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Yifan", + "last_name": "Qiao", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Miryung", + "last_name": "Kim", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/pldi/MaLWQBBKX22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523443", + "title": "A flexible type system for fearless concurrency", + "abstract": "This paper proposes a new type system for concurrent programs, allowing threads to exchange complex object graphs without risking destructive data races. While this goal is shared by a rich history of past work, existing solutions either rely on strictly enforced heap invariants that prohibit natural programming patterns or demand pervasive annotations even for simple programming tasks. As a result, past systems cannot express intuitively simple code without unnatural rewrites or substantial annotation burdens. Our work avoids these pitfalls through a novel type system that provides sound reasoning about separation in the heap while remaining flexible enough to support a wide range of desirable heap manipulations. This new sweet spot is attained by enforcing a heap domination invariant similarly to prior work, but tempering it by allowing complex exceptions that add little annotation burden. Our results include: (1) code examples showing that common data structure manipulations which are difficult or impossible to express in prior work are natural and direct in our system, (2) a formal proof of correctness demonstrating that well-typed programs cannot encounter destructive data races at run time, and (3) an efficient type checker implemented in Gallina and OCaml.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523443", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mae", + "last_name": "Milano", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Julia", + "last_name": "Turcotti", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/MilanoTM22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523704", + "title": "RustHornBelt: a semantic foundation for functional verification of Rust programs with unsafe code", + "abstract": "Rust is a systems programming language that offers both low-level memory operations and high-level safety guarantees, via a strong ownership type system that prohibits mutation of aliased state. In prior work, Matsushita et al. developed RustHorn, a promising technique for functional verification of Rust code: it leverages the strong invariants of Rust types to express the behavior of stateful Rust code with first-order logic (FOL) formulas, whose verification is amenable to off-the-shelf automated techniques. RustHorn’s key idea is to use prophecies to describe the behavior of mutable borrows. However, the soundness of RustHorn was only established for a safe subset of Rust, and it has remained unclear how to extend it to support various safe APIs that encapsulate unsafe code (i.e., code where Rust’s aliasing discipline is relaxed).", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523704", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yusuke", + "last_name": "Matsushita", + "institution": "The University of Tokyo" + }, + { + "first_name": "Xavier", + "last_name": "Denis", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/pldi/MatsushitaDJD22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523432", + "title": "Diaframe: automated verification of fine-grained concurrent programs in Iris", + "abstract": "Fine-grained concurrent programs are difficult to get right, yet play an important role in modern-day computers. We want to prove strong specifications of such programs, with minimal user effort, in a trustworthy way. In this paper, we present Diaframe—an automated and foundational verification tool for fine-grained concurrent programs.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523432", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ike", + "last_name": "Mulder", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Herman", + "last_name": "Geuvers", + "institution": "Eindhoven University of Technology" + } + ], + "dblp_key": "conf/pldi/MulderKG22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523705", + "title": "Landmarks and regions: a robust approach to data extraction", + "abstract": "We propose a new approach to extracting data items or field values from semi-structured documents. Examples of such problems include extracting passenger name, departure time and departure airport from a travel itinerary, or extracting price of an item from a purchase receipt. Traditional approaches to data extraction use machine learning or program synthesis to process the whole document to extract the desired fields. Such approaches are not robust to for- mat changes in the document, and the extraction process typically fails even if changes are made to parts of the document that are unrelated to the desired fields of interest. We propose a new approach to data extraction based on the concepts of landmarks and regions. Humans routinely use landmarks in manual processing of documents to zoom in and focus their attention on small regions of interest in the document. Inspired by this human intuition, we use the notion of landmarks in program synthesis to automatically synthesize extraction programs that first extract a small region of interest, and then automatically extract the desired value from the region in a subsequent step. We have implemented our landmark based extraction approach in a tool LRSyn, and show extensive valuation on documents in HTML as well as scanned images of invoices and receipts. Our results show that the our approach is robust to various types of format changes that routinely happen in real-world settings", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523705", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Suresh", + "last_name": "Parthasarathy", + "institution": "Microsoft (United Kingdom)" + }, + { + "first_name": "Lincy", + "last_name": "Pattanaik", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Anirudh", + "last_name": "Khatry", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Arun", + "last_name": "Iyer", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Mohammad", + "last_name": "Raza", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/ParthasarathyPK22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523713", + "title": "Algebraic reasoning of Quantum programs via non-idempotent Kleene algebra", + "abstract": "We investigate the algebraic reasoning of quantum programs inspired by the success of classical program analysis based on Kleene algebra. One prominent example of such is the famous Kleene Algebra with Tests (KAT), which has furnished both theoretical insights and practical tools. The succinctness of algebraic reasoning would be especially desirable for scalable analysis of quantum programs, given the involvement of exponential-size matrices in most of the existing methods. A few key features of KAT including the idempotent law and the nice properties of classical tests, however, fail to hold in the context of quantum programs due to their unique quantum features, especially in branching. We propose Non-idempotent Kleene Algebra (NKA) as a natural alternative and identify complete and sound semantic models for NKA as well as their quantum interpretations. In light of applications of KAT, we demonstrate algebraic proofs in NKA of quantum compiler optimization and the normal form of quantum while-programs. Moreover, we extend NKA with Tests (i.e., NKAT), where tests model quantum predicates following effect algebra, and illustrate how to encode propositional quantum Hoare logic as NKAT theorems.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523713", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuxiang", + "last_name": "Peng", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Institute of Software" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/pldi/PengYW22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523714", + "title": "Warping cache simulation of polyhedral programs", + "abstract": "Techniques to evaluate a program's cache performance fall into two camps: 1. Traditional trace-based cache simulators precisely account for sophisticated real-world cache models and support arbitrary workloads, but their runtime is proportional to the number of memory accesses performed by the program under analysis. 2. Relying on implicit workload characterizations such as the polyhedral model, analytical approaches often achieve problem-size-independent runtimes, but so far have been limited to idealized cache models.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523714", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Canberk", + "last_name": "Morelli", + "institution": "Saarland University" + }, + { + "first_name": "Jan", + "last_name": "Reineke", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/pldi/MorelliR22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523735", + "title": "Certified mergeable replicated data types", + "abstract": "Replicated data types (RDTs) are data structures that permit concurrent modification of multiple, potentially geo-distributed, replicas without coordination between them. RDTs are designed in such a way that conflicting operations are eventually deterministically reconciled ensuring convergence. Constructing correct RDTs remains a difficult endeavour due to the complexity of reasoning about independently evolving states of the replicas. With the focus on the correctness of RDTs (and rightly so), existing approaches to RDTs are less efficient compared to their sequential counterparts in terms of the time and space complexity of local operations. This is unfortunate since RDTs are often used in a local-first setting where the local operations far outweigh remote communication.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523735", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vimala", + "last_name": "Soundarapandian", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Adharsh", + "last_name": "Kamath", + "institution": "National Institute of Technology Karnataka" + }, + { + "first_name": "Kartik", + "last_name": "Nagar", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "conf/pldi/Soundarapandian22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523706", + "title": "Relational compilation for performance-critical applications: extensible proof-producing translation of functional models into low-level code", + "abstract": "There are typically two ways to compile and run a purely functional program verified using an interactive theorem prover (ITP): automatically extracting it to a similar language (typically an unverified process, like Coq to OCaml) or manually proving it equivalent to a lower-level reimplementation (like a C program). Traditionally, only the latter produced both excellent performance and end-to-end proofs.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523706", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Jade", + "last_name": "Philipoom", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Dustin", + "last_name": "Jamner", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Andres", + "last_name": "Erbsen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/pldi/Pit-ClaudelPJEC22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523457", + "title": "Interpreter-guided differential JIT compiler unit testing", + "abstract": "Modern language implementations using Virtual Machines feature diverse execution engines such as byte-code interpreters and machine-code dynamic translators, a.k.a. JIT compilers. Validating such engines requires not only validating each in isolation, but also that they are functionally equivalent. Tests should be duplicated for each execution engine, exercising the same execution paths on each of them.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523457", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guillermo", + "last_name": "Polito", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Sté́phane", + "last_name": "Ducasse", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Pablo", + "last_name": "Tesone", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/pldi/PolitoDT22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523428", + "title": "Odin: on-demand instrumentation with on-the-fly recompilation", + "abstract": "Instrumentation is vital to fuzzing. It provides fuzzing directions and helps detect covert bugs, yet its overhead greatly reduces the fuzzing throughput. To reduce the overhead, compilers compromise instrumentation correctness for better optimization, or seek convoluted runtime support to remove unused probes during fuzzing.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523428", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mingzhe", + "last_name": "Wang", + "institution": "Tsinghua University" + }, + { + "first_name": "Jie", + "last_name": "Liang", + "institution": "Tsinghua University" + }, + { + "first_name": "Chijin", + "last_name": "Zhou", + "institution": "Tsinghua University" + }, + { + "first_name": "Zhiyong", + "last_name": "Wu", + "institution": "Tsinghua University" + }, + { + "first_name": "Xinyi", + "last_name": "Xu", + "institution": "Tsinghua University" + }, + { + "first_name": "Yu", + "last_name": "Jiang", + "institution": "Tsinghua University" + } + ], + "dblp_key": "conf/pldi/WangLZWX022", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523448", + "title": "FreeTensor: a free-form DSL with holistic optimizations for irregular tensor programs", + "abstract": "Tensor programs are of critical use in many domains. Existing frameworks, such as PyTorch, TensorFlow, and JAX, adopt operator-based programming to ease programming, increase performance, and perform automatic differentiation. However, as the rapid development of tensor programs, operator-based programming shows significant limitations for irregular patterns since a large amount of redundant computation or memory access is introduced.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523448", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shizhi", + "last_name": "Tang", + "institution": "Tsinghua University" + }, + { + "first_name": "Jidong", + "last_name": "Zhai", + "institution": "Tsinghua University" + }, + { + "first_name": "Haojie", + "last_name": "Wang", + "institution": "Tsinghua University" + }, + { + "first_name": "Lin", + "last_name": "Jiang", + "institution": "Tsinghua University" + }, + { + "first_name": "Liyan", + "last_name": "Zheng", + "institution": "Tsinghua University" + }, + { + "first_name": "Zhenhao", + "last_name": "Yuan", + "institution": "Tsinghua University" + }, + { + "first_name": "Chen", + "last_name": "Zhang", + "institution": "Tsinghua University" + } + ], + "dblp_key": "conf/pldi/TangZWJZYZ22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523434", + "title": "Islaris: verification of machine code against authoritative ISA semantics", + "abstract": "Recent years have seen great advances towards verifying large-scale systems code. However, these verifications are usually based on hand-written assembly or machine-code semantics for the underlying architecture that only cover a small part of the instruction set architecture (ISA). In contrast, other recent work has used Sail to establish formal models for large real-world architectures, including Armv8-A and RISC-V, that are comprehensive (complete enough to boot an operating system or hypervisor) and authoritative (automatically derived from the Arm internal model and validated against the Arm validation suite, and adopted as the official formal specification by RISC-V International, respectively). But the scale and complexity of these models makes them challenging to use as a basis for verification.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523434", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Angus", + "last_name": "Hammond", + "institution": "University of Cambridge" + }, + { + "first_name": "Rodolphe", + "last_name": "Lepigre", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "B. K.", + "last_name": "Campbell", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "Aarhus University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/pldi/SammlerHL0PD0S22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523455", + "title": "PDL: a high-level hardware design language for pipelined processors", + "abstract": "Processors are typically designed in Register Transfer Level (RTL) languages, which give designers low-level control over circuit structure and timing. To achieve good performance, processors are pipelined, with multiple instructions execut- ing concurrently in different parts of the circuit. Thus even though processors implement a fundamentally sequential specification (the instruction set architecture), the imple- mentation is highly concurrent. The interactions of multiple instructions—potentially speculative—can cause incorrect behavior.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523455", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Drew", + "last_name": "Zagieboylo", + "institution": "Cornell University" + }, + { + "first_name": "Charles", + "last_name": "Sherk", + "institution": "Cornell University" + }, + { + "first_name": "Gookwon Edward", + "last_name": "Suh", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/pldi/ZagieboyloSSM22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523719", + "title": "Lasagne: a static binary translator for weak memory model architectures", + "abstract": "The emergence of new architectures create a recurring challenge to ensure that existing programs still work on them. Manually porting legacy code is often impractical. Static binary translation (SBT) is a process where a program’s binary is automatically translated from one architecture to another, while preserving their original semantics. However, these SBT tools have limited support to various advanced architectural features. Importantly, they are currently unable to translate concurrent binaries. The main challenge arises from the mismatches of the memory consistency model specified by the different architectures, especially when porting existing binaries to a weak memory model architecture.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523719", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rodrigo C. O.", + "last_name": "Rocha", + "institution": "University of Edinburgh" + }, + { + "first_name": "Dennis", + "last_name": "Sprokholt", + "institution": "Delft University of Technology" + }, + { + "first_name": "Martin", + "last_name": "Fink", + "institution": "" + }, + { + "first_name": "Redha", + "last_name": "Gouicem", + "institution": "" + }, + { + "first_name": "Tom", + "last_name": "Spink", + "institution": "University of St Andrews" + }, + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Delft University of Technology" + }, + { + "first_name": "Pramod", + "last_name": "Bhatotia", + "institution": "" + } + ], + "dblp_key": "conf/pldi/RochaS0GSCB22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523708", + "title": "Hardening attack surfaces with formally proven binary format parsers", + "abstract": "With an eye toward performance, interoperability, or legacy concerns, low-level system software often must parse binary encoded data formats. Few tools are available for this task, especially since the formats involve a mixture of arithmetic and data dependence, beyond what can be handled by typical parser generators. As such, parsers are written by hand in languages like C, with inevitable errors leading to security vulnerabilities.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523708", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Irina", + "last_name": "Spiridonova", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Haobin", + "last_name": "Ni", + "institution": "Cornell University" + }, + { + "first_name": "Dmitry", + "last_name": "Malloy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Juan", + "last_name": "Vazquez", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Michael T.", + "last_name": "Tang", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Omar D.", + "last_name": "Cardona", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arti", + "last_name": "Gupta", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/SwamyRRSNMVTCG22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523710", + "title": "A typed continuation-passing translation for lexical effect handlers", + "abstract": "Effect handlers are a language feature which enjoys popularity in academia and is also gaining traction in industry. Programs use abstract effect operations and handlers provide meaning to them in a delimited scope. Each effect operation is handled by the dynamically closest handler. Using an effect operation outside of a matching handler is meaningless and results in an error. A type-and-effect system prevents such errors from happening. Lexical effect handlers are a recent variant of effect handlers with a number of attractive properties. Just as with traditional effect handlers, programs use effect operations and handlers give meaning to them. But unlike with traditional effect handlers, the connection between effect operations and their handler is lexical. Consequently, they typically have different type-and-effect systems. The semantics of lexical effect handlers as well as their implementations use multi-prompt delimited control. They rely on the generation of fresh labels at runtime, which associate effect operations with their handlers. This use of labels and multi-prompt delimited control is theoretically and practically unsatisfactory. Our main result is that typed lexical effect handlers do not need the full power of multi-prompt delimited control. We present the first CPS translation for lexical effect handlers to pure System F. It preserves well-typedness and simulates the traditional operational semantics. Importantly, it does so without requiring runtime labels. The CPS translation can be used to study the semantics of lexical effect handlers as well as as an implementation technique.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523710", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Marius", + "last_name": "Müller", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/pldi/SchusterB0O22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523431", + "title": "Giallar: push-button verification for the qiskit Quantum compiler", + "abstract": "This paper presents Giallar, a fully-automated verification toolkit for quantum compilers. Giallar requires no manual specifications, invariants, or proofs, and can automatically verify that a compiler pass preserves the semantics of quantum circuits. To deal with unbounded loops in quantum compilers, Giallar abstracts three loop templates, whose loop invariants can be automatically inferred. To efficiently check the equivalence of arbitrary input and output circuits that have complicated matrix semantics representation, Giallar introduces a symbolic representation for quantum circuits and a set of rewrite rules for showing the equivalence of symbolic quantum circuits. With Giallar, we implemented and verified 44 (out of 56) compiler passes in 13 versions of the Qiskit compiler, the open-source quantum compiler standard, during which three bugs were detected in and confirmed by Qiskit. Our evaluation shows that most of Qiskit compiler passes can be automatically verified in seconds and verification imposes only a modest overhead to compilation performance.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523431", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Runzhou", + "last_name": "Tao", + "institution": "Columbia University" + }, + { + "first_name": "Yunong", + "last_name": "Shi", + "institution": "Amazon (United States)" + }, + { + "first_name": "Jianan", + "last_name": "Yao", + "institution": "Columbia University" + }, + { + "first_name": "Xupeng", + "last_name": "Li", + "institution": "Columbia University" + }, + { + "first_name": "Ali", + "last_name": "Javadi-Abhari", + "institution": "" + }, + { + "first_name": "Andrew W.", + "last_name": "Cross", + "institution": "" + }, + { + "first_name": "Frederic T.", + "last_name": "Chong", + "institution": "University of Chicago" + }, + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/pldi/TaoSYLJCCG22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523702", + "title": "Formally verified lifting of C-compiled x86-64 binaries", + "abstract": "Lifting binaries to a higher-level representation is an essential step for decompilation, binary verification, patching and security analysis. In this paper, we present the first approach to provably overapproximative x86-64 binary lifting. A stripped binary is verified for certain sanity properties such as return address integrity and calling convention adherence. Establishing these properties allows the binary to be lifted to a representation that contains an overapproximation of all possible execution paths of the binary. The lifted representation contains disassembled instructions, reconstructed control flow, invariants and proof obligations that are sufficient to prove the sanity properties as well as correctness of the lifted representation. We apply this approach to Linux Foundation and Intel’s Xen Hypervisor covering about 400K instructions. This demonstrates our approach is the first approach to provably overapproximative binary lifting scalable to commercial off-the-shelf systems. The lifted representation is exportable to the Isabelle/HOL theorem prover, allowing formal verification of its correctness. If our technique succeeds and the proofs obligations are proven true, then – under the generated assumptions – the lifted representation is correct.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523702", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Freek", + "last_name": "Verbeek", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Joshua A.", + "last_name": "Bockenek", + "institution": "Virginia Tech" + }, + { + "first_name": "Zhoulai", + "last_name": "Fu", + "institution": "SUNY Korea" + }, + { + "first_name": "Binoy", + "last_name": "Ravindran", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/pldi/VerbeekBFR22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523732", + "title": "Karp: a language for NP reductions", + "abstract": "In CS theory courses, NP reductions are a notorious source of pain for students and instructors alike. Invariably, students use pen and paper to write down reductions that “work” in many but not all cases. When instructors observe that a student’s reduction deviates from the expected one, they have to manually compute a counterexample that exposes the mistake. In other words, NP reductions are subtle yet, most of the time, unimplemented programs. And for a good reason: there exists no language tailored to NP reductions.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523732", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chenhao", + "last_name": "Zhang", + "institution": "Northwestern University" + }, + { + "first_name": "Jason D.", + "last_name": "Hartline", + "institution": "Northwestern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/pldi/ZhangHD22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523439", + "title": "Bind the gap: compiling real software to hardware FFT accelerators", + "abstract": "Specialized hardware accelerators continue to be a source of performance improvement. However, such specialization comes at a programming price. The fundamental issue is that of a mismatch between the diversity of user code and the functionality of fixed hardware, limiting its wider uptake. Here we focus on a particular set of accelerators: those for Fast Fourier Transforms. We present FACC (Fourier ACcelerator Compiler), a novel approach to automatically map legacy code to Fourier Transform accelerators. It automatically generates drop-in replacement adapters using Input-Output (IO)-based program synthesis that bridge the gap between user code and accelerators. We apply FACC to unmodified GitHub C programs of varying complexity and compare against two existing approaches. We target FACC to a high-performance library, FFTW, and two hardware accelerators, the NXP PowerQuad and the Analog Devices FFTA, and demonstrate mean speedups of 9x, 17x and 27x respectively", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523439", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jackson", + "last_name": "Woodruff", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jordi", + "last_name": "Armengol-Estapé", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Ainsworth", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/pldi/WoodruffAAO22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523433", + "title": "Quartz: superoptimization of Quantum circuits", + "abstract": "Existing quantum compilers optimize quantum circuits by applying circuit transformations designed by experts. This approach requires significant manual effort to design and implement circuit transformations for different quantum devices, which use different gate sets, and can miss optimizations that are hard to find manually. We propose Quartz, a quantum circuit superoptimizer that automatically generates and verifies circuit transformations for arbitrary quantum gate sets. For a given gate set, Quartz generates candidate circuit transformations by systematically exploring small circuits and verifies the discovered transformations using an automated theorem prover. To optimize a quantum circuit, Quartz uses a cost-based backtracking search that applies the verified transformations to the circuit. Our evaluation on three popular gate sets shows that Quartz can effectively generate and verify transformations for different gate sets. The generated transformations cover manually designed transformations used by existing optimizers and also include new transformations. Quartz is therefore able to optimize a broad range of circuits for diverse gate sets, outperforming or matching the performance of hand-tuned circuit optimizers.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523433", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mingkuan", + "last_name": "Xu", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Zikun", + "last_name": "Li", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "" + }, + { + "first_name": "Sina", + "last_name": "Lin", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jessica", + "last_name": "Pointing", + "institution": "University of Oxford" + }, + { + "first_name": "Auguste", + "last_name": "Hirth", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Henry", + "last_name": "Ma", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Zhihao", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/pldi/XuLPLPHMPAAJ22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523734", + "title": "Verifying optimizations of concurrent programs in the promising semantics", + "abstract": "Weak memory models for concurrent programming languages are expected to admit standard compiler optimizations. However, prior works on verifying optimizations in weak memory models are mostly focused on simple optimizations on small code snippets which satisfy certain syntactic requirements. It receives less attention whether weak memory models can admit real-world optimization algorithms based on program analyses.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523734", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Junpeng", + "last_name": "Zha", + "institution": "Nanjing University" + }, + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "Nanjing University" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Nanjing University" + } + ], + "dblp_key": "conf/pldi/ZhaL022", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523437", + "title": "DISTAL: the distributed tensor algebra compiler", + "abstract": "We introduce DISTAL, a compiler for dense tensor algebra that targets modern distributed and heterogeneous systems. DISTAL lets users independently describe how tensors and computation map onto target machines through separate format and scheduling languages. The combination of choices for data and computation distribution creates a large design space that includes many algorithms from both the past (e.g., Cannon’s algorithm) and the present (e.g., COSMA). DISTAL compiles a tensor algebra domain specific language to a distributed task-based runtime system and supports nodes with multi-core CPUs and multiple GPUs. Code generated by is competitive with optimized codes for matrix multiply on 256 nodes of the Lassen supercomputer and outperforms existing systems by between 1.8x to 3.7x (with a 45.7x outlier) on higher order tensor operations.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523437", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rohan", + "last_name": "Yadav", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/pldi/YadavAK22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523440", + "title": "Low-latency, high-throughput garbage collection", + "abstract": "To achieve short pauses, state-of-the-art concurrent copying collectors such as C4, Shenandoah, and ZGC use substantially more CPU cycles and memory than simpler collectors. They suffer from design limitations: i) concurrent copying with inherently expensive read and write barriers, ii) scalability limitations due to tracing, and iii) immediacy limitations for mature objects that impose memory overheads.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523440", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wenyu", + "last_name": "Zhao", + "institution": "Australian National University" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/pldi/ZhaoBM22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523435", + "title": "Differential cost analysis with simultaneous potentials and anti-potentials", + "abstract": "We present a novel approach to differential cost analysis that, given a program revision, attempts to statically bound the difference in resource usage, or cost, between the two program versions. Differential cost analysis is particularly interesting because of the many compelling applications for it, such as detecting resource-use regressions at code-review time or proving the absence of certain side-channel vulnerabilities. One prior approach to differential cost analysis is to apply relational reasoning that conceptually constructs a product program on which one can over-approximate the difference in costs between the two program versions. However, a significant challenge in any relational approach is effectively aligning the program versions to get precise results. In this paper, our key insight is that we can avoid the need for and the limitations of program alignment if, instead, we bound the difference of two cost-bound summaries rather than directly bounding the concrete cost difference. In particular, our method computes a threshold value for the maximal difference in cost between two program versions simultaneously using two kinds of cost-bound summaries---a potential function that evaluates to an upper bound for the cost incurred in the first program and an anti-potential function that evaluates to a lower bound for the cost incurred in the second. Our method has a number of desirable properties: it can be fully automated, it allows optimizing the threshold value on relative cost, it is suitable for programs that are not syntactically similar, and it supports non-determinism. We have evaluated an implementation of our approach on a number of program pairs collected from the literature, and we find that our method computes tight threshold values on relative cost in most examples.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523435", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Đorđe", + "last_name": "Žikelić", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "Amazon (United States)" + }, + { + "first_name": "Pauline", + "last_name": "Bolignano", + "institution": "Amazon (United Kingdom)" + }, + { + "first_name": "Franco", + "last_name": "Raimondi", + "institution": "Amazon (United Kingdom)" + } + ], + "dblp_key": "conf/pldi/ZikelicCBR22", + "venue": "pldi", + "year": 2022 + }, + { + "paper_id": "10.1145/3519939.3523712", + "title": "Synthesizing analytical SQL queries from computation demonstration", + "abstract": "Analytical SQL is widely used in modern database applications and data analysis. However, its partitioning and grouping operators are challenging for novice users. Unfortunately, programming by example, shown effective on standard SQL, are less attractive because examples for analytical queries are more laborious to solve by hand.", + "date": "2022-06-02", + "link": "https://doi.org/10.1145/3519939.3523712", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiangyu", + "last_name": "Zhou", + "institution": "University of Washington" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Chenglong", + "last_name": "Wang", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/pldi/ZhouBCW22", + "venue": "pldi", + "year": 2022 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2023.json b/data/pl_conferences/pldi/2023.json new file mode 100644 index 0000000..985e1d7 --- /dev/null +++ b/data/pl_conferences/pldi/2023.json @@ -0,0 +1,2791 @@ +[ + { + "paper_id": "10.1145/3591293", + "title": "Cutting the Cake: A Language for Fair Division", + "abstract": "The fair division literature in economics considers how to divide resources between multiple agents such that the allocation is envy-free: each agent receives their favorite piece. Researchers have developed a variety of fair division protocols for the most standard setting, where the agents want to split a single item, however, the protocols are highly intricate and the proofs of envy-freeness involve tedious case analysis. We propose Slice, a domain specific language for fair-division. Programs in our language can be converted to logical formulas encoding envy-freeness and other target properties. Then, the constraints can be dispatched to automated solvers. We prove that our constraint generation procedure is sound and complete. We also report on a prototype implementation of Slice, which we have used to automatically check envy-freeness for several protocols from the fair division literature.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591293", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Noah", + "last_name": "Bertram", + "institution": "Cornell University" + }, + { + "first_name": "Alex", + "last_name": "Levinson", + "institution": "Cornell University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/BertramLH23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591236", + "title": "Mosaic: An Interoperable Compiler for Tensor Algebra", + "abstract": "We introduce Mosaic, a sparse tensor algebra compiler that can bind tensor expressions to external functions of other tensor algebra libraries and compilers. Users can extend Mosaic by adding new functions and bind a sub-expression to a function using a scheduling API. Mosaic substitutes the bound sub-expressions with calls to the external functions and automatically generates the remaining code using a default code generator. As the generated code is fused by default, users can productively leverage both fusion and calls to specialized functions within the same compiler. We demonstrate the benefits of our dual approach by showing that calling hand-written CPU and specialized hardware functions can provide speedups of up to 206× against fused code in some cases, while generating fused code can provide speedups of up to 3.57× against code that calls external functions in other cases. Mosaic also offers a search system that can automatically map an expression to a set of registered external functions. Both the explicit binding and automatic search are verified by Mosaic. Additionally, the interface for adding new external functions is simple and general. Currently, 38 external functions have been added to Mosaic, with each addition averaging 20 lines of code.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591236", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manya", + "last_name": "Bansal", + "institution": "Stanford University" + }, + { + "first_name": "Olivia", + "last_name": "Hsu", + "institution": "Stanford University" + }, + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/BansalHOK23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591263", + "title": "Automated Expected Value Analysis of Recursive Programs", + "abstract": "In this work, we study the fully automated inference of expected result values of probabilistic programs in the presence of natural programming constructs such as procedures, local variables and recursion. While crucial, capturing these constructs becomes highly non-trivial. The key contribution is the definition of a term representation, denoted as infer[.], translating a pre-expectation semantics into first-order constraints, susceptible to automation via standard methods. A crucial step is the use of logical variables, inspired by previous work on Hoare logics for recursive programs. Noteworthy, our methodology is not restricted to tail-recursion, which could unarguably be replaced by iteration and wouldn't need additional insights. We have implemented this analysis in our prototype ev-imp. We provide ample experimental evidence of the prototype's algorithmic expressibility.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591263", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Avanzini", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Georg", + "last_name": "Moser", + "institution": "Universität Innsbruck" + }, + { + "first_name": "Michael", + "last_name": "Schaper", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/AvanziniMS23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591243", + "title": "Dynamic Partial Order Reduction for Checking Correctness against Transaction Isolation Levels", + "abstract": "Modern applications, such as social networking systems and e-commerce platforms are centered around using large-scale databases for storing and retrieving data. Accesses to the database are typically enclosed in transactions that allow computations on shared data to be isolated from other concurrent computations and resilient to failures. Modern databases trade isolation for performance. The weaker the isolation level is, the more behaviors a database is allowed to exhibit and it is up to the developer to ensure that their application can tolerate those behaviors. In this work, we propose stateless model checking algorithms for studying correctness of such applications that rely on dynamic partial order reduction. These algorithms work for a number of widely-used weak isolation levels, including Read Committed, Causal Consistency, Snapshot Isolation and Serializability. We show that they are complete, sound and optimal, and run with polynomial memory consumption in all cases. We report on an implementation of these algorithms in the context of Java Pathfinder applied to a number of challenging applications drawn from the literature of distributed systems and databases.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591243", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Enrique", + "last_name": "Román-Calvo", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/BouajjaniER23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591300", + "title": "Prompting Is Programming: A Query Language for Large Language Models", + "abstract": "Large language models have demonstrated outstanding performance on a wide range of tasks such as question answering and code generation. On a high level, given an input, a language model can be used to automatically complete the sequence in a statistically-likely way. Based on this, users prompt these models with language instructions or examples, to implement a variety of downstream tasks. Advanced prompting methods can even imply interaction between the language model, a user, and external tools such as calculators. However, to obtain state-of-the-art performance or adapt language models for specific tasks, complex task- and model-specific programs have to be implemented, which may still require ad-hoc interaction. Based on this, we present the novel idea of Language Model Programming (LMP). LMP generalizes language model prompting from pure text prompts to an intuitive combination of text prompting and scripting. Additionally, LMP allows constraints to be specified over the language model output. This enables easy adaption to many tasks while abstracting language model internals and providing high-level semantics. To enable LMP, we implement LMQL (short for Language Model Query Language), which leverages the constraints and control flow from an LMP prompt to generate an efficient inference procedure that minimizes the number of expensive calls to the underlying language model. We show that LMQL can capture a wide range of state-of-the-art prompting methods in an intuitive way, especially facilitating interactive flows that are challenging to implement with existing high-level APIs. Our evaluation shows that we retain or increase the accuracy on several downstream tasks, while also significantly reducing the required amount of computation or cost in the case of pay-to-use APIs (26-85% cost savings).", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591300", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Luca", + "last_name": "Beurer-Kellner", + "institution": "ETH Zurich" + }, + { + "first_name": "M.", + "last_name": "Fischer", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/Beurer-Kellner023", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591260", + "title": "Better Defunctionalization through Lambda Set Specialization", + "abstract": "Higher-order functions pose a challenge for both static program analyses and optimizing compilers. To simplify the analysis and compilation of languages with higher-order functions, a rich body of prior work has proposed a variety of defunctionalization techniques, which can eliminate higher-order functions from a program by transforming the program to a semantically-equivalent first-order representation. Several modern languages take this a step further, specializing higher-order functions with respect to the functions on which they operate, and in turn allowing compilers to generate more efficient code. However, existing specializing defunctionalization techniques restrict how function values may be used, forcing implementations to fall back on costly dynamic alternatives. We propose lambda set specialization (LSS), the first specializing defunctionalization technique which imposes no restrictions on how function values may be used. We formulate LSS in terms of a polymorphic type system which tracks the flow of function values through the program, and use this type system to recast specialization of higher-order functions with respect to their arguments as a form of type monomorphization. We show that our type system admits a simple and tractable type inference algorithm, and give a formalization and fully-mechanized proof in the Isabelle/HOL proof assistant showing soundness and completeness of the type inference algorithm with respect to the type system. To show the benefits of LSS, we evaluate its impact on the run time performance of code generated by the MLton compiler for Standard ML, the OCaml compiler, and the new Morphic functional programming language. We find that pre-processing with LSS achieves run time speedups of up to 6.85x under MLton, 3.45x for OCaml, and 78.93x for Morphic.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591260", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "William T.", + "last_name": "Brandon", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Benjamin", + "last_name": "Driscoll", + "institution": "Stanford University" + }, + { + "first_name": "Frank", + "last_name": "Dai", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Wilson", + "last_name": "Berkow", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mae", + "last_name": "Milano", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/BrandonDDBM23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591296", + "title": "Embedding Hindsight Reasoning in Separation Logic", + "abstract": "Automatically proving linearizability of concurrent data structures remains a key challenge for verification. We present temporal interpolation as a new proof principle to guide automated proof search using hindsight arguments within concurrent separation logic. Temporal interpolation offers an easy-to-automate alternative to prophecy variables and has the advantage of structuring proofs into easy-to-discharge hypotheses. Additionally, we advance hindsight theory by integrating it into a program logic, bringing formal rigor and complementary proof machinery. We substantiate the usefulness of temporal interpolation by implementing it in a tool and using it to automatically verify the Logical Ordering tree. The proof is challenging due to future-dependent linearization points and complex structure overlays. It is the first formal proof of this data structure. Interestingly, our formalization revealed an unknown bug and an existing informal proof as erroneous.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591296", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + }, + { + "first_name": "Sebastian", + "last_name": "Wolff", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/0001W023", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591284", + "title": "Efficient Parallel Functional Programming with Effects", + "abstract": "Although functional programming languages simplify writing safe parallel programs by helping programmers to avoid data races, they have traditionally delivered poor performance. Recent work improved performance by using a hierarchical memory architecture that allows processors to allocate and reclaim memory independently without any synchronization, solving thus the key performance challenge afflicting functional programs. The approach, however, restricts mutation, or memory effects, so as to ensure \"disentanglement\", a low-level memory property that guarantees independence between different heaps in the hierarchy. This paper proposes techniques for supporting entanglement and for allowing functional programs to use mutation at will. Our techniques manage entanglement by distinguishing between disentangled and entangled objects and shielding disentangled objects from the cost of entanglement management. We present a semantics that formalizes entanglement as a property at the granularity of memory objects, and define several cost metrics to reason about and bound the time and space cost of entanglement. We present an implementation of the techniques by extending the MPL compiler for Parallel ML. The extended compiler supports all features of the Parallel ML language, including unrestricted effects. Our experiments using a variety of benchmarks show that MPL incurs a small time and space overhead compared to sequential runs, scales well, and is competitive with languages such as C++, Go, Java, OCaml. These results show that our techniques can marry the safety benefits of functional programming with performance.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591284", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jatin", + "last_name": "Arora", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/0002WA23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591248", + "title": "ImageEye: Batch Image Processing using Program Synthesis", + "abstract": "This paper presents a new synthesis-based approach for batch image processing. Unlike existing tools that can only apply global edits to the entire image, our method can apply fine-grained edits to individual objects within the image. For example, our method can selectively blur or crop specific objects that have a certain property. To facilitate such fine-grained image editing tasks, we propose a neuro-symbolic domain-specific language (DSL) that combines pre-trained neural networks for image classification with other language constructs that enable symbolic reasoning. Our method can automatically learn programs in this DSL from user demonstrations by utilizing a novel synthesis algorithm. We have implemented the proposed technique in a tool called ImageEye and evaluated it on 50 image editing tasks. Our evaluation shows that ImageEye is able to automate 96% of these tasks.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591248", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Celeste", + "last_name": "Barnaby", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Qiaochu", + "last_name": "Chen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/BarnabyCSD23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591297", + "title": "Putting Weak Memory in Order via a Promising Intermediate Representation", + "abstract": "We investigate the problem of developing an \"in-order\" shared-memory concurrency model for languages like C and C++, which executes instructions following their program order, and is thus more amenable to reasoning and verification compared to recent complex proposals with out-of-order execution. We demonstrate that it is possible to fully support non-atomic accesses in an in-order model in a way that validates all compiler optimizations that are performed in single-threaded code (including irrelevant load introduction). The key to doing so is to utilize the distinction between a source model (with catch-fire semantics) and an intermediate representation (IR) model (with undefined value for racy reads) and formally establish the soundness of mapping from source to IR. As for relaxed atomic accesses, an in-order model must forbid load-store reordering. We discuss the rather limited performance impact of this fact and present a pragmatic approach to this problem, which, in the long term, requires a new kind of hardware store instructions for implementing relaxed stores. The source and IR semantics proposed in this paper are based on recent versions of the promising semantics, and the correctness proofs of the mappings from the source to the IR and from the IR to Armv8 are mechanized in Coq. This work is the first to formally relate an in-order source model and an out-of-order IR model with the goal of having an in-order source semantics without any performance overhead for non-atomics.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591297", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sung-Hwan", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Roy", + "last_name": "Margalit", + "institution": "Tel Aviv University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/0001CMHL23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591287", + "title": "Repairing Regular Expressions for Extraction", + "abstract": "While synthesizing and repairing regular expressions (regexes) based on Programming-by-Examples (PBE) methods have seen rapid progress in recent years, all existing works only support synthesizing or repairing regexes for membership testing, and the support for extraction is still an open problem. This paper fills the void by proposing the first PBE-based method for synthesizing and repairing regexes for extraction. Our work supports regexes that have real-world extensions such as backreferences and lookarounds. The extensions significantly affect the PBE-based synthesis and repair problem. In fact, we show that there are unsolvable instances of the problem if the synthesized regexes are not allowed to use the extensions, i.e., there is no regex without the extensions that correctly classify the given set of examples, whereas every problem instance is solvable if the extensions are allowed. This is in stark contrast to the case for the membership where every instance is guaranteed to have a solution expressible by a pure regex without the extensions. The main contribution of the paper is an algorithm to solve the PBE-based synthesis and repair problem for extraction. Our algorithm builds on existing methods for synthesizing and repairing regexes for membership testing, i.e., the enumerative search algorithms with SMT constraint solving. However, significant extensions are needed because the SMT constraints in the previous works are based on a non-deterministic semantics of regexes. Non-deterministic semantics is sound for membership but not for extraction, because which substrings are extracted depends on the deterministic behavior of actual regex engines. To address the issue, we propose a new SMT constraint generation method that respects the deterministic behavior of regex engines. For this, we first define a novel formal semantics of an actual regex engine as a deterministic big-step operational semantics, and use it as a basis to design the new SMT constraint generation method. The key idea to simulate the determinism in the formal semantics and the constraints is to consider continuations of regex matching and use them for disambiguation. We also propose two new search space pruning techniques called approximation-by-pure-regex and approximation-by-backreferences that make use of the extraction information in the examples. We have implemented the synthesis and repair algorithm in a tool called R3 (Repairing Regex for extRaction) and evaluated it on 50 regexes that contain real-world extensions. Our evaluation shows the effectiveness of the algorithm and that our new pruning techniques substantially prune the search space.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591287", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nariyoshi", + "last_name": "Chida", + "institution": "Waseda University" + }, + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Waseda University" + } + ], + "dblp_key": "journals/pacmpl/ChidaT23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591270", + "title": "An Automata-Based Framework for Verification and Bug Hunting in Quantum Circuits", + "abstract": "We introduce a new paradigm for analysing and finding bugs in quantum circuits. In our approach, the problem is given by a ‍triple { P } C { Q } and the question is whether, given a set P of quantum states on the input of a circuit C , the set of quantum states on the output is equal to (or included in) a set Q . While this is not suitable to specify, e.g., functional correctness of a quantum circuit, it is sufficient to detect many bugs in quantum circuits. We propose a technique based on tree automata to compactly represent sets of quantum states and develop transformers to implement the semantics of quantum gates over this representation. Our technique computes with an algebraic representation of quantum states, avoiding the inaccuracy of working with floating-point numbers. We implemented the proposed approach in a prototype tool and evaluated its performance against various benchmarks from the literature. The evaluation shows that our approach is quite scalable, e.g., we managed to verify a large circuit with 40 qubits and 141,527 gates, or catch bugs injected into a circuit with 320 qubits and 1,758 gates, where all tools we compared with failed. In addition, our work establishes a connection between quantum program verification and automata, opening new possibilities to exploit the richness of automata theory and automata-based verification in the world of quantum computing.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591270", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yu‐Fang", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "Kai-Min", + "last_name": "Chung", + "institution": "Academia Sinica" + }, + { + "first_name": "Ondřej", + "last_name": "Lengál", + "institution": "Brno University of Technology" + }, + { + "first_name": "Jyun-Ao", + "last_name": "Lin", + "institution": "Academia Sinica" + }, + { + "first_name": "Wei-Lun", + "last_name": "Tsai", + "institution": "National Taiwan University" + }, + { + "first_name": "Di-De", + "last_name": "Yen", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/0001CLLTY23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591223", + "title": "A Lineage-Based Referencing DSL for Computer-Aided Design", + "abstract": "3D Computer-Aided Design (CAD) modeling is ubiquitous in mechanical engineering and design. Modern CAD models are programs that produce geometry and can be used to implement high-level geometric changes by modifying input parameters. While there has been a surge of recent interest in program-based tooling for the CAD domain, one fundamental problem remains unsolved. CAD programs pass geometric arguments to operations using references, which are queries that select elements from the constructed geometry according to programmer intent. The challenge is designing reference semantics that can express programmer intent across all geometric topologies achievable with model parameters, including topologies where the desired elements are not present. In current systems, both users and automated tools may create invalid models when parameters are changed, as references to geometric elements are lost or silently and arbitrarily switched. While existing CAD systems use heuristics to attempt to infer user intent in cases of this undefined behavior, this best-effort solution is not suitable for constructing automated tools to edit and optimize CAD programs. We analyze the failure modes of existing referencing schemes and formalize a set of criteria on which to evaluate solutions to the CAD referencing problem. In turn, we propose a domain-specific language that exposes references as a first-class language construct, using user-authored queries to introspect element history and define references safely over all paths. We give a semantics for fine-grained element lineage that can subsequently be queried; and show that our language meets the desired properties. Finally, we provide an implementation of a lineage-based referencing system in a 2.5D CAD kernel, demonstrating realistic referencing scenarios and illustrating how our system safely represents models that cause reference breakage in existing CAD systems.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591223", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dan", + "last_name": "Cascaval", + "institution": "University of Washington" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Google (United States)" + }, + { + "first_name": "Adriana", + "last_name": "Schulz", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/CascavalBS23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591220", + "title": "Formally Verified Samplers from Probabilistic Programs with Loops and Conditioning", + "abstract": "We present Zar: a formally verified compiler pipeline from discrete probabilistic programs with unbounded loops in the conditional probabilistic guarded command language (cpGCL) to proved-correct executable samplers in the random bit model. We exploit the key idea that all discrete probability distributions can be reduced to unbiased coin-flipping schemes. The compiler pipeline first translates cpGCL programs into choice-fix trees, an intermediate representation suitable for reduction of biased probabilistic choices. Choice-fix trees are then translated to coinductive interaction trees for execution within the random bit model. The correctness of the composed translations establishes the sampling equidistribution theorem: compiled samplers are correct wrt. the conditional weakest pre-expectation semantics of cpGCL source programs. Zar is implemented and fully verified in the Coq proof assistant. We extract verified samplers to OCaml and Python and empirically validate them on a number of illustrative examples.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591220", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Bagnall", + "institution": "Ohio University" + }, + { + "first_name": "Gordon", + "last_name": "Stewart", + "institution": "" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "IMDEA Software Institute" + } + ], + "dblp_key": "journals/pacmpl/Bagnall0023", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591289", + "title": "CommCSL: Proving Information Flow Security for Concurrent Programs using Abstract Commutativity", + "abstract": "Information flow security ensures that the secret data manipulated by a program does not influence its observable output. Proving information flow security is especially challenging for concurrent programs, where operations on secret data may influence the execution time of a thread and, thereby, the interleaving between different threads. Such internal timing channels may affect the observable outcome of a program even if an attacker does not observe execution times. Existing verification techniques for information flow security in concurrent programs attempt to prove that secret data does not influence the relative timing of threads. However, these techniques are often restrictive (for instance because they disallow branching on secret data) and make strong assumptions about the execution platform (ignoring caching, processor instructions with data-dependent runtime, and other common features that affect execution time). In this paper, we present a novel verification technique for secure information flow in concurrent programs that lifts these restrictions and does not make any assumptions about timing behavior. The key idea is to prove that all mutating operations performed on shared data commute, such that different thread interleavings do not influence its final value. Crucially, commutativity is required only for an abstraction of the shared data that contains the information that will be leaked to a public output. Abstract commutativity is satisfied by many more operations than standard commutativity, which makes our technique widely applicable. We formalize our technique in CommCSL, a relational concurrent separation logic with support for commutativity-based reasoning, and prove its soundness in Isabelle/HOL. We implemented CommCSL in HyperViper, an automated verifier based on the Viper verification infrastructure, and demonstrate its ability to verify challenging examples.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591289", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marco", + "last_name": "Eilers", + "institution": "ETH Zurich" + }, + { + "first_name": "Thibault", + "last_name": "Dardinier", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/EilersD023", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591241", + "title": "Defunctionalization with Dependent Types", + "abstract": "The defunctionalization translation that eliminates higher-order functions from programs forms a key part of many compilers. However, defunctionalization for dependently-typed languages has not been formally studied. We present the first formally-specified defunctionalization translation for a dependently-typed language and establish key metatheoretical properties such as soundness and type preservation. The translation is suitable for incorporation into type-preserving compilers for dependently-typed languages", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591241", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Y", + "last_name": "Huang", + "institution": "University of Cambridge" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/HuangY23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591229", + "title": "Garbage-Collection Safety for Region-Based Type-Polymorphic Programs", + "abstract": "Region inference offers a mechanism to reduce (and sometimes entirely remove) the need for reference-tracing garbage collection by inferring where to insert allocation and deallocation instructions in a program at compile time. When the mechanism is combined with techniques for reference-tracing garbage collection, which is helpful in general to support programs with very dynamic memory behaviours, it turns out that region-inference is complementary to adding generations to a reference-tracing collector. However, region-inference and the associated region-representation analyses that make such a memory management strategy perform well in practice are complex, both from a theoretical point-of-view and from an implementation point-of-view. In this paper, we demonstrate a soundness problem with existing theoretical developments, which have to do with ensuring that, even for higher-order polymorphic programs, no dangling-pointers appear during a reference-tracing collection. This problem has materialised as a practical soundness problem in a real implementation based on region inference. As a solution, we present a modified, yet simple, region type-system that captures garbage-collection effects, even for polymorphic higher-order code, and outline how region inference and region-representation analyses are adapted to the new type system. The new type system allows for associating simpler region type-schemes with functions, compared to original work, makes it possible to combine region-based memory management with partly tag-free reference-tracing (and generational) garbage-collection, and repairs previously derived work that is based on the erroneous published results.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591229", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/Elsman23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591278", + "title": "Leveraging Rust Types for Program Synthesis", + "abstract": "The Rust type system guarantees memory safety and data-race freedom. However, to satisfy Rust's type rules, many familiar implementation patterns must be adapted substantially. These necessary adaptations complicate programming and might hinder language adoption. In this paper, we demonstrate that, in contrast to manual programming, automatic synthesis is not complicated by Rust's type system, but rather benefits in two major ways. First, a Rust synthesizer can get away with significantly simpler specifications. While in more traditional imperative languages, synthesizers often require lengthy annotations in a complex logic to describe the shape of data structures, aliasing, and potential side effects, in Rust, all this information can be inferred from the types, letting the user focus on specifying functional properties using a slight extension of Rust expressions. Second, the Rust type system reduces the search space for synthesis, which improves performance. In this work, we present the first approach to automatically synthesizing correct-by-construction programs in safe Rust. The key ingredient of our synthesis procedure is Synthetic Ownership Logic, a new program logic for deriving programs that are guaranteed to satisfy both a user-provided functional specification and, importantly, Rust's intricate type system. We implement this logic in a new tool called RusSOL. Our evaluation shows the effectiveness of RusSOL, both in terms of annotation burden and performance, in synthesizing provably correct solutions to common problems faced by new Rust developers.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591278", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jonáš", + "last_name": "Fiala", + "institution": "ETH Zurich" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/FialaI0PS23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591256", + "title": "Parallelism in a Region Inference Context", + "abstract": "Region inference is a type-based program analysis that takes a non-annotated program as input and constructs a program that explicitly manages memory allocation and deallocation by dividing the heap into a stack of regions, each of which can grow and shrink independently from other regions, using constant-time operations. Whereas region-based memory management has shown useful in the contexts of explicit region-based memory management, and in particular, in combination with parallel execution of code, combining region inference with techniques for higher-order parallel programming has not been investigated. In this paper, we present an implementation of a fork-join parallel construct suitable for a compiler based on region inference. We present a minimal higher-order language incorporating the parallel construct, including typing rules and a dynamic semantics for the language, and demonstrate type soundness. We present a novel effect-based region-protection inference algorithm and discuss benefits and shortcomings of the approach. We also describe an efficient implementation embedded in the MLKit Standard ML compiler. Finally, we evaluate the approach and the implementation based on a number of parallel benchmarks, and thereby demonstrate that the technique effectively utilises multi-core architectures in a higher-order functional setting.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591256", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" + }, + { + "first_name": "Troels", + "last_name": "Henriksen", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/ElsmanH23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591267", + "title": "Compound Memory Models", + "abstract": "Today's mobile, desktop, and server processors are heterogeneous, consisting not only of CPUs but also GPUs and other accelerators. Such heterogeneous processors are starting to expose a shared memory interface across these devices.Given that each of these individual devices typically supports a distinct instruction set architecture and a distinct memory consistency model, it is not clear what the memory consistency model of the heterogeneous machine should be. In this paper, we answer this question by formalizing \"compound\" memory models: we present a compositional operational model describing the resulting model when devices with distinct consistency models are fused together. We instantiate our model with the compound x86TSO/PTX model -- a CPU enforcing x86TSO and a GPU enforcing the PTX model. A key result is that the x86TSO/PTX compound model retains compiler mappings from the language-based (scoped) C memory model. This means that threads mapped to the x86TSO device can continue to use the already proven C-to-x86TSO compiler mapping, and the same for PTX.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591267", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andrés", + "last_name": "Goens", + "institution": "University of Edinburgh" + }, + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Delft University of Technology" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of St Andrews" + }, + { + "first_name": "Sukarn", + "last_name": "Agarwal", + "institution": "University of Edinburgh" + }, + { + "first_name": "Nicolai", + "last_name": "Oswald", + "institution": "" + }, + { + "first_name": "Vijay", + "last_name": "Nagarajan", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/Goens0SAON23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591285", + "title": "Absynthe: Abstract Interpretation-Guided Synthesis", + "abstract": "Synthesis tools have seen significant success in recent times. However, past approaches often require a complete and accurate embedding of the source language in the logic of the underlying solver, an approach difficult for industrial-grade languages. Other approaches couple the semantics of the source language with purpose-built synthesizers, necessarily tying the synthesis engine to a particular language model. In this paper, we propose Absynthe, an alternative approach based on user-defined abstract semantics that aims to be both lightweight and language agnostic, yet effective in guiding the search for programs. A synthesis goal in Absynthe is specified as an abstract specification in a lightweight user-defined abstract domain and concrete test cases. The synthesis engine is parameterized by the abstract semantics and independent of the source language. Absynthe validates candidate programs against test cases using the actual concrete language implementation to ensure correctness. We formalize the synthesis rules for Absynthe and describe how the key ideas are scaled-up in our implementation in Ruby. We evaluated Absynthe on SyGuS strings benchmark and found it competitive with other enumerative search solvers. Moreover, Absynthe's ability to combine abstract domains allows the user to move along a cost spectrum, i.e., expressive domains prune more programs but require more time. Finally, to verify Absynthe can act as a general purpose synthesis tool, we use Absynthe to synthesize Pandas data frame manipulating programs in Python using simple abstractions like types and column labels of a data frame. Absynthe reaches parity with AutoPandas, a deep learning based tool for the same benchmark suite. In summary, our results demonstrate Absynthe is a promising step forward towards a general-purpose approach to synthesis that may broaden the applicability of synthesis to more full-featured languages.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591285", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sankha Narayan", + "last_name": "Guria", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "Tufts University" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/GuriaFH23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591286", + "title": "Extensible Metatheory Mechanization via Family Polymorphism", + "abstract": "With the growing practice of mechanizing language metatheories, it has become ever more pressing that interactive theorem provers make it easy to write reusable, extensible code and proofs. This paper presents a novel language design geared towards extensible metatheory mechanization in a proof assistant. The new design achieves reuse and extensibility via a form of family polymorphism, an object-oriented idea, that allows code and proofs to be polymorphic to their enclosing families. Our development addresses technical challenges that arise from the underlying language of a proof assistant being simultaneously functional, dependently typed, a logic, and an interactive tool. Our results include (1) a prototypical implementation of the language design as a Coq plugin, (2) a dependent type theory capturing the essence of the language mechanism and its consistency and canonicity results, and (3) case studies showing how the new expressiveness naturally addresses real programming challenges in metatheory mechanization.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591286", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ende", + "last_name": "Jin", + "institution": "University of Waterloo" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "Harvard University Press" + }, + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/JinAZ23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591227", + "title": "Discrete Adversarial Attack to Models of Code", + "abstract": "The pervasive brittleness of deep neural networks has attracted significant attention in recent years. A particularly interesting finding is the existence of adversarial examples, imperceptibly perturbed natural inputs that induce erroneous predictions in state-of-the-art neural models. In this paper, we study a different type of adversarial examples specific to code models, called discrete adversarial examples , which are created through program transformations that preserve the semantics of original inputs.In particular, we propose a novel, general method that is highly effective in attacking a broad range of code models. From the defense perspective, our primary contribution is a theoretical foundation for the application of adversarial training — the most successful algorithm for training robust classifiers — to defending code models against discrete adversarial attack. Motivated by the theoretical results, we present a simple realization of adversarial training that substantially improves the robustness of code models against adversarial attacks in practice. We extensively evaluate both our attack and defense methods. Results show that our discrete attack is significantly more effective than state-of-the-art whether or not defense mechanisms are in place to aid models in resisting attacks. In addition, our realization of adversarial training improves the robustness of all evaluated models by the widest margin against state-of-the-art adversarial attacks as well as our own.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591227", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fengjuan", + "last_name": "Gao", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Yu", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "Visa (United States)" + } + ], + "dblp_key": "journals/pacmpl/Gao0W23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591221", + "title": "Mostly Automated Proof Repair for Verified Libraries", + "abstract": "The cost of maintaining formally specified and verified software is widely considered prohibitively high due to the need to constantly keep code and the proofs of its correctness in sync—the problem known as proof repair . One of the main challenges in automated proof repair for evolving code is to infer invariants for a new version of a once verified program that are strong enough to establish its full functional correctness. In this work, we present the first proof repair methodology for higher-order imperative functions, whose initial versions were verified in the Coq proof assistant and whose specifications remained unchanged. Our proof repair procedure is based on the combination of dynamic program alignment, enumerative invariant synthesis, and a novel technique for efficiently pruning the space of invariant candidates, dubbed proof-driven testing , enabled by the constructive nature of Coq’s proof certificates. We have implemented our approach in a mostly-automated proof repair tool called Sisyphus. Given an OCaml function verified in Coq and its unverified new version, Sisyphus produces a Coq proof for the new version, discharging most of the new proof goals automatically and suggesting high-confidence obligations for the programmer to prove for the cases when automation fails. We have evaluated Sisyphus on 10 OCaml programs taken from popular libraries, that manipulate arrays and mutable data structures, considering their verified original and unverified evolved versions. Sisyphus has managed to repair proofs for all those functions, suggesting correct invariants and generating a small number of easy-to-prove residual obligations.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591221", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kiran", + "last_name": "Gopinathan", + "institution": "National University of Singapore" + }, + { + "first_name": "Mayank", + "last_name": "Keoliya", + "institution": "National University of Singapore" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/GopinathanKS23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591272", + "title": "CryptOpt: Verified Compilation with Randomized Program Search for Cryptographic Primitives", + "abstract": "Most software domains rely on compilers to translate high-level code to multiple different machine languages, with performance not too much worse than what developers would have the patience to write directly in assembly language. However, cryptography has been an exception, where many performance-critical routines have been written directly in assembly (sometimes through metaprogramming layers). Some past work has shown how to do formal verification of that assembly, and other work has shown how to generate C code automatically along with formal proof, but with consequent performance penalties vs. the best- known assembly. We present CryptOpt, the first compilation pipeline that specializes high-level cryptographic functional programs into assembly code significantly faster than what GCC or Clang produce, with mechanized proof (in Coq) whose final theorem statement mentions little beyond the input functional program and the operational semantics of x86-64 assembly. On the optimization side, we apply randomized search through the space of assembly programs, with repeated automatic benchmarking on target CPUs. On the formal-verification side, we connect to the Fiat Cryptography framework (which translates functional programs into C-like IR code) and extend it with a new formally verified program-equivalence checker, incorporating a modest subset of known features of SMT solvers and symbolic-execution engines. The overall prototype is quite practical, e.g. producing new fastest-known implementations of finite-field arithmetic for both Curve25519 (part of the TLS standard) and the Bitcoin elliptic curve secp256k1 for the Intel 12𝑡ℎ and 13𝑡ℎ generations.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591272", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joel", + "last_name": "Kuepper", + "institution": "The University of Adelaide" + }, + { + "first_name": "Andres", + "last_name": "Erbsen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jason", + "last_name": "Gross", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Owen", + "last_name": "Conoly", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Chuyue", + "last_name": "Sun", + "institution": "Stanford University" + }, + { + "first_name": "Samuel", + "last_name": "Tian", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "David", + "last_name": "Wu", + "institution": "The University of Adelaide" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Chitchanok", + "last_name": "Chuengsatiansup", + "institution": "The University of Melbourne" + }, + { + "first_name": "Daniel", + "last_name": "Genkin", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Markus", + "last_name": "Wagner", + "institution": "Monash University" + }, + { + "first_name": "Yuval", + "last_name": "Yarom", + "institution": "Ruhr University Bochum" + } + ], + "dblp_key": "journals/pacmpl/KuepperEGCSTWCC23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591230", + "title": "CQS: A Formally-Verified Framework for Fair and Abortable Synchronization", + "abstract": "Writing concurrent code that is both correct and efficient is notoriously difficult. Thus, programmers often prefer to use synchronization abstractions, which render code simpler and easier to reason about. Despite a wealth of work on this topic, there is still a gap between the rich semantics provided by synchronization abstractions in modern programming languages—specifically, fair FIFO ordering of synchronization requests and support for abortable operations—and frameworks for implementing it correctly and efficiently. Supporting such semantics is critical given the rising popularity of constructs for asynchronous programming, such as coroutines, which abort frequently and are cheaper to suspend and resume compared to native threads. This paper introduces a new framework called CancellableQueueSynchronizer (CQS), which enables simple yet efficient implementations of a wide range of fair and abortable synchronization primitives: mutexes, semaphores, barriers, count-down latches, and blocking pools. Our main contribution is algorithmic, as implementing both fairness and abortability efficiently at this level of generality is non-trivial. Importantly, all our algorithms, including the CQS framework and the primitives built on top of it, come with formal proofs in the Iris framework for Coq for many of their properties. These proofs are modular, so it is easy to show correctness for new primitives implemented on top of CQS. From a practical perspective, implementation of CQS for native threads on the JVM improves throughput by up to two orders of magnitude over Java’s AbstractQueuedSynchronizer, the only practical abstraction offering similar semantics. Further, we successfully integrated CQS as a core component of the popular Kotlin Coroutines library, validating the framework’s practical impact and expressiveness in a real-world environment. In sum, CancellableQueueSynchronizer is the first framework to combine expressiveness with formal guarantees and solid practical performance. Our approach should be extensible to other languages and families of synchronization primitives.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591230", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Koval’", + "last_name": "Mykyta", + "institution": "" + }, + { + "first_name": "Dmitry", + "last_name": "Khalanskiy", + "institution": "" + }, + { + "first_name": "Dan", + "last_name": "Alistarh", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "journals/pacmpl/KovalKA23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591268", + "title": "Indexed Streams: A Formal Intermediate Representation for Fused Contraction Programs", + "abstract": "We introduce indexed streams, a formal operational model and intermediate representation that describes the fused execution of a contraction language that encompasses both sparse tensor algebra and relational algebra. We prove that the indexed stream model is correct with respect to a functional semantics. We also develop a compiler for contraction expressions that uses indexed streams as an intermediate representation. The compiler is only 540 lines of code, but we show that its performance can match both the TACO compiler for sparse tensor algebra and the SQLite and DuckDB query processing libraries for relational algebra.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591268", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Scott", + "last_name": "Kovach", + "institution": "Stanford University" + }, + { + "first_name": "Praneeth", + "last_name": "Kolichala", + "institution": "Stanford University" + }, + { + "first_name": "Tiancheng", + "last_name": "Gu", + "institution": "Stanford University" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/KovachKGK23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591259", + "title": "PureCake: A Verified Compiler for a Lazy Functional Language", + "abstract": "We present PureCake, a mechanically-verified compiler for PureLang, a lazy, purely functional programming language with monadic effects. PureLang syntax is Haskell-like and indentation-sensitive, and its constraint-based Hindley-Milner type system guarantees safe execution. We derive sound equational reasoning principles over its operational semantics, dramatically simplifying some proofs. We prove end-to-end correctness for the compilation of PureLang down to machine code---the first such result for any lazy language---by targeting CakeML and composing with its verified compiler. Multiple optimisation passes are necessary to handle realistic lazy idioms effectively. We develop PureCake entirely within the HOL4 interactive theorem prover.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591259", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hrutvik", + "last_name": "Kanabar", + "institution": "University of Kent" + }, + { + "first_name": "Samuel", + "last_name": "Vivien", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Oskar", + "last_name": "Abrahamsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Michael", + "last_name": "Norrish", + "institution": "Australian National University" + }, + { + "first_name": "Johannes Åman", + "last_name": "Pohjola", + "institution": "UNSW Sydney" + }, + { + "first_name": "Riccardo", + "last_name": "Zanetti", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "journals/pacmpl/KanabarVAMNPZ23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591257", + "title": "Don't Look UB: Exposing Sanitizer-Eliding Compiler Optimizations", + "abstract": "Sanitizers are widely used compiler features that detect undefined behavior and resulting vulnerabilities by injecting runtime checks into programs. For better performance, sanitizers are often used in conjunction with optimization passes. But doing so combines two compiler features with conflicting objectives. While sanitizers want to expose undefined behavior, optimizers often exploit these same properties for performance. In this paper, we show that this clash can have serious consequences: optimizations can remove sanitizer failures, thereby hiding the presence of bugs or even introducing new ones. We present LookUB, a differential-testing based framework for finding optimizer transformations that elide sanitizer failures. We used our method to find 17 such sanitizer-eliding optimizations in Clang. Next, we used static analysis and fuzzing to search for bugs in open-source projects that were previously hidden due to sanitizer-eliding optimizations. This led us to discover 20 new bugs in Linux Containers, libmpeg2, NTFS-3G, and WINE. Finally, we present an effective mitigation strategy based on a customization of the Clang optimizer with an overhead increase of 4%.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591257", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Raphael", + "last_name": "Isemann", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Cristiano", + "last_name": "Giuffrida", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Herbert", + "last_name": "Bos", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Erik van der", + "last_name": "Kouwe", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Klaus von", + "last_name": "Gleissenthall", + "institution": "Vrije Universiteit Amsterdam" + } + ], + "dblp_key": "journals/pacmpl/IsemannGBKG23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591232", + "title": "Memento: A Framework for Detectable Recoverability in Persistent Memory", + "abstract": "Persistent memory (PM) is an emerging class of storage technology that combines the performance of DRAM with the durability of SSD, offering the best of both worlds. This had led to a surge of research on persistent objects in PM. Among such persistent objects, concurrent data structures (DSs) are particularly interesting thanks to their performance and scalability. One of the most widely used correctness criteria for persistent concurrent DSs is detectable recoverability , ensuring both thread safety (for correctness in non-crashing concurrent executions) and crash consistency (for correctness in crashing executions). However, the existing approaches to designing detectably recoverable concurrent DSs are either limited to simple algorithms or suffer from high runtime overheads. We present Memento: a general and high-performance programming framework for detectably recoverable concurrent DSs in PM. To ensure general applicability to various DSs, Memento supports primitive operations such as checkpoint and compare-and-swap and their composition with control constructs. To ensure high performance, Memento employs a timestamp-based recovery strategy that requires fewer writes and flushes to PM than the existing approaches. We formally prove that Memento ensures detectable recoverability in the presence of crashes. To showcase Memento, we implement a lock-free stack, list, queue, and hash table, and a combining queue that detectably recovers from random crashes in stress tests and performs comparably to existing hand-tuned persistent DSs with and without detectable recoverability.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591232", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kyeongmin", + "last_name": "Cho", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Seungmin", + "last_name": "Jeon", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ChoJRK23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591294", + "title": "Program Reconditioning: Avoiding Undefined Behaviour When Finding and Reducing Compiler Bugs", + "abstract": "We introduce program reconditioning, a method for allowing program generation and differential testing to be used to find miscompilation bugs, and test-case reduction to be used to simplify bug-triggering programs, even when (a) the programming language of interest features undefined behaviour (UB) and (b) no tools exist to detect and avoid this UB. We present two program generation tools based on our reconditioning idea: GLSLsmith for the OpenGL Shading Language (GLSL), a widely-used language for graphics programming, and WGSLsmith for the WebGPU Shading Language (WGSL), a new language for web-based graphics rendering. GLSL features many UBs, but unlike for languages such as C and C++ no tools exist to detect them automatically. While the WGSL language specification features very limited UB, early WGSL implementations do exhibit UB, for reasons of initial implementation simplicity, making it challenging to test them to quickly detect and eliminate unrelated miscompilation bugs. Thanks to reconditioning, we show that GLSLsmith and WGSLsmith allow differential testing and test-case reduction to be applied to compilers for GLSL and WGSL for the first time, despite the unavailability of UB detection techniques for these languages. Through a large testing campaign, we have found 24 and 33 bugs in GLSL and WGSL compilers, respectively. We present experiments showing that when reconditioning is disabled, compiler testing leads to a high rate of test programs that appear to trigger miscompilation bugs, but actually just feature UB. We also present a novel approach to managing floating-point roundoff error using reconditioning, implemented for both GLSL and WGSL.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591294", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bastien", + "last_name": "Lecoeur", + "institution": "Imperial College London" + }, + { + "first_name": "Hasan", + "last_name": "Mohsin", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/LecoeurMD23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591253", + "title": "Fair Operational Semantics", + "abstract": "Fairness properties, which state that a sequence of bad events cannot happen infinitely before a good event takes place, are often crucial in program verification. However, general methods for expressing and reasoning about various kinds of fairness properties are relatively underdeveloped compared to those for safety properties. This paper proposes FOS (Fair Operational Semantics), a theory capable of expressing arbitrary notions of fairness as an operational semantics and reasoning about these notions of fairness. In addition, FOS enables thread-local reasoning about fairness by providing thread-local simulation relations equipped with separation- logic-style resource algebras. We verify a ticket lock implementation and a client of the ticket lock under weak memory concurrency as an example, which requires reasoning about different notions of fairness including fairness of a scheduler, fairness of the ticket lock implementation, and even fairness of weak memory. The theory of FOS, as well as the examples in the paper, are fully formalized in Coq.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591253", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dongjae", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Jinwoo", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "S.-M.", + "last_name": "Moon", + "institution": "Inha University" + }, + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/LeeCKMSH23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591233", + "title": "Recursive State Machine Guided Graph Folding for Context-Free Language Reachability", + "abstract": "Context-free language reachability (CFL-reachability) is a fundamental framework for program analysis. A large variety of static analyses can be formulated as CFL-reachability problems, which determines whether specific source-sink pairs in an edge-labeled graph are connected by a reachable path, i.e., a path whose edge labels form a string accepted by the given CFL. Computing CFL-reachability is expensive. The fastest algorithm exhibits a slightly subcubic time complexity with respect to the input graph size. Improving the scalability of CFL-reachability is of practical interest, but reducing the time complexity is inherently difficult. In this paper, we focus on improving the scalability of CFL-reachability from a more practical perspective---reducing the input graph size. Our idea arises from the existence of trivial edges, i.e., edges that do not affect any reachable path in CFL-reachability. We observe that two nodes joined by trivial edges can be folded---by merging the two nodes with all the edges joining them removed---without affecting the CFL-reachability result. By studying the characteristic of the recursive state machines (RSMs), an alternative form of CFLs, we propose an approach to identify foldable node pairs without the need to verify the underlying reachable paths (which is equivalent to solving the CFL-reachability problem). In particular, given a CFL-reachability problem instance with an input graph G and an RSM, based on the correspondence between paths in G and state transitions in RSM, we propose a graph folding principle, which can determine whether two adjacent nodes are foldable by examining only their incoming and outgoing edges. On top of the graph folding principle, we propose an efficient graph folding algorithm GF. The time complexity of GF is linear with respect to the number of nodes in the input graph. Our evaluations on two clients (alias analysis and value-flow analysis) show that GF significantly accelerates RSM/CFL-reachability by reducing the input graph size. On average, for value-flow analysis, GF reduces 60.96% of nodes and 42.67% of edges of the input graphs, obtaining a speedup of 4.65× and a memory usage reduction of 57.35%. For alias analysis, GF reduces 38.93% of nodes and 35.61% of edges of the input graphs, obtaining a speedup of 3.21× and a memory usage reduction of 65.19%.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591233", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuxiang", + "last_name": "Lei", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "UNSW Sydney" + }, + { + "first_name": "Shin Hwei", + "last_name": "Tan", + "institution": "Concordia University" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LeiSTZ23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591226", + "title": "Lilac: A Modal Separation Logic for Conditional Probability", + "abstract": "We present Lilac, a separation logic for reasoning about probabilistic programs where separating conjunction captures probabilistic independence. Inspired by an analogy with mutable state where sampling corresponds to dynamic allocation, we show how probability spaces over a fixed, ambient sample space appear to be the natural analogue of heap fragments, and present a new combining operation on them such that probability spaces behave like heaps and measurability of random variables behaves like ownership. This combining operation forms the basis for our model of separation, and produces a logic with many pleasant properties. In particular, Lilac has a frame rule identical to the ordinary one, and naturally accommodates advanced features like continuous random variables and reasoning about quantitative properties of programs. Then we propose a new modality based on disintegration theory for reasoning about conditional probability. We show how the resulting modal logic validates examples from prior work, and give a formal verification of an intricate weighted sampling algorithm whose correctness depends crucially on conditional independence structure.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591226", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "John M.", + "last_name": "Li", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + }, + { + "first_name": "Steven", + "last_name": "Holtzen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/Li0H23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591283", + "title": "Flux: Liquid Types for Rust", + "abstract": "We introduce Flux, which shows how logical refinements can work hand in glove with Rust's ownership mechanisms to yield ergonomic type-based verification of low-level pointer manipulating programs. First, we design a novel refined type system for Rust that indexes mutable locations, with pure (immutable) values that can appear in refinements, and then exploits Rust's ownership mechanisms to abstract sub-structural reasoning about locations within Rust's polymorphic type constructors, while supporting strong updates. We formalize the crucial dependency upon Rust's strong aliasing guarantees by exploiting the Stacked Borrows aliasing model to prove that \"well-borrowed evaluations of well-typed programs do not get stuck\". Second, we implement our type system in Flux, a plug-in to the Rust compiler that exploits the factoring of complex invariants into types and refinements to efficiently synthesize loop annotations-including complex quantified invariants describing the contents of containers-via liquid inference. Third, we evaluate Flux with a benchmark suite of vector manipulating programs and parts of a previously verified secure sandboxing library to demonstrate the advantages of refinement types over program logics as implemented in the state-of-the-art Prusti verifier. While Prusti's more expressive program logic can, in general, verify deep functional correctness specifications, for the lightweight but ubiquitous and important verification use-cases covered by our benchmarks, liquid typing makes verification ergonomic by slashing specification lines by a factor of two, verification time by an order of magnitude, and annotation overhead from up to 24% of code size (average 14%), to nothing at all.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591283", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nico", + "last_name": "Lehmann", + "institution": "University of California San Diego" + }, + { + "first_name": "Adam T.", + "last_name": "Geller", + "institution": "University of British Columbia" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/LehmannGVJ23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591290", + "title": "Probabilistic Programming with Stochastic Probabilities", + "abstract": "We present a new approach to the design and implementation of probabilistic programming languages (PPLs), based on the idea of stochastically estimating the probability density ratios necessary for probabilistic inference. By relaxing the usual PPL design constraint that these densities be computed exactly, we are able to eliminate many common restrictions in current PPLs, to deliver a language that, for the first time, simultaneously supports first-class constructs for marginalization and nested inference, unrestricted stochastic control flow, continuous and discrete sampling, and programmable inference with custom proposals. At the heart of our approach is a new technique for compiling these expressive probabilistic programs into randomized algorithms for unbiasedly estimating their densities and density reciprocals. We employ these stochastic probability estimators within modified Monte Carlo inference algorithms that are guaranteed to be sound despite their reliance on inexact estimates of density ratios. We establish the correctness of our compiler using logical relations over the semantics of λ SP , a new core calculus for modeling and inference with stochastic probabilities. We also implement our approach in an open-source extension to Gen, called GenSP, and evaluate it on six challenging inference problems adapted from the modeling and inference literature. We find that: (1) ‍can automate fast density estimators for programs with very expensive exact densities; (2) convergence of inference is mostly unaffected by the noise from these estimators; and (3) our sound-by-construction estimators are competitive with hand-coded density estimators, incurring only a small constant-factor overhead.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591290", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Matin", + "last_name": "Ghavamizadeh", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LewGRM23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591246", + "title": "Conflict-Driven Synthesis for Layout Engines", + "abstract": "Modern web browsers rely on layout engines to convert HTML documents to layout trees that specify color, size, and position. However, existing layout engines are notoriously difficult to maintain because of the complexity of web standards. This is especially true for incremental layout engines, which are designed to improve performance by updating only the parts of the layout tree that need to be changed. In this paper, we propose Medea, a new framework for automatically generating incremental layout engines. Medea separates the specification of the layout engine from its incremental implementation, and guarantees correctness through layout engine synthesis. The synthesis is driven by a new iterative algorithm based on detecting conflicts that prevent optimality of the incremental algorithm. We evaluated Medea on a fragment of HTML layout that includes challenging features such as margin collapse, floating layout, and absolute positioning. Medea successfully synthesized an incremental layout engine for this fragment. The synthesized layout engine is both correct and efficient. In particular, we demonstrated that it avoids real-world bugs that have been reported in the layout engines of Chrome, Firefox, and Safari. The incremental layout engine synthesized by Medea is up to 1.82× faster than a naive incremental baseline. We also demonstrated that our conflict-driven algorithm produces engines that are 2.74× faster than a baseline without conflict analysis.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591246", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Junrui", + "last_name": "Liu", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Yanju", + "last_name": "Chen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Eric", + "last_name": "Atkinson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/LiuCA0B23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591295", + "title": "Fuzzing Loop Optimizations in Compilers for C++ and Data-Parallel Languages", + "abstract": "Compilers are part of the foundation upon which software systems are built; they need to be as correct as possible. This paper is about stress-testing loop optimizers; it presents a major reimplementation of Yet Another Random Program Generator (YARPGen), an open-source generative compiler fuzzer. This new version has found 122 bugs, both in compilers for data-parallel languages, such as the Intel® Implicit SPMD Program Compiler and the Intel® oneAPI DPC++ compiler, and in C++ compilers such as GCC and Clang/LLVM. The first main contribution of our work is a novel method for statically avoiding undefined behavior when generating loops; the resulting programs conform to the relevant language standard, enabling automated testing. The second main contribution is a collection of mechanisms for increasing the diversity of generated loop code; in our evaluation, we demonstrate that these make it possible to trigger loop optimizations significantly more often, providing opportunities to discover bugs in the optimizers.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591295", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vsevolod", + "last_name": "Livinskii", + "institution": "University of Utah" + }, + { + "first_name": "Dmitry", + "last_name": "Babokin", + "institution": "Intel (United States)" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/LivinskiiBR23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591279", + "title": "VMSL: A Separation Logic for Mechanised Robust Safety of Virtual Machines Communicating above FF-A", + "abstract": "Thin hypervisors make it possible to isolate key security components like keychains, fingerprint readers, and digital wallets from the easily-compromised operating system. To work together, virtual machines running on top of the hypervisor can make hypercalls to the hypervisor to share pages between each other in a controlled way. However, the design of such hypercall ABIs remains a delicate balancing task between conflicting needs for expressivity, performance, and security. In particular, it raises the question of what makes the specification of a hypervisor, and of its hypercall ABIs, good enough for the virtual machines. In this paper, we validate the expressivity and security of the design of the hypercall ABIs of Arm's FF-A. We formalise a substantial fragment of FF-A as a machine with a simplified ISA in which hypercalls are steps of the machine. We then develop VMSL, a novel separation logic, which we prove sound with respect to the machine execution model, and use it to reason modularly about virtual machines which communicate through the hypercall ABIs, demonstrating the hypercall ABIs' expressivity. Moreover, we use the logic to prove robust safety of communicating virtual machines, that is, the guarantee that even if some of the virtual machines are compromised and execute unknown code, they cannot break the safety properties of other virtual machines running known code. This demonstrates the intended security guarantees of the hypercall ABIs. All the results in the paper have been formalised in Coq using the Iris framework.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591279", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zongyuan", + "last_name": "Liu", + "institution": "Aarhus University" + }, + { + "first_name": "Sergei", + "last_name": "Stepanenko", + "institution": "Aarhus University" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "Aarhus University" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Aslan", + "last_name": "Askarov", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/LiuSPTAB23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591280", + "title": "Scallop: A Language for Neurosymbolic Programming", + "abstract": "We present Scallop, a language which combines the benefits of deep learning and logical reasoning. Scallop enables users to write a wide range of neurosymbolic applications and train them in a data- and compute-efficient manner. It achieves these goals through three key features: 1) a flexible symbolic representation that is based on the relational data model; 2) a declarative logic programming language that is based on Datalog and supports recursion, aggregation, and negation; and 3) a framework for automatic and efficient differentiable reasoning that is based on the theory of provenance semirings. We evaluate Scallop on a suite of eight neurosymbolic applications from the literature. Our evaluation demonstrates that Scallop is capable of expressing algorithmic reasoning in diverse and challenging AI tasks, provides a succinct interface for machine learning programmers to integrate logical domain knowledge, and yields solutions that are comparable or superior to state-of-the-art models in terms of accuracy. Furthermore, Scallop's solutions outperform these models in aspects such as runtime and data efficiency, interpretability, and generalizability.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591280", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ziyang", + "last_name": "Li", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Jiani", + "last_name": "Huang", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LiHN23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591242", + "title": "Context Sensitivity without Contexts: A Cut-Shortcut Approach to Fast and Precise Pointer Analysis", + "abstract": "Over the past decades, context sensitivity has been considered as one of the most effective ideas for improving the precision of pointer analysis for Java. Different from the extremely fast context-insensitivity approach, context sensitivity requires every program method to be analyzed under different contexts for separating the static abstractions of different dynamic instantiations of the method’s variables and heap objects, and thus reducing spurious object flows introduced by method calls. However, despite great precision benefits, as each method is equivalently cloned and analyzed under each context, context sensitivity brings heavy efficiency costs. Recently, numerous selective context-sensitive approaches have been put forth for scaling pointer analysis to large and complex Java programs by applying contexts only to the selected methods while analyzing the remaining ones context-insensitively; however, because the selective approaches do not fundamentally alter the primary methodology of context sensitivity (and do not thus remove its efficiency bottleneck), they produce much improved but still limited results. In this work, we present a fundamentally different approach called Cut-Shortcut for fast and precise pointer analysis for Java. Its insight is simple: the main effect of cloning methods under different contexts is to filter spurious object flows that have been merged inside a callee method; from the view of a typical pointer flow graph (PFG), such effect can be simulated by cutting off (Cut) the edges that introduce precision loss to certain pointers and adding Shortcut edges directly from source pointers to the target ones circumventing the method on PFG. As a result, we can achieve the effect of context sensitivity without contexts. We identify three general program patterns and develop algorithms based on them to safely cut off and add shortcut edges on PFG, formalize them and formally prove the soundness. To comprehensively validate Cut-Shortcut’s effectiveness, we implement two versions of Cut-Shortcut for two state-of-the-art pointer analysis frameworks for Java, one in Datalog for the declarative Doop and the other in Java for the imperative Tai-e, and we consider all the large and complex programs used in recent literatures that meet the experimental requirements. The evaluation results are extremely promising: Cut-Shortcut is even able to run faster than context insensitivity for most evaluated programs while obtaining high precision that is comparable to context sensitivity (if scalable) in both frameworks. This is for the first time that we have been able to achieve such a good efficiency and precision trade-off for those hard-to-analyze programs, and we hope Cut-Shortcut could offer new perspectives for developing more effective pointer analysis for Java in the future.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591242", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wenjie", + "last_name": "Ma", + "institution": "Nanjing University" + }, + { + "first_name": "Sheng-Yuan", + "last_name": "Yang", + "institution": "Nanjing University" + }, + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "Nanjing University" + }, + { + "first_name": "Xiaoxing", + "last_name": "Ma", + "institution": "Nanjing University" + }, + { + "first_name": "Chang", + "last_name": "Xu", + "institution": "Nanjing University" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/MaY0M0023", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591262", + "title": "Derivative Based Nonbacktracking Real-World Regex Matching with Backtracking Semantics", + "abstract": "We develop a new derivative based theory and algorithm for nonbacktracking regex matching that supports anchors and counting, preserves backtracking semantics, and can be extended with lookarounds. The algorithm has been implemented as a new regex backend in .NET and was extensively tested as part of the formal release process of .NET7. We present a formal proof of the correctness of the algorithm, which we believe to be the first of its kind concerning industrial implementations of regex matchers. The paper describes the complete foundation, the matching algorithm, and key aspects of the implementation involving a regex rewrite system, as well as a comprehensive evaluation over industrial case studies and other regex engines.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591262", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dan", + "last_name": "Moseley", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Mario", + "last_name": "Nishio", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jose Perez", + "last_name": "Rodriguez", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Olli", + "last_name": "Saarikivi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Stephen", + "last_name": "Toub", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tiki", + "last_name": "Wan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Eric You", + "last_name": "Xu", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/MoseleyNRSTVWX23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591277", + "title": "Parameterized Algebraic Protocols", + "abstract": "We propose algebraic protocols that enable the definition of protocol templates and session types analogous to the definition of domain-specific types with algebraic datatypes. Parameterized algebraic protocols subsume all regular as well as most context-free and nested session types and, at the same time, replace the expensive superlinear algorithms for type checking by a nominal check that runs in linear time. Algebraic protocols in combination with polymorphism increase expressiveness and modularity by facilitating new ways of parameterizing and composing session types.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591277", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andreia", + "last_name": "Mordido", + "institution": "University of Lisbon" + }, + { + "first_name": "Janek", + "last_name": "Spaderna", + "institution": "University of Freiburg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + } + ], + "dblp_key": "journals/pacmpl/MordidoS0V23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591231", + "title": "Generalized Policy-Based Noninterference for Efficient Confidentiality-Preservation", + "abstract": "As more organizations are leveraging third-party cloud and edge data centers to process data efficiently, the issue of preserving data confidentiality becomes increasingly important. In response, numerous security mechanisms have been introduced and promoted in recent years including software-based ones such as homomorphic encryption, as well as hardware-based ones such as Intel SGX and AMD SEV. However these mechanisms vary in their security properties, performance characteristics, availability, and application modalities, making it hard for programmers to judiciously choose and correctly employ the right one for a given data query. This paper presents a mechanism-independent approach to distributed confidentiality-preserving data analytics. Our approach hinges on a core programming language which abstracts the intricacies of individual security mechanisms. Data is labeled using custom confidentiality levels arranged along a lattice in order to capture its exact confidentiality constraints. High-level mappings between available mechanisms and these labels are captured through a novel expressive form of security policy. Confidentiality is guaranteed through a type system based on a novel formulation of noninterference, generalized to support our security policy definition. Queries written in a largely security-agnostic subset of our language are transformed to the full language to automatically use mechanisms in an efficient, possibly combined manner, while provably preserving confidentiality in data queries end-to-end. We prototype our approach as an extension to the popular Apache Spark analytics engine, demonstrating the significant versatility and performance benefits of our approach over single hardwired mechanisms --- including in existing systems --- without compromising on confidentiality.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591231", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shamiek", + "last_name": "Mangipudi", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Pavel", + "last_name": "Chuprikov", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Malte", + "last_name": "Viering", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Savvas", + "last_name": "Savvides", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/MangipudiCEVS23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591275", + "title": "Beyond Backtracking: Connections in Fine-Grained Concurrent Separation Logic", + "abstract": "Concurrent separation logic has been responsible for major advances in the formal verification of fine-grained concurrent algorithms and data structures such as locks, barriers, queues, and reference counters. The key ingredient of the verification of a fine-grained program is an invariant, which relates the physical data representation (on the heap) to a logical representation (in mathematics) and to the state of the threads (using a form of ghost state). An invariant is typically represented as a disjunction of logical states, but this disjunctive nature makes invariants a difficult target for automated verification. Current approaches roughly suffer from two problems. They use backtracking to introduce disjunctions in an uninformed manner, which can lead to unprovable goals if an appropriate case analysis has not been made before choosing the disjunct. Moreover, they eliminate disjunctions too eagerly, which can cause poor efficiency. While disjunctions are no problem for automated provers based on classical (i.e., non-separating) logic, the challenges with disjunctions are prominent in the study of proof automation for intuitionistic logic. We take inspiration from that area—specifically, based on ideas from connection calculus , we design a simple multi-succedent calculus for separation logic with disjunctions featuring a novel concept of a connection . While our calculus is not complete, it has the advantage that it can be extended with features of the state-of-the-art concurrent separation logic Iris (such as modalities, higher-order quantification, ghost state, and invariants), and can be implemented effectively in the Coq proof assistant with little need for backtracking. We evaluate the practicality on 24 challenging benchmarks, 14 of which we can verify fully automatically.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591275", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ike", + "last_name": "Mulder", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Łukasz", + "last_name": "Czajka", + "institution": "TU Dortmund University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/Mulder0K23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591258", + "title": "Proving and Disproving Equivalence of Functional Programming Assignments", + "abstract": "We present an automated approach to verify the correctness of programming assignments, such as the ones that arise in a functional programming course. Our approach takes as input student submissions and reference solutions, and uses equivalence checking to automatically prove or disprove correctness of each submission. To be effective in the context of a real-world programming course, an automated grading system must be both robust, to support programs written in a variety of style, and scalable, to treat hundreds of submissions at once. We achieve robustness by handling recursion using functional induction and by handling auxiliary functions using function call matching. We achieve scalability using a clustering algorithm that leverages the transitivity of equivalence to discover intermediate reference solutions among student submissions. We implement our approach on top of the Stainless verification system, to support equivalence checking of Scala programs. We evaluate our system and its components on over 4000 programs drawn from a functional programming course and from the program equivalence checking literature; this is the largest such evaluation to date. We show that our system is capable of proving program correctness by generating inductive equivalence proofs, and providing counterexamples for incorrect programs, with a high success rate.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591258", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dragana", + "last_name": "Milovančević", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/MilovancevicK23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591252", + "title": "Abstract Interpretation of Fixpoint Iterators with Applications to Neural Networks", + "abstract": "We present a new abstract interpretation framework for the precise over-approximation of numerical fixpoint iterators. Our key observation is that unlike in standard abstract interpretation (AI), typically used to over-approximate all reachable program states, in this setting, one only needs to abstract the concrete fixpoints, i.e., the final program states. Our framework targets numerical fixpoint iterators with convergence and uniqueness guarantees in the concrete and is based on two major technical contributions: (i) theoretical insights which allow us to compute sound and precise fixpoint abstractions without using joins, and (ii) a new abstract domain, CH-Zonotope, which admits efficient propagation and inclusion checks while retaining high precision. We implement our framework in a tool called CRAFT and evaluate it on a novel fixpoint-based neural network architecture (monDEQ) that is particularly challenging to verify. Our extensive evaluation demonstrates that CRAFT exceeds the state-of-the-art performance in terms of speed (two orders of magnitude), scalability (one order of magnitude), and precision (25% higher certified accuracies).", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591252", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark Niklas", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "M.", + "last_name": "Fischer", + "institution": "ETH Zurich" + }, + { + "first_name": "Robin", + "last_name": "Staab", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/Muller0SV23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591249", + "title": "Responsive Parallelism with Synchronization", + "abstract": "Many concurrent programs assign priorities to threads to improve responsiveness. When used in conjunction with synchronization mechanisms such as mutexes and condition variables, however, priorities can lead to priority inversions, in which high-priority threads are delayed by low-priority ones. Priority inversions in the use of mutexes are easily handled using dynamic techniques such as priority inheritance, but priority inversions in the use of condition variables are not well-studied and dynamic techniques are not suitable. In this work, we use a combination of static and dynamic techniques to prevent priority inversion in code that uses mutexes and condition variables. A type system ensures that condition variables are used safely, even while dynamic techniques change thread priorities at runtime to eliminate priority inversions in the use of mutexes. We prove the soundness of our system, using a model of priority inversions based on cost models for parallel programs. To show that the type system is practical to implement, we encode it within the type systems of Rust and C++, and show that the restrictions are not overly burdensome by writing sizeable case studies using these encodings, including porting the Memcached object server to use our C++ implementation.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591249", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Kyle", + "last_name": "Singer", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Devyn Terra", + "last_name": "Keeney", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Andrew", + "last_name": "Neth", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Kunal", + "last_name": "Agrawal", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "I-Ting Angelina", + "last_name": "Lee", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/MullerSKNALA23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591234", + "title": "Modular Hardware Design with Timeline Types", + "abstract": "Modular design is a key challenge for enabling large-scale reuse of hardware modules. Unlike software, however, hardware designs correspond to physical circuits and inherit constraints from them. Timing constraints—which cycle a signal arrives, when an input is read—and structural constraints—how often a multiplier accepts new inputs—are fundamental to hardware interfaces. Existing hardware design languages do not provide a way to encode these constraints; a user must read documentation, build scripts, or in the worst case, a module’s implementation to understand how to use it. We present Filament, a language for modular hardware design that supports the specification and enforcement of timing and structural constraints for statically scheduled pipelines. Filament uses timeline types , which describe the intervals of clock-cycle time when a given signal is available or required. Filament enables safe composition of hardware modules, ensures that the resulting designs are correctly pipelined, and predictably lowers them to efficient hardware.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591234", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rachit", + "last_name": "Nigam", + "institution": "Cornell University" + }, + { + "first_name": "Pedro H. Azevedo de", + "last_name": "Amorim", + "institution": "Cornell University" + }, + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/NigamAS23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591282", + "title": "Automated Detection of Under-Constrained Circuits in Zero-Knowledge Proofs", + "abstract": "As zero-knowledge proofs gain increasing adoption, the cryptography community has designed domain-specific languages (DSLs) that facilitate the construction of zero-knowledge proofs (ZKPs). Many of these DSLs, such as Circom, facilitate the construction of arithmetic circuits, which are essentially polynomial equations over a finite field. In particular, given a program in a zero-knowledge proof DSL, the compiler automatically produces the corresponding arithmetic circuit. However, a common and serious problem is that the generated circuit may be underconstrained, either due to a bug in the program or a bug in the compiler itself. Underconstrained circuits admit multiple witnesses for a given input, so a malicious party can generate bogus witnesses, thereby causing the verifier to accept a proof that it should not. Because of the increasing prevalence of such arithmetic circuits in blockchain applications, several million dollars worth of cryptocurrency have been stolen due to underconstrained arithmetic circuits. Motivated by this problem, we propose a new technique for finding ZKP bugs caused by underconstrained polynomial equations over finite fields. Our method performs semantic reasoning over the finite field equations generated by the compiler to prove whether or not each signal is uniquely determined by the input. Our proposed approach combines SMT solving with lightweight uniqueness inference to effectively reason about underconstrained circuits. We have implemented our proposed approach in a tool called QED 2 and evaluate it on 163 Circom circuits. Our evaluation shows that QED 2 can successfully solve 70% of these benchmarks, meaning that it either verifies the uniqueness of the output signals or finds a pair of witnesses that demonstrate non-uniqueness of the circuit. Furthermore, QED 2 has found 8 previously unknown vulnerabilities in widely-used circuits.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591282", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "" + }, + { + "first_name": "Yanju", + "last_name": "Chen", + "institution": "" + }, + { + "first_name": "Franklyn", + "last_name": "Wang", + "institution": "Harvard University" + }, + { + "first_name": "Clara", + "last_name": "Rodríguez-Núñez", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Jacob Van", + "last_name": "Geffen", + "institution": "" + }, + { + "first_name": "Jason", + "last_name": "Morton", + "institution": "" + }, + { + "first_name": "Michael A.", + "last_name": "Chu", + "institution": "" + }, + { + "first_name": "B.Y.", + "last_name": "GU", + "institution": "" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/PailoorCWRGMCG023", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591265", + "title": "Iris-Wasm: Robust and Modular Verification of WebAssembly Programs", + "abstract": "WebAssembly makes it possible to run C/C++ applications on the web with near-native performance. A WebAssembly program is expressed as a collection of higher-order ML-like modules, which are composed together through a system of explicit imports and exports using a host language, enabling a form of higher- order modular programming. We present Iris-Wasm, a mechanized higher-order separation logic building on a specification of Wasm 1.0 mechanized in Coq and the Iris framework. Using Iris-Wasm, we are able to specify and verify individual modules separately, and then compose them modularly in a simple host language featuring the core operations of the WebAssembly JavaScript Interface. Building on Iris-Wasm, we develop a logical relation that enforces robust safety: unknown, adversarial code can only affect other modules through the functions that they explicitly export. Together, the program logic and the logical relation allow us to formally verify functional correctness of WebAssembly programs, even when they invoke and are invoked by unknown code, thereby demonstrating that WebAssembly enforces strong isolation between modules.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591265", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiaojia", + "last_name": "Rao", + "institution": "Imperial College London" + }, + { + "first_name": "Aïna Linn", + "last_name": "Georges", + "institution": "Aarhus University" + }, + { + "first_name": "Maxime", + "last_name": "Legoupil", + "institution": "Aarhus University" + }, + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "University of Cambridge" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "Aarhus University" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/RaoGLWPGB23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591292", + "title": "Merging Inductive Relations", + "abstract": "Inductive relations offer a powerful and expressive way of writing program specifications while facilitating compositional reasoning. Their widespread use by proof assistant users has made them a particularly attractive target for proof engineering tools such as QuickChick, a property-based testing tool for Coq which can automatically derive generators for values satisfying an inductive relation. However, while such generators are generally efficient, there is an infrequent yet seemingly inevitable situation where their performance greatly degrades: when multiple inductive relations constrain the same piece of data. In this paper, we introduce an algorithm for merging two such inductively defined properties that share an index. The algorithm finds shared structure between the two relations, and creates a single merged relation that is provably equivalent to the conjunction of the two. We demonstrate, through a series of case studies, that the merged relations can improve the performance of automatic generation by orders of magnitude, as well as simplify mechanized proofs by getting rid of the need for nested induction and tedious low-level book-keeping.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591292", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Prinz", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/PrinzL23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591281", + "title": "Obtaining Information Leakage Bounds via Approximate Model Counting", + "abstract": "Information leaks are a significant problem in modern software systems. In recent years, information theoretic concepts, such as Shannon entropy, have been applied to quantifying information leaks in programs. One recent approach is to use symbolic execution together with model counting constraints solvers in order to quantify information leakage. There are at least two reasons for unsoundness in quantifying information leakage using this approach: 1) Symbolic execution may not be able to explore all execution paths, 2) Model counting constraints solvers may not be able to provide an exact count. We present a sound symbolic quantitative information flow analysis that bounds the information leakage both for the cases where the program behavior is not fully explored and the model counting constraint solver is unable to provide a precise model count but provides an upper and a lower bound. We implemented our approach as an extension to KLEE for computing sound bounds for information leakage in C programs.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591281", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Seemanta", + "last_name": "Saha", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Surendra", + "last_name": "Ghentiyala", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Songhe", + "last_name": "Lu", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Lucas", + "last_name": "Bang", + "institution": "Harvey Mudd College" + }, + { + "first_name": "Tevfik", + "last_name": "Bultan", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "journals/pacmpl/SahaGLBB23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591240", + "title": "Feature-Sensitive Coverage for Conformance Testing of Programming Language Implementations", + "abstract": "The conformance testing of programming language implementations is crucial to support correct and consistent execution environments. Because manually maintaining conformance tests for real-world programming languages is cumbersome and labor-intensive, researchers have presented various ways to make conformance tests effective and efficient. One such approach is to use graph coverage, one of the most widely-used coverage criteria, to generate tests that reach different parts of a mechanized language specification. Since mechanized specifications use functions or inductive definitions to describe the semantics of language features, traditional graph coverage criteria for software work as they are. However, they may not produce high-quality conformance tests because language implementations often have specialized execution paths for different features, even when their semantics descriptions use the same functions. Traditional graph coverage may not distinguish test requirements of such language features, which degrades the quality of conformance testing. Similarly, it may not distinguish test requirements of different parts of the same language feature when their semantics descriptions use the same functions. We present feature-sensitive (FS) coverage as a novel coverage criterion to generate high-quality conformance tests for language implementations. It is a general extension of graph coverage, refining conventional test requirements using the innermost enclosing language features. We also introduce feature-call-path-sensitive (FCPS) coverage, a variant of FS coverage, and extend both coverage criteria using the 𝑘-limiting approach. To evaluate the effectiveness of the new coverage criteria for language implementations, we apply them to a mechanized specification of JavaScript. We extend JEST, the state-of-the-art JavaScript conformance test synthesizer using coverage-guided mutational fuzzing, with various FS and FCPS coverage criteria. For the latest JavaScript language specification (ES13, 2022), our tool automatically synthesizes 237,981 conformance tests in 50 hours with five coverage criteria. We evaluated the conformance of eight mainstream JavaScript implementations (four engines and four transpilers) with the synthesized conformance tests and discovered bugs in all of them. The tool detected 143 distinct conformance bugs (42 in engines and 101 in transpilers), 85 of which were confirmed by the developers and 83 of which were newly discovered bugs.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591240", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jihyeok", + "last_name": "Park", + "institution": "Korea University" + }, + { + "first_name": "Dongjun", + "last_name": "Youn", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Kanguk", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ParkYLR23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591228", + "title": "HEaaN.MLIR: An Optimizing Compiler for Fast Ring-Based Homomorphic Encryption", + "abstract": "Homomorphic encryption (HE) is an encryption scheme that provides arithmetic operations on the encrypted data without doing decryption. For Ring-based HE, an encryption scheme that uses arithmetic operations on a polynomial ring as building blocks, performance improvement of unit HE operations has been achieved by two kinds of efforts. The first one is through accelerating the building blocks, polynomial operations. However, it does not facilitate optimizations across polynomial operations such as fusing two polynomial operations. The second one is implementing highly optimized HE operations in an amalgamated manner. The written codes have superior performance, but they are hard to maintain. To resolve these challenges, we propose HEaaN.MLIR, a compiler that performs optimizations across polynomial operations. Also, we propose Poly and ModArith, compiler intermediate representations (IRs) for integer polynomial arithmetic and modulus arithmetic on integer arrays. HEaaN.MLIR has compiler optimizations that are motivated by manual optimizations that HE developers do. These include optimizing modular arithmetic operations, fusing loops, and vectorizing integer arithmetic instructions. HEaaN.MLIR can parse a program consisting of the Poly and ModArith instructions and generate a high-performance, multithreaded machine code for a CPU. Our experiment shows that the compiled operations outperform heavily optimized open-source and commercial HE libraries by up to 3.06x in a single thread and 4.55x in multiple threads.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591228", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "S.", + "last_name": "Park", + "institution": "Seoul National University" + }, + { + "first_name": "Woosung", + "last_name": "Song", + "institution": "" + }, + { + "first_name": "Nam", + "last_name": "SeungHyeon", + "institution": "Seoul National University" + }, + { + "first_name": "Hyeongyu", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Junbum", + "last_name": "Shin", + "institution": "" + }, + { + "first_name": "Juneyoung", + "last_name": "Lee", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/ParkSNKSL23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591266", + "title": "Cakes That Bake Cakes: Dynamic Computation in CakeML", + "abstract": "We have extended the verified CakeML compiler with a new language primitive, Eval, which permits evaluation of new CakeML syntax at runtime. This new implementation supports an ambitious form of compilation at runtime and dynamic execution, where the original and dynamically added code can share (higher-order) values and recursively call each other. This is, to our knowledge, the first verified run-time environment capable of supporting a standard LCF-style theorem prover design. Modifying the modern CakeML compiler pipeline and proofs to support a dynamic computation semantics was an extensive project. We review the design decisions, proof techniques, and proof engineering lessons from the project, and highlight some unexpected complications.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591266", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Yong Kiam", + "last_name": "Tan", + "institution": "" + }, + { + "first_name": "Ramana", + "last_name": "Kumar", + "institution": "" + }, + { + "first_name": "Alexander", + "last_name": "Mihajlovic", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Oskar", + "last_name": "Abrahamsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/SewellMTKMAO23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591247", + "title": "Psym: Efficient Symbolic Exploration of Distributed Systems", + "abstract": "Verification of distributed systems using systematic exploration is daunting because of the many possible interleavings of messages and failures. When faced with this scalability challenge, existing approaches have traditionally mitigated state space explosion by avoiding exploration of redundant states (e.g., via state hashing) and redundant interleavings of transitions (e.g., via partial-order reductions). In this paper, we present an efficient symbolic exploration method that not only avoids redundancies in states and interleavings, but additionally avoids redundant computations that are performed during updates to states on transitions. Our symbolic explorer leverages a novel, fine-grained, canonical representation of distributed system configurations (states) to identify opportunities for avoiding such redundancies on-the-fly. The explorer also includes an interface that is compatible with abstractions for state-space reduction and with partial-order and other reductions for avoiding redundant interleavings. We implement our approach in the tool Psym and empirically demonstrate that it outperforms a state-of-the-art exploration tool, can successfully verify many common distributed protocols, and can scale to multiple real-world industrial case studies across", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591247", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lauren", + "last_name": "Pick", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ankush", + "last_name": "Desai", + "institution": "Amazon (United States)" + }, + { + "first_name": "Aarti", + "last_name": "Gupta", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/PickDG23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591273", + "title": "Reliable Actors with Retry Orchestration", + "abstract": "Cloud developers have to build applications that are resilient to failures and interruptions. We advocate for a fault-tolerant programming model for the cloud based on actors, retry orchestration, and tail calls. This model builds upon persistent data stores and message queues readily available on the cloud. Retry orchestration not only guarantees that (1) failed actor invocations will be retried but also that (2) completed invocations are never repeated and (3) it preserves a strict happen-before relationship across failures within call stacks. Tail calls can break complex tasks into simple steps to minimize re-execution during recovery. We review key application patterns and failure scenarios. We formalize a process calculus to precisely capture the mechanisms of fault tolerance in this model. We briefly describe our implementation. Using an application inspired by a typical enterprise scenario, we validate the functional correctness of our implementation and assess the impact of fault preparedness and recovery on performance.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591273", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Tardieu", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Grove", + "institution": "" + }, + { + "first_name": "Gheorghe-Teodor", + "last_name": "Bercea", + "institution": "" + }, + { + "first_name": "Paul", + "last_name": "Castro", + "institution": "" + }, + { + "first_name": "Jaroslaw", + "last_name": "Cwiklik", + "institution": "" + }, + { + "first_name": "Edward S.", + "last_name": "Epstein", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/TardieuGBCCE23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591237", + "title": "Loop Rerolling for Hardware Decompilation", + "abstract": "We introduce the new problem of hardware decompilation . Analogous to software decompilation, hardware decompilation is about analyzing a low-level artifact—in this case a netlist , i.e., a graph of wires and logical gates representing a digital circuit—in order to recover higher-level programming abstractions, and using those abstractions to generate code written in a hardware description language (HDL). The overall problem of hardware decompilation requires a number of pieces. In this paper we focus on one specific piece of the puzzle: a technique we call hardware loop rerolling . Hardware loop rerolling leverages clone detection and program synthesis techniques to identify repeated logic in netlists (such as would be synthesized from loops in the original HDL code) and reroll them into syntactic loops in the recovered HDL code. We evaluate hardware loop rerolling for hardware decompilation over a set of hardware design benchmarks written in the PyRTL HDL and industry standard SystemVerilog. Our implementation identifies and rerolls loops in 52 out of 53 of the netlists in our benchmark suite, and we show three examples of how hardware decompilation can provide concrete benefits: transpilation between HDLs, faster simulation times over netlists (with mean speedup of 6x), and artifact compaction (39% smaller on average).", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591237", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zachary D.", + "last_name": "Sisco", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Jonathan", + "last_name": "Balkind", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Timothy", + "last_name": "Sherwood", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Ben", + "last_name": "Hardekopf", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "journals/pacmpl/SiscoBSH23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591250", + "title": "A Type System for Safe Intermittent Computing", + "abstract": "Batteryless energy-harvesting devices enable computing in inaccessible environments, at a cost to programmability and correctness. These devices operate intermittently as energy is available, using a recovery system to save and restore state. Some program tasks must execute atomically w.r.t. power failures, re-executing if power fails before completion. Any re-execution should typically be idempotent —its behavior should match the behavior of a single execution. Thus, a key aspect of correct intermittent execution is identifying and recovering state causing undesired non-idempotence. Unfortunately, past intermittent systems take an ad-hoc approach, using unsound dataflow analyses or conservatively recovering all written state. Moreover, no prior work allows the programmer to directly specify idempotence requirements (including allowable non-idempotence). We present curricle, the first type system approach to safe intermittence, for Rust. Type level reasoning allows programmers to express requirements and retains alias information crucial for sound analyses. Curricle uses information flow and type qualifiers to reject programs causing undesired non-idempotence. We implement Curricle’s type system on top of Rust’s compiler, evaluating the prototype on benchmarks from prior work. We find that Curricle benefits application programmers by allowing them to express idempotence requirements that are checked to be satisfied, and that targeting programs checked with Curricle allows intermittent system designers to write simpler recovery systems that perform better.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591250", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Milijana", + "last_name": "Surbatovich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Naomi", + "last_name": "Spargo", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/SurbatovichS0L23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591238", + "title": "Architecture-Preserving Provable Repair of Deep Neural Networks", + "abstract": "Deep neural networks (DNNs) are becoming increasingly important components of software, and are considered the state-of-the-art solution for a number of problems, such as image recognition. However, DNNs are far from infallible, and incorrect behavior of DNNs can have disastrous real-world consequences. This paper addresses the problem of architecture-preserving V-polytope provable repair of DNNs. A V-polytope defines a convex bounded polytope using its vertex representation. V-polytope provable repair guarantees that the repaired DNN satisfies the given specification on the infinite set of points in the given V-polytope. An architecture-preserving repair only modifies the parameters of the DNN, without modifying its architecture. The repair has the flexibility to modify multiple layers of the DNN, and runs in polynomial time. It supports DNNs with activation functions that have some linear pieces, as well as fully-connected, convolutional, pooling and residual layers. To the best our knowledge, this is the first provable repair approach that has all of these features. We implement our approach in a tool called APRNN. Using MNIST, ImageNet, and ACAS Xu DNNs, we show that it has better efficiency, scalability, and generalization compared to PRDNN and REASSURE, prior provable repair methods that are not architecture preserving.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591238", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhe", + "last_name": "Tao", + "institution": "University of California, Davis" + }, + { + "first_name": "Stephanie", + "last_name": "Nawas", + "institution": "University of California, Davis" + }, + { + "first_name": "Jacqueline", + "last_name": "Mitchell", + "institution": "University of California, Davis" + }, + { + "first_name": "Aditya", + "last_name": "Thakur", + "institution": "University of California, Davis" + } + ], + "dblp_key": "journals/pacmpl/TaoNMT23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591245", + "title": "Verified Density Compilation for a Probabilistic Programming Language", + "abstract": "This paper presents ProbCompCert, a compiler for a subset of the Stan probabilistic programming language (PPL), in which several key compiler passes have been formally verified using the Coq proof assistant. Because of the probabilistic nature of PPLs, bugs in their compilers can be difficult to detect and fix, making verification an interesting possibility. However, proving correctness of PPL compilation requires new techniques because certain transformations performed by compilers for PPLs are quite different from other kinds of languages. This paper describes techniques for verifying such transformations and their application in ProbCompCert. In the course of verifying ProbCompCert, we found an error in the Stan language reference manual related to the semantics and implementation of a key language construct.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591245", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Jean-Baptiste", + "last_name": "Tristan", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/TassarottiT23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591222", + "title": "Modular Control Plane Verification via Temporal Invariants", + "abstract": "Monolithic control plane verification cannot scale to hyperscale network architectures with tens of thousands of nodes, heterogeneous network policies and thousands of network changes a day. Instead, modular verification offers improved scalability, reasoning over diverse behaviors, and robustness following policy updates. We introduce Timepiece, a new modular control plane verification system. While one class of verifiers, starting with Minesweeper, were based on analysis of stable paths, we show that such models, when deployed naïvely for modular verification, are unsound. To rectify the situation, we adopt a routing model based around a logical notion of time and develop a sound, expressive, and scalable verification engine. Our system requires that a user specifies interfaces between module components. We develop methods for defining these interfaces using predicates inspired by temporal logic, and show how to use those interfaces to verify a range of network-wide properties such as reachability or access control. Verifying a prefix-filtering policy using a non-modular verification engine times out on an 80-node fattree network after 2 hours. However, Timepiece verifies a 2,000-node fattree in 2.37 minutes on a 96-core virtual machine. Modular verification of individual routers is embarrassingly parallel and completes in seconds, which allows verification to scale beyond non-modular engines, while still allowing the full power of SMT-based symbolic reasoning.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591222", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Timothy Alberdingk", + "last_name": "Thijm", + "institution": "Princeton University" + }, + { + "first_name": "Ryan", + "last_name": "Beckett", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aarti", + "last_name": "Gupta", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/ThijmBGW23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591291", + "title": "Sound Dynamic Deadlock Prediction in Linear Time", + "abstract": "Deadlocks are one of the most notorious concurrency bugs, and significant research has focused on detecting them efficiently. Dynamic predictive analyses work by observing concurrent executions, and reason about alternative interleavings that can witness concurrency bugs. Such techniques offer scalability and sound bug reports, and have emerged as an effective approach for concurrency bug detection, such as data races. Effective dynamic deadlock prediction, however, has proven a challenging task, as no deadlock predictor currently meets the requirements of soundness, high-precision, and efficiency. In this paper, we first formally establish that this tradeoff is unavoidable, by showing that (a) sound and complete deadlock prediction is intractable, in general, and (b) even the seemingly simpler task of determining the presence of potential deadlocks, which often serve as unsound witnesses for actual predictable deadlocks, is intractable. The main contribution of this work is a new class of predictable deadlocks, called sync(hronization)-preserving deadlocks. Informally, these are deadlocks that can be predicted by reordering the observed execution while preserving the relative order of conflicting critical sections. We present two algorithms for sound deadlock prediction based on this notion. Our first algorithm SPDOffline detects all sync-preserving deadlocks, with running time that is linear per abstract deadlock pattern, a novel notion also introduced in this work. Our second algorithm SPDOnline predicts all sync-preserving deadlocks that involve two threads in a strictly online fashion, runs in overall linear time, and is better suited for a runtime monitoring setting. We implemented both our algorithms and evaluated their ability to perform offline and online deadlock-prediction on a large dataset of standard benchmarks. Our results indicate that our new notion of sync-preserving deadlocks is highly effective, as (i) it can characterize the vast majority of deadlocks and (ii) it can be detected using an online, sound, complete and highly efficient algorithm.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591291", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hünkar Can", + "last_name": "Tunç", + "institution": "Aarhus University" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/Tunc0P023", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591298", + "title": "Synthesizing MILP Constraints for Efficient and Robust Optimization", + "abstract": "While mixed integer linear programming (MILP) solvers are routinely used to solve a wide range of important science and engineering problems, it remains a challenging task for end users to write correct and efficient MILP constraints, especially for problems specified using the inherently non-linear Boolean logic operations. To overcome this challenge, we propose a syntax guided synthesis (SyGuS) method capable of generating high-quality MILP constraints from the specifications expressed using arbitrary combinations of Boolean logic operations. At the center of our method is an extensible domain specification language (DSL) whose expressiveness may be improved by adding new integer variables as decision variables, together with an iterative procedure for synthesizing linear constraints from non-linear Boolean logic operations using these integer variables. To make the synthesis method efficient, we also propose an over-approximation technique for soundly proving the correctness of the synthesized linear constraints, and an under-approximation technique for safely pruning away the incorrect constraints. We have implemented and evaluated the method on a wide range of benchmark specifications from statistics, machine learning, and data science applications. The experimental results show that the method is efficient in handling these benchmarks, and the quality of the synthesized MILP constraints is close to, or higher than, that of manually-written constraints in terms of both compactness and solving time.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591298", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jingbo", + "last_name": "Wang", + "institution": "University of Southern California" + }, + { + "first_name": "Aarti", + "last_name": "Gupta", + "institution": "Princeton University" + }, + { + "first_name": "Chao", + "last_name": "Wang", + "institution": "University of Southern California" + } + ], + "dblp_key": "journals/pacmpl/WangGW23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591251", + "title": "Optimal Reads-From Consistency Checking for C11-Style Memory Models", + "abstract": "Over the years, several memory models have been proposed to capture the subtle concurrency semantics of C/C++. One of the most fundamental problems associated with a memory model M is consistency checking: given an execution X , is X consistent with M ? This problem lies at the heart of numerous applications, including specification testing and litmus tests, stateless model checking, and dynamic analyses. As such, it has been explored extensively and its complexity is well-understood for traditional models like SC and TSO. However, less is known for the numerous model variants of C/C++, for which the problem becomes challenging due to the intricacies of their concurrency primitives. In this work we study the problem of consistency checking for popular variants of the C11 memory model, in particular, the RC 20 model, its release-acquire ( RA ) fragment, the strong and weak variants of RA ( SRA and WRA ), as well as the Relaxed fragment of RC 20. Motivated by applications in testing and model checking, we focus on reads-from consistency checking. The input is an execution X specifying a set of events, their program order and their reads-from relation, and the task is to decide the existence of a modification order on the writes of X that makes X consistent in a memory model. We draw a rich complexity landscape for this problem; our results include (i) nearly-linear-time algorithms for certain variants, which improve over prior results, (ii) fine-grained optimality results, as well as (iii) matching upper and lower bounds (NP-hardness) for other variants. To our knowledge, this is the first work to characterize the complexity of consistency checking for C11 memory models. We have implemented our algorithms inside the TruSt model checker and the C11Tester testing tool. Experiments on standard benchmarks show that our new algorithms improve consistency checking, often by a significant margin.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591251", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hünkar Can", + "last_name": "Tunç", + "institution": "Aarhus University" + }, + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Delft University of Technology" + }, + { + "first_name": "Shankara Narayanan", + "last_name": "Krishna", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/TuncA0K0P23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591299", + "title": "Incremental Verification of Neural Networks", + "abstract": "Complete verification of deep neural networks (DNNs) can exactly determine whether the DNN satisfies a desired trustworthy property (e.g., robustness, fairness) on an infinite set of inputs or not. Despite the tremendous progress to improve the scalability of complete verifiers over the years on individual DNNs, they are inherently inefficient when a deployed DNN is updated to improve its inference speed or accuracy. The inefficiency is because the expensive verifier needs to be run from scratch on the updated DNN. To improve efficiency, we propose a new, general framework for incremental and complete DNN verification based on the design of novel theory, data structure, and algorithms. Our contributions implemented in a tool named IVAN yield an overall geometric mean speedup of 2.4x for verifying challenging MNIST and CIFAR10 classifiers and a geometric mean speedup of 3.8x for the ACAS-XU classifiers over the state-of-the-art baselines.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591299", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shubham", + "last_name": "Ugare", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Debangshu", + "last_name": "Banerjee", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/UgareBM023", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591224", + "title": "WasmRef-Isabelle: A Verified Monadic Interpreter and Industrial Fuzzing Oracle for WebAssembly", + "abstract": "We present WasmRef-Isabelle, a monadic interpreter for WebAssembly written in Isabelle/HOL and proven correct with respect to the WasmCert-Isabelle mechanisation of WebAssembly. WasmRef-Isabelle has been adopted and deployed as a fuzzing oracle in the continuous integration infrastructure of Wasmtime, a widely used WebAssembly implementation. Previous efforts to fuzz Wasmtime against WebAssembly's official OCaml reference interpreter were abandoned by Wasmtime's developers after the reference interpreter exhibited unacceptable performance characteristics, which its maintainers decided not to fix in order to preserve the interpreter's close definitional correspondence with the official specification. With WasmRef-Isabelle, we achieve the best of both worlds - an interpreter fast enough to be useable as a fuzzing oracle that also maintains a close correspondence with the specification through a mechanised proof of correctness. We verify the correctness of WasmRef-Isabelle through a two-step refinement proof in Isabelle/HOL. We demonstrate that WasmRef-Isabelle significantly outperforms the official reference interpreter, has performance comparable to a Rust debug build of the industry WebAssembly interpreter Wasmi, and competes with unverified oracles on fuzzing throughput when deployed in Wasmtime's fuzzing infrastructure. We also present several new extensions to WasmCert-Isabelle which enhance WasmRef-Isabelle's utility as a fuzzing oracle: we add support for a number of upcoming WebAssembly features, and fully mechanise the numeric semantics of WebAssembly's integer operations.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591224", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "University of Cambridge" + }, + { + "first_name": "Maja", + "last_name": "Trela", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Lammich", + "institution": "University of Twente" + }, + { + "first_name": "Florian", + "last_name": "Märkl", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/WattTLM23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591274", + "title": "Search-Based Regular Expression Inference on a GPU", + "abstract": "Regular expression inference (REI) is a supervised machine learning and program synthesis problem that takes a cost metric for regular expressions, and positive and negative examples of strings as input. It outputs a regular expression that is precise (i.e., accepts all positive and rejects all negative examples), and minimal w.r.t. to the cost metric. We present a novel algorithm for REI over arbitrary alphabets that is enumerative and trades off time for space. Our main algorithmic idea is to implement the search space of regular expressions succinctly as a contiguous matrix of bitvectors. Collectively, the bitvectors represent, as characteristic sequences, all sub-languages of the infix-closure of the union of positive and negative examples. Mathematically, this is a semiring of (a variant of) formal power series. Infix-closure enables bottom-up compositional construction of larger from smaller regular expressions using the operations of our semiring. This minimises data movement and data-dependent branching, hence maximises data-parallelism. In addition, the infix-closure remains unchanged during the search, hence search can be staged: first pre-compute various expensive operations, and then run the compute intensive search process. We provide two C++ implementations, one for general purpose CPUs and one for Nvidia GPUs (using CUDA). We benchmark both on Google Colab Pro: the GPU implementation is on average over 1000x faster than the CPU implementation on the hardest benchmarks.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591274", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mojtaba", + "last_name": "Valizadeh", + "institution": "University of Sussex" + }, + { + "first_name": "Martin", + "last_name": "Berger", + "institution": "University of Sussex" + } + ], + "dblp_key": "journals/pacmpl/ValizadehB23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591254", + "title": "Synthesizing Quantum-Circuit Optimizers", + "abstract": "Near-term quantum computers are expected to work in an environment where each operation is noisy, with no error correction. Therefore, quantum-circuit optimizers are applied to minimize the number of noisy operations. Today, physicists are constantly experimenting with novel devices and architectures. For every new physical substrate and for every modification of a quantum computer, we need to modify or rewrite major pieces of the optimizer to run successful experiments. In this paper, we present QUESO, an efficient approach for automatically synthesizing a quantum-circuit optimizer for a given quantum device. For instance, in 1.2 minutes, QUESO can synthesize an optimizer with high-probability correctness guarantees for IBM computers that significantly outperforms leading compilers, such as IBM's Qiskit and TKET, on the majority (85%) of the circuits in a diverse benchmark suite. A number of theoretical and algorithmic insights underlie QUESO: (1) An algebraic approach for representing rewrite rules and their semantics. This facilitates reasoning about complex symbolic rewrite rules that are beyond the scope of existing techniques. (2) A fast approach for probabilistically verifying equivalence of quantum circuits by reducing the problem to a special form of polynomial identity testing . (3) A novel probabilistic data structure, called a polynomial identity filter (PIF), for efficiently synthesizing rewrite rules. (4) A beam-search-based algorithm that efficiently applies the synthesized symbolic rewrite rules to optimize quantum circuits.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591254", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amanda", + "last_name": "Xu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Abtin", + "last_name": "Molavi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Lauren", + "last_name": "Pick", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Swamit", + "last_name": "Tannu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/XuMPTA23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591244", + "title": "Collecting Cyclic Garbage across Foreign Function Interfaces: Who Takes the Last Piece of Cake?", + "abstract": "A growing number of libraries written in managed languages, such as Python and JavaScript, are bringing about new demand for a foreign language interface (FFI) between two managed languages. Such an FFI allows a host-language program to seamlessly call a library function written in a foreign language and exchange objects. It is often implemented by a user-level library but such implementation cannot reclaim cyclic garbage, or a group of objects with circular references, across the language boundary. This paper proposes Refgraph GC , which enables FFI implementation that can reclaim cyclic garbage. Refgraph GC coordinates the garbage collectors of two languages and it needs to modify the managed runtime of one language only. It does not modify that of the other language. This paper discusses the soundness and completeness of the proposed algorithm and also shows the results of the experiments with our implementation of FFI with Refgraph GC. This FFI allows a Ruby program to access a JavaScript library.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591244", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tetsuro", + "last_name": "Yamazaki", + "institution": "The University of Tokyo" + }, + { + "first_name": "Tomoki", + "last_name": "Nakamaru", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryota", + "last_name": "Shioya", + "institution": "The University of Tokyo" + }, + { + "first_name": "Tomoharu", + "last_name": "Ugawa", + "institution": "The University of Tokyo" + }, + { + "first_name": "Shigeru", + "last_name": "Chiba", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "journals/pacmpl/YamazakiNSUC23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591269", + "title": "flap: A Deterministic Parser with Fused Lexing", + "abstract": "Lexers and parsers are typically defined separately and connected by a token stream. This separate definition is important for modularity and reduces the potential for parsing ambiguity. However, materializing tokens as data structures and case-switching on tokens comes with a cost. We show how to fuse separately-defined lexers and parsers, drastically improving performance without compromising modularity or increasing ambiguity. We propose a deterministic variant of Greibach Normal Form that ensures deterministic parsing with a single token of lookahead and makes fusion strikingly simple, and prove that normalizing context free expressions into the deterministic normal form is semantics-preserving. Our staged parser combinator library, flap, provides a standard interface, but generates specialized token-free code that runs two to six times faster than ocamlyacc on a range of benchmarks.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591269", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Toronto" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/YallopXK23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591302", + "title": "Register Tiling for Unstructured Sparsity in Neural Network Inference", + "abstract": "Unstructured sparse neural networks are an important class of machine learning (ML) models, as they compact model size and reduce floating point operations. The execution time of these models is frequently dominated by the sparse matrix multiplication (SpMM) kernel, C = A × B , where A is a sparse matrix, and B and C are dense matrices. The unstructured sparsity pattern of matrices in pruned machine learning models along with their sparsity ratio has rendered useless the large class of libraries and systems that optimize sparse matrix multiplications. Reusing registers is particularly difficult because accesses to memory locations should be known statically. This paper proposes Sparse Register Tiling, a new technique composed of an unroll-and-sparse-jam transformation followed by data compression that is specifically tailored to sparsity patterns in ML matrices. Unroll-and-sparse-jam uses sparsity information to jam the code while improving register reuse. Sparse register tiling is evaluated across 2396 weight matrices from transformer and convolutional models with a sparsity range of 60-95% and provides an average speedup of 1.72× and 2.65× over MKL SpMM and dense matrix multiplication, respectively, on a multicore CPU processor. It also provides an end-to-end speedup of 2.12× for MobileNetV1 with 70% sparsity on an ARM processor commonly used in edge devices.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591302", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "L.R.", + "last_name": "Wilkinson", + "institution": "University of Toronto" + }, + { + "first_name": "Kazem", + "last_name": "Cheshmi", + "institution": "McMaster University" + }, + { + "first_name": "Maryam Mehri", + "last_name": "Dehnavi", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/WilkinsonCD23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591255", + "title": "Trace-Guided Inductive Synthesis of Recursive Functional Programs", + "abstract": "We propose a novel trace-guided approach to tackle the challenges of ambiguity and generalization in synthesis of recursive functional programs from input-output examples. Our approach augments the search space of programs with recursion traces consisting of recursive subcalls of the programs. Our method is based on a new version space algebra (VSA) for succinct representation and efficient manipulation of pairs of recursion traces and programs that are consistent with each other. We have implemented this approach in a tool called SyRup and evaluated it on benchmarks from prior work. Our evaluation demonstrates that SyRup not only requires fewer examples to achieve a certain success rate than existing synthesizers, but is also less sensitive to the quality of the examples.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591255", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yongwei", + "last_name": "Yuan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/YuanRS23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591288", + "title": "Inductive Program Synthesis via Iterative Forward-Backward Abstract Interpretation", + "abstract": "A key challenge in example-based program synthesis is the gigantic search space of programs. To address this challenge, various work proposed to use abstract interpretation to prune the search space. However, most of existing approaches have focused only on forward abstract interpretation, and thus cannot fully exploit the power of abstract interpretation. In this paper, we propose a novel approach to inductive program synthesis via iterative forward-backward abstract interpretation. The forward abstract interpretation computes possible outputs of a program given inputs, while the backward abstract interpretation computes possible inputs of a program given outputs. By iteratively performing the two abstract interpretations in an alternating fashion, we can effectively determine if any completion of each partial program as a candidate can satisfy the input-output examples. We apply our approach to a standard formulation, syntax-guided synthesis (SyGuS), thereby supporting a wide range of inductive synthesis tasks. We have implemented our approach and evaluated it on a set of benchmarks from the prior work. The experimental results show that our approach significantly outperforms the state-of-the-art approaches thanks to the sophisticated abstract interpretation techniques.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591288", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yong-Ho", + "last_name": "Yoon", + "institution": "Seoul National University" + }, + { + "first_name": "Woosuk", + "last_name": "Lee", + "institution": "Hanyang University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/YoonLY23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591261", + "title": "Taype: A Policy-Agnostic Language for Oblivious Computation", + "abstract": "Secure multiparty computation (MPC) allows for joint computation over private data from multiple entities, usually backed by powerful cryptographic techniques that protect sensitive data. Several high-level programming languages have been proposed to make writing MPC applications accessible to non-experts. These languages typically require developers to enforce security policies within the logic of the secure application itself, making it difficult to update security requirements, or to experiment with different policies. This paper presents the design and implementation of Taype, a language that permits security concerns to be decoupled from the program logic. To do so, Taype provides the first implementation of oblivious algebraic data types and tape semantics, two language features recently proposed by a core calculus for oblivious computation, λ OADT + . We evaluate our implementation of Taype on a range of benchmarks, demonstrating its ability to encode a range of security polices for a rich class of data types.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591261", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qianchuan", + "last_name": "Ye", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/YeD23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591301", + "title": "One Pixel Adversarial Attacks via Sketched Programs", + "abstract": "Neural networks are successful in various tasks but are also susceptible to adversarial examples. An adversarial example is generated by adding a small perturbation to a correctly-classified input with the goal of causing a network classifier to misclassify. In one pixel attacks, an attacker aims to fool an image classifier by modifying a single pixel. This setting is challenging for two reasons: the perturbation region is very small and the perturbation is not differentiable. To cope, one pixel attacks iteratively generate candidate adversarial examples and submit them to the network until finding a successful candidate. However, existing works require a very large number of queries, which is infeasible in many practical settings, where the attacker is limited to a few thousand queries to the network. We propose a novel approach for computing one pixel attacks. The key idea is to leverage program synthesis and identify an expressive program sketch that enables to compute adversarial examples using significantly fewer queries. We introduce OPPSLA, a synthesizer that, given a classifier and a training set, instantiates the sketch with customized conditions over the input’s pixels and the classifier’s output. OPPSLA employs a stochastic search, inspired by the Metropolis-Hastings algorithm, that synthesizes typed expressions enabling minimization of the number of queries to the classifier. We further show how to extend OPPSLA to compute few pixel attacks minimizing the number of perturbed pixels. We evaluate OPPSLA on several deep networks for CIFAR-10 and ImageNet. We show that OPPSLA obtains a state-of-the-art success rate, often with an order of magnitude fewer queries than existing attacks. We further show that OPPSLA’s programs are transferable to other classifiers, unlike existing one pixel attacks, which run from scratch on every classifier and input.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591301", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tom", + "last_name": "Yuviler", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Dana", + "last_name": "Drachsler-Cohen", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/YuvilerD23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591276", + "title": "Type-Checking CRDT Convergence", + "abstract": "Conflict-Free Replicated Data Types (CRDTs) are a recent approach for keeping replicated data consistent while guaranteeing the absence of conflicts among replicas. For correct operation, CRDTs rely on a merge function that is commutative, associative and idempotent. Ensuring that such algebraic properties are satisfied by implementations, however, is left to the programmer, resulting in a process that is complex and error-prone. While techniques based on testing, automatic verification of a model, and mechanized or handwritten proofs are available, we lack an approach that is able to verify such properties on concrete CRDT implementations. In this paper, we present Propel, a programming language with a type system that captures the algebraic properties required by a correct CRDT implementation. The Propel type system deduces such properties by case analysis and induction: sum types guide the case analysis and algebraic properties in function types enable induction for free. Propel’s key feature is its capacity to reason about algebraic properties (a) in terms of rewrite rules and (b) to derive the equality or inequality of expressions from the properties. We provide an implementation of Propel as a Scala embedding, we implement several CRDTs, verify them with Propel and compare the verification process with four state-of-the-art verification tools. Our evaluation shows that Propel is able to automatically deduce the properties that are relevant for common CRDT implementations found in open-source libraries even in cases in which competitors timeout.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591276", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "George", + "last_name": "Zakhour", + "institution": "University of St.Gallen" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "University of St.Gallen" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "University of St.Gallen" + } + ], + "dblp_key": "journals/pacmpl/ZakhourWS23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591264", + "title": "Interval Parsing Grammars for File Format Parsing", + "abstract": "File formats specify how data is encoded for persistent storage. They cannot be formalized as context-free grammars since their specifications include context-sensitive patterns such as the random access pattern and the type-length-value pattern. We propose a new grammar mechanism called Interval Parsing Grammars IPGs) for file format specifications. An IPG attaches to every nonterminal/terminal an interval, which specifies the range of input the nonterminal/terminal consumes. By connecting intervals and attributes, the context-sensitive patterns in file formats can be well handled. In this paper, we formalize IPGs' syntax as well as its semantics, and its semantics naturally leads to a parser generator that generates a recursive-descent parser from an IPG. In general, IPGs are declarative, modular, and enable termination checking. We have used IPGs to specify a number of file formats including ZIP, ELF, GIF, PE, and part of PDF; we have also evaluated the performance of the generated parsers.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591264", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jialun", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/ZhangMT23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591235", + "title": "Performal: Formal Verification of Latency Properties for Distributed Systems", + "abstract": "Understanding and debugging the performance of distributed systems is a notoriously hard task, but a critical one. Traditional techniques like logging, tracing, and benchmarking represent a best-effort way to find performance bugs, but they either require a full deployment to be effective or can only find bugs after they manifest. Even with such techniques in place, real deployments often exhibit performance bugs that cause unwanted behavior. In this paper, we present Performal, a novel methodology that leverages the recent advances in formal verification to provide rigorous latency guarantees for real, complex distributed systems. The task is not an easy one: it requires carefully decoupling the formal proofs from the execution environment, formally defining latency properties, and proving them on real, distributed implementations. We used Performal to prove rigorous upper bounds for the latency of three applications: a distributed lock, ZooKeeper and a MultiPaxos-based State Machine Replication system. Our experimental evaluation shows that these bounds are a good proxy for the behavior of the deployed system and can be used to identify performance bugs in real-world systems.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591235", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tony", + "last_name": "Zhang", + "institution": "University of Michigan" + }, + { + "first_name": "Upamanyu", + "last_name": "Sharma", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Manos", + "last_name": "Kapritsos", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/ZhangSK23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591271", + "title": "Covering All the Bases: Type-Based Verification of Test Input Generators", + "abstract": "Test input generators are an important part of property-based testing (PBT) frameworks. Because PBT is intended to test deep semantic and structural properties of a program, the outputs produced by these generators can be complex data structures, constrained to satisfy properties the developer believes is most relevant to testing the function of interest. An important feature expected of these generators is that they be capable of producing all acceptable elements that satisfy the function’s input type and generator-provided constraints. However, it is not readily apparent how we might validate whether a particular generator’s output satisfies this coverage requirement. Typically, developers must rely on manual inspection and post-mortem analysis of test runs to determine if the generator is providing sufficient coverage; these approaches are error-prone and difficult to scale as generators become more complex. To address this important concern, we present a new refinement type-based verification procedure for validating the coverage provided by input test generators, based on a novel interpretation of types that embeds “ must -style” underapproximate reasoning principles as a fundamental part of the type system. The types associated with expressions now capture the set of values guaranteed to be produced by the expression, rather than the typical formulation that uses types to represent the set of values an expression may produce. Beyond formalizing the notion of coverage types in the context of a rich core language with higher-order procedures and inductive datatypes, we also present a detailed evaluation study to justify the utility of our ideas.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591271", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Z.", + "last_name": "Zhou", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Ashish", + "last_name": "Mishra", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/ZhouMDJ23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591239", + "title": "Better Together: Unifying Datalog and Equality Saturation", + "abstract": "We present egglog, a fixpoint reasoning system that unifies Datalog and equality saturation (EqSat). Like Datalog, egglog supports efficient incremental execution, cooperating analyses, and lattice-based reasoning. Like EqSat, egglog supports term rewriting, efficient congruence closure, and extraction of optimized terms. We identify two recent applications -- a unification-based pointer analysis in Datalog and an EqSat-based floating-point term rewriter -- that have been hampered by features missing from Datalog but found in EqSat or vice-versa. We evaluate our system by reimplementing those projects in egglog. The resulting systems in egglog are faster, simpler, and fix bugs found in the original systems.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591239", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yihong", + "last_name": "Zhang", + "institution": "University of Washington" + }, + { + "first_name": "Yisu Remy", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Oliver", + "last_name": "Flatt", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Cao", + "institution": "University of California San Diego" + }, + { + "first_name": "Philip", + "last_name": "Zucker", + "institution": "Draper Laboratory" + }, + { + "first_name": "Eli", + "last_name": "Rosenthal", + "institution": "Google (United States)" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Max", + "last_name": "Willsey", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/ZhangWFCZRTW23", + "venue": "pldi", + "year": 2023 + }, + { + "paper_id": "10.1145/3591225", + "title": "cuCatch: A Debugging Tool for Efficiently Catching Memory Safety Violations in CUDA Applications", + "abstract": "CUDA, OpenCL, and OpenACC are the primary means of writing general-purpose software for NVIDIA GPUs, all of which are subject to the same well-documented memory safety vulnerabilities currently plaguing software written in C and C++. One can argue that the GPU execution environment makes software development more error prone. Unlike C and C++, CUDA features multiple, distinct memory spaces to map to the GPU’s unique memory hierarchy, and a typical CUDA program has thousands of concurrently executing threads. Furthermore, the CUDA platform has fewer guardrails than CPU platforms that have been forced to incrementally adjust to a barrage of security attacks. Unfortunately, the peculiarities of the GPU make it difficult to directly port memory safety solutions from the CPU space. This paper presents cuCatch, a new memory safety error detection tool designed specifically for the CUDA programming model. cuCatch combines optimized compiler instrumentation with driver support to implement a novel algorithm for catching spatial and temporal memory safety errors with low performance overheads. Our experimental results on a wide set of GPU applications show that cuCatch incurs a 19% runtime slowdown on average, which is orders of magnitude faster than state-of-the-art debugging tools on GPUs. Moreover, our quantitative evaluation demonstrates cuCatch’s higher error detection coverage compared to prior memory safety tools. The combination of high error detection coverage and low runtime overheads makes cuCatch an ideal candidate for accelerating memory safety debugging for GPU applications.", + "date": "2023-06-06", + "link": "https://doi.org/10.1145/3591225", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mohamed Tarek Ibn", + "last_name": "Ziad", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Sana", + "last_name": "Damani", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Aamer", + "last_name": "Jaleel", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Stephen W.", + "last_name": "Keckler", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Mark W.", + "last_name": "Stephenson", + "institution": "Nvidia (United States)" + } + ], + "dblp_key": "journals/pacmpl/ZiadDJKS23", + "venue": "pldi", + "year": 2023 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2024.json b/data/pl_conferences/pldi/2024.json new file mode 100644 index 0000000..eeb9c0c --- /dev/null +++ b/data/pl_conferences/pldi/2024.json @@ -0,0 +1,3009 @@ +[ + { + "paper_id": "10.1145/3656425", + "title": "Verification under Intel-x86 with Persistency", + "abstract": "The full semantics of the Intel-x86 architecture has been defined by Raad et al in POPL 2022, extending the earlier formalization based on the TSO memory model incorporating persistency. This new semantics involves an intricate combination of the SC, TSO, and PSO models to account for the diverse features of the enlarged instruction set. In this paper we investigate the reachability problem under this semantics, including both its consistency and persistency aspects each of which requires reasoning about unbounded operation reorderings. Our first contribution is to show that reachability under this model can be reduced to reachability under a model without the persistency component. This is achieved by showing that the persistency semantics can be simulated by a finite-state protocol running in parallel with the program. Our second contribution is to prove that reachability under the consistency model of Intel-x86 (even without crashes and persistency) is undecidable. Undecidability is obtained as soon as one thread in the program is allowed to use both TSO variables and two PSO variables. The third contribution is showing that for any fixed bound on the alternation between TSO writes (write-backs), and PSO writes (non-temporal writes), the reachability problem is decidable. This defines a complete parametrized schema for under-approximate analysis that can be used for bug finding.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656425", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Université Paris Cité" + }, + { + "first_name": "K. Narayan", + "last_name": "Kumar", + "institution": "Chennai Mathematical Institute" + }, + { + "first_name": "Prakash", + "last_name": "Saivasan", + "institution": "Institute of Mathematical Sciences" + } + ], + "dblp_key": "journals/pacmpl/AbdullaABKS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656377", + "title": "Input-Relational Verification of Deep Neural Networks", + "abstract": "We consider the verification of input-relational properties defined over deep neural networks (DNNs) such as robustness against universal adversarial perturbations, monotonicity, etc. Precise verification of these properties requires reasoning about multiple executions of the same DNN. We introduce a novel concept of difference tracking to compute the difference between the outputs of two executions of the same DNN at all layers. We design a new abstract domain, DiffPoly for efficient difference tracking that can scale large DNNs. DiffPoly is equipped with custom abstract transformers for common activation functions (ReLU, Tanh, Sigmoid, etc.) and affine layers and can create precise linear cross-execution constraints. We implement an input-relational verifier for DNNs called RaVeN which uses DiffPoly and linear program formulations to handle a wide range of input-relational properties. Our experimental results on challenging benchmarks show that by leveraging precise linear constraints defined over multiple executions of the DNN, RaVeN gains substantial precision over baselines on a wide range of datasets, networks, and input-relational properties.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656377", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Debangshu", + "last_name": "Banerjee", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Changming", + "last_name": "Xu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/BanerjeeXS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656435", + "title": "SuperStack: Superoptimization of Stack-Bytecode via Greedy, Constraint-Based, and SAT Techniques", + "abstract": "Given a loop-free sequence of instructions, superoptimization techniques use a constraint solver to search for an equivalent sequence that is optimal for a desired objective. The complexity of the search grows exponentially with the length of the solution being constructed and the problem becomes intractable for large sequences of instructions. This paper presents a new approach to superoptimizing stack-bytecode via three novel components: (1) a greedy algorithm to refine the bound on the length of the optimal solution; (2) a new representation of the optimization problem as a set of weighted soft clauses in MaxSAT; (3) a series of domain-specific dominance and redundant constraints to reduce the search space for optimal solutions. We have developed a tool, named S uper S tack , which can be used to find optimal code translations of modern stack-based bytecode, namely WebAssembly or Ethereum bytecode. Experimental evaluation on more than 500,000 sequences shows the proposed greedy, constraint-based and SAT combination is able to greatly increase optimization gains achieved by existing superoptimizers and reduce to at least a fourth the optimization time.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656435", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Elvira", + "last_name": "Albert", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "María García de la", + "last_name": "Banda", + "institution": "Monash University" + }, + { + "first_name": "Alejandro", + "last_name": "Hernández-Cerezo", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Alexey", + "last_name": "Ignatiev", + "institution": "Monash University" + }, + { + "first_name": "Albert", + "last_name": "Rubio", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Peter J.", + "last_name": "Stuckey", + "institution": "Monash University" + } + ], + "dblp_key": "journals/pacmpl/AlbertBHIRS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656463", + "title": "Probabilistic Programming with Programmable Variational Inference", + "abstract": "Compared to the wide array of advanced Monte Carlo methods supported by modern probabilistic programming languages (PPLs), PPL support for variational inference (VI) is less developed: users are typically limited to a predefined selection of variational objectives and gradient estimators, which are implemented monolithically (and without formal correctness arguments) in PPL backends. In this paper, we propose a more modular approach to supporting variational inference in PPLs, based on compositional program transformation. In our approach, variational objectives are expressed as programs, that may employ first-class constructs for computing densities of and expected values under user-defined models and variational families. We then transform these programs systematically into unbiased gradient estimators for optimizing the objectives they define. Our design enables modular reasoning about many interacting concerns, including automatic differentiation, density accumulation, tracing, and the application of unbiased gradient estimation strategies. Additionally, relative to existing support for VI in PPLs, our design increases expressiveness along three axes: (1) it supports an open-ended set of user-defined variational objectives, rather than a fixed menu of options; (2) it supports a combinatorial space of gradient estimation strategies, many not automated by today’s PPLs; and (3) it supports a broader class of models and variational families, because it supports constructs for approximate marginalization and normalization (previously introduced only for Monte Carlo inference). We implement our approach in an extension to the Gen probabilistic programming system (genjax.vi, implemented inJAX), and evaluate our automation on several deep generative modeling tasks, showing minimal performance overhead vs. hand-coded implementations and performance competitive with well-established open-source PPLs.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656463", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "McCoy", + "last_name": "Becker", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Xiaoyan", + "last_name": "Wang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Matin", + "last_name": "Ghavami", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Mathieu", + "last_name": "Huot", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BeckerLWGHRM24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656421", + "title": "Decidable Subtyping of Existential Types for Julia", + "abstract": "Julia is a modern scientific-computing language that relies on multiple dispatch to implement generic libraries. While the language does not have a static type system, method declarations are decorated with expressive type annotations to determine when they are applicable. To find applicable methods, the implementation uses subtyping at run-time. We show that Julia’s subtyping is undecidable, and we propose a restriction on types to recover decidability by stratifying types into method signatures over value types—where the former can freely use bounded existential types but the latter are restricted to use-site variance. A corpus analysis suggests that nearly all Julia programs written in practice already conform to this restriction.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656421", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Julia", + "last_name": "Belyakova", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Chung", + "institution": "Boston University" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Ithaka Harbors" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Boston University" + } + ], + "dblp_key": "journals/pacmpl/BelyakovaCTV24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656431", + "title": "Linear Matching of JavaScript Regular Expressions", + "abstract": "Modern regex languages have strayed far from well-understood traditional regular expressions: they include features that fundamentally transform the matching problem. In exchange for these features, modern regex engines at times suffer from exponential complexity blowups, a frequent source of denial-of-service vulnerabilities in JavaScript applications. Worse, regex semantics differ across languages, and the impact of these divergences on algorithmic design and worst-case matching complexity has seldom been investigated. This paper provides a novel perspective on JavaScript’s regex semantics by identifying a larger-than-previously-understood subset of the language that can be matched with linear time guarantees. In the process, we discover several cases where state-of-the-art algorithms were either wrong (semantically incorrect), inefficient (suffering from superlinear complexity) or excessively restrictive (assuming certain features could not be matched linearly). We introduce novel algorithms to restore correctness and linear complexity. We further advance the state-of-the-art in linear regex matching by presenting the first nonbacktracking algorithms for matching lookarounds in linear time: one supporting captureless lookbehinds in any regex language, and another leveraging a JavaScript property to support unrestricted lookaheads and lookbehinds. Finally, we describe new time and space complexity tradeoffs for regex engines. All of our algorithms are practical: we validated them in a prototype implementation, and some have also been merged in the V8 JavaScript implementation used in Chrome and Node.js.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656431", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aurèle", + "last_name": "Barrière", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/BarriereP24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656405", + "title": "Jacdac: Service-Based Prototyping of Embedded Systems", + "abstract": "The traditional approach to programming embedded systems is monolithic: firmware on a microcontroller contains both application code and the drivers needed to communicate with sensors and actuators, using low-level protocols such as I2C, SPI, and RS232. In comparison, software development for the cloud has moved to a service-based development and operation paradigm: a service provides a discrete unit of functionality that can be accessed remotely by an application, or other service, but is independently managed and updated. We propose, design, implement, and evaluate a service-based approach to prototyping embedded systems called Jacdac. Jacdac defines a service specification language, designed especially for embedded systems, along with a host of specifications for a variety of sensors and actuators. With Jacdac, each sensor/actuator in a system is paired with a low-cost microcontroller that advertises the services that represent the functionality of the underlying hardware over an efficient and low-cost single-wire bus protocol. A separate microcontroller executes the user's application program, which is a client of the Jacdac services on the bus. Our evaluation shows that Jacdac supports a service-based abstraction for sensors/actuators at low cost and reasonable performance, with many benefits for prototyping: ease of use via the automated discovery of devices and their capabilities, substitution of same-service devices for each other, as well as high-level programming, monitoring, and debugging. We also report on the experience of bringing Jacdac to commercial availability via third-party manufacturers.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656405", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thomas S.", + "last_name": "Ball", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Peli de", + "last_name": "Halleux", + "institution": "Microsoft (United States)" + }, + { + "first_name": "James", + "last_name": "Devine", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Steve", + "last_name": "Hodges", + "institution": "Lancaster University" + }, + { + "first_name": "Michał", + "last_name": "Moskal", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/BallHDHM24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656447", + "title": "Reward-Guided Synthesis of Intelligent Agents with Control Structures", + "abstract": "Deep reinforcement learning (RL) has led to encouraging successes in numerous challenging robotics applications. However, the lack of inductive biases to support logic deduction and generalization in the representation of a deep RL model causes it less effective in exploring complex long-horizon robot-control tasks with sparse reward signals. Existing program synthesis algorithms for RL problems inherit the same limitation, as they either adapt conventional RL algorithms to guide program search or synthesize robot-control programs to imitate an RL model. We propose ReGuS, a reward-guided synthesis paradigm, to unlock the potential of program synthesis to overcome the exploration challenges. We develop a novel hierarchical synthesis algorithm with decomposed search space for loops, on-demand synthesis of conditional statements, and curriculum synthesis for procedure calls, to effectively compress the exploration space for long-horizon, multi-stage, and procedural robot-control tasks that are difficult to address by conventional RL techniques. Experiment results demonstrate that ReGuS significantly outperforms state-of-the-art RL algorithms and standard program synthesis baselines on challenging robot tasks including autonomous driving, locomotion control, and object manipulation. CCS Concepts: • Software and its engineering → Automatic programming.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656447", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guofeng", + "last_name": "Cui", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Yuning", + "last_name": "Wang", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Wenjie", + "last_name": "Qiu", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "He", + "last_name": "Zhu", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "journals/pacmpl/CuiWQZ24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656430", + "title": "An Algebraic Language for Specifying Quantum Networks", + "abstract": "Quantum networks connect quantum capable nodes in order to achieve capabilities that are impossible only using classical information. Their fundamental unit of communication is the Bell pair , which consists of two entangled quantum bits. Unfortunately, Bell pairs are fragile and difficult to transmit directly, necessitating a network of repeaters, along with software and hardware that can ensure the desired results. Challenging intrinsic features of quantum networks, such as dealing with resource competition, motivate formal reasoning about quantum network protocols. To this end, we developed BellKAT, a novel specification language for quantum networks based upon Kleene algebra. To cater to the specific needs of quantum networks, we designed an algebraic structure, called BellSKA, which we use as the basis of BellKAT’s denotational semantics. BellKAT’s constructs describe entanglement distribution rules that allow for modular specification. We give BellKAT a sound and complete equational theory, allowing us to verify network protocols. We provide a prototype tool to showcase the expressiveness of BellKAT and how to optimize and verify networks in practice.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656430", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anita", + "last_name": "Buckley", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Pavel", + "last_name": "Chuprikov", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Rodrigo", + "last_name": "Otoni", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Robert", + "last_name": "Soulé", + "institution": "Yale University" + }, + { + "first_name": "Robert W.", + "last_name": "Rand", + "institution": "University of Chicago" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "journals/pacmpl/BuckleyCOSRE24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656442", + "title": "Quest Complete: The Holy Grail of Gradual Security", + "abstract": "Languages with gradual information-flow control combine static and dynamic techniques to prevent security leaks. Gradual languages should satisfy the gradual guarantee: programs that only differ in the precision of their type annotations should behave the same modulo cast errors. Unfortunately, Toro et al. [ 2018 ] identify a tension between the gradual guarantee and information security; they were unable to satisfy both properties in the language GSL Ref and had to settle for only satisfying information-flow security. Azevedo de Amorim et al. [ 2020 ] show that by sacrificing type-guided classification, one obtains a language that satisfies both noninterference and the gradual guarantee. Bichhawat et al. [ 2021 ] show that both properties can be satisfied by sacrificing the no-sensitive-upgrade mechanism, replacing it with a static analysis. In this paper we present a language design, λ IFC ★ , that satisfies both noninterference and the gradual guarantee without making any sacrifices. We keep the type-guided classification of GSL Ref and use the standard no-sensitive-upgrade mechanism to prevent implicit flows through mutable references. The key to the design of λ IFC ★ is to walk back the decision in GSL Ref to include the unknown label ★ among the runtime security labels. We give a formal definition of λ IFC ★ , prove the gradual guarantee, and prove noninterference. Of technical note, the semantics of λ IFC ★ is the first gradual information-flow control language to be specified using coercion calculi (a la Henglein), thereby expanding the coercion-based theory of gradual typing.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656442", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tianyu", + "last_name": "Chen", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "journals/pacmpl/ChenS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656389", + "title": "Optimistic Stack Allocation and Dynamic Heapification for Managed Runtimes", + "abstract": "The runtimes of managed object-oriented languages such as Java allocate objects on the heap, and rely on automatic garbage collection (GC) techniques for freeing up unused objects. Most such runtimes also consist of just-in-time (JIT) compilers that optimize memory access and GC times by employing escape analysis: an object that does not escape (outlive) its allocating method can be allocated on (and freed up with) the stack frame of the corresponding method. However, in order to minimize the time spent in JIT compilation, the scope of such useful analyses is quite limited, thereby restricting their precision significantly. On the contrary, even though it is feasible to perform precise program analyses statically, it is not possible to use their results in a managed runtime without a closed-world assumption. In this paper, we propose a static+dynamic scheme that allows one to harness the results of a precise static escape analysis for allocating objects on stack, while taking care of both soundness and efficiency concerns in the runtime. Our scheme comprises of three key ideas. First, using the results of a statically performed escape analysis, it performs optimistic stack allocation during JIT compilation. Second, it handles the challenges associated with features that may invalidate the optimism, using a novel idea of dynamic heapification. Third, it uses another novel notion of stack ordering, again supported by a static analysis, to reduce the overheads associated with the checks that determine the need for heapification. The static and the runtime components of our approach are implemented in the Soot optimization framework and in the tiered infrastructure of the Eclipse OpenJ9 VM, respectively. To evaluate the benefits, we compare our scheme with the existing escape analysis and find that it succeeds in allocating a much larger number of objects on the stack. Furthermore, the enhanced stack allocation leads to a significant reduction in the number of GC cycles and brings decent performance improvements, especially suited for constrained-memory environments.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656389", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aditya", + "last_name": "Anand", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "S S S N V", + "last_name": "Adithya", + "institution": "Indian Institute of Technology Mandi" + }, + { + "first_name": "Swapnil", + "last_name": "Rustagi", + "institution": "Indian Institute of Technology Mandi" + }, + { + "first_name": "Priyam", + "last_name": "Seth", + "institution": "Indian Institute of Technology Mandi" + }, + { + "first_name": "Vijay", + "last_name": "Sundaresan", + "institution": "IBM (Canada)" + }, + { + "first_name": "Daryl", + "last_name": "Maier", + "institution": "IBM (Canada)" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Manas", + "last_name": "Thakur", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "journals/pacmpl/AnandARSSMNT24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656396", + "title": "NetBlocks: Staging Layouts for High-Performance Custom Host Network Stacks", + "abstract": "Modern network applications and environments, ranging from data centers and IoT devices to AR/VR headsets and underwater robotics, present diverse requirements that cannot be satisfied by the all-or-nothing approach of TCP and UDP protocols. Network researchers and engineers need to create highly tailored protocols targeting individual problem domains. Existing library-based approaches either fall short on the flexibility in features or offer them at a significant performance overhead. To address this challenge, we present NetBlocks, a domain-specific language, and compiler for designing ad-hoc protocols and generating their highly optimized host network stack implementations. NetBlocks DSL input allows users to configure protocols by selecting and customizing features. Unlike other DSL compilers, NetBlocks also allows network researchers to extend the system and add more features easily without any prior compiler knowledge. Our design and implementation employ a high-performance Aspect-Oriented Programming framework written with the staging framework BuildIt. We also introduce a novel Layout Customization Layer that allows \"staging packet layouts\" alongside the implementation, which is critical for getting the best performance out of the protocol when possible, while allowing the practitioners to maintain compatibility with existing protocol layers where needed. Our evaluations on three applications ranging across deployments in data centers and underwater acoustic networks demonstrate a trade-off between performance (both latency and throughput) and selected features allowing the user to only pay-for-what-they-use.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656396", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ajay", + "last_name": "Brahmakshatriya", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Chris", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Manya", + "last_name": "Ghobadi", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BrahmakshatriyaRGA24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656462", + "title": "Equivalence and Similarity Refutation for Probabilistic Programs", + "abstract": "We consider the problems of statically refuting equivalence and similarity of output distributions defined by a pair of probabilistic programs. Equivalence and similarity are two fundamental relational properties of probabilistic programs that are essential for their correctness both in implementation and in compilation. In this work, we present a new method for static equivalence and similarity refutation. Our method refutes equivalence and similarity by computing a function over program outputs whose expected value with respect to the output distributions of two programs is different. The function is computed simultaneously with an upper expectation supermartingale and a lower expectation submartingale for the two programs, which we show to together provide a formal certificate for refuting equivalence and similarity. To the best of our knowledge, our method is the first approach to relational program analysis to offer the combination of the following desirable features: (1) it is fully automated, (2) it is applicable to infinite-state probabilistic programs, and (3) it provides formal guarantees on the correctness of its results. We implement a prototype of our method and our experiments demonstrate the effectiveness of our method to refute equivalence and similarity for a number of examples collected from the literature. CCS Concepts: • Theory of computation → Program verification; Program analysis; • Software and its engineering → Formal software verification; • Mathematics of computing → Probability and statistics .", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656462", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Ehsan Kafshdar", + "last_name": "Goharshady", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Petr", + "last_name": "Novotný", + "institution": "Masaryk University" + }, + { + "first_name": "Đorđe", + "last_name": "Žikelić", + "institution": "Singapore Management University" + } + ], + "dblp_key": "journals/pacmpl/ChatterjeeGNZ24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656427", + "title": "Maximum Consensus Floating Point Solutions for Infeasible Low-Dimensional Linear Programs with Convex Hull as the Intermediate Representation", + "abstract": "This paper proposes a novel method to efficiently solve infeasible low-dimensional linear programs (LDLPs) with billions of constraints and a small number of unknown variables, where all the constraints cannot be satisfied simultaneously. We focus on infeasible linear programs generated in the RL ibm project for creating correctly rounded math libraries. Specifically, we are interested in generating a floating point solution that satisfies the maximum number of constraints. None of the existing methods can solve such large linear programs while producing floating point solutions. We observe that the convex hull can serve as an intermediate representation (IR) for solving infeasible LDLPs using the geometric duality between linear programs and convex hulls. Specifically, some of the constraints that correspond to points on the convex hull are precisely those constraints that make the linear program infeasible. Our key idea is to split the entire set of constraints into two subsets using the convex hull IR: (a) a set X of feasible constraints and (b) a superset V of infeasible constraints. Using the special structure of the RL ibm constraints and the presence of a method to check whether a system is feasible or not. we identify a superset of infeasible constraints by computing the convex hull in 2-dimensions. Subsequently, we identify the key constraints (i.e., basis constraints) in the set of feasible constraints X and use them to create a new linear program whose solution identifies the maximum set of constraints satisfiable in V while satisfying all the constraints in X . This new solver enabled us to improve the performance of the resulting RL ibm polynomials while solving the corresponding linear programs significantly faster.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656427", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mridul", + "last_name": "Aanjaneya", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "journals/pacmpl/AanjaneyaN24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656401", + "title": "Allo: A Programming Model for Composable Accelerator Design", + "abstract": "Special-purpose hardware accelerators are increasingly pivotal for sustaining performance improvements in emerging applications, especially as the benefits of technology scaling continue to diminish. However, designers currently lack effective tools and methodologies to construct complex, high-performance accelerator architectures in a productive manner. Existing high-level synthesis (HLS) tools often require intrusive sourcelevel changes to attain satisfactory quality of results. Despite the introduction of several new accelerator design languages (ADLs) aiming to enhance or replace HLS, their advantages are more evident in relatively simple applications with a single kernel. Existing ADLs prove less effective for realistic hierarchical designs with multiple kernels, even if the design hierarchy is flattened. In this paper, we introduce Allo, a composable programming model for efficient spatial accelerator design. Allo decouples hardware customizations, including compute, memory, communication, and data type from algorithm specification, and encapsulates them as a set of customization primitives. Allo preserves the hierarchical structure of an input program by combining customizations from different functions in a bottomup, type-safe manner. This approach facilitates holistic optimizations that span across function boundaries. We conduct comprehensive experiments on commonly-used HLS benchmarks and several realistic deep learning models. Our evaluation shows that Allo can outperform state-of-the-art HLS tools and ADLs on all test cases in the PolyBench. For the GPT2 model, the inference latency of the Allo generated accelerator is 1.7× faster than the NVIDIA A100 GPU with 5.4× higher energy efficiency, demonstrating the capability of Allo to handle large-scale designs.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656401", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hongzheng", + "last_name": "Chen", + "institution": "Cornell University" + }, + { + "first_name": "Niansong", + "last_name": "Zhang", + "institution": "Cornell University" + }, + { + "first_name": "Shaojie", + "last_name": "Xiang", + "institution": "Cornell University" + }, + { + "first_name": "Zhichen", + "last_name": "Zeng", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Mengjia", + "last_name": "Dai", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Zhiru", + "last_name": "Zhang", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/ChenZXZDZ24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656459", + "title": "Hashing Modulo Context-Sensitive 𝛼-Equivalence", + "abstract": "The notion of 𝛼-equivalence between 𝜆-terms is commonly used to identify terms that are considered equal. However, due to the primitive treatment of free variables, this notion falls short when comparing subterms occurring within a larger context. Depending on the usage of the Barendregt convention (choosing different variable names for all involved binders), it will equate either too few or too many subterms. We introduce a formal notion of context-sensitive 𝛼-equivalence, where two open terms can be compared within a context that resolves their free variables. We show that this equivalence coincides exactly with the notion of bisimulation equivalence. Furthermore, we present an efficient O ( n log n ) runtime hashing scheme that identifies 𝜆-terms modulo context-sensitive 𝛼 -equivalence, generalizing over traditional bisimulation partitioning algorithms and improving upon a previously established O ( n log 2 n ) bound for a hashing modulo ordinary 𝛼-equivalence byMaziarz et al [ 21 ]. Hashing 𝜆-terms is useful in many applications that require common subterm elimination and structure sharing. We hav employed the algorithm to obtain a large-scale, densely packed, interconnected graph of mathematical knowledge from the Coq proof assistant for machine learning purposes.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656459", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lasse", + "last_name": "Blaauwbroek", + "institution": "Institut des Hautes Études Scientifiques" + }, + { + "first_name": "Miroslav", + "last_name": "Olšák", + "institution": "Institut des Hautes Études Scientifiques" + }, + { + "first_name": "Herman", + "last_name": "Geuvers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/BlaauwbroekOG24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656439", + "title": "Live Verification in an Interactive Proof Assistant", + "abstract": "We present a prototype for a tool that enables programmers to verify their code as they write it in real-time. After each line of code that the programmer writes, the tool tells the programmer whether it was able to prove absence of undefined behavior so far, and it displays a concise representation of the symbolic state of the program right after the added line. The user can then either write the next line of code, or if needed or desired, write a specially marked comment that provides hints on how to solve side conditions or on how to represent the symbolic state more nicely. Once the programmer has finished writing the program, it is already verified with a mathematical correctness proof. Other tools providing real-time feedback already exist, but ours is the first one that only relies on a small trusted proof checker and that provides a concise summary of the symbolic state at the point in the program currently being edited, as opposed to only indicating whether user-stated assertions or postconditions hold. Program verification requires loop invariants, which are hard to find and tedious to spell out. We explore a middle ground in the design space between the two extremes of requiring users to spell out loop invariants manually and attempting to infer loop invariants automatically: Since a loop invariant often looks quite similar to the symbolic state right before the loop, our tool asks the user to express the desired loop invariant as a diff from the symbolic state before the loop, which has the potential to lead to shorter, more maintainable proofs. We prototyped our technique in the interactive proof assistant Coq, so our framework creates machine-checked proofs that the developed functions satisfy their specifications when executed according to the formal semantics of the source language. Using a verified compiler proven against the same source-language semantics, we can ensure that the behavior of the compiled program matches the program’s behavior as represented by the framework during the proof. Additionally, since our polyglot source files can be viewed as Coq or C files at the same time, users willing to accept a larger trusted code base can compile them with GCC.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656439", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Samuel", + "last_name": "Gruetter", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Viktor", + "last_name": "Fukala", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/GruetterFC24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656410", + "title": "Daedalus: Safer Document Parsing", + "abstract": "Despite decades of contributions to the theoretical foundations of parsing and the many tools available to aid in parser development, many security attacks in the wild still exploit parsers. The issues are myriad—flaws in memory management in contexts lacking memory safety, flaws in syntactic or semantic validation of input, and misinterpretation of hundred-page-plus standards documents. It remains challenging to build and maintain parsers for common, mature data formats. In response to these challenges, we present Daedalus, a new domain-specific language (DSL) and toolchain for writing safe parsers. Daedalus is built around functional-style parser combinators, which suit the rich data dependencies often found in complex data formats. It adds domain-specific constructs for stream manipulation, allowing the natural expression of parsing noncontiguous formats. Balancing between expressivity and domain-specific constructs lends Daedalus specifications simplicity and leaves them amenable to analysis. As a stand-alone DSL, Daedalus is able to generate safe parsers in multiple languages, currently C++ and Haskell. We have implemented 20 data formats with Daedalus, including two large, complex formats—PDF and NITF–and our evaluation shows that Daedalus parsers are concise and performant. Our experience with PDF forms our largest case study. We worked with the PDF Association to build a reference implementation, which was subject to a red-teaming exercise along with a number of other PDF parsers and was the only parser to be found free of defects.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656410", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Iavor S.", + "last_name": "Diatchki", + "institution": "Galois (United States)" + }, + { + "first_name": "Mike", + "last_name": "Dodds", + "institution": "Galois (United States)" + }, + { + "first_name": "Harrison", + "last_name": "Goldstein", + "institution": "University of Portland" + }, + { + "first_name": "Bill", + "last_name": "Harris", + "institution": "Galois (United States)" + }, + { + "first_name": "David A.", + "last_name": "Holland", + "institution": "Galois (United States)" + }, + { + "first_name": "Benoît", + "last_name": "Razet", + "institution": "Galois (United States)" + }, + { + "first_name": "Cole", + "last_name": "Schlesinger", + "institution": "Galois (United States)" + }, + { + "first_name": "Simon", + "last_name": "Winwood", + "institution": "Galois (United States)" + } + ], + "dblp_key": "journals/pacmpl/DiatchkiDGHHRSW24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656434", + "title": "Stream Types", + "abstract": "We propose a rich foundational theory of typed data streams and stream transformers, motivated by two high-level goals. First, the type of a stream should be able to express complex sequential patterns of events over time. And second, it should describe the internal parallel structure of the stream, to support deterministic stream processing on parallel and distributed systems. To these ends, we introduce stream types , with operators capturing sequential composition, parallel composition, and iteration, plus a core calculus λ ST of transformers over typed streams that naturally supports a number of common streaming idioms, including punctuation, windowing, and parallel partitioning, as first-class constructions. λ ST exploits a Curry-Howardlike correspondence with an ordered variant of the Logic of Bunched Implication to program with streams compositionally and uses Brzozowski-style derivatives to enable an incremental, prefix-based operational semantics. To illustrate the programming style supported by the rich types of λ ST , we present a number of examples written in Delta, a prototype high-level language design based on λ ST .", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656434", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joseph W.", + "last_name": "Cutler", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Christopher", + "last_name": "Watson", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Emeka", + "last_name": "Nkurumeh", + "institution": "California Institute of Technology" + }, + { + "first_name": "Phillip", + "last_name": "Hilliard", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Harrison", + "last_name": "Goldstein", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Caleb", + "last_name": "Stanford", + "institution": "University of California, Davis" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/CutlerWNHGSP24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656379", + "title": "Verified Extraction from Coq to OCaml", + "abstract": "One of the central claims of fame of the C oq proof assistant is extraction, i.e., the ability to obtain efficient programs in industrial programming languages such as OC aml , Haskell, or Scheme from programs written in Coq’s expressive dependent type theory. Extraction is of great practical usefulness, used crucially e.g. , in the CompCert project. However, for such executables obtained by extraction, the extraction process is part of the trusted code base (TCB), as are Coq’s kernel and the compiler used to compile the extracted code. The extraction process contains intricate semantic transformation of programs that rely on subtle operational features of both the source and target language. Its code has also evolved since the last theoretical exposition in the seminal PhD thesis of Pierre Letouzey. Furthermore, while the exact correctness statements for the execution of extracted code are described clearly in academic literature, the interoperability with unverified code has never been investigated formally, and yet is used in virtually every project relying on extraction. In this paper, we describe the development of a novel extraction pipeline from C oq to OC aml , implemented and verified in C oq itself, with a clear correctness theorem and guarantees for safe interoperability. We build our work on the M eta Coq project, which aims at decreasing the TCB of Coq’s kernel by re-implementing it in C oq itself and proving it correct w.r.t. a formal specification of Coq’s type theory in Coq. Since OC aml does not have a formal specification, we make use of the M alfunction project specifying the semantics of the intermediate language of the OC aml compiler. Our work fills some gaps in the literature and highlights important differences between the operational semantics of C oq programs and their extraction. In particular, we focus on the guarantees that can be provided for interoperability with unverified code, and prove that extracted programs of first-order data type are correct and can safely interoperate, whereas for higher-order programs already simple interoperations can lead to incorrect behaviour and even outright segfaults. CCS Concepts: • Software and its engineering → Compilers; Functional languages; Formal software verification; • Theory of computation → Type theory.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656379", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yannick", + "last_name": "Forster", + "institution": "Centre Inria de l'Université de Rennes" + }, + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Centre Inria de l'Université de Rennes" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Centre Inria de l'Université de Rennes" + } + ], + "dblp_key": "journals/pacmpl/ForsterST24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656381", + "title": "Recursive Program Synthesis using Paramorphisms", + "abstract": "We show that synthesizing recursive functional programs using a class of primitive recursive combinators is both simpler and solves more benchmarks from the literature than previously proposed approaches. Our method synthesizes paramorphisms, a class of programs that includes the most common recursive programming patterns on algebraic data types. The crux of our approach is to split the synthesis problem into two parts: a multi-hole template that fixes the recursive structure, and a search for non-recursive program fragments to fill the template holes.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656381", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qiantan", + "last_name": "Hong", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/HongA24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656437", + "title": "Hyper Hoare Logic: (Dis-)Proving Program Hyperproperties", + "abstract": "Hoare logics are proof systems that allowone to formally establish properties of computer programs. Traditional Hoare logics prove properties of individual program executions (such as functional correctness). Hoare logic has been generalized to prove also properties of multiple executions of a program (so-called hyperproperties, such as determinism or non-interference). These program logics prove the absence of (bad combinations of) executions. On the other hand, program logics similar to Hoare logic have been proposed to disprove program properties (e.g., Incorrectness Logic), by proving the existence of (bad combinations of) executions. All of these logics have in common that they specify program properties using assertions over a fixed number of states, for instance, a single pre- and post-state for functional properties or pairs of pre- and post-states for non-interference. In this paper, we present Hyper Hoare Logic, a generalization of Hoare logic that lifts assertions to properties of arbitrary sets of states. The resulting logic is simple yet expressive: its judgments can express arbitrary program hyperproperties , a particular class of hyperproperties over the set of terminating executions of a program (including properties of individual program executions). By allowing assertions to reason about sets of states, Hyper Hoare Logic can reason about both the absence and the existence of (combinations of) executions, and, thereby, supports both proving and disproving program (hyper-)properties within the same logic, including (hyper-)properties that no existing Hoare logic can express. We prove that Hyper Hoare Logic is sound and complete, and demonstrate that it captures important proof principles naturally. All our technical results have been proved in Isabelle/HOL.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656437", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Thibault", + "last_name": "Dardinier", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/DardinierM24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656419", + "title": "Symbolic Execution for Quantum Error Correction Programs", + "abstract": "We define QSE, a symbolic execution framework for quantum programs by integrating symbolic variables into quantum states and the outcomes of quantum measurements. The soundness of QSE is established through a theorem that ensures the correctness of symbolic execution within operational semantics. We further introduce symbolic stabilizer states, which symbolize the phases of stabilizer generators, for the efficient analysis of quantum error correction (QEC) programs. Within the QSE framework, we can use symbolic expressions to characterize the possible discrete Pauli errors in QEC, providing a significant improvement over existing methods that rely on sampling with simulators. We implement QSE with the support of symbolic stabilizer states in a prototype tool named QuantumSE.jl . Our experiments on representative QEC codes, including quantum repetition codes, Kitaev’s toric codes, and quantum Tanner codes, demonstrate the efficiency of QuantumSE.jl for debugging QEC programs with over 1000 qubits. In addition, by substituting concrete values in symbolic expressions of measurement results, QuantumSE.jl is also equipped with a sampling feature for stabilizer circuits. Despite a longer initialization time than the state-of-the-art stabilizer simulator, Google’s Stim, QuantumSE.jl offers a quicker sampling rate in the experiments.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656419", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Wang", + "last_name": "Fang", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "journals/pacmpl/FangY24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656412", + "title": "Bit Blasting Probabilistic Programs", + "abstract": "Probabilistic programming languages (PPLs) are an expressive means for creating and reasoning about probabilistic models. Unfortunately hybrid probabilistic programs that involve both continuous and discrete structures are not well supported by today’s PPLs. In this paper we develop a new approximate inference algorithm for hybrid probabilistic programs that first discretizes the continuous distributions and then performs discrete inference on the resulting program. The key novelty is a form of discretization that we call bit blasting , which uses a binary representation of numbers such that a domain of 2 b discretized points can be succinctly represented as a discrete probabilistic program over poly b Boolean random variables. Surprisingly, we prove that many common continuous distributions can be bit blasted in a manner that incurs no loss of accuracy over an explicit discretization and supports efficient probabilistic inference. We have built a probabilistic programming system for hybrid programs called HyBit , which employs bit blasting followed by discrete probabilistic inference. We empirically demonstrate the benefits of our approach over existing sampling-based and symbolic inference approaches", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656412", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Poorva", + "last_name": "Garg", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Steven", + "last_name": "Holtzen", + "institution": "Northeastern University" + }, + { + "first_name": "Guy Van den", + "last_name": "Broeck", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/GargHBM24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656422", + "title": "RefinedRust: A Type System for High-Assurance Verification of Rust Programs", + "abstract": "Rust is a modern systems programming language whose ownership-based type system statically guarantees memory safety, making it particularly well-suited to the domain of safety-critical systems. In recent years, a wellspring of automated deductive verification tools have emerged for establishing functional correctness of Rust code. However, none of the previous tools produce foundational proofs (machine-checkable in a generalpurpose proof assistant), and all of them are restricted to the safe fragment of Rust. This is a problem because the vast majority of Rust programs make use of unsafe code at critical points, such as in the implementation of widely-used APIs. We propose RefinedRust , a refinement type system—proven sound in the Coq proof assistant—with the goal of establishing foundational semi-automated functional correctness verification of both safe and unsafe Rust code. We have developed a prototype verification tool implementing RefinedRust. Our tool translates Rust code (with user annotations) into a model of Rust embedded in Coq, and then checks its adherence to the RefinedRust type system using separation logic automation in Coq. All proofs generated by RefinedRust are checked by the Coq proof assistant, so the automation and type system do not have to be trusted. We evaluate the effectiveness of RefinedRust by verifying a variant of Rust’s Vec implementation that involves intricate reasoning about unsafe pointer-manipulating code.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656422", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lennard", + "last_name": "Gäher", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "ETH Zurich" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/GaherSJKD24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656444", + "title": "RichWasm: Bringing Safe, Fine-Grained, Shared-Memory Interoperability Down to WebAssembly", + "abstract": "Safe, shared-memory interoperability between languageswith different type systems and memory-safety guarantees is an intricate problem as crossing language boundaries may result in memory-safety violations. In this paper, we present RichWasm, a novel richly typed intermediate language designed to serve as a compilation target for typed high-level languages with different memory-safety guarantees. RichWasm is based on WebAssemblyand enables safe shared-memory interoperability by incorporating a variety of type features that support fine-grained memory ownership and sharing. RichWasm is rich enough to serve as a typed compilation target for both typed garbage-collected languages and languages with an ownership-based type system and manually managed memory. We demonstrate this by providing compilers from core ML and L 3 , a type-safe language with strong updates, to RichWasm. RichWasm is compiled to regular Wasm, allowing for use in existing environments. We formalize RichWasm in Coq and prove type safety.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656444", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Fitzgibbons", + "institution": "Northeastern University" + }, + { + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Northeastern University" + }, + { + "first_name": "Noble", + "last_name": "Mushtak", + "institution": "Northeastern University" + }, + { + "first_name": "Michelle Davies", + "last_name": "Thalakottur", + "institution": "Northeastern University" + }, + { + "first_name": "Jose Sulaiman", + "last_name": "Manzur", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/FitzgibbonsPMTMA24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656391", + "title": "IsoPredict: Dynamic Predictive Analysis for Detecting Unserializable Behaviors in Weakly Isolated Data Store Applications", + "abstract": "Distributed data stores typically provide weak isolation levels, which are efficient but can lead to unserializable behaviors, which are hard for programmers to understand and often result in errors. This paper presents the first dynamic predictive analysis for data store applications under weak isolation levels, called IsoPredict . Given an observed serializable execution of a data store application, IsoPredict generates and solves SMT constraints to find an unserializable execution that is a feasible execution of the application. IsoPredict introduces novel techniques that handle divergent application behavior; solve mutually recursive sets of constraints; and balance coverage, precision, and performance. An evaluation on four transactional data store benchmarks shows that IsoPredict often predicts unserializable behaviors, 99 % of which are feasible.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656391", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chujun", + "last_name": "Geng", + "institution": "The Ohio State University" + }, + { + "first_name": "Spyros", + "last_name": "Blanas", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Yang", + "last_name": "Wang", + "institution": "The Ohio State University" + } + ], + "dblp_key": "journals/pacmpl/GengBBW24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656394", + "title": "Efficient Static Vulnerability Analysis for JavaScript with Multiversion Dependency Graphs", + "abstract": "While static analysis tools that rely on Code Property Graphs (CPGs) to detect security vulnerabilities have proven effective, deciding how much information to include in the graphs remains a challenge. Including less information can lead to a more scalable analysis but at the cost of reduced effectiveness in identifying vulnerability patterns, potentially resulting in classification errors. Conversely, more information in the graph allows for a more effective analysis but may affect scalability. For example, scalability issues have been recently highlighted in ODGen, the state-of-the-art CPG-based tool for detecting Node.js vulnerabilities. This paper examines a new point in the design space of CPGs for JavaScript vulnerability detection. We introduce the Multiversion Dependency Graph (MDG), a novel graph-based data structure that captures the state evolution of objects and their properties during program execution. Compared to the graphs used by ODGen, MDGs are significantly simpler without losing key information needed for vulnerability detection. We implemented Graph.js, a new MDG-based static vulnerability scanner specialized in analyzing npm packages and detecting taint-style and prototype pollution vulnerabilities. Our evaluation shows that Graph.js outperforms ODGen by significantly reducing both the false negatives and the analysis time. Additionally, we have identified 49 previously undiscovered vulnerabilities in npm packages.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656394", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mafalda", + "last_name": "Ferreira", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Miguel", + "last_name": "Monteiro", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Tiago", + "last_name": "Brito", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Miguel E.", + "last_name": "Coimbra", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Nuno", + "last_name": "Santos", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "José Fragoso", + "last_name": "Santos", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + } + ], + "dblp_key": "journals/pacmpl/FerreiraMBCSJS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656446", + "title": "Foundational Integration Verification of a Cryptographic Server", + "abstract": "We present verification of a bare-metal server built using diverse implementation techniques and languages against a whole-system input-output specification in terms of machine code, network packets, and mathematical specifications of elliptic-curve cryptography. We used very different formal-reasoning techniques throughout the stack, ranging from computer algebra, symbolic execution, and verification-condition generation to interactive verification of functional programs including compilers for C-like and functional languages. All these component specifications and domain-specific reasoning techniques are defined and justified against common foundations in the Coq proof assistant. Connecting these components is a minimalistic specification style based on functional programs and assertions over simple objects, omnisemantics for program execution, and basic separation logic for memory layout. This design enables us to bring the components together in a top-level correctness theorem that can be audited without understanding or trusting the internal interfaces and tools. Our case study is a simple cryptographic server for flipping of a bit of state through public-key authenticated network messages, and its proof shows total functional correctness including static bounds on memory usage. This paper also describes our experiences with the specific verification tools we build upon, along with detailed analysis of reasons behind the widely varying levels of productivity we experienced between combinations of tools and tasks.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656446", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andres", + "last_name": "Erbsen", + "institution": "Google (United States)" + }, + { + "first_name": "Jade", + "last_name": "Philipoom", + "institution": "" + }, + { + "first_name": "Dustin", + "last_name": "Jamner", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ashley", + "last_name": "Lin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Samuel", + "last_name": "Gruetter", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ErbsenPJLGPC24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656407", + "title": "Quantitative Robustness for Vulnerability Assessment", + "abstract": "Most software analysis techniques focus on bug reachability. However, this approach is not ideal for security evaluation as it does not take into account the difficulty of triggering said bugs. The recently introduced notion of robust reachability tackles this issue by distinguishing between bugs that can be reached independently from uncontrolled inputs, from those that cannot. Yet, this qualitative notion is too strong in practice as it cannot distinguish mostly replicable bugs from truly unrealistic ones. In this work we propose a more flexible quantitative version of robust reachability together with a dedicated form of symbolic execution, in order to automatically measure the difficulty of triggering bugs. This Quantitative Robust Symbolic Execution (QRSE) relies on a variant of model counting, which allows to account for the asymmetry between attacker-controlled and uncontrolled variables. While this specific model counting problem has been studied in AI research fields such as Bayesian networks, knowledge representation and probabilistic planning, its use within the context of formal verification presents new challenges. We show the applicability of our solutions through security-oriented case studies, including real-world vulnerabilities such as CVE-2019-20839 from libvncserver.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656407", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Girol", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Guilhem", + "last_name": "Lacombe", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Sébastien", + "last_name": "Bardin", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + } + ], + "dblp_key": "journals/pacmpl/GirolLB24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656403", + "title": "Mechanised Hypersafety Proofs about Structured Data", + "abstract": "Arrays are a fundamental abstraction to represent collections of data. It is often possible to exploit structural properties of the data stored in an array ( e.g ., repetition or sparsity) to develop a specialised representation optimised for space efficiency. Formally reasoning about correctness of manipulations with such structured data is challenging, as they are often composed of multiple loops with non-trivial invariants. In this work, we observe that specifications for structured data manipulations can be phrased as hypersafety properties, i.e ., predicates that relate traces of k programs. To turn this observation into an effective verification methodology, we developed the Logic for Graceful Tensor Manipulation (LGTM), a new Hoare-style relational separation logic for specifying and verifying computations over structured data. The key enabling idea of LGTM is that of parametrised hypersafety specifications that allow the number k of the program components to depend on the program variables . We implemented LGTM as a foundational embedding into Coq, mechanising its rules, meta-theory, and the proof of soundness. Furthermore, we developed a library of domain-specific tactics that automate computer-aided hypersafety reasoning, resulting in pleasantly short proof scripts that enjoy a high degree of reuse. We argue for the effectiveness of relational reasoning about structured data in LGTM by specifying and mechanically proving correctness of 13 case studies including computations on compressed arrays and efficient operations over multiple kinds of sparse tensors.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656403", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Vladimir", + "last_name": "Gladshtein", + "institution": "National University of Singapore" + }, + { + "first_name": "Qiyuan", + "last_name": "Zhao", + "institution": "National University of Singapore" + }, + { + "first_name": "Willow", + "last_name": "Ahrens", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/GladshteinZAAS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656455", + "title": "Hyperblock Scheduling for Verified High-Level Synthesis", + "abstract": "High-level synthesis (HLS) is the automatic compilation of software programs into custom hardware designs. With programmable hardware devices (such as FPGAs) now widespread, HLS is increasingly relied upon, but existing HLS tools are too unreliable for safety- and security-critical applications. Herklotz et al. partially addressed this concern by building Vericert , a prototype HLS tool that is proven correct in Coq (à la CompCert), but it cannot compete performance-wise with unverified tools. This paper reports on our efforts to close this performance gap, thus obtaining the first practical verified HLS tool. We achieve this by implementing a flexible operation scheduler based on hyperblocks (basic blocks of predicated instructions) that supports operation chaining (packing dependent operations into a single clock cycle). Correctness is proven via translation validation: each schedule is checked using a Coq-verified validator that uses a SAT solver to reason about predicates. Avoiding exponential blow-up in this validation process is a key challenge, which we address by using final-state predicates and value summaries . Experiments on the PolyBench/C suite indicate that scheduling makes Vericert-generated hardware 2.1× faster, thus bringing Vericert into competition with a state-of-the-art open-source HLS tool when a similar set of optimisations is enabled.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656455", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yann", + "last_name": "Herklotz", + "institution": "Imperial College London" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/HerklotzW24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656436", + "title": "Compiling Conditional Quantum Gates without Using Helper Qubits", + "abstract": "We present a compilation scheme for conditional quantumgates. Our scheme compiles amulti-qubit conditional to a linear number of two-qubit conditionals. This can be done straightforwardly with helper qubits, but we show how to do it without using helper qubits and with much fewer gates than in previous work. Specifically, our scheme requires 1/3 as many gates as the previous best scheme without using helper qubits, which is essential for practical use. Our experiments show that several quantum-circuit optimizers have little impact on the compiled code from the previous best scheme, confirming the need for our new scheme. Our experiments with Grover’s algorithm and quantum walk also show that our scheme has a major impact on the reliability of the compiled code.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656436", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "K. F.", + "last_name": "Huang", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/HuangP24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656406", + "title": "Don't Write, but Return: Replacing Output Parameters with Algebraic Data Types in C-to-Rust Translation", + "abstract": "Translating legacy system programs from C to Rust is a promising way to enhance their reliability. To alleviate the burden of manual translation, automatic C-to-Rust translation is desirable. However, existing translators fail to generate Rust code fully utilizing Rust’s language features, including algebraic data types. In this work, we focus on tuples and Option/Result types, an important subset of algebraic data types. They are used as functions’ return types to represent those returning multiple values and those that may fail. Due to the absence of these types, C programs use output parameters , i.e., pointer-type parameters for producing outputs, to implement such functions. As output parameters make code less readable and more error-prone, their use is discouraged in Rust. To address this problem, this paper presents a technique for removing output parameters during C-to-Rust translation. This involves three steps: (1) syntactically translating C code to Rust using an existing translator; (2) analyzing the Rust code to extract information related to output parameters; and (3) transforming the Rust code using the analysis result. The second step poses several challenges, including the identification and classification of output parameters. To overcome these challenges, we propose a static analysis based on abstract interpretation, complemented by the notion of abstract read/write sets , which approximate the sets of read/written pointers, and two sensitivities: write set sensitivity and nullity sensitivity . Our evaluation shows that the proposed technique is (1) scalable, with the analysis and transformation of 190k LOC within 213 seconds, (2) useful, with the detection of 1,670 output parameters across 55 real-world C programs, and (3) mostly correct, with 25 out of 26 programs passing their test suites after the transformation.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656406", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jaemin", + "last_name": "Hong", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/HongR24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656428", + "title": "Qubit Recycling Revisited", + "abstract": "Reducing the width of quantum circuits is crucial due to limited number of qubits in quantum devices. This paper revisit an optimization strategy known as qubit recycling (alternatively wire-recycling or measurement- and-reset ), which leverages gate commutativity to reuse discarded qubits, thereby reducing circuit width. We introduce qubit dependency graphs (QDGs) as a key abstraction for this optimization. With QDG, we isolate the computationally demanding components, and observe that qubit recycling is essentially a matrix triangularization problem. Based on QDG and this observation, we study qubit recycling with a focus on complexity, algorithmic, and verification aspects. Firstly, we establish qubit recycling’s NP-hardness through reduction from Wilf’s question, another matrix triangularization problem. Secondly, we propose a QDG-guided solver featuring multiple heuristic options for effective qubit recycling. Benchmark tests conducted on RevLib illustrate our solver’s superior or comparable performance to existing alternatives. Notably, it achieves optimal solutions for the majority of circuits. Finally, we develop a certified qubit recycler that integrates verification and validation techniques, with its correctness proof mechanized in Coq.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656428", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hanru", + "last_name": "Jiang", + "institution": "Beijing Institute of Mathematical Sciences and Applications" + } + ], + "dblp_key": "journals/pacmpl/Jiang24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656464", + "title": "PL4XGL: A Programming Language Approach to Explainable Graph Learning", + "abstract": "In this article, we present a new, language-based approach to explainable graph learning. Though graph neural networks (GNNs) have shown impressive performance in various graph learning tasks, they have severe limitations in explainability, hindering their use in decision-critical applications. To address these limitations, several GNN explanation techniques have been proposed using a post-hoc explanation approach providing subgraphs as explanations for classification results. Unfortunately, however, they have two fundamental drawbacks in terms of 1) additional explanation costs and 2) the correctness of the explanations. This paper aims to address these problems by developing a new graph-learning method based on programming language techniques. Our key idea is two-fold: 1) designing a graph description language (GDL) to explain the classification results and 2) developing a new GDL-based interpretable classification model instead of GNN-based models. Our graph-learning model, called PL4XGL, consists of a set of candidate GDL programs with labels and quality scores. For a given graph component, it searches the best GDL program describing the component and provides the corresponding label as the classification result and the program as the explanation. In our approach, learning from data is formulated as a program-synthesis problem, and we present top-down and bottom-up algorithms for synthesizing GDL programs from training data. Evaluation using widely-used datasets demonstrates that PL4XGL produces high-quality explanations that outperform those produced by the state-of-the-art GNN explanation technique, S ubgraph X. We also show that PL4XGL achieves competitive classification accuracy comparable to popular GNN models.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656464", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Minseok", + "last_name": "Jeon", + "institution": "Korea University" + }, + { + "first_name": "Jihyeok", + "last_name": "Park", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/JeonPO24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656383", + "title": "Concurrent Immediate Reference Counting", + "abstract": "Memory management for optimistic concurrency in unmanaged programming languages is challenging. Safe memory reclamation (SMR) algorithms help address this, but they are difficult to use correctly. Automatic reference counting provides a simpler interface, but it has been less efficient than SMR algorithms. Recently, there has been a push to apply the optimizations used in garbage collectors for managed languages to elide reference count updates from local references. Notably, Fast Reference Counter, OrcGC, and Concurrent Deferred Reference Counting use SMR algorithms to protect local references by deferring decrements or reclamation. While they show a significant performance improvement, their use of deferral may result in growing memory usage due to slow reclamation of linked structures, and suboptimal performance in update-heavy workloads. We present Concurrent Immediate Reference Counting (CIRC), a new combination of SMR algorithms with reference counting. CIRC employs deferral like other modern methods, but it avoids their problems with novel algorithms for (1) immediately reclaiming linked structures recursively by tracking the reachability of each object, and (2) applying decrements immediately and deferring only the reclamation. Our experiments show that CIRC’s memory usage does not grow over time and is only slightly higher than the underlying SMR. Moreover, CIRC further narrows the performance gap between the underlying SMR, positioning it as a promising solution to safe automatic memory management for highly concurrent data structures in unmanaged languages.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656383", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jaehwang", + "last_name": "Jung", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeonghyeon", + "last_name": "Kim", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/JungKPK24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656378", + "title": "Modular Hardware Design of Pipelined Circuits with Hazards", + "abstract": "Modular design is critical in reducing hardware designer’s cognitive load and development cost. However, it is challenging to modularize high-performance pipelined circuits with structural, data, and control hazards because their resolution—stalling, and bypassing, and discard-and-restarting—introduce cross-stage dependencies. The dependencies could potentially mandate monolithic control logic and create combinational loops, hindering modular design. An effective method to modularize pipelined circuits is valid-ready interfaces, but they apply to a relatively simple form of pipelined circuits only with structural hazards. We propose hazard interfaces, a generalization of valid-ready interfaces that can modularize pipelined circuits not only with structural but also with data and control hazards. The key idea is enveloping the cross-stage dependencies within interfaces. We also design combinators for hazard interfaces in the style of map-reduce that facilitate decomposition of control logic. We implement a compiler (to synthesizable Verilog) for a prototype language supporting hazard interfaces and combinators, and design a sound and efficient type checker that proves the absence of combinational loops. With case studies on 5-stage RISC-V CPU core and 100 Gbps Ethernet NIC, we demonstrate that hazard interfaces indeed facilitate modular design while incurring no noticeable cost in performance, power, and area over reference designs in Chisel and Verilog. CCS Concepts: • Hardware → Hardware description languages and compilation ; • Software and its engineering → Functional languages .", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656378", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Minseong", + "last_name": "Jang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "J. G.", + "last_name": "Rhee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Woojin", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Shuangshuang", + "last_name": "Zhao", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/JangRLZK24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656409", + "title": "GenSQL: A Probabilistic Programming System for Querying Generative Models of Database Tables", + "abstract": "This article presents GenSQL, a probabilistic programming system for querying probabilistic generative models of database tables. By augmenting SQL with only a few key primitives for querying probabilistic models, GenSQL enables complex Bayesian inference workflows to be concisely implemented. GenSQL’s query planner rests on a unified programmatic interface for interacting with probabilistic models of tabular data, which makes it possible to use models written in a variety of probabilistic programming languages that are tailored to specific workflows. Probabilistic models may be automatically learned via probabilistic program synthesis, hand-designed, or a combination of both. GenSQL is formalized using a novel type system and denotational semantics, which together enable us to establish proofs that precisely characterize its soundness guarantees. We evaluate our system on two case real-world studies—an anomaly detection in clinical trials and conditional synthetic data generation for a virtual wet lab—and show that GenSQL more accurately captures the complexity of the data as compared to common baselines. We also show that the declarative syntax in GenSQL is more concise and less error-prone as compared to several alternatives. Finally, GenSQL delivers a 1.7-6.8x speedup compared to its closest competitor on a representative benchmark set and runs in comparable time to hand-written code, in part due to its reusable optimizations and code specialization.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656409", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mathieu", + "last_name": "Huot", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Matin", + "last_name": "Ghavami", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ulrich", + "last_name": "Schaechtle", + "institution": "" + }, + { + "first_name": "Cameron E.", + "last_name": "Freer", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Z.", + "last_name": "Shelby", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/HuotGLSFSRSM24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656441", + "title": "Space-Efficient Polymorphic Gradual Typing, Mostly Parametric", + "abstract": "Since the arrival of gradual typing, which allows partially typed code in a single program, efficient implementations of gradual typing have been an active research topic. In this paper, we study the space-efficient problem of gradual typing in the presence of parametric polymorphism. Based on the existing work that showed the impossibility of a space-efficient implementation that supports fully parametric polymorphism, this paper will show that a space-efficient implementation is, in principle, possible by slightly relaxing parametricity. We first develop λC m p ∀ , which is a coercion calculus with mostly parametric polymorphism, and show its relaxed parametricity. Then, we present λS m p ∀ , a space-efficient version of λC m p ∀ , and prove that λS m p ∀ programs can be executed in a space-efficient manner and that translation from λC m p ∀ to λS m p ∀ is type-and semantics-preserving.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656441", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + }, + { + "first_name": "S.", + "last_name": "Ozaki", + "institution": "Kyoto University" + }, + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Yudai", + "last_name": "Tanabe", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/IgarashiOST24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656385", + "title": "Diffy: Data-Driven Bug Finding for Configurations", + "abstract": "Configuration errors remain a major cause of system failures and service outages. One promising approach to identify configuration errors automatically is to learn common usage patterns (and anti-patterns) using data-driven methods. However, existing data-driven learning approaches analyze only simple configurations ( e.g. , those with no hierarchical structure), identify only simple types of issues ( e.g. , type errors), or require extensive domain-specific tuning. In this paper, we present D iffy , the first push-button configuration analyzer that detects likely bugs in structured configurations. From example configurations, D iffy learns a common template, with \"holes\" that capture their variation. It then applies unsupervised learning to identify anomalous template parameters as likely bugs. We evaluate D iffy on a large cloud provider’s wide-area network, an operational 5G network testbed, and MySQL configurations, demonstrating its versatility, performance, and accuracy. During D iffy ’s development, it caught and prevented a bug in a configuration timer value that had previously caused an outage for the cloud provider.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656385", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Siva Kesava Reddy", + "last_name": "Kakarla", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Francis Y.", + "last_name": "Yan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ryan", + "last_name": "Beckett", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/KakarlaYB24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656429", + "title": "A Lightweight Polyglot Code Transformation Language", + "abstract": "In today’s software industry, large-scale, multi-language codebases are the norm. This brings substantial challenges in developing automated tools for code maintenance tasks such as API migration or dead code cleanup. Tool builders often find themselves caught between two less-than-ideal tooling options: (1) languagespecific code rewriting tools or (2) generic, lightweight match-replace transformation tools with limited expressiveness. The former leads to tool fragmentation and a steep learning curve for each language, while the latter forces developers to create ad-hoc, throwaway scripts to handle realistic tasks. To fill this gap, we introduce a new declarative domain-specific language (DSL) for expressing interdependent multi-language code transformations. Our key insight is that we can increase the expressiveness and applicability of lightweight match-replace tools by extending them to support for composition, ordering, and flow. We implemented an open-source tool for our language, called P olyglot P iranha , and deployed it in an industrial setting. We demonstrate its effectiveness through three case studies, where it deleted 210K lines of dead code and migrated 20K lines, across 1611 pull requests. We compare our DSL against state-of-the-art alternatives, and show that the tools we developed are faster, more concise, and easier to maintain.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656429", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ameya", + "last_name": "Ketkar", + "institution": "" + }, + { + "first_name": "Daniel", + "last_name": "Ramos", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Lazaro", + "last_name": "Clapp", + "institution": "" + }, + { + "first_name": "Rajkishore", + "last_name": "Barik", + "institution": "" + }, + { + "first_name": "Murali Krishna", + "last_name": "Ramanathan", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/KetkarRCBR24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656382", + "title": "A Tensor Compiler with Automatic Data Packing for Simple and Efficient Fully Homomorphic Encryption", + "abstract": "Fully Homomorphic Encryption (FHE) enables computing on encrypted data, letting clients securely offload computation to untrusted servers. While enticing, FHE has two key challenges that limit its applicability: it has high performance overheads (10,000× over unencrypted computation) and it is extremely hard to program. Recent hardware accelerators and algorithmic improvements have reduced FHE’s overheads and enabled large applications to run under FHE. These large applications exacerbate FHE’s programmability challenges. Writing FHE programs directly is hard because FHE schemes expose a restrictive, low-level interface that prevents abstraction and composition. Specifically, FHE requires packing encrypted data into large vectors (tens of thousands of elements long), FHE provides limited operations on these vectors, and values have noise that grows with each operation, which creates unintuitive performance tradeoffs. As a result, translating large applications, like neural networks, into efficient FHE circuits takes substantial tedious work. We address FHE’s programmability challenges with the Fhelipe FHE compiler. Fhelipe exposes a simple, numpy-style tensor programming interface, and compiles high-level tensor programs into efficient FHE circuits. Fhelipe’s key contribution is automatic data packing , which chooses data layouts for tensors and packs them into ciphertexts to maximize performance. Our novel framework considers a wide range of layouts and optimizes them analytically. This lets Fhelipe compile large FHE programs efficiently, unlike prior FHE compilers, which either use inefficient layouts or do not scale beyond tiny programs. We evaluate Fhelipe on both a state-of-the-art FHE accelerator and a CPU. Fhelipe is the first compiler that matches or exceeds the performance of large hand-optimized FHE applications, like deep neural networks, and outperforms a state-of-the-art FHE compiler by gmean 18.5×. At the same time, Fhelipe dramatically simplifies programming, reducing code size by 10× – 48×. CCS Concepts: • Software and its engineering → Compilers; • Security and privacy → Cryptography.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656382", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Krastev", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Nikola", + "last_name": "Samardzic", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Simon", + "last_name": "Langowski", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Srinivas", + "last_name": "Devadas", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Daniel", + "last_name": "Sánchez", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KrastevSLDS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656456", + "title": "Numerical Fuzz: A Type System for Rounding Error Analysis", + "abstract": "Algorithms operating on real numbers are implemented as floating-point computations in practice, but floatingpoint operations introduce roundoff errors that can degrade the accuracy of the result. We propose Λ num , a functional programming language with a type system that can express quantitative bounds on roundoff error. Our type system combines a sensitivity analysis, enforced through a linear typing discipline, with a novel graded monad to track the accumulation of roundoff errors. We prove that our type system is sound by relating the denotational semantics of our language to the exact and floating-point operational semantics. To demonstrate our system, we instantiate Λ num with error metrics proposed in the numerical analysis literature and we show how to incorporate rounding operations that faithfully model aspects of the IEEE 754 floating-point standard. To show that Λ num can be a useful tool for automated error analysis, we develop a prototype implementation for Λ num that infers error bounds that are competitive with existing tools, while often running significantly faster. Finally, we consider semantic extensions of our graded monad to bound error under more complex rounding behaviors, such as non-deterministic and randomized rounding.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656456", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ariel", + "last_name": "Kellison", + "institution": "Cornell University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/KellisonH24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656411", + "title": "Descend: A Safe GPU Systems Programming Language", + "abstract": "Graphics Processing Units (GPU) offer tremendous computational power by following a throughput oriented paradigm where many thousand computational units operate in parallel. Programming such massively parallel hardware is challenging. Programmers must correctly and efficiently coordinate thousands of threads and their accesses to various shared memory spaces. Existing mainstream GPU programming languages, such as CUDA and OpenCL, are based on C/C++ inheriting their fundamentally unsafe ways to access memory via raw pointers. This facilitates easy to make, but hard to detect bugs, such as data races and deadlocks . In this paper, we present Descend : a safe GPU programming language. In contrast to prior safe high-level GPU programming approaches, Descend is an imperative GPU systems programming language in the spirit of Rust, enforcing safe CPU and GPU memory management in the type system by tracking Ownership and Lifetimes . Descend introduces a new holistic GPU programming model where computations are hierarchically scheduled over the GPU’s execution resources : grid, blocks, warps, and threads. Descend’s extended Borrow checking ensures that execution resources safely access memory regions without data races. For this, we introduced views describing safe parallel access patterns of memory regions, as well as atomic variables. For memory accesses that can’t be checked by our type system, users can annotate limited code sections as unsafe . We discuss the memory safety guarantees offered by Descend and evaluate our implementation using multiple benchmarks, demonstrating that Descend is capable of expressing real-world GPU programs showing competitive performance compared to manually written CUDA programs lacking Descend’s safety guarantees.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656411", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bastian", + "last_name": "Köpcke", + "institution": "University of Münster" + }, + { + "first_name": "Sergei", + "last_name": "Gorlatch", + "institution": "University of Münster" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "Technische Universität Berlin" + } + ], + "dblp_key": "journals/pacmpl/KopckeGS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656415", + "title": "Superfusion: Eliminating Intermediate Data Structures via Inductive Synthesis", + "abstract": "Intermediate data structures are a common cause of inefficiency in functional programming. Fusion attempts to eliminate intermediate data structures by combining adjacent data traversals into one; existing fusion techniques, however, are based on predefined rewrite rules and hence are limited in expressiveness. In this work we explore a different approach to eliminating intermediate data structures, based on inductive program synthesis. We dub this approach superfusion (by analogy with superoptimization , which uses inductive synthesis for program optimization). Starting from a reference program annotated with data structures to be eliminated, superfusion first generates a sketch where program fragments operating on those data structures are replaced with holes; it then fills the holes with constant-time expressions such that the resulting program is equivalent to the reference. The main technical challenge here is scalability because optimized programs are often complex, making the search space intractably large for naive enumeration. To address this challenge, our key insight is to first synthesize a ghost function that describes the relationship between the original intermediate data structure and its compressed version; this function, although not used in the final program, serves to decompose the joint sketch filling problem into independent simpler problems for each hole. We implement superfusion in a tool called SuFu and evaluate it on a dataset of 290 tasks collected from prior work on deductive fusion and program restructuring. The results show that SuFu solves 264 out of 290 tasks, exceeding the capabilities of rewriting-based fusion systems and achieving comparable performance with specialized approaches to program restructuring on their respective domains.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656415", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ruyi", + "last_name": "Ji", + "institution": "Peking University" + }, + { + "first_name": "Yuwei", + "last_name": "Zhao", + "institution": "Peking University" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/JiZPXH24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656458", + "title": "V-Star: Learning Visibly Pushdown Grammars from Program Inputs", + "abstract": "Accurate description of program inputs remains a critical challenge in the field of programming languages. Active learning, as a well-established field, achieves exact learning for regular languages. We offer an innovative grammar inference tool, V-Star, based on the active learning of visibly pushdown automata. V-Star deduces nesting structures of program input languages from sample inputs, employing a novel inference mechanism based on nested patterns. This mechanism identifies token boundaries and converts languages such as XML documents into VPLs. We then adapted Angluin’s L-Star, an exact learning algorithm, for VPA learning, which improves the precision of our tool. Our evaluation demonstrates that V-Star effectively and efficiently learns a variety of practical grammars, including S-Expressions, JSON, and XML, and outperforms other state-of-the-art tools.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656458", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiaodong", + "last_name": "Jia", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/JiaT24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656449", + "title": "SPORE: Combining Symmetry and Partial Order Reduction", + "abstract": "Symmetry reduction (SR) and partial order reduction (POR) aim to scale up model checking by exploiting the underlying program structure: SR avoids exploring executions equivalent up to some permutation of symmetric threads, while POR avoids exploring executions equivalent up to reordering of independent instructions. While both SR and POR have been well studied individually, their combination in the context of stateless model checking has remained an open problem. In this paper, we present Spore, the first stateless model checker that combines SR and POR in a sound, complete and optimal manner. Spore can leverage both symmetries in the client program itself, but also internal symmetries in the underlying implementation (i.e., idempotent operations), a novel symmetry notion we introduce in this paper. Our experiments confirm that Spore explores drastically fewer executions than tools that solely employ SR/POR, thereby greatly advancing the state-of-the-art. CCS Concepts: • Theory of computation → Concurrency; Verification by model checking .", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656449", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Iason", + "last_name": "Marmanis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/KokologiannakisMV24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656445", + "title": "SpEQ: Translation of Sparse Codes using Equivalences", + "abstract": "We present S p EQ, a quick and correct strategy for detecting semantics in sparse codes and enabling automatic translation to high-performance library calls or domain-specific languages (DSLs). When sparse linear algebra codes contain implicit preconditions about how data is stored that hamper direct translation, S p EQ identifies the high-level computation along with storage details and related preconditions. A run-time check guards the translation and ensures that required preconditions are met. We implement S p EQ using the LLVM framework, the Z3 solver, and egglog library and correctly translate sparse linear algebra codes into two high-performance libraries, NVIDIA cuSPARSE and Intel MKL, and OpenMP (OMP). We evaluate S p EQ on ten diverse benchmarks against two state-of-the-art translation tools. S p EQ achieves geometric mean speedups of 3.25 × , 5.09 × , and 8.04 × on OpenMP, MKL, and cuSPARSE backends, respectively. S p EQ is the only tool that can guarantee the correct translation of sparse computations.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656445", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Avery", + "last_name": "Laird", + "institution": "University of Toronto" + }, + { + "first_name": "Bangtian", + "last_name": "Liu", + "institution": "University of Toronto" + }, + { + "first_name": "Nikolaj", + "last_name": "Bjørner", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Maryam Mehri", + "last_name": "Dehnavi", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/LairdLBD24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656414", + "title": "Program Analysis for Adaptive Data Analysis", + "abstract": "Data analyses are usually designed to identify some property of the population from which the data are drawn, generalizing beyond the specific data sample. For this reason, data analyses are often designed in a way that guarantees that they produce a low generalization error. That is, they are designed so that the result of a data analysis run on a sample data does not differ too much from the result one would achieve by running the analysis over the entire population. An adaptive data analysis can be seen as a process composed by multiple queries interrogating some data, where the choice of which query to run next may rely on the results of previous queries. The generalization error of each individual query/analysis can be controlled by using an array of well-established statistical techniques. However, when queries are arbitrarily composed, the different errors can propagate through the chain of different queries and bring to a high generalization error. To address this issue, data analysts are designing several techniques that not only guarantee bounds on the generalization errors of single queries, but that also guarantee bounds on the generalization error of the composed analyses. The choice of which of these techniques to use, often depends on the chain of queries that an adaptive data analysis can generate. In this work, we consider adaptive data analyses implemented as while-like programs and we design a program analysis which can help with identifying which technique to use to control their generalization errors. More specifically, we formalize the intuitive notion of adaptivity as a quantitative property of programs. We do this because the adaptivity level of a data analysis is a key measure to choose the right technique. Based on this definition, we design a program analysis for soundly approximating this quantity. The program analysis generates a representation of the data analysis as a weighted dependency graph, where the weight is an upper bound on the number of times each variable can be reached, and uses a path search strategy to guarantee an upper bound on the adaptivity. We implement our program analysis and show that it can help to analyze the adaptivity of several concrete data analyses with different adaptivity structures.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656414", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jiawen", + "last_name": "Liu", + "institution": "" + }, + { + "first_name": "Weihao", + "last_name": "Qu", + "institution": "Monmouth University" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jonathan", + "last_name": "Ullman", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/LiuQGGU24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656451", + "title": "Context-Free Language Reachability via Skewed Tabulation", + "abstract": "Context-free language reachability (CFL-reachability) is a prominent model for formulating program analysis problems. Almost all CFL-reachability algorithms are based on the Reps-Horwitz-Sagiv (RHS) tabulation. In essence, the RHS tabulation, based on normalized context-free grammars, is similar to the CYK algorithm for CFL-parsing. Consider a normalized rule S : : = A B and a CFL-reachability problem instance of computing S -edges in the input graph. The RHS tabulation obtains all summary edges ( i.e., S -, A-, and B -edges) based on the grammar rules. However, many A - and B -edges are wasted because only a subset of those edges eventually contributes to generating S -edges in the input graph. This paper proposes a new tabulation strategy for speeding up CFL-reachability by eliminating wasted and unnecessary summary edges. We particularly focus on recursive nonterminals. Our key technical insight is that the wasted edge generations and insertions caused by recursive nonterminals can be avoided by modifying the parse trees either statically (by transforming the grammar) or dynamically (using a specialized online CFL-reachability solver). For example, if a recursive nonterminal B , generated by a rule B : : = B X , appears on the right-hand side of a rule S : : = A B , we can make S recursive (by introducing a new rule S : : = S X ) and eliminate the original recursive rule ( B : : = B X ). Due to the rule S : : = S X , the shapes of the parse trees associated with the left-hand-side nonterminal S become more “skewed”. Thus, we name our approach skewed tabulation for CFL-reachability. Skewed tabulation can significantly improve the scalability of CFL-reachability by reducing wasted and unnecessary summary edges. We have implemented skewed tabulation and applied the corresponding CFL- reachability algorithm to an alias analysis, a value-flow analysis, and a taint analysis. Our extensive evaluation based on SPEC 2017 benchmarks yields promising results. For the three client analyses, CFL-reachability based on skewed tabulation can achieve 3.34×, 1.13× and 2.05× speedup over the state-of-the-art RHS-tabulation- based CFL-reachability solver and consume 60.05%, 20.38% and 63.06% less memory, respectively. Furthermore, the cost of grammar transformation for skewed tabulation is negligible, typically taking less than one second.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656451", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuxiang", + "last_name": "Lei", + "institution": "UNSW Sydney" + }, + { + "first_name": "Camille", + "last_name": "Bossut", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "UNSW Sydney" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LeiBSZ24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656424", + "title": "Reducing Static Analysis Unsoundness with Approximate Interpretation", + "abstract": "Static program analysis for JavaScript is more difficult than for many other programming languages. One of the main reasons is the presence of dynamic property accesses that read and write object properties via dynamically computed property names. To ensure scalability and precision, existing state-of-the-art analyses for JavaScript mostly ignore these operations although it results in missed call edges and aliasing relations. We present a novel dynamic analysis technique named approximate interpretation that is designed to efficiently and fully automatically infer likely determinate facts about dynamic property accesses, in particular those that occur in complex library API initialization code, and how to use the produced information in static analysis to recover much of the abstract information that is otherwise missed. Our implementation of the technique and experiments on 141 real-world Node.js-based JavaScript applications and libraries show that the approach leads to significant improvements in call graph construction. On average the use of approximate interpretation leads to 55.1 % more call edges, 21.8 % more reachable functions, 17.7 % more resolved call sites, and only 1.5 % fewer monomorphic call sites. For 36 JavaScript projects where dynamic call graphs are available, average analysis recall is improved from 75.9 % to 88.1 % with a negligible reduction in precision.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656424", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mathias Rud", + "last_name": "Laursen", + "institution": "Aarhus University" + }, + { + "first_name": "Wenyuan", + "last_name": "Xu", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/LaursenXM24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656450", + "title": "Predictable Verification using Intrinsic Definitions", + "abstract": "We propose a novel mechanism of defining data structures using intrinsic definitions that avoids recursion and instead utilizes monadic maps satisfying local conditions. We show that intrinsic definitions are a powerful mechanism that can capture a variety of data structures naturally. We show that they also enable a predictable verification methodology that allows engineers to write ghost code to update monadic maps and perform verification using reduction to decidable logics. We evaluate our methodology using B oogie and prove a suite of data structure manipulating programs correct.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656450", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Cody", + "last_name": "Rivera", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MuraliRM24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656392", + "title": "Compiling with Abstract Interpretation", + "abstract": "Rewriting and static analyses are mutually beneficial techniques: program transformations change the inten- sional aspects of the program, and can thus improve analysis precision, while some efficient transformations are enabled by specific knowledge of some program invariants. Despite the strong interaction between these techniques, they are usually considered distinct. In this paper, we demonstrate that we can turn abstract interpreters into compilers, using a simple free algebra over the standard signature of abstract domains. Functor domains correspond to compiler passes, for which soundness is translated to a proof of forward simulation, and completeness to backward simulation. We achieve translation to SSA using an abstract domain with a non-standard SSA signature. Incorporating such an SSA translation to an abstract interpreter improves its precision; in particular we show that an SSA-based non-relational domain is always more precise than a standard non-relational domain for similar time and memory complexity. Moreover, such a domain allows recovering from precision losses that occur when analyzing low-level machine code instead of source code. These results help implement analyses or compilation passes where symbolic and semantic methods simultaneously refine each other, and improves precision when compared to doing the passes in sequence. CCS Concepts: • Software and its engineering → Compilers ; Formal Software verification; • Theory of computation → Program analysis ; Program verification ; Abstraction ; Equational logic and rewriting.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656392", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dorian", + "last_name": "Lesbre", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Matthieu", + "last_name": "Lemerre", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + } + ], + "dblp_key": "journals/pacmpl/LesbreL24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656386", + "title": "Boosting Compiler Testing by Injecting Real-World Code", + "abstract": "We introduce a novel approach for testing optimizing compilers with code from real-world applications The main idea is to construct well-formed programs by fusing multiple code snippets from various realworld projects. The key insight is backed by the fact that the large volume of real-world code exercises rich syntactical and semantic language features, which current engineering-intensive approaches like random program generators are hard to fully support. To construct well-formed programs from real-world code our approach works by (1) extracting real-world code at the granularity of function, (2) injecting function calls into seed programs, and (3) leveraging dynamic execution information to maintain the semantics and build complex data dependencies between injected functions and the seed program. With this idea, our approach complements the existing generators by boosting their expressiveness via fusing real-world code in a semantics-preserving way. We implement our idea in a tool, Creal, to test C compilers. In a nine-month testing period, we have reported 132 bugs to GCC and LLVM, two of the most popular and well-tested C compilers. At the time of writing, 121 of them have been confirmed as unknown bugs, and 101 of them have been fixed. Most of these bugs were miscompilations, and many were recognized as long-latent and critical. Our evaluation results evidently demonstrate the significant advantage of using real-world code to stress-test compilers. We believe this idea will benefit the general compiler testing direction and will be directly applicable to other compilers.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656386", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shaohua", + "last_name": "Li", + "institution": "ETH Zurich" + }, + { + "first_name": "Theodoros", + "last_name": "Theodoridis", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/LiTS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656448", + "title": "Compiling Probabilistic Programs for Variable Elimination with Information Flow", + "abstract": "A key promise of probabilistic programming is the ability to specify rich models using an expressive programming language. However, the expressive power that makes probabilistic programming languages enticing also poses challenges to inference, so much so that specialized approaches to inference ban language features such as recursion. We present an approach to variable elimination and marginal inference for probabilistic programs featuring bounded recursion, discrete distributions, and sometimes continuous distributions. A compiler eliminates probabilistic side effects, using a novel information-flow type system to factorize probabilistic computations and hoist independent subcomputations out of sums or integrals. For a broad class of recursive programs with dynamically recurring substructure, the compiler effectively decomposes a global marginal-inference problem, which may otherwise be intractable, into tractable subproblems. We prove the compilation correct by showing that it preserves denotational semantics. Experiments show that the compiled programs subsume widely used PTIME algorithms for recursive models and that the compilation time scales with the size of the inference problems. As a separate contribution, we develop a denotational, logical-relations model of information-flow types in the novel measure-theoretic setting of probabilistic programming; we use it to prove noninterference and consequently the correctness of variable elimination. CCS Concepts: • Theory of computation → Probabilistic computation; Program semantics; Program reasoning; Type theory; • Mathematics of computing → Bayesian computation; Statistical software; • Computing methodologies → Machine learning; • Software and its engineering → Compilers; Functional languages; Language features; Formal language definitions .", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656448", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jianlin", + "last_name": "Li", + "institution": "University of Waterloo" + }, + { + "first_name": "Eric", + "last_name": "Wang", + "institution": "University of Waterloo" + }, + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/LiWZ24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656390", + "title": "A Verified Compiler for a Functional Tensor Language", + "abstract": "Producing efficient array code is crucial in high-performance domains like image processing and machine learning. It requires the ability to control factors like compute intensity and locality by reordering computations into different stages and granularities with respect to where they are stored. However, traditional pure, functional tensor languages struggle to do so. In a previous publication, we introduced ATL as a pure, functional tensor language capable of systematically decoupling compute and storage order via a set of high-level combinators known as reshape operators. Reshape operators are a unique functional-programming construct since they manipulate storage location in the generated code by modifying the indices that appear on the left-hand sides of storage expressions. We present a formal correctness proof for an implementation of the compilation algorithm, marking the first verification of a lowering algorithm targeting imperative loop nests from a source functional language that enables separate control of compute and storage ordering. One of the core difficulties of this proof required properly formulating the complex invariants to ensure that these storage-index remappings were well-formed. Notably, this exercise revealed a soundness bug in the original published compilation algorithm regarding the truncation reshape operators. Our fix is a new type system that captures safety conditions that were previously implicit and enables us to prove compiler correctness for well-typed source programs. We evaluate this type system and compiler implementation on a range of common programs and optimizations, including but not limited to those previously studied to demonstrate performance comparable to established compilers like Halide.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656390", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Amanda", + "last_name": "Liu", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Gilbert", + "last_name": "Bernstein", + "institution": "University of Washington" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LiuBCR24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656460", + "title": "Syntactic Code Search with Sequence-to-Tree Matching: Supporting Syntactic Search with Incomplete Code Fragments", + "abstract": "Lightweight syntactic analysis tools like Semgrep and Comby leverage the tree structure of code, making them more expressive than string and regex search. Unlike traditional language frameworks (e.g., ESLint) that analyze codebases via explicit syntax tree manipulations, these tools use query languages that closely resemble the source language. However, state-of-the-art matching techniques for these tools require queries to be complete and parsable snippets, which makes in-progress query specifications useless. We propose a new search architecture that relies only on tokenizing (not parsing) a query. We introduce a novel language and matching algorithm to support tree-aware wildcards on this architecture by building on tree automata. We also present stsearch , a syntactic search tool leveraging our approach. In contrast to past work, our approach supports syntactic search even for previously unparsable queries. We show empirically that stsea rch can support all tokenizable queries, while still providing results comparable to Semgrep for existing queries. Our work offers evidence that lightweight syntactic code search can accept in-progress specifications, potentially improving support for interactive settings. CCS Concepts: • Software and its engineering → Formal language definitions ; Software maintenance tools; • Information systems → Query representation; • Theory of computation → Tree languages.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656460", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Matute", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Wode", + "last_name": "Ni", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Titus", + "last_name": "Barik", + "institution": "Apple (United States)" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/MatuteNBCC24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656461", + "title": "Static Analysis for Checking the Disambiguation Robustness of Regular Expressions", + "abstract": "Regular expressions are commonly used for finding and extracting matches from sequence data. Due to the inherent ambiguity of regular expressions, a disambiguation policy must be considered for the match extraction problem, in order to uniquely determine the desired match out of the possibly many matches. The most common disambiguation policies are the POSIX policy and the greedy (PCRE) policy. The POSIX policy chooses the longest match out of the leftmost ones. The greedy policy chooses a leftmost match and further disambiguates using a greedy interpretation of Kleene iteration to match as many times as possible. The choice of disambiguation policy can affect the output of match extraction, which can be an issue for reusing regular expressions across regex engines. In this paper, we introduce and study the notion of disambiguation robustness for regular expressions. A regular expression is robust if its extraction semantics is indifferent to whether the POSIX or greedy disambiguation policy is chosen. This gives rise to a decision problem for regular expressions, which we prove to be PSPACE-complete. We propose a static analysis algorithm for checking the (non-)robustness of regular expressions and two performance optimizations. We have implemented the proposed algorithms and we have shown experimentally that they are practical for analyzing large datasets of regular expressions derived from various application domains.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656461", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + }, + { + "first_name": "Alexis Le", + "last_name": "Glaunec", + "institution": "Rice University" + }, + { + "first_name": "Wu Angela", + "last_name": "Li", + "institution": "Rice University" + }, + { + "first_name": "Agnishom", + "last_name": "Chattopadhyay", + "institution": "Rice University" + } + ], + "dblp_key": "journals/pacmpl/MamourasGLC24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656393", + "title": "Associated Effects: Flexible Abstractions for Effectful Programming", + "abstract": "We present associated effects, a programming language feature that enables type classes to abstract over the effects of their function signatures, allowing each type class instance to specify its concrete effects. Associated effects significantly increase the flexibility and expressive power of a programming language that combines a type and effect system with type classes. In particular, associated effects allow us to (i) abstract over total and partial functions, where partial functions may throw exceptions, (ii) abstract over immutable data structures and mutable data structures that have heap effects, and (iii) implement adaptors that combine type classes with algebraic effects. We implement associated effects as an extension of the Flix programming language and refactor the Flix Standard Library to use associated effects, significantly increasing its flexibility and expressive power. Specifically, we add associated effects to 11 type classes, which enables us to add 28 new type class instances. CCS Concepts: • Software and its engineering → Language features .", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656393", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Lutze", + "institution": "Aarhus University" + }, + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/LutzeM24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656454", + "title": "KATch: A Fast Symbolic Verifier for NetKAT", + "abstract": "We develop new data structures and algorithms for checking verification queries in NetKAT, a domain-specific language for specifying the behavior of network data planes. Our results extend the techniques obtained in prior work on symbolic automata and provide a framework for building efficient and scalable verification tools. We present KATch, an implementation of these ideas in Scala, featuring an extended set of NetKAT operators that are useful for expressing network-wide specifications, and a verification engine that constructs a bisimulation or generates a counter-example showing that none exists. We evaluate the performance of our implementation on real-world and synthetic benchmarks, verifying properties such as reachability and slice isolation, typically returning a result in well under a second, which is orders of magnitude faster than previous approaches. Our advancements underscore NetKAT’s potential as a practical, declarative language for network specification and verification.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656454", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark", + "last_name": "Moeller", + "institution": "Cornell University" + }, + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Cornell University" + }, + { + "first_name": "Olivier", + "last_name": "Bélanger", + "institution": "Galois (United States)" + }, + { + "first_name": "David", + "last_name": "Darais", + "institution": "Galois (United States)" + }, + { + "first_name": "Cole", + "last_name": "Schlesinger", + "institution": "Galois (United States)" + }, + { + "first_name": "Steffen", + "last_name": "Smolka", + "institution": "Google (United States)" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/MoellerJBDSSFS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656398", + "title": "The Functional Essence of Imperative Binary Search Trees", + "abstract": "Algorithms on restructuring binary search trees are typically presented in imperative pseudocode. Understandably so, as their performance relies on in-place execution, rather than the repeated allocation of fresh nodes in memory. Unfortunately, these imperative algorithms are notoriously difficult to verify as their loop invariants must relate the unfinished tree fragments being rebalanced. This paper presents several novel functional algorithms for accessing and inserting elements in a restructuring binary search tree that are as fast as their imperative counterparts; yet the correctness of these functional algorithms is established using a simple inductive argument. For each data structure, move-to-root, splay, and zip trees, this paper describes both a bottom-up algorithm using zippers and a top-down algorithm using a novel first-class constructor context primitive. The functional and imperative algorithms are equivalent: we mechanise the proofs establishing this in the Coq proof assistant using the Iris framework. This yields a first fully verified implementation of well known algorithms on binary search trees with performance on par with the fastest implementations in C.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656398", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Anton", + "last_name": "Lorenzen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wouter", + "last_name": "Swierstra", + "institution": "Utrecht University" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/LorenzenLSL24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656453", + "title": "Equivalence by Canonicalization for Synthesis-Backed Refactoring", + "abstract": "We present an enumerative program synthesis framework called component-based refactoring that can refactor “direct” style code that does not use library components into equivalent “combinator” style code that does use library components. This framework introduces a sound but incomplete technique to check the equivalence of direct code and combinator code called equivalence by canonicalization that does not rely on input-output examples or logical specifications. Moreover, our approach can repurpose existing compiler optimizations, leveraging decades of research from the programming languages community. We instantiated our new synthesis framework in two contexts: (i) higher-order functional combinators such as map and filter in the staticallytyped functional programming language Elm and (ii) high-performance numerical computing combinators provided by the NumPy library for Python. We implemented both instantiations in a tool called Cobbler and evaluated it on thousands of real programs to test the performance of the component-based refactoring framework in terms of execution time and output quality. Our work offers evidence that synthesis-backed refactoring can apply across a range of domains without specification beyond the input program.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656453", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Justin", + "last_name": "Lubin", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Jeremy", + "last_name": "Ferguson", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Kevin", + "last_name": "Ye", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Jacob", + "last_name": "Yim", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/LubinFYYC24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3658851", + "title": "A Family of Fast and Memory Efficient Lock- and Wait-Free Reclamation", + "abstract": "Historically, memory management based on lock-free reference counting was very inefficient, especially for read-dominated workloads. Thus, approaches such as epoch-based reclamation (EBR), hazard pointers (HP), or a combination thereof have received significant attention. EBR exhibits excellent performance but is blocking due to potentially unbounded memory usage. In contrast, HP are non-blocking and achieve good memory efficiency but are much slower. Moreover, HP are only lock-free in the general case. Recently, several new memory reclamation approaches such as WFE and Hyaline have been proposed. WFE achieves wait-freedom, but is less memory efficient and performs suboptimally in oversubscribed scenarios; Hyaline achieves higher performance and memory efficiency, but lacks wait-freedom. We present a family of non-blocking memory reclamation schemes, called Crystalline, that simultaneously addresses the challenges of high performance, high memory efficiency, and wait-freedom. Crystalline can guarantee complete wait-freedom even when threads are dynamically recycled, asynchronously reclaims memory in the sense that any thread can reclaim memory retired by any other thread, and ensures (an almost) balanced reclamation workload across all threads. The latter two properties result in Crystalline’s high performance and memory efficiency. Simultaneously ensuring all three properties requires overcoming unique challenges. Crystalline supports ubiquitous x86-64 and ARM64 architectures, while achieving superior throughput than prior fast schemes such as EBR as the number of threads grows. We also accentuate that many recent approaches, unlike HP, lack strict non-blocking guarantees when used with multiple data structures. By providing full wait-freedom, Crystalline addresses this problem as well.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3658851", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ruslan", + "last_name": "Nikolaev", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Binoy", + "last_name": "Ravindran", + "institution": "Virginia Tech" + } + ], + "dblp_key": "journals/pacmpl/NikolaevR24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656452", + "title": "Falcon: A Scalable Analytical Cache Model", + "abstract": "Compilers often use performance models to decide how to optimize code. This is often preferred over using hardware performance measurements, since hardware measurements can be expensive, limited by hardware availability, and makes the output of compilation non-deterministic. Analytical models, on the other hand, serve as efficient and noise-free performance indicators. Since many optimizations focus on improving memory performance, memory cache miss rate estimations can serve as an effective and noise-free performance indicator for superoptimizers, worst-case execution time analyses, manual program optimization, and many other performance-focused use cases. Existing methods to model the cache behavior of affine programs work on small programs such as those in the Polybench benchmark but do not scale to the larger programs we would like to optimize in production, which can be orders of magnitude bigger by lines of code. These analytical approaches hand off the whole program to a Presburger solver and perform expensive mathematical operations on the huge resulting formulas. We develop a scalable cache model for affine programs that splits the computation into smaller pieces that do not trigger the worst-case asymptotic behavior of these solvers. We evaluate our approach on 46 TorchVision neural networks, finding that our model has a geomean runtime of 44.9 seconds compared to over 32 minutes for the state-of-the-art prior cache model, and the latter is actually smaller than the true value because the prior model reached our four-hour time limit on 54% of the networks, and this limit was never reached by our tool. Our model exploits parallelism effectively: running it on sixteen cores is 8.2x faster than running it single-threaded. While the state-of-the-art model takes over four hours to analyze a majority of the benchmark programs, Falcon produces results in at most 3 minutes and 3 seconds; moreover, after a local modification to the program being analyzed, our model efficiently updates the predictions in 513 ms on average (geomean). Thus, we provide the first scalable analytical cache model. CCS Concepts: • Software and its engineering → Compilers .", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656452", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Arjun", + "last_name": "Pitchanathan", + "institution": "University of Edinburgh" + }, + { + "first_name": "Kunwar Shaanjeet Singh", + "last_name": "Grover", + "institution": "Advanced Micro Devices (United Kingdom)" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/PitchanathanGG24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656384", + "title": "A Proof Recipe for Linearizability in Relaxed Memory Separation Logic", + "abstract": "Linearizability is the de facto standard for correctness of concurrent objects–it essentially says that all the object’s operations behave as if they were atomic. There have been a number of recent advances in developing increasingly strong linearizability specifications for relaxed memory consistency (RMC), but scalable proof methods for these specifications do not exist due to the challenges arising from out-of-order executions (requiring event reordering) and selected synchronization (requiring tracking of view transfers). We propose a proof recipe for the linearizable history specifications by Dang et al . in the Iris-based iRC11 concurrent separation logic in Coq. Key to our proof recipe is the notion of object modification order (OMO) , which generalizes the modification order of the C11 memory model to an object-local setting. Using OMO we minimize the conditions that need to be proved for event reordering. To enable proof reuse for concurrent libraries that are built on top of others, OMO provides the novel notion of a commit-with relation that connects the linearization points of the lower and upper libraries. Using our recipe, we verify the linearizability of the Michael–Scott queue, the elimination stack, and Folly’s MPMC queue in RMC for the first time; and verify stronger specifications of a spinlock and atomic reference counting in RMC than prior work.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656384", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sunho", + "last_name": "Park", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jaewoo", + "last_name": "Kim", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Ike", + "last_name": "Mulder", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Jaehwang", + "last_name": "Jung", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Janggun", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ParkKMJLKK24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656438", + "title": "Towards Trustworthy Automated Program Verifiers: Formally Validating Translations into an Intermediate Verification Language", + "abstract": "Automated program verifiers are typically implemented using an intermediate verification language (IVL), such as Boogie or Why3. A verifier front-end translates the input program and specification into an IVL program, while the back-end generates proof obligations for the IVL program and employs an SMT solver to discharge them. Soundness of such verifiers therefore requires that the front-end translation faithfully captures the semantics of the input program and specification in the IVL program, and that the back-end reports success only if the IVL program is actually correct. For a verification tool to be trustworthy, these soundness conditions must be satisfied by its actual implementation , not just the program logic it uses. In this paper, we present a novel validation methodology that, given a formal semantics for the input language and IVL, provides formal soundness guarantees for front-end implementations. For each run of the verifier, we automatically generate a proof in Isabelle showing that the correctness of the produced IVL program implies the correctness of the input program. This proof can be checked independently from the verifier, in Isabelle, and can be combined with existing work on validating back-ends to obtain an end-to-end soundness result. Our methodology based on forward simulation employs several modularisation strategies to handle the large semantic gap between the input language and the IVL, as well as the intricacies of practical, optimised translations. We present our methodology for the widely-used Viper and Boogie languages. Our evaluation shows that it is effective in validating the translations performed by the existing Viper implementation.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656438", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G.", + "last_name": "Parthasarathy", + "institution": "ETH Zurich" + }, + { + "first_name": "Thibault", + "last_name": "Dardinier", + "institution": "ETH Zurich" + }, + { + "first_name": "Benjamin", + "last_name": "Bonneau", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/ParthasarathyDBMS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656387", + "title": "SMT Theory Arbitrage: Approximating Unbounded Constraints using Bounded Theories", + "abstract": "SMT solvers are foundational tools for reasoning about constraints in practical problems both within and outside program analysis. Faster SMT solving improves the performance of practical tools and expands the set of tractable problems. Existing approaches to improving solver performance either focus on general algorithms applied below the level of individual theories, or focus on optimizations within a single theory. Unbounded constraints in which the number of possible variable values is infinite, such as real numbers and integers, pose a particularly difficult challenge for solvers. Bounded constraints in which the set of possible values is finite such as bitvectors and floating-point numbers, on the other hand, are decidable and have been the subject of extensive performance improvement efforts. This paper introduces a theory arbitrage: we transform unbounded constraints, which are often expensive to solve, into bounded constraints, which are typically cheaper to solve. By converting unbounded problems into bounded ones, theory arbitrage takes advantage of better performance on bounded constraints and unlocks optimization techniques that only apply to bounded theories. The transformation is achieved by harnessing a novel abstract interpretation strategy to infer bounds. The bounded transformed constraint is then an underapproximation of the semantics of the unbounded original. We realize our method for the theories of integers and real numbers with a practical tool (STAUB). Our evaluation demonstrates that theory arbitrage alone can speed up individual constraints by orders of magnitude and achieve up to a 1.4 × speedup on average across nonlinear integer benchmarks. Furthermore, it enables the use of the recent compiler optimization-based technique SLOT for unbounded SMT theories, unlocking a further speedup of up to 3 × . Finally, we incorporate STAUB into a practical termination proving tool and observe an overall 9 % improvement in performance.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656387", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Mikek", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/MikekZ24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656380", + "title": "Robust Resource Bounds with Static Analysis and Bayesian Inference", + "abstract": "There are two approaches to automatically deriving symbolic worst-case resource bounds for programs: static analysis of the source code and data-driven analysis of cost measurements obtained by running the program. Static resource analysis is usually sound but incomplete. Data-driven analysis can always return a result, but its lack of robustness often leads to unsound results. This paper presents the design, implementation, and empirical evaluation of hybrid resource bound analyses that tightly integrate static analysis and data-driven analysis. The static analysis part builds on automatic amortized resource analysis (AARA), a state-of-the-art type-based resource analysis method that performs cost bound inference using linear optimization. The data-driven part is rooted in novel Bayesian modeling and inference techniques that improve upon previous data-driven analysis methods by reporting an entire probability distribution over likely resource cost bounds. A key innovation is a new type inference system called Hybrid AARA that coherently integrates Bayesian inference into conventional AARA, combining the strengths of both approaches. Hybrid AARA is proven to be statistically sound under standard assumptions on the runtime cost data. An experimental evaluation on a challenging set of benchmarks shows that Hybrid AARA (i) effectively mitigates the incompleteness of purely static resource analysis; and (ii) is more accurate and robust than purely data-driven resource analysis.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656380", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Long", + "last_name": "Pham", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/PhamSH24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656402", + "title": "VESTA: Power Modeling with Language Runtime Events", + "abstract": "Power modeling is an essential building block for computer systems in support of energy optimization, energy profiling, and energy-aware application development. We introduce Vesta , a novel approach to modeling the power consumption of applications with one key insight: language runtime events are often correlated with a sustained level of power consumption. When compared with the established approach of power modeling based on hardware performance counters (HPCs), Vesta has the benefit of solely requiring application-scoped information and enabling a higher level of explainability, while achieving comparable or even higher precision. Through experiments performed on 37 real-world applications on the Java Virtual Machine (JVM), we find the power model built by Vesta is capable of predicting energy consumption with a mean absolute percentage error of 1.56 % , while the monitoring of language runtime events incurs small performance and energy overhead.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656402", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Raskind", + "institution": "Binghamton University" + }, + { + "first_name": "Timur", + "last_name": "Babakol", + "institution": "Binghamton University" + }, + { + "first_name": "Khaled", + "last_name": "Mahmoud", + "institution": "Binghamton University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + } + ], + "dblp_key": "journals/pacmpl/RaskindBML24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656423", + "title": "LiDO: Linearizable Byzantine Distributed Objects with Refinement-Based Liveness Proofs", + "abstract": "Byzantine fault-tolerant state machine replication (SMR) protocols, such as PBFT, HotStuff, and Jolteon, are essential for modern blockchain technologies. However, they are challenging to implement correctly because they have to deal with any unexpected message from Byzantine peers and ensure safety and liveness at all times. Many formal frameworks have been developed to verify the safety of SMR implementations, but there is still a gap in the verification of their liveness. Existing liveness proofs are either limited to the network level or do not cover popular partially synchronous protocols. We introduce LiDO, a consensus model that enables the verification of both safety and liveness of implementations through refinement. We observe that current consensus models cannot handle liveness because they do not include a pacemaker state. We show that by adding a pacemaker state to the LiDO model, we can express the liveness properties of SMR protocols as a few safety properties that can be easily verified by refinement proofs. Based on our LiDO model, we provide mechanized safety and liveness proofs for both unpipelined and pipelined Jolteon in Coq. This is the first mechanized liveness proof for a byzantine consensus protocol with non-trivial optimizations such as pipelining.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656423", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Longfei", + "last_name": "Qiu", + "institution": "Yale University" + }, + { + "first_name": "Y. K.", + "last_name": "Kim", + "institution": "Yale University" + }, + { + "first_name": "Ji-Yong", + "last_name": "Shin", + "institution": "Northeastern University" + }, + { + "first_name": "Jieung", + "last_name": "Kim", + "institution": "Inha University" + }, + { + "first_name": "Wolf", + "last_name": "Honoré", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/QiuKSKHS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656395", + "title": "Floating-Point TVPI Abstract Domain", + "abstract": "Floating-point arithmetic is natively supported in hardware and the preferred choice when implementing numerical software in scientific or engineering applications. However, such programs are notoriously hard to analyze due to round-off errors and the frequent use of elementary functions such as log, arctan, or sqrt. In this work, we present the Two Variables per Inequality Floating-Point (TVPI-FP) domain, a numerical and constraint-based abstract domain designed for the analysis of floating-point programs. TVPI-FP supports all features of real-world floating-point programs including conditional branches, loops, and elementary functions and it is efficient asymptotically and in practice. Thus it overcomes limitations of prior tools that often are restricted to straight-line programs or require the use of expensive solvers. The key idea is the consistent use of interval arithmetic in inequalities and an associated redesign of all operators. Our extensive experiments show that TVPI-FP is often orders of magnitudes faster than more expressive tools at competitive, or better precision while also providing broader support for realistic programs with loops and conditionals.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656395", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Joao", + "last_name": "Rivera", + "institution": "ETH Zurich" + }, + { + "first_name": "Franz", + "last_name": "Franchetti", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/RiveraFP24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656388", + "title": "Compilation of Qubit Circuits to Optimized Qutrit Circuits", + "abstract": "Quantum computers are a revolutionary class of computational platforms that are capable of solving computationally hard problems. However, today’s quantum hardware is subject to noise and decoherence issues that together limit the scale and complexity of the quantum circuits that can be implemented. Recently, practitioners have developed qutrit-based quantum hardware platforms that compute over ∣ 0 ⟩ , ∣ 1 ⟩ , and ∣ 2 ⟩ states, and have presented circuit depth reduction techniques using qutrits’ higher energy ∣ 2 ⟩ states to temporarily store information. However, thus far, such quantum circuits that use higher order states for temporary storage need to be manually crafted by hardware designers. We present D are , an optimizing compiler for qutrit circuits that implement qubit computations. D are deploys a qutrit circuit decomposition algorithm and a rewrite engine to construct and optimize qutrit circuits. We evaluate D are against hand-optimized qutrit circuits and qubit circuits, and find D are delivers up to 65 % depth improvement over manual qutrit implementations, and 43-75% depth improvement over qubit circuits. We also perform a fidelity analysis and find DARE-optimized qutrit circuits deliver up to 8.9 × higher fidelity circuits than their manually implemented counterparts.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656388", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ritvik", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Sara", + "last_name": "Achour", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/SharmaA24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656420", + "title": "Wavefront Threading Enables Effective High-Level Synthesis", + "abstract": "Digital systems are growing in importance and computing hardware is growing more heterogeneous. Hardware design, however, remains laborious and expensive, in part due to the limitations of conventional hardware description languages (HDLs) like VHDL and Verilog. A longstanding research goal has been programming hardware like software, with high-level languages that can generate efficient hardware designs. This paper describes Kanagawa, a language that takes a new approach to combine the programmer productivity benefits of traditional High-Level Synthesis (HLS) approaches with the expressibility and hardware efficiency of Register-Transfer Level (RTL) design. The language’s concise syntax, matched with a hardware design-friendly execution model, permits a relatively simple toolchain to map high-level code into efficient hardware implementations.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656420", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Blake", + "last_name": "Pelton", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Adam", + "last_name": "Sapek", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ken", + "last_name": "Eguro", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Daniel", + "last_name": "Lo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Alessandro", + "last_name": "Forin", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Matt", + "last_name": "Humphrey", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jin-wen", + "last_name": "Xi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "D. J.", + "last_name": "Cox", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Rajas H.", + "last_name": "Karandikar", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Johannes de Fine", + "last_name": "Licht", + "institution": "ETH Zurich" + }, + { + "first_name": "Evgeny", + "last_name": "Babin", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Adrian M.", + "last_name": "Caulfield", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Doug", + "last_name": "Burger", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/PeltonSELFHXCKLBCB24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656413", + "title": "Quiver: Guided Abductive Inference of Separation Logic Specifications in Coq", + "abstract": "Over the past two decades, there has been a great deal of progress on verification of full functional correctness of programs using separation logic, sometimes even producing “foundational” proofs in proof assistants like Coq. Unfortunately, even though existing approaches to this problem provide significant support for automated verification, they still incur a significant specification overhead : the user must supply the specification against which the program is verified, and the specification may be long, complex, or tedious to formulate. In this paper, we introduce Quiver, the first technique for inferring functional correctness specifications in separation logic while simultaneously verifying foundationally that they are correct. To guide Quiver towards the final specification, we take hints from the user in the form of a specification sketch , and then complete the sketch using inference. To do so, Quiver introduces a new abductive deductive verification technique, which integrates ideas from abductive inference (for specification inference) together with deductive separation logic automation (for foundational verification). The result is that users have to provide some guidance, but significantly less than with traditional deductive verification techniques based on separation logic. We have evaluated Quiver on a range of case studies, including code from popular open-source libraries.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656413", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Simon", + "last_name": "Spies", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lennard", + "last_name": "Gäher", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/SpiesGSD24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656399", + "title": "Compositional Semantics for Shared-Variable Concurrency", + "abstract": "We revisit the fundamental problem of defining a compositional semantics for a concurrent programming language under sequentially consistent memory with the aim of equating the denotations of pieces of code if and only if these pieces induce the same behavior under all program contexts. While the denotational semantics presented by Brookes [Information and Computation 127, 2 (1996)] has been considered a definitive solution, we observe that Brookes’s full abstraction result crucially relies on the availability of an impractical whole-memory atomic read-modify-write instruction. In contrast, we consider a language with standard primitives, which apply to a single variable. For that language, we propose an alternative denotational semantics based on traces that track program write actions together with the writes expected from the environment, and equipped with several closure operators to achieve necessary abstraction. We establish the adequacy of the semantics, and demonstrate full abstraction for the case that the analyzed code segment is loop-free. Furthermore, we show that by including a whole-memory atomic read in the language, one obtains full abstraction for programs with loops. To gain confidence, our results are fully mechanized in Coq.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656399", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mikhail", + "last_name": "Svyatlovskiy", + "institution": "Tel Aviv University" + }, + { + "first_name": "Shai", + "last_name": "Mermelstein", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/SvyatlovskiyML24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656457", + "title": "Inductive Approach to Spacer", + "abstract": "The constrained Horn clause satisfiability problem is at the core of many automated verification methods, and S pacer is one of the most efficient solvers of this problem. The standard description of S pacer is based on an abstract transition system, dividing the whole procedure into small rules. This division makes individual rules easier to understand but, conversely, makes it difficult to discuss the procedure as a whole. As evidence of the difficulty in understanding the whole procedure, we point out that the claimed refutational completeness actually fails for several reasons, some of which were not present in the original version and subsequently added. It is also difficult to grasp the differences between S pacer and another procedure, such as GPDR. This paper aims to provide a better understanding of S pacer by developing a S pacer -like procedure defined by structural induction. We first formulate the problem to be solved inductively, then give its naive solver and transform it to obtain a S pacer -like procedure. Interestingly, our inductive approach almost unifies S pacer and GPDR, which differ in only one respect in our understanding. To demonstrate the usefulness of our inductive approach in understanding S pacer , we examine S pacer variants in the literature in terms of inductive procedures and discuss why they are not refutationally complete and how to fix them. We also implemented the proposed procedure and evaluated it experimentally.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656457", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/TsukadaU24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656404", + "title": "Refined Input, Degraded Output: The Counterintuitive World of Compiler Behavior", + "abstract": "To optimize a program, a compiler needs precise information about it. Significant effort is dedicated to improving the ability of compilers to analyze programs, with the expectation that more information results in better optimization. But this assumption does not always hold: due to unexpected interactions between compiler components and phase ordering issues, sometimes more information leads to worse optimization. This can lead to wasted research and engineering effort whenever compilers cannot efficiently leverage additional information. In this work, we systematically examine the extent to which additional information can be detrimental to compilers. We consider two types of information: dead code, i.e ., whether a program location is unreachable, and value ranges, i.e ., the possible values a variable can take at a specific program location. Given a seed program, we refine it with additional information and check whether this degrades the output. Based on this approach, we develop a fully automated and effective testing method for identifying such issues, and through an extensive evaluation and analysis, we quantify their existence and prevalence in widely used compilers. In particular, we have reported 59 cases in GCC and LLVM, of which 55 have been confirmed or fixed so far, highlighting the practical relevance and value of our findings. This work’s fresh perspective opens up a new direction in understanding and improving compilers.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656404", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Theodoros", + "last_name": "Theodoridis", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/TheodoridisS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656418", + "title": "From Batch to Stream: Automatic Generation of Online Algorithms", + "abstract": "Online streaming algorithms, tailored for continuous data processing, offer substantial benefits but are often more intricate to design than their offline counterparts. This paper introduces a novel approach for automatically synthesizing online streaming algorithms from their offline versions. In particular, we propose a novel methodology, based on the notion of relational function signature (RFS) , for deriving an online algorithm given its offline version. Then, we propose a concrete synthesis algorithm that is an instantiation of the proposed methodology. Our algorithm uses the RFS to decompose the synthesis problem into a set of independent subtasks and uses a combination of symbolic reasoning and search to solve each subproblem. We implement the proposed technique in a new tool called Opera and evaluate it on over 50 tasks spanning two domains: statistical computations and online auctions. Our results show that Opera can automatically derive the online version of the original algorithm for 98% of the tasks. Our experiments also demonstrate that Opera significantly outperforms alternative approaches, including adaptations of SyGuS solvers to this problem as well as two of Opera ’s own ablations.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656418", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ziteng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "A. Arun", + "last_name": "Prakash", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "Simon Fraser University" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/WangPPWD24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656443", + "title": "Compatible Branch Coverage Driven Symbolic Execution for Efficient Bug Finding", + "abstract": "Symbolic execution is a powerful technique for bug finding by generating test inputs to systematically explore all feasible paths within a given threshold. However, its practical usage is often limited by the path explosion problem. In this paper, we propose compatible branch coverage driven symbolic execution for efficient bug finding. Our new technique owns a novel path-pruning strategy obtained from program dependency analysis to effectively avoid unnecessary explorations. Specifically, based on a Compatible Branch Set , our technique directs symbolic execution to explore feasible branches while soundly pruning redundant paths that have no new contributions to branch coverage. We have implemented our approach atop KLEE and conducted experiments on a set of programs from Siemens Suite, GNU Coreutils, and other real-world programs. Experimental results show that, compared with the state-of-the-art symbolic execution techniques, our approach always uses significantly less time to reproduce bugs while achieving the same or better branch coverage. On average, our approach got over 45% path reduction and 3x speedup on the GNU Coreutils programs", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656443", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qiuping", + "last_name": "Yi", + "institution": "Beijing University of Posts and Telecommunications" + }, + { + "first_name": "Yifan", + "last_name": "Yu", + "institution": "Beijing University of Posts and Telecommunications" + }, + { + "first_name": "Guowei", + "last_name": "Yang", + "institution": "The University of Queensland" + } + ], + "dblp_key": "journals/pacmpl/YiYY24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656416", + "title": "Consolidating Smart Contracts with Behavioral Contracts", + "abstract": "Ensuring the reliability of smart contracts is of vital importance due to the wide adoption of smart contract programs in decentralized financial applications. However, statically checking many rich properties of smart contract programs can be challenging. On the other hand, dynamic validation approaches have shown promise for widespread adoption in practice. Nevertheless, as part of the programming environment for smart contracts, existing dynamic validation approaches have not provided programmers with a notion to clearly articulate the interface between components, especially for addresses representing opaque contract instances. We argue that the “design-by-contract” approach should complement the development of smart contract programs. Unfortunately, there is limited linguistic support for it in existing smart contract languages. In this paper, we design a Solidity language extension, ConSol, that supports behavioral contracts. ConSol provides programmers with a modular specification and monitoring system for both functional and latent address behaviors. The key capability of ConSol is to attach specifications to first-class addresses and monitor violations when invoking these addresses. We evaluate ConSol using 20 real-world cases, demonstrating its effectiveness in expressing critical conditions and preventing attacks. Additionally, we assess ConSol’s efficiency and compare gas consumption with programs fixed with manually inserted assertions, showing that our approach introduces only marginal gas overhead. By separating specifications and implementations using behavioral contracts, ConSol assists programmers in writing more robust and readable smart contracts.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656416", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Danning", + "last_name": "Xie", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Wuqi", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Yongwei", + "last_name": "Yuan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Zhuo", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WeiXZYZ24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656432", + "title": "Static Posterior Inference of Bayesian Probabilistic Programming via Polynomial Solving", + "abstract": "In Bayesian probabilistic programming, a central problem is to estimate the normalised posterior distribution (NPD) of a probabilistic program with conditioning via score (a.k.a. observe ) statements. Most previous approaches address this problem by Markov Chain Monte Carlo and variational inference, and therefore could not generate guaranteed outcomes within a finite time limit. Moreover, existing methods for exact inference either impose syntactic restrictions or cannot guarantee successful inference in general. In this work, we propose a novel automated approach to derive guaranteed bounds for NPD via polynomial solving. We first establish a fixed-point theorem for the wide class of score-at-end Bayesian probabilistic programs that terminate almost-surely and have a single bounded score statement at program termination. Then, we propose a multiplicative variant of Optional Stopping Theorem (OST) to address score-recursive Bayesian programs where score statements with weights greater than one could appear inside a loop. Bayesian nonparametric models, enjoying a renaissance in statistics and machine learning, can be represented by score-recursive Bayesian programs and are difficult to handle due to an integrability issue. Finally, we use polynomial solving to implement our fixed-point theorem and OST variant. To improve the accuracy of the polynomial solving, we further propose a truncation operation and the synthesis of multiple bounds over various program inputs. Our approach can handle Bayesian probabilistic programs with unbounded while loops and continuous distributions with infinite supports. Experiments over a wide range of benchmarks show that compared with the most relevant approach (Beutner et al. , PLDI 2022) for guaranteed NPD analysis via recursion unrolling, our approach is more time efficient and derives comparable or even tighter NPD bounds. Furthermore, our approach can handle score-recursive programs which previous approaches could not.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656432", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peixin", + "last_name": "Wang", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Tengshun", + "last_name": "Yang", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Guanyan", + "last_name": "Li", + "institution": "University of Oxford" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "Nanyang Technological University" + } + ], + "dblp_key": "journals/pacmpl/WangYFLO24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656417", + "title": "Scaling Type-Based Points-to Analysis with Saturation", + "abstract": "Designing a whole-program static analysis requires trade-offs between precision and scalability. While a context-insensitive points-to analysis is often considered a good compromise, it still has non-linear complexity that leads to scalability problems when analyzing large applications. On the other hand, rapid type analysis scales well but lacks precision. We use saturation in a context-insensitive type-based points-to analysis to make it as scalable as a rapid type analysis, while preserving most of the precision of the points-to analysis. With saturation, the points-to analysis only propagates small points-to sets for variables. If a variable can have more values than a certain threshold, the variable and all its usages are considered saturated and no longer analyzed. Our implementation in the points-to analysis of GraalVM Native Image, a closed-world approach to build standalone binaries for Java applications, shows that saturation allows GraalVM Native Image to analyze large Java applications with hundreds of thousands of methods in less than two minutes.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656417", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Christian", + "last_name": "Wimmer", + "institution": "Oracle (United States)" + }, + { + "first_name": "Codruţ", + "last_name": "Stancu", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Kozák", + "institution": "Oracle (United States)" + }, + { + "first_name": "Thomas", + "last_name": "Würthinger", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/WimmerSKW24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656400", + "title": "Falcon: A Fused Approach to Path-Sensitive Sparse Data Dependence Analysis", + "abstract": "This paper presents a scalable path- and context-sensitive data dependence analysis. The key is to address the aliasing-path-explosion problem when enforcing a path-sensitive memory model. Specifically, our approach decomposes the computational efforts of disjunctive reasoning into 1) a context- and semi-path-sensitive analysis that concisely summarizes data dependence as the symbolic and storeless value-flow graphs, and 2) a demand-driven phase that resolves transitive data dependence over the graphs, piggybacking the computation of fully path-sensitive pointer information with the resolution of data dependence of interest. We have applied the approach to two clients, namely thin slicing and value-flow bug finding. Using a suite of 16 C / C + + programs ranging from 13 KLoC to 8 MLoC, we compare our techniques against a diverse group of state-of-the-art analyses, illustrating the significant precision and scalability advantages of our approach.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656400", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Peisen", + "last_name": "Yao", + "institution": "Zhejiang University" + }, + { + "first_name": "Jinguo", + "last_name": "Zhou", + "institution": "" + }, + { + "first_name": "Xiao", + "last_name": "Xiao", + "institution": "" + }, + { + "first_name": "Qingkai", + "last_name": "Shi", + "institution": "Nanjing University" + }, + { + "first_name": "Rongxin", + "last_name": "Wu", + "institution": "Xiamen University" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/YaoZXSWZ24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656397", + "title": "The T-Complexity Costs of Error Correction for Control Flow in Quantum Computation", + "abstract": "Numerous quantum algorithms require the use of quantum error correction to overcome the intrinsic unreliability of physical qubits. However, quantum error correction imposes a unique performance bottleneck, known as T -complexity, that can make an implementation of an algorithm as a quantum program run more slowly than on idealized hardware. In this work, we identify that programming abstractions for control flow, such as the quantum if-statement, can introduce polynomial increases in the T -complexity of a program. If not mitigated, this slowdown can diminish the computational advantage of a quantum algorithm. To enable reasoning about the costs of control flow, we present a cost model that a developer can use to accurately analyze the T -complexity of a program under quantum error correction and pinpoint the sources of slowdown. To enable the mitigation of these costs, we present a set of program-level optimizations that a developer can use to rewrite a program to reduce its T -complexity, predict the T -complexity of the optimized program using the cost model, and then compile it to an efficient circuit via a straightforward strategy. We implement the program-level optimizations in Spire, an extension of the Tower quantum compiler. Using a set of 11 benchmark programs that use control flow, we empirically show that the cost model is accurate, and that Spire's optimizations recover programs that are asymptotically efficient, meaning their runtime T -complexity under error correction is equal to their time complexity on idealized hardware. Our results show that optimizing a program before it is compiled to a circuit can yield better results than compiling the program to an inefficient circuit and then invoking a quantum circuit optimizer found in prior work. For our benchmarks, only 2 of 8 tested quantum circuit optimizers recover circuits with asymptotically efficient T -complexity. Compared to these 2 optimizers, Spire uses 54 × − 2400 × less compile time.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656397", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Charles", + "last_name": "Yuan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/YuanC24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656440", + "title": "Bringing the WebAssembly Standard up to Speed with SpecTec", + "abstract": "WebAssembly (Wasm) is a portable low-level bytecode language and virtual machine that has seen increasing use in a variety of ecosystems. Its specification is unusually rigorous – including a full formal semantics for the language – and every new feature must be specified in this formal semantics, in prose, and in the official reference interpreter before it can be standardized. With the growing size of the language, this manual process with its redundancies has become laborious and error-prone, and in this work, we offer a solution. We present SpecTec, a domain-specific language (DSL) and toolchain that facilitates both the Wasm specification and the generation of artifacts necessary to standardize new features. SpecTec serves as a single source of truth — from a SpecTec definition of the Wasm semantics, we can generate a typeset specification, including formal definitions and prose pseudocode descriptions, and a meta-level interpreter. Further backends for test generation and interactive theorem proving are planned. We evaluate SpecTec’s ability to represent the latest Wasm 2.0 and show that the generated meta-level interpreter passes 100% of the applicable official test suite. We show that SpecTec is highly effective at discovering and preventing errors by detecting historical errors in the specification that have been corrected and ten errors in five proposals ready for inclusion in the next version of Wasm. Our ultimate aim is that SpecTec should be adopted by the Wasm standards community and used to specify future versions of the standard.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656440", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dongjun", + "last_name": "Youn", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Wonho", + "last_name": "Shin", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jaehyun", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Joachim", + "last_name": "Breitner", + "institution": "" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "Matija", + "last_name": "Pretnar", + "institution": "University of Ljubljana" + }, + { + "first_name": "Xiaojia", + "last_name": "Rao", + "institution": "Imperial College London" + }, + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "University of Cambridge" + }, + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/YounSLRBGLPRWR24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656426", + "title": "Compilation of Modular and General Sparse Workspaces", + "abstract": "Recent years have seen considerable work on compiling sparse tensor algebra expressions. This paper addresses a shortcoming in that work, namely how to generate efficient code (in time and space) that scatters values into a sparse result tensor. We address this shortcoming through a compiler design that generates code that uses sparse intermediate tensors (sparse workspaces) as efficient adapters between compute code that scatters and result tensors that do not support random insertion. Our compiler automatically detects sparse scattering behavior in tensor expressions and inserts necessary intermediate workspace tensors. We present an algorithm template for workspace insertion that is the backbone of our code generation algorithm. Our algorithm template is modular by design, supporting sparse workspaces that span multiple user-defined implementations. Our evaluation shows that sparse workspaces can be up to 27.12 × faster than the dense workspaces of prior work. On the other hand, dense workspaces can be up to 7.58 × faster than the sparse workspaces generated by our compiler in other situations, which motivates our compiler design that supports both. Our compiler produces sequential code that is competitive with hand-optimized linear and tensor algebra libraries on the expressions they support, but that generalizes to any other expression. Sparse workspaces are also more memory efficient than dense workspaces as they compress away zeros. This compression can asymptotically decrease memory usage, enabling tensor computations on data that would otherwise run out of memory.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656426", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Genghan", + "last_name": "Zhang", + "institution": "Stanford University" + }, + { + "first_name": "Olivia", + "last_name": "Hsu", + "institution": "Stanford University" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/ZhangHK24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656408", + "title": "Automated Verification of Fundamental Algebraic Laws", + "abstract": "Algebraic laws of functions in mathematics – such as commutativity, associativity, and idempotence – are often used as the basis to derive more sophisticated properties of complex mathematical structures and are heavily used in abstract computational thinking. Algebraic laws of functions in coding , however, are rarely considered. Yet, they are essential. For example, commutativity and associativity are crucial to ensure correctness of a variety of software systems in numerous domains, such as compiler optimization, big data processing, data flow processing, machine learning or distributed algorithms and data structures. Still, most programming languages lack built-in mechanisms to enforce and verify that operations adhere to such properties. In this paper, we propose a verifier specialized on a set of fundamental algebraic laws that ensures that such laws hold in application code. The verifier can conjecture auxiliary properties and can reason about both equalities and inequalities of expressions, which is crucial to prove a given property when other competitors do not succeed. We implement these ideas in the Propel verifier. Our evaluation against five state-of-the-art verifiers on a total of 142 instances of algebraic properties shows that Propel is able to automatically deduce algebraic properties in different domains that rely on such properties for correctness, even in cases where competitors fail to verify the same properties or time out.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656408", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "George", + "last_name": "Zakhour", + "institution": "University of St.Gallen" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "University of St.Gallen" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "University of St.Gallen" + } + ], + "dblp_key": "journals/pacmpl/ZakhourWS24", + "venue": "pldi", + "year": 2024 + }, + { + "paper_id": "10.1145/3656433", + "title": "A HAT Trick: Automatically Verifying Representation Invariants using Symbolic Finite Automata", + "abstract": "Functional programs typically interact with stateful libraries that hide state behind typed abstractions. One particularly important class of applications are data structure implementations that rely on such libraries to provide a level of efficiency and scalability that may be otherwise difficult to achieve. However, because the specifications of the methods provided by these libraries are necessarily general and rarely specialized to the needs of any specific client, any required application-level invariants must often be expressed in terms of additional constraints on the (often) opaque state maintained by the library. In this paper, we consider the specification and verification of such representation invariants using symbolic finite automata (SFA). We show that SFAs can be used to succinctly and precisely capture fine-grained temporal and data-dependent histories of interactions between functional clients and stateful libraries. To facilitate modular and compositional reasoning, we integrate SFAs into a refinement type system to qualify stateful computations resulting from such interactions. The particular instantiation we consider, Hoare Automata Types (HATs), allows us to both specify and automatically type-check the representation invariants of a datatype, even when its implementation depends on stateful library methods that operate over hidden state. We also develop a new bidirectional type checking algorithm that implements an efficient subtyping inclusion check over HATs, enabling their translation into a form amenable for SMT-based automated verification. We present extensive experimental results on an implementation of this algorithm that demonstrates the feasibility of type-checking complex and sophisticated HAT-specified OCaml data structure implementations layered on top of stateful library APIs.", + "date": "2024-06-20", + "link": "https://doi.org/10.1145/3656433", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Z.", + "last_name": "Zhou", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Qianchuan", + "last_name": "Ye", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/ZhouYDJ24", + "venue": "pldi", + "year": 2024 + } +] \ No newline at end of file diff --git a/data/pl_conferences/pldi/2025.json b/data/pl_conferences/pldi/2025.json new file mode 100644 index 0000000..76e218c --- /dev/null +++ b/data/pl_conferences/pldi/2025.json @@ -0,0 +1,2996 @@ +[ + { + "paper_id": "10.1145/3729289", + "title": "A Hybrid Approach to Semi-automated Rust Verification", + "abstract": "We propose a hybrid approach to end-to-end Rust verification where the proof effort is split into powerful automated verification of safe Rust and targeted semi-automated verification of unsafe Rust. To this end, we present Gillian-Rust, a proof-of-concept semi-automated verification tool built on top of the Gillian platform that can reason about type safety and functional correctness of unsafe code. Gillian-Rust automates a rich separation logic for real-world Rust, embedding the lifetime logic of RustBelt and the parametric prophecies of RustHornBelt, and is able to verify real-world Rust standard library code with only minor annotations and with verification times orders of magnitude faster than those of comparable tools. We link Gillian-Rust with Creusot, a state-of-the-art verifier for safe Rust, by providing a systematic encoding of unsafe code specifications that Creusot can use but cannot verify, demonstrating the feasibility of our hybrid approach.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729289", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sacha-Élie", + "last_name": "Ayoun", + "institution": "Imperial College London" + }, + { + "first_name": "Xavier", + "last_name": "Denis", + "institution": "ETH Zurich" + }, + { + "first_name": "Petar", + "last_name": "Maksimović", + "institution": "Google DeepMind (United Kingdom)" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/AyounDMG25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729249", + "title": "RefinedProsa: Connecting Response-Time Analysis with C Verification for Interrupt-Free Schedulers", + "abstract": "There has been a recent upsurge of interest in formal, machine-checked verification of timing guarantees for C implementations of real-time system schedulers. However, prior work has only considered tick-based schedulers, which enjoy a clearly defined notion of time: the time \"quantum\". In this work, we present a new approach to real-time systems verification for interrupt-free schedulers, which are commonly used in deeply embedded and resource-constrained systems but which do not enjoy a natural notion of periodic time. Our approach builds on and connects two recently developed Rocq-based systems—RefinedC (for foundational C verification) and Prosa (for verified response-time analysis)—adapting the former to reason about timed traces and the latter to reason about overheads. We apply the resulting system, which we call RefinedProsa, to verify Rössl, a simple yet representative, fixed-priority, non-preemptive, interrupt-free scheduler implemented in C.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729249", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Kimaya", + "last_name": "Bedarkar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Laila", + "last_name": "Elbeheiry", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Lennard", + "last_name": "Gäher", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Björn B.", + "last_name": "Brandenburg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/BedarkarESGBDG25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729336", + "title": "A Concurrent Approach to String Transformation Synthesis", + "abstract": "Program synthesis aims at the automatic generation of programs based on given specifications. Despite significant progress, the inherent complexity of synthesis tasks and the interplay among intention, invention and adaptation limit its scope. A promising yet challenging avenue is the integration of concurrency to enhance synthesis algorithms. While some efforts have applied basic concurrency by parallelizing search spaces, more intricate synthesis scenarios involving interdependent subproblems remain unexplored. In this paper, we focus on string transformation as the target domain and introduce the first concurrent synthesis algorithm that enables asynchronous coordination between deductive and enumerative processes, featuring an asynchronous deducer for dynamic task decomposition, a versatile enumerator for resolving enumeration requests, and an accumulative case splitter for if-then-else condition/branch search and assembling. Our implementation, Synthphonia exhibits substantial performance improvements over state-of-the-art synthesizers, successfully solving 116 challenging string transformation tasks for the first time.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729336", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yuantian", + "last_name": "Ding", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/DingQ25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729311", + "title": "PulseCore: An Impredicative Concurrent Separation Logic for Dependently Typed Programs", + "abstract": "PulseCore is a new program logic suitable for intrinsic proofs of higher-order, stateful, concurrent, dependently typed programs. It provides many of the features of a modern, concurrent separation logic, including dynamically allocated impredicative invariants, higher-order ghost state, step-indexing with later credits, and support for user-defined ghost state constructions. PulseCore is developed foundationally within the F★ programming language with fully mechanized proofs, and is applicable to F★ programs itself. To evaluate our work, we use Pulse, a surface language within F★ for PulseCore, to develop a range of program proofs. Illustrating its suitability for proving higher-order concurrent programs, we present a verified library for task pools in the style of OCaml5, together with some verified task-parallel programs. Next, we present various data structures and synchronization primitives, including a barrier that requires the use of higher-order ghost state. Finally, we present a verified implementation of the DICE Protection Environment, an industry standard secure boot protocol. Taken together, our evaluation consists of more than 31,000 lines of verified code in a range of settings, providing evidence that PulseCore is both highly expressive as well as practical for a variety of program proof applications.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729311", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Ebner", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Thibault", + "last_name": "Dardinier", + "institution": "ETH Zurich" + }, + { + "first_name": "Megan", + "last_name": "Frisella", + "institution": "University of Washington" + }, + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/EbnerMRDFRS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729296", + "title": "Efficient, Portable, Census-Polymorphic Choreographic Programming", + "abstract": "Choreographic programming (CP) is a paradigm for implementing distributed systems that uses a single global program to define the actions and interactions of all participants. Library-level CP implementations, like HasChor, integrate well with mainstream programming languages but have several limitations: Their conditionals require extra communication; they require specific host-language features (e.g., monads); and they lack support for programming patterns that are essential for implementing realistic distributed applications. We make three contributions to library-level CP to specifically address these challenges. First, we propose and formalize conclaves and multiply-located values , which enable efficient conditionals in library-level CP without redundant communication. Second, we propose census polymorphism , a technique for abstracting over the number of participants in a choreography. Third, we introduce a design pattern for library-level CP in host languages without support for monads. We demonstrate these contributions via implementations in Haskell, Rust, and TypeScript.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729296", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mako", + "last_name": "Bates", + "institution": "University of Vermont" + }, + { + "first_name": "Shun", + "last_name": "Kashiwa", + "institution": "University of California San Diego" + }, + { + "first_name": "Syed", + "last_name": "Jafri", + "institution": "University of Vermont" + }, + { + "first_name": "Gan", + "last_name": "Shen", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Joseph P.", + "last_name": "Near", + "institution": "University of Vermont" + } + ], + "dblp_key": "journals/pacmpl/BatesKJSKN25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729337", + "title": "RRR-SMR: Reduce, Reuse, Recycle: Better Methods for Practical Lock-Free Data Structures", + "abstract": "Traditionally, most concurrent algorithms rely on safe memory reclamation (SMR) schemes for manual memory management. SMR schemes such as epoch-based reclamation (EBR) and hazard pointers (HP) are typically viewed as the only solution for memory recycling. When using SMR, a new object needs to be allocated whenever something new is added to a data structure. However, in more complex scenarios, the same object may need to be moved between different data structures (e.g., moving a node from one list to another, and then back to the original list) in a copy-free manner, i.e., without deallocating and allocating the node again. It is typically impossible for two reasons: (1) the ABA problem would still arise even when using SMR since the same pointer can reappear (without going through the full SMR cycle) if the same node eventually ends up back in the original data structure; (2) while in simple queues and stacks, nodes can immediately be recycled, it is unclear how to adapt data structures which use non-trivial traversal and two-phase deletion strategies, e.g., linked lists, skip lists, hash tables, trees, etc., where it is seemingly impossible to always immediately move (logically) deleted objects since they might still be accessed by other threads. We propose a general method of creating RRR (Reduce, Reuse, Recycle) data structures to allow safe memory recycling when using SMR which addresses the above-mentioned problems. Our method is applicable to linked lists, skip lists, hash tables, Natarajan-Mittal tree, and other data structures. We also discuss and propose a specialized approach -- a more efficient version of Michael-and-Scott's (recycling) queue. Our evaluation on x86-64 shows promising results when using our methods for different data structures and SMR schemes.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729337", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Md Amit Hasan", + "last_name": "Arovi", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Ruslan", + "last_name": "Nikolaev", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/AroviN25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729292", + "title": "Lightweight and Locality-Aware Composition of Black-Box Subroutines", + "abstract": "Subroutines are essential building blocks in software design: users encapsulate common functionality in libraries and write applications by composing calls to subroutines. Unfortunately, performance may be lost at subroutine boundaries due to reduced locality and increased memory consumption. Operator fusion helps recover the performance lost at composition boundaries. Previous solutions fuse operators by manually rewriting code into monolithic fused subroutines, or by relying on heavy-weight compilers to generate code that performs fusion. Both approaches require a semantic understanding of the entire computation, breaking the decoupling necessary for modularity and reusability of subroutines. In this work, we attempt to identify the minimal ingredients required to fuse computations, enabling composition of subroutines without sacrificing performance or modularity. We find that, unlike previous approaches that require a semantic understanding of the computation, most opportunities for fusion require understanding only data production and consumption patterns.Exploiting this insight, we add fusion on top of black-box subroutines by proposing a lightweight enrichment of subroutine declarations to expose data-dependence patterns. We implement our approach in a system called Fern, and demonstrate Fern’s benefits by showing that it is competitive with state-of-the-art, high-performance libraries with manually fused operators, can fuse across library and domain boundaries for unforeseen workloads, and can deliver speedups of up to 5× over unfused code.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729292", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Manya", + "last_name": "Bansal", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Dillon", + "last_name": "Sharlet", + "institution": "Google (United States)" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BansalSRA25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729314", + "title": "Multi-stage Relational Programming", + "abstract": "We transport multi-stage programming from functional to relational programming, with novel constructs to give programmers control over staging and non-determinism. We stage interpreters written as relations, in which the programs under interpretation can contain holes representing unknown expressions or values. By compiling the known parts without interpretive overhead and deferring interpretation to run time only for the unknown parts, we compound the benefits of staging (e.g., turning interpreters into compilers) and relational interpretation (e.g., turning functions into relations and synthesizing from sketches). We extend miniKanren with staging constructs and apply the resulting multi-stage language to relational interpreters for subsets of Racket and miniKanren as well as a relational recognizer for context-free grammars. We demonstrate significant performance gains across multiple synthesis problems, systematically comparing unstaged and staged computation, as well as indicatively comparing with an existing hand-tuned relational interpreter.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729314", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michael", + "last_name": "Ballantyne", + "institution": "Northeastern University" + }, + { + "first_name": "Raffaella", + "last_name": "Sanna", + "institution": "Harvard University Press" + }, + { + "first_name": "Jason", + "last_name": "Hemann", + "institution": "Seton Hall University" + }, + { + "first_name": "William E.", + "last_name": "Byrd", + "institution": "University of Alabama at Birmingham" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "Harvard University Press" + } + ], + "dblp_key": "journals/pacmpl/BallantyneSHBA25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729269", + "title": "MarQSim: Reconciling Determinism and Randomness in Compiler Optimization for Quantum Simulation", + "abstract": "Quantum Hamiltonian simulation, fundamental in quantum algorithm design, extends far beyond its foundational roots, powering diverse quantum computing applications. However, optimizing the compilation of quantum Hamiltonian simulation poses significant challenges. Existing approaches fall short in reconciling deterministic and randomized compilation, lack appropriate intermediate representations, and struggle to guarantee correctness. Addressing these challenges, we present MarQSim, a novel compilation framework. MarQSim leverages a Markov chain-based approach, encapsulated in the Hamiltonian Term Transition Graph, adeptly reconciling deterministic and randomized compilation benefits. Furthermore, we formulate a Minimum-Cost Flow model that can tune transition matrices to enforce correctness while accommodating various optimization objectives. Experimental results demonstrate MarQSim's superiority in generating more efficient quantum circuits for simulating various quantum Hamiltonians while maintaining precision.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729269", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiuqi", + "last_name": "Cao", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Junyu", + "last_name": "Zhou", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yuhao", + "last_name": "Liu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yunong", + "last_name": "Shi", + "institution": "Applied Quantum Technologies (United States)" + }, + { + "first_name": "Gushu", + "last_name": "Li", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/CaoZLSL25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729273", + "title": "A Uniform Framework for Handling Position Constraints in String Solving", + "abstract": "We introduce a novel decision procedure for solving the class of position string constraints, which includes string disequalities, ¬prefixof, ¬suffixof, str.at, and ¬str.at. These constraints are generated frequently in almost any application of string constraint solving. Our procedure avoids expensive encoding of the constraints to word equations and, instead, reduces the problem to checking conflicts on positions satisfying an integerconstraint obtained from the Parikh image of a polynomial-sized finite automaton with a special structure. By the reduction to counting, solving position constraints becomes NP-complete and for some cases even falls into PTime. This is much cheaper than the previously used techniques, which either used reductions generating word equations and length constraints (for which modern string solvers use exponential-space algorithms) or incomplete techniques. Our method is relevant especially for automata-based string solvers, which have recently achieved the best results in terms of practical efficiency, generality, and completeness guarantees. This work allows them to excel also on position constraints, which used to be their weakness. Besides the efficiency gains, we show that our framework may be extended to solve a large fragment of ¬contains (in NExpTime), for which decidability has been long open, and gives a hope to solve the general problem. Our implementation of the technique within the Z3-Noodler solver significantly improves its performance on position constraints.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729273", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yu‐Fang", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "Vojtěch", + "last_name": "Havlena", + "institution": "Brno University of Technology" + }, + { + "first_name": "Michal", + "last_name": "Hečko", + "institution": "Brno University of Technology" + }, + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" + }, + { + "first_name": "Ondřej", + "last_name": "Lengál", + "institution": "Brno University of Technology" + } + ], + "dblp_key": "journals/pacmpl/ChenHHHL25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729318", + "title": "Smooth, Integrated Proofs of Cryptographic Constant Time for Nondeterministic Programs and Compilers", + "abstract": "Formal verification of software and compilers has been used to rule out large classes of security-critical issues, but risk of unintentional information leakage has received much less consideration. It is a key requirement for formal specifications to leave some details of a system's behavior unspecified so that future implementation changes can be accommodated, and yet it is nonetheless expected that these choices would not be made based on confidential information the system handles. This paper formalizes that notion using omnisemantics and plain single-copy assertions, giving for the first time a specification of what it means for a nondeterministic program to be constant-time or more generally to avoid leaking (a part of) its inputs. We use this theory to prove data-leak-free execution of core cryptographic routines compiled from Bedrock2 C to RISC-V machine code, showing that the smooth specification and proof experience omnisemantics provides for nondeterminism extends to constant-time properties in the same setting. We also study variants of the key program-compiler contract, highlighting pitfalls of tempting simplifications and subtle consequences of how inputs to nondeterministic choices are constrained. Our results are backed by modular program-logic and compiler-correctness theorems, and they integrate into a neat end-to-end theorem in the Coq proof assistant.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729318", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Owen", + "last_name": "Conoly", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Andres", + "last_name": "Erbsen", + "institution": "Google (United States)" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ConolyEC25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729261", + "title": "Certified Compilers à la Carte", + "abstract": "Certified compilers are complex software systems. Like other large systems, they demand modular, extensible designs. While there has been progress in extensible metatheory mechanization, scaling extensibility and reuse to meet the demands of full compiler verification remains a major challenge. We respond to this challenge by introducing novel expressive power to a proof language. Our language design equips the Rocq prover with an extensibility mechanism inspired by the object-oriented ideas of late binding, mixin composition, and family polymorphism. We implement our design as a plugin for Rocq, called Rocqet. We identify strategies for using Rocqet’s new expressive power to modularize the monolithic design of large certified developments as complex as the CompCert compiler. The payoff is a high degree of modularity and reuse in the formalization of intermediate languages, ISAs, compiler transformations, and compiler extensions, with the ability to compose these reusable components—certified compilers à la carte. We report significantly improved proof-compilation performance compared to earlier work on extensible metatheory mechanization. We also report good performance of the extracted compiler.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729261", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Oghenevwogaga", + "last_name": "Ebresafe", + "institution": "University of Waterloo" + }, + { + "first_name": "Ian", + "last_name": "Zhao", + "institution": "University of Waterloo" + }, + { + "first_name": "Ende", + "last_name": "Jin", + "institution": "University of Waterloo" + }, + { + "first_name": "Arthur", + "last_name": "Bright", + "institution": "University of Waterloo" + }, + { + "first_name": "Charles", + "last_name": "Jian", + "institution": "University of Waterloo" + }, + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/EbresafeZJBJZ25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729325", + "title": "Stochastic Lazy Knowledge Compilation for Inference in Discrete Probabilistic Programs", + "abstract": "We present new techniques for exact and approximate inference in discrete probabilistic programs, based on two new ways of exploiting lazy evaluation. First, we show how knowledge compilation, a state-of-the art technique for exact inference in discrete probabilistic programs, can be made lazy, enabling asymptotic speed-ups. Second, we show how a probabilistic program’s lazy semantics naturally give rise to a division of its random choices into subproblems, which can be solved in sequence by sequential Monte Carlo with locally-optimal proposals automatically computed via lazy knowledge compilation. We implement our approach in a new tool, Pluck, and evaluate its performance against state-of-the-art approaches to inference in discrete probabilistic languages. We find that on a suite of inference benchmarks, lazy knowledge compilation can be faster than state-of-the-art approaches, sometimes by orders of magnitude.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729325", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew L.", + "last_name": "Bowers", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Yale University" + }, + { + "first_name": "Joshua B.", + "last_name": "Tenenbaum", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BowersLTSM25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729265", + "title": "DR.FIX: Automatically Fixing Data Races at Industry Scale", + "abstract": "Data races are a prevalent class of concurrency bugs in shared-memory parallel programs, posing significant challenges to software reliability and reproducibility. While there is an extensive body of research on detecting data races and a wealth of practical detection tools across various programming languages, considerably less effort has been directed toward automatically fixing data races at an industrial scale. In large codebases, data races are continuously introduced and exhibit myriad patterns, making automated fixing particularly challenging. In this paper, we tackle the problem of automatically fixing data races at an industrial scale. We present Dr.Fix, a tool that combines large language models (LLMs) with program analysis to generate fixes for data races in real-world settings, effectively addressing a broad spectrum of racy patterns in complex code contexts. Implemented for Go—the programming language widely used in modern microservice architectures where concurrency is pervasive and data races are common—Dr.Fix seamlessly integrates into existing development workflows. We detail the design of Dr.Fix and examine how individual design choices influence the quality of the fixes produced. Over the past 18 months, Dr.Fix has been integrated into developer workflows at Uber demonstrating its practical utility. During this period, Dr.Fix produced patches for 224 (55%) from a corpus of 404 data races spanning various categories; 193 of these patches (86%) were accepted by more than a hundred developers via code reviews and integrated into the codebase.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729265", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Farnaz", + "last_name": "Behrang", + "institution": "Uber AI (United States)" + }, + { + "first_name": "Zhizhou", + "last_name": "Zhang", + "institution": "Uber AI (United States)" + }, + { + "first_name": "Georgian-Vlad", + "last_name": "Saioc", + "institution": "Aarhus University" + }, + { + "first_name": "Peng", + "last_name": "Liu", + "institution": "Uber AI (United States)" + }, + { + "first_name": "Milind", + "last_name": "Chabbi", + "institution": "Uber AI (United States)" + } + ], + "dblp_key": "journals/pacmpl/BehrangZSLC25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729279", + "title": "Solving Floating-Point Constraints with Continuous Optimization", + "abstract": "The Satisfiability Modulo Theory (SMT) problem over floating-point operations presents a significant challenge. State-of-the-art SMT solvers often run into difficulties when dealing with large, complex floating-point constraints. Recently, a new approach to floating-point constraint solving emerges, utilizing mathematical optimization (MO) methods as an engine of their solving approach. Despite the novelty, these methods can fall short in both effectiveness and efficiency due to issues of the translated functions (e.g., discontinuity) and inherent limitations of their underlying MO method (e.g., imprecise search process, scalability issues). Driven by these weaknesses of prior solvers, this paper introduces a new MO-based approach that is shown highly potent in solving floating-point constraints. Specifically, on the benchmarks of JFS (a recent solver based on fuzzing), Grater, a realization of our approach, solves as many constraints as Bitwuzla and one more than CVC5 but runs over 10 times faster and over 40 times faster than Bitwuzla and CVC5 in median solving time across all benchmarks. It is worth mentioning that Bitwuzla and CVC5 are the strongest solvers for floating-point constraints according to results of the annual international SMT solver competition (SMT-COMP). Together, they have won all gold medals for QF_FPArith and FPArith divisions, which focus on floating-point constraints solving, over the past three years. To further evaluate Grater, we select over 100 most difficult benchmarks from the FP SMT-LIB, a logic regularly used in SMT-COMP. The difficulty is measured by the complexity of the composition (e.g., number of variables, clauses) and the interdependencies within constraints. Grater again solves the same number of constraints as Bitwuzla and CVC5 while running over 10 times faster than both solvers in average solving time, and over 50 times (resp. 30 times) faster than Bitwuzla (resp. CVC5) in median solving time. We release the source code of Grater, along with all evaluation data, including detailed comparisons of Grater against each baseline solver (i.e., Z3, CVC5, Bitwuzla, JFS, XSat, and CoverMe), at https://github.com/grater-exp/grater-experiment to facilitate reproducibility.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729279", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qian", + "last_name": "Chen", + "institution": "Nanjing University" + }, + { + "first_name": "Chenqi", + "last_name": "Cui", + "institution": "Nanjing University" + }, + { + "first_name": "Fengjuan", + "last_name": "Gao", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Yu", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "Visa (United States)" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/ChenCGWWW25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729328", + "title": "Efficient Linearizability Monitoring", + "abstract": "This paper revisits the fundamental problem of monitoring the linearizability of concurrent stacks, queues, sets, and multisets. Given a history of a library implementing one of these abstract data types, the monitoring problem is to answer whether the given history is linearizable. For stacks, queues, and (multi)sets, we present monitoring algorithms with complexities ( n 2 ), ( n log n ), and ( n ), respectively, where n is the number of operations in the input history. For stacks and queues, our results hold under the standard assumption of data-independence , i.e., the behavior of the library is not sensitive to the actual values stored in the data structure. Past works to solve the same problems have cubic time complexity and (more seriously) have correctness issues: they either (i) lack correctness proofs or (ii) have unsound correctness proofs (we present counter-examples of the correctness proofs), or (iii) have unsound algorithms. Our improved complexity results rely on substantially different algorithms for which we provide detailed proofs of correctness. We have implemented our stack and queue algorithms in LiMo (Linearizability Monitor). We evaluate LiMo and compare it with the state-of-the-art tool Violin – whose correctness proofs we have found errors in – which checks for linearizability violations. Our experimental evaluation confirms that LiMo outperforms Violin regarding both efficiency and scalability.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729328", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Sofia", + "last_name": "Grahn", + "institution": "Uppsala University" + }, + { + "first_name": "Bengt", + "last_name": "Jönsson", + "institution": "Uppsala University" + }, + { + "first_name": "Shankara Narayanan", + "last_name": "Krishna", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Om Swostik", + "last_name": "Mishra", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "journals/pacmpl/AbdullaGJKM25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729259", + "title": "Partial Evaluation, Whole-Program Compilation", + "abstract": "There is a tension in dynamic language runtime design between speed and correctness. State-of-the-art JIT compilation, the result of enormous industrial investment and significant research, achieves heroic speedups at the cost of complexity. This complexity leads to subtle and sometimes catastrophic correctness bugs. Much of this complexity comes from the existence of multiple tiers and the need to maintain correspondence between these separate definitions of the language’s semantics; it also comes from the indirect nature of the semantics implicitly encoded in a compiler backend. One way to address this complexity is to automatically derive, as much as possible, the compiled code from a single source-of-truth, such as the interpreter tier. In this work, we introduce a partial evaluator that can compile a whole guest-language function ahead-of-time, without tracing or profiling, “for free.” This transform unrolls an interpreter function expressed in a standard compiler intermediate representation (static single assignment or SSA) and uses partial evaluation of the interpreter function and its regular control flow to drive the guest-language compilation. The effect of this is that the transform is applicable to almost unmodified existing interpreters in systems languages such as C or C++, producing ahead-of-time guest-language compilers. We show the effectiveness of this new tool by applying it to the interpreter tier of an existing industrial JavaScript engine, SpiderMonkey, yielding 2.17× speedups, and the PUC-Rio Lua interpreter, yielding 1.84× speedups. Finally, we outline an approach to carry this work further, deriving more of the capabilities of a JIT backend from first principles while retaining correctness.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729259", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Chris", + "last_name": "Fallin", + "institution": "" + }, + { + "first_name": "Maxwell", + "last_name": "Bernstein", + "institution": "Boston University" + } + ], + "dblp_key": "journals/pacmpl/FallinB25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729338", + "title": "Practical Type Inference with Levels", + "abstract": "Modern functional languages rely on sophisticated type inference algorithms. However, there often exists a gap between the theoretical presentation of these algorithms and their practical implementations. Specifically, implementations employ techniques not explicitly included in formal specifications, causing undesirable consequences. First, this leads to confusion and unforeseen challenges for developers adhering to the formal specification. Moreover, theoretical guarantees established for a formal presentation may not directly translate to the implementation. This paper focuses on formalizing one such technique, known as levels , which is widely used in practice but whose theoretical treatment remains largely understudied. We present the first comprehensive formalization of levels and demonstrate their applicability to type inference implementations.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729338", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Andong", + "last_name": "Fan", + "institution": "University of Toronto" + }, + { + "first_name": "Han", + "last_name": "Xu", + "institution": "Princeton University" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/FanXX25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729309", + "title": "First-Class Verification Dialects for MLIR", + "abstract": "MLIR is a toolkit supporting the development of extensible and composable intermediate representations (IRs) called dialects ; it was created in response to rapid changes in hardware platforms, programming languages, and application domains such as machine learning. MLIR supports development teams creating compilers and compiler-adjacent tools by factoring out common infrastructure such as parsers and printers. A major limitation of MLIR is that it is syntax-focused: it has no support for directly encoding the semantics of operations in its dialects. Thus, at present, the parts of MLIR tools that depend on semantics—optimizers, analyzers, verifiers, transformers—must all be engineered by hand. Our work makes formal semantics a first-class citizen in the MLIR ecosystem. We designed and implemented a collection of semantics-supporting MLIR dialects for encoding the semantics of compiler IRs. These dialects support a separation of concerns between three domains of expertise when building formal-methods-based tooling for compilers. First, compiler developers define their dialect’s semantics as a lowering (compilation transformation) from their dialect to one or more of ours. Second, SMT solver experts provide tools to optimize domain-specific high-level semantics and lower them to SMT queries. Third, tool builders create dialect-independent verification tools. We validate our work by defining semantics for five key MLIR dialects, defining a state-of-the-art SMT encoding for memory-based semantics, and building three dialect-agnostic tools, which we used to find five miscompilation bugs in upstream MLIR, verify a canonicalization pass, and also formally verify transfer functions for two dataflow analyses: “known bits” (that finds individual bits that are always zero or one in all executions) and “demanded bits” (that finds don’t-care bits). The transfer functions that we verify are improved versions of those in upstream MLIR; they detect on average 36.6% more known bits in real-world MLIR programs compared to the upstream implementation.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729309", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mathieu", + "last_name": "Fehr", + "institution": "University of Edinburgh" + }, + { + "first_name": "Yuyou", + "last_name": "Fan", + "institution": "University of Utah" + }, + { + "first_name": "Hugo", + "last_name": "Pompougnac", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/FehrFPRG25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729317", + "title": "Probabilistic Refinement Session Types", + "abstract": "Session types provide a formal type system to define and verify communication protocols between message-passing processes. In order to analyze randomized systems, recent works have extended session types with probabilistic type constructors. Unfortunately, all the proposed extensions only support constant probabilities which limits their applicability to real-world systems. Our work addresses this limitation by introducing probabilistic refinement session types which enable symbolic reasoning for concurrent probabilistic systems in a core calculus we call PReST. The type system is carefully designed to be a conservative extension of refinement session types and supports both probabilistic and regular choice type operators. We also implement PReST in a prototype which we use for validating probabilistic concurrent programs. The added expressive power leads to significant challenges, both in the meta theory and implementation of PReST, particularly with type checking: it requires reconstructing intermediate types for channels when type checking probabilistic branching expressions. The theory handles this by semantically quantifying refinement variables in probabilistic typing rules, a deviation from standard refinement type systems. The implementation relies on a bi-directional type checker that uses an SMT solver to reconstruct the intermediate types minimizing annotation overhead and increasing usability. To guarantee that probabilistic processes are almost-surely terminating, we integrate cost analysis into our type system to obtain expected upper bounds on recursion depth. We evaluate PReST on a wide variety of benchmarks from 4 categories: (i) randomized distributed protocols such as Itai and Rodeh's leader election, bounded retransmission, etc., (ii) parametric Markov chains such as random walks, (iii) probabilistic analysis of concurrent data structures such as queues, and (iv) distributions obtained by composing uniform distributions using operators like max, and sum. Our experiments show that the PReST type checker scales to large programs with sophisticated probabilistic distributions.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729317", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qiancheng", + "last_name": "Fu", + "institution": "" + }, + { + "first_name": "Ankush", + "last_name": "Das", + "institution": "" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/FuDG25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729327", + "title": "Usability Barriers for Liquid Types", + "abstract": "Liquid types can express richer verification properties than simple type systems. However, despite their advantages, liquid types have yet to achieve widespread adoption. To understand why, we conducted a study analyzing developers' challenges with liquid types, focusing on LiquidHaskell. Our findings reveal nine key barriers that span three categories, including developer experience, scalability challenges with complex and large codebases, and understanding the verification process. Together, these obstacles provide a comprehensive view of the usability challenges to the broader adoption of liquid types and offer insights that can inform the current and future design and implementation of liquid type systems.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729327", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Catarina", + "last_name": "Gamboa", + "institution": "University of Lisbon" + }, + { + "first_name": "Abigail", + "last_name": "Reese", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Alcides", + "last_name": "Fonseca", + "institution": "University of Lisbon" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/GamboaRFA25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729256", + "title": "Ripple: Asynchronous Programming for Spatial Dataflow Architectures", + "abstract": "Spatial dataflow architectures (SDAs) are a promising and versatile accelerator platform. They are software-programmable and achieve near-ASIC performance and energy efficiency, beating CPUs by orders of magnitude. Unfortunately, many SDAs struggle to efficiently implement irregular computations because they suffer from an abstraction inversion : they fail to capture coarse-grain dataflow semantics in the application — namely asynchronous communication, pipelining, and queueing — that are naturally supported by the dataflow execution model and existing SDA hardware. Ripple is a language and architecture that corrects the abstraction inversion by preserving dataflow semantics down the stack. Ripple provides asynchronous iterators , shared-memory atomics, and a familiar task-parallel interface to concisely express the asynchronous pipeline parallelism enabled by an SDA. Ripple efficiently implements deadlock-free, asynchronous task communication by exposing hardware token queues in its ISA. Across nine important workloads, compared to a recent ordered-dataflow SDA, Ripple shrinks programs by 1.9×, improves performance by 3×, increases IPC by 58%, and reduces dynamic instructions by 44%.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729256", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "S.", + "last_name": "Ghosh", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yufei", + "last_name": "Shi", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Nathan", + "last_name": "Beckmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/GhoshSLB25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729302", + "title": "An Interactive Debugger for Rust Trait Errors", + "abstract": "Compiler diagnostics for type inference failures are notoriously bad, and type classes only make the problem worse. By introducing a complex search process during inference, type classes can lead to wholly inscrutable or useless errors. We describe a system, Argus, for interactively visualizing type class inferences to help programmers debug inference failures, applied specifically to Rust’s trait system. The core insight of Argus is to avoid the traditional model of compiler diagnostics as one-size-fits-all, instead providing the programmer with different views on the search tree corresponding to different debugging goals. Argus carefully uses defaults to improve debugging productivity, including interface design (e.g., not showing full paths of types by default) and heuristics (e.g., sorting obligations based on the expected complexity of fixing them). We evaluated Argus in a user study where N = 25 participants debugged type inference failures in realistic Rust programs, finding that participants using Argus correctly localized 2.2× as many faults and localized 3.3× faster compared to not using Argus.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729302", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "G R", + "last_name": "Gray", + "institution": "Brown University" + }, + { + "first_name": "Will", + "last_name": "Crichton", + "institution": "Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "journals/pacmpl/GrayCK25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729316", + "title": "Program Synthesis from Partial Traces", + "abstract": "We present the first technique to synthesize programs that compose side-effecting functions, pure functions, and control flow, from partial traces containing records of only the side-effecting functions. This technique can be applied to synthesize API composing scripts from logs of calls made to those APIs, or a script from traces of system calls made by a workload, for example. All of the provided traces are positive examples, meaning that they describe desired behavior. Our approach does not require negative examples. Instead, it generalizes over the examples and uses cost metrics to prevent over-generalization. Because the problem is too complex for traditional monolithic program synthesis techniques, we propose a new combination of optimizing rewrites and syntax-guided program synthesis. The resulting program is correct by construction, so its output will always be able to reproduce the input traces. We evaluate the quality of the programs synthesized when considering various optimization metrics and the synthesizer's efficiency on real-world benchmarks. The results show that our approach can generate useful real-world programs.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729316", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Margarida", + "last_name": "Ferreira", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Victor", + "last_name": "Nicolet", + "institution": "Amazon (United States)" + }, + { + "first_name": "Joey", + "last_name": "Dodds", + "institution": "Amazon (United States)" + }, + { + "first_name": "Daniel", + "last_name": "Kroening", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/FerreiraNDK25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729322", + "title": "Spineless Traversal for Layout Invalidation", + "abstract": "Latency is a major concern for web rendering engines like those in Chrome, Safari, and Firefox. These engines reduce latency by using an incremental layout algorithm to redraw the page when the user interacts with it. In such an algorithm, elements that change frame-to-frame are marked dirty, and only those elements are processed to draw the next frame, dramatically reducing latency. However, the standard incremental layout algorithm must search the page for dirty elements, accessing auxiliary elements in the process. These auxiliary elements add cache misses and stalled cycles, and are responsible for a sizable fraction of all layout latency. We introduce a new, faster incremental layout algorithm called Spineless Traversal. Spineless Traversal uses a cache-friendlier priority queue algorithm that avoids accessing auxiliary nodes and thus reduces cache traffic and stalls. This leads to dramatic speedups on the most latency-critical interactions such as hovering, typing, and animation. Moreover, thanks to numerous low-level optimizations, Spineless Traversal is competitive across the whole spectrum of incremental layout workloads. Spineless Traversal is faster than the standard approach on 83.0% of 2216 benchmarks, with a mean speedup of 1.80× concentrated in the most latency-critical interactions.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729322", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Marisa", + "last_name": "Kirisame", + "institution": "University of Utah" + }, + { + "first_name": "Tiezhi", + "last_name": "Wang", + "institution": "Tongji University" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/KirisameWP25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729293", + "title": "Efficient Formal Verification of Quantum Error Correcting Programs", + "abstract": "Quantum error correction (QEC) is fundamental for suppressing noise in quantum hardware and enabling fault-tolerant quantum computation. In this paper, we propose an efficient verification framework for QEC programs. We define an assertion logic and a program logic specifically crafted for QEC programs and establish a sound proof system. We then develop an efficient method for handling verification conditions (VCs) of QEC programs: for Pauli errors, the VCs are reduced to classical assertions that can be solved by SMT solvers, and for non-Pauli errors, we provide a heuristic algorithm. We formalize the proposed program logic in Coq proof assistant, making it a verified QEC verifier. Additionally, we implement an automated QEC verifier, Veri-QEC, for verifying various fault-tolerant scenarios. We demonstrate the efficiency and broad functionality of the framework by performing different verification tasks across various scenarios. Finally, we present a benchmark of 14 verified stabilizer codes.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729293", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Qifan", + "last_name": "Huang", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Li", + "last_name": "Zhou", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Wang", + "last_name": "Fang", + "institution": "University of Edinburgh" + }, + { + "first_name": "Mengyu", + "last_name": "Zhao", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "University of Technology Sydney" + } + ], + "dblp_key": "journals/pacmpl/HuangZFZY25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729319", + "title": "Graphiti: Bridging Graph and Relational Database Queries", + "abstract": "This paper presents an automated reasoning technique for checking equivalence between graph database queries written in Cypher and relational queries in SQL. To formalize a suitable notion of equivalence in this setting, we introduce the concept of database transformers, which transform database instances between graph and relational models. We then propose a novel verification methodology that checks equivalence modulo a given transformer by reducing the original problem to verifying equivalence between a pair of SQL queries. This reduction is achieved by embedding a subset of Cypher into SQL through syntax-directed translation, allowing us to leverage existing research on automated reasoning for SQL while obviating the need for reasoning simultaneously over two different data models. We have implemented our approach in a tool called Graphiti and used it to check equivalence between graph and relational queries. Our experiments demonstrate that Graphiti is useful both for verification and refutation and that it can uncover subtle bugs, including those found in Cypher tutorials and academic papers.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729319", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yang", + "last_name": "He", + "institution": "Simon Fraser University" + }, + { + "first_name": "Ruijie", + "last_name": "Fang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "Simon Fraser University" + } + ], + "dblp_key": "journals/pacmpl/HeFDW25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729329", + "title": "Morello-Cerise: A Proof of Strong Encapsulation for the Arm Morello Capability Hardware Architecture", + "abstract": "When designing new architectural security mechanisms, a key question is whether they actually provide the intended security, but this has historically been very hard to assess. One cannot gain much confidence by testing, as such mechanisms should provide protection in the presence of arbitrary unknown code. Previously, one also could not gain confidence by mechanised proof, as the scale of production instruction-set architecture (ISA) designs, many tens or hundreds of thousands of lines of specification, made that prohibitive. We focus in this paper especially on the secure encapsulation of software components, as supported by CHERI architectures in general and by the Arm Morello prototype architecture and hardware design in particular. Secure encapsulation is an essential security mechanism, for fault isolation and to constrain untrusted third-party code. It has previously often been implemented using virtual memory, but that does not scale to large numbers of compartments. Morello provides capability-based mechanisms that do scale, within a single address space. We prove a strong secure encapsulation property for an example of encapsulated code running on Morello, that holds in the presence of arbitrary untrusted code, above a full-scale sequential model of the Morello ISA. To do so, we build on, extend, and unify three orthogonal lines of previous work: the Cerise proof of such an encapsulation property for a highly idealised capability machine, expressed using a logical relation in Iris; the Islaris approach for reasoning about known code in production-scale ISAs; and the T-CHERI security properties of arbitrary Morello code, previously proved only for executions up to domain crossing. This demonstrates how one can prove such strong properties of security mechanisms for full-scale industry architectures.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729329", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Angus", + "last_name": "Hammond", + "institution": "University of Cambridge" + }, + { + "first_name": "Ricardo", + "last_name": "Almeida", + "institution": "University of Glasgow" + }, + { + "first_name": "Thomas", + "last_name": "Bauereiß", + "institution": "University of Cambridge" + }, + { + "first_name": "B. K.", + "last_name": "Campbell", + "institution": "University of Edinburgh" + }, + { + "first_name": "Ian", + "last_name": "Stark", + "institution": "University of Edinburgh" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/HammondABCSS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729300", + "title": "Membership Testing for Semantic Regular Expressions", + "abstract": "This paper is about semantic regular expressions (SemREs). This is a concept that was recently proposed by Smore (Chen et al. 2023) in which classical regular expressions are extended with a primitive to query external oracles such as databases and large language models (LLMs). SemREs can be used to identify lines of text containing references to semantic concepts such as cities, celebrities, political entities, etc. The focus in their paper was on automatically synthesizing semantic regular expressions from positive and negative examples. In this paper, we study the membership testing problem . First, we present a two-pass NFA-based algorithm to determine whether a string w matches a SemRE r in O (| r | 2 | w | 2 + | r | | w | 3 ) time, assuming the oracle responds to each query in unit time. In common situations, where oracle queries are not nested, we show that this procedure runs in O (| r | 2 | w | 2 ) time. Experiments with a prototype implementation of this algorithm validate our theoretical analysis, and show that the procedure massively outperforms a dynamic programming-based baseline, and incurs a ≈ 2 × overhead over the time needed for interaction with the oracle. Second, we establish connections between SemRE membership testing and the triangle finding problem from graph theory, which suggest that developing algorithms which are simultaneously practical and asymptotically faster might be challenging. Furthermore, algorithms for classical regular expressions primarily aim to optimize their time and memory consumption. In contrast, an important consideration in our setting is to minimize the cost of invoking the oracle. We demonstrate an Ω(| w | 2 ) lower bound on the number of oracle queries necessary to make this determination.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729300", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yifei", + "last_name": "Huang", + "institution": "University of Southern California" + }, + { + "first_name": "Matin", + "last_name": "Amini", + "institution": "University of Southern California" + }, + { + "first_name": "Alexis Le", + "last_name": "Glaunec", + "institution": "Rice University" + }, + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + }, + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "University of Southern California" + } + ], + "dblp_key": "journals/pacmpl/HuangAGMR25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729257", + "title": "StacKAT: Infinite State Network Verification", + "abstract": "We develop StacKAT, a network verification language featuring loops, finite state variables, nondeterminism, and---most importantly---access to a stack with accompanying push and pop operations. By viewing the variables and stack as the (parsed) headers and (to-be-parsed) contents of a network packet, StacKAT can express a wide range of network behaviors including parsing, source routing, and telemetry. These behaviors are difficult or impossible to model using existing languages like NetKAT. We develop a decision procedure for StacKAT program equivalence, based on finite automata. This decision procedure provides the theoretical basis for verifying network-wide properties and is able to provide counterexamples for inequivalent programs. Finally, we provide an axiomatization of StacKAT equivalence and establish its completeness.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729257", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "Leiden University" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Lily", + "last_name": "Saada", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + }, + { + "first_name": "Jana", + "last_name": "Wagemaker", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/JacobsFKKSSW25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729246", + "title": "Verifying General-Purpose RCU for Reclamation in Relaxed Memory Separation Logic", + "abstract": "Read-Copy-Update (RCU) is a critical synchronization mechanism for concurrent data structures, enabling efficient deferred memory reclamation. However, implementing and using RCU correctly is challenging due to its inherent concurrency complexities. While previous work verified RCU, they either relied on unrealistic assumptions of sequentially consistent (SC) memory model or lacked three key features of general-purpose RCU libraries: modular specification, switchable critical sections, and concurrent writer support. We present the first formal verification of a general-purpose RCU in realistic relaxed memory consistency (RMC), addressing the challenges posed by these features. To achieve modular specification that encompasses relaxed behaviors, we extend existing SC specifications to account for explicit synchronization. To support switchable critical sections, which require read-after-write (RAW) synchronization, we introduce a reasoning principle for RAW-synchronizing SC fences. Using this principle, we also present the first formal verification of Peterson’s mutex in RMC. To support concurrent writers performing partially ordered writes, we avoid assuming a total order of links and instead formulate invariants based on per-node incoming link histories. Our proofs are mechanized in the iRC11 relaxed memory separation logic, built upon Iris, in Rocq.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729246", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jaehwang", + "last_name": "Jung", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sunho", + "last_name": "Park", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Janggun", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeho", + "last_name": "Yeon", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/JungPLYK25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729267", + "title": "Robustifying Debug Information Updates in LLVM via Control-Flow Conformance Analysis", + "abstract": "Optimizing compilers, such as LLVM, generate debug information in machine code to aid debugging. This information is particularly important when debugging optimized code, as modern software is often compiled with optimization enabled. However, properly updating debug information to reflect code transformations during optimization is a complex task that often relies on manual effort. This complexity makes the process prone to errors, which can lead to incorrect or lost debug information. Finding and fixing potential debug information update errors is vital to maintaining the accuracy and reliability of the overall debugging process. To our knowledge, no existing techniques can rectify debug information update errors in LLVM. While black-box testing approaches can find such bugs, they can neither pinpoint the root causes nor suggest fixes. To fill the gap, we propose the first technique to robustify debug information updates in LLVM. In particular, our robustification approach can find and fix incorrect debug location updates. Central to our approach is the observation that the debug locations in the original and optimized programs must satisfy a conformance relation . The relation ensures that LLVM optimizations do not introduce extraneous debug location information on the control-flow paths of the optimized programs. We introduce control-flow conformance analysis , a novel approach that determines the reference updates ensuring the conformance relation by observing the execution of LLVM optimization passes and analyzing the debug locations in the control-flow graphs of programs under optimization. The determined reference updates are then used to check developer-written updates in LLVM. When discrepancies arise, the reference updates serve as the update skeletons to guide the fixing. We realized our approach as a tool named MetaLoc, which determines proper debug location updates for LLVM optimizations. More importantly, with MetaLoc, we have reported and patched 46 previously unknown update errors in LLVM. All the patches, along with 22 new regression tests, have been merged into the LLVM codebase, effectively improving the accuracy and reliability of debug information in all programs optimized by LLVM. Furthermore, our approach uncovered and led to corrections in two issues within LLVM’s official documentation on debug information updates.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729267", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shan", + "last_name": "Huang", + "institution": "East China Normal University" + }, + { + "first_name": "Jingjing", + "last_name": "Liang", + "institution": "East China Normal University" + }, + { + "first_name": "Ting", + "last_name": "Su", + "institution": "East China Normal University" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/HuangLSZ25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729310", + "title": "Robust Constant-Time Cryptography", + "abstract": "Cryptographic library developers take care to ensure their library does not leak secrets even when there are (inevitably) exploitable vulnerabilities in the applications the library is linked against. To do so, they choose some class of application vulnerabilities to defend against and hardcode protections against those vulnerabilities in the library code. A single set of choices is a poor fit for all contexts: a chosen protection could impose unnecessary overheads in contexts where those attacks are impossible, and an ignored protection could render the library insecure in contexts where the attack is feasible. We introduce RoboCop, a new methodology and toolchain for building secure and efficient applications from cryptographic libraries, via four contributions. First, we present an operational semantics that describes the behavior of a (cryptographic) library executing in the context of a potentially vulnerable application so that we can precisely specify what different attackers can observe. Second, we use our semantics to define a novel security property, Robust Constant Time (RCT), that defines when a cryptographic library is secure in the context of a vulnerable application. Crucially, our definition is parameterized by an attacker model, allowing us to factor out the classes of attackers that a library may wish to secure against. This refactoring yields our third contribution: a compiler that can synthesize bespoke cryptographic libraries with security tailored to the specific application context against which the library will be linked, guaranteeing that the library is RCT in that context. Finally, we present an empirical evaluation that shows the RoboCop compiler can automatically generate code to efficiently protect a wide range (over 500) of cryptographic library primitives against three classes of attacks: read gadgets (due to application memory safety vulnerabilities), speculative read gadgets (due to application speculative execution vulnerabilities), and concurrent observations (due to application threads), with performance overhead generally under 2% for protections from read gadgets and under 4% for protections from speculative read gadgets, thus freeing library developers from making one-size-fits-all choices between security and performance.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729310", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Kolosick", + "institution": "" + }, + { + "first_name": "Basavesh Ammanaghatta", + "last_name": "Shivakumar", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Sunjay", + "last_name": "Cauligi", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "University of Trento" + }, + { + "first_name": "Marco", + "last_name": "Vassena", + "institution": "Utrecht University" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/KolosickSCPVJS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729275", + "title": "Optimization-Directed Compiler Fuzzing for Continuous Translation Validation", + "abstract": "Incorrect compiler optimizations can lead to unintended program behavior and security vulnerabilities. However, the enormous size and complexity of modern compilers make it challenging to ensure the correctness of optimizations. The problem becomes more severe as compiler engineers continuously add new optimizations to improve performance and support new language features. In this paper, we propose Optimuzz, a framework to effectively detect incorrect optimization bugs in such continuously changing compilers. The key idea is to combine two complementary techniques: directed grey-box fuzzing and translation validation. We design a novel optimization-directed fuzzing framework that efficiently generates input programs to trigger specific compiler optimizations. Optimuzz then use existing translation validation tools to verify the correctness of the optimizations on the input programs. We instantiate our approach for two major compilers, LLVM and TurboFan. The results show that Optimuzz can effectively detect miscompilation bugs in these compilers compared to the state-of-the-art tools. We also applied Optimuzz to the latest version of LLVM and discovered 55 new miscompilation bugs.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729275", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jaeseong", + "last_name": "Kwon", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Bongjun", + "last_name": "Jang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Juneyoung", + "last_name": "Lee", + "institution": "" + }, + { + "first_name": "Kihong", + "last_name": "Heo", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/KwonJLH25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729255", + "title": "Support Triangle Machine", + "abstract": "Approximations play a pivotal role in verifying deep neural networks (DNNs). Existing approaches typically rely on either single-neuron approximations (simpler to design but less precise) or multi-neuron approximations (higher precision but significantly more complex to construct). Between them, a notable gap exists. This work bridges the gap. The idea is to lift single-neuron approximations into multi-neuron approximations with precision gain. To this end, we formulate the approximation transition as a novel problem, named Convex Approximation Lifting (CAL), and propose a constructive approach, Support Triangle Machine (STM), to solving it. STM is grounded in two core insights: (i) there exists a simple geometric structure, called the support triangle, along with an efficient triangle lifting technique that connects single-neuron approximations and multi-neuron approximations; and (ii) typical single-neuron approximations can be easily decomposed into multiple atomically liftable components. Specifically, given a CAL instance, STM constructs a multi-neuron approximation by iteratively processing each output coordinate. For each coordinate, it decomposes the single-neuron approximation into several linear parts, lifts each of them using the triangle lifting technique, and then synthesize an intermediate approximation, which later servers as input for the next iteration. We theoretically prove the correctness of STM and empirically evaluate its performance on a variety of CAL problems and DNN verification tasks. Experimental results demonstrate STM's broad applicability, improved precision, and sustained efficiency. Beyond DNN verification, STM has the potential to facilitate approximation construction process in more general tasks, and we expect it to catalyze further research in related fields.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729255", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jiaying", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Chunxue", + "last_name": "Hao", + "institution": "CITIC Group (China)" + } + ], + "dblp_key": "journals/pacmpl/LiH25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729258", + "title": "Circuit Optimization using Arithmetic Table Lookups", + "abstract": "Fully Homomorphic Encryption (FHE) is a cryptographic technique that enables privacy-preserving computation. State-of-the-art Boolean FHE implementations provide a very low-level interface, usually exposing a limited set of Boolean gates that programmers must use to write their FHE applications. This programming model is unnecessarily restrictive: many Boolean FHE schemes support programmable bootstrapping , an operation that allows evaluation of an arbitrary fixed-size lookup table. However, most modern FHE compilers are only capable of reasoning about traditional Boolean circuits, and therefore struggle to take full advantage of programmable bootstrapping. We present COATL, an FHE compiler that makes use of programmable bootstrapping to produce circuits that are smaller and more efficient than their traditional Boolean counterparts. COATL generates circuits using arithmetic lookup tables , a novel abstraction we introduce for reasoning about computations in Boolean FHE programs. We demonstrate on a variety of benchmarks that COATL can generate circuits that run up to 1.5× faster than those generated by other state-of-the-art compilation strategies.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729258", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Raghav", + "last_name": "Malik", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Vedant", + "last_name": "Paranjape", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/MalikPK25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729247", + "title": "Leveraging Immutability to Validate Hazard Pointers for Optimistic Traversals", + "abstract": "Hazard pointers (HP) is one of the earliest manual memory reclamation algorithms for concurrent data structures. It is widely used for its robustness: memory overhead is bounded (e.g., by the number of threads). To access a node, threads first announce the protection of each to-be-accessed node, which prevents its reclamation. After announcement, they validate the node's reachability from the root to ensure that no threads have missed the announcement and reclaimed it. Traversal-based data structures typically takes a marking-based validation strategy. This strategy uses a node's mark to indicate whether the node is to be detached. Unmarked nodes are considered safe to traverse as both the node and its successors are still reachable, while marked nodes are considered unsafe. However, this strategy is inapplicable to the efficient optimistic traversal strategy that skips over marked nodes. We propose a new validation strategy for HP that supports lock-free data structures with optimistic traversal, such as lists, trees, and skip lists. The key idea is to exploit the immutability of marked nodes, and validate their reachability at once by checking the reachability of the most recent unmarked node. To ensure correctness, we prove the safety of Harris's list protected with the new strategy in Rocq using the Iris separation logic framework. We show that the new strategy's performance is competitive with state-of-the-art reclamation algorithms when applied to data structures with optimistic traversal, while remaining simple and robust.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729247", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Janggun", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeonghyeon", + "last_name": "Kim", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/LeeKK25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729330", + "title": "Guided Tensor Lifting", + "abstract": "Domain-specific languages (DSLs) for machine learning are revolutionizing the speed and efficiency of machine learning workloads as they enable users easy access to high-performance compiler optimizations and accelerators. However, to take advantage of these capabilities, a user must first translate their legacy code from the language it is currently written in, into the new DSL. The process of automatically lifting code into these DSLs has been identified by several recent works, which propose program synthesis as a solution. However, synthesis is expensive and struggles to scale without carefully designed and hard-wired heuristics. In this paper, we present an approach for lifting that combines an enumerative synthesis approach with a Large Language Model used to automatically learn the domain-specific heuristics for program lifting, in the form of a probabilistic grammar. Our approach outperforms the state-of-the-art tools in this area, despite only using learned heuristics.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729330", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yixuan", + "last_name": "Li", + "institution": "University of Edinburgh" + }, + { + "first_name": "José Wesley de Souza", + "last_name": "Magalhães", + "institution": "University of Edinburgh" + }, + { + "first_name": "Alexander", + "last_name": "Brauckmann", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + }, + { + "first_name": "Elizabeth", + "last_name": "Polgreen", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/LiMBOP25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729308", + "title": "Principal Type Inference under a Prefix: A Fresh Look at Static Overloading", + "abstract": "At the heart of the Damas-Hindley-Milner (HM) type system lies the abstraction rule which derives a function type for a lambda expression. In this rule, the type of the parameter can be ”guessed”, and can be any type that fits the derivation. The beauty of the HM system is that there always exists a most general type that encompasses all possible derivations – Algorithm W is used to infer these most general types in practice. Unfortunately, this property is also the bane of the HM type rules. Many languages extend HM typing with additional features which often require complex side conditions to the type rules to maintain principal types. For example, various type systems for impredicative type inference, like HMF, FreezeML, or Boxy types, require let-bindings to always assign most general types. Such a restriction is difficult to specify as a logical deduction rule though, as it ranges over all possible derivations. Despite these complications, the actual implementations of various type inference algorithms are usually straightforward extensions of algorithm W, and from an implementation perspective, much of the complexity of various type system extensions, like boxes or polymorphic weights, is in some sense artificial. In this article we rephrase the HM type rules as _type inference under a prefix_, called HMQ. HMQ is sound and complete with respect to the HM type rules, but always derives principal types that correspond to the types inferred by algorithm W. The HMQ type rules are close to the clarity of the declarative HM type rules, but also specific enough to ”read off” an inference algorithm, and can form an excellent basis to describe type system extensions in practice. We show in particular how to describe the FreezeML and HMF systems in terms of inference under a prefix, and how we no longer require complex side conditions. We also show a novel formalization of static overloading in HMQ as implemented in Koka language.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729308", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wenjia", + "last_name": "Ye", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/LeijenY25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729298", + "title": "Relational Abstractions Based on Labeled Union-Find", + "abstract": "We introduce a new family of abstractions based on a data structure that we call labeled union-find , an extension of the classic efficient union-find data structure where edges carry labels. These labels have a composition operation that obey the group axioms. Like union-find, the labeled version can efficiently compute the transitive closure of a relation, but it is not limited to equivalence relations; it can represent any injective transformation between equivalence classes, which includes two-variables per equality (TVPE) constraints of the form y = a × x + b . Using abstract interpretation theory, we study the properties deriving from the use of abstract relations as labels, and the combination of labeled union-find with other representations of constraints, allowing both improvements in precision and simplification of existing constraints. Due to its efficiency, the labeled union-find abstractions could find many uses; we use it in two use cases, program analysis based on abstract interpretation and constraint solving for SMT, with encouraging preliminary results.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729298", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dorian", + "last_name": "Lesbre", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Matthieu", + "last_name": "Lemerre", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Hichem Rami Ait El", + "last_name": "Hara", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "François", + "last_name": "Bobot", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + } + ], + "dblp_key": "journals/pacmpl/LesbreLHB25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729307", + "title": "Pointer Analysis for Database-Backed Applications", + "abstract": "Database-backed applications form the backbone of modern software, yet their complexity poses significant challenges for static analysis. These applications involve intricate interactions among application code, diverse database frameworks such as JDBC, Hibernate, and Spring Data JPA, and languages like Java and SQL. In this paper, we introduce DBridge, the first pointer analysis specifically designed for Java database-backed applications, capable of statically constructing comprehensive Java-to-database value flows. DBridge unifies application code analysis, database access specification modeling, SQL analysis, and database abstraction within a single pointer analysis framework, capturing interactions across a wide range of database access APIs and frameworks. Additionally, we present DB-Micro, a new micro-benchmark suite with 824 test cases crafted to systematically evaluate static analysis for database-backed applications. Experiments on DB-Micro and large, complex, real-world applications demonstrate DBridge's effectiveness, achieving high recall and precision in building Java-to-database value flows efficiently and outperforming state-of-the-art tools in SQL statement identification. To further validate DBridge's utility, we develop three client analyses for security and program understanding. Evaluation on these real-world applications reveals 30 Stored XSS attack vulnerabilities and 3 horizontal broken access control vulnerabilities, all previously undiscovered and real, as well as a high detection rate in impact analysis for schema changes. By open-sourcing DBridge (14K LoC) and DB-Micro (22K LoC), we seek to help advance static analysis for modern database-backed applications in the future.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729307", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yufei", + "last_name": "Liang", + "institution": "Nanjing University" + }, + { + "first_name": "Teng", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Ganlin", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "Nanjing University" + }, + { + "first_name": "Chang", + "last_name": "Xu", + "institution": "Nanjing University" + }, + { + "first_name": "Chun", + "last_name": "Cao", + "institution": "Nanjing University" + }, + { + "first_name": "Xiaoxing", + "last_name": "Ma", + "institution": "Nanjing University" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/LiangZLTXCML25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729266", + "title": "Link-Time Optimization of Dynamic Casts in C++ Programs", + "abstract": "A core design principle of C++ is that users should only incur costs for features they actually use, both in terms of performance and code size. A notable exception to this rule is the run-time type information (RTTI) data, used for dynamic downcasts, exceptions, and run-time type introspection. For classes that define at least one virtual method, compilers generate RTTI data that uniquely identifies the type, including a string for the type name. In large programs with complex type inheritance hierarchies, this RTTI data can grow substantially in size. Moreover, dynamic casting algorithms are linear in the type hierarchy size, causing some programs to spend considerable time on these casts. The common workaround is to use the -fno-rtti compiler flag, which disables RTTI data generation. However, this approach has significant drawbacks, such as disabling polymorphic exceptions and dynamic casts, and requiring the flag to be applied across the entire program due to ABI changes. In this paper, we propose a new link-time optimization to mitigate both the performance and size overhead associated with dynamic casts and RTTI data. Our optimization replaces costly library calls for downcasts with short instruction sequences and eliminates unnecessary RTTI data by modifying vtables to remove RTTI slots. Our prototype, implemented in the LLVM compiler, demonstrates an average speedup of 1.4", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729266", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xufan", + "last_name": "Lu", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + } + ], + "dblp_key": "journals/pacmpl/LuL25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729277", + "title": "Dynamic Robustness Verification against Weak Memory", + "abstract": "Dynamic race detection is a highly effective runtime verification technique for identifying data races by instrumenting and monitoring concurrent program runs. However, standard dynamic race detection is incompatible with practical weak memory models; the added instrumentation introduces extra synchronization, which masks weakly consistent behaviors and inherently misses certain data races. In response, we propose to dynamically verify program robustness-a property ensuring that a program exhibits only strongly consistent behaviors. Building on an existing static decision procedure, we develop an algorithm for dynamic robustness verification under a C11-style memory model. The algorithm is based on \"location clocks\", a variant of vector clocks used in standard race detection. It allows effective and easy-to-apply defense against weak memory on a per-program basis, which can be combined with race detection that assumes strong consistency. We implement our algorithm in a tool, called RSAN, and evaluate it across various settings. To our knowledge, this work is the first to propose and develop dynamic verification of robustness against weak memory models.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729277", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Roy", + "last_name": "Margalit", + "institution": "Tel Aviv University" + }, + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "ETH Zurich" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/MargalitKIL25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729324", + "title": "Bean: A Language for Backward Error Analysis", + "abstract": "Backward error analysis offers a method for assessing the quality of numerical programs in the presence of floating-point rounding errors. However, techniques from the numerical analysis literature for quantifying backward error require substantial human effort, and there are currently no tools or automated methods for statically deriving sound backward error bounds. To address this gap, we propose Bean, a typed first-order programming language designed to express quantitative bounds on backward error. Bean’s type system combines a graded coeffect system with strict linearity to soundly track the flow of backward error through programs. We prove the soundness of our system using a novel categorical semantics, where every Bean program denotes a triple of related transformations that together satisfy a backward error guarantee. To illustrate Bean’s potential as a practical tool for automated backward error analysis, we implement a variety of standard algorithms from numerical linear algebra in Bean, establishing fine-grained backward error bounds via typing in a compositional style. We also develop a prototype implementation of Bean that infers backward error bounds automatically. Our evaluation shows that these inferred bounds match worst-case theoretical relative backward error bounds from the literature, underscoring Bean’s utility in validating a key property of numerical programs: numerical stability .", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729324", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ariel", + "last_name": "Kellison", + "institution": "Cornell University" + }, + { + "first_name": "Laura", + "last_name": "Zielinski", + "institution": "Cornell University" + }, + { + "first_name": "David", + "last_name": "Bindel", + "institution": "Cornell University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/KellisonZBH25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729264", + "title": "Programming by Navigation", + "abstract": "When a program synthesis task starts from an ambiguous specification, the synthesis process often involves an iterative specification refinement process. We introduce the Programming by Navigation Synthesis Problem, a new synthesis problem adapted specifically for supporting iterative specification refinement in order to find a particular target solution. In contrast to prior work, we prove that synthesizers that solve the Programming by Navigation Synthesis Problem show all valid next steps ( Strong Completeness ) and only valid next steps ( Strong Soundness ). To meet the demands of the Programming by Navigation Synthesis Problem, we introduce an algorithm to turn a type inhabitation oracle (in the style of classical logic) into a fully constructive program synthesizer. We then define such an oracle via sound compilation to Datalog. Our empirical evaluation shows that this technique results in an efficient Programming by Navigation synthesizer that solves tasks that are either impossible or too large for baselines to solve. Our synthesizer is the first to guarantee that its specification refinement process satisfies both Strong Completeness and Strong Soundness .", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729264", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Justin", + "last_name": "Lubin", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Parker", + "last_name": "Ziegler", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/LubinZC25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729250", + "title": "Nola: Later-Free Ghost State for Verifying Termination in Iris", + "abstract": "Separation logic (SL) has recently evolved at an exciting pace, opening the way to more complex goals, notably soundness proof of Rust's ownership type system and functional verification of Rust programs. In this paper, we address verification of termination in the presence of advanced features, especially Rust's ownership types. Perhaps surprisingly, this goal cannot be achieved by a simple application of existing studies that dealt only with safety properties. For high-level reasoning about advanced shared mutable state as used in Rust, they used higher-order ghost state (i.e., logical state that depends on SL assertions), but in a way that depends on the later modality, a fundamental obstacle to verifying termination. To solve this situation, we propose a novel general framework, Nola, which achieves later-free higher-order ghost state. Even in the presence of advanced features such as invariants and borrows, Nola enables natural termination verification, allowing arbitrary induction in the meta-logic. Its key idea is to parameterize higher-order ghost state, generalizing and subsuming the existing approach. Nola is fully mechanized in Rocq as a library of Iris. Moreover, to demonstrate the power of Nola, we develop a prototype of RustHalt, the first semantic and mechanized foundation for total correctness verification of Rust programs.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729250", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Yusuke", + "last_name": "Matsushita", + "institution": "Kyoto University" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + } + ], + "dblp_key": "journals/pacmpl/MatsushitaT25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729294", + "title": "Verified Foundations for Differential Privacy", + "abstract": "Differential privacy (DP) has become the gold standard for privacy-preserving data analysis, but implementing it correctly has proven challenging. Prior work has focused on verifying DP at a high level, assuming either that the foundations are correct or that a perfect source of random noise is available. However, the underlying theory of differential privacy can be very complex and subtle. Flaws in basic mechanisms and random number generation have been a critical source of vulnerabilities in real-world DP systems. In this paper, we present SampCert, the first comprehensive, mechanized foundation for executable implementations of differential privacy. SampCert is written in Lean with over 12,000 lines of proof. It offers a generic and extensible notion of DP, a framework for constructing and composing DP mechanisms, and formally verified implementations of Laplace and Gaussian sampling algorithms. SampCert provides (1) a mechanized foundation for developing the next generation of differentially private algorithms, and (2) mechanically verified primitives that can be deployed in production systems. Indeed, SampCert's verified algorithms power the DP offerings of Amazon Web Services, demonstrating its real-world impact. SampCert's key innovations include: (1) A generic DP foundation that can be instantiated for various DP definitions (e.g., pure, concentrated, Rényi DP); (2) formally verified discrete Laplace and Gaussian sampling algorithms that avoid the pitfalls of floating-point implementations; and (3) a simple probability monad and novel proof techniques that streamline the formalization. To enable proving complex correctness properties of DP and random number generation, SampCert makes heavy use of Lean's extensive Mathlib library, leveraging theorems in Fourier analysis, measure and probability theory, number theory, and topology.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729294", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Markus de", + "last_name": "Medeiros", + "institution": "New York University" + }, + { + "first_name": "Muhammad", + "last_name": "Naveed", + "institution": "Amazon (United States)" + }, + { + "first_name": "Tancrède", + "last_name": "Lepoint", + "institution": "Amazon (United States)" + }, + { + "first_name": "Temesghen", + "last_name": "Kahsai", + "institution": "Amazon (United States)" + }, + { + "first_name": "Tristan", + "last_name": "Ravitch", + "institution": "Amazon (United States)" + }, + { + "first_name": "Stefan", + "last_name": "Zetzsche", + "institution": "Amazon (United Kingdom)" + }, + { + "first_name": "Anjali", + "last_name": "Joshi", + "institution": "Boston University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "Amazon (United States)" + }, + { + "first_name": "Jean-Baptiste", + "last_name": "Tristan", + "institution": "Boston University" + } + ], + "dblp_key": "journals/pacmpl/MedeirosNLKRZJTAT25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729263", + "title": "Semantics of Integrating and Differentiating Singularities", + "abstract": "A singular function is a partial function such that at one or more points, the left and/or right limit diverge (e.g., the function 1/ x ). Since programming languages typically support division, programs may denote singular functions. Although on its own, a singularity may be considered a bug, introducing a division-by-zero error, singular integrals —a version of the integral that is well-defined when the integrand is a singular function and the domain of integration contains a singularity—arise in science and engineering, including in physics, aerodynamics, mechanical engineering, and computer graphics. In this paper, we present the first semantics of a programming language for singular integration. Our differentiable programming language, SingularFlow, supports the evaluation and differentiation of singular integrals. We formally define the denotational semantics of SingularFlow, deriving all the necessary mathematical machinery so that this work is rigorous and self-contained. We then define an operational semantics for SingularFlow that estimates integrals and their derivatives using Monte Carlo samples, and show that the operational semantics is a well-behaved estimator for the denotational semantics. We implement SingularFlow in JAX and evaluate the implementation on a suite of benchmarks that perform the finite Hilbert transform , an integral transform related to the Fourier transform, which arises in domains such as physics and electrical engineering. We then use SingularFlow to approximate the solutions to four singular integral equations —equations where the unknown function is in the integrand of a singular integral—arising in aerodynamics and mechanical engineering.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729263", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Jesse", + "last_name": "Michel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/MichelLY25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729304", + "title": "Automated Exploit Generation for Node.js Packages", + "abstract": "The Node.js ecosystem, with its growing popularity and increasing exposure to security vulnerabilities, has a pressing need for more effective security analysis tools. To reduce false positives, recent works on detecting vulnerabilities in Node.js packages have developed synthesis algorithms to generate proof-of-concept exploits. However, these tools focus mainly on vulnerabilities that can be triggered by a single direct call to an exported function of the analyzed package, failing to generate exploits that require more complex interactions. In this paper, we present Explode.js, the first tool capable of synthesizing exploits that include complex call sequences to trigger vulnerabilities in Node.js packages. By combining static analysis and symbolic execution, Explode.js generates functional exploits that confirm the existence of command, code injection, prototype pollution, and path traversal vulnerabilities, effectively eliminating false positives. The results of evaluating Explode.js on two state-of-the-art datasets of Node.js packages with confirmed vulnerabilities show that it generates significantly more exploits than its main competitor tools. Furthermore, when applied to real-world Node.js packages, Explode.js uncovered 44 zero-day vulnerabilities, with 4 new CVEs.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729304", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Filipe", + "last_name": "Marques", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Mafalda", + "last_name": "Ferreira", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "André", + "last_name": "Nascimento", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Miguel E.", + "last_name": "Coimbra", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Nuno", + "last_name": "Santos", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "José Fragoso", + "last_name": "Santos", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + } + ], + "dblp_key": "journals/pacmpl/MarquesFNCSJS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729295", + "title": "Active Learning of Symbolic NetKAT Automata", + "abstract": "NetKAT is a domain-specific programming language and logic that has been successfully used to specify and verify the behavior of packet-switched networks. This paper develops techniques for automatically learning NetKAT models of unknown networks using active learning. Prior work has explored active learning for a wide range of automata (e.g., deterministic, register, Büchi, timed etc.) and also developed applications, such as validating implementations of network protocols. We present algorithms for learning different types of NetKAT automata, including symbolic automata proposed in recent work. We prove the soundness of these algorithms, build a prototype implementation, and evaluate it on a standard benchmark. Our results highlight the applicability of symbolic NetKAT learning for realistic network configurations and topologies.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729295", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Mark", + "last_name": "Moeller", + "institution": "Cornell University" + }, + { + "first_name": "Tiago", + "last_name": "Ferreira", + "institution": "University College London" + }, + { + "first_name": "Thomas", + "last_name": "Lu", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/MoellerFLFS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3742465", + "title": "AWDIT: An Optimal Weak Database Isolation Tester", + "abstract": "Database isolation is a formal contract concerning the level of data consistency that a database provides to its clients. In order to achieve low latency, high throughput, and partition tolerance, modern databases forgo strong transaction isolation for weak isolation guarantees. However, several production databases have been found to suffer from isolation bugs , breaking their data-consistency contract. Black-box testing is a prominent technique for detecting isolation bugs, by checking whether histories of database transactions adhere to a prescribed isolation level. In order to test databases on realistic workloads of large size, isolation testers must be as efficient as possible, a requirement that has initiated a study of the complexity of isolation testing. Although testing strong isolation has been known to be NP-complete, weak isolation levels were recently shown to be testable in polynomial time, which has propelled the scalability of testing tools. However, existing testers have a large polynomial complexity, restricting testing to workloads of only moderate size, which is not typical of large-scale databases. How efficiently can we provably test weak database isolation? In this work, we develop AWDIT, a highly-efficient and provably optimal tester for weak database isolation . Given a history H of size n and k sessions, AWDIT tests whether H satisfies the most common weak isolation levels of Read Committed (RC), Read Atomic (RA), and Causal Consistency (CC) in time O ( n 3/2 ), O ( n 3/2 ), and O ( n · k ), respectively, improving significantly over the state of the art. Moreover, we prove that AWDIT is essentially optimal , in the sense that there is a lower bound of n 3/2 , based on the combinatorial BMM hypothesis, for any weak isolation level between RC and CC. Our experiments show that AWDIT is significantly faster than existing, highly optimized testers; e.g., for the ∼20% largest histories, AWDIT obtains an average speedup of 245×, 193×, and 62× for RC, RA, and CC, respectively, over the best baseline.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3742465", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lasse", + "last_name": "Møldrup", + "institution": "Aarhus University" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/MoldrupP25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729286", + "title": "Probabilistic Kleene Algebra with Angelic Nondeterminism", + "abstract": "We introduce a version of probabilistic Kleene algebra with angelic nondeterminism and a corresponding class of automata. Our approach implements semantics via distributions over multisets in order to overcome theoretical barriers arising from the lack of a distributive law between the powerset and Giry monads. We produce a full Kleene theorem and a coalgebraic theory, as well as both operational and denotational semantics and equational reasoning principles.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729286", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Shawn", + "last_name": "Ong", + "institution": "Cornell University" + }, + { + "first_name": "Stephanie", + "last_name": "Ma", + "institution": "Cornell University" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/OngMK25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729274", + "title": "Type-Constrained Code Generation with Language Models", + "abstract": "Large language models (LLMs) have achieved notable success in code generation. However, they still frequently produce uncompilable output because their next-token inference procedure does not model formal aspects of code. Although constrained decoding is a promising approach to alleviate this issue, it has only been applied to handle either domain-specific languages or syntactic features of general-purpose programming languages. However, LLMs frequently generate code with typing errors, which are beyond the domain of syntax and generally hard to adequately constrain. To address this challenge, we introduce a type-constrained decoding approach that leverages type systems to guide code generation. For this purpose, we develop novel prefix automata and a search over inhabitable types, forming a sound approach to enforce well-typedness on LLM-generated code. We formalize our approach on a foundational simply-typed language and extend it to TypeScript to demonstrate practicality. Our evaluation on the HumanEval and MBPP datasets shows that our approach reduces compilation errors by more than half and significantly increases functional correctness in code synthesis, translation, and repair tasks across LLMs of various sizes and model families, including state-of-the-art open-weight models with more than 30B parameters. The results demonstrate the generality and effectiveness of our approach in constraining LLM code generation with formal rules of type systems.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729274", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Niels", + "last_name": "Mündler", + "institution": "ETH Zurich" + }, + { + "first_name": "Jingxuan", + "last_name": "He", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Hao", + "last_name": "Wang", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Dawn", + "last_name": "Song", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/MundlerHWSSV25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729334", + "title": "Roulette: A Language for Expressive, Exact, and Efficient Discrete Probabilistic Programming", + "abstract": "Exact probabilistic inference is a requirement for many applications of probabilistic programming languages (PPLs) such as in high-consequence settings or verification. However, designing and implementing a PPL with scalable high-performance exact inference is difficult: exact inference engines, much like SAT solvers, are intricate low-level programs that are hard to implement. Due to this implementation challenge, PPLs that support scalable exact inference are restrictive and lack many features of general-purpose languages. This paper presents Roulette, the first discrete probabilistic programming language that combines high-performance exact inference with general-purpose language features. Roulette supports a significant subset of Racket, including data structures, first-class functions, surely-terminating recursion, mutable state, modules, and macros, along with probabilistic features such as finitely supported discrete random variables, conditioning, and top-level inference. The key insight is that there is a close connection between exact probabilistic inference and the symbolic evaluation strategy of Rosette. Building on this connection, Roulette generalizes and extends the Rosette solver-aided programming system to reason about probabilistic rather than symbolic quantities. We prove Roulette sound by generalizing a proof of correctness for Rosette to handle probabilities, and demonstrate its scalability and expressivity on a number of examples.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729334", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Cameron", + "last_name": "Moy", + "institution": "Northeastern University" + }, + { + "first_name": "Jack", + "last_name": "Czenszak", + "institution": "Northeastern University" + }, + { + "first_name": "John M.", + "last_name": "Li", + "institution": "Northeastern University" + }, + { + "first_name": "Brianna", + "last_name": "Marshall", + "institution": "Northeastern University" + }, + { + "first_name": "Steven", + "last_name": "Holtzen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/MoyCLMH25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729301", + "title": "MISAAL: Synthesis-Based Automatic Generation of Efficient and Retargetable Semantics-Driven Optimizations", + "abstract": "Using program synthesis to select instructions for and optimize input programs is receiving increasing attention. However, existing synthesis-based compilers are faced by two major challenges that prohibit the deployment of program synthesis in production compilers: exorbitantly long synthesis times spanning several minutes and hours; and scalability issues that prevent synthesis of complex modern compute and data swizzle instructions, which have been found to maximize performance of modern tensor and stencil workloads. This paper proposes MISAAL, a synthesis-based compiler that employs a novel strategy to use formal semantics of hardware instructions to automatically prune a large search space of rewrite rules for modern complex instructions in an offline stage. MISAAL also proposes a novel methodology to make term-rewriting process in the online stage (at compile-time) extremely lightweight so as to enable programs to compile in seconds. Our results show that MISAAL reduces compilation times by up to a geomean of 16x compared to the state-of-the-art synthesis-based compiler, HYDRIDE. MISAAL also delivers competitive runtime performance against the production compiler for image processing and deep learning workloads, Halide, as well as HYDRIDE across x86, Hexagon and ARM.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729301", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Abdul Rafae", + "last_name": "Noor", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Dhruv", + "last_name": "Baronia", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Anshul", + "last_name": "Kothari", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Muchen", + "last_name": "Xu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/NoorBKXMA25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729320", + "title": "Verifying Solutions to Semantics-Guided Synthesis Problems", + "abstract": "Semantics-Guided Synthesis (SemGuS) provides a framework to specify synthesis problems in a solver-agnostic and domain-agnostic way, by allowing a user to provide both the syntax and semantics of the language in which the desired program should be synthesized. Because synthesis and verification are closely intertwined, the SemGuS framework raises the following question: how does one verify that a user-given program satisfies a given specification when interpreted according to a user-given semantics? In this paper, we prove that this form of language-agnostic verification (specifically that verifying whether a program is a valid solution to a SemGuS problem) can be reduced to proving validity of a query in the µCLP calculus, a fixed-point logic that is capable of expressing alternating least and greatest fixed-points. Our encoding into µCLP allows us to further classify the SemGuS verification problems into ones that are reducible to satisfiability of (i) first-order-logic formulas, (ii) Constrained Horn Clauses, and (iii) µCLP queries. Furthermore, our encoding shines light on some limitations of the SemGuS framework, such as its inability to model nondeterminism and reactive synthesis. We thus propose a modification to SemGuS that makes it more expressive, and for which verifying solutions is exactly equivalent to proving validity of a query in the µCLP calculus. Our implementation of SemGuS verifiers based on the above encoding can verify instances that were not even encodable in previous work. Furthermore, we use our SemGuS verifiers within an enumeration-based SemGuS solver to correctly synthesize solutions to SemGuS problems that no previous SemGuS synthesizer could solve.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729320", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Charlie", + "last_name": "Murphy", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Keith J. C.", + "last_name": "Johnson", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/MurphyJRD25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729333", + "title": "Thrust: A Prophecy-Based Refinement Type System for Rust", + "abstract": "We introduce Thrust, a new verification tool for ensuring functional correctness in Rust, distinguished by its strengths in automated verification, including the synthesis of inductive invariants for loops and recursive functions. Thrust is built on a novel dependent refinement type system for Rust and refinement type inference techniques based on Constrained Horn Clause (CHC) solvers. Leveraging advantages of the type system, Thrust also supports semi-automated verification utilizing user type annotations to complement CHC solvers in cases where automatic constraint solving is unsuccessful, as well as modular verification at the function and subexpression levels. Thrust also achieves precise verification, especially for programs involving pointer aliasing and borrowing, without sacrificing the benefits of automated verification, by incorporating the notion of prophecy into the refinement type system: it not only enables strong updates by leveraging the “aliasing XOR mutability” guarantee provided by Rust’s type system, but also achieves propagation of update information to the original owner upon mutable borrow release through the use of a prophecy variable. Incorporating prophecy into a refinement type system is itself challenging and requires certain tricks, as discussed in this paper, making a theoretical contribution and paving the way for further research into prophecy-based refinement type systems. While our type system addresses the challenge, we keep it simple for extensibility, specifically by delegating the guarantee of “aliasing XOR mutability,” and, more technically, the “well-borrowedness” of the program in the sense of the stacked borrows aliasing model, to Rust’s type system, allowing us to focus on reasoning about functional correctness and propagating update information through prophecy variables. Compared to RustHorn, another automated verification tool based on prophecy, our approach leverages the strengths of refinement types to support modular verification, higher-order functions, and refinement of data stored in algebraic data structures. We implemented Thrust, a refinement type inference tool as a plugin for the Rust compiler, and evaluated it using RustHorn benchmarks, as well as additional new benchmarks, including those that are beyond the capabilities of RustHorn and other semi-automated verification tools, obtaining promising results.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729333", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hiromi", + "last_name": "Ogawa", + "institution": "University of Tsukuba" + }, + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/OgawaSU25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729248", + "title": "Verifying Lock-Free Traversals in Relaxed Memory Separation Logic", + "abstract": "We report the first formal verification of a lock-free list, skiplist, and a skiplist-based priority queue against a strong specification in relaxed memory consistency (RMC). RMC allows relaxed behaviors in which memory accesses may be reordered with other operations, posing two significant challenges for the verification of lock-free traversals. (1) Specification challenge : formulating a specification that is flexible enough to capture relaxed behaviors, yet simple enough to be easily understood and used. We address this challenge by proposing the per-key linearizable history specification that enforces a total order of operations for each key that respects causality, rather than a total order of all operations. (2) Verification challenge : devising verification techniques for reasoning about the reachability of edges for traversing threads, which can read stale edges due to relaxed behaviors. We address this challenge by introducing the shadowed-by relation that formalizes the notion of outdated edges. This relation enables us to establish a total order of edges and thus their associated operations for each key, required to satisfy the strong specification. All our proofs are mechanized on the iRC11 relaxed memory separation logic, built on the Iris framework in Rocq.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729248", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sunho", + "last_name": "Park", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jaehwang", + "last_name": "Jung", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Janggun", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ParkJLK25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729332", + "title": "Correctly Rounded Math Libraries without Worrying about the Application's Rounding Mode", + "abstract": "Our RLibm project has recently proposed methods to generate a single implementation for an elementary function that produces correctly rounded results for multiple rounding modes and representations with up to 32-bits. They are appealing for developing fast reference libraries without double rounding issues. The key insight is to build polynomial approximations that produce the correctly rounded result for a representation with two additional bits when compared to the largest target representation and with the \"non-standard\" round-to-odd rounding mode, which makes double rounding the RLibm math library result to any smaller target representation innocuous. The resulting approximations generated by the RLibm approach are implemented with machine supported floating-point operations with the round-to-nearest rounding mode. When an application uses a rounding mode other than the round-to-nearest mode, the RLibm math library saves the application's rounding mode, changes the system's rounding mode to round-to-nearest, computes the correctly rounded result, and restores the application’s rounding mode. This frequent change of rounding modes has a performance cost. This paper proposes two new methods, which we call rounding-invariant outputs and rounding-invariant input bounds, to avoid the frequent changes to the rounding mode and the dependence on the round-to-nearest mode. First, our new rounding-invariant outputs method proposes using the round-to-zero rounding mode to implement RLibm's polynomial approximations. We propose fast, error-free transformations to emulate a round-to-zero result from any standard rounding mode without changing the rounding mode. Second, our rounding-invariant input bounds method factors any rounding error due to different rounding modes using interval bounds in the RLibm pipeline. Both methods make a different set of trade-offs and improve the performance of resulting libraries by more than 2X.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729332", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Sehyeok", + "last_name": "Park", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Justin", + "last_name": "Kim", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "journals/pacmpl/ParkKN25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729288", + "title": "CRGC: Fault-Recovering Actor Garbage Collection in Pekko", + "abstract": "Actors are lightweight reactive processes that communicate by asynchronous message-passing. Actors address common problems like concurrency control and fault tolerance, but resource management remains challenging: in all four of the most popular actor frameworks (Pekko, Akka, Erlang, and Elixir) programmers must explicitly kill actors to free up resources. To simplify resource management, researchers have devised actor garbage collectors (actor GCs) that monitor the application and detect when actors are safe to kill. However, existing actor GCs are impractical for distributed systems where the network is unreliable and nodes can fail. The simplest actor GCs do not collect cyclic garbage, whereas more sophisticated actor GCs are not fault-recovering : dropped messages and crashed nodes can cause actors to become garbage that never gets collected. We present Conflict-free Replicated Garbage Collection (CRGC): the first fault-recovering cyclic actor GC. In CRGC, actors and nodes record information locally and broadcast updates to the garbage collectors running on each node. CRGC does not require locks, explicit memory barriers, or any assumptions about message delivery order, except for reliable FIFO channels from actors to their local garbage collector. Moreover, CRGC is simple: we concisely present its operational semantics, which has been formalized in TLA + , and prove both soundness (non-garbage actors are never killed) and completeness (all garbage actors are eventually killed, under reasonable assumptions). We also present a preliminary implementation in Apache Pekko and measure its performance using two actor benchmark suites. Our results show the performance overhead of CRGC is competitive with simpler approaches like weighted reference counting, while also being much more powerful.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729288", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dan", + "last_name": "Plyukhin", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Gul", + "last_name": "Agha", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Fabrizio", + "last_name": "Montesi", + "institution": "University of Southern Denmark" + } + ], + "dblp_key": "journals/pacmpl/PlyukhinAM25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729321", + "title": "Handling the Selection Monad", + "abstract": "The selection monad on a set consists of selection functions. These select an element from the set, based on a loss (dually, reward) function giving the loss resulting from a choice of an element. Abadi and Plotkin used the monad to model a language with operations making choices of computations taking account of the loss that would arise from each choice. However, their choices were optimal, and they asked if they could instead be programmer provided. In this work, we present a novel design enabling programmers to do so. We present a version of algebraic effect handlers enriched by computational ideas inspired by the selection monad. Specifically, as well as the usual delimited continuations, our new kind of handlers additionally have access to choice continuations, that give the possible future losses. In this way programmers can write operations implementing optimisation algorithms that are aware of the losses arising from their possible choices. We give an operational semantics for a higher-order model language λ C , and establish desirable properties including progress, type soundness, and termination for a subset with a mild hierarchical constraint on allowable operation types. We give this subset a selection monad denotational semantics, and prove soundness and adequacy results. We also present a Haskell implementation and give a variety of programming examples.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729321", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "Google (United States)" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/PlotkinX25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729260", + "title": "Exploiting Undefined Behavior in C/C++ Programs for Optimization: A Study on the Performance Impact", + "abstract": "The C and C++ languages define hundreds of cases as having undefined behavior (UB). These include, for example, corner cases where different CPU architectures disagree on the semantics of an instruction and the language does not want to force a specific implementation (e.g., shift by a value larger than the bitwidth). Another class of UB involves errors that the language chooses not to detect because it would be too expensive or impractical, such as dereferencing out-of-bounds pointers. Although there is a common belief within the compiler community that UB enables certain optimizations that would not be possible otherwise, no rigorous large-scale studies have been conducted on this subject. At the same time, there is growing interest in eliminating UB from programming languages to improve security. In this paper, we present the first comprehensive study that examines the performance impact of exploiting UB in C and C++ applications across multiple CPU architectures. Using LLVM, a compiler known for its extensive use of UB for optimizations, we demonstrate that, for the benchmarks and UB categories that we evaluated, the end-to-end performance gains are minimal. Moreover, when performance regresses, it can often be recovered through small improvements to optimization algorithms or by using link-time optimizations.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729260", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Lucian", + "last_name": "Popescu", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + } + ], + "dblp_key": "journals/pacmpl/PopescuL25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729285", + "title": "Iso: Request-Private Garbage Collection", + "abstract": "Large-scale, revenue-critical application services are often written in Java or other memory-safe languages whose type systems do not expose immutable state. Such applications are especially exposed to garbage collection performance overheads because latency, throughput, and memory consumption are first-order concerns for service providers. We observe that: i) An important class of server applications are request-based: they scale by concurrently servicing large numbers of quasi-independent requests. ii) Object lifetimes are strongly tied to request lifetimes. iii) Most objects remain private to the request in which they were allocated. iv) Global operations are the primary impediment to responsiveness at scale. If we could perform request-private garbage collection , we might achieve both responsiveness and efficiency at scale. Unfortunately, this straightforward insight runs into significant practical problems. The most obvious of these is that a request-private collection cannot safely move objects that may be referenced outside the scope of that request, and yet moving objects is a requirement of most modern high performance collector designs. This dilemma can be sidestepped by exploiting immutability, which is unfortunately not practical in languages like Java whose type systems do not expose it. We develop Iso, a garbage collector for request-based services that exploits a mark-region heap structure to solve these impediments and deliver outstanding performance. The key contributions of this paper are that: i) We use opportunistic copying to solve the problem of practical thread-local garbage collection for languages without exploitable immutability. ii) We provide the first detailed analysis of the behavior of Java workloads with respect to thread-local collection, identify shortcomings of existing benchmarks and introduce a new one. iii) We design, implement, and evaluate Iso, a practical and effective request-private GC. We show that dynamic tracking of object visibility, a prerequisite for request-private GC, incurs an overhead of just 2% for important request-based workloads including Tomcat and Spring. Iso demonstrates that for suitable workloads, request-based garbage collection is extremely effective, outperforming OpenJDK with its default collector, G1, by 32% and 22% in execution time in a modest heap. This work presents the first request-private garbage collector for Java. It shows a promising way forward for highly responsive collection on an important class of large scale workloads.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729285", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Tianle", + "last_name": "Qiu", + "institution": "Australian National University" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + } + ], + "dblp_key": "journals/pacmpl/QiuB25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729280", + "title": "Webs and Flow-Directed Well-Typedness Preserving Program Transformations", + "abstract": "We define webs to be the collections of producers and consumers ( e.g. , functions and calls) in a program that are constrained: in higher-order languages, multiple functions can flow to the same call, all of which must agree on an interface ( e.g. , calling convention). We argue that webs are fundamentally the unit of transformation : a change to one member requires changes across the entire web. We introduce a web-centric intermediate language that exposes webs as annotations, and describe web-based (that is, flow-directed) transformations guided by these annotations. As they affect all members of a web, these transformations are interprocedural, operating over entire modules. Through the lens of webs we reframe and generalize a collection of transformations from the literature, including dead-parameter elimination, uncurrying, and defunctionalization, as well as describe novel transformations. We contrast this approach with rewriting strategies that rely on inlining and cascading rewrites. Webs are an over-approximation of the semantic function-call relationship produced by control-flow analyses (CFA). This information is inherently independent from the transformations; more precise analyses permit more transformations. A limitation of precise analyses is that the transformations may not maintain well-typedness, as the type system is a less-precise static analysis. Our solution is a simple and lightweight typed-based analysis that causes the flow-directed transformations to preserve well-typedness, making flow-directed, type-preserving transformations easily accessible in many compilers. This analysis builds on unification, distinguishing types that look the same from types that have to be the same. Our experiments show that while our analysis is theoretically less precise, in practice its precision is similar to CFAs.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729280", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Quiring", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Chicago" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/QuiringHRS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729306", + "title": "LiDO-DAG: A Framework for Verifying Safety and Liveness of DAG-Based Consensus Protocols", + "abstract": "Blockchains operating at the global scale demand high-performance byzantine fault-tolerant (BFT) consensus protocols. Most classic PBFT-like protocols suffer from an issue known as the leader bottleneck, which severely limits their throughput and resource utilization. Recently, Directed Acyclic Graph, or DAG-based protocols, have emerged as a promising approach for eliminating the leader bottleneck and achieving better performance. They attain higher throughput by separating data dissemination and block ordering. However, their safety and liveness logic is also significantly more elaborate. So far, most DAG-based protocols have only enjoyed on-paper security proofs, and it is not clear how to construct formal proofs of these protocols efficiently. We introduce LiDO-DAG, a concurrent object model that abstracts the common logic of these protocols. LiDO-DAG is constructed by combining a DAG abstraction and LiDO, a recently proposed abstraction for leader-based consensus. To demonstrate that our framework enables rapid validation of new DAG-based protocol designs, we implemented LiDO-DAG in Coq and applied it to three recent DAG-based protocols, including Narwhal, Bullshark, and Sailfish. Our framework readily yields mechanized safety and liveness proofs for all three protocols, which are also the first mechanized liveness proofs of any DAG-based protocol. Our framework has also revealed an optimization for Sailfish that improves its worst-case latency.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729306", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Longfei", + "last_name": "Qiu", + "institution": "Yale University" + }, + { + "first_name": "Jingqi", + "last_name": "Xiao", + "institution": "Yale University" + }, + { + "first_name": "Ji-Yong", + "last_name": "Shin", + "institution": "Northeastern University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/QiuXSS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729299", + "title": "Functional Meaning for Parallel Streaming", + "abstract": "Nondeterminism introduced by race conditions and message reorderings makes parallel and distributed programming hard. Nevertheless, promising approaches such as LVars and CRDTs address this problem by introducing a partial order structure on shared state that describes how the state evolves over time. Monotone programs that respect the order are deterministic. Datalog-inspired languages incorporate this idea of monotonicity in a first-class way but they are not general-purpose. We would like parallel and distributed languages to be as natural to use as any functional language, without sacrificing expressivity, and with a formal basis of study as appealing as the lambda calculus. This paper presents λ ∨ , a core language for deterministic parallelism that embodies the ideas above. In λ ∨ , values may increase over time according to a streaming order and all computations are monotone with respect to that order. The streaming order coincides with the approximation order found in Scott semantics and so unifies the foundations of functional programming with the foundations of deterministic distributed computation. The resulting lambda calculus has a computationally adequate model rooted in domain theory. It integrates the compositionality and power of abstraction characteristic of functional programming with the declarative nature of Datalog.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729299", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nick", + "last_name": "Rioux", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/RiouxZ25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729323", + "title": "Exact Loop Bound Analysis", + "abstract": "There are many state-of-the-art techniques for loop bound analysis. Most of them target an upper bound for a given program, and others find a lower bound. Exact bound analysis still remains largely unexplored, but it offers new applications. To compute an exact bound for a program it is necessary to reason about the possible values the program’s inputs can take and how they relate to each other. Since inputs can vary on any given execution of the program, it makes the problem of computing an exact bound challenging. In this work, we present a new approach to find an exact bound by way of precondition synthesis which iteratively considers under-approximations of a program under which the bound can be precomputed over initial values of program variables. For each precondition, our approach synthesizes a function over program variables such that when the function is applied to the initial values of the program variables, its output is an exact bound for the program. We reduce the precondition synthesis problem to that of safety verification which lends its correctness guarantees to the exact bounds we compute. Our technique has been implemented in a tool called Elba, and we show that it is effective on a set of challenging single loop benchmarks under Linear Integer Arithmetic.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729323", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Riley", + "institution": "Florida State University" + }, + { + "first_name": "Grigory", + "last_name": "Fedyukovich", + "institution": "Florida State University" + } + ], + "dblp_key": "journals/pacmpl/RileyF25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729251", + "title": "Random Variate Generation with Formal Guarantees", + "abstract": "Generating random variates is a fundamental operation in diverse areas of computer science and is supported in almost all modern programming languages. Traditional software libraries for random variate generation are grounded in the idealized \"Real-RAM\" model of computation, where algorithms are assumed to be able to access uniformly distributed real numbers from the unit interval and compute with infinite-precision real arithmetic. These assumptions are unrealistic, as any software implementation of a Real-RAM algorithm on a physical computer can instead access a stream of individual random bits and computes with finite-precision arithmetic. As a result, existing libraries have few theoretical guarantees in practice. For example, the actual distribution of a random variate generator is generally unknown, intractable to quantify, and arbitrarily different from the desired distribution; causing runtime errors, unexpected behavior, and inconsistent APIs. This article introduces a new approach to principled and practical random variate generation with formal guarantees. The key idea is to first specify the desired probability distribution in terms of a finite-precision numerical program that defines its cumulative distribution function (CDF), and then generate exact random variates according to this CDF. We present a universal and fully automated method to synthesize exact random variate generators given any numerical CDF implemented in any binary number format, such as floating-point, fixed-point, and posits. The method is guaranteed to operate with the same precision used to specify the CDF, does not overflow, avoids expensive arbitrary-precision arithmetic, and exposes a consistent API. The method rests on a novel space-time optimal implementation for the class of generators that attain the information-theoretically optimal Knuth and Yao entropy rate, consuming the least possible number of input random bits per output variate. We develop a random variate generation library using our method in C and evaluate it on a diverse set of \"continuous\" and \"discrete\" distributions, showing competitive runtime with the state-of-the-art GNU Scientific Library while delivering higher accuracy, entropy efficiency, and automation.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729251", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Pohang University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/SaadL25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729335", + "title": "Modular Construction and Optimization of the UZP Sparse Format for SpMV on CPUs", + "abstract": "Sparse data structures are ubiquitous in modern computing, and numerous formats have been designed to represent them. These formats may exploit specific sparsity patterns, aiming to achieve higher performance for key numerical computations than more general-purpose formats such as CSR and COO. In this work we present UZP, a new sparse format based on polyhedral sets of integer points. UZP is a flexible format that subsumes CSR, COO, DIA, BCSR, etc., by raising them to a common mathematical abstraction: a union of integer polyhedra, each intersected with an affine lattice. We present a modular approach to building and optimizing UZP: it captures equivalence classes for the sparse structure, enabling the tuning of the representation for target-specific and application-specific performance considerations. UZP is built from any input sparse structure using integer coordinates, and is interoperable with existing software using CSR and COO data layout. We provide detailed performance evaluation of UZP on 200+ matrices from SuiteSparse, demonstrating how simple and mostly unoptimized generic executors for UZP can already achieve solid performance by exploiting Z-polyhedra structures.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729335", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Alonso", + "last_name": "Rodríguez-Iglesias", + "institution": "Universidade da Coruña" + }, + { + "first_name": "Santoshkumar T.", + "last_name": "Tongli", + "institution": "Colorado State University" + }, + { + "first_name": "Emily", + "last_name": "Tucker", + "institution": "Colorado State University" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Colorado State University" + }, + { + "first_name": "Gabriel", + "last_name": "Rodríguez", + "institution": "Universidade da Coruña" + }, + { + "first_name": "Juan", + "last_name": "Touriño", + "institution": "Universidade da Coruña" + } + ], + "dblp_key": "journals/pacmpl/RodriguezIglesiasTTPRT25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729253", + "title": "Optimizing Ancilla-Based Quantum Circuits with SPARE", + "abstract": "Many quantum algorithms instantiate and use ancillas, spare qubits that serve as temporary storage in a quantum circuit. In particular, many recently developed high-level and modular quantum programming languages (QPLs) use ancilla qubits to implement various programming constructs. These are lowered to circuits with nested/cascading compute-uncompute gate sequences that use ancilla qubits to track internal state. We present SPARE, a rewrite-based quantum circuit optimizer that restructures these compute-uncompute gate sequences, leveraging the ancilla qubit state information to optimize the circuit. In this work, we prove the correctness of SPARE’s rewrites and link SPARE’s gate-level transforms to language-level program rewrites, which may be performed on the input language. We evaluate SPARE on QPL-generated quantum circuits against Unqomp and Spire, two optimizing compilers for QPLs. SPARE achieves a reduction of up to 27.3% in qubit count, 56.7% in 2-qubit gates, 68.2% in 1-qubit gates and 73.9% in depth against Unqomp, and up to 17.8% in qubits, 67.3% in 2-qubit gates, 61.4% in 1-qubit gates and 59.9% in depth against Spire. We also evaluate SPARE against the Quartz, Feynman, and PyZX circuit optimizers: SPARE achieves up to a 70.0% reduction in two-qubit gates, up to a 53.6% reduction in 1-qubit gates, and up to a 56.7% reduction in depth compared to the best result from all the gate-level optimizers.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729253", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ritvik", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Sara", + "last_name": "Achour", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/SharmaA25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729284", + "title": "Destabilizing Iris", + "abstract": "The separation logic framework Iris has been built on the premise that all assertions are stable , meaning they unconditionally enjoy the famous frame rule . This gives Iris—and the numerous program logics that build on it—very modular reasoning principles. But stability also comes at a cost. It excludes a core feature of the Viper verifier family, heap-dependent expression assertions , which lift program expressions to the assertion level in order to reduce redundancy between code and specifications and better facilitate SMT-based automation. In this paper, we bring heap-dependent expression assertions to Iris with Daenerys . To do so, we must first revisit the very core of Iris, extending it with a new form of unstable resources (and adapting the frame rule accordingly). On top, we then build a program logic with heap-dependent expression assertions and lay the foundations for connecting Iris to SMT solvers. We apply Daenerys to several case studies, including some that go beyond what Viper and Iris can do individually and others that benefit from the connection to SMT.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729284", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Simon", + "last_name": "Spies", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Niklas", + "last_name": "Mück", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Haoyi", + "last_name": "Zeng", + "institution": "Saarland University" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Andrea", + "last_name": "Lattuada", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/SpiesMZSLMD25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729281", + "title": "Intrinsic Verification of Parsers and Formal Grammar Theory in Dependent Lambek Calculus", + "abstract": "We present Dependent Lambek Calculus (Lambek D ), a domain-specific dependent type theory for verified parsing and formal grammar theory. In Lambek D , linear types are used as a syntax for formal grammars, and parsers can be written as linear terms. The linear typing restriction provides a form of intrinsic verification that a parser yields only valid parse trees for the input string. We demonstrate the expressivity of this system by showing that the combination of inductive linear types and dependency on non-linear data can be used to encode commonly used grammar formalisms such as regular and context-free grammars as well as traces of various types of automata. Using these encodings, we define parsers for regular expressions using deterministic automata, as well as examples of verified parsers of context-free grammars. We present a denotational semantics of our type theory that interprets the linear types as functions from strings to sets of abstract parse trees and terms as parse transformers. Based on this denotational semantics, we have made a prototype implementation of Lambek D using a shallow embedding in the Agda proof assistant. All of our examples parsers have been implemented in this prototype implementation.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729281", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Steven D.", + "last_name": "Schaefer", + "institution": "University of Michigan" + }, + { + "first_name": "Nathan", + "last_name": "Varner", + "institution": "University of Michigan" + }, + { + "first_name": "Pedro H. Azevedo de", + "last_name": "Amorim", + "institution": "University of Oxford" + }, + { + "first_name": "Max S.", + "last_name": "New", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/SchaeferVAN25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729326", + "title": "Slotted E-Graphs: First-Class Support for (Bound) Variables in E-Graphs", + "abstract": "Equality saturation has gained significant interest as a powerful optimization and reasoning technique. At its heart is the e-graph data structure, that space-efficiently represents equal sub-terms uniquely. An important open problem in this context is extending this efficient representation to languages featuring (bound) variables. Independent of how we represent variables in e-graphs, either as names or nameless (using de Bruijn indices), sharing is broken as sub-terms that differ only in the names of their variables are represented separately. This results in aggressive e-graph growth, bad performance, as well as reduced expressiveness. In this paper, we present a novel approach to representing bound variables in e-graphs by making them a first-class built-in feature of the data structure. Our slotted e-graph represents terms that differ only by (bound or free) variable names uniquely. To do so, e-classes that represent equivalent terms via e-nodes are parameterized by slots , abstracting over free variables of the represented terms. Referring to an e-class from an e-node now requires relating the variables from its context to the slots of the e-class. Our evaluation of slotted e-graph uses two case studies from compiler optimization and theorem proving to show that performing equality saturation for languages with bound variables is greatly simplified and that we can solve practically relevant problems that cannot be solved with e-graphs using de Bruijn indices.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729326", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "R.", + "last_name": "Schneider", + "institution": "Technische Universität Berlin" + }, + { + "first_name": "Marcus", + "last_name": "Rossel", + "institution": "Barkhausen Institut" + }, + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Edinburgh" + }, + { + "first_name": "Andrés", + "last_name": "Goens", + "institution": "Amsterdam University of the Arts" + }, + { + "first_name": "Thomas", + "last_name": "Kœhler", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "Technische Universität Berlin" + } + ], + "dblp_key": "journals/pacmpl/SchneiderRSGKS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729290", + "title": "QVM: Quantum Gate Virtualization Machine", + "abstract": "We present the Quantum Gate Virtualization Machine (QVM), an end-to-end generic system for scalable execution of large quantum circuits with high fidelity on noisy and small quantum processors (QPUs) by leveraging gate virtualization. QVM exposes a virtual circuit intermediate representation (IR) that extends the notion of quantum circuits to incorporate gate virtualization. Based on the virtual circuit as our IR, we propose the QVM compiler—an extensible compiler infrastructure to transpile a virtual circuit through a series of modular optimization passes to produce a set of optimized circuit fragments. Lastly, these transpiled circuit fragments are executed on QPUs using our QVM runtime—a scalable and parallel infrastructure to virtualize and execute circuit fragments on a set of QPUs. We evaluate QVM on IBM’s 7- and 27-qubit QPUs. Our evaluation shows that our approach allows for the execution of circuits with up to double the number of qubits compared to the qubit-count of a QPU, while improving fidelity by 4.7× on average compared to larger QPUs and that we can effectively reduce circuit depths to only 40% of the original circuit depths.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729290", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Nathaniel", + "last_name": "Tornow", + "institution": "" + }, + { + "first_name": "Emmanouil", + "last_name": "Giortamis", + "institution": "" + }, + { + "first_name": "Pramod", + "last_name": "Bhatotia", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/TornowGB25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729297", + "title": "Taking Out the Toxic Trash: Recovering Precision in Mixed Flow-Sensitive Static Analyses", + "abstract": "Static analysis of real-world programs combines flow- and context-sensitive analyses of local program states with computation of flow- and context-insensitive invariants at globals, that, e.g., abstract data shared by multiple threads. The values of locals and globals may mutually depend on each other, with the analysis of local program states both making contributions to globals and querying their values. Usually, all contributions to globals are accumulated during fixpoint iteration, with widening applied to enforce termination. Such flow-insensitive information often becomes unnecessarily imprecise and can include superfluous contributions — trash — which, in turn, may be toxic to the precision of the overall analysis. To recover precision of globals, we propose techniques complementing each other: Narrowing on globals differentiates contributions by origin; reluctant widening limits the amount of widening applied at globals; and finally, abstract garbage collection undoes contributions to globals and propagates their withdrawal. The experimental evaluation shows that these techniques increase the precision of mixed flow-sensitive analyses at a reasonable cost.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729297", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Stemmler", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Schwarz", + "institution": "" + }, + { + "first_name": "Julian", + "last_name": "Erhard", + "institution": "LMU Klinikum" + }, + { + "first_name": "Sarah", + "last_name": "Tilscher", + "institution": "LMU Klinikum" + }, + { + "first_name": "Helmut", + "last_name": "Seidl", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/StemmlerSETS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729313", + "title": "Dynamic Region Ownership for Concurrency Safety", + "abstract": "The ways in which the components of a program interact with each other in a concurrent setting can be considerably more complex than in a sequential setting. The core problem is unrestricted shared mutable state. An alternative to unrestricted shared mutable state is to restrict the sharing using Ownership. Ownership can turn what would have been a race into a deterministic failure that can be explained to the programmer. However, Ownership has predominantly taken place in statically typed languages. In this paper, we explore retrofitting an existing dynamically typed programming language with an ownership model based on regions. Our core aim is to provide safe concurrency, that is, the ownership model should provide deterministic dynamic failures of ownership that can be explained to the programmer. We present a dynamic model of ownership that provides ownership of groups objects called regions. We provide dynamic enforcement of our region discipline, which we have implemented in a simple interpreter that provides a Python-like syntax and semantics, and report on our first steps into integrating it into an existing language, Python.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729313", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Fridtjof Peer", + "last_name": "Stoldt", + "institution": "Uppsala University" + }, + { + "first_name": "Brandt", + "last_name": "Bucher", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sylvan", + "last_name": "Clebsch", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Matthew", + "last_name": "Johnson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Guido van", + "last_name": "Rossum", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Eric", + "last_name": "Snow", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "journals/pacmpl/StoldtBCJPRSW25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3735592", + "title": "Tree Borrows", + "abstract": "The Rust programming language is well known for its ownership-based type system, which offers strong guarantees like memory safety and data race freedom. However, Rust also provides unsafe escape hatches, for which safety is not guaranteed automatically and must instead be manually upheld by the programmer. This creates a tension. On the one hand, compilers would like to exploit the strong guarantees of the type system—particularly those pertaining to aliasing of pointers—in order to unlock powerful intraprocedural optimizations. On the other hand, those optimizations are easily invalidated by “badly behaved” unsafe code. To ensure correctness of such optimizations, it thus becomes necessary to clearly define what unsafe code is “badly behaved.” In prior work, Stacked Borrows defined a set of rules achieving this goal. However, Stacked Borrows rules out several patterns that turn out to be common in real-world unsafe Rust code, and it does not account for advanced features of the Rust borrow checker that were introduced more recently. To resolve these issues, we present Tree Borrows . As the name suggests, Tree Borrows is defined by replacing the stack at the heart of Stacked Borrows with a tree. This overcomes the aforementioned limitations: our evaluation on the 30 000 most widely used Rust crates shows that Tree Borrows rejects 54 % fewer test cases than Stacked Borrows does. Additionally, we prove (in Rocq) that it retains most of the Stacked Borrows optimizations and also enables important new ones, notably read-read reorderings.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3735592", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Neven", + "last_name": "Villani", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Johannes", + "last_name": "Hostert", + "institution": "ETH Zurich" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/VillaniHDJ25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729282", + "title": "Reductive Analysis with Compiler-Guided Large Language Models for Input-Centric Code Optimizations", + "abstract": "Input-centric program optimization aims to optimize code by considering the relations between program inputs and program behaviors. Despite its promise, a long-standing barrier for its adoption is the difficulty of automatically identifying critical features of complex inputs. This paper introduces a novel technique, reductive analysis through compiler-guided Large Language Models (LLMs) , to solve the problem through a synergy between compilers and LLMs. It uses a reductive approach to overcome the scalability and other limitations of LLMs in program code analysis. The solution, for the first time, automates the identification of critical input features without heavy instrumentation or profiling, cutting the time needed for input identification by 44× (or 450× for local LLMs), reduced from 9.6 hours to 13 minutes (with remote LLMs) or 77 seconds (with local LLMs) on average, making input characterization possible to be integrated into the workflow of program compilations. Optimizations on those identified input features show similar or even better results than those identified by previous profiling-based methods, leading to optimizations that yield 92.6% accuracy in selecting the appropriate adaptive OpenMP parallelization decisions, and 20–30% performance improvement of serverless computing while reducing resource usage by 50–60%.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729282", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Xiangwei", + "last_name": "Wang", + "institution": "North Carolina State University" + }, + { + "first_name": "Xinning", + "last_name": "Hui", + "institution": "North Carolina State University" + }, + { + "first_name": "Chunhua", + "last_name": "Liao", + "institution": "Lawrence Livermore National Laboratory" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + } + ], + "dblp_key": "journals/pacmpl/WangHLS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729287", + "title": "Program Skeletons for Automated Program Translation", + "abstract": "Translating software between programming languages is a challenging task, for which automated techniques have been elusive and hard to scale up to larger programs. A key difficulty in cross-language translation is that one has to re-express the intended behavior of the source program into idiomatic constructs of a different target language. This task needs abstracting away from the source language-specific details, while keeping the overall functionality the same. In this work, we propose a novel and systematic approach for making such translation amenable to automation based on a framework we call program skeletons. A program skeleton retains the high-level structure of the source program by abstracting away and effectively summarizing lower-level concrete code fragments, which can be mechanically translated to the target programming language. A skeleton, by design, permits many different ways of filling in the concrete implementation for fragments, which can work in conjunction with existing data-driven code synthesizers. Most importantly, skeletons can conceptually enable sound decomposition, i.e., if each individual fragment is correctly translated, taken together with the mechanically translated skeleton, the final translated program is deemed to be correct as a whole. We present a prototype system called SKEL embodying the idea of skeleton-based translation from Python to JavaScript. Our results show promising scalability compared to prior works. For 9 real-world Python programs, some with more than about 1k lines of code, 95% of their code fragments can be automatically translated, while about 5% require manual effort. All the final translations are correct with respect to whole-program test suites.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729287", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Bo", + "last_name": "Wang", + "institution": "National University of Singapore" + }, + { + "first_name": "Tianyu", + "last_name": "Li", + "institution": "National University of Singapore" + }, + { + "first_name": "Ruishi", + "last_name": "Li", + "institution": "National University of Singapore" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + }, + { + "first_name": "Prateek", + "last_name": "Saxena", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/WangLLMS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729305", + "title": "Divergence-Aware Testing of Graphics Shader Compiler Back-Ends", + "abstract": "Graphics shaders are the core of modern 3D visual effects, enabling developers to create realistic, real-time rendering of 3D scenes. Shaders are specialized programs written in high-level shading languages like GLSL, and graphics shader compilers translate these high-level shader programs into low-level binaries that run on GPUs. These shader compilers are complex programs with multiple layers: front-end, middle-end, and back-end. Despite significant development efforts from industrial GPU vendors such as NVIDIA and AMD, graphics shader compilers still contain bugs that can impact downstream applications and lead to negative consequences from poor user experience in entertainment to accidents in driving assistance systems. Because they are complex and deep in the compilation pipeline, the back-ends of shader compilers are particularly challenging to test. Our empirical exploration shows that state-of-the-art testing tools for shader compilers do not specifically target the back-ends and are thus ineffective in uncovering back-end bugs. This work fills this gap and introduces ShaDiv, an automated testing tool specifically designed to uncover bugs in the back-ends of graphics shader compilers. To this end, ShaDiv generates test inputs with two novel, carefully designed strategies to support the unique computational models of the back-ends, namely control and data flow divergence among GPU threads. Indeed, ShaDiv deliberately perturbs divergence patterns in both the control and data flow of shader programs to effectively trigger back-end optimizations. Our evaluation of ShaDiv on graphics shader compilers from four mainstream GPU vendors uncovered 12 back-end bugs. Further comparison with existing shader compiler testing tools shows that ShaDiv achieves a 25% coverage increase in the back-end components and finds four times as many back-end bugs.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729305", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Dongwei", + "last_name": "Xiao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Shuai", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Zhibo", + "last_name": "Liu", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Yiteng", + "last_name": "Peng", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Daoyuan", + "last_name": "Wu", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/XiaoWLPWS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729262", + "title": "Task-Based Tensor Computations on Modern GPUs", + "abstract": "Domain-specific, fixed-function units are becoming increasingly common in modern processors. As the computational demands of applications evolve, the capabilities and programming interfaces of these fixed-function units continue to change. NVIDIA’s Hopper GPU architecture contains multiple fixed-function units per compute unit, including an asynchronous data movement unit (TMA) and an asynchronous matrix multiplication unit (Tensor Core). Efficiently utilizing these units requires a fundamentally different programming style than previous architectures; programmers must now develop warp-specialized kernels that orchestrate producer-consumer pipelines between the asynchronous units. To manage the complexity of programming these new architectures, we introduce Cypress, a task-based programming model with sequential semantics. Cypress programs are a set of designated functions called tasks that operate on tensors and are free of communication and synchronization. Cypress programs are bound to the target machine through a mapping specification that describes where tasks should run and in which memories tensors should be materialized. We present a compiler architecture that lowers Cypress programs into CUDA programs that perform competitively with expert-written codes. Cypress achieves 0.88x-1.06x the performance of cuBLAS on GEMM, and between 0.80x-0.98x the performance of the currently best-known Flash Attention implementation while eliminating all aspects of explicit data movement and asynchronous computation from application code.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729262", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Rohan", + "last_name": "Yadav", + "institution": "Stanford University" + }, + { + "first_name": "Michael", + "last_name": "Garland", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Alexander M.", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Michael", + "last_name": "Bauer", + "institution": "Nvidia (United States)" + } + ], + "dblp_key": "journals/pacmpl/YadavGAB25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729254", + "title": "Relaxing Alias Analysis: Exploring the Unexplored Space", + "abstract": "Alias analysis is a fundamental compiler analysis that powers numerous optimizations. While research has focused on deriving more precise alias information assuming that the compiler will optimize better, recent work shows a negligible, or even negative, performance impact of alias information. In this work, we shift the perspective from refining to relaxing alias information, i.e. , removing information, to complement existing work and challenge that assumption systematically. Our study on a state-of-the-art compiler, LLVM, running the SPEC CPU 2017 benchmark suite, shows (1) a small overall impact —removing alias analysis entirely has little impact on the final binaries, (2) few influential queries —only a small fraction, namely ∼3%, of the alias information leads to changes in the final binary, and (3) lost potential —random relaxations can reduce execution time by 21% and binary size by 39% for certain cases, suggesting that compilers could better utilize alias information. Through this work, we advocate that it is beneficial for future research to avoid simply refining the general precision of alias analysis, but also to explore how to find and refine the most relevant queries, and how to more effectively utilize alias information.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729254", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Michel", + "last_name": "Weber", + "institution": "ETH Zurich" + }, + { + "first_name": "Theodoros", + "last_name": "Theodoridis", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/WeberTS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729315", + "title": "Scalable, Validated Code Translation of Entire Projects using Large Language Models", + "abstract": "Large language models (LLMs) show promise in code translation due to their ability to generate idiomatic code. However, a significant limitation when using LLMs for code translation is scalability: existing works have shown a drop in translation success rates for code exceeding around 100 lines. We overcome this limitation by developing a modular approach to translation, where we partition the code into small code fragments which can be translated independently and semantically validated (that is, by checking I/O equivalence). When this approach is applied naively, we discover that LLMs are unreliable when translating features of the source language that do not have a direct mapping to the target language, and that the LLM often gets stuck in repair loops when attempting to fix errors. To address these issues, we introduce two key concepts: (1) feature mapping , which integrates predefined translation rules with LLM-based translation to guide the LLM in navigating subtle language differences and producing semantically accurate code; and (2) type-compatibility , which facilitates localized checks at the function signature level to detect errors early, thereby narrowing the scope of potential repairs. We apply our approach to translating real-world Go codebases to Rust, demonstrating that we can consistently generate reliable Rust translations for projects up to 9,700 lines of code and 780 functions, with an average of 73% of functions successfully validated for I/O equivalence, considerably higher than any existing work.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729315", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Hanliang", + "last_name": "Zhang", + "institution": "University of Bristol" + }, + { + "first_name": "Cristina", + "last_name": "David", + "institution": "University of Bristol" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + }, + { + "first_name": "Brandon", + "last_name": "Paulsen", + "institution": "Amazon (United States)" + }, + { + "first_name": "Daniel", + "last_name": "Kroening", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/ZhangDWPK25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729276", + "title": "CompCertOC: Verified Compositional Compilation of Multi-threaded Programs with Shared Stacks", + "abstract": "It is a long-standing open problem to support verified compilation of multi-threaded programs compositionally when sharing of stack data between threads is allowed. Although certain solutions exist on paper, none of them is completely formalized because of the difficulty in simultaneously enabling sharing and forbidding modification of stack memory in presence of arbitrary memory operations (e.g., pointer arithmetic). We present a compiler verification framework that solves this open problem in the setting of cooperative multi-threading . To address the challenges of sharing stack data, we introduce threaded Kripke memory relations (TKMR) to support both protection and sharing of stacks in a multi-stack memory model. We further introduce threaded forward simulations parameterized by TKMR to capture semantics preservation for compiling program modules in multi-threaded contexts. We show that threaded forward simulations are both horizontally composable —thereby enabling the compositional verification of open threads and heterogeneous modules—and vertically composable —thereby enabling composition of compiler correctness for multiple compiler passes. Furthermore, threaded forward simulations can be converted into backward simulations. We apply this framework to 18 passes of CompCert to get CompCertOC, the first optimizing verified compiler that supports compositional verification of cooperative multi-threaded programs with shared stacks.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729276", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Ling", + "last_name": "Zhang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Yuting", + "last_name": "Wang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Yalun", + "last_name": "Liang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/ZhangWLS25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729303", + "title": "Polygon: Symbolic Reasoning for SQL using Conflict-Driven Under-Approximation Search", + "abstract": "We present a novel symbolic reasoning engine for SQL which can efficiently generate an input I for n queries P 1 , ⋯, P n , such that their outputs on I satisfy a given property (expressed in SMT). This is useful in different contexts, such as disproving equivalence of two SQL queries and disambiguating a set of queries. Our first idea is to reason about an under-approximation of each P i — that is, a subset of P i ’s input-output behaviors. While it makes our approach both semantics-aware and lightweight, this idea alone is incomplete (as a fixed under-approximation might miss some behaviors of interest). Therefore, our second idea is to perform search over an expressive family of under-approximations (which collectively cover all program behaviors of interest), thereby making our approach complete. We have implemented these ideas in a tool, Polygon, and evaluated it on over 30,000 benchmarks across two tasks (namely, SQL equivalence refutation and query disambiguation). Our evaluation results show that Polygon significantly outperforms all prior techniques.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729303", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "P.", + "last_name": "Zhao", + "institution": "University of Michigan" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "Simon Fraser University" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/ZhaoWW25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729252", + "title": "Efficient Timestamping for Sampling-Based Race Detection", + "abstract": "Dynamic race detection based on the happens before (HB) partial order has now become the de facto approach to quickly identify data races in multi-threaded software. Most practical implementations for detecting these races use timestamps to infer causality between events and detect races based on these timestamps. Such an algorithm updates timestamps (stored in vector clocks) at every event in the execution, and is known to induce excessive overhead. Random sampling has emerged as a promising algorithmic paradigm to offset this overhead. It offers the promise of making sound race detection scalable. In this work we consider the task of designing an efficient sampling based race detector with low overhead for timestamping when the number of sampled events is much smaller than the total events in an execution. To solve this problem, we propose (1) a new notion of freshness timestamp, (2) a new data structure to store timestamps, and (3) an algorithm that uses a combination of them to reduce the cost of timestamping in sampling based race detection. Further, we prove that our algorithm is close to optimal --- the number of vector clock traversals is bounded by the number of sampled events and number of threads, and further, on any given dynamic execution, the cost of timestamping due to our algorithm is close to the amount of work any timestamping-based algorithm must perform on that execution, that is it is instance optimal. Our evaluation on real world benchmarks demonstrates the effectiveness of our proposed algorithm over prior timestamping algorithms that are agnostic to sampling.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729252", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Minjian", + "last_name": "Zhang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Daniel Wee Soong", + "last_name": "Lim", + "institution": "National University of Singapore" + }, + { + "first_name": "Mosaad Al", + "last_name": "Thokair", + "institution": "Saudi Aramco (Saudi Arabia)" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/ZhangLTMV25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729283", + "title": "Quantum Register Machine: Efficient Implementation of Quantum Recursive Programs", + "abstract": "Quantum recursive programming has been recently introduced for describing sophisticated and complicated quantum algorithms in a compact and elegant way. However, implementation of quantum recursion involves intricate interplay between quantum control flow and recursive procedure calls. In this paper, we aim at resolving this fundamental challenge and develop a series of techniques to efficiently implement quantum recursive programs. Our main contributions include: 1. We propose a notion of quantum register machine, the first quantum architecture (including an instruction set) that provides instruction-level support for quantum control flow and recursive procedure calls at the same time. 2. Based on quantum register machine, we describe the first comprehensive implementation process of quantum recursive programs, including the compilation, the partial evaluation of quantum control flow, and the execution on the quantum register machine. 3. As a bonus, our efficient implementation of quantum recursive programs also offers automatic parallelisation of quantum algorithms. For implementing certain quantum algorithmic subroutine, like the widely used quantum multiplexor, we can even obtain exponential parallel speed-up (over the straightforward implementation) from this automatic parallelisation. This demonstrates that quantum recursive programming can be win-win for both modularity of programs and efficiency of their implementation.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729283", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Zhicheng", + "last_name": "Zhang", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "University of Technology Sydney" + } + ], + "dblp_key": "journals/pacmpl/ZhangY25", + "venue": "pldi", + "year": 2025 + }, + { + "paper_id": "10.1145/3729278", + "title": "Fast Direct Manipulation Programming with Patch-Reconciliation Correspondence", + "abstract": "Direct manipulation programming gives users a way to write programs without directly writing code, by using the familiar GUI-style interactions they know from direct manipulation interfaces. To date, direct manipulation programming systems have relied on two core components: (1) a patch component, which modifies the program based on a GUI interaction, and (2) a forward evaluator , which executes the modified program to produce an updated program output. This architecture has worked for developing short-running programs—i.e., programs that reliably execute in <1 second—generating outputs such as SVG and HTML documents. However, direct manipulation programming has not yet been applied to long-running programs (e.g., data visualization, mapping), perhaps because executing such programs in response to every GUI interaction would mean crossing outside of interactive speeds. We propose extending direct manipulation programming to long-running programs by pairing a standard patch component ( patch ) with a corresponding reconciliation component ( recon ). recon directly updates the program output in response to a GUI interaction, obviating the need for forward evaluation. We introduce corresponding patch and recon procedures for the domain of geospatial data visualization and prove them sound—that is, we show that the output produced by recon is identical to the output produced by forward-evaluating a patch -modified program. recon can operate both incrementally and in parallel with patch . Our implementation of our patch - recon instantiation achieves a 2.92x median reduction in interface latency compared to forward evaluation on a suite of real-world geospatial visualization tasks. Looking forward, our results suggest that patch-reconciliation correspondence offers a promising pathway for extending direct manipulation programming to domains involving large-scale computation.", + "date": "2025-06-10", + "link": "https://doi.org/10.1145/3729278", + "conference_name": "PLDI", + "authors": [ + { + "first_name": "Parker", + "last_name": "Ziegler", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Justin", + "last_name": "Lubin", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/ZieglerLC25", + "venue": "pldi", + "year": 2025 + } +] \ No newline at end of file From d70687e17655f458acc358d226b12885fc69f87c Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:26:57 +0200 Subject: [PATCH 09/34] feat: ingest ICFP back-catalogue (1996-2025) 30 years of ICFP proceedings harvested via DBLP, OpenAlex, and Semantic Scholar fallback. ICFP started in 1996; DBLP has no entry for 2026 yet. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/icfp/1996.json | 572 +++++++++++++ data/pl_conferences/icfp/1997.json | 904 ++++++++++++++++++++ data/pl_conferences/icfp/1998.json | 944 +++++++++++++++++++++ data/pl_conferences/icfp/1999.json | 597 +++++++++++++ data/pl_conferences/icfp/2000.json | 628 ++++++++++++++ data/pl_conferences/icfp/2001.json | 534 ++++++++++++ data/pl_conferences/icfp/2002.json | 593 +++++++++++++ data/pl_conferences/icfp/2003.json | 648 ++++++++++++++ data/pl_conferences/icfp/2004.json | 508 +++++++++++ data/pl_conferences/icfp/2005.json | 731 ++++++++++++++++ data/pl_conferences/icfp/2006.json | 638 ++++++++++++++ data/pl_conferences/icfp/2007.json | 819 ++++++++++++++++++ data/pl_conferences/icfp/2008.json | 843 ++++++++++++++++++ data/pl_conferences/icfp/2009.json | 962 +++++++++++++++++++++ data/pl_conferences/icfp/2010.json | 930 ++++++++++++++++++++ data/pl_conferences/icfp/2011.json | 999 ++++++++++++++++++++++ data/pl_conferences/icfp/2012.json | 907 ++++++++++++++++++++ data/pl_conferences/icfp/2013.json | 1068 +++++++++++++++++++++++ data/pl_conferences/icfp/2014.json | 840 ++++++++++++++++++ data/pl_conferences/icfp/2015.json | 988 ++++++++++++++++++++++ data/pl_conferences/icfp/2016.json | 1137 +++++++++++++++++++++++++ data/pl_conferences/icfp/2017.json | 1269 ++++++++++++++++++++++++++++ data/pl_conferences/icfp/2018.json | 1182 ++++++++++++++++++++++++++ data/pl_conferences/icfp/2019.json | 1184 ++++++++++++++++++++++++++ data/pl_conferences/icfp/2020.json | 1093 ++++++++++++++++++++++++ data/pl_conferences/icfp/2021.json | 1032 ++++++++++++++++++++++ data/pl_conferences/icfp/2022.json | 997 ++++++++++++++++++++++ data/pl_conferences/icfp/2023.json | 996 ++++++++++++++++++++++ data/pl_conferences/icfp/2024.json | 1057 +++++++++++++++++++++++ data/pl_conferences/icfp/2025.json | 1105 ++++++++++++++++++++++++ 30 files changed, 26705 insertions(+) create mode 100644 data/pl_conferences/icfp/1996.json create mode 100644 data/pl_conferences/icfp/1997.json create mode 100644 data/pl_conferences/icfp/1998.json create mode 100644 data/pl_conferences/icfp/1999.json create mode 100644 data/pl_conferences/icfp/2000.json create mode 100644 data/pl_conferences/icfp/2001.json create mode 100644 data/pl_conferences/icfp/2002.json create mode 100644 data/pl_conferences/icfp/2003.json create mode 100644 data/pl_conferences/icfp/2004.json create mode 100644 data/pl_conferences/icfp/2005.json create mode 100644 data/pl_conferences/icfp/2006.json create mode 100644 data/pl_conferences/icfp/2007.json create mode 100644 data/pl_conferences/icfp/2008.json create mode 100644 data/pl_conferences/icfp/2009.json create mode 100644 data/pl_conferences/icfp/2010.json create mode 100644 data/pl_conferences/icfp/2011.json create mode 100644 data/pl_conferences/icfp/2012.json create mode 100644 data/pl_conferences/icfp/2013.json create mode 100644 data/pl_conferences/icfp/2014.json create mode 100644 data/pl_conferences/icfp/2015.json create mode 100644 data/pl_conferences/icfp/2016.json create mode 100644 data/pl_conferences/icfp/2017.json create mode 100644 data/pl_conferences/icfp/2018.json create mode 100644 data/pl_conferences/icfp/2019.json create mode 100644 data/pl_conferences/icfp/2020.json create mode 100644 data/pl_conferences/icfp/2021.json create mode 100644 data/pl_conferences/icfp/2022.json create mode 100644 data/pl_conferences/icfp/2023.json create mode 100644 data/pl_conferences/icfp/2024.json create mode 100644 data/pl_conferences/icfp/2025.json diff --git a/data/pl_conferences/icfp/1996.json b/data/pl_conferences/icfp/1996.json new file mode 100644 index 0000000..f32346d --- /dev/null +++ b/data/pl_conferences/icfp/1996.json @@ -0,0 +1,572 @@ +[ + { + "paper_id": "10.1145/232627.232633", + "title": "Lag, Drag, Void and Use - Heap Profiling and Space-Efficient Compilation Revisited", + "abstract": "The context for this paper is functional computation by graph reduction. Our overall aim is more efficient use of memory. The specific topic is the detection of dormant cells in the live graph --- those retained in heap memory though not actually playing a useful role in computation. We describe a profiler that can identify heap consumption by such 'useless' cells. Unlike heap profilers based on traversals of the live heap, this profiler works by examining cells postmortem. The new profiler has revealed a surprisingly large proportion of 'useless' cells, even in some programs that previously seemed space-efficient such as the boot-strapping Haskell compiler nhc.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232633", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Niklas", + "last_name": "Röjemo", + "institution": "University of York" + }, + { + "first_name": "Colin", + "last_name": "Runciman", + "institution": "University of York" + } + ], + "dblp_key": "conf/icfp/RojemoR96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232654", + "title": "Mixin Modules", + "abstract": "Mixin modules are proposed as a new construct for module languages, allowing recursive definitions to span module boundaries. Mixin modules are proposed specifically for the Standard ML language. Several applications are described, including the resolution of cycles in module import dependency graphs, as well as functionality related to Haskell type classes and CLOS generic functions, though without any complications to the core language semantics. Mixin modules require no changes to the core ML type system, and only a very minor change to its run-time semantics. A type system and reduction semantics are provided, and the former is verified to be sound relative to the latter.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232654", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dominic", + "last_name": "Duggan", + "institution": "University of Waterloo" + }, + { + "first_name": "Constantinos", + "last_name": "Sourelis", + "institution": "" + } + ], + "dblp_key": "conf/icfp/DugganS96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232644", + "title": "The Semantics of Scheme with Future", + "abstract": "We present the formal semantics of future in a Scheme-like language which has both side-effects and first-class continuations. Correctness is established by proving that programs annotated by future have the same observable behaviour as their non-annotated counterparts, even though evaluation may be parallel.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232644", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Luc", + "last_name": "Moreau", + "institution": "University of Southampton" + } + ], + "dblp_key": "conf/icfp/Moreau96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232635", + "title": "Storage Use Analysis and its Applications", + "abstract": "In this paper we present a new program analysis method which we call Storage Use Analysis. This analysis deduces how objects are used by the program and allows the optimization of their allocation. This analysis can be applied to both statically typed languages (e.g. ML) and latently typed languages (e.g. Scheme). It handles side-effects, higher order functions, separate compilation and does not require CPS transformation. We show the application of our analysis to two important optimizations: stack allocation and unboxing. The first optimization replaces some heap allocations by stack allocations for user and system data storage (e.g. lists, vectors, procedures). The second optimization avoids boxing some objects. This analysis and associated optimitations have been implemented in the Bigloo Scheme/ML compiler. Experimental results show that for many allocation intensive programs we get a significant speedup. In particular, numerically intensive programs are almost 20 times faster because floating point numbers are unboxed and no longer heap allocated.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232635", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Marc", + "last_name": "Feeley", + "institution": "Université de Montréal" + } + ], + "dblp_key": "conf/icfp/SerranoF96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232630", + "title": "Let-floating: Moving Bindings to Give Faster Programs", + "abstract": "Virtually every compiler performs transformations on the program it is compiling in an attempt to improve efficiency. Despite their importance, however, there have been few systematic attempts to categorise such transformations and measure their impact.In this paper we describe a particular group of transformations --- the \"let-floating\" transformations --- and give detailed measurements of their effect in an optimizing compiler for the non-strict functional language Haskell. Let-floating has not received much explicit attention in the past, but our measurements show that it is an important group of transformations (at least for lazy languages), offering a reduction of more than 30% in heap allocation and 15% in execution time.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232630", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "University of Glasgow" + }, + { + "first_name": "Will", + "last_name": "Partain", + "institution": "University of Glasgow" + }, + { + "first_name": "André L. M.", + "last_name": "Santos", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/icfp/JonesPS96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232638", + "title": "Analysis and Caching of Dependencies", + "abstract": "We address the problem of dependency analysis and caching in the context of the λ-calculus. The dependencies of a λ-term are (roughly) the parts of the λ-term that contribute to the result of evaluating it. We introduce a mechanism for keeping track of dependencies, and discuss how to use these dependencies in caching.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232638", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "" + }, + { + "first_name": "Butler", + "last_name": "Lampson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Jean-Jacques", + "last_name": "Lévy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/AbadiLL96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232632", + "title": "Functional Back-Ends within the Lambda-Sigma Calculus", + "abstract": "We dene a weak -calculus, w , as a subsystem of the full -calculus with explicit substitutions * . We claim that w could be the archetypal output language of functional compilers, just as the -calculus is their universal input language. Furthermore, * could be the adequate theory to establish the correctness of simplied functional compilers. Here, we illustrate these claims by proving the correctness of two simplied compilers and runtime systems modeled as abstract machines. We rst present the Krivine machine. Then, we give the rst formal proofs of Cardelli&apos;s FAM and of its compiler. 1 Introduction It is folklore to dene a compiler as a translator from a highlevel language intended for humans to a low-level language intended for machines. For mostly theoretical issues such as semantics or correctness of high-level program transformations, real programming languages are too complicated and lack generality. Instead, it is convenient to use an archetypal language, sta...", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232632", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thérèse", + "last_name": "Hardin", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Bruno", + "last_name": "Pagano", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/HardinMP96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232642", + "title": "Simplifying Subtyping Constraints", + "abstract": "This paper studies type inference for a functional, ML-style language with subtyping, and focuses on the issue of simplifying inferred constraint sets. We propose a powerful notion of entailment between constraint sets, as well as an algorithm to check it, which we prove to be sound. The algorithm, although very powerful in practice, is not complete. We also introduce two new typing rules which allow simplifying constraint sets. These rules give very good practical results.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232642", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Pottier96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232637", + "title": "Deriving Structural Hylomorphisms From Recursive Definitions", + "abstract": "... this paper, we propose an algorithm which can automatically turn all practical recursive definitions into structural hylomorphisms making program fusion be easily applied.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232637", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Tokyo University of Information Sciences" + }, + { + "first_name": "Hideya", + "last_name": "Iwasaki", + "institution": "The University of Tokyo" + }, + { + "first_name": "Masato", + "last_name": "Takeichi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/icfp/HuIT96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232648", + "title": "A Probabilistic Approach to the Problem of Automatic Selection of Data Representations", + "abstract": "The designs and implementations of efficient aggregate data structures have been important issues in functional programming. It is not clear how to select a good representation for an aggregate when access patterns to the aggregate are highly variant, or even unpredictable. Previous approaches rely on compile--time analyses or programmer annotations. These methods can be unreliable because they try to predict a program's behavior before it is executed.We propose a probabilistic approach, which is based on Markov processes, for automatic selection of data representations. The selection is modeled as a random process moving in a graph with weighted edges. The proposed approach employs coin tossing at run--time to help choosing a suitable data representation. The transition probability function used by the coin tossing is constructed in a simple and common way from a measured cost function. We show that, under this setting, random selections of data representations can be quite effective. The probabilistic approach is used to implement bag aggregates, and the performance results are compared to those of deterministic selection strategies.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232648", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tyng–Ruey", + "last_name": "Chuang", + "institution": "Institute of Information Science, Academia Sinica" + }, + { + "first_name": "Wen-Liang", + "last_name": "Hwang", + "institution": "Institute of Information Science, Academia Sinica" + } + ], + "dblp_key": "conf/icfp/ChuangH96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232650", + "title": "A Provable Time and Space Efficient Implementation of NESL", + "abstract": "In this paper we prove time and space bounds for the implementation of the programming language NESL on various parallel machine models. NESL is a sugared typed λ-calculus with a set of array primitives and an explicit parallel map over arrays. Our results extend previous work on provable implementation bounds for functional languages by considering space and by including arrays. For modeling the cost of NESL we augment a standard call-by-value operational semantics to return two cost measures: a DAG representing the sequential dependence in the computation, and a measure of the space taken by a sequential implementation. We show that a NESL program with w work (nodes in the DAG), d depth (levels in the DAG), and s sequential space can be implemented on a p processor butterfly network, hypercube, or CRCW PRAM using O(w/p + d log p) time and O(s + dp log p) reachable space.1 For programs with sufficient parallelism these bounds are optimal in that they give linear speedup and use space within a constant factor of the sequential space.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232650", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "John", + "last_name": "Greiner", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/BlellochG96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232652", + "title": "Enriching the Lambda Calculus with Contexts: Toward a Theory of Incremental Program Construction", + "abstract": "A context in the λ-calculus is a term with some holes. Hole filling differs from β-substitution in that name capture is intended. This seemingly simple feature transcends static scope and lies at the heart of modular and object-oriented programming. Still, the name capture feature of hole filling is at odds with hygienic β-substitution. In this paper we conservatively extend the λ-calculus to incorporate the notion of contexts without jeopardizing the β-rule. We perceive contexts as source code and λ-terms as target code. Context filling is encoded as compilation operations and the enriched calculus is a theory of separate compilation and incremental program construction. Linking of separately-developed programs is done by coherent renaming of free variables.We apply our context-enriching schema to the λ-calculus extended with definitions and devise a calculus of first-class modules. We show that module linking can be modeled solely by the renaming of import and export variables. We add relinkable variable references to model virtual method references essential to object systems.The inclusion of contexts introduces parameters whose linking is based on names (symbols, identifiers, or keywords). We simulate in the context-enriched calculus other extensions of the λ-calculus with name-based programming notions such as Dami's λ-calculus with names, Aït-Kaci and Garrigue's label-selective λ-calculus, Lamping's transparent data parameters, and our quasi-static procedures.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232652", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Shinn-Der", + "last_name": "Lee", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/icfp/LeeF96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232636", + "title": "The Role of Lazy Evaluation in Amortized Data Structures", + "abstract": "Traditional techniques for designing and analyzing amortized data structures in an imperative setting are of limited use in a functional setting because they apply only to single-threaded data structures, yet functional data structures can be non-single-threaded. In earlier work, we showed how lazy evaluation supports functional amortized data structures and described a technique (the banker's method) for analyzing such data structures. In this paper, we present a new analysis technique (the physicist's method) and show how one can sometimes derive a worst-case data structure from an amortized data structure by appropriately scheduling the premature execution of delayed components. We use these techniques to develop new implementations of FIFO queues and binomial queues.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232636", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chris", + "last_name": "Okasaki", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Okasaki96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232653", + "title": "Sharing Code through First-class Environments", + "abstract": "Nowadays the Net is one of the most obvious driving forces. Yet, to consider it as one global store through which values and code may be shared is still immature. This paper suggests first-class environments as a means to achieve that goal in a multi-user Scheme framework. We propose two new special forms with a simple semantics. Our model allows precise control over environments (including extensible environments) and does not require (but does not prevent) reflective operations.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232653", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christian", + "last_name": "Queinnec", + "institution": "Laboratoire d'Informatique de l'École Polytechnique" + }, + { + "first_name": "David De", + "last_name": "Roure", + "institution": "University of Southampton" + } + ], + "dblp_key": "conf/icfp/QueinnecR96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232640", + "title": "Inductive, Coinductive, and Pointed Types", + "abstract": "An extension of the simply-typed lambda calculus is presented which contains both well-structured inductive and coinductive types, and which also identifies a class of types for which general recursion is possible. The motivations for this work are certain natural constructions in category theory, in particular the notion of an algebraically bounded functor, due to Freyd. We propose that this is a particularly elegant core language in which to work with recursive objects, since the potential for general recursion is contained in a single operator which interacts well with the facilities for bounded iteration and coiteration.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232640", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Brian", + "last_name": "Howard", + "institution": "Kansas State University" + } + ], + "dblp_key": "conf/icfp/Howard96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232641", + "title": "A New Look to Pattern Matching in Abstract Data Types", + "abstract": "In this paper we present a construction smoothly integrating pattern matching with abstract data types. We review some previous proposals [19, 23, 20, 6, 1] and their drawbacks, and show how our proposal can solve them. In particular we pay attention to equational reasoning about programs containing this new facility. We also give its formal syntax and semantics, as well as some guidelines in order to compile the construction efficiently.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232641", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pedro Palao", + "last_name": "Gostanza", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Ricardo", + "last_name": "Peña", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Manuel", + "last_name": "Núñez", + "institution": "Universidad Complutense de Madrid" + } + ], + "dblp_key": "conf/icfp/GostanzaPN96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232649", + "title": "A Theory of Weak Bisimulation for Core CML", + "abstract": "Concurrent ML (CML) is an extension of Standard ML of New Jersey with concurrent features similar to those of process algebra. In this papes we build upon John Reppy's reduction semantics for CML by constructing a compositional operational semantics for a fragment of CML, based on higher-order process algebra. We use this to build a semantic theory for CML, based on weak bisimulation equivalence. We give some small examples of proofs about CML expressions, and show that our semantics corresponds to Reppy's up to weak first-order bisimulation.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232649", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "William", + "last_name": "Ferreira", + "institution": "University of Sussex" + }, + { + "first_name": "Matthew", + "last_name": "Hennessy", + "institution": "University of Sussex" + }, + { + "first_name": "Alan", + "last_name": "Jeffrey", + "institution": "University of Sussex" + } + ], + "dblp_key": "conf/icfp/FerreiraHJ96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232643", + "title": "Complexity of Kernel Fun Subtype Checking", + "abstract": "System kernel Fun is an abstract version of the system Fun defined by Cardelli's and Wegner's seminal paper [CW85], and is strictly related to system F≤. Extensions of these two systems are currently the basis of most proposals for strong type systems for object-oriented languages.We study here the problem of subtype checking for system kernel Fun, presenting the following results. We show that the standard kernel Fun subtype checking algorithm has an exponential complexity, and generates an exponential number of different subproblems. We then present a new subtype checking algorithm which has a polynomial complexity. In the process we study how variable names can be managed by a kernel Fun subtype checker which is not based on the De Bruijn encoding, and we show how to perform kernel Fun subtype checking with a \"constraint generating\" technique.The algorithm we give is described by a set of type rules, which we prove to be equivalent to the standard one. This new presentation of kernel Fun type system is characterized by a \"multiplicative\" behaviour, and it may open the way to new presentations for system F≤ as well.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232643", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Giorgio", + "last_name": "Ghelli", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Ghelli96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232651", + "title": "Synchronous Kahn Networks", + "abstract": "Synchronous data-flow is a programming paradigm which has been successfully applied in reactive systems. In this context, it can be characterized as some class of static bounded memory data-flow networks. In particular, these networks are not recursively defined, and obey some kind of \"synchronous\" constraints (clock calculus). Based on Kahn's relationship between data-flow and stream functions, the synchronous constraints can be related to Wadler's listlessness, and can be seen as sufficient conditions ensuring listless evaluation. As a by-product, those networks enjoy efficient compiling techniques. In this paper, we show that it is possible to extend the class of static synchronous data-flow to higher order and dynamical networks, thus giving sense to a larger class of synchronous data-flow networks.This is done by extending both the synchronous operational semantics, the clock calculus and the compiling technique of static data-flow networks, to these more general networks.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232651", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Caspi", + "institution": "Verimag" + }, + { + "first_name": "Marc", + "last_name": "Pouzet", + "institution": "McGill University" + } + ], + "dblp_key": "conf/icfp/CaspiP96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232631", + "title": "A Reflection on Call-by-Value", + "abstract": "A number of compilers exploit the following strategy: translate a term to continuation-passing style (CPS) and optimize the resulting term using a sequence of reductions. Recent work suggests that an alternative strategy is superior: optimize directly in an extended source calculus. We suggest that the appropriate relation between the source and target calculi may be captured by a special case of a Galois connection known as a reflection. Previous work has focused on the weaker notion of an equational correspondence, which is based on equality rather than reduction. We show that Moggi's monad translation and Plotkin's CPS translation can both be regarded as reflections, and thereby strengthen a number of results in the literature.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232631", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "University of Oregon" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/icfp/SabryW96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232639", + "title": "Optimality and Inefficiency: What Isn't a Cost Model of the Lambda Calculus?", + "abstract": "We investigate the computational efficiency of the sharing graphs of Lamping [Lam90], Gonthier, Abadi, and Lévy [GAL92], and Asperti [Asp94], designed to effect so-called optimal evaluation, with the goal of reconciling optimality, efficiency, and the clarification of reasonable cost models for the λ-calculus. Do these graphs suggest reasonable cost models for the λ-calculus? If they are optimal, are they efficient?We present a brief survey of these optimal evaluators, identifying their common characteristics, as well as their shared failures. We give a lower bound on the efficiency of sharing graphs by identifying a class of λ-terms that are normalizable in Θ(n) time, and require Θ(n) \"fan interactions,\" but require Ω(2n) bookkeeping steps. For [GAL92], we analyze this anomaly in terms of the dynamic maintenance of deBruijn indices for intermediate terms. We give another lower bound showing that sharing graphs can do Ω(2n) work (via fan interactions) on graphs that have no β-redexes. Finally, we criticize a proposed cost model for λ-calculus given by Frandsen and Sturtivant [FS91], showing by example that the model does not take account of the size of intermediate forms. Our example is a term requiring Θ(2n) steps while having proposed cost Θ(n). We propose some cost models that both reflect this parameter, and simultaneously reconcile key concepts from optimal reduction.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232639", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Julia L.", + "last_name": "Lawall", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/icfp/LawallM96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232646", + "title": "pHluid: The Design of a Parallel Functional Language Implementation on Workstations", + "abstract": "This paper describes the distributed memory implementation of a shared memory parallel functional language. The language is Id, an implicitly parallel, mostly functional language that is currently evolving into a dialect of Haskell. The target is a distributed memory machine, because we expect these to be the most widely available parallel platforms in the future. The difficult problem is to bridge the gap between the shared memory language model and the distributed memory machine model. The language model assumes that all data is uniformly accessible, whereas the machine has a severe memory hierarchy: a processor's access to remote memory (using explicit communication) is orders of magnitude slower than its access to local memory. Thus, avoiding communication is crucial for good performance. The Id language, and its general dataflow-inspierd compilation to multithreaded code are described elsewhere. In this paper, we focus on our new parallel runtime system and its features for avoiding communication and for tolerating its latency when necessary: multithreading, scheduling and load balancing; the distributed heap model and distributed coherent cacheing, and parallel garbage collection. We have completed the first implementation, and we present some preliminary performance mearsurements.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232646", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "Rice University" + }, + { + "first_name": "Rishiyur S.", + "last_name": "Nikhil", + "institution": "" + } + ], + "dblp_key": "conf/icfp/FlanaganN96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232645", + "title": "First-Class Synchronization Barriers", + "abstract": "Our purpose is to promote a second-class mechanism --- the synchronization barrier --- to a first-class value. We introduce the synchron, a novel synchronization mechanism that enables the coordination of a dynamically varying set of concurrent threads that share access to a first-class synchronization token. We demonstrate how synchrons can be used to modularly manage resources in cases where existing techniques are either inapplicable or non-modular. In particular, synchronized lazy aggregates enable the first space-efficient aggregate data decomposition of a wide range of algorithms. We also introduce explicit-demand graph reduction, a new semantic framework that we have developed to describe concurrency and explain the meaning of a synchron rendezvous.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232645", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Franklyn", + "last_name": "Turbak", + "institution": "Wellesley College" + } + ], + "dblp_key": "conf/icfp/Turbak96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232647", + "title": "Cogen in Six Lines", + "abstract": "We have designed and implemented a program-generator generator (PGG) for an untyped higher-order functional programming language. The program generators perform continuation-based multi-level offline specialization and thus combine the most powerful and general offline partial evaluation techniques. The correctness of the PGG is ensured by deriving it from a multi-level specialize. Our PGG is extremely simple to implement due to the use of multi-level techniques and higher-order abstract syntax.", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232647", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/icfp/Thiemann96", + "venue": "icfp", + "year": 1996 + }, + { + "paper_id": "10.1145/232627.232634", + "title": "Static and Dynamic Partitioning of Pointers as Links and Threads", + "abstract": "Identifying some pointers as invisible threads, for the purposes of storage management, is a generalization from several widely used programming conventions, like threaded trees. The necessary invariant is that nodes that are accessible (without threads) emit threads only to other accessible nodes. Dynamic tagging or static typing of threads ameliorates storage recycling both in functional and imperative languages. We have seen the distinction between threads and links sharpen both hardware- and software-supported storage management in Scheme, and also in C. Certainly, therefore, implementations of languages that already have abstract management and concrete typing, should detect and use this as a new static type. Categories and subject descriptors: D.3.3 [Programming Languages]: Language Constructs and Features---data types and structures, dynamic storage management, abstract data types; E.2 [Data Storage Representations ]: Linked representations; B.3.2 [Memory Structures]: Design S...", + "date": "1996-06-15", + "link": "https://doi.org/10.1145/232627.232634", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David S.", + "last_name": "Wise", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Joshua", + "last_name": "Walgenbach", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/icfp/WiseW96", + "venue": "icfp", + "year": 1996 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/1997.json b/data/pl_conferences/icfp/1997.json new file mode 100644 index 0000000..96d63e9 --- /dev/null +++ b/data/pl_conferences/icfp/1997.json @@ -0,0 +1,904 @@ +[ + { + "paper_id": "10.1145/258948.258961", + "title": "Foundations for the Implementation of Higher-Order Subtyping", + "abstract": "We show how to implement a calculus with higher-order subtyping and subkinding by replacing uses of implicit subsumption with explicit coercions. To ensure this can be done, a polymorphic function is adjusted to take, as an additional argument, a proof that its type constructor argument has the desired kind. Such a proof is extracted from the derivation of a kinding judgement and may in turn require proof coercions, which are extracted from subkinding judgements. This technique is formalized as a type-directed translation from a calculus of higher-order subtyping to a subtyping-free calculus. This translation generalizes an existing result for second-order subtyping calculi (such as F ≤).We also discuss two interpretations of subtyping, one that views it as type inclusion and another that views it is the existence of a well-behaved coercion, and we show, by a type-theoretic construction, that our translation is the minimum consequence of shifting from the inclusion interpretation to the coercion-existence interpretation. This construction shows that the translation is the natural one, and it also provides a framework for extending the translation to richer type systems. Finally, we show how the two interpretations can be reconciled in a common semantics. It is then easy to show the coherence of the translation relative to that semantics.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258961", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/icfp/Crary97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258956", + "title": "Catenable Double-Ended Queues", + "abstract": "Catenable double-ended queues are double-ended queues (deques) that support catenation (i.e., append) efficiently without sacrificing the efficiency of other operations. We present a purely functional implementation of catenable deques for which every operation, including catenation, takes O(1) amortized time. Kaplan and Tarjan have independently developed a much more complicated implemen-tation of catenable deques that achieves similar worst-case bounds. The two designs are superficially similar, but differ in the underlying mechanism used to achieve efficiency in a persistent setting (i.e., when used in a non-single-threaded fashion). Their implementation uses a technique called recursive slowdown, while ours relies on the simpler mechanism of lazy evaluation.Besides lazy evaluation, our implementation also exemplifies the use of two additional language features: polymorphic recursion and views. Neither is indispensable, but both significantly simplify the presentation.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258956", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chris", + "last_name": "Okasaki", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Okasaki97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258962", + "title": "A Practical Subtyping System For Erlang", + "abstract": "We present a type system for the programming language Erlang. The type system supports subtyping and declaration-free recursive types, using subtyping constraints. Our system is similar to one explored by Aiken and Wimmers, though it sacrifices expressive power in favour of simplicity. We cover our techniques for type inference, type simplification, and checking when an inferred type conforms to a user-supplied type signature, and report on early experience with our prototype.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258962", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "University of Glasgow" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/icfp/MarlowW97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258952", + "title": "Strongly Typed Flow-Directed Representation Transformations", + "abstract": "We present a new framework for transforming data representations in a strongly typed intermediate language. Our method allows both value producers (sources) and value consumers (sinks) to support multiple representations, automatically inserting any required code. Specialized representations can be easily chosen for particular source/sink pairs.The framework is based on these techniques:1. Flow annotated types encode the \"flows-from\" (source) and \"flows-to\" (sink) information of a flow graph.2. Intersection and union types support (a) encoding precise flow information, (b) separating flow information so that transformations can be well typed, (c) automatically reorganizing flow paths to enable multiple representations.As an instance of our framework, we provide a function representation transformation that encompasses both closure conversion and inlining. Our framework is adaptable to data other than functions.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258952", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Allyn", + "last_name": "Dimock", + "institution": "Harvard University Press" + }, + { + "first_name": "Robert", + "last_name": "Muller", + "institution": "Boston College" + }, + { + "first_name": "Franklyn", + "last_name": "Turbak", + "institution": "Wellesley College" + }, + { + "first_name": "J. B.", + "last_name": "Wells", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/icfp/DimockMTW97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258951", + "title": "A Modular, Polyvariant, and Type-Based Closure Analysis", + "abstract": "We observe that the principal typing property of a type system is the enabling technology for modularity and separate compilation [10]. We use this technology to formulate a modular and polyvariant closure analysis, based on the rank 2 intersection types annotated with control-flow information. Modularity manifests itself in a syntax-directed, annotated-type inference algorithm that can analyse program fragments containing free variables: a principal typing property is used to formalise it. Polyvariance manifests itself in the separation of different behaviours of the same function at its different uses: this is formalised via the rank 2 intersection types. As the rank 2 intersection type discipline types at least all (core) ML programs, our analysis can be used in the separate compilation of such programs. 1 Introduction Compiler optimisations are crucially dependent on the availability of control-flow information at compile time. For any first-order imperative program, this infor...", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258951", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Banerjee97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258976", + "title": "The Measured Cost of Copying Garbage Collection Mechanisms", + "abstract": "We examine the costs and benefits of a variety of copying garbage collection (GC) mechanisms across multiple architectures and programming languages. Our study covers both low-level object representation and copying issues as well as the mechanisms needed to support more advanced techniques such as generational collection, large object spaces, and type segregated areas.Our experiments are made possible by a novel performance analysis tool, Oscar. Oscar allows us to capture snapshots of programming language heaps that may then be used to replay garbage collections. The replay program is self-contained and written in C, which makes it easy to port to other architectures and to analyze with standard performance analysis tools. Furthermore, it is possible to study additional programming languages simply by instrumenting existing implementations to capture heap snapshots.In general, we found that careful implementation of GC mechanisms can have a significant benefit. For a simple collector, we measured improvements of as much as 95%. We then found that while the addition of advanced features can have a sizeable overhead (up to 15%), the net benefit is quite positive, resulting in additional gains of up to 42%. We also found that results varied depending upon the platform and language. Machine characteristics such as cache arrangements, instruction set (RISC/CISC), and register pool were important. For different languages, average object size seemed to be most important.The results of our experiments demonstrate the usefulness of a tool like Oscar for studying GC performance. Without much overhead, we can easily identify areas where programming language implementors could collaborate with GC implementors to improve GC performance.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258976", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jonathan T.", + "last_name": "Moore", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Scott", + "last_name": "Nettles", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/HicksMN97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258960", + "title": "Lambda-Splitting: A Higher-Order Approach to Cross-Module Optimizations", + "abstract": "We describe an algorithm for automatic inline expansion across module boundaries that works in the presence of higher-order functions and free variables; it rearranges bindings and scopes as necessary to move nonexpansive code from one module to another. We describe---and implement---the algorithm as transformations on λ-calculus. Our inliner interacts well with separate compilation and is efficient, robust, and practical enough for everyday use in the SML/NJ compiler. Inlining improves performance by 4--8% on existing code, and makes it possible to use much more data abstraction by consistently eliminating penalties for modularity.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258960", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "M.", + "last_name": "Blume", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/icfp/BlumeA97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258973", + "title": "Functional Reactive Animation", + "abstract": "Fran (Functional Reactive Animation) is a collection of data types and functions for composing richly interactive, multi-media animations. The key ideas in Fran are its notions of behaviors and events. Behaviors are time-varying, reactive values, while events are sets of arbitrarily complex condi-tions, carrying possibly rich information. Most traditional values can be treated as behaviors, and when images are thus treated, they become animations. Although these no-tions are captured as data types rather than a programming language, we provide them with a denotational semantics, including a proper treatment of real time, to guide reason-ing and implementation. A method to eectively and ef-ciently perform event detection using interval analysis is also described, which relies on the partial information struc-ture on the domain of event times. Fran has been imple-mented in Hugs, yielding surprisingly good performance for an interpreter-based system. Several examples are given, in-cluding the ability to describe physical phenomena involving", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258973", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/ElliottH97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258989", + "title": "Distributed Programming, a Purely Functional Approach", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258989", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Eleni", + "last_name": "Spiliopoulou", + "institution": "University of Bristol" + }, + { + "first_name": "Ian", + "last_name": "Holyer", + "institution": "University of Bristol" + }, + { + "first_name": "Neil M", + "last_name": "Davies", + "institution": "University of Bristol" + } + ], + "dblp_key": "conf/icfp/SpiliopoulouHD97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258983", + "title": "Modelling String Folding with G2L Grammars", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258983", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Natalio", + "last_name": "Krasnogor", + "institution": "Universidad Nacional de La Plata" + }, + { + "first_name": "Pablo E. Martínez", + "last_name": "López", + "institution": "Universidad Nacional de La Plata" + }, + { + "first_name": "Pablo", + "last_name": "Mocciola", + "institution": "Universidad Nacional de La Plata" + }, + { + "first_name": "David A.", + "last_name": "Pelta", + "institution": "Universidad Nacional de La Plata" + } + ], + "dblp_key": "conf/icfp/KrasnogorLMP97a", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258982", + "title": "Protien Folding meets Functional Programming", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258982", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Natalio", + "last_name": "Krasnogor", + "institution": "Universidad Nacional de La Plata" + }, + { + "first_name": "Pablo E. Martínez", + "last_name": "López", + "institution": "Universidad Nacional de La Plata" + }, + { + "first_name": "Pablo", + "last_name": "Mocciola", + "institution": "Universidad Nacional de La Plata" + }, + { + "first_name": "David A.", + "last_name": "Pelta", + "institution": "Universidad Nacional de La Plata" + } + ], + "dblp_key": "conf/icfp/KrasnogorLMP97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258966", + "title": "on Global Dynamics of Optimal Graph Reduction", + "abstract": "Optimal graph reduction technology for the λ-calculus, as developed by Lamping, with modifications by Asperti, Gonthier, Abadl, and Lévy, has a well-understood local dynamics based on a standard menagerie of reduction rules, as well as a global context semantics based on Girard's geometry of interaction. However, the global dynamics of graph reduction has not been subject to careful investigation. In particular, graphs lose their structural resemblance to λ-terms after only a few graph reduction steps, and little is known about graph reduction strategies that maintain efficiency or structure. While the context semantics provides global information about the computation, its use as part of a reduction strategy seems computationally infeasible. We propose a tractable graph reduction strategy that preserves computationally relevant global structure, and allows us to efficiently bound the computational resources needed to implement optimal reduction.A simple canonical representation for graphs is introduced that we call fan-normal form. This normal form allows us to reduce graphs based on efficient identification of β-redexes, rather than being guided by lower-level search for interacting nodes. In addition and perhaps more important, the fan-normal form facilitates a complexity analysis of graph reductions, showing that the number of fan interactions is essentially bounded by a polynomial in the number of unique Lévy labels generated during a labelled reduction. This global analysis of the finitary dynamics of optimal reduction is the first demonstration that a reasonable implementation-independent cost model for the λ-calculus is in fact realized by Lamping's abstract algorithm. It remains to be seen whether similar claims can be made about so-called bookkeeping for fan interactions.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258966", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Julia L.", + "last_name": "Lawall", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/icfp/LawallM97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258964", + "title": "Tupling Calculation Eliminates Multiple Data Traversals", + "abstract": "Tupling is a well-known transformation tactic to obtain new efficient recursive functions by grouping some recursive functions into a tuple. It may be applied to eliminate multiple traversals over the common data structure. The major difficulty in tupling transformation is to find what functions are to be tupled and how to transform the tupled function into an efficient one. Previous approaches to tupling transformation are essentially based on fold/unfold transformation. Though general, they suffer from the high cost of keeping track of function calls to avoid infinite unfolding, which prevents them from being used in a compiler.To remedy this situation, we propose a new method to expose recursive structures in recursive definitions and show how this structural information can be explored for calculating out efficient programs by means of tupling. Our new tupling calculation algorithm can eliminate most of multiple data traversals and is easy to be implemented.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258964", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "The University of Tokyo" + }, + { + "first_name": "Hideya", + "last_name": "Iwasaki", + "institution": "Tokyo University of Agriculture and Technology" + }, + { + "first_name": "Masato", + "last_name": "Takeichi", + "institution": "Tokyo University of Information Sciences" + }, + { + "first_name": "Akihiko", + "last_name": "Takano", + "institution": "Hitachi (Japan)" + } + ], + "dblp_key": "conf/icfp/HuITT97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258953", + "title": "Type-Driven Defunctionalization", + "abstract": "In 1972, Reynolds outlined a general method for eliminating functional arguments known as defunctionalization. The idea underlying defunctionalization is encoding a functional value as first-order data, and then realizing the applications of the encoded function via an apply function. Although this process is simple enough, problems arise when defunctionalization is used in a polymorphic language. In such a language, a functional argument of a higher-order function can take different type instances in different applications. As a consequence, its associated apply function can be untypable in the source language. In the paper we present a defunctionalization transformation which preserves typability. Moreover, the transformation imposes no restriction on functional arguments of recursive functions, and it handles functions as results as well as functions encapsulated in constructors. The key to this success is the use of type information in the defunctionalization transformation. Run-time characteristics are preserved by defunctionalization; hence, there is no performance improvement coming from the transformation itself. However closures need not be implemented to compile the transformed program.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258953", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeffrey", + "last_name": "Bell", + "institution": "" + }, + { + "first_name": "Françoise", + "last_name": "Bellegarde", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Hook", + "institution": "" + } + ], + "dblp_key": "conf/icfp/BellBH97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258986", + "title": "Synthesis of Functions by Transformations and Constraints", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258986", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cristóbal", + "last_name": "Pareja-Flores", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "J. Ángel", + "last_name": "Velázquez‐Iturbide", + "institution": "Universidad Politécnica de Madrid" + } + ], + "dblp_key": "conf/icfp/Pareja-FloresV97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258963", + "title": "On the Complexity of Set-Based Analysis", + "abstract": "We define a general notion of set-based analysis --- any language whose operational semantics is defined by environment evaluation has a well defined set-based abstraction. This general definition covers both Aiken and Wimmers' type system and Heintze' set-based analysis. Aiken and Wimmers give a nondeterministic exponential time algorithm for their analysis. Heintze gives an O(n3) procedure. We show that this discrepancy is due to the complexity of the case statements analyzed. For polymorphic programs with deep patterns in case statements (as in the Aiken-Wimmers language) we show that the problem of determining type-safety under set-based abstraction is complete for deterministic exponential time. The problem remains complete for deterministic exponential time for programs without let (monovariant programs). However, for monovariant programs in which all patterns in case statements are shallow, as in the Heintze language, type-safety under set-based abstraction is decidable in cubic time. We give five additional theorems which (nearly exhaustively) characterize the time complexity of set-based analysis as a function of the complexity of case statements.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258963", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nevin", + "last_name": "Heintze", + "institution": "Nokia (United States)" + }, + { + "first_name": "David", + "last_name": "McAllester", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/icfp/HeintzeM97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258971", + "title": "Implementing Bit-addressing with Specialization", + "abstract": "General media-processing programs are easily expressed with bit-addressing and variable-sized bit-fields. But the natural implementation of bit-addressing relies on dynamic shift offsets and repeated loads, resulting in slow execution. If the code is specialized to the alignment of the data against word boundaries, the offsets become static and many repeated loads can be removed. We show how introducing modular arithmetic into an automatic compiler generator enables the transformation of a program that uses bit-addressing into a synthesizes of fast specialized programs.In partiai-evaluation jargon we say: modular arithmetic is supported by extending the binding time lattice used by the static analysis in a polyvariant compiler generator. The new binding time Cyclic functions like a partially static integer.A software cache combined with a fast, optimistic sharing analysis built into the compilers eliminates repeated loads and stores. The utility of the transformation is demonstrated with a collection of examples and benchmark data. The examples include vector arithmetic, audio synthesis, image processing, and a base-64 codec.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258971", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Scott", + "last_name": "Draves", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Draves97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258957", + "title": "Statically Checkable Pattern Abstractions", + "abstract": "Pattern abstractions increase the expressiveness of pattern matching, enabling the programmer to describe a broader class of regular forests with patterns. Furthermore, pattern abstractions support code reuse and code factoring, features that facilitate maintenance and evolution of code. Past research on pattern abstractions has generally ignored the aspect of compile-time checks for exhaustiveness and redundancy. In this paper we propose a class of expressive patterns that admits these compile-time checks.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258957", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "University of California, Berkeley" + }, + { + "first_name": "John", + "last_name": "Boyland", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/FahndrichB97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258979", + "title": "Disposable Memo Functions (Extended Abstract)", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258979", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "" + } + ], + "dblp_key": "conf/icfp/CookL97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258972", + "title": "Structuring Graphical Paradigms in TkGofer", + "abstract": "In this paper we describe the implementation of several graphical programming paradigms (Model View Controller, Fudgets, and Functional Animations) using the GUI library TkGofer. This library relies on a combination of monads and multiple-parameter type classes to provide an abstract, type safe interface to Tcl/Tk. We show how choosing the right abstractions makes the given implementations surprisingly concise and easy to understand. 1 Introduction In his article `Why Functional Programming Matters&apos; [7], John Hughes explains that an important feature of a programming language is the way in which a language provides glue for combining building blocks to form larger structures. The better the glue, the more modular programs can be made. He argues that functional languages offer very powerful kinds of glue like higher order functions and lazy evaluation. Further research evolved a new kind of glue: type and constructor classes [9]. Unfortunately, there used to be a separation between th...", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258972", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Utrecht University" + }, + { + "first_name": "Ton", + "last_name": "Vullinghs", + "institution": "Universität Ulm" + }, + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/ClaessenVM97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258970", + "title": "Monadic State: Axiomatization and Type Safety", + "abstract": "Type safety of imperative programs is an area fraught with difficulty and requiring great care. The SML solution to the problem, originally involving imperative type variables, has been recently simplified to the syntactic-value restriction. In Haskell, the problem is addressed in a rather different way using explicit monadic state. We present an operational semantics for state in Haskell and the first full proof of type safety. We demonstrate that the semantic notion of value provided by the explicit monadic types is able to avoid any problems with generalization.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258970", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Oregon Research Institute" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/icfp/LaunchburyS97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258954", + "title": "Systematic Realisation of Control Flow Analyses for CML", + "abstract": "We present a methodology for the systematic realisation of control flow analyses and illustrate it for Concurrent ML. We start with an abstract specification of the analysis that is next proved semantically sound with respect to a traditional small-step operational semantics; this result holds for terminating as well as non-terminating programs. The analysis is defined coinductively and it is shown that all programs have a least analysis result (that is indeed the best one). To realise the analysis we massage the specification in three stages: (i) to explicitly record reachability of subexpressions, (ii) to be defined in a syntax-directed manner, and (iii) to generate a set of constraints that subsequently can be solved by standard techniques. We prove equivalence results between the different versions of the analysis; in particular it follows that the least solution to the constraints generated will be the least analysis result also to the initial specification. 1 Introduction Many c...", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258954", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kirsten L. Solberg", + "last_name": "Gasser", + "institution": "Aarhus University" + }, + { + "first_name": "Flemming", + "last_name": "Nielson", + "institution": "Aarhus University" + }, + { + "first_name": "Hanne Riis", + "last_name": "Nielson", + "institution": "" + } + ], + "dblp_key": "conf/icfp/GasserNN97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258977", + "title": "A GUI on Top of a Functional Language", + "abstract": "status: Published", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258977", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kris", + "last_name": "Aerts", + "institution": "KU Leuven" + }, + { + "first_name": "Karel De", + "last_name": "Vlaminck", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/icfp/AertsV97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258985", + "title": "BigTypes in ML", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258985", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bruce J.", + "last_name": "McAdam", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/McAdam97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258969", + "title": "Compositional References for Stateful Functional Programming", + "abstract": "We introduce the notion of compositional references into the framework of monadic functional programming and propose a set of new primitives based on this notion. They enable us to use a wide range of mutable data structures. There, references may be passed around explicitly, or mutable data structures such as arrays and tuples may be passed implicitly as hidden state. The former style is called the explicit style and is usually more expressive, while the latter is called the implicit style and has simpler semantics. We investigate the relation between the two styles and discus implementation issues.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258969", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Koji", + "last_name": "Kagawa", + "institution": "Kagawa University" + } + ], + "dblp_key": "conf/icfp/Kagawa97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258955", + "title": "Functional Programming with Graphs", + "abstract": "Graph algorithms expressed in functional languages often suffer from their inherited imperative, state-based style. In particular, this impedes formal program manipulation. We show how to model persistent graphs in functional languages by graph constructors. This provides a decompositional view of graphs which is very close to that of data types and leads to a \"more fictional\" formulation of graph algorithms. Graph constructors enable the definition of general fold operations for graphs. We present a promotion theorem for one of these folds that allows program fusion and the elimination of intermediate results. Fusion is not restricted to the elimination of tree-like structures, and we prove another theorem that facilitates the elimination of intermediate graphs. We describe an ML-implementation of persistent graphs which efficiently supports the presented fold operators. For example, depth-first-search expressed by a fold over a functional graph has the same complexity as the corresponding imperative algorithm.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258955", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Erwig", + "institution": "University of Hagen" + } + ], + "dblp_key": "conf/icfp/Erwig97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258965", + "title": "A Bounds Inference Method for Vector-Based Memoisation", + "abstract": "The dynamic-sized tabulation method can be used to eliminate redundant calls for certain classes of recursive programs. An innovative aspect of the method is the use of lambda abstractions that may subsequently be converted to bounded vectors, in order to share redundant calls via vector lookup.To facilitate this conversion to vector form, we propose a new inference method to conservatively determine the bounds for arithmetic parameters of recursive functions. Suitable techniques for inferring the safe bounds of these parameters are introduced, together with supporting transformations. The resulting method can obtain efficient vector-based programs without the need for run-time bounds checking.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258965", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + }, + { + "first_name": "Masami", + "last_name": "Hagiya", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/icfp/ChinH97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258967", + "title": "The Development of Erlang", + "abstract": "This paper describes the development of the programming language Erlang during the period 1985-1997. Erlang is a concurrent programming language designed for programming large-scale distributed soft real-time control applications. The design of Erlang was heavily influenced by ideas from the logic and functional programming communities. Other sources of inspiration came from languages such as Chill and Ada which are used in industry for programming control systems. 1 Introduction This paper describes the development of the Erlang programming language. Erlang is a language which draws heavily from various traditions in the logic, functional and realtime control programming communities. Our goal was to make a language which could be used for building large soft real-time control systems. By large I mean systems with possibly millions of lines of code. By a soft real-time system I mean a system which does not fail catastrophically if a real-time deadline is missed. Erlang was developed ...", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258967", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joe", + "last_name": "Armstrong", + "institution": "Ericsson (Sweden)" + } + ], + "dblp_key": "conf/icfp/Armstrong97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258959", + "title": "The Effectiveness of Flow Analysis for Inlining", + "abstract": "An interprocedural flow analysis can justify inlining in higher-order languages. In principle, more inlining can be performed as analysis accuracy improves. This paper compares four flow analyses to determine how effectively they justify inlining in practice. The paper makes two contributions. First, the relative merits of the flow analyses are measured with all other variables held constant. The four analyses include two monovariant and two polyvariant analyses that cover a wide range of the accuracy/cost spectrum. Our measurements show that the effectiveness of the inliner improves slightly as analysis accuracy improves, but the improvement is offset by the compile-time cost of the accurate analyses. The second contribution is an improvement to the previously reported inlining algorithm used in our experiments. The improvement causes flow information provided by a polyvariant analysis to be selectively merged. By merging flow information depending on the inlining context, the algorithm is able to expose additional opportunities for inlining. This merging technique can be used in any program transformer justified by a polyvariant flow analysis. The revised algorithm is fully implemented in a production Scheme compiler.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258959", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John M.", + "last_name": "Ashley", + "institution": "University of Kansas" + } + ], + "dblp_key": "conf/icfp/Ashley97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258980", + "title": "Affordable Dynamic Types", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258980", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chris", + "last_name": "Dornan", + "institution": "University College Cork" + } + ], + "dblp_key": "conf/icfp/Dornan97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258968", + "title": "Type Specialization for Imperative Languages", + "abstract": "We extend type specialisation to a computational lambda calculus with first-class references. The resulting specialiser has been used to specialise a self-interpreter for this typed computational lambda calculus optimally. Furthermore, this specialiser can perform operations on references at specialisation time, when possible. Keywords: program transformation, specialisation, type systems, monads. 1 Introduction Partial evaluation is an important program specialisation technique [18]. Partial evaluation is a program transformation, which transforms a program and parts of its input (the static part) into a new program. The partial evaluator performs the operations for which enough data is available and reconstructs the rest. A partial evaluator operates on both values and symbolic values (code or values or a combination of code and values), whereas an interpreter operates only on values. Partial evaluators appear in two variants, online and offline. In online partial evaluators a...", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258968", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dirk", + "last_name": "Dussart", + "institution": "KU Leuven" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/icfp/DussartHT97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258984", + "title": "A Functional Macro Expansion System for Optimizing Code Generation: Gaining Context-Sensitivity without Losing Confluence", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258984", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Eero", + "last_name": "Lassila", + "institution": "University of Helsinki" + } + ], + "dblp_key": "conf/icfp/Lassila97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258988", + "title": "Simple Semantic Analysis Problems for Functional Programs", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258988", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Viktor", + "last_name": "Sabelfeld", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Andrei", + "last_name": "Sabelfeld", + "institution": "Folkwang University of the Arts" + } + ], + "dblp_key": "conf/icfp/SabelfeldS97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258974", + "title": "Automatic Management of Operating System Resources", + "abstract": "One of the attractive features of functional programming languages is that they provide automatic management of the store, in the form of garbage collection. However, the benefits of automatic resource management can be applied to other resources as well. Scsh, a systems-programming dialect of Scheme, provides automatic resource management for operating-systems structures, notably processes, I/O channels, and signal events. This kind of automatic management extends the benefits of garbage collection---modularity, robustness, simplicity, and clarity---to new sets of objects in programming, and also gives us hints as to how operating systems should be structured from the perspective of functional programming languages.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258974", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Shivers97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258987", + "title": "Intensional Sets Using Explicit Substitutions", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258987", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Richard", + "institution": "Université d'Orléans" + }, + { + "first_name": "Frédéric", + "last_name": "Saubion", + "institution": "Université d'Orléans" + }, + { + "first_name": "A.", + "last_name": "Tellez-Arenas", + "institution": "Université d'Orléans" + } + ], + "dblp_key": "conf/icfp/RichardST97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258975", + "title": "Formal Models of Distributed Memory Management", + "abstract": "We develop am abstract model of memory management in distributed systems. The model is low-level enough so that we can express communication, allocation and garbage collection, but otherwise hides many of the lower-level details of an actual implementation.Recently, such formal models have been developed for memory management in a functional, sequential setting [10]. The models are rewriting systems whose terms are programs. Programs have both the \"code\" (control string) and the \"store\" syntactically apparent. Evaluation is expressed as conditional rewriting and includes store operations. Garbage collection becomes a rewriting relation that removes part of the store without affecting the behavior of the program.Distribution adds another dimension to an already complex problem. By using techniques developed for communicating and concurrent systems [9], we extend their work to a distributed environment. Sending and receiving messages is also made apparent at the syntactic level. A very general garbage collection rule based on reachability is introduced and proved correct. Now proving correct a specific collection strategy is reduced to showing that the relation between programs defined by the strategy is a sub-relation of the general relation. Any actual implementation which is capable of providing the transitions (including their atomicity constraints) specified by the strategy is therefore correct.This model allows us to specify and prove correct in a compact manner two garbage collectors; the first one does a simple garbage collection local to a node. The second garbage collector uses migration of data in order to be able to reclaim inter-node cyclic garbage.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258975", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christian", + "last_name": "Ungureanu", + "institution": "New York University" + }, + { + "first_name": "Benjamin", + "last_name": "Goldberg", + "institution": "New York University" + } + ], + "dblp_key": "conf/icfp/UngureanuG97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258958", + "title": "Flexible Representation Analysis", + "abstract": "Statically typed languages with Hindley-Milner polymorphism have long been compiled using inefficient and fully boxed data representations. Recently, several new compilation methods have been proposed to support more efficient and unboxed multi-word representations. Unfortunately, none of these techniques is fully satisfactory. For example, Leroy's coercion-based approach does not handle recursive data types and mutable types well. The type-passing approach (proposed by Harper and Morrisett) handles all data objects, but it involves extensive runtime type analysis and code manipulations.This paper presents a new flexible representation analysis technique that combines the best of both approaches. Our new scheme supports unboxed representations for recursive and mutable types, yet it only requires little runtime type analysis. In fact, we show that there is a continuum of possibilities between the coercion-based approach and the type-passing approach. By varying the amount of boxing and the type information passed at runtime, a compiler can freely explore any point in the continuum---choosing from a wide range of representation strategies based on practical concerns. Finally, our new scheme also easily extends to handle type abstractions across ML-like higher-order modules.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258958", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/Shao97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258990", + "title": "Multi-Stage Programming", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258990", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Walid", + "last_name": "Taha", + "institution": "Oregon Museum of Science and Industry" + }, + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Oregon Museum of Science and Industry" + } + ], + "dblp_key": "conf/icfp/TahaS97", + "venue": "icfp", + "year": 1997 + }, + { + "paper_id": "10.1145/258948.258991", + "title": "Lambda-Flow: A Parallel Functional Synchronous Dataflow Language", + "abstract": "No abstract available.", + "date": "1997-08-01", + "link": "https://doi.org/10.1145/258948.258991", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guilhem de", + "last_name": "Wailly", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/icfp/Wailly97", + "venue": "icfp", + "year": 1997 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/1998.json b/data/pl_conferences/icfp/1998.json new file mode 100644 index 0000000..ed067b4 --- /dev/null +++ b/data/pl_conferences/icfp/1998.json @@ -0,0 +1,944 @@ +[ + { + "paper_id": "10.1145/289423.289442", + "title": "Functional Differentiation of Computer Programs", + "abstract": "We present two purely functional implementations of the computational differentiation tools -- the well known numeric (not symbolic!) techniques which permit to compute pointwise derivatives of functions defined by computer programs economically and exactly. We show how the co-recursive (lazy) algorithm formulation permits to construct in a transparent and elegant manner the entire infinite tower of derivatives of higher order for any expressions present in the program, and we present a purely functional variant of the reverse (or adjoint) mode of computational differentiation, using a chain of delayed evaluations represented by closures. Some concrete applications are also discussed.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289442", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jerzy", + "last_name": "Karczmarczuk", + "institution": "Université de Caen Normandie" + } + ], + "dblp_key": "conf/icfp/Karczmarczuk98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289451", + "title": "Cayenne - a Language with Dependent Types", + "abstract": "Cayenne is a Haskell-like language. The main difference between Haskell and Cayenne is that Cayenne has dependent types, i.e., the result type of a function may depend on the argument value, and types of record components (which can be types or values) may depend on other components. Cayenne also combines the syntactic categories for value expressions and type expressions; thus reducing the number of language concepts.Having dependent types and combined type and value expressions makes the language very powerful. It is powerful enough that a special module concept is unnecessary; ordinary records suffice. It is also powerful enough to encode predicate logic at the type level, allowing types to be used as specifications of programs. However, this power comes at a cost: type checking of Cayenne is undecidable. While this may appear to be a steep price to pay, it seems to work well in practice.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289451", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lennart", + "last_name": "Augustsson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/Augustsson98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289473", + "title": "A Structured Approach to Retrieving Functions by Types", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289473", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nancy", + "last_name": "An", + "institution": "University of Windsor" + }, + { + "first_name": "Young", + "last_name": "Park", + "institution": "University of Windsor" + } + ], + "dblp_key": "conf/icfp/AnP98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289465", + "title": "Type Errors Confuse the Programmer (Poster Abstract)", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289465", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bruce J.", + "last_name": "McAdam", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/McAdam98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289426", + "title": "Higher-Order Arity Raising", + "abstract": "Arity raising, also known as variable splitting or flattening, is the program optimization which transforms a function of one argument into a function of several arguments by decomposing the structure of the original one argument into individual components in that structure. This optimization eliminates the need for the structuring of the components and also allows more arguments to be passed in registers during a function call. We present a formal specification of arity raising for a higher-order functional language. This specification supports the general arity raising of functions, even for functions which are passed as arguments or returned as values. We define a practical algorithm, based on algorithm W, which implements arity raising, and we prove this algorithm sound with respect to the deductive system. These results provide a declarative framework for reasoning about arity raising and support a richer form of the transformation than is currently found in compilers for functional languages.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289426", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John", + "last_name": "Hannan", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Patrick", + "last_name": "Hicks", + "institution": "Saint Vincent College" + } + ], + "dblp_key": "conf/icfp/HannanH98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289439", + "title": "The Spineless Tagless G-machine, naturally", + "abstract": "The application of natural semantic specifications of lazy evaluation to areas such as usage analysis, formal profiling and abstract machine construction has shown it to be a useful formalism. This paper introduces several variants and extensions of this specification.The first variant is derived from observations of the Spineless Tagless G-machine (STG), used in the Glasgow Haskell compiler. We present a modified natural semantic specification which can be formally manipulated to derive an STG-like machine.The second variant is the development of a natural semantic specification which allows functions to be applied to more than one argument at once. The STG and TIM abstract machines both allow this kind of behaviour, and we illustrate a use of this semantics by again modifying this semantics following observations of the STG machine. The resulting semantics can be used to formally derive the STG machine. This effectively proves the STG machine correct with respect to Launchbury's semantics.En route, we also show that update markers in the STG machine are necessary for termination, and show how well-known abstract machine instructions, such as the squeeze operation, appear quite naturally as optimisations of the derived abstract machine.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289439", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jon", + "last_name": "Mountjoy", + "institution": "University of Amsterdam" + } + ], + "dblp_key": "conf/icfp/Mountjoy98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289457", + "title": "Fold and Unfold for Program Semantics", + "abstract": "In this paper we explain how recursion operators can be used to structure and reason about program semantics within a functional language. In particular, we show how the recursion operator fold can be used to structure denotational semantics, how the dual recursion operator unfold can be used to structure operational semantics, and how algebraic properties of these operators can be used to reason about program semantics. The techniques are explained with the aid of two main examples, the first concerning arithmetic expressions, and the second concerning Milner's concurrent language CCS. The aim of the paper is to give functional programmers new insights into recursion operators, program semantics, and the relationships between them.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289457", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/icfp/Hutton98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289468", + "title": "Verbose Typing", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289468", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert", + "last_name": "Ennals", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/Ennals98a", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289467", + "title": "Controlled Temporal Non-Determinism for Reasoning with a Machine of Finite Speed", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289467", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert", + "last_name": "Ennals", + "institution": "Bridge University" + } + ], + "dblp_key": "conf/icfp/Ennals98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289440", + "title": "Lava: Hardware Design in Haskell", + "abstract": "Lava is a tool to assist circuit designers in specifying, designing, verifying and implementing hardware. It is a collection of Haskell modules. The system design exploits functional programming language features, such as monads and type classes, to provide multiple interpretations of circuit descriptions. These interpretations implement standard circuit analyses such as simulation, formal verification and the generation of code for the production of real circuits.Lava also uses polymorphism and higher order functions to provide more abstract and general descriptions than are possible in traditional hardware description languages. Two Fast Fourier Transform circuit examples illustrate this.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289440", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Per", + "last_name": "Bjesse", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Mary", + "last_name": "Sheeran", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Satnam", + "last_name": "Singh", + "institution": "Xilinx (United States)" + } + ], + "dblp_key": "conf/icfp/BjesseCSS98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289427", + "title": "A Type Based Sharing Analysis for Update Avoidance and Optimisation", + "abstract": "Sharing of evaluation is crucial for the efficiency of lazy functional languages, but unfortunately the machinery to implement it carries an inherent overhead. In abstract machines this overhead shows up as the cost of performing updates, many of them actually unnecessary, and also in the cost of the associated bookkeeping, that is keeping track of when and where to update. In spineless abstract machines, such as the STG-machine and the TIM, this bookkeeping consists of pushing, checking for and popping update markers. Checking for update markers is a very frequent operation and indeed the implementation of the STG-machine has been optimised for fast update marker checks at the expense of making the pushing and popping of update markers more costly.In this paper we present a type based sharing analysis that can determine when updates can be safely omitted and marker checks bypassed. The type system is proved sound with respect to the lazy Krivine machine. We have implemented the analysis and the preliminary benchmarks seem very promising. Most notably, virtually all update marker checks can be avoided. This may make the tradeoffs of current implementations obsolete and calls for new abstract machine designs.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289427", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jörgen", + "last_name": "Gustavsson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/Gustavsson98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289463", + "title": "LAND*: an AND with local bindings, a guarded LET* special form", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289463", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Kiselyov98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289428", + "title": "Taming Effects with Monadic Typing", + "abstract": "The familiar Hindley-Milner type system of the ML language family is extended with monad annotations to account for possible side effects of expression evaluation. This also allows effects to be effectively encapsulated by lexical scopes Γ with enforcement provided by type checking. A type-and-effects analysis supports type inference. Type soundness and completeness theorems establish the coherence of monadic type inference with the reference semantics of a small ML-style language.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289428", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Richard B.", + "last_name": "Kieburtz", + "institution": "Oregon Research Institute" + } + ], + "dblp_key": "conf/icfp/Kieburtz98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289431", + "title": "PLAN: A Packet Language for Active Networks", + "abstract": "PLAN (Packet Language for Active Networks) is a new language for programs that form the packets of a programmable network. These programs replace the packet headers (which can be viewed as very rudimentary programs) used in current networks. As such, PLAN programs are lightweight and of restricted functionality. These limitations are mitigated by allowing PLAN code to call node-resident service routines written in other, more powerful languages. This two-level architecture, in which PLAN serves as a scripting or 'glue' language for more general services, is the primary contribution of this paper. We have successfully applied the PLAN programming environment to implement an IP-free internetwork.PLAN is based on the simply typed lambda calculus and provides a restricted set of primitives and datatypes. PLAN defines a special construct called a chunk used to describe the remote execution of PLAN programs on other nodes. Primitive operations on chunks are used to provide basic data transport in the network and to support layering of protocols. Remote execution can make debugging difficult, so PLAN provides strong static guarantees to the programmer, such as type safety. A more novel property aimed at protecting network availability is a guarantee that PLAN programs use a bounded amount of network resources.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289431", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Pankaj", + "last_name": "Kakkar", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jonathan T.", + "last_name": "Moore", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Carl A.", + "last_name": "Gunter", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Scott", + "last_name": "Nettles", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/HicksKMGN98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289455", + "title": "The Under-Appreciated Unfold", + "abstract": "<em>Folds</em> are appreciated by functional programmers. Their dual, <em>unfolds</em>, are not new, but they are not nearly as well appreciated. We believe they deserve better. To illustrate, we present (indeed, we calculate) a number of algorithms for computing the <em>breadth-first traversal</em> of a tree. We specify breadth-first traversal in terms of <em>level-order traversal</em>, which we characterize first as a fold. The presentation as a fold is simple, but it is inefficient, and removing the inefficiency makes it no longer a fold. We calculate a characterization as an unfold from the characterization as a fold; this unfold is equally clear, but more efficient. We also calculate a characterization of breadth-first traversal directly as an unfold; this turns out to be the `standard' queue-based algorithm.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289455", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "Oxford Brookes University" + }, + { + "first_name": "Geraint", + "last_name": "Jones", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/GibbonsJ98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289432", + "title": "Modular Object-Oriented Programming with Units and Mixins", + "abstract": "Module and class systems have evolved to meet the demand for reuseable software components. Considerable effort has been invested in developing new module and class systems, and in demonstrating how each promotes code reuse. However, relatively little has been said about the interaction of these constructs, and how using modules and classes together can improve programs. In this paper, we demonstrate the synergy of a particular form of modules and classes---called units and mixins, respectively---for solving complex reuse problems in a natural manner.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289432", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Rice University" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "Rice University" + } + ], + "dblp_key": "conf/icfp/FindlerF98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289441", + "title": "Lazy Computation with Exact Real Numbers", + "abstract": "We provide a semantical framework for exact real arithmetic using linear fractional transformations on the extended real line. We present an extension of PCF with a real type which introduces an eventually breadth-first strategy for lazy evaluation of exact real numbers. In this language, we present the constant redundant if, rif, for defining functions by cases which, in contrast to parallel if (pif), overcomes the problem of undecidability of comparison of real numbers in finite time. We use the upper space of the one-point compactification of the real line to develop a denotational semantics for the lazy evaluation of real programs. Finally two adequacy results are proved, one for programs containing rif and one for those not containing it. Our adequacy results in particular provide the proof of correctness of algorithms for computation of single-valued elementary functions. 1 Introduction It is well known that the accumulation of round-off errors in floating point programs can l...", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289441", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Abbas", + "last_name": "Edalat", + "institution": "Imperial College London" + }, + { + "first_name": "Peter John", + "last_name": "Potts", + "institution": "Imperial College London" + }, + { + "first_name": "Philipp", + "last_name": "Sünderhauf", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/icfp/EdalatPS98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289445", + "title": "Pragmatic Subtyping in Polymorphic Languages", + "abstract": "We present a subtyping extension to the Hindley/Milner type system that is based on name inequivalence. This approach allows the subtype relation to be defined by incremental construction of polymorphic records and datatypes, in a way that subsumes the basic type systems of both languages like ML and Java. As the main contribution of the paper, we describe a partial type inference algorithm for the extended system which favours succinctness over generality, in the sense that it never infers types with subtype constraints. The algorithm is based on an efficient approximating constraint solver, and is able to type a wide range of programs that utilize subtyping and polymorphism in a non-trivial way. Since constrained types are not inferred, the algorithm cannot be complete; however, we provide a completeness result w.r.t. the Hindley/Milner type system as a form of characterizing lower bound.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289445", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Johan", + "last_name": "Nordlander", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/Nordlander98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289424", + "title": "On the Runtime Complexity of Type-Directed Unboxing", + "abstract": "Avoiding boxing when representing native objects is essential for the efficient compilation of any programming language For polymorphic languages this task is difficult, but several schemes have been proposed that remove boxing on the basis of type information. Leroy's type-directed unboxing transformation is one of them. One of its nicest properties is that it relies only on visible types, which makes it compatible with separate compilation. However it has been noticed that it is not safe both in terms of time and space complexity ---i.e. transforming a program may raise its complexity. We propose a refinement of this transformation, still relying only on visible types, and prove that it satisfies the safety condition for time complexity. The proof is an extension of the usual logical relation method, in which correctness and safety are proved simultaneously.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289424", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yasuhiko", + "last_name": "Minamide", + "institution": "Kyoto University" + }, + { + "first_name": "Jacques", + "last_name": "Garrigue", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/icfp/MinamideG98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289478", + "title": "Implementing Design Patterns as Language Constructs", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289478", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yan-David", + "last_name": "Erlich", + "institution": "Rice University" + } + ], + "dblp_key": "conf/icfp/Erlich98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289437", + "title": "H/Direct: A Binary Foreign Language Interface for Haskell", + "abstract": "H/Direct is a foreign-language interface for the purely functional language Haskell. Rather than rely on host-language type signatures, H/Direct compiles Interface Definition Language (IDL) to Haskell stub code that marshals data across the interface. This approach allows Haskell to call both C and COM, and allows a Haskell component to be wrapped in a C or COM interface. IDL is a complex language and language mappings for IDL are usually described informally. In contrast, we provide a relatively formal and precise definition of the mapping between Haskell and IDL.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289437", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sigbjørn", + "last_name": "Finne", + "institution": "University of Glasgow" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Utrecht University" + }, + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "Utrecht University" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/icfp/FinneLMJ98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289475", + "title": "Frob - Functional Robotics", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289475", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gary Shu", + "last_name": "Ling", + "institution": "Laboratoire d'Informatique de Paris-Nord" + } + ], + "dblp_key": "conf/icfp/Ling98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289443", + "title": "A Distributed Garbage Collector with Diffusion Tree Reorganisation and Mobile Objects", + "abstract": "We present a new distributed garbage collection algorithm that is able to reorganise diffusion trees and to support mobile objects. It has a modular design comprising three components: a reliable transport mechanism, a reference-counting based distributed garbage collector for non-mobile objects, and an extra layer that provides mobility. The algorithm is formalised by an abstract machine and is proved to be correct. The safety property ensures that an object may not be reclaimed as long as it is referred to locally or remotely. The liveness property guarantees that unreachable objects will eventually be reclaimed. The mobility property certifies that messages are always forwarded towards more recent mobile object positions.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289443", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Luc", + "last_name": "Moreau", + "institution": "University of Southampton" + } + ], + "dblp_key": "conf/icfp/Moreau98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289434", + "title": "YALE: Yet Another Lambda Evaluator Based on Interaction Nets", + "abstract": "Interaction nets provide a graphical paradigm of computation based on net rewriting. They have proved most successful in understanding the dynamics of reduction in the λ-calculus, where the prime example is the implementation of optimal reduction for the λ-calculus (Lamping's algorithm), given by Gonthier, Abadi and Lévy. However, efficient implementations of optimal reduction have had to break away from the interaction net paradigm. In this paper we give a new efficient interaction net encoding of the λ-calculus which is not optimal, but overcomes the inefficiencies caused by the bookkeeping operations in the implementations of optimal reduction. We believe that this implementation of the λ-calculus could provide the basis for highly efficient implementations of functional languages.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289434", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ian", + "last_name": "Mackie", + "institution": "Laboratoire d'Informatique de l'École Polytechnique" + } + ], + "dblp_key": "conf/icfp/Mackie98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289472", + "title": "A Delegation Language to Request Weather Products and a Scheme of Its Interpretation", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289472", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Kiselyov98b", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289479", + "title": "A Lazy CGI Namespace in Scheme", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289479", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Kiselyov98c", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289435", + "title": "Compiling Standard ML to Java Bytecodes", + "abstract": "MLJ compiles SML&apos;97 into verifier-compliant Java bytecodes. Its features include type-checked interlanguage working extensions which allow ML and Java code to call each other, automatic recompilation management, compact compiled code and runtime performance which, using a `just in time&apos; compiling Java virtual machine, usually exceeds that of existing specialised bytecode interpreters for ML. Notable features of the compiler itself include whole-program optimisation based on rewriting, compilation of polymorphism by specialisation, a novel monadic intermediate lang...", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289435", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Abcam (United States)" + }, + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Abcam (United States)" + }, + { + "first_name": "George", + "last_name": "Russell", + "institution": "Abcam (United States)" + } + ], + "dblp_key": "conf/icfp/BentonKR98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289436", + "title": "Typed Cross-Module Compilation", + "abstract": "Higher-order modules are very effective in structuring large programs and defining generic, reusable software components. Unfortunately, many compilation techniques for the core languages do not work across the module boundaries. As a result, few optimizing compilers support these module facilities well.This paper exploits the semantic property of ML-style modules to support efficient cross-module compilation. More specifically, we present a type-directed translation of the MacQueen-Tofte higher-order modules into a predicative variant of the polymorphic λ-calculus Fω. Because modules can be compiled in the same way as ordinary polymorphic functions, standard type-based optimizations such as representation analysis immediately carry over to the module languages.We further show that the full-transparency property of the MacQueen-Tofte system yields a near optimal cross-module compilation framework. By propagating various static information through the module boundaries, many static program analyses for the core languages can be extended to work across higher-order modules.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289436", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/Shao98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289482", + "title": "Combining CFG and Recursive Functions to Get a New Language", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289482", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Haiming", + "last_name": "Chen", + "institution": "Institute of Software" + } + ], + "dblp_key": "conf/icfp/Haiming98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289471", + "title": "MAP: A Functional Analysis and Design Method", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289471", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dan", + "last_name": "Russell", + "institution": "Kingston University" + } + ], + "dblp_key": "conf/icfp/Russell98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289476", + "title": "A Functional Programming Approach to Hypermedia Authoring", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289476", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel H.", + "last_name": "Marcos", + "institution": "Universidad Nacional de La Plata" + }, + { + "first_name": "Pablo E. Martínez", + "last_name": "López", + "institution": "Universidad Nacional de La Plata" + }, + { + "first_name": "Walter A.", + "last_name": "Risi", + "institution": "Universidad Nacional de La Plata" + } + ], + "dblp_key": "conf/icfp/MarcosLR98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289477", + "title": "A Term Calculus for Unitary Approach to Nomalization", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289477", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Claudia", + "last_name": "Faggian", + "institution": "University of Padua" + } + ], + "dblp_key": "conf/icfp/Faggian98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289459", + "title": "Intensional Polymorphism in Type-Erasure Semantics", + "abstract": "Intensional polymorphism, the ability to dispatch to different routines based on types at run time, enables a variety of advanced implementation techniques for polymorphic languages, including tag-free garbage collection, unboxed function arguments, polymorphic marshalling, and flattened data structures. To date, languages that support intensional polymorphism have required a type-passing (as opposed to type-erasure) interpretation where types are constructed and passed to polymorphic functions at run time. Unfortunately, type-passing suffers from a number of drawbacks: it requires duplication of constructs at the term and type levels, it prevents abstraction, and it severely complicates polymorphic closure conversion.We present a type-theoretic framework that supports intensional polymorphism, but avoids many of the disadvantages of type passing. In our approach, run-time type information is represented by ordinary terms. This avoids the duplication problem, allows us to recover abstraction, and avoids complications with closure conversion. In addition, our type system provides another improvement in expressiveness; it allows unknown types to be refined in place thereby avoiding certain beta-expansions required by other frameworks.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289459", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Cornell University" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "Cornell University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/icfp/CraryWM98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289462", + "title": "A Non-Deterministic Call-by-Need Lambda Calculus", + "abstract": "In this paper we present a non-deterministic call-by-need (untyped) lambda calculus X,d with a constant choice and a let-syntax that models sharing. Our main result is that Xnd has the nice operational properties of the standard lambda calculus: confluence on sets of expressions, and normal or-der reduction is sufficient to reach head normal form. Us-ing a strong contextual equivalence we show correctness of several program transformations. In particular of lambda-lifting using deterministic maximal free expressions. These results show that And is a new and also natural combination of non-determinism and lambda-calculus, which has a lot of opportunities for parallel evaluation. An intended application of And is as a foundation for compil-ing lazy functional programming languages with I/O based on direct calls. The set of correct program transformations can be rigorously distinguished from non-correct ones. All program transformations are permitted with the slight ex-ception that for transformations like common subexpression elimination and lambda-lifting with maximal free expres-sions the involved subexpressions have to be deterministic ones. 1", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289462", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Arne", + "last_name": "Kutzner", + "institution": "Goethe University Frankfurt" + }, + { + "first_name": "Manfred", + "last_name": "Schmidt-Schauß", + "institution": "Goethe University Frankfurt" + } + ], + "dblp_key": "conf/icfp/KutznerS98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289448", + "title": "A Framework for Type Inference with Subtyping", + "abstract": "This paper appeared at the International Conference on Functional Programming, Baltimore, September 1998.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289448", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Pottier98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289430", + "title": "A Theory of Core Fudgets", + "abstract": "The Fudgets system is a toolkit for developing graphical applications in the lazy functional programming language Haskell. In this paper we develop an operational semantics for a subset of this system, inspired by ideas from concurrency theory. A semantic theory based on bisimulation is defined and shown to be a congruence. We consider two applications of this theory: firstly, some equational rules useful for reasoning about Fudget programs are verified; secondly, we show how the operational semantics can be used to check the correctness of implementations of the Fudgets system.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289430", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Colin J.", + "last_name": "Taylor", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/icfp/Taylor98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289425", + "title": "Building Program Optimizers with Rewriting Strategies", + "abstract": "We describe a language for defining term rewriting strategies, and its application to the production of program optimizers. Valid transformations on program terms can be described by a set of rewrite rules; rewriting strategies are used to describe when and how the various rules should be applied in order to obtain the desired optimization effects. Separating rules from strategies in this fashion makes it easier to reason about the behavior of the optimizer as a whole, compared to traditional monolithic optimizer implementations. We illustrate the expressiveness of our language by using it to describe a simple optimizer for an ML-like intermediate representation.The basic strategy language uses operators such as sequential composition, choice, and recursion to build transformers from a set of labeled unconditional rewrite rules. We also define an extended language in which the side-conditions and contextual rules that arise in realistic optimizer specifications can themselves be expressed as strategy-driven rewrites. We show that the features of the basic and extended languages can be expressed by breaking down the rewrite rules into their primitive building blocks, namely matching and building terms in variable binding environments. This gives us a low-level core language which has a clear semantics, can be implemented straightforwardly and can itself be optimized. The current implementation generates C code from a strategy specification.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289425", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Oregon Research Institute" + }, + { + "first_name": "Zine-el-Abidine", + "last_name": "Benaissa", + "institution": "Oregon Research Institute" + }, + { + "first_name": "Andrew", + "last_name": "Tolmach", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/VisserBT98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289433", + "title": "Programming with Variable Functions", + "abstract": "What is a good method to specify and derive imperative programs? This paper argues that a new form of functional programming fits the bill, where variable functions can be updated at specified points in their domain. Traditional algebraic specification and functional programming are a powerful pair of tools for specifying and implementing domains of discourse and operations on them. Recent work on evolving algebras has introduced the function update in algebraic specifications, and has applied it with good success in the modelling of reactive systems. We show that similar concepts allow one to derive efficient programs in a systematic way from functional specifications. The final outcome of such a derivation can be made as efficient as a traditional imperative program with pointers, but can still be reasoned about at a high level. Variable functions can also play an important role in the structuring of large systems. They can subsume object-oriented programming languages, without incurring the latter's problems with pointer aliasing and modularity.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289433", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "University of South Australia" + } + ], + "dblp_key": "conf/icfp/Odersky98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289454", + "title": "Imperative Streams - A Monadic Combinator Library for Synchronous Programming", + "abstract": "The paper presents a generalization of Haskell's IO monad suitable for synchronous concurrent programming. The new monad integrates the deterministic concurrency paradigm of synchronous programming with the powerful abstraction features of functional languages and with full support for imperative programming. For event-driven applications, it offers an alternative to the use of existing, thread-based concurrency extensions of functional languages. The concepts presented have been applied in practice in a framework for programming interactive graphics.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289454", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Enno", + "last_name": "Scholz", + "institution": "Daimler (Germany)" + } + ], + "dblp_key": "conf/icfp/Scholz98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289460", + "title": "Implementing Typed Intermediate Languages", + "abstract": "Recent advances in compiler technology have demonstrated the benefits of using strongly typed intermediate languages to compile richly typed source languages (e.g., ML). A typepreserving compiler can use types to guide advanced optimizations and to help generate provably secure mobile code. Types, unfortunately, are very hard to represent and manipulate efficiently; a naive implementation can easily add exponential overhead to the compilation and execution of a program. This paper describes our experience with implementing the FLINT typed intermediate language in the SML/NJ production compiler. We observe that a type-preserving compiler will not scale to handle large types unless all of its type-preserving stages preserve the asymptotic time and space usage in representing and manipulating types. We present a series of novel techniques for achieving this property and give empirical evidence of their effectiveness.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289460", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Christopher", + "last_name": "League", + "institution": "Yale University" + }, + { + "first_name": "Stefan", + "last_name": "Monnier", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/ShaoLM98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289429", + "title": "The Marriage of Effects and Monads", + "abstract": "Gifford and others proposed an effect typing discipline to delimit the scope of computational effects within a program, while Moggi and others proposed monads for much the same purpose. Here we marry effects to monads, uniting two previously separate lines of research. In particular, we show that the type, region, and effect system of Talpin and Jouvelot carries over directly to an analogous system for monads, including a type and effect reconstruction algorithm. The same technique should allow one to transpose any effect systems into a corresponding monad system.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289429", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/icfp/Wadler98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289458", + "title": "Encoding Types in ML-Like Languages", + "abstract": "A Hindley-Milner type system such as ML's seems to prohibit type-indexed values, i.e., functions that map a family of types to a family of values. Such functions generally perform case analysis on the input types and return values of possibly different types. The goal of our work is to demonstrate how to program with type-indexed values within a Hindley-Milner type system.Our first approach is to interpret an input type as its corresponding value, recursively. This solution is type-safe, in the sense that the ML type system statically prevents any mismatch between the input type and function arguments that depend on this type.Such specific type interpretations, however, prevent us from combining different type-indexed values that share the same type. To meet this objection, we focus on finding a value-independent type encoding that can be shared by different functions. We propose and compare two solutions. One requires first-class and higher-order polymorphism, and, thus, is not implementable in the core language of ML, but it can be programmed using higher-order functors in Standard ML of New Jersey. Its usage, however, is clumsy. The other approach uses embedding/projection functions. It appears to be more practical.We demonstrate the usefulness of type-indexed values through examples including type-directed partial evaluation, C printf-like formatting, and subtype coercions. Finally, we discuss the tradeoffs between our approach and some other solutions based on more expressive typing disciplines.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289458", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhe", + "last_name": "Yang", + "institution": "Mercer University" + } + ], + "dblp_key": "conf/icfp/Yang98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289452", + "title": "Recycling Continuations", + "abstract": "If the continuations in functional data-structure-generating programs are made explicit and represented as records, they can be \"recycled.\" Once they have served their purpose as temporary, intermediate structures for managing program control, the space they occupy can be reused for the structures that the programs produce as their output. To effect this immediate memory reclamation, we use a sequence of correctness-preserving program transformations, demonstrated through a series of simple examples. We then apply the transformations to general anamorphism operators, with the important consequence that all finite-output anamorphisms can now be run without any stack- or continuation-space overhead.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289452", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Sobel", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/icfp/SobelF98", + "venue": "icfp", + "year": 1998 + }, + { + "paper_id": "10.1145/289423.289480", + "title": "Automating Derivation of Incremental Programs", + "abstract": "No abstract available.", + "date": "1998-09-29", + "link": "https://doi.org/10.1145/289423.289480", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yuchen", + "last_name": "Zhang", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Yanhong A.", + "last_name": "Lin", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/icfp/ZhangL98", + "venue": "icfp", + "year": 1998 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/1999.json b/data/pl_conferences/icfp/1999.json new file mode 100644 index 0000000..784fc92 --- /dev/null +++ b/data/pl_conferences/icfp/1999.json @@ -0,0 +1,597 @@ +[ + { + "paper_id": "10.1145/317636.317784", + "title": "On Embedding a Microarchitectural Design Language within Haskell", + "abstract": "Based on our experience with modelling and verifying microarchitectural designs within Haskell, this paper examines our use of Haskell as host for an embedded language. In particular, we highlight our use of Haskell's lazy lists, type classes, lazy state monad, and unsafe Perform I0, and point to several areas where Haskell could be improved in the future. We end with an example of a benefit gained by bringing the functional perspective to microarchitectural modelling.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317784", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Oregon Museum of Science and Industry" + }, + { + "first_name": "Jeffrey R.", + "last_name": "Lewis", + "institution": "Oregon Museum of Science and Industry" + }, + { + "first_name": "Byron", + "last_name": "Cook", + "institution": "Oregon Museum of Science and Industry" + } + ], + "dblp_key": "conf/icfp/LaunchburyLC99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317790", + "title": "Calling Hell From Heaven and Heaven From Hell", + "abstract": "The increasing popularity of component-based programming tools offer a big opportunity to designers of advanced programming languages, such as Haskell. If we can package our programs as COM objects, then it is easy to integrate them into applications written in other languages. In earlier work we described a preliminary integration of Haskell with Microsoft&apos;s Component Object Model (COM), focusing on how Haskell can create and invoke COM objects. This paper develops that work, concentrating on the mechanisms that support externally-callable Haskell functions, and the encapsulation of a Haskell program as a COM object. 1 Introduction &quot;Component-based programming&quot; is all the rage. It has come to mean an approach to software construction in which a program is an assembly software components, perhaps written in different languages, glued together by some common substrate [16]. The most widely used substrates are Microsoft&apos;s Component Object Model (COM), and the Common Object Request Broke...", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317790", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sigbjørn", + "last_name": "Finne", + "institution": "University of Glasgow" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Utrecht University" + }, + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "Utrecht University" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/FinneLMJ99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317787", + "title": "A Simple Proof Technique for Certain Parametricity Results", + "abstract": "Many properties of parametric, polymorphic functions can be determined simply by inspection of their types. Such results are usually proven using Reynolds's parametricity theorem. However, Reynolds's theorem can be difficult to show in some settings, particularly ones involving computational effects. I present an alternative technique for proving some parametricity results. This technique is considerably simpler and easily generalizes to effectful settings. It works by instantiating polymorphic functions with singleton types that fully specify the behavior of the functions. Using this technique, I show that callers' stacks are protected from corruption during function calls in Typed Assembly Language programs.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317787", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Crary99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317799", + "title": "Principals in Programming Languages: A Syntactic Proof Technique", + "abstract": "Programs are often structured around the idea that di#erent pieces of code comprise distinct principals, each with a view of its environment. Typical examples include the modules of a large program, a host and its clients, or a collection of interactive agents. In this paper, we formalize this notion of principal in the programming language itself. The result is a language in which intuitive statements such as, &quot;the client must call open to obtain a file handle&quot; can be phrased and proven formally. We add principals to variants of the simply-typed #-calculus and show how we can track the code corresponding to each principal throughout evaluation. We use this multiagent calculus to give syntactic proofs of some type abstraction properties that traditionally require semantic arguments. 1 Introduction Programmers often have a notion of principal in mind when designing the structure of a program. Examples of such principals include modules of a large system, a host and its clients, and, ...", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317799", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "Cornell University" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "Cornell University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/icfp/ZdancewicGM99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317797", + "title": "Type Dispatch for Named Hierarchical Types", + "abstract": "Type dispatch constructs are an important feature of many programming languages. Scheme has predicates for testing the runtime type of a value. Java has a class cast expression and a try statement for switching on an exception&apos;s class. Crucial to these mechanisms, in typed languages, is type renement: The static type system will use type dispatch to rene types in successful dispatch branches. Existing work in functional languages has addressed certain kinds of type dispatch, namely, intensional type analysis. However, this work does not extend to languages with subtyping nor to named types. This paper describes a number of type dispatch constructs that share a common theme: class cast and class case constructs in object oriented languages, ML style exceptions, hier-archical extensible sums, and multimethods. I describe a unifying mechanism, tagging, that abstracts the operation of these constructs, and formalise a small tagging language. After discussing how to implement the tagging language, I present a more primitive language and give a formal translation from the tagging language. 1", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317797", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neal", + "last_name": "Glew", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/icfp/Glew99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317801", + "title": "Transparent Modules with Fully Syntactic Signatures", + "abstract": "ML-style modules are valuable in the development and maintenance of large software systems, unfortunately, none of the existing languages support them in a fully satisfactory manner. The Official SML'97 Definition does not allow higher-order functors, so a module that refers to externally defined functors cannot accurately describe its import interface. MacQueen and Tofte [26] extended SML'97 with fully transparent higher-order functors, but their system does not have a type-theoretic semantics thus fails to support fully syntactic signatures. The systems of manifest types [19, 20] and translucent sums [12] support fully syntactic signatures but they may propagate fewer type equalities than fully transparent functors. This paper presents a module calculus that supports both fully transparent higher-order functors and fully syntactic signatures (and thus true separate compilation). We give a simple type-theoretic semantics to our calculus and show how to compile it into an Fω-like λ-calculus extended with existential types.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317801", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/Shao99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317798", + "title": "Representing Java Classes in a Typed Intermediate Language", + "abstract": "We propose a conservative extension of the polymorphic lambda calculus (Fω) as an intermediate language for compiling languages with name-based class and interface hierarchies. Our extension enriches standard Fω with recursive types, existential types, and row polymorphism, but only ordered records with no subtyping. Basing our language on Fω makes it also a suitable target for translation from other higher-order languages; this enables the safe interoperation between class-based and higher-order languages and the reuse of common type-directed optimization techniques, compiler back ends, and runtime support.We present the formal semantics of our intermediate language and illustrate its features by providing a formal translation from a subset of Java, including classes, interfaces, and private instance variables. The translation preserves the name-based hierarchical relation between Java classes and interfaces, and allows access to private instance variables of parameters of the same class as the one defining the method. It also exposes the details of method invocation and instance variable access and allows many standard optimizations to be performed on the object-oriented code.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317798", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christopher", + "last_name": "League", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Valery", + "last_name": "Trifonov", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/LeagueST99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317800", + "title": "Static Interpretation of Modules", + "abstract": "Berkeley* This paper presents a technique for compiling Standard ML Modules into typed intermediate language fragments, which may be compiled separately and linked using traditional linking technology to form executable code. The technique is called static inteqretataon and allows compile-time implementation details to propagate across module boundaries. Static interpretation eliminates all module-level code at compile time. The technique scales to full Standard ML and is used in the ML Kit with Regions compiler. A framework for smart recompilation makes the technique useful for compiling large programs. 1", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317800", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/icfp/Elsman99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317791", + "title": "Interlanguage Working Without Tears: Blending SML with Java", + "abstract": "A good foreign-language interface is crucial for the success of any modern programming language implementation. Although all serious compilers for functional languages have some facility for interlanguage working, these are often limited and awkward to use.This article describes the features for bidirectional interlanguage working with Java that are built into the latest version of the MLj compiler. Because the MLj foreign interface is to another high-level typed language which shares a garbage collector with compiled ML code, and because we are willing to extend the ML language, we are able to provide unusually powerful, safe and easy to use interlanguage working features. Indeed, rather then being a traditional foreign interface, our language extensions are more a partial integration of Java features into SML.We describe this integration of Standard ML and Java, first informally with example program fragments, and then formally in the notation used by The Definition of Standard ML.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317791", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/BentonK99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317793", + "title": "Programming Languages as Operating Systems (or Revenge of the Son of the Lisp Machine)", + "abstract": "The MrEd virtual machine serves both as the implementation platform for the DrScheme programming environment, and as the underlying Scheme engine for executing expressions and programs entered into DrScheme's read-eval-print loop. We describe the key elements of the MrEd virtual machine for building a programming environment, and we step through the implementation of a miniature version of DrScheme in MrEd. More generally, we show how MrEd defines a high-level operating system for graphical programs.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317793", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "Rice University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Rice University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/icfp/FlattFKF99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317789", + "title": "Type Fixpoints: Iteration vs. Recursion", + "abstract": "Positive recursive (fixpoint) types can be added to the polymorphic (Church-style) lambda calculus λ2 (System F) in several different ways, depending on the choice of the elimination operator. We compare several such definitions and we show that they fall into two equivalence classes with respect to mutual interpretability by means of beta-eta reductions. Elimination operators for fixpoint types are thus classified as either or recursors. This classification has an interpretation in terms of the Curry-Howard correspondence: types of iterators and recursors can be seen as images of induction axioms under different dependency-erasing maps. Systems with recursors are beta-eta equivalent to a calculus λ2U of recursive types with the operators Fold: σ[μα.σ/α]←μα.σ and Unfold: μα.σ←σ[μα.σ/α], where the composition Unfold or Fold reduces to identity.It is known that systems with iterators can be defined within λ2, by means of beta reductions. We conjecture that systems with recursors can not. In this paper we show that the system λ2U does not have such a property. For this we study the notion of polymorphic type embeddability (via (beta) left-invertible terms) and we show that if a type σ is embedded into another type τ then τ must be of depth at least equal to the depth of σ.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317789", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zdzisław", + "last_name": "Spławski", + "institution": "Wrocław University of Science and Technology" + }, + { + "first_name": "Paweł", + "last_name": "Urzyczyn", + "institution": "" + } + ], + "dblp_key": "conf/icfp/SplawskiU99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317906", + "title": "Flexible Type Analysis", + "abstract": "Run-time type dispatch enables a variety of advanced optimization techniques for polymorphic languages, including tag-free garbage collection, unboxed function arguments, and flattened data structures. However, modern type-preserving compilers transform types between stages of compilation, making type dispatch prohibitively complex at low levels of typed compilation. It is crucial therefore for type analysis at these low levels to refer to the types of previous stages. Unfortunately, no current intermediate language supports this facility.To fill this gap, we present the language LX, which provides a rich language of type constructors supporting type analysis (possibly of previous-stage types) as a programming idiom. This language is quite flexible, supporting a variety of other applications such as analysis of quantified types, analysis with incomplete type information, and type classes. We also show that LX is compatible with a type-erasure semantics.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317906", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/icfp/CraryW99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317779", + "title": "Trampolined Style", + "abstract": "A trampolined program is organized as a single loop in which computations are scheduled and their execution allowed to proceed in discrete steps. Writing programs in trampolined style supports primitives for multithreading without language support for continuations. Various forms of trampolining allow for different degrees of interaction between threads. We present two architectures based on an only mildly intrusive trampolined style. Concurrency can be supported at multiple levels of granularity by performing the trampolining transformation multiple times.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317779", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Steven E.", + "last_name": "Ganz", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/GanzFW99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317788", + "title": "Relating Typability and Expressiveness in Finite-Rank Intersection Type Systems (Extended Abstract)", + "abstract": "We investigate finite-rank intersection type systems, analyzing the complexity of their type inference problems and their relation to the problem of recognizing semantically equivalent terms. Intersection types allow something of type τ1 Λ τ2 to be used in some places at type τ1 and in other places at type τ2. A finite-rank intersection type system bounds how deeply the Λ can appear in type expressions. Such type systems enjoy strong normalization, subject reduction, and computable type inference, and they support a pragmatics for implementing parametric polymorphism. As a consequence, they provide a conceptually simple and tractable alternative to the impredicative polymorphism of System F and its extensions, while typing many more programs than the Hindley-Milner type system found in ML and Haskell.While type inference is computable at every rank, we show that its complexity grows exponentially as rank increases. Let K(0, n) = n and K(t + 1, n) = 2K(t,n); we prove that recognizing the pure λ-terms of size n that are typable at rank k is complete for DTIME[K(k−1, n)]. We then consider the problem of deciding whether two λ-terms typable at rank k have the same normal form, generalizing a well-known result of Statman from simple types to finite-rank intersection types. We show that the equivalence problem is DTIME[K(K(k − 1, n), 2)]-complete. This relationship between the complexity of typability and expressiveness is identical in wellknown decidable type systems such as simple types and Hindley-Milner types, but seems to fail for System F and its generalizations. The correspondence gives rise to a conjecture that if Τ is a predicative type system where typability has complexity t(n) and expressiveness has complexity e(n), then t(n) = Ω(log* e(n)).", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317788", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "A. J.", + "last_name": "Kfoury", + "institution": "" + }, + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + }, + { + "first_name": "Franklyn", + "last_name": "Turbak", + "institution": "Wellesley College" + }, + { + "first_name": "J. B.", + "last_name": "Wells", + "institution": "" + } + ], + "dblp_key": "conf/icfp/KfouryMTW99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317782", + "title": "Tracing Piece by Piece: Affordable Debugging for Lazy Functional Languages", + "abstract": "The advantage of lazy functional languages is that programs may be written declaratively without specifying the exact evaluation order. The ensuing order of evaluation can however be quite involved which makes it difficult to debug such programs using traditional, operational techniques. A solution is to trace the computation in a way which focuses on the declarative aspects and hides irrelevant operational details. The main problem with this approach is the immense cost in time and space of tracing large computations. Dealing with these performance issues is thus the key to practical, general purpose debuggers for lazy functional languages. In this paper we show that computing partial traces on demand by re-executing the traced program is a viable way to overcome these difficulties. This allows any program to be traced using only a fixed amount of extra storage. Since it takes a lot of time to build a complete trace, most of which is wasted since only a fraction of a typical trace is investigated during debugging, partial tracing and repeated re-execution is also attractive from a time perspective. Performance figures are presented to substantiate our claims.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317782", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Henrik", + "last_name": "Nilsson", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Nilsson99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317907", + "title": "Type Inference Builds a Short Cut to Deforestation", + "abstract": "Deforestation optimises a functional program by transforming it into another one that does not create certain intermediate data structures. Short cut deforestation is a deforestation method which is based on a single, local transformation rule. In return, short cut deforestation expects both producer and consumer of the intermediate structure in a certain form. Warm fusion wan proposed to automatically transform functions into this form. Unfortunately, it is costly and hard to implement. Starting from the fact that short cut deforestation is based on a parametricity theorem of the second-order typed λ-calculus, we show how the required form of a list producer can be derived by the use of type inference. Typability for the second-order typed λ-calculus is undecidable. However, we present a linear-time algorithm that solves a partial type inference problem and that, together with controlled inlining and polymorphic type instantiation, suffices for deforestation. The resulting new short cut deforestation algorithm is efficient and removes more intermediate lists than the original.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317907", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olaf", + "last_name": "Chitil", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "conf/icfp/Chitil99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317908", + "title": "Verification of Erlang Programs using Abstract Interpretation and Model Mhecking", + "abstract": "We present an approach for the verification of Erlang programs using abstract interpretation and model checking. In general model checking for temporal logics like LTL and Erlang programs is undecidable. Therefore we define a frame-work for abstract interpretations for a core fragment of Erlang. In this framework it is guaranteed, that the abstract operational semantics preserves all paths of the standard operational semantics. We consider properties that have to hold on all paths of a system, like properties in LTL. If these properties can be proved for the abstract operational semantics, they also hold for the Erlang program. They can be proved with model checking if the abstract operational semantics is a finite transition system. Therefore we introduce a example abstract interpretation, which has this property. We have implemented this approach as a prototype and were able to prove properties like mutual exclusion or the absence of deadlocks and lifelocks for some Erlang programs.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317908", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Frank", + "last_name": "Huch", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "conf/icfp/Huch99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317910", + "title": "Specialization of Inductively Sequential Functional Logic Programs", + "abstract": "Functional logic languages combine the operational principles of the most important declarative programming paradigms, namely functional and logic programming. Inductively sequential programs admit the definition of optimal computation strategies and are the basis of several recent (lazy) functional logic languages. In this paper, we define a partial evaluator for inductively sequential functional logic programs. We prove strong correctness of this partial evaluator and show that the nice properties of inductively sequential programs carry over to the specialization process and the specialized programs. In particular, the structure of the programs is preserved by the specialization process. This is in contrast to other partial evaluation methods for functional logic programs which can destroy the original program structure. Finally, we present some experiments which highlight the practical advantages of our approach.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317910", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marı́a", + "last_name": "Alpuente", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Hanus", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Salvador", + "last_name": "Lucas", + "institution": "" + }, + { + "first_name": "Germán", + "last_name": "Vidal", + "institution": "" + } + ], + "dblp_key": "conf/icfp/AlpuenteHLV99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317775", + "title": "When is a Functional Program Not a Functional Program?", + "abstract": "In an impure functional language, there are programs whose behaviour is completely functional (in that they behave extensionally on inputs), but the functions they compute cannot be written in the purely functional fragment of the language. That is, the class of programs with functional behaviour is more expressive than the usual class of pure functional programs. In this paper we introduce this extended class of \"functional\" programs by means of examples in Standard ML, and explore what they might have to offer to programmers and language implementors.After reviewing some theoretical background, we present some examples of functions of the above kind, and discuss how they may be implemented. We then consider two possible programming applications for these functions: the implementation of a search algorithm, and an algorithm for exact real-number integration. We discuss the advantages and limitations of this style of programming relative to other approaches. We also consider the increased scope for compiler optimizations that these functions would offer.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317775", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John", + "last_name": "Longley", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Longley99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317794", + "title": "Haskell and XML: Generic Combinators or Type-Based Translation?", + "abstract": "We present two complementary approaches to writing XML document-processing applications in a functional language.In the first approach, the generic tree structure of XML documents is used as the basis for the design of a library of combinators for generic processing: selection, generation, and transformation of XML trees.The second approach is to use a type-translation framework for treating XML document type definitions (DTDs) as declarations of algebraic data types, and a derivation of the corresponding functions for reading and writing documents as typed values in Haskell.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317794", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Malcolm", + "last_name": "Wallace", + "institution": "University of York" + }, + { + "first_name": "Colin", + "last_name": "Runciman", + "institution": "University of York" + } + ], + "dblp_key": "conf/icfp/WallaceR99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317785", + "title": "Recursion and Dynamic Data-structures in Bounded Space: Towards Embedded ML Programming", + "abstract": "We present a functional language with a type system such that well typed programs run within stated space-bounds. The language is a strict, first-order variant of ML with constructs for explicit storage management. The type system is a variant of Tofte and Talpin's region inference system to which the notion of sized types, of Hughes, Pareto and Sabry, has been added.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317785", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Lars", + "last_name": "Pareto", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/HughesP99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317796", + "title": "Type Inference with Rank 1 Polymorphism for Type-Directed Compilation of ML", + "abstract": "This paper defines an extended polymorphic type system for an ML-style programming language, and develops a sound and complete type inference algorithm. Different frdm the conventional ML type discipline, the proposed type system allows full rank 1 polymorphism, where polymorphic types can appear in other types such as product types, disjoint union types and range types of function types. Because of this feature, the proposed type system significantly reduces the value-only restriction of polymorphism, which is currently adopted in most of ML-style impure languages. It also serves as a basis for efficient implementation of type-directed compilation of polymorphism. The extended type system achieves more efficient type inference algorithm, and it also contributes to develop more efficient type-passing implementation of polymorphism. We show that the conventional ML polymorphism sometimes introduces exponential overhead both at compile-time elaboration and run-time type-passing execution, and that these problems can be eliminated by our type inference system. Compared with a more powerful rank 2 type inference systems based on semi-unification, the proposed type inference algorithm infers a most general type for any typable expression by using the conventional first-order unification, and it is therefore easily adopted in existing implementation of ML family of languages.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317796", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Kyoto University" + }, + { + "first_name": "Nobuaki", + "last_name": "Yoshida", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/icfp/OhoriY99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317783", + "title": "Atomic Heap Transactions and Fine-grain Interrupts", + "abstract": "Languages such as Java, ML, Scheme, and Haskell provide automatic storage management, that is, garbage collection. The two fundamental operations performed on a garbage-collected heap are \"allocate\" and \"collect.\" Because the heap is in an inconsistent state during these operations, they must be performed atomically. Otherwise, a heap client might access the heap during a time when its fundamental invariants do not hold, corrupting the heap.Standard techniques for providing this atomicity guarantee have large latencies and other performance problems that impede their application in high-performance, interruptladen, thread-based systems applications. In particular, the standard techniques prevent thread schedulers from switching threads on VM page faults.We cast the space of possible implementations into a general taxonomy, and describe a new technique that provides a simple, low-overhead, low-latency interlock. We have implemented this technique in a version of SML/NJ, and, because of its applicability to thread-based systems, are currently implementing it in the scheduler of our raw-hardware SML-based kernel, ML/OS. Our technique can be extended to provide other atomic sequences besides storage allocation.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317783", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "" + }, + { + "first_name": "JAMES W.", + "last_name": "CLARK", + "institution": "" + }, + { + "first_name": "Roland", + "last_name": "McGrath", + "institution": "" + } + ], + "dblp_key": "conf/icfp/ShiversCM99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317777", + "title": "Monadic Encapsulation in ML", + "abstract": "In a programming language with procedures and assignments, it is often important to isolate uses of state to particular program fragments. The frameworks of type, region, and effect inference, and monadic state are technologies that have been used to state and enforce the property that an expression has no visible side-effects. This property has been exploited", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317777", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Miley", + "last_name": "Semmelroth", + "institution": "University of Oregon" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/icfp/SemmelrothS99", + "venue": "icfp", + "year": 1999 + }, + { + "paper_id": "10.1145/317636.317781", + "title": "From Fast Exponentiation to Square Matrices: An Adventure in Types", + "abstract": "Square matrices serve as an interesting case study in functional programming. Common representations, such as lists of lists, are both inefficient---at least for access to individual elements---and error-prone, because the compiler cannot enforce \"squareness\". Switching to a typical balanced-tree representation solves the first problem, but not the second. We develop a representation that solves both problems: it offers logarithmic access to each individual element and it captures the shape invariants in the type, where they can be checked by the compiler. One interesting feature of our solution is that it translates the well-known fast exponentiation algorithm to the level of types. Our implementation also provides a stress test for today's advanced type systems---it uses nested types, polymorphic recursion, higher-order kinds, and rank-2 polymorphism.", + "date": "1999-09-01", + "link": "https://doi.org/10.1145/317636.317781", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chris", + "last_name": "Okasaki", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/icfp/Okasaki99", + "venue": "icfp", + "year": 1999 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2000.json b/data/pl_conferences/icfp/2000.json new file mode 100644 index 0000000..4ca64d4 --- /dev/null +++ b/data/pl_conferences/icfp/2000.json @@ -0,0 +1,628 @@ +[ + { + "paper_id": "10.1145/351240.351266", + "title": "QuickCheck: a lightweight tool for random testing of Haskell programs", + "abstract": "Quick Check is a tool which aids the Haskell programmer in formulating and testing properties of programs. Properties are described as Haskell functions, and can be automatically tested on random input, but it is also possible to define custom test data generators. We present a number of case studies, in which the tool was successfully used, and also point out some pitfalls to avoid. Random testing is especially suitable for functional programs because properties can be stated at a fine grain. When a function is built from separately tested components, then random testing suffices to obtain good coverage of the definition under test.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351266", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/ClaessenH00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351261", + "title": "Recursive subtyping revealed: functional pearl", + "abstract": "Algorithms for checking subtyping between recursive types lie at the core of many programming language implementations. But the fundamental theory of these algorithms and how they relate to simpler declarative specifications is not widely understood, due in part to the difficulty of the available introductions to the area. This tutorial paper offers an \"end-to-end\" introduction to recursive types and subtyping algorithms, from basic theory to efficient implementation, set in the unifying mathematical framework of coinduction.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351261", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Vladimir", + "last_name": "Gapeyev", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Michael Y.", + "last_name": "Levin", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/GapeyevLP00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351267", + "title": "Composing contracts: an adventure in financial engineering, functional pearl", + "abstract": "Financial and insurance contracts do not sound like promising territory for functional programming and formal semantics, but in fact we have discovered that insights from programming languages bear directly on the complex subject of describing and valuing a large class of contracts.We introduce a combinator library that allows us to describe such contracts precisely, and a compositional denotational semantics that says what such contracts are worth. We sketch an implementation of our combinator library in Haskell. Interestingly, lazy evaluation plays a crucial role.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351267", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Jean‐Marc", + "last_name": "Eber", + "institution": "" + }, + { + "first_name": "Julian", + "last_name": "Seward", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/icfp/JonesES00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351265", + "title": "Non-stop Haskell", + "abstract": "We describe an efficient technique for incorporating Baker's incremental garbage collection algorithm into the Spineless Tagless G-machine on stock hardware. This algorithm eliminates the stop/go execution associated with bulk copying collection algorithms, allowing the system to place an upper bound on the pauses due to garbage collection. The technique exploits the fact that objects are always accessed by jumping to code rather than being explicitly dereferenced. It works by modifying the entry code-pointer when an object is in the transient state of being evacuated but not scavenged. An attempt to enter it from the mutator causes the object to \"self-scavenge\" transparently before resetting its entry code pointer. We describe an implementation of the scheme in v4.01 of the Glasgow Haskell Compiler and report performance results obtained by executing a range of applications. These experiments show that the read barrier can be implemented in dynamic dispatching systems such as the STG-machine with very short mutator pause times and with negligible overhead on execution time.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351265", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "A. M.", + "last_name": "Cheadle", + "institution": "Imperial College London" + }, + { + "first_name": "A. J.", + "last_name": "Field", + "institution": "Imperial College London" + }, + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "R. L.", + "last_name": "While", + "institution": "University of Western Australia" + } + ], + "dblp_key": "conf/icfp/CheadleFMJW00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351256", + "title": "An operational semantics for parallel lazy evaluation", + "abstract": "We present an operational semantics for parallel lazy evaluation that accurately models the parallel behaviour of the non-strict parallel functional language GpH. Parallelism is modelled synchronously, that is, single reductions are carried out separately then combined before proceeding to the next set of reductions. Consequently the semantics has two levels, with transition rules for individual threads at one level and combining rules at the other. Each parallel thread is modelled by a binding labelled with an indication of its activity status. To the best of our knowledge this is the first semantics that models such thread states. A set of labelled bindings corresponds to a heap and is used to model sharing.The semantics is set at a higher level of abstraction than an abstract machine and is therefore more manageable for proofs about programs rather than implementations. At the same time, it is sufficiently low level to allow us to reason about programs in terms of parallelism (i.e. the number of processors used) as well as work and run-time with different numbers of processors.The framework used by the semantics is sufficiently flexible and general that it can easily be adapted to express other evaluation models such as sequential call-by-need, speculative evaluation, non-deterministic choice and others.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351256", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Clem", + "last_name": "Baker-Finch", + "institution": "University of Canberra" + }, + { + "first_name": "David J.", + "last_name": "King", + "institution": "Motorola (United Kingdom)" + }, + { + "first_name": "Phil", + "last_name": "Trinder", + "institution": "Heriot-Watt University Malaysia" + } + ], + "dblp_key": "conf/icfp/Baker-FinchKT00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351242", + "title": "Regular expression types for XML", + "abstract": "We propose regular expression types as a foundation for XML processing languages. Regular expression types are a natural generalization of Document Type Definitions (DTDs), describing structures in XML documents using regular expression operators (i.e., *, ?, |, etc.) and supporting a simple but powerful notion of subtyping.The decision problem for the subtype relation is EXPTIME-hard, but it can be checked quite efficiently in many cases of practical interest. The subtyping algorithm developed here is a variant of Aiken and Murphy's set-inclusion constraint solver, to which are added several optimizations and two new properties: (1) our algorithm is provably complete, and (2) it allows a useful \"subtagging\" relation between nodes with different labels in XML trees.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351242", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Haruo", + "last_name": "Hosoya", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jérôme", + "last_name": "Vouillon", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/HosoyaVP00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351262", + "title": "The duality of computation", + "abstract": "We present the μ -calculus, a syntax for λ-calculus + control operators exhibiting symmetries such as program/context and call-by-name/call-by-value. This calculus is derived from implicational Gentzen's sequent calculus LK, a key classical logical system in proof theory. Under the Curry-Howard correspondence between proofs and programs, we can see LK, or more precisely a formulation called LKμ , as a syntax-directed system of simple types for μ -calculus. For μ -calculus, choosing a call-by-name or call-by-value discipline for reduction amounts to choosing one of the two possible symmetric orientations of a critical pair. Our analysis leads us to revisit the question of what is a natural syntax for call-by-value functional computation. We define a translation of λμ-calculus into μ -calculus and two dual translations back to λ-calculus, and we recover known CPS translations by composing these translations.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351262", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pierre-Louis", + "last_name": "Curien", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Hugo", + "last_name": "Herbelin", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/CurienH00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351258", + "title": "Deriving backtracking monad transformers", + "abstract": "In a paper about pretty printing J. Hughes introduced two fundamental techniques for deriving programs from their specification, where a specification consists of a signature and properties that the operations of the signature are required to satisfy. Briefly, the first technique, the term implementation, represents the operations by terms and works by defining a mapping from operations to observations --- this mapping can be seen as defining a simple interpreter. The second, the context-passing implementation, represents operations as functions from their calling context to observations. We apply both techniques to derive a backtracking monad transformer that adds backtracking to an arbitrary monad. In addition to the usual backtracking operations --- failure and nondeterministic choice --- the prolog cut and an operation for delimiting the effect of a cut are supported.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351258", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Bonn" + } + ], + "dblp_key": "conf/icfp/Hinze00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351252", + "title": "Advanced module systems: a guide for the perplexed (abstract of invited talk)", + "abstract": "The past three decades have seen a plethora of language features for large-scale software composition. Some of these are fairly simple, others quite sophisticated. Each embodies an implicit claim that its particular combination of features is both necessary and sufficient for some problem domain. But there have been few attempts to compare module systems, or to explain the practical and theoretical issues that motivate the choices they embody. This can make it difficult to evaluate which features are really needed for a given setting, and which may be overkill.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351252", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/HarperP00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351255", + "title": "Cheap eagerness: speculative evaluation in a lazy functional language", + "abstract": "Cheap eagerness is an optimization where cheap and safe expressions are evaluated before it is known that their values are needed. Many compilers for lazy functional languages implement this optimization, but they are limited by a lack of information about the global flow of control and about which variables are already evaluated. Without this information, even a variable reference is a potentially unsafe expression!In this paper we show that significant speedups are achievable by cheap eagerness. Our cheapness analysis uses the results of a program-wide data and control flow analysis to find out which variables may be unevaluated and which variables may be bound to functions which are dangerous to call.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351255", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl‐Filip", + "last_name": "Faxén", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/icfp/Faxen00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351259", + "title": "Intersection types and computational effects", + "abstract": "We show that standard formulations of intersection type systems are unsound in the presence of computational effects, and propose a solution similar to the value restriction for polymorphism adopted in the revised definition of Standard ML. It differs in that it is not tied to let-expressions and requires an additional weakening of the usual subtyping rules. We also present a bi-directional type-checking algorithm for the resulting language that does not require an excessive amount of type annotations and illustrate it through some examples. We further show that the type assignment system can be extended to incorporate parametric polymorphism. Taken together, we see our system and associated type-checking algorithm as a significant step towards the introduction of intersection types into realistic programming languages. The added expressive power would allow many more properties of programs to be stated by the programmer and statically verified by a compiler.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351259", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Rowan", + "last_name": "Davies", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/DaviesP00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351253", + "title": "Breadth-first numbering: lessons from a small exercise in algorithm design", + "abstract": "Every programmer has blind spots. Breadth-first numbering is an interesting toy problem that exposes a blind spot common to many---perhaps most---functional programmers.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351253", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chris", + "last_name": "Okasaki", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/icfp/Okasaki00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351257", + "title": "Recursive monadic bindings", + "abstract": "Monads have become a popular tool for dealing with computational effects in Haskell for two significant reasons: equational reasoning is retained even in the presence of effects; and program modularity is enhanced by hiding \"plumbing\" issues inside the monadic infrastructure. Unfortunately, not all the facilities provided by the underlying language are readily available for monadic computations. In particular, while recursive monadic computations can be defined directly using Haskell's built-in recursion capabilities, there is no natural way to express recursion over the values of monadic actions. Using examples, we illustrate why this is a problem, and we propose an extension to Haskell's donotation to remedy the situation. It turns out that the structure of monadic value-recursion depends on the structure of the underlying monad. We propose an axiomatization of the recursion operation and provide a catalogue of definitions that satisfy our criteria.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351257", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Levent", + "last_name": "Erkök", + "institution": "Oregon Museum of Science and Industry" + }, + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Oregon Museum of Science and Industry" + } + ], + "dblp_key": "conf/icfp/ErkokL00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351260", + "title": "Syntactic accidents in program analysis: on the impact of the CPS transformation", + "abstract": "We show that a non-duplicating CPS transformation has no effect on control-flow analysis and that it has a positive effect on binding-time analysis: a monovariant control-flow analysis yields equivalent results on a direct-style program and on its CPS counterpart, and a monovariant binding-time analysis yields more precise results on a CPS program than on its direct-style counterpart. Our proof technique amounts to constructing the continuation-passing style (CPS) counterpart of flow information and of binding times.Our results confirm a folklore theorem about binding-time analysis, namely that CPS has a positive effect on binding times. What may be more surprising is that this benefit holds even if contexts or continuations are not duplicated.The present study is symptomatic of an unsettling property of program analyses: their quality is unpredictably vulnerable to syntactic accidents in source programs, i.e., to the way these programs are written. More reliable program analyses require a better understanding of the effect of syntactic change.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351260", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Damian", + "institution": "Aarhus University" + }, + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/icfp/DamianD00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351247", + "title": "Typed compilation of inclusive subtyping", + "abstract": "I present a type-preserving translation that eliminates subtyping and bounded quantification without introducing any run-time costs. This translation is based on Mitchell and Pierce's encoding of bounded quantification using intersection types. I show that, previous negative observations notwithstanding, the encoding is adequate given a sufficiently rich target type theory. The necessary target type theory is made easily typecheckable by including a collection of explicit coercion combinators, which are already desired for eliminating subtyping. However, no form of coercion abstraction is necessary (even to support bounded quantification), leading to a simple target language.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351247", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Crary00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351249", + "title": "More types for nested data parallel programming", + "abstract": "This paper generalises the flattening transformation - a technique for the efficient implementation of nested data parallelism - and reconciles it with main stream functional programming. Nested data parallelism is significantly more expressive and convenient to use than the flat data parallelism typically used in conventional parallel languages like High Performance Fortran and C*. The flattening transformation of Blelloch and Sabot is a key technique for the efficient implementation of nested parallelism via flat parallelism, but originally it was severely restricted, as it did not permit general sum types, recursive types, higher-order functions, and separate compilation. Subsequent work, including some of our own, generalised the transformation and allowed higher-order functions and recursive types. In this paper, we take the final step of generalising flattening to cover the full range of types available in modern languages like Haskell and ML; furthermore, we enable the use of separate compilation. In addition, we present a completely new formulation of the transformation, which is based on the standard lambda calculus notation, and replace a previously ad-hoc transformation step by a systematic generic programming technique. First experiments demonstrate the efficiency of our approach.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351249", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "University of Technology Sydney" + } + ], + "dblp_key": "conf/icfp/ChakravartyK00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351245", + "title": "Information flow inference for free", + "abstract": "This paper shows how to systematically extend an arbitrary type system with dependency information, and how soundness and non-interference proofs for the new system may rely upon, rather than duplicate, the soundness proof of the original system. This allows enriching virtually any of the type systems known today with information flow analysis, while requiring only a minimal proof effort. Our approach is based on an untyped operational semantics for a labelled calculus akin to core ML. Thus, it is simple, and should be applicable to other computing paradigms, such as object or process calculi. The paper also discusses access control, and shows it may be viewed as entirely independent of information flow control. Letting the two mechanisms coexist, without interacting, yields a simple and expressive type system, which allows, in particular, (selective) declassification.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351245", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Sylvain", + "last_name": "Conchon", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/PottierC00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351243", + "title": "The influence of browsers on evaluators or, continuations to program web servers", + "abstract": "While developing the software of a browser-operated educational CD-ROM, we had to face a number of problems. This paper presents these problems and the solutions we found. Amusingly, most of our solutions rely on continuations. Are browsers and multimedia the future of continuations?Through their \"Back\" button or \"Clone window\" menu item, browsers have powerful abilities that force servers to take care of multiply and simultaneously answered questions. A comprehensive tool to apprehend these problems as well as to solve them is to view these abilities as operators acting on the continuations of the computation performed by servers.Thematical trails are provided to walk through the CD-ROM but do not prevent students to wander elsewhere. A trail may contain choices or quizzes so the rest of the trail should adapt to the walked part. We consider the trail as a computation and the position of the student as a continuation within that computation.Moreover this paper advocates a computation-centric view of servers (in opposition to the usual page-centric view) where interactions with users suspend the computation into continuations that may be later resumed. This approach is superior because the continuation reifies, automatically and without errors, the whole state of the computation.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351243", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christian", + "last_name": "Queinnec", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "conf/icfp/Queinnec00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351254", + "title": "Make it practical: a generic linear-time algorithm for solving maximum-weightsum problems", + "abstract": "In this paper we propose a new method for deriving a practical linear-time algorithm from the specification of a maximum-weightsum problem: From the elements of a data structure x, find a subset which satisfies a certain property p and whose weightsum is maximum. Previously proposed methods for automatically generating linear-time algorithms are theoretically appealing, but the algorithms generated are hardly useful in practice due to a huge constant factor for space and time. The key points of our approach are to express the property p by a recursive boolean function over the structure x rather than a usual logical predicate and to apply program transformation techniques to reduce the constant factor. We present an optimization theorem, give a calculational strategy for applying the theorem, and demonstrate the effectiveness of our approach through several nontrivial examples which would be difficult to deal with when using the methods previously available.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351254", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Isao", + "last_name": "Sasano", + "institution": "The University of Tokyo" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Tokyo University of Information Sciences" + }, + { + "first_name": "Masato", + "last_name": "Takeichi", + "institution": "Tokyo University of Information Sciences" + }, + { + "first_name": "Mizuhito", + "last_name": "Ogawa", + "institution": "" + } + ], + "dblp_key": "conf/icfp/SasanoHTO00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351251", + "title": "Functional programming in C++", + "abstract": "This paper describes FC++: a rich library supporting functional programming in C++. Prior approaches to encoding higher order functions in C++ have suffered with respect to polymorphic functions from either lack of expressiveness or high complexity. In contrast, FC++ offers full and concise support for higher-order polymorphic functions through a novel use of C++ type inference.Another new element in FC++ is that it implements a subtype polymorphism policy for functions, in addition to the more common parametric polymorphism facilities. Subtype polymorphism is common in object oriented languages and ensures that functions in FC++ fit well within the C++ object model.Apart from these conceptual differences, FC++ is also an improvement in technical terms over previous efforts in the literature. Our function objects are reference-counted and can be aliased without needing to be copied, resulting in an efficient implementation. The reference-counting mechanism is also exported to the user as a general-purpose replacement of native C++ pointers. Finally, we supply a number of useful functional operators (a large part of the Haskell Standard Prelude) to facilitate programming with FC++. The end result is a library that is usable and efficient, while requiring no extensions to the base C++ language.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351251", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Brian", + "last_name": "McNamara", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/icfp/McNamaraS00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351264", + "title": "Understanding memory allocation of scheme programs", + "abstract": "Memory is the performance bottleneck of modern architectures. Keeping memory consumption as low as possible enables fast and unobtrusive applications. But it is not easy to estimate the memory use of programs implemented in functional languages, due to both the complex translations of some high level constructs, and the use of automatic memory managers.To help understand memory allocation behavior of Scheme programs, we have designed two complementary tools. The first one reports on frequency of allocation, heap configurations and on memory reclamation. The second tracks down memory leaks1. We have applied these tools to our Scheme compiler, the largest Scheme program we have been developing. This has allowed us to drastically reduce the amount of memory consumed during its bootstrap process, without requiring much development time.Development tools will be neglected unless they are both conveniently accessible and easy to use. In order to avoid this pitfall, we have carefully designed the user interface of these two tools. Their integration into a real programming environment for Scheme is detailed in the paper.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351264", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Université Côte d'Azur" + }, + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/icfp/SerranoB00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351250", + "title": "FranTk - a declarative GUI language for Haskell", + "abstract": "FranTk is a new high level library for programming Graphical User Interfaces (GUIs) in Haskell. It is based on Fran (Functional Reactive Animation), and uses the notions of Behaviors and Events to structure code. Behaviors are time-varying, reactive values. They can be used to represent the state of an application. Events are streams of values that occur at discrete points in time. They can be used, for instance, to represent user input. FranTk allows user interfaces to be structured in a more declarative manner than has been possible with previous functional GUI libraries. We demonstrate, through a series of examples, how this is achieved, and why it is important. These examples are elements of a prototype, Air Traffic Control simulator. FranTk uses a binding to the popular Tcl/Tk toolkit to provide a powerful set of platform independent set of widgets. It has been released as a Haskell library that runs under Hugs and GHC.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351250", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Meurig", + "last_name": "Sage", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/icfp/Sage00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351244", + "title": "Static enforcement of security with types", + "abstract": "A number of security systems for programming languages have recently appeared, including systems for enforcing some form of access control. The Java JDK 1.2 security architecture is one such system that is widely studied and used. While the architecture has many appealing features, access control checks are all implemented via dynamic method calls. This is a highly non-declarative form of specification which is hard to read, and which leads to additional run-time overhead. In this paper, we present a novel security type system that enforces the same security guarantees as Java Stack Inspection, but via a static type system with no additional run-time checks. The system allows security properties of programs to be clearly expressed within the types themselves. We also define and prove correct an inference algorithm for security types, meaning that the system has the potential to be layered on top of the existing Java architecture, without requiring new syntax.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351244", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christian", + "last_name": "Skalka", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/icfp/SkalkaS00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351241", + "title": "The functional guts of the Kleisli query system", + "abstract": "Kleisli is a modern data integration system that has made a significant impact on bioinformatics data integration. The primary query language provided by Kleisli is called CPL, which is a functional query language whose surface syntax is based on the comprehension syntax. Kleisli is itself implemented using the functional language SML. This paper describes the influence of functional programming research that benefits the Kleisli system, especially the less obvious ones at the implementation level.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351241", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Limsoon", + "last_name": "Wong", + "institution": "Advanced Digital Sciences Center" + } + ], + "dblp_key": "conf/icfp/Wong00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351246", + "title": "Type-safe cast: functional pearl", + "abstract": "In a language with non-parametric or ad-hoc polymorphism, it is possible to determine the identity of a type variable at run-time. With this facility, we can write a function to convert a term from one abstract type to another, if the two hidden types are identical. However, the naive implementation of this function requires that the term be destructed and rebuilt. In this paper, we show how to eliminate this overhead using higher-order type abstraction. We demonstrate this solution in two frameworks for ad-hoc polymorphism: intensional type analysis and type classes.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351246", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/icfp/Weirich00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351263", + "title": "Combining functional programming and hardware verification (abstract of invited talk)", + "abstract": "No abstract available.", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351263", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Carl", + "last_name": "Seger", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/icfp/Seger00", + "venue": "icfp", + "year": 2000 + }, + { + "paper_id": "10.1145/351240.351248", + "title": "Fully reflexive intensional type analysis", + "abstract": "Compilers for polymorphic languages can use runtime type inspection to support advanced implementation techniques such as tagless garbage collection, polymorphic marshalling, and flattened data structures. Intensional type analysis is a type-theoretic framework for expressing and certifying such type-analyzing computations. Unfortunately, existing approaches to intensional analysis do not work well on types with universal, existential, or fixpoint quantifiers. This makes it impossible to code applications such as garbage collection, persistence, or marshalling which must be able to examine the type of any runtime value. We present a typed intermediate language that supports fully reflexive intensional type analysis. By fully reflexive, we mean that type-analyzing operations are applicable to the type of any runtime value in the language. In particular, we provide both type-level and term-level constructs for analyzing quantified types. Our system supports structural induction on quant...", + "date": "2000-09-01", + "link": "https://doi.org/10.1145/351240.351248", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Valery", + "last_name": "Trifonov", + "institution": "Yale University" + }, + { + "first_name": "Bratin", + "last_name": "Saha", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/TrifonovSS00", + "venue": "icfp", + "year": 2000 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2001.json b/data/pl_conferences/icfp/2001.json new file mode 100644 index 0000000..21b8e06 --- /dev/null +++ b/data/pl_conferences/icfp/2001.json @@ -0,0 +1,534 @@ +[ + { + "paper_id": "10.1145/507635.507661", + "title": "Functional Array Fusion", + "abstract": "This paper introduces a new approach to optimizing array algorithms in functional languages. We are specifically aiming at an efficient implementation of irregular array algorithms that are hard to implement in conventional array languages such as Fortran. We optimize the storage layout of arrays containing complex data structures and reduce the running time of functions operating on these arrays by means of equational program transformations. In particular, this paper discusses a novel form of combinator loop fusion, which by removing intermediate structures optimizes the use of the memory hierarchy. We identify a combinator named loop P that provides a general scheme for iterating over an array and that in conjunction with an array constructor replicate P is sufficient to express a wide range of array algorithms. On this basis, we define equational transformation rules that combine traversals of loop P and replicate P as well as sequences of applications of loop P into a single loop P traversal. Our approach naturally generalizes to a parallel implementation and includes facilities for optimizing load balancing and communication. A prototype implementation based on the rewrite rule pragma of the Glasgow Haskell Compiler is significantly faster than standard Haskell arrays and approaches the speed of hand coded C for simple examples.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507661", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/icfp/ChakravartyK01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507659", + "title": "Compositional Explanation of Types and Algorithmic Debugging of Type Errors", + "abstract": "The type systems of most typed functional programming languages are based on the Hindley-Milner type system. A practical problem with these type systems is that it is often hard to understand why a program is not type correct or a function does not have the intended type. We suggest that at the core of this problem is the difficulty of explaining why a given expression has a certain type. The type system is not defined compositionally. We propose to explain types using a variant of the Hindley-Milner type system that defines a compositional type explanation graph of principal typing. We describe how the programmer understands types by interactive navigation through the explanation graph. Furthermore, the explanation graph can be the foundation for algorithmic debugging of type errors, that is, semi-automatic localisation of the source of a type error without even having to understand the type inference steps. We implemented a prototype of a tool to explore the usefulness of the proposed methods.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507659", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olaf", + "last_name": "Chitil", + "institution": "University of York" + } + ], + "dblp_key": "conf/icfp/Chitil01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507640", + "title": "Functioning without Closure: Type-Safe Customized Function Representations for Standard ML", + "abstract": "The CIL compiler for core Standard ML compiles whole ML programs using a novel typed intermediate language that supports the generation of type-safe customized data representations. In this paper, we present empirical data comparing the relative efficacy of several different flow-based customization strategies for function representations. We develop a cost model to interpret dynamic counts of operations required for each strategy. In this cost model, customizing the representation of closed functions gives a 12-17% improvement on average over uniform closure representations, depending on the layout of the closure. We also present data on the relative effectiveness of various strategies for reducing representation pollution, i.e., situations where flow constraints require the representation of a value to be less efficient than it would be in ideal circumstances. For the benchmarks tested and the types of representation pollution detected by our compiler, the pollution removal strategies we consider often cost more in overhead than they gain via enabled customizations. Notable exceptions are selective defunctionalization, a function representation strategy that often achieves significant customization benefits via aggressive pollution removal, and a simple form of flow-directed inlining, in which pollution removal allows multiple functions to be inlined at the same call site.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507640", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Allyn", + "last_name": "Dimock", + "institution": "Harvard University Press" + }, + { + "first_name": "Ian", + "last_name": "Westmacott", + "institution": "" + }, + { + "first_name": "Robert", + "last_name": "Muller", + "institution": "Boston College" + }, + { + "first_name": "Franklyn", + "last_name": "Turbak", + "institution": "Wellesley College" + }, + { + "first_name": "J. B.", + "last_name": "Wells", + "institution": "" + } + ], + "dblp_key": "conf/icfp/DimockWMTW01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507664", + "title": "A New Notation for Arrows", + "abstract": "The categorical notion of monad, used by Moggi to structure denotational descriptions, has proved to be a powerful tool for structuring combinator libraries. Moreover, the monadic programming style provides a convenient syntax for many kinds of computation, so that each library defines a new sublanguage. Recently, several workers have proposed a generalization of monads, called variously \"arrows\" or Freyd-categories. The extra generality promises to increase the power, expressiveness and efficiency of the embedded approach, but does not mesh as well with the native abstraction and application. Definitions are typically given in a point-free style, which is useful for proving general properties, but can be awkward for programming specific instances. In this paper we define a simple extension to the functional language Haskell that makes these new notions of computation more convenient to use. Our language is similar to the monadic style, and has similar reasoning properties. Moreover, it is extensible, in the sense that new combining forms can be defined as expressions in the host language.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507664", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ross", + "last_name": "Paterson", + "institution": "City, University of London" + } + ], + "dblp_key": "conf/icfp/Paterson01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507662", + "title": "Automatic Generation of Staged Geometric Predicates", + "abstract": "Algorithms in Computational Geometry and Computer Aided Design are often developed for the Real RAM model of computation, which assumes exactness of all the input arguments and operations. In practice, however, the exactness imposes tremendous limitations on the algorithms --- even the basic operations become uncomputable, or prohibitively slow. When the computations of interest are limited to determining the sign of polynomial expressions over floating point numbers, faster approaches are available. One can evaluate the polynomial in floating-point first, together with some estimate of the rounding error, and fall back to exact arithmetic only if this error is too big to determine the sign reliably. A particularly efficient variation on this approach has been used by Shewchuk in his robust implementations of Orient and InSphere geometric predicates. We extend Shewchuk's method to arbitrary polynomial expressions. The expressions are given as programs in a suitable source language featuring basic arithmetic operations of addition, subtraction, multiplication and squaring, which are to be perceived by the programmer as exact. The source language also allows for anonymous functions, and thus enables the common functional programming technique of staging. The method is presented formally through several judgments that govern the compilation of the source expression into target code, which is then easily transformed into SML or, in case of single-stage expressions, into C.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507662", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/NanevskiBH01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507646", + "title": "Macros as Multi-Stage Computations: Type-Safe, Generative, Binding Macros in MacroML", + "abstract": "With few exceptions, macros have traditionally been viewed as operations on syntax trees or even on plain strings. This view makes macros seem ad hoc, and is at odds with two desirable features of contemporary typed functional languages: static typing and static scoping. At a deeper level, there is a need for a simple, usable semantics for macros. This paper argues that these problems can be addressed by formally viewing macros as multi-stage computations. This view eliminates the need for freshness conditions and tests on variable names, and provides a compositional interpretation that can serve as a basis for designing a sound type system for languages supporting macros, or even for compilation. To illustrate our approach, we develop and present MacroML, an extension of ML that supports inlining, recursive macros, and the definition of new binding constructs. The latter is subtle, and is the most novel addition in a statically typed setting. The semantics of a core subset of MacroML is given by an interpretation into MetaML, a statically-typed multi-stage programming language. It is then easy to show that MacroML is stage- and type-safe: macro expansion does not depend on runtime evaluation, and both stages do not \"go wrong.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507646", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Steven E.", + "last_name": "Ganz", + "institution": "" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "" + }, + { + "first_name": "Walid", + "last_name": "Taha", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/GanzST01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507641", + "title": "Optimizing Pattern Matching", + "abstract": "We present improvements to the backtracking technique of pattern-matching compilation. Several optimizations are introduced, such as commutation of patterns, use of exhaustiveness information, and control flow optimization through the use of labeled static exceptions and context information. These optimizations have been integrated in the Objective-Caml compiler. They have shown good results in increasing the speed of pattern-matching intensive programs, without increasing final code size.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507641", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Fabrice Le", + "last_name": "Fessant", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/FessantM01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507666", + "title": "Cost Recurrences for DML Programs", + "abstract": "A cost recurrence describes an upper bound for the running time of a program in terms of the size of its input. Finding cost recurrences is a frequent intermediate step in complexity analysis, and this step requires an abstraction from data to data size. In this article, we use information contained in dependent types to achieve such an abstraction: Dependent ML (DML), a conservative extension of ML, provides dependent types that can be used to associate data with size information, thus describing a possible abstraction. We automatically extract cost recurrences from first-order DML programs, guiding the abstraction from data to data size with information contained in DML type derivations.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507666", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bernd", + "last_name": "Grobauer", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/icfp/Grobauer01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507642", + "title": "Down with Emacs Lisp: Dynamic Scope Analysis", + "abstract": "It is possible to translate code written in Emacs Lisp or another Lisp dialect which uses dynamic scoping to a more modern programming language with lexical scoping while largely preserving structure and readability of the code. The biggest obstacle to such an idiomatic translation from Emacs Lisp is the translation of dynamic binding into suitable instances of lexical binding: Many binding constructs in real programs in fact exhibit identical behavior under both dynamic and lexical binding. An idiomatic translation needs to detect as many of these binding constructs as possible and convert them into lexical binding constructs in the target language to achieve readability and efficiency of the target code. The basic prerequisite for such an idiomatic translation is thus a dynamic scope analysis which associates variable occurrences with binding constructs. We present such an analysis. It is an application of the Nielson/Nielson framework for flow analysis to a semantics for dynamic binding akin to Moreau's. Its implementation handles a substantial portion of Emacs Lisp, has been applied to realistic Emacs Lisp code, and is highly accurate and reasonably efficient in practice.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507642", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Neubauer", + "institution": "University of Freiburg" + }, + { + "first_name": "Michael", + "last_name": "Sperber", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/icfp/NeubauerS01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507645", + "title": "Type-Based Hot Swapping of Running Modules", + "abstract": "While dynamic linking has become an integral part of the run-time execution of modem programming languages, there is increasing recognition of the need for support for hot swapping of running modules, particularly in long-lived server applications. The interesting challenge for such a facility is to allow the new module to change the types exported by the original module, while preserving type safety. This paper describes a type-based approach to hot swapping running modules. The approach is based on a reflective mechanism for dynamically adding type sharing constraints to the type system, realized by programmer-defined version adapters in the run-time.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507645", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dominic", + "last_name": "Duggan", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "conf/icfp/Duggan01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507650", + "title": "A Simple Implementation Technique for Priority Search Queues", + "abstract": "This paper presents a new implementation technique for priority search queues. This abstract data type is an amazing blend of finite maps and priority queues. Our implementation supports logarithmic access to a binding with a given key and constant access to a binding with the minimum value. Priority search queues can be used, for instance, to give a simple, purely functional implementation of Dijkstra's single-source shortest-paths algorithm. A non-technical concern of the paper is to foster abstract data types and views. Priority search queues have been largely ignored by the functional programming community and we believe that they deserve to be known better. Views prove their worth both in defining a convenient interface to the abstract data type and in providing a readable implementation.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507650", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/Hinze01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507639", + "title": "Contification Using Dominators", + "abstract": "Contification is a compiler optimization that turns a function that always returns to the same place into a continuation. Compilers for functional languages use contification to expose the control-flow information that is required by many optimizations, including traditional loop optimizations. This paper gives a formal presentation of contification in MLton, a whole-program optimizing Standard ML compiler. We present two existing algorithms for contification in our framework, as well as a new algorithm based on the dominator tree of a program's call graph. We prove that the dominator algorithm is optimal. We present benchmark results on realistic SML programs demonstrating that contification has minimal overhead on compile time and significantly improves run time.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507639", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Cornell University" + }, + { + "first_name": "Stephen", + "last_name": "Weeks", + "institution": "" + } + ], + "dblp_key": "conf/icfp/FluetW01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507653", + "title": "Charting Patterns on Price History", + "abstract": "It is an established notion among financial analysts that price moves in patterns and these patterns can be used to forecast future price. As the definitions of these patterns are often subjective, every analyst has a need to define and search meaningful patterns from historical time series quickly and efficiently. However, such discovery process can be extremely laborious and technically challenging in the absence of a high level pattern definition language. In this paper, we propose a chart-pattern language (CPL for short) to facilitate pattern discovery process. Our language enables financial analysts to (1) define patterns with subjective criteria, through introduction of fuzzy constraints, and (2) incrementally compose complex patterns from simpler patterns. We demonstrate through an array of examples how real life patterns can be expressed in CPL. In short, CPL provides a high-level platform upon which analysts can define and search patterns easily and without any programming expertise. CPL is a domain-specific language embedded in Haskell. We show how various features of a functional language, such as pattern matching, higher-order functions, lazy evaluation, facilitate pattern definitions and implementation. Furthermore, Haskell&apos;s type system frees the programmers from annotating the programs with types.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507653", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Saswat", + "last_name": "Anand", + "institution": "National University of Singapore" + }, + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + }, + { + "first_name": "Siau‐Cheng", + "last_name": "Khoo", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/icfp/AnandCK01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507649", + "title": "Generic Validation of Structural Content with Parametric Modules", + "abstract": "In this paper, we demonstrate a natural mapping from element types of XML to module expressions of ML-like programming languages. The mapping is inductive, and the definitions of common XML operations can be derived as the module expressions are constructed. We show how to derive, in a generic way, the validation function, which checks an XML document for conformance to the content model specified by its DTD (Document Type Definition). One can view the validation function as giving types to XML elements, and the validation procedure a pre-requirement for typeful XML programming in ML.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507649", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tyng–Ruey", + "last_name": "Chuang", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Chuang01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507637", + "title": "A Fresh Approach to Representing Syntax with Static Binders in Functional Programming", + "abstract": "Tell category theorists about the concept of abstract syntax for a language and they may say \"that's just the initial algebra for a sum-of-products functor on the category of sets\". Despite what you might think, they are trying to be helpful since the initiality property is the common denominator of both definitions by structural recursion and proofs by structural induction [5, Sect. 4.4]. In recent years we have learned how to extend this initial algebra view of abstract syntax to encompass languages with statically scoped binders. In the presence of such binders one wants to abstract away from the specific names of bound variables, either by quotienting parse trees by a suitable notion of alpha-equivalence, or by replacing conventional trees with ones containing de Bruijn indices [1]. By changing from the category of sets to other well-known, but still 'set-like' categories of sheaves or presheaves, one can regain an initial algebra view of this even more than normally abstract syntax---the pay-off being new and automatically generated forms of structural recursion and induction that respect alpha-equivalence [2, 3]. One good test of these new ideas is to see if they give rise to new forms of functional programming. In fact they do. The paper [6] sketches a functional programming language for representing and manipulating syntactical structure involving binders, based on the mathematical model of variable-binding in [3, 4]. In this ML-like language there are new forms of type for names and name-binding that come along with facilities for declaring fresh names, for binding names in abstractions and for pulling apart such name-abstractions via pattern-matching. The key idea is that properly abstract uses of names, i.e. ones that do not descend below the level of alpha-conversion, can be imposed on the user by a static type system that deduces information about the freshness of names. Even though we appear to be giving users a 'gensym' facility, the type system restricts the way it can be used to the extent that we keep within effect-free functional programming, in the sense that the usual laws of pure functional programming remain valid (augmented with new laws for names and name-abstractions). In this talk I will introduce this new approach to representing languages static binders in functional programming and discuss some of the difficulties we have had verifying its semantic properties.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507637", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrew M.", + "last_name": "Pitts", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/Pitts01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507667", + "title": "Possibilities and Limitations of Call-by-Need Space Improvement", + "abstract": "Innocent-looking program transformations can easily change the space complexity of lazy functional programs. The theory of space improvement seeks to characterize those local program transformations which are guaranteed never to worsen asymptotic space complexity of any program. Previous work by the authors introduced the space improvement relation and showed that a number of simple local transformation laws are indeed space improvements. This paper seeks an answer to the following questions: is the improvement relation inhabited by interesting program transformations, and, if so, how might they be established? We show that the asymptotic space improvement relation is semantically badly behaved, but that the theory of strong space improvement possesses a fixed-point induction theorem which permits the derivation of improvement properties for recursive definitions. With the help of this tool we explore the landscape of space improvement by considering a range of classical program transformation.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507667", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jörgen", + "last_name": "Gustavsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "David", + "last_name": "Sands", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/GustavssonS01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507644", + "title": "Recursive Structures for Standard ML", + "abstract": "Standard ML is a statically typed programming language that is suited for the construction of both small and large programs. \"Programming in the small\" is captured by Standard ML's Core language. \"Programming in the large\" is captured by Standard ML's Modules language that provides constructs for organizing related Core language definitions into self-contained modules with descriptive interfaces. While the Core is used to express details of algorithms and data structures, Modules is used to express the overall architecture of a software system. In Standard ML, modular programs must have a strictly hierarchical structure: the dependency between modules can never be cyclic. In particular, definitions of mutually recursive Core types and values, that arise frequently in practice, can never span module boundaries. This limitation compromises modular programming, forcing the programmer to merge conceptually (i.e. architecturally) distinct modules. We propose a practical and simple extension of the Modules language that caters for cyclic dependencies between both types and terms defined in separate modules. Our design leverages existing features of the language, supports separate compilation of mutually recursive modules and is easy to implement.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507644", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Claudio", + "last_name": "Russo", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/Russo01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507648", + "title": "Generic Unification via Two-Level Types and Parameterized Modules", + "abstract": "As a functional pearl, we describe an efficient, modularized implementation of unification using the state of mutable reference cells to encode substitutions. We abstract our algorithms along two dimensions, first abstracting away from the structure of the terms to be unified, and second over the monad in which the mutable state is encapsulated. We choose this example to illustrate two important techniques that we believe many functional programmers would find useful. The first of these is the definition of recursive data types using two levels: a structure defining level, and a recursive knot-tying level. The second is the use of rank-2 polymorphism inside Haskell's record types to implement a form of type parameterized modules.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507648", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Oregon Research Institute" + } + ], + "dblp_key": "conf/icfp/Sheard01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507655", + "title": "Events in Haskell, and How to Implement Them", + "abstract": "We describe a new and simpler implementation in Haskell of CML's events, which encode reactions by a thread to combinations of messages from other threads. We add a new type of Guarded Events, by which recipients can filter messages with conditions on their value known as Guards. We implement guarded channels. The guard type and the indexing algorithm are not part of the channel definition, so that the user can trade off what guards are required against the cost of indexing. As an example we sketch the encapsulation of a graphical user interface toolkit. This can be done concisely not only because of guarded events, but also because we construct events monadically. Monadic events are especially helpful for representing concurrent processes which transform themselves in reaction to external communications.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507655", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "George", + "last_name": "Russell", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Russell01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507654", + "title": "Real-Time FRP", + "abstract": "Functional reactive programming (FRP) is a declarative programming paradigm where the basic notions are continuous, time-varying behaviors and discrete, event-based reactivity. FRP has been used successfully in many reactive programming domains such as animation, robotics, and graphical user interfaces. The success of FRP in these domains encourages us to consider its use in real-time applications, where it is crucial that the cost of running a program be bounded and known before run-time. But previous work on the semantics and implementation of FRP was not explicitly concerned about the issues of cost. In fact, the resource consumption of FRP programs in the current implementation is often hard to predict. As a first step towards addressing these concerns, this paper presents real-time FRP (RT-FRP), a statically-typed language where the time and space cost of each execution step for a given program is statically bounded. To take advantage of existing work on languages with bounded resources, we split RT-FRP into two parts: a reactive part that captures the essential ingredients of FRP programs, and a base language part that can be instantiated to any generic programming language that has been shown to be terminating and resource-bounded. This allows us to focus on the issues specific to RT-FRP, namely, two forms of recursion. After presenting the operational explanation of what can go wrong due to the presence of recursion, we show how the typed version of the language is terminating and resource-bounded. Most of our FRP programs are expressible directly in RT. The rest are expressible via a simple mechanism that integrates RT-FRP with the base language.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507654", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhanyong", + "last_name": "Wan", + "institution": "Yale University" + }, + { + "first_name": "Walid", + "last_name": "Taha", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/WanTH01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507652", + "title": "Developing a Stage Lighting System from Scratch", + "abstract": "Lula is a system for computer-assisted stage lighting design and control. Whereas other systems for the same purpose are usually the results of long chains of incremental improvements of historic concepts, Lula represents a complete redesign. Whereas other systems focus on control aspects of lighting, Lula focuses on design and generates control information from it. This approach gives significantly more flexibility to the lighting designer and shortens the design process itself. Lula's design and implementation draw from a number of disciplines in advanced programming. It is written in Scheme and runs atop PLT Scheme, and benefits from its high-level GUI library. Lula uses an algebraic model for lighting looks based on just three combinators. It employs Functional Reactive Programming for all dynamic aspects of lighting, and is programmable via a functional reactive domain-specific language. Lula is an actual product and has users who have neither interest in nor knowledge of functional programming.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507652", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael", + "last_name": "Sperber", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/icfp/Sperber01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507658", + "title": "On Regions and Linear Types", + "abstract": "We explore how two different mechanisms for reasoning about state, linear typing and the type, region and effect discipline, complement one another in the design of a strongly typed functional programming language. The basis for our language is a simple lambda calculus containing first-class memory regions, which are explicitly passed as arguments to functions, returned as results and stored in user-defined data structures. In order to ensure appropriate memory safety properties, we draw upon the literature on linear type systems to help control access to and deallocation of regions. In fact, we use two different interpretations of linear types, one in which multiple-use values are freely copied and discarded and one in which multiple-use values are explicitly reference-counted, and show that both interpretations give rise to interesting invariants for manipulating regions. We also explore new programming paradigms that arise by mixing first-class regions and conventional linear data structures.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507658", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Walker", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kevin", + "last_name": "Watkins", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/WalkerW01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507657", + "title": "A Dependently Typed Assembly Language", + "abstract": "We present a dependently typed assembly language (DTAL) in which the type system supports the use of a restricted form of dependent types, reaping some benefits of dependent types at the assembly level. DTAL improves upon TAL , enabling certain important compiler optimizations such as run-time array bound check elimination and tag check elimination. Also, DTAL formally addresses the issue of representing sum types at assembly level, making it suitable for handling not only datatypes in ML but also dependent datatypes in Dependent ML (DML).", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507657", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Hongwei", + "last_name": "Xi", + "institution": "University of Cincinnati" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/XiH01", + "venue": "icfp", + "year": 2001 + }, + { + "paper_id": "10.1145/507635.507665", + "title": "Extensible Algebraic Datatypes with Defaults", + "abstract": "A major problem for writing extensible software arises when recursively defined datatypes and operations on these types have to be extended simultaneously without modifying existing code. This paper introduces Extensible Algebraic Datatypes with defaults, which promote a simple programming pattern to solve this well-known problem. We show that it is possible to encode extensible algebraic datatypes in an object-oriented language, using a new design pattern for extensible visitors. Extensible algebraic datatypes have been successfully applied in the implementation of an extensible Java compiler. Our technique allows for the reuse of existing components in compiler extensions without the need for any adaptations.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/507635.507665", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Zenger", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/icfp/ZengerO01", + "venue": "icfp", + "year": 2001 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2002.json b/data/pl_conferences/icfp/2002.json new file mode 100644 index 0000000..c4a3f2e --- /dev/null +++ b/data/pl_conferences/icfp/2002.json @@ -0,0 +1,593 @@ +[ + { + "paper_id": "10.1145/581478.581504", + "title": "Final shift for call/cc: : direct implementation of shift and reset", + "abstract": "We present a direct implementation of the shift and reset control operators in the SFE system. The new implementation improves upon the traditional technique of simulating shift and reset via callcc. Typical applications of these operators exhibit space savings and a significant overall performance gain. Our technique is based upon the popular incremental stack/heap strategy for representing continuations. We present implementation details as well as some benchmark measurements for typical applications.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581504", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Gasbichler", + "institution": "University of Tübingen" + }, + { + "first_name": "Michael", + "last_name": "Sperber", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/icfp/GasbichlerS02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581493", + "title": "Interactive visual functional programming", + "abstract": "An interactive graphical environment for supporting the development and use of Haskell applications programs is described. The environment, named Vital, is particularly intended for supporting the open-ended, incremental development style often preferred by non-specialist users in which successive steps of program development are motivated and informed by results so far obtained.Significant features of Vital include: the graphical display of data structures in a format defined by a datatype-indexed stylesheet, the way that evaluation of (possibly infinite) values is demand-driven by the action of the user scrolling around an unbounded workspace, and support for copy-and-paste graphical editing of data structures. This latter allows, for example, the user to modify a complex data structure by point-and-click operations, or to create (by functional evaluation) a regular data structure and then edit values or expressions into it. The effect of each editing operation is immediately reflected in the Haskell program source code.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581493", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Keith", + "last_name": "Hanna", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/icfp/Hanna02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581482", + "title": "Monads for incremental computing", + "abstract": "This paper presents a monadic approach to incremental computation, suitable for purely functional languages such as Haskell. A program that uses incremental computation is able to perform an incremental amount of computation to accommodate for changes in input data. Recently, Acar, Blelloch and Harper presented a small Standard ML library that supports efficient, high-level incremental computations [1]. Here, we present a monadic variant of that library, written in Haskell extended with first-class references. By using monads, not only are we able to provide a purely functional interface to the library, the types also enforce \"correct usage\" without having to resort to any type-system extension. We also find optimization opportunities based on standard monadic combinators.This is an exercise in putting to work monad transformers with environments, references, and continuations.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581482", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Carlsson", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "conf/icfp/Carlsson02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581486", + "title": "Composable and compilable macros: : you want it when?", + "abstract": "Many macro systems, especially for Lisp and Scheme, allow macro transformers to perform general computation. Moreover, the language for implementing compile-time macro transformers is usually the same as the language for implementing run-time functions. As a side effect of this sharing, implementations tend to allow the mingling of compile-time values and run-time values, as well as values from separate compilations. Such mingling breaks programming tools that must parse code without executing it. Macro implementors avoid harmful mingling by obeying certain macro-definition protocols and by inserting phase-distinguishing annotations into the code. However, the annotations are fragile, the protocols are not enforced, and programmers can only reason about the result in terms of the compiler's implementation. MzScheme---the language of the PLT Scheme tool suite---addresses the problem through a macro system that separates compilation without sacrificing the expressiveness of macros.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581486", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/icfp/Flatt02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581488", + "title": "Exception analysis for non-strict languages", + "abstract": "In this paper we present the first exception analysis for a non-strict language. We augment a simply-typed functional language with exceptions, and show that we can define a type-based inference system to detect uncaught exceptions. We have implemented this exception analysis in the GHC compiler for Haskell, which has been recently extended with exceptions. We give empirical evidence that the analysis is practical.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581488", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Glynn", + "institution": "UCLouvain" + }, + { + "first_name": "Peter J.", + "last_name": "Stuckey", + "institution": "University of Melbourne" + }, + { + "first_name": "Martin", + "last_name": "Sulzmann", + "institution": "National University of Singapore" + }, + { + "first_name": "Harald", + "last_name": "Søndergaard", + "institution": "University of Melbourne" + } + ], + "dblp_key": "conf/icfp/GlynnSSS02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581483", + "title": "Packrat parsing: : simple, powerful, lazy, linear time, functional pearl", + "abstract": "Packrat parsing is a novel technique for implementing parsers in a lazy functional programming language. A packrat parser provides the power and flexibility of top-down parsing with backtracking and unlimited lookahead, but nevertheless guarantees linear parse time. Any language defined by an LL(k) or LR(k) grammar can be recognized by a packrat parser, in addition to many languages that conventional linear-time algorithms do not support. This additional power simplifies the handling of common syntactic idioms such as the widespread but troublesome longest-match rule, enables the use of sophisticated disambiguation strategies such as syntactic and semantic predicates, provides better grammar composition properties, and allows lexical analysis to be integrated seamlessly into parsing. Yet despite its power, packrat parsing shares the same simplicity and elegance as recursive descent parsing; in fact converting a backtracking recursive descent parser into a linear-time packrat parser often involves only a fairly straightforward structural change. This paper describes packrat parsing informally with emphasis on its use in practical applications, and explores its advantages and disadvantages with respect to the more conventional alternatives.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581483", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bryan", + "last_name": "Ford", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/icfp/Ford02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581502", + "title": "An experimental study of renewal-older-first garbage collection", + "abstract": "Generational collection has improved the efficiency of garbage collection in fast-allocating programs by focusing on collecting young garbage, but has done little to reduce the cost of collecting a heap containing large amounts of older data. A new generational technique, older-first collection, shows promise in its ability to manage older data.This paper reports on an implementation study that compared two older-first collectors to traditional (younger-first) generational collectors. One of the older-first collectors performed well and was often effective at reducing the first-order cost of collection relative to younger-first collectors. Older-first collectors perform especially well when objects have queue-like or random lifetimes.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581502", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lars T.", + "last_name": "Hansen", + "institution": "Opera Software (Norway)" + }, + { + "first_name": "William", + "last_name": "Clinger", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/HansenC02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581492", + "title": "Composing monads using coproducts", + "abstract": "Monads are a useful abstraction of computation, as they model diverse computational effects such as stateful computations, exceptions and I/O in a uniform manner. Their potential to provide both a modular semantics and a modular programming style was soon recognised. However, in general, monads proved difficult to compose and so research focused on special mechanisms for their composition such as distributive monads and monad transformers.We present a new approach to this problem which is general in that nearly all monads compose, mathematically elegant in using the standard categorical tools underpinning monads and computationally expressive in supporting a canonical recursion operator. In a nutshell, we propose that two monads should be composed by taking their coproduct. Although abstractly this is a simple idea, the actual construction of the coproduct of two monads is non-trivial. We outline this construction, show how to implement the coproduct within Haskell and demonstrate its usage with a few examples. We also discuss its relationship with other ways of combining monads, in particular distributive laws for monads and monad transformers.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581492", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christoph", + "last_name": "Lüth", + "institution": "University of Bremen" + }, + { + "first_name": "Neil", + "last_name": "Ghani", + "institution": "University of Leicester" + } + ], + "dblp_key": "conf/icfp/LuthG02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581480", + "title": "Bootstrapping one-sided flexible arrays", + "abstract": "The abstract data type one-sided flexible array, also called random-access list, supports look-up and update of elements and can grow and shrink at one end. We describe a purely functional implementation based on weight-balanced multiway trees that is both simple and versatile. A novel feature of the representation is that the running time of the operations can be tailored to one's needs---even dynamically at array-creation time. In particular, one can trade the running time of look-up operations for the running time of update operations. For instance, if the multiway trees have a fixed degree, the operations take θ(log n) time, where n is the size of the flexible array. If the degree doubles levelwise, look-up speeds up to θ(sqrtlog n) while update slows down to θ(2sqrt log n). We show that different tree shapes can be conveniently modelled after mixed-radix number systems.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581480", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Bonn" + } + ], + "dblp_key": "conf/icfp/Hinze02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581500", + "title": "There and back again", + "abstract": "We present a programming pattern where a recursive function traverses a data structure---typically a list---at return time. The idea is that the recursive calls get us there (typically to a base case) and the returns get us back again while traversing the data structure. We name this programming pattern of traversing a data structure at return time \"There And Back Again\" (TABA).The TABA pattern directly applies to computing a symbolic convolution. It also synergizes well with other programming patterns, e.g., dynamic programming and traversing a list at double speed. We illustrate TABA and dynamic programming with Catalan numbers. We illustrate TABA and traversing a list at double speed with palindromes and we obtain a novel solution to this traditional exercise.A TABA-based function written in direct style makes full use of an Algol-like control stack and needs no heap allocation. Conversely, in a TABA-based function written in continuation-passing style, the continuation acts as a list iterator. In general, the TABA pattern saves one from constructing intermediate lists in reverse order.", + "date": "2001-10-04", + "link": "https://doi.org/10.1145/581478.581500", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Aarhus University" + }, + { + "first_name": "Mayer", + "last_name": "Goldberg", + "institution": "Ben-Gurion University of the Negev" + } + ], + "dblp_key": "conf/icfp/DanvyG02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581501", + "title": "A compiled implementation of strong reduction", + "abstract": "Motivated by applications to proof assistants based on dependent types, we develop and prove correct a strong reducer and ß-equivalence checker for the λ-calculus with products, sums, and guarded fixpoints. Our approach is based on compilation to the bytecode of an abstract machine performing weak reductions on non-closed terms, derived with minimal modifications from the ZAM machine used in the Objective Caml bytecode interpreter, and complemented by a recursive \"read back\" procedure. An implementation in the Coq proof assistant demonstrates important speed-ups compared with the original interpreter-based implementation of strong reduction in Coq.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581501", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/GregoireL02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581487", + "title": "A demand-driven adaptive type analysis", + "abstract": "Compilers for dynamically and statically typed languages ensure safe execution by verifying that all operations are performed on appropriate values. An operation as simple as car in Scheme and hd in SML will include a run time check unless the compiler can prove that the argument is always a non-empty list using some type analysis. We present a demand-driven type analysis that can adapt the precision of the analysis to various parts of the program being compiled. This approach has the advantage that the analysis effort can be spent where it is justified by the possibility of removing a run time check, and where added precision is needed to accurately analyze complex parts of the program. Like the k-cfa our approach is based on abstract interpretation but it can analyze some important programs more accurately than the k-cfa for any value of k. We have built a prototype of our type analysis and tested it on various programs with higher order functions. It can remove all run time type checks in some nontrivial programs which use map and the Y combinator.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581487", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Danny", + "last_name": "Dubé", + "institution": "Université de Montréal" + }, + { + "first_name": "Marc", + "last_name": "Feeley", + "institution": "Université de Montréal" + } + ], + "dblp_key": "conf/icfp/DubeF02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581484", + "title": "Contracts for higher-order functions", + "abstract": "Assertions play an important role in the construction of robust software. Their use in programming languages dates back to the 1970s. Eiffel, an object-oriented programming language, wholeheartedly adopted assertions and developed the \"Design by Contract\" philosophy. Indeed, the entire object-oriented community recognizes the value of assertion-based contracts on methods.In contrast, languages with higher-order functions do not support assertion-based contracts. Because predicates on functions are, in general, undecidable, specifying such predicates appears to be meaningless. Instead, the functional languages community developed type systems that statically approximate interesting predicates.In this paper, we show how to support higher-order function contracts in a theoretically well-founded and practically viable manner. Specifically, we introduce λcon, a typed lambda calculus with assertions for higher-order functions. The calculus models the assertion monitoring system that we employ in DrScheme. We establish basic properties of the model (type soundness, etc.) and illustrate the usefulness of contract checking with examples from DrScheme's code base.We believe that the development of an assertion system for higher-order functions serves two purposes. On one hand, the system has strong practical potential because existing type systems simply cannot express many assertions that programmers would like to state. On the other hand, an inspection of a large base of invariants may provide inspiration for the direction of practical future type system research.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581484", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/FindlerF02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581497", + "title": "An expressive, scalable type theory for certified code", + "abstract": "We present the type theory LTT, intended to form a basis for typed target languages, providing an internal notion of logical proposition and proof. The inclusion of explicit proofs allows the type system to guarantee properties that would otherwise be incompatible with decidable type checking. LTT also provides linear facilities for tracking ephemeral properties that hold only for certain program states.Our type theory allows for re-use of typechecking software by casting a variety of type systems within a single language. We illustrate our methodology of representation by means of two examples, one functional and one stateful, and describe the associated operational semantics and proofs of type safety.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581497", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Joseph C.", + "last_name": "Vanderwaart", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/CraryV02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581494", + "title": "Typing dynamic typing", + "abstract": "Even when programming in a statically typed language we every now and then encounter statically untypable values; such values result from interpreting values or from communicating with the outside world. To cope with this problem most languages include some form of dynamic types. It may be that the core language has been explicitly extended with such a type, or that one is allowed to live dangerously by using functions like unsafeCoerce. We show how, by a careful use of existentially and universally quantified types, one may achievem the same effect, without extending the language with new or unsafe features. The techniques explained are universally applicable, provided the core language is expressive enough; this is the case for the common implementations of Haskell. The techniques are used in the description of a type checking compiler that, starting from an expression term, constructs a typed function representing the semantics of that expression. In this function the overhead associated with the type checking is only once being paid for; in this sense we have thus achieved static type checking.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581494", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Arthur I.", + "last_name": "Baars", + "institution": "Utrecht University" + }, + { + "first_name": "S. Doaitse", + "last_name": "Swierstra", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/BaarsS02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581505", + "title": "Program generation, termination, and binding-time analysis", + "abstract": "Recent research suggests that the goal of fully automatic and reliable program generation for a broad range of applications is coming nearer to feasibility. However, several interesting and challenging problems remain to be solved before it becomes a reality.We first discuss the relations between problem specifications and their solutions in program form, and then narrow the discussion to an important special case: program transformation. Although the goal of fully automatic program generation is still far from fully achieved, there has been some success in a special case: partial evaluation, also known as program specialization.A key problem in all program generation is termination of the generation process. This paper (See the GPCE'02 proceedings for the full paper.} describes recent progress towards automatically solving the termination problem, first for individual programs, and then for specializers and \"generating extensions,\" the program generators that most offline partial evaluators produce.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581505", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neil D.", + "last_name": "Jones", + "institution": "University of Copenhagen" + }, + { + "first_name": "Arne John", + "last_name": "Glenstrup", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/JonesG02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581489", + "title": "Modular typechecking for hierarchically extensible datatypes and functions", + "abstract": "One promising approach for adding object-oriented (OO) facilities to functional languages like ML is to generalize the existing datatype and function constructs to be hierarchical and extensible, so that datatype variants simulate classes and function cases simulate methods. This approach allows existing datatypes to be easily extended with both new operations and new variants, resolving a long-standing conflict between the functional and OO styles. However, previous designs based on this approach have been forced to give up modular typechecking, requiring whole-program checks to ensure type safety. We describe Extensible ML (eml), an ML-like language that supports hierarchical, extensible datatypes and functions while preserving purely modular typechecking. To achieve this result, eml's type system imposes a few requirements on datatype and function extensibility, but eml is still able to express both traditional functional and OO idioms. We have formalized a core version of eml and proven the associated type system sound, and we have developed a prototype interpreter for the language.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581489", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of Washington" + }, + { + "first_name": "Colin", + "last_name": "Bleckner", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/icfp/MillsteinBC02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581490", + "title": "Functional formal methods", + "abstract": "Some functional programming languages are also mathematical logics. One can reason formally, traditionally, and directly about programs in such languages. This is driving a new application area for functional programming: modeling microarchitectures, hardware design languages, and imperative programming languages. Such models serve the dual purposes of simulation and formal analysis.ACL2, \"A Computational Logic for Applicative Common Lisp,\" is a functional programming language that is also a first-order mathematical logic supported by a Boyer-Moore style mechanical theorem prover [5]. It is being used to model and verify artifacts of commercial and industrial interest.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581490", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "J Strother", + "last_name": "Moore", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/icfp/Moore02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581498", + "title": "Meta-programming with names and necessity", + "abstract": "Meta-programming languages provide infrastructure to generate and execute object programs at run-time. In a typed setting, they contain a modal type constructor which classifies object code. These code types generally come in two flavors: closed and open. Closed code expressions can be invoked at run-time, but the computations over them are more rigid, and typically produce less efficient residual object programs. Open code provides better inlining and partial evaluation of object programs, but once constructed, expressions of this type cannot in general be evaluated.Recent work in this area has focused on combining the two notions into a sound system. We present a novel way to achieve this. It is based on adding the notion of names from the work on Nominal Logic and FreshML to the λ -calculus of proof terms for the necessity fragment of modal logic S4. The resulting language provides a more fine-grained control over free variables of object programs when compared to the existing languages for meta-programming. In addition, this approach lends itself well to addition of intensional code analysis, i.e. ability of meta programs to inspect and destruct object programs at run-time in a type-safe manner, which we also undertake.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581498", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Nanevski02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581479", + "title": "Towards more natural functional programming languages", + "abstract": "Programming languages are the way for a person to express a mental plan in a way that the computer can understand. Therefore, it is appropriate to consider properties of people when designing new programming languages. In our research, we are investigating how people think about algorithms, and how programming languages can be made easier to learn and more effective for people to use. By taking human-productivity aspects of programming languages seriously, designers can more effectively match programming language features with human capabilities and problem solving methods. Human factors methods can be used to measure the effects, so unsubstantiated claims can be avoided.This talk will present a quick summary of new and old results in what is known about people and programming, from areas that are sometimes called \"empirical studies of programmers\" and \"psychology of programming.\" Much is known about what people find difficult, and what syntax and language features are especially tricky and bug-prone. Our new research has discovered how people naturally think about algorithms and data structures, which can help with making programming languages more closely match people's problem solving techniques.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581479", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Brad A.", + "last_name": "Myers", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Myers02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581503", + "title": "Compiling scheme to JVM bytecode: : a performance study", + "abstract": "We have added a Java virtual machine (henceforth JVM) bytecode generator to the optimizing Scheme-to-C compiler Bigloo. We named this new compiler BiglooJVM. We have used this new compiler to evaluate how suitable the JVM bytecode is as a target for compiling strict functional languages such as Scheme. In this paper, we focus on the performance issue. We have measured the execution time of many Scheme programs when compiled to C and when compiled to JVM. We found that for each benchmark, at least one of our hardware platforms ran the BiglooJVM version in less than twice the time taken by the Bigloo version. In order to deliver fast programs the generated JVM bytecode must be carefully crafted in order to benefit from the speedup of just-in-time compilers.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581503", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bernard", + "last_name": "Serpette", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/SerpetteS02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581495", + "title": "A theory of overloading", + "abstract": "We present a minimal extension of the Hindley/Milner system to allow for overloading of identifiers. Our approach relies on a combination of the HM(X) type system framework with Constraint Handling Rules (CHRs). CHRs are a declarative language for writing incremental constraint solvers. CHRs allow us to precisely describe the relationships among overloaded identifiers. Under some sufficient conditions on the CHRs we achieve decidable type inference and the semantic meaning of programs is unambiguous. Our approach allows us to combine open and closed world overloading. We also show how to deal with overlapping definitions.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581495", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Peter J.", + "last_name": "Stuckey", + "institution": "University of Melbourne" + }, + { + "first_name": "Martin", + "last_name": "Sulzmann", + "institution": "University of Melbourne" + } + ], + "dblp_key": "conf/icfp/StuckeyS02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581481", + "title": "Concatenate, reverse and map vanish for free", + "abstract": "We introduce a new transformation method to eliminate intermediate data structures occurring in functional programs due to repeated list concatenations and other data manipulations (additionally exemplified with list reversal and mapping of functions over lists).The general idea is to uniformly abstract from data constructors and manipulating operations by means of rank-2 polymorphic combinators that exploit algebraic properties of these operations to provide an optimized implementation. The correctness of transformations is proved by using the free theorems derivable from parametric polymorphic types.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581481", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Janis", + "last_name": "Voigtländer", + "institution": "Technische Universität Dresden" + } + ], + "dblp_key": "conf/icfp/Voigtlander02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581496", + "title": "Type classes with more higher-order polymorphism", + "abstract": "We propose an extension of Haskell's type class system with lambda abstractions in the type language. Type inference for our extension relies on a novel constrained unification procedure called guided higher-order unification. This unification procedure is more general than Haskell's kind-preserving unification but less powerful than full higher-order unification.The main technical result is the soundness and completeness of the unification rules for the fragment of lambda calculus that we admit on the type level.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581496", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Neubauer", + "institution": "University of Fribourg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Fribourg" + } + ], + "dblp_key": "conf/icfp/NeubauerT02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581491", + "title": "Shortcut fusion for accumulating parameters & zip-like functions", + "abstract": "We present an alternative approach to shortcut fusion based on the function unfoldr. Despite its simplicity the technique can remove intermediate lists in examples which are known to be difficult. We show that it can remove all lists from definitions involving zip-like functions and functions using accumulating parameters.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581491", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Josef", + "last_name": "Svenningsson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/Svenningsson02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581485", + "title": "An interoperable calculus for external object access", + "abstract": "By extending an ML-style type system with record polymorphism, recursive type definition, and an ordering relation induced by field inclusion, it is possible to achieve seamless and type safe interoperability with an object-oriented language. Based on this observation, we define a polymorphic language that can directly access external objects and methods, and develop a type inference algorithm. This calculus enjoys the features of both higher-order programming with ML polymorphism and class-based object-oriented programming with dynamic method dispatch. To establish type safety, we define a sample object-oriented language with multiple inheritance as the target for interoperability, define an operational semantics of the calculus, and show that the type system is sound with respect to the operational semantics. These results have been implemented in our prototype interpretable language, which can access Java class files and other external resources.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581485", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Japan Advanced Institute of Science and Technology" + }, + { + "first_name": "Kiyoshi", + "last_name": "Yamatodani", + "institution": "Japan Advanced Institute of Science and Technology" + } + ], + "dblp_key": "conf/icfp/OhoriY02", + "venue": "icfp", + "year": 2002 + }, + { + "paper_id": "10.1145/581478.581499", + "title": "Tagless staged interpreters for typed languages", + "abstract": "Multi-stage programming languages provide a convenient notation for explicitly staging programs. Staging a definitional interpreter for a domain specific language is one way of deriving an implementation that is both readable and efficient. In an untyped setting, staging an interpreter \"removes a complete layer of interpretive overhead\", just like partial evaluation. In a typed setting however, Hindley-Milner type systems do not allow us to exploit typing information in the language being interpreted. In practice, this can mean a slowdown cost by a factor of three or mor.Previously, both type specialization and tag elimination were applied to this problem. In this paper we propose an alternative approach, namely, expressing the definitional interpreter in a dependently typed programming language. We report on our experience with the issues that arise in writing such an interpreter and in designing such a language. .To demonstrate the soundness of combining staging and dependent types in a general sense, we formalize our language (called Meta-D) and prove its type safety. To formalize Meta-D, we extend Shao, Saha, Trifonov and Papaspyrou's λH language to a multi-level setting. Building on λH allows us to demonstrate type safety in a setting where the type language contains all the calculus of inductive constructions, but without having to repeat the work needed for establishing the soundness of that system.", + "date": "2002-09-17", + "link": "https://doi.org/10.1145/581478.581499", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Emir", + "last_name": "PašaliΕ", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "Walid", + "last_name": "Taha", + "institution": "Rice University" + }, + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "conf/icfp/PasalicTS02", + "venue": "icfp", + "year": 2002 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2003.json b/data/pl_conferences/icfp/2003.json new file mode 100644 index 0000000..d8f4960 --- /dev/null +++ b/data/pl_conferences/icfp/2003.json @@ -0,0 +1,648 @@ +[ + { + "paper_id": "10.1145/944705.944707", + "title": "Scripting the type inference process", + "abstract": "To improve the quality of type error messages in functional programming languages, we propose four techniques which influence the behaviour of constraint-based type inference processes. These techniques take the form of externally supplied type inference directives, precluding the need to make any changes to the compiler. A second advantage is that the directives are automatically checked for soundness with respect to the underlying type system. We show how the techniques can be used to improve the type error messages reported for a combinator library. More specifically, how they can help to generate error messages which are conceptually closer to the domain for which the library was developed. The techniques have all been incorporated in the Helium compiler, which implements a large subset of Haskell.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944707", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bastiaan", + "last_name": "Heeren", + "institution": "Utrecht University" + }, + { + "first_name": "Jurriaan", + "last_name": "Hage", + "institution": "Utrecht University" + }, + { + "first_name": "S. Doaitse", + "last_name": "Swierstra", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/HeerenHS03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944731", + "title": "Optimistic evaluation: an adaptive evaluation strategy for non-strict programs", + "abstract": "Lazy programs are beautiful, but they are slow because they build many thunks. Simple measurements show that most of these thunks are unnecessary: they are in fact always evaluated, or are always cheap. In this paper we describe Optimistic Evaluation --- an evaluation strategy that exploits this observation. Optimistic Evaluation complements compile-time analyses with run-time experiments: it evaluates a thunk speculatively, but has an abortion mechanism to back out if it makes a bad choice. A run-time adaption mechanism records expressions found to be unsuitable for speculative evaluation, and arranges for them to be evaluated more lazily in the future.We have implemented optimistic evaluation in the Glasgow Haskell Compiler. The results are encouraging: many programs speed up significantly (5-25%), some improve dramatically, and none go more than 15% slower.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944731", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert", + "last_name": "Ennals", + "institution": "University of Cambridge" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/EnnalsJ03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944709", + "title": "MLF: raising ML to the power of system F", + "abstract": "We propose a type system MLF that generalizes ML with first-class polymorphism as in System F. Expressions may contain second-order type annotations. Every typable expression admits a principal type, which however depends on type annotations. Principal types capture all other types that can be obtained by implicit type instantiation and they can be inferred.All expressions of ML are well-typed without any annotations. All expressions of System F can be mechanically encoded into MLF by dropping all type abstractions and type applications, and injecting types of lambda-abstractions into MLF types. Moreover, only parameters of lambda-abstractions that are used polymorphically need to remain annotated.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944709", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Didier Le", + "last_name": "Botlan", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/BotlanR03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944726", + "title": "A static type system for JVM access control", + "abstract": "This paper presents a static type system for JAVA Virtual Machine (JVM) code that enforces an access control mechanism similar to the one found, for example, in a JAVA implementation. In addition to verifying type consistency of a given JVM code, the type system statically verifies that the code accesses only those resources that are granted by the prescribed access policy. The type system is proved to be sound with respect to an operational semantics that enforces access control dynamically, similarly to JAVA stack inspection. This result ensures that \"well typed code cannot violate access policy.\" The paper then develops a type inference algorithm and shows that it is sound with respect to the type system and that it always infers a minimal set of access privileges. These results allows us to develop a static system for JVM access control without resorting to costly runtime stack inspection.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944726", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tomoyuki", + "last_name": "Higuchi", + "institution": "Japan Advanced Institute of Science and Technology" + }, + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Japan Advanced Institute of Science and Technology" + } + ], + "dblp_key": "conf/icfp/HiguchiO03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944724", + "title": "Disjunctive normal forms and local exceptions", + "abstract": "All classical ?-terms typable with disjunctive normal forms are shown to share a common computational behavior: they implement a local exception handling mechanism whose exact workings depend on the tautology. Equivalent and more efficient control combinators are described through a specialized sequent calculus and shown to be correct.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944724", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Emmanuel", + "last_name": "Beffara", + "institution": "Université Paris Cité" + }, + { + "first_name": "Vincent", + "last_name": "Danos", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/icfp/BeffaraD03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944712", + "title": "Compiling regular patterns", + "abstract": "Pattern matching mechanisms based on regular expressions feature in a number of recent languages for processing tree-structured data such as XML. A compiler for such a language must address not only the familiar problems of pattern optimization for ML-style algebraic datatypes and pattern matching, but also some new ones, arising principally from the use of recursion in patterns. We identify several factors playing a significant role in the quality of the generated code, propose two pattern compilers---one generating backtracking target programs, the other non-backtracking---and sketch proofs of their correctness.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944712", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael Y.", + "last_name": "Levin", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/Levin03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944727", + "title": "Polish parsers, step by step", + "abstract": "We present the derivation of a space efficient parser combinator library: the constructed parsers do not keep unnecessary references to the input, produce online results and efficiently handle ambiguous grammars. The underlying techniques can be applied in many contexts where traditionally backtracking is used.We present two data types, one for keeping track of the progress of the search process, and one for representing the final result in a linear way. Once these data types are combined into a single type, we can perform a breadth-first search, while returning parts of the result as early as possible.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944727", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "R. J. M.", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "S. Doaitse", + "last_name": "Swierstra", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/HughesS03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944706", + "title": "Conservation of information: applications in functional, reversible, and quantum computing", + "abstract": "Microscopic physics is entirely reversible, yet almost all computation is done using irreversible processes. Adding two numbers together, for example, destroys information, unless one of the numbers is retained. Over the past few years, some advantages of taking reversible computation seriously have emerged -- first in the context of saving energy, through the development of dissipationless logic, and then in the promise of quantum computation, which is necessarily also reversible and dissipationless.The necessary conservation of information in these systems raises the question of how we can best capture this strong constraint from an abstract point of view. Already ideas such as linear logic can be applied, but the full implementation of conservative logic ideas will require language and architectural innovation and a rethink of our computational models.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944706", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thomas F.", + "last_name": "Knight", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/icfp/Knight03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944730", + "title": "Meta-programming through typeful code representation", + "abstract": "By allowing the programmer to write code that can generate code at run-time, meta-programming offers a powerful approach to program construction. For instance, meta-programming can often be employed to enhance program efficiency and facilitate the construction of generic programs. However, meta-programming, especially in an untyped setting, is notoriously error-prone. In this paper, we aim at making meta-programming less error-prone by providing a type system to facilitate the construction of correct meta-programs. We first introduce some code constructors for constructing typeful code representation in which program variables are replaced with deBruijn indices, and then formally demonstrate how such typeful code representation can be used to support meta-programming. The main contribution of the paper lies in recognition and then formalization of a novel approach to typed meta-programming that is practical, general and flexible.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944730", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chiyan", + "last_name": "Chen", + "institution": "" + }, + { + "first_name": "Hongwei", + "last_name": "Xi", + "institution": "" + } + ], + "dblp_key": "conf/icfp/ChenX03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944717", + "title": "From Hilbert space to Dilbert space: context semantics as a language for games and flow analysis", + "abstract": "We give a tutorial and first-principles description of the context semantics of Gonthier, Abadi, and Lévy [5, 4], a computer-science analogue of Girard's geometry of interaction [3]. In the spirit of the invited presentation of Tom Knight (see this Proceedings [7]), the semantics is reversible, and supports pseudo-quantum computation via a superposed sharing of terms and evaluation contexts [2].Context semantics provides a mechanism for modelling ?-calculus, and more generally multiplicative-exponential linear logic (MELL); we explain the the call-by-name (CBN) coding of the ?-calculus, and sketch a proof of the correctness of readback, where the normal form of a ?-term is recovered from its semantics. This analysis yields the algorithmic correctness of Lamping's optimal reduction algorithm [8]. We relate the context semantics to linear logic types and to ideas from game semantics, used to prove full abstraction theorems for PCF and other ?-calculus variants [1, 6, 10]. Readback is essentially a game played by an environment (the Opponent) who wants to discover the Böhm tree (normal form) of a term known by a Player. A type plays the role---using the games jargon---of an arena of possible moves, and a term of that type provides a winning strategy for the Player, permitting the Player to respond correctly to moves made by the Opponent. The interaction between Opponent and Player describes a perfect flow analysis which answers questions like, \"can call site a ever call procedure p?\" The context semantics provides a low-level coding mechanism for describing such flows, the positions of subexpressions and head variables in Böhm trees, as well as moves in the above described two-player games.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944717", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/icfp/Mairson03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944719", + "title": "Dependency-style generic Haskell", + "abstract": "Generic Haskell is an extension of Haskell that supports the construction of generic programs. During the development of several applications, such as an XML editor and compressor, we encountered a number of limitations with the existing (Classic) Generic Haskell language, as implemented by the current Generic Haskell compiler. Specifically, generic definitions become disproportionately more difficult to write as their complexity increases, such as when one generic function uses another, because recursion is implicit in generic definitions. In the current implementation, writing such functions suffers the burden of a large administrative overhead and is at times counter-intuitive. Furthermore, the absence of type checking in the current implementation can make Generic Haskell hard to use.In this paper we develop the foundations of Dependency-style Generic Haskell which addresses the above problems, shifting the burden from the programmer to the compiler. These foundations consist of a full type system for Dependency-style Generic Haskell's core language and appropriate reduction rules. The type system enables the programmer to write generic functions in a more natural style, taking care of dependency details which were previously the programmer's responsibility.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944719", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andres", + "last_name": "Löh", + "institution": "Utrecht University" + }, + { + "first_name": "Dave", + "last_name": "Clarke", + "institution": "Utrecht University" + }, + { + "first_name": "Johan", + "last_name": "Jeuring", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/LohCJ03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944722", + "title": "A sound and complete axiomatization of delimited continuations", + "abstract": "The shift and reset operators, proposed by Danvy and Filinski, are powerful control primitives for capturing delimited continuations. Delimited continuation is a similar concept as the standard (unlimited) continuation, but it represents part of the rest of the computation, rather than the whole rest of computation. In the literature, the semantics of shift and reset has been given by a CPS-translation only. This paper gives a direct axiomatization of calculus with shift and reset, namely, we introduce a set of equations, and prove that it is sound and complete with respect to the CPS-translation. We also introduce a calculus with control operators which is as expressive as the calculus with shift and reset, has a sound and complete axiomatization, and is conservative over Sabry and Felleisen's theory for first-class continuations.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944722", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yukiyoshi", + "last_name": "Kameyama", + "institution": "University of Tsukuba" + }, + { + "first_name": "Masahito", + "last_name": "Hasegawa", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/icfp/KameyamaH03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944711", + "title": "CDuce: an XML-centric general-purpose language", + "abstract": "We present the functional language CDuce, discuss some design issues, and show its adequacy for working with XML documents. Distinctive features of CDuce are a powerful pattern matching, first class functions, overloaded functions, a very rich type system (arrows, sequences, pairs, records, intersections, unions, differences), precise type inference for patterns and error localization, and a natural interpretation of types as sets of values. We also outline some important implementation issues; in particular, a dispatch algorithm that demonstrates how static type information can be used to obtain very efficient compilation schemas..", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944711", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Véronique", + "last_name": "Benzaken", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Alain", + "last_name": "Frisch", + "institution": "Département d'Informatique" + } + ], + "dblp_key": "conf/icfp/BenzakenCF03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944714", + "title": "Global abstraction-safe marshalling with hash types", + "abstract": "Type abstraction is a key feature of ML-like languages for writing large programs. Marshalling is necessary for writing distributed programs, exchanging values via network byte-streams or persistent stores. In this paper we combine the two, developing compile-time and run-time semantics for marshalling, that guarantee abstraction-safety between separately-built programs. We obtain a namespace for abstract types that is global, i.e. meaningful between programs, by hashing module declarations. We examine the scenarios in which values of abstract types are communicated from one program to another, and ensure, by constructing hashes appropriately, that the dynamic and static notions of type equality mirror each other. We use singleton kinds to express abstraction in the static semantics; abstraction is tracked in the dynamic semantics by coloured brackets. These allow us to prove preservation, erasure, and coincidence results. We argue that our proposal is a good basis for extensions to existing ML-like languages, pragmatically straightforward for language users and for implementors.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944714", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "James J.", + "last_name": "Leifer", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Gilles", + "last_name": "Peskine", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Keith", + "last_name": "Wansbrough", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/LeiferPSW03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944721", + "title": "A user-centred approach to functions in Excel", + "abstract": "We describe extensions to the Excel spreadsheet that integrate userdefined functions into the spreadsheet grid, rather than treating them as a &quot;bolt-on&quot;. Our first objective was to bring the benefits of additional programming language features to a system that is often not recognised as a programming language. Second, in a project involving the evolution of a well-established language, compatibility with previous versions is a major issue, and maintaining this compatibility was our second objective. Third and most important, the commercial success of spreadsheets is largely due to the fact that many people find them more usable than programming languages for programming-like tasks. Thus, our third objective (with resulting constraints) was to maintain this usability advantage.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944721", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Alan F.", + "last_name": "Blackwell", + "institution": "University of Cambridge" + }, + { + "first_name": "Margaret", + "last_name": "Burnett", + "institution": "Oregon State University" + } + ], + "dblp_key": "conf/icfp/JonesBB03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944715", + "title": "Dynamic rebinding for marshalling and update, with destruct-time?", + "abstract": "Most programming languages adopt static binding, but for distributed programming an exclusive reliance on static binding is too restrictive: dynamic binding is required in various guises, for example when a marshalled value is received from the network, containing identifiers that must be rebound to local resources. Typically it is provided only by ad-hoc mechanisms that lack clean semantics.In this paper we adopt a foundational approach, developing core dynamic rebinding mechanisms as extensions to simply-typed call-by-value ? -calculus. To do so we must first explore refinements of the call-by-value reduction strategy that delay instantiation, to ensure computations make use of the most recent versions of rebound definitions. We introduce redex-time and destruct-time strategies. The latter forms the basis for a ?marsh calculus that supports dynamic rebinding of marshalled values, while remaining as far as possible statically-typed. We sketch an extension of ? marsh with concurrency and communication, giving examples showing how wrappers for encapsulating untrusted code can be expressed. Finally, we show that a high-level semantics for dynamic updating can also be based on the destruct-time strategy, defining a ?marsh calculus with simple primitives to provide type-safe updating of running code. We thereby establish primitives and a common semantic foundation for a variety of real-world dynamic rebinding requirements.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944715", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "University of Cambridge" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Gareth", + "last_name": "Stoyle", + "institution": "University of Cambridge" + }, + { + "first_name": "Keith", + "last_name": "Wansbrough", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/BiermanHSSW03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944713", + "title": "Software is discrete mathematics", + "abstract": "A three-year study collected information bearing on the question of whether studying mathematics improves programming skills. An analysis of the data revealed significant differences in the programming effectiveness of two populations of students: (1) those who studied discrete mathematics through examples focused on reasoning about software and (2) those who studied the same mathematical topics illustrated with more traditional examples. Functional programming played a central role in the study because it provides a straightforward framework for the presentation of concepts such as predicate logic and proof by induction. Such topics can be covered in depth, staying almost entirely within the context of reasoning about software. The intricate complexities in logic that mutable variables carry with them need not arise, early on, to confuse novices struggling to understand new ideas. In addition, because functional languages provide useful and compact ways to express mathematical concepts, and because the choice of notation in mathematics courses is often at the discretion of the instructor (in contrast to the notational restrictions often fiercely guarded by the faculty in programming courses), discrete mathematics courses, as they are found in most computer science programs, provide an easy opportunity to enhance the education of students by exposing them to functional programming concepts.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944713", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Rex", + "last_name": "Page", + "institution": "University of Oklahoma" + } + ], + "dblp_key": "conf/icfp/Page03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944710", + "title": "An extension of HM(X) with bounded existential and universal data-types", + "abstract": "We propose a conservative extension of HM(X), a generic constraint-based type inference framework, with bounded existential (a.k.a. abstract) and universal (a.k.a. polymorphic) data-types. In the first part of the article, which remains abstract of the type and constraint language (i.e. the logic X), we introduce the type system, prove its safety and define a type inference algorithm which computes principal typing judgments. In the second part, we propose a realistic constraint solving algorithm for the case of structural sub-typing, which handles the non-standard construct of the constraint language generated by type inference: a form of bounded universal quantification.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944710", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Vincent", + "last_name": "Simonet", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Simonet03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944723", + "title": "Call-by-value is dual to call-by-name", + "abstract": "The rules of classical logic may be formulated in pairs corresponding to De Morgan duals: rules about & are dual to rules about V. A line of work, including that of Filinski (1989), Griffin (1990), Parigot (1992), Danos, Joinet, and Schellinx (1995), Selinger (1998,2001), and Curien and Herbelin (2000), has led to the startling conclusion that call-by-value is the de Morgan dual of call-by-name.This paper presents a dual calculus that corresponds to the classical sequent calculus of Gentzen (1935) in the same way that the lambda calculus of Church (1932,1940) corresponds to the intuitionistic natural deduction of Gentzen (1935). The paper includes crisp formulations of call-by-value and call-by-name that are obviously dual; no similar formulations appear in the literature. The paper gives a CPS translation and its inverse, and shows that the translation is both sound and complete, strengthening a result in Curien and Herbelin (2000).", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944723", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "Avaya (Bermuda)" + } + ], + "dblp_key": "conf/icfp/Wadler03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944732", + "title": "Understanding aspects: extended abstract", + "abstract": "No abstract available.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944732", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/Wand03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944725", + "title": "An effective theory of type refinements", + "abstract": "We develop an explicit two level system that allows programmers to reason about the behavior of effectful programs. The first level is an ordinary ML-style type system, which confers standard properties on program behavior. The second level is a conservative extension of the first that uses a logic of type refinements to check more precise properties of program behavior. Our logic is a fragment of intuitionistic linear logic, which gives programmers the ability to reason locally about changes of program state. We provide a generic resource semantics for our logic as well as a sound, decidable, syntactic refinement-checking system. We also prove that refinements give rise to an optimization principle for programs. Finally, we illustrate the power of our system through a number of examples.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944725", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yitzhak", + "last_name": "Mandelbaum", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/MandelbaumWH03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944729", + "title": "FreshML: programming with binders made simple", + "abstract": "FreshML extends ML with elegant and practical constructs for declaring and manipulating syntactical data involving statically scoped binding operations. User-declared FreshML datatypes involving binders are concrete, in the sense that values of these types can be deconstructed by matching against patterns naming bound variables explicitly. This may have the computational effect of swapping bound names with freshly generated ones; previous work on FreshML used a complicated static type system inferring information about the 'freshness' of names for expressions in order to tame this effect. The main contribution of this paper is to show (perhaps surprisingly) that a standard type system without freshness inference, coupled with a conventional treatment of fresh name generation, suffices for FreshML's crucial correctness property that values of datatypes involving binders are operationally equivalent if and only if they represent a-equivalent pieces of object-level syntax. This is established via a novel denotational semantics. FreshML without static freshness inference is no more impure than ML and experience with it shows that it supports a programming style pleasingly close to informal practice when it comes to dealing with object-level syntax modulo a-equivalence.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944729", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mark R.", + "last_name": "Shinwell", + "institution": "University of Cambridge" + }, + { + "first_name": "Andrew M.", + "last_name": "Pitts", + "institution": "University of Cambridge" + }, + { + "first_name": "Murdoch J.", + "last_name": "Gabbay", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/ShinwellPG03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944720", + "title": "Functional automatic differentiation with dirac impulses", + "abstract": "Functional Reactive Programming (FRP) is a framework for reactive programming in a functional setting. FRP has been applied to a number of domains, such as graphical animation, graphical user interfaces, robotics, and computer vision. Recently, we have been interested in applying FRP-like principles to hybrid modeling and simulation of physical systems. As a step in that direction, we have extended an existing FRP implementation, Yampa, in two new ways that make it possible to express certain models in a very natural way, and reduces the amount of work needed to put modeling equations into a suitable form for simulation. First, we have added Dirac impulses that allow certain types of discontinuities to be handled in an easy yet rigorous manner. Second, we have adapted automatic differentiation to the setting of Yampa, and generalized it to work correctly with Dirac impulses. This allows derivatives of piecewise continuous signals to be well-defined at all points. This paper reviews the basic ideas behind automatic differentiation, in particular Jerzy Karczmarczuk's elegant version for a lazy functional language with overloading, and then considers the integration with Yampa and the addition of Dirac impulses.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944720", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Henrik", + "last_name": "Nilsson", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/Nilsson03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944708", + "title": "Discriminative sum types locate the source of type errors", + "abstract": "We propose a type system for locating the source of type errors in an applied lambda calculus with ML-style polymorphism. The system is based on discriminative sum types---known from work on soft typing---with annotation subtyping and recursive types. This way, type clashes can be registered in the type for later reporting. The annotations track the potential producers and consumers for each value so that clashes can be traced to their cause.Every term is typeable in our system and type inference is decidable. A type derivation in our system describes all type errors present in the program, so that a principal derivation yields a principal description of all type errors present. Error messages are derived from completed type derivations. Thus, error messages are independent of the particular algorithm used for type inference, provided it constructs such a derivation.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944708", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Neubauer", + "institution": "University of Fribourg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Fribourg" + } + ], + "dblp_key": "conf/icfp/NeubauerT03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944716", + "title": "Iterative-free program analysis", + "abstract": "flow analyses are reduced to the problem of finding a fixed point in a certain transition system, and such fixed point is commonly computed through an iterative procedure that repeats tracing until convergence.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944716", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mizuhito", + "last_name": "Ogawa", + "institution": "Japan Advanced Institute of Science and Technology" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "The University of Tokyo" + }, + { + "first_name": "Isao", + "last_name": "Sasano", + "institution": "Japan Advanced Institute of Science and Technology" + } + ], + "dblp_key": "conf/icfp/OgawaHS03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944718", + "title": "A theory of aspects", + "abstract": "This paper define the semantics of MinAML, an idealized aspect-oriented programming language, by giving a type-directed translation from its user-friendly external language to its compact, well-defined core language. We argue that our framework is an effective way to give semantics to aspect-oriented programming languages in general because the translation eliminates shallow syntactic differences between related constructs and permits definition of a clean, easy-to-understand, and easy-to-reason-about core language.The core language extends the simply-typed lambda calculus with two central new abstractions: explicitly labeled program points and first-class advice. The labels serve both to trigger advice and to mark continuations that the advice may return to. These constructs are defined orthogonally to the other features of the language and we show that our abstractions can be used in both functional and object-oriented contexts. The labels are well-scoped and the language as a whole is well-typed. Consequently, programmers can use lexical scoping in the standard way to prevent aspects from interfering with local program invariants.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944718", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Jay", + "last_name": "Ligatti", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/icfp/WalkerZL03", + "venue": "icfp", + "year": 2003 + }, + { + "paper_id": "10.1145/944705.944728", + "title": "Boxes go bananas: encoding higher-order abstract syntax with parametric polymorphism", + "abstract": "Higher-order abstract syntax is a simple technique for implementing languages with functional programming. Object variables and binders are implemented by variables and binders in the host language. By using this technique, one can avoid implementing common and tricky routines dealing with variables, such as capture-avoiding substitution. However, despite the advantages this technique provides, it is not commonly used because it is difficult to write sound elimination forms (such as folds or catamorphisms) for higher-order abstract syntax. To fold over such a datatype, one must either simultaneously define an inverse operation (which may not exist) or show that all functions embedded in the datatype are parametri.In this paper, we show how first-class polymorphism can be used to guarantee the parametricity of functions embedded in higher-order abstract syntax. With this restriction, we implement a library of iteration operators over data-structures containing functionals. From this implementation, we derive \"fusion laws\" that functional programmers may use to reason about the iteration operator. Finally, we show how this use of parametric polymorphism corresponds to the Schürmann, Despeyroux and Pfenning method of enforcing parametricity through modal types. We do so by using this library to give a sound and complete encoding of their calculus into System F?. This encoding can serve as a starting point for reasoning about higher-order structures in polymorphic languages.", + "date": "2003-08-25", + "link": "https://doi.org/10.1145/944705.944728", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Geoffrey", + "last_name": "Washburn", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/WashburnW03", + "venue": "icfp", + "year": 2003 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2004.json b/data/pl_conferences/icfp/2004.json new file mode 100644 index 0000000..fa419c9 --- /dev/null +++ b/data/pl_conferences/icfp/2004.json @@ -0,0 +1,508 @@ +[ + { + "paper_id": "10.1145/1016850.1016858", + "title": "Searching for deadlocks while debugging concurrent haskell programs", + "abstract": "This paper presents an approach to searching for deadlocks in Concurrent Haskell programs. The search is based on a redefinition of the IO monad which allows the reversal of Concurrent Haskells concurrency primitives. Hence, it is possible to implement this search by a backtracking algorithm checking all possible schedules of the system. It is integrated in the Concurrent Haskell Debugger (CHD), and automatically searches for deadlocks in the background while debugging. The tool is easy to use and the small modifications of the source program are done by a preprocessor. In the tool we use iterative deepening as search strategy which quickly detects deadlocks close to the actual system configuration and utilizes idle time during debugging at the best.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016858", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jan", + "last_name": "Christiansen", + "institution": "Kiel University" + }, + { + "first_name": "Frank", + "last_name": "Huch", + "institution": "Kiel University" + } + ], + "dblp_key": "conf/icfp/ChristiansenH04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016874", + "title": "From process logic to program logic", + "abstract": "We present a process logic for the p -calculus with the linear/affine type discipline [6, 7, 31, 32, 33, 59, 60]. Built on the preceding studies on logics for programs and processes, simple systems of assertions are developed, capturing the classes of behaviours ranging from purely functional interactions to those with destructive update, local state and genericity. A central feature of the logic is representation of the behaviour of an environment as the dual of that of a process in an assertion, which is crucial for obtaining compositional proof systems. From the process logic we can derive compositional program logics for various higher-order programming languages, whose soundness is proved via their embeddings into the process logic. In this paper, the key technical framework of the process logic and its applications is presented focussing on pure functional behaviour and a prototypical call-by-value functional language, leaving the full technical development to [27, 26].", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016874", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kohei", + "last_name": "Honda", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/icfp/Honda04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016883", + "title": "Scrap more boilerplate: reflection, zips, and generalised casts", + "abstract": "Writing boilerplate code is a royal pain. Generic programming promises to alleviate this pain by allowing the programmer to write a generic \"recipe\" for boilerplate code, and use that recipe in many places. In earlier work we introduced the \"Scrap your boilerplate\" approach to generic programming, which exploits Haskell's existing type-class mechanism to support generic transformations and queries.This paper completes the picture. We add a few extra \"introspective\" or \"reflective\" facilities, that together support a rich variety of serialisation and de-serialisation. We also show how to perform generic \"zips\", which at first appear to be somewhat tricky in our framework. Lastly, we generalise the ability to over-ride a generic function with a type-specific one.All of this can be supported in Haskell with independently-useful extensions: higher-rank types and type-safe cast. The GHC implementation of Haskell readily derives the required type classes for user-defined data types.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016883", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Lämmel", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/LammelJ04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016872", + "title": "Numbering matters: first-order canonical forms for second-order recursive types", + "abstract": "We study a type system equipped with universal types and equire-cursive types, which we refer to as F͘. We show that type equality may be decided in time O(nlog n), an improvement over the previous known bound of O(n2 ). In fact, we show that two more general problems, namely entailment of type equations and type unification, may be decided in time O(nlog n), a new result. To achieve this bound, we associate, with every F͘ type, a first-order canonical form, which may be computed in time O(nlogn). By exploiting this notion, we reduce all three problems to equality and unification of first-order recursive terms, for which efficient algorithms are known.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016872", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nadji", + "last_name": "Gauthier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/GauthierP04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016876", + "title": "A sound (and complete) model of contracts", + "abstract": "Even in statically typed languages it is useful to have certain invariants checked dynamically. Findler and Felleisen gave an algorithm for dynamically checking expressive higher-order types called contracts. If we postulate soundness (in the sense that whenever a term is accused of violating its contract it really does fail to satisfy it), then their algorithm implies a semantics for contracts. Unfortunately, the implicit nature of the resulting model makes it rather unwieldy.In this paper we demonstrate that a direct approach yields essentially the same semantics without having to refer to contract-checking in its definition. The so-defined model largely coincides with intuition, but it does expose some peculiarities in its interpretation of predicate contracts where a notion of safety (which we define in the paper) \"leaks\" into the semantics of Findler and Felleisen's original unrestricted predicate contracts.This counter-intuitive aspect of the semantics can be avoided by changing the language, replacing unrestricted predicate contracts with a restricted version. The corresponding loss in expressive power can be recovered by also providing a way of explicitly expressing safety as a contract-either in ad-hoc fashion or, e.g., by including general recursive contracts.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016876", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "M.", + "last_name": "Blume", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "David", + "last_name": "McAllester", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/icfp/BlumeM04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016853", + "title": "Don't make the wrong mistakes: programming as debugging", + "abstract": "Sometimes it's worth doing things badly in order to do them fast. When is this the right plan? Are some kinds of mistakes worse than others? Could the right infrastructure make trial and error programming more effective? How will it play out in the future?", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016853", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Graham", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Graham04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016869", + "title": "Types for path correctness of XML queries", + "abstract": "If a subexpression in a query will never contribute data to the query answer, this should be regarded as an error. This principle has been recently accepted into mainstream XML query languages, but was still waiting for a complete treatment. We provide here a precise definition for this class of errors, and define a type system that is sound and complete, in its search for such errors, for a core language, under mild restrictions on the use of recursion in type definitions. In the process, we describe a dichotomy among existential and universal type systems, which is useful to understand some unusual features of our type system.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016869", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dario", + "last_name": "Colazzo", + "institution": "University of Pisa" + }, + { + "first_name": "Giorgio", + "last_name": "Ghelli", + "institution": "University of Pisa" + }, + { + "first_name": "Paolo", + "last_name": "Manghi", + "institution": "University of Pisa" + }, + { + "first_name": "Carlo", + "last_name": "Sartiani", + "institution": "University of Pisa" + } + ], + "dblp_key": "conf/icfp/ColazzoGMS04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016852", + "title": "Galois: high assurance software", + "abstract": "As a company, Galois began its life with the mission simply of supplying functional programming services, building tools and products for clients, leveraging the productivity of functional languages and the abilities of our engineers. This went well, except that our business lacked focus. Every new job had to be found and sold from scratch. We realized that we had to focus on a specific market if we wanted to achieve stability and growth. We chose High Assurance Software as it was a natural fit both for our technology and our expertise, further narrowing our attention to information assurance (IA).", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016852", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Galois (United States)" + } + ], + "dblp_key": "conf/icfp/Launchbury04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016863", + "title": "Regular expression patterns", + "abstract": "We extend Haskell with regular expression patterns. Regular expression patterns provide means for matching and extracting data which goes well beyond ordinary pattern matching as found in Haskell. It has proven useful for string manipulation and for processing structured data such as XML. Regular expression patterns can be used with arbitrary lists, and work seamlessly together with ordinary pattern matching in Haskell. Our extension is lightweight, it is little more than syntactic sugar. We present a semantics and a type system, and show how to implement it as a preprocessor to Haskell.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016863", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Niklas", + "last_name": "Broberg", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Andreas", + "last_name": "Farre", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Josef", + "last_name": "Svenningsson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/BrobergFS04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016882", + "title": "Generics for the masses", + "abstract": "A generic function is a function that can be instantiated on many data types to obtain data type specific functionality. Examples of generic functions are the functions that can be derived in Haskell, such as show, read, and '=='. The recent years have seen a number of proposals that support the definition of generic functions. Some of the proposals define new languages, some define extensions to existing languages. As a common characteristic none of the proposals can be made to work within Haskell 98: they all require something extra, either a more sophisticated type system or an additional language construct. The purpose of this pearl is to show that one can, in fact, program generically within Haskell 98 obviating to some extent the need for fancy type systems or separate tools. Haskell's type classes are at the heart of this approach: they ensure that generic functions can be defined succinctly and, in particular, that they can be used painlessly.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016882", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Bonn" + } + ], + "dblp_key": "conf/icfp/Hinze04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016879", + "title": "Functional morphology", + "abstract": "This paper presents a methodology for implementing natural language morphology in the functional language Haskell. The main idea behind is simple: instead of working with untyped regular expressions, which is the state of the art of morphology in computational linguistics, we use finite functions over hereditarily finite algebraic datatypes. The definitions of these datatypes and functions are the language-dependent part of the morphology. The language-independent part consists of an untyped dictionary format which is used for synthesis of word forms, and a decorated trie, which is used for analysis.Functional Morphology builds on ideas introduced by Huet in his computational linguistics toolkit Zen, which he has used to implement the morphology of Sanskrit. The goal has been to make it easy for linguists, who are not trained as functional programmers, to apply the ideas to new languages. As a proof of the productivity of the method, morphologies for Swedish, Italian, Russian, Spanish, and Latin have already been implemented using the library. The Latin morphology is used as a running example in this article.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016879", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Markus", + "last_name": "Forsberg", + "institution": "University of Gothenburg" + }, + { + "first_name": "Aarne", + "last_name": "Ranta", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/ForsbergR04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016867", + "title": "Monadic regions", + "abstract": "Region-based type systems provide programmer control over memory management without sacrificing type-safety. However, the type systems for region-based languages, such as the ML-Kit or Cyclone, are relatively complicated, so proving their soundness is non-trivial. This paper shows that the complication is in principle unnecessary. In particular, we show that plain old parametric polymorphism, as found in Haskell, is all that is needed. We substantiate this claim by giving a type- and meaning-preserving translation from a region-based language based on core Cyclone to a monadic variant of System F with region primitives whose types and operations are inspired by (and generalize) the ST monad.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016867", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Cornell University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/icfp/FluetM04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016860", + "title": "A type-theoretic foundation of continuations and prompts", + "abstract": "There is a correspondence between classical logic and programming language calculi with first-class continuations. With the addition of control delimiters (prompts), the continuations become composable and the calculi are believed to become more expressive. We formalise that the addition of prompts corresponds to the addition of a single dynamically-scoped variable modelling the special top-level continuation. From a type perspective, the dynamically-scoped variable requires effect annotations. From a logic perspective, the effect annotations can be understood in a standard logic extended with the dual of implication, namely subtraction.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016860", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "" + }, + { + "first_name": "Hugo", + "last_name": "Herbelin", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/icfp/AriolaHS04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016871", + "title": "Types, potency, and idempotency: why nonlinearity and amnesia make a type system work", + "abstract": "Useful type inference must be faster than normalization. Otherwise, you could check safety conditions by running the program. We analyze the relationship between bounds on normalization and type inference. We show how the success of type inference is fundamentally related to the amnesia of the type system: the nonlinearity by which all instances of a variable are constrained to have the same type.Recent work on intersection types has advocated their usefulness for static analysis and modular compilation. We analyze System-I (and some instances of its descendant, System E), an intersection type system with a type inference algorithm. Because System-I lacks idempotency, each occurrence of a variable requires a distinct type. Consequently, type inference is equivalent to normalization in every single case, and time bounds on type inference and normalization are identical. Similar relationships hold for other intersection type systems without idempotency.The analysis is founded on an investigation of the relationship between linear logic and intersection types. We show a lockstep correspondence between normalization and type inference. The latter shows the promise of intersection types to facilitate static analyses of varied granularity, but also belies an immense challenge: to add amnesia to such analysis without losing all of its benefits.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016871", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Peter Møller", + "last_name": "Neergaard", + "institution": "Brandeis University" + }, + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/icfp/NeergaardM04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016851", + "title": "The C - compiler infrastructure", + "abstract": "No abstract available.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016851", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Harvard University Press" + }, + { + "first_name": "Simon", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/RamseyJ04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016864", + "title": "Multi-return function call", + "abstract": "It is possible to extend the basic notion of \"function call\" to allow functions to have multiple return points. This turns out to be a surprisingly useful mechanism. This paper conducts a fairly wide-ranging tour of such a feature: a formal semantics for a minimal λ -calculus capturing the mechanism; a motivating example; a static type system; useful transformations; implementation concerns and experience with an implementation; and comparison to related mechanisms, such as exceptions, sum-types and explicit continuations. We conclude that multiple-return function call is not only a useful and expressive mechanism, both at the source-code and intermediate-representation level, but is also quite inexpensive to implement.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016864", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "David", + "last_name": "Fisher", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/icfp/ShiversF04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016854", + "title": "20 years of industrial functional programming", + "abstract": "It is now 20 years since the Ericsson Computer Science Laboratory (CSLab) was formed, and 20 years since CSLab started performing the programming language experiments that eventually led to the development of the Erlang programming language. For 15 years, Ericsson has conducted experiments with Erlang in an industrial setting, and for 12 years, actual commercial products have been developed.This talk summarizes some of the lessons learned from this work. It is well known that it is difficult to introduce a new programming technology. Even so, engineers often fail to realize that the reasons for resisting change are more often social/political than technical, even though the objections may seem technical in nature. This talk will highlight a few of the common objections to Erlang, and measure them against practical experience. In addition, it will suggest some topics for research that could result in significant cost savings in the near future, as well as inspire closer cooperation between industry and academia.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016854", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ulf", + "last_name": "Wiger", + "institution": "Ericsson (Sweden)" + } + ], + "dblp_key": "conf/icfp/Wiger04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016878", + "title": "A nanopass infrastructure for compiler education", + "abstract": "Compilers structured as a small number of monolithic passes are difficult to understand and difficult to maintain. Adding new optimizations often requires major restructuring of existing passes that cannot be understood in isolation. The steep learning curve is daunting, and even experienced developers find it hard to modify existing passes without introducing subtle and tenacious bugs. These problems are especially frustrating when the developer is a student in a compiler class.An attractive alternative is to structure a compiler as a collection of many small passes, each of which performs a single task. This \"micropass\" structure aligns the actual implementation of a compiler with its logical organization, simplifying development, testing, and debugging. Unfortunately, writing many small passes duplicates code for traversing and rewriting abstract syntax trees and can obscure the meaningful transformations performed by individual passes.To address these problems, we have developed a methodology and associated tools that simplify the task of building compilers composed of many fine-grained passes. We describe these compilers as \"nanopass\" compilers to indicate both the intended granularity of the passes and the amount of source code required to implement each pass. This paper describes the methodology and tools comprising the nanopass framework.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016878", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dipanwita", + "last_name": "Sarkar", + "institution": "Indiana University" + }, + { + "first_name": "Oscar", + "last_name": "Waddell", + "institution": "" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/SarkarWD04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016868", + "title": "Translating dependency into parametricity", + "abstract": "Abadi et al. introduced the dependency core calculus (DCC) as a unifying framework to study many important program analyses such as binding time, information flow, slicing, and function call tracking. DCC uses a lattice of monads and a nonstandard typing rule for their associated bind operations to describe the dependency of computations in a program. Abadi et al. proved a noninterference theorem that establishes the correctness of DCC's type system and thus the correctness of the type systems for the analyses above.In this paper, we study the relationship between DCC and the Girard-Reynolds polymorphic lambda calculus (System F). We encode the recursion-free fragment of DCC into F via a type-directed translation. Our main theoretical result is that, following from the correctness of the translation, the parametricity theorem for F implies the noninterference theorem for DCC. In addition, the translation provides insights into DCC's type system and suggests implementation strategies of dependency calculi in polymorphic languages.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016868", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Tse", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/TseZ04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016861", + "title": "Relating models of backtracking", + "abstract": "Past attempts to relate two well-known models of backtracking computation have met with only limited success. We relate these two models using logical relations. We accommodate higher-order values and infinite computations. We also provide an operational semantics, and we prove it adequate for both models.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016861", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + }, + { + "first_name": "Dale", + "last_name": "Vaillancourt", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/WandV04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016875", + "title": "Verification of safety properties for concurrent assembly code", + "abstract": "Concurrency, as a useful feature of many modern programming languages and systems, is generally hard to reason about. Although existing work has explored the verification of concurrent programs using high-level languages and calculi, the verification of concurrent assembly code remains an open problem, largely due to the lack of abstraction at a low-level. Nevertheless, it is sometimes necessary to reason about assembly code or machine executables so as to achieve higher assurance.In this paper, we propose a logic-based \"type\" system for the static verification of concurrent assembly programs, applying the \"invariance proof\" technique for verifying general safety properties and the \"assume-guarantee\" paradigm for decomposition. In particular, we introduce a notion of \"local guarantee\" for the thread-modular verification in a non-preemptive setting.Our system is fully mechanized. Its soundness has been verified using the Coq proof assistant. A safety proof of a program is semi-automatically constructed with help of Coq, allowing the verification of even undecidable safety properties. We demonstrate the usage of our system using three examples, addressing mutual exclusion, deadlock freedom, and partial correctness respectively.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016875", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dachuan", + "last_name": "Yu", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/YuS04", + "venue": "icfp", + "year": 2004 + }, + { + "paper_id": "10.1145/1016850.1016856", + "title": "Making a fast curry: push/enter vs. eval/apply for higher-order languages", + "abstract": "Higher-order languages that encourage currying are implemented using one of two basic evaluation models: push/enter or eval/apply. Implementors use their intuition and qualitative judgements to choose one model or the other.Our goal in this paper is to provide, for the first time, a more substantial basis for this choice, based on our qualitative and quantitative experience of implementing both models in a state-of-the-art compiler for Haskell.Our conclusion is simple, and contradicts our initial intuition: compiled implementations should use eval/apply.", + "date": "2004-09-19", + "link": "https://doi.org/10.1145/1016850.1016856", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/MarlowJ04", + "venue": "icfp", + "year": 2004 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2005.json b/data/pl_conferences/icfp/2005.json new file mode 100644 index 0000000..dc55455 --- /dev/null +++ b/data/pl_conferences/icfp/2005.json @@ -0,0 +1,731 @@ +[ + { + "paper_id": "10.1145/1086365.1086375", + "title": "Combining programming with theorem proving", + "abstract": "1. Introduction The notion of type equality plays a pivotal r^ole in type systemdesign. However, the importance of this role is often less evident in commonly studied type systems. For instance, in the simplytyped", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086375", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chiyan", + "last_name": "Chen", + "institution": "" + }, + { + "first_name": "Hongwei", + "last_name": "Xi", + "institution": "" + } + ], + "dblp_key": "conf/icfp/ChenX05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086382", + "title": "JavaScript at ten years", + "abstract": "This talk presents the tumultuous history of JavaScript, from its first appearance in Netscape 2 beta releases in the fall of 1995 through the present, with emphasis on the unvarnished, real-world side of designing, implementing, shipping, and standardizing a functional programming language used by millions of people. JavaScript was conceived of as an \"object-based scripting language\", but its inspiration came originally from Scheme, with an admixture of Self. Designing a language to fit the constraints of the target audience of HTML authors, the embedding browser application, and the market conditions of that time was challenging. We discuss what worked and what did not, and how the language evolved due to competition and de jure standardization. The talk ranges widely over the history of the web, including the recent renaissance of JavaScript and its development in the ECMA standards group. We close by presenting new work likely to appear in the next version of the language.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086382", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Brendan", + "last_name": "Eich", + "institution": "Mozilla Foundation" + } + ], + "dblp_key": "conf/icfp/Eich05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086391", + "title": "Scrap your boilerplate with class: extensible generic functions", + "abstract": "The 'Scrap your boilerplate' approach to generic programming allows the programmer to write generic functions that can traverse arbitrary data structures, and yet have type-specific cases. However, the original approach required all the type-specific cases to be supplied at once, when the recursive knot of generic function definition is tied. Hence, generic functions were closed. In contrast, Haskell's type classes support open, or extensible, functions that can be extended with new type-specific cases as new data types are defined. In this paper, we extend the 'Scrap your boilerplate' approach to support this open style. On the way, we demonstrate the desirability of abstraction over type classes, and the usefulness of recursive dictionarie.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086391", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Lämmel", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/LammelJ05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086399", + "title": "Modular verification of concurrent assembly code with dynamic thread creation and termination", + "abstract": "Proof-carrying code (PCC) is a general framework that can, in principle, verify safety properties of arbitrary machine-language programs. Existing PCC systems and typed assembly languages, however, can only handle sequential programs. This severely limits their applicability since many real-world systems use some form of concurrency in their core software. Recently Yu and Shao proposed a logic-based \"type\" system for verifying concurrent assembly programs. Their thread model, however, is rather restrictive in that no threads can be created or terminated dynamically and no sharing of code is allowed between threads. In this paper, we present a new formal framework for verifying general multi-threaded assembly code with unbounded dynamic thread creation and termination as well as sharing of code between threads. We adapt and generalize the rely-guarantee methodology to the assembly level and show how to specify the semantics of thread \"fork\" with argument passing. In particular, we allow threads to have different assumptions and guarantees at different stages of their lifetime so they can coexist with the dynamically changing thread environment. Our work provides a foundation for certifying realistic multi-threaded programs and makes an important advance toward generating proof-carrying concurrent code.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086399", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/FengS05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086397", + "title": "Associated type synonyms", + "abstract": "Haskell programmers often use a multi-parameter type class in which one or more type parameters are functionally dependent on the first. Although such functional dependencies have proved quite popular in practice, they express the programmer's intent somewhat indirectly. Developing earlier work on associated data types, we propose to add functionally dependent types as type synonyms to type-class bodies. These associated type synonyms constitute an interesting new alternative to explicit functional dependencies.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086397", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "UNSW Sydney" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/ChakravartyKJ05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086385", + "title": "Qualified types for MLF", + "abstract": "MLF is a type system that extends a functional language with impredicative rank-n polymorphism. Type inference remains possible and only in some clearly defined situations, a local type annotation is required. Qualified types are a general concept that can accommodate a wide range of type systems extension, for example, type classes in Haskell. We show how the theory of qualified types can be used seamlessly with the higher-ranked impredicative polymorphism of MLF, and give a solution to the non-trivial problem of evidence translation in the presence of impredicative datatypes.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086385", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Utrecht University" + }, + { + "first_name": "Andres", + "last_name": "Löh", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/LeijenL05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086396", + "title": "Mechanizing the meta-theory of programming languages", + "abstract": "What does it mean for a programming language to exist? Usually languages are defined by an informal description augmented by a reference compiler whose behavior is regarded as normative. This approach works well so long as the one true implementation suffices, but as soon as we wish to have multiple compilers for the same language, we must agree on what the language is independently of its implementations. Most often this is accomplished through social processes such as standardization committees for building consensus.These processes have served us well, and will continue to be important for language design. But they are not sufficient to support the level of rigor required to prove theorems about languages and programs written in them. For that we need a semantics, which provides an objective foundation for such analyses, typically in the form of a type system and an operational semantics. But merely having such a rigorous definition for a language is not enough — it must be validated by a body of meta-theory that establishes its coherence and its consistency with expectations.But how are we to develop and maintain this body of theory? For full-scale languages the task is so onerous as to inhibit innovation and foster stagnation. The way forward is to take advantage of the recent advances in mechanized reasoning. By representing a language definition within a logical framework we may subject it to formal analysis, much as we use types to express and enforce crucial invariants in our programs. I will describe our use of the Twelf implementation of the LF logical framework, and discuss our successes and difficulties in using it as a tool for mechanizing the meta-theory of programming languages.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086396", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Harper05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086372", + "title": "Recursive type generativity", + "abstract": "Existential types provide a simple and elegant foundation for understanding generative abstract data types, of the kind supported by the Standard ML module system. However, in attempting to extend ML with support for recursive modules, we have found that the traditional existential account of type generativity does not work well in the presence of mutually recursive module definitions. The key problem is that, in recursive modules, one may wish to define an abstract type in a context where a name for the type already exists, but the existential type mechanism does not allow one to do so.We propose a novel account of recursive type generativity that resolves this problem. The basic idea is to separate the act of generating a name for an abstract type from the act of defining its underlying representation. To define several abstract types recursively, one may first \"forward-declare\" them by generating their names, and then define each one secretly within its own defining expression. Intuitively, this can be viewed as a kind of backpatching semantics for recursion at the level of types. Care must be taken to ensure that a type name is not defined more than once, and that cycles do not arise among \"transparent\" type definitions.In contrast to the usual continuation-passing interpretation of existential types in terms of universal types, our account of type generativity suggests a destination-passing interpretation. Briefly, instead of viewing a value of existential type as something that creates a new abstract type every time it is unpacked, we view it as a function that takes as input a pre-existing undefined abstract type and defines it. By leaving the creation of the abstract type name up to the client of the existential, our approach makes it significantly easier to link abstract data types together recursively.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086372", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/icfp/Dreyer05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086380", + "title": "A principled approach to operating system construction in Haskell", + "abstract": "We describe a monadic interface to low-level hardware features that is a suitable basis for building operating systems in Haskell. The interface includes primitives for controlling memory management hardware, user-mode process execution, and low-level device I/O. The interface enforces memory safety in nearly all circumstances. Its behavior is specified in part by formal assertions written in a programming logic called P-Logic. The interface has been implemented on bare IA32 hardware using the Glasgow Haskell Compiler (GHC) runtime system. We show how a variety of simple O/S kernels can be constructed on top of the interface, including a simple separation kernel and a demonstration system in which the kernel, window system, and all device drivers are written in Haskell.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086380", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Hallgren", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "Rebekah", + "last_name": "Leslie", + "institution": "Portland State University" + }, + { + "first_name": "Andrew", + "last_name": "Tolmach", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/HallgrenJLT05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086376", + "title": "A step-indexed model of substructural state", + "abstract": "The concept of a “unique” object arises in many emerging programming languages such as Clean, CQual, Cyclone, TAL, and Vault. In each of these systems, unique objects make it possible to perform operations that would otherwise be prohibited (e.g., deallocating an object) or to ensure that some obligation will be met (e.g., an opened file will be closed). However, different languages provide different interpretations of “uniqueness” and have different rules regarding how unique objects interact with the rest of the language. Our goal is to establish a common model that supports each of these languages, by allowing us to encode and study the interactions of the different forms of uniqueness. The model we provide is based on a substructural variant of the polymorphic λ-calculus, augmented with four kinds of mutable references: unrestricted, relevant, affine, and linear. The language has a natural operational semantics that supports deallocation of references, strong (type-varying) updates, and storage of unique objects in shared references. We establish the strong soundness of the type system by constructing a novel, semantic interpretation of the types. This technical report is really two documents in one: The first part is a paper appearing in the Tenth ACM SIGPLAN International Conference on Functional Programming (ICFP’05). The second part is a formal development of the language, step-indexed model, and soundness proof referenced in the first part. If you have already read a version of “A Step-Indexed Model of Substructural State”, then you should proceed directly to the appendices.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086376", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Harvard University Press" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Cornell University" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/icfp/AhmedFM05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086401", + "title": "A logical analysis of aliasing in imperative higher-order functions", + "abstract": "We present a compositional program logic for call-by-value imperative higher-order functions with general forms of aliasing, which can arise from the use of reference names as function parameters, return values, content of references and parts of data structures. The program logic extends our earlier logic for alias-free imperative higher-order functions with new modal operators which serve as building blocks for clean structural reasoning about programs and data structures in the presence of aliasing. This has been an open issue since the pioneering work by Cartwright-Oppen and Morris twenty-five years ago. We illustrate usage of the logic for description and reasoning through concrete examples including a higher-order polymorphic Quicksort. The logical status of the new operators is clarified by translating them into (in)equalities of reference names. The logic is observationally complete in the sense that two programs are observationally indistinguishable if they satisfy the same set of assertions.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086401", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Berger", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Kohei", + "last_name": "Honda", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/icfp/BergerHY05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086404", + "title": "PolyAML: a polymorphic aspect-oriented functional programming language", + "abstract": "This paper defines PolyAML, a typed functional, aspect-oriented programming language. The main contribution of PolyAML is the seamless integration of polymorphism, run-time type analysis and aspect-oriented programming language features. In particular, PolyAML allows programmers to define type-safe polymorphic advice using pointcuts constructed from a collection of polymorphic join points. PolyAML also comes equipped with a type inference algorithm that conservatively extends Hindley-Milner type inference. To support first-class polymorphic point-cut designators, a crucial feature for developing aspect-oriented profiling or logging libraries, the algorithm blends the conventional Hindley-Milner type inference algorithm with a simple form of local type inference.We give our language operational meaning via a type-directed translation into an expressive type-safe intermediate language. Many complexities of the source language are eliminated in this translation, leading to a modular specification of its semantics. One of the novelties of the intermediate language is the definition of polymorphic labels for marking control-flow points. These labels are organized in a tree structure such that a parent in the tree serves as a representative for all of its children. Type safety requires that the type of each child is less polymorphic than its parent type. Similarly, when a set of labels is assembled as a pointcut, the type of each label is an instance of the type of the pointcut.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086404", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel S.", + "last_name": "Dantas", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Geoffrey", + "last_name": "Washburn", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/DantasWWW05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086387", + "title": "High-level views on low-level representations", + "abstract": "This paper explains how the high-level treatment of datatypes in functional languages—using features like constructor functions and pattern matching—can be made to coexist with bitdata. We use this term to describe the bit- level representations of data that are required in the construction of many different applications, including operating systems, device drivers, and assemblers. We explain our approach as a combination of two language extensions, each of which could potentially be adapted to any modern functional language. The first adds simple and elegant constructs for manipulating raw bitfield values, while the second provides a view-like mechanism for defining distinct new bitdata types with fine-control over the underlying representation. Our design leverages polymorphic type inference, as well as techniques for improvement of qualified types, to track both the type and the width of bitdata structures. We have implemented our extensions in a small functional language interpreter, and used it to show that our approach can handle a wide range of practical bitdata types.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086387", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Iavor S.", + "last_name": "Diatchki", + "institution": "" + }, + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "" + }, + { + "first_name": "Rebekah", + "last_name": "Leslie", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/DiatchkiJL05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086390", + "title": "Backtracking, interleaving, and terminating monad transformers: (functional pearl)", + "abstract": "We design and implement a library for adding backtracking computations to any Haskell monad. Inspired by logic programming, our library provides, in addition to the operations required by the MonadPlus interface, constructs for fair disjunctions, fair conjunctions, conditionals, pruning, and an expressive top-level interface. Implementing these additional constructs is easy in models of backtracking based on streams, but not known to be possible in continuation-based models. We show that all these additional constructs can be generically and monadically realized using a single primitive msplit. We present two implementations of the library: one using success and failure continuations; and the other using control operators for manipulating delimited continuations.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086390", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "" + }, + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Harvard University Press" + }, + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "Indiana University" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/KiselyovSFS05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086403", + "title": "Monadic augment and generalised short cut fusion", + "abstract": "Monads are commonplace programming devices that are used to uniformly structure computations with effects such as state, exceptions, and I/O. This paper further develops the monadic programming paradigm by investigating the extent to which monadic computations can be optimised by using generalisations of short cut fusion to eliminate monadic structures whose sole purpose is to \"glue together\" monadic program components.We make several contributions. First, we show that every inductive type has an associated build combinator and an associated short cut fusion rule. Second, we introduce the notion of an inductive monad to describe those monads that give rise to inductive types, and we give examples of such monads which are widely used in functional programming. Third, we generalise the standard augment combinators and cata/augment fusion rules for algebraic data types to types induced by inductive monads. This allows us to give the first cata/augment rules for some common data types, such as rose trees. Fourth, we demonstrate the practical applicability of our generalisations by providing Haskell implementations for all concepts and examples in the paper. Finally, we offer deep theoretical insights by showing that the augment combinators are monadic in nature, and thus that our cata/build and cata/augment rules are arguably the best generally applicable fusion rules obtainable.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086403", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neil", + "last_name": "Ghani", + "institution": "University of Leicester" + }, + { + "first_name": "Patricia", + "last_name": "Johann", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Tarmo", + "last_name": "Uustalu", + "institution": "Cybernetica (Estonia)" + }, + { + "first_name": "Varmo", + "last_name": "Vene", + "institution": "University of Tartu" + } + ], + "dblp_key": "conf/icfp/GhaniJUV05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086405", + "title": "Aspectual Caml: an aspect-oriented functional language", + "abstract": "We propose an aspect-oriented programming (AOP) language called Aspectual Caml based on a strongly-typed functional language Objective Caml with two AOP mechanisms similar to those in AspectJ language. This paper describes the design and implementation issues of those AOP mechanisms that give us insights into the interaction between AOP features and common features in strongly-typed functional languages such as type inference, polymorphic types and curried functions. We implemented a prototype compiler of the language and used the language for separating crosscutting concerns in application programs, including for separating descriptions of a type system from compiler descriptions.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086405", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Hidehiko", + "last_name": "Masuhara", + "institution": "The University of Tokyo" + }, + { + "first_name": "Hideaki", + "last_name": "Tatsuzawa", + "institution": "The University of Tokyo" + }, + { + "first_name": "Akinori", + "last_name": "Yonezawa", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/icfp/MasuharaTY05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086393", + "title": "Continuations from generalized stack inspection", + "abstract": "Implementing first-class continuations can pose a challenge if the target machine makes no provisions for accessing and re-installing the run-time stack. In this paper, we present a novel translation that overcomes this problem. In the first half of the paper, we introduce a theoretical model that shows how to eliminate the capture and the use of first-class continuations in the presence of a generalized stack inspection mechanism. The second half of the paper explains how to translate this model into practice in two different contexts. First, we reformulate the servlet interaction language in the PLT Web server, which heavily relies on first-class continuations. Using our technique, servlet programs can be run directly under the control of non-cooperative web servers such as Apache. Second, we show how to use our new technique to copy and reconstitute the stack on MSIL.Net using exception handlers. This establishes that Scheme’s first-class continuations can exist on non-cooperative virtual machines.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086393", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Greg", + "last_name": "Pettyjohn", + "institution": "Universidad del Noreste" + }, + { + "first_name": "John", + "last_name": "Clements", + "institution": "Universidad del Noreste" + }, + { + "first_name": "Joe", + "last_name": "Marshall", + "institution": "Universidad del Noreste" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "John Brown University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/icfp/PettyjohnCMKF05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086367", + "title": "From ML type inference to stratified type inference", + "abstract": "Hindley and Milner's type system, in its purest form, allows what one might call full type inference. Even when a program contains no explicit type information, its very structure gives rise to a conjunction of type equations (or, more generally, to a constraint) whose resolution allows reconstructing the type of every variable and of every sub-expression. Actual programming languages based on this type system, such as Standard ML, Objective Caml, and Haskell, do allow users to provide explicit type information via optional type annotations. Yet, this extra information does not make type inference any easier: it simply gives rise to extra equations, leading to a more specific constraint.There are extensions of Hindley and Milner's type system where full type inference becomes undecidable or intractable. Then, it is common to require explicit type information, via mandatory type annotations. Polymorphic recursion is a simple and well-known instance of this phenomenon. This talk presents two more elaborate instances, commonly known as arbitrary-rank polymorphism and generalized algebraic data types.In both cases, type inference is made tractable thanks to mandatory type annotations. There is a twist, though: these required annotations are often numerous and redundant. So, it seems desirable to make them optional again, and to set up a distinct mechanism to guess some of the elided annotations. This mechanism, referred to as elaboration, can be heuristic. It must be predictable. In the two cases considered in this talk, it is a form of local type inference.This approach leads to a so-called stratified type inference system, where type information is propagated first in a local, ad hoc manner during elaboration, then in a possibly nonlocal, but well-specified manner during constraint solving. This appears to be one of the less displeasing ways of describing type inference systems that are able to exploit optional type annotations to infer better (or different) types.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086367", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Pottier05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086394", + "title": "Fast narrowing-driven partial evaluation for inductively sequential programs", + "abstract": "Narrowing-driven partial evaluation is a powerful technique for the specialization of (first-order) functional and functional logic programs. However, although it gives good results on small programs, it does not scale up well to realistic problems (e.g., interpreter specialization). In this work, we introduce a faster partial evaluation scheme by ensuring the termination of the process offline. For this purpose, we first characterize a class of programs which are quasi-terminating, i.e., the computations performed with needed narrowing—the symbolic computation mechanism of narrowing-driven partial evaluation—only contain finitely many different terms (and, thus, partial evaluation terminates). Since this class is quite restrictive, we also introduce an annotation algorithm for a broader class of programs so that they behave like quasi-terminating programs w.r.t. an extension of needed narrowing. Preliminary experiments are encouraging and demonstrate the usefulness of our approach.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086394", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "J. Guadalupe", + "last_name": "Ramos", + "institution": "" + }, + { + "first_name": "Josep", + "last_name": "Silva", + "institution": "Universitat Politècnica de València" + }, + { + "first_name": "Germán", + "last_name": "Vidal", + "institution": "Universitat Politècnica de València" + } + ], + "dblp_key": "conf/icfp/RamosSV05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086386", + "title": "Type inference, principal typings, and let-polymorphism for first-class mixin modules", + "abstract": "A mixin module is a programming abstraction that simultaneously generalizes λ-abstractions, records, and mutually recursive definitions. Although various mixin module type systems have been developed, no one has investigated principal typings or developed type inference for first-class mixin modules, nor has anyone added Milner's let-polymorphism to such a system.This paper proves that typability is NP-complete for the naive approach followed by previous mixin module type systems. Because a λ-calculus extended with record concatenation is a simple restriction of our mixin module calculus, we also prove the folk belief that typability is NP-complete for the naive early type systems for record concatenation.To allow feasible type inference, we present Martini, a new system of simple types for mixin modules with principal typings. Martini is conceptually simple, with no subtyping and a clean and balanced separation between unification-based type inference with type and row variables and constraint solving for safety of linking and field extraction. We have implemented a type inference algorithm and we prove its complexity to be O(n2), or O(n) given a fixed bound on the number of field labels. To prove the complexity, we need to present an algorithm for row unification that may have been implemented by others, but which we could not find written down anywhere. Because Martini has principal typings, we successfully extend it with Milner's let-polymorphism.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086386", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Henning", + "last_name": "Makholm", + "institution": "Technical University of Denmark" + }, + { + "first_name": "J. B.", + "last_name": "Wells", + "institution": "" + } + ], + "dblp_key": "conf/icfp/MakholmW05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086378", + "title": "AtomCaml: first-class atomicity via rollback", + "abstract": "We have designed, implemented, and evaluated AtomCaml, an extension to Objective Caml that provides a synchronization primitive for atomic (transactional) execution of code. A first-class primitive function of type (unit->'a)->'a evaluates its argument (which may call other functions, even external C functions) as though no other thread has interleaved execution. Our design ensures fair scheduling and obstruction-freedom. Our implementation extends the Objective Caml bytecode compiler and run-time system to support atomicity. A logging-and-rollback approach lets us undo uncompleted atomic blocks upon thread pre-emption, and retry them when the thread is rescheduled. The mostly functional nature of the Caml language and the Objective Caml implementation's commitment to a uniprocessor execution model (i.e., threads are interleaved, not executed simultaneously) allow particularly efficient logging. We have evaluated the efficiency and ease-of-use of AtomCaml by writing libraries and microbenchmarks, writing a small application, and replacing all locking with atomicity in an existing, large multithreaded application. Our experience indicates the performance overhead is negligible, atomic helps avoid synchronization mistakes, and idioms such as condition variables adapt reasonably to the atomic approach.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086378", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael F.", + "last_name": "Ringenburg", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/icfp/RingenburgG05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086379", + "title": "Witnessing side-effects", + "abstract": "We present a new approach to the old problem of adding side effects to purely functional languages. Our idea is to extend the language with \"witnesses,\" which is based on an arguably more pragmatic motivation than past approaches. We give a semantic condition for correctness and prove it is sufficient. We also give a static checking algorithm that makes use of a network flow property equivalent to the semantic condition.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086379", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/icfp/TerauchiA05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086368", + "title": "The anatomy of a loop: a story of scope and control", + "abstract": "Writing loops with tail-recursive function calls is the equivalent of writing them with goto's. Given that loop packages for Lisp-family languages have been around for over 20 years, it is striking that none have had much success in the Scheme world. I suggest the reason is that Scheme forces us to be precise about the scoping of the various variables introduced by our loop forms, something previous attempts to design ambitious loop forms have not managed to do.I present the design of a loop package for Scheme with a well-defined and natural scoping rule, based on a notion of control dominance that generalizes the standard lexical-scope rule of the λ-calculus. The new construct is powerful, clear, modular and extensible.The loop language is defined in terms of an underlying language for expressing control-flow graphs. This language itself has interesting properties as an intermediate representation.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086368", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/icfp/Shivers05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086374", + "title": "Dynamic optimization for functional reactive programming using generalized algebraic data types", + "abstract": "A limited form of dependent types, called Generalized Algebraic Data Types (GADTs), has recently been added to the list of Haskell extensions supported by the Glasgow Haskell Compiler. Despite not being full-fledged dependent types, GADTs still offer considerably enlarged scope for enforcing important code and data invariants statically. Moreover, GADTs offer the tantalizing possibility of writing more efficient programs since capturing invariants statically through the type system sometimes obviates entire layers of dynamic tests and associated data markup. This paper is a case study on the applications of GADTs in the context of Yampa, a domain-specific language for Functional Reactive Programming in the form of a self-optimizing, arrow-based Haskell combinator library. The paper has two aims. Firstly, to explore what kind of optimizations GADTs make possible in this context. Much of that should also be relevant for other domain-specific embedded language implementations, in particular arrow-based ones. Secondly, as the actual performance impact of the GADT-based optimizations is not obvious, to quantify this impact, both on tailored micro benchmarks, to establish the effectiveness of individual optimizations, and on two fairly large, realistic applications, to gauge the overall impact. The performance gains for the micro benchmarks are substantial. This implies that the Yampa API could be simplified as a number of \"pre-composed\" primitives that were there mainly for performance reasons are no longer needed. As to the applications, a worthwhile performance gain was obtained in one case whereas the performance was more or less unchanged in the other.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086374", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Henrik", + "last_name": "Nilsson", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/icfp/Nilsson05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086370", + "title": "Acute: high-level programming language design for distributed computation", + "abstract": "Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programminglanguage support for such systems, focussing on their typing and naming issues.We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility.These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086370", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "James J.", + "last_name": "Leifer", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Keith", + "last_name": "Wansbrough", + "institution": "University of Cambridge" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Mair", + "last_name": "Allen-Williams", + "institution": "University of Cambridge" + }, + { + "first_name": "Pierre", + "last_name": "Habouzit", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/SewellLWNAHV05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086383", + "title": "Simple, partial type-inference for System F based on type-containment", + "abstract": "We explore partial type-inference for System F based on type-containment. We consider both cases of a purely functional semantics and a call-by-value stateful semantics. To enable type-inference, we require higher-rank polymorphism to be user-specified via type annotations on source terms. We allow implicit predicative type-containment and explicit impredicative type-instantiation. We obtain a core language that is both as expressive as System F and conservative over ML. Its type system has a simple logical specification and a partial type-reconstruction algorithm that are both very close to the ones for ML. We then propose a surface language where some annotations may be omitted and rebuilt by some algorithmically defined but logically incomplete elaboration mechanism.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086383", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Remy05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086371", + "title": "An expressive language of signatures", + "abstract": "Current languages allow a programmer to describe an interface only by enumerating its parts, possibly including other interfaces wholesale. Such languages cannot express relationships between interfaces, yet when independently developed software components are combined into a larger system, significant relationships arise.To address this shortcoming, we define, as a conservative extension of ML, a language for manipulating interfaces. Our language includes operations for adding, renaming, and removing components; for changing the type associated with a value; for making manifest types abstract and vice versa; and for combining interfaces. These operations can express useful relationships among interfaces. We have defined a formal semantics in which an interface denotes a group of four sets; we show how these sets determine a subtyping relation, and we sketch the elaboration of an interface into its denotation.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086371", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Harvard University" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "AT&T (United States)" + }, + { + "first_name": "Paul", + "last_name": "Govereau", + "institution": "Harvard University" + } + ], + "dblp_key": "conf/icfp/RamseyFG05", + "venue": "icfp", + "year": 2005 + }, + { + "paper_id": "10.1145/1086365.1086400", + "title": "A language-based approach to functionally correct imperative programming", + "abstract": "In this paper a language-based approach to functionally correct imperative programming is proposed. The approach is based on a programming language called RSP1, which combines dependent types, general recursion, and imperative features in a type-safe way, while preserving decidability of type checking. The methodology used is that of internal verification, where programs manipulate programmer-supplied proofs explicitly as data. The fundamental technical idea of RSP1 is to identify problematic operations as impure, and keep them out of dependent types. The resulting language is powerful enough to verify statically non-trivial properties of imperative and functional programs. The paper presents the ideas through the examples of statically verified merge sort, statically verified imperative binary search trees, and statically verified directed acyclic graphs.", + "date": "2005-09-12", + "link": "https://doi.org/10.1145/1086365.1086400", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Edwin M.", + "last_name": "Westbrook", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Aaron", + "last_name": "Stump", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Ian", + "last_name": "Wehrman", + "institution": "Washington University in St. Louis" + } + ], + "dblp_key": "conf/icfp/WestbrookSW05", + "venue": "icfp", + "year": 2005 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2006.json b/data/pl_conferences/icfp/2006.json new file mode 100644 index 0000000..bea69dd --- /dev/null +++ b/data/pl_conferences/icfp/2006.json @@ -0,0 +1,638 @@ +[ + { + "paper_id": "10.1145/1159803.1159841", + "title": "Abstraction preservation and subtyping in distributed languages", + "abstract": "In most programming languages, type abstraction is guaranteed by syntactic scoping in a single program, but is not preserved by marshalling during distributed communication. A solution is to generate hash types at compile time that consist of a fingerprint of the source code implementing the data type. These hash types can be tupled with a marshalled value and compared efficiently at unmarshall time to guarantee abstraction safety. In this paper, we extend a core calculus of ML-like modules, functions, distributed communication, and hash types, to integrate structural subtyping, user-declared subtyping between abstract types, and bounded existential types. Our semantics makes two contributions: (1) the explicit tracking of the interaction between abstraction boundaries and subtyping; (2) support for user-declared module upgrades with propagation of the resulting subhashing relation throughout the network during communication. We prove type preservation, progress, determinacy, and erasure for our system.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159841", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pierre-Malo", + "last_name": "Deniélou", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "James J.", + "last_name": "Leifer", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/DenielouL06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159805", + "title": "The development of Chez Scheme", + "abstract": "Chez Scheme is now over 20 years old, the first version having been released in 1985. This paper takes a brief look back on the history of Chez Scheme's development to explore how and why it became the system it is today.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159805", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Cadence Design Systems (United States)" + } + ], + "dblp_key": "conf/icfp/Dybvig06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159823", + "title": "Modelling deterministic concurrent I/O", + "abstract": "The problem of expressing I/O and side effects in functional languages is a well-established one. This paper addresses this problem from a general semantic viewpoint by giving a unified framework for describing shared state, I/O and deterministic concurrency. We develop a modified state transformer which lets us mathematically model the API, then investigate and machine verify some broad conditions under which confluence holds. This semantics is used as the basis for a small deterministic Haskell language extension called CURIO, which enforces determinism using runtime checks.Our confluence condition is first shown to hold for a variety of small components, such as individual shared variables, 1-to-1 communication channels, and I-structures. We then show how models of substantial APIs (like a modification of Haskell's file I/O API which permits inter-process communication) may be constructed from these smaller components using \"combinators\" in such a way that determinism is always preserved. We describe combinators for product, name-indexing and dynamic allocation, the last of which requires some small extensions to cater for process locality.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159823", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Malcolm", + "last_name": "Dowse", + "institution": "" + }, + { + "first_name": "Andrew", + "last_name": "Butterfield", + "institution": "" + } + ], + "dblp_key": "conf/icfp/DowseB06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159829", + "title": "OCaml + XDuce", + "abstract": "This paper presents the core type system and type inference algorithm of OCamlDuce, a merger between OCaml and XDuce. The challenge was to combine two type checkers of very different natures while preserving the best properties of both (principality and automatic type reconstruction on one side; very precise types and implicit subtyping on the other side). Type inference can be described by two successive passes: the first one is an ML-like unification-based algorithm which also extracts data flow constraints about XML values; the second one is an XDuce-like algorithm which computes XML types in a direct way. An optional preprocessing pass, called strengthening, can be added to allow more implicit use of XML subtyping. This pass is also very similar to an ML type checker.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159829", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alain", + "last_name": "Frisch", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Frisch06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159839", + "title": "Access control in a core calculus of dependency", + "abstract": "The Dependency Core Calculus (DCC) is an extension of the computational lambda calculus that was designed in order to capture the notion of dependency that arises in information-flow control, partial evaluation, and other programming-language settings. We show that, unexpectedly, DCC can also be used as a calculus for access control in distributed systems. Initiating the study of DCC from this perspective, we explore some of its appealing properties.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159839", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/Abadi06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159825", + "title": "Modular development of certified program verifiers with a proof assistant", + "abstract": "I report on an experience using the Coq proof assistant to develop a program verification tool with a machine-checkable proof of full correctness. The verifier is able to prove memory safety of x86 machine code programs compiled from code that uses algebraic datatypes. The tool's soundness theorem is expressed in terms of the bit-level semantics of x86 programs, so its correctness depends on very few assumptions. I take advantage of Coq's support for programming with dependent types and modules in the structure of my development. The approach is based on developing a library of reusable functors for transforming a verifier at one level of abstraction into a verifier at a lower level. Using this library, it's possible to prototype a verifier based on a new type system with a minimal amount of work, while obtaining a very strong soundness theorem about the final product.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159825", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/icfp/Chlipala06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159821", + "title": "Transactional events", + "abstract": "Concurrent programs require high-level abstractions in order to manage complexity and enable compositional reasoning. In this paper, we introduce a novel concurrency abstraction, dubbed transactional events, which combines first-class synchronous messagepassing events with all-or-nothing transactions. This combination enables simple solutions to interesting problems in concurrent programming. For example, guarded synchronous receive can be implemented as an abstract transactional event, whereas in other languages it requires a non-abstract, non-modular protocol. Likewise, three-way rendezvous can also be implemented as an abstract transactional event, which is impossible using first-class events alone. Both solutions are easy to code and easy to reason about.The expressive power of transactional events arises from a sequencing combinator whose semantics enforces an all-or-nothing transactional property - either both of the constituent events synchronize in sequence or neither of them synchronizes. This sequencing combinator, along with a non-deterministic choice combinator, gives transactional events the compositional structure of a monad-with-plus. We provide a formal semantics for and a preliminary implementation of transactional events.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159821", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "K.", + "last_name": "Donnelly", + "institution": "" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/icfp/DonnellyF06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159836", + "title": "Extensible programming with first-class cases", + "abstract": "We present language mechanisms for polymorphic, extensible records and their exact dual, polymorphic sums with extensible first-class cases. These features make it possible to easily extend existing code with new cases. In fact, such extensions do not require any changes to code that adheres to a particular programming style. Using that style, individual extensions can be written independently and later be composed to form larger components. These language mechanisms provide a solution to the expression problem.We study the proposed mechanisms in the context of an implicitly typed, purely functional language PolyR. We give a type system for the language and provide rules for a 2-phase transformation: first into an explicitly typed λ-calculus with record polymorphism, and finally to efficient index-passing code. The first phase eliminates sums and cases by taking advantage of the duality with records.We implement a version of PolyR extended with imperative features and pattern matching - we call this language MLPolyR. Programs in MLPolyR require no type annotations - the implementation employs a reconstruction algorithm to infer all types. The compiler generates machine code (currently for PowerPC) and optimizes the representation of sums by eliminating closures generated by the dual construction.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159836", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "M.", + "last_name": "Blume", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Wonseok", + "last_name": "Chae", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/icfp/BlumeAC06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159811", + "title": "Simple unification-based type inference for GADTs", + "abstract": "Generalized algebraic data types (GADTs), sometimes known as “guarded recursive data types ” or “first-class phantom types”, are a simple but powerful generalization of the data types of Haskell and ML. Recent works have given compelling examples of the utility of GADTs, although type inference is known to be difficult. Our contribution is to show how to exploit programmer-supplied type annotations to make the type inference task almost embarrassingly easy. Our main technical innovation is wobbly types, which express in a declarative way the uncertainty caused by the incremental nature of typical type-inference algorithms. 1.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159811", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Geoffrey", + "last_name": "Washburn", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/JonesVWW06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159817", + "title": "Static analysis for syntax objects", + "abstract": "We describe an s-expression based syntax-extension framework much like Scheme macros, with a key additional facility: the ability to define static semantics, such as type systems or program analysis, for the new, user-defined forms or embedded languages, thus allowing us to construct \"towers\" of language levels. In addition, the static semantics of the languages at two adjacent levels in the tower can be connected, allowing improved reasoning power at a higher (and perhaps more restricted) level to be reflected down to the static semantics of the language level below. We demonstrate our system by designing macros for an assembly language, together with some example static analyses (termination analysis, type inference and control-flow analysis).", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159817", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Fisher", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/icfp/FisherS06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159835", + "title": "Algebraic fusion of functions with an accumulating parameter and its improvement", + "abstract": "We present a unifying solution to the problem of fusion of functions, where both the producer function and the consumer function have one accumulating parameter. The key idea in this development is to formulate the producer function as a function which computes over a monoid of data contexts. Upon this formulation, we develop a fusion method called algebraic fusion based on the elementary theory of universal algebra and monoids. The producer function is fused with a monoid homomorphism that is derived from the definition of the consumer function, and is turned into a higher-order function f that computes over the monoid of endofunctions.We then introduce a general concept called improvement, in order to reduce the cost of computing over the monoid of endofunctions (i. e., function closures). An improvement of the function f via a monoid homomorphism h is a function g that satisfies f =h ºg. This provides a principled way of finding a first-order function representing a solution to the fusion problem. It also presents a clean and unifying account for varying fusion methods that have been proposed so far. Furthermore, we show that our method extends to support partial and infinite data structures, by means of an appropriate monoid structure.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159835", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "Kyoto University" + }, + { + "first_name": "Susumu", + "last_name": "Nishimura", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/icfp/KatsumataN06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159808", + "title": "Delimited dynamic binding", + "abstract": "Dynamic binding and delimited control are useful together in many settings, including Web applications, database cursors, and mobile code. We examine this pair of language features to show that the semantics of their interaction is ill-defined yet not expressive enough for these uses.We solve this open and subtle problem. We formalise a typed language DB+DC that combines a calculus DB of dynamic binding and a calculus DC of delimited control. We argue from theoretical and practical points of view that its semantics should be based on delimited dynamic binding: capturing a delimited continuation closes over part of the dynamic environment, rather than all or none of it; reinstating the captured continuation supplements the dynamic environment, rather than replacing or inheriting it. We introduce a type- and reduction-preserving translation from DB + DC to DC, which proves that delimited control macro-expresses dynamic binding. We use this translation to implement DB+DC in Scheme, OCaml, and Haskell.We extend DB + DC with mutable dynamic variables and a facility to obtain not only the latest binding of a dynamic variable but also older bindings. This facility provides for stack inspection and (more generally) folding over the execution context as an inductive data structure.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159808", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "" + }, + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Rutgers Sexual and Reproductive Health and Rights" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/KiselyovSS06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159834", + "title": "A pattern for almost compositional functions", + "abstract": "This paper introduces a pattern for almost compositional functions over recursive data types, and over families of mutually recursive data types. Here \"almost compositional\" means that for a number of the constructors in the type(s), the result of the function depends only on the constructor and the results of calling the function on the constructor's arguments. The pattern consists of a generic part constructed once for each data type or family of data types, and a task-specific part. The generic part contains the code for the predictable compositional cases, leaving the interesting work to the task-specific part. Examples of the pattern implemented in dependent type theory with inductive families, in Haskell with generalized algebraic data types and rank-2 polymorphism, and in Java using a variant of the Visitor design pattern are given. The relationship to the \"Scrap Your Boilerplate\" approach to generic programming, and to general tree types in dependent type theory are also investigated.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159834", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Björn", + "last_name": "Bringert", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Aarne", + "last_name": "Ranta", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/BringertR06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159830", + "title": "biXid: a bidirectional transformation language for XML", + "abstract": "Often, independent organizations define and advocate different XML formats for a similar purpose and, as a result, application programs need to mutually convert between such formats. Existng XML transformation languages, such as XSLT and XDuce, are unsatisfactory for this purpose since we would have to write, e.g., two programs for the forward and the backward transformations in case of two formats, incur high developing and maintenance costs.This paper proposes the bidirectional XML transformation language biXid, allowing us to write only one program for both directions of conversion. Our language adopts a common paradigm programming-by-relation, where a program defines a relation over documents and transforms a document to another in a way satisfying this relation. Our contributions here are specific language features for facilitating realistic conversions whose target formats are loosely in parallel but have many discrepancies in details. Concretely, we (1) adopt XDuce-style regular expression patterns for describing and analyzing XML structures, (2) fully permit ambiguity for treating formats that do not have equivalent expressivenesses, and (3) allow non-linear pattern variables for expressing non-trivial transformations that cannot be written only with linear patterns, such as conversion between unordered and ordered data.We further develop an efficient evaluation algorithm for biXid, consisting of the \"parsing\" phase that transforms the input document to an intermediate \"parse tree\" structure and the \"unparsing\" phase that transforms it to an output document. Both phases use a variant of finite tree automata for performing a one-pass scan on the input or the parse tree by using a standard technique that \"maintains the set of all transitable states.\" However, the construction of the \"unparsing\" phase is challenging since ambiguity causes different ways of consuming the parse tree and thus results in multiple possible outputs that may have different structures.We have implemented a prototype system of biXid and confirmed that it has enough expressiveness and a linear-time performance from experiments with several realistic bidirectional transformations including one between vCard-XML and ContactXML.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159830", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Shinya", + "last_name": "Kawanaka", + "institution": "IBM (United States)" + }, + { + "first_name": "Haruo", + "last_name": "Hosoya", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/icfp/KawanakaH06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159826", + "title": "Mechanized meta-reasoning using a hybrid HOAS/de bruijn representation and reflection", + "abstract": "We investigate the development of a general-purpose framework for mechanized reasoning about the meta-theory of programming languages. In order to provide a standard, uniform account of a programming language, we propose to define it as a logic in a logical framework, using the same mechanisms for definition, reasoning, and automation that are available to other logics. Then, in order to reason about the language's meta-theory, we use reflection to inject the programming language into (usually richer and more expressive) meta-theory.One of the key features of our approach is that structure of the language is preserved when it is reflected, including variables, meta-variables, and binding structure. This allows the structure of proofs to be preserved as well, and there is a one-to-one map from proof steps in the original programming logic to proof steps in the reflected logic. The act of reflecting a language is automated; all definitions, theorems, and proofs are preserved by the transformation and all the key lemmas (such as proof and structural induction) are automatically derived.The principal representation used by the reflected logic is higher-order abstract syntax (HOAS). However, reasoning about terms in HOAS can be awkward in some cases, especially for variables. For this reason, we define a computationally equivalent variable-free de Bruijn representation that is interchangeable with the HOAS in all contexts. The de Bruijn representation inherits the properties of substitution and alpha-equality from the logical framework, and it is not complicated by administrative issues like variable renumbering.We further develop the concepts and principles of proofs, provability, and structural and proof induction. This work is fully implemented in the MetaPRL theorem prover. We illustrate with an application to F<: as defined in the POPLmark challenge.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159826", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jason", + "last_name": "Hickey", + "institution": "California Institute of Technology" + }, + { + "first_name": "Aleksey", + "last_name": "Nogin", + "institution": "California Institute of Technology" + }, + { + "first_name": "Xin", + "last_name": "Yu", + "institution": "California Institute of Technology" + }, + { + "first_name": "Alexei", + "last_name": "Kopylov", + "institution": "California Institute of Technology" + } + ], + "dblp_key": "conf/icfp/HickeyNYK06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159840", + "title": "Programming monads operationally with Unimo", + "abstract": "Monads are widely used in Haskell for modeling computational effects, but defining monads remains a daunting challenge. Since every part of a monad's definition depends on its computational effects, programmers cannot leverage the common behavior of all monads easily and thus must build from scratch each monad that models a new computational effect.I propose the Unimo framework which allows programmers to define monads and monad transformers in a modular manner. Unimo contains a heavily parameterized observer function which enforces the monad laws, and programmers define a monad by invoking the observer function with arguments that specify the computational effects of the monad. Since Unimo provides the common behavior of all monads in a reusable form, programmers no longer need to rebuild the semantic boilerplate for each monad and can instead focus on the more interesting and rewarding task of modeling the desired computational effects.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159840", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chuan-kai", + "last_name": "Lin", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/Lin06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159807", + "title": "Improving flow analyses via GammaCFA: abstract garbage collection and counting", + "abstract": "We present two independent and complementary improvements for flow-based analysis of higher-order languages: (1) abstract garbage collection and (2) abstract counting, collectively titled ΓCFA.Abstract garbage collection is an analog to its concrete counterpart: we determine when an abstract resource has become unreachable, and then reallocate it as fresh. This prevents flow sets from merging in the abstract, which has two immediate effects: (1) the precision of the analysis is increased, and (2) the running time of the analysis is frequently reduced. In some nontrivial cases, we achieve an order of magnitude improvement in precision and time simultaneously.In abstract counting, we track how many times an abstract resource has been allocated. A count of one implies that the abstract resource momentarily represents only one concrete resource. This, in turn, allows us to perform environment analysis and to expand the kinds (rather than just the degree) of optimizations available to the compiler.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159807", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/icfp/MightS06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159815", + "title": "From structures and functors to modules and units", + "abstract": "Component programming techniques encourage abstraction and reuse through external linking. Some parts of a program, however, must use concrete, internally specified references, so a pure component system is not a sufficient mechanism for structuring programs. We present the combination of a static, internally-linked module system and a purely abstractive component system. The latter extends our previous model of typed units to properly account for translucency and sharing. We also show how units and modules can express an SML-style system of structures and functors, and we explore the consequences for recursive structures and functors.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159815", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/icfp/OwensF06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159813", + "title": "Recursive modules for programming", + "abstract": "TheML module system is useful for building large-scale programs. The programmer can factor programs into nested and parameterized modules, and can control abstraction with signatures. Yet ML prohibits recursion between modules. As a result of this constraint, the programmer may have to consolidate conceptually separate components into a single module, intruding on modular programming. Introducing recursive modules is a natural way out of this predicament. Existing proposals, however, vary in expressiveness and verbosity. In this paper, we propose a type system for recursive modules, which can infer their signatures. Opaque signatures can also be given explicitly, to provide type abstraction either inside or outside the recursion. The type system is decidable, and is sound for a call-by-value semantics. We also present a solution to the expression problem, in support of our design choices.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159813", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Keiko", + "last_name": "Nakata", + "institution": "Kyoto University" + }, + { + "first_name": "Jacques", + "last_name": "Garrigue", + "institution": "Nagoya University" + } + ], + "dblp_key": "conf/icfp/NakataG06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159832", + "title": "Fifteen years of functional pearls", + "abstract": "In 1991, when the Journal of Functional Programming was inaugurated, the editors, Simon Peyton Jones and Philip Wadler, asked me to contribute a regular column to be called Functional Pearls. The idea was to emulate the very successful series of essays that Jon Bentley had written under the title Programming Pearls in the Communications of the ACM. A possible alternative model for the column was Martin Rem's Small Programming Exercises that appeared regularly in the Science of Computer Programming in the 1980s. In Rem's articles, various programming tasks were posed in one issue, and solved in the subsequent one. It was felt that similar material could be adapted to a functional style, using equational reasoning rather than the Dijkstra-Hoare framework to derive the final product. After all, one reason that functional programming stimulated the interest of many at that time was that it was good for equational reasoning, a slogan captured in Mark Jone's GOFER system (Good For Equational Reasoning).I agreed to the suggestion, but only under the proviso that other contributors to the column should be sought. Counting to the end of the present year, 2006, about 64 pearls will have appeared in JFP, of which I have written 14. There are also various pearls that have been presented at ICFP and at MPC (Mathematics of Program Construction). The pearls range in content, from (hopefully) instructive exercises in program calculation - my own area of interest, to attractive presentations of new functional data structures - of which Ralf Hinze and Chris Okasaki were the main contributors, as well as interesting algorithms in their own right, such as Runciman's Lazy wheel sieves, and Huet's Zipper.This talk will review a little of the history of Functional Pearls, and tentatively try to suggest what ingredients make a good pearl and how pearls differ from normal research papers. Indeed, my brief from the Program Chair for this talk was expressed as follows: \"Well done Functional Pearls are often the highlight of an ICFP conference, but many of the submitted ones somehow miss the mark, by being too trivial, too complicated, or somehow not quite the elegant solution one hopes for. So it would be interesting to hear about your experiences as to what makes a good one and how to go about creating it.Having accepted this daunting commission, and being mindful of Horace's remark that good advice should be short, I am now busily engaged in finding a pearl that is not too trivial, nor too complicated, and is sufficiently elegant to serve as a decent example, both to illustrate the talk and to provide some technical content.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159832", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Richard", + "last_name": "Bird", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/Bird06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159816", + "title": "The missing link: dynamic components for ML", + "abstract": "Despite its powerful module system, ML has not yet evolved for the modern world of dynamic and open modular programming, to which more primitive languages have adapted better so far. We present the design and semantics of a simple yet expressive firstclass component system for ML. It provides dynamic linking in a type-safe and type-flexible manner, and allows selective execution in sandboxes. The system is defined solely by reduction to higherorder modules plus an extension with simple module-level dynamics, which we call packages. To represent components outside processes we employ generic pickling. We give a module calculus formalising the semantics of packages and pickling.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159816", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/icfp/Rossberg06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159819", + "title": "Practical proofs of concurrent programs", + "abstract": "Invited Talk", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159819", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marc", + "last_name": "Shapiro", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Shapiro06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159838", + "title": "Boxy types: inference for higher-rank types and impredicativity", + "abstract": "Languages with rich type systems are beginning to employ a blend of type inference and type checking, so that the type inference engine is guided by programmer-supplied type annotations. In this paper we show, for the first time, how to combine the virtues of two well-established ideas: unification-based inference, and bidi-rectional propagation of type annotations. The result is a type system that conservatively extends Hindley-Milner, and yet supports both higher-rank types and impredicativity.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159838", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/VytiniotisWJ06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159827", + "title": "Equality of streams is a Pi0 over 2-complete problem", + "abstract": "This paper gives a precise characterization for the complexity of the problem of proving equal two streams defined with a finite number of equations: Π0 over 2. Since the Π 0 over 2 class includes properly both the reursively enumerable and the corecursively enumerable classes, this result implies that neither the set of pairs of equal streams nor the set of pairs of unequal streams is recursively enumerable. Consequently, one can find no algorithm for determining equality of streams, as well as no algorithm for determining inequality of streams. In particular, there is no complete proof system for equality of streams and no complete system for inequality of streams.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159827", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/icfp/Rosu06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159812", + "title": "Polymorphism and separation in hoare type theory", + "abstract": "In previous work, we proposed a Hoare Type Theory (HTT) which combines effectful higher-order functions, dependent types and Hoare Logic specifications into a unified framework. However, the framework did not support polymorphism, and ailed to provide a modular treatment of state in specifications. In this paper, we address these shortcomings by showing that the addition of polymorphism alone is sufficient for capturing modular state specifications in the style of Separation Logic. Furthermore, we argue that polymorphism is an essential ingredient of the extension, as the treatment of higher-order functions requires operations not encodable via the spatial connectives of Separation Logic.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159812", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "Harvard University Press" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/NanevskiMB06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159809", + "title": "Static typing for a faulty lambda calculus", + "abstract": "A transient hardware fault occurs when an energetic particle strikes a transistor, causing it to change state. These faults do not cause permanent damage, but may result in incorrect program execution by altering signal transfers or stored values. While the likelihood that such transient faults will cause any significant damage may seem remote, over the last several years transient faults have caused costly failures in high-end machines at America Online, eBay, and the Los Alamos Neutron Science Center, among others [6, 44, 15]. Because susceptibility to transient faults is proportional to the size and density of transistors, the problem of transient faults will become increasingly important in the coming decades.This paper defines the first formal, type-theoretic framework for studying reliable computation in the presence of transient faults. More specifically, it defines λzap, a lambda calculus that exhibits intermittent data faults. In order to detect and recover from these faults, λzap programs replicate intermediate computations and use majority voting, thereby modeling software-based fault tolerance techniques studied extensively, but informally [10, 20, 30, 31, 32, 33, 41].To ensure that programs maintain the proper invariants and use λzap primitives correctly, the paper defines a type system for the language. This type system guarantees that well-typed programs can tolerate any single data fault. To demonstrate that λzap can serve as an idealized typed intermediate language, we define a type-preserving translation from a standard simply-typed lambda calculus into λzap.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159809", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Lester", + "last_name": "Mackey", + "institution": "Princeton University" + }, + { + "first_name": "Jay", + "last_name": "Ligatti", + "institution": "Princeton University" + }, + { + "first_name": "George A.", + "last_name": "Reis", + "institution": "Princeton University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/icfp/WalkerMLRA06", + "venue": "icfp", + "year": 2006 + }, + { + "paper_id": "10.1145/1159803.1159822", + "title": "Stabilizers: a modular checkpointing abstraction for concurrent functional programs", + "abstract": "Transient faults that arise in large-scale software systems can often be repaired by re-executing the code in which they occur. Ascribing a meaningful semantics for safe re-execution in multi-threaded code is not obvious, however. For a thread to correctly rexecute a region of code, it must ensure that all other threads which have witnessed its unwanted effects within that region are also reverted to a meaningful earlier state. If not done properly, data inconsistencies and other undesirable behavior may result. however, automatically determining what constitutes a consistent global checkpoint is not straightforward since thread interactions are a dynamic property of the program.In this paper, we present a safe and efficient checkpointing mechanism for Concurrent ML (CML) that can be used to recover from transient faults. We introduce a new linguistic abstraction called stabilizers that permits the specification of per-thread monitors and the restoration of globally consistent checkpoints. Safe global states are computed through lightweight monitoring of communication events among threads (e.g. message-passing operations or updates to shared variables).Our experimental results on several realistic, multithreaded, server-style CML applications, including a web server and a windowing toolkit, show that the overheads to use stabilizers are small, and lead us to conclude that they are a viable mechanism for defining safe checkpoints in concurrent functional programs.", + "date": "2006-09-16", + "link": "https://doi.org/10.1145/1159803.1159822", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lukasz", + "last_name": "Ziarek", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Philip", + "last_name": "Schatz", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/icfp/ZiarekSJ06", + "venue": "icfp", + "year": 2006 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2007.json b/data/pl_conferences/icfp/2007.json new file mode 100644 index 0000000..3d513c7 --- /dev/null +++ b/data/pl_conferences/icfp/2007.json @@ -0,0 +1,819 @@ +[ + { + "paper_id": "10.1145/1291151.1291187", + "title": "User-friendly functional programming for web mashups", + "abstract": "MashMaker is a web-based tool that makes it easy for a normal user to create web mashups by browsing around, without needing to type, or plan in advance what they want to do.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291187", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Rob", + "last_name": "Ennals", + "institution": "Intel (United States)" + }, + { + "first_name": "David", + "last_name": "Gay", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/icfp/EnnalsG07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291184", + "title": "Experience report: using functional programming to manage a linux distribution", + "abstract": "We report on our experience using functional programming languages in the development of a commercial GNU/Linux distribution, discussing features of several significant systems: hardware detection and system configuration; OS installer CD creation; package compilation and management. Static typing helps compensate for the lack of a complete testing lab and helps us be effective with a very small team. Most importantly, we believe that going beyond merely using functional languages to using purely functional designs really helps to create simple, effective tools.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291184", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Clifford", + "last_name": "Beshers", + "institution": "Linde (United States)" + }, + { + "first_name": "David L.", + "last_name": "Fox", + "institution": "Linde (United States)" + }, + { + "first_name": "Jeremy", + "last_name": "Shaw", + "institution": "Linde (United States)" + } + ], + "dblp_key": "conf/icfp/BeshersFS07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291163", + "title": "Tangible functional programming", + "abstract": "We present a user-friendly approach to unifying program creation and execution, based on a notion of \"tangible values\" (TVs), which are visual and interactive manifestations of pure values, including functions. Programming happens by gestural composition of TVs. Our goal is to give end-users the ability to create parameterized, composable content without imposing the usual abstract and linguistic working style of programmers. We hope that such a system will put the essence of programming into the hands of many more people, and in particular people with artistic/visual creative style.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291163", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Elliott07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291171", + "title": "McErlang: a model checker for a distributed functional programming language", + "abstract": "We present a model checker for verifying distributed programs written in the Erlang programming language. Providing a model checker for Erlang is especially rewarding since the language is by now being seen as a very capable platform for developing industrial strength distributed applications with excellent failure tolerance characteristics. In contrast to most other Erlang verification attempts, we provide support for a very substantial part of the language. The model checker has full Erlang data type support, support for general process communication, node semantics (inter-process behave subtly different from intra-process communication), fault detection and fault tolerance through process linking, and can verify programs written using the OTP Erlang component library (used by most modern Erlang programs).", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291171", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lars‐Åke", + "last_name": "Fredlund", + "institution": "Universidad Politécnica de Madrid" + }, + { + "first_name": "H.", + "last_name": "Svensson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/FredlundS07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291190", + "title": "Experience report: a Haskell interpreter for cellML", + "abstract": "In this paper we present our use of functional programming (FP), specifically Haskell, to provide an operational semantics for a domain-specific language, CellML, that describes mathematical models of biological processes. We analyse the benefits and shortcomings of this approach, in comparison with other semantic definitions for CellML.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291190", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Cooper", + "institution": "University of Oxford" + }, + { + "first_name": "Steve", + "last_name": "McKeever", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/CooperM07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291196", + "title": "A type system for recursive modules", + "abstract": "There has been much work in recent years on extending ML with recursive modules. One of the most difficult problems in the development of such an extension is the double vision problem, which concerns the interaction of recursion and data abstraction. In previous work, I defined a type system called RTG, which solves the double vision problem at the level of a System-F-style core calculus. In this paper, I scale the ideas and techniques of RTG to the level of a recursive ML-style module calculus called RMC, thus establishing that no tradeoff between data abstraction and recursive modules is necessary. First, I describe RMC’s typing rules for recursive modules informally and discuss some of the design questions that arose in developing them. Then, I present the formal semantics of RMC, which is interesting in its own right. The formalization synthesizes aspects of both the Definition and the Harper-Stone interpretation of Standard ML, and includes a novel two-pass algorithm for recursive module typechecking in which the coherence of the two passes is emphasized by their representation in terms of the same set of inference rules.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291196", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/icfp/Dreyer07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291186", + "title": "Experience report: building an eclipse-based IDE for Haskell", + "abstract": "This paper summarizes experiences from an open source project that builds a free Haskell IDE based on Eclipse (an open source IDE platform). Eclipse is extensible and has proved to be a good basis for IDEs for several programming languages. Difficulties arise mainly because it is written in Java and requires extensions to be written in Java. This made it hard to reuse existing development tools implemented in Haskell, and turned out to be a considerable obstacle to finding contributors. Several approaches to resolve these issues are described and their advantages and disadvantages discussed.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291186", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Leif", + "last_name": "Frenzel", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Frenzel07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291199", + "title": "Stream fusion: from lists to streams to nothing at all", + "abstract": "This paper presents an automatic deforestation system, stream fusion, based on equational transformations, that fuses a wider range of functions than existing short-cut fusion systems. In particular, stream fusion is able to fuse zips, left folds and functions over nested lists, including list comprehensions. A distinguishing feature of the framework is its simplicity: by transforming list functions to expose their structure, intermediate values are eliminated by general purpose compiler optimisations.We have reimplemented the Haskell standard List library on top of our framework, providing stream fusion for Haskell lists. By allowing a wider range of functions to fuse, we see an increase in the number of occurrences of fusion in typical Haskell programs. We present benchmarks documenting time and space improvements.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291199", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Duncan", + "last_name": "Coutts", + "institution": "University of Oxford" + }, + { + "first_name": "Roman", + "last_name": "Leshchinskiy", + "institution": "UNSW Sydney" + }, + { + "first_name": "Don", + "last_name": "Stewart", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/icfp/CouttsLS07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291189", + "title": "A generic usage analysis with subeffect qualifiers", + "abstract": "Sharing analysis and uniqueness typing are static analyses that aim at determining which of a program's objects are to be used at most once. There are many commonalities between these two forms of usage analysis. We make their connection precise by developing an expressive generic analysis that can be instantiated to both sharing analysis and uniqueness typing. The resulting system, which combines parametric polymorphism with effect subsumption, is specified within the general framework of qualified types, so that readily available tools and techniques can be used for the development of implementations and metatheory.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291189", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jurriaan", + "last_name": "Hage", + "institution": "Utrecht University" + }, + { + "first_name": "Stefan", + "last_name": "Holdermans", + "institution": "Utrecht University" + }, + { + "first_name": "Arie", + "last_name": "Middelkoop", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/HageHM07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291177", + "title": "Functional pearl: the great escape or, how to jump the border without getting caught", + "abstract": "Filinski showed that callcc and a single mutable reference cell are sufficient to express the delimited control operators shift and reset. However, this implementation interacts poorly with dynamic bindings like exception handlers. We present a variation on Filinski's encoding of delimited continuations that behaves appropriately in the presence of exceptions and give an implementation in Standard ML of New Jersey. We prove the encoding correct with respect to the semantics of delimited dynamic binding.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291177", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Herman", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/Herman07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291197", + "title": "Implicit phasing for R6RS libraries", + "abstract": "The forthcoming Revised6 Report on Scheme differs from previous reports in that the language it describes is structured as a set of libraries. It also provides a syntax for defining new portable libraries. The same library may export both procedure and hygienic macro definitions, which allows procedures and syntax to be freely intermixed, hidden, and exported.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291197", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Abdulaziz", + "last_name": "Ghuloum", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/icfp/GhuloumD07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291193", + "title": "Lazy call-by-value evaluation", + "abstract": "Designing debugging tools for lazy functional programming languages is a complex task which is often solved by expensive tracing of lazy computations. We present a new approach in which the information collected as a trace is reduced considerably (kilobytes instead of megabytes). The idea is to collect a kind of step information for a call-by-value interpreter, which can then efficiently reconstruct the computation for debugging/viewing tools, like declarative debugging. We show the correctness of the approach, discuss a proof-of-concept implementation with a declarative debugger as back end and present some benchmarks comparing our new approach with the Haskell debugger Hat.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291193", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bernd", + "last_name": "Braßel", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Hanus", + "institution": "" + }, + { + "first_name": "Sebastian", + "last_name": "Fischer", + "institution": "" + }, + { + "first_name": "Frank", + "last_name": "Huch", + "institution": "" + }, + { + "first_name": "Germán", + "last_name": "Vidal", + "institution": "Universitat Politècnica de València" + } + ], + "dblp_key": "conf/icfp/BrasselHFHV07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291161", + "title": "On Barron and Strachey's cartesian product function", + "abstract": "Over forty years ago, David Barron and Christopher Strachey published a startlingly elegant program for the Cartesian product of a list of lists, expressing it with a three nested occurrences of the function we now call foldr. This program is remarkable for its time because of its masterful display of higher-order functions and lexical scope, and we put it forward as possibly the first ever functional pearl. We first characterize it as the result of a sequence of program transformations, and then apply similar transformations to a program for the classical power set example. We also show that using a higher-order representation of lists allows a definition of the Cartesian product function where foldr is nested only twice.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291161", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Aarhus University" + }, + { + "first_name": "Michael Z.", + "last_name": "Spivey", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/DanvyS07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291192", + "title": "Feedback directed implicit parallelism", + "abstract": "In this paper we present an automated way of using spare CPU resources within a shared memory multi-processor or multi-core machine. Our approach is (i) to profile the execution of a program, (ii) from this to identify pieces of work which are promising sources of parallelism, (iii) recompile the program with this work being performed speculatively via a work-stealing system and then (iv) to detect at run-time any attempt to perform operations that would reveal the presence of speculation.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291192", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tim", + "last_name": "Harris", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Satnam", + "last_name": "Singh", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/HarrisS07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291168", + "title": "Inductive reasoning about effectful data types", + "abstract": "We present a pair of reasoning principles, definition and proof by rigid induction, which can be seen as proper generalizations of lazy-datatype induction to monadic effects other than partiality. We further show how these principles can be integrated into logical-relations arguments, and obtain as a particular instance a general and principled proof that the success-stream and failure-continuation models of backtracking are equivalent. As another application, we present a monadic model of general search trees, not necessarily traversed depth-first. The results are applicable to both lazy and eager languages, and we emphasize this by presenting most examples in both Haskell and SML.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291168", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrzej", + "last_name": "Filinski", + "institution": "University of Copenhagen" + }, + { + "first_name": "Kristian", + "last_name": "Støvring", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/icfp/FilinskiS07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291178", + "title": "Adding delimited and composable control to a production programming environment", + "abstract": "Operators for delimiting control and for capturing composable continuations litter the landscape of theoretical programming language research. Numerous papers explain their advantages, how the operators explain each other (or don't), and other aspects of the operators' existence. Production programming languages, however, do not support these operators, partly because their relationship to existing and demonstrably useful constructs - such as exceptions and dynamic binding - remains relatively unexplored.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291178", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Gang", + "last_name": "Yu", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "University of Chicago" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/FlattYFF07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291179", + "title": "Compiling with continuations, continued", + "abstract": "We present a series of CPS-based intermediate languages suitable for functional language compilation, arguing that they have practical benefits over direct-style languages based on A-normal form (ANF) or monads. Inlining of functions demonstrates the benefits most clearly: in ANF-based languages, inlining involves a re-normalization step that rearranges let expressions and possibly introduces a new 'join point' function, and in monadic languages, commuting conversions must be applied; in contrast, inlining in our CPS language is a simple substitution of variables for variables.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291179", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/Kennedy07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291194", + "title": "Faster laziness using dynamic pointer tagging", + "abstract": "In the light of evidence that Haskell programs compiled by GHC exhibit large numbers of mispredicted branches on modern processors, we re-examine the \"tagless\" aspect of the STG-machine that GHC uses as its evaluation model.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291194", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Alexey Rodriguez", + "last_name": "Yakushev", + "institution": "Utrecht University" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/MarlowYJ07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291152", + "title": "Declarative programming for artificial intelligence applications", + "abstract": "In this talk, I will consider some possible extensions to existing functional programming languages that would make them more suitable for the important and growing class of artificial intelligence applications. First, I will motivate the need for these language extensions. Then I will give some technical detail about these extensions that provide the logic programming idioms, probabilistic computation, and modal computation. Some examples will be given to illustrate these ideas which have been implemented in the Bach programming language that is an extension of Haskell.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291152", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John W.", + "last_name": "Lloyd", + "institution": "Australian National University" + } + ], + "dblp_key": "conf/icfp/Lloyd07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291200", + "title": "Call-pattern specialisation for haskell programs", + "abstract": "User-defined data types, pattern-matching, and recursion are ubiquitous features of Haskell programs. Sometimes a function is called with arguments that are statically known to be in constructor form, so that the work of pattern-matching is wasted. Even worse, the argument is sometimes freshly-allocated, only to be immediately decomposed by the function.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291200", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/Jones07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291169", + "title": "A type directed translation of MLF to system F", + "abstract": "The MLF type system by Le Botlan and Rémy is a natural extension of Hindley-Milner type inference that supports full first-class polymorphism, where types can be of higher-rank and impredicatively instantiated. Even though MLF is theoretically very attractive, it has not seen widespread adoption. We believe that this partly because it is unclear how the rich language of MLF types relate to standard System F types. In this article we give the first type directed translation of MLF terms to System F terms. Based on insight gained from this translation, we also define \"Rigid MLF\" (MLF=), a restriction of MLF where all bound values have a System F type. The expressiveness of MLF= is the same as that of boxy types, but MLF= needs fewer annotations and we give a detailed comparison between them.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291169", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/Leijen07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291182", + "title": "Evaluating high-level distributed language constructs", + "abstract": "The paper investigates the impact of high level distributed programming language constructs on the engineering of realistic software components. Based on reengineering two non-trivial telecoms components, we compare two high-level distributed functional languages, Erlang and GdH, with conventional distributed technologies C++/CORBA and C++/UDP.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291182", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jan", + "last_name": "Nyström", + "institution": "" + }, + { + "first_name": "Phil", + "last_name": "Trinder", + "institution": "Heriot-Watt University" + }, + { + "first_name": "David", + "last_name": "King", + "institution": "Praxis" + } + ], + "dblp_key": "conf/icfp/NystromTK07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291153", + "title": "Subtyping and intersection types revisited", + "abstract": "Church's system of simple types has proven to be remarkably robust: call-by-name, call-by-need, and call-by-value languages, with or without effects, and even logical frameworks can be based on the same typing rules. When type systems become more expressive, this unity fractures. An early example is the value restriction for parametric polymorphism which is necessary for ML but not Haskell; a later manifestation is the lack of distributivity of function types over intersections in call-by-value languages with effects.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291153", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Pfenning07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291181", + "title": "Type-safe higher-order channels in ML-like languages", + "abstract": "As a means of transmitting not only data but also code encapsulated within functions, higher-order channels provide an advanced form of task parallelism in parallel computations. In the presence of mutable references, however, they pose a safety problem because references may be transmitted to remote threads where they are no longer valid.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291181", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sungwoo", + "last_name": "Park", + "institution": "Pohang University of Science and Technology" + } + ], + "dblp_key": "conf/icfp/Park07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291165", + "title": "Termination analysis and call graph construction for higher-order functional programs", + "abstract": "The analysis and verification of higher-order programs raises the issue of control-flow analysis for higher-order languages. The problem of constructing an accurate call graph for a higher-order program has been the topic of extensive research, and numerous methods for flow analysis, varying in complexity and precision, have been suggested.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291165", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Damien", + "last_name": "Sereni", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/Sereni07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291166", + "title": "Relating complexity and precision in control flow analysis", + "abstract": "We analyze the computational complexity of kCFA, a hierarchy of control flow analyses that determine which functions may be applied at a given call-site. This hierarchy specifies related decision problems, quite apart from any algorithms that may implement their solutions. We identify a simple decision problem answered by this analysis and prove that in the 0CFA case, the problem is complete for polynomial time. The proof is based on a nonstandard, symmetric implementation of Boolean logic within multiplicative linear logic (MLL). We also identify a simpler version of 0CFA related to η-expansion, and prove that it is complete for logarithmic space, using arguments based on computing paths and permutations.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291166", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "Brandeis University" + }, + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/icfp/HornM07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291174", + "title": "iTasks: executable specifications of interactive work flow systems for the web", + "abstract": "In this paper we introduce the iTask system: a set of combinators to specify work flows in a pure functional language at a very high level of abstraction. Work flow systems are automated systems in which tasks are coordinated that have to be executed by humans and computers. The combinators that we propose support work flow patterns commonly found in commercial work flow systems. Compared with most of these commercial systems, the iTask system offers several advantages: tasks are statically typed, tasks can be higher order, the combinators are fully compositional, dynamic and recursive work flows can be specified, and last but not least, the specification is used to generate an executable web-based multi-user work flow application. With the iTask system, useful work flows can be defined which cannot be expressed in other systems: work can be interrupted and subsequently directed to other workers for further processing.The implementation is special as well. It is based on the Clean iData toolkit which makes it possible to create fully dynamic, interactive, thin client web applications. Thanks to the generic programming techniques used in the iData toolkit, the programming effort is reduced significantly: state handling, form rendering, user interaction, and storage management is handled automatically. The iTask system allows a task to be regarded as a special kind of persistent redex being reduced by the application user via task completion. The combinators control the order in which these redexes are made available to the application user. The system rewrites the persistent task redexes in a similar way as functions are rewritten in lazy functional languages.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291174", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Rinus", + "last_name": "Plasmeijer", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Peter", + "last_name": "Achten", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Pieter", + "last_name": "Koopman", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "conf/icfp/PlasmeijerAK07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291162", + "title": "Bidirectionalization transformation based on automatic derivation of view complement functions", + "abstract": "Bidirectional transformation is a pair of transformations: a view function and a backward transformation. A view function maps one data structure called source onto another called view. The corresponding backward transformation reflects changes in the view to the source. Its practically useful applications include replicated data synchronization, presentation-oriented editor development, tracing software development, and view updating in the database community. However, developing a bidirectional transformation is hard, because one has to give two mappings that satisfy the bidirectional properties for system consistency.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291162", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "The University of Tokyo" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "The University of Tokyo" + }, + { + "first_name": "Keisuke", + "last_name": "Nakano", + "institution": "The University of Tokyo" + }, + { + "first_name": "Makoto", + "last_name": "Hamana", + "institution": "Gunma University" + }, + { + "first_name": "Masato", + "last_name": "Takeichi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/icfp/MatsudaHNHT07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291156", + "title": "Program-ing finger trees in Coq", + "abstract": "International audience", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291156", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Université Paris-Sud" + } + ], + "dblp_key": "conf/icfp/Sozeau07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291172", + "title": "Experience report: the reactis validation tool", + "abstract": "Reactis is a commercially successful testing and validation tool which is implemented almost entirely in Standard ML. Our experience using a functional language to develop a commercial product has led us to the conclusion that while functional languages have some disadvantages, in the case of Reactis the benefits of a functional language substantially outweigh the drawbacks.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291172", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Steve", + "last_name": "Sims", + "institution": "" + }, + { + "first_name": "Daniel C.", + "last_name": "DuVarney", + "institution": "" + } + ], + "dblp_key": "conf/icfp/SimsD07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291158", + "title": "Experience report: functional programming in c-rules", + "abstract": "C-Rules is a business rules management system developed by Constraint Technologies International1 (CTI), designed for use in transportation problems. Users define rules describing various aspects of a problem, such as solution costs and legality, which are then queried from a host application, typically an optimising solver. At its core, C-Rules provides a functional expression language which affords users both power and flexibility when formulating rules. In this paper we will describe our experiences of using functional programming both at the end-user level, as well as at the implementation level. We highlight some of the benefits we, and the product's users, have enjoyed from the decision to base our rule system on features such as: higher-order functions, referential transparency, and static, polymorphic typing. We also outline some of our experiences in using Haskell to build an efficient compiler for the core language.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291158", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Wazny", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Wazny07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291175", + "title": "Experience report: scheme in commercial web application development", + "abstract": "Over the past year Untyped has developed some 40'000 lines of Scheme code for a variety of web-based applications, which receive over 10'000 hits a day. This is, to our knowledge, the largest web-based application deployment of PLT Scheme. Our experiences developing with PLT Scheme show that deficiencies in the existing infrastructure can be easily overcome, and we can exploit advanced language features to improve productivity. We conclude that PLT Scheme makes an excellent platform for developing web-based applications, and is competitive with more mainstream choices.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291175", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Noel", + "last_name": "Welsh", + "institution": "University of Birmingham" + }, + { + "first_name": "David", + "last_name": "Gurnell", + "institution": "" + } + ], + "dblp_key": "conf/icfp/WelshG07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291155", + "title": "Ott: effective tool support for the working semanticist", + "abstract": "It is rare to give a semantic definition of a full-scale programming language, despite the many potential benefits. Partly this is because the available metalanguages for expressing semantics - usually either LaTEX for informal mathematics, or the formal mathematics of a proof assistant - make it much harder than necessary to work with large definitions.We present a metalanguage specifically designed for this problem, and a tool, ott, that sanity-checks such definitions and compiles them into proof assistant code for Coq, HOL, Isabelle, and (in progress) Twelf, together with LaTEX code for production-quality typesetting, and OCaml boilerplate. The main innovations are:(1) metalanguage design to make definitions concise, and easy to read and edit;(2) an expressive but intuitive metalanguage for specifying binding structures; and (3) compilation to proof assistant code.This has been tested in substantial case studies, including modular specifications of calculi from the TAPL text, a Lightweight Java with Java JSR 277/294 module system proposals, and a large fragment of OCaml (around 306 rules), with machine proofs of various soundness results. Our aim with this work is to enable a phase change: making it feasible to work routinely, without heroic effort, with rigorous semantic definitions of realistic languages.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291155", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Cambridge" + }, + { + "first_name": "Gilles", + "last_name": "Peskine", + "institution": "University of Cambridge" + }, + { + "first_name": "Thomas J.", + "last_name": "Ridge", + "institution": "University of Cambridge" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of Cambridge" + }, + { + "first_name": "Rok", + "last_name": "Strniša", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/SewellNOPRSS07", + "venue": "icfp", + "year": 2007 + }, + { + "paper_id": "10.1145/1291151.1291159", + "title": "Extensible pattern matching via a lightweight language extension", + "abstract": "Pattern matching of algebraic data types (ADTs) is a standard feature in typed functional programming languages, but it is well known that it interacts poorly with abstraction. While several partial solutions to this problem have been proposed, few have been implemented or used. This paper describes an extension to the .NET language F# called active patterns, which supports pattern matching over abstract representations of generic heterogeneous data such as XML and term structures, including where these are represented via object models in other .NET languages. Our design is the first to incorporate both ad hoc pattern matching functions for partial decompositions and \"views\" for total decompositions, and yet remains a simple and lightweight extension. We give a description of the language extension along with numerous motivating examples. Finally we describe how this feature would interact with other reasonable and related language extensions: existential types quantified at data discrimination tags, GADTs, and monadic generalizations of pattern matching.", + "date": "2007-10-01", + "link": "https://doi.org/10.1145/1291151.1291159", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Don", + "last_name": "Syme", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Gregory", + "last_name": "Neverov", + "institution": "Queensland University of Technology" + }, + { + "first_name": "J.", + "last_name": "Margetson", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/SymeNM07", + "venue": "icfp", + "year": 2007 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2008.json b/data/pl_conferences/icfp/2008.json new file mode 100644 index 0000000..7e744f6 --- /dev/null +++ b/data/pl_conferences/icfp/2008.json @@ -0,0 +1,843 @@ +[ + { + "paper_id": "10.1145/1411204.1411236", + "title": "Paradise: a two-stage DSL embedded in Haskell", + "abstract": "We have implemented a two-stage language, Paradise, for building reusable components which are used to price financial products. Paradise is embedded in Haskell and makes heavy use of type-class based overloading, allowing the second stage to be compiled into a variety of backend platforms.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411236", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lennart", + "last_name": "Augustsson", + "institution": "" + }, + { + "first_name": "Howard L.", + "last_name": "Mansell", + "institution": "" + }, + { + "first_name": "Ganesh", + "last_name": "Sittampalam", + "institution": "" + } + ], + "dblp_key": "conf/icfp/AugustssonMS08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411223", + "title": "Experience report: erlang in acoustic ray tracing", + "abstract": "We investigated the relative merits of C++ and Erlang in the implementation of a parallel acoustic ray tracing algorithm for the U.S. Navy. We found a much smaller learning curve and better debugging environment for parallel Erlang than for pthreads-based C++ programming. Our C++ implementation outperformed the Erlang program by at least 12x. Attempts to use Erlang on the IBM Cell BE microprocessor were frustrated by Erlang's memory footprint.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411223", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christian", + "last_name": "Convey", + "institution": "Naval Undersea Warfare Center" + }, + { + "first_name": "Andrew J.", + "last_name": "Fredricks", + "institution": "Naval Undersea Warfare Center" + }, + { + "first_name": "Christopher", + "last_name": "Gagner", + "institution": "Naval Undersea Warfare Center" + }, + { + "first_name": "D. P.", + "last_name": "Maxwell", + "institution": "Naval Undersea Warfare Center" + }, + { + "first_name": "Lutz", + "last_name": "Hamel", + "institution": "University of Rhode Island" + } + ], + "dblp_key": "conf/icfp/ConveyFGMH08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411259", + "title": "Report on the tenth ICFP programming contest", + "abstract": "The ICFP programming contest is a 72-hour contest, which attracts thousands of contestants from all over the world. In this report we describe what it takes to organise this contest, the main ideas behind the contest we organised, the task, how to solve it, how we created it, and how well the contestants did.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411259", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Eelco", + "last_name": "Dolstra", + "institution": "Delft University of Technology" + }, + { + "first_name": "Jurriaan", + "last_name": "Hage", + "institution": "Utrecht University" + }, + { + "first_name": "Bastiaan", + "last_name": "Heeren", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Stefan", + "last_name": "Holdermans", + "institution": "Utrecht University" + }, + { + "first_name": "Johan", + "last_name": "Jeuring", + "institution": "Utrecht University" + }, + { + "first_name": "Andres", + "last_name": "Löh", + "institution": "Utrecht University" + }, + { + "first_name": "Clara", + "last_name": "Löh", + "institution": "" + }, + { + "first_name": "Arie", + "last_name": "Middelkoop", + "institution": "Utrecht University" + }, + { + "first_name": "Alexey", + "last_name": "Rodriguez", + "institution": "Utrecht University" + }, + { + "first_name": "John van", + "last_name": "Schie", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/DolstraHHHJLLMRS08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411206", + "title": "Defunctionalized interpreters for programming languages", + "abstract": "This document illustrates how functional implementations of formal semantics (structural operational semantics, reduction semantics, small-step and big-step abstract machines, natural semantics, and denotational semantics) can be transformed into each other. These transformations were foreshadowed by Reynolds in \"Definitional Interpreters for Higher-Order Programming Languages\" for functional implementations of denotational semantics, natural semantics, and big-step abstract machines using closure conversion, CPS transformation, and defunctionalization. Over the last few years, the author and his students have further observed that functional implementations of small-step and of big-step abstract machines are related using fusion by fixed-point promotion and that functional implementations of reduction semantics and of small-step abstract machines are related using refocusing and transition compression. It furthermore appears that functional implementations of structural operational semantics and of reduction semantics are related as well, also using CPS transformation and defunctionalization. This further relation provides an element of answer to Felleisen's conjecture that any structural operational semantics can be expressed as a reduction semantics: for deterministic languages, a reduction semantics is a structural operational semantics in continuation style, where the reduction context is a defunctionalized continuation. As the defunctionalized counterpart of the continuation of a one-step reduction function, a reduction context represents the rest of the reduction, just as an evaluation context represents the rest of the evaluation since it is the defunctionalized counterpart of the continuation of an evaluation function.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411206", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/icfp/Danvy08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411209", + "title": "FLUX: functional updates for XML", + "abstract": "XML database query languages have been studied extensively, but XML database updates have received relatively little attention, and pose many challenges to language design. We are developing an XML update language called FLUX, which stands for FunctionaL Updates for XML, drawing upon ideas from functional programming languages. In prior work, we have introduced a core language for FLUX with a clear operational semantics and a sound, decidable static type system based on regular expression types.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411209", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "James", + "last_name": "Cheney", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/Cheney08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411230", + "title": "Efficient nondestructive equality checking for trees and graphs", + "abstract": "The Revised6 Report on Scheme requires its generic equivalence predicate, equal?, to terminate even on cyclic inputs. While the terminating equal? can be implemented via a DFA-equivalence or union-find algorithm, these algorithms usually require an additional pointer to be stored in each object, are not suitable for multithreaded code due to their destructive nature, and may be unacceptably slow for the small acyclic values that are the most likely inputs to the predicate.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411230", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/icfp/AdamsD08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411227", + "title": "Typed closure conversion preserves observational equivalence", + "abstract": "Language-based security relies on the assumption that all potential attacks are bound by the rules of the language in question. When programs are compiled into a different language, this is true only if the translation process preserves observational equivalence.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411227", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "M.", + "last_name": "Blume", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/icfp/AhmedB08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411255", + "title": "NixOS: a purely functional Linux distribution", + "abstract": "Existing package and system configuration management tools suffer from an imperative model, where system administration actions such as upgrading packages or changes to system configuration files are stateful: they destructively update the state of the system. This leads to many problems, such as the inability to roll back changes easily, to run multiple versions of a package side-by-side, to reproduce a configuration deterministically on another machine, or to reliably upgrade a system. In this paper we show that we can overcome these problems by moving to a purely functional system configuration model. This means that all static parts of a system (such as software packages, configuration files and system startup scripts) are built by pure functions and are immutable, stored in a way analogously to a heap in a purely function language. We have implemented this model in NixOS, a non-trivial Linux distribution that uses the Nix package manager to build the entire system configuration from a purely functional specification.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411255", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Eelco", + "last_name": "Dolstra", + "institution": "Delft University of Technology" + }, + { + "first_name": "Andres", + "last_name": "Löh", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/DolstraL08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411248", + "title": "Mixin' up the ML module system", + "abstract": "ML modules provide hierarchical namespace management, as well as fine-grained control over the propagation of type information, but they do not allow modules to be broken up into mutually recursive, separately compilable components. Mixin modules facilitate recursive linking of separately compiled components, but they are not hierarchically composable and typically do not support type abstraction. We synthesize the complementary advantages of these two mechanisms in a novel module system design we call MixML.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411248", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/DreyerR08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411235", + "title": "Functional translation of a calculus of capabilities", + "abstract": "Reasoning about imperative programs requires the ability to track aliasing and ownership properties. We present a type system that provides this ability, by using regions, capabilities, and singleton types. It is designed for a high-level calculus with higher-order functions, algebraic data structures, and references (mutable memory cells). The type system has polymorphism, yet does not require a value restriction, because capabilities act as explicit store typings.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411235", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/ChargueraudP08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411210", + "title": "Typed iterators for XML", + "abstract": "XML transformations are very sensitive to types: XML types describe the tags and attributes of XML elements as well as the number, kind, and order of their sub-elements. Therefore, operations, even simple ones, that modify these features may affect the types of documents. Operations on XML documents are performed by iterators that, to be useful, need to be typed by a kind of polymorphism that goes beyond what currently exists. For this reason these iterators are not programmed but, rather, hard-coded in the language. However, this approach soon reaches its limits, as the hard-coded iterators cannot cover fairly standard usage scenarios. As a solution to this problem we propose a generic language to define iterators for XML data to be grafted on some host programming language. We show that our language mostly offers the required degree of polymorphism, study its formal properties, and show its expressiveness and practical impact by providing several usage examples and encodings.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411210", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Université Paris Cité" + }, + { + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Université Paris-Sud" + } + ], + "dblp_key": "conf/icfp/CastagnaN08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411239", + "title": "A scheduling framework for general-purpose parallel languages", + "abstract": "The trend in microprocessor design toward multicore and manycore processors means that future performance gains in software will largely come from harnessing parallelism. To realize such gains, we need languages and implementations that can enable parallelism at many different levels. For example, an application might use both explicit threads to implement course-grain parallelism for independent tasks and implicit threads for fine-grain data-parallel computation over a large array. An important aspect of this requirement is supporting a wide range of different scheduling mechanisms for parallel computation.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411239", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "University of Chicago" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/icfp/FluetRR08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411222", + "title": "Transactional events for ML", + "abstract": "Transactional events (TE) are an approach to concurrent programming that enriches the first-class synchronous message-passing of Concurrent ML (CML) with a combinator that allows multiple messages to be passed as part of one all-or-nothing synchronization. Donnelly and Fluet (2006) designed and implemented TE as a Haskell library and demonstrated that it enables elegant solutions to programming patterns that are awkward or impossible in CML. However, both the definition and the implementation of TE relied fundamentally on the code in a synchronization not using mutable memory, an unreasonable assumption for mostly functional languages like ML where functional interfaces may have impure implementations.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411222", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Laura", + "last_name": "Effinger-Dean", + "institution": "University of Washington" + }, + { + "first_name": "Matthew", + "last_name": "Kehrt", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/icfp/Effinger-DeanKG08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411218", + "title": "A type-preserving compiler in Haskell", + "abstract": "There has been a lot of interest of late for programming languages that incorporate features from dependent type systems and proof assistants, in order to capture important invariants of the program in the types. This allows type-based program verification and is a promising compromise between plain old types and full blown Hoare logic proofs. The introduction of GADTs in GHC (and more recently type families) made such dependent typing available in an industry-quality implementation, making it possible to consider its use in large scale programs.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411218", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Louis-Julien", + "last_name": "Guillemette", + "institution": "Université de Montréal" + }, + { + "first_name": "Stefan", + "last_name": "Monnier", + "institution": "Université de Montréal" + } + ], + "dblp_key": "conf/icfp/GuillemetteM08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411257", + "title": "Quotient lenses", + "abstract": "There are now a number of BIDIRECTIONAL PROGRAMMING LANGUAGES, where every program can be read both as a forward transformation mapping one data structure to another and as a reverse transformation mapping an edited output back to a correspondingly edited input. Besides parsimony - the two related transformations are described by just one expression - such languages are attractive because they promise strong behavioral laws about how the two transformations fit together - e.g., their composition is the identity function. It has repeatedly been observed, however, that such laws are actually a bit too strong: in practice, we do not want them \"on the nose,\" but only up to some equivalence, allowing inessential details, such as whitespace, to be modified after a round trip. Some bidirectional languages loosen their laws in this way, but only for specific, baked-in equivalences.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411257", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "J. Nathan", + "last_name": "Foster", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Alexandre", + "last_name": "Pilkiewicz", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/FosterPP08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411243", + "title": "Deciding kCFA is complete for EXPTIME", + "abstract": "We give an exact characterization of the computational complexity of the kCFA hierarchy. For any k&gt; 0, we prove that the con-trol flow decision problem is complete for deterministic exponen-tial time. This theorem validates empirical observations that such control flow analysis is intractable. It also provides more general insight into the complexity of abstract interpretation.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411243", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "Brandeis University" + }, + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/icfp/HornM08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411242", + "title": "Pattern minimization problems over recursive data types", + "abstract": "In the context of program verification in an interactive theorem prover, we study the problem of transforming function definitions with ML-style (possibly overlapping) pattern matching into minimal sets of independent equations. Since independent equations are valid unconditionally, they are better suited for the equational proof style using induction and rewriting, which is often found in proofs in theorem provers or on paper.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411242", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Krauß", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/icfp/Krauss08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411220", + "title": "Generic discrimination: sorting and paritioning unshared data in linear time", + "abstract": "We introduce the notion of discrimination as a generalization of both sorting and partitioning and show that worst-case linear-time discrimination functions (discriminators) can be defined generically, by (co-)induction on an expressive language of order denotations. The generic definition yields discriminators that generalize both distributive sorting and multiset discrimination. The generic discriminator can be coded compactly using list comprehensions, with order denotations specified using Generalized Algebraic Data Types (GADTs). A GADT-free combinator formulation of discriminators is also given.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411220", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Fritz", + "last_name": "Henglein", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/Henglein08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411207", + "title": "Polymorphism and page tables: systems programming from a functional programmer's perspective", + "abstract": "With features that include lightweight syntax, expressive type systems, and deep semantic foundations, functional languages are now being used to develop an increasingly broad range of complex, real-world applications. In the area of systems software, however, where performance and interaction with low-level aspects of hardware are central concerns, many practitioners still eschew the advantages of higher-level languages for the potentially unsafe but predictable behavior of traditional imperative languages like C. It is ironic that critical applications such as operating systems kernels, device drivers, and VMMs - where a single bug could compromise the reliability or security of a whole system - are among the least likely to benefit from the abstractions and safety guarantees of modern language designs.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411207", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/Jones08a", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411219", + "title": "Experience report: playing the DSL card", + "abstract": "This paper describes our experience using a functional language, Haskell, to build an embedded, domain-specific language (DSL) for component configuration in large-scale, real-time, embedded systems. Prior to the introduction of the DSL, engineers would describe the steps needed to configure a particular system in a handwritten XML document. In this paper, we outline the application domain, give a brief overview of the DSL that we developed, and provide concrete data to demonstrate its effectiveness. In particular, we show that the DSL has several significant benefits over the original, XML-based approach including reduced code size, increased modularity and scalability, and detection and prevention of common defects. For example, using the DSL, we were able to produce clear and intuitive descriptions of component configurations that were sometimes less than 1/30 of the size of the original XML.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411219", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/Jones08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411232", + "title": "Functional pearl: streams and unique fixed points", + "abstract": "Streams, infinite sequences of elements, live in a coworld: they are given by a coinductive data type, operations on streams are implemented by corecursive programs, and proofs are conducted using coinduction. But there is more to it: suitably restricted, stream equations possess unique solutions, a fact that is not very widely appreciated. We show that this property gives rise to a simple and attractive proof technique essentially bringing equational reasoning to the coworld. In fact, we redevelop the theory of recurrences, finite calculus and generating functions using streams and stream operators building on the cornerstone of unique solutions. The development is constructive: streams and stream operators are implemented in Haskell, usually by one-liners. The resulting calculus or library, if you wish, is elegant and fun to use. Finally, we rephrase the proof of uniqueness using generalised algebraic data types.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411232", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/Hinze08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411245", + "title": "HMF: simple type inference for first-class polymorphism", + "abstract": "HMF is a conservative extension of Hindley-Milner type inference with first-class polymorphism. In contrast to other proposals, HML uses regular System F types and has a simple type inference algorithm that is just a small extension of the usual Damas-Milner algorithm W. Given the relative simplicity and expressive power, we feel that HMF can be an attractive type system in practice. There is a reference implementation of the type system available online together with a technical report containing proofs (Leijen 2007a,b).", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411245", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/Leijen08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411212", + "title": "AURA: a programming language for authorization and audit", + "abstract": "This paper presents AURA, a programming language for access control that treats ordinary programming constructs (e.g., integers and recursive functions) and authorization logic constructs (e.g., principals and access control policies) in a uniform way. AURA is based on polymorphic DCC and uses dependent types to permit assertions that refer directly to AURA values while keeping computation out of the assertion level to ensure tractability. The main technical results of this paper include fully mechanically verified proofs of the decidability and soundness for AURA's type system, and a prototype typechecker and interpreter.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411212", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Jeffrey A.", + "last_name": "Vaughan", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Karl", + "last_name": "Mazurak", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yun", + "last_name": "Zhao", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Luke", + "last_name": "Zarko", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Joseph", + "last_name": "Schorr", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/JiaVMZZSZ08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411249", + "title": "Compiling self-adjusting programs with continuations", + "abstract": "Self-adjusting programs respond automatically and efficiently to input changes by tracking the dynamic data dependences of the computation and incrementally updating the output as needed. In order to identify data dependences, previously proposed approaches require the user to make use of a set of monadic primitives. Rewriting an ordinary program into a self-adjusting program with these primitives, however, can be difficult and error-prone due to various monadic and proper-usage restrictions, some of which cannot be enforced statically. Previous work therefore suggests that self-adjusting computation would benefit from direct language and compiler support.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411249", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ruy", + "last_name": "Ley-Wild", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Toyota Technological Institute at Chicago" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Toyota Technological Institute at Chicago" + } + ], + "dblp_key": "conf/icfp/Ley-WildFA08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411252", + "title": "Experience report: a pure shirt fits", + "abstract": "Bluespec is a hardware-design tools startup whose core technology is developed using Haskell. Haskell is an unusual choice for a startup because it adds technical risk to the inherent business risk. In the years since Bluespec's founding, we have discovered that Haskell's purity is an unexpected match for the development needs of a startup. Based on Bluespec's experience, we conclude that pure programming languages can be the source of a competitive advantage for startup software companies.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411252", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ravi", + "last_name": "Nanavati", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Nanavati08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411237", + "title": "Ynot: dependent types for imperative programs", + "abstract": "We describe an axiomatic extension to the Coq proof assistant, that supports writing, reasoning about, and extracting higher-order, dependently-typed programs with side-effects. Coq already includes a powerful functional language that supports dependent types, but that language is limited to pure, total functions. The key contribution of our extension, which we call Ynot, is the added support for computations that may have effects such as non-termination, accessing a mutable store, and throwing/catching exceptions.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411237", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + }, + { + "first_name": "Avraham", + "last_name": "Shinnar", + "institution": "Harvard University Press" + }, + { + "first_name": "Paul", + "last_name": "Govereau", + "institution": "Harvard University Press" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/NanevskiMSGB08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411253", + "title": "Functional netlists", + "abstract": "In efforts to overcome the complexity of the syntax and the lack of formal semantics of conventional hardware description languages, a number of functional hardware description languages have been developed. Like conventional hardware description languages, however, functional hardware description languages eventually convert all source programs into netlists, which describe wire connections in hardware circuits at the lowest level and conceal all high-level descriptions written into source programs.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411253", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sungwoo", + "last_name": "Park", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Jinha", + "last_name": "Kim", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Hyeonseung", + "last_name": "Im", + "institution": "Pohang University of Science and Technology" + } + ], + "dblp_key": "conf/icfp/ParkKI08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411213", + "title": "The power of Pi", + "abstract": "This paper exhibits the power of programming with dependent types by dint of embedding three domain-specific languages: Cryptol, a language for cryptographic protocols; a small data description language; and relational algebra. Each example demonstrates particular design patterns inherent to dependently-typed programming. Documenting these techniques paves the way for further research in domain-specific embedded type systems.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411213", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Oury", + "institution": "University of Nottingham" + }, + { + "first_name": "Wouter", + "last_name": "Swierstra", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/icfp/OuryS08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411216", + "title": "From ML to MLF: graphic type constraints with efficient type inference", + "abstract": "MLF is a type system that seamlessly merges ML-style type inference with System-F polymorphism. We propose a system of graphic (type) constraints that can be used to perform type inference in both ML or MLF. We show that this constraint system is a small extension of the formalism of graphic types, originally introduced to represent MLF types. We give a few semantic preserving transformations on constraints and propose a strategy for applying them to solve constraints. We show that the resulting algorithm has optimal complexity for MLF type inference, and argue that, as for ML, this complexity is linear under reasonable assumptions.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411216", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Boris", + "last_name": "Yakobowski", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/icfp/RemyY08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411240", + "title": "Space profiling for parallel functional programs", + "abstract": "This paper presents a semantic space profiler for parallel functional programs. Building on previous work in sequential profiling, our tools help programmers to relate runtime resource use back to program source code. Unlike many profiling tools, our profiler is based on a cost semantics. This provides a means to reason about performance without requiring a detailed understanding of the compiler or runtime system. It also provides a specification for language implementers. This is critical in that it enables us to separate cleanly the performance of the application from that of the language implementation.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411240", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Spoonhower", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Phillip B.", + "last_name": "Gibbons", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/icfp/SpoonhowerBHG08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411246", + "title": "FPH: first-class polymorphism for Haskell", + "abstract": "Languages supporting polymorphism typically have ad-hoc restrictions on where polymorphic types may occur. Supporting \"firstclass\" polymorphism, by lifting those restrictions, is obviously desirable, but it is hard to achieve this without sacrificing type inference. We present a new type system for higher-rank and impredicative polymorphism that improves on earlier proposals: it is an extension of Damas-Milner; it relies only on System F types; it has a simple, declarative specification; it is robust to program transformations; and it enjoys a complete and decidable type inference algorithm.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411246", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/VytiniotisWJ08", + "venue": "icfp", + "year": 2008 + }, + { + "paper_id": "10.1145/1411204.1411215", + "title": "Type checking with open type functions", + "abstract": "We report on an extension of Haskell with open type-level functions and equality constraints that unifies earlier work on GADTs, functional dependencies, and associated types. The contribution of the paper is that we identify and characterise the key technical challenge of entailment checking; and we give a novel, decidable, sound, and complete algorithm to solve it, together with some practically-important variants. Our system is implemented in GHC, and is already in active use.", + "date": "2008-09-20", + "link": "https://doi.org/10.1145/1411204.1411215", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Martin", + "last_name": "Sulzmann", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/SchrijversJCS08", + "venue": "icfp", + "year": 2008 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2009.json b/data/pl_conferences/icfp/2009.json new file mode 100644 index 0000000..8df7280 --- /dev/null +++ b/data/pl_conferences/icfp/2009.json @@ -0,0 +1,962 @@ +[ + { + "paper_id": "10.1145/1596550.1596581", + "title": "OXenstored: an efficient hierarchical and transactional database using functional programming with reference cell comparisons", + "abstract": "We describe in this paper our implementation of the Xenstored service which is part of the Xen architecture. Xenstored maintains a hierarchical and transactional database, used for storing and managing configuration values.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596581", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Gazagnaire", + "institution": "Citrix (United Kingdom)" + }, + { + "first_name": "Vincent", + "last_name": "Hanquez", + "institution": "Citrix (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/GazagnaireH09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596595", + "title": "Experience report: ocsigen, a web programming framework", + "abstract": "The evolution of Web sites towards very dynamic applications makes it necessary to reconsider current Web programming technologies. We believe that Web development would benefit greatly from more abstract paradigms and that a more semantical approach would result in huge gains in expressiveness. In particular, functional programming provides a really elegant solution to some important Web interaction problems, but few frameworks take advantage of it.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596595", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Vincent", + "last_name": "Balat", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Jérôme", + "last_name": "Vouillon", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Boris", + "last_name": "Yakobowski", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/icfp/BalatVY09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596569", + "title": "Scribble: closing the book on ad hoc documentation tools", + "abstract": "Scribble is a system for writing library documentation, user guides, and tutorials. It builds on PLT Scheme's technology for language extension, and at its heart is a new approach to connecting prose references with library bindings. Besides the base system, we have built Scribble libraries for JavaDoc-style API documentation, literate programming, and conference papers. We have used Scribble to produce thousands of pages of documentation for PLT Scheme; the new documentation is more complete, more accessible, and better organized, thanks in large part to Scribble's flexibility and the ease with which we cross-reference information across levels. This paper reports on the use of Scribble and on its design as both an extension and an extensible part of PLT Scheme.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596569", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Eli", + "last_name": "Barzilay", + "institution": "Northeastern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/icfp/FlattBF09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596555", + "title": "Functional pearl: la tour d'Hanoï", + "abstract": "This pearl aims to demonstrate the ideas of wholemeal and projective programming using the Towers of Hanoi puzzle as a running example. The puzzle has its own beauty, which we hope to expose along the way.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596555", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/Hinze09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596566", + "title": "Experience report: seL4: formally verifying a high-performance microkernel", + "abstract": "We report on our experience using Haskell as an executable specification language in the formal verification of the seL4 microkernel. The verification connects an abstract operational specification in the theorem prover Isabelle/HOL to a C implementation of the microkernel. We describe how this project differs from other efforts, and examine the effect of using Haskell in a large-scale formal verification. The kernel comprises 8,700 lines of C code; the verification more than 150,000 lines of proof script.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596566", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gerwin", + "last_name": "Klein", + "institution": "UNSW Sydney" + }, + { + "first_name": "Philip", + "last_name": "Derrin", + "institution": "Data61" + }, + { + "first_name": "Kevin", + "last_name": "Elphinstone", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/icfp/KleinDE09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596561", + "title": "A functional I/O system or, fun for freshman kids", + "abstract": "Functional programming languages ought to play a central role in mathematics education for middle schools (age range: 10-14). After all, functional programming is a form of algebra and programming is a creative activity about problem solving. Introducing it into mathematics courses would make pre-algebra course come alive. If input and output were invisible, students could implement fun simulations, animations, and even interactive and distributed games all while using nothing more than plain mathematics. We have implemented this vision with a simple framework for purely functional I/O. Using this framework, students design, implement, and test plain mathematical functions over numbers, booleans, string, and images. Then the framework wires them up to devices and performs all the translation from external information to internal data (and vice versa)--just like every other operating system. Once middle school students are hooked on this form of programming, our curriculum provides a smooth path for them from pre-algebra to freshman courses in college on object-oriented design and theorem proving.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596561", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "conf/icfp/FelleisenFFK09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596567", + "title": "Biorthogonality, step-indexing and compiler correctness", + "abstract": "We define logical relations between the denotational semantics of a simply typed functional language with recursion and the operational behaviour of low-level programs in a variant SECD machine. The relations, which are defined using biorthogonality and stepindexing, capture what it means for a piece of low-level code to implement a mathematical, domain-theoretic function and are used to prove correctness of a simple compiler. The results have been formalized in the Coq proof assistant.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596567", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/BentonH09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596556", + "title": "Purely functional lazy non-deterministic programming", + "abstract": "Functional logic programming and probabilistic programming have demonstrated the broad benefits of combining laziness (non-strict evaluation with sharing of the results) with non-determinism. Yet these benefits are seldom enjoyed in functional programming, because the existing features for non-strictness, sharing, and non-determinism in functional languages are tricky to combine.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596556", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Fischer", + "institution": "Kiel University" + }, + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "" + }, + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/icfp/FischerKS09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596565", + "title": "Effective interactive proofs for higher-order imperative programs", + "abstract": "We present a new approach for constructing and verifying higher-order, imperative programs using the Coq proof assistant. We build on the past work on the Ynot system, which is based on Hoare Type Theory. That original system was a proof of concept, where every program verification was accomplished via laborious manual proofs, with much code devoted to uninteresting low-level details. In this paper, we present a re-implementation of Ynot which makes it possible to implement fully-verified, higher-order imperative programs with reasonable proof burden. At the same time, our new system is implemented entirely in Coq source files, showcasing the versatility of that proof assistant as a platform for research on language design and verification. Both versions of the system have been evaluated with case studies in the verification of imperative data structures, such as hash tables with higher-order iterators. The verification burden in our new system is reduced by at least an order of magnitude compared to the old system, by replacing manual proof with automation. The core of the automation is a simplification procedure for implications in higher-order separation logic, with hooks that allow programmers to add domain-specific simplification rules.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596565", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Harvard University Press" + }, + { + "first_name": "Gregory", + "last_name": "Malecha", + "institution": "Harvard University Press" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + }, + { + "first_name": "Avraham", + "last_name": "Shinnar", + "institution": "Harvard University Press" + }, + { + "first_name": "Ryan", + "last_name": "Wisnesky", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/icfp/ChlipalaMMSW09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596579", + "title": "Beautiful differentiation", + "abstract": "Automatic differentiation (AD) is a precise, efficient, and convenient method for computing derivatives of functions. Its forward-mode implementation can be quite simple even when extended to compute all of the higher-order derivatives as well. The higher-dimensional case has also been tackled, though with extra complexity. This paper develops an implementation of higher-dimensional, higher-order, forward-mode AD in the extremely general and elegant setting of calculus on manifolds and derives that implementation from a simple and precise specification. In order to motivate and discover the implementation, the paper poses the question \"What does AD mean, independently of implementation?\" An answer arises in the form of naturality of sampling a function and its derivative. Automatic differentiation flows out of this naturality condition, together with the chain rule. Graduating from first-order to higher-order AD corresponds to sampling all derivatives instead of just one. Next, the setting is expanded to arbitrary vector spaces, in which derivative values are linear maps. The specification of AD adapts to this elegant and very general setting, which even simplifies the development.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596579", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Elliott09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596591", + "title": "Experience report: OCaml for an industrial-strength static analysis framework", + "abstract": "This experience report describes the choice of OCaml as the implementation language for Frama-C, a framework for the static analysis of C programs. OCaml became the implementation language for Frama-C because it is expressive. Most of the reasons listed in the remaining of this article are secondary reasons, features which are not specific to OCaml (modularity, availability of a C parser, control over the use of resources...) but could have prevented the use of OCaml for this project if they had been missing.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596591", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pascal", + "last_name": "Cuoq", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Julien", + "last_name": "Signoles", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Patrick", + "last_name": "Baudin", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Richard", + "last_name": "Bonichon", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Géraud", + "last_name": "Canet", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Loïc", + "last_name": "Correnson", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Benjamin", + "last_name": "Monate", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Virgile", + "last_name": "Prévosto", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Armand", + "last_name": "Puccetti", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + } + ], + "dblp_key": "conf/icfp/CuoqSBBCCMPP09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596559", + "title": "Causal commutative arrows and their optimization", + "abstract": "Arrows are a popular form of abstract computation. Being more general than monads, they are more broadly applicable, and in particular are a good abstraction for signal processing and dataflow computations. Most notably, arrows form the basis for a domain specific language called Yampa, which has been used in a variety of concrete applications, including animation, robotics, sound synthesis, control systems, and graphical user interfaces. Our primary interest is in better understanding the class of abstract computations captured by Yampa. Unfortunately, arrows are not concrete enough to do this with precision. To remedy this situation we introduce the concept of commutative arrows that capture a kind of non-interference property of concurrent computations. We also add an init operator, and identify a crucial law that captures the causal nature of arrow effects. We call the resulting computational model causal commutative arrows. To study this class of computations in more detail, we define an extension to the simply typed lambda calculus called causal commutative arrows (CCA), and study its properties. Our key contribution is the identification of a normal form for CCA called causal commutative normal form (CCNF). By defining a normalization procedure we have developed an optimization strategy that yields dramatic improvements in performance over conventional implementations of arrows. We have implemented this technique in Haskell, and conducted benchmarks that validate the effectiveness of our approach. When combined with stream fusion, the overall methodology can result in speed-ups of greater than two orders of magnitude.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596559", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Hai", + "last_name": "Liu", + "institution": "Yale University" + }, + { + "first_name": "Eric", + "last_name": "Cheng", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/LiuCH09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596574", + "title": "Finding race conditions in Erlang with QuickCheck and PULSE", + "abstract": "We address the problem of testing and debugging concurrent, distributed Erlang applications. In concurrent programs, race conditions are a common class of bugs and are very hard to find in practice. Traditional unit testing is normally unable to help finding all race conditions, because their occurrence depends so much on timing. Therefore, race conditions are often found during system testing, where due to the vast amount of code under test, it is often hard to diagnose the error resulting from race conditions. We present three tools (QuickCheck, PULSE, and a visualizer) that in combination can be used to test and debug concurrent programs in unit testing with a much better possibility of detecting race conditions. We evaluate our method on an industrial concurrent case study and illustrate how we find and analyze the race conditions.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596574", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Michał H.", + "last_name": "Pałka", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Nicholas", + "last_name": "Smallbone", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Quviq (Sweden)" + }, + { + "first_name": "H.", + "last_name": "Svensson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Thomas", + "last_name": "Arts", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Ulf", + "last_name": "Wiger", + "institution": "Erlang Solutions (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/ClaessenPSHSAW09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596571", + "title": "A universe of binding and computation", + "abstract": "We construct a logical framework supporting datatypes that mix binding and computation, implemented as a universe in the dependently typed programming language Agda 2. We represent binding pronominally, using well-scoped de Bruijn indices, so that types can be used to reason about the scoping of variables. We equip our universe with datatype-generic implementations of weakening, substitution, exchange, contraction, and subordination-based strengthening, so that programmers need not reimplement these operations for each individual language they define. In our mixed, pronominal setting, weakening and substitution hold only under some conditions on types, but we show that these conditions can be discharged automatically in many cases. Finally, we program a variety of standard difficult test cases from the literature, such as normalization-by-evaluation for the untyped lambda-calculus, demonstrating that we can express detailed invariants about variable usage in a program's type while still writing clean and clear code.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596571", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/LicataH09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596583", + "title": "Identifying query incompatibilities with evolving XML schemas", + "abstract": "During the life cycle of an XML application, both schemas and queries may change from one version to another. Schema evolutions may affect query results and potentially the validity of produced data. Nowadays, a challenge is to assess and accommodate the impact of these changes in evolving XML applications. Such questions arise naturally in XML static analyzers. These analyzers often rely on decision procedures such as inclusion between XML schemas, query containment and satisfiability. However, existing decision procedures cannot be used directly in this context. The reason is that they are unable to distinguish information related to the evolution from information corresponding to bugs. This paper proposes a predicate language within a logical framework that can be used to make this distinction.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596583", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Genevès", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Nabil", + "last_name": "Layaïda", + "institution": "Centre Inria de l'Université Grenoble Alpes" + }, + { + "first_name": "Vincent", + "last_name": "Quint", + "institution": "Centre Inria de l'Université Grenoble Alpes" + } + ], + "dblp_key": "conf/icfp/GenevesLQ09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596589", + "title": "A concurrent ML library in concurrent Haskell", + "abstract": "In Concurrent ML, synchronization abstractions can be defined and passed as values, much like functions in ML. This mechanism admits a powerful, modular style of concurrent programming, called higher-order concurrent programming. Unfortunately, it is not clear whether this style of programming is possible in languages such as Concurrent Haskell, that support only first-order message passing. Indeed, the implementation of synchronization abstractions in Concurrent ML relies on fairly low-level, language-specific details. In this paper we show, constructively, that synchronization abstractions can be supported in a language that supports only first-order message passing. Specifically, we implement a library that makes Concurrent ML-style programming possible in Concurrent Haskell. We begin with a core, formal implementation of synchronization abstractions in the π-calculus. Then, we extend this implementation to encode all of Concurrent ML's concurrency primitives (and more!) in Concurrent Haskell. Our implementation is surprisingly efficient, even without possible optimizations. In several small, informal experiments, our library seems to outperform OCaml's standard library of Concurrent ML-style primitives. At the heart of our implementation is a new distributed synchronization protocol that we prove correct. Unlike several previous translations of synchronization abstractions in concurrent languages, we remain faithful to the standard semantics for Concurrent ML's concurrency primitives. For example, we retain the symmetry of choose, which can express selective communication. As a corollary, we establish that implementing selective communication on distributed machines is no harder than implementing first-order message passing on such machines.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596589", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Avik", + "last_name": "Chaudhuri", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/icfp/Chaudhuri09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596594", + "title": "Automatically RESTful web applications: marking modular serializable continuations", + "abstract": "Continuation-based Web servers provide distinct advantages over traditional Web application development: expressive power and modularity. This power leads to fewer errors and more interesting applications. Furthermore, these Web servers are more than prototypes; they are used in some real commercial applications. Unfortunately, they pay a heavy price for the additional power in the form of lack of scalability.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596594", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jay", + "last_name": "McCarthy", + "institution": "Brigham Young University" + } + ], + "dblp_key": "conf/icfp/McCarthy09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596563", + "title": "Runtime support for multicore Haskell", + "abstract": "Purely functional programs should run well on parallel hardware because of the absence of side effects, but it has proved hard to realise this potential in practice. Plenty of papers describe promising ideas, but vastly fewer describe real implementations with good wall-clock performance. We describe just such an implementation, and quantitatively explore some of the complex design tradeoffs that make such implementations hard to build. Our measurements are necessarily detailed and specific, but they are reproducible, and we believe that they offer some general insights.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596563", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Satnam", + "last_name": "Singh", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/MarlowJS09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596553", + "title": "Commutative monads, diagrams and knots", + "abstract": "There is certain diverse class of diagram that is found in a variety of branches of mathematics and which all share this property: there is a common scheme for translating all of these diagrams into useful functional code. These diagrams include Bayesian networks, quantum computer circuits [1], trace diagrams for multilinear algebra [2], Feynman diagrams and even knot diagrams [3]. I will show how a common thread lying behind these diagrams is the presence of a commutative monad and I will show how we can use this fact to translate these diagrams directly into Haskell code making use of do-notation for monads. I will also show a number of examples of such translated code at work and use it to solve problems ranging from Bayesian inference to the topological problem of untangling tangled strings. Along the way I hope to give a little insight into the subjects mentioned above and illustrate how a functional programming language can be a valuable tool in mathematical research and experimentation.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596553", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dan P.", + "last_name": "Piponi", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Piponi09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596552", + "title": "Lambda, the ultimate TA: using a proof assistant to teach programming language foundations", + "abstract": "Ambitious experiments using proof assistants for programming language research and teaching are all the rage. In this talk, I'll report on one now underway at the University of Pennsylvania and several other sites: a one-semester graduate course in the theory of programming languages presented entirely - every lecture, every homework assignment - in Coq. I'll try to give a sense of what the course is like for both instructors and students, describe some of the most interesting challenges in developing it, and explain why I now believe such machine-assisted courses are the way of the future.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596552", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/Pierce09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596578", + "title": "Experience report: Haskell in the 'real world': writing a commercial application in a lazy functional lanuage", + "abstract": "I describe the initial attempt of experienced business software developers with minimal functional programming background to write a non-trivial, business-critical application entirely in Haskell. Some parts of the application domain are well suited to a mathematically-oriented language; others are more typically done in languages such as C++.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596578", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Curt J.", + "last_name": "Sampson", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Sampson09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596558", + "title": "Safe functional reactive programming through dependent types", + "abstract": "Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on signals. FRP is based on the synchronous data-flow paradigm and supports both continuous-time and discrete-time signals (hybrid systems). What sets FRP apart from most other languages for similar applications is its support for systems with dynamic structure and for higher-order reactive constructs.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596558", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neil", + "last_name": "Sculthorpe", + "institution": "University of Nottingham" + }, + { + "first_name": "Henrik", + "last_name": "Nilsson", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/icfp/SculthorpeN09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596592", + "title": "Control-flow analysis of function calls and returns by abstract interpretation", + "abstract": "We derive a control-flow analysis that approximates the interprocedural control-flow of both function calls and returns in the presence of first-class functions and tail-call optimization. In addition to an abstract environment, our analysis computes for each expression an abstract control stack, effectively approximating where function calls return across optimized tail calls. The analysis is systematically calculated by abstract interpretation of the stack-based CaEK abstract machine of Flanagan et al. using a series of Galois connections. Abstract interpretation provides a unifying setting in which we 1) prove the analysis equivalent to the composition of a continuation-passing style (CPS) transformation followed by an abstract interpretation of a stack-less CPS machine, and 2) extract an equivalent constraint-based formulation, thereby providing a rational reconstruction of a constraint-based control-flow analysis from abstract interpretation principles.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596592", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jan", + "last_name": "Midtgaard", + "institution": "Roskilde University" + }, + { + "first_name": "Thomas Wiben", + "last_name": "Jensen", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/icfp/MidtgaardJ09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596572", + "title": "Non-parametric parametricity", + "abstract": "Type abstraction and intensional type analysis are features seemingly at odds-type abstraction is intended to guarantee parametricity and representation independence, while type analysis is inherently non-parametric. Recently, however, several researchers have proposed and implemented \"dynamic type generation\" as a way to reconcile these features. The idea is that, when one defines an abstract type, one should also be able to generate at run time a fresh type name, which may be used as a dynamic representative of the abstract type for purposes of type analysis. The question remains: in a language with non-parametric polymorphism, does dynamic type generation provide us with the same kinds of abstraction guarantees that we get from parametric polymorphism?", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596572", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Georg", + "last_name": "Neis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/NeisDR09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596582", + "title": "Experience report: using objective caml to develop safety-critical embedded tools in a certification framework", + "abstract": "High-level tools have become unavoidable in industrial software development processes. Safety-critical embedded programs don't escape this trend. In the context of safety-critical embedded systems, the development processes follow strict guidelines and requirements. The development quality assurance applies as much to the final embedded code, as to the tools themselves. The French company Esterel Technologies decided in 2006 to base its new SCADE SUITE 6TM certifiable code generator on Objective Caml. This paper outlines how it has been challenging in the context of safety critical software development by the rigorous norms DO-178B, IEC 61508, EN 50128 and such.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596582", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bruno", + "last_name": "Pagano", + "institution": "" + }, + { + "first_name": "Olivier", + "last_name": "Andrieu", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "Moniot", + "institution": "" + }, + { + "first_name": "Benjamin", + "last_name": "Canou", + "institution": "Sorbonne Université" + }, + { + "first_name": "Emmanuel", + "last_name": "Chailloux", + "institution": "Sorbonne Université" + }, + { + "first_name": "Philippe", + "last_name": "Wang", + "institution": "Sorbonne Université" + }, + { + "first_name": "Pascal", + "last_name": "Manoury", + "institution": "Sorbonne Université" + }, + { + "first_name": "Jean-Louis", + "last_name": "Colaço", + "institution": "" + } + ], + "dblp_key": "conf/icfp/PaganoAMCCWMC09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596551", + "title": "Organizing functional code for parallel execution or, foldl and foldr considered slightly harmful", + "abstract": "Alan Perlis, inverting OscarWilde's famous quip about cynics, once suggested, decades ago, that a Lisp programmer is one who knows the value of everything and the cost of nothing. Now that the conference on Lisp and Functional Programming has become ICFP, some may think that OCaml and Haskell programmers have inherited this (now undeserved) epigram.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596551", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Steele09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596562", + "title": "Experience report: embedded, parallel computer-vision with a functional DSL", + "abstract": "This paper presents our experience using a domain-specific functional language, WaveScript, to build embedded sensing applications used in scientific research. We focus on a recent computervision application for detecting birds in their natural environment. The application was ported from a prototype in C++. In reimplementing the application, we gained a much cleaner factoring of its functionality (through higher-order functions and better interfaces to libraries) and a near-linear parallel speed-up with no additional effort. These benefits are offset by one substantial downside: the lack of familiarity with the language of the original vision researchers, who understandably tried to use the language in the familiar way they use C++ and thus ran into various problems.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596562", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "IIT@MIT" + }, + { + "first_name": "Teresa", + "last_name": "Ko", + "institution": "UCLA Health" + } + ], + "dblp_key": "conf/icfp/NewtonK09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596596", + "title": "Implementing first-class polymorphic delimited continuations by a type-directed selective CPS-transform", + "abstract": "We describe the implementation of first-class polymorphic delimited continuations in the programming language Scala. We use Scala's pluggable typing architecture to implement a simple type and effect system, which discriminates expressions with control effects from those without and accurately tracks answer type modification incurred by control effects. To tackle the problem of implementing first-class continuations under the adverse conditions brought upon by the Java VM, we employ a selective CPS transform, which is driven entirely by effect-annotated types and leaves pure code in direct style. Benchmarks indicate that this high-level approach performs competitively.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596596", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ingo", + "last_name": "Maier", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/icfp/RompfMO09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596588", + "title": "Parallel concurrent ML", + "abstract": "Concurrent ML (CML) is a high-level message-passing language that supports the construction of first-class synchronous abstractions called events. This mechanism has proven quite effective over the years and has been incorporated in a number of other languages. While CML provides a concurrent programming model, its implementation has always been limited to uniprocessors. This limitation is exploited in the implementation of the synchronization protocol that underlies the event mechanism, but with the advent of cheap parallel processing on the desktop (and laptop), it is time for Parallel CML.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596588", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Chicago" + }, + { + "first_name": "Claudio", + "last_name": "Russo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Yingqi", + "last_name": "Xiao", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/icfp/ReppyRX09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596577", + "title": "Free theorems involving type constructor classes: functional pearl", + "abstract": "Free theorems are a charm, allowing the derivation of useful statements about programs from their (polymorphic) types alone. We show how to reap such theorems not only from polymorphism over ordinary types, but also from polymorphism over type constructors restricted by class constraints. Our prime application area is that of monads, which form the probably most popular type constructor class of Haskell. To demonstrate the broader scope, we also deal with a transparent way of introducing difference lists into a program, endowed with a neat and general correctness proof.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596577", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Janis", + "last_name": "Voigtländer", + "institution": "TU Dresden" + } + ], + "dblp_key": "conf/icfp/Voigtlander09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596598", + "title": "A theory of typed coercions and its applications", + "abstract": "A number of important program rewriting scenarios can be recast as type-directed coercion insertion. These range from more theoretical applications such as coercive subtyping and supporting overloading in type theories, to more practical applications such as integrating static and dynamically typed code using gradual typing, and inlining code to enforce security policies such as access control and provenance tracking. In this paper we give a general theory of type-directed coercion insertion. We specifically explore the inherent tradeoff between expressiveness and ambiguity--the more powerful the strategy for generating coercions, the greater the possibility of several, semantically distinct rewritings for a given program. We consider increasingly powerful coercion generation strategies, work out example applications supported by the increased power (including those mentioned above), and identify the inherent ambiguity problems of each setting, along with various techniques to tame the ambiguities.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596598", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/SwamyHB09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596599", + "title": "Complete and decidable type inference for GADTs", + "abstract": "GADTs have proven to be an invaluable language extension, for ensuring data invariants and program correctness among others. Unfortunately, they pose a tough problem for type inference: we lose the principal-type property, which is necessary for modular type inference.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596599", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Martin", + "last_name": "Sulzmann", + "institution": "" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/SchrijversJSV09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596586", + "title": "Attribute grammars fly first-class: how to do aspect oriented programming in Haskell", + "abstract": "Attribute Grammars (AGs), a general-purpose formalism for describing recursive computations over data types, avoid the trade-off which arises when building software incrementally: should it be easy to add new data types and data type alternatives or to add new operations on existing data types? However, AGs are usually implemented as a pre-processor, leaving e.g. type checking to later processing phases and making interactive development, proper error reporting and debugging difficult. Embedding AG into Haskell as a combinator library solves these problems.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596586", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marcos", + "last_name": "Viera", + "institution": "" + }, + { + "first_name": "S. Doaitse", + "last_name": "Swierstra", + "institution": "Utrecht University" + }, + { + "first_name": "Wouter", + "last_name": "Swierstra", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/VieraSS09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596585", + "title": "Generic programming with fixed points for mutually recursive datatypes", + "abstract": "Many datatype-generic functions need access to the recursive positions in the structure of the datatype, and therefore adopt a fixed point view on datatypes. Examples include variants of fold that traverse the data following the recursive structure, or the Zipper data structure that enables navigation along the recursive positions. However, Hindley-Milner-inspired type systems with algebraic datatypes make it difficult to express fixed points for anything but regular datatypes. Many real-life examples such as abstract syntax trees are in fact systems of mutually recursive datatypes and therefore excluded. Using Haskell's GADTs and type families, we describe a technique that allows a fixed-point view for systems of mutually recursive datatypes. We demonstrate that our approach is widely applicable by giving several examples of generic functions for this view, most prominently the Zipper.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596585", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alexey Rodriguez", + "last_name": "Yakushev", + "institution": "Vector Fabrics (Netherlands)" + }, + { + "first_name": "Stefan", + "last_name": "Holdermans", + "institution": "Utrecht University" + }, + { + "first_name": "Andres", + "last_name": "Löh", + "institution": "Utrecht University" + }, + { + "first_name": "Johan", + "last_name": "Jeuring", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/YakushevHLJ09", + "venue": "icfp", + "year": 2009 + }, + { + "paper_id": "10.1145/1596550.1596575", + "title": "Partial memoization of concurrency and communication", + "abstract": "Memoization is a well-known optimization technique used to eliminate redundant calls for pure functions. If a call to a function f with argument v yields result r, a subsequent call to f with v can be immediately reduced to r without the need to re-evaluate f's body. Understanding memoization in the presence of concurrency and communication is significantly more challenging. For example, if f communicates with other threads, it is not sufficient to simply record its input/output behavior; we must also track inter-thread dependencies induced by these communication actions. Subsequent calls to f can be elided only if we can identify an interleaving of actions from these call-sites that lead to states in which these dependencies are satisfied. Similar issues arise if f spawns additional threads. In this paper, we consider the memoization problem for a higher-order concurrent language whose threads may communicate through synchronous message-based communication. To avoid the need to perform unbounded state space search that may be necessary to determine if all communication dependencies manifest in an earlier call can be satisfied in a later one, we introduce a weaker notion of memoization called partial memoization that gives implementations the freedom to avoid performing some part, if not all, of a previously memoized call. To validate the effectiveness of our ideas, we consider the benefits of memoization for reducing the overhead of recomputation for streaming, server-based, and transactional applications executed on a multi-core machine. We show that on a variety of workloads, memoization can lead to substantial performance improvements without incurring high memory costs.", + "date": "2009-08-31", + "link": "https://doi.org/10.1145/1596550.1596575", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lukasz", + "last_name": "Ziarek", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/icfp/ZiarekSJ09", + "venue": "icfp", + "year": 2009 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2010.json b/data/pl_conferences/icfp/2010.json new file mode 100644 index 0000000..554f5ba --- /dev/null +++ b/data/pl_conferences/icfp/2010.json @@ -0,0 +1,930 @@ +[ + { + "paper_id": "10.1145/1863543.1863572", + "title": "Matching lenses: alignment and view update", + "abstract": "Bidirectional programming languages are a practical approach to the view update problem. Programs in these languages, called lenses, define both a view and an update policy - i.e., every program can be read as a function mapping sources to views as well as one mapping updated views back to updated sources.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863572", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Davi", + "last_name": "Barbosa", + "institution": "École Polytechnique" + }, + { + "first_name": "Julien", + "last_name": "Cretin", + "institution": "École Polytechnique" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Princeton University" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/BarbosaCFGP10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863585", + "title": "Total parser combinators", + "abstract": "A monadic parser combinator library which guarantees termination of parsing, while still allowing many forms of left recursion, is described. The library's interface is similar to those of many other parser combinator libraries, with two important differences: one is that the interface clearly specifies which parts of the constructed parsers may be infinite, and which parts have to be finite, using dependent types and a combination of induction and coinduction; and the other is that the parser type is unusually informative.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863585", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nils Anders", + "last_name": "Danielsson", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/icfp/Danielsson10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863590", + "title": "Program verification through characteristic formulae", + "abstract": "This paper describes CFML, the first program verification tool based on characteristic formulae. Given the source code of a pure Caml program, this tool generates a logical formula that implies any valid post-condition for that program. One can then prove that the program satisfies a given specification by reasoning interactively about the characteristic formula using a proof assistant such as Coq. Our characteristic formulae improve over Honda et al's total characteristic assertion pairs in that they are expressible in standard higher-order logic, allowing to exploit them in practice to verify programs using existing proof assistants. Our technique has been applied to formally verify more than half of the content of Okasaki's Purely Functional Data Structures reference book", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863590", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Chargueraud10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863579", + "title": "Functional parallel algorithms", + "abstract": "Functional programming presents several important advantages in the design, analysis and implementation of parallel algorithms:", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863579", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Blelloch10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863576", + "title": "Experience report: growing programming languages for beginning students", + "abstract": "A student learning how to program learns best when the programming language and programming environment cater to her specific needs. These needs are different from the requirements of a professional programmer. Consequently, the design of teaching languages poses challenges different from the design of professional languages. Using a functional language by itself gives advantages over more popular, professional languages, but fully exploiting these advantages requires careful adaptation to the needs of the students' as-is, these languages do not support the students nearly as well as they could. This paper describes our experience adopting the didactic approach of How to Design Programs, focussing on the design process for our own set of teaching languages. We have observed students as they try to program as part of our introductory course, and used these observations to significantly improve the design of these languages. This paper describes the changes we have made, and the journey we took to get there.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863576", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marcus", + "last_name": "Crestani", + "institution": "University of Tübingen" + }, + { + "first_name": "Michael", + "last_name": "Sperber", + "institution": "" + } + ], + "dblp_key": "conf/icfp/CrestaniS10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863563", + "title": "TeachScheme!: a checkpoint", + "abstract": "In 1995, my team and I decided to create an outreach project that would use our research on functional programming to change the K-12 computer science curriculum. We had two different goals in mind. On the one hand, our curriculum should rely on mathematics to teach programming, and it d exploit programming to teach mathematics. All students - not just those who major in computer science - should benefit. On the other hand, our course should demonstrate that introductory programming can focus on program design, not just a specific syntax. We also wished to create a smooth path from a design-oriented introductory course all the way to courses on large software projects.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863563", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/Felleisen10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863577", + "title": "Fortifying macros", + "abstract": "Existing macro systems force programmers to make a choice between clarity of specification and robustness. If they choose clarity, they must forgo validating significant parts of the specification and thus produce low-quality language extensions. If they choose robustness, they must write in a style that mingles the implementation with the specification and therefore obscures the latter.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863577", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Culpepper", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/CulpepperF10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863558", + "title": "Lazy tree splitting", + "abstract": "Nested data-parallelism (NDP) is a declarative style for programming irregular parallel applications. NDP languages provide language features favoring the NDP style, efficient compilation of NDP programs, and various common NDP operations like parallel maps, filters, and sum-like reductions. In this paper, we describe the implementation of NDP in Parallel ML (PML), part of the Manticore project. Managing the parallel decomposition of work is one of the main challenges of implementing NDP. If the decomposition creates too many small chunks of work, performance will be eroded by too much parallel overhead. If, on the other hand, there are too few large chunks of work, there will be too much sequential processing and processors will sit idle.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863558", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lars", + "last_name": "Bergström", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Adam", + "last_name": "Shaw", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Rochester Institute of Technology" + } + ], + "dblp_key": "conf/icfp/BergstromRRSF10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863581", + "title": "Specifying and verifying sparse matrix codes", + "abstract": "Sparse matrix formats are typically implemented with low-level imperative programs. The optimized nature of these implementations hides the structural organization of the sparse format and complicates its verification. We define a variable-free functional language (LL) in which even advanced formats can be expressed naturally, as a pipeline-style composition of smaller construction steps. We translate LL programs to Isabelle/HOL and describe a proof system based on parametric predicates for tracking relationship between mathematical vectors and their concrete representations. This proof theory automatically verifies full functional correctness of many formats. We show that it is reusable and extensible to hierarchical sparse formats.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863581", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gilad", + "last_name": "Arnold", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Johannes", + "last_name": "Hölzl", + "institution": "Technical University of Munich" + }, + { + "first_name": "Ali Sinan", + "last_name": "Köksal", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/icfp/ArnoldHKBS10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863547", + "title": "The gentle art of levitation", + "abstract": "We present a closed dependent type theory whose inductive types are given not by a scheme for generative declarations, but by encoding in a universe. Each inductive datatype arises by interpreting its description - a first-class value in a datatype of descriptions. Moreover, the latter itself has a description. Datatype-generic programming thus becomes ordinary programming. We show some of the resulting generic operations and deploy them in particular, useful ways on the datatype of datatype descriptions itself. Simulations in existing systems suggest that this apparently self-supporting setup is achievable without paradox or infinite regress.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863547", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "James", + "last_name": "Chapman", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Pierre-Évariste", + "last_name": "Dagand", + "institution": "University of Strathclyde" + }, + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" + }, + { + "first_name": "Peter", + "last_name": "Morris", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/icfp/ChapmanDMM10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863550", + "title": "ReCaml: execution state as the cornerstone of reconfigurations", + "abstract": "To fix bugs or to enhance a software system without service disruption, one has to update it dynamically during execution. Most prior dynamic software updating techniques require that the code to be changed is not running at the time of the update. However, this restriction precludes any change to the outermost loops of servers, OS scheduling loops and recursive functions. Permitting a dynamic update to more generally manipulate the program's execution state, including the runtime stack, alleviates this restriction but increases the likelihood of type errors. In this paper we present ReCaml, a language for writing dynamic updates to running programs that views execution state as a delimited continuation. ReCaml includes a novel feature for introspecting continuations called match_cont which is sufficiently powerful to implement a variety of updating policies. We have formalized the core of ReCaml and proved it sound (using the Coq proof assistant), thus ensuring that state-manipulating updates preserve type-safe execution of the updated program. We have implemented ReCaml as an extension to the Caml bytecode interpreter and used it for several examples.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863550", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jérémy", + "last_name": "Buisson", + "institution": "Université Européenne de Bretagne" + }, + { + "first_name": "Fabien", + "last_name": "Dagnat", + "institution": "Université Européenne de Bretagne" + } + ], + "dblp_key": "conf/icfp/BuissonD10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863560", + "title": "Semantic subtyping with an SMT solver", + "abstract": "We study a first-order functional language with the novel combination of the ideas of refinement type (the subset of a type to satisfy a Boolean expression) and type-test (a Boolean expression testing whether a value belongs to a type). Our core calculus can express a rich variety of typing idioms; for example, intersection, union, negation, singleton, nullable, variant, and algebraic types are all derivable. We formulate a semantics in which expressions denote terms, and types are interpreted as first-order logic formulas. Subtyping is defined as valid implication between the semantics of types. The formulas are interpreted in a specific model that we axiomatize using standard first-order theories. On this basis, we present a novel type-checking algorithm able to eliminate many dynamic tests and to detect many errors statically. The key idea is to rely on an SMT solver to compute subtyping efficiently. Moreover, interpreting types as formulas allows us to call the SMT solver at run-time to compute instances of types.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863560", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Saarland University" + }, + { + "first_name": "David E.", + "last_name": "Langworthy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/BiermanGHL10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863592", + "title": "Parametricity and dependent types", + "abstract": "Reynolds' abstraction theorem shows how a typing judgement in System F can be translated into a relational statement (in second order predicate logic) about inhabitants of the type. We (in second order predicate logic) about inhabitants of the type. We obtain a similar result for a single lambda calculus (a pure type system), in which terms, types and their relations are expressed. Working within a single system dispenses with the need for an interpretation layer, allowing for an unusually simple presentation. While the unification puts some constraints on the type system (which we spell out), the result applies to many interesting cases, including dependently-typed ones.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863592", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "University of Gothenburg" + }, + { + "first_name": "Patrik", + "last_name": "Jansson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Ross", + "last_name": "Paterson", + "institution": "City, University of London" + } + ], + "dblp_key": "conf/icfp/BernardyJP10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863587", + "title": "Scrapping your inefficient engine: using partial evaluation to improve domain-specific language implementation", + "abstract": "Partial evaluation aims to improve the efficiency of a program by specialising it with respect to some known inputs. In this paper, we show that partial evaluation can be an effective and, unusually, easy to use technique for the efficient implementation of embedded domain-specific languages. We achieve this by exploiting dependent types and by following some simple rules in the definition of the interpreter for the domain-specific language. We present experimental evidence that partial evaluation of programs in domain-specific languages can yield efficient residual programs whose performance is competitive with their Java and C equivalents and which are also, through the use of dependent types, verifiably resource-safe. Using our technique, it follows that a verifiably correct and resource-safe program can also be an efficient program", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863587", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Edwin", + "last_name": "Brady", + "institution": "University of St Andrews" + }, + { + "first_name": "Kevin", + "last_name": "Hammond", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/icfp/BradyH10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863566", + "title": "The impact of higher-order state and control effects on local relational reasoning", + "abstract": "Reasoning about program equivalence is one of the oldest problems in semantics. In recent years, useful techniques have been developed, based on bisimulations and logical relations, for reasoning about equivalence in the setting of increasingly realistic languages - languages nearly as complex as ML or Haskell. Much of the recent work in this direction has considered the interesting representation independence principles enabled by the use of local state, but it is also important to understand the principles that powerful features like higher-order state and control effects disable. This latter topic has been broached extensively within the framework of game semantics, resulting in what Abramsky dubbed the \"semantic cube\": fully abstract game-semantic characterizations of various axes in the design space of ML-like languages. But when it comes to reasoning about many actual examples, game semantics does not yet supply a useful technique for proving equivalences.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863566", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Georg", + "last_name": "Neis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/DreyerNB10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863594", + "title": "A play on regular expressions: functional pearl", + "abstract": "Cody, Hazel, and Theo, two experienced Haskell programmers and an expert in automata theory, develop an elegant Haskell program for matching regular expressions: (i) the program is purely functional; (ii) it is overloaded over arbitrary semirings, which not only allows to solve the ordinary matching problem but also supports other applications like computing leftmost longest matchings or the number of matchings, all with a single algorithm; (iii) it is more powerful than other matchers, as it can be used for parsing every context-free language by taking advantage of laziness.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863594", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Fischer", + "institution": "Kiel University" + }, + { + "first_name": "Frank", + "last_name": "Huch", + "institution": "Kiel University" + }, + { + "first_name": "Thomas", + "last_name": "Wilke", + "institution": "Kiel University" + } + ], + "dblp_key": "conf/icfp/FischerHW10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863565", + "title": "Higher-order representation of substructural logics", + "abstract": "We present a technique for higher-order representation of substructural logics such as linear or modal logic. We show that such logics can be encoded in the (ordinary) Logical Framework, without any linear or modal extensions. Using this encoding, metatheoretic proofs about such logics can easily be developed in the Twelf proof assistant.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863565", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/Crary10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863545", + "title": "ML: metalanguage or object language?", + "abstract": "My talk will celebrate Robin Milner's contribution to functional programming via a combination of reminiscences about the early days of ML and speculations about its future.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863545", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael J. C.", + "last_name": "Gordon", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/Gordon10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863553", + "title": "Abstracting abstract machines", + "abstract": "We describe a derivational approach to abstract interpretation that yields novel and transparently sound static analyses when applied to well-established abstract machines. To demonstrate the technique and support our claim, we transform the CEK machine of Felleisen and Friedman, a lazy variant of Krivine's machine, and the stack-inspecting CM machine of Clements and Felleisen into abstract interpretations of themselves. The resulting analyses bound temporal ordering of program events; predict return-flow and stack-inspection behavior; and approximate the flow and evaluation of by-need parameters. For all of these machines, we find that a series of well-known concrete machine refactorings, plus a technique we call store-allocated continuations, leads to machines that abstract into static analyses simply by bounding their stores. We demonstrate that the technique scales up uniformly to allow static analysis of realistic language features, including tail calls, conditionals, side effects, exceptions, first-class continuations, and even garbage collection.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863553", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "Northeastern University" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/icfp/HornM10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863554", + "title": "Polyvariant flow analysis with higher-ranked polymorphic types and higher-order effect operators", + "abstract": "We present a type and effect system for flow analysis that makes essential use of higher-ranked polymorphism. We show that, for higher-order functions, the expressiveness of higher-ranked types enables us to improve on the precision of conventional let-polymorphic analyses. Modularity and decidability of the analysis are guaranteed by making the analysis of each program parametric in the analyses of its inputs; in particular, we have that higher-order functions give rise to higher-order operations on effects. As flow typing is archetypical to a whole class of type and effect systems, our approach can be used to boost the precision of a wide range of type-based program analyses for higher-order languages.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863554", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Holdermans", + "institution": "Vector Fabrics (Netherlands)" + }, + { + "first_name": "Jurriaan", + "last_name": "Hage", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/HoldermansH10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863582", + "title": "Regular, shape-polymorphic, parallel arrays in Haskell", + "abstract": "We present a novel approach to regular, multi-dimensional arrays in Haskell. The main highlights of our approach are that it (1) is purely functional, (2) supports reuse through shape polymorphism, (3) avoids unnecessary intermediate structures rather than relying on subsequent loop fusion, and (4) supports transparent parallelisation.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863582", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "UNSW Sydney" + }, + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Roman", + "last_name": "Leshchinskiy", + "institution": "UNSW Sydney" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Ben", + "last_name": "Lippmeier", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/icfp/KellerCLJL10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863551", + "title": "Lolliproc: to concurrency from classical linear logic via curry-howard and control", + "abstract": "While many type systems based on the intuitionistic fragment of linear logic have been proposed, applications in programming languages of the full power of linear logic - including double-negation elimination - have remained elusive. Meanwhile, linearity has been used in many type systems for concurrent programs - e.g., session types - which suggests applicability to the problems of concurrent programming, but the ways in which linearity has interacted with concurrency primitives in lambda calculi have remained somewhat ad-hoc. In this paper we connect classical linear logic and concurrent functional programming in the language Lolliproc, which provides simple primitives for concurrency that have a direct logical interpretation and that combine to provide the functionality of session types. Lolliproc features a simple process calculus \"under the hood\" but hides the machinery of processes from programmers. We illustrate Lolliproc by example and prove soundness, strong normalization, and confluence results, which, among other things, guarantees freedom from deadlocks and race conditions.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863551", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Karl", + "last_name": "Mazurak", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/MazurakZ10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863584", + "title": "A certified framework for compiling and executing garbage-collected languages", + "abstract": "We describe the design, implementation, and use of a machine-certified framework for correct compilation and execution of programs in garbage-collected languages. Our framework extends Leroy's Coq-certified Compcert compiler and Cminor intermediate language. We add: (i) a new intermediate language, GCminor, that includes primitives for allocating memory in a garbage-collected heap and for specifying GC roots; (ii) a precise, low-level specification for a Cminor library for garbage collection; and (iii) a proven semantics-preserving translation from GCminor to Cminor plus the GC library. GCminor neatly encapsulates the interface between mutator and collector code, while remaining simple and flexible enough to be used with a wide variety of source languages and collector styles. Front ends targeting GCminor can be implemented using any compiler technology and any desired degree of verification, including full semantics preservation, type preservation, or informal trust.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863584", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrew", + "last_name": "McCreight", + "institution": "Portland State University" + }, + { + "first_name": "Tim", + "last_name": "Chevalier", + "institution": "Portland State University" + }, + { + "first_name": "Andrew", + "last_name": "Tolmach", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/McCreightCT10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863573", + "title": "Bidirectionalizing graph transformations", + "abstract": "Bidirectional transformations provide a novel mechanism for syn-chronizing and maintaining the consistency of information between input and output. Despite many promising results on bidirectional transformations, these have been limited to the context of relational or XML (tree-like) databases. We challenge the problem of bidirec-tional transformations within the context of graphs, by proposing a formal definition of a well-behaved bidirectional semantics for UnCAL, i.e., a graph algebra for the known UnQL graph query language. The key to our successful formalization is full utiliza-tion of both the recursive and bulk semantics of structural recur-sion on graphs. We carefully refine the existing forward evaluation of structural recursion so that it can produce sufficient trace infor-mation for later backward evaluation. We use the trace information for backward evaluation to reflect in-place updates and deletions on the view to the source, and adopt the universal resolving algorithm for inverse computation and the narrowing technique to tackle the difficult problem with insertion. We prove our bidirectional evalu-ation is well-behaved. Our current implementation is available on-line and confirms the usefulness of our approach with nontrivial applications.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863573", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Soichiro", + "last_name": "Hidaka", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Kazuhiro", + "last_name": "Inaba", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Hiroyuki", + "last_name": "Kato", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + }, + { + "first_name": "Keisuke", + "last_name": "Nakano", + "institution": "University of Electro-Communications" + } + ], + "dblp_key": "conf/icfp/HidakaHIKMN10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863569", + "title": "Security-typed programming within dependently typed programming", + "abstract": "Abstract. Several recent security-typed programming languages allow programmers to express and enforce authorization policies governing access to controlled resources. Policies are expressed as propositions in an authorization logic, and enforced by a type system that requires each access to a sensitive resource to be accompanied by a proof. The securitytyped languages described in the literature, such as Aura and PCML5, have been presented as new, stand-alone language designs. In this paper, we instead show how to embed a security-typed programming language within an existing dependently typed programming language, Agda. This language-design strategy allows us to inherit both the metatheoretic results, such as type safety, and the implementation of the host language. Our embedding consists of the following ingredients: First, we represent the syntax and proofs of an authorization logic, Garg and Pfenning’s BL0, using dependent types. Second, we implement a proof search procedure, based on a focused sequent calculus, to ease the burden of constructing proofs. Third, we define an indexed monad of computations on behalf of a principal, with proof-carrying primitive operations. Our work shows that a dependently typed language can be used to prototype a security-typed language, and contributes to the growing body of literature on using dependently typed languages to construct domain-specific type systems. 1", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863569", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jamie", + "last_name": "Morgenstern", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/MorgensternL10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863596", + "title": "Instance chains: type class programming without overlapping instances", + "abstract": "Type classes have found a wide variety of uses in Haskell programs, from simple overloading of operators (such as equality or ordering) to complex invariants used to implement type-safe heterogeneous lists or limited subtyping. Unfortunately, many of the richer uses of type classes require extensions to the class system that have been incompletely described in the research literature and are not universally accepted within the Haskell community.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863596", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "Portland State University" + }, + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/MorrisJ10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863595", + "title": "Experience report: Haskell as a reagent: results and observations on the use of Haskell in a python project", + "abstract": "In system administration, the languages of choice for solving automation tasks are scripting languages, owing to their flexibility, extensive library support and quick development cycle. Functional programming is more likely to be found in software development teams and the academic world.This separation means that system administrators cannot use the most effective tool for a given problem; in an ideal world, we should be able to mix and match different languages, based on the problem at hand.This experience report details our initial introduction and use of Haskell in a mature, medium size project implemented in Python. We also analyse the interaction between the two languages, and show how Haskell has excelled at solving a particular type of real-world problems", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863595", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Iustin", + "last_name": "Pop", + "institution": "Google (Switzerland)" + } + ], + "dblp_key": "conf/icfp/Pop10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863575", + "title": "A fresh look at programming with names and binders", + "abstract": "A wide range of computer programs, including compilers and theorem provers, manipulate data structures that involve names and binding. However, the design of programming idioms which allow performing these manipulations in a safe and natural style has, to a large extent, remained elusive.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863575", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Pouillard", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/PouillardP10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863588", + "title": "Rethinking supercompilation", + "abstract": "Supercompilation is a program optimisation technique that is particularly effective at eliminating unnecessary overheads. We have designed a new supercompiler, making many novel choices, including different termination criteria and handling of let bindings. The result is a supercompiler that focuses on simplicity, compiles programs quickly and optimises programs well. We have benchmarked our supercompiler, with some programs running more than twice as fast than when compiled with GHC.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863588", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neil", + "last_name": "Mitchell", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Mitchell10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863556", + "title": "The reduceron reconfigured", + "abstract": "The leading implementations of graph reduction all target conventional processors designed for low-level imperative execution. In this paper, we present a processor specially designed to perform graph-reduction. Our processor -- the Reduceron -- is implemented using off-the-shelf reconfigurable hardware. We highlight the low-level parallelism present in sequential graph reduction, and show how parallel memories and dynamic analyses are used in the Reduceron to achieve an average reduction rate of 0.55 function applications per clock-cycle.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863556", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Naylor", + "institution": "University of York" + }, + { + "first_name": "Colin", + "last_name": "Runciman", + "institution": "University of York" + } + ], + "dblp_key": "conf/icfp/NaylorR10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863557", + "title": "Using functional programming within an industrial product group: perspectives and perceptions", + "abstract": "We present a case-study of using OCaml within a large product development project, focussing on both the technical and non-technical issues that arose as a result. We draw comparisons between the OCaml team and the other teams that worked on the project, providing comparative data on hiring patterns and cross-team code contribution.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863557", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Scott", + "institution": "Citrix (United Kingdom)" + }, + { + "first_name": "Richard R.", + "last_name": "Sharp", + "institution": "Citrix (United Kingdom)" + }, + { + "first_name": "Thomas", + "last_name": "Gazagnaire", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Anil", + "last_name": "Madhavapeddy", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/ScottSGM10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863561", + "title": "Logical types for untyped languages", + "abstract": "Programmers reason about their programs using a wide variety of formal and informal methods. Programmers in untyped languages such as Scheme or Erlang are able to use any such method to reason about the type behavior of their programs. Our type system for Scheme accommodates common reasoning methods by assigning variable occurrences a subtype of their declared type based on the predicates prior to the occurrence, a discipline dubbed occurrence typing. It thus enables programmers to enrich existing Scheme code with types, while requiring few changes to the code itself.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863561", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/Tobin-HochstadtF10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863568", + "title": "Distance makes the types grow stronger: a calculus for differential privacy", + "abstract": "We want assurances that sensitive information will not be disclosed when aggregate data derived from a database is published. Differential privacy offers a strong statistical guarantee that the effect of the presence of any individual in a database will be negligible, even when an adversary has auxiliary knowledge. Much of the prior work in this area consists of proving algorithms to be differentially private one at a time; we propose to streamline this process with a functional language whose type system automatically guarantees differential privacy, allowing the programmer to write complex privacy-safe query programs in a flexible and compositional way.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863568", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jason", + "last_name": "Reed", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/ReedP10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863548", + "title": "Functional pearl: every bit counts", + "abstract": "We show how the binary encoding and decoding of typed data and typed programs can be understood, programmed, and verified with the help of question-answer games. The encoding of a value is determined by the yes/no answers to a sequence of questions about that value; conversely, decoding is the interpretation of binary data as answers to the same question scheme.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863548", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/VytiniotisK10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863571", + "title": "Combining syntactic and semantic bidirectionalization", + "abstract": "Matsuda et al. [2007, ICFP] and Voigtländer [2009, POPL] introduced two techniques that given a source-to-view function provide an update propagation function mapping an original source and an updated view back to an updated source, subject to standard consistency conditions. Being fundamentally different in approach, both techniques have their respective strengths and weaknesses. Here we develop a synthesis of the two techniques to good effect. On the intersection of their applicability domains we achieve more than what a simple union of applying the techniques side by side delivers.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863571", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Janis", + "last_name": "Voigtländer", + "institution": "University of Bonn" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/VoigtlanderHMW10", + "venue": "icfp", + "year": 2010 + }, + { + "paper_id": "10.1145/1863543.1863591", + "title": "VeriML: typed computation of logical terms inside a language with effects", + "abstract": "Modern proof assistants such as Coq and Isabelle provide high degrees of expressiveness and assurance because they support formal reasoning in higher-order logic and supply explicit machine-checkable proof objects. Unfortunately, large scale proof development in these proof assistants is still an extremely difficult and time-consuming task. One major weakness of these proof assistants is the lack of a single language where users can develop complex tactics and decision procedures using a rich programming model and in a typeful manner. This limits the scalability of the proof development process, as users avoid developing domain-specific tactics and decision procedures.", + "date": "2010-09-27", + "link": "https://doi.org/10.1145/1863543.1863591", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Antonis", + "last_name": "Stampoulis", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/StampoulisS10", + "venue": "icfp", + "year": 2010 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2011.json b/data/pl_conferences/icfp/2011.json new file mode 100644 index 0000000..0b06d66 --- /dev/null +++ b/data/pl_conferences/icfp/2011.json @@ -0,0 +1,999 @@ +[ + { + "paper_id": "10.1145/2034773.2034830", + "title": "An equivalence-preserving CPS translation via multi-language semantics", + "abstract": "Language-based security relies on the assumption that all potential attacks follow the rules of the language in question. When programs are compiled into a different language, this is true only if the translation process preserves observational equivalence.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034830", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "M.", + "last_name": "Blume", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/icfp/AhmedB11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034809", + "title": "Using camlp4 for presenting dynamic mathematics on the web: DynaMoW, an OCaml language extension for the run-time generation of mathematical contents and their presentation on the web", + "abstract": "International audience", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034809", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Frédéric", + "last_name": "Chyzak", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Alexis", + "last_name": "Darrasse", + "institution": "Laboratoire de Recherche en Informatique de Paris 6" + } + ], + "dblp_key": "conf/icfp/ChyzakD11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034828", + "title": "Characteristic formulae for the verification of imperative programs", + "abstract": "In previous work, we introduced an approach to program verification based on characteristic formulae. The approach consists of generating a higher-order logic formula from the source code of a program. This characteristic formula is constructed in such a way that it gives a sound and complete description of the semantics of that program. The formula can thus be exploited in an interactive proof assistant to formally verify that the program satisfies a particular specification.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034828", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/Chargueraud11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034807", + "title": "A hierarchy of mendler style recursion combinators: taming inductive datatypes with negative occurrences", + "abstract": "The Mendler style catamorphism (which corresponds to weak induction) always terminates even for negative inductive datatypes. The Mendler style histomorphism (which corresponds to strong induction) is known to terminate for positive inductive datatypes. To our knowledge, the literature is silent on its termination properties for negative datatypes. In this paper, we prove that histomorphisms do not always termintate by showing a counter-example. We also enrich the Mendler collection of recursion combinators by defining a new form of Mendler style catamorphism (msfcata), which terminates for all inductive datatypes, that is more expressive than the original. We organize the collection of combinators by placing them into a hierarchy of ever increasing generality, and describing the termination properties of each point on the hierarchy. We also provide many examples (including a case study on a negative inductive datatype), which illustrate both the expressive power and beauty of the Mendler style. One lesson we learn from this work is that weak induction applies to negative inductive datatypes but strong induction is problematic. We provide a proof of weak induction by exhibiting an embedding of our new combinator into Fω. We pose the open question: Is there a safe way to apply strong induction to negative inductive datatypes?", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034807", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ki Yung", + "last_name": "Ahn", + "institution": "Portland State University" + }, + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/AhnS11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034792", + "title": "Implicit self-adjusting computation for purely functional programs", + "abstract": "Computational problems that involve dynamic data, such as physics simulations and program development environments, have been an important subject of study in programming languages. Building on this work, recent advances in self-adjusting computation have developed techniques that enable programs to respond automatically and efficiently to dynamic changes in their inputs. Self-adjusting programs have been shown to be efficient for a reasonably broad range of problems but the approach still requires an explicit programming style, where the programmer must use specific monadic types and primitives to identify, create and operate on data that can change over time.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034792", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yan", + "last_name": "Chen", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/ChenDHA11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034789", + "title": "Parametric polymorphism and semantic subtyping: the logical connection", + "abstract": "We consider a type algebra equipped with recursive, product, function, intersection, union, and complement types together with type variables and implicit universal quantification over them. We consider the subtyping relation recently defined by Castagna and Xu over such type expressions and show how this relation can be decided in EXPTIME, answering an open question. The novelty, originality and strength of our solution reside in introducing a logical modeling for the semantic subtyping framework. We model semantic subtyping in a tree logic and use a satisfiability-testing algorithm in order to decide subtyping. We report on practical experiments made with a full implementation of the system. This provides a powerful polymorphic type system aiming at maintaining full static type-safety of functional programs that manipulate trees, even with higher-order functions, which is particularly useful in the context of XML.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034789", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nils", + "last_name": "Gesbert", + "institution": "Centre Inria de l'Université Grenoble Alpes" + }, + { + "first_name": "Pierre", + "last_name": "Genevès", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Nabil", + "last_name": "Layaïda", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/GesbertGL11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034804", + "title": "Deriving an efficient FPGA implementation of a low density parity check forward error corrector", + "abstract": "Creating correct hardware is hard. Though there is much talk of using formal and semi-formal methods to develop designs and implementations, in practice most implementations are written without the support of any formal or semi-formal methodology. Having such a methodology brings many benefits, including improved likelihood of a correct implementation, lowering the cost of design exploration and lowering the cost of certification. In this paper, we introduce a semi formal methodology for connecting executable specifications written in the functional language Haskell to efficient VHDL implementations. The connection is performed by manual edits, using semi-formal equational reasoning facilitated by the worker/wrapper transformation, and directed using commutable functors. We explain our methodology on a full-scale example, an efficient Low-Density Parity Check forward error correcting code, which has been implemented on a Virtex-5 FPGA.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034804", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andy", + "last_name": "Gill", + "institution": "University of Kansas" + }, + { + "first_name": "Andrew", + "last_name": "Farmer", + "institution": "University of Kansas" + } + ], + "dblp_key": "conf/icfp/GillF11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034814", + "title": "Forest: a language and toolkit for programming with filestores", + "abstract": "A filestore is a structured collection of data files housed in a conventional hierarchical file system. Many applications use filestores as a poor-man's database, and the correct execution of these applications requires that the collection of files, directories, and symbolic links stored on disk satisfy a variety of precise invariants. Moreover, all of these structures must have acceptable ownership, permission, and timestamp attributes. Unfortunately, current programming languages do not provide support for documenting assumptions about filestores, detecting errors in them, or safely loading from and storing to them.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034814", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Kenny Q.", + "last_name": "Zhu", + "institution": "Shanghai Jiao Tong University" + } + ], + "dblp_key": "conf/icfp/FisherFWZ11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034775", + "title": "Towards a comprehensive theory of monadic effects", + "abstract": "It has been more than 20 years since monads were proposed as a unifying concept for computational effects, in both formal semantics and functional programs. Over that period, there has been substantial incremental progress on several fronts within the ensuing research area, including denotational, operational, and axiomatic characterizations of effects; principles and frameworks for combining effects; prescriptive vs. descriptive effect-type systems; specification vs. implementation of effects; and realizations of effect-related theoretical constructions in practical functional languages, both eager and lazy. Yet few would confidently claim that programs with computational effects are by now as well understood, and as thoroughly supported by formal reasoning techniques, as types and terms in purely functional settings.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034775", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrzej", + "last_name": "Filinski", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/Filinski11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034822", + "title": "Linearity and PCF: a semantic insight!", + "abstract": "Linearity is a multi-faceted and ubiquitous notion in the analysis and the development of programming language concepts. We study linearity in a denotational perspective by picking out programs that correspond to linear functions between coherence spaces.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034822", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University of Bologna" + }, + { + "first_name": "Luca", + "last_name": "Paolini", + "institution": "University of Turin" + }, + { + "first_name": "Mauro", + "last_name": "Piccolo", + "institution": "University of Turin" + } + ], + "dblp_key": "conf/icfp/GaboardiPP11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034777", + "title": "Just do it: simple monadic equational reasoning", + "abstract": "One of the appeals of pure functional programming is that it is so amenable to equational reasoning. One of the problems of pure functional programming is that it rules out computational effects. Moggi and Wadler showed how to get round this problem by using monads to encapsulate the effects, leading in essence to a phase distinction - a pure functional evaluation yielding an impure imperative computation. Still, it has not been clear how to reconcile that phase distinction with the continuing appeal of functional programming; does the impure imperative part become inaccessible to equational reasoning? We think not; and to back that up, we present a simple axiomatic approach to reasoning about programs with computational effects.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034777", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + }, + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/GibbonsH11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034796", + "title": "On the bright side of type classes: instance arguments in Agda", + "abstract": "We present instance arguments: an alternative to type classes and related features in the dependently typed, purely functional programming language/proof assistant Agda. They are a new, general type of function arguments, resolved from call-site scope in a type-directed way. The mechanism is inspired by both Scala's implicits and Agda's existing implicit arguments, but differs from both in important ways. Our mechanism is designed and implemented for Agda, but our design choices can be applied to other programming languages as well.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034796", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/icfp/DevrieseP11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034812", + "title": "Frenetic: a network programming language", + "abstract": "Modern networks provide a variety of interrelated services including routing, traffic monitoring, load balancing, and access control. Unfortunately, the languages used to program today's networks lack modern features - they are usually defined at the low level of abstraction supplied by the underlying hardware and they fail to provide even rudimentary support for modular programming. As a result, network programs tend to be complicated, error-prone, and difficult to maintain.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034812", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Rob", + "last_name": "Harrison", + "institution": "Princeton University" + }, + { + "first_name": "Michael J.", + "last_name": "Freedman", + "institution": "Princeton University" + }, + { + "first_name": "Christopher", + "last_name": "Monsanto", + "institution": "Princeton University" + }, + { + "first_name": "Jennifer", + "last_name": "Rexford", + "institution": "Princeton University" + }, + { + "first_name": "A. S.", + "last_name": "Story", + "institution": "Cornell University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/icfp/FosterHFMRSW11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034805", + "title": "Geometry of synthesis iv: compiling affine recursion into static hardware", + "abstract": "Abramsky's Geometry of Interaction interpretation (GoI) is a logical-directed way to reconcile the process and functional views of computation, and can lead to a dataflow-style semantics of programming languages that is both operational (i.e. effective) and denotational (i.e. inductive on the language syntax). The key idea of Ghica's Geometry of Synthesis (GoS) approach is that for certain programming languages (namely Reynolds's affine Syntactic Control of Interference - SCI) the GoI processes-like interpretation of the language can be given a finitary representation, for both internal state and tokens. A physical realisation of this representation becomes a semantics-directed compiler for SCI into hardware. In this paper we examine the issue of compiling affine recursive programs into hardware using the GoS method. We give syntax and compilation techniques for unfolding recursive computation in space or in time and we illustrate it with simple benchmark-style examples. We examine the performance of the benchmarks against conventional CPU-based execution models.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034805", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dan R.", + "last_name": "Ghica", + "institution": "University of Birmingham" + }, + { + "first_name": "Alex", + "last_name": "Smith", + "institution": "University of Birmingham" + }, + { + "first_name": "Satnam", + "last_name": "Singh", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/GhicaSS11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034800", + "title": "Temporal higher-order contracts", + "abstract": "Behavioral contracts are embraced by software engineers because they document module interfaces, detect interface violations, and help identify faulty modules (packages, classes, functions, etc). This paper extends prior higher-order contract systems to also express and enforce temporal properties, which are common in software systems with imperative state, but which are mostly left implicit or are at best informally specified. The paper presents both a programmatic contract API as well as a temporal contract language, and reports on experience and performance results from implementing these contracts in Racket.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034800", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tim", + "last_name": "Disney", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Jay", + "last_name": "McCarthy", + "institution": "Brigham Young University" + } + ], + "dblp_key": "conf/icfp/DisneyFM11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034798", + "title": "How to make ad hoc proof automation less ad hoc", + "abstract": "Most interactive theorem provers provide support for some form of user-customizable proof automation. In a number of popular systems, such as Coq and Isabelle, this automation is achieved primarily through tactics, which are programmed in a separate language from that of the prover's base logic. While tactics are clearly useful in practice, they can be difficult to maintain and compose because, unlike lemmas, their behavior cannot be specified within the expressive type system of the prover itself.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034798", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Georges", + "last_name": "Gonthier", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Beta", + "last_name": "Ziliani", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/GonthierZND11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034827", + "title": "Modular verification of preemptive OS kernels", + "abstract": "Most major OS kernels today run on multiprocessor systems and are preemptive: it is possible for a process running in the kernel mode to get descheduled. Existing modular techniques for verifying concurrent code are not directly applicable in this setting: they rely on scheduling being implemented correctly, and in a preemptive kernel, the correctness of the scheduler is interdependent with the correctness of the code it schedules. This interdependency is even stronger in mainstream kernels, such as Linux, FreeBSD or XNU, where the scheduler and processes interact in complex ways.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034827", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "IMDEA Software" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/GotsmanY11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034782", + "title": "A semantic model for graphical user interfaces", + "abstract": "We give a denotational model for graphical user interface (GUI) programming using the Cartesian closed category of ultrametric spaces. The ultrametric structure enforces causality restrictions on reactive systems and allows well-founded recursive definitions by a generalization of guardedness. We capture the arbitrariness of user input (e.g., a user gets to decide the stream of clicks she sends to a program) by making use of the fact that the closed subsets of an ultrametric space themselves form an ultrametric space, allowing us to interpret nondeterminism with a \"powerspace\" monad.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034782", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/KrishnaswamiB11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034801", + "title": "Parsing with derivatives: a functional pearl", + "abstract": "We present a functional approach to parsing unrestricted context-free grammars based on Brzozowski's derivative of regular expressions. If we consider context-free grammars as recursive regular expressions, Brzozowski's equational theory extends without modification to context-free grammars (and it generalizes to parser combinators). The supporting actors in this story are three concepts familiar to functional programmers - laziness, memoization and fixed points; these allow Brzozowski's original equations to be transliterated into purely functional code in about 30 lines spread over three functions.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034801", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "David", + "last_name": "Darais", + "institution": "University of Utah" + }, + { + "first_name": "Daniel", + "last_name": "Spiewak", + "institution": "University of Wisconsin–Milwaukee" + } + ], + "dblp_key": "conf/icfp/MightDS11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034791", + "title": "Balanced trees inhabiting functional parallel programming", + "abstract": "Divide-and-conquer is an important technique in parallel programming. However, algebraic data structures do not fit divide-and-conquer parallelism. For example, the usual pointer-based implementation of lists cannot efficiently be divided at their middle, which prevents us from developing list-iterating divide-and-conquer parallel programs. Tree-iterating programs possibly face a similar problem, because trees might be ill-balanced and list-like shapes. This paper examines parallel programming based on balanced trees: we consider balanced-tree structures and develop recursive functions on them. By virtue of their balancing nature, either bottom-up or top-down recursive functions exploit divide-and-conquer parallelism. Our main contribution is to demonstrate the promise of this approach. We propose a way of systematically developing balanced trees from parallel algorithms, and then, we show that efficient parallel programs on them can be developed by equational reasoning powered by Reynolds' relational parametricity. We consider functions that operate either lists or binary trees, and show that our methods can uniformly deal with both cases. The developed parallel programs are purely functional, correct by construction, and sometimes even simpler than known algorithms.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034791", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Akimasa", + "last_name": "Morihata", + "institution": "Tohoku University Hospital" + }, + { + "first_name": "Kiminori", + "last_name": "Matsuzaki", + "institution": "Kochi University of Technology" + } + ], + "dblp_key": "conf/icfp/MorihataM11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034779", + "title": "Functional programming through deep time: modeling the first complex ecosystems on earth", + "abstract": "The ecology of Earth's first large organisms is an unsolved problem in palaeontology. This experience report discusses the determination of which ecosystems could have been feasible, by considering the biological feedbacks within them. Haskell was used to model the ecosystems for these first large organisms - the Ediacara biota. For verification of the results, the statistical language R was used. Neither Haskell nor R would have been sufficient for this work - Haskell's libraries for statistics are weak, while R lacks the structure for expressing algorithms in a maintainable manner. This work is the first to quantify all feedback loops in an ecosystem, and has generated considerable interest from both the ecological and palaeontological communities.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034779", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Emily G.", + "last_name": "Mitchell", + "institution": "British Antarctic Survey" + } + ], + "dblp_key": "conf/icfp/Mitchell11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034824", + "title": "Generalising and dualising the third list-homomorphism theorem: functional pearl", + "abstract": "The third list-homomorphism theorem says that a function is a list homomorphism if it can be described as an instance of both a foldr and a foldl. We prove a dual theorem for unfolds and generalise both theorems to trees: if a function generating a list can be described both as an unfoldr and an unfoldl, the list can be generated from the middle, and a function that processes or builds a tree both upwards and downwards may independently process/build a subtree and its one-hole context. The point-free, relational formalism helps to reveal the beautiful symmetry hidden in the theorem.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034824", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Shin-Cheng", + "last_name": "Mu", + "institution": "Academia Sinica" + }, + { + "first_name": "Akimasa", + "last_name": "Morihata", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/icfp/MuM11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034808", + "title": "Typed self-interpretation by pattern matching", + "abstract": "Self-interpreters can be roughly divided into two sorts: self-recognisers that recover the input program from a canonical representation, and self-enactors that execute the input program. Major progress for statically-typed languages was achieved in 2009 by Rendel, Ostermann, and Hofer who presented the first typed self-recogniser that allows representations of different terms to have different types. A key feature of their type system is a type:type rule that renders the kind system of their language inconsistent.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034808", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Barry", + "last_name": "Jay", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/icfp/JayP11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034797", + "title": "Functional modelling of musical harmony: an experience report", + "abstract": "Music theory has been essential in composing and performing music for centuries. Within Western tonal music, from the early Baroque on to modern-day jazz and pop music, the function of chords within a chord sequence can be explained by harmony theory. Although Western tonal harmony theory is a thoroughly studied area, formalising this theory is a hard problem.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034797", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "José Pedro", + "last_name": "Magalhães", + "institution": "Utrecht University" + }, + { + "first_name": "Wolfgang", + "last_name": "Haas", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/MagalhaesH11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034819", + "title": "Recursion principles for syntax with bindings and substitution", + "abstract": "We characterize the data type of terms with bindings, freshness and substitution, as an initial model in a suitable Horn theory. This characterization yields a convenient recursive definition principle, which we have formalized in Isabelle/HOL and employed in a series of case studies taken from the λ-calculus literature.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034819", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "Romanian Academy" + }, + { + "first_name": "Elsa L.", + "last_name": "Gunter", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/icfp/PopescuG11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034786", + "title": "Subtyping delimited continuations", + "abstract": "We present a type system with subtyping for first-class delimited continuations that generalizes Danvy and Filinski's type system for shift and reset by maintaining explicit information about the types of contexts in the metacontext. We exploit this generalization by considering the control operators known as shift0 and reset0 that can access arbitrary contexts in the metacontext. We use subtyping to control the level of information about the metacontext the expression actually requires and in particular to coerce pure expressions into effectful ones. For this type system we prove strong type soundness and termination of evaluation and we present a provably correct type reconstruction algorithm. We also introduce two CPS translations for shift0 and reset0: one targeting the untyped lambda calculus, and another - type-directed - targeting the simply-typed lambda calculus. The latter translation preserves typability and is selective in that it keeps pure expressions in direct style.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034786", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marek", + "last_name": "Materzok", + "institution": "University of Wrocław" + }, + { + "first_name": "Dariusz", + "last_name": "Biernacki", + "institution": "University of Wrocław" + } + ], + "dblp_key": "conf/icfp/MaterzokB11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034821", + "title": "Proving the unique fixed-point principle correct: an adventure with category theory", + "abstract": "Say you want to prove something about an infinite data-structure, such as a stream or an infinite tree, but you would rather not subject yourself to coinduction. The unique fixed-point principle is an easy-to-use, calculational alternative. The proof technique rests on the fact that certain recursion equations have unique solutions; if two elements of a coinductive type satisfy the same equation of this kind, then they are equal. In this paper we precisely characterize the conditions that guarantee a unique solution. Significantly, we do so not with a syntactic criterion, but with a semantic one that stems from the categorical notion of naturality. Our development is based on distributive laws and bialgebras, and draws heavily on Turi and Plotkin's pioneering work on mathematical operational semantics. Along the way, we break down the design space in two dimensions, leading to a total of nine points. Each gives rise to varying degrees of expressiveness, and we will discuss three in depth. Furthermore, our development is generic in the syntax of equations and in the behaviour they encode - we are not caged in the world of streams.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034821", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Oxford" + }, + { + "first_name": "Daniel W.H.", + "last_name": "James", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/HinzeJ11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034781", + "title": "Monads, zippers and views: virtualizing the monad stack", + "abstract": "We make monadic components more reusable and robust to changes by employing two new techniques for virtualizing the monad stack: the monad zipper and monad views. The monad zipper is a higher-order monad transformer that creates virtual monad stacks by ignoring particular layers in a concrete stack. Monad views provide a general framework for monad stack virtualization: they take the monad zipper one step further and integrate it with a wide range of other virtualizations. For instance, particular views allow restricted access to monads in the stack. Furthermore, monad views provide components with a call-by-reference-like mechanism for accessing particular layers of the monad stack.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034781", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "Ghent University" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/icfp/SchrijversO11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034817", + "title": "Nameless, painless", + "abstract": "De Bruijn indices are a well known technique for programming with names and binders. They provide a representation that is both simple and canonical.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034817", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Pouillard", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Pouillard11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034783", + "title": "Modular rollback through control logging: a pair of twin functional pearls", + "abstract": "We present a technique, based on the use of first-class control operators, enabling programs to maintain and invoke rollback logs for sequences of reversible effects. Our technique is modular, in that it provides complete separation between some library of effectful operations, and a client, \"driver\" program which invokes and rolls back sequences of these operations. In particular, the checkpoint mechanism, which is entirely encapsulated within the effect library, logs not only the library's effects, but also the client's control state. Thus, logging and rollback can be almost completely transparent to the client code.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034783", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Northeastern University" + }, + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/ShiversT11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034815", + "title": "Making standard ML a practical database programming language", + "abstract": "Integrating a database query language into a programming language is becoming increasingly important in recently emerging high-level cloud computing and other applications, where efficient and sophisticated data manipulation is required during computation. This paper reports on seamless integration of SQL into SML# - an extension of Standard ML. In the integrated language, the type system always infers a principal type for any type consistent SQL expression. This makes SQL queries first-class citizens, which can be freely combined with any other language constructs definable in Standard ML. For a program involving SQL queries, the compiler separates SQL queries and delegates their evaluation to a database server, e.g. PostgreSQL or MySQL in the currently implemented version.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034815", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Tohoku University" + }, + { + "first_name": "Katsuhiro", + "last_name": "Ueno", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/icfp/OhoriU11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034802", + "title": "An efficient non-moving garbage collector for functional languages", + "abstract": "Motivated by developing a memory management system that allows functional languages to seamlessly inter-operate with C, we propose an efficient non-moving garbage collection algorithm based on bitmap marking and report its implementation and performance evaluation.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034802", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Katsuhiro", + "last_name": "Ueno", + "institution": "Tohoku University" + }, + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Tohoku University" + }, + { + "first_name": "Toshiaki", + "last_name": "Otomo", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/icfp/UenoOO11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034785", + "title": "Pushdown flow analysis of first-class control", + "abstract": "Pushdown models are better than control-flow graphs for higher-order flow analysis. They faithfully model the call/return structure of a program, which results in fewer spurious flows and increased precision. However, pushdown models require that calls and returns in the analyzed program nest properly. As a result, they cannot be used to analyze language constructs that break call/return nesting such as generators, coroutines, call/cc, etc.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034785", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dimitris", + "last_name": "Vardoulakis", + "institution": "Northeastern University" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/VardoulakisS11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034831", + "title": "A kripke logical relation for effect-based program transformations", + "abstract": "We present a Kripke logical relation for showing the correctness of program transformations based on a type-and-effect system for an ML-like programming language with higher-order store and dynamic allocation.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034831", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Thamsborg", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/ThamsborgB11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034794", + "title": "Programming assurance cases in Agda", + "abstract": "Agda is a modern functional programming language equipped with an interactive proof assistant as its developing environment. Its features include dependent types, type universe, inductive and coinductive families of types, pattern matching, records, and nested parameterized modules. Based on the \"propositions as types, proofs as programs\" correspondence in Martin-Löf's Type Theory, Agda lets users to construct, verify, and execute a smooth mixture of programs and proofs.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034794", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Makoto", + "last_name": "Takeyama", + "institution": "National Institute of Advanced Industrial Science and Technology" + } + ], + "dblp_key": "conf/icfp/Takeyama11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034818", + "title": "Binders unbound", + "abstract": "Implementors of compilers, program refactorers, theorem provers, proof checkers, and other systems that manipulate syntax know that dealing with name binding is difficult to do well. Operations such as α-equivalence and capture-avoiding substitution seem simple, yet subtle bugs often go undetected. Furthermore, their implementations are tedious, requiring \"boilerplate\" code that must be updated whenever the object language definition changes.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034818", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Brent A.", + "last_name": "Yorgey", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/WeirichYS11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034811", + "title": "Secure distributed programming with value-dependent types", + "abstract": "Distributed applications are difficult to program reliably and securely. Dependently typed functional languages promise to prevent broad classes of errors and vulnerabilities, and to enable program verification to proceed side-by-side with development. However, as recursion, effects, and rich libraries are added, using types to reason about programs, specifications, and proofs becomes challenging.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034811", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Juan", + "last_name": "Chen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "Microsoft (France)" + }, + { + "first_name": "Karthikeyan", + "last_name": "Bhargavan", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jean", + "last_name": "Yang", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/icfp/SwamyCFSBY11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034778", + "title": "Lightweight monadic programming in ML", + "abstract": "Many useful programming constructions can be expressed as monads. Examples include probabilistic modeling, functional reactive programming, parsing, and information flow tracking, not to mention effectful functionality like state and I/O. In this paper, we present a type-based rewriting algorithm to make programming with arbitrary monads as easy as using ML's built-in support for state and I/O. Developers write programs using monadic values of type m τ as if they were of type τ, and our algorithm inserts the necessary binds, units, and monad-to-monad morphisms so that the program type checks. Our algorithm, based on Jones' qualified types, produces principal types. But principal types are sometimes problematic: the program's semantics could depend on the choice of instantiation when more than one instantiation is valid. In such situations we are able to simplify the types to remove any ambiguity but without adversely affecting typability; thus we can accept strictly more programs. Moreover, we have proved that this simplification is efficient (linear in the number of constraints) and coherent: while our algorithm induces a particular rewriting, all related rewritings will have the same semantics. We have implemented our approach for a core functional language and applied it successfully to simple examples from the domains listed above, which are used as illustrations throughout the paper.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034778", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nataliya", + "last_name": "Guts", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/icfp/SwamyGLH11", + "venue": "icfp", + "year": 2011 + }, + { + "paper_id": "10.1145/2034773.2034825", + "title": "Incremental updates for efficient bidirectional transformations", + "abstract": "A bidirectional transformation is a pair of mappings between source and view data objects, one in each direction. When the view is modified, the source is updated accordingly. The key to handling large data objects that are subject to relatively small modifications is to process the updates incrementally. Incrementality has been explored in the semi-structured settings of relational databases and graph transformations; this flexibility in structure makes it relatively easy to divide the data into separate parts that can be transformed and updated independently. The same is not true if the data is to be encoded with more general-purpose algebraic datatypes, with transformations defined as functions: dividing data into well-typed separate parts is tricky, and recursions typically create interdependencies. In this paper, we study transformations that support incremental updates, and devise a constructive process to achieve this incrementality.", + "date": "2011-09-19", + "link": "https://doi.org/10.1145/2034773.2034825", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "" + } + ], + "dblp_key": "conf/icfp/WangGW11", + "venue": "icfp", + "year": 2011 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2012.json b/data/pl_conferences/icfp/2012.json new file mode 100644 index 0000000..7c806fa --- /dev/null +++ b/data/pl_conferences/icfp/2012.json @@ -0,0 +1,907 @@ +[ + { + "paper_id": "10.1145/2364527.2364563", + "title": "Nested data-parallelism on the gpu", + "abstract": "Graphics processing units (GPUs) provide both memory bandwidth and arithmetic performance far greater than that available on CPUs but, because of their Single-Instruction-Multiple-Data (SIMD) architecture, they are hard to program. Most of the programs ported to GPUs thus far use traditional data-level parallelism, performing only operations that operate uniformly over vectors.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364563", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lars", + "last_name": "Bergström", + "institution": "University of Chicago" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/icfp/BergstromR12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364551", + "title": "On the complexity of equivalence of specifications of infinite objects", + "abstract": "We study the complexity of deciding the equality of infinite objects specified by systems of equations, and of infinite objects specified by λ-terms. For equational specifications there are several natural notions of equality: equality in all models, equality of the sets of solutions, and equality of normal forms for productive specifications. For λ-terms we investigate Böhm-tree equality and various notions of observational equality. We pinpoint the complexity of each of these notions in the arithmetical or analytical hierarchy.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364551", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jörg", + "last_name": "Endrullis", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Dimitri", + "last_name": "Hendriks", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Rena", + "last_name": "Bakhshi", + "institution": "Vrije Universiteit Amsterdam" + } + ], + "dblp_key": "conf/icfp/EndrullisHB12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364534", + "title": "Elaborating intersection and union types", + "abstract": "Designing and implementing typed programming languages is hard. Every new type system feature requires extending the metatheory and implementation, which are often complicated and fragile. To ease this process, we would like to provide general mechanisms that subsume many different features.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364534", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/Dunfield12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364573", + "title": "A generic abstract syntax model for embedded languages", + "abstract": "Representing a syntax tree using a data type often involves having many similar-looking constructors. Functions operating on such types often end up having many similar-looking cases. Different languages often make use of similar-looking constructions. We propose a generic model of abstract syntax trees capable of representing a wide range of typed languages. Syntactic constructs can be composed in a modular fashion enabling reuse of abstract syntax and syntactic processing within and across languages. Building on previous methods of encoding extensible data types in Haskell, our model is a pragmatic solution to Wadler's \"expression problem\". Its practicality has been confirmed by its use in the implementation of the embedded language Feldspar.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364573", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Emil", + "last_name": "Axelsson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/Axelsson12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364532", + "title": "Formal verification of monad transformers", + "abstract": "We present techniques for reasoning about constructor classes that (like the monad class) fix polymorphic operations and assert polymorphic axioms. We do not require a logic with first-class type constructors, first-class polymorphism, or type quantification; instead, we rely on a domain-theoretic model of the type system in a universal domain to provide these features. These ideas are implemented in the Tycon library for the Isabelle theorem prover, which builds on the HOLCF library of domain theory. The Tycon library provides various axiomatic type constructor classes, including functors and monads. It also provides automation for instantiating those classes, and for defining further subclasses.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364532", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Brian", + "last_name": "Huffman", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/icfp/Huffman12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364560", + "title": "Experience report: Haskell in computational biology", + "abstract": "Haskell gives computational biologists the flexibility and rapid prototyping of a scripting language, plus the performance of native code. In our experience, higher-order functions, lazy evaluation, and monads really worked, but profiling and debugging presented obstacles. Also, Haskell libraries vary greatly: memoization combinators and parallel-evaluation strategies helped us a lot, but other, nameless libraries mostly got in our way. Despite the obstacles and the uncertain quality of some libraries, Haskell's ecosystem made it easy for us to develop new algorithms in computational biology.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364560", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Noah M.", + "last_name": "Daniels", + "institution": "Tufts University" + }, + { + "first_name": "Andrew", + "last_name": "Gallant", + "institution": "Tufts University" + }, + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/icfp/DanielsGR12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364535", + "title": "An error-tolerant type system for variational lambda calculus", + "abstract": "Conditional compilation and software product line technologies make it possible to generate a huge number of different programs from a single software project. Typing each of these programs individually is usually impossible due to the sheer number of possible variants. Our previous work has addressed this problem with a type system for variational lambda calculus (VLC), an extension of lambda calculus with basic constructs for introducing and organizing variation. Although our type inference algorithm is more efficient than the brute-force strategy of inferring the types of each variant individually, it is less robust since type inference will fail for the entire variational expression if any one variant contains a type error. In this work, we extend our type system to operate on VLC expressions containing type errors. This extension directly supports locating ill-typed variants and the incremental development of variational programs. It also has many subtle implications for the unification of variational types. We show that our extended type system possesses a principal typing property and that the underlying unification problem is unitary. Our unification algorithm computes partial unifiers that lead to result types that (1) contain errors in as few variants as possible and (2) are most general. Finally, we perform an empirical evaluation to determine the overhead of this extension compared to our previous work, to demonstrate the improvements over the brute-force approach, and to explore the effects of various error distributions on the inference process.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364535", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "Oregon State University" + }, + { + "first_name": "Martin", + "last_name": "Erwig", + "institution": "Oregon State University" + }, + { + "first_name": "Eric", + "last_name": "Walkingshaw", + "institution": "Oregon State University" + } + ], + "dblp_key": "conf/icfp/ChenEW12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364576", + "title": "Introspective pushdown analysis of higher-order programs", + "abstract": "In the static analysis of functional programs, pushdown flow analysis and abstract garbage collection skirt just inside the boundaries of soundness and decidability. Alone, each method reduces analysis times and boosts precision by orders of magnitude. This work illuminates and conquers the theoretical challenges that stand in the way of combining the power of these techniques. The challenge in marrying these techniques is not subtle: computing the reachable control states of a pushdown system relies on limiting access during transition to the top of the stack; abstract garbage collection, on the other hand, needs full access to the entire stack to compute a root set, just as concrete collection does. Introspective pushdown systems resolve this conflict. Introspective pushdown systems provide enough access to the stack to allow abstract garbage collection, but they remain restricted enough to compute control-state reachability, thereby enabling the sound and precise product of pushdown analysis and abstract garbage collection. Experiments reveal synergistic interplay between the techniques, and the fusion demonstrates \"better-than-both-worlds\" precision.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364576", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Earl", + "institution": "University of Utah" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "KU Leuven" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/EarlSMH12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364539", + "title": "Practical typed lazy contracts", + "abstract": "Until now there has been no support for specifying and enforcing contracts within a lazy functional program. That is a shame, because contracts consist of pre- and post-conditions for functions that go beyond the standard static types. This paper presents the design and implementation of a small, easy-to-use, purely functional contract library for Haskell, which, when a contract is violated, also provides more useful information than the classical blaming of one contract partner. From now on lazy functional languages can profit from the assurances in the development of correct programs that contracts provide.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364539", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olaf", + "last_name": "Chitil", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/icfp/Chitil12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364544", + "title": "Transporting functions across ornaments", + "abstract": "Programming with dependent types is a blessing and a curse. It is a blessing to be able to bake invariants into the definition of datatypes: we can finally write correct-by-construction software. However, this extreme accuracy is also a curse: a datatype is the combination of a structuring medium together with a special purpose logic. These domain-specific logics hamper any effort of code reuse among similarly structured data. In this paper, we exorcise our datatypes by adapting the notion of ornament to our universe of inductive families. We then show how code reuse can be achieved by ornamenting functions. Using these functional ornaments, we capture the relationship between functions such as the addition of natural numbers and the concatenation of lists. With this knowledge, we demonstrate how the implementation of the former informs the implementation of the latter: the user can ask the definition of addition to be lifted to lists and she will only be asked the details necessary to carry on adding lists rather than numbers. Our presentation is formalised in a type theory with a universe of datatypes and all our constructions have been implemented as generic programs, requiring no extension to the type theory.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364544", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pierre-Évariste", + "last_name": "Dagand", + "institution": "University of Strathclyde" + }, + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" + } + ], + "dblp_key": "conf/icfp/DagandM12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364562", + "title": "A meta-scheduler for the par-monad: composable scheduling for the heterogeneous cloud", + "abstract": "Modern parallel computing hardware demands increasingly specialized attention to the details of scheduling and load balancing across heterogeneous execution resources that may include GPU and cloud environments, in addition to traditional CPUs. Many existing solutions address the challenges of particular resources, but do so in isolation, and in general do not compose within larger systems. We propose a general, composable abstraction for execution resources, along with a continuation-based meta-scheduler that harnesses those resources in the context of a deterministic parallel programming library for Haskell. We demonstrate performance benefits of combined CPU/GPU scheduling over either alone, and of combined multithreaded/distributed scheduling over existing distributed programming approaches for Haskell.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364562", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Adam", + "last_name": "Foltzer", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Abhishek", + "last_name": "Kulkarni", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Rebecca", + "last_name": "Swords", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Sajith", + "last_name": "Sasidharan", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Eric", + "last_name": "Jiang", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/icfp/FoltzerKSSJN12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364536", + "title": "Superficially substructural types", + "abstract": "Many substructural type systems have been proposed for controlling access to shared state in higher-order languages. Central to these systems is the notion of a *resource*, which may be split into disjoint pieces that different parts of a program can manipulate independently without worrying about interfering with one another. Some systems support a *logical* notion of resource (such as permissions), under which two resources may be considered disjoint even if they govern the *same* piece of state. However, in nearly all existing systems, the notions of resource and disjointness are fixed at the outset, baked into the model of the language, and fairly coarse-grained in the kinds of sharing they enable.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364536", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Northeastern University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/KrishnaswamiTDG12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364546", + "title": "Operational semantics using the partiality monad", + "abstract": "The operational semantics of a partial, functional language is often given as a relation rather than as a function. The latter approach is arguably more natural: if the language is functional, why not take advantage of this when defining the semantics? One can immediately see that a functional semantics is deterministic and, in a constructive setting, computable.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364546", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nils Anders", + "last_name": "Danielsson", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "conf/icfp/Danielsson12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364556", + "title": "Efficient lookup-table protocol in secure multiparty computation", + "abstract": "Secure multiparty computation (SMC) permits a collection of parties to compute a collaborative result, without any of the parties gaining any knowledge about the inputs provided by other parties. Specifications for SMC are commonly presented as boolean circuits, where optimizations come mostly from reducing the number of multiply-operations (including and-gates) - these are the operations which incur significant cost, either in computation overhead or in communication between the parties. Instead, we take a language-oriented approach, and consequently are able to explore many other kinds of optimizations. We present an efficient and general purpose SMC table-lookup algorithm that can serve as a direct alternative to circuits. Looking up a private (i.e. shared, or encrypted) n-bit argument in a public table requires log(n) parallel-and operations. We use the advanced encryption standard algorithm (AES) as a driving motivation, and by introducing different kinds of parallelization techniques, produce the fastest current SMC implementation of AES, improving the best previously reported results by well over an order of magnitude.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364556", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Galois (United States)" + }, + { + "first_name": "Iavor S.", + "last_name": "Diatchki", + "institution": "Galois (United States)" + }, + { + "first_name": "Thomas", + "last_name": "Dubuisson", + "institution": "Galois (United States)" + }, + { + "first_name": "Andy", + "last_name": "Adams-Moran", + "institution": "Galois (United States)" + } + ], + "dblp_key": "conf/icfp/LaunchburyDDA12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364571", + "title": "Deconstraining DSLs", + "abstract": "Strongly-typed functional languages provide a powerful framework for embedding Domain-Specific Languages (DSLs). However, building type-safe functions defined over an embedded DSL can introduce application-specific type constraints that end up being imposed on the DSL data types themselves. At best, these constraints are unwieldy and at worst they can limit the range of DSL expressions that can be built. We present a simple solution to this problem that allows application-specific constraints to be specified at the point of use of a DSL expression rather than when the DSL's embedding types are defined. Our solution applies equally to both tagged and tagless representations and, importantly, also works in the presence of higher-rank types.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364571", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Will", + "last_name": "Jones", + "institution": "Imperial College London" + }, + { + "first_name": "Tony", + "last_name": "Field", + "institution": "Imperial College London" + }, + { + "first_name": "Tristan O.R.", + "last_name": "Allwood", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/icfp/JonesFA12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364569", + "title": "Typing unmarshalling without marshalling types", + "abstract": "Unmarshalling primitives in statically typed language require, in order to preserve type safety, to dynamically verify the compatibility between the incoming values and the statically expected type. In the context of programming languages based on parametric polymorphism and uniform data representation, we propose a relation of compatibility between (unmarshalled) memory graphs and types. It is defined as constraints over nodes of the memory graph. Then, we propose an algorithm to check the compatibility between a memory graph and a type. It is described as a constraint solver based on a rewriting system. We have shown that the proposed algorithm is sound and semi-complete in presence of algebraic data types, mutable data, polymorphic sharing, cycles, and functional values, however, in its general form, it may not terminate. We have implemented a prototype tailored for the OCaml compiler [17] that always terminates and still seems sufficiently complete in practice.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364569", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Grégoire", + "last_name": "Henry", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Michel", + "last_name": "Mauny", + "institution": "École Nationale Supérieure de Techniques Avancées" + }, + { + "first_name": "Emmanuel", + "last_name": "Chailloux", + "institution": "Sorbonne Université" + }, + { + "first_name": "Pascal", + "last_name": "Manoury", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "conf/icfp/HenryMCM12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364572", + "title": "Explicitly heterogeneous metaprogramming with MetaHaskell", + "abstract": "Languages with support for metaprogramming, like MetaOCaml, offer a principled approach to code generation by guaranteeing that well-typed metaprograms produce well-typed programs. However, many problem domains where metaprogramming can fruitfully be applied require generating code in languages like C, CUDA, or assembly. Rather than resorting to add-hoc code generation techniques, these applications should be directly supported by explicitly heterogeneous metaprogramming languages.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364572", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Geoffrey", + "last_name": "Mainland", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/Mainland12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364529", + "title": "Agda-curious?: an exploration of programming with dependent types", + "abstract": "I explore programming with the dependently typed functional language, AGDA. I present the progress which AGDA has made, demonstrate its usage in a small development, reflect critically on the state of the art, and speculate about the way ahead. I do not seek to persuade you to adopt AGDA as your primary tool for systems development, but argue that AGDA stimulates new useful ways to think about programming problems and deserves not just curiosity but interest, support and contribution.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364529", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" + } + ], + "dblp_key": "conf/icfp/McBride12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364545", + "title": "Proof-producing synthesis of ML from higher-order logic", + "abstract": "The higher-order logic found in proof assistants such as Coq and various HOL systems provides a convenient setting for the development and verification of pure functional programs. However, to efficiently run these programs, they must be converted (or \"extracted\") to functional programs in a programming language such as ML or Haskell. With current techniques, this step, which must be trusted, relates similar looking objects that have very different semantic definitions, such as the set-theoretic model of a logic and the operational semantics of a programming language.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364545", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "University of Cambridge" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/MyreenO12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364564", + "title": "Work efficient higher-order vectorisation", + "abstract": "Existing approaches to higher-order vectorisation, also known as flattening nested data parallelism, do not preserve the asymptotic work complexity of the source program. Straightforward examples, such as sparse matrix-vector multiplication, can suffer a severe blow-up in both time and space, which limits the practicality of this method. We discuss why this problem arises, identify the mis-handling of index space transforms as the root cause, and present a solution using a refined representation of nested arrays. We have implemented this solution in Data Parallel Haskell (DPH) and present benchmarks showing that realistic programs, which used to suffer the blow-up, now have the correct asymptotic work complexity. In some cases, the asymptotic complexity of the vectorised program is even better than the original.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364564", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ben", + "last_name": "Lippmeier", + "institution": "UNSW Sydney" + }, + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "UNSW Sydney" + }, + { + "first_name": "Roman", + "last_name": "Leshchinskiy", + "institution": "UNSW Sydney" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/LippmeierCKLJ12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364538", + "title": "Shake before building: replacing make with haskell", + "abstract": "Most complex software projects are compiled using a build tool (e.g. make), which runs commands in an order satisfying user-defined dependencies. Unfortunately, most build tools require all dependencies to be specified before the build starts. This restriction makes many dependency patterns difficult to express, especially those involving files generated at build time. We show how to eliminate this restriction, allowing additional dependencies to be specified while building. We have implemented our ideas in the Haskell library Shake, and have used Shake to write a complex build system which compiles millions of lines of code.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364538", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neil", + "last_name": "Mitchell", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Mitchell12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364553", + "title": "Experience report: a do-it-yourself high-assurance compiler", + "abstract": "Embedded domain-specific languages (EDSLs) are an approach for quickly building new languages while maintaining the advantages of a rich metalanguage. We argue in this experience report that the \"EDSL approach\" can surprisingly ease the task of building a high-assurance compiler. We do not strive to build a fully formally-verified tool-chain, but take a \"do-it-yourself\" approach to increase our confidence in compiler-correctness without too much effort. Copilot is an EDSL developed by Galois, Inc. and the National Institute of Aerospace under contract to NASA for the purpose of runtime monitoring of flight-critical avionics. We report our experience in using type-checking, QuickCheck, and model-checking \"off-the-shelf\" to quickly increase confidence in our EDSL tool-chain.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364553", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lee", + "last_name": "Pike", + "institution": "Galois (United States)" + }, + { + "first_name": "Nis", + "last_name": "Wegmann", + "institution": "University of Copenhagen" + }, + { + "first_name": "Sebastian", + "last_name": "Niller", + "institution": "" + }, + { + "first_name": "Alwyn E.", + "last_name": "Goodloe", + "institution": "Langley Research Center" + } + ], + "dblp_key": "conf/icfp/PikeWNG12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364566", + "title": "Tales from the jungle", + "abstract": "We rely on a computational infrastructure that is a densely interwined mass of software and hardware: programming languages, network protocols, operating systems, and processors. It has accumulated great complexity, from a combination of engineering design decisions, contingent historical choices, and sheer scale, yet it is defined at best by prose specifications, or, all too often, just by the common implementations. Can we do better? More specifically, can we apply rigorous methods to this mainstream infrastructure, taking the accumulated complexity seriously, and if we do, does it help? My colleagues and I have looked at these questions in several contexts: the TCP/IP network protocols with their Sockets API; programming language design, including the Java module system and the C11/C++11 concurrency model; the hardware concurrency behaviour of x86, IBM POWER, and ARM multiprocessors; and compilation of concurrent code.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364566", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/Sewell12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364542", + "title": "Painless programming combining reduction and search: design principles for embedding decision procedures in high-level languages", + "abstract": "We describe the Funlogic system which extends a functional language with existentially quantified declarations. An existential declaration introduces a variable and a set of constraints that its value should meet. Existential variables are bound to conforming values by a decision procedure. Funlogic embeds multiple external decision procedures using a common framework. Design principles for embedding decision procedures are developed and illustrated for three different decision procedures from widely varying domains.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364542", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Timothy E.", + "last_name": "Sheard", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/icfp/Sheard12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364548", + "title": "High performance embedded domain specific languages", + "abstract": "Today, all high-performance computer architectures are parallel and heterogeneous; a combination of multiple CPUs, GPUs and specialized processors. This creates a complex programming problem for application developers. Domain-specific languages (DSLs) are a promising solution to this problem because they provide an avenue for application-specific abstractions to be mapped directly to low level architecture-specific programming models providing high programmer productivity and high execution performance.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364548", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/icfp/Olukotun12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364578", + "title": "A traversal-based algorithm for higher-order model checking", + "abstract": "Higher-order model checking - the model checking of trees generated by higher-order recursion schemes (HORS) - is a natural generalisation of finite-state and pushdown model checking. Recent work has shown that it can serve as a basis for software model checking for functional languages such as ML and Haskell. In this paper, we introduce higher-order recursion schemes with cases (HORSC), which extend HORS with a definition-by-cases construct (to express program branching based on data) and non-determinism (to express abstractions of behaviours). This paper is a study of the universal HORSC model checking problem for deterministic trivial automata: does the automaton accept every tree in the tree language generated by the given HORSC? We first characterise the model checking problem by an intersection type system extended with a carefully restricted form of union types. We then present an algorithm for deciding the model checking problem, which is based on the notion of traversals induced by the fully abstract game semantics of these schemes, but presented as a goal-directed construction of derivations in the intersection and union type system. We view HORSC model checking as a suitable backend engine for an approach to verifying functional programs. We have implemented the algorithm in a tool called TravMC, and demonstrated its effectiveness on a test suite of programs, including abstract models of functional programs obtained via an abstraction-refinement procedure from pattern-matching recursion schemes.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364578", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robin P.", + "last_name": "Neatherway", + "institution": "University of Oxford" + }, + { + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Oxford" + }, + { + "first_name": "Chih-Hao Luke", + "last_name": "Ong", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/NeatherwayRO12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364579", + "title": "Functional programs that explain their work", + "abstract": "We present techniques that enable higher-order functional computations to \"explain\" their work by answering questions about how parts of their output were calculated. As explanations, we consider the traditional notion of program slices, which we show can be inadequate, and propose a new notion: trace slices. We present techniques for specifying flexible and rich slicing criteria based on partial expressions, parts of which have been replaced by holes.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364579", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Roly", + "last_name": "Perera", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "University of Edinburgh" + }, + { + "first_name": "Paul Blain", + "last_name": "Levy", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/icfp/PereraACL12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364541", + "title": "Functional programming with structured graphs", + "abstract": "This paper presents a new functional programming model for graph structures called structured graphs. Structured graphs extend conventional algebraic datatypes with explicit definition and manipulation of cycles and/or sharing, and offer a practical and convenient way to program graphs in functional programming languages like Haskell. The representation of sharing and cycles (edges) employs recursive binders and uses an encoding inspired by parametric higher-order abstract syntax. Unlike traditional approaches based on mutable references or node/edge lists, well-formedness of the graph structure is ensured statically and reasoning can be done with standard functional programming techniques. Since the binding structure is generic, we can define many useful generic combinators for manipulating structured graphs. We give applications and show how to reason about structured graphs.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364541", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "National University of Singapore" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/icfp/OliveiraC12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364559", + "title": "Sneaking around concatMap: efficient combinators for dynamic programming", + "abstract": "We present a framework of dynamic programming combinators that provides a high-level environment to describe the recursions typical of dynamic programming over sequence data in a style very similar to algebraic dynamic programming (ADP). Using a combination of type-level programming and stream fusion leads to a substantial increase in performance, without sacrificing much of the convenience and theoretical underpinnings of ADP.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364559", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christian Höner zu", + "last_name": "Siederdissen", + "institution": "University of Vienna" + } + ], + "dblp_key": "conf/icfp/Siederdissen12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364531", + "title": "Verified heap theorem prover by paramodulation", + "abstract": "We present VeriStar, a verified theorem prover for a decidable subset of separation logic. Together with VeriSmall [3], a proved-sound Smallfoot-style program analysis for C minor, VeriStar demonstrates that fully machine-checked static analyses equipped with efficient theorem provers are now within the reach of formal methods. As a pair, VeriStar and VeriSmall represent the first application of the Verified Software Toolchain [4], a tightly integrated collection of machine-verified program logics and compilers giving foundational correctness guarantees.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364531", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gordon", + "last_name": "Stewart", + "institution": "Princeton University" + }, + { + "first_name": "Lennart", + "last_name": "Beringer", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/icfp/StewartBA12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364550", + "title": "Pure type systems with corecursion on streams: from finite to infinitary normalisation", + "abstract": "In this paper, we use types for ensuring that programs involving streams are well-behaved. We extend pure type systems with a type constructor for streams, a modal operator next and a fixed point operator for expressing corecursion. This extension is called Pure Type Systems with Corecursion (CoPTS). The typed lambda calculus for reactive programs defined by Krishnaswami and Benton can be obtained as a CoPTS. CoPTSs allow us to study a wide range of typed lambda calculi extended with corecursion using only one framework. In particular, we study this extension for the calculus of constructions which is the underlying formal language of Coq. We use the machinery of infinitary rewriting and formalise the idea of well-behaved programs using the concept of infinitary normalisation. The set of finite and infinite terms is defined as a metric completion. We establish a precise connection between the modal operator (• A) and the metric at a syntactic level by relating a variable of type (• A) with the depth of all its occurrences in a term. This syntactic connection between the modal operator and the depth is the key to the proofs of infinitary weak and strong normalisation.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364550", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paula", + "last_name": "Severi", + "institution": "University of Leicester" + }, + { + "first_name": "F. J. de", + "last_name": "Vries", + "institution": "University of Leicester" + } + ], + "dblp_key": "conf/icfp/SeveriV12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364557", + "title": "Addressing covert termination and timing channels in concurrent information flow systems", + "abstract": "When termination of a program is observable by an adversary, confidential information may be leaked by terminating accordingly. While this termination covert channel has limited bandwidth for sequential programs, it is a more dangerous source of information leakage in concurrent settings. We address concurrent termination and timing channels by presenting a dynamic information-flow control system that mitigates and eliminates these channels while allowing termination and timing to depend on secret values. Intuitively, we leverage concurrency by placing such potentially sensitive actions in separate threads. While termination and timing of these threads may expose secret values, our system requires any thread observing these properties to raise its information-flow label accordingly, preventing leaks to lower-labeled contexts. We implement this approach in a Haskell library and demonstrate its applicability by building a web server that uses information-flow control to restrict untrusted web applications.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364557", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "Stanford University" + }, + { + "first_name": "Alejandro", + "last_name": "Russo", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Pablo", + "last_name": "Buiras", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Amit", + "last_name": "Levy", + "institution": "Stanford University" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Mazières", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/icfp/StefanRBLMM12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364575", + "title": "Automatic amortised analysis of dynamic memory allocation for lazy functional programs", + "abstract": "This paper describes the first successful attempt, of which we are aware, to define an automatic, type-based static analysis of resource bounds for lazy functional programs. Our analysis uses the automatic amortisation approach developed by Hofmann and Jost, which was previously restricted to eager evaluation. In this paper, we extend this work to a lazy setting by capturing the costs of unevaluated expressions in type annotations and by amortising the payment of these costs using a notion of lazy potential. We present our analysis as a proof system for predicting heap allocations of a minimal functional language (including higher-order functions and recursive data types) and define a formal cost model based on Launchbury's natural semantics for lazy evaluation. We prove the soundness of our analysis with respect to the cost model. Our approach is illustrated by a number of representative and non-trivial examples that have been analysed using a prototype implementation of our analysis.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364575", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Hugo", + "last_name": "Simões", + "institution": "Universidade do Porto" + }, + { + "first_name": "Pedro", + "last_name": "Vasconcelos", + "institution": "Universidade do Porto" + }, + { + "first_name": "Mário", + "last_name": "Florido", + "institution": "Universidade do Porto" + }, + { + "first_name": "Steffen", + "last_name": "Jost", + "institution": "" + }, + { + "first_name": "Kevin", + "last_name": "Hammond", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/icfp/SimoesVFJH12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364554", + "title": "Equality proofs and deferred type errors: a compiler pearl", + "abstract": "The Glasgow Haskell Compiler is an optimizing compiler that expresses and manipulates first-class equality proofs in its intermediate language. We describe a simple, elegant technique that exploits these equality proofs to support deferred type errors. The technique requires us to treat equality proofs as possibly-divergent terms; we show how to do so without losing either soundness or the zero-overhead cost model that the programmer expects.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364554", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + }, + { + "first_name": "José Pedro", + "last_name": "Magalhães", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/VytiniotisJM12", + "venue": "icfp", + "year": 2012 + }, + { + "paper_id": "10.1145/2364527.2364568", + "title": "Propositions as sessions", + "abstract": "Continuing a line of work by Abramsky (1994), by Bellin and Scott (1994), and by Caires and Pfenning (2010), among others, this paper presents CP, a calculus in which propositions of classical linear logic correspond to session types. Continuing a line of work by Honda (1993), by Honda, Kubo, and Vasconcelos (1998), and by Gay and Vasconcelos (2010), among others, this paper presents GV, a linear functional language with session types, and presents a translation from GV into CP. The translation formalises for the first time a connection between a standard presentation of session types and linear logic, and shows how a modification to the standard presentation yield a language free from deadlock, where deadlock freedom follows from the correspondence to linear logic.", + "date": "2012-09-09", + "link": "https://doi.org/10.1145/2364527.2364568", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/Wadler12", + "venue": "icfp", + "year": 2012 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2013.json b/data/pl_conferences/icfp/2013.json new file mode 100644 index 0000000..7d5930d --- /dev/null +++ b/data/pl_conferences/icfp/2013.json @@ -0,0 +1,1068 @@ +[ + { + "paper_id": "10.1145/2500365.2500614", + "title": "Using circular programs for higher-order syntax: functional pearl", + "abstract": "This pearl presents a novel technique for constructing a first-order syntax tree directly from a higher-order interface. We exploit circular programming to generate names for new variables, resulting in a simple yet efficient method. Our motivating application is the design of embedded languages supporting variable binding, where it is convenient to use higher-order syntax when constructing programs, but first-order syntax when processing or transforming programs.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500614", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Emil", + "last_name": "Axelsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/AxelssonC13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500603", + "title": "Calculating threesomes, with blame", + "abstract": "Coercions and threesomes both enable a language to combine static and dynamic types while avoiding cast-based space leaks. Coercion calculi elegantly specify space-efficient cast behavior, even when augmented with blame tracking, but implementing their semantics directly is difficult. Threesomes, on the other hand, have a straightforward recursive implementation, but endowing them with blame tracking is challenging. In this paper, we show that you can use that elegant spec to produce that straightforward implementation: we use the coercion calculus to derive threesomes with blame. In particular, we construct novel threesome calculi for blame tracking strategies that detect errors earlier, catch more errors, and reflect an intuitive conception of safe and unsafe casts based on traditional subtyping.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500603", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/icfp/Garcia13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500613", + "title": "Fun with semirings: a functional pearl on the abuse of linear algebra", + "abstract": "Describing a problem using classical linear algebra is a very well-known problem-solving technique. If your question can be formulated as a question about real or complex matrices, then the answer can often be found by standard techniques.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500613", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephen K.", + "last_name": "Dolan", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/Dolan13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500597", + "title": "Productive coprogramming with guarded recursion", + "abstract": "Total functional programming offers the beguiling vision that, just by virtue of the compiler accepting a program, we are guaranteed that it will always terminate. In the case of programs that are not intended to terminate, e.g., servers, we are guaranteed that programs will always be productive. Productivity means that, even if a program generates an infinite amount of data, each piece will be generated in finite time. The theoretical underpinning for productive programming with infinite output is provided by the category theoretic notion of final coalgebras. Hence, we speak of coprogramming with non-well-founded codata, as a dual to programming with well-founded data like finite lists and trees.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500597", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert", + "last_name": "Atkey", + "institution": "Quantemplate (United Kingdom)" + }, + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" + } + ], + "dblp_key": "conf/icfp/AtkeyM13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500606", + "title": "Weak optimality, and the meaning of sharing", + "abstract": "In this paper we investigate laziness and optimal evaluation strategies for functional programming languages. We consider the weak lambda-calculus as a basis of functional programming languages, and we adapt to this setting the concepts of optimal reductions that were defined for the full lambda-calculus. We prove that the usual implementation of call-by-need using sharing is optimal, that is, normalizing any lambda-term with call-by-need requires exactly the same number of reduction steps as the shortest reduction sequence in the weak lambda-calculus without sharing. Furthermore, we prove that optimal reduction sequences without sharing are not computable. Hence sharing is the only computable means to reach weak optimality.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500606", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thibaut", + "last_name": "Balabonski", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Balabonski13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500581", + "title": "Programming and reasoning with algebraic effects and dependent types", + "abstract": "One often cited benefit of pure functional programming is that pure code is easier to test and reason about, both formally and informally. However, real programs have side-effects including state management, exceptions and interactions with the outside world. Haskell solves this problem using monads to capture details of possibly side-effecting computations --- it provides monads for capturing state, I/O, exceptions, non-determinism, libraries for practical purposes such as CGI and parsing, and many others, as well as monad transformers for combining multiple effects.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500581", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Edwin", + "last_name": "Brady", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/icfp/Brady13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500576", + "title": "Efficient divide-and-conquer parsing of practical context-free languages", + "abstract": "We present a divide-and-conquer algorithm for parsing context-free languages efficiently. Our algorithm is an instance of Valiant's (1975), who reduced the problem of parsing to matrix multiplications. We show that, while the conquer step of Valiant's is O(n3) in the worst case, it improves to O(logn3), under certain conditions satisfied by many useful inputs. These conditions occur for example in program texts written by humans. The improvement happens because the multiplications involve an overwhelming majority of empty matrices. This result is relevant to modern computing: divide-and-conquer algorithms can be parallelized relatively easily.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500576", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "conf/icfp/BernardyC13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500577", + "title": "Type-theory in color", + "abstract": "Dependent type-theory aims to become the standard way to formalize mathematics at the same time as displacing traditional platforms for high-assurance programming. However, current implementations of type theory are still lacking, in the sense that some obvious truths require explicit proofs, making type-theory awkward to use for many applications, both in formalization and programming. In particular, notions of erasure are poorly supported.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500577", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Guilhem", + "last_name": "Moulin", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/BernardyM13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500591", + "title": "Wellfounded recursion with copatterns: a unified approach to termination and productivity", + "abstract": "In this paper, we study strong normalization of a core language based on System F-omega which supports programming with finite and infinite structures. Building on our prior work, finite data such as finite lists and trees are defined via constructors and manipulated via pattern matching, while infinite data such as streams and infinite trees is defined by observations and synthesized via copattern matching. In this work, we take a type-based approach to strong normalization by tracking size information about finite and infinite data in the type. This guarantees compositionality. More importantly, the duality of pattern and copatterns provide a unifying semantic concept which allows us for the first time to elegantly and uniformly support both well-founded induction and coinduction by mere rewriting. The strong normalization proof is structured around Girard's reducibility candidates. As such our system allows for non-determinism and does not rely on coverage. Since System F-omega is general enough that it can be the target of compilation for the Calculus of Constructions, this work is a significant step towards representing observation-centric infinite data in proof assistants such as Coq and Agda.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500591", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "Ludwig-Maximilians-Universität München" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "conf/icfp/AbelP13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500582", + "title": "Complete and easy bidirectional typechecking for higher-rank polymorphism", + "abstract": "Bidirectional typechecking, in which terms either synthesize a type or are checked against a known type, has become popular for its scalability (unlike Damas-Milner type inference, bidirectional typing remains decidable even for very expressive type systems), its error reporting, and its relative ease of implementation. Following design principles from proof theory, bidirectional typing can be applied to many type constructs. The principles underlying a bidirectional approach to polymorphism, however, are less obvious. We give a declarative, bidirectional account of higher-rank polymorphism, grounded in proof theory; this calculus enjoys many properties such as eta-reduction and predictability of annotations. We give an algorithm for implementing the declarative system; our algorithm is remarkably simple and well-behaved, despite being both sound and complete.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500582", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/DunfieldK13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500593", + "title": "Hoare-style reasoning with (algebraic) continuations", + "abstract": "Continuations are programming abstractions that allow for manipulating the \"future\" of a computation. Amongst their many applications, they enable implementing unstructured program flow through higher-order control operators such as callcc. In this paper we develop a Hoare-style logic for the verification of programs with higher-order control, in the presence of dynamic state. This is done by designing a dependent type theory with first class callcc and abort operators, where pre- and postconditions of programs are tracked through types. Our operators are algebraic in the sense of Plotkin and Power, and Jaskelioff, to reduce the annotation burden and enable verification by symbolic evaluation. We illustrate working with the logic by verifying a number of characteristic examples.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500593", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Germán Andrés", + "last_name": "Delbianco", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/icfp/DelbiancoN13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500589", + "title": "C-SHORe: a collapsible approach to higher-order verification", + "abstract": "Higher-order recursion schemes (HORS) have recently received much attention as a useful abstraction of higher-order functional programs with a number of new verification techniques employing HORS model-checking as their centrepiece. This paper contributes to the ongoing quest for a truly scalable model-checker for HORS by offering a different, automata theoretic perspective. We introduce the first practical model-checking algorithm that acts on a generalisation of pushdown automata equi-expressive with HORS called collapsible pushdown systems (CPDS). At its core is a substantial modification of a recently studied saturation algorithm for CPDS. In particular it is able to use information gathered from an approximate forward reachability analysis to guide its backward search. Moreover, we introduce an algorithm that prunes the CPDS prior to model-checking and a method for extracting counter-examples in negative instances. We compare our tool with the state-of-the-art verification tools for HORS and obtain encouraging results. In contrast to some of the main competition tackling the same problem, our algorithm is fixed-parameter tractable, and we also offer significantly improved performance over the only previously published tool of which we are aware that also enjoys this property. The tool and additional material are available from http://cshore.cs.rhul.ac.uk.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500589", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christopher H.", + "last_name": "Broadbent", + "institution": "Technical University of Munich" + }, + { + "first_name": "Arnaud", + "last_name": "Carayol", + "institution": "Paris-Est Sup" + }, + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Olivier", + "last_name": "Serre", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/icfp/BroadbentCHS13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500586", + "title": "A practical theory of language-integrated query", + "abstract": "Language-integrated query is receiving renewed attention, in part because of its support through Microsoft’s LINQ framework. We present a practical theory of language-integrated query based on quotation and normalisation of quoted terms. Our technique supports join queries, abstraction over values and predicates, composition of queries, dynamic generation of queries, and queries with nested intermediate data. Higher-order features prove useful even for constructing first-order queries. We prove a theorem characterising when a host query is guaranteed to generate a single SQL query. We present experimental results confirming our technique works, even in situations where Microsoft’s LINQ framework either fails to produce an SQL query or, in one case, produces an avalanche of SQL queries.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500586", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "James", + "last_name": "Cheney", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Strathclyde" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/CheneyLW13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500592", + "title": "The bedrock structured programming system: combining generative metaprogramming and hoare logic in an extensible program verifier", + "abstract": "We report on the design and implementation of an extensible programming language and its intrinsic support for formal verification. Our language is targeted at low-level programming of infrastructure like operating systems and runtime systems. It is based on a cross-platform core combining characteristics of assembly languages and compiler intermediate languages. From this foundation, we take literally the saying that C is a \"macro assembly language\": we introduce an expressive notion of certified low-level macros, sufficient to build up the usual features of C and beyond as macros with no special support in the core. Furthermore, our macros have integrated support for strongest postcondition calculation and verification condition generation, so that we can provide a high-productivity formal verification environment within Coq for programs composed from any combination of macros. Our macro interface is expressive enough to support features that low-level programs usually only access through external tools with no formal guarantees, such as declarative parsing or SQL-inspired querying. The abstraction level of these macros only imposes a compile-time cost, via the execution of functional Coq programs that compute programs in our intermediate language; but the run-time cost is not substantially greater than for more conventional C code. We describe our experiences constructing a full C-like language stack using macros, with some experiments on the verifiability and performance of individual programs running on that stack.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500592", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Chlipala13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500587", + "title": "Modular monadic meta-theory", + "abstract": "This paper presents 3MT, a framework for modular mechanized meta-theory of languages with effects. Using 3MT, individual language features and their corresponding definitions -- semantic functions, theorem statements and proofs-- can be built separately and then reused to create different languages with fully mechanized meta-theory. 3MT combines modular datatypes and monads to define denotational semantics with effects on a per-feature basis, without fixing the particular set of effects or language constructs.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500587", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Steven", + "last_name": "Keuchel", + "institution": "Ghent University" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "Chinese University of Hong Kong" + } + ], + "dblp_key": "conf/icfp/DelawareKSO13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500575", + "title": "Typed syntactic meta-programming", + "abstract": "We present a novel set of meta-programming primitives for use in a dependently-typed functional language. The types of our meta-programs provide strong and precise guarantees about their termination, correctness and completeness. Our system supports type-safe construction and analysis of terms, types and typing contexts. Unlike alternative approaches, they are written in the same style as normal programs and use the language's standard functional computational model. We formalise the new meta-programming primitives, implement them as an extension of Agda, and provide evidence of usefulness by means of two compelling applications in the fields of datatype-generic programming and proof tactics.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500575", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/icfp/DevrieseP13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500609", + "title": "Computer science as a school subject", + "abstract": "Computer science is one of the richest, most exciting disciplines on the planet, yet any teenager will tell you that ICT (as it is called in UK schools --- \"information and communication technology\") is focused almost entirely on the use and application of computers, and in practice covers nothing about how computers work, nor programming, nor anything of the discipline of computer science as we understand it. Over the last two decades, computing at school has drifted from writing adventure games on the BBC Micro to writing business plans in Excel.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500609", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/Jones13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500584", + "title": "Functional reactive programming with liveness guarantees", + "abstract": "Functional Reactive Programming (FRP) is an approach to the development of reactive systems which provides a pure functional interface, but which may be implemented as an abstraction of an imperative event-driven layer. FRP systems typically provide a model of behaviours (total time-indexed values, implemented as pull systems) and event sources (partial time-indexed values, implemented as push systems). In this paper, we investigate a type system for event-driven FRP programs which provide liveness guarantees, that is every input event is guaranteed to generate an output event. We show that FRP can be implemented on top of a model of sets and relations, and that the isomorphism between event sources and behaviours corresponds to the isomorphism between relations and set-valued functions. We then implement sets and relations using a model of continuations using the usual double-negation CPS transform. The implementation of behaviours as pull systems based on futures, and of event sources as push systems based on the observer pattern, thus arises from first principles. We also discuss a Java implementation of the FRP model.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500584", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alan", + "last_name": "Jeffrey", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Jeffrey13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500588", + "title": "Higher-order functional reactive programming without spacetime leaks", + "abstract": "Functional reactive programming (FRP) is an elegant approach to declaratively specify reactive systems. However, the powerful abstractions of FRP have historically made it difficult to predict and control the resource usage of programs written in this style.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500588", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "Max Planck Society" + } + ], + "dblp_key": "conf/icfp/Krishnaswami13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500608", + "title": "Structural recursion for querying ordered graphs", + "abstract": "Structural recursion, in the form of, for example, folds on lists and catamorphisms on algebraic data structures including trees, plays an important role in functional programming, by providing a systematic way for constructing and manipulating functional programs. It is, however, a challenge to define structural recursions for graph data structures, the most ubiquitous sort of data in computing. This is because unlike lists and trees, graphs are essentially not inductive and cannot be formalized as an initial algebra in general. In this paper, we borrow from the database community the idea of structural recursion on how to restrict recursions on infinite unordered regular trees so that they preserve the finiteness property and become terminating, which are desirable properties for query languages. We propose a new graph transformation language called lambdaFG for transforming and querying ordered graphs, based on the well-defined bisimulation relation on ordered graphs with special epsilon-edges. The language lambdaFG is a higher order graph transformation language that extends the simply typed lambda calculus with graph constructors and more powerful structural recursions, which is extended for transformations on the sibling dimension. It not only gives a general framework for manipulating graphs and reasoning about them, but also provides a solution to the open problem of how to define a structural recursion on ordered graphs, with the help of the bisimilarity for ordered graphs with epsilon-edges.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500608", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Soichiro", + "last_name": "Hidaka", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Kazuyuki", + "last_name": "Asada", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Hiroyuki", + "last_name": "Kato", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Keisuke", + "last_name": "Nakano", + "institution": "University of Electro-Communications" + } + ], + "dblp_key": "conf/icfp/HidakaAHKN13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500601", + "title": "Exploiting vector instructions with generalized stream fusio", + "abstract": "Stream fusion is a powerful technique for automatically transforming high-level sequence-processing functions into efficient implementations. It has been used to great effect in Haskell libraries for manipulating byte arrays, Unicode text, and unboxed vectors. However, some operations, like vector append, still do not perform well within the standard stream fusion framework. Others, like SIMD computation using the SSE and AVX instructions available on modern x86 chips, do not seem to fit in the framework at all.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500601", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Geoffrey", + "last_name": "Mainland", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Roman", + "last_name": "Leshchinskiy", + "institution": "" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/MainlandLJ13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500578", + "title": "Unifying structured recursion schemes", + "abstract": "Folds over inductive datatypes are well understood and widely used. In their plain form, they are quite restricted; but many disparate generalisations have been proposed that enjoy similar calculational benefits. There have also been attempts to unify the various generalisations: two prominent such unifications are the 'recursion schemes from comonads' of Uustalu, Vene and Pardo, and our own 'adjoint folds'. Until now, these two unified schemes have appeared incompatible. We show that this appearance is illusory: in fact, adjoint folds subsume recursion schemes from comonads. The proof of this claim involves standard constructions in category theory that are nevertheless not well known in functional programming: Eilenberg-Moore categories and bialgebras.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500578", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Oxford" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "University of Oxford" + }, + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/HinzeWG13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500610", + "title": "Interactive programming with dependent types", + "abstract": "In dependently typed languages run-time values can appear in types, making it possible to give programs more precise types than in languages without dependent types. This can range from keeping track of simple invariants like the length of a list, to full functional correctness. In addition to having some correctness guarantees on the final program, assigning more precise types to programs means that you can get more assistance from the type checker while writing them. This is what I focus on here, demonstrating how the programming environment of Agda can help you when developing dependently typed programs.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500610", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ulf", + "last_name": "Norell", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "conf/icfp/Norell13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500580", + "title": "A short cut to parallelization theorems", + "abstract": "The third list-homomorphism theorem states that if a function is both foldr and foldl, it has a divide-and-conquer parallel implementation as well. In this paper, we develop a theory for obtaining such parallelization theorems. The key is a new proof of the third list-homomorphism theorem based on shortcut deforestation. The proof implies that there exists a divide-and-conquer parallel program of the form of h(x 'merge' y) = h1 x odot h2 y, where h is the subject of parallelization, merge is the operation of integrating independent substructures, h1 and h2 are computations applied to substructures, possibly in parallel, and odot merges the results calculated for substructures, if (i) h can be specified by two certain forms of iterative programs, and (ii) merge can be implemented by a function of a certain polymorphic type. Therefore, when requirement (ii) is fulfilled, h has a divide-and-conquer implementation if h has two certain forms of implementations. We show that our approach is applicable to structure-consuming operations by catamorphisms (folds), structure-generating operations by anamorphisms (unfolds), and their generalizations called hylomorphisms.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500580", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Akimasa", + "last_name": "Morihata", + "institution": "Tohoku University Hospital" + } + ], + "dblp_key": "conf/icfp/Morihata13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500574", + "title": "Testing noninterference, quickly", + "abstract": "Information-flow control mechanisms are difficult to design and labor intensive to prove correct. To reduce the time wasted on proof attempts doomed to fail due to broken definitions, we advocate modern random testing techniques for finding counterexamples during the design process. We show how to use QuickCheck, a property-based random-testing tool, to guide the design of a simple information-flow abstract machine. We find that both sophisticated strategies for generating well-distributed random programs and readily falsifiable formulations of noninterference properties are critically important. We propose several approaches and evaluate their effectiveness on a collection of injected bugs of varying subtlety. We also present an effective technique for shrinking large counterexamples to minimal, easily comprehensible ones. Taken together, our best methods enable us to quickly and automatically generate simple counterexamples for all these bugs.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500574", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Antal", + "last_name": "Spector-Zabusky", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/HritcuHPSVAL13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500596", + "title": "Modular and automated type-soundness verification for language extensions", + "abstract": "Language extensions introduce high-level programming constructs that protect programmers from low-level details and repetitive tasks. For such an abstraction barrier to be sustainable, it is important that no errors are reported in terms of generated code. A typical strategy is to check the original user code prior to translation into a low-level encoding, applying the assumption that the translation does not introduce new errors. Unfortunately, such assumption is untenable in general, but in particular in the context of extensible programming languages, such as Racket or SugarJ, that allow regular programmers to define language extensions.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500596", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Florian", + "last_name": "Lorenzen", + "institution": "Technische Universität Berlin" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/icfp/LorenzenE13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500617", + "title": "Functional geometry and the Traité de Lutherie: functional pearl", + "abstract": "We describe a functional programming approach to the design of outlines of eighteenth-century string instruments. The approach is based on the research described in François Denis's book, Traité de lutherie. The programming vernacular for Denis's instructions, which we call functional geometry, is meant to reiterate the historically justified language and techniques of this musical instrument design. The programming metaphor is entirely Euclidean, involving straightedge and compass constructions, with few (if any) numbers, and no Cartesian equations or grid. As such, it is also an interesting approach to teaching programming and mathematics without numerical calculation or equational reasoning.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500617", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Harry G.", + "last_name": "Mairson", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/icfp/Mairson13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500590", + "title": "Handlers in action", + "abstract": "Plotkin and Pretnar's handlers for algebraic effects occupy a sweet spot in the design space of abstractions for effectful computation. By separating effect signatures from their implementation, algebraic effects provide a high degree of modularity, allowing programmers to express effectful programs independently of the concrete interpretation of their effects. A handler is an interpretation of the effects of an algebraic computation. The handler abstraction adapts well to multiple settings: pure or impure, strict or lazy, static types or dynamic types. This is a position paper whose main aim is to popularise the handler abstraction. We give a gentle introduction to its use, a collection of illustrative examples, and a straightforward operational semantics. We describe our Haskell implementation of handlers in detail, outline the ideas behind our OCaml, SML, and Racket implementations, and present experimental results comparing handlers with existing code.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500590", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Cambridge" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Strathclyde" + }, + { + "first_name": "Nicolas", + "last_name": "Oury", + "institution": "" + } + ], + "dblp_key": "conf/icfp/KammarLO13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500604", + "title": "Optimizing abstract abstract machines", + "abstract": "The technique of abstracting abstract machines (AAM) provides a systematic approach for deriving computable approximations of evaluators that are easily proved sound. This article contributes a complementary step-by-step process for subsequently going from a naive analyzer derived under the AAM approach, to an efficient and correct implementation. The end result of the process is a two to three order-of-magnitude improvement over the systematically derived analyzer, making it competitive with hand-optimized implementations that compute fundamentally less precise results.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500604", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dionna", + "last_name": "Glaze", + "institution": "Northeastern University" + }, + { + "first_name": "Nicholas", + "last_name": "Labich", + "institution": "Northeastern University" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/JohnsonLMH13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500618", + "title": "A nanopass framework for commercial compiler development", + "abstract": "Contemporary compilers must typically handle sophisticated high-level source languages, generate efficient code for multiple hardware architectures and operating systems, and support source-level debugging, profiling, and other program development tools. As a result, compilers tend to be among the most complex of software systems. Nanopass frameworks are designed to help manage this complexity. A nanopass compiler is comprised of many single-task passes with formally defined intermediate languages. The perceived downside of a nanopass compiler is that the extra passes will lead to substantially longer compilation times. To determine whether this is the case, we have created a plug replacement for the commercial Chez Scheme compiler, implemented using an updated nanopass framework, and we have compared the speed of the new compiler and the code it generates against the original compiler for a large set of benchmark programs. This paper describes the updated nanopass framework, the new compiler, and the results of our experiments. The compiler produces faster code than the original, averaging 15-27% depending on architecture and optimization level, due to a more sophisticated but slower register allocator and improvements to several optimizations. Compilation times average well within a factor of two of the original compiler, despite the slower register allocator and the replacement of five passes of the original 10 with over 50 nanopasses.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500618", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrew W.", + "last_name": "Keep", + "institution": "University of Utah" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Cisco Systems (United States)" + } + ], + "dblp_key": "conf/icfp/KeepD13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500595", + "title": "Optimising purely functional GPU programs", + "abstract": "Purely functional, embedded array programs are a good match for SIMD hardware, such as GPUs. However, the naive compilation of such programs quickly leads to both code explosion and an excessive use of intermediate data structures. The resulting slow-down is not acceptable on target hardware that is usually chosen to achieve high performance.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500595", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Trevor L.", + "last_name": "McDonell", + "institution": "UNSW Sydney" + }, + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gabriele", + "last_name": "Keller", + "institution": "UNSW Sydney" + }, + { + "first_name": "Ben", + "last_name": "Lippmeier", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/icfp/McDonellCKL13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500615", + "title": "Experience report: functional programming of mHealth applications", + "abstract": "A modular framework for the development of medical applications that promotes deterministic, robust and correct code is presented. The system is based on the portable Gambit Scheme programming language and provides a flexible cross-platform environment for developing graphical applications on mobile devices as well as medical instrumentation interfaces running on embedded platforms. Real world applications of this framework for mobile diagnostics, telemonitoring and automated drug infusions are reported. The source code for the core framework is open source and available at: https://github.com/part-cw/lambdanative.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500615", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christian L.", + "last_name": "Petersen", + "institution": "University of British Columbia" + }, + { + "first_name": "Matthias", + "last_name": "Görges", + "institution": "University of British Columbia" + }, + { + "first_name": "Dustin", + "last_name": "Dunsmuir", + "institution": "University of British Columbia" + }, + { + "first_name": "J. Mark", + "last_name": "Ansermino", + "institution": "University of British Columbia" + }, + { + "first_name": "Guy A.", + "last_name": "Dumont", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/icfp/PetersenGDAD13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500605", + "title": "Automatic SIMD vectorization for Haskell", + "abstract": "Expressing algorithms using immutable arrays greatly simplifies the challenges of automatic SIMD vectorization, since several important classes of dependency violations cannot occur. The Haskell programming language provides libraries for programming with immutable arrays, and compiler support for optimizing them to eliminate the overhead of intermediate temporary arrays. We describe an implementation of automatic SIMD vectorization in a Haskell compiler which gives substantial vector speedups for a range of programs written in a natural programming style. We compare performance with that of programs compiled by the Glasgow Haskell Compiler.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500605", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Leaf", + "last_name": "Petersen", + "institution": "Intel (United States)" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Cambridge" + }, + { + "first_name": "Neal", + "last_name": "Glew", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/icfp/PetersenOG13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500585", + "title": "Correctness of an STM Haskell implementation", + "abstract": "A concurrent implementation of software transactional memory in Concurrent Haskell using a call-by-need functional language with processes and futures is given. The description of the small-step operational semantics is precise and explicit, and employs an early abort of conflicting transactions. A proof of correctness of the implementation is given for a contextual semantics with may- and should-convergence. This implies that our implementation is a correct evaluator for an abstract specification equipped with a big-step semantics.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500585", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manfred", + "last_name": "Schmidt-Schauß", + "institution": "Goethe University Frankfurt" + }, + { + "first_name": "David", + "last_name": "Sabel", + "institution": "Goethe University Frankfurt" + } + ], + "dblp_key": "conf/icfp/Schmidt-SchaussS13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500616", + "title": "Experience report: applying random testing to a base type environment", + "abstract": "As programmers, programming in typed languages increases our confidence in the correctness of our programs. As type system designers, soundness proofs increase our confidence in the correctness of our type systems. There is more to typed languages than their typing rules, however. To be usable, a typed language needs to provide a well-furnished standard library and to specify types for its exports.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500616", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Vincent", + "last_name": "St-Amour", + "institution": "Boston University" + }, + { + "first_name": "Neil", + "last_name": "Toronto", + "institution": "Brigham Young University" + } + ], + "dblp_key": "conf/icfp/St-AmourT13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500611", + "title": "Simple and compositional reification of monadic embedded languages", + "abstract": "When writing embedded domain specific languages in Haskell, it is often convenient to be able to make an instance of the Monad class to take advantage of the do-notation and the extensive monad libraries. Commonly it is desirable to compile such languages rather than just interpret them. This introduces the problem of monad reification, i.e. observing the structure of the monadic computation. We present a solution to the monad reification problem and illustrate it with a small robot control language. Monad reification is not new but the novelty of our approach is in its directness, simplicity and compositionality.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500611", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Josef", + "last_name": "Svenningsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Bo Joel", + "last_name": "Svensson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/SvenningssonS13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500598", + "title": "Programming with permissions in Mezzo", + "abstract": "We present Mezzo, a typed programming language of ML lineage. Mezzo is equipped with a novel static discipline of duplicable and affine permissions, which controls aliasing and ownership. This rules out certain mistakes, including representation exposure and data races, and enables new idioms, such as gradual initialization, memory re-use, and (type)state changes. Although the core static discipline disallows sharing a mutable data structure, Mezzo offers several ways of working around this restriction, including a novel dynamic ownership control mechanism which we dub \"adoption and abandon\".", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500598", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/PottierP13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500602", + "title": "The constrained-monad problem", + "abstract": "In Haskell, there are many data types that would form monads were it not for the presence of type-class constraints on the operations on that data type. This is a frustrating problem in practice, because there is a considerable amount of support and infrastructure for monads that these data types cannot use. Using several examples, we show that a monadic computation can be restructured into a normal form such that the standard monad class can be used. The technique is not specific to monads, and we show how it can also be applied to other structures, such as applicative functors. One significant use case for this technique is domain-specific languages, where it is often desirable to compile a deep embedding of a computation to some other language, which requires restricting the types that can appear in that computation.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500602", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Neil", + "last_name": "Sculthorpe", + "institution": "University of Kansas" + }, + { + "first_name": "Jan", + "last_name": "Bracker", + "institution": "Kiel University" + }, + { + "first_name": "George", + "last_name": "Giorgidze", + "institution": "University of Tübingen" + }, + { + "first_name": "Andy", + "last_name": "Gill", + "institution": "University of Kansas" + } + ], + "dblp_key": "conf/icfp/SculthorpeBGG13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500579", + "title": "Mtac: a monad for typed tactic programming in Coq", + "abstract": "Effective support for custom proof automation is essential for large scale interactive proof development. However, existing languages for automation via *tactics* either (a) provide no way to specify the behavior of tactics within the base logic of the accompanying theorem prover, or (b) rely on advanced type-theoretic machinery that is not easily integrated into established theorem provers.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500579", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Beta", + "last_name": "Ziliani", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/ZilianiDKNV13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500599", + "title": "System FC with explicit kind equality", + "abstract": "System FC, the core language of the Glasgow Haskell Compiler, is an explicitly-typed variant of System F with first-class type equality proofs called coercions. This extensible proof system forms the foundation for type system extensions such as type families (type-level functions) and Generalized Algebraic Datatypes (GADTs). Such features, in conjunction with kind polymorphism and datatype promotion, support expressive compile-time reasoning.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500599", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/WeirichHE13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500600", + "title": "Unifying refinement and hoare-style reasoning in a logic for higher-order concurrency", + "abstract": "Modular programming and modular verification go hand in hand, but most existing logics for concurrency ignore two crucial forms of modularity: *higher-order functions*, which are essential for building reusable components, and *granularity abstraction*, a key technique for hiding the intricacies of fine-grained concurrent data structures from the clients of those data structures. In this paper, we present CaReSL, the first logic to support the use of granularity abstraction for modular verification of higher-order concurrent programs. After motivating the features of CaReSL through a variety of illustrative examples, we demonstrate its effectiveness by using it to tackle a significant case study: the first formal proof of (partial) correctness for Hendler et al.'s \"flat combining\" algorithm.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500600", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/icfp/TuronDB13", + "venue": "icfp", + "year": 2013 + }, + { + "paper_id": "10.1145/2500365.2500612", + "title": "Verified decision procedures for MSO on words based on derivatives of regular expressions", + "abstract": "Monadic second-order logic on finite words (MSO) is a decidable yet expressive logic into which many decision problems can be encoded. Since MSO formulas correspond to regular languages, equivalence of MSO formulas can be reduced to the equivalence of some regular structures (e.g. automata). This paper presents a verified functional decision procedure for MSO formulas that is not based on automata but on regular expressions. Functional languages are ideally suited for this task: regular expressions are data types and functions on them are defined by pattern matching and recursion and are verified by structural induction.", + "date": "2013-09-25", + "link": "https://doi.org/10.1145/2500365.2500612", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dmitriy", + "last_name": "Traytel", + "institution": "Technical University of Munich" + }, + { + "first_name": "Tobias", + "last_name": "Nipkow", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/icfp/TraytelN13", + "venue": "icfp", + "year": 2013 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2014.json b/data/pl_conferences/icfp/2014.json new file mode 100644 index 0000000..f05aa72 --- /dev/null +++ b/data/pl_conferences/icfp/2014.json @@ -0,0 +1,840 @@ +[ + { + "paper_id": "10.1145/2628136.2628165", + "title": "Using formal methods to enable more secure vehicles: DARPA's HACMS program", + "abstract": "Networked embedded systems are ubiquitous in modern society. Examples include SCADA systems that manage physical infrastructure, medical devices such as pacemakers and insulin pumps, and vehicles such as airplanes and automobiles. Such devices are connected to networks for a variety of compelling reasons, including the ability to access diagnostic information conveniently, perform software updates, provide innovative features, and lower costs. Researchers and hackers have shown that these kinds of networked embedded systems are vulnerable to remote attacks and that such attacks can cause physical damage and can be hidden from monitors [1, 4].", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628165", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/icfp/Fisher14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628138", + "title": "Folding domain-specific languages: deep and shallow embeddings (functional Pearl)", + "abstract": "A domain-specific language can be implemented by embedding within a general-purpose host language. This embedding may be deep or shallow, depending on whether terms in the language construct syntactic or semantic representations. The deep and shallow styles are closely related, and intimately connected to folds; in this paper, we explore that connection.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628138", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/icfp/GibbonsW14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2632855", + "title": "Behavioral software contracts", + "abstract": "Programmers embrace contracts. They can use the language they know and love to formulate logical assertions about the behavior of their programs. They can use the existing IDE infrastructure to log contracts, to test, to debug, and to profile their programs.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2632855", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/icfp/Findler14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628158", + "title": "Homotopical patch theory", + "abstract": "Homotopy type theory is an extension of Martin-Löf type theory, based on a correspondence with homotopy theory and higher category theory. In homotopy type theory, the propositional equality type becomes proof-relevant, and corresponds to paths in a space. This allows for a new class of datatypes, called higher inductive types, which are specified by constructors not only for points but also for paths. In this paper, we consider a programming application of higher inductive types. Version control systems such as Darcs are based on the notion of patches - syntactic representations of edits to a repository. We show how patch theory can be developed in homotopy type theory. Our formulation separates formal theories of patches from their interpretation as edits to repositories. A patch theory is presented as a higher inductive type. Models of a patch theory are given by maps out of that type, which, being functors, automatically preserve the structure of patches. Several standard tools of homotopy theory come into play, demonstrating the use of these methods in a practical programming context.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628158", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Carlo", + "last_name": "Angiuli", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Edward", + "last_name": "Morehouse", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Wesleyan University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/AngiuliMLH14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628153", + "title": "Practical and effective higher-order optimizations", + "abstract": "Inlining is an optimization that replaces a call to a function with that function's body. This optimization not only reduces the overhead of a function call, but can expose additional optimization opportunities to the compiler, such as removing redundant operations or unused conditional branches. Another optimization, copy propagation, replaces a redundant copy of a still-live variable with the original. Copy propagation can reduce the total number of live variables, reducing register pressure and memory usage, and possibly eliminating redundant memory-to-memory copies. In practice, both of these optimizations are implemented in nearly every modern compiler.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628153", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lars", + "last_name": "Bergström", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Matthew", + "last_name": "Le", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Nora", + "last_name": "Sandler", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/icfp/BergstromFLRS14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628147", + "title": "Compositional semantics for composable continuations: from abortive to delimited control", + "abstract": "Parigot's λμ-calculus, a system for computational reasoning about classical proofs, serves as a foundation for control operations embodied by operators like Scheme's callcc. We demonstrate that the call-by-value theory of the λμ-calculus contains a latent theory of delimited control, and that a known variant of λμ which unshackles the syntax yields a calculus of composable continuations from the existing constructs and rules for classical control. To relate to the various formulations of control effects, and to continuation-passing style, we use a form of compositional program transformations which preserves the underlying structure of equational theories, contexts, and substitution. Finally, we generalize the call-by-name and call-by-value theories of the λμ-calculus by giving a single parametric theory that encompasses both, allowing us to generate a call-by-need instance that defines a calculus of classical and delimited control with lazy evaluation and sharing.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628147", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Downen", + "institution": "University of Oregon" + }, + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/icfp/DownenA14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628139", + "title": "Pattern matching without K", + "abstract": "Dependent pattern matching is an intuitive way to write programs and proofs in dependently typed languages. It is reminiscent of both pattern matching in functional languages and case analysis in on-paper mathematics. However, in general it is incompatible with new type theories such as homotopy type theory (HoTT). As a consequence, proofs in such theories are typically harder to write and to understand. The source of this incompatibility is the reliance of dependent pattern matching on the so-called K axiom - also known as the uniqueness of identity proofs - which is inadmissible in HoTT. The Agda language supports an experimental criterion to detect definitions by pattern matching that make use of the K axiom, but so far it lacked a formal correctness proof.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628139", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jesper", + "last_name": "Cockx", + "institution": "KU Leuven" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/icfp/CockxDP14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628148", + "title": "Maximal sharing in the Lambda calculus with letrec", + "abstract": "Increasing sharing in programs is desirable to compactify the code, and to avoid duplication of reduction work at run-time, thereby speeding up execution. We show how a maximal degree of sharing can be obtained for programs expressed as terms in the lambda calculus with letrec. We introduce a notion of `maximal compactness' for lambda-letrec-terms among all terms with the same infinite unfolding. Instead of defined purely syntactically, this notion is based on a graph semantics. lambda-letrec-terms are interpreted as first-order term graphs so that unfolding equivalence between terms is preserved and reflected through bisimilarity of the term graph interpretations. Compactness of the term graphs can then be compared via functional bisimulation. We describe practical and efficient methods for the following two problems: transforming a lambda-letrec-term into a maximally compact form; and deciding whether two lambda-letrec-terms are unfolding-equivalent. The transformation of a lambda-letrec-term L into maximally compact form L0 proceeds in three steps: (i) translate L into its term graph G=[[L]]; (ii) compute the maximally shared form of G as its bisimulation collapse G0; (iii) read back a lambda-letrec-term L0 from the term graph G0 with the property [[L0]]=G0. This guarantees that L0 and L have the same unfolding, and that L0 exhibits maximal sharing. The procedure for deciding whether two given lambda-letrec-terms L1 and L2 are unfolding-equivalent computes their term graph interpretations [[L1]] and [[L2]], and checks whether these term graphs are bisimilar. For illustration, we also provide a readily usable implementation.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628148", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Clemens", + "last_name": "Grabmayer", + "institution": "" + }, + { + "first_name": "Jan", + "last_name": "Rochel", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/icfp/GrabmayerR14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628154", + "title": "Distilling abstract machines", + "abstract": "It is well-known that many environment-based abstract machines can be seen as strategies in lambda calculi with explicit substitutions (ES). Recently, graphical syntaxes and linear logic led to the linear substitution calculus (LSC), a new approach to ES that is halfway between small-step calculi and traditional calculi with ES. This paper studies the relationship between the LSC and environment-based abstract machines. While traditional calculi with ES simulate abstract machines, the LSC rather distills them: some transitions are simulated while others vanish, as they map to a notion of structural congruence. The distillation process unveils that abstract machines in fact implement weak linear head reduction, a notion of evaluation having a central role in the theory of linear logic. We show that such a pattern applies uniformly in call-by-name, call-by-value, and call-by-need, catching many machines in the literature. We start by distilling the KAM, the CEK, and a sketch of the ZINC, and then provide simplified versions of the SECD, the lazy KAM, and Sestoft's machine. Along the way we also introduce some new machines with global environments. Moreover, we show that distillation preserves the time complexity of the executions, i.e. the LSC is a complexity-preserving abstraction of abstract machines.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628154", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Pablo", + "last_name": "Barenbaum", + "institution": "Consejo Nacional de Investigaciones Científicas y Técnicas" + }, + { + "first_name": "Damiano", + "last_name": "Mazza", + "institution": "Université Sorbonne Paris Nord" + } + ], + "dblp_key": "conf/icfp/AccattoliBM14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628150", + "title": "Functional programming for dynamic and large data with self-adjusting computation", + "abstract": "Combining type theory, language design, and empirical work, we present techniques for computing with large and dynamically changing datasets. Based on lambda calculus, our techniques are suitable for expressing a diverse set of algorithms on large datasets and, via self-adjusting computation, enable computations to respond automatically to changes in their data. To improve the scalability of self-adjusting computation, we present a type system for precise dependency tracking that minimizes the time and space for storing dependency metadata. The type system eliminates an important assumption of prior work that can lead to recording spurious dependencies. We present a type-directed translation algorithm that generates correct self-adjusting programs without relying on this assumption. We then show a probabilistic-chunking technique to further decrease space usage by controlling the fundamental space-time tradeoff in self-adjusting computation. We implement and evaluate these techniques, showing promising results on challenging benchmarks involving large graphs.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628150", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yan", + "last_name": "Chen", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kanat", + "last_name": "Tangwongsan", + "institution": "Mahidol University" + } + ], + "dblp_key": "conf/icfp/ChenAT14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628155", + "title": "Type-based parametric analysis of program families", + "abstract": "Previous research on static analysis for program families has focused on lifting analyses for single, plain programs to program families by employing idiosyncratic representations. The lifting effort typically involves a significant amount of work for proving the correctness of the lifted algorithm and demonstrating its scalability. In this paper, we propose a parameterized static analysis framework for program families that can automatically lift a class of type-based static analyses for plain programs to program families. The framework consists of a parametric logical specification and a parametric variational constraint solver. We prove that a lifted algorithm is correct provided that the underlying analysis algorithm is correct. An evaluation of our framework has revealed an error in a previous manually lifted analysis. Moreover, performance tests indicate that the overhead incurred by the general framework is bounded by a factor of 2.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628155", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "Oregon State University" + }, + { + "first_name": "Martin", + "last_name": "Erwig", + "institution": "Oregon State University" + } + ], + "dblp_key": "conf/icfp/0008E14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628159", + "title": "A relational framework for higher-order shape analysis", + "abstract": "We propose the integration of a relational specification framework within a dependent type system capable of verifying complex invariants over the shapes of algebraic datatypes. Our approach is based on the observation that structural properties of such datatypes can often be naturally expressed as inductively-defined relations over the recursive structure evident in their definitions. By interpreting constructor applications (abstractly) in a relational domain, we can define expressive relational abstractions for a variety of complex data structures, whose structural and shape invariants can be automatically verified. Our specification language also allows for definitions of parametricrelations for polymorphic data types that enable highly composable specifications and naturally generalizes to higher-order polymorphic functions.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628159", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/icfp/KakiJ14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628146", + "title": "Building embedded systems with embedded DSLs", + "abstract": "We report on our experiences in synthesizing a fully-featured autopilot from embedded domain-specific languages (EDSLs) hosted in Haskell. The autopilot is approximately 50k lines of C code generated from 10k lines of EDSL code and includes control laws, mode logic, encrypted communications system, and device drivers. The autopilot was built in less than two engineer years. This is the story of how EDSLs provided the productivity and safety gains to do large-scale low-level embedded programming and lessons we learned in doing so.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628146", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Patrick C.", + "last_name": "Hickey", + "institution": "Galois (United States)" + }, + { + "first_name": "Lee", + "last_name": "Pike", + "institution": "Galois (United States)" + }, + { + "first_name": "Trevor", + "last_name": "Elliott", + "institution": "Galois (United States)" + }, + { + "first_name": "James", + "last_name": "Bielman", + "institution": "Galois (United States)" + }, + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Galois (United States)" + } + ], + "dblp_key": "conf/icfp/HickeyPEBL14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628141", + "title": "Safe zero-cost coercions for Haskell", + "abstract": "Generative type abstractions -- present in Haskell, OCaml, and other languages -- are useful concepts to help prevent programmer errors. They serve to create new types that are distinct at compile time but share a run-time representation with some base type. We present a new mechanism that allows for zero-cost conversions between generative type abstractions and their representations, even when such types are deeply nested. We prove type safety in the presence of these conversions and have implemented our work in GHC.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628141", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joachim", + "last_name": "Breitner", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/BreitnerEJW14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628142", + "title": "Worker/wrapper/makes it/faster", + "abstract": "Much research in program optimization has focused on formal approaches to correctness: proving that the meaning of programs is preserved by the optimisation. Paradoxically, there has been comparatively little work on formal approaches to efficiency: proving that the performance of optimized programs is actually improved. This paper addresses this problem for a general-purpose optimization technique, the worker/wrapper transformation. In particular, we use the call-by-need variant of improvement theory to establish conditions under which the worker/wrapper transformation is formally guaranteed to preserve or improve the time performance of programs in lazy languages such as Haskell.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628142", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jennifer", + "last_name": "Hackett", + "institution": "University of Nottingham" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "conf/icfp/HackettH14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628152", + "title": "Krivine nets: a semantic foundation for distributed execution", + "abstract": "We define a new approach to compilation to distributed architectures based on networks of abstract machines. Using it we can implement a generalised and fully transparent form of Remote Procedure Call that supports calling higher-order functions across node boundaries, without sending actual code. Our starting point is the classic Krivine machine, which implements reduction for untyped call-by-name PCF. We successively add the features that we need for distributed execution and show the correctness of each addition. Then we construct a two-level operational semantics, where the high level is a network of communicating machines, and the low level is given by local machine transitions. Using these networks, we arrive at our final system, the Krivine Net. We show that Krivine Nets give a correct distributed implementation of the Krivine machine, which preserves both termination and non-termination properties. All the technical results have been formalised and proved correct in Agda. We also implement a prototype compiler which we compare with previous distributing compilers based on Girard's Geometry of Interaction and on Game Semantics.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628152", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Olle", + "last_name": "Fredriksson", + "institution": "University of Birmingham" + }, + { + "first_name": "Dan R.", + "last_name": "Ghica", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/icfp/FredrikssonG14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628144", + "title": "There is no fork: an abstraction for efficient, concurrent, and concise data access", + "abstract": "We describe a new programming idiom for concurrency, based on Applicative Functors, where concurrency is implicit in the Applicative <*> operator. The result is that concurrent programs can be written in a natural applicative style, and they retain a high degree of clarity and modularity while executing with maximal concurrency. This idiom is particularly useful for programming against external data sources, where the application code is written without the use of explicit concurrency constructs, while the implementation is able to batch together multiple requests for data from the same source, and fetch data from multiple sources concurrently. Our abstraction uses a cache to ensure that multiple requests for the same data return the same result, which frees the programmer from having to arrange to fetch data only once, which in turn leads to greater modularity.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628144", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Louis", + "last_name": "Brandy", + "institution": "Menlo School" + }, + { + "first_name": "Jonathan", + "last_name": "Coens", + "institution": "Menlo School" + }, + { + "first_name": "Jon", + "last_name": "Purdy", + "institution": "Menlo School" + } + ], + "dblp_key": "conf/icfp/MarlowBCP14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628162", + "title": "Romeo: a system for more flexible binding-safe programming", + "abstract": "Current languages for safely manipulating values with names only support term languages with simple binding syntax. As a result, no tools exist to safely manipulate code written in those languages for which name problems are the most challenging. We address this problem with Romeo, a language that respects α-equivalence on its values, and which has access to a rich specification language for binding, inspired by attribute grammars. Our work has the complex-binding support of David Herman's λm, but is a full-fledged binding-safe language like Pure FreshML.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628162", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Stansifer", + "institution": "Northeastern University" + }, + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/StansiferW14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628145", + "title": "Hindley-milner elaboration in applicative style: functional pearl", + "abstract": "Type inference - the problem of determining whether a program is well-typed - is well-understood. In contrast, elaboration - the task of constructing an explicitly-typed representation of the program - seems to have received relatively little attention, even though, in a non-local type inference system, it is non-trivial. We show that the constraint-based presentation of Hindley-Milner type inference can be extended to deal with elaboration, while preserving its elegance. This involves introducing a new notion of \"constraint with a value\", which forms an applicative functor.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628145", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/Pottier14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628137", + "title": "On teaching *how to design programs*: observations from a newcomer", + "abstract": "This paper presents a personal, qualitative case study of a first course using How to Design Programs and its functional teaching languages. The paper reconceptualizes the book's six-step design process as an eight-step design process ending in a new \"review and refactor\" step. It recommends specific approaches to students' difficulties with function descriptions, function templates, data examples, and other parts of the design process. It connects the process to interactive \"world programs.\" It recounts significant, informative missteps in course design and delivery. Finally, it identifies some unsolved teaching problems and some potential solutions.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628137", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/icfp/Ramsey14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628160", + "title": "Coeffects: a calculus of context-dependent computation", + "abstract": "The notion of context in functional languages no longer refers just to variables in scope. Context can capture additional properties of variables (usage patterns in linear logics; caching requirements in dataflow languages) as well as additional resources or properties of the execution environment (rebindable resources; platform version in a cross-platform application). The recently introduced notion of coeffects captures the latter, whole-context properties, but it failed to capture fine-grained per-variable properties.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628160", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tomas", + "last_name": "Petricek", + "institution": "University of Cambridge" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Cambridge" + }, + { + "first_name": "Alan", + "last_name": "Mycroft", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/PetricekOM14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628143", + "title": "Lem: reusable engineering of real-world semantics", + "abstract": "Recent years have seen remarkable successes in rigorous engineering: using mathematically rigorous semantic models (not just idealised calculi) of real-world processors, programming languages, protocols, and security mechanisms, for testing, proof, analysis, and design. Building these models is challenging, requiring experimentation, dialogue with vendors or standards bodies, and validation; their scale adds engineering issues akin to those of programming to the task of writing clear and usable mathematics. But language and tool support for specification is lacking. Proof assistants can be used but bring their own difficulties, and a model produced in one, perhaps requiring many person-years effort and maintained over an extended period, cannot be used by those familiar with another.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628143", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dominic P.", + "last_name": "Mulligan", + "institution": "University of Cambridge" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Kent" + }, + { + "first_name": "Kathryn E.", + "last_name": "Gray", + "institution": "University of Cambridge" + }, + { + "first_name": "Tom", + "last_name": "Ridge", + "institution": "University of Leicester" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/icfp/MulliganOGRS14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628163", + "title": "How to keep your neighbours in order", + "abstract": "I present a datatype-generic treatment of recursive container types whose elements are guaranteed to be stored in increasing order, with the ordering invariant rolled out systematically. Intervals, lists and binary search trees are instances of the generic treatment. On the journey to this treatment, I report a variety of failed experiments and the transferable learning experiences they triggered. I demonstrate that a total element ordering is enough to deliver insertion and flattening algorithms, and show that (with care about the formulation of the types) the implementations remain as usual. Agda's instance arguments and pattern synonyms maximize the proof search done by the typechecker and minimize the appearance of proofs in program text, often eradicating them entirely. Generalizing to indexed recursive container types, invariants such as size and balance can be expressed in addition to ordering. By way of example, I implement insertion and deletion for 2-3 trees, ensuring both order and balance by the discipline of type checking.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628163", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" + } + ], + "dblp_key": "conf/icfp/McBride14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2631168", + "title": "Depending on types", + "abstract": "Is Haskell a dependently typed programming language? Should it be? GHC's many type-system features, such as Generalized Algebraic Datatypes (GADTs), datatype promotion, multiparameter type classes, and type families, give programmers the ability to encode domain-specific invariants in their types. Clever Haskell programmers have used these features to enhance the reasoning capabilities of static type checking. But really, how far have we come? Could we do more?", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2631168", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/icfp/Weirich14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628156", + "title": "Soft contract verification", + "abstract": "Behavioral software contracts are a widely used mechanism for governing the flow of values between components. However, run-time monitoring and enforcement of contracts imposes significant overhead and delays discovery of faulty components to run-time.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628156", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Phúc C.", + "last_name": "Nguyen", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/icfp/NguyenTH14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628140", + "title": "Settable and non-interfering signal functions for FRP: how a first-order switch is more than enough", + "abstract": "Functional Reactive Programming (FRP) provides a method for programming continuous, reactive systems by utilizing signal functions that, abstractly, transform continuous input signals into continuous output signals. These signals may also be streams of events, and indeed, by allowing signal functions themselves to be the values carried by these events (in essence, signals of signal functions), one can conveniently make discrete changes in program behavior by \"switching\" into and out of these signal functions. This higher-order notion of switching is common among many FRP systems, in particular those based on arrows, such as Yampa.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628140", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Winograd-Cort", + "institution": "Yale University" + }, + { + "first_name": "Paul", + "last_name": "Hudak", + "institution": "Yale University" + } + ], + "dblp_key": "conf/icfp/Winograd-CortH14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628151", + "title": "SeLINQ: tracking information across application-database boundaries", + "abstract": "The root cause for confidentiality and integrity attacks against computing systems is insecure information flow. The complexity of modern systems poses a major challenge to secure end-to-end information flow, ensuring that the insecurity of a single component does not render the entire system insecure. While information flow in a variety of languages and settings has been thoroughly studied in isolation, the problem of tracking information across component boundaries has been largely out of reach of the work so far. This is unsatisfactory because tracking information across component boundaries is necessary for end-to-end security.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628151", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Schoepe", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Daniel", + "last_name": "Hedin", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Andrei", + "last_name": "Sabelfeld", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/SchoepeHS14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628149", + "title": "A theory of gradual effect systems", + "abstract": "Effect systems have the potential to help software developers, but their practical adoption has been very limited. We conjecture that this limited adoption is due in part to the difficulty of transitioning from a system where effects are implicit and unrestricted to a system with a static effect discipline, which must settle for conservative checking in order to be decidable. To address this hindrance, we develop a theory of gradual effect checking, which makes it possible to incrementally annotate and statically check effects, while still rejecting statically inconsistent programs. We extend the generic type-and-effect framework of Marino and Millstein with a notion of unknown effects, which turns out to be significantly more subtle than unknown types in traditional gradual typing. We appeal to abstract interpretation to develop and validate the concepts of gradual effect checking. We also demonstrate how an effect system formulated in Marino and Millstein's framework can be automatically extended to support gradual checking.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628149", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Felipe Bañados", + "last_name": "Schwerter", + "institution": "University of Chile" + }, + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/icfp/SchwerterGT14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628161", + "title": "Refinement types for Haskell", + "abstract": "SMT-based checking of refinement types for call-by-value languages is a well-studied subject. Unfortunately, the classical translation of refinement types to verification conditions is unsound under lazy evaluation. When checking an expression, such systems implicitly assume that all the free variables in the expression are bound to values. This property is trivially guaranteed by eager, but does not hold under lazy, evaluation. Thus, to be sound and precise, a refinement type system for Haskell and the corresponding verification conditions must take into account which subset of binders actually reduces to values. We present a stratified type system that labels binders as potentially diverging or not, and that (circularly) uses refinement types to verify the labeling. We have implemented our system in LIQUIDHASKELL and present an experimental evaluation of our approach on more than 10,000 lines of widely used Haskell libraries. We show that LIQUIDHASKELL is able to prove 96% of all recursive functions terminating, while requiring a modest 1.7 lines of termination-annotations per 100 lines of code.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628161", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "University of California, San Diego" + }, + { + "first_name": "Eric L.", + "last_name": "Seidel", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Simon", + "last_name": "Peyton-Jones", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/VazouSJVJ14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628157", + "title": "Concurrent NetCore: from policies to pipelines", + "abstract": "In a Software-Defined Network (SDN), a central, computationally powerful controller manages a set of distributed, computationally simple switches. The controller computes a policy describing how each switch should route packets and populates packet-processing tables on each switch with rules to enact the routing policy. As network conditions change, the controller continues to add and remove rules from switches to adjust the policy as needed.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628157", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cole", + "last_name": "Schlesinger", + "institution": "Princeton University" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Princeton University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/icfp/SchlesingerGW14", + "venue": "icfp", + "year": 2014 + }, + { + "paper_id": "10.1145/2628136.2628164", + "title": "SML# in industry: a practical ERP system development", + "abstract": "This paper reports on our industry-academia project of using a functional language in business software production. The general motivation behind the project is our ultimate goal of adopting an ML-style higher-order typed functional language in a wide range of ordinary software development in industry. To probe the feasibility and identify various practical problems and needs, we have conducted a 15 month pilot project for developing an enterprise resource planning (ERP) system in SML#. The project has successfully completed as we have planned, demonstrating the feasibility of SML#. In particular, seamless integration of SQL and direct C language interface are shown to be useful in reliable and efficient development of a data intensive business application. During the program development, we have found several useful functional programming patterns and a number of possible extensions of an ML-style language with records. This paper reports on the project details and the lessons learned from the project.", + "date": "2014-08-19", + "link": "https://doi.org/10.1145/2628136.2628164", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Tohoku University" + }, + { + "first_name": "Katsuhiro", + "last_name": "Ueno", + "institution": "Tohoku University" + }, + { + "first_name": "Kazunori", + "last_name": "Hoshi", + "institution": "NEC (Japan)" + }, + { + "first_name": "Shinji", + "last_name": "Nozaki", + "institution": "NEC (Japan)" + }, + { + "first_name": "Takashi", + "last_name": "Satō", + "institution": "NEC (Japan)" + }, + { + "first_name": "Tasuku", + "last_name": "Makabe", + "institution": "NEC (Japan)" + }, + { + "first_name": "Yuki", + "last_name": "Ito", + "institution": "NEC (Japan)" + } + ], + "dblp_key": "conf/icfp/OhoriUHNSMI14", + "venue": "icfp", + "year": 2014 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2015.json b/data/pl_conferences/icfp/2015.json new file mode 100644 index 0000000..9ad3bef --- /dev/null +++ b/data/pl_conferences/icfp/2015.json @@ -0,0 +1,988 @@ +[ + { + "paper_id": "10.1145/2784731.2789052", + "title": "Program synthesis: opportunities for the next decade", + "abstract": "Program synthesis is the contemporary answer to automatic programming. It innovates in two ways: First, it replaces batch automation with interactivity, assisting the programmer in refining the understanding of the programming problem. Second, it produces programs using search in a candidate space rather than by derivation from a specification. Searching for an acceptable program means that we can accommodate incomplete specifications, such as examples. Additionally, search makes synthesis applicable to domains that lack correct-by-construction derivation rules, such as hardware design, education, end-user programming, and systems biology. The future of synthesis rests on four challenges, each presenting an opportunity to develop novel abstractions for \"programming with search.\" Larger scope: today, we synthesize small, flat programs; synthesis of large software will need constructs for modularity and stepwise refinement. New interaction modes: to solicit the specification without simply asking for more examples, we need to impose a structure on the candidate space and explore it in a dialogue. Construction: how to compile a synthesis problem to a search algorithm without building a compiler? Everything is a program: whatever can be phrased as a program can be in principle synthesized. Indeed, we will see synthesis advance from synthesis of plain programs to synthesis of compilers and languages. The latter may include DSLs, type systems, and modeling languages for biology. As such, synthesis could help mechanize the crown jewel of programming languages research --- the design of abstractions --- which has so far been done manually and only by experts.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2789052", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/icfp/Bodik15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784737", + "title": "Blame assignment for higher-order contracts with intersection and union", + "abstract": "We present an untyped calculus of blame assignment for a higher-order contract system with two new operators: intersection and union. The specification of these operators is based on the corresponding type theoretic constructions. This connection makes intersection and union contracts their inevitable dynamic counterparts with a range of desirable properties and makes them suitable for subsequent integration in a gradual type system. A denotational specification provides the semantics of a contract in terms of two sets: a set of terms satisfying the contract and a set of contexts respecting the contract. This kind of specification for contracts is novel and interesting in its own right. A nondeterministic operational semantics serves as the specification for contract monitoring and for proving its correctness. It is complemented by a deterministic semantics that is closer to an implementation and that is connected to the nondeterministic semantics by simulation. The calculus is the formal basis of TJS, a language embedded, higher-order contract system implemented for JavaScript.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784737", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthias S.", + "last_name": "Keil", + "institution": "University of Freiburg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/icfp/KeilT15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784733", + "title": "Noninterference for free", + "abstract": "The dependency core calculus (DCC) is a framework for studying a variety of dependency analyses (e.g., secure information flow). The key property provided by DCC is noninterference, which guarantees that a low-level observer (attacker) cannot distinguish high-level (protected) computations. The proof of noninterference for DCC suggests a connection to parametricity in System F, which suggests that it should be possible to implement dependency analyses in languages with parametric polymorphism. We present a translation from DCC into Fω and prove that the translation preserves noninterference. To express noninterference in Fω, we define a notion of observer-sensitive equivalence that makes essential use of both first-order and higher-order polymorphism. Our translation provides insights into DCC's type system and shows how DCC can be implemented in a polymorphic language without loss of the noninterference (security) guarantees available in DCC. Our contributions include proof techniques that should be valuable when proving other secure compilation or full abstraction results.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784733", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/BowmanA15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784759", + "title": "Algebras and coalgebras in the light affine Lambda calculus", + "abstract": "Algebra and coalgebra are widely used to model data types in functional programming languages and proof assistants. Their use permits to better structure the computations and also to enhance the expressivity of a language or of a proof system. Interestingly, parametric polymorphism à la System F provides a way to encode algebras and coalgebras in strongly normalizing languages without losing the good logical properties of the calculus. Even if these encodings are sometimes unsatisfying because they provide only limited forms of algebras and coalgebras, they give insights on the expressivity of System F in terms of functions that we can program in it. With the goal of contributing to a better understanding of the expressivity of Implicit Computational Complexity systems, we study the problem of defining algebras and coalgebras in the Light Affine Lambda Calculus, a system characterizing the complexity class FPTIME. This system limits the computational complexity of programs but it also limits the ways we can use parametric polymorphism, and in general the way we can write our programs. We show here that while the restrictions imposed by the Light Affine Lambda Calculus pose some issues to the standard System F encodings, they still permit to encode some form of algebra and coalgebra. Using the algebra encoding one can define in the Light Affine Lambda Calculus the traditional inductive types. Unfortunately, the corresponding coalgebra encoding permits only a very limited form of coinductive data types. To extend this class we study an extension of the Light Affine Lambda Calculus by distributive laws for the modality §. This extension has been discussed but not studied before.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784759", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University of Dundee" + }, + { + "first_name": "Romain", + "last_name": "Péchoux", + "institution": "Université de Lorraine" + } + ], + "dblp_key": "conf/icfp/GaboardiP15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784746", + "title": "XQuery and static typing: tackling the problem of backward axes", + "abstract": "Abstract. XQuery is a functional language dedicated to XML data querying and manipulation. As opposed to other W3C-standardized languages for XML (e.g. XSLT), it has been intended to feature strong static typing. Currently, however, some expressions of the language cannot be statically typed with any precision. We argue that this is due to a discrepancy between the semantics of the language and its type algebra: namely, the values of the language are (possibly inner) tree nodes, which may have siblings and ancestors in the data. The types on the other hand are regular tree types, as usual in the XML world: they describe sets of trees. The type associated to a node then corresponds to the subtree whose root is that node and contains no information about the rest of the data. This makes navigational expressions using ‘backward axes,’ which return e.g. the siblings of a node, impossible to type. We discuss how to solve this discrepancy and propose a compromise: to use extended types representing possibly inner tree nodes in some key parts of a program, and to cut out the subtrees from their original context in the rest. 1", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784746", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Genevès", + "institution": "Université Grenoble Alpes" + }, + { + "first_name": "Nils", + "last_name": "Gesbert", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/GenevesG15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784741", + "title": "An optimizing compiler for a purely functional web-application language", + "abstract": "High-level scripting languages have become tremendously popular for development of dynamic Web applications. Many programmers appreciate the productivity benefits of automatic storage management, freedom from verbose type annotations, and so on. While it is often possible to improve performance substantially by rewriting an application in C or a similar language, very few programmers bother to do so, because of the consequences for human development effort. This paper describes a compiler that makes it possible to have most of the best of both worlds, coding Web applications in a high-level language but compiling to native code with performance comparable to handwritten C code. The source language is Ur/Web, a domain-specific, purely functional, statically typed language for the Web. Through a coordinated suite of relatively straightforward program analyses and algebraic optimizations, we transform Ur/Web programs into almost-idiomatic C code, with no garbage collection, little unnecessary memory allocation for intermediate values, etc. Our compiler is in production use for commercial Web sites supporting thousands of users, and microbenchmarks demonstrate very competitive performance versus mainstream tools.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784741", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/icfp/Chlipala15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784740", + "title": "Pycket: a tracing JIT for a functional language", + "abstract": "We present Pycket, a high-performance tracing JIT compiler for Racket. Pycket supports a wide variety of the sophisticated features in Racket such as contracts, continuations, classes, structures, dynamic binding, and more. On average, over a standard suite of benchmarks, Pycket outperforms existing compilers, both Racket's JIT and other highly-optimizing Scheme compilers. Further, Pycket provides much better performance for Racket proxies than existing systems, dramatically reducing the overhead of contracts and gradual typing. We validate this claim with performance evaluation on multiple existing benchmark suites. The Pycket implementation is of independent interest as an application of the RPython meta-tracing framework (originally created for PyPy), which automatically generates tracing JIT compilers from interpreters. Prior work on meta-tracing focuses on bytecode interpreters, whereas Pycket is a high-level interpreter based on the CEK abstract machine and operates directly on abstract syntax trees. Pycket supports proper tail calls and first-class continuations. In the setting of a functional language, where recursion and higher-order functions are more prevalent than explicit loops, the most significant performance challenge for a tracing JIT is identifying which control flows constitute a loop---we discuss two strategies for identifying loops and measure their impact.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784740", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Spenser", + "last_name": "Bauman", + "institution": "Indiana University" + }, + { + "first_name": "Carl Friedrich", + "last_name": "Bolz", + "institution": "King's College London" + }, + { + "first_name": "Robert", + "last_name": "Hirschfeld", + "institution": "" + }, + { + "first_name": "Vasily", + "last_name": "Kirilichev", + "institution": "" + }, + { + "first_name": "Tobias", + "last_name": "Pape", + "institution": "" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/BaumanBHKPST15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784762", + "title": "Structures for structural recursion", + "abstract": "Our goal is to develop co-induction from our understanding of induction, putting them on level ground as equal partners for reasoning about programs. We investigate several structures which represent well-founded forms of recursion in programs. These simple structures encapsulate reasoning by primitive and noetherian induction principles, and can be composed together to form complex recursion schemes for programs operating over a wide class of data and co-data types. At its heart, this study is guided by duality: each structure for recursion has a dual form, giving perfectly symmetric pairs of equal and opposite data and co-data types for representing recursion in programs. Duality is brought out through a framework presented in sequent style, which inherently includes control effects that are interpreted logically as classical reasoning principles. To accommodate the presence of effects, we give a calculus parameterized by a notion of strategy, which is strongly normalizing for a wide range of strategies. We also present a more traditional calculus for representing effect-free functional programs, but at the cost of losing some of the founding dualities.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784762", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Downen", + "institution": "University of Oregon" + }, + { + "first_name": "Philip", + "last_name": "Johnson-Freyd", + "institution": "University of Oregon" + }, + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/icfp/DownenJA15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784747", + "title": "Certified symbolic management of financial multi-party contracts", + "abstract": "Domain-specific languages (DSLs) for complex financial contracts are in practical use in many banks and financial institutions today. Given the level of automation and pervasiveness of software in the sector, the financial domain is immensely sensitive to software bugs. At the same time, there is an increasing need to analyse (and report on) the interaction between multiple parties. In this paper, we present a multi-party contract language that rigorously relegates any artefacts of simulation and computation from its core, which leads to favourable algebraic properties, and therefore allows for formalising domain-specific analyses and transformations using a proof assistant. At the centre of our formalisation is a simple denotational semantics independent of any stochastic aspects. Based on this semantics, we devise certified contract analyses and transformations. In particular, we give a type system, with an accompanying type inference procedure, that statically ensures that contracts follow the principle of causality. Moreover, we devise a reduction semantics that allows us to evolve contracts over time, in accordance with the denotational semantics. From the verified Coq definitions, we automatically extract a Haskell implementation of an embedded contract DSL along with the formally verified contract management functionality. This approach opens a road map towards more reliable contract management software, including the possibility of analysing contracts based on symbolic instead of numeric methods.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784747", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Bahr", + "institution": "University of Copenhagen" + }, + { + "first_name": "Jost", + "last_name": "Berthold", + "institution": "Reserve Bank of Australia" + }, + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/icfp/BahrBE15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784749", + "title": "Denotational cost semantics for functional languages with inductive types", + "abstract": "A central method for analyzing the asymptotic complexity of a functional program is to extract and then solve a recurrence that expresses evaluation cost in terms of input size. The relevant notion of input size is often specific to a datatype, with measures including the length of a list, the maximum element in a list, and the height of a tree. In this work, we give a formal account of the extraction of cost and size recurrences from higher-order functional programs over inductive datatypes. Our approach allows a wide range of programmer-specified notions of size, and ensures that the extracted recurrences correctly predict evaluation cost. To extract a recurrence from a program, we first make costs explicit by applying a monadic translation from the source language to a complexity language, and then abstract datatype values as sizes. Size abstraction can be done semantically, working in models of the complexity language, or syntactically, by adding rules to a preorder judgement. We give several different models of the complexity language, which support different notions of size. Additionally, we prove by a logical relations argument that recurrences extracted by this process are upper bounds for evaluation cost; the proof is entirely syntactic and therefore applies to all of the models we consider.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784749", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Norman", + "last_name": "Danner", + "institution": "Wesleyan University" + }, + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Wesleyan University" + }, + { + "first_name": "Ramyaa", + "last_name": "Ramyaa", + "institution": "Wesleyan University" + } + ], + "dblp_key": "conf/icfp/DannerLR15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784753", + "title": "Analysing the complexity of functional programs: higher-order meets first-order", + "abstract": "We show how the complexity of higher-order functional programs can be analysed automatically by applying program transformations to a defunctionalised versions of them, and feeding the result to existing tools for the complexity analysis of first-order term rewrite systems. This is done while carefully analysing complexity preservation and reflection of the employed transformations such that the complexity of the obtained term rewrite system reflects on the complexity of the initial program. Further, we describe suitable strategies for the application of the studied transformations and provide ample experimental data for assessing the viability of our method.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784753", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Avanzini", + "institution": "University of Bologna" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Georg", + "last_name": "Moser", + "institution": "Universität Innsbruck" + } + ], + "dblp_key": "conf/icfp/AvanziniLM15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784743", + "title": "Functional pearl: a smart view on datatypes", + "abstract": "Left-nested list concatenations, left-nested binds on the free monad, and left-nested choices in many non-determinism monads have an algorithmically bad performance. Can we solve this problem without losing the ability to pattern-match on the computation? Surprisingly, there is a deceptively simple solution: use a smart view to pattern-match on the datatype. We introduce the notion of smart view and show how it solves the problem of slow left-nested operations. In particular, we use the technique to obtain fast and simple implementations of lists, of free monads, and of two non-determinism monads.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784743", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mauro", + "last_name": "Jaskelioff", + "institution": "Consejo Nacional de Investigaciones Científicas y Técnicas" + }, + { + "first_name": "Exequiel", + "last_name": "Rivas", + "institution": "Centro Internacional Franco-Argentino de Ciencias de la Información y de Sistemas" + } + ], + "dblp_key": "conf/icfp/JaskelioffR15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784758", + "title": "HLIO: mixing static and dynamic typing for information-flow control in Haskell", + "abstract": "Information-Flow Control (IFC) is a well-established approach for allowing untrusted code to manipulate sensitive data without disclosing it. IFC is typically enforced via type systems and static analyses or via dynamic execution monitors. The LIO Haskell library, originating in operating systems research, implements a purely dynamic monitor of the sensitivity level of a computation, particularly suitable when data sensitivity levels are only known at runtime. In this paper, we show how to give programmers the flexibility of deferring IFC checks to runtime (as in LIO), while also providing static guarantees---and the absence of runtime checks---for parts of their programs that can be statically verified (unlike LIO). We present the design and implementation of our approach, HLIO (Hybrid LIO), as an embedding in Haskell that uses a novel technique for deferring IFC checks based on singleton types and constraint polymorphism. We formalize HLIO, prove non-interference, and show how interesting IFC examples can be programmed. Although our motivation is IFC, our technique for deferring constraints goes well beyond and offers a methodology for programmer-controlled hybrid type checking in Haskell.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784758", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pablo", + "last_name": "Buiras", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Alejandro", + "last_name": "Russo", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/BuirasVR15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784748", + "title": "GADTs meet their match: pattern-matching warnings that account for GADTs, guards, and laziness", + "abstract": "For ML and Haskell, accurate warnings when a function definition has redundant or missing patterns are mission critical. But today's compilers generate bogus warnings when the programmer uses guards (even simple ones), GADTs, pattern guards, or view patterns. We give the first algorithm that handles all these cases in a single, uniform framework, together with an implementation in GHC, and evidence of its utility in practice.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784748", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Georgios", + "last_name": "Karachalias", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/icfp/KarachaliasSVJ15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784732", + "title": "Foundational extensible corecursion: a proof assistant perspective", + "abstract": "This paper presents a formalized framework for defining corecursive functions safely in a total setting, based on corecursion up-to and relational parametricity. The end product is a general corecursor that allows corecursive (and even recursive) calls under \"friendly\" operations, including constructors. Friendly corecursive functions can be registered as such, thereby increasing the corecursor's expressiveness. The metatheory is formalized in the Isabelle proof assistant and forms the core of a prototype tool. The corecursor is derived from first principles, without requiring new axioms or extensions of the logic.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784732", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jasmin Christian", + "last_name": "Blanchette", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "Middlesex University" + }, + { + "first_name": "Dmitriy", + "last_name": "Traytel", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Blanchette0T15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784744", + "title": "Elaborating evaluation-order polymorphism", + "abstract": "We classify programming languages according to evaluation order: each language fixes one evaluation order as the default, making it transparent to program in that evaluation order, and troublesome to program in the other. This paper develops a type system that is impartial with respect to evaluation order. Evaluation order is implicit in terms, and explicit in types, with by-value and by-name versions of type connectives. A form of intersection type quantifies over evaluation orders, describing code that is agnostic over (that is, polymorphic in) evaluation order. By allowing such generic code, programs can express the by-value and by-name versions of a computation without code duplication. We also formulate a type system that only has by-value connectives, plus a type that generalizes the difference between by-value and by-name connectives: it is either a suspension (by name) or a \"no-op\" (by value). We show a straightforward encoding of the impartial type system into the more economical one. Then we define an elaboration from the economical language to a call-by-value semantics, and prove that elaborating a well-typed source program, where evaluation order is implicit, produces a well-typed target program where evaluation order is explicit. We also prove a simulation between evaluation of the target program and reductions (either by-value or by-name) in the source program. Finally, we prove that typing, elaboration, and evaluation are faithful to the type annotations given in the source program: if the programmer only writes by-value types, no by-name reductions can occur at run time.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784744", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/icfp/Dunfield15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784736", + "title": "Partial aborts for transactions via first-class continuations", + "abstract": "Software transactional memory (STM) has proven to be a useful abstraction for developing concurrent applications, where programmers denote transactions with an atomic construct that delimits a collection of reads and writes to shared mutable references. The runtime system then guarantees that all transactions are observed to execute atomically with respect to each other. Traditionally, when the runtime system detects that one transaction conflicts with another, it aborts one of the transactions and restarts its execution from the beginning. This can lead to problems with both execution time and throughput. In this paper, we present a novel approach that uses first-class continuations to restart a conflicting transaction at the point of a conflict, avoiding the re-execution of any work from the beginning of the transaction that has not been compromised. In practice, this allows transactions to complete more quickly, decreasing execution time and increasing throughput. We have implemented this idea in the context of the Manticore project, an ML-family language with support for parallelism and concurrency. Crucially, we rely on constant-time continuation capturing via a continuation-passing-style (CPS) transformation and heap-allocated continuations. When comparing our STM that performs partial aborts against one that performs full aborts, we achieve a decrease in execution time of up to 31% and an increase in throughput of up to 351%.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784736", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Le", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Rochester Institute of Technology" + } + ], + "dblp_key": "conf/icfp/LeF15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784764", + "title": "Pilsner: a compositionally verified compiler for a higher-order imperative language", + "abstract": "Compiler verification is essential for the construction of fully verified software, but most prior work (such as CompCert) has focused on verifying whole-program compilers. To support separate compilation and to enable linking of results from different verified compilers, it is important to develop a compositional notion of compiler correctness that is modular (preserved under linking), transitive (supports multi-pass compilation), and flexible (applicable to a wide variety of languages and program transformations). In this work, building on prior work of Hur et al. [6, 7], we develop a novel approach to compositional compiler verification based on parametric inter-language simulations (PILS). PILS are as modular and flexible as state-of-the-art logical-relations models, but are transitive as well. We demonstrate the effectiveness of PILS by using them to verify Pilsner, a simple but non-trivial multi-pass optimizing compiler for an ML-like language programmed in Coq. Pilsner is the first compiler for a higher-order imperative language to be compositionally and mechanically verified. This has been a significant undertaking, involving several person-years of work and over 48,000 lines of Coq. 1.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784764", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Georg", + "last_name": "Neis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Jan-Oliver", + "last_name": "Kaiser", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Craig", + "last_name": "McLaughlin", + "institution": "University of Glasgow" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/NeisHKMDV15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784750", + "title": "Applicative bidirectional programming with lenses", + "abstract": "A bidirectional transformation is a pair of mappings between source and view data objects, one in each direction. When the view is modified, the source is updated accordingly with respect to some laws. One way to reduce the development and maintenance effort of bidirectional transformations is to have specialized languages in which the resulting programs are bidirectional by construction---giving rise to the paradigm of bidirectional programming. In this paper, we develop a framework for applicative-style and higher-order bidirectional programming, in which we can write bidirectional transformations as unidirectional programs in standard functional languages, opening up access to the bundle of language features previously only available to conventional unidirectional languages. Our framework essentially bridges two very different approaches of bidirectional programming, namely the lens framework and Voigtländer's semantic bidirectionalization, creating a new programming style that is able to bag benefits from both.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784750", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/icfp/MatsudaW15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784734", + "title": "Adaptive lock-free maps: purely-functional to scalable", + "abstract": "Purely functional data structures stored inside a mutable variable provide an excellent concurrent data structure—obviously correct, cheap to create, and supporting snapshots. They are not, however, scalable. We provide a way to retain the benefits of these pure-in-a-box data structures while dynamically converting to a more scalable lock-free data structure under contention. Our solution scales to any pair of pure and lock-free container types with key/value set semantics, while retaining lock-freedom. We demonstrate the principle in action on two very different platforms: first in the Glasgow Haskell Compiler and second in Java. To this end we extend GHC to support lock-free data structures and introduce a new approach for safe CAS in a lazy language.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784734", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + }, + { + "first_name": "Peter", + "last_name": "Fogg", + "institution": "Indiana University" + }, + { + "first_name": "Ali", + "last_name": "Varamesh", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/NewtonFV15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784765", + "title": "Practical SMT-based type error localization", + "abstract": "Compilers for statically typed functional programming languages are notorious for generating confusing type error messages. When the compiler detects a type error, it typically reports the program location where the type checking failed as the source of the error. Since other error sources are not even considered, the actual root cause is often missed. A more adequate approach is to consider all possible error sources and report the most useful one subject to some usefulness criterion. In our previous work, we showed that this approach can be formulated as an optimization problem related to satisfiability modulo theories (SMT). This formulation cleanly separates the heuristic nature of usefulness criteria from the underlying search problem. Unfortunately, algorithms that search for an optimal error source cannot directly use principal types which are crucial for dealing with the exponential-time complexity of the decision problem of polymorphic type checking. In this paper, we present a new algorithm that efficiently finds an optimal error source in a given ill-typed program. Our algorithm uses an improved SMT encoding to cope with the high complexity of polymorphic typing by iteratively expanding the typing constraints from which principal types are derived. The algorithm preserves the clean separation between the heuristics and the actual search. We have implemented our algorithm for OCaml. In our experimental evaluation, we found that the algorithm reduces the running times for optimal type error localization from minutes to seconds and scales better than previous localization algorithms.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784765", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zvonimir", + "last_name": "Pavlinovic", + "institution": "New York University" + }, + { + "first_name": "Tim L.", + "last_name": "King", + "institution": "Verimag" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "conf/icfp/Pavlinovic0W15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784752", + "title": "Practical principled FRP: forget the past, change the future, FRPNow!", + "abstract": "We present a new interface for practical Functional Reactive Programming (FRP) that (1) is close in spirit to the original FRP ideas, (2) does not have the original space-leak problems, without using arrows or advanced types, and (3) provides a simple and expressive way for performing IO actions from FRP code. We also provide a denotational semantics for this new interface, and a technique (using Kripke logical relations) for reasoning about which FRP functions may \"forget their past\", i.e. which functions do not have an inherent space-leak. Finally, we show how we have implemented this interface as a Haskell library called FRPNow.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784752", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Atze van der", + "last_name": "Ploeg", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/PloegC15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784757", + "title": "Which simple types have a unique inhabitant?", + "abstract": "We study the question of whether a given type has a unique inhabitant modulo program equivalence. In the setting of simply-typed lambda-calculus with sums, equipped with the strong --equivalence, we show that uniqueness is decidable. We present a saturating focused logic that introduces irreducible cuts on positive types ``as soon as possible''. Backward search in this logic gives an effective algorithm that returns either zero, one or two distinct inhabitants for any given type. Preliminary application studies show that such a feature can be useful in strongly-typed programs, inferring the code of highly-polymorphic library functions, or ``glue code'' inside more complex terms.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784757", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/SchererR15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784763", + "title": "Automatic refunctionalization to a language with copattern matching: with applications to the expression problem", + "abstract": "Defunctionalization and refunctionalization establish a correspondence between first-class functions and pattern matching, but the correspondence is not symmetric: Not all uses of pattern matching can be automatically refunctionalized to uses of higher-order functions. To remedy this asymmetry, we generalize from first-class functions to arbitrary codata. This leads us to full defunctionalization and refunctionalization between a codata language based on copattern matching and a data language based on pattern matching. We observe how programs can be written as matrices so that they are modularly extensible in one dimension but not the other. In this representation, defunctionalization and refunctionalization correspond to matrix transposition which effectively changes the dimension of extensibility a program supports. This suggests applications to the expression problem.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784763", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tillmann", + "last_name": "Rendel", + "institution": "University of Tübingen" + }, + { + "first_name": "Julia", + "last_name": "Trieflinger", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/icfp/RendelTO15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784756", + "title": "Functional pearl: two can keep a secret, if one of them uses Haskell", + "abstract": "For several decades, researchers from different communities have independently focused on protecting confidentiality of data. Two distinct technologies have emerged for such purposes: Mandatory Access Control (MAC) and Information-Flow Control (IFC)—the former belonging to operating systems (OS) research, while the latter to the programming languages community. These approaches restrict how data gets propagated within a system in order to avoid information leaks. In this scenario, Haskell plays a unique privileged role: it is able to protect confidentiality via libraries. This pearl presents a monadic API which statically protects confidentiality even in the presence of advanced features like exceptions, concurrency, and mutable data structures. Additionally, we present a mechanism to safely extend the library with new primitives, where library designers only need to indicate the read and write effects of new operations.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784756", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Russo", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/Russo15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784761", + "title": "A fast compiler for NetKAT", + "abstract": "High-level programming languages play a key role in a growing number of networking platforms, streamlining application development and enabling precise formal reasoning about network behavior. Unfortunately, current compilers only handle \"local\" programs that specify behavior in terms of hop-by-hop forwarding behavior, or modest extensions such as simple paths. To encode richer \"global\" behaviors, programmers must add extra state -- something that is tricky to get right and makes programs harder to write and maintain. Making matters worse, existing compilers can take tens of minutes to generate the forwarding state for the network, even on relatively small inputs. This forces programmers to waste time working around performance issues or even revert to using hardware-level APIs. This paper presents a new compiler for the NetKAT language that handles rich features including regular paths and virtual networks, and yet is several orders of magnitude faster than previous compilers. The compiler uses symbolic automata to calculate the extra state needed to implement \"global\" programs, and an intermediate representation based on binary decision diagrams to dramatically improve performance. We describe the design and implementation of three essential compiler stages: from virtual programs (which specify behavior in terms of virtual topologies) to global programs (which specify network-wide behavior in terms of physical topologies), from global programs to local programs (which specify behavior in terms of single-switch behavior), and from local programs to hardware-level forwarding tables. We present results from experiments on real-world benchmarks that quantify performance in terms of compilation time and forwarding table size.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784761", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Steffen", + "last_name": "Smolka", + "institution": "Cornell University" + }, + { + "first_name": "Spiridon", + "last_name": "Eliopoulos", + "institution": "American Type Culture Collection" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/icfp/SmolkaEFG15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784760", + "title": "Functional pearl: a SQL to C compiler in 500 lines of code", + "abstract": "We present the design and implementation of a SQL query processor that outperforms existing database systems and is written in just about 500 lines of Scala code -- a convincing case study that high-level functional programming can handily beat C for systems-level programming where the last drop of performance matters. The key enabler is a shift in perspective towards generative programming. The core of the query engine is an interpreter for relational algebra operations, written in Scala. Using the open-source LMS Framework (Lightweight Modular Staging), we turn this interpreter into a query compiler with very low effort. To do so, we capitalize on an old and widely known result from partial evaluation known as Futamura projections, which state that a program that can specialize an interpreter to any given input program is equivalent to a compiler. In this pearl, we discuss LMS programming patterns such as mixed-stage data structures (e.g. data records with static schema and dynamic field components) and techniques to generate low-level C code, including specialized data structures and data loading primitives.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784760", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/icfp/RompfA15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784754", + "title": "Generating performance portable code using rewrite rules: from high-level functional expressions to high-performance OpenCL code", + "abstract": "Computers have become increasingly complex with the emergence of heterogeneous hardware combining multicore CPUs and GPUs. These parallel systems exhibit tremendous computational power at the cost of increased programming effort resulting in a tension between performance and code portability. Typically, code is either tuned in a low-level imperative language using hardware-specific optimizations to achieve maximum performance or is written in a high-level, possibly functional, language to achieve portability at the expense of performance. We propose a novel approach aiming to combine high-level programming, code portability, and high-performance. Starting from a high-level functional expression we apply a simple set of rewrite rules to transform it into a low-level functional representation, close to the OpenCL programming model, from which OpenCL code is generated. Our rewrite rules define a space of possible implementations which we automatically explore to generate hardware-specific OpenCL implementations. We formalize our system with a core dependently-typed lambda-calculus along with a denotational semantics which we use to prove the correctness of the rewrite rules. We test our design in practice by implementing a compiler which generates high performance imperative OpenCL code. Our experiments show that we can automatically derive hardware-specific implementations from simple functional high-level algorithmic expressions offering performance on a par with highly tuned code for multicore CPUs and GPUs written by experts.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784754", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "University of Münster" + }, + { + "first_name": "Christian", + "last_name": "Fensch", + "institution": "Heriot-Watt University" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "Christophe", + "last_name": "Dubach", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/SteuwerFLD15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784738", + "title": "1ML - core and modules united (F-ing first-class modules)", + "abstract": "ML is two languages in one: there is the core, with types and expressions, and there are modules, with signatures, structures and functors. Modules form a separate, higher-order functional language on top of the core. There are both practical and technical reasons for this stratification; yet, it creates substantial duplication in syntax and semantics, and it reduces expressiveness. For example, selecting a module cannot be made a dynamic decision. Language extensions allowing modules to be packaged up as first-class values have been proposed and implemented in different variations. However, they remedy expressiveness only to some extent, are syntactically cumbersome, and do not alleviate redundancy. We propose a redesign of ML in which modules are truly first-class values, and core and module layer are unified into one language. In this \"1ML\", functions, functors, and even type constructors are one and the same construct; likewise, no distinction is made between structures, records, or tuples. Or viewed the other way round, everything is just (\"a mode of use of\") modules. Yet, 1ML does not require dependent types, and its type structure is expressible in terms of plain System Fω, in a minor variation of our F-ing modules approach. We introduce both an explicitly typed version of 1ML, and an extension with Damas/Milner-style implicit quantification. Type inference for this language is not complete, but, we argue, not substantially worse than for Standard ML. An alternative view is that 1ML is a user-friendly surface syntax for System Fω that allows combining term and type abstraction in a more compositional manner than the bare calculus.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784738", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "" + } + ], + "dblp_key": "conf/icfp/Rossberg15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784755", + "title": "Hygienic resugaring of compositional desugaring", + "abstract": "Syntactic sugar is widely used in language implementation. Its benefits are, however, offset by the comprehension problems it presents to programmers once their program has been transformed. In particular, after a transformed program has begun to evaluate (or otherwise be altered by a black-box process), it can become unrecognizable. We present a new approach to _resugaring_ programs, which is the act of reflecting evaluation steps in the core language in terms of the syntactic sugar that the programmer used. Relative to prior work, our approach has two important advances: it handles hygiene, and it allows almost arbitrary rewriting rules (as opposed to restricted patterns). We do this in the context of a DAG representation of programs, rather than more traditional trees.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784755", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Justin", + "last_name": "Pombrio", + "institution": "Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "conf/icfp/PombrioK15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784739", + "title": "RRB vector: a practical general purpose immutable sequence", + "abstract": "State-of-the-art immutable collections have wildly differing performance characteristics across their operations, often forcing programmers to choose different collection implementations for each task. Thus, changes to the program can invalidate the choice of collections, making code evolution costly. It would be desirable to have a collection that performs well for a broad range of operations. To this end, we present the RRB-Vector, an immutable sequence collection that offers good performance across a large number of sequential and parallel operations. The underlying innovations are: (1) the Relaxed-Radix-Balanced (RRB) tree structure, which allows efficient structural reorganization, and (2) an optimization that exploits spatio-temporal locality on the RRB data structure in order to offset the cost of traversing the tree. In our benchmarks, the RRB-Vector speedup for parallel operations is lower bounded by 7x when executing on 4 CPUs of 8 cores each. The performance for discrete operations, such as appending on either end, or updating and removing elements, is consistently good and compares favorably to the most important immutable sequence collections in the literature and in use today. The memory footprint of RRB-Vector is on par with arrays and an order of magnitude less than competing collections.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784739", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Stucki", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Vlad", + "last_name": "Ureche", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Phil", + "last_name": "Bagwell", + "institution": "" + } + ], + "dblp_key": "conf/icfp/StuckiRUB15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784745", + "title": "Bounded refinement types", + "abstract": "We present a notion of bounded quantification for refinement types and show how it expands the expressiveness of refinement typing by using it to develop typed combinators for: (1) relational algebra and safe database access, (2) Floyd-Hoare logic within a state transformer monad equipped with combinators for branching and looping, and (3) using the above to implement a refined IO monad that tracks capabilities and resource usage. This leap in expressiveness comes via a translation to ``ghost\" functions, which lets us retain the automated and decidable SMT based checking and inference that makes refinement typing effective in practice.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784745", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "University of California, San Diego" + }, + { + "first_name": "Alexander", + "last_name": "Bakst", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/icfp/VazouBJ15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2789053", + "title": "Functional programming and hardware design: still interesting after all these years", + "abstract": "Higher order functions provide an elegant way to express algorithms designed for implementation in hardware. By showing examples of both classic and new algorithms, I will explain why higher order functions deserve to be studied. Next, I will consider the extent to which ideas from functional programming, and associated formal verification methods, have influenced hardware design in practice. What can we learn from looking back? You might ask \"Why are methods of hardware design still important to our community?\". Maybe we should just give up? One reason for not giving up is that hardware design is really a form of parallel programming. And here there is still a lot to do! Inspired by Blelloch's wonderful invited talk at ICFP 2010, I still believe that functional programming has much to offer in the central question of how to program the parallel machines of today, and, more particularly, of the future. I will briefly present some of the areas where I think that we are poised to make great contributions. But maybe we need to work harder on getting our act together?", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2789053", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mary", + "last_name": "Sheeran", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/icfp/Sheeran15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784742", + "title": "Expressing contract monitors as patterns of communication", + "abstract": "We present a new approach to contract semantics which expresses myriad monitoring strategies using a small core of foundational communication primitives. This approach allows multiple existing contract monitoring approaches, ranging from Findler and Felleisen’s original model of higher-order contracts to semi-eager, parallel, or asynchronous monitors, to be expressed in a single language built on well-understood constructs. We prove that this approach accurately simulates the original semantics of higher-order contracts. A straightforward implementation in Racket demonstrates the practicality of our approach which not only enriches existing Racket monitoring strategies, but also support a new style of monitoring in which collections of contracts collaborate to establish a global invariant.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784742", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cameron", + "last_name": "Swords", + "institution": "Indiana University" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/SwordsST15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784735", + "title": "Efficient communication and collection with compact normal forms", + "abstract": "In distributed applications, the transmission of non-contiguous data structures is greatly slowed down by the need to serialize them into a buffer before sending. We describe Compact Normal Forms, an API that allows programmers to explicitly place immutable heap objects into regions, which can both be accessed like ordinary data as well as efficiently transmitted over the network. The process of placing objects into compact regions (essentially a copy) is faster than any serializer and can be amortized over a series of functional updates to the data structure in question. We implement this scheme in the Glasgow Haskell Compiler and show that even with the space expansion attendant with memory-oriented data structure representations, we achieve between x2 and x4 speedups on fast local networks with sufficiently large data structures.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784735", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Edward Z.", + "last_name": "Yang", + "institution": "Stanford University" + }, + { + "first_name": "Giovanni", + "last_name": "Campagna", + "institution": "Stanford University" + }, + { + "first_name": "Ömer S.", + "last_name": "Ağacan", + "institution": "Indiana University" + }, + { + "first_name": "Ahmed", + "last_name": "El-Hassany", + "institution": "Indiana University" + }, + { + "first_name": "Abhishek", + "last_name": "Kulkarni", + "institution": "Indiana University" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/YangCAEKN15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784766", + "title": "Learning refinement types", + "abstract": "We propose the integration of a random test generation system (capable of discovering program bugs) and a refinement type system (capable of expressing and verifying program invariants), for higher-order functional programs, using a novel lightweight learning algorithm as an effective intermediary between the two. Our approach is based on the well-understood intuition that useful, but difficult to infer, program properties can often be observed from concrete program states generated by tests; these properties act as likely invariants, which if used to refine simple types, can have their validity checked by a refinement type checker. We describe an implementation of our technique for a variety of benchmarks written in ML, and demonstrate its effectiveness in inferring and proving useful invariants for programs that express complex higher-order control and dataflow.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784766", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "He", + "last_name": "Zhu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/icfp/ZhuNJ15", + "venue": "icfp", + "year": 2015 + }, + { + "paper_id": "10.1145/2784731.2784751", + "title": "A unification algorithm for Coq featuring universe polymorphism and overloading", + "abstract": "Unification is a core component of every proof assistant or programming language featuring dependent types. In many cases, it must deal with higher-order problems up to conversion. Since unification in such conditions is undecidable, unification algorithms may include several heuristics to solve common problems. However, when the stack of heuristics grows large, the result and complexity of the algorithm can become unpredictable. Our contributions are twofold: (1) We present a full description of a new unification algorithm for the Calculus of Inductive Constructions (the base logic of Coq), including universe polymorphism, canonical structures (the overloading mechanism baked into Coq's unification), and a small set of useful heuristics. (2) We implemented our algorithm, and tested it on several libraries, providing evidence that the selected set of heuristics suffices for large developments.", + "date": "2015-08-26", + "link": "https://doi.org/10.1145/2784731.2784751", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Beta", + "last_name": "Ziliani", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/icfp/ZilianiS15", + "venue": "icfp", + "year": 2015 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2016.json b/data/pl_conferences/icfp/2016.json new file mode 100644 index 0000000..a6094c6 --- /dev/null +++ b/data/pl_conferences/icfp/2016.json @@ -0,0 +1,1137 @@ +[ + { + "paper_id": "10.1145/2951913.2976746", + "title": "TensorFlow: learning functions at scale", + "abstract": "TensorFlow is a machine learning system that operates at large scale and in heterogeneous environments. Its computational model is based on dataflow graphs with mutable state. Graph nodes may be mapped to different machines in a cluster, and within each machine to CPUs, GPUs, and other devices. TensorFlow supports a variety of applications, but it particularly targets training and inference with deep neural networks. It serves as a platform for research and for deploying machine learning systems across many areas, such as speech recognition, computer vision, robotics, information retrieval, and natural language processing. In this talk, we describe TensorFlow and outline some of its applications. We also discuss the question of what TensorFlow and deep learning may have to do with functional programming. Although TensorFlow is not purely functional, many of its uses are concerned with optimizing functions (during training), then with applying those functions (during inference). These functions are defined as compositions of simple primitives (as is common in functional programming), with internal data representations that are learned rather than manually designed. TensorFlow is joint work with many other people in the Google Brain team and elsewhere. More information is available at tensorflow.org.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2976746", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/icfp/Abadi16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951943", + "title": "Higher-order ghost state", + "abstract": "The development of concurrent separation logic (CSL) has sparked a long line of work on modular verification of sophisticated concurrent programs. Two of the most important features supported by several existing extensions to CSL are higher-order quantification and custom ghost state. However, none of the logics that support both of these features reap the full potential of their combination. In particular, none of them provide general support for a feature we dub \"higher-order ghost state\": the ability to store arbitrary higher-order separation-logic predicates in ghost variables.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951943", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/0002KBD16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951950", + "title": "A type theory for incremental computational complexity with control flow changes", + "abstract": "Incremental computation aims to speed up re-runs of a program after its inputs have been modified slightly. It works by recording a trace of the program's first run and propagating changes through the trace in incremental runs, trying to re-use as much of the original trace as possible. The recent work CostIt is a type and effect system to establish the time complexity of incremental runs of a program, as a function of input changes. However, CostIt is limited in two ways. First, it prohibits input changes that influence control flow. This makes it impossible to type programs that, for instance, branch on inputs that may change. Second, the soundness of CostIt is proved relative to an abstract cost semantics, but it is unclear how the semantics can be realized.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951950", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ezgi", + "last_name": "Çiçek", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Princeton University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/icfp/CicekP016", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951946", + "title": "Dag-calculus: a calculus for parallel computation", + "abstract": "Increasing availability of multicore systems has led to greater focus on the design and implementation of languages for writing parallel programs. Such languages support various abstractions for parallelism, such as fork-join, async-finish, futures. While they may seem similar, these abstractions lead to different semantics, language design and implementation decisions, and can significantly impact the performance of end-user applications.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951946", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/AcarCRS16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951932", + "title": "Elaborator reflection: extending Idris in Idris", + "abstract": "Many programming languages and proof assistants are defined by elaboration from a high-level language with a great deal of implicit information to a highly explicit core language. In many advanced languages, these elaboration facilities contain powerful tools for program construction, but these tools are rarely designed to be repurposed by users. We describe elaborator reflection, a paradigm for metaprogramming in which the elaboration machinery is made directly available to metaprograms, as well as a concrete realization of elaborator reflection in Idris, a functional language with full dependent types. We demonstrate the applicability of Idris’s reflected elaboration framework to a number of realistic problems, we discuss the motivation for the specific features of its design, and we explore the broader meaning of elaborator reflection as it can relate to other languages.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951932", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David Thrane", + "last_name": "Christiansen", + "institution": "Indiana University" + }, + { + "first_name": "Edwin", + "last_name": "Brady", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/icfp/ChristiansenB16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951920", + "title": "Farms, pipes, streams and reforestation: reasoning about structured parallel processes using types and hylomorphisms", + "abstract": "The increasing importance of parallelism has motivated the creation of better abstractions for writing parallel software, including structured parallelism using nested algorithmic skeletons. Such approaches provide high-level abstractions that avoid common problems, such as race conditions, and often allow strong cost models to be defined. However, choosing a combination of algorithmic skeletons that yields good parallel speedups for a program on some specific parallel architecture remains a difficult task. In order to achieve this, it is necessary to simultaneously reason both about the costs of different parallel structures and about the semantic equivalences between them. This paper presents a new type-based mechanism that enables strong static reasoning about these properties. We exploit well-known properties of a very general recursion pattern, hylomorphisms, and give a denotational semantics for structured parallel processes in terms of these hylomorphisms. Using our approach, it is possible to determine formally whether it is possible to introduce a desired parallel structure into a program without altering its functional behaviour, and also to choose a version of that parallel structure that minimises some given cost model.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951920", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Castro", + "institution": "University of St Andrews" + }, + { + "first_name": "Kevin", + "last_name": "Hammond", + "institution": "University of St Andrews" + }, + { + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/icfp/CastroHS16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951928", + "title": "Set-theoretic types for polymorphic variants", + "abstract": "Polymorphic variants are a useful feature of the OCaml language whose current definition and implementation rely on kinding constraints to simulate a subtyping relation via unification. This yields an awkward formalization and results in a type system whose behaviour is in some cases unintuitive and/or unduly restrictive.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951928", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Institut de Recherche en Informatique Fondamentale" + }, + { + "first_name": "Tommaso", + "last_name": "Petrucciani", + "institution": "Ingegneria dei Sistemi (Italy)" + }, + { + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Université Paris-Sud" + } + ], + "dblp_key": "conf/icfp/CastagnaP016", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951937", + "title": "An abstract memory functor for verified C static analyzers", + "abstract": "Abstract interpretation provides advanced techniques to infer numerical invariants on programs. There is an abundant literature about numerical abstract domains that operate on scalar variables. This work deals with lifting these techniques to a realistic C memory model. We present an abstract memory functor that takes as argument any standard numerical abstract domain, and builds a memory abstract domain that finely tracks properties about memory contents, taking into account union types, pointer arithmetic and type casts. This functor is implemented and verified inside the Coq proof assistant with respect to the CompCert compiler memory model. Using the Coq extraction mechanism, it is fully executable and used by the Verasco C static analyzer.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951937", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Vincent", + "last_name": "Laporte", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + } + ], + "dblp_key": "conf/icfp/BlazyLP16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951948", + "title": "Datafun: a functional Datalog", + "abstract": "Datalog may be considered either an unusually powerful query language or a carefully limited logic programming language. Datalog is declarative, expressive, and optimizable, and has been applied successfully in a wide variety of problem domains. However, most use-cases require extending Datalog in an application-specific manner. In this paper we define Datafun, an analogue of Datalog supporting higher-order functional programming. The key idea is to track monotonicity with types.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951948", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael", + "last_name": "Arntzenius", + "institution": "University of Birmingham" + }, + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/icfp/ArntzeniusK16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951949", + "title": "All sorts of permutations (functional pearl)", + "abstract": "The combination of non-determinism and sorting is mostly associated with permutation sort, a sorting algorithm that is not very useful for sorting and has an awful running time. In this paper we look at the combination of non-determinism and sorting in a different light: given a sorting function, we apply it to a non-deterministic predicate to gain a function that enumerates permutations of the input list. We get to the bottom of necessary properties of the sorting algorithms and predicates in play as well as discuss variations of the modelled non-determinism. On top of that, we formulate and prove a theorem stating that no matter which sorting function we use, the corresponding permutation function enumerates all permutations of the input list. We use free theorems, which are derived from the type of a function alone, to prove the statement.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951949", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jan", + "last_name": "Christiansen", + "institution": "Flensburg University of Applied Sciences" + }, + { + "first_name": "Nikita", + "last_name": "Danilenko", + "institution": "Kiel University" + }, + { + "first_name": "Sandra", + "last_name": "Dylus", + "institution": "Kiel University" + } + ], + "dblp_key": "conf/icfp/ChristiansenDD16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951933", + "title": "Partial type equivalences for verified dependent interoperability", + "abstract": "Full-spectrum dependent types promise to enable the development of correct-by-construction software. However, even certified software needs to interact with simply-typed or untyped programs, be it to perform system calls, or to use legacy libraries. Trading static guarantees for runtime checks, the dependent interoperability framework provides a mechanism by which simply-typed values can safely be coerced to dependent types and, conversely, dependently-typed programs can defensively be exported to a simply-typed application. In this paper, we give a semantic account of dependent interoperability. Our presentation relies on and is guided by a pervading notion of type equivalence, whose importance has been emphasized in recent work on homotopy type theory. Specifically, we develop the notion of partial type equivalences as a key foundation for dependent interoperability. Our framework is developed in Coq; it is thus constructive and verified in the strictest sense of the terms. Using our library, users can specify domain-specific partial equivalences between data structures. Our library then takes care of the (sometimes, heavy) lifting that leads to interoperable programs. It thus becomes possible, as we shall illustrate, to internalize and hand-tune the extraction of dependently-typed programs to interoperable OCaml programs within Coq itself.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951933", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pierre-Évariste", + "last_name": "Dagand", + "institution": "Laboratoire de Recherche en Informatique de Paris 6" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/icfp/DagandTT16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951917", + "title": "Unifiers as equivalences: proof-relevant unification of dependently typed data", + "abstract": "Dependently typed languages such as Agda, Coq and Idris use a syntactic first-order unification algorithm to check definitions by dependent pattern matching. However, these algorithms don’t adequately consider the types of the terms being unified, leading to various unintended results. As a consequence, they require ad hoc restrictions to preserve soundness, but this makes them very hard to prove correct, modify, or extend.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951917", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jesper", + "last_name": "Cockx", + "institution": "iMinds" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "iMinds" + } + ], + "dblp_key": "conf/icfp/CockxDP16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951931", + "title": "Sequent calculus as a compiler intermediate language", + "abstract": "The λ-calculus is popular as an intermediate language for practical compilers. But in the world of logic it has a lesser-known twin, born at the same time, called the sequent calculus. Perhaps that would make for a good intermediate language, too? To explore this question we designed Sequent Core, a practically-oriented core calculus based on the sequent calculus, and used it to re-implement a substantial chunk of the Glasgow Haskell Compiler.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951931", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Downen", + "institution": "University of Oregon" + }, + { + "first_name": "Luke", + "last_name": "Maurer", + "institution": "University of Oregon" + }, + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "University of Oregon" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/icfp/DownenMAJ16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951942", + "title": "A lambda-calculus foundation for universal probabilistic programming", + "abstract": "We develop the operational semantics of an untyped probabilistic λ-calculus with continuous distributions, and both hard and soft constraints,as a foundation for universal probabilistic programming languages such as Church, Anglican, and Venture. Our first contribution is to adapt the classic operational semantics of λ-calculus to a continuous setting via creating a measure space on terms and defining step-indexed approximations. We prove equivalence of big-step and small-step formulations of this distribution-based semantics. To move closer to inference techniques, we also define the sampling-based semantics of a term as a function from a trace of random samples to a value. We show that the distribution induced by integration over the space of traces equals the distribution-based semantics. Our second contribution is to formalize the implementation technique of trace Markov chain Monte Carlo (MCMC) for our calculus and to show its correctness. A key step is defining sufficient conditions for the distribution induced by trace MCMC to converge to the distribution-based semantics. To the best of our knowledge, this is the first rigorous correctness proof for trace MCMC for a higher-order functional language, or for a language with soft constraints.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951942", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Borgström", + "institution": "Uppsala University" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "University of Edinburgh" + }, + { + "first_name": "Marcin", + "last_name": "Szymczak", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/BorgstromLGS16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951930", + "title": "Oh Lord, please don't let contracts be misunderstood (functional pearl)", + "abstract": "Contracts feel misunderstood, especially those with a higher-order soul. While software engineers appreciate contracts as tools for articulating the interface between components, functional programmers desperately search for their types and meaning, completely forgetting about their pragmatics.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951930", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "" + }, + { + "first_name": "Max S.", + "last_name": "New", + "institution": "" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "" + } + ], + "dblp_key": "conf/icfp/DimoulasNFF16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951934", + "title": "Constructive Galois connections: taming the Galois connection framework for mechanized metatheory", + "abstract": "Galois connections are a foundational tool for structuring abstraction in semantics and their use lies at the heart of the theory of abstract interpretation. Yet, mechanization of Galois connections remains limited to restricted modes of use, preventing their general application in mechanized metatheory and certified programming.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951934", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Darais", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/icfp/DaraisH16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951938", + "title": "Think like a vertex, behave like a function! a functional DSL for vertex-centric big graph processing", + "abstract": "The vertex-centric programming model, known as “think like a vertex”, is being used more and more to support various big graph processing methods through iterative supersteps that execute in parallel a user-defined vertex program over each vertex of a graph. However, the imperative and message-passing style of existing systems makes defining a vertex program unintuitive. In this paper, we show that one can benefit more from “Thinking like a vertex” by “Behaving like a function” rather than “Acting like a procedure” with full use of side effects and explicit control of message passing, state, and termination. We propose a functional approach to vertex-centric graph processing in which the computation at every vertex is abstracted as a higher-order function and present Fregel, a new domain-specific language. Fregel has clear functional semantics, supports declarative description of vertex computation, and can be automatically translated into Pregel, an emerging imperative-style distributed graph processing framework, and thereby achieve promising performance. Experimental results for several typical examples show the promise of this functional approach.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951938", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kento", + "last_name": "Emoto", + "institution": "Kyushu Institute of Technology" + }, + { + "first_name": "Kiminori", + "last_name": "Matsuzaki", + "institution": "Kochi University of Technology" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Akimasa", + "last_name": "Morihata", + "institution": "The University of Tokyo" + }, + { + "first_name": "Hideya", + "last_name": "Iwasaki", + "institution": "University of Electro-Communications" + } + ], + "dblp_key": "conf/icfp/EmotoMHMI16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2976748", + "title": "A functional programmer's guide to homotopy type theory", + "abstract": "Dependent type theories are functional programming languages with types rich enough to do computer-checked mathematics and software verification. Homotopy type theory is a recent area of work that connects dependent type theory to the mathematical disciplines of homotopy theory and higher-dimensional category theory. From a programming point of view, these connections have revealed that all types in dependent type theory support a certain generic program that had not previously been exploited. Specifically, each type can be equipped with computationally relevant witnesses of equality of elements of that type, and all types support a generic program that transports elements along these equalities. One mechanism for equipping types with non-trivial witnesses of equality is Voevodsky’s univalence axiom, which implies that equality of types themselves is witnessed by type isomorphism. Another is higher inductive types, an extended datatype schema that allows identifications between different datatype constructors. While these new mechanisms were originally formulated as axiomatic extensions of type theory, recent work has investigated their computational meaning, leading to the development of new programming languages that better support them. In this talk, I will illustrate what univalence and higher inductive types mean in programming terms. I will also discuss how studying some related semantic settings can reveal additional structure on types; for example, moving from groupoids (categories where all maps are invertible) to general categories yields an account of coercions instead of equalities. Overall, I hope to convey some of the beauty and richness of these connections between disciplines, which we are just beginning to understand.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2976748", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Wesleyan University" + } + ], + "dblp_key": "conf/icfp/Licata16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951939", + "title": "Combining effects and coeffects via grading", + "abstract": "Effects and coeffects are two general, complementary aspects of program behaviour. They roughly correspond to computations which change the execution context (effects) versus computations which make demands on the context (coeffects). Effectful features include partiality, non-determinism, input-output, state, and exceptions. Coeffectful features include resource demands, variable access, notions of linearity, and data input requirements. The effectful or coeffectful behaviour of a program can be captured and described via type-based analyses, with fine grained information provided by monoidal effect annotations and semiring coeffects. Various recent work has proposed models for such typed calculi in terms of graded (strong) monads for effects and graded (monoidal) comonads for coeffects. Effects and coeffects have been studied separately so far, but in practice many computations are both effectful and coeffectful, e.g., possibly throwing exceptions but with resource requirements. To remedy this, we introduce a new general calculus with a combined effect-coeffect system. This can describe both the changes and requirements that a program has on its context, as well as interactions between these effectful and coeffectful features of computation. The effect-coeffect system has a denotational model in terms of effect-graded monads and coeffect-graded comonads where interaction is expressed via the novel concept of graded distributive laws. This graded semantics unifies the syntactic type theory with the denotational model. We show that our calculus can be instantiated to describe in a natural way various different kinds of interaction between a program and its evaluation context.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951939", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Buffalo State University" + }, + { + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "Kyoto University" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + }, + { + "first_name": "Flavien", + "last_name": "Breuvart", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Tarmo", + "last_name": "Uustalu", + "institution": "Tallinn University of Technology" + } + ], + "dblp_key": "conf/icfp/GaboardiKOBU16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951923", + "title": "Queueing and glueing for optimal partitioning (functional pearl)", + "abstract": "The queueing-glueing algorithm is the nickname we give to an algorithmic pattern that provides amortised linear time solutions to a number of optimal list partition problems that have a peculiar property: at various moments we know that two of three candidate solutions could be optimal. The algorithm works by keeping a queue of lists, glueing them from one end, while chopping from the other end, hence the name. We give a formal derivation of the algorithm, and demonstrate it with several non-trivial examples.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951923", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Shin-Cheng", + "last_name": "Mu", + "institution": "Academia Sinica" + }, + { + "first_name": "Yu-Hsi", + "last_name": "Chiang", + "institution": "National Taiwan University" + }, + { + "first_name": "Yu-Han", + "last_name": "Lyu", + "institution": "Dartmouth College" + } + ], + "dblp_key": "conf/icfp/MuCL16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951945", + "title": "Disjoint intersection types", + "abstract": "Dunfield showed that a simply typed core calculus with intersection types and a merge operator is able to capture various programming language features. While his calculus is type-safe, it is not coherent: different derivations for the same expression can elaborate to expressions that evaluate to different values. The lack of coherence is an important disadvantage for adoption of his core calculus in implementations of programming languages, as the semantics of the programming language becomes implementation-dependent.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951945", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Zhiyuan", + "last_name": "Shi", + "institution": "University of Hong Kong" + }, + { + "first_name": "João", + "last_name": "Alpuim", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/icfp/OliveiraSA16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951936", + "title": "Allocation characterizes polyvariance: a unified methodology for polyvariant control-flow analysis", + "abstract": "The polyvariance of a static analysis is the degree to which it structurally differentiates approximations of program values. Polyvariant techniques come in a number of different flavors that represent alternative heuristics for managing the trade-off an analysis strikes between precision and complexity. For example, call sensitivity supposes that values will tend to correlate with recent call sites, object sensitivity supposes that values will correlate with the allocation points of related objects, the Cartesian product algorithm supposes correlations between the values of arguments to the same function, and so forth.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951936", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Gilray", + "institution": "University of Utah" + }, + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/icfp/Gilray0M16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951935", + "title": "Hierarchical memory management for parallel programs", + "abstract": "An important feature of functional programs is that they are parallel by default. Implementing an efficient parallel functional language, however, is a major challenge, in part because the high rate of allocation and freeing associated with functional programs requires an efficient and scalable memory manager.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951935", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ram", + "last_name": "Raghunathan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guy E.", + "last_name": "Blelloch", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/icfp/RaghunathanMAB16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2976747", + "title": "Journey to find bugs in JavaScript web applications in the wild", + "abstract": "Analyzing real-world JavaScript web applications is a challenging task. On top of understanding the semantics of JavaScript, it requires modeling of web documents, platform objects, and interactions between them. Not only the JavaScript language itself but also its usage patterns are extremely dynamic. JavaScript can generate code and run it during evaluation, and most web applications load JavaScript code dynamically. Such dynamic characteristics of JavaScript web applications make pure static analysis approaches inapplicable. In this talk, we present our attempts to analyze JavaScript web applications in the wild mostly statically using various approaches. From pure JavaScript programs to JavaScript web applications using platform-specific libraries and dynamic code loading, we explain technical challenges in analyzing each of them and how we built an open-source analysis framework for JavaScript, SAFE, that addresses the challenges incrementally. In spite of active research accomplishments in analysis of JavaScript web applications, many issues still remain to be resolved such as events, callback functions, and hybrid web applications. We discuss possible future research directions and open challenges.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2976747", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "conf/icfp/Ryu16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951922", + "title": "Deriving a probability density calculator (functional pearl)", + "abstract": "Given an expression that denotes a probability distribution, often we want a corresponding density function, to use in probabilistic inference. Fortunately, the task of finding a density has been automated. It turns out that we can derive a compositional procedure for finding a density, by equational reasoning about integrals, starting with the mathematical specification of what a density is. Moreover, the density found can be run as an estimation algorithm, as well as simplified as an exact formula to improve the estimate.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951922", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Wazim Mohammed", + "last_name": "Ismail", + "institution": "Indiana University" + }, + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/IsmailS16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951925", + "title": "The best of both worlds: linear functional programming without compromise", + "abstract": "We present a linear functional calculus with both the safety guarantees expressible with linear types and the rich language of combinators and composition provided by functional programming. Unlike previous combinations of linear typing and functional programming, we compromise neither the linear side (for example, our linear values are first-class citizens of the language) nor the functional side (for example, we do not require duplicate definitions of compositions for linear and unrestricted functions). To do so, we must generalize abstraction and application to encompass both linear and unrestricted functions. We capture the typing of the generalized constructs with a novel use of qualified types. Our system maintains the metatheoretic properties of the theory of qualified types, including principal types and decidable type inference. Finally, we give a formal basis for our claims of expressiveness, by showing that evaluation respects linearity, and that our language is a conservative extension of existing functional calculi.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951925", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/Morris16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951921", + "title": "Talking bananas: structural recursion for session types", + "abstract": "Session types provide static guarantees that concurrent programs respect communication protocols. We give a novel account of recursive session types in the context of GV, a small concurrent extension of the linear λ-calculus. We extend GV with recursive types and catamorphisms, following the initial algebra semantics of recursion, and show that doing so naturally gives rise to recursive session types. We show that this principled approach to recursion resolves long-standing problems in the treatment of duality for recursive session types.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951921", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/icfp/LindleyM16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951914", + "title": "Ghostbuster: a tool for simplifying and converting GADTs", + "abstract": "Generalized Algebraic Dataypes, or simply GADTs, can encode non-trivial properties in the types of the constructors. Once such properties are encoded in a datatype, however, all code manipulating that datatype must provide proof that it maintains these properties in order to typecheck. In this paper, we take a step towards gradualizing these obligations. We introduce a tool, Ghostbuster, that produces simplified versions of GADTs which elide selected type parameters, thereby weakening the guarantees of the simplified datatype in exchange for reducing the obligations necessary to manipulate it. Like ornaments, these simplified datatypes preserve the recursive structure of the original, but unlike ornaments we focus on information-preserving bidirectional transformations. Ghostbuster generates type-safe conversion functions between the original and simplified datatypes, which we prove are the identity function when composed. We evaluate a prototype tool for Haskell against thousands of GADTs found on the Hackage package database, generating simpler Haskell'98 datatypes and round-trip conversion functions between the two.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951914", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Trevor L.", + "last_name": "McDonell", + "institution": "Indiana University" + }, + { + "first_name": "Timothy A. K.", + "last_name": "Zakian", + "institution": "University of Oxford" + }, + { + "first_name": "Matteo", + "last_name": "Cimini", + "institution": "Indiana University" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/icfp/McDonellZCN16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951941", + "title": "Fully abstract compilation via universal embedding", + "abstract": "A fully abstract compiler guarantees that two source components are observationally equivalent in the source language if and only if their translations are observationally equivalent in the target. Full abstraction implies the translation is secure: target-language attackers can make no more observations of a compiled component than a source-language attacker interacting with the original source component. Proving full abstraction for realistic compilers is challenging because realistic target languages contain features (such as control effects) unavailable in the source, while proofs of full abstraction require showing that every target context to which a compiled component may be linked can be back-translated to a behaviorally equivalent source context.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951941", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Max S.", + "last_name": "New", + "institution": "Northeastern University" + }, + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/icfp/NewBA16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951940", + "title": "Refinement through restraint: bringing down the cost of verification", + "abstract": "We present a framework aimed at significantly reducing the cost of verifying certain classes of systems software, such as file systems. Our framework allows for equational reasoning about systems code written in our new language, Cogent. Cogent is a restricted, polymorphic, higher-order, and purely functional language with linear types and without the need for a trusted runtime or garbage collector. Linear types allow us to assign two semantics to the language: one imperative, suitable for efficient C code generation; and one functional, suitable for equational reasoning and verification. As Cogent is a restricted language, it is designed to easily interoperate with existing C functions and to connect to existing C verification frameworks. Our framework is based on certifying compilation: For a well-typed Cogent program, our compiler produces C code, a high-level shallow embedding of its semantics in Isabelle/HOL, and a proof that the C code correctly refines this embedding. Thus one can reason about the full semantics of real-world systems code productively and equationally, while retaining the interoperability and leanness of C. The compiler certificate is a series of language-level proofs and per-program translation validation phases, combined into one coherent top-level theorem in Isabelle/HOL.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951940", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Liam", + "last_name": "O’Connor", + "institution": "Data61" + }, + { + "first_name": "Zilin", + "last_name": "Chen", + "institution": "Data61" + }, + { + "first_name": "Christine", + "last_name": "Rizkallah", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Sidney", + "last_name": "Amani", + "institution": "Data61" + }, + { + "first_name": "Japheth", + "last_name": "Lim", + "institution": "Data61" + }, + { + "first_name": "Toby", + "last_name": "Murray", + "institution": "University of Melbourne" + }, + { + "first_name": "Yutaka", + "last_name": "Nagashima", + "institution": "Data61" + }, + { + "first_name": "Thomas", + "last_name": "Sewell", + "institution": "Data61" + }, + { + "first_name": "Gerwin", + "last_name": "Klein", + "institution": "Data61" + } + ], + "dblp_key": "conf/icfp/OConnorCRALMNSK16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951915", + "title": "Dynamic witnesses for static type errors (or, ill-typed programs usually go wrong)", + "abstract": "Static type errors are a common stumbling block for newcomers to typed functional languages. We present a dynamic approach to explaining type errors by generating counterexample witness inputs that illustrate how an ill-typed program goes wrong. First, given an ill-typed function, we symbolically execute the body to synthesize witness values that make the program go wrong. We prove that our procedure synthesizes general witnesses in that if a witness is found, then for all inhabited input types, there exist values that can make the function go wrong. Second, we show how to extend the above procedure to produce a reduction graph that can be used to interactively visualize and debug witness executions. Third, we evaluate the coverage of our approach on two data sets comprising over 4,500 ill-typed student programs. Our technique is able to generate witnesses for 88% of the programs, and our reduction graph yields small counterexamples for 81% of the witnesses. Finally, we evaluate whether our witnesses help students understand and fix type errors, and find that students presented with our witnesses show a greater understanding of type errors than those presented with a standard error message.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951915", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Eric L.", + "last_name": "Seidel", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Westley", + "last_name": "Weimer", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/icfp/SeidelJW16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951916", + "title": "A glimpse of Hopjs", + "abstract": "Hop.js is a multitier programming environment for JavaScript. It allows a single JavaScript program to describe the client-side and the server-side components of a web application. Its runtime environment ensures consistent executions of the application on the server and on the client.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951916", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Vincent", + "last_name": "Prunet", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/icfp/SerranoP16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951947", + "title": "String diagrams for free monads (functional pearl)", + "abstract": "We show how one can reason about free monads using their universal properties rather than any concrete implementation. We introduce a graphical, two-dimensional calculus tailor-made to accommodate these properties.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951947", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Maciej", + "last_name": "Piróg", + "institution": "KU Leuven" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "University of Bristol" + } + ], + "dblp_key": "conf/icfp/PirogW16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951918", + "title": "Compact bit encoding schemes for simply-typed lambda-terms", + "abstract": "We consider the problem of how to compactly encode simply-typed λ-terms into bit strings. The work has been motivated by Kobayashi et al.’s recent work on higher-order data compression, where data are encoded as functional programs (or, λ-terms) that generate them. To exploit its good compression power, the compression scheme has to come with a method for compactly encoding the λ-terms into bit strings. To this end, we propose two type-based bit-encoding schemes; the first one encodes a λ-term into a sequence of symbols by using type information, and then applies arithmetic coding to convert the sequence to a bit string. The second one is more sophisticated; we prepare a context-free grammar (CFG) that describes only well-typed terms, and then use a variation of arithmetic coding specialized for the CFG. We have implemented both schemes and confirmed that they often output more compact codes than previous bit encoding schemes for λ-terms.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951918", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kotaro", + "last_name": "Takeda", + "institution": "The University of Tokyo" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Kazuya", + "last_name": "Yaguchi", + "institution": "Tohoku University" + }, + { + "first_name": "Ayumi", + "last_name": "Shinohara", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/icfp/Takeda0YS16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951929", + "title": "Indexed codata types", + "abstract": "Indexed data types allow us to specify and verify many interesting invariants about finite data in a general purpose programming language. In this paper we investigate the dual idea: indexed codata types, which allow us to describe data-dependencies about infinite data structures. Unlike finite data which is defined by constructors, we define infinite data by observations. Dual to pattern matching on indexed data which may refine the type indices, we define copattern matching on indexed codata where type indices guard observations we can make.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951929", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Thibodeau", + "institution": "McGill University" + }, + { + "first_name": "Andrew", + "last_name": "Cave", + "institution": "McGill University" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "conf/icfp/ThibodeauCP16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951944", + "title": "A fully concurrent garbage collector for functional programs on multicore processors", + "abstract": "This paper presents a concurrent garbage collection method for functional programs running on a multicore processor. It is a concurrent extension of our bitmap-marking non-moving collector with Yuasa's snapshot-at-the-beginning strategy. Our collector is unobtrusive in the sense of the Doligez-Leroy-Gonthier collector; the collector does not stop any mutator thread nor does it force them to synchronize globally. The only critical sections between a mutator and the collector are the code to enqueue/dequeue a 32 kB allocation segment to/from a global segment list and the write barrier code to push an object pointer onto the collector's stack. Most of these data structures can be implemented in standard lock-free data structures. This achieves both efficient allocation and unobtrusive collection in a multicore system. The proposed method has been implemented in SML#, a full-scale Standard ML compiler supporting multiple native threads on multicore CPUs. Our benchmark tests show a drastically short pause time with reasonably low overhead compared to the sequential bitmap-marking collector.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951944", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Katsuhiro", + "last_name": "Ueno", + "institution": "Tohoku University" + }, + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/icfp/UenoO16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951926", + "title": "Context-free session types", + "abstract": "Session types describe structured communication on heterogeneously typed channels at a high level. Their tail-recursive structure imposes a protocol that can be described by a regular language. The types of transmitted values are drawn from the underlying functional language, abstracting from the details of serializing values of structured data types.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951926", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + } + ], + "dblp_key": "conf/icfp/ThiemannV16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951924", + "title": "A new verified compiler backend for CakeML", + "abstract": "We have developed and mechanically verified a new compiler backend for CakeML. Our new compiler features a sequence of intermediate languages that allows it to incrementally compile away high-level features and enables verification at the right levels of semantic detail. In this way, it resembles mainstream (unverified) compilers for strict functional languages. The compiler supports efficient curried multi-argument functions, configurable data representations, exceptions that unwind the call stack, register allocation, and more. The compiler targets several architectures: x86-64, ARMv6, ARMv8, MIPS-64, and RISC-V. In this paper, we present the overall structure of the compiler, including its 12 intermediate languages, and explain how everything fits together. We focus particularly on the interaction between the verification of the register allocator and the garbage collector, and memory representations. The entire development has been carried out within the HOL4 theorem prover.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951924", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yong Kiam", + "last_name": "Tan", + "institution": "A*STAR Graduate Academy" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Ramana", + "last_name": "Kumar", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Anthony", + "last_name": "Fox", + "institution": "University of Cambridge" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Kent" + }, + { + "first_name": "Michael", + "last_name": "Norrish", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + } + ], + "dblp_key": "conf/icfp/TanMKFON16", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951919", + "title": "Automatically disproving fair termination of higher-order functional programs", + "abstract": "We propose an automated method for disproving fair termination of higher-order functional programs, which is complementary to Murase et al.’s recent method for proving fair termination. A program is said to be fair terminating if it has no infinite execution trace that satisfies a given fairness constraint. Fair termination is an important property because program verification problems for arbitrary ω-regular temporal properties can be transformed to those of fair termination. Our method reduces the problem of disproving fair termination to higher-order model checking by using predicate abstraction and CEGAR. Given a program, we convert it to an abstract program that generates an approximation of the (possibly infinite) execution traces of the original program, so that the original program has a fair infinite execution trace if the tree generated by the abstract program satisfies a certain property. The method is a non-trivial extension of Kuwahara et al.’s method for disproving plain termination.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951919", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Keiichi", + "last_name": "Watanabe", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryosuke", + "last_name": "Sato", + "institution": "The University of Tokyo" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "The University of Tokyo" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/icfp/WatanabeST016", + "venue": "icfp", + "year": 2016 + }, + { + "paper_id": "10.1145/2951913.2951927", + "title": "Experience report: growing and shrinking polygons for random testing of computational geometry algorithms", + "abstract": "This paper documents our experience of adapting and using the QuickCheck-style approach for extensive randomised property-based testing of computational geometry algorithms.", + "date": "2016-08-29", + "link": "https://doi.org/10.1145/2951913.2951927", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "University College London" + } + ], + "dblp_key": "conf/icfp/Sergey16", + "venue": "icfp", + "year": 2016 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2017.json b/data/pl_conferences/icfp/2017.json new file mode 100644 index 0000000..39d51f2 --- /dev/null +++ b/data/pl_conferences/icfp/2017.json @@ -0,0 +1,1269 @@ +[ + { + "paper_id": "10.1145/3110250", + "title": "A pretty but not greedy printer (functional pearl)", + "abstract": "This paper proposes a new specification of pretty printing which is stronger than the state of the art: we require the output to be the shortest possible, and we also offer the ability to align sub-documents at will. We argue that our specification precludes a greedy implementation. Yet, we provide an implementation which behaves linearly in the size of the output. The derivation of the implementation demonstrates functional programming methodology.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110250", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "journals/pacmpl/Bernardy17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110252", + "title": "A unified approach to solving seven programming problems (functional pearl)", + "abstract": "We present seven programming challenges in Racket, and an elegant, unified approach to solving them using constraint logic programming in miniKanren.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110252", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "William E.", + "last_name": "Byrd", + "institution": "University of Utah" + }, + { + "first_name": "Michael", + "last_name": "Ballantyne", + "institution": "University of Utah" + }, + { + "first_name": "Gregory", + "last_name": "Rosenblatt", + "institution": "" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/ByrdBRM17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110257", + "title": "On the expressive power of user-defined effects: effect handlers, monadic reflection, delimited control", + "abstract": "We compare the expressive power of three programming abstractions for user-defined computational effects: Plotkin and Pretnar's effect handlers, Filinski's monadic reflection, and delimited control without answer-type-modification. This comparison allows a precise discussion about the relative expressiveness of each programming abstraction. It also demonstrates the sensitivity of the relative expressiveness of user-defined effects to seemingly orthogonal language features. We present three calculi, one per abstraction, extending Levy's call-by-push-value. For each calculus, we present syntax, operational semantics, a natural type-and-effect system, and, for effect handlers and monadic reflection, a set-theoretic denotational semantics. We establish their basic metatheoretic properties: safety, termination, and, where applicable, soundness and adequacy. Using Felleisen's notion of a macro translation, we show that these abstractions can macro-express each other, and show which translations preserve typeability. We use the adequate finitary set-theoretic denotational semantics for the monadic calculus to show that effect handlers cannot be macro-expressed while preserving typeability either by monadic reflection or by delimited control. Our argument fails with simple changes to the type system such as polymorphism and inductive types. We supplement our development with a mechanised Abella formalisation.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110257", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yannick", + "last_name": "Forster", + "institution": "Saarland University" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Oxford" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "Matija", + "last_name": "Pretnar", + "institution": "University of Ljubljana" + } + ], + "dblp_key": "journals/pacmpl/0002KLP17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110265", + "title": "A relational logic for higher-order programs", + "abstract": "Relational program verification is a variant of program verification where one can reason about two programs and as a special case about two executions of a single program on different inputs. Relational program verification can be used for reasoning about a broad range of properties, including equivalence and refinement, and specialized notions such as continuity, information flow security or relative cost. In a higher-order setting, relational program verification can be achieved using relational refinement type systems, a form of refinement types where assertions have a relational interpretation. Relational refinement type systems excel at relating structurally equivalent terms but provide limited support for relating terms with very different structures. We present a logic, called Relational Higher Order Logic (RHOL), for proving relational properties of a simply typed λ-calculus with inductive types and recursive definitions. RHOL retains the type-directed flavour of relational refinement type systems but achieves greater expressivity through rules which simultaneously reason about the two terms as well as rules which only contemplate one of the two terms. We show that RHOL has strong foundations, by proving an equivalence with higher-order logic (HOL), and leverage this equivalence to derive key meta-theoretical properties: subject reduction, admissibility of a transitivity rule and set-theoretical soundness. Moreover, we define sound embeddings for several existing relational type systems such as relational refinement types and type systems for dependency analysis and relative cost, and we verify examples that were out of reach of prior work.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110265", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "École Polytechnique" + } + ], + "dblp_key": "journals/pacmpl/AguirreBG0S17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110247", + "title": "Lock-step simulation is child's play (experience report)", + "abstract": "Implementing multi-player networked games by broadcasting the player’s input and letting each client calculate the game state -- a scheme known as *lock-step simulation* – is an established technique. However, ensuring that every client in this scheme obtains a consistent state is infamously hard and in general requires great discipline from the game programmer. The thesis of this pearl is that in the realm of functional programming – in particular with Haskell's purity and static pointers – this hard problem becomes almost trivially easy. We support this thesis by implementing lock-step simulation under very adverse conditions. We extended the educational programming environment CodeWorld, which is used to teach math and programming to middle school students, with the ability to create and run interactive, networked multi-user games. Despite providing a very abstract and high-level interface, and without requiring any discipline from the programmer, we can provide consistent lock-step simulation with client prediction.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110247", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joachim", + "last_name": "Breitner", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Chris", + "last_name": "Smith", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/BreitnerS17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110268", + "title": "Kami: a platform for high-level parametric hardware specification and its modular verification", + "abstract": "It has become fairly standard in the programming-languages research world to verify functional programs in proof assistants using induction, algebraic simplification, and rewriting. In this paper, we introduce Kami, a Coq library that enables similar expressive and modular reasoning for hardware designs expressed in the style of the Bluespec language. We can specify, implement, and verify realistic designs entirely within Coq, ending with automatic extraction into a pipeline that bottoms out in FPGAs. Our methodology, using labeled transition systems, has been evaluated in a case study verifying an infinite family of multicore systems, with cache-coherent shared memory and pipelined cores implementing (the base integer subset of) the RISC-V instruction set.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110268", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joonwon", + "last_name": "Choi", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Muralidaran", + "last_name": "Vijayaraghavan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Benjamin", + "last_name": "Sherman", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Arvind", + "last_name": "Arvind", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ChoiVSCA17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110281", + "title": "Manifest sharing with session types", + "abstract": "Session-typed languages building on the Curry-Howard isomorphism between linear logic and session-typed communication guarantee session fidelity and deadlock freedom. Unfortunately, these strong guarantees exclude many naturally occurring programming patterns pertaining to shared resources. In this paper, we introduce sharing into a session-typed language where types are stratified into linear and shared layers with modal operators connecting the layers. The resulting language retains session fidelity but not the absence of deadlocks, which can arise from contention for shared processes. We illustrate our language on various examples, such as the dining philosophers problem, and provide a translation of the untyped asynchronous π-calculus into our language.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110281", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/BalzerP17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110253", + "title": "Prototyping a query compiler using Coq (experience report)", + "abstract": "Designing and prototyping new features is important in many industrial projects. Functional programming and formal verification tools can prove valuable for that purpose, but lead to challenges when integrating with existing product code or when planning technology transfer. This article reports on our experience using the Coq proof assistant as a prototyping environment for building a query compiler intended for use in IBM's ODM Insights product. We discuss the pros and cons of using Coq for this purpose and describe our methodology for porting the compiler to Java, as required for product integration.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110253", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Auerbach", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "" + }, + { + "first_name": "Louis", + "last_name": "Mandel", + "institution": "" + }, + { + "first_name": "Avraham", + "last_name": "Shinnar", + "institution": "" + }, + { + "first_name": "Jérǒme", + "last_name": "Simèon", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/AuerbachHMSS17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110283", + "title": "Theorems for free for free: parametricity, with and without types", + "abstract": "The polymorphic blame calculus integrates static typing, including universal types, with dynamic typing. The primary challenge with this integration is preserving parametricity: even dynamically-typed code should satisfy it once it has been cast to a universal type. Ahmed et al. (2011) employ runtime type generation in the polymorphic blame calculus to preserve parametricity, but a proof that it does so has been elusive. Matthews and Ahmed (2008) gave a proof of parametricity for a closely related system that combines ML and Scheme, but later found a flaw in their proof. In this paper we present an improved version of the polymorphic blame calculus and we prove that it satisfies relational parametricity. The proof relies on a step-indexed Kripke logical relation. The step-indexing is required to make the logical relation well-defined in the case for the dynamic type. The possible worlds include the mapping of generated type names to their types and the mapping of type names to relations. We prove the Fundamental Property of this logical relation and that it is sound with respect to contextual equivalence. To demonstrate the utility of parametricity in the polymorphic blame calculus, we derive two free theorems.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110283", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + }, + { + "first_name": "Dustin", + "last_name": "Jamner", + "institution": "Northeastern University" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/AhmedJSW17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110287", + "title": "Automating sized-type inference for complexity analysis", + "abstract": "This paper introduces a new methodology for the complexity analysis of higher-order functional programs, which is based on three ingredients: a powerful type system for size analysis and a sound type inference procedure for it, a ticking monadic transformation and constraint solving. Noticeably, the presented methodology can be fully automated, and is able to analyse a series of examples which cannot be handled by most competitor methodologies. This is possible due to various key ingredients, and in particular an abstract index language and index polymorphism at higher ranks. A prototype implementation is available.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110287", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Avanzini", + "institution": "University of Bologna" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/AvanziniL17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110274", + "title": "Super 8 languages for making movies (functional pearl)", + "abstract": "The Racket doctrine tells developers to narrow the gap between the terminology of a problem domain and general programming constructs by creating languages instead of just plain programs. This pearl illustrates this point with the creation of a relatively simple domain-specific language for editing videos. To produce the video proceedings of a conference, for example, video professionals traditionally use \"non-linear\" GUI editors to manually edit each talk, despite the repetitive nature of the process. As it turns out, video editing naturally splits the work into a declarative phase and an imperative rendering phase at the end. Hence it is natural to create a functional-declarative language for the first phase, which reduces a lot of manual labor. This user-facing DSL utilizes a second, internal DSL to implement the second phase, which is an interface to a general, low-level C library. Finally, we inject type checking into our language via another DSL that supports programming in the language of type formalisms. In short, the development of the video editing language cleanly demonstrates how the Racket doctrine naturally leads to the creation of language hierarchies, analogous to the hierarchies of modules found in conventional functional languages.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110274", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Leif", + "last_name": "Andersen", + "institution": "Northeastern University" + }, + { + "first_name": "Stephen", + "last_name": "Chang", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/AndersenCF17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110285", + "title": "Gradual typing with union and intersection types", + "abstract": "We propose a type system for functional languages with gradual types and set-theoretic type connectives and prove its soundness. In particular, we show how to lift the definition of the domain and result type of an application from non-gradual types to gradual ones and likewise for the subtyping relation. We also show that deciding subtyping for gradual types can be reduced in linear time to deciding subtyping on non-gradual types and that the same holds true for all subtyping-related decision problems that must be solved for type inference. More generally, this work not only enriches gradual type systems with unions and intersections and with the type precision that arise from their use, but also proposes and advocates a new style of gradual types programming where union and intersection types are used by programmers to instruct the system to perform fewer dynamic checks.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110285", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Victor", + "last_name": "Lanvin", + "institution": "École Normale Supérieure Paris-Saclay" + } + ], + "dblp_key": "journals/pacmpl/CastagnaL17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110277", + "title": "Normalization by evaluation for sized dependent types", + "abstract": "Sized types have been developed to make termination checking more perspicuous, more powerful, and more modular by integrating termination into type checking. In dependently-typed proof assistants where proofs by induction are just recursive functional programs, the termination checker is an integral component of the trusted core, as validity of proofs depend on termination. However, a rigorous integration of full-fledged sized types into dependent type theory is lacking so far. Such an integration is non-trivial, as explicit sizes in proof terms might get in the way of equality checking, making terms appear distinct that should have the same semantics. In this article, we integrate dependent types and sized types with higher-rank size polymorphism, which is essential for generic programming and abstraction. We introduce a size quantifier ∀ which lets us ignore sizes in terms for equality checking, alongside with a second quantifier Π for abstracting over sizes that do affect the semantics of types and terms. Judgmental equality is decided by an adaptation of normalization-by-evaluation for our new type theory, which features type shape -directed reflection and reification. It follows that subtyping and type checking of normal forms are decidable as well, the latter by a bidirectional algorithm.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110277", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "University of Gothenburg" + }, + { + "first_name": "Andrea", + "last_name": "Vezzosi", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/0001VW17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110264", + "title": "Foundations of strong call by need", + "abstract": "We present a call-by-need strategy for computing strong normal forms of open terms (reduction is admitted inside the body of abstractions and substitutions, and the terms may contain free variables), which guarantees that arguments are only evaluated when needed and at most once. The strategy is shown to be complete with respect to β -reduction to strong normal form. The proof of completeness relies on two key tools: (1) the definition of a strong call-by-need calculus where reduction may be performed inside any context, and (2) the use of non-idempotent intersection types. More precisely, terms admitting a β -normal form in pure lambda calculus are typable, typability implies (weak) normalisation in the strong call-by-need calculus, and weak normalisation in the strong call-by-need calculus implies normalisation in the strong call-by-need strategy. Our (strong) call-by-need strategy is also shown to be conservative over the standard (weak) call-by-need.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110264", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thibaut", + "last_name": "Balabonski", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Pablo", + "last_name": "Barenbaum", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Eduardo", + "last_name": "Bonelli", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Delia", + "last_name": "Kesner", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "journals/pacmpl/BalabonskiBBK17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110248", + "title": "Scaling up functional programming education: under the hood of the OCaml MOOC", + "abstract": "This article describes the key innovations used in the massive open online course ``Introduction to Functional Programming using OCaml'' that has run since the fall semester of 2015. A fully in-browser development environment with an integrated grader provides an exceptional level of feedback to the learners. A functional library of grading combinators greatly simplifies the notoriously complex task of writing test suites for the exercises, and provides static type-safety guarantees on the tested user code. Even the error-prone manual process of importing the course content in the learning platform has been replaced by a functional program that describes the course and statically checks its contents. A detailed statistical analysis of the data collected during and after the course assesses the effectiveness of these innovations.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110248", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Canou", + "institution": "" + }, + { + "first_name": "Roberto Di", + "last_name": "Cosmo", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Grégoire", + "last_name": "Henry", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/CanouCH17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110270", + "title": "Local refinement typing", + "abstract": "We introduce the FUSION algorithm for local refinement type inference, yielding a new SMT-based method for verifying programs with polymorphic data types and higher-order functions. FUSION is concise as the programmer need only write signatures for (externally exported) top-level functions and places with cyclic (recursive) dependencies, after which FUSION can predictably synthesize the most precise refinement types for all intermediate terms (expressible in the decidable refinement logic), thereby checking the program without false alarms. We have implemented FUSION and evaluated it on the benchmarks from the LiquidHaskell suite totalling about 12KLOC. FUSION checks an existing safety benchmark suite using about half as many templates as previously required and nearly 2 × faster. In a new set of theorem proving benchmarks FUSION is both 10 — 50 × faster and, by synthesizing the most precise types, avoids false alarms to make verification possible.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110270", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Cosman", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/CosmanJ17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110256", + "title": "Abstracting definitional interpreters (functional pearl)", + "abstract": "In this functional pearl, we examine the use of definitional interpreters as a basis for abstract interpretation of higher-order programming languages. As it turns out, definitional interpreters, especially those written in monadic style, can provide a nice basis for a wide variety of collecting semantics, abstract interpretations, symbolic executions, and their intermixings. But the real insight of this story is a replaying of an insight from Reynold's landmark paper, Definitional Interpreters for Higher-Order Programming Languages , in which he observes definitional interpreters enable the defined-language to inherit properties of the defining-language. We show the same holds true for definitional abstract interpreters. Remarkably, we observe that abstract definitional interpreters can inherit the so-called “pushdown control flow” property, wherein function calls and returns are precisely matched in the abstract semantics, simply by virtue of the function call mechanism of the defining-language. The first approaches to achieve this property for higher-order languages appeared within the last ten years, and have since been the subject of many papers. These approaches start from a state-machine semantics and uniformly involve significant technical engineering to recover the precision of pushdown control flow. In contrast, starting from a definitional interpreter, the pushdown control flow property is inherent in the meta-language and requires no further technical mechanism to achieve.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110256", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Darais", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Nicholas", + "last_name": "Labich", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Phúc C.", + "last_name": "Nguyen", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/DaraisLNH17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110251", + "title": "Generic functional parallel algorithms: scan and FFT", + "abstract": "Parallel programming, whether imperative or functional, has long focused on arrays as the central data type. Meanwhile, typed functional programming has explored a variety of data types, including lists and various forms of trees. Generic functional programming decomposes these data types into a small set of fundamental building blocks: sum, product, composition, and their associated identities. Definitions over these few fundamental type constructions then automatically assemble into algorithms for an infinite variety of data types—some familiar and some new. This paper presents generic functional formulations for two important and well-known classes of parallel algorithms: parallel scan (generalized prefix sum) and fast Fourier transform (FFT). Notably, arrays play no role in these formulations. Consequent benefits include a simpler and more compositional style, much use of common algebraic patterns and freedom from possibility of run-time indexing errors. The functional generic style also clearly reveals deep commonality among what otherwise appear to be quite different algorithms. Instantiating the generic formulations, two well-known algorithms for each of parallel scan and FFT naturally emerge, as well as two possibly new algorithms.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110251", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "Target (United States)" + } + ], + "dblp_key": "journals/pacmpl/Elliott17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110267", + "title": "No-brainer CPS conversion (functional pearl)", + "abstract": "Algorithms that convert direct-style λ-calculus terms to their equivalent terms in continuation-passing style (CPS) typically introduce so-called “administrative redexes:” useless artifacts of the conversion that must be cleaned up by a subsequent pass over the result to reduce them away. We present a simple, linear-time algorithm for CPS conversion that introduces no administrative redexes. In fact, the output term is a normal form in a reduction system that generalizes the notion of “administrative redexes” to what we call “no-brainer redexes,” that is, redexes whose reduction shrinks the size of the term. We state the theorems which establish the algorithm's desireable properties, along with sketches of the full proofs.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110267", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Milo", + "last_name": "Davis", + "institution": "Northeastern University" + }, + { + "first_name": "William P.", + "last_name": "Meehan", + "institution": "Northeastern University" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/DavisMS17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110278", + "title": "A metaprogramming framework for formal verification", + "abstract": "We describe the metaprogramming framework currently used in Lean, an interactive theorem prover based on dependent type theory. This framework extends Lean's object language with an API to some of Lean's internal structures and procedures, and provides ways of reflecting object-level expressions into the metalanguage. We provide evidence to show that our implementation is performant, and that it provides a convenient and flexible way of writing not only small-scale interactive tactics, but also more substantial kinds of automation.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110278", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Ebner", + "institution": "TU Wien" + }, + { + "first_name": "Sebastian", + "last_name": "Ullrich", + "institution": "" + }, + { + "first_name": "Jared", + "last_name": "Roesch", + "institution": "University of Washington" + }, + { + "first_name": "Jeremy", + "last_name": "Avigad", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Leonardo de", + "last_name": "Moura", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/EbnerURAM17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110271", + "title": "Compiling to categories", + "abstract": "It is well-known that the simply typed lambda-calculus is modeled by any cartesian closed category (CCC). This correspondence suggests giving typed functional programs a variety of interpretations, each corresponding to a different category. A convenient way to realize this idea is as a collection of meaning-preserving transformations added to an existing compiler, such as GHC for Haskell. This paper describes such an implementation and demonstrates its use for a variety of interpretations including hardware circuits, automatic differentiation, incremental computation, and interval analysis. Each such interpretation is a category easily defined in Haskell (outside of the compiler). The general technique appears to provide a compelling alternative to deeply embedded domain-specific languages.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110271", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "Target (United States)" + } + ], + "dblp_key": "journals/pacmpl/Elliott17a", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110282", + "title": "Gradual session types", + "abstract": "Session types are a rich type discipline, based on linear types, that lift the sort of safety claims that come with type systems to communications. However, web-based applications and micro services are often written in a mix of languages, with type disciplines in a spectrum between static and dynamic typing. Gradual session types address this mixed setting by providing a framework which grants seamless transition between statically typed handling of sessions and any required degree of dynamic typing. We propose GradualGV as an extension of the functional session type system GV with dynamic types and casts. We demonstrate type and communication safety as well as blame safety, thus extending previous results to functional languages with session-based communication. The interplay of linearity and dynamic types requires a novel approach to specifying the dynamics of the language.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110282", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/IgarashiTVW17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110266", + "title": "How to prove your calculus is decidable: practical applications of second-order algebraic theories and computation", + "abstract": "We present a general methodology of proving the decidability of equational theory of programming language concepts in the framework of second-order algebraic theories. We propose a Haskell-based analysis tool SOL, Second-Order Laboratory, which assists the proofs of confluence and strong normalisation of computation rules derived from second-order algebraic theories. To cover various examples in programming language theory, we combine and extend both syntactical and semantical results of second-order computation in a non-trivial manner. We demonstrate how to prove decidability of various algebraic theories in the literature. It includes the equational theories of monad and lambda-calculi, Plotkin and Power's theory of states, and Stark's theory of pi-calculus.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110266", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Makoto", + "last_name": "Hamana", + "institution": "Gunma University" + } + ], + "dblp_key": "journals/pacmpl/Hamana17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110284", + "title": "On polymorphic gradual typing", + "abstract": "We study an extension of gradual typing—a method to integrate dynamic typing and static typing smoothly in a single language—to parametric polymorphism and its theoretical properties, including conservativity of typing and semantics over both statically and dynamically typed languages, type safety, blame-subtyping theorem, and the gradual guarantee—the so-called refined criteria, advocated by Siek et al. We develop System F G , which is a gradually typed extension of System F with the dynamic type and a new type consistency relation, and translation to a new polymorphic blame calculus System F C , which is based on previous polymorphic blame calculi by Ahmed et al. The design of System F G and System F C , geared to the criteria, is influenced by the distinction between static and gradual type variables, first observed by Garcia and Cimini. This distinction is also useful to execute statically typed code without incurring additional overhead to manage type names as in the prior calculi. We prove that System F G satisfies most of the criteria: all but the hardest property of the gradual guarantee on semantics. We show that a key conjecture to prove the gradual guarantee leads to the Jack-of-All-Trades property, conjectured as an important property of the polymorphic blame calculus by Ahmed et al.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110284", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yuu", + "last_name": "Igarashi", + "institution": "Kyoto University" + }, + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "journals/pacmpl/IgarashiSI17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110255", + "title": "Symbolic conditioning of arrays in probabilistic programs", + "abstract": "Probabilistic programming systems make machine learning more modular by automating inference . Recent work by Shan and Ramsey makes inference more modular by automating conditioning . Their technique uses a symbolic program transformation that treats conditioning generally via the measure-theoretic notion of disintegration . This technique, however, is limited to conditioning a single scalar variable. As a step towards modular inference for realistic machine learning applications, we have extended the disintegration algorithm to symbolically condition arrays in probabilistic programs. The extended algorithm implements lifted disintegration , where repetition is treated symbolically and without unrolling loops. The technique uses a language of index variables for tracking expressions at various array levels. We find that the method works well for arbitrarily-sized arrays of independent random choices, with the conditioning step taking time linear in the number of indices needed to select an element.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110255", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "P. J.", + "last_name": "Narayanan", + "institution": "Indiana University" + }, + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/NarayananS17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110263", + "title": "Better living through operational semantics: an optimizing compiler for radio protocols", + "abstract": "Software-defined radio (SDR) promises to bring the flexibility and rapid iterative workflow of software to radio protocol design. Many factors make achieving this promise challenging, not least of which are the high data rates and timing requirements of real-world radio protocols. The Ziria language and accompanying compiler demonstrated that a high-level language can compete in this demanding space, but extracting reusable lessons from this success is difficult due to Ziria's lack of a formal semantics. Our first contribution is a core language, operational semantics, and type system for Ziria. The insight we gained through developing this operational semantics led to our second contribution, consisting of two program transformations. The first is fusion, which can eliminate intermediate queues in Ziria programs. Fusion subsumes many one-off optimizations performed by the original Ziria compiler. The second transformation is pipeline coalescing, which reduces execution overhead by batching IO. Pipeline coalescing relies critically on fusion and provides a much simpler story for the original Ziria compiler's \"vectorization\" transformation. These developments serve as the basis of our third contribution, a new compiler for Ziria that produces significantly faster code than the original compiler. The new compiler leverages our intermediate language to help eliminate unnecessary memory traffic. As well as providing a firm foundation for the Ziria language, our work on an operational semantics resulted in very real software engineering benefits. These benefits need not be limited to SDR---the core language and accompanying transformations we present are applicable to other domains that require processing streaming data at high speed.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110263", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Geoffrey", + "last_name": "Mainland", + "institution": "Drexel University" + } + ], + "dblp_key": "journals/pacmpl/Mainland17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110279", + "title": "Chaperone contracts for higher-order sessions", + "abstract": "Contracts have proved to be an effective mechanism that helps developers in identifying those modules of a program that violate the contracts of the functions and objects they use. In recent years, sessions have established as a key mechanism for realizing inter-module communications in concurrent programs. Just like values flow into or out of a function or object, messages are sent on, and received from, a session endpoint. Unlike conventional functions and objects, however, the kind, direction, and properties of messages exchanged in a session may vary over time, as the session progresses. This feature of sessions calls for contracts that evolve along with the session they describe. In this work, we extend to sessions the notion of chaperone contract (roughly, a contract that applies to a mutable object) and investigate the ramifications of contract monitoring in a higher-order language that features sessions. We give a characterization of correct module, one that honors the contracts of the sessions it uses, and prove a blame theorem. Guided by the calculus, we describe a lightweight implementation of monitored sessions as an OCaml module with which programmers can benefit from static session type checking and dynamic contract monitoring using an off-the-shelf version of OCaml.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110279", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Hernán", + "last_name": "Melgratti", + "institution": "University of Buenos Aires" + }, + { + "first_name": "Luca", + "last_name": "Padovani", + "institution": "University of Turin" + } + ], + "dblp_key": "journals/pacmpl/MelgrattiP17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110262", + "title": "Verifying efficient function calls in CakeML", + "abstract": "We have designed an intermediate language (IL) for the CakeML compiler that supports the verified, efficient compilation of functions and calls. Verified compilation steps include batching of multiple curried arguments, detecting calls to statically known functions, and specialising calls to known functions with no free variables. Finally, we verify the translation to a lower-level IL that only supports closed, first-order functions. These compilation steps resemble those found in other compilers (especially OCaml). Our contribution here is the design of the semantics of the IL, and the demonstration that our verification techniques over this semantics work well in practice at this scale. The entire development was carried out in the HOL4 theorem prover.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110262", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Kent" + }, + { + "first_name": "Michael", + "last_name": "Norrish", + "institution": "Australian National University" + }, + { + "first_name": "Ramana", + "last_name": "Kumar", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Yong Kiam", + "last_name": "Tan", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/OwensNKMT17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110288", + "title": "Inferring scope through syntactic sugar", + "abstract": "Many languages use syntactic sugar to define parts of their surface language in terms of a smaller core. Thus some properties of the surface language, like its scoping rules , are not immediately evident. Nevertheless, IDEs, refactorers, and other tools that traffic in source code depend on these rules to present information to users and to soundly perform their operations. In this paper, we show how to lift scoping rules defined on a core language to rules on the surface, a process of scope inference . In the process we introduce a new representation of binding structure---scope as a preorder---and present a theoretical advance: proving that a desugaring system preserves α-equivalence even though scoping rules have been provided only for the core language. We have also implemented the system presented in this paper.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110288", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Justin", + "last_name": "Pombrio", + "institution": "John Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "John Brown University" + }, + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/PombrioKW17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110286", + "title": "Constrained type families", + "abstract": "We present an approach to support partiality in type-level computation without compromising expressiveness or type safety. Existing frameworks for type-level computation either require totality or implicitly assume it. For example, type families in Haskell provide a powerful, modular means of defining type-level computation. However, their current design implicitly assumes that type families are total, introducing nonsensical types and significantly complicating the metatheory of type families and their extensions. We propose an alternative design, using qualified types to pair type-level computations with predicates that capture their domains. Our approach naturally captures the intuitive partiality of type families, simplifying their metatheory. As evidence, we present the first complete proof of consistency for a language with closed type families.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110286", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Edinburgh" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + } + ], + "dblp_key": "journals/pacmpl/MorrisE17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110246", + "title": "Testing and debugging functional reactive programming", + "abstract": "Many types of interactive applications, including video games, raise particular challenges when it comes to testing and debugging. Reasons include de-facto lack of reproducibility and difficulties of automatically generating suitable test data. This paper demonstrates that certain variants of Functional Reactive Programming (FRP) implemented in pure functional languages can mitigate such difficulties by offering referential transparency at the level of whole programs. This opens up for a multi-pronged approach for assisting with testing and debugging that works across platforms, including assertions based on temporal logic, recording and replaying of runs (also from deployed code), and automated random testing using QuickCheck. The approach has been validated on real, non-trivial games implemented in the FRP system Yampa through a tool providing a convenient Graphical User Interface that allows the execution of the code under scrutiny to be controlled, moving along the execution time line, and pin-pointing of violations of assertions on PCs as well as mobile platforms.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110246", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ivan", + "last_name": "Pérez", + "institution": "University of Nottingham" + }, + { + "first_name": "Henrik", + "last_name": "Nilsson", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/PerezN17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110276", + "title": "Parametric quantifiers for dependent type theory", + "abstract": "Polymorphic type systems such as System F enjoy the parametricity property: polymorphic functions cannot inspect their type argument and will therefore apply the same algorithm to any type they are instantiated on. This idea is formalized mathematically in Reynolds's theory of relational parametricity, which allows the metatheoretical derivation of parametricity theorems about all values of a given type. Although predicative System F embeds into dependent type systems such as Martin-Löf Type Theory (MLTT), parametricity does not carry over as easily. The identity extension lemma, which is crucial if we want to prove theorems involving equality, has only been shown to hold for small types, excluding the universe. We attribute this to the fact that MLTT uses a single type former Π to generalize both the parametric quantifier ∀ and the type former → which is non-parametric in the sense that its elements may use their argument as a value. We equip MLTT with parametric quantifiers ∀ and ∃ alongside the existing Π and Σ, and provide relation type formers for proving parametricity theorems internally. We show internally the existence of initial algebras and final co-algebras of indexed functors both by Church encoding and, for a large class of functors, by using sized types. We prove soundness of our type system by enhancing existing iterated reflexive graph (cubical set) models of dependently typed parametricity by distinguishing between edges that express relatedness of objects (bridges) and edges that express equality (paths). The parametric functions are those that map bridges to paths. We implement an extension to the Agda proof assistant that type-checks proofs in our type system.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110276", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Nuyts", + "institution": "KU Leuven" + }, + { + "first_name": "Andrea", + "last_name": "Vezzosi", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/NuytsVD17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110259", + "title": "Effect-driven QuickChecking of compilers", + "abstract": "How does one test a language implementation with QuickCheck (aka. property-based testing)? One approach is to generate programs following the grammar of the language. But in a statically-typed language such as OCaml too many of these candidate programs will be rejected as ill-typed by the type checker. As a refinement Pałka et al. propose to generate programs in a goal-directed, bottom-up reading up of the typing relation. We have written such a generator. However many of the generated programs has output that depend on the evaluation order, which is commonly under-specified in languages such as OCaml, Scheme, C, C++, etc. In this paper we develop a type and effect system for conservatively detecting evaluation-order dependence and propose its goal-directed reading as a generator of programs that are independent of evaluation order. We illustrate the approach by generating programs to test OCaml's two compiler backends against each other and report on a number of bugs we have found doing so.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110259", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jan", + "last_name": "Midtgaard", + "institution": "" + }, + { + "first_name": "Mathias Nygaard", + "last_name": "Justesen", + "institution": "" + }, + { + "first_name": "Patrick", + "last_name": "Kasting", + "institution": "" + }, + { + "first_name": "Flemming", + "last_name": "Nielson", + "institution": "" + }, + { + "first_name": "Hanne Riis", + "last_name": "Nielson", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/MidtgaardJKNN17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110272", + "title": "Visitors unchained", + "abstract": "Traversing and transforming abstract syntax trees that involve name binding is notoriously difficult to do in a correct, concise, modular, customizable manner. We address this problem in the setting of OCaml, a functional programming language equipped with powerful object-oriented features. We use visitor classes as partial, composable descriptions of the operations that we wish to perform on abstract syntax trees. We introduce \"visitors\", a simple type-directed facility for generating visitor classes that have no knowledge of binding. Separately, we present \"alphaLib\", a library of small hand-written visitor classes, each of which knows about a specific binding construct, a specific representation of names, and/or a specific operation on abstract syntax trees. By combining these components, a wide range of operations can be defined. Multiple representations of names can be supported, as well as conversions between representations. Binding structure can be described either in a programmatic style, by writing visitor methods, or in a declarative style, via preprogrammed binding combinators.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110272", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/Pottier17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110261", + "title": "Verified low-level programming embedded in F", + "abstract": "We present Low*, a language for low-level programming and verification, and its application to high-assurance optimized cryptographic libraries. Low* is a shallow embedding of a small, sequential, well-behaved subset of C in F*, a dependently- typed variant of ML aimed at program verification. Departing from ML, Low* does not involve any garbage collection or implicit heap allocation; instead, it has a structured memory model à la CompCert, and it provides the control required for writing efficient low-level security-critical code. By virtue of typing, any Low* program is memory safe. In addition, the programmer can make full use of the verification power of F* to write high-level specifications and verify the functional correctness of Low* code using a combination of SMT automation and sophisticated manual proofs. At extraction time, specifications and proofs are erased, and the remaining code enjoys a predictable translation to C. We prove that this translation preserves semantics and side-channel resistance. We provide a new compiler back-end from Low* to C and, to evaluate our approach, we implement and verify various cryptographic algorithms, constructions, and tools for a total of about 28,000 lines of code. We show that our Low* code delivers performance competitive with existing (unverified) C cryptographic libraries, suggesting our approach may be applicable to larger-scale low-level software.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110261", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jean-Karim", + "last_name": "Zinzindohoué", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Peng", + "last_name": "Wang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Santiago", + "last_name": "Zanella-Béguelin", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Antoine", + "last_name": "Delignat-Lavaud", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Karthikeyan", + "last_name": "Bhargavan", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/ProtzenkoZRRWBD17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110260", + "title": "Persistence for the masses: RRB-vectors in a systems language", + "abstract": "Relaxed Radix Balanced Trees (RRB-Trees) is one of the latest members in a family of persistent tree based data-structures that combine wide branching factors with simple and relatively flat structures. Like the battle-tested immutable sequences of Clojure and Scala, they have effectively constant lookup and updates, good cache utilization, but also logarithmic concatenation and slicing. Our goal is to bring the benefits of persistent data structures to the discipline of systems programming via generic yet efficient immutable vectors supporting transient batch updates. We describe a C++ implementation that can be integrated in the runtime of higher level languages with a C core (Lisps like Guile or Racket, but also Python or Ruby), thus widening the access to these persistent data structures. In this work we propose (1) an Embedding RRB-Tree (ERRB-Tree) data structure that efficiently stores arbitrary unboxed types, (2) a technique for implementing tree operations orthogonal to optimizations for a more compact representation of the tree, (3) a policy-based design to support multiple memory management and reclamation mechanisms (including automatic garbage collection and reference counting), (4) a model of transience based on move-semantics and reference counting, and (5) a definition of transience for confluent meld operations. Combining these techniques a performance comparable to that of mutable arrays can be achieved in many situations, while using the data structure in a functional way.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110260", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Juan Pedro Bolívar", + "last_name": "Puente", + "institution": "N&N Pharmaceuticals (United States)" + } + ], + "dblp_key": "journals/pacmpl/Puente17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110258", + "title": "Imperative functional programs that explain their work", + "abstract": "Program slicing provides explanations that illustrate how program outputs were produced from inputs. We build on an approach introduced in prior work, where dynamic slicing was defined for pure higher-order functional programs as a Galois connection between lattices of partial inputs and partial outputs. We extend this approach to imperative functional programs that combine higher-order programming with references and exceptions. We present proofs of correctness and optimality of our approach and a proof-of-concept implementation and experimental evaluation.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110258", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Wilmer", + "last_name": "Ricciotti", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jan", + "last_name": "Stolarek", + "institution": "University of Edinburgh" + }, + { + "first_name": "Roly", + "last_name": "Perera", + "institution": "University of Edinburgh" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/RicciottiSPC17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110249", + "title": "Faster coroutine pipelines", + "abstract": "Coroutine pipelines provide an attractive structuring mechanism for complex programs that process streams of data, with the advantage over lazy streams that both ends of a pipeline may interact with the I/O system, as may processes in the middle. Two popular Haskell libraries, Pipes and Conduit, support such pipelines. In both libraries, pipelines are implemented in a direct style by combining a free monad of communication events with an interpreter for (pseudo-)parallel composition that interleaves the events of its argument processes. These implementations both suffer from a slow-down when processes are deeply nested in sequence or in parallel. We propose an alternative implementation of pipelines based on continuations that does not suffer from this slow-down. What is more, the implementation is significantly faster on small, communication-intensive examples even where they do not suffer from the slow-down, and comparable in speed with similar programs based on lazy streams. We also show that the continuation-based implementation may be derived from the direct-style implementation by algebraic reasoning.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110249", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael Z.", + "last_name": "Spivey", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/Spivey17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110269", + "title": "SpaceSearch: a library for building and verifying solver-aided tools", + "abstract": "Many verification tools build on automated solvers. These tools reduce problems in a specific application domain (e.g., compiler optimization validation) to queries that can be discharged with a highly optimized solver. But the correctness of the reductions themselves is rarely verified in practice, limiting the confidence that the solver's output establishes the desired domain-level property. This paper presents SpaceSearch, a new library for developing solver-aided tools within a proof assistant. A user builds their solver-aided tool in Coq against the SpaceSearch interface, and the user then verifies that the results provided by the interface are sufficient to establish the tool's desired high-level properties. Once verified, the tool can be extracted to an implementation in a solver-aided language (e.g., Rosette), where SpaceSearch provides an efficient instantiation of the SpaceSearch interface with calls to an underlying SMT solver. This combines the strong correctness guarantees of developing a tool in a proof assistant with the high performance of modern SMT solvers. This paper also introduces new optimizations for such verified solver-aided tools, including parallelization and incrementalization. We evaluate SpaceSearch by building and verifying two solver-aided tools. The first, SaltShaker, checks that RockSalt's x86 semantics for a given instruction agrees with STOKE's x86 semantics. SaltShaker identified 7 bugs in RockSalt and 1 bug in STOKE. After these systems were patched by their developers, SaltShaker verified the semantics' agreement on 15,255 instruction instantiations in under 2h. The second tool, BGProof, is a verified version of an existing Border Gateway Protocol (BGP) router configuration checker. Like the existing checker, BGProof scales to checking industrial configurations spanning over 240 KLOC, identifying 19 configuration inconsistencies with no false positives. However, the correctness of BGProof has been formally proven, and we found 2 bugs in the unverified implementation. These results demonstrate that SpaceSearch is a practical approach to developing efficient, verified solver-aided tools.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110269", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Konstantin", + "last_name": "Weitz", + "institution": "University of Washington" + }, + { + "first_name": "Steven", + "last_name": "Lyubomirsky", + "institution": "University of Washington" + }, + { + "first_name": "Stefan", + "last_name": "Heule", + "institution": "Stanford University" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/WeitzLHTET17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110275", + "title": "A specification for dependent types in Haskell", + "abstract": "We propose a core semantics for Dependent Haskell, an extension of Haskell with full-spectrum dependent types. Our semantics consists of two related languages. The first is a Curry-style dependently-typed language with nontermination, irrelevant arguments, and equality abstraction. The second, inspired by the Glasgow Haskell Compiler's core language FC, is its explicitly-typed analogue, suitable for implementation in GHC. All of our results---chiefly, type safety, along with theorems that relate these two languages---have been formalized using the Coq proof assistant. Because our work is backwards compatible with Haskell, our type safety proof holds in the presence of nonterminating computation. However, unlike other full-spectrum dependently-typed languages, such as Coq, Agda or Idris, because of this nontermination, Haskell's term language does not correspond to a consistent logic.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110275", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Antoine", + "last_name": "Voizard", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Pedro H. Azevedo de", + "last_name": "Amorim", + "institution": "Universidade Estadual de Campinas (UNICAMP)" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + } + ], + "dblp_key": "journals/pacmpl/WeirichVAE17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110245", + "title": "Herbarium Racketensis: a stroll through the woods (functional pearl)", + "abstract": "Domain-specific languages are the ultimate abstraction, dixit Paul Hudak. But what abstraction should we use to build such ultimate abstractions? What is sauce for the goose is sauce for the gander: a language, of course! Racket is the ultimate abstraction-abstraction, a platform for quickly and easily building new ultimate abstractions. This pearl demonstrates Racket's power by taking a leisurely walk through the implementation of a DSL for Lindenmayer systems, the computational model par excellence of theoretical botany.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110245", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Vincent", + "last_name": "St-Amour", + "institution": "Northwestern University" + }, + { + "first_name": "Daniel", + "last_name": "Feltey", + "institution": "Northwestern University" + }, + { + "first_name": "Spencer P.", + "last_name": "Florence", + "institution": "Northwestern University" + }, + { + "first_name": "Shu-Hung", + "last_name": "You", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/St-AmourFFYF17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110280", + "title": "Whip: higher-order contracts for modern services", + "abstract": "Modern service-oriented applications forgo semantically rich protocols and middleware when composing services. Instead, they embrace the loosely-coupled development and deployment of services that communicate via simple network protocols. Even though these applications do expose interfaces that are higher-order in spirit, the simplicity of the network protocols forces them to rely on brittle low-level encodings. To bridge the apparent semantic gap, programmers introduce ad-hoc and error-prone defensive code. Inspired by Design by Contract, we choose a different route to bridge this gap. We introduce Whip, a contract system for modern services. Whip (i) provides programmers with a higher-order contract language tailored to the needs of modern services; and (ii) monitors services at run time to detect services that do not live up to their advertised interfaces. Contract monitoring is local to a service. Services are treated as black boxes, allowing heterogeneous implementation languages without modification to services' code. Thus, Whip does not disturb the loosely coupled nature of modern services.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110280", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lucas", + "last_name": "Waye", + "institution": "Harvard University Press" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Harvard University Press" + } + ], + "dblp_key": "journals/pacmpl/WayeCD17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110254", + "title": "A framework for adaptive differential privacy", + "abstract": "Differential privacy is a widely studied theory for analyzing sensitive data with a strong privacy guarantee—any change in an individual's data can have only a small statistical effect on the result—and a growing number of programming languages now support differentially private data analysis. A common shortcoming of these languages is poor support for adaptivity . In practice, a data analyst rarely wants to run just one function over a sensitive database, nor even a predetermined sequence of functions with fixed privacy parameters; rather, she wants to engage in an interaction where, at each step, both the choice of the next function and its privacy parameters are informed by the results of prior functions. Existing languages support this scenario using a simple composition theorem , which often gives rather loose bounds on the actual privacy cost of composite functions, substantially reducing how much computation can be performed within a given privacy budget. The theory of differential privacy includes other theorems with much better bounds, but these have not yet been incorporated into programming languages. We propose a novel framework for adaptive composition that is elegant, practical, and implementable. It consists of a reformulation based on typed functional programming of privacy filters , together with a concrete realization of this framework in the design and implementation of a new language, called Adaptive Fuzz . Adaptive Fuzz transplants the core static type system of Fuzz to the adaptive setting by wrapping the Fuzz typechecker and runtime system in an outer adaptive layer , allowing Fuzz programs to be conveniently constructed and typechecked on the fly. We describe an interpreter for Adaptive Fuzz and report results from two case studies demonstrating its effectiveness for implementing common statistical algorithms over real data sets.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110254", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Winograd-Cort", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Andreas", + "last_name": "Haeberlen", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Aaron", + "last_name": "Roth", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/Winograd-CortHR17", + "venue": "icfp", + "year": 2017 + }, + { + "paper_id": "10.1145/3110273", + "title": "Staged generic programming", + "abstract": "Generic programming libraries such as Scrap Your Boilerplate eliminate the need to write repetitive code, but typically introduce significant performance overheads. This leaves programmers with the regrettable choice between writing succinct but slow programs and writing tedious but efficient programs. Applying structured multi-stage programming techniques transforms Scrap Your Boilerplate from an inefficient library into a typed optimising code generator, bringing its performance in line with hand-written code, and so combining high-level programming with uncompromised performance.", + "date": "2017-08-29", + "link": "https://doi.org/10.1145/3110273", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/Yallop17", + "venue": "icfp", + "year": 2017 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2018.json b/data/pl_conferences/icfp/2018.json new file mode 100644 index 0000000..5182fcc --- /dev/null +++ b/data/pl_conferences/icfp/2018.json @@ -0,0 +1,1182 @@ +[ + { + "paper_id": "10.1145/3236789", + "title": "Tight typings and split bounds", + "abstract": "Multi types—aka non-idempotent intersection types—have been used to obtain quantitative bounds on higher-order programs, as pioneered by de Carvalho. Notably, they bound at the same time the number of evaluation steps and the size of the result. Recent results show that the number of steps can be taken as a reasonable time complexity measure. At the same time, however, these results suggest that multi types provide quite lax complexity bounds, because the size of the result can be exponentially bigger than the number of steps. Starting from this observation, we refine and generalise a technique introduced by Bernadet & Graham-Lengrand to provide exact bounds for the maximal strategy. Our typing judgements carry two counters, one measuring evaluation lengths and the other measuring result sizes. In order to emphasise the modularity of the approach, we provide exact bounds for four evaluation strategies, both in the λ-calculus (head, leftmost-outermost, and maximal evaluation) and in the linear substitution calculus (linear head evaluation). Our work aims at both capturing the results in the literature and extending them with new outcomes. Concerning the literature, it unifies de Carvalho and Bernadet & Graham-Lengrand via a uniform technique and a complexity-based perspective. The two main novelties are exact split bounds for the leftmost strategy—the only known strategy that evaluates terms to full normal forms and provides a reasonable complexity measure—and the observation that the computing device hidden behind multi types is the notion of substitution at a distance, as implemented by the linear substitution calculus.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236789", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "École Polytechnique" + }, + { + "first_name": "Stéphane", + "last_name": "Graham-Lengrand", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Delia", + "last_name": "Kesner", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "journals/pacmpl/AccattoliGK18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236779", + "title": "What you needa know about Yoneda: profunctor optics and the Yoneda lemma (functional pearl)", + "abstract": "Profunctor optics are a neat and composable representation of bidirectional data accessors, including lenses, and their dual, prisms. The profunctor representation exploits higher-order functions and higher-kinded type constructor classes, but the relationship between this and the familiar representation in terms of \"getter\" and \"setter\" functions is not at all obvious. We derive the profunctor representation from the concrete representation, making the relationship clear. It turns out to be a fairly direct application of the Yoneda Lemma, arguably the most important result in category theory. We hope this derivation aids understanding of the profunctor representation. Conversely, it might also serve to provide some insight into the Yoneda Lemma.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236779", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Boisseau", + "institution": "University of Oxford" + }, + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/BoisseauG18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236770", + "title": "Elaborating dependent (co)pattern matching", + "abstract": "In a dependently typed language, we can guarantee correctness of our programs by providing formal proofs. To check them, the typechecker elaborates these programs and proofs into a low level core language. However, this core language is by nature hard to understand by mere humans, so how can we know we proved the right thing? This question occurs in particular for dependent copattern matching, a powerful language construct for writing programs and proofs by dependent case analysis and mixed induction/coinduction. A definition by copattern matching consists of a list of clauses that are elaborated to a case tree , which can be further translated to primitive eliminators . In previous work this second step has received a lot of attention, but the first step has been mostly ignored so far. We present an algorithm elaborating definitions by dependent copattern matching to a core language with inductive datatypes, coinductive record types, an identity type, and constants defined by well-typed case trees. To ensure correctness, we prove that elaboration preserves the first-match semantics of the user clauses. Based on this theoretical work, we reimplement the algorithm used by Agda to check left-hand sides of definitions by pattern matching. The new implementation is at the same time more general and less complex, and fixes a number of bugs and usability issues with the old version. Thus we take another step towards the formally verified implementation of a practical dependently typed language.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236770", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jesper", + "last_name": "Cockx", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "journals/pacmpl/CockxA18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236765", + "title": "The simple essence of automatic differentiation", + "abstract": "Automatic differentiation (AD) in reverse mode (RAD) is a central component of deep learning and other uses of large-scale optimization. Commonly used RAD algorithms such as backpropagation, however, are complex and stateful, hindering deep understanding, improvement, and parallel execution. This paper develops a simple, generalized AD algorithm calculated from a simple, natural specification. The general algorithm is then specialized by varying the representation of derivatives. In particular, applying well-known constructions to a naive representation yields two RAD algorithms that are far simpler than previously known. In contrast to commonly used RAD implementations, the algorithms defined here involve no graphs, tapes, variables, partial derivatives, or mutation. They are inherently parallel-friendly, correct by construction, and usable directly from an existing programming language with no need for new data types or programming style, thanks to use of an AD-agnostic compiler plugin.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236765", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "Target (United States)" + } + ], + "dblp_key": "journals/pacmpl/Elliott18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236798", + "title": "Merlin: a language server for OCaml (experience report)", + "abstract": "We report on the experience of developing Merlin, a language server for the OCaml programming language in development since 2013. Merlin is a daemon that connects to your favourite text editor and provides services that require a fine-grained understanding of the programming language syntax and static semantics: instant feedback on warnings and errors, autocompletion, \"type of the code under the cursor\", \"go to definition\", etc. Language servers need to handle incomplete and partially-incorrect programs, and try to be incremental to minimize recomputation after small editing actions. Merlin was built by carefully adapting the existing tools (the OCamllex lexer and Menhir parser generators) to better support incrementality, incompleteness and error handling. These extensions are elegant and general, as demonstrated by the interesting, unplanned uses that the OCaml community found for them. They could be adapted to other frontends -- in any language. Besides incrementality, we discuss the way Merlin communicates with editors, describe the design decisions that went into some demanding features and report on some of the non-apparent difficulties in building good editor support, emerging from expressive programming languages or frustrating tooling ecosystems. We expect this experience report to be of interest to authors of interactive language tooling for any programming language; many design choices may be reused, and some hard-won lessons can serve as warnings.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236798", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Frédéric", + "last_name": "Bour", + "institution": "Meta (Israel)" + }, + { + "first_name": "Thomas", + "last_name": "Refis", + "institution": "" + }, + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/BourRS18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236799", + "title": "Generic zero-cost reuse for dependent types", + "abstract": "Dependently typed languages are well known for having a problem with code reuse. Traditional non-indexed algebraic datatypes (e.g. lists) appear alongside a plethora of indexed variations (e.g. vectors). Functions are often rewritten for both non-indexed and indexed versions of essentially the same datatype, which is a source of code duplication. We work in a Curry-style dependent type theory, where the same untyped term may be classified as both the non-indexed and indexed versions of a datatype. Many solutions have been proposed for the problem of dependently typed reuse, but we exploit Curry-style type theory in our solution to not only reuse data and programs, but do so at zero-cost (without a runtime penalty). Our work is an exercise in dependently typed generic programming, and internalizes the process of zero-cost reuse as the identity function in a Curry-style theory.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236799", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Larry", + "last_name": "Diehl", + "institution": "University of Iowa" + }, + { + "first_name": "Denis", + "last_name": "Firsov", + "institution": "University of Iowa" + }, + { + "first_name": "Aaron", + "last_name": "Stump", + "institution": "University of Iowa" + } + ], + "dblp_key": "journals/pacmpl/DiehlFS18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236777", + "title": "Teaching how to program using automated assessment and functional glossy games (experience report)", + "abstract": "Our department has long been an advocate of the functional-first school of programming and has been teaching Haskell as a first language in introductory programming course units for 20 years. Although the functional style is largely beneficial, it needs to be taught in an enthusiastic and captivating way to fight the unusually high computer science drop-out rates and appeal to a heterogeneous population of students. This paper reports our experience of restructuring, over the last 5 years, an introductory laboratory course unit that trains hands-on functional programming concepts and good software development practices. We have been using game programming to keep students motivated, and following a methodology that hinges on test-driven development and continuous bidirectional feedback . We summarise successes and missteps, and how we have learned from our experience to arrive at a model for comprehensive and interactive functional game programming assignments and a general functionally-powered automated assessment platform , that together provide a more engaging learning experience for students. In our experience, we have been able to teach increasingly more advanced functional programming concepts while improving student engagement.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236777", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "José Bacelar", + "last_name": "Almeida", + "institution": "University of Minho" + }, + { + "first_name": "Alcino", + "last_name": "Cunha", + "institution": "INESC TEC" + }, + { + "first_name": "Nuno", + "last_name": "Macedo", + "institution": "INESC TEC" + }, + { + "first_name": "Hugo", + "last_name": "Pacheco", + "institution": "University of Minho" + }, + { + "first_name": "José", + "last_name": "Proença", + "institution": "University of Minho" + } + ], + "dblp_key": "journals/pacmpl/AlmeidaCM0P18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236792", + "title": "Static interpretation of higher-order modules in Futhark: functional GPU programming in the large", + "abstract": "We present a higher-order module system for the purely functional data-parallel array language Futhark. The module language has the property that it is completely eliminated at compile time, yet it serves as a powerful tool for organizing libraries and complete programs. The presentation includes a static and a dynamic semantics for the language in terms of, respectively, a static type system and a provably terminating elaboration of terms into terms of an underlying target language. The development is formalised in Coq using a novel encoding of semantic objects based on products, sets, and finite maps. The module language features a unified treatment of module type abstraction and core language polymorphism and is rich enough for expressing practical forms of module composition.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236792", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" + }, + { + "first_name": "Troels", + "last_name": "Henriksen", + "institution": "University of Copenhagen" + }, + { + "first_name": "Danil", + "last_name": "Annenkov", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Cosmin E.", + "last_name": "Oancea", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/ElsmanHAO18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236797", + "title": "Keep your laziness in check", + "abstract": "We introduce StrictCheck: a property-based random testing framework for observing, specifying, and testing the strictness of Haskell functions. Strictness is traditionally considered a non-functional property; StrictCheck allows it to be tested as if it were one, by reifying demands on data structures so they can be manipulated and examined within Haskell. Testing strictness requires us to 1) precisely specify the strictness of functions, 2) efficiently observe the evaluation of data structures, and 3) correctly generate functions with random strictness. We tackle all three of these challenges, designing an efficient generic framework for precise dynamic strictness testing. StrictCheck can specify and test the strictness of any Haskell function---including higher-order ones---with only a constant factor of overhead, and requires no boilerplate for testing functions on Haskell-standard algebraic data types. We provide an expressive but low-level specification language as a foundation upon which to build future higher-level abstractions. We demonstrate a non-trivial application of our library, developing a correct specification of a data structure whose properties intrinsically rely on subtle use of laziness: Okasaki's constant-time purely functional queue.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236797", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kenneth", + "last_name": "Foner", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Hengchu", + "last_name": "Zhang", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/FonerZL18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236762", + "title": "Versatile event correlation with algebraic effects", + "abstract": "We present the first language design to uniformly express variants of n -way joins over asynchronous event streams from different domains, e.g., stream-relational algebra, event processing, reactive and concurrent programming. We model asynchronous reactive programs and joins in direct style, on top of algebraic effects and handlers. Effect handlers act as modular interpreters of event notifications, enabling fine-grained control abstractions and customizable event matching. Join variants can be considered as cartesian product computations with ”degenerate” control flow, such that unnecessary tuples are not materialized a priori. Based on this computational interpretation, we decompose joins into a generic, naive enumeration procedure of the cartesian product, plus variant-specific extensions, represented in terms of user-supplied effect handlers. Our microbenchmarks validate that this extensible design avoids needless materialization. Alongside a formal semantics for joining and prototypes in Koka and multicore OCaml, we contribute a systematic comparison of the covered domains and features.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236762", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "University of Cambridge" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Delft University of Technology" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "journals/pacmpl/BracevacASEEM18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236785", + "title": "A type and scope safe universe of syntaxes with binding: their semantics and proofs", + "abstract": "Almost every programming language’s syntax includes a notion of binder and corresponding bound occurrences, along with the accompanying notions of α-equivalence, capture avoiding substitution, typing contexts, runtime environments, and so on. In the past, implementing and reasoning about programming languages required careful handling to maintain the correct behaviour of bound variables. Modern programming languages include features that enable constraints like scope safety to be expressed in types. Nevertheless, the programmer is still forced to write the same boilerplate over again for each new implementation of a scope safe operation (e.g., renaming, substitution, desugaring, printing, etc.), and then again for correctness proofs. We present an expressive universe of syntaxes with binding and demonstrate how to (1) implement scope safe traversals once and for all by generic programming; and (2) how to derive properties of these traversals by generic proving. Our universe description, generic traversals and proofs, and our examples have all been formalised in Agda and are available in the accompanying material. NB. we recommend printing the paper in colour to benefit from syntax highlighting in code fragments.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236785", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Allais", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Robert", + "last_name": "Atkey", + "institution": "University of Strathclyde" + }, + { + "first_name": "James", + "last_name": "Chapman", + "institution": "University of Strathclyde" + }, + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" + }, + { + "first_name": "James", + "last_name": "McKinna", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/AllaisA0MM18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236786", + "title": "Parallel complexity analysis with temporal session types", + "abstract": "We study the problem of parametric parallel complexity analysis of concurrent, message-passing programs. To make the analysis local and compositional, it is based on a conservative extension of binary session types, which structure the type and direction of communication between processes and stand in a Curry-Howard correspondence with intuitionistic linear logic. The main innovation is to enrich session types with the temporal modalities next (◯ A ), always (□ A ), and eventually (◇ A ), to additionally prescribe the timing of the exchanged messages in a way that is precise yet flexible. The resulting temporal session types uniformly express properties such as the message rate of a stream, the latency of a pipeline, the response time of a concurrent queue, or the span of a fork/join parallel program. The analysis is parametric in the cost model and the presentation focuses on communication cost as a concrete example. The soundness of the analysis is established by proofs of progress and type preservation using a timed multiset rewriting semantics. Representative examples illustrate the scope and usability of the approach.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236786", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ankush", + "last_name": "Das", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/Das0P18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236784", + "title": "Ready, set, verify! applying hs-to-coq to real-world Haskell code (experience report)", + "abstract": "Good tools can bring mechanical verification to programs written in mainstream functional languages. We use <pre>hs-to-coq</pre> to translate significant portions of Haskell’s <pre>containers</pre> library into Coq, and verify it against specifications that we derive from a variety of sources including type class laws, the library’s test suite, and interfaces from Coq’s standard library. Our work shows that it is feasible to verify mature, widely-used, highly optimized, and unmodified Haskell code. We also learn more about the theory of weight-balanced trees, extend <pre>hs-to-coq</pre> to handle partiality, and – since we found no bugs – attest to the superb quality of well-tested functional code.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236784", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joachim", + "last_name": "Breitner", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Antal", + "last_name": "Spector-Zabusky", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Yao", + "last_name": "Li", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Christine", + "last_name": "Rizkallah", + "institution": "UNSW Sydney" + }, + { + "first_name": "John", + "last_name": "Wiegley", + "institution": "BAE Systems (United States)" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/BreitnerSLRWW18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236793", + "title": "Casts and costs: harmonizing safety and performance in gradual typing", + "abstract": "Gradual typing allows programmers to use both static and dynamic typing in a single program. However, a well-known problem with sound gradual typing is that the interactions between static and dynamic code can cause significant performance degradation. These performance pitfalls are hard to predict and resolve, and discourage users from using gradual typing features. For example, when migrating to a more statically typed program, often adding a type annotation will trigger a slowdown that can be resolved by adding more annotations elsewhere, but since it is not clear where the additional annotations must be added, the easier solution is to simply remove the annotation. To address these problems, we develop: (1) a static cost semantics that accurately predicts the overhead of static-dynamic interactions in a gradually typed program, (2) a technique for efficiently inferring such costs for all combinations of inferrable type assignments in a program, and (3) a method for translating the results of this analysis into specific recommendations and explanations that can help programmers understand, debug, and optimize the performance of gradually typed programs. We have implemented our approach in Herder, a tool for statically analyzing the performance of different typing configurations for Reticulated Python programs. An evaluation on 15 Python programs shows that Herder can use this analysis to accurately and efficiently recommend type assignments that optimize the performance of these programs without sacrificing the safety guarantees provided by static typing.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236793", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John Peter", + "last_name": "Campora", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Eric", + "last_name": "Walkingshaw", + "institution": "Oregon State University" + } + ], + "dblp_key": "journals/pacmpl/Campora0W18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236781", + "title": "Relational algebra by way of adjunctions", + "abstract": "Bulk types such as sets, bags, and lists are monads, and therefore support a notation for database queries based on comprehensions. This fact is the basis of much work on database query languages. The monadic structure easily explains most of standard relational algebra---specifically, selections and projections---allowing for an elegant mathematical foundation for those aspects of database query language design. Most, but not all: monads do not immediately offer an explanation of relational join or grouping, and hence important foundations for those crucial aspects of relational algebra are missing. The best they can offer is cartesian product followed by selection. Adjunctions come to the rescue: like any monad, bulk types also arise from certain adjunctions; we show that by paying due attention to other important adjunctions, we can elegantly explain the rest of standard relational algebra. In particular, graded monads provide a mathematical foundation for indexing and grouping, which leads directly to an efficient implementation, even of joins.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236781", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + }, + { + "first_name": "Fritz", + "last_name": "Henglein", + "institution": "University of Copenhagen" + }, + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/GibbonsHHW18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236764", + "title": "Handling delimited continuations with dependent types", + "abstract": "Dependent types are a powerful tool for maintaining program invariants. To take advantage of this aspect in real-world programming, efforts have been put into enriching dependently typed languages with missing constructs, most notably, effects. This paper presents a language that has two practically interesting ingredients: dependent inductive types, and the delimited control constructs shift and reset. When integrating delimited control into a dependently typed language, however, two challenges arise. First, the dynamic nature of control operators, which is the source of their expressiveness, can break fundamental language properties such as logical consistency and subject reduction. Second, CPS translations, which we often use to define the semantics of control operators, do not scale straightforwardly to dependently typed languages. We solve the former issue by restricting dependency of types, and the latter using answer-type polymorphism of pure terms. The main contribution of this paper is to give a sound type system of our language, as well as a type-preserving CPS translation. We also discuss various extensions, which would make our language more like a full-spectrum proof assistant but pose non-trivial issues.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236764", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Youyou", + "last_name": "Cong", + "institution": "Ochanomizu University" + }, + { + "first_name": "Kenichi", + "last_name": "Asai", + "institution": "Ochanomizu University" + } + ], + "dblp_key": "journals/pacmpl/CongA18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236774", + "title": "Build systems à la carte", + "abstract": "Build systems are awesome, terrifying -- and unloved. They are used by every developer around the world, but are rarely the object of study. In this paper we offer a systematic, and executable, framework for developing and comparing build systems, viewing them as related points in landscape rather than as isolated phenomena. By teasing apart existing build systems, we can recombine their components, allowing us to prototype new build systems with desired properties.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236774", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrey", + "last_name": "Mokhov", + "institution": "Newcastle University" + }, + { + "first_name": "Neil", + "last_name": "Mitchell", + "institution": "" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/MokhovMJ18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236766", + "title": "A spectrum of type soundness and performance", + "abstract": "The literature on gradual typing presents three fundamentally different ways of thinking about the integrity of programs that combine statically typed and dynamically typed code. This paper presents a uniform semantic framework that explains all three approaches, illustrates how each approach affects a developer's work, and adds a systematic performance comparison for a single implementation platform.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236766", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/GreenmanF18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236763", + "title": "Parametric polymorphism and operational improvement", + "abstract": "Parametricity, in both operational and denotational forms, has long been a useful tool for reasoning about program correctness. However, there is as yet no comparable technique for reasoning about program improvement , that is, when one program uses fewer resources than another. Existing theories of parametricity cannot be used to address this problem as they are agnostic with regard to resource usage. This article addresses this problem by presenting a new operational theory of parametricity that is sensitive to time costs, which can be used to reason about time improvement properties. We demonstrate the applicability of our theory by showing how it can be used to prove that a number of well-known program fusion techniques are time improvements, including fixed point fusion, map fusion and short cut fusion.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236763", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jennifer", + "last_name": "Hackett", + "institution": "University of Nottingham" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/HackettH18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236783", + "title": "Strict and lazy semantics for effects: layering monads and comonads", + "abstract": "Two particularly important classes of effects are those that can be given semantics using a monad and those that can be given semantics using a comonad. Currently, programs with both kinds of effects are usually given semantics using a technique that relies on a distributive law. While it is known that not every pair of a monad and a comonad has a distributive law, it was previously unknown if there were any realistic pairs of effects that could not be given semantics in this manner. This paper answers that question by giving an example of a pair of effects that cannot be given semantics using a distributive law. Our example furthermore is intimately tied to the duality of strictness and laziness. We discuss how to view this duality through the lens of effects.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236783", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrew K.", + "last_name": "Hirsch", + "institution": "Cornell University" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/HirschT18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236767", + "title": "Compositional soundness proofs of abstract interpreters", + "abstract": "Abstract interpretation is a technique for developing static analyses. Yet, proving abstract interpreters sound is challenging for interesting analyses, because of the high proof complexity and proof effort . To reduce complexity and effort, we propose a framework for abstract interpreters that makes their soundness proof compositional. Key to our approach is to capture the similarities between concrete and abstract interpreters in a single shared interpreter, parameterized over an arrow-based interface. In our framework, a soundness proof is reduced to proving reusable soundness lemmas over the concrete and abstract instances of this interface; the soundness of the overall interpreters follows from a generic theorem. To further reduce proof effort, we explore the relationship between soundness and parametricity. Parametricity not only provides us with useful guidelines for how to design non-leaky interfaces for shared interpreters, but also provides us soundness of shared pure functions as free theorems . We implemented our framework in Haskell and developed a k -CFA analysis for PCF and a tree-shape analysis for Stratego. We were able to prove both analyses sound compositionally with manageable complexity and effort, compared to a conventional soundness proof.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236767", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sven", + "last_name": "Keidel", + "institution": "Delft University of Technology" + }, + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/KeidelPE18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236773", + "title": "Mtac2: typed tactics for backward reasoning in Coq", + "abstract": "Coq supports a range of built-in tactics, which are engineered primarily to support backward reasoning . Starting from a desired goal, the Coq programmer can use these tactics to manipulate the proof state interactively, applying axioms or lemmas to break the goal into subgoals until all subgoals have been solved. Additionally, it provides support for tactic programming via OCaml and Ltac, so that users can roll their own custom proof automation routines. Unfortunately, though, these tactic languages share a significant weakness. They do not offer the tactic programmer any static guarantees about the soundness of their custom tactics, making large tactic developments difficult to maintain. To address this limitation, Ziliani et al. previously proposed Mtac , a new typed approach to custom proof automation in Coq which provides the static guarantees that OCaml and Ltac are missing. However, despite its name, Mtac is really more of a metaprogramming language than it is a full-blown tactic language: it misses an essential feature of tactic programming, namely the ability to directly manipulate Coq’s proof state and perform backward reasoning on it. In this paper, we present Mtac2 , a next-generation version of Mtac that combines its support for typed metaprogramming with additional support for the programming of backward-reasoning tactics in the style of Ltac. In so doing, Mtac2 introduces a novel feature in tactic programming languages—what we call typed backward reasoning . With this feature, Mtac2 is capable of statically ruling out several classes of errors that would otherwise remain undetected at tactic definition time. We demonstrate the utility of Mtac2’s typed tactics by porting several tactics from a large Coq development, the Iris Proof Mode, from Ltac to Mtac2.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236773", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jan-Oliver", + "last_name": "Kaiser", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Beta", + "last_name": "Ziliani", + "institution": "Universidad Nacional de Córdoba" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + }, + { + "first_name": "Yann", + "last_name": "Régis-Gianas", + "institution": "Université Paris Cité" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/KaiserZKRD18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236780", + "title": "Generic deriving of generic traversals", + "abstract": "Functional programmers have an established tradition of using traversals as a design pattern to work with recursive data structures. The technique is so prolific that a whole host of libraries have been designed to help in the task of automatically providing traversals by analysing the generic structure of data types. More recently, lenses have entered the functional scene and have proved themselves to be a simple and versatile mechanism for working with product types. They make it easy to focus on the salient parts of a data structure in a composable and reusable manner. This paper uses the combination of lenses and traversals to give rise to a library with unprecedented expressivity and flexibility for querying and modifying complex data structures. Furthermore, since lenses and traversals are based on the generic shape of data, this information is used to generate code that is as efficient as hand-optimised versions. The technique leverages the structure of data to produce generic abstractions that are then eliminated by the standard workhorses of modern functional compilers: inlining and specialisation.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236780", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Csongor", + "last_name": "Kiss", + "institution": "Imperial College London" + }, + { + "first_name": "Matthew C.", + "last_name": "Pickering", + "institution": "University of Bristol" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/KissPW18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236771", + "title": "Capturing the future by replaying the past (functional pearl)", + "abstract": "Delimited continuations are the mother of all monads! So goes the slogan inspired by Filinski’s 1994 paper, which showed that delimited continuations can implement any monadic effect, letting the programmer use an effect as easily as if it was built into the language. It’s a shame that not many languages have delimited continuations. Luckily, exceptions and state are also the mother of all monads! In this Pearl, we show how to implement delimited continuations in terms of exceptions and state, a construction we call thermometer continuations . While traditional implementations of delimited continuations require some way of ”capturing” an intermediate state of the computation, the insight of thermometer continuations is to reach this intermediate state by replaying the entire computation from the start, guiding it using a recording so that the same thing happens until the captured point. Along the way, we explain delimited continuations and monadic reflection, show how the Filinski construction lets thermometer continuations express any monadic effect, share an elegant special-case for nondeterminism, and discuss why our construction is not prevented by theoretical results that exceptions and state cannot macro-express continuations.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236771", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "James", + "last_name": "Koppel", + "institution": "Vassar College" + }, + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KoppelSS18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236769", + "title": "Incremental relational lenses", + "abstract": "Lenses are a popular approach to bidirectional transformations, a generalisation of the view update problem in databases, in which we wish to make changes to source tables to effect a desired change on a view . However, perhaps surprisingly, lenses have seldom actually been used to implement updatable views in databases. Bohannon, Pierce and Vaughan proposed an approach to updatable views called relational lenses , but to the best of our knowledge this proposal has not been implemented or evaluated to date. We propose incremental relational lenses , that equip relational lenses with change-propagating semantics that map small changes to the view to (potentially) small changes to the source tables. We also present a language-integrated implementation of relational lenses and a detailed experimental evaluation, showing orders of magnitude improvement over the non-incremental approach. Our work shows that relational lenses can be used to support expressive and efficient view updates at the language level, without relying on updatable view support from the underlying database.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236769", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Rudi", + "last_name": "Horn", + "institution": "University of Edinburgh" + }, + { + "first_name": "Roly", + "last_name": "Perera", + "institution": "University of Edinburgh" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/HornPC18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236776", + "title": "Finitary polymorphism for optimizing type-directed compilation", + "abstract": "We develop a type-theoretical method for optimizing type directed compilation of polymorphic languages, implement the method in SML#, which is a full-scale compiler of Standard ML extended with several advanced features that require type-passing operational semantics, and report its effectiveness through performance evaluation. For this purpose, we first define a predicative second-order lambda calculus with finitary polymorphism, where each type abstraction is explicitly constrained to a finite type universe, and establishes the type soundness with respect to a type-passing operational semantics. Different from a calculus with stratified type universes, type universes of the calculus are terms that represent a finite set of instance types. We then develop a universe reconstruction algorithm that takes a term of the standard second-order lambda calculus, checks if the term is typable with finitary polymorphism, and, if typable, constructs a term in the calculus of finitary polymorphism. Based on these results, we present a type-based optimization method for polymorphic functions. Since our formalism is based on the second-order lambda calculus, it can be used to optimize various polymorphic languages. We implement the optimization method for native (tag-free) data representation and record polymorphism, and evaluate its effectiveness through benchmarks. The evaluation shows that 83.79% of type passing abstractions are eliminated, and achieves the average of 15.28% speed-up of compiled code.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236776", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Tohoku University" + }, + { + "first_name": "Katsuhiro", + "last_name": "Ueno", + "institution": "Tohoku University" + }, + { + "first_name": "Hisayuki", + "last_name": "Mima", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/OhoriUM18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236775", + "title": "Synthesizing quotient lenses", + "abstract": "Quotient lenses are bidirectional transformations whose correctness laws are “loosened” by specified equivalence relations, allowing inessential details in concrete data formats to be suppressed. For example, a programmer could use a quotient lens to define a transformation that ignores the order of fields in XML data, so that two XML files with the same fields but in different orders would be considered the same, allowing a single, simple program to handle them both. Building on a recently published algorithm for synthesizing plain bijective lenses from high-level specifications, we show how to synthesize bijective quotient lenses in three steps. First, we introduce quotient regular expressions (QREs), annotated regular expressions that conveniently mark inessential aspects of string data formats; each QRE specifies, simulteneously, a regular language and an equivalence relation on it. Second, we introduce QRE lenses , i.e., lenses mapping between QREs. Our key technical result is a proof that every QRE lens can be transformed into a functionally equivalent lens that canonizes source and target data just at the “edges” and that uses a bijective lens to map between the respective canonical elements; no internal canonization occurs in a lens in this normal form. Third, we leverage this normalization theorem to synthesize QRE lenses from a pair of QREs and example input-output pairs, reusing earlier work on synthesizing plain bijective lenses. We have implemented QREs and QRE lens synthesis as an extension to the bidirectional programming language Boomerang. We evaluate the effectiveness of our approach by synthesizing QRE lenses between various real-world data formats in the Optician benchmark suite.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236775", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Solomon", + "last_name": "Maina", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Anders", + "last_name": "Miltner", + "institution": "Princeton University" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/MainaMFPWZ18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236790", + "title": "Competitive parallelism: getting your priorities right", + "abstract": "Multi-threaded programs have traditionally fallen into one of two domains: cooperative and competitive. These two domains have traditionally remained mostly disjoint, with cooperative threading used for increasing throughput in compute-intensive applications such as scientific workloads and cooperative threading used for increasing responsiveness in interactive applications such as GUIs and games. As multicore hardware becomes increasingly mainstream, there is a need for bridging these two disjoint worlds, because many applications mix interaction and computation and would benefit from both cooperative and competitive threading. In this paper, we present techniques for programming and reasoning about parallel interactive applications that can use both cooperative and competitive threading. Our techniques enable the programmer to write rich parallel interactive programs by creating and synchronizing with threads as needed, and by assigning threads user-defined and partially ordered priorities. To ensure important responsiveness properties, we present a modal type system analogous to S4 modal logic that precludes low-priority threads from delaying high-priority threads, thereby statically preventing a crucial set of priority-inversion bugs. We then present a cost model that allows reasoning about responsiveness and completion time of well-typed programs. The cost model extends the traditional work-span model for cooperative threading to account for competitive scheduling decisions needed to ensure responsiveness. Finally, we show that our proposed techniques are realistic by implementing them as an extension to the Standard ML language.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236790", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/MullerA018", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236794", + "title": "Functional programming for compiling and decompiling computer-aided design", + "abstract": "Desktop-manufacturing techniques like 3D printing are increasingly popular because they reduce the cost and complexity of producing customized objects on demand. Unfortunately, the vibrant communities of early adopters, often referred to as \"makers,\" are not well-served by currently available software pipelines. Users today must compose idiosyncratic sequences of tools which are typically repurposed variants of proprietary software originally designed for expert specialists. This paper proposes fundamental programming-languages techniques to bring improved rigor, reduced complexity, and new functionality to the computer-aided design (CAD) software pipeline for applications like 3D-printing. Compositionality, denotational semantics, compiler correctness, and program synthesis all play key roles in our approach, starting from the perspective that solid geometry is a programming language. Specifically, we define a purely functional language for CAD called LambdaCAD and a polygon surface-mesh intermediate representation. We then define denotational semantics of both languages to 3D solids and a compiler from CAD to mesh accompanied by a proof of semantics preservation. We illustrate the utility of this foundation by developing a novel synthesis algorithm based on evaluation contexts to \"reverse compile\" difficult-to-edit meshes downloaded from online maker communities back to more-editable CAD programs. All our prototypes have been implemented in OCaml to enable further exploration of functional programming for desktop manufacturing.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236794", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chandrakana", + "last_name": "Nandi", + "institution": "University of Washington" + }, + { + "first_name": "James R.", + "last_name": "Wilcox", + "institution": "University of Washington" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Washington" + }, + { + "first_name": "Taylor", + "last_name": "Blau", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/NandiWPBGT18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236772", + "title": "MoSeL: a general, extensible modal framework for interactive proofs in separation logic", + "abstract": "A number of tools have been developed for carrying out separation-logic proofs mechanically using an interactive proof assistant. One of the most advanced such tools is the Iris Proof Mode (IPM) for Coq, which offers a rich set of tactics for making separation-logic proofs look and feel like ordinary Coq proofs. However, IPM is tied to a particular separation logic (namely, Iris), thus limiting its applicability. In this paper, we propose MoSeL, a general and extensible Coq framework that brings the benefits of IPM to a much larger class of separation logics. Unlike IPM, MoSeL is applicable to both affine and linear separation logics (and combinations thereof), and provides generic tactics that can be easily extended to account for the bespoke connectives of the logics with which it is instantiated. To demonstrate the effectiveness of MoSeL, we have instantiated it to provide effective tactical support for interactive and semi-automated proofs in six very different separation logics.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236772", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Université Paris-Sud" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan-Oliver", + "last_name": "Kaiser", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "IMEC" + }, + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/KrebbersJ0TKTCD18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236768", + "title": "Graduality from embedding-projection pairs", + "abstract": "Gradually typed languages allow statically typed and dynamically typed code to interact while maintaining benefits of both styles. The key to reasoning about these mixed programs is Siek-Vitousek-Cimini-Boyland’s (dynamic) gradual guarantee, which says that giving components of a program more precise types only adds runtime type checking, and does not otherwise change behavior. In this paper, we give a semantic reformulation of the gradual guarantee called graduality . We change the name to promote the analogy that graduality is to gradual typing what parametricity is to polymorphism. Each gives a local-to-global, syntactic-to-semantic reasoning principle that is formulated in terms of a kind of observational approximation. Utilizing the analogy, we develop a novel logical relation for proving graduality. We show that embedding-projection pairs (ep pairs) are to graduality what relations are to parametricity. We argue that casts between two types where one is “more dynamic” (less precise) than the other necessarily form an ep pair, and we use this to cleanly prove the graduality cases for casts from the ep-pair property. To construct ep pairs, we give an analysis of the type dynamism relation—also known as type precision or naïve subtyping—that interprets the rules for type dynamism as compositional constructions on ep pairs, analogous to the coercion interpretation of subtyping.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236768", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Max S.", + "last_name": "New", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/NewA18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236801", + "title": "Reasonably programmable literal notation", + "abstract": "General-purpose programming languages typically define literal notation for only a small number of common data structures, like lists. This is unsatisfying because there are many other data structures for which literal notation might be useful, e.g. finite maps, regular expressions, HTML elements, SQL queries, syntax trees for various languages and chemical structures. There may also be different implementations of each of these data structures behind a common interface that could all benefit from common literal notation. This paper introduces typed literal macros (TLMs) , which allow library providers to define new literal notation of nearly arbitrary design at any specified type or parameterized family of types. Compared to existing approaches, TLMs are uniquely reasonable . TLM clients can reason abstractly, i.e. without examining grammars or generated expansions, about types and binding. The system only needs to convey to clients, via secondary notation, the inferred segmentation of each literal body, which gives the locations and types of spliced subterms. TLM providers can reason modularly about syntactic ambiguity and expansion correctness according to clear criteria. This paper incorporates TLMs into Reason, an emerging alternative front-end for OCaml, and demonstrates, through several non-trivial case studies, how TLMs integrate with the advanced features of OCaml, including pattern matching and the module system. We also discuss optional integration with MetaOCaml, which allows TLM providers to be more confident about type correctness. Finally, we establish these abstract reasoning principles formally with a detailed type-theoretic account of expression and pattern TLMs for “core ML”.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236801", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Chicago" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/OmarA18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236796", + "title": "What's the difference? a functional pearl on subtracting bijections", + "abstract": "It is a straightforward exercise to write a program to \"add\" two bijections---resulting in a bijection between two sum types, which runs the first bijection on elements from the left summand and the second bijection on the right. It is much less obvious how to \"subtract\" one bijection from another. This problem has been studied in the context of combinatorics, with several computational principles known for producing the \"difference\" of two bijections. We consider the problem from a computational and algebraic perspective, showing how to construct such bijections at a high level, avoiding pointwise reasoning or being forced to construct the forward and backward directions separately---without sacrificing performance.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236796", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Brent A.", + "last_name": "Yorgey", + "institution": "Hendrix College" + }, + { + "first_name": "Kenneth", + "last_name": "Foner", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/YorgeyF18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236791", + "title": "Fault tolerant functional reactive programming (functional pearl)", + "abstract": "Highly critical application domains, like medicine and aerospace, require the use of strict design, implementation and validation techniques. Functional languages have been used in these domains to develop synchronous dataflow programming languages for reactive systems. Causal stream functions and Functional Reactive Programming capture the essence of those languages in a way that is both elegant and robust. To guarantee that critical systems can operate under high stress over long periods of time, these applications require clear specifications of possible faults and hazards, and how they are being handled. Modeling failure is straightforward in functional languages, and many Functional Reactive abstractions incorporate support for failure or termination. However, handling unknown types of faults , and incorporating fault tolerance into Functional Reactive Programming, requires a different construction and remains an open problem. This work presents extensions to an existing functional reactive abstraction to facilitate tagging reactive transformations with hazard tags or confidence levels. We present a prototype framework to quantify the reliability of a reactive construction, by means of numeric factors or probability distributions, and demonstrate how to aid the design of fault-tolerant systems, by constraining the allowed reliability to required boundaries. By applying type-level programming, we show that it is possible to improve static analysis and have compile-time guarantees of key aspects of fault tolerance. Our approach is powerful enough to be used in systems with realistic complexity, and flexible enough to be used to guide their analysis and design, to test system properties, to verify fault tolerance properties, to perform runtime monitoring, to implement fault tolerance during execution and to address faults during runtime. We present implementations in Haskell and in Idris.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236791", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ivan", + "last_name": "Pérez", + "institution": "National Institute of Aerospace" + } + ], + "dblp_key": "journals/pacmpl/Perez18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236778", + "title": "Functional programming for modular Bayesian inference", + "abstract": "We present an architectural design of a library for Bayesian modelling and inference in modern functional programming languages. The novel aspect of our approach are modular implementations of existing state-of-the-art inference algorithms. Our design relies on three inherently functional features: higher-order functions, inductive data-types, and support for either type-classes or an expressive module system. We provide a performant Haskell implementation of this architecture, demonstrating that high-level and modular probabilistic programming can be added as a library in sufficiently expressive languages. We review the core abstractions in this architecture: inference representations, inference transformations, and inference representation transformers. We then implement concrete instances of these abstractions, counterparts to particle filters and Metropolis-Hastings samplers, which form the basic building blocks of our library. By composing these building blocks we obtain state-of-the-art inference algorithms: Resample-Move Sequential Monte Carlo, Particle Marginal Metropolis-Hastings, and Sequential Monte Carlo Squared. We evaluate our implementation against existing probabilistic programming systems and find it is already competitively performant, although we conjecture that existing functional programming optimisation techniques could reduce the overhead associated with the abstractions we use. We show that our modular design enables deterministic testing of inherently stochastic Monte Carlo algorithms. Finally, we demonstrate using OCaml that an expressive module system can also implement our design.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236778", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Adam", + "last_name": "Ścibior", + "institution": "University of Cambridge" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Oxford" + }, + { + "first_name": "Zoubin", + "last_name": "Ghahramani", + "institution": "Uber AI (United States)" + } + ], + "dblp_key": "journals/pacmpl/ScibiorKG18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236787", + "title": "Equivalences for free: univalent parametricity for effective transport", + "abstract": "Homotopy Type Theory promises a unification of the concepts of equality and equivalence in Type Theory, through the introduction of the univalence principle. However, existing proof assistants based on type theory treat this principle as an axiom, and it is not yet clear how to extend them to handle univalence internally. In this paper, we propose a construction grounded on a univalent version of parametricity to bring the benefits of univalence to the programmer and prover, that can be used on top of existing type theories. In particular, univalent parametricity strengthens parametricity to ensure preservation of type equivalences. We present a lightweight framework implemented in the Coq proof assistant that allows the user to transparently transfer definitions and theorems for a type to an equivalent one, as if they were equal. Our approach handles both type and term dependency. We study how to maximize the effectiveness of these transports in terms of computational behavior, and identify a fragment useful for certified programming on which univalent transport is guaranteed to be effective. This work paves the way to easier-to-use environments for certified programming by supporting seamless programming and proving modulo equivalences.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236787", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/TabareauTS18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236782", + "title": "Contextual equivalence for a probabilistic language with continuous random variables and recursion", + "abstract": "We present a complete reasoning principle for contextual equivalence in an untyped probabilistic language. The language includes continuous (real-valued) random variables, conditionals, and scoring. It also includes recursion, since the standard call-by-value fixpoint combinator is expressible. We demonstrate the usability of our characterization by proving several equivalence schemas, including familiar facts from lambda calculus as well as results specific to probabilistic programming. In particular, we use it to prove that reordering the random draws in a probabilistic program preserves contextual equivalence. This allows us to show, for example, that (let x = e 1 in let y = e 2 in e 0 ) = ctx (let y = e 2 in let x = e 1 in e 0 ) (provided x does not occur free in e 2 and y does not occur free in e 1 ) despite the fact that e 1 and e 2 may have sampling and scoring effects.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236782", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Wand", + "institution": "Northeastern University" + }, + { + "first_name": "Ryan", + "last_name": "Culpepper", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Theophilos", + "last_name": "Giannakopoulos", + "institution": "BAE Systems (United States)" + }, + { + "first_name": "Andrew", + "last_name": "Cobb", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/WandCGC18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236788", + "title": "Prototyping a functional language using higher-order logic programming: a functional pearl on learning the ways of λProlog/Makam", + "abstract": "We demonstrate how the framework of higher-order logic programming , as exemplified in the λProlog language design, is a prime vehicle for rapid prototyping of implementations for programming languages with sophisticated type systems. We present the literate development of a type checker for a language with a number of complicated features, culminating in a standard ML-style core with algebraic datatypes and type generalization, extended with staging constructs that are generic over a separately defined language of terms. We add each new feature in sequence, with little to no changes to existing code. Scaling the higher-order logic programming approach to this setting required us to develop approaches to challenges like complex variable binding patterns in object languages and performing generic structural traversals of code, making use of novel constructions in the setting of λProlog, such as GADTs and generic programming. For our development, we make use of Makam, a new implementation of λProlog, which we introduce in tutorial style as part of our (quasi-)literate development.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236788", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Antonis", + "last_name": "Stampoulis", + "institution": "" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/StampoulisC18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236800", + "title": "Refunctionalization of abstract abstract machines: bridging the gap between abstract abstract machines and abstract definitional interpreters (functional pearl)", + "abstract": "Abstracting abstract machines is a systematic methodology for constructing sound static analyses for higher-order languages, by deriving small-step abstract abstract machines (AAMs) that perform abstract interpretation from abstract machines that perform concrete evaluation. Darais et al. apply the same underlying idea to monadic definitional interpreters, and obtain monadic abstract definitional interpreters (ADIs) that perform abstract interpretation in big-step style using monads. Yet, the relation between small-step abstract abstract machines and big-step abstract definitional interpreters is not well studied. In this paper, we explain their functional correspondence and demonstrate how to systematically transform small-step abstract abstract machines into big-step abstract definitional interpreters. Building on known semantic interderivation techniques from the concrete evaluation setting, the transformations include linearization, lightweight fusion, disentanglement, refunctionalization, and the left inverse of the CPS transform. Linearization expresses nondeterministic choice through first-order data types, after which refunctionalization transforms the first-order data types that represent continuations into higher-order functions. The refunctionalized AAM is an abstract interpreter written in continuation-passing style (CPS) with two layers of continuations, which can be converted back to direct style with delimited control operators. Based on the known correspondence between delimited control and monads, we demonstrate that the explicit use of monads in abstract definitional interpreters is optional. All transformations properly handle the collecting semantics and nondeterminism of abstract interpretation. Remarkably, we reveal how precise call/return matching in control-flow analysis can be obtained by refunctionalizing a small-step abstract abstract machine with proper caching.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236800", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "James", + "last_name": "Decker", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WeiDR18", + "venue": "icfp", + "year": 2018 + }, + { + "paper_id": "10.1145/3236795", + "title": "Partially-static data as free extension of algebras", + "abstract": "Partially-static data structures are a well-known technique for improving binding times. However, they are often defined in an ad-hoc manner, without a unifying framework to ensure full use of the equations associated with each operation. We present a foundational view of partially-static data structures as free extensions of algebras for suitable equational theories, i.e. the coproduct of an algebra and a free algebra in the category of algebras and their homomorphisms. By precalculating these free extensions, we construct a high-level library of partially-static data representations for common algebraic structures. We demonstrate our library with common use-cases from the literature: string and list manipulation, linear algebra, and numerical simplification.", + "date": "2018-07-30", + "link": "https://doi.org/10.1145/3236795", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + }, + { + "first_name": "Tamara von", + "last_name": "Glehn", + "institution": "University of Cambridge" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/YallopGK18", + "venue": "icfp", + "year": 2018 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2019.json b/data/pl_conferences/icfp/2019.json new file mode 100644 index 0000000..75ff07f --- /dev/null +++ b/data/pl_conferences/icfp/2019.json @@ -0,0 +1,1184 @@ +[ + { + "paper_id": "10.1145/3341713", + "title": "Simply RaTT: a fitch-style modal calculus for reactive programming without space leaks", + "abstract": "Functional reactive programming (FRP) is a paradigm for programming with signals and events, allowing the user to describe reactive programs on a high level of abstraction. For this to make sense, an FRP language must ensure that all programs are causal, and can be implemented without introducing space leaks and time leaks. To this end, some FRP languages do not give direct access to signals, but just to signal functions.

Recently, modal types have been suggested as an alternative approach to ensuring causality in FRP languages in the synchronous case, giving direct access to the signal and event abstractions. This paper presents Simply RaTT, a new modal calculus for reactive programming. Unlike prior calculi, Simply RaTT uses a Fitch-style approach to modal types, which simplifies the type system and makes programs more concise. Echoing a previous result by Krishnaswami for a different language, we devise an operational semantics that safely executes Simply RaTT programs without space leaks.

We also identify a source of time leaks present in other modal FRP languages: The unfolding of fixed points in delayed computations. The Fitch-style presentation allows an easy way to rules out these leaks, which appears not to be possible in the more traditional dual context approach.", + "date": "2019-03-14", + "link": "https://doi.org/10.1145/3341713", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Bahr", + "institution": "" + }, + { + "first_name": "Christian Uldal", + "last_name": "Graulund", + "institution": "" + }, + { + "first_name": "Rasmus Ejlers", + "last_name": "Møgelberg", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/BahrGM19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341719", + "title": "Teaching the art of functional programming using automated grading (experience report)", + "abstract": "Online programming platforms have immense potential to improve students' educational experience. They make programming more accessible, as no installation is required; and automatic grading facilities provide students with immediate feedback on their code, allowing them to to fix bugs and address errors in their understanding right away. However, these graders tend to focus heavily on the functional correctness of a solution, neglecting other aspects of students' code and thereby causing students to miss out on a significant amount of valuable feedback. In this paper, we recount our experience in using the Learn-OCaml online programming platform to teach functional programming in a second-year university course on programming languages and paradigms. Moreover, we explore how to leverage Learn-OCaml's automated grading infrastructure to make it easy to write more expressive graders that give students feedback on properties of their code beyond simple input/output correctness, in order to effectively teach elements of functional programming style. In particular, we describe our extensions to the Learn-OCaml platform that evaluate students on test quality and code style. By providing these tools and a suite of our own homework problems and associated graders, we aim to promote functional programming education, enhance students' educational experience, and make teaching and learning typed functional programming more accessible to instructors and students alike, in our community and beyond.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341719", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Aliya", + "last_name": "Hameer", + "institution": "McGill University" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "journals/pacmpl/HameerP19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341715", + "title": "Mixed linear and non-linear recursive types", + "abstract": "We describe a type system with mixed linear and non-linear recursive types called LNL-FPC (the linear/non-linear fixpoint calculus). The type system supports linear typing which enhances the safety properties of programs, but also supports non-linear typing as well which makes the type system more convenient for programming. Just like in FPC, we show that LNL-FPC supports type-level recursion which in turn induces term-level recursion. We also provide sound and computationally adequate categorical models for LNL-FPC which describe the categorical structure of the substructural operations of Intuitionistic Linear Logic at all non-linear types, including the recursive ones. In order to do so, we describe a new technique for solving recursive domain equations within the category CPO by constructing the solutions over pre-embeddings. The type system also enjoys implicit weakening and contraction rules which we are able to model by identifying the canonical comonoid structure of all non-linear types. We also show that the requirements of our abstract model are reasonable by constructing a large class of concrete models that have found applications not only in classical functional programming, but also in emerging programming paradigms that incorporate linear types, such as quantum programming and circuit description programming languages.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341715", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bert", + "last_name": "Lindenhovius", + "institution": "Tulane University" + }, + { + "first_name": "Michael", + "last_name": "Mislove", + "institution": "Tulane University" + }, + { + "first_name": "Vladimir", + "last_name": "Zamdzhiev", + "institution": "Université de Lorraine" + } + ], + "dblp_key": "journals/pacmpl/LindenhoviusMZ19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341642", + "title": "Rebuilding racket on chez scheme (experience report)", + "abstract": "We rebuilt Racket on Chez Scheme, and it works well&mdash;as long as we're allowed a few patches to Chez Scheme. DrRacket runs, the Racket distribution can build itself, and nearly all of the core Racket test suite passes. Maintainability and performance of the resulting implementation are good, although some work remains to improve end-to-end performance. The least predictable part of our effort was how big the differences between Racket and Chez Scheme would turn out to be and how we would manage those differences. We expect Racket on Chez Scheme to become the main Racket implementation, and we encourage other language implementers to consider Chez Scheme as a target virtual machine.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341642", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Caner", + "last_name": "Derici", + "institution": "Indiana University" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Cisco Systems (United States)" + }, + { + "first_name": "Andrew W.", + "last_name": "Keep", + "institution": "Cisco Systems (United States)" + }, + { + "first_name": "Gustavo E.", + "last_name": "Massaccesi", + "institution": "University of Buenos Aires" + }, + { + "first_name": "Sarah", + "last_name": "Spall", + "institution": "Indiana University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + }, + { + "first_name": "Jon", + "last_name": "Zeppieri", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/FlattDDKMSTZ19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341706", + "title": "Higher-order type-level programming in Haskell", + "abstract": "Type family applications in Haskell must be fully saturated. This means that all type-level functions have to be first-order, leading to code that is both messy and longwinded. In this paper we detail an extension to GHC that removes this restriction. We augment Haskell’s existing type arrow, |->|, with an unmatchable arrow, | >|, that supports partial application of type families without compromising soundness. A soundness proof is provided. We show how the techniques described can lead to substantial code-size reduction (circa 80%) in the type-level logic of commonly-used type-level libraries whilst simultaneously improving code quality and readability.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341706", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Csongor", + "last_name": "Kiss", + "institution": "Imperial College London" + }, + { + "first_name": "Tony", + "last_name": "Field", + "institution": "Imperial College London" + }, + { + "first_name": "Susan", + "last_name": "Eisenbach", + "institution": "Imperial College London" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/KissFEJ19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341710", + "title": "Sequential programming for replicated data stores", + "abstract": "We introduce Carol, a refinement-typed programming language for replicated data stores. The salient feature of Carol is that it allows programming and verifying replicated store operations modularly , without consideration of other operations that might interleave, and sequentially , without requiring reference to or knowledge of the concurrent execution model. This is in stark contrast with existing systems, which require understanding the concurrent interactions of all pairs of operations when developing or verifying them. The key enabling idea is the consistency guard , a two-state predicate relating the locally-viewed store and the hypothetical remote store that an operation’s updates may eventually be applied to, which is used by the Carol programmer to declare their precise consistency requirements. Guards appear to the programmer and refinement typechecker as simple data pre-conditions, enabling sequential reasoning, while appearing to the distributed runtime as consistency control instructions. We implement and evaluate the Carol system in two parts: (1) the algorithm used to statically translate guards into the runtime coordination actions required to enforce them, and (2) the networked-replica runtime which executes arbitrary operations, written in a Haskell DSL, according to the Carol language semantics.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341710", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nicholas V.", + "last_name": "Lewchenko", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Akash", + "last_name": "Gaonkar", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Pavol", + "last_name": "Černý", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "journals/pacmpl/LewchenkoRGC19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341686", + "title": "Narcissus: correct-by-construction derivation of decoders and encoders from binary formats", + "abstract": "It is a neat result from functional programming that libraries of parser combinators can support rapid construction of decoders for quite a range of formats. With a little more work, the same combinator program can denote both a decoder and an encoder. Unfortunately, the real world is full of gnarly formats, as with the packet formats that make up the standard Internet protocol stack. Most past parser-combinator approaches cannot handle these formats, and the few exceptions require redundancy – one part of the natural grammar needs to be hand-translated into hints in multiple parts of a parser program. We show how to recover very natural and nonredundant format specifications, covering all popular network packet formats and generating both decoders and encoders automatically. The catch is that we use the Coq proof assistant to derive both kinds of artifacts using tactics, automatically, in a way that guarantees that they form inverses of each other. We used our approach to reimplement packet processing for a full Internet protocol stack, inserting our replacement into the OCaml-based MirageOS unikernel, resulting in minimal performance degradation.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341686", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Sorawit", + "last_name": "Suriyakarn", + "institution": "Mayo Hospital" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Qianchuan", + "last_name": "Ye", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/DelawareSPYC19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341643", + "title": "Compiling with continuations, or without? whatever", + "abstract": "What makes a good compiler IR? In the context of functional languages, there has been an extensive debate on the advantages and disadvantages of continuation-passing-style (CPS). The consensus seems to be that some form of explicit continuations is necessary to model jumps in a functional style, but that they should have a 2nd-class status, separate from regular functions, to ensure efficient code generation. Building on this observation, a recent study from PLDI 2017 proposed a direct-style IR with explicit join points, which essentially represent local continuations, i.e., functions that do not return or escape. While this IR can work well in practice, as evidenced by the implementation of join points in the Glasgow Haskell Compiler (GHC), there still seems to be room for improvement, especially with regard to the way continuations are handled in the course of optimization. In this paper, we contribute to the CPS debate by developing a novel IR with the following features. First, we integrate a control operator that resembles Felleisen’s C , eliminating certain redundant rewrites observed in the previous study. Second, we treat the non-returning and non-escaping aspects of continuations separately, allowing efficient compilation of well-behaved functions defined by the user. Third, we define a selective CPS translation of our IR, which erases control operators while preserving the meaning and typing of programs. These features enable optimizations in both direct style and full CPS, as well as in any intermediate style with selectively exposed continuations. Thus, we change the spectrum of available options from “CPS yes or no” to “as much or as little CPS as you want, when you want it”.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341643", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Youyou", + "last_name": "Cong", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Leo", + "last_name": "Osvald", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Grégory M.", + "last_name": "Essertel", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/CongOER19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341711", + "title": "Implementing a modal dependent type theory", + "abstract": "Modalities are everywhere in programming and mathematics! Despite this, however, there are still significant technical challenges in formulating a core dependent type theory with modalities. We present a dependent type theory MLTT 🔒 supporting the connectives of standard Martin-Löf Type Theory as well as an S4 -style necessity operator. MLTT 🔒 supports a smooth interaction between modal and dependent types and provides a common basis for the use of modalities in programming and in synthetic mathematics. We design and prove the soundness and completeness of a type checking algorithm for MLTT 🔒 , using a novel extension of normalization by evaluation. We have also implemented our algorithm in a prototype proof assistant for MLTT 🔒 , demonstrating the ease of applying our techniques.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341711", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Gratzer", + "institution": "Aarhus University" + }, + { + "first_name": "Jonathan", + "last_name": "Sterling", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/GratzerSB19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341693", + "title": "Simple noninterference from parametricity", + "abstract": "In this paper we revisit the connection between parametricity and noninterference. Our primary contribution is a proof of noninterference for a polyvariant variation of the Dependency Core Calculus of in the Calculus of Constructions. The proof is modular: it leverages parametricity for the Calculus of Constructions and the encoding of data abstraction using existential types. This perspective gives rise to simple and understandable proofs of noninterference from parametricity. All our contributions have been mechanised in the Agda proof assistant.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341693", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Maximilian", + "last_name": "Algehed", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "journals/pacmpl/AlgehedB19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341695", + "title": "Coherence of type class resolution", + "abstract": "Elaboration-based type class resolution, as found in languages like Haskell, Mercury and PureScript, is generally nondeterministic: there can be multiple ways to satisfy a wanted constraint in terms of global instances and locally given constraints. Coherence is the key property that keeps this sane; it guarantees that, despite the nondeterminism, programs still behave predictably. Even though elaboration-based resolution is generally assumed coherent, as far as we know, there is no formal proof of this property in the presence of sources of nondeterminism, like superclasses and flexible contexts. This paper provides a formal proof to remedy the situation. The proof is non-trivial because the semantics elaborates resolution into a target language where different elaborations can be distinguished by contexts that do not have a source language counterpart. Inspired by the notion of full abstraction, we present a two-step strategy that first elaborates nondeterministically into an intermediate language that preserves contextual equivalence, and then deterministically elaborates from there into the target language. We use an approach based on logical relations to establish contextual equivalence and thus coherence for the first step of elaboration, while the second step’s determinism straightforwardly preserves this coherence property.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341695", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gert-Jan", + "last_name": "Bottu", + "institution": "KU Leuven" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" + }, + { + "first_name": "Koar", + "last_name": "Marntirosian", + "institution": "KU Leuven" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/BottuXMS19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341704", + "title": "Dependently typed Haskell in industry (experience report)", + "abstract": "Recent versions of the Haskell compiler GHC have a number of advanced features that allow many idioms from dependently typed programming to be encoded. We describe our experiences using this \"dependently typed Haskell\" to construct a performance-critical library that is a key component in a number of verification tools. We have discovered that it can be done, and it brings significant value, but also at a high cost. In this experience report, we describe the ways in which programming at the edge of what is expressible in Haskell's type system has brought us value, the difficulties that it has imposed, and some of the ways we coped with the difficulties.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341704", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David Thrane", + "last_name": "Christiansen", + "institution": "Galois (United States)" + }, + { + "first_name": "Iavor S.", + "last_name": "Diatchki", + "institution": "Galois (United States)" + }, + { + "first_name": "Robert", + "last_name": "Dockins", + "institution": "Galois (United States)" + }, + { + "first_name": "Joe", + "last_name": "Hendrix", + "institution": "Galois (United States)" + }, + { + "first_name": "Tristan", + "last_name": "Ravitch", + "institution": "Galois (United States)" + } + ], + "dblp_key": "journals/pacmpl/ChristiansenDDH19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341718", + "title": "Call-by-need is clairvoyant call-by-value", + "abstract": "Call-by-need evaluation, also known as lazy evaluation, provides two key benefits: compositional programming and infinite data. The standard semantics for laziness is Launchbury’s natural semantics DBLP:conf/popl/Launchbury93, which uses a heap to memoise the results of delayed evaluations. However, the stateful nature of this heap greatly complicates reasoning about the operational behaviour of lazy programs. In this article, we propose an alternative semantics for laziness, clairvoyant evaluation , that replaces the state effect with nondeterminism, and prove this semantics equivalent in a strong sense to the standard semantics. We show how this new semantics greatly simplifies operational reasoning, admitting much simpler proofs of a number of results from the literature, and how it leads to the first denotational cost semantics for lazy evaluation.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341718", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jennifer", + "last_name": "Hackett", + "institution": "University of Nottingham" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/HackettH19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341692", + "title": "Approximate normalization for gradual dependent types", + "abstract": "Dependent types help programmers write highly reliable code. However, this reliability comes at a cost: it can be challenging to write new prototypes in (or migrate old code to) dependently-typed programming languages. Gradual typing makes static type disciplines more flexible, so an appropriate notion of gradual dependent types could fruitfully lower this cost. However, dependent types raise unique challenges for gradual typing. Dependent typechecking involves the execution of program code, but gradually-typed code can signal runtime type errors or diverge. These runtime errors threaten the soundness guarantees that make dependent types so attractive, while divergence spoils the type-driven programming experience. This paper presents GDTL, a gradual dependently-typed language that emphasizes pragmatic dependently-typed programming. GDTL fully embeds both an untyped and dependently-typed language, and allows for smooth transitions between the two. In addition to gradual types we introduce gradual terms , which allow the user to be imprecise in type indices and to omit proof terms; runtime checks ensure type safety. To account for nontermination and failure, we distinguish between compile-time normalization and run-time execution: compile-time normalization is approximate but total, while runtime execution is exact , but may fail or diverge. We prove that GDTL has decidable typechecking and satisfies all the expected properties of gradual languages. In particular, GDTL satisfies the static and dynamic gradual guarantees: reducing type precision preserves typedness, and altering type precision does not change program behavior outside of dynamic type failures. To prove these properties, we were led to establish a novel normalization gradual guarantee that captures the monotonicity of approximate normalization with respect to imprecision.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341692", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Eremondi", + "institution": "University of British Columbia" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/EremondiTG19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341689", + "title": "The next 700 compiler correctness theorems (functional pearl)", + "abstract": "Compiler correctness is an old problem, with results stretching back beyond the last half-century. Founding the field, John McCarthy and James Painter set out to build a \"completely trustworthy compiler\". And yet, until quite recently, even despite truly impressive verification efforts, the theorems being proved were only about the compilation of whole programs, a theoretically quite appealing but practically unrealistic simplification. For a compiler correctness theorem to assure complete trust, the theorem must reflect the reality of how the compiler will be used. There has been much recent work on more realistic \"compositional\" compiler correctness aimed at proving correct compilation of components while supporting linking with components compiled from different languages using different compilers. However, the variety of theorems, stated in remarkably different ways, raises questions about what researchers even mean by a \"compiler is correct.\" In this pearl, we develop a new framework with which to understand compiler correctness theorems in the presence of linking, and apply it to understanding and comparing this diversity of results. In doing so, not only are we better able to assess their relative strengths and weaknesses, but gain insight into what we as a community should expect from compiler correctness theorems of the future.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341689", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Patterson", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/0001A19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341708", + "title": "Dijkstra monads for all", + "abstract": "This paper proposes a general semantic framework for verifying programs with arbitrary monadic side-effects using Dijkstra monads, which we define as monad-like structures indexed by a specification monad. We prove that any monad morphism between a computational monad and a specification monad gives rise to a Dijkstra monad, which provides great flexibility for obtaining Dijkstra monads tailored to the verification task at hand. We moreover show that a large variety of specification monads can be obtained by applying monad transformers to various base specification monads, including predicate transformers and Hoare-style pre- and postconditions. For defining correct monad transformers, we propose a language inspired by Moggi's monadic metalanguage that is parameterized by a dependent type theory. We also develop a notion of algebraic operations for Dijkstra monads, and start to investigate two ways of also accommodating effect handlers. We implement our framework in both Coq and F*, and illustrate that it supports a wide variety of verification styles for effects such as exceptions, nondeterminism, state, input-output, and general recursion.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341708", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "University of Ljubljana" + }, + { + "first_name": "Robert", + "last_name": "Atkey", + "institution": "University of Strathclyde" + }, + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "Consejo Nacional de Investigaciones Científicas y Técnicas" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Exequiel", + "last_name": "Rivas", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "Inria Chile" + } + ], + "dblp_key": "journals/pacmpl/MaillardAAMHRT19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341699", + "title": "Synthesizing symmetric lenses", + "abstract": "Lenses are programs that can be run both \"front to back\" and \"back to front,\" allowing updates to either their source or their target data to be transferred in both directions. Since their introduction by Foster et al., lenses have been extensively studied, extended, and applied. Recent work has also demonstrated how techniques from type-directed program synthesis can be used to efficiently synthesize a simple class of lenses---so-called bijective lenses over string data---given a pair of types (regular expressions) and a small number of examples. We extend this synthesis algorithm to a much broader class of lenses, called simple symmetric lenses, including all bijective lenses, all of the popular category of \"asymmetric\" lenses, and a rich subset of the more powerful \"symmetric lenses\" proposed by Hofmann et al. Intuitively, simple symmetric lenses allow some information to be present on one side but not the other and vice versa. They are of independent theoretical interest, being the largest class of symmetric lenses that do not rely on persistent internal state. Synthesizing simple symmetric lenses is substantially more challenging than synthesizing bijective lenses: Since some of the information on each side can be \"disconnected\" from the other side, there will, in general, be many lenses that agree with a given example. To guide the search process, we use stochastic regular expressions and ideas from information theory to estimate the amount of information propagated by a candidate lens, generally preferring lenses that propagate more information, as well as user annotations marking parts of the source and target data structures as either irrelevant or essential. We describe an implementation of simple symmetric lenses and our synthesis procedure as extensions to the Boomerang language. We evaluate its performance on 48 benchmark examples drawn from Flash Fill, Augeas, the bidirectional programming literature, and electronic file format synchronization tasks. Our implementation can synthesize each of these lenses in under 30 seconds.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341699", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Anders", + "last_name": "Miltner", + "institution": "Princeton University" + }, + { + "first_name": "Solomon", + "last_name": "Maina", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/MiltnerMFPWZ19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341717", + "title": "An efficient algorithm for type-safe structural diffing", + "abstract": "Effectively computing the difference between two version of a source file has become an indispensable part of software development. The de facto standard tool used by most version control systems is the UNIX diff utility, that compares two files on a line-by-line basis without any regard for the structure of the data stored in these files. This paper presents an alternative datatype generic algorithm for computing the difference between two values of any algebraic datatype. This algorithm maximizes sharing between the source and target trees, while still running in linear time. Finally, this paper demonstrates that by instantiating this algorithm to the Lua abstract syntax tree and mining the commit history of repositories found on GitHub, the resulting patches can often be merged automatically, even when existing technology has failed.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341717", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Victor Cacciari", + "last_name": "Miraldo", + "institution": "Utrecht University" + }, + { + "first_name": "Wouter", + "last_name": "Swierstra", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/pacmpl/MiraldoS19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341714", + "title": "Quantitative program reasoning with graded modal types", + "abstract": "In programming, some data acts as a resource (e.g., file handles, channels) subject to usage constraints. This poses a challenge to software correctness as most languages are agnostic to constraints on data. The approach of linear types provides a partial remedy, delineating data into resources to be used but never copied or discarded, and unconstrained values. Bounded Linear Logic provides a more fine-grained approach, quantifying non-linear use via an indexed-family of modalities. Recent work on coeffect types generalises this idea to graded comonads, providing type systems which can capture various program properties. Here, we propose the umbrella notion of graded modal types, encompassing coeffect types and dual notions of type-based effect reasoning via graded monads. In combination with linear and indexed types, we show that graded modal types provide an expressive type theory for quantitative program reasoning, advancing the reach of type systems to capture and verify a broader set of program properties. We demonstrate this approach via a type system embodied in a fully-fledged functional language called Granule, exploring various examples.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341714", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + }, + { + "first_name": "Vilem-Benjamin", + "last_name": "Liepelt", + "institution": "University of Kent" + }, + { + "first_name": "Harley", + "last_name": "Eades", + "institution": "Augusta University" + } + ], + "dblp_key": "journals/pacmpl/OrchardLE19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341644", + "title": "Lambda calculus with algebraic simplification for reduction parallelization by equational reasoning", + "abstract": "Parallel reduction is a major component of parallel programming and widely used for summarization and aggregation. It is not well understood, however, what sorts of nontrivial summarizations can be implemented as parallel reductions. This paper develops a calculus named λ as , a simply typed lambda calculus with algebraic simplification. This calculus provides a foundation for studying parallelization of complex reductions by equational reasoning. Its key feature is δ abstraction. A δ abstraction is observationally equivalent to the standard λ abstraction, but its body is simplified before the arrival of its arguments by using algebraic properties such as associativity and commutativity. In addition, the type system of λ as guarantees that simplifications due to δ abstractions do not lead to serious overheads. The usefulness of λ as is demonstrated on examples of developing complex parallel reductions, including those containing more than one reduction operator, loops with jumps, prefix-sum patterns, and even tree manipulations.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341644", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Akimasa", + "last_name": "Morihata", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "journals/pacmpl/Morihata19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341687", + "title": "Closure conversion is safe for space", + "abstract": "We formally prove that closure conversion with flat environments for CPS lambda calculus is correct (preserves semantics) and safe for time and space, meaning that produced code preserves the time and space required for the execution of the source program. We give a cost model to pre- and post-closure-conversion code by formalizing profiling semantics that keep track of the time and space resources needed for the execution of a program, taking garbage collection into account. To show preservation of time and space we set up a general, \"garbage-collection compatible\", binary logical relation that establishes invariants on resource consumption of the related programs, along with functional correctness. Using this framework, we show semantics preservation and space and time safety for terminating source programs, and divergence preservation and space safety for diverging source programs. We formally prove that closure conversion with flat environments for CPS lambda calculus is correct (preserves semantics) and safe for time and space, meaning that produced code preserves the time and space required for the execution of the source program. We give a cost model to pre- and post-closure-conversion code by formalizing profiling semantics that keep track of the time and space resources needed for the execution of a program, taking garbage collection into account. To show preservation of time and space we set up a general, \"garbage-collection compatible\", binary logical relation that establishes invariants on resource consumption of the related programs, along with functional correctness. Using this framework, we show semantics preservation and space and time safety for terminating source programs, and divergence preservation and space safety for diverging source programs. This is the first formal proof of space-safety of a closure-conversion transformation. The transformation and the proof are parts of the CertiCoq compiler pipeline from Coq (Gallina) through CompCert Clight to assembly language. Our results are mechanized in the Coq proof assistant.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341687", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/Paraskevopoulou19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341694", + "title": "Selective applicative functors", + "abstract": "Applicative functors and monads have conquered the world of functional programming by providing general and powerful ways of describing effectful computations using pure functions. Applicative functors provide a way to compose independent effects that cannot depend on values produced by earlier computations, and all of which are declared statically. Monads extend the applicative interface by making it possible to compose dependent effects, where the value computed by one effect determines all subsequent effects, dynamically. This paper introduces an intermediate abstraction called selective applicative functors that requires all effects to be declared statically, but provides a way to select which of the effects to execute dynamically. We demonstrate applications of the new abstraction on several examples, including two industrial case studies.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341694", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrey", + "last_name": "Mokhov", + "institution": "Newcastle University" + }, + { + "first_name": "Georgy", + "last_name": "Lukyanov", + "institution": "Newcastle University" + }, + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Jeremie", + "last_name": "Dimino", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/MokhovLMD19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341696", + "title": "Relational cost analysis for functional-imperative programs", + "abstract": "Relational cost analysis aims at formally establishing bounds on the difference in the evaluation costs of two programs. As a particular case, one can also use relational cost analysis to establish bounds on the difference in the evaluation cost of the same program on two different inputs. One way to perform relational cost analysis is to use a relational type-and-effect system that supports reasoning about relations between two executions of two programs. Building on this basic idea, we present a type-and-effect system, called ARel, for reasoning about the relative cost of array-manipulating, higher-order functional-imperative programs. The key ingredient of our approach is a new lightweight type refinement discipline that we use to track relations (differences) between two mutable arrays. This discipline combined with Hoare-style triples built into the types allows us to express and establish precise relative costs of several interesting programs which imperatively update their data. We have implemented ARel using ideas from bidirectional type checking.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341696", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Weihao", + "last_name": "Qu", + "institution": "Buffalo State University" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Buffalo State University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/QuG019", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341685", + "title": "Fairness in responsive parallelism", + "abstract": "Research on parallel computing has historically revolved around compute-intensive applications drawn from traditional areas such as high-performance computing. With the growing availability and usage of multicore chips, applications of parallel computing now include interactive parallel applications that mix compute-intensive tasks with interaction, e.g., with the user or more generally with the external world. Recent theoretical work on responsive parallelism presents abstract cost models and type systems for ensuring and reasoning about responsiveness and throughput of such interactive parallel programs. In this paper, we extend prior work by considering a crucial metric: fairness. To express rich interactive parallel programs, we allow programmers to assign priorities to threads and instruct the scheduler to obey a notion of fairness. We then propose the fairly prompt scheduling principle for executing such programs; the principle specifies the schedule for multithreaded programs on multiple processors. For such schedules, we prove theoretical bounds on the execution and response times of jobs of various priorities. In particular, we bound the amount, i.e., stretch, by which a low-priority job can be delayed by higher-priority work. We also present an algorithm designed to approximate the fairly prompt scheduling principle on multicore computers, implement the algorithm by extending the Standard ML language, and present an empirical evaluation.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341685", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/MullerWA19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341703", + "title": "Sound and robust solid modeling via exact real arithmetic and continuity", + "abstract": "Algorithms for solid modeling, i.e., Computer-Aided Design (CAD) and computer graphics, are often specified on real numbers and then implemented with finite-precision arithmetic, such as floating-point. The result is that these implementations do not soundly compute the results that are expected from their specifications. We present a new library, StoneWorks, that provides sound and robust solid modeling primitives. We implement StoneWorks in MarshallB, a pure functional programming language for exact real arithmetic in which types denote topological spaces and functions denote continuous maps, ensuring that all programs are sound and robust. We developed MarshallB as an extension of the Marshall language. We also define a new shape representation, compact representation ( K-rep ), that enables constructions such as Minkowski sum and analyses such as Hausdorff distance that are not possible with traditional representations. K-rep is a nondeterminism monad for describing all the points in a shape. With our library, language, and representation together, we show that short StoneWorks programs can specify and execute sound and robust solid modeling algorithms and tasks.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341703", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Sherman", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jesse", + "last_name": "Michel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ShermanMC19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341701", + "title": "Efficient differentiable programming in a functional array-processing language", + "abstract": "We present a system for the automatic differentiation (AD) of a higher-order functional array-processing language. The core functional language underlying this system simultaneously supports both source-to-source forward-mode AD and global optimisations such as loop transformations. In combination, gradient computation with forward-mode AD can be as efficient as reverse mode, and that the Jacobian matrices required for numerical algorithms such as Gauss-Newton and Levenberg-Marquardt can be efficiently computed.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341701", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Oxford" + }, + { + "first_name": "Andrew", + "last_name": "Fitzgibbon", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "DeepMind (United Kingdom)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/ShaikhhaFVJ19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341707", + "title": "A predicate transformer semantics for effects (functional pearl)", + "abstract": "Reasoning about programs that use effects can be much harder than reasoning about their pure counterparts. This paper presents a predicate transformer semantics for a variety of effects, including exceptions, state, non-determinism, and general recursion. The predicate transformer semantics gives rise to a refinement relation that can be used to relate a program to its specification, or even calculate effectful programs that are correct by construction.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341707", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Wouter", + "last_name": "Swierstra", + "institution": "Utrecht University" + }, + { + "first_name": "Tim", + "last_name": "Baanen", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/pacmpl/SwierstraB19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341690", + "title": "Equations reloaded: high-level dependently-typed functional programming and proving in Coq", + "abstract": "Equations is a plugin for the Coq proof assistant which provides a notation for defining programs by dependent pattern-matching and structural or well-founded recursion. It additionally derives useful high-level proof principles for demonstrating properties about them, abstracting away from the implementation details of the function and its compiled form. We present a general design and implementation that provides a robust and expressive function definition package as a definitional extension to the Coq kernel. At the core of the system is a new simplifier for dependent equalities based on an original handling of the no-confusion property of constructors.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341690", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthieu", + "last_name": "Sozeau", + "institution": "Université Paris Cité" + }, + { + "first_name": "Cyprien", + "last_name": "Mangin", + "institution": "Délégation Paris 7" + } + ], + "dblp_key": "journals/pacmpl/SozeauM19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341712", + "title": "A reasonably exceptional type theory", + "abstract": "Traditional approaches to compensate for the lack of exceptions in type theories for proof assistants have severe drawbacks from both a programming and a reasoning perspective. Pédrot and Tabareau recently extended the Calculus of Inductive Constructions (CIC) with exceptions. The new exceptional type theory is interpreted by a translation into CIC, covering full dependent elimination, decidable type-checking and canonicity. However, the exceptional theory is inconsistent as a logical system. To recover consistency, Pédrot and Tabareau propose an additional translation that uses parametricity to enforce that all exceptions are caught locally. While this enforcement brings logical expressivity gains over CIC, it completely prevents reasoning about exceptional programs such as partial functions. This work addresses the dilemma between exceptions and consistency in a more flexible manner, with the Reasonably Exceptional Type Theory (RETT). RETT is structured in three layers: (a) the exceptional layer, in which all terms can raise exceptions; (b) the mediation layer, in which exceptional terms must be provably parametric; (c) the pure layer, in which terms are non-exceptional, but can refer to exceptional terms. We present the general theory of RETT, where each layer is realized by a predicative hierarchy of universes, and develop an instance of RETT in Coq: the impure layer corresponds to the predicative universe hierarchy, the pure layer is realized by the impredicative universe of propositions, and the mediation layer is reified via a parametricity type class. RETT is the first full dependent type theory to support consistent reasoning about exceptional terms, and the CoqRETT plugin readily brings this ability to Coq programmers.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341712", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pierre-Marie", + "last_name": "Pédrot", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Hans Jacob", + "last_name": "Fehrmann", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "Inria Chile" + } + ], + "dblp_key": "journals/pacmpl/PedrotTFT19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341688", + "title": "Linear capabilities for fully abstract compilation of separation-logic-verified code", + "abstract": "Separation logic is a powerful program logic for the static modular verification of imperative programs. However, dynamic checking of separation logic contracts on the boundaries between verified and untrusted modules is hard, because it requires one to enforce (among other things) that outcalls from a verified to an untrusted module do not access memory resources currently owned by the verified module. This paper proposes an approach to dynamic contract checking by relying on support for capabilities, a well-studied form of unforgeable memory pointers that enables fine-grained, efficient memory access control. More specifically, we rely on a form of capabilities called linear capabilities for which the hardware enforces that they cannot be copied. We formalize our approach as a fully abstract compiler from a statically verified source language to an unverified target language with support for linear capabilities. The key insight behind our compiler is that memory resources described by spatial separation logic predicates can be represented at run time by linear capabilities. The compiler is separation-logic-proof-directed: it uses the separation logic proof of the source program to determine how memory accesses in the source program should be compiled to linear capability accesses in the target program. The full abstraction property of the compiler essentially guarantees that compiled verified modules can interact with untrusted target language modules as if they were compiled from verified code as well.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341688", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thomas Van", + "last_name": "Strydonck", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "journals/pacmpl/StrydonckPD19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341698", + "title": "Synthesizing differentially private programs", + "abstract": "Inspired by the proliferation of data-analysis tasks, recent research in program synthesis has had a strong focus on enabling users to specify data-analysis programs through intuitive specifications, like examples and natural language. However, with the ever-increasing threat to privacy through data analysis, we believe it is imperative to reimagine program synthesis technology in the presence of formal privacy constraints. In this paper, we study the problem of automatically synthesizing randomized, differentially private programs, where the user can provide the synthesizer with a constraint on the privacy of the desired algorithm. We base our technique on a linear dependent type system that can track the resources consumed by a program, and hence its privacy cost. We develop a novel type-directed synthesis algorithm that constructs randomized differentially private programs. We apply our technique to the problems of synthesizing database-like queries as well as recursive differential privacy mechanisms from the literature.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341698", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Calvin", + "last_name": "Smith", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/SmithA19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341709", + "title": "Mechanized relational verification of concurrent programs with continuations", + "abstract": "Concurrent higher-order imperative programming languages with continuations are very flexible and allow for the implementation of sophisticated programming patterns. For instance, it is well known that continuations can be used to implement cooperative concurrency. Continuations can also simplify web server implementations. This, in particular, helps simplify keeping track of the state of server’s clients. However, such advanced programming languages are very challenging to reason about. One of the main challenges in reasoning about programs in the presence of continuations is due to the fact that the non-local flow of control breaks the bind rule, one of the important modular reasoning principles of Hoare logic. In this paper we present the first completely formalized tool for interactive mechanized relational verification of programs written in a concurrent higher-order imperative programming language with continuations (call/cc and throw). We develop novel logical relations which can be used to give mechanized proofs of relational properties. In particular, we prove correctness of an implementation of cooperative concurrency with continuations. In addition, we show that that a rudimentary web server implemented using the continuation-based pattern is contextually equivalent to one implemented without the continuation-based pattern. We introduce context-local reasoning principles for our calculus which allows us to regain modular reasoning principles for the fragment of the language without non-local control flow. These novel reasoning principles can be used in tandem with our (non-context-local) Hoare logic for reasoning about programs that do feature non-local control flow. Indeed, we use the combination of context-local and non-context-local reasoning to simplify reasoning about the examples.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341709", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "KU Leuven" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/TimanyB19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341691", + "title": "Cubical agda: a dependently typed programming language with univalence and higher inductive types", + "abstract": "Proof assistants based on dependent type theory provide expressive languages for both programming and proving within the same system. However, all of the major implementations lack powerful extensionality principles for reasoning about equality, such as function and propositional extensionality. These principles are typically added axiomatically which disrupts the constructive properties of these systems. Cubical type theory provides a solution by giving computational meaning to Homotopy Type Theory and Univalent Foundations, in particular to the univalence axiom and higher inductive types. This paper describes an extension of the dependently typed functional programming language Agda with cubical primitives, making it into a full-blown proof assistant with native support for univalence and a general schema of higher inductive types. These new primitives make function and propositional extensionality as well as quotient types directly definable with computational content. Additionally, thanks also to copatterns, bisimilarity is equivalent to equality for coinductive types. This extends Agda with support for a wide range of extensionality principles, without sacrificing type checking and constructivity.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341691", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Vezzosi", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Anders", + "last_name": "Mörtberg", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "journals/pacmpl/VezzosiM019", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3342713", + "title": "Lambda: the ultimate sublanguage (experience report)", + "abstract": "We describe our experience teaching an advanced typed functional programming course based around the use of System Fω as a programming language.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3342713", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + }, + { + "first_name": "Leo", + "last_name": "White", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/YallopW19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341702", + "title": "From high-level inference algorithms to efficient code", + "abstract": "Probabilistic programming languages are valuable because they allow domain experts to express probabilistic models and inference algorithms without worrying about irrelevant details. However, for decades there remained an important and popular class of probabilistic inference algorithms whose efficient implementation required manual low-level coding that is tedious and error-prone. They are algorithms whose idiomatic expression requires random array variables that are latent or whose likelihood is conjugate . Although that is how practitioners communicate and compose these algorithms on paper, executing such expressions requires eliminating the latent variables and recognizing the conjugacy by symbolic mathematics. Moreover, matching the performance of handwritten code requires speeding up loops by more than a constant factor. We show how probabilistic programs that directly and concisely express these desired inference algorithms can be compiled while maintaining efficiency. We introduce new transformations that turn high-level probabilistic programs with arrays into pure loop code. We then make great use of domain-specific invariants and norms to optimize the code, and to specialize and JIT-compile the code per execution. The resulting performance is competitive with manual implementations.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341702", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Rajan", + "last_name": "Walia", + "institution": "Indiana University" + }, + { + "first_name": "P. J.", + "last_name": "Narayanan", + "institution": "Indiana University" + }, + { + "first_name": "Jacques", + "last_name": "Carette", + "institution": "McMaster University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + }, + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/WaliaNCTS19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341697", + "title": "Fuzzi: a three-level logic for differential privacy", + "abstract": "Curators of sensitive datasets sometimes need to know whether queries against the data are differentially private . Two sorts of logics have been proposed for checking this property: (1) type systems and other static analyses, which fully automate straightforward reasoning with concepts like “program sensitivity” and “privacy loss,” and (2) full-blown program logics such as apRHL (an approximate, probabilistic, relational Hoare logic), which support more flexible reasoning about subtle privacy-preserving algorithmic techniques but offer only minimal automation. We propose a three-level logic for differential privacy in an imperative setting and present a prototype implementation called Fuzzi. Fuzzi’s lowest level is a general-purpose logic; its middle level is apRHL; and its top level is a novel sensitivity logic adapted from the linear-logic-inspired type system of Fuzz, a differentially private functional language. The key novelty is a high degree of integration between the sensitivity logic and the two lower-level logics: the judgments and proofs of the sensitivity logic can be easily translated into apRHL; conversely, privacy properties of key algorithmic building blocks can be proved manually in apRHL and the base logic, then packaged up as typing rules that can be applied by a checker for the sensitivity logic to automatically construct privacy proofs for composite programs of arbitrary size. We demonstrate Fuzzi’s utility by implementing four different private machine-learning algorithms and showing that Fuzzi’s checker is able to derive tight sensitivity bounds.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341697", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Hengchu", + "last_name": "Zhang", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Edo", + "last_name": "Roth", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Andreas", + "last_name": "Haeberlen", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Aaron", + "last_name": "Roth", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/ZhangRHP019", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341705", + "title": "A role for dependent types in Haskell", + "abstract": "Modern Haskell supports zero-cost coercions, a mechanism where types that share the same run-time representation may be freely converted between. To make sure such conversions are safe and desirable, this feature relies on a mechanism of roles to prohibit invalid coercions. In this work, we show how to incorporate roles into dependent types systems and prove, using the Coq proof assistant, that the resulting system is sound. We have designed this work as a foundation for the addition of dependent types to the Glasgow Haskell Compiler, but we also expect that it will be of use to designers of other dependently-typed languages who might want to adopt Haskell’s safe coercions feature.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341705", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Pritam", + "last_name": "Choudhury", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Antoine", + "last_name": "Voizard", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + } + ], + "dblp_key": "journals/pacmpl/WeirichCVE19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341700", + "title": "Demystifying differentiable programming: shift/reset the penultimate backpropagator", + "abstract": "Deep learning has seen tremendous success over the past decade in computer vision, machine translation, and gameplay. This success rests crucially on gradient-descent optimization and the ability to “learn” parameters of a neural network by backpropagating observed errors. However, neural network architectures are growing increasingly sophisticated and diverse, which motivates an emerging quest for even more general forms of differentiable programming, where arbitrary parameterized computations can be trained by gradient descent. In this paper, we take a fresh look at automatic differentiation (AD) techniques, and especially aim to demystify the reverse-mode form of AD that generalizes backpropagation in neural networks. We uncover a tight connection between reverse-mode AD and delimited continuations, which permits implementing reverse-mode AD purely via operator overloading and without managing any auxiliary data structures. We further show how this formulation of AD can be fruitfully combined with multi-stage programming (staging), leading to an efficient implementation that combines the performance benefits of deep learning frameworks based on explicit reified computation graphs (e.g., TensorFlow) with the expressiveness of pure library approaches (e.g., PyTorch).", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341700", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Fei", + "last_name": "Wang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Daniel", + "last_name": "Zheng", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "James", + "last_name": "Decker", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xilun", + "last_name": "Wu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Grégory M.", + "last_name": "Essertel", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WangZDWER19", + "venue": "icfp", + "year": 2019 + }, + { + "paper_id": "10.1145/3341716", + "title": "A mechanical formalization of higher-ranked polymorphic type inference", + "abstract": "Modern functional programming languages, such as Haskell or OCaml, use sophisticated forms of type inference. While an important topic in the Programming Languages research, there is little work on the mechanization of the metatheory of type inference in theorem provers. In particular we are unaware of any complete formalization of the type inference algorithms that are the backbone of modern functional languages. This paper presents the first full mechanical formalization of the metatheory for higher-ranked polymorphic type inference. The system that we formalize is the bidirectional type system by Dunfield and Krishnaswami (DK). The DK type system has two variants (a declarative and an algorithmic one) that have been manually proven sound , complete and decidable . We present a mechanical formalization in the Abella theorem prover of DK’s declarative type system with a novel algorithmic system. We have a few reasons to use a new algorithm. Firstly, our new algorithm employs worklist judgments , which precisely capture the scope of variables and simplify the formalization of scoping in a theorem prover. Secondly, while DK’s original formalization comes with very well-written manual proofs, there are several details missing and some incorrect proofs, which complicate the task of writing a mechanized proof. Despite the use of a different algorithm we prove the same results as DK, although with significantly different proofs and proof techniques. Since such type inference algorithms are quite subtle and have a complex metatheory, mechanical formalizations are an important advance in type-inference research.", + "date": "2019-07-26", + "link": "https://doi.org/10.1145/3341716", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jinxu", + "last_name": "Zhao", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/ZhaoOS19", + "venue": "icfp", + "year": 2019 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2020.json b/data/pl_conferences/icfp/2020.json new file mode 100644 index 0000000..00eca81 --- /dev/null +++ b/data/pl_conferences/icfp/2020.json @@ -0,0 +1,1093 @@ +[ + { + "paper_id": "10.1145/3408979", + "title": "Denotational recurrence extraction for amortized analysis", + "abstract": "A typical way of analyzing the time complexity of functional programs is to extract a recurrence expressing the running time of the program in terms of the size of its input, and then to solve the recurrence to obtain a big-O bound. For recurrence extraction to be compositional, it is also necessary to extract recurrences for the size of outputs of helper functions. Previous work has developed techniques for using logical relations to state a formal correctness theorem for a general recurrence extraction translation: a program is bounded by a recurrence when the operational cost is bounded by the extracted cost, and the output value is bounded, according to a value bounding relation defined by induction on types, by the extracted size. This previous work supports higher-order functions by viewing recurrences as programs in a lambda-calculus, or as mathematical entities in a denotational semantics thereof. In this paper, we extend these techniques to support amortized analysis, where costs are rearranged from one portion of a program to another to achieve more precise bounds. We give an intermediate language in which programs can be annotated according to the banker's method of amortized analysis; this language has an affine type system to ensure credits are not spent more than once. We give a recurrence extraction translation of this language into a recurrence language, a simply-typed lambda-calculus with a cost type, and state and prove a bounding logical relation expressing the correctness of this translation. The recurrence language has a denotational semantics in preorders, and we use this semantics to solve recurrences, e.g analyzing binary counters and splay trees.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408979", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joseph W.", + "last_name": "Cutler", + "institution": "Wesleyan University" + }, + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Wesleyan University" + }, + { + "first_name": "Norman", + "last_name": "Danner", + "institution": "Wesleyan University" + } + ], + "dblp_key": "journals/pacmpl/CutlerLD20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408994", + "title": "Regular language type inference with term rewriting", + "abstract": "This paper defines a new type system applied to the fully automatic verification of safety properties of tree-processing higher-order functional programs. We use term rewriting systems to model the program and its semantics and tree automata to model algebraic data types. We define the regular abstract interpretation of the input term rewriting system where the abstract domain is a set of regular languages. From the regular abstract interpretation we derive a type system where each type is a regular language. We define an inference procedure for this type system which allows us check the validity of safety properties. The inference mechanism is built on an invariant learning procedure based on the tree automata completion algorithm. This invariant learning procedure is regularly-complete and complete in refutation, meaning that if it is possible to give a regular type to a term then we will eventually find it, and if there is no possible type (regular or not) then we will eventually find a counter-example.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408994", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Timothée", + "last_name": "Haudebourg", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Thomas", + "last_name": "Genet", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Thomas Wiben", + "last_name": "Jensen", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/HaudebourgGJ20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408980", + "title": "Duplo: a framework for OCaml post-link optimisation", + "abstract": "We present a novel framework, Duplo , for the low-level post-link optimisation of OCaml programs, achieving a speedup of 7% and a reduction of at least 15% of the code size of widely-used OCaml applications. Unlike existing post-link optimisers, which typically operate on target-specific machine code, our framework operates on a Low-Level Intermediate Representation (LLIR) capable of representing both the OCaml programs and any C dependencies they invoke through the foreign-function interface (FFI). LLIR is analysed, transformed and lowered to machine code by our post-link optimiser, LLIR-OPT. Most importantly, LLIR allows the optimiser to cross the OCaml-C language boundary, mitigating the overhead incurred by the FFI and enabling analyses and transformations in a previously unavailable context. The optimised IR is then lowered to amd64 machine code through the existing target-specific code generator of LLVM, modified to handle garbage collection just as effectively as the native OCaml backend. We equip our optimiser with a suite of SSA-based transformations and points-to analyses capable of capturing the semantics and representing the memory models of both languages, along with a cross-language inliner to embed C methods into OCaml callers. We evaluate the gains of our framework, which can be attributed to both our optimiser and the more sophisticated amd64 backend of LLVM, on a wide-range of widely-used OCaml applications, as well as an existing suite of micro- and macro-benchmarks used to track the performance of the OCaml compiler.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408980", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nandor", + "last_name": "Licker", + "institution": "University of Cambridge" + }, + { + "first_name": "Timothy M.", + "last_name": "Jones", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/LickerJ20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408974", + "title": "Achieving high-performance the functional way: a functional pearl on expressing high-performance optimizations as rewrite strategies", + "abstract": "Optimizing programs to run efficiently on modern parallel hardware is hard but crucial for many applications. The predominantly used imperative languages - like C or OpenCL - force the programmer to intertwine the code describing functionality and optimizations. This results in a portability nightmare that is particularly problematic given the accelerating trend towards specialized hardware devices to further increase efficiency. Many emerging DSLs used in performance demanding domains such as deep learning or high-performance image processing attempt to simplify or even fully automate the optimization process. Using a high-level - often functional - language, programmers focus on describing functionality in a declarative way. In some systems such as Halide or TVM, a separate schedule specifies how the program should be optimized. Unfortunately, these schedules are not written in well-defined programming languages. Instead, they are implemented as a set of ad-hoc predefined APIs that the compiler writers have exposed. In this functional pearl, we show how to employ functional programming techniques to solve this challenge with elegance. We present two functional languages that work together - each addressing a separate concern. RISE is a functional language for expressing computations using well known functional data-parallel patterns. ELEVATE is a functional language for describing optimization strategies. A high-level RISE program is transformed into a low-level form using optimization strategies written in ELEVATE . From the rewritten low-level program high-performance parallel code is automatically generated. In contrast to existing high-performance domain-specific systems with scheduling APIs, in our approach programmers are not restricted to a set of built-in operations and optimizations but freely define their own computational patterns in RISE and optimization strategies in ELEVATE in a composable and reusable way. We show how our holistic functional approach achieves competitive performance with the state-of-the-art imperative systems Halide and TVM.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408974", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bastian", + "last_name": "Hagedorn", + "institution": "University of Münster" + }, + { + "first_name": "Johannes", + "last_name": "Lenfers", + "institution": "University of Münster" + }, + { + "first_name": "Thomas", + "last_name": "Kœhler", + "institution": "University of Glasgow" + }, + { + "first_name": "Xueying", + "last_name": "Qin", + "institution": "University of Glasgow" + }, + { + "first_name": "Sergei", + "last_name": "Gorlatch", + "institution": "University of Münster" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "University of Glasgow" + } + ], + "dblp_key": "journals/pacmpl/HagedornLKQGS20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408988", + "title": "Liquid resource types", + "abstract": "This article presents liquid resource types, a technique for automatically verifying the resource consumption of functional programs. Existing resource analysis techniques trade automation for flexibility – automated techniques are restricted to relatively constrained families of resource bounds, while more expressive proof techniques admitting value-dependent bounds rely on handwritten proofs. Liquid resource types combine the best of these approaches, using logical refinements to automatically prove precise bounds on a program’s resource consumption. The type system augments refinement types with potential annotations to conduct an amortized resource analysis. Importantly, users can annotate data structure declarations to indicate how potential is allocated within the type, allowing the system to express bounds with polynomials and exponentials, as well as more precise expressions depending on program values. We prove the soundness of the type system, provide a library of flexible and reusable data structures for conducting resource analysis, and use our prototype implementation to automatically verify resource bounds that previously required a manual proof.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408988", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tristan", + "last_name": "Knoth", + "institution": "University of California San Diego" + }, + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Adam", + "last_name": "Reynolds", + "institution": "University of California San Diego" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/KnothWRHP20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408990", + "title": "Parsing with zippers (functional pearl)", + "abstract": "Parsing with Derivatives (PwD) is an elegant approach to parsing context-free grammars (CFGs). It takes the equational theory behind Brzozowski's derivative for regular expressions and augments that theory with laziness, memoization, and fixed points. The result is a simple parser for arbitrary CFGs. Although recent work improved the performance of PwD, it remains inefficient due to the algorithm repeatedly traversing some parts of the grammar. In this functional pearl, we show how to avoid this inefficiency by suspending the state of the traversal in a zipper. When subsequent derivatives are taken, we can resume the traversal from where we left off without retraversing already traversed parts of the grammar. However, the original zipper is designed for use with trees, and we want to parse CFGs. CFGs can include shared regions, cycles, and choices between alternates, which makes them incompatible with the traditional tree model for zippers. This paper develops a generalization of zippers to properly handle these additional features. Just as PwD generalized Brzozowski's derivatives from regular expressions to CFGs, we generalize Huet's zippers from trees to CFGs. Abstract The resulting parsing algorithm is concise and efficient: it takes only 31 lines of OCaml code to implement the derivative function but performs 6,500 times faster than the original PwD and 3.24 times faster than the optimized implementation of PwD.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408990", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pierce", + "last_name": "Darragh", + "institution": "University of Utah" + }, + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/DarraghA20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408989", + "title": "Lower your guards: a compositional pattern-match coverage checker", + "abstract": "A compiler should warn if a function defined by pattern matching does not cover its inputs—that is, if there are missing or redundant patterns. Generating such warnings accurately is difficult for modern languages due to the myriad of language features that interact with pattern matching. This is especially true in Haskell, a language with a complicated pattern language that is made even more complex by extensions offered by the Glasgow Haskell Compiler (GHC). Although GHC has spent a significant amount of effort towards improving its pattern-match coverage warnings, there are still several cases where it reports inaccurate warnings. We introduce a coverage checking algorithm called Lower Your Guards, which boils down the complexities of pattern matching into guard trees . While the source language may have many exotic forms of patterns, guard trees only have three different constructs, which vastly simplifies the coverage checking process. Our algorithm is modular, allowing for new forms of source-language patterns to be handled with little changes to the overall structure of the algorithm. We have implemented the algorithm in GHC and demonstrate places where it performs better than GHC’s current coverage checker, both in accuracy and performance.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408989", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Graf", + "institution": "" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Ryan G.", + "last_name": "Scott", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/GrafJS20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408996", + "title": "Scala step-by-step: soundness for DOT with step-indexed logical relations in Iris", + "abstract": "The metatheory of Scala’s core type system—the Dependent Object Types (DOT) calculus—is hard to extend, like the metatheory of other type systems combining subtyping and dependent types. Soundness of important Scala features therefore remains an open problem in theory and in practice. To address some of these problems, we use a semantics-first approach to develop a logical relations model for a new version of DOT, called guarded DOT (gDOT) . Our logical relations model makes use of an abstract form of step-indexing , as supported by the Iris framework, to model various forms of recursion in gDOT. To demonstrate the expressiveness of gDOT, we show that it handles Scala examples that could not be handled by previous versions of DOT, and prove using our logical relations model that gDOT provides the desired data abstraction. The gDOT type system, its semantic model, its soundness proofs, and all examples in the paper have been mechanized in Coq.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408996", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paolo G.", + "last_name": "Giarrusso", + "institution": "Delft University of Technology" + }, + { + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "Université Paris Cité" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/GiarrussoSTBK20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408970", + "title": "A general approach to define binders using matching logic", + "abstract": "We propose a novel definition of binders using matching logic, where the binding behavior of object-level binders is directly inherited from the built-in exists binder of matching logic. We show that the behavior of binders in various logical systems such as lambda-calculus, System F, pi-calculus, pure type systems, can be axiomatically defined in matching logic as notations and logical theories. We show the correctness of our definitions by proving conservative extension theorems, which state that a sequent/judgment is provable in the original system if and only if it is provable in matching logic, in the corresponding theory. Our matching logic definition of binders also yields models to all binders, which are deductively complete with respect to formal reasoning in the original systems. For lambda-calculus, we further show that the yielded models are representationally complete, a desired property that is not enjoyed by many existing lambda-calculus semantics. This work is part of a larger effort to develop a logical foundation for the programming language semantics framework K (http://kframework.org).", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408970", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Xiaohong", + "last_name": "Chen", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/ChenR20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408982", + "title": "Effects for efficiency: asymptotic speedup with first-class control", + "abstract": "We study the fundamental efficiency of delimited control. Specifically, we show that effect handlers enable an asymptotic improvement in runtime complexity for a certain class of functions. We consider the generic count problem using a pure PCF-like base language λ b and its extension with effect handlers λ h . We show that λ h admits an asymptotically more efficient implementation of generic count than any λ b implementation. We also show that this efficiency gap remains when λ b is extended with mutable state. To our knowledge this result is the first of its kind for control operators.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408982", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Hillerström", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "Heriot-Watt University" + }, + { + "first_name": "John", + "last_name": "Longley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/HillerstromLL20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408998", + "title": "Separation logic for sequential programs (functional pearl)", + "abstract": "This paper presents a simple mechanized formalization of Separation Logic for sequential programs. This formalization is aimed for teaching the ideas of Separation Logic, including its soundness proof and its recent enhancements. The formalization serves as support for a course that follows the style of the successful Software Foundations series, with all the statement and proofs formalized in Coq. This course only assumes basic knowledge of lambda-calculus, semantics and logics, and therefore should be accessible to a broad audience.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408998", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/Chargueraud20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408986", + "title": "Kinds are calling conventions", + "abstract": "A language supporting polymorphism is a boon to programmers: they can express complex ideas once and reuse functions in a variety of situations. However, polymorphism is pain for compilers tasked with producing efficient code that manipulates concrete values. This paper presents a new intermediate language that allows for efficient static compilation, while still supporting flexible polymorphism. Specifically, it permits polymorphism over not only the types of values, but also the representation of values, the arity of primitive machine functions, and the evaluation order of arguments---all three of which are useful in practice. The key insight is to encode information about a value's calling convention in the kind of its type, rather than in the type itself.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408986", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Downen", + "institution": "University of Oregon" + }, + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "University of Oregon" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + } + ], + "dblp_key": "journals/pacmpl/DownenAJE20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3409005", + "title": "TLC: temporal logic of distributed components", + "abstract": "Distributed systems are critical to reliable and scalable computing; however, they are complicated in nature and prone to bugs. To manage this complexity, network middleware has been traditionally built in layered stacks of components.We present a novel approach to compositional verification of distributed stacks to verify each component based on only the specification of lower components. We present TLC (Temporal Logic of Components), a novel temporal program logic that offers intuitive inference rules for verification of both safety and liveness properties of functional implementations of distributed components. To support compositional reasoning, we define a novel transformation on the assertion language that lowers the specification of a component to be used as a subcomponent. We prove the soundness of TLC and the lowering transformation with respect to a novel operational semantics for stacks of composed components in partially synchronous networks. We successfully apply TLC to compose and verify a stack of fundamental distributed components.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3409005", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jeremiah", + "last_name": "Griffin", + "institution": "University of California, Riverside" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Riverside" + }, + { + "first_name": "Narges", + "last_name": "Shadab", + "institution": "University of California, Riverside" + }, + { + "first_name": "Xizhe", + "last_name": "Yin", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "journals/pacmpl/GriffinLSY20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408993", + "title": "Recovering purity with comonads and capabilities", + "abstract": "In this paper, we take a pervasively effectful (in the style of ML) typed lambda calculus, and show how to extend it to permit capturing pure expressions with types. Our key observation is that, just as the pure simply-typed lambda calculus can be extended to support effects with a monadic type discipline, an impure typed lambda calculus can be extended to support purity with a comonadic type discipline. We establish the correctness of our type system via a simple denotational model, which we call the capability space model. Our model formalises the intuition common to systems programmers that the ability to perform effects should be controlled via access to a permission or capability, and that a program is capability-safe if it performs no effects that it does not have a runtime capability for. We then identify the axiomatic categorical structure that the capability space model validates, and use these axioms to give a categorical semantics for our comonadic type system. We then give an equational theory (substitution and the call-by-value β and η laws) for the imperative lambda calculus, and show its soundness relative to this semantics. Finally, we give a translation of the pure simply-typed lambda calculus into our comonadic imperative calculus, and show that any two terms which are βη-equal in the STLC are equal in the equational theory of the comonadic calculus, establishing that pure programs can be mapped in an equation-preserving way into our imperative calculus.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408993", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Vikraman", + "last_name": "Choudhury", + "institution": "Indiana University" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/ChoudhuryK20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408983", + "title": "Elaboration with first-class implicit function types", + "abstract": "Implicit functions are dependently typed functions, such that arguments are provided (by default) by inference machinery instead of programmers of the surface language. Implicit functions in Agda are an archetypal example. In the Haskell language as implemented by the Glasgow Haskell Compiler (GHC), polymorphic types are another example. Implicit function types are first-class if they are treated as any other type in the surface language. This holds in Agda and partially holds in GHC. Inference and elaboration in the presence of first-class implicit functions poses a challenge; in the context of Haskell and ML-like languages, this has been dubbed “impredicative instantiation” or “impredicative inference”. We propose a new solution for elaborating first-class implicit functions, which is applicable to full dependent type theories and compares favorably to prior solutions in terms of power, generality and simplicity. We build atop Norell’s bidirectional elaboration algorithm for Agda, and we note that the key issue is incomplete information about insertions of implicit abstractions and applications. We make it possible to track and refine information related to such insertions, by adding a function type to a core Martin-L'of type theory, which supports strict (definitional) currying. This allows us to represent undetermined domain arities of implicit function types, and we can decide at any point during elaboration whether implicit abstractions should be inserted.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408983", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "András", + "last_name": "Kovács", + "institution": "Eötvös Loránd University" + } + ], + "dblp_key": "journals/pacmpl/Kovacs20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408991", + "title": "Program sketching with live bidirectional evaluation", + "abstract": "We present a system called Smyth for program sketching in a typed functional language whereby the concrete evaluation of ordinary assertions gives rise to input-output examples, which are then used to guide the search to complete the holes. The key innovation, called live bidirectional evaluation, propagates examples \"backward\" through partially evaluated sketches. Live bidirectional evaluation enables Smyth to (a) synthesize recursive functions without trace-complete sets of examples and (b) specify and solve interdependent synthesis goals. Eliminating the trace-completeness requirement resolves a significant limitation faced by prior synthesis techniques when given partial specifications in the form of input-output examples. To assess the practical implications of our techniques, we ran several experiments on benchmarks used to evaluate Myth, a state-of-the-art example-based synthesis tool. First, given expert examples (and no partial implementations), we find that Smyth requires on average 66% of the number of expert examples required by Myth. Second, we find that Smyth is robust to randomly-generated examples, synthesizing many tasks with relatively few more random examples than those provided by an expert. Third, we create a suite of small sketching tasks by systematically employing a simple sketching strategy to the Myth benchmarks; we find that user-provided sketches in Smyth often further reduce the total specification burden (i.e. the combination of partial implementations and examples). Lastly, we find that Leon and Synquid, two state-of-the-art logic-based synthesis tools, fail to complete several tasks on which Smyth succeeds.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408991", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Justin", + "last_name": "Lubin", + "institution": "University of Chicago" + }, + { + "first_name": "Nick", + "last_name": "Collins", + "institution": "University of Chicago" + }, + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" + }, + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of Chicago" + } + ], + "dblp_key": "journals/pacmpl/LubinCOC20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408972", + "title": "A unified view of modalities in type systems", + "abstract": "We propose to unify the treatment of a broad range of modalities in typed lambda calculi. We do so by defining a generic structure of modalities, and show that this structure arises naturally from the structure of intuitionistic logic, and as such finds instances in a wide range of type systems previously described in literature. Despite this generality, this structure has a rich metatheory, which we expose.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408972", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "University of Gothenburg" + }, + { + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "journals/pacmpl/AbelB20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3409000", + "title": "Sparcl: a language for partially-invertible computation", + "abstract": "Invertibility is a fundamental concept in computer science, with various manifestations in software development (serializer/deserializer, parser/printer, redo/undo, compressor/decompressor, and so on). Full invertibility necessarily requires bijectivity, but the direct approach of composing bijective functions to develop invertible programs is too restrictive to be useful. In this paper, we take a different approach by focusing on partially-invertible functions—functions that become invertible if some of their arguments are fixed. The simplest example of such is addition, which becomes invertible when fixing one of the operands. More involved examples include entropy-based compression methods (e.g., Huffman coding), which carry the occurrence frequency of input symbols (in certain formats such as Huffman tree), and fixing this frequency information makes the compression methods invertible. We develop a language Sparcl for programming such functions in a natural way, where partial-invertibility is the norm and bijectivity is a special case, hence gaining significant expressiveness without compromising correctness. The challenge in designing such a language is to allow ordinary programming (the “partially” part) to interact with the invertible part freely, and yet guarantee invertibility by construction. The language Sparcl is linear-typed, and has a type constructor to distinguish data that are subject to invertible computation and those that are not. We present the syntax, type system, and semantics of the language, and prove that Sparcl correctly guarantees invertibility for its programs. We demonstrate the expressiveness of Sparcl with examples including tree rebuilding from preorder and inorder traversals and Huffman coding.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3409000", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/MatsudaW20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408997", + "title": "Sealing pointer-based optimizations behind pure functions", + "abstract": "Functional programming languages are particularly well-suited for building automated reasoning systems, since (among other reasons) a logical term is well modeled by an inductive type, traversing a term can be implemented generically as a higher-order combinator, and backtracking search is dramatically simplified by persistent datastructures. However, existing pure functional programming languages all suffer a major limitation in these domains: traversing a term requires time proportional to the tree size of the term as opposed to its graph size. This limitation would be particularly devastating when building automation for interactive theorem provers such as Lean and Coq, for which the exponential blowup of term-tree sizes has proved to be both common and difficult to prevent. All that is needed to recover the optimal scaling is the ability to perform simple operations on the memory addresses of terms, and yet allowing these operations to be used freely would clearly violate the basic premise of referential transparency. We show how to use dependent types to seal the necessary pointer-address manipulations behind pure functional interfaces while requiring only a negligible amount of additional trust. We have implemented our approach for the upcoming version (v4) of Lean, and our approach could be adopted by other languages based on dependent type theory as well.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408997", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Selsam", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Simon", + "last_name": "Hudon", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Leonardo de", + "last_name": "Moura", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/SelsamHM20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3409006", + "title": "The simple essence of algebraic subtyping: principal type inference with subtyping made easy (functional pearl)", + "abstract": "MLsub extends traditional Hindley-Milner type inference with subtyping while preserving compact principal types, an exciting new development. However, its specification in terms of biunification is difficult to understand, relying on the new concepts of bisubstitution and polar types, and making use of advanced notions from abstract algebra. In this paper, we show that these are in fact not essential to understanding the mechanisms at play in MLsub. We propose an alternative algorithm called Simple-sub, which can be implemented efficiently in under 500 lines of code (including parsing, simplification, and pretty-printing), looks more familiar, and is easier to understand. We present an experimental evaluation of Simple-sub against MLsub on a million randomly-generated well-scoped expressions, showing that the two systems agree. The mutable automaton-based implementation of MLsub is quite far from its algebraic specification, leaving a lot of space for errors; in fact, our evaluation uncovered several bugs in it. We sketch more straightforward soundness and completeness arguments for Simple-sub, based on a syntactic specification of the type system. This paper is meant to be light in formalism, rich in insights, and easy to consume for prospective designers of new type systems and programming languages. In particular, no abstract algebra is inflicted on readers.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3409006", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/Parreaux20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408978", + "title": "Cosmo: a concurrent separation logic for multicore OCaml", + "abstract": "Multicore OCaml extends OCaml with support for shared-memory concurrency. It is equipped with a weak memory model, for which an operational semantics has been published. This begs the question: what reasoning rules can one rely upon while writing or verifying Multicore OCaml code? To answer it, we instantiate Iris, a modern descendant of Concurrent Separation Logic, for Multicore OCaml. This yields a low-level program logic whose reasoning rules expose the details of the memory model. On top of it, we build a higher-level logic, Cosmo, which trades off some expressive power in return for a simple set of reasoning rules that allow accessing nonatomic locations in a data-race-free manner, exploiting the sequentially-consistent behavior of atomic locations, and exploiting the release/acquire behavior of atomic locations. Cosmo allows both low-level reasoning, where the details of the Multicore OCaml memory model are apparent, and high-level reasoning, which is independent of this memory model. We illustrate this claim via a number of case studies: we verify several implementations of locks with respect to a classic, memory-model-independent specification. Thus, a coarse-grained application that uses locks as the sole means of synchronization can be verified in the Concurrent-Separation-Logic fragment of Cosmo, without any knowledge of the weak memory model.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408978", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Glen", + "last_name": "Mével", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Laboratoire de Recherche en Informatique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/MevelJP20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408985", + "title": "Kindly bent to free us", + "abstract": "Systems programming often requires the manipulation of resources like file handles, network connections, or dynamically allocated memory. Programmers need to follow certain protocols to handle these resources correctly. Violating these protocols causes bugs ranging from type mismatches over data races to use-after-free errors and memory leaks. These bugs often lead to security vulnerabilities. While statically typed programming languages guarantee type soundness and memory safety by design, most of them do not address issues arising from improper handling of resources. An important step towards handling resources is the adoption of linear and affine types that enforce single-threaded resource usage. However, the few languages supporting such types require heavy type annotations. We present Affe, an extension of ML that manages linearity and affinity properties using kinds and constrained types. In addition Affe supports the exclusive and shared borrowing of affine resources, inspired by features of Rust. Moreover, Affe retains the defining features of the ML family: it is an impure, strict, functional expression language with complete principal type inference and type abstraction. does not require any linearity annotations in expressions and supports common functional programming idioms.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408985", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Radanne", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Hannes", + "last_name": "Saffrich", + "institution": "University of Freiburg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "journals/pacmpl/RadanneST20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408984", + "title": "Higher-order demand-driven symbolic evaluation", + "abstract": "Symbolic backwards execution (SBE) is a useful variation on standard forward symbolic evaluation; it allows a symbolic evaluation to start anywhere in the program and proceed by executing in reverse to the program start. SBE brings goal-directed reasoning to symbolic evaluation and has proven effective in e.g. automated test generation for imperative languages. In this paper we define DDSE, a novel SBE which operates on a functional as opposed to imperative language; furthermore, it is defined as a natural extension of a backwards-executing interpreter. We establish the soundness of DDSE and define a test generation algorithm for this toy language. We report on an initial reference implementation to confirm the correctness of the principles.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408984", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Palmer", + "institution": "Swarthmore College" + }, + { + "first_name": "Theodore", + "last_name": "Park", + "institution": "Swarthmore College" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Shiwei", + "last_name": "Weng", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "journals/pacmpl/PalmerPSW20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3409001", + "title": "Stable relations and abstract interpretation of higher-order programs", + "abstract": "We present a novel denotational semantics for the untyped call-by-value λ-calculus, where terms are interpreted as stable relations , i.e. as binary relations between substitutions and values, enjoying a monotonicity property. The denotation captures the input-output behaviour of higher-order programs, and is proved sound and complete with respect to the operational semantics. The definition also admits a presentation as a program logic. Following the principles of abstract interpretation, we use our denotational semantics as a collecting semantics to derive a modular relational analysis for higher-order programs. The analysis infers equalities between the arguments of a program and its result—a form of frame condition for functional programs.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3409001", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benoît", + "last_name": "Montagu", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Thomas Wiben", + "last_name": "Jensen", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/MontaguJ20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408975", + "title": "Compiling effect handlers in capability-passing style", + "abstract": "Effect handlers encourage programmers to abstract over repeated patterns of complex control flow. As of today, this abstraction comes at a significant price in performance. In this paper, we aim to achieve abstraction without regret for effect handlers. We present a language for effect handlers in _capability-passing style_ (λ Cap ) and an implementation of this language as a translation to simply-typed lambda calculus in _iterated continuation-passing style_. A suite of benchmarks indicates that the novel combination of capability-passing style and iterated CPS enables significant speedups over existing languages with effect handlers or control operators. Our implementation technique is general and allows us to generate code in any language that supports first-class functions. We then identify a subset of programs for which we can further improve the performance and guarantee full elimination of the effect handler abstraction. To formally capture this subset, we refine λ Cap to λ λ Cap with a more restrictive type system. We present a type-directed translation for λ λ Cap that inserts staging annotations and prove that no abstractions or applications related to effect handlers occur in the translated program. Using this second translation we observe additional speedups in some of the benchmarks.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408975", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/SchusterBO20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408987", + "title": "Liquid information flow control", + "abstract": "We present Lifty, a domain-specific language for data-centric applications that manipulate sensitive data. A Lifty programmer annotates the sources of sensitive data with declarative security policies, and the language statically and automatically verifies that the application handles the data according to the policies. Moreover, if verification fails, Lifty suggests a provably correct repair, thereby easing the programmer burden of implementing policy enforcing code throughout the application. The main insight behind Lifty is to encode information flow control using liquid types, an expressive yet decidable type system. Liquid types enable fully automatic checking of complex, data dependent policies, and power our repair mechanism via type-driven error localization and patch synthesis. Our experience using Lifty to implement three case studies from the literature shows that (1) the Lifty policy language is sufficiently expressive to specify many real-world policies, (2) the Lifty type checker is able to verify secure programs and find leaks in insecure programs quickly, and (3) even if the programmer leaves out all policy enforcing code, the Lifty repair engine is able to patch all leaks automatically within a reasonable time.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408987", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + }, + { + "first_name": "Deian", + "last_name": "Stefan", + "institution": "University of California San Diego" + }, + { + "first_name": "Jean", + "last_name": "Yang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Travis", + "last_name": "Hance", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/PolikarpovaSYIH20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408977", + "title": "Computation focusing", + "abstract": "Focusing is a technique from proof theory that exploits type information to prune inessential nondeterminism from proof search procedures. Viewed through the lens of the Curry-Howard correspondence, a focused typing derivation yields terms in normal form. This paper explores how to exploit focusing for reasoning about contextual equivalences and full abstraction. We present a focused polymorphic call-by-push-value calculus and prove a computational completeness result: for every well-typed term, there exists a focused term that is βη-equivalent to it. This completeness result yields a powerful way to refine the context lemmas for establishing contextual equivalences, cutting down the set that must be considered to just focused contexts. The paper demonstrates the application of focusing to establish program equivalences, including free theorems. It also uses focusing to prove full abstraction of a translation of the pure, total call-by-push-value language into a language with divergence and simple effect types, yielding a novel solution to a simple-to-state, but hitherto difficult to solve problem.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408977", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nick", + "last_name": "Rioux", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/RiouxZ20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408999", + "title": "Signature restriction for polymorphic algebraic effects", + "abstract": "The naive combination of polymorphic effects and polymorphic type assignment has been well known to break type safety. Existing approaches to this problem are classified into two groups: one for restricting how effects are triggered and the other for restricting how they are implemented. This work explores a new approach to ensuring the safety of polymorphic effects in polymorphic type assignment. A novelty of our work lies in finding a restriction on effect interfaces. To formalize our idea, we employ algebraic effects and handlers, where an effect interface is given by a set of operations coupled with type signatures. We propose signature restriction, a new notion to restrict the type signatures of operations, and show that signature restriction is sufficient to ensure type safety of an effectful language equipped with unrestricted polymorphic type assignment. We also develop a type-and-effect system to enable the use of both operations that satisfy and do not satisfy the signature restriction in a single program.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408999", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "The University of Tokyo" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "journals/pacmpl/SekiyamaTI20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408971", + "title": "A quick look at impredicativity", + "abstract": "Type inference for parametric polymorphism is wildly successful, but has always suffered from an embarrassing flaw: polymorphic types are themselves not first class. We present Quick Look, a practical, implemented, and deployable design for impredicative type inference. To demonstrate our claims, we have modified GHC, a production-quality Haskell compiler, to support impredicativity. The changes required are modest, localised, and are fully compatible with GHC's myriad other type system extensions.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408971", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Serrano", + "institution": "Utrecht University" + }, + { + "first_name": "Jurriaan", + "last_name": "Hage", + "institution": "Utrecht University" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "DeepMind (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/SerranoHJV20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3409004", + "title": "Strong functional pearl: Harper's regular-expression matcher in Cedille", + "abstract": "This paper describes an implementation of Harper's continuation-based regular-expression matcher as a strong functional program in Cedille; i.e., Cedille statically confirms termination of the program on all inputs. The approach uses neither dependent types nor termination proofs. Instead, a particular interface dubbed a recursion universe is provided by Cedille, and the language ensures that all programs written against this interface terminate. Standard polymorphic typing is all that is needed to check the code against the interface. This answers a challenge posed by Bove, Krauss, and Sozeau.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3409004", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Stump", + "institution": "University of Iowa" + }, + { + "first_name": "Christa", + "last_name": "Jenkins", + "institution": "University of Iowa" + }, + { + "first_name": "Stephan", + "last_name": "Spahn", + "institution": "University of Iowa" + }, + { + "first_name": "Colin", + "last_name": "McDonald", + "institution": "University of Notre Dame" + } + ], + "dblp_key": "journals/pacmpl/StumpJSM20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408995", + "title": "Retrofitting parallelism onto OCaml", + "abstract": "OCaml is an industrial-strength, multi-paradigm programming language, widely used in industry and academia. OCaml is also one of the few modern managed system programming languages to lack support for shared memory parallel programming. This paper describes the design, a full-fledged implementation and evaluation of a mostly-concurrent garbage collector (GC) for the multicore extension of the OCaml programming language. Given that we propose to add parallelism to a widely used programming language with millions of lines of existing code, we face the challenge of maintaining backwards compatibility--not just in terms of the language features but also the performance of single-threaded code running with the new GC. To this end, the paper presents a series of novel techniques and demonstrates that the new GC strikes a balance between performance and feature backwards compatibility for sequential programs and scales admirably on modern multicore processors.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408995", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Stephen", + "last_name": "Dolan", + "institution": "" + }, + { + "first_name": "Leo", + "last_name": "White", + "institution": "" + }, + { + "first_name": "Sadiq", + "last_name": "Jaffer", + "institution": "" + }, + { + "first_name": "Tom", + "last_name": "Kelly", + "institution": "" + }, + { + "first_name": "Anmol", + "last_name": "Sahoo", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Sudha", + "last_name": "Parimala", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Atul", + "last_name": "Dhiman", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Anil", + "last_name": "Madhavapeddy", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/Sivaramakrishnan20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3409003", + "title": "SteelCore: an extensible concurrent separation logic for effectful dependently typed programs", + "abstract": "Much recent research has been devoted to modeling effects within type theory. Building on this work, we observe that effectful type theories can provide a foundation on which to build semantics for more complex programming constructs and program logics, extending the reasoning principles that apply within the host effectful type theory itself. Concretely, our main contribution is a semantics for concurrent separation logic (CSL) within the F ⋆ proof assistant in a manner that enables dependently typed, effectful F ⋆ programs to make use of concurrency and to be specified and verified using a full-featured, extensible CSL. In contrast to prior approaches, we directly derive the partial-correctness Hoare rules for CSL from the denotation of computations in the effectful semantics of non-deterministically interleaved atomic actions. Demonstrating the flexibility of our semantics, we build generic, verified libraries that support various concurrency constructs, ranging from dynamically allocated, storable spin locks, to protocol-indexed channels. We conclude that our effectful semantics provides a simple yet expressive basis on which to layer domain-specific languages and logics for verified, concurrent programming.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3409003", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Aymeric", + "last_name": "Fromherz", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Denis", + "last_name": "Merigoux", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "University of Ljubljana" + }, + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "Consejo Nacional de Investigaciones Científicas y Técnicas" + } + ], + "dblp_key": "journals/pacmpl/SwamyRFMAM20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408973", + "title": "A dependently typed calculus with pattern matching and erasure inference", + "abstract": "Some parts of dependently typed programs constitute evidence of their type-correctness and, once checked, are unnecessary for execution. These parts can easily become asymptotically larger than the remaining runtime-useful computation, which can cause normally linear-time programs run in exponential time, or worse. We should not make programs run slower by just describing them more precisely. Current dependently typed systems do not erase such computation satisfactorily. By modelling erasure indirectly through type universes or irrelevance, they impose the limitations of these means to erasure. Some useless computation then cannot be erased and idiomatic programs remain asymptotically sub-optimal. In this paper, we explain why we need erasure, that it is different from other concepts like irrelevance, and propose a dependently typed calculus with pattern matching with erasure annotations to model it. We show that erasure in well-typed programs is sound in that it commutes with reduction. Assuming the Church-Rosser property, erasure furthermore preserves convertibility in general. We also give an erasure inference algorithm for erasure-unannotated or partially annotated programs and prove it sound, complete, and optimal with respect to the typing rules of the calculus. Finally, we show that this erasure method is effective in that it can not only recover the expected asymptotic complexity in compiled programs at run time, but it can also shorten compilation times.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408973", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matúš", + "last_name": "Tejiščák", + "institution": "University of St Andrews" + } + ], + "dblp_key": "journals/pacmpl/Tejiscak20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408992", + "title": "Raising expectations: automating expected cost analysis with types", + "abstract": "This article presents a type-based analysis for deriving upper bounds on the expected execution cost of probabilistic programs. The analysis is naturally compositional, parametric in the cost model, and supports higher-order functions and inductive data types. The derived bounds are multivariate polynomials that are functions of data structures. Bound inference is enabled by local type rules that reduce type inference to linear constraint solving. The type system is based on the potential method of amortized analysis and extends automatic amortized resource analysis (AARA) for deterministic programs. A main innovation is that bounds can contain symbolic probabilities, which may appear in data structures and function arguments. Another contribution is a novel soundness proof that establishes the correctness of the derived bounds with respect to a distribution-based operational cost semantics that also includes nontrivial diverging behavior. For cost models like time, derived bounds imply termination with probability one. To highlight the novel ideas, the presentation focuses on linear potential and a core language. However, the analysis is implemented as an extension of Resource Aware ML and supports polynomial bounds and user defined data structures. The effectiveness of the technique is evaluated by analyzing the sample complexity of discrete distributions and with a novel average-case estimation for deterministic programs that combines expected cost analysis with statistical methods.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408992", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "David", + "last_name": "Kahn", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/WangKH20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408981", + "title": "Effect handlers, evidently", + "abstract": "Algebraic effect handlers are a powerful way to incorporate effects in a programming language. Sometimes perhaps even _too_ powerful. In this article we define a restriction of general effect handlers with _scoped resumptions_. We argue one can still express all important effects, while improving reasoning about effect handlers. Using the newly gained guarantees, we define a sound and coherent evidence translation for effect handlers, which directly passes the handlers as evidence to each operation. We prove full soundness and coherence of the translation into plain lambda calculus. The evidence in turn enables efficient implementations of effect operations; in particular, we show we can execute tail-resumptive operations _in place_ (without needing to capture the evaluation context), and how we can replace the runtime search for a handler by indexing with a constant offset.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3408981", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Daniel", + "last_name": "Hillerström", + "institution": "University of Edinburgh" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/XieBHSL20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3409002", + "title": "Staged selective parser combinators", + "abstract": "Parser combinators are a middle ground between the fine control of hand-rolled parsers and the high-level almost grammar-like appearance of parsers created via parser generators. They also promote a cleaner, compositional design for parsers. Historically, however, they cannot match the performance of their counterparts. This paper describes how to compile parser combinators into parsers of hand-written quality. This is done by leveraging the static information present in the grammar by representing it as a tree. However, in order to exploit this information, it will be necessary to drop support for monadic computation since this generates dynamic structure. Selective functors can help recover lost functionality in the absence of monads, and the parser tree can be partially evaluated with staging. This is implemented in a library called Parsley.", + "date": "2020-08-02", + "link": "https://doi.org/10.1145/3409002", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jamie", + "last_name": "Willis", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + }, + { + "first_name": "Matthew C.", + "last_name": "Pickering", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/WillisWP20", + "venue": "icfp", + "year": 2020 + }, + { + "paper_id": "10.1145/3408976", + "title": "Composing and decomposing op-based CRDTs with semidirect products", + "abstract": "Operation-based Conflict-free Replicated Data Types (CRDTs) are eventually consistent replicated data types that automatically resolve conflicts between concurrent operations. Op-based CRDTs must be designed differently for each data type, and current designs use ad-hoc techniques to handle concurrent operations that do not naturally commute. We present a new construction, the semidirect product of op-based CRDTs, which combines the operations of two CRDTs into one while handling conflicts between their concurrent operations in a uniform way. We demonstrate the construction's utility by using it to construct novel CRDTs, as well as decomposing several existing CRDTs as semidirect products of simpler CRDTs. Although it reproduces common CRDT semantics, the semidirect product can be viewed as a restricted kind of operational transformation, thus forming a bridge between these two opposing techniques for constructing replicated data types.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3408976", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Weidner", + "institution": "" + }, + { + "first_name": "Heather", + "last_name": "Miller", + "institution": "" + }, + { + "first_name": "Christopher", + "last_name": "Meiklejohn", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/WeidnerMM20", + "venue": "icfp", + "year": 2020 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2021.json b/data/pl_conferences/icfp/2021.json new file mode 100644 index 0000000..c07d574 --- /dev/null +++ b/data/pl_conferences/icfp/2021.json @@ -0,0 +1,1032 @@ +[ + { + "paper_id": "10.1145/3473601", + "title": "Newly-single and loving it: improving higher-order must-alias analysis with heap fragments", + "abstract": "Theories of higher-order must-alias analysis, often under the guise of environment analysis, provide deep behavioral insight. But these theories---in particular those that are most insightful otherwise---can reason about recursion only in limited cases. This weakness is not inherent to the theories but to the frameworks in which they're defined: machine models which thread the heap through evaluation. Since these frameworks allocate each abstract resource in the heap, the constituent theories of environment analysis conflate co-live resources identified in the abstract, such as recursively-created bindings. We present heap fragments as a general technique to allow these theories to reason about recursion in a general and robust way. We instantiate abstract counting in a heap-fragment framework and compare its performance to a precursor entire-heap framework. We also sketch an approach to realizing binding invariants, a more powerful environment analysis, in the heap-fragment framework.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473601", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kimball", + "last_name": "Germane", + "institution": "Brigham Young University" + }, + { + "first_name": "Jay", + "last_name": "McCarthy", + "institution": "University of Massachusetts Lowell" + } + ], + "dblp_key": "journals/pacmpl/GermaneM21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473586", + "title": "Theorems for free from separation logic specifications", + "abstract": "Separation logic specifications with abstract predicates intuitively enforce a discipline that constrains when and how calls may be made between a client and a library. Thus a separation logic specification of a library intuitively enforces a protocol on the trace of interactions between a client and the library. We show how to formalize this intuition and demonstrate how to derive \"free theorems\" about such interaction traces from abstract separation logic specifications. We present several examples of free theorems. In particular, we prove that a so-called logically atomic concurrent separation logic specification of a concurrent module operation implies that the operation is linearizable. All the results presented in this paper have been mechanized and formally proved in the Coq proof assistant using the Iris higher-order concurrent separation logic framework.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473586", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + }, + { + "first_name": "Thomas", + "last_name": "Dinsdale-Young", + "institution": "Concord Consortium" + }, + { + "first_name": "Armaël", + "last_name": "Guéneau", + "institution": "Aarhus University" + }, + { + "first_name": "Guilhem", + "last_name": "Jaber", + "institution": "Laboratoire des Sciences du Numérique de Nantes" + }, + { + "first_name": "Kasper", + "last_name": "Svendsen", + "institution": "" + }, + { + "first_name": "Nikos", + "last_name": "Tzevelekos", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "journals/pacmpl/BirkedalDGJST21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473569", + "title": "An existential crisis resolved: type inference for first-class existential types", + "abstract": "Despite the great success of inferring and programming with universal types, their dual—existential types—are much harder to work with. Existential types are useful in building abstract types, working with indexed types, and providing first-class support for refinement types. This paper, set in the context of Haskell, presents a bidirectional type-inference algorithm that infers where to introduce and eliminate existentials without any annotations in terms, along with an explicitly typed, type-safe core language usable as a compilation target. This approach is backward compatible. The key ingredient is to use strong existentials, which support (lazily) projecting out the encapsulated data, not weak existentials accessible only by pattern-matching.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473569", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "" + }, + { + "first_name": "Guillaume", + "last_name": "Duboc", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Daniel", + "last_name": "Lee", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/EisenbergDWL21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473590", + "title": "Steel: proof-oriented programming in a dependently typed concurrent separation logic", + "abstract": "Steel is a language for developing and proving concurrent programs embedded in F ⋆ , a dependently typed programming language and proof assistant. Based on SteelCore, a concurrent separation logic (CSL) formalized in F ⋆ , our work focuses on exposing the proof rules of the logic in a form that enables programs and proofs to be effectively co-developed. Our main contributions include a new formulation of a Hoare logic of quintuples involving both separation logic and first-order logic, enabling efficient verification condition (VC) generation and proof discharge using a combination of tactics and SMT solving. We relate the VCs produced by our quintuple system to solving a system of associativity-commutativity (AC) unification constraints and develop tactics to (partially) solve these constraints using AC-matching modulo SMT-dischargeable equations. Our system is fully mechanized and implemented in F ⋆ . We evaluate it by developing several verified programs and libraries, including various sequential and concurrent linked data structures, proof libraries, and a library for 2-party session types. Our experience leads us to conclude that our system enables a mixture of automated and interactive proof, making it productive to build programs foundationally verified against a highly expressive, state-of-the-art CSL.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473590", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Aymeric", + "last_name": "Fromherz", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sydney", + "last_name": "Gibson", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "Consejo Nacional de Investigaciones Científicas y Técnicas" + }, + { + "first_name": "Denis", + "last_name": "Merigoux", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/FromherzRSGMMR21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473595", + "title": "ProbNV: probabilistic verification of network control planes", + "abstract": "ProbNV is a new framework for probabilistic network control plane verification that strikes a balance between generality and scalability. ProbNV is general enough to encode a wide range of features from the most common protocols (eBGP and OSPF) and yet scalable enough to handle challenging properties, such as probabilistic all-failures analysis of medium-sized networks with 100-200 devices. When there are a small, bounded number of failures, networks with up to 500 devices may be verified in seconds. ProbNV operates by translating raw CISCO configurations into a probabilistic and functional programming language designed for network verification. This language comes equipped with a novel type system that characterizes the sort of representation to be used for each data structure: concrete for the usual representation of values; symbolic for a BDD-based representation of sets of values; and multi-value for an MTBDD-based representation of values that depend upon symbolics. Careful use of these varying representations speeds execution of symbolic simulation of network models. The MTBDD-based representations are also used to calculate probabilistic properties of network models once symbolic simulation is complete. We implement the language and evaluate its performance on benchmarks constructed from real network topologies and synthesized routing policies.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473595", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nick", + "last_name": "Giannarakis", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/GiannarakisSW21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473583", + "title": "Symbolic and automatic differentiation of languages", + "abstract": "Formal languages are usually defined in terms of set theory. Choosing type theory instead gives us languages as type-level predicates over strings. Applying a language to a string yields a type whose elements are language membership proofs describing how a string parses in the language. The usual building blocks of languages (including union, concatenation, and Kleene closure) have precise and compelling specifications uncomplicated by operational strategies and are easily generalized to a few general domain-transforming and codomain-transforming operations on predicates. A simple characterization of languages (and indeed functions from lists to any type) captures the essential idea behind language “differentiation” as used for recognizing languages, leading to a collection of lemmas about type-level predicates. These lemmas are the heart of two dual parsing implementations—using (inductive) regular expressions and (coinductive) tries—each containing the same code but in dual arrangements (with representation and primitive operations trading places). The regular expression version corresponds to symbolic differentiation, while the trie version corresponds to automatic differentiation. The relatively easy-to-prove properties of type-level languages transfer almost effortlessly to the decidable implementations. In particular, despite the inductive and coinductive nature of regular expressions and tries respectively, we need neither inductive nor coinductive/bisimulation arguments to prove algebraic properties.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473583", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "N&N Pharmaceuticals (United States)" + } + ], + "dblp_key": "journals/pacmpl/Elliott21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473594", + "title": "Distributing intersection and union types with splits and duality (functional pearl)", + "abstract": "Subtyping with intersection and union types is nowadays common in many programming languages. From the perspective of logic, the subtyping problem is essentially the problem of determining logical entailment : does a logical statement follow from another one? Unfortunately, algorithms for deciding subtyping and logical entailment with intersections, unions and various distributivity laws can be highly non-trivial. This functional pearl presents a novel algorithmic formulation for subtyping (and logical entailment) in the presence of various distributivity rules between intersections, unions and implications (i.e. function types). Unlike many existing algorithms which first normalize types and then apply a subtyping algorithm on the normalized types, our new subtyping algorithm works directly on source types. Our algorithm is based on two recent ideas: a generalization of subtyping based on the duality of language constructs called duotyping ; and splittable types , which characterize types that decompose into two simpler types. We show that our algorithm is sound, complete and decidable with respect to a declarative formulation of subtyping based on the minimal relevant logic B + . Moreover, it leads to a simple and compact implementation in under 50 lines of functional code.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473594", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Xuejing", + "last_name": "Huang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/HuangO21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473596", + "title": "Efficient tree-traversals: reconciling parallelism and dense data representations", + "abstract": "Recent work showed that compiling functional programs to use dense, serialized memory representations for recursive algebraic datatypes can yield significant constant-factor speedups for sequential programs. But serializing data in a maximally dense format consequently serializes the processing of that data, yielding a tension between density and parallelism. This paper shows that a disciplined, practical compromise is possible. We present Parallel Gibbon, a compiler that obtains the benefits of dense data formats and parallelism. We formalize the semantics of the parallel location calculus underpinning this novel implementation strategy, and show that it is type-safe. Parallel Gibbon exceeds the parallel performance of existing compilers for purely functional programs that use recursive algebraic datatypes, including, notably, abstract-syntax-tree traversals as in compilers.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473596", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chaitanya", + "last_name": "Koparkar", + "institution": "Indiana University" + }, + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Michael", + "last_name": "Vollmer", + "institution": "University of Kent" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/KoparkarRVKN21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473592", + "title": "On continuation-passing transformations and expected cost analysis", + "abstract": "We define a continuation-passing style (CPS) translation for a typed λ-calculus with probabilistic choice, unbounded recursion, and a tick operator — for modeling cost. The target language is a (non-probabilistic) λ-calculus, enriched with a type of extended positive reals and a fixpoint operator. We then show that applying the CPS transform of an expression M to the continuation λ v . 0 yields the expected cost of M . We also introduce a formal system for higher-order logic, called EHOL, prove it sound, and show it can derive tight upper bounds on the expected cost of classic examples, including Coupon Collector and Random Walk. Moreover, we relate our translation to Kaminski et al.’s ert-calculus, showing that the latter can be recovered by applying our CPS translation to (a generalization of) the classic embedding of imperative programs into λ-calculus. Finally, we prove that the CPS transform of an expression can also be used to compute pre-expectations and to reason about almost sure termination.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473592", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Avanzini", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/AvanziniBL21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473581", + "title": "Automatic amortized resource analysis with the Quantum physicist's method", + "abstract": "We present a novel method for working with the physicist's method of amortized resource analysis, which we call the quantum physicist's method. These principles allow for more precise analyses of resources that are not monotonically consumed, like stack. This method takes its name from its two major features, worldviews and resource tunneling, which behave analogously to quantum superposition and quantum tunneling. We use the quantum physicist's method to extend the Automatic Amortized Resource Analysis (AARA) type system, enabling the derivation of resource bounds based on tree depth. In doing so, we also introduce remainder contexts, which aid bookkeeping in linear type systems. We then evaluate this new type system's performance by bounding stack use of functions in the Set module of OCaml's standard library. Compared to state-of-the-art implementations of AARA, our new system derives tighter bounds with only moderate overhead.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473581", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David", + "last_name": "Kahn", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/KahnH21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473577", + "title": "Algebras for weighted search", + "abstract": "Weighted search is an essential component of many fundamental and useful algorithms. Despite this, it is relatively under explored as a computational effect, receiving not nearly as much attention as either depth- or breadth-first search. This paper explores the algebraic underpinning of weighted search, and demonstrates how to implement it as a monad transformer. The development first explores breadth-first search, which can be expressed as a polynomial over semirings. These polynomials are generalised to the free semimodule monad to capture a wide range of applications, including probability monads, polynomial monads, and monads for weighted search. Finally, a monad transformer based on the free semimodule monad is introduced. Applying optimisations to this type yields an implementation of pairing heaps, which is then used to implement Dijkstra's algorithm and efficient probabilistic sampling. The construction is formalised in Cubical Agda and implemented in Haskell.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473577", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Donnacha Oisín", + "last_name": "Kidney", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/KidneyW21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473570", + "title": "An order-aware dataflow model for parallel Unix pipelines", + "abstract": "We present a dataflow model for modelling parallel Unix shell pipelines. To accurately capture the semantics of complex Unix pipelines, the dataflow model is order-aware, i.e., the order in which a node in the dataflow graph consumes inputs from different edges plays a central role in the semantics of the computation and therefore in the resulting parallelization. We use this model to capture the semantics of transformations that exploit data parallelism available in Unix shell computations and prove their correctness. We additionally formalize the translations from the Unix shell to the dataflow model and from the dataflow model back to a parallel shell script. We implement our model and transformations as the compiler and optimization passes of a system parallelizing shell pipelines, and use it to evaluate the speedup achieved on 47 pipelines.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473570", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Shivam", + "last_name": "Handa", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Κωνσταντίνος", + "last_name": "Καλλάς", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Nikos", + "last_name": "Vasilakis", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/HandaKVR21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473568", + "title": "Persistent software transactional memory in Haskell", + "abstract": "Emerging persistent memory in commodity hardware allows byte-granular accesses to persistent state at memory speeds. However, to prevent inconsistent state in persistent memory due to unexpected system failures, different write-semantics are required compared to volatile memory. Transaction-based library solutions for persistent memory facilitate the atomic modification of persistent data in languages where memory is explicitly managed by the programmer, such as C/C++. For languages that provide extended capabilities like automatic memory management, a more native integration into the language is needed to maintain the high level of memory abstraction. It is shown in this paper how persistent software transactional memory (PSTM) can be tightly integrated into the runtime system of Haskell to atomically manage values of persistent transactional data types. PSTM has a clear interface and semantics extending that of software transactional memory (STM). Its integration with the language’s memory management retains features like garbage collection and allocation strategies, and is fully compatible with Haskell's lazy execution model. Our PSTM implementation demonstrates competitive performance with low level libraries and trivial portability of existing STM libraries to PSTM. The implementation allows further interesting use cases, such as persistent memoization and persistent Haskell expressions.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473568", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Krauter", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Patrick", + "last_name": "Raaf", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Peter J.", + "last_name": "Braam", + "institution": "University of Oxford" + }, + { + "first_name": "Reza", + "last_name": "Salkhordeh", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "André", + "last_name": "Brinkmann", + "institution": "Johannes Gutenberg University Mainz" + } + ], + "dblp_key": "journals/pacmpl/KrauterRBSEB21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473599", + "title": "Skipping the binder bureaucracy with mixed embeddings in a semantics course (functional pearl)", + "abstract": "Rigorous reasoning about programs calls for some amount of bureaucracy in managing details like variable binding, but, in guiding students through big ideas in semantics, we might hope to minimize the overhead. We describe our experiment introducing a range of such ideas, using the Coq proof assistant, without any explicit representation of variables, instead using a higher-order syntax encoding that we dub \"mixed embedding\": it is neither the fully explicit syntax of deep embeddings nor the syntax-free programming of shallow embeddings. Marquee examples include different takes on concurrency reasoning, including in the traditions of model checking (partial-order reduction), program logics (concurrent separation logic), and type checking (session types) -- all presented without any side conditions on variables.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473599", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/Chlipala21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473588", + "title": "Grafs: declarative graph analytics", + "abstract": "Graph analytics elicits insights from large graphs to inform critical decisions for business, safety and security. Several large-scale graph processing frameworks feature efficient runtime systems; however, they often provide programming models that are low-level and subtly different from each other. Therefore, end users can find implementation and specially optimization of graph analytics error-prone and time-consuming. This paper regards the abstract interface of the graph processing frameworks as the instruction set for graph analytics, and presents Grafs, a high-level declarative specification language for graph analytics and a synthesizer that automatically generates efficient code for five high-performance graph processing frameworks. It features novel semantics-preserving fusion transformations that optimize the specifications and reduce them to three primitives: reduction over paths, mapping over vertices and reduction over vertices. Reductions over paths are commonly calculated based on push or pull models that iteratively apply kernel functions at the vertices. This paper presents conditions, parametric in terms of the kernel functions, for the correctness and termination of the iterative models, and uses these conditions as specifications to automatically synthesize the kernel functions. Experimental results show that the generated code matches or outperforms handwritten code, and that fusion accelerates execution.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473588", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Farzin", + "last_name": "Houshmand", + "institution": "University of California, Riverside" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Riverside" + }, + { + "first_name": "Keval", + "last_name": "Vora", + "institution": "Simon Fraser University" + } + ], + "dblp_key": "journals/pacmpl/HoushmandLV21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473598", + "title": "Higher-order probabilistic adversarial computations: categorical semantics and program logics", + "abstract": "Adversarial computations are a widely studied class of computations where resource-bounded probabilistic adversaries have access to oracles, i.e., probabilistic procedures with private state. These computations arise routinely in several domains, including security, privacy and machine learning. In this paper, we develop program logics for reasoning about adversarial computations in a higher-order setting. Our logics are built on top of a simply typed λ-calculus extended with a graded monad for probabilities and state. The grading is used to model and restrict the memory footprint and the cost (in terms of oracle calls) of computations. Under this view, an adversary is a higher-order expression that expects as arguments the code of its oracles. We develop unary program logics for reasoning about error probabilities and expected values, and a relational logic for reasoning about coupling-based properties. All logics feature rules for adversarial computations, and yield guarantees that are valid for all adversaries that satisfy a fixed resource policy. We prove the soundness of the logics in the category of quasi-Borel spaces, using a general notion of graded predicate liftings, and we use logical relations over graded predicate liftings to establish the soundness of proof rules for adversaries. We illustrate the working of our logics with simple but illustrative examples.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473598", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Boston University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Tetsuya", + "last_name": "Sato", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AguirreBGGKS21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473573", + "title": "How to evaluate blame for gradual types", + "abstract": "Programming language theoreticians develop blame assignment systems and prove blame theorems for gradually typed programming languages. Practical implementations of gradual typing almost completely ignore the idea of blame assignment. This contrast raises the question whether blame provides any value to the working programmer and poses the challenge of how to evaluate the effectiveness of blame assignment strategies. This paper contributes (1) the first evaluation method for blame assignment strategies and (2) the results from applying it to three different semantics for gradual typing. These results cast doubt on the theoretical effectiveness of blame in gradual typing. In most scenarios, strategies with imprecise blame assignment are as helpful to a rationally acting programmer as strategies with provably correct blame.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473573", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lukas", + "last_name": "Lazarek", + "institution": "Northwestern University" + }, + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/LazarekGFD21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473575", + "title": "Of JavaScript AOT compilation performance", + "abstract": "The fastest JavaScript production implementations use just-in-time (JIT) compilation and the vast majority of academic publications about implementations of dynamic languages published during the last two decades focus on JIT compilation. This does not imply that static compilers (AoT) cannot be competitive; as comparatively little effort has been spent creating fast AoT JavaScript compilers, a scientific comparison is lacking. This paper presents the design and implementation of an AoT JavaScript compiler, focusing on a performance analysis. The paper reports on two experiments, one based on standard JavaScript benchmark suites and one based on new benchmarks chosen for their diversity of styles, authors, sizes, provenance, and coverage of the language. The first experiment shows an advantage to JIT compilers, which is expected after the decades of effort that these compilers have paid to these very tests. The second shows more balanced results, as the AoT compiler generates programs that reach competitive speeds and that consume significantly less memory. The paper presents and evaluates techniques that we have either invented or adapted from other systems, to improve AoT JavaScript compilation.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473575", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/Serrano21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473587", + "title": "Calculating dependently-typed compilers (functional pearl)", + "abstract": "Compilers are difficult to write, and difficult to get right. Bahr and Hutton recently developed a new technique for calculating compilers directly from specifications of their correctness, which ensures that the resulting compilers are correct-by-construction. To date, however, this technique has only been applicable to source languages that are untyped. In this article, we show that moving to a dependently-typed setting allows us to naturally support typed source languages, ensure that all compilation components are type-safe, and make the resulting calculations easier to mechanically check using a proof assistant.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473587", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mitchell", + "last_name": "Pickard", + "institution": "University of Nottingham" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/PickardH21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473579", + "title": "Deriving efficient program transformations from rewrite rules", + "abstract": "An efficient optimizing compiler can perform many cascading rewrites in a single pass, using auxiliary data structures such as variable binding maps, delayed substitutions, and occurrence counts. Such optimizers often perform transformations according to relatively simple rewrite rules, but the subtle interactions between the data structures needed for efficiency make them tricky to write and trickier to prove correct. We present a system for semi-automatically deriving both an efficient program transformation and its correctness proof from a list of rewrite rules and specifications of the auxiliary data structures it requires. Dependent types ensure that the holes left behind by our system (for the user to fill in) are filled in correctly, allowing the user low-level control over the implementation without having to worry about getting it wrong. We implemented our system in Coq (though it could be implemented in other logics as well), and used it to write optimization passes that perform uncurrying, inlining, dead code elimination, and static evaluation of case expressions and record projections. The generated implementations are sometimes faster, and at most 40% slower, than hand-written counterparts on a small set of benchmarks; in some cases, they require significantly less code to write and prove correct.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473579", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "John M.", + "last_name": "Li", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/LiA21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473585", + "title": "Reasoning about the garden of forking paths", + "abstract": "Lazy evaluation is a powerful tool for functional programmers. It enables the concise expression of on-demand computation and a form of compositionality not available under other evaluation strategies. However, the stateful nature of lazy evaluation makes it hard to analyze a program's computational cost, either informally or formally. In this work, we present a novel and simple framework for formally reasoning about lazy computation costs based on a recent model of lazy evaluation: clairvoyant call-by-value. The key feature of our framework is its simplicity, as expressed by our definition of the clairvoyance monad. This monad is both simple to define (around 20 lines of Coq) and simple to reason about. We show that this monad can be effectively used to mechanically reason about the computational cost of lazy functional programs written in Coq.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473585", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yao", + "last_name": "Li", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Li-yao", + "last_name": "Xia", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LiXW21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473574", + "title": "A theory of higher-order subtyping with type intervals", + "abstract": "The calculus of Dependent Object Types (DOT) has enabled a more principled and robust implementation of Scala, but its support for type-level computation has proven insufficient. As a remedy, we propose $F^\\omega_{..}$, a rigorous theoretical foundation for Scala's higher-kinded types. $F^\\omega_{..}$ extends $F^\\omega_{<:}$ with interval kinds, which afford a unified treatment of important type- and kind-level abstraction mechanisms found in Scala, such as bounded quantification, bounded operator abstractions, translucent type definitions and first-class subtyping constraints. The result is a flexible and general theory of higher-order subtyping. We prove type and kind safety of $F^\\omega_{..}$, as well as weak normalization of types and undecidability of subtyping. All our proofs are mechanized in Agda using a fully syntactic approach based on hereditary substitution.", + "date": "2021-07-05", + "link": "https://doi.org/10.1145/3473574", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sandro", + "last_name": "Stucki", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Paolo G.", + "last_name": "Giarrusso", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/StuckiG21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473600", + "title": "CPS transformation with affine types for call-by-value implicit polymorphism", + "abstract": "Transformation of programs into continuation-passing style (CPS) reveals the notion of continuations, enabling many applications such as control operators and intermediate representations in compilers. Although type preservation makes CPS transformation more beneficial, achieving type-preserving CPS transformation for implicit polymorphism with call-by-value (CBV) semantics is known to be challenging. We identify the difficulty in the problem that we call scope intrusion. To address this problem, we propose a new CPS target language Λ open that supports two additional constructs for polymorphism: one only binds and the other only generalizes type variables. Unfortunately, their unrestricted use makes Λ open unsafe due to undesired generalization of type variables. We thus equip Λ open with affine types to allow only the type-safe generalization. We then define a CPS transformation from Curry-style CBV System F to type-safe Λ open and prove that the transformation is meaning and type preserving. We also study parametricity of Λ open as it is a fundamental property of polymorphic languages and plays a key role in applications of CPS transformation. To establish parametricity, we construct a parametric, step-indexed Kripke logical relation for Λ open and prove that it satisfies the Fundamental Property as well as soundness with respect to contextual equivalence.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473600", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "Chiba University" + } + ], + "dblp_key": "journals/pacmpl/SekiyamaT21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473593", + "title": "Getting to the point: index sets and parallelism-preserving autodiff for pointful array programming", + "abstract": "We present a novel programming language design that attempts to combine the clarity and safety of high-level functional languages with the efficiency and parallelism of low-level numerical languages. We treat arrays as eagerly-memoized functions on typed index sets, allowing abstract function manipulations, such as currying, to work on arrays. In contrast to composing primitive bulk-array operations, we argue for an explicit nested indexing style that mirrors application of functions to arguments. We also introduce a fine-grained typed effects system which affords concise and automatically-parallelized in-place updates. Specifically, an associative accumulation effect allows reverse-mode automatic differentiation of in-place updates in a way that preserves parallelism. Empirically, we benchmark against the Futhark array programming language, and demonstrate that aggressive inlining and type-driven compilation allows array programs to be written in an expressive, \"pointful\" style with little performance penalty.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473593", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Adam", + "last_name": "Paszke", + "institution": "" + }, + { + "first_name": "Daniel D.", + "last_name": "Johnson", + "institution": "Google (Canada)" + }, + { + "first_name": "David", + "last_name": "Duvenaud", + "institution": "University of Toronto" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "DeepMind (United Kingdom)" + }, + { + "first_name": "Alexey", + "last_name": "Radul", + "institution": "Google (United States)" + }, + { + "first_name": "Matthew", + "last_name": "Johnson", + "institution": "Google (United States)" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Dougal", + "last_name": "Maclaurin", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/PaszkeJDVRJRM21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473591", + "title": "Compositional optimizations for CertiCoq", + "abstract": "Compositional compiler verification is a difficult problem that focuses on separate compilation of program components with possibly different verified compilers. Logical relations are widely used in proving correctness of program transformations in higher-order languages; however, they do not scale to compositional verification of multi-pass compilers due to their lack of transitivity. The only known technique to apply to compositional verification of multi-pass compilers for higher-order languages is parametric inter-language simulations (PILS), which is however significantly more complicated than traditional proof techniques for compiler correctness. In this paper, we present a novel verification framework for lightweight compositional compiler correctness . We demonstrate that by imposing the additional restriction that program components are compiled by pipelines that go through the same sequence of intermediate representations , logical relation proofs can be transitively composed in order to derive an end-to-end compositional specification for multi-pass compiler pipelines. Unlike traditional logical-relation frameworks, our framework supports divergence preservation—even when transformations reduce the number of program steps. We achieve this by parameterizing our logical relations with a pair of relational invariants . We apply this technique to verify a multi-pass, optimizing middle-end pipeline for CertiCoq, a compiler from Gallina (Coq’s specification language) to C. The pipeline optimizes and closure-converts an untyped functional intermediate language (ANF or CPS) to a subset of that language without nested functions, which can be easily code-generated to low-level languages. Notably, our pipeline performs more complex closure-allocation optimizations than the state of the art in verified compilation. Using our novel verification framework, we prove an end-to-end theorem for our pipeline that covers both termination and divergence and applies to whole-program and separate compilation, even when different modules are compiled with different optimizations. Our results are mechanized in the Coq proof assistant.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473591", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Northeastern University" + }, + { + "first_name": "John M.", + "last_name": "Li", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/Paraskevopoulou21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473584", + "title": "Propositions-as-types and shared state", + "abstract": "We develop a principled integration of shared mutable state into a proposition-as-types linear logic interpretation of a session-based concurrent programming language. While the foundation of type systems for the functional core of programming languages often builds on the proposition-as-types correspondence, automatically ensuring strong safety and liveness properties, imperative features have mostly been handled by extra-logical constructions. Our system crucially builds on the integration of nondeterminism and sharing, inspired by logical rules of differential linear logic, and ensures session fidelity, progress, confluence and normalisation, while being able to handle first-class shareable reference cells storing any persistent object. We also show how preservation and, perhaps surprisingly, progress, resiliently survive in a natural extension of our language with first-class locks. We illustrate the expressiveness of our language with examples highlighting detailed features, up to simple shareable concurrent ADTs.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473584", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Pedro", + "last_name": "Rocha", + "institution": "University of Lisbon" + }, + { + "first_name": "Luı́s", + "last_name": "Caires", + "institution": "University of Lisbon" + } + ], + "dblp_key": "journals/pacmpl/RochaC21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473567", + "title": "Client-server sessions in linear logic", + "abstract": "We introduce coexponentials, a new set of modalities for Classical Linear Logic. As duals to exponentials, the coexponentials codify a distributed form of the structural rules of weakening and contraction. This makes them a suitable logical device for encapsulating the pattern of a server receiving requests from an arbitrary number of clients on a single channel. Guided by this intuition we formulate a system of session types based on Classical Linear Logic with coexponentials, which is suited to modelling client-server interactions. We also present a session-typed functional programming language for client-server programming, which we translate to our system of coexponentials.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473567", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zesen", + "last_name": "Qian", + "institution": "Aarhus University" + }, + { + "first_name": "G. A.", + "last_name": "Kavvos", + "institution": "University of Bristol" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/QianKB21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473576", + "title": "Generalized evidence passing for effect handlers: efficient compilation of effect handlers to C", + "abstract": "This paper studies compilation techniques for algebraic effect handlers. In particular, we present a sequence of refinements of algebraic effects, going via multi-prompt delimited control, _generalized evidence passing_, yield bubbling, and finally a monadic translation into plain lambda calculus which can be compiled efficiently to many target platforms. Along the way we explore various interesting points in the design space. We provide two implementations of our techniques, one as a library in Haskell, and one as a C backend for the Koka programming language. We show that our techniques are effective, by comparing against three other best-in-class implementations of effect handlers: multi-core OCaml, the _Ev.Eff_ Haskell library, and the libhandler C library. We hope this work can serve as a basis for future designs and implementations of algebraic effects.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473576", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/XieL21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473582", + "title": "Catala: a programming language for the law", + "abstract": "Law at large underpins modern society, codifying and governing many aspects of citizens' daily lives. Oftentimes, law is subject to interpretation, debate and challenges throughout various courts and jurisdictions. But in some other areas, law leaves little room for interpretation, and essentially aims to rigorously describe a computation, a decision procedure or, simply said, an algorithm. Unfortunately, prose remains a woefully inadequate tool for the job. The lack of formalism leaves room for ambiguities; the structure of legal statutes, with many paragraphs and sub-sections spread across multiple pages, makes it hard to compute the intended outcome of the algorithm underlying a given text; and, as with any other piece of poorly-specified critical software, the use of informal, natural language leaves corner cases unaddressed. We introduce Catala, a new programming language that we specifically designed to allow a straightforward and systematic translation of statutory law into an executable implementation. Notably, Catala makes it natural and easy to express the general case / exceptions logic that permeates statutory law. Catala aims to bring together lawyers and programmers through a shared medium, which together they can understand, edit and evolve, bridging a gap that too often results in dramatically incorrect implementations of the law. We have implemented a compiler for Catala, and have proven the correctness of its core compilation steps using the F* proof assistant. We evaluate Catala on several legal texts that are algorithms in disguise, notably section 121 of the US federal income tax and the byzantine French family benefits; in doing so, we uncover a bug in the official implementation of the French benefits. We observe as a consequence of the formalization process that using Catala enables rich interactions between lawyers and programmers, leading to a greater understanding of the original legislative intent, while producing a correct-by-construction executable specification reusable by the greater software ecosystem. Doing so, Catala increases trust in legal institutions, and mitigates the risk of societal damage due to incorrect implementations of the law.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473582", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Denis", + "last_name": "Merigoux", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Nicolas", + "last_name": "Chataing", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/MerigouxCP21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473571", + "title": "Formal verification of a concurrent bounded queue in a weak memory model", + "abstract": "We use Cosmo, a modern concurrent separation logic, to formally specify and verify an implementation of a multiple-producer multiple-consumer concurrent queue in the setting of the Multicore OCaml weak memory model. We view this result as a demonstration and experimental verification of the manner in which Cosmo allows modular and formal reasoning about advanced concurrent data structures. In particular, we show how the joint use of logically atomic triples and of Cosmo's views makes it possible to describe precisely in the specification the interaction between the queue library and the weak memory model.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473571", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Glen", + "last_name": "Mével", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/MevelJ21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473578", + "title": "Reasoning about effect interaction by fusion", + "abstract": "Effect handlers can be composed by applying them sequentially, each handling some operations and leaving other operations uninterpreted in the syntax tree. However, the semantics of composed handlers can be subtle---it is well known that different orders of composing handlers can lead to drastically different semantics. Determining the correct order of composition is a non-trivial task. To alleviate this problem, this paper presents a systematic way of deriving sufficient conditions on handlers for their composite to correctly handle combinations, such as the sum and the tensor, of the effect theories separately handled. These conditions are solely characterised by the clauses for relevant operations of the handlers, and are derived by fusing two handlers into one using a form of fold/build fusion and continuation-passing style transformation. As case studies, the technique is applied to commutative and distributive interaction of handlers to obtain a series of results about the interaction of common handlers: (a) equations respected by each handler are preserved after handler composition; (b) handling mutable state before any handler gives rise to a semantics in which state operations are commutative with any operations from the latter handler; (c) handling the writer effect and mutable state in either order gives rise to a correct handler of the commutative combination of these two theories.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473578", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhixuan", + "last_name": "Yang", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/YangW21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473589", + "title": "Certifying the synthesis of heap-manipulating programs", + "abstract": "Automated deductive program synthesis promises to generate executable programs from concise specifications, along with proofs of correctness that can be independently verified using third-party tools. However, an attempt to exercise this promise using existing proof-certification frameworks reveals significant discrepancies in how proof derivations are structured for two different purposes: program synthesis and program verification. These discrepancies make it difficult to use certified verifiers to validate synthesis results, forcing one to write an ad-hoc translation procedure from synthesis proofs to correctness proofs for each verification backend. In this work, we address this challenge in the context of the synthesis and verification of heap-manipulating programs. We present a technique for principled translation of deductive synthesis derivations (a.k.a. source proofs) into deductive target proofs about the synthesised programs in the logics of interactive program verifiers. We showcase our technique by implementing three different certifiers for programs generated via SuSLik, a Separation Logic-based tool for automated synthesis of programs with pointers, in foundational verification frameworks embedded in Coq: Hoare Type Theory (HTT), Iris, and Verified Software Toolchain (VST), producing concise and efficient machine-checkable proofs for characteristic synthesis benchmarks.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473589", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yasunari", + "last_name": "Watanabe", + "institution": "National University of Singapore" + }, + { + "first_name": "Kiran", + "last_name": "Gopinathan", + "institution": "National University of Singapore" + }, + { + "first_name": "George", + "last_name": "Pîrlea", + "institution": "National University of Singapore" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/WatanabeGPPS21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473597", + "title": "GhostCell: separating permissions from data in Rust", + "abstract": "The Rust language offers a promising approach to safe systems programming based on the principle of aliasing XOR mutability : a value may be either aliased or mutable, but not both at the same time. However, to implement pointer-based data structures with internal sharing, such as graphs or doubly-linked lists, we need to be able to mutate aliased state. To support such data structures, Rust provides a number of APIs that offer so-called interior mutability : the ability to mutate data via method calls on a shared reference. Unfortunately, the existing APIs sacrifice flexibility, concurrent access, and/or performance, in exchange for safety. In this paper, we propose a new Rust API called GhostCell which avoids such sacrifices by separating permissions from data : it enables the user to safely synchronize access to a collection of data via a single permission. GhostCell repurposes an old trick from typed functional programming: branded types (as exemplified by Haskell’s ST monad), which combine phantom types and rank-2 polymorphism to simulate a lightweight form of state-dependent types. We have formally proven the soundness of GhostCell by adapting and extending RustBelt, a semantic soundness proof for a representative subset of Rust, mechanized in Coq.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473597", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Yanovski", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Hoang-Hai", + "last_name": "Dang", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/YanovskiDJD21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473572", + "title": "Modular, compositional, and executable formal semantics for LLVM IR", + "abstract": "This paper presents a novel formal semantics, mechanized in Coq, for a large, sequential subset of the LLVM IR. In contrast to previous approaches, which use relationally-specified operational semantics, this new semantics is based on monadic interpretation of interaction trees, a structure that provides a more compositional approach to defining language semantics while retaining the ability to extract an executable interpreter. Our semantics handles many of the LLVM IR's non-trivial language features and is constructed modularly in terms of event handlers, including those that deal with nondeterminism in the specification. We show how this semantics admits compositional reasoning principles derived from the interaction trees equational theory of weak bisimulation, which we extend here to better deal with nondeterminism, and we use them to prove that the extracted reference interpreter faithfully refines the semantic model. We validate the correctness of the semantics by evaluating it on unit tests and LLVM IR programs generated by HELIX.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473572", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Calvin", + "last_name": "Beck", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Irene", + "last_name": "Yoon", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Ilia", + "last_name": "Zaichuk", + "institution": "Taras Shevchenko National University of Kyiv" + }, + { + "first_name": "Vadim", + "last_name": "Zaliva", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/ZakowskiBYZZZ21", + "venue": "icfp", + "year": 2021 + }, + { + "paper_id": "10.1145/3473580", + "title": "Contextual modal types for algebraic effects and handlers", + "abstract": "Programming languages with algebraic effects often track the computations’ effects using type-and-effect systems. In this paper, we propose to view an algebraic effect theory of a computation as a variable context; consequently, we propose to track algebraic effects of a computation with contextual modal types . We develop ECMTT, a novel calculus which tracks algebraic effects by a contextualized variant of the modal □ (necessity) operator, that it inherits from Contextual Modal Type Theory (CMTT). Whereas type-and-effect systems add effect annotations on top of a prior programming language, the effect annotations in ECMTT are inherent to the language, as they are managed by programming constructs corresponding to the logical introduction and elimination forms for the □ modality. Thus, the type-and-effect system of ECMTT is actually just a type system. Our design obtains the properties of local soundness and completeness, and determines the operational semantics solely by β-reduction, as customary in other logic-based calculi. In this view, effect handlers arise naturally as a witness that one context (i.e., algebraic theory) can be reached from another, generalizing explicit substitutions from CMTT. To the best of our knowledge, ECMTT is the first system to relate algebraic effects to modal types. We also see it as a step towards providing a correspondence in the style of Curry and Howard that may transfer a number of results from the fields of modal logic and modal type theory to that of algebraic effects.", + "date": "2021-08-19", + "link": "https://doi.org/10.1145/3473580", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nikita", + "last_name": "Zyuzin", + "institution": "IMDEA Food" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software Institute" + } + ], + "dblp_key": "journals/pacmpl/ZyuzinN21", + "venue": "icfp", + "year": 2021 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2022.json b/data/pl_conferences/icfp/2022.json new file mode 100644 index 0000000..e7045f8 --- /dev/null +++ b/data/pl_conferences/icfp/2022.json @@ -0,0 +1,997 @@ +[ + { + "paper_id": "10.1145/3547650", + "title": "Multi types and reasonable space", + "abstract": "Accattoli, Dal Lago, and Vanoni have recently proved that the space used by the Space KAM, a variant of the Krivine abstract machine, is a reasonable space cost model for the λ-calculus accounting for logarithmic space, solving a longstanding open problem. In this paper, we provide a new system of multi types (a variant of intersection types) and extract from multi type derivations the space used by the Space KAM, capturing into a type system the space complexity of the abstract machine. Additionally, we show how to capture also the time of the Space KAM, which is a reasonable time cost model, via minor changes to the type system.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547650", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "École Polytechnique" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Gabriele", + "last_name": "Vanoni", + "institution": "University of Bologna" + } + ], + "dblp_key": "journals/pacmpl/AccattoliLV22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547628", + "title": "Verified symbolic execution with Kripke specification monads (and no meta-programming)", + "abstract": "Verifying soundness of symbolic execution-based program verifiers is a significant challenge. This is especially true if the resulting tool needs to be usable outside of the proof assistant, in which case we cannot rely on shallowly embedded assertion logics and meta-programming. The tool needs to manipulate deeply embedded assertions, and it is crucial for efficiency to eagerly prune unreachable paths and simplify intermediate assertions in a way that can be justified towards the soundness proof. Only a few such tools exist in the literature, and their soundness proofs are intricate and hard to generalize or reuse. We contribute a novel, systematic approach for the construction and soundness proof of such a symbolic execution-based verifier. We first implement a shallow verification condition generator as an object language interpreter in a specification monad, using an abstract interface featuring angelic and demonic nondeterminism. Next, we build a symbolic executor by implementing a similar interpreter, in a symbolic specification monad. This symbolic monad lives in a universe that is Kripke-indexed by variables in scope and a path condition. Finally, we reduce the soundness of the symbolic execution to the soundness of the shallow execution by relating both executors using a Kripke logical relation. We report on the practical application of these techniques in Katamaran, a tool for verifying security guarantees offered by instruction set architectures (ISAs). The tool is fully verified by combining our symbolic execution machinery with a soundness proof of the shallow verification conditions against an axiomatized separation logic, and an Iris-based implementation of the axioms, proven sound against the operational semantics. Based on our experience with Katamaran, we can report good results on practicality and efficiency of the tool, demonstrating practical viability of our symbolic execution approach.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547628", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Steven", + "last_name": "Keuchel", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Sander", + "last_name": "Huyghebaert", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Georgy", + "last_name": "Lukyanov", + "institution": "Newcastle University" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/KeuchelHLD22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547629", + "title": "Datatype-generic programming meets elaborator reflection", + "abstract": "Datatype-generic programming is natural and useful in dependently typed languages such as Agda. However, datatype-generic libraries in Agda are not reused as much as they should be, because traditionally they work only on datatypes decoded from a library’s own version of datatype descriptions; this means that different generic libraries cannot be used together, and they do not work on native datatypes, which are preferred by the practical Agda programmer for better language support and access to other libraries. Based on elaborator reflection, we present a framework in Agda featuring a set of general metaprograms for instantiating datatype-generic programs as, and for, a useful range of native datatypes and functions —including universe-polymorphic ones— in programmer-friendly and customisable forms. We expect that datatype-generic libraries built with our framework will be more attractive to the practical Agda programmer. As the elaborator reflection features used by our framework become more widespread, our design can be ported to other languages too.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547629", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Hsiang−Shang", + "last_name": "Ko", + "institution": "Academia Sinica" + }, + { + "first_name": "Liang-Ting", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "Tzu-Chi", + "last_name": "Lin", + "institution": "Academia Sinica" + } + ], + "dblp_key": "journals/pacmpl/KoCL22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547624", + "title": "Monadic compiler calculation (functional pearl)", + "abstract": "Bahr and Hutton recently developed a new approach to calculating correct compilers directly from specifications of their correctness. However, the methodology only considers converging behaviour of the source language, which means that the compiler could potentially produce arbitrary, erroneous code for source programs that diverge. In this article, we show how the methodology can naturally be extended to support the calculation of compilers that address both convergent and divergent behaviour simultaneously , without the need for separate reasoning for each aspect. Our approach is based on the use of the partiality monad to make divergence explicit, together with the use of strong bisimilarity to support equational-style calculations, but also generalises to other forms of effect by changing the underlying monad.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547624", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Bahr", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/BahrH22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547654", + "title": "Flexible presentations of graded monads", + "abstract": "A large class of monads used to model computational effects have natural presentations by operations and equations, for example, the list monad can be presented by a constant and a binary operation subject to unitality and associativity. Graded monads are a generalization of monads that enable us to track quantitative information about the effects being modelled. Correspondingly, a large class of graded monads can be presented using an existing notion of graded presentation. However, the existing notion has some deficiencies, in particular many effects do not have natural graded presentations. We introduce a notion of flexibly graded presentation that does not suffer from these issues, and develop the associated theory. We show that every flexibly graded presentation induces a graded monad equipped with interpretations of the operations of the presentation, and that all graded monads satisfying a particular condition on colimits have a flexibly graded presentation. As part of this, we show that the usual algebra-preserving correspondence between presentations and a class of monads transfers to an algebra-preserving correspondence between flexibly graded presentations and a class of flexibly graded monads.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547654", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Dylan", + "last_name": "McDermott", + "institution": "Reykjavík University" + }, + { + "first_name": "Tarmo", + "last_name": "Uustalu", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/KatsumataMUW22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547638", + "title": "Multiparty GV: functional multiparty session types with certified deadlock freedom", + "abstract": "Session types have recently been integrated with functional languages, bringing message-passing concurrency to functional programming. Channel endpoints then become first-class and can be stored in data structures, captured in closures, and sent along channels. Representatives of the GV (Wadler's \"Good Variation\") session type family are of particular appeal because they not only assert session fidelity but also deadlock freedom, inspired by a Curry-Howard correspondence to linear logic. A restriction of current versions of GV, however, is the focus on binary sessions, limiting concurrent interactions within a session to two participants. This paper introduces Multiparty GV (MPGV), a functional language with multiparty session types, allowing concurrent interactions among several participants. MPGV upholds the strong guarantees of its ancestor GV, including deadlock freedom, despite session interleaving and delegation. MPGV has a novel redirecting construct for modular programming with first-class endpoints, thanks to which we give a type-preserving translation from binary session types to MPGV to show that MPGV is strictly more general than binary GV. All results in this paper have been mechanized using the Coq proof assistant.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547638", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/JacobsBK22a", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547652", + "title": "The theory of call-by-value solvability", + "abstract": "The semantics of the untyped (call-by-name) lambda-calculus is a well developed field built around the concept of solvable terms, which are elegantly characterized in many different ways. In particular, unsolvable terms provide a consistent notion of meaningless term. The semantics of the untyped call-by-value lambda-calculus (CbV) is instead still in its infancy, because of some inherent difficulties but also because CbV solvable terms are less studied and understood than in call-by-name. On the one hand, we show that a carefully crafted presentation of CbV allows us to recover many of the properties that solvability has in call-by-name, in particular qualitative and quantitative characterizations via multi types. On the other hand, we stress that, in CbV, solvability plays a different role: identifying unsolvable terms as meaningless induces an inconsistent theory.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547652", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "École Polytechnique" + }, + { + "first_name": "Giulio", + "last_name": "Guerrieri", + "institution": "Huawei Technologies (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/AccattoliG22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547651", + "title": "On Feller continuity and full abstraction", + "abstract": "We study the nature of applicative bisimilarity in λ-calculi endowed with operators for sampling from contin- uous distributions. On the one hand, we show that bisimilarity, logical equivalence, and testing equivalence all coincide with contextual equivalence when real numbers can be manipulated through continuous functions only. The key ingredient towards this result is a notion of Feller-continuity for labelled Markov processes, which we believe of independent interest, giving rise a broad class of LMPs for which coinductive and logically inspired equivalences coincide. On the other hand, we show that if no constraint is put on the way real numbers are manipulated, characterizing contextual equivalence turns out to be hard, and most of the aforementioned notions of equivalence are even unsound.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547651", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Raphaëlle", + "last_name": "Crubillé", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" + }, + { + "first_name": "Francesco", + "last_name": "Gavazzo", + "institution": "University of Pisa" + } + ], + "dblp_key": "journals/pacmpl/BartheCLG22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547644", + "title": "Practical generic programming over a universe of native datatypes", + "abstract": "Datatype-generic programming makes it possible to define a construction once and apply it to a large class of datatypes. It is often used to avoid code duplication in languages that encourage the definition of custom datatypes, in particular state-of-the-art dependently typed languages where one can have many variants of the same datatype with different type-level invariants. In addition to giving access to familiar programming constructions for free, datatype-generic programming in the dependently typed setting also allows for the construction of generic proofs. However, the current interfaces available for this purpose are needlessly hard to use or are limited in the range of datatypes they handle. In this paper, we describe the design of a library for safe and user-friendly datatype-generic programming in the Agda language. Generic constructions in our library are regular Agda functions over a broad universe of datatypes, yet they can be specialized to native Agda datatypes with a simple one-liner. Furthermore, we provide building blocks so that library designers can too define their own datatype-generic constructions.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547644", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lucas", + "last_name": "Escot", + "institution": "Delft University of Technology" + }, + { + "first_name": "Jesper", + "last_name": "Cockx", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/EscotC22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547647", + "title": "Aeneas: Rust verification by functional translation", + "abstract": "We present Aeneas, a new verification toolchain for Rust programs based on a lightweight functional translation. We leverage Rust’s rich region-based type system to eliminate memory reasoning for a large class of Rust programs, as long as they do not rely on interior mutability or unsafe code. Doing so, we relieve the proof engineer of the burden of memory-based reasoning, allowing them to instead focus on functional properties of their code. The first contribution of Aeneas is a new approach to borrows and controlled aliasing. We propose a pure, functional semantics for LLBC, a Low-Level Borrow Calculus that captures a large subset of Rust programs. Our semantics is value-based, meaning there is no notion of memory, addresses or pointer arithmetic. Our semantics is also ownership-centric, meaning that we enforce soundness of borrows via a semantic criterion based on loans rather than through a syntactic type-based lifetime discipline. We claim that our semantics captures the essence of the borrow mechanism rather than its current implementation in the Rust compiler. The second contribution of Aeneas is a translation from LLBC to a pure lambda-calculus. This allows the user to reason about the original Rust program through the theorem prover of their choice, and fulfills our promise of enabling lightweight verification of Rust programs. To deal with the well-known technical difficulty of terminating a borrow, we rely on a novel approach, in which we approximate the borrow graph in the presence of function calls. This in turn allows us to perform the translation using a new technical device called backward functions. We implement our toolchain in a mixture of Rust and OCaml; our chief case study is a low-level, resizing hash table, for which we prove functional correctness, the first such result in Rust. Our evaluation shows significant gains of verification productivity for the programmer. This paper therefore establishes a new point in the design space of Rust verification toolchains, one that aims to verify Rust programs simply, and at scale. Rust goes to great lengths to enforce static control of aliasing; the proof engineer should not waste any time on memory reasoning when so much already comes “for free”!", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547647", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Son", + "last_name": "Ho", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/HoP22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547653", + "title": "Random testing of a higher-order blockchain language (experience report)", + "abstract": "We describe our experience of using property-based testing---an approach for automatically generating random inputs to check executable program specifications---in a development of a higher-order smart contract language that powers a state-of-the-art blockchain with thousands of active daily users. We outline the process of integrating QuickChick---a framework for property-based testing built on top of the Coq proof assistant---into a real-world language implementation in OCaml. We discuss the challenges we have encountered when generating well-typed programs for a realistic higher-order smart contract language, which mixes purely functional and imperative computations and features runtime resource accounting. We describe the set of the language implementation properties that we tested, as well as the semantic harness required to enable their validation. The properties range from the standard type safety to the soundness of a control- and type-flow analysis used by the optimizing compiler. Finally, we present the list of bugs discovered and rediscovered with the help of QuickChick and discuss their severity and possible ramifications.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547653", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tram", + "last_name": "Hoang", + "institution": "National University of Singapore" + }, + { + "first_name": "Anton", + "last_name": "Trunov", + "institution": "" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/HoangTLS22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3549822", + "title": "A simple and efficient implementation of strong call by need by an abstract machine", + "abstract": "We present an abstract machine for a strong call-by-need strategy in the lambda calculus. The machine has been derived automatically from a higher-order evaluator that uses the technique of memothunks to implement laziness. The derivation has been done with the use of an off-the-shelf transformation tool implementing the \"functional correspondence\" between higher-order interpreters and abstract machines, and it yields a simple and concise description of the machine. We prove that the resulting machine conservatively extends the lazy version of Krivine machine for the weak call-by-need strategy, and that it simulates the normal-order strategy in bilinear number of steps.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3549822", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Małgorzata", + "last_name": "Biernacka", + "institution": "University of Wrocław" + }, + { + "first_name": "Witold", + "last_name": "Charatonik", + "institution": "University of Wrocław" + }, + { + "first_name": "Tomasz", + "last_name": "Drab", + "institution": "University of Wrocław" + } + ], + "dblp_key": "journals/pacmpl/BiernackaCD22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547627", + "title": "Propositional equality for gradual dependently typed programming", + "abstract": "Gradual dependent types can help with the incremental adoption of dependently typed code by providing a principled semantics for imprecise types and proofs, where some parts have been omitted. Current theories of gradual dependent types, though, lack a central feature of type theory: propositional equality. Lennon-Bertrand et al. show that, when the reflexive proof refl is the only closed value of an equality type, a gradual extension of the Calculus of Inductive Constructions (CIC) with propositional equality violates static observational equivalences. Extensionally-equal functions should be indistinguishable at run time, but they can be distinguished using a combination of equality and type imprecision. This work presents a gradual dependently typed language that supports propositional equality. We avoid the above issues by devising an equality type of which refl is not the only closed inhabitant. Instead, each equality proof is accompanied by a term that is at least as precise as the equated terms, acting as a witness of their plausible equality. These witnesses track partial type information as a program runs, raising errors when that information shows that two equated terms are undeniably inconsistent. Composition of type information is internalized as a construct of the language, and is deferred for function bodies whose evaluation is blocked by variables. We thus ensure that extensionally-equal functions compose without error, thereby preventing contexts from distinguishing them. We describe the challenges of designing consistency and precision relations for this system, along with solutions to these challenges. Finally, we prove important metatheory: type safety, conservative embedding of CIC, weak canonicity, and the gradual guarantees of Siek et al., which ensure that reducing a program’s precision introduces no new static or dynamic errors.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547627", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Eremondi", + "institution": "University of British Columbia" + }, + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/EremondiGT22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547642", + "title": "Constraint-based type inference for FreezeML", + "abstract": "FreezeML is a new approach to first-class polymorphic type inference that employs term annotations to control when and how polymorphic types are instantiated and generalised. It conservatively extends Hindley-Milner type inference and was first presented as an extension to Algorithm W. More modern type inference techniques such as HM(X) and OutsideIn(X) employ constraints to support features such as type classes, type families, rows, and other extensions. We take the first step towards modernising FreezeML by presenting a constraint-based type inference algorithm. We introduce a new constraint language, inspired by the Pottier/Rémy presentation of HM(X), in order to allow FreezeML type inference problems to be expressed as constraints. We present a deterministic stack machine for solving FreezeML constraints and prove its termination and correctness.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547642", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Frank", + "last_name": "Emrich", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jan", + "last_name": "Stolarek", + "institution": "University of Edinburgh" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/EmrichSCL22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547648", + "title": "Automatically deriving control-flow graph generators from operational semantics", + "abstract": "We develop the first theory of control-flow graphs from first principles, and use it to create an algorithm for automatically synthesizing many variants of control-flow graph generators from a language’s operational semantics. Our approach first introduces a new algorithm for converting a large class of small-step operational semantics to an abstract machine. It next uses a technique called ”abstract rewriting” to automatically abstract the semantics of a language, which is used both to directly generate a CFG from a program (”interpreted mode”) and to generate standalone code, similar to a human-written CFG generator, for any program in a language. We show how the choice of two abstraction and projection parameters allow our approach to synthesize several families of CFG-generators useful for different kinds of tools. We prove the correspondence between the generated graphs and the original semantics. We provide and prove an algorithm for automatically proving the termination of interpreted-mode generators. In addition to our theoretical results, we have implemented this algorithm in a tool called Mandate, and show that it produces human-readable code on two medium-size languages with 60−80 rules, featuring nearly all intraprocedural control constructs common in modern languages. We then show these CFG-generators were sufficient to build two static analyses atop them. Our work is a promising step towards the grand vision of being able to synthesize all desired tools from the semantics of a programming language.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547648", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "James", + "last_name": "Koppel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jackson", + "last_name": "Kearl", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KoppelKS22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547622", + "title": "Searching entangled program spaces", + "abstract": "Many problem domains, including program synthesis and rewrite-based optimization, require searching astronomically large spaces of programs. Existing approaches often rely on building specialized data structures—version-space algebras, finite tree automata, or e-graphs—to compactly represent such spaces. At their core, all these data structures exploit independence of subterms; as a result, they cannot efficiently represent more complex program spaces, where the choices of subterms are entangled. We introduce equality-constrained tree automata (ECTAs), a new data structure, designed to compactly represent large spaces of programs with entangled subterms. We present efficient algorithms for extracting programs from ECTAs, implemented in a performant Haskell library, ecta. Using the ecta library, we construct Hectare, a type-driven program synthesizer for Haskell. Hectare significantly outperforms a state-of-the-art synthesizer Hoogle+—providing an average speedup of 8×—despite its implementation being an order of magnitude smaller.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547622", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "James", + "last_name": "Koppel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Zheng", + "last_name": "Guo", + "institution": "University of California San Diego" + }, + { + "first_name": "Edsko de", + "last_name": "Vries", + "institution": "" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/KoppelGVSP22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547641", + "title": "Staged compilation with two-level type theory", + "abstract": "The aim of staged compilation is to enable metaprogramming in a way such that we have guarantees about the well-formedness of code output, and we can also mix together object-level and meta-level code in a concise and convenient manner. In this work, we observe that two-level type theory (2LTT), a system originally devised for the purpose of developing synthetic homotopy theory, also serves as a system for staged compilation with dependent types. 2LTT has numerous good properties for this use case: it has a concise specification, well-behaved model theory, and it supports a wide range of language features both at the object and the meta level. First, we give an overview of 2LTT's features and applications in staging. Then, we present a staging algorithm and prove its correctness. Our algorithm is \"staging-by-evaluation\", analogously to the technique of normalization-by-evaluation, in that staging is given by the evaluation of 2LTT syntax in a semantic domain. The staging algorithm together with its correctness constitutes a proof of strong conservativity of 2LLT over the object theory. To our knowledge, this is the first description of staged compilation which supports full dependent types and unrestricted staging for types.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547641", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "András", + "last_name": "Kovács", + "institution": "Eötvös Loránd University" + } + ], + "dblp_key": "journals/pacmpl/Kovacs22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547633", + "title": "Structural versus pipeline composition of higher-order functions (experience report)", + "abstract": "In teaching students to program with compositions of higher-order functions, we have encountered a sharp distinction in the difficulty of problems as perceived by students. This distinction especially matters as growing numbers of programmers learn about functional programming for data processing. We have made initial progress on identifying this distinction, which appears counter-intuitive to some. We describe the phenomenon, provide some preliminary evidence of the difference in difficulty, and suggest consequences for functional programming pedagogy.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547633", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Elijah", + "last_name": "Rivera", + "institution": "John Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "John Brown University" + } + ], + "dblp_key": "journals/pacmpl/RiveraK22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547632", + "title": "Program adverbs and Tlön embeddings", + "abstract": "Free monads (and their variants) have become a popular general-purpose tool for representing the semantics of effectful programs in proof assistants. These data structures support the compositional definition of semantics parameterized by uninterpreted events, while admitting a rich equational theory of equivalence. But monads are not the only way to structure effectful computation, why should we limit ourselves? In this paper, inspired by applicative functors, selective functors, and other structures, we define a collection of data structures and theories, which we call program adverbs, that capture a variety of computational patterns. Program adverbs are themselves composable, allowing them to be used to specify the semantics of languages with multiple computation patterns. We use program adverbs as the basis for a new class of semantic embeddings called Tlön embeddings. Compared with embeddings based on free monads, Tlön embeddings allow more flexibility in computational modeling of effects, while retaining more information about the program's syntactic structure.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547632", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yao", + "last_name": "Li", + "institution": "Portland State University" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LiW22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547639", + "title": "Fusing industry and academia at GitHub (experience report)", + "abstract": "GitHub hosts hundreds of millions of code repositories written in hundreds of different programming languages. In addition to its hosting services, GitHub provides data and insights into code, such as vulnerability analysis and code navigation, with which users can improve and understand their software development process. GitHub has built Semantic, a program analysis tool capable of parsing and extracting detailed information from source code. The development of Semantic has relied extensively on the functional programming literature; this paper describes how connections to academic research inspired and informed the development of an industrial-scale program analysis toolkit.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547639", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Thomson", + "institution": "" + }, + { + "first_name": "Rob", + "last_name": "Rix", + "institution": "" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/ThomsonRWS22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547655", + "title": "A reasonably gradual type theory", + "abstract": "Gradualizing the Calculus of Inductive Constructions (CIC) involves dealing with subtle tensions between normalization, graduality, and conservativity with respect to CIC. Recently, GCIC has been proposed as a parametrized gradual type theory that admits three variants, each sacrificing one of these properties. For devising a gradual proof assistant based on CIC, normalization and conservativity with respect to CIC are key, but the tension with graduality needs to be addressed. Additionally, several challenges remain: (1) The presence of two wildcard terms at any type---the error and unknown terms---enables trivial proofs of any theorem, jeopardizing the use of a gradual type theory in a proof assistant; (2) Supporting general indexed inductive families, most prominently equality, is an open problem; (3) Theoretical accounts of gradual typing and graduality so far do not support handling type mismatches detected during reduction; (4) Precision and graduality are external notions not amenable to reasoning within a gradual type theory. All these issues manifest primally in CastCIC, the cast calculus used to define GCIC. In this work, we present an extension of CastCIC called GRIP. GRIP is a reasonably gradual type theory that addresses the issues above, featuring internal precision and general exception handling. By adopting a novel interpretation of the unknown term that carefully accounts for universe levels, GRIP satisfies graduality for a large and well-defined class of terms, in addition to being normalizing and a conservative extension of CIC. Internal precision supports reasoning about graduality within GRIP itself, for instance to characterize gradual exception-handling terms, and supports gradual subset types. We develop the metatheory of GRIP using a model formalized in Coq, and provide a prototype implementation of GRIP in Agda.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547655", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Meven", + "last_name": "Lennon-Bertrand", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/MaillardLTT22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547621", + "title": "Beyond Relooper: recursive translation of unstructured control flow to structured control flow (functional pearl)", + "abstract": "In many compilers, control flow is represented using an arbitrary directed graph. But in some interesting target languages, including JavaScript and WebAssembly, intraprocedural control flow can be expressed only in structured ways, using loops, conditionals, and multilevel breaks or exits. As was shown by Peterson, Kasami, and Tokura in 1973, such structured control flow can be obtained by translating arbitrary control flow. The translation uses two standard analyses, but as published, it takes three passes—which may explain why it was overlooked by Emscripten, a popular compiler from C to JavaScript. By tweaking the analyses and by applying fundamental ideas from functional programming (recursive functions and immutable abstract-syntax trees), the translation, along with a couple of code improvements, can be implemented in a single pass. This new implementation is slated to be added to the Glasgow Haskell Compiler. Its single-pass translation, its immutable representation, and its use of dominator trees make it much easier to reason about than the original translation.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547621", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Norman F.", + "last_name": "Ramsey", + "institution": "Tufts University" + } + ], + "dblp_key": "journals/pacmpl/Ramsey22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3549821", + "title": "Generating circuits with generators", + "abstract": "The most widely used languages and methods used for designing digital hardware fall into two rough categories. One of them, register transfer level (RTL), requires specifying each and every component in the designed circuit. This gives the designer full control, but burdens the designer with many trivial details. The other, the high-level synthesis (HLS) method, allows the designer to abstract the details of hardware away and focus on the problem being solved. This method however cannot be used for a class of hardware design problems because the circuit's clock is also abstracted away. We present YieldFSM, a hardware description language that uses the generator abstraction to represent clock-level timing in a digital circuit. It represents a middle ground between the RTL and HLS approaches: the abstraction level is higher than in RTL, but thanks to explicit information about clock-level timing, it can be used in applications where RTL is traditionally used. We also present the YieldFSM compiler, which uses methods developed by the functional programming community -- including continuation-passsing style translation and defunctionalization -- to translate YieldFSM programs to Mealy machines. It is implemented using Template Haskell and the Clash functional hardware description language. We show that this approach leads to short and conceptually simple hardware descriptions.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3549821", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marek", + "last_name": "Materzok", + "institution": "University of Wrocław" + } + ], + "dblp_key": "journals/pacmpl/Materzok22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547645", + "title": "Analyzing binding extent in 3CPS", + "abstract": "To date, the most effective approach to compiling strict, higher-order functional languages (such as OCaml, Scheme, and SML) has been to use whole-program techniques to convert the program to a first-order monomorphic representation that can be optimized using traditional compilation techniques. This approach, popularized by MLton, has limitations, however. We are interested in exploring a different approach to compiling such languages, one that preserves the higher-order and polymorphic character of the program throughout optimization. To enable such an approach, we must have effective analyses that both provide precise information about higher-order programs and that scale to larger units of compilation. This paper describes one such analysis for determining the extent of variable bindings. We classify the extent of variables as either register (only one binding instance can be live at any time), stack (the lifetimes of binding instances obey a LIFO order), or heap (binding lifetimes are arbitrary). These extents naturally connect variables to the machine resources required to represent them. We believe that precise information about binding extents will enable efficient management of environments, which is a key problem in the efficient compilation of higher-order programs. At the core of the paper is the 3CPS intermediate representation, which is a factored CPS-based intermediate representation (IR) that statically marks variables to indicate their binding extent. We formally specify the management of this binding structure by means of a small-step operational semantics and define a static analysis that determines the extents of the variables in a program. We evaluate our analysis using a standard suite of SML benchmark programs. Our implementation gets surprisingly high yield and exhibits scalable performance. While this paper uses a CPS-based IR, the algorithm and results are easily transferable to other λ-calculus IRs, such as ANF.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547645", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Quiring", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Chicago" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/QuiringRS22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547635", + "title": "Modular probabilistic models via algebraic effects", + "abstract": "Probabilistic programming languages (PPLs) allow programmers to construct statistical models and then simulate data or perform inference over them. Many PPLs restrict models to a particular instance of simulation or inference, limiting their reusability. In other PPLs, models are not readily composable. Using Haskell as the host language, we present an embedded domain specific language based on algebraic effects, where probabilistic models are modular, first-class, and reusable for both simulation and inference. We also demonstrate how simulation and inference can be expressed naturally as composable program transformations using algebraic effect handlers.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547635", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Minh Son", + "last_name": "Nguyen", + "institution": "University of Bristol" + }, + { + "first_name": "Roly", + "last_name": "Perera", + "institution": "The Alan Turing Institute" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/NguyenPWW22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547636", + "title": "A completely unique account of enumeration", + "abstract": "How can we enumerate the inhabitants of an algebraic datatype? This paper explores a datatype generic solution that works for all regular types and indexed families . The enumerators presented here are provably both complete and unique —they will eventually produce every value exactly once—and fair —they avoid bias when composing enumerators. Finally, these enumerators memoise previously enumerated values whenever possible, thereby avoiding repeatedly recomputing recursive results.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547636", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cas van der", + "last_name": "Rest", + "institution": "Delft University of Technology" + }, + { + "first_name": "Wouter", + "last_name": "Swierstra", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/pacmpl/RestS22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547634", + "title": "Reference counting with frame limited reuse", + "abstract": "The recently introduced _Perceus_ algorithm can automatically insert reference count instructions such that the resulting (cycle-free) program is _garbage free_: objects are freed at the very moment they can no longer be referenced. An important extension is reuse analysis. This optimization pairs objects of known size with fresh allocations of the same size and tries to reuse the object in-place at runtime if it happens to be unique. Unfortunately, current implementations of reuse analysis are fragile with respect to small program transformations, or can cause an arbitrary increase in the peak heap usage. We present a novel _drop-guided_ reuse algorithm that is simpler and more robust than previous approaches. Moreover, we generalize the linear resource calculus to precisely characterize garbage-free and frame-limited evaluations. On each function call, a frame-limited evaluation may hold on to memory longer if the size is bounded by a constant factor. Using this framework we show that our drop-guided reuse _is_ frame-limited and find that an implementation of our new reuse approach in Koka can provide significant speedups.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547634", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Anton", + "last_name": "Lorenzen", + "institution": "University of Bonn" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/LorenzenL22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547637", + "title": "Introduction and elimination, left and right", + "abstract": "Functional programming language design has been shaped by the framework of natural deduction, in which language constructs are divided into introduction and elimination rules for producers of values. In sequent calculus-based languages, left introduction rules replace (right) elimination rules and provide a dedicated sublanguage for consumers of values. In this paper, we present and analyze a wider design space of programming languages which encompasses four kinds of rules: Introduction and elimination, both left and right. We analyze the influence of rule choice on program structure and argue that having all kinds of rules enriches a programmer’s modularity arsenal. In particular, we identify four ways of adhering to the principle that ”the structure of the program follows the structure of the data“ and show that they correspond to the four possible choices of rules. We also propose the principle of bi-expressibility to guide and validate the design of rules for a connective. Finally, we deepen the well-known dualities between different connectives by means of the proof/refutation duality.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547637", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + }, + { + "first_name": "David A.", + "last_name": "Binder", + "institution": "University of Tübingen" + }, + { + "first_name": "Ingo", + "last_name": "Skupin", + "institution": "University of Tübingen" + }, + { + "first_name": "Tim", + "last_name": "Süberkrüb", + "institution": "University of Tübingen" + }, + { + "first_name": "Paul", + "last_name": "Downen", + "institution": "University of Massachusetts Lowell" + } + ], + "dblp_key": "journals/pacmpl/OstermannBSSD22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547631", + "title": "Later credits: resourceful reasoning for the later modality", + "abstract": "In the past two decades, step-indexed logical relations and separation logics have both come to play a major role in semantics and verification research. More recently, they have been married together in the form of step-indexed separation logics like VST, iCAP, and Iris, which provide powerful tools for (among other things) building semantic models of richly typed languages like Rust. In these logics, propositions are given semantics using a step-indexed model, and step-indexed reasoning is reflected into the logic through the so-called “later” modality. On the one hand, this modality provides an elegant, high-level account of step-indexed reasoning; on the other hand, when used in sufficiently sophisticated ways, it can become a nuisance, turning perfectly natural proof strategies into dead ends. In this work, we introduce later credits , a new technique for escaping later-modality quagmires. By leveraging the second ancestor of these logics—separation logic—later credits turn “the right to eliminate a later” into an ownable resource, which is subject to all the traditional modular reasoning principles of separation logic. We develop the theory of later credits in the context of Iris, and present several challenging examples of proofs and proof patterns which were previously not possible in Iris but are now possible due to later credits.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547631", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Spies", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lennard", + "last_name": "Gäher", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/SpiesGTJKBD22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547626", + "title": "Linearly qualified types: generic inference for capabilities and uniqueness", + "abstract": "A linear parameter must be consumed exactly once in the body of its function. When declaring resources such as file handles and manually managed memory as linear arguments, a linear type system can verify that these resources are used safely. However, writing code with explicit linear arguments requires bureaucracy. This paper presents linear constraints, a front-end feature for linear typing that decreases the bureaucracy of working with linear types. Linear constraints are implicit linear arguments that are filled in automatically by the compiler. We present linear constraints as a qualified type system,together with an inference algorithm which extends GHC's existing constraint solver algorithm. Soundness of linear constraints is ensured by the fact that they desugar into Linear Haskell.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547626", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Arnaud", + "last_name": "Spiwack", + "institution": "" + }, + { + "first_name": "Csongor", + "last_name": "Kiss", + "institution": "Imperial College London" + }, + { + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "University of Gothenburg" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/SpiwackKBWE22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547649", + "title": "Normalization for fitch-style modal calculi", + "abstract": "Fitch-style modal lambda calculi enable programming with necessity modalities in a typed lambda calculus by extending the typing context with a delimiting operator that is denoted by a lock. The addition of locks simplifies the formulation of typing rules for calculi that incorporate different modal axioms, but each variant demands different, tedious and seemingly ad hoc syntactic lemmas to prove normalization. In this work, we take a semantic approach to normalization, called normalization by evaluation (NbE), by leveraging the possible-world semantics of Fitch-style calculi to yield a more modular approach to normalization. We show that NbE models can be constructed for calculi that incorporate the K, T and 4 axioms of modal logic, as suitable instantiations of the possible-world semantics. In addition to existing results that handle 𝛽-equivalence, our normalization result also considers 𝜂-equivalence for these calculi. Our key results have been mechanized in the proof assistant Agda. Finally, we showcase several consequences of normalization for proving meta-theoretic properties of Fitch-style calculi as well as programming-language applications based on different interpretations of the necessity modality.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547649", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nachiappan", + "last_name": "Valliappan", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Fabian", + "last_name": "Ruch", + "institution": "N&N Pharmaceuticals (United States)" + }, + { + "first_name": "Carlos Tomé", + "last_name": "Cortiñas", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "journals/pacmpl/ValliappanRC22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547640", + "title": "'do' unchained: embracing local imperativity in a purely functional language (functional pearl)", + "abstract": "Purely functional programming languages pride themselves with reifying effects that are implicit in imperative languages into reusable and composable abstractions such as monads. This reification allows for more exact control over effects as well as the introduction of new or derived effects. However, despite libraries of more and more powerful abstractions over effectful operations being developed, syntactically the common 'do' notation still lags behind equivalent imperative code it is supposed to mimic regarding verbosity and code duplication. In this paper, we explore extending 'do' notation with other imperative language features that can be added to simplify monadic code: local mutation, early return, and iteration. We present formal translation rules that compile these features back down to purely functional code, show that the generated code can still be reasoned over using an implementation of the translation in the Lean 4 theorem prover, and formally prove the correctness of the translation rules relative to a simple static and dynamic semantics in Lean.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547640", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Ullrich", + "institution": "" + }, + { + "first_name": "Leonardo de", + "last_name": "Moura", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/UllrichM22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547643", + "title": "Safe couplings: coupled refinement types", + "abstract": "We enhance refinement types with mechanisms to reason about relational properties of probabilistic computations. Our mechanisms, which are inspired from probabilistic couplings, are applicable to a rich set of probabilistic properties, including expected sensitivity, which ensures that the distance between outputs of two probabilistic computations can be controlled from the distance between their inputs. We implement our mechanisms in the type system of Liquid Haskell and we use them to formally verify Haskell implementations of two classic machine learning algorithms: Temporal Difference (TD) reinforcement learning and stochastic gradient descent (SGD). We formalize a fragment of our system for discrete distributions and we prove soundness with respect to a set-theoretical semantics.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547643", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Elizaveta", + "last_name": "Vasilenko", + "institution": "National Research University Higher School of Economics" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + } + ], + "dblp_key": "journals/pacmpl/VasilenkoVB22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547646", + "title": "Entanglement detection with near-zero cost", + "abstract": "Recent research on parallel functional programming has culminated in a provably efficient (in work and space) parallel memory manager, which has been incorporated into the MPL (MaPLe) compiler for Parallel ML and shown to deliver practical efficiency and scalability. The memory manager exploits a property of parallel programs called disentanglement, which restricts computations from accessing concurrently allocated objects. Disentanglement is closely related to race-freedom, but subtly differs from it. Unlike race-freedom, however, no known techniques exists for ensuring disentanglement, leaving the task entirely to the programmer. This is a challenging task, because it requires reasoning about low-level memory operations (e.g., allocations and accesses), which is especially difficult in functional languages. In this paper, we present techniques for detecting entanglement dynamically, while the program is running. We first present a dynamic semantics for a functional language with references that checks for entanglement by consulting parallel and sequential dependency relations in the program. Notably, the semantics requires checks for mutable objects only. We prove the soundness of the dynamic semantics and present several techniques for realizing it efficiently, in particular by pruning away a large number of entanglement checks. We also provide bounds on the work and space of our techniques. We show that the entanglement detection techniques are practical by implementing them in the MPL compiler for Parallel ML. Considering a variety of benchmarks, we present an evaluation and measure time and space overheads of less than 5% on average with up to 72 cores. These results show that entanglement detection has negligible cost and can therefore remain deployed with little or no impact on efficiency, scalability, and space.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547646", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jatin", + "last_name": "Arora", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/WestrickAA22", + "venue": "icfp", + "year": 2022 + }, + { + "paper_id": "10.1145/3547630", + "title": "Formal reasoning about layered monadic interpreters", + "abstract": "Monadic computations built by interpreting, or handling , operations of a free monad are a compelling formalism for modeling language semantics and defining the behaviors of effectful systems. The resulting layered semantics offer the promise of modular reasoning principles based on the equational theory of the underlying monads. However, there are a number of obstacles to using such layered interpreters in practice. With more layers comes more boilerplate and glue code needed to define the monads and interpreters involved. That overhead is compounded by the need to define and justify the relational reasoning principles that characterize the equivalences at each layer. This paper addresses these problems by significantly extending the capabilities of the Coq interaction trees (ITrees) library, which supports layered monadic interpreters. We characterize a rich class of interpretable monads ---obtained by applying monad transformers to ITrees---and show how to generically lift interpreters through them. We also introduce a corresponding framework for relational reasoning about \"equivalence of monads up to a relation R\". This collection of typeclasses, instances, new reasoning principles, and tactics greatly generalizes the existing theory of the ITree library, eliminating large amounts of unwieldy boilerplate code and dramatically simplifying proofs.", + "date": "2022-08-29", + "link": "https://doi.org/10.1145/3547630", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Irene", + "last_name": "Yoon", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/YoonZZ22", + "venue": "icfp", + "year": 2022 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2023.json b/data/pl_conferences/icfp/2023.json new file mode 100644 index 0000000..94905be --- /dev/null +++ b/data/pl_conferences/icfp/2023.json @@ -0,0 +1,996 @@ +[ + { + "paper_id": "10.1145/3607861", + "title": "Timely Computation", + "abstract": "This paper addresses the question “what is a digital circuit?” in relation to the fundamentally analog nature of actual (physical) circuits. A simple informal definition is given and then formalized in the proof assistant Agda. At the heart of this definition is the timely embedding of discrete information in temporally continuous signals. Once this embedding is defined (in constructive logic, i.e., type theory), it is extended in a generic fashion from one signal to many and from simple boolean operations (logic gates) to arbitrarily sophisticated sequential and parallel compositions, i.e., to computational circuits. Rather than constructing circuits and then trying to prove their correctness, a compositionally correct methodology maintains specification, implementation, timing, and correctness proofs at every step. Compositionality of each aspect and of their combination is supported by a single, shared algebraic vocabulary and related by homomorphisms. After formally defining and proving these notions, a few key transformations are applied to reveal the linearity of circuit timing (over a suitable semiring), thus enabling practical, modular, and fully verified timing analysis as linear maps over higher-dimensional time intervals. An emphasis throughout the paper is simplicity and generality of specification, minimizing circuit-specific definitions and proofs while highlighting a broadly applicable methodology of scalable, compositionally correct engineering through simple denotations and homomorphisms.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607861", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/Elliott23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607853", + "title": "More Fixpoints! (Functional Pearl)", + "abstract": "Haskell’s laziness allows the programmer to solve some problems naturally and declaratively via recursive equations. Unfortunately, if the input is “too recursive”, these very elegant idioms can fall into the dreaded black hole, and the programmer has to resort to more pedestrian approaches. It does not have to be that way: We built variants of common pure data structures (Booleans, sets) where recursive definitions are productive. Internally, the infamous unsafePerformIO is at work, but the user only sees a beautiful and pure API, and their pretty recursive idioms – magically – work again.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607853", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Joachim", + "last_name": "Breitner", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/Breitner23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607845", + "title": "The Verse Calculus: A Core Calculus for Deterministic Functional Logic Programming", + "abstract": "Functional logic languages have a rich literature, but it is tricky to give them a satisfying semantics. In this paper we describe the Verse calculus, VC, a new core calculus for deterministic functional logic programming. Our main contribution is to equip VC with a small-step rewrite semantics, so that we can reason about a VC program in the same way as one does with lambda calculus; that is, by applying successive rewrites to it. We also show that the rewrite system is confluent for well-behaved terms.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607845", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lennart", + "last_name": "Augustsson", + "institution": "" + }, + { + "first_name": "Joachim", + "last_name": "Breitner", + "institution": "" + }, + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "Epic Systems (United States)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Epic Systems (United States)" + }, + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "Oracle (United States)" + }, + { + "first_name": "Tim", + "last_name": "Sweeney", + "institution": "Epic Systems (United States)" + } + ], + "dblp_key": "journals/pacmpl/AugustssonBCJJSSS23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607844", + "title": "Modularity, Code Specialization, and Zero-Cost Abstractions for Program Verification", + "abstract": "For all the successes in verifying low-level, efficient, security-critical code, little has been said or studied about the structure, architecture and engineering of such large-scale proof developments. We present the design, implementation and evaluation of a set of language-based techniques that allow the programmer to modularly write and verify code at a high level of abstraction, while retaining control over the compilation process and producing high-quality, zero-overhead, low-level code suitable for integration into mainstream software. We implement our techniques within the F proof assistant, and specifically its shallowly-embedded Low toolchain that compiles to C. Through our evaluation, we establish that our techniques were critical in scaling the popular HACL library past 100,000 lines of verified source code, and brought about significant gains in proof engineer productivity. The exposition of our methodology converges on one final, novel case study: the streaming API, a finicky API that has historically caused many bugs in high-profile software. Using our approach, we manage to capture the streaming semantics in a generic way, and apply it “for free” to over a dozen use-cases. Six of those have made it into the reference implementation of the Python programming language, replacing the previous CVE-ridden code.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607844", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Son", + "last_name": "Ho", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Aymeric", + "last_name": "Fromherz", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/HoFP23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607847", + "title": "Asynchronous Modal FRP", + "abstract": "Over the past decade, a number of languages for functional reactive programming (FRP) have been suggested, which use modal types to ensure properties like causality, productivity and lack of space leaks. So far, almost all of these languages have included a modal operator for delay on a global clock. For some applications, however, a global clock is unnatural and leads to leaky abstractions as well as inefficient implementations. While modal languages without a global clock have been proposed, no operational properties have been proved about them, yet. This paper proposes Async RaTT, a new modal language for asynchronous FRP, equipped with an operational semantics mapping complete programs to machines that take asynchronous input signals and produce output signals. The main novelty of Async RaTT is a new modality for asynchronous delay, allowing each output channel to be associated at runtime with the set of input channels it depends on, thus causing the machine to only compute new output when necessary. We prove a series of operational properties including causality, productivity and lack of space leaks. We also show that, although the set of input channels associated with an output channel can change during execution, upper bounds on these can be determined statically by the type system.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607847", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Bahr", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Rasmus Ejlers", + "last_name": "Møgelberg", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/BahrM23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607862", + "title": "A Graded Modal Dependent Type Theory with a Universe and Erasure, Formalized", + "abstract": "We present a graded modal type theory, a dependent type theory with grades that can be used to enforce various properties of the code. The theory has Π-types, weak and strong Σ-types, natural numbers, an empty type, and a universe, and we also extend the theory with a unit type and graded Σ-types. The theory is parameterized by a modality, a kind of partially ordered semiring, whose elements (grades) are used to track the usage of variables in terms and types. Different modalities are possible. We focus mainly on quantitative properties, in particular erasure: with the erasure modality one can mark function arguments as erasable. The theory is fully formalized in Agda. The formalization, which uses a syntactic Kripke logical relation at its core and is based on earlier work, establishes major meta-theoretic properties such as subject reduction, consistency, normalization, and decidability of definitional equality. We also prove a substitution theorem for grade assignment, and preservation of grades under reduction. Furthermore we study an extraction function that translates terms to an untyped λ-calculus and removes erasable content, in particular function arguments with the “erasable” grade. For a certain class of modalities we prove that extraction is sound, in the sense that programs of natural number type have the same value before and after extraction. Soundness of extraction holds also for open programs, as long as all variables in the context are erasable, the context is consistent, and erased matches are not allowed for weak Σ-types.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607862", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Nils Anders", + "last_name": "Danielsson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Oskar", + "last_name": "Eriksson", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "journals/pacmpl/AbelDE23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607843", + "title": "Generic Programming with Extensible Data Types: Or, Making Ad Hoc Extensible Data Types Less Ad Hoc", + "abstract": "We present a novel approach to generic programming over extensible data types. Row types capture the structure of records and variants, and can be used to express record and variant subtyping, record extension, and modular composition of case branches. We extend row typing to capture generic programming over rows themselves, capturing patterns including lifting operations to records and variations from their component types, and the duality between cases blocks over variants and records of labeled functions, without placing specific requirements on the fields or constructors present in the records and variants. We formalize our approach in System R𝜔, an extension of F𝜔 with row types, and give a denotational semantics for (stratified) R𝜔 in Agda.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607843", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alex", + "last_name": "Hubers", + "institution": "University of Iowa" + }, + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Iowa" + } + ], + "dblp_key": "journals/pacmpl/HubersM23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607859", + "title": "Verifying Reliable Network Components in a Distributed Separation Logic with Dependent Separation Protocols", + "abstract": "We present a foundationally verified implementation of a reliable communication library for asynchronous client-server communication, and a stack of formally verified components on top thereof. Our library is implemented in an OCaml-like language on top of UDP and features characteristic traits of existing protocols, such as a simple handshaking protocol, bidirectional channels, and retransmission/acknowledgement mechanisms. We verify the library in the Aneris distributed separation logic using a novel proof pattern---dubbed the session escrow pattern---based on the existing escrow proof pattern and the so-called dependent separation protocols, which hitherto have only been used in a non-distributed concurrent setting. We demonstrate how our specification of the reliable communication library simplifies formal reasoning about applications, such as a remote procedure call library, which we in turn use to verify a lazily replicated key-value store with leader-followers and clients thereof. Our development is highly modular---each component is verified relative to specifications of the components it uses (not the implementation). All our results are formalized in the Coq proof assistant.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607859", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Léon", + "last_name": "Gondelman", + "institution": "Aarhus University" + }, + { + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", + "institution": "Aarhus University" + }, + { + "first_name": "Mário", + "last_name": "Pereira", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/GondelmanHPTB23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607837", + "title": "Explicit Refinement Types", + "abstract": "We present λ ert , a type theory supporting refinement types with <em>explicit proofs</em>. Instead of solving refinement constraints with an SMT solver like DML and Liquid Haskell, our system requires and permits programmers to embed proofs of properties within the program text, letting us support a rich logic of properties including quantifiers and induction. We show that the type system is sound by showing that every refined program erases to a simply-typed program, and by means of a denotational semantics, we show that every erased program has all of the properties demanded by its refined type. All of our proofs are formalised in Lean 4.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607837", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jad Elkhaleq", + "last_name": "Ghalayini", + "institution": "University of Cambridge" + }, + { + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/GhalayiniK23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607838", + "title": "Typing Records, Maps, and Structs", + "abstract": "Records are finite functions from keys to values. In this work we focus on two main distinct usages of records: structs and maps. The former associate different keys to values of different types, they are accessed by providing nominal keys, and trying to access a non-existent key yields an error. The latter associate all keys to values of the same type, they are accessed by providing expressions that compute a key, and trying to access a non-existent key usually yields some default value such as Null or nil. Here, we propose a type theory that covers both kinds of usage, where record types may associate to different types either single keys (as for structs) or sets of keys (as for maps) and where the same record expression can be accessed and used both in the struct-like style and in the map-like style we just described. Since we target dynamically-typed languages our type theory includes union and intersection types, characterized by a subtyping relation. We define the subtyping relation for our record types via a semantic interpretation and derive the decomposition rules to decide it, define a backtracking-free subtyping algorithm that we prove to be correct, and provide a canonical representation for record types that is used to define various type operators needed to type record operations such as selection, concatenation, and field deletion.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607838", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/Castagna23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607858", + "title": "Bit-Stealing Made Legal: Compilation for Custom Memory Representations of Algebraic Data Types", + "abstract": "Initially present only in functional languages such as OCaml and Haskell, Algebraic Data Types (ADTs) have now become pervasive in mainstream languages, providing nice data abstractions and an elegant way to express functions through pattern matching. Unfortunately, ADTs remain seldom used in low-level programming. One reason is that their increased convenience comes at the cost of abstracting away the exact memory layout of values. Even Rust, which tries to optimize data layout, severely limits control over memory representation. In this article, we present a new approach to specify the data layout of rich data types based on a dual view: a source type, providing a high-level description available in the rest of the code, along with a memory type, providing full control over the memory layout. This dual view allows for better reasoning about memory layout, both for correctness, with dedicated validity criteria linking the two views, and for optimizations that manipulate the memory view. We then provide algorithms to compile constructors and destructors, including pattern matching, to their low-level memory representation. We prove our compilation algorithms correct, implement them in a tool called ribbit that compiles to LLVM IR, and show some early experimental results.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607858", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thaïs", + "last_name": "Baudon", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Gabriel", + "last_name": "Radanne", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Laure", + "last_name": "Gonnord", + "institution": "Institut polytechnique de Grenoble" + } + ], + "dblp_key": "journals/pacmpl/BaudonRG23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607832", + "title": "Special Delivery: Programming with Mailbox Types", + "abstract": "The asynchronous and unidirectional communication model supported by mailboxes is a key reason for the success of actor languages like Erlang and Elixir for implementing reliable and scalable distributed systems. While many actors may send messages to some actor, only the actor may (selectively) receive from its mailbox. Although actors eliminate many of the issues stemming from shared memory concurrency, they remain vulnerable to communication errors such as protocol violations and deadlocks. Mailbox types are a novel behavioural type system for mailboxes first introduced for a process calculus by de’Liguoro and Padovani in 2018, which capture the contents of a mailbox as a commutative regular expression. Due to aliasing and nested evaluation contexts, moving from a process calculus to a programming language is challenging. This paper presents Pat, the first programming language design incorporating mailbox types, and describes an algorithmic type system. We make essential use of quasi-linear typing to tame some of the complexity introduced by aliasing. Our algorithmic type system is necessarily co-contextual, achieved through a novel use of backwards bidirectional typing, and we prove it sound and complete with respect to our declarative type system. We implement a prototype type checker, and use it to demonstrate the expressiveness of Pat on a factory automation case study and a series of examples from the Savina actor benchmark suite.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607832", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Fowler", + "institution": "University of Glasgow" + }, + { + "first_name": "Duncan Paul", + "last_name": "Attard", + "institution": "University of Glasgow" + }, + { + "first_name": "Franciszek", + "last_name": "Sowul", + "institution": "University of Glasgow" + }, + { + "first_name": "Simon J.", + "last_name": "Gay", + "institution": "University of Glasgow" + }, + { + "first_name": "Phil", + "last_name": "Trinder", + "institution": "University of Glasgow" + } + ], + "dblp_key": "journals/pacmpl/FowlerASGT23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607833", + "title": "Flexible Instruction-Set Semantics via Abstract Monads (Experience Report)", + "abstract": "Instruction sets, from families like x86 and ARM, are at the center of many ambitious formal-methods projects. Many verification, synthesis, programming, and debugging tools rely on formal semantics of instruction sets, but different tools can use semantics in rather different ways. The best-known work applying single semantics across diverse tools relies on domain-specific languages like Sail, where the language and its translation tools are specialized to the realm of instruction sets. In the context of the open RISC-V instruction-set family, we decided to explore a different approach, with semantics written in a carefully chosen subset of Haskell. This style does not depend on any new language translators, relying instead on parameterization of semantics over type-class instances. We have used a single core semantics to support testing, interactive proof, and model checking of both software and hardware, demonstrating that monads and the ability to abstract over them using type classes can support pleasant prototyping of ISA semantics.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607833", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Bourgeat", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ian", + "last_name": "Clester", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Andres", + "last_name": "Erbsen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Samuel", + "last_name": "Gruetter", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Pratap", + "last_name": "Singh", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "A.", + "last_name": "Wright", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BourgeatCEGSWC23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607842", + "title": "Reflecting on Random Generation", + "abstract": "Expert users of property-based testing often labor to craft random generators that encode detailed knowledge about what it means for a test input to be valid and interesting. Fortunately, the fruits of this labor can also be put to other uses. In the bidirectional programming literature, for example, generators have been repurposed as validity checkers, while Python's Hypothesis library uses the same structures for shrinking and mutating test inputs. To unify and generalize these uses and many others, we propose reflective generators, a new foundation for random data generators that can \"reflect\" on an input value to calculate the random choices that could have been made to produce it. Reflective generators combine ideas from two existing abstractions: free generators and partial monadic profunctors. They can be used to implement and enhance the aforementioned shrinking and mutation algorithms, generalizing them to work for any values that can be produced by the generator, not just ones for which a trace of the generator's execution is available. Beyond shrinking and mutation, reflective generators generalize a published algorithm for example-based generation, and they can also be used as checkers, partial value completers, and other kinds of test data producers.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607842", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Harrison", + "last_name": "Goldstein", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Samantha", + "last_name": "Frohlich", + "institution": "University of Bristol" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/GoldsteinFWP23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607855", + "title": "Calculating Compilers for Concurrency", + "abstract": "Choice trees have recently been introduced as a general structure for defining the semantics of programming languages with a wide variety of features and effects. In this article we focus on concurrent languages, and show how a codensity version of choice trees allows the semantics for such languages to be systematically transformed into compilers using equational reasoning techniques. The codensity construction is the key ingredient that enables a high-level, algebraic approach. As a case study, we calculate a compiler for a concurrent lambda calculus with channel-based communication.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607855", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Bahr", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/BahrH23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607839", + "title": "LURK: Lambda, the Ultimate Recursive Knowledge (Experience Report)", + "abstract": "We introduce Lurk, a new LISP-based programming language for zk-SNARKs. Traditional approaches to programming over zero-knowledge proofs require compiling the desired computation into a flat circuit, imposing serious constraints on the size and complexity of computations that can be achieved in practice. Lurk programs are instead provided as data to the universal Lurk interpreter circuit, allowing the resulting language to be Turing-complete without compromising the size of the resulting proof artifacts. Our work describes the design and theory behind Lurk, along with detailing how its implementation of content addressing can be used to sidestep many of the usual concerns of programming zero-knowledge proofs.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607839", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "Harvard University Press" + }, + { + "first_name": "John C.", + "last_name": "Burnham", + "institution": "" + }, + { + "first_name": "François", + "last_name": "Garillot", + "institution": "" + }, + { + "first_name": "Rosario", + "last_name": "Gennaro", + "institution": "City College of New York" + }, + { + "first_name": "Chhi’mèd", + "last_name": "Künzang", + "institution": "" + }, + { + "first_name": "Daniel", + "last_name": "Rogozin", + "institution": "University College London" + }, + { + "first_name": "Cameron", + "last_name": "Wong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "journals/pacmpl/AminBGGKRW23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607856", + "title": "Dependent Session Protocols in Separation Logic from First Principles (Functional Pearl)", + "abstract": "We develop an account of dependent session protocols in concurrent separation logic for a functional language with message-passing. Inspired by minimalistic session calculi, we present a layered design: starting from mutable references, we build one-shot channels, session channels, and imperative channels. Whereas previous work on dependent session protocols in concurrent separation logic required advanced mechanisms such as recursive domain equations and higher-order ghost state, we only require the most basic mechanisms to verify that our one-shot channels satisfy one-shot protocols, and subsequently treat their specification as a black box on top of which we define dependent session protocols. This has a number of advantages in terms of simplicity, elegance, and flexibility: support for subprotocols and guarded recursion automatically transfers from the one-shot protocols to the dependent session protocols, and we easily obtain various forms of channel closing. Because the meta theory of our results is so simple, we are able to give all definitions as part of this paper, and mechanize all our results using the Iris framework in less than 1000 lines of Coq.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607856", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", + "institution": "Aarhus University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/JacobsHK23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607831", + "title": "Higher-Order Property-Directed Reachability", + "abstract": "The property-directed reachability (PDR) has been used as a successful method for automated verification of first-order transition systems. We propose a higher-order extension of PDR, called HoPDR, where higher-order recursive functions may be used to describe transition systems. We formalize HoPDR for the validity checking problem for conjunctive nu-HFL(Z), a higher-order fixpoint logic with integers and greatest fixpoint operators. The validity checking problem can also be viewed as a higher-order extension of the satisfiability problem for Constrained Horn Clauses (CHC), and safety property verification of higher-order programs can naturally be reduced to the validity checking problem. We have implemented a prototype verification tool based on HoPDR and confirmed its effectiveness. We also compare our HoPDR procedure with the PDR procedure for first-order systems and previous methods for fully automated higher-order program verification.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607831", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Hiroyuki", + "last_name": "Katsura", + "institution": "The University of Tokyo" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryosuke", + "last_name": "Sato", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "journals/pacmpl/KatsuraKS23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607863", + "title": "Combinator-Based Fixpoint Algorithms for Big-Step Abstract Interpreters", + "abstract": "Big-step abstract interpreters are an approach to build static analyzers based on big-step interpretation. While big-step interpretation provides a number of benefits for the definition of an analysis, it also requires particularly complicated fixpoint algorithms because the analysis definition is a recursive function whose termination is uncertain. This is in contrast to other analysis approaches, such as small-step reduction, abstract machines, or graph reachability, where the analysis essentially forms a finite transition system between widened analysis states. We show how to systematically develop sophisticated fixpoint algorithms for big-step abstract interpreters and how to ensure their soundness. Our approach is based on small and reusable fixpoint combinators that can be composed to yield fixpoint algorithms. For example, these combinators describe the order in which the program is analyzed, how deep recursive functions are unfolded and loops unrolled, or they record auxiliary data such as a (context-sensitive) call graph. Importantly, each combinator can be developed separately, reused across analyses, and can be verified sound independently. Consequently, analysis developers can freely compose combinators to obtain sound fixpoint algorithms that work best for their use case. We provide a formal metatheory that guarantees a fixpoint algorithm is sound if its composed from sound combinators only. We experimentally validate our combinator-based approach by describing sophisticated fixpoint algorithms for analyses of Stratego, Scheme, and WebAssembly.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607863", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sven", + "last_name": "Keidel", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "" + }, + { + "first_name": "Tobias", + "last_name": "Hombücher", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/KeidelEH23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607836", + "title": "How to Evaluate Blame for Gradual Types, Part 2", + "abstract": "Equipping an existing programming language with a gradual type system requires two major steps. The first and most visible one in academia is to add a notation for types and a type checking apparatus. The second, highly practical one is to provide a type veneer for the large number of existing untyped libraries; doing so enables typed components to import pieces of functionality and get their uses type-checked, without any changes to the libraries. When programmers create such typed veneers for libraries, they make mistakes that persist and cause trouble. The question is whether the academically investigated run-time checks for gradual type systems assist programmers with debugging such mistakes. This paper provides a first, surprising answer to this question via a rational-programmer investigation: run-time checks alone are typically less helpful than the safety checks of the underlying language. Combining Natural run-time checks with blame, however, provides significantly superior debugging hints.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607836", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Lukas", + "last_name": "Lazarek", + "institution": "Northwestern University" + }, + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "John Brown University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/LazarekGFD23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607840", + "title": "FP²: Fully in-Place Functional Programming", + "abstract": "As functional programmers we always face a dilemma: should we write purely functional code, or sacrifice purity for efficiency and resort to in-place updates? This paper identifies precisely when we can have the best of both worlds: a wide class of purely functional programs can be executed safely using in-place updates without requiring allocation, provided their arguments are not shared elsewhere. We describe a linear _fully in-place_ (FIP) calculus where we prove that we can always execute such functions in a way that requires no (de)allocation and uses constant stack space. Of course, such a calculus is only relevant if we can express interesting algorithms; we provide numerous examples of in-place functions on datastructures such as splay trees or finger trees, together with in-place versions of merge sort and quick sort. We also show how we can generically derive a map function over _any_ polynomial data type that is fully in-place. Finally, we have implemented the rules of the FIP calculus in the Koka language. Using the Perceus reference counting garbage collection, this implementation dynamically executes FIP functions in-place whenever possible.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607840", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Anton", + "last_name": "Lorenzen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wouter", + "last_name": "Swierstra", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/pacmpl/LorenzenLS23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607849", + "title": "HasChor: Functional Choreographic Programming for All (Functional Pearl)", + "abstract": "Choreographic programming is an emerging paradigm for programming distributed systems. In choreographic programming, the programmer describes the behavior of the entire system as a single, unified program -- a choreography -- which is then compiled to individual programs that run on each node, via a compilation step called endpoint projection. We present a new model for functional choreographic programming where choreographies are expressed as computations in a monad. Our model supports cutting-edge choreographic programming features that enable modularity and code reuse: in particular, it supports higher-order choreographies, in which a choreography may be passed as an argument to another choreography, and location-polymorphic choreographies, in which a choreography can abstract over nodes. Our model is implemented in a Haskell library, HasChor , which lets programmers write choreographic programs while using the rich Haskell ecosystem at no cost, bringing choreographic programming within reach of everyday Haskellers. Moreover, thanks to Haskell's abstractions, the implementation of the HasChor library itself is concise and understandable, boiling down endpoint projection to its short and simple essence.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607849", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Gan", + "last_name": "Shen", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Shun", + "last_name": "Kashiwa", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "journals/pacmpl/ShenKK23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607830", + "title": "Embedding by Unembedding", + "abstract": "Embedding is a language development technique that implements the object language as a library in a host language. There are many advantages of the approach, including being lightweight and the ability to inherit features of the host language. A notable example is the technique of HOAS, which makes crucial use of higher-order functions to represent abstract syntax trees with binders. Despite its popularity, HOAS has its limitations. We observe that HOAS struggles with semantic domains that cannot be naturally expressed as functions, particularly when open expressions are involved. Prominent examples of this include incremental computation and reversible/bidirectional languages. In this paper, we pin-point the challenge faced by HOAS as a mismatch between the semantic domain of host and object language functions, and propose a solution. The solution is based on the technique of unembedding , which converts from the finally-tagless representation to de Bruijn-indexed terms with strong correctness guarantees. We show that this approach is able to extend the applicability of HOAS while preserving its elegance. We provide a generic strategy for Embedding by Unembedding, and then demonstrate its effectiveness with two substantial case studies in the domains of incremental computation and bidirectional transformations. The resulting embedded implementations are comparable in features to the state-of-the-art language implementations in the respective areas.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607830", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + }, + { + "first_name": "Samantha", + "last_name": "Frohlich", + "institution": "University of Bristol" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/MatsudaFWW23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607854", + "title": "Intrinsically Typed Sessions with Callbacks (Functional Pearl)", + "abstract": "All formalizations of session types rely on linear types for soundness as session-typed communication channels must change their type at every operation. Embedded language implementations of session types follow suit. They either rely on clever typing constructions to guarantee linearity statically, or on run-time checks that approximate linearity. We present a new language-embedded implementation of session types, which is inspired by the inversion-of-control design principle. With our approach, all application programs are intrinsically session-typed and unable to break linearity by construction. Our design relies on a tiny encapsulated library, for which linearity remains a proof obligation that can be discharged once and for all when the library is built. We demonstrate that our proposed design extends to a wide range of features of session type systems: branching, recursion, multichannel and higher-order sessions, as well as context-free sessions. The multichannel extension provides an embedded implementation of session types which guarantees deadlock freedom by construction. The development reported in this paper is fully backed by type-checked Agda code.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607854", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "journals/pacmpl/Thiemann23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607852", + "title": "Dependently-Typed Programming with Logical Equality Reflection", + "abstract": "In dependently-typed functional programming languages that allow general recursion, programs used as proofs must be evaluated to retain type soundness. As a result, programmers must make a trade-off between performance and safety. To address this problem, we propose System DE, an explicitly-typed, moded core calculus that supports termination tracking and equality reflection. Programmers can write inductive proofs about potentially diverging programs in a logical sublanguage and reflect those proofs to the type checker, while knowing that such proofs will be erased by the compiler before execution. A key feature of System DE is its use of modes for both termination and relevance tracking, which not only simplifies the design but also leaves it open for future extension. System DE is suitable for use in the Glasgow Haskell Compiler, but could serve as the basis for any general purpose dependently-typed language.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607852", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yiyun", + "last_name": "Liu", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LiuW23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607846", + "title": "With or Without You: Programming with Effect Exclusion", + "abstract": "Type and effect systems have been successfully used to statically reason about effects in many different domains, including region-based memory management, exceptions, and algebraic effects and handlers. Such systems’ soundness is often stated in terms of the absence of effects. Yet, existing systems only admit indirect reasoning about the absence of effects. This is further complicated by effect polymorphism which allows function signatures to abstract over arbitrary, unknown sets of effects. We present a new type and effect system with effect polymorphism as well as union, intersection, and complement effects. The effect system allows us to express effect exclusion as a new class of effect polymorphic functions: those that permit any effects except those in a specific set. This way, we equip programmers with the means to directly reason about the absence of effects. Our type and effect system builds on the Hindley-Milner type system, supports effect polymorphism, and preserves principal types modulo Boolean equivalence. In addition, a suitable extension of Algorithm W with Boolean unification on the algebra of sets enables complete type and effect inference. We formalize these notions in the λ ∁ calculus. We prove the standard progress and preservation theorems as well as a non-standard effect safety theorem: no excluded effect is ever performed. We implement the type and effect system as an extension of the Flix programming language. We conduct a case study of open source projects identifying 59 program fragments that require effect exclusion for correctness. To demonstrate the usefulness of the proposed type and effect system, we recast these program fragments into our extension of Flix.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607846", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Lutze", + "institution": "Aarhus University" + }, + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/LutzeMSB23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607860", + "title": "Etna: An Evaluation Platform for Property-Based Testing (Experience Report)", + "abstract": "Property-based testing is a mainstay of functional programming, boasting a rich literature, an enthusiastic user community, and an abundance of tools — so many, indeed, that new users may have difficulty choosing. Moreover, any given framework may support a variety of strategies for generating test inputs; even experienced users may wonder which are better in a given situation. Sadly, the PBT literature, though long on creativity, is short on rigorous comparisons to help answer such questions. We present Etna, a platform for empirical evaluation and comparison of PBT techniques. Etna incorporates a number of popular PBT frameworks and testing workloads from the literature, and its extensible architecture makes adding new ones easy, while handling the technical drudgery of performance measurement. To illustrate its benefits, we use Etna to carry out several experiments with popular PBT approaches in both Coq and Haskell, allowing users to more clearly understand best practices and tradeoffs.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607860", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jessica", + "last_name": "Shi", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "A.", + "last_name": "Keleş", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Harrison", + "last_name": "Goldstein", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/ShiKGPL23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607848", + "title": "A General Fine-Grained Reduction Theory for Effect Handlers", + "abstract": "Effect handlers are a modern and increasingly popular approach to structuring computational effects in functional programming languages. However, while their traditional operational semantics is well-suited to implementation tasks, it is less ideal as a reduction theory. We therefore introduce a fine-grained reduction theory for deep effect handlers, inspired by our existing reduction theory for shift0, along with a standard reduction strategy. We relate this strategy to the traditional, non-local operational semantics via a simulation argument, and show that the reduction theory preserves observational equivalence with respect to the classical semantics of handlers, thus allowing its use as a rewriting theory for handler-equipped programming languages -- this rewriting system mostly coincides with previously studied type-based optimisations. In the process, we establish theoretical properties of our reduction theory, including confluence and standardisation theorems, adapting and extending existing techniques. Finally, we demonstrate the utility of our semantics by providing the first normalisation-by-evaluation algorithm for effect handlers, and prove its soundness and completeness. Additionally, we establish non-expressibility of the lift operator, found in some effect-handler calculi, by the other constructs.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607848", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "Heriot-Watt University" + }, + { + "first_name": "Mateusz", + "last_name": "Pyzik", + "institution": "University of Wrocław" + }, + { + "first_name": "Dariusz", + "last_name": "Biernacki", + "institution": "University of Wrocław" + } + ], + "dblp_key": "journals/pacmpl/SieczkowskiPB23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607841", + "title": "Trustworthy Runtime Verification via Bisimulation (Experience Report)", + "abstract": "When runtime verification is used to monitor safety-critical systems, it is essential that monitoring code behaves correctly. The Copilot runtime verification framework pursues this goal by automatically generating C monitor programs from a high-level DSL embedded in Haskell. In safety-critical domains, every piece of deployed code must be accompanied by an assurance argument that is convincing to human auditors. However, it is difficult for auditors to determine with confidence that a compiled monitor cannot crash and implements the behavior required by the Copilot semantics. In this paper we describe CopilotVerifier, which runs alongside the Copilot compiler, generating a proof of correctness for the compiled output. The proof establishes that a given Copilot monitor and its compiled form produce equivalent outputs on equivalent inputs, and that they either crash in identical circumstances or cannot crash. The proof takes the form of a bisimulation broken down into a set of verification conditions. We leverage two pieces of SMT-backed technology: the Crucible symbolic execution library for LLVM and the What4 solver interface library. Our results demonstrate that dramatically increased compiler assurance can be achieved at moderate cost by building on existing tools. This paves the way to our ultimate goal of generating formal assurance arguments that are convincing to human auditors.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607841", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ryan G.", + "last_name": "Scott", + "institution": "Galois (United States)" + }, + { + "first_name": "Mike", + "last_name": "Dodds", + "institution": "Galois (United States)" + }, + { + "first_name": "Ivan", + "last_name": "Pérez", + "institution": "Ames Research Center" + }, + { + "first_name": "Alwyn E.", + "last_name": "Goodloe", + "institution": "Ames Research Center" + }, + { + "first_name": "Robert", + "last_name": "Dockins", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/ScottDPGD23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607857", + "title": "What Happens When Students Switch (Functional) Languages (Experience Report)", + "abstract": "When novice programming students already know one programming language and have to learn another, what issues do they run into? We specifically focus on one or both languages being functional, varying along two axes: syntax and semantics. We report on problems, especially persistent ones. This work can be of immediate value to educators and also sets up avenues for future research.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607857", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kuang-Chen", + "last_name": "Lu", + "institution": "John Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "John Brown University" + }, + { + "first_name": "Kathi", + "last_name": "Fisler", + "institution": "John Brown University" + }, + { + "first_name": "Ethel", + "last_name": "Tshukudu", + "institution": "University of Botswana" + } + ], + "dblp_key": "journals/pacmpl/LuKFT23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607851", + "title": "MacoCaml: Staging Composable and Compilable Macros", + "abstract": "We introduce MacoCaml, a new design and implementation of compile-time code generation for the OCaml language. MacoCaml features a novel combination of macros with phase separation and quotation-based staging, where macros are considered as compile-time bindings, expression cross evaluation phases using staging annotations, and compile-time evaluation happens inside top-level splices. We provide a theoretical foundation for MacoCaml by formalizing a typed source calculus maco that supports interleaving typing and compile-time code generation, references with explicit compile-time heaps, and modules. We study various crucial properties including soundness and phase distinction. We have implemented MacoCaml in the OCaml compiler, and ported two substantial existing libraries to validate our implementation.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607851", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Toronto" + }, + { + "first_name": "Leo", + "last_name": "White", + "institution": "" + }, + { + "first_name": "Olivier", + "last_name": "Nicole", + "institution": "" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/XieWNY23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607835", + "title": "Formal Specification and Testing for Reinforcement Learning", + "abstract": "The development process for reinforcement learning applications is still exploratory rather than systematic. This exploratory nature reduces reuse of specifications between applications and increases the chances of introducing programming errors. This paper takes a step towards systematizing the development of reinforcement learning applications. We introduce a formal specification of reinforcement learning problems and algorithms, with a particular focus on temporal difference methods and their definitions in backup diagrams. We further develop a test harness for a large class of reinforcement learning applications based on temporal difference learning, including SARSA and Q-learning. The entire development is rooted in functional programming methods; starting with pure specifications and denotational semantics, ending with property-based testing and using compositional interpreters for a domain-specific term language as a test oracle for concrete implementations. We demonstrate the usefulness of this testing method on a number of examples, and evaluate with mutation testing. We show that our test suite is effective in killing mutants (90% mutants killed for 75% of subject agents). More importantly, almost half of all mutants are killed by generic write-once-use-everywhere tests that apply to any reinforcement learning problem modeled using our library, without any additional effort from the programmer.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607835", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mahsa", + "last_name": "Varshosaz", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Mohsen", + "last_name": "Ghaffari", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Einar Broch", + "last_name": "Johnsen", + "institution": "University of Oslo" + }, + { + "first_name": "Andrzej", + "last_name": "Wąsowski", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/VarshosazGJW23", + "venue": "icfp", + "year": 2023 + }, + { + "paper_id": "10.1145/3607850", + "title": "Modular Models of Monoids with Operations", + "abstract": "Inspired by algebraic effects and the principle of notions of computations as monoids, we study a categorical framework for equational theories and models of monoids equipped with operations. The framework covers not only algebraic operations but also scoped and variable-binding operations. Appealingly, in this framework both theories and models can be modularly composed. Technically, a general monoid-theory correspondence is shown, saying that the category of theories of algebraic operations is equivalent to the category of monoids. Moreover, more complex forms of operations can be coreflected into algebraic operations, in a way that preserves initial algebras. On models, we introduce modular models of a theory, which can interpret abstract syntax in the presence of other operations. We show constructions of modular models (i) from monoid transformers, (ii) from free algebras, (iii) by composition, and (iv) in symmetric monoidal categories.", + "date": "2023-08-30", + "link": "https://doi.org/10.1145/3607850", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Zhixuan", + "last_name": "Yang", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/YangW23", + "venue": "icfp", + "year": 2023 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2024.json b/data/pl_conferences/icfp/2024.json new file mode 100644 index 0000000..e7721e5 --- /dev/null +++ b/data/pl_conferences/icfp/2024.json @@ -0,0 +1,1057 @@ +[ + { + "paper_id": "10.1145/3674627", + "title": "Compiled, Extensible, Multi-language DSLs (Functional Pearl)", + "abstract": "Implementations of domain-specific languages should offer both extensibility and performance optimizations. With the new syntax-spec metalanguage in Racket, programmers can easily create DSL implementations that are both automatically macro-extensible and subject to conventional compiler optimizations. This pearl illustrates this approach through a new implementation of miniKanren, a widely used relational programming DSL. The miniKanren community has explored, in separate implementations, optimization techniques and a wide range of extensions. We demonstrate how our new miniKanren implementation with syntax-spec reconciles these features in a single implementation that comes with both an optimizing compiler and an extension mechanism. Furthermore, programmers using the new implementation benefit from the same seamless integration between Racket and miniKanren as in existing shallow embeddings.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674627", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Michael", + "last_name": "Ballantyne", + "institution": "Northeastern University" + }, + { + "first_name": "Mitch", + "last_name": "Gamburg", + "institution": "Boston University" + }, + { + "first_name": "Jason", + "last_name": "Hemann", + "institution": "Seton Hall University" + } + ], + "dblp_key": "journals/pacmpl/BallantyneGH24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674633", + "title": "Functional Programming in Financial Markets (Experience Report)", + "abstract": "We present a case-study of using functional programming in the real world at a very large scale. At Standard Chartered Bank, Haskell is used in a core software library supporting the entire Markets division – a business line with 3 billion USD operating income in 2023. Typed functional programming is used across the entire tech stack, including foundational APIs and CLIs for deal valuation and risk analysis, server-side components for long-running batches or sub-second RESTful services, and end-user GUIs. Thousands of users across Markets interact with software built using functional programming, and over one hundred write functional code. In this experience report we focus on how we leverage functional programming to orchestrate type-driven large-scale pricing workflows. The same API can be used to price one trade locally, or millions of trades across thousands of cloud nodes. Different parts of the computation can be run and inspected individually, and recomputing one part triggers recalculation of the dependent parts only. We build upon decades of research and experience in the functional programming community, relying on concepts such as monads, lenses, datatype generics, and closure serialisation. We conclude that the use of functional programming is one of the main drivers of the success of our project, and we see no significant downsides from it.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674633", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Atze", + "last_name": "Dijkstra", + "institution": "" + }, + { + "first_name": "José Pedro", + "last_name": "Magalhães", + "institution": "" + }, + { + "first_name": "Pierre", + "last_name": "Néron", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/DijkstraMN24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674654", + "title": "Call-by-Unboxed-Value", + "abstract": "Call-By-Push-Value has famously subsumed both call-by-name and call-by-value by decomposing programs along the axis of “values” versus “computations.” Here, we introduce Call-By-Unboxed-Value which further decomposes programs along an orthogonal axis separating “atomic” versus “complex.” As the name suggests, these two dimensions make it possible to express the representations of values as boxed or unboxed, so that functions pass unboxed values as inputs and outputs. More importantly, Call-By-Unboxed-Value allows for an unrestricted mixture of polymorphism and unboxed types, giving a foundation for studying compilation techniques for polymorphism based on representation irrelevance . In this regard, we use Call-By-UnboxedValue to formalize representation polymorphism independently of types; for the first time compiling untyped representation-polymorphic code, while nonetheless preserving types all the way to the machine.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674654", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Downen", + "institution": "University of Massachusetts Lowell" + } + ], + "dblp_key": "journals/pacmpl/Downen24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674635", + "title": "Error Credits: Resourceful Reasoning about Error Bounds for Higher-Order Probabilistic Programs", + "abstract": "Probabilistic programs often trade accuracy for efficiency, and thus may, with a small probability, return an incorrect result. It is important to obtain precise bounds for the probability of these errors, but existing verification approaches have limitations that lead to error probability bounds that are excessively coarse, or only apply to first-order programs. In this paper we present Eris, a higher-order separation logic for proving error probability bounds for probabilistic programs written in an expressive higher-order language. Our key novelty is the introduction of error credits , a separation logic resource that tracks an upper bound on the probability that a program returns an erroneous result. By representing error bounds as a resource, we recover the benefits of separation logic, including compositionality, modularity, and dependency between errors and program terms, allowing for more precise specifications. Moreover, we enable novel reasoning principles such as expectation-preserving error composition, amortized error reasoning, and error induction. We illustrate the advantages of our approach by proving amortized error bounds on a range of examples, including collision probabilities in hash functions, which allow us to write more modular specifications for data structures that use them as clients. We also use our logic to prove correctness and almost-sure termination of rejection sampling algorithms. All of our results have been mechanized in the Coq proof assistant using the Iris separation logic framework and the Coquelicot real analysis library.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674635", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Philipp G.", + "last_name": "Haselwarter", + "institution": "Aarhus University" + }, + { + "first_name": "Markus de", + "last_name": "Medeiros", + "institution": "New York University" + }, + { + "first_name": "Kwing Hei", + "last_name": "Li", + "institution": "Aarhus University" + }, + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "New York University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/0001HMLGTB24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674634", + "title": "The Long Way to Deforestation: A Type Inference and Elaboration Technique for Removing Intermediate Data Structures", + "abstract": "Deforestation is a compiler optimization that removes intermediate data structure allocations from functional programs to improve their efficiency. This is an old idea, but previous approaches have proved limited or impractical — they either only worked on compositions of predefined combinators (shortcut fusion), or involved the aggressive unfolding of recursive definitions until a depth limit was reached or a reoccurring pattern was found to tie the recursive knot, resulting in impractical algorithmic complexity and large amounts of code duplication. We present Lumberhack, a general-purpose deforestation approach for purely functional call-by-need and call-by-value programs. Lumberhack uses subtype inference to reason about data structure production and consumption and uses an elaboration pass to fuse the corresponding recursive definitions. It fuses large classes of mutually recursive definitions while avoiding much of the unproductive (and sometimes counter-productive) code duplication inherent in previous approaches. We prove the soundness of Lumberhack using step-indexed logical relations and experimentally demonstrate significant speedups in the standard nofib benchmark suite. We manually adapted nofib programs to call-by-value semantics and compiled them using the OCaml compiler. The average speedup over the 38 benchmarked programs is 8.2 % while the average code size increases by just about 1 . 79 x . In particular, 19 programs see their performance mostly unchanged, 17 programs improve significantly (by an average speedup of 16.6 % ), and only two programs visibly worsen (by an average slowdown of 1.8 % ). As a point of comparison, we measured that the well-proven but semi-manual list fusion technique of the Glasgow Haskell Compiler (GHC), which only works for call-by-need programs, had an average speedup of 6.5 % . Our technique is still in its infancy and misses some deforestation opportunities. We are confident that further refinements will yield greater performance improvements in the future.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674634", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yijia", + "last_name": "Chen", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ChenP24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674649", + "title": "Staged Compilation with Module Functors", + "abstract": "Multi-stage programming has been used in a wide variety of domains to eliminate the tension between abstraction and performance. However, the interaction of multi-stage programming features with features for programming-in-the-large remains understudied, hindering the full integration of multi-stage programming support into existing languages, and limiting the effective use of staging in large programs. We take steps to remedy the situation by studying the extension of MacoCaml, a recent OCaml extension that supports compile-time code generation via macros and quotations , with module functors, the key mechanism in OCaml for assembling program components into larger units. We discuss design choices related to evaluation order, formalize our calculus via elaboration, and show that the design enjoys key metatheoretical properties: syntactic type soundness, elaboration soundness, and phase distinction. We believe that this study lays a foundation for the continued exploration and implementation of the OCaml macro system.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674649", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tsung-Ju", + "last_name": "Chiang", + "institution": "University of Toronto" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + }, + { + "first_name": "Leo", + "last_name": "White", + "institution": "" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/ChiangYWX24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674657", + "title": "Synchronous Programming with Refinement Types", + "abstract": "Cyber-Physical Systems (CPS) consist of software interacting with the physical world, such as robots, vehicles, and industrial processes. CPS are frequently responsible for the safety of lives, property, or the environment, and so software correctness must be determined with a high degree of certainty. To that end, simply testing a CPS is insufficient, as its interactions with the physical world may be difficult to predict, and unsafe conditions may not be immediately obvious. Formal verification can provide stronger safety guarantees but relies on the accuracy of the verified system in representing the real system. Bringing together verification and implementation can be challenging, as languages that are typically used to implement CPS are not easy to formally verify, and languages that lend themselves well to verification often abstract away low-level implementation details. Translation between verification and implementation languages is possible, but requires additional assurances in the translation process and increases software complexity; having both in a single language is desirable. This paper presents a formalization of MARVeLus, a CPS language which combines verification and implementation. We develop a metatheory for its synchronous refinement type system and demonstrate verified synchronous programs executing on real systems.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674657", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jiawei", + "last_name": "Chen", + "institution": "University of Michigan" + }, + { + "first_name": "José Luiz Vargas de", + "last_name": "Mendonça", + "institution": "University of Michigan" + }, + { + "first_name": "Bereket Shimels", + "last_name": "Ayele", + "institution": "Addis Ababa Science and Technology University" + }, + { + "first_name": "Bereket Ngussie", + "last_name": "Bekele", + "institution": "Addis Ababa Science and Technology University" + }, + { + "first_name": "Shayan", + "last_name": "Jalili", + "institution": "University of Michigan" + }, + { + "first_name": "Pranjal", + "last_name": "Sharma", + "institution": "University of Michigan" + }, + { + "first_name": "Nicholas", + "last_name": "Wohlfeil", + "institution": "University of Michigan" + }, + { + "first_name": "Y.", + "last_name": "Zhang", + "institution": "University of Michigan" + }, + { + "first_name": "Jean-Baptiste", + "last_name": "Jeannin", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/ChenMABJSWZJ24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674639", + "title": "Grokking the Sequent Calculus (Functional Pearl)", + "abstract": "The sequent calculus is a proof system which was designed as a more symmetric alternative to natural deduction. The λμμ˜-calculus is a term assignment system for the sequent calculus and a great foundation for compiler intermediate languages due to its first-class representation of evaluation contexts. Unfortunately, only experts of the sequent calculus can appreciate its beauty. To remedy this, we present the first introduction to the λμμ˜-calculus which is not directed at type theorists or logicians but at compiler hackers and programming-language enthusiasts. We do this by writing a compiler from a small but interesting surface language to the λμμ˜-calculus as a compiler intermediate language.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674639", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "David A.", + "last_name": "Binder", + "institution": "University of Tübingen" + }, + { + "first_name": "Marco", + "last_name": "Tzschentke", + "institution": "University of Tübingen" + }, + { + "first_name": "Marius", + "last_name": "Müller", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/BinderT0O24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674637", + "title": "Snapshottable Stores", + "abstract": "We say that an imperative data structure is snapshottable or supports snapshots if we can efficiently capture its current state, and restore a previously captured state to become the current state again. This is useful, for example, to implement backtracking search processes that update the data structure during search. Inspired by a data structure proposed in 1978 by Baker, we present a snapshottable store, a bag of mutable references that supports snapshots. Instead of capturing and restoring an array, we can capture an arbitrary set of references (of any type) and restore all of them at once. This snapshottable store can be used as a building block to support snapshots for arbitrary data structures, by simply replacing all mutable references in the data structure by our store references. We present use-cases of a snapshottable store when implementing type-checkers and automated theorem provers. Our implementation is designed to provide a very low overhead over normal references, in the common case where the capture/restore operations are infrequent. Read and write in store references are essentially as fast as in plain references in most situations, thanks to a key optimisation we call record elision. In comparison, the common approach of replacing references by integer indices into a persistent map incurs a logarithmic overhead on reads and writes, and sophisticated algorithms typically impose much larger constant factors. The implementation, which is inspired by Baker’s and the OCaml implementation of persistent arrays by Conchon and Filliâtre, is both fairly short and very hard to understand: it relies on shared mutable state in subtle ways. We provide a mechanized proof of correctness of its core using the Iris framework for the Coq proof assistant.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674637", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Clément", + "last_name": "Allain", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Basile", + "last_name": "Clément", + "institution": "" + }, + { + "first_name": "Alexandre", + "last_name": "Moine", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/AllainC0S24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674662", + "title": "Automated Verification of Higher-Order Probabilistic Programs via a Dependent Refinement Type System", + "abstract": "Verification of higher-order probabilistic programs is a challenging problem. We present a verification method that supports several quantitative properties of higher-order probabilistic programs. Usually, extending verification methods to handle the quantitative aspects of probabilistic programs often entails extensive modifications to existing tools, reducing compatibility with advanced techniques developed for qualitative verification. In contrast, our approach necessitates only small amounts of modification, facilitating the reuse of existing techniques and implementations. On the theoretical side, we propose a dependent refinement type system for a generalised higher-order fixed point logic (HFL). Combined with continuation-passing style encodings of properties into HFL, our dependent refinement type system enables reasoning about several quantitative properties, including weakest pre-expectations, expected costs, moments of cost, and conditional weakest pre-expectations for higher-order probabilistic programs with continuous distributions and conditioning. The soundness of our approach is proved in a general setting using a framework of categorical semantics so that we don’t have to repeat similar proofs for each individual problem. On the empirical side, we implement a type checker for our dependent refinement type system that reduces the problem of type checking to constraint solving. We introduce admissible predicate variables and integrable predicate variables to constrained Horn clauses (CHC) so that we can soundly reason about the least fixed points and samplings from probability distributions. Our implementation demonstrates that existing CHC solvers developed for non-probabilistic programs can be extended to a solver for the extended CHC with only small efforts. We also demonstrate the ability of our type checker to verify various concrete examples.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674662", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Satoshi", + "last_name": "Kura", + "institution": "Waseda University" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/0001024", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674640", + "title": "Sound Borrow-Checking for Rust via Symbolic Semantics", + "abstract": "The Rust programming language continues to rise in popularity, and as such, warrants the close attention of the programming languages community. In this work, we present a new foundational contribution towards the theoretical understanding of Rust’s semantics. We prove that LLBC, a high-level, borrow-centric model previously proposed for Rust’s semantics and execution, is sound with regards to a low-level pointer-based language à la CompCert. Specifically, we prove the following: that LLBC is a correct view over a traditional model of execution; that LLBC’s symbolic semantics are a correct abstraction of LLBC programs; and that LLBC’s symbolic semantics act as a borrow-checker for LLBC, i.e. that symbolically-checked LLBC programs do not get stuck when executed on a heap-and-addresses model of execution. To prove these results, we introduce a new proof style that considerably simplifies our proofs of simulation, which relies on a notion of hybrid states. Equipped with this reasoning framework, we show that a new addition to LLBC’s symbolic semantics, namely a join operation, preserves the abstraction and borrow-checking properties. This in turn allows us to add support for loops to the Aeneas framework; we show, using a series of examples and case studies, that this unlocks new expressive power for Aeneas.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674640", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Son", + "last_name": "Ho", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Aymeric", + "last_name": "Fromherz", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/HoFP24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674652", + "title": "A Two-Phase Infinite/Finite Low-Level Memory Model: Reconciling Integer-Pointer Casts, Finite Space, and undef at the LLVM IR Level of Abstraction", + "abstract": "This paper provides a novel approach to reconciling complex low-level memory model features, such as pointerinteger casts, with desired refinements that are needed to justify the correctness of program transformations. The idea is to use a “two-phase” memory model, one with an unbounded memory and corresponding unbounded integer type, and one with a finite memory; the connection between the two levels is made explicit by a notion of refinement that handles out-of-memory behaviors. This approach allows for more optimizations to be performed and establishes a clear boundary between the idealized semantics of a program and the implementation of that program on finite hardware. The two-phase memory model has been incorporated into an LLVM IR semantics, demonstrating its utility in practice in the context of a low-level language with features like undef and bitcast. This yields infinite and finite memory versions of the language semantics that are proven to be in refinement with respect to out-of-memory behaviors. Each semantics is accompanied by a verified executable reference interpreter. The semantics justify optimizations, such as dead-alloca-elimination, that were previously impossible or difficult to prove correct.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674652", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Calvin", + "last_name": "Beck", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Irene", + "last_name": "Yoon", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Hanxi", + "last_name": "Chen", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/Beck0CZZ24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674625", + "title": "How to Bake a Quantum Π", + "abstract": "We construct a computationally universal quantum programming language Quantum Π from two copies of Π , the internal language of rig groupoids. The first step constructs a pure (measurement-free) term language by interpreting each copy of Π in a generalisation of the category Unitary in which every morphism is “rotated” by a particular angle, and the two copies are amalgamated using a free categorical construction expressed as a computational effect. The amalgamated language only exhibits quantum behaviour for specific values of the rotation angles, a property which is enforced by imposing a small number of equations on the resulting category. The second step in the construction introduces measurements by layering an additional computational effect.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674625", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jacques", + "last_name": "Carette", + "institution": "McMaster University" + }, + { + "first_name": "Chris", + "last_name": "Heunen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Robin", + "last_name": "Kaarsgaard", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "journals/pacmpl/CaretteHKS24a", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674632", + "title": "Almost-Sure Termination by Guarded Refinement", + "abstract": "Almost-sure termination is an important correctness property for probabilistic programs, and a number of program logics have been developed for establishing it. However, these logics have mostly been developed for first-order programs written in languages with specific syntactic patterns for looping. In this paper, we consider almost-sure termination for higher-order probabilistic programs with general references. This combination of features allows for recursion and looping to be encoded through a variety of patterns. Therefore, rather than developing proof rules for reasoning about particular recursion patterns, we instead propose an approach based on proving refinement between a higher-order program and a simpler probabilistic model, in such a way that the refinement preserves termination behavior. By proving a refinement, almost-sure termination behavior of the program can then be established by analyzing the simpler model. We present this approach in the form of Caliper , a higher-order separation logic for proving terminationpreserving refinements. Caliper uses probabilistic couplings to carry out relational reasoning between a program and a model. To handle the range of recursion patterns found in higher-order programs, Caliper uses guarded recursion, in particular the principle of Löb induction. A technical novelty is that Caliper does not require the use of transfinite step indexing or other technical restrictions found in prior work on guarded recursion for termination-preservation refinement. We demonstrate the flexibility of this approach by proving almost-sure termination of several examples, including first-order loop constructs, a random list generator, treaps, and a sampler for Galton-Watson trees that uses higher-order store. All the results have been mechanized in the Coq proof assistant.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674632", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "New York University" + }, + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Philipp G.", + "last_name": "Haselwarter", + "institution": "Aarhus University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/Gregersen0HTB24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674638", + "title": "Beyond Trees: Calculating Graph-Based Compilers (Functional Pearl)", + "abstract": "Bahr and Hutton recently developed an approach to compiler calculation that allows a wide range of compilers to be derived from specifications of their correctness. However, a limitation of the approach is that it results in compilers that produce tree-structured code. By contrast, realistic compilers produce code that is essentially graph-structured, where the edges in the graph represent jumps that transfer the flow of control to other locations in the code. In this article, we show how their approach can naturally be adapted to calculate compilers that produce graph-structured code, without changing the underlying calculational methodology, by using a higher-order abstract syntax representation of graphs.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674638", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Bahr", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "University of Nottingham" + } + ], + "dblp_key": "journals/pacmpl/BahrH24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674628", + "title": "Double-Ended Bit-Stealing for Algebraic Data Types", + "abstract": "Algebraic data types are central to the development and evaluation of most functional programs. It is therefore important for compilers to choose compact and efficient representations of such types, in particular to achieve good memory footprints for applications. Algebraic data types are most often represented using blocks of memory where the first word is used as a so-called tag, carrying information about the constructor, and the following words are used for carrying the constructor’s arguments. As an optimisation, lists are usually represented more compactly, using a technique called bit-stealing, which, in its simplest form, uses the word-alignment property of pointers to byte-addressed allocated memory to discriminate between the nil constructor (often represented as 0 × 1 ) and the cons constructor (aligned pointer to allocated pair). Because the representation supports that all values can be held uniformly in one machine word, possibly pointing to blocks of memory, type erasure is upheld. However, on today’s 64-bit architectures, memory addresses (pointers) are represented using only a subset of the 64 bits available in a machine word, which leave many bits unused. In this paper, we explore the use, not only of the least-significant bits of pointers, but also of the most-significant bits, for representing algebraic data types in a full ML compiler. It turns out that, with such a particular utilisation of otherwise unused bits, which we call double-ended bit-stealing, it is possible to choose unboxed representations for a large set of data types, while still not violating the principle of uniform data-representations. Examples include Patricia trees, union-find data structures, stream data types, internal language representations for types and expressions, and mutually recursive ASTs for full language definitions. The double-ended bit-stealing technique is implemented in the MLKit compiler and speedup ranges from 0 to 26 percent on benchmarks that are influenced by the technique. For MLKit, which uses abstract data types extensively, compilation speedups of around 9 percent are achieved for compiling MLton (another Standard ML compiler) and for compiling MLKit itself.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674628", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/Elsman24a", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674648", + "title": "Closure-Free Functional Programming in a Two-Level Type Theory", + "abstract": "Many abstraction tools in functional programming rely heavily on general-purpose compiler optimization to achieve adequate performance. For example, monadic binding is a higher-order function which yields runtime closures in the absence of sufficient compile-time inlining and beta-reductions, thereby significantly degrading performance. In current systems such as the Glasgow Haskell Compiler, there is no strong guarantee that general-purpose optimization can eliminate abstraction overheads, and users only have indirect and fragile control over code generation through inlining directives and compiler options. We propose a two-stage language to simultaneously get strong guarantees about code generation and strong abstraction features. The object language is a simply-typed first-order language which can be compiled without runtime closures. The compile-time language is a dependent type theory. The two are integrated in a two-level type theory. We demonstrate two applications of the system. First, we develop monads and monad transformers. Here, abstraction overheads are eliminated by staging and we can reuse almost all definitions from the existing Haskell ecosystem. Second, we develop pull-based stream fusion. Here we make essential use of dependent types to give a concise definition of a concatMap operation with guaranteed fusion. We provide an Agda implementation and a typed Template Haskell implementation of these developments.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674648", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "András", + "last_name": "Kovács", + "institution": "University of Gothenburg" + } + ], + "dblp_key": "journals/pacmpl/Kovacs24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674642", + "title": "Oxidizing OCaml with Modal Memory Management", + "abstract": "Programmers can often improve the performance of their programs by reducing heap allocations: either by allocating on the stack or reusing existing memory in-place. However, without safety guarantees, these optimizations can easily lead to use-after-free errors and even type unsoundness. In this paper, we present a design based on modes which allows programmers to safely reduce allocations by using stack allocation and in-place updates of immutable structures. We focus on three mode axes: affinity, uniqueness and locality. Modes are fully backwards compatible with existing OCaml code and can be completely inferred. Our work makes manual memory management in OCaml safe and convenient and charts a path towards bringing the benefits of Rust to OCaml.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674642", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Anton", + "last_name": "Lorenzen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Leo", + "last_name": "White", + "institution": "" + }, + { + "first_name": "Stephen", + "last_name": "Dolan", + "institution": "" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "The Jane Goodall Institute" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/LorenzenWDEL24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674653", + "title": "CCLemma: E-Graph Guided Lemma Discovery for Inductive Equational Proofs", + "abstract": "The problem of automatically proving the equality of terms over recursive functions and inductive data types is challenging, as such proofs often require auxiliary lemmas which must themselves be proven. Previous attempts at lemma discovery compromise on either efficiency or efficacy. Goal-directed approaches are fast but limited in expressiveness, as they can only discover auxiliary lemmas which entail their goals. Theory exploration approaches are expressive but inefficient, as they exhaustively enumerate candidate lemmas. We introduce e-graph guided lemma discovery , a new approach to finding equational proofs that makes theory exploration goal-directed. We accomplish this by using e-graphs and equality saturation to efficiently construct and compactly represent the space of all goal-oriented proofs. This allows us to explore only those auxiliary lemmas guaranteed to help make progress on some of these proofs. We implemented our method in a new prover called CCLemma and compared it with three state-of-the-art provers across a variety of benchmarks. CCLemma performs consistently well on two standard benchmarks and additionally solves 50% more problems than the next best tool on a new challenging set.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674653", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cole", + "last_name": "Kurashige", + "institution": "University of California San Diego" + }, + { + "first_name": "Ruyi", + "last_name": "Ji", + "institution": "Peking University" + }, + { + "first_name": "Aditya", + "last_name": "Giridharan", + "institution": "University of California San Diego" + }, + { + "first_name": "Mark", + "last_name": "Barbone", + "institution": "University of California San Diego" + }, + { + "first_name": "Daniel", + "last_name": "Noor", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/KurashigeJGBNIJ24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674650", + "title": "Deriving with Derivatives: Optimizing Incremental Fixpoints for Higher-Order Flow Analysis", + "abstract": "Attheheartofefficientprogramanalysisimplementationsareincrementalsolutionstofixpointproblems.These solutions can be interpreted as the derivative of the underlying analysis function. Methods that describe how to systematically derive higher-order analyses from program semantics, such as Abstracting Abstract Machines, don’t shed light on how to efficiently implement those analyses. In this paper, we explore complementary techniques to optimize the derivative computation towards deriving efficient implementations. In particular, we use static specializations (by partial evaluation and rewriting) and dynamic specializations (in the form of tracking dependencies during the fixpoint), yielding efficient incremental fixpoints. We present how these optimizations apply to an example analysis of continuation-passing-style 𝜆-calculus, and describe how they pair particularly well with tunable and optimized workset-based fixpoint methods. We demonstrate the efficacy of this approach on a flow analysis for the Standard ML language, yielding an average speed-up of 56x over an existing fixpoint method for higher-order analyses from the literature.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674650", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Quiring", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/QuiringH24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674644", + "title": "Gradual Indexed Inductive Types", + "abstract": "Indexed inductive types are essential in dependently-typed programming languages, enabling precise and expressive specifications of data structures and properties. Recognizing that programming and proving with dependent types could benefit from the smooth integration of static and dynamic checking that gradual typing offers, recent efforts have studied gradual dependent types. Gradualizing indexed inductive types however remains mostly unexplored: the standard encodings of indexed inductive types in intensional type theory, e.g., using type-level fixpoints or subset types, break in the presence of gradual features; and previous work on gradual dependent types focus on very specific instances of indexed inductive types. This paper contributes a general framework, named P unk , specifically designed for exploring the design space of gradual indexed inductive types. P unk is a versatile framework, enabling the exploration of the space between eager and lazy cast reduction semantics that arise from the interaction between casts and the inductive eliminator, allowing them to coexist and interoperate in a single system. Our work provides significant insights into the intersection of dependent types and gradual typing, by proposing a criteria for well-behaved gradual indexed inductive types, systematically addressing the outlined challenges of integrating these types. The contributions of this paper are a step forward in the quest for making gradual theorem proving and gradual dependently-typed programming a reality.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674644", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Malewski", + "institution": "Universidad Bernardo O'Higgins" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/MalewskiMTT24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674636", + "title": "Example-Based Reasoning about the Realizability of Polymorphic Programs", + "abstract": "Parametricity states that polymorphic functions behave the same regardless of how they are instantiated. When developing polymorphic programs, Wadler’s free theorems can serve as free specifications, which can turn otherwise partial specifications into total ones, and can make otherwise realizable specifications unrealizable. This is of particular interest to the field of program synthesis, where the unrealizability of a specification can be used to prune the search space. In this paper, we focus on the interaction between parametricity, input-output examples, and sketches. Unfortunately, free theorems introduce universally quantified functions that make automated reasoning difficult. Container morphisms provide an alternative representation for polymorphic functions that captures parametricity in a more manageable way. By using a translation to the container setting, we show how reasoning about the realizability of polymorphic programs with input-output examples can be automated.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674636", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Niek", + "last_name": "Mulleners", + "institution": "Utrecht University" + }, + { + "first_name": "Johan", + "last_name": "Jeuring", + "institution": "Utrecht University" + }, + { + "first_name": "Bastiaan", + "last_name": "Heeren", + "institution": "Open University of the Netherlands" + } + ], + "dblp_key": "journals/pacmpl/MullenersJH24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674646", + "title": "Abstract Interpreters: A Monadic Approach to Modular Verification", + "abstract": "We argue that monadic interpreters built as layers of handlers stacked atop the free monad, as advocated notably by the ITree library, also constitute a promising way to implement and verify abstract interpreters in dependently-typed theories such as the one underlying the Coq proof assistant. The approach enables both code reuse across projects and modular proofs of soundness of the resulting interpreters. We provide generic abstract control flow combinators proven correct once and for all against their concrete counterpart. We demonstrate how to relate concrete handlers implementing effects to abstract variants of these handlers, essentially capturing the traditional soundness of transfer functions in the context of monadic interpreters. Finally, we provide generic results to lift soundness statements via the interpretation of stateful and failure effects. We formalize all the aforementioned combinators and theories into a Coq library, and demonstrate their benefits by implementing and proving correct two illustrative abstract interpreters respectively for a structured imperative language and a toy assembly.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674646", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sébastien", + "last_name": "Michelland", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Laure", + "last_name": "Gonnord", + "institution": "Institut polytechnique de Grenoble" + } + ], + "dblp_key": "journals/pacmpl/MichellandZG24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674629", + "title": "A Safe Low-Level Language for Computer Algebra and Its Formally Verified Compiler", + "abstract": "This article describes a programming language for writing low-level libraries for computer algebra systems. Such libraries (GMP, BLAS/LAPACK, etc) are usually written in C, Fortran, and Assembly, and make heavy use of arrays and pointers. The proposed language, halfway between C and Rust, is designed to be safe and to ease the deductive verification of programs, while being low-level enough to be suitable for this kind of computationally intensive applications. This article also describes a compiler for this language, based on CompCert. The safety of the language has been formally proved using the Coq proof assistant, and so has the property of semantics preservation for the compiler. While the language is not yet feature-complete, this article shows what it entails to design a new domain-specific programming language along its formally verified compiler.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674629", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Melquiond", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Josué", + "last_name": "Moreau", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/MelquiondM24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674647", + "title": "Dependent Ghosts Have a Reflection for Free", + "abstract": "We introduce ghost type theory (GTT) a dependent type theory extended with a new universe for ghost data that can safely be erased when running a program but which is not proof irrelevant like with a universe of (strict) propositions. Instead, ghost data carry information that can be used in proofs or to discard impossible cases in relevant computations. Casts can be used to replace ghost values by others that are propositionally equal, but crucially these casts can be ignored for conversion without compromising soundness. We provide a type-preserving erasure procedure which gets rid of all ghost data and proofs, a step which may be used as a first step to program extraction. We give a syntactical model of GTT using a program translation akin to the parametricity translation and thus show consistency of the theory. Because it is a parametricity model, it can also be used to derive free theorems about programs using ghost code. We further extend GTT to support equality reflection and show that we can eliminate its use without the need for the usual extra axioms of function extensionality and uniqueness of identity proofs. In particular we validate the intuition that indices of inductive types—such as the length index of vectors—do not matter for computation and can safely be considered modulo theory. The results of the paper have been formalised in Coq.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674647", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/Winterhalter24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674643", + "title": "Blame-Correct Support for Receiver Properties in Recursively-Structured Actor Contracts", + "abstract": "Actor languages model concurrency as processes that communicate through asynchronous message sends. Unfortunately, as the complexity of these systems increases, it becomes more difficult to compose and integrate their components. This is because of assumptions made by components about their communication partners which may not be upheld when they remain implicit. In this paper, we bring design-by-contract programming to actor programs through a contract system that enables expressing constraints on receiver-related properties. Expressing properties about the expected receiver of a message, and about this receiver’s communication behavior, requires two novel types of contracts. Through their recursive structure, these contracts can govern entire communication chains. We implement the contract system for an actor extension of Scheme, describe it formally, and show how to assign blame in case of a contract violation. Finally, we prove our contract system and its blame assignment correct by formulating and proving a blame correctness theorem.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674643", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Bram", + "last_name": "Vandenbogaerde", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Quentin", + "last_name": "Stiévenart", + "institution": "Université du Québec à Montréal" + }, + { + "first_name": "Coen De", + "last_name": "Roover", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "journals/pacmpl/VandenbogaerdeS24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674645", + "title": "Refinement Composition Logic", + "abstract": "One successful approach to verifying programs is refinement, where one establishes that the implementation ( e.g. , in C) behaves as specified in its mathematical specification. In this approach, the end result (a whole implementation refines a whole specification) is often established via composing multiple “small” refinements. In this paper, we focus on the task of composing refinements. Our key observation is a novel correspondence between the task of composing refinements and the task of proving entailments in modern separation logic. This correspondence is useful. First, it unlocks tools and abstract constructs developed for separation logic, greatly streamlining the composition proof. Second, it uncovers a fundamentally new verification strategy. We address the key challenge in establishing the correspondence with a novel use of angelic non-determinism . Guided by the correspondence, we develop RCL (Refinement Composition Logic) , a logic dedicated to composing refinements. All our results are formalized in Coq.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674645", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Dongjae", + "last_name": "Lee", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/SongL24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674656", + "title": "Specification and Verification for Unrestricted Algebraic Effects and Handling", + "abstract": "Programming with user-defined effects and effect handlers has many practical use cases involving imperative effects. Additionally, it is natural and powerful to use multi-shot effect handlers for non-deterministic or probabilistic programs that allow backtracking to compute a comprehensive outcome. Existing works for verifying effect handlers are restricted in one of three ways: i) permitting multi-shot continuations under pure setting; ii) allowing heap manipulation for only one-shot continuations; or iii) allowing multi-shot continuations with heap-manipulation but under a restricted frame rule. This work proposes a novel calculus called Effectful Specification Logic (ESL) to support unrestricted effect handlers, where zero-/one-/multi-shot continuations can co-exist with imperative effects and higher-order constructs. ESL captures behaviors in stages, and provides precise models to support invoked effects, handlers and continuations. To show its feasibility, we prototype an automated verification system for this novel specification logic, prove its soundness, report on useful case studies, and present experimental results. With this proposal, we have provided an extended specification logic that is capable of modeling arbitrary imperative higher-order programs with algebraic effects and continuation-enabled handlers.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674656", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Yahui", + "last_name": "Song", + "institution": "National University of Singapore" + }, + { + "first_name": "Darius", + "last_name": "Foo", + "institution": "National University of Singapore" + }, + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/SongFC24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674630", + "title": "On the Operational Theory of the CPS-Calculus: Towards a Theoretical Foundation for IRs", + "abstract": "The continuation-passing style translation often employed by compilers gives rise to a class of intermediate representation languages where functions are not allowed to return anymore. Though the primary use of these intermediate representation languages is to expose details about a program’s control flow, they may be equipped with an equational theory in order to be seen as specialized calculi, which in turn may be related to the original languages by means of a factorization theorem. In this paper, we explore Thielecke’s CPS-calculus, a small theory of continuations inspired by compiler implementations, and study its metatheory. We extend it with a sound reduction semantics that faithfully represents optimization rules used in actual compilers, and prove that it acts as a suitable theoretical foundation for the intermediate representation of Appel’s and Kennedy’s compilers by following the guidelines set out by Plotkin. Finally, we prove that the CPS-calculus is strongly normalizing in the simply typed setting by using a novel proof method for reasoning about reducibility at a distance, from which logical consistency follows. Taken together, these results close a gap in the existing literature, providing a formal theory for reasoning about intermediate representations.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674630", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paulo", + "last_name": "Torrens", + "institution": "University of Kent" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + }, + { + "first_name": "Cristiano", + "last_name": "Vasconcellos", + "institution": "Universidade do Estado de Santa Catarina" + } + ], + "dblp_key": "journals/pacmpl/TorrensOV24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674631", + "title": "The Functional, the Imperative, and the Sudoku: Getting Good, Bad, and Ugly to Get Along (Functional Pearl)", + "abstract": "Conventional wisdom suggests that the benefits of functional programming no longer apply in the presence of even a small amount of imperative code, as if the addition of imperative code effectively subtracts. And yet, as we show in this paper, combining functional programming with the special imperative language Esterel provides a multiplicative improvement to the benefits of functional programming. The key to the benefit of both Esterel and functional programming stems from a restriction that both share. As in functional programming, where only the inputs to a function determine its outputs, the state of an Esterel computation is fully determined by the program’s input and the state that the computation had in the previous time step, where the notion of a time step is explicit in the language. Esterel’s guarantee holds even though Esterel programs feature concurrent threads, mutable state, and the ability to create, suspend, and even terminate threads as the computation proceeds. This similarity is the root of the benefits that programmers accrue as they informally reason about their program’s behavior. To illustrate these benefits, the bulk of this paper consists of an in-depth exploration of HipHop code (a mashup of JavaScript and Esterel) that implements a Sudoku solver, showing how it is possible to write code that is as easy to understand as if it were written in a pure functional programming style, even though it uses multiple threads, mutable state, thread preemption, and even thread abortion. Even better, concurrent composition and task canceling provide significant program structuring benefits that allow a clean decomposition and task separation in the solver.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674631", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/SerranoF24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674626", + "title": "Story of Your Lazy Function's Life: A Bidirectional Demand Semantics for Mechanized Cost Analysis of Lazy Programs", + "abstract": "Lazy evaluation is a powerful tool that enables better compositionality and potentially better performance in functional programming, but it is challenging to analyze its computation cost. Existing works either require manually annotating sharing, or rely on separation logic to reason about heaps of mutable cells. In this paper, we propose a bidirectional demand semantics that allows for extrinsic reasoning about the computation cost of lazy programs without relying on special program logics. To show the effectiveness of our approach, we apply the demand semantics to a variety of case studies including insertion sort, selection sort, Okasaki’s banker’s queue, and the implicit queue. We formally prove that the banker’s queue and the implicit queue are both amortized and persistent using the Rocq Prover (formerly known as Coq). We also propose the reverse physicist’s method, a novel variant of the classical physicist’s method, which enables mechanized, modular and compositional reasoning about amortization and persistence with the demand semantics.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674626", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Li-yao", + "last_name": "Xia", + "institution": "" + }, + { + "first_name": "Laura", + "last_name": "Israel", + "institution": "Portland State University" + }, + { + "first_name": "Maite", + "last_name": "Kramarz", + "institution": "University of Toronto" + }, + { + "first_name": "Nicholas", + "last_name": "Coltharp", + "institution": "Portland State University" + }, + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yao", + "last_name": "Li", + "institution": "Portland State University" + } + ], + "dblp_key": "journals/pacmpl/XiaIKCCW024", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674666", + "title": "A Coq Mechanization of JavaScript Regular Expression Semantics", + "abstract": "We present an executable, proven-safe, faithful, and future-proof Coq mechanization of JavaScript regular expression (regex) matching, as specified by the latest published edition of ECMA-262 section 22.2. This is, to our knowledge, the first time that an industrial-strength regex language has been faithfully mechanized in an interactive theorem prover. We highlight interesting challenges that arose in the process (including issues of encoding, corner cases, and executability), and we document the steps that we took to ensure that the result is straightforwardly auditable and that our understanding of the specification aligns with existing implementations. We demonstrate the usability and versatility of the mechanization through a broad collection of analyses, case studies, and experiments: we prove that JavaScript regex matching always terminates and is safe (no assertion failures); we identify subtle corner cases that led to mistakes in previous publications; we verify an optimization extracted from a state-of-the-art regex engine; we show that some classic properties described in automata textbooks and used in derivatives-based matchers do not hold in JavaScript regexes; and we demonstrate that the cost of updating the mechanization to account for changes in the original specification is reasonably low. Our mechanization can be extracted to OCaml and JavaScript and linked with Unicode libraries to produce an executable regex engine that passes the relevant parts of the official Test262 conformance test suite.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674666", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Noé De", + "last_name": "Santo", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Aurèle", + "last_name": "Barrière", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/SantoBP24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674655", + "title": "Contextual Typing", + "abstract": "Bidirectional typing is a simple, lightweight approach to type inference that propagates known type information during typing, and can scale up to many different type systems and features. It typically only requires a reasonable amount of annotations and eliminates the need for many obvious annotations. Nonetheless the power of inference is still limited, and complications arise in the presence of more complex features. In this paper we present a generalization of bidirectional typing called contextual typing . In contextual typing not only known type information is propagated during typing, but also other known information about the surrounding context of a term. This information can be of various forms, such as other terms or record labels. Due to this richer notion of contextual information, less annotations are needed, while the approach remains lightweight and scalable. For type systems with subtyping, contextual typing subsumption is also more expressive than subsumption with bidirectional typing, since partially known contextual information can be exploited. To aid specifying type systems with contextual typing, we introduce Q uantitative T ype A ssignment S ystems (QTASs). A QTAS quantifies the amount of type information that a term needs in order to type check using counters. Thus, a counter in a QTAS generalizes modes in traditional bidirectional typing, which can only model an all (checking mode) or nothing (inference mode) approach. QTASs enable precise guidelines for annotatability of contextual type systems formalized as a theorem. We illustrate contextual typing first on a simply typed lambda calculus, and then on a richer calculus with subtyping, intersection types, records and overloading. All the metatheory is formalized in the Agda theorem prover.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674655", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Xu", + "last_name": "Xue", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/XueO24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674641", + "title": "Abstracting Effect Systems for Algebraic Effect Handlers", + "abstract": "Many effect systems for algebraic effect handlers are designed to guarantee that all invoked effects are handled adequately. However, respective researchers have developed their own effect systems that differ in how to represent the collections of effects that may happen. This situation results in blurring what is required for the representation and manipulation of effect collections in a safe effect system. In this work, we present a language λ EA equipped with an effect system that abstracts the existing effect systems for algebraic effect handlers. The effect system of λ EA is parameterized over effect algebras , which abstract the representation and manipulation of effect collections in safe effect systems. We prove the type-and-effect safety of λ EA by assuming that a given effect algebra meets certain properties called safety conditions . As a result, we can obtain the safety properties of a concrete effect system by proving that an effect algebra corresponding to the concrete system meets the safety conditions. We also show that effect algebras meeting the safety conditions are expressive enough to accommodate some existing effect systems, each of which represents effect collections in a different style. Our framework can also differentiate the safety aspects of the effect collections of the existing effect systems. To this end, we extend λ EA and the safety conditions to lift coercions and type-erasure semantics , propose other effect algebras including ones for which no effect system has been studied in the literature, and compare which effect algebra is safe and which is not for the extensions.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674641", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "T.", + "last_name": "Yoshioka", + "institution": "Kyoto University" + }, + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "journals/pacmpl/YoshiokaSI24", + "venue": "icfp", + "year": 2024 + }, + { + "paper_id": "10.1145/3674651", + "title": "Parallel Algebraic Effect Handlers", + "abstract": "Algebraic effect handlers support composable and structured control-flow abstraction. However, existing designs of algebraic effects often require effects to be executed sequentially. This paper studies parallel algebraic effect handlers. In particular, we formalize λ p , a lambda calculus which models two key features, effect handlers and parallelizable computations, the latter of which takes the form of a for expression, inspired by the Dex programming language. We present various interesting examples expressible in our calculus. To show that our design can be implemented in a type-safe way, we present a higher-order polymorphic lambda calculus F p that extends λ p with a lightweight value dependent type system, and prove that F p preserves the semantics of λ p and enjoys syntactic type soundness. Lastly, we provide an implementation of the language design as a Haskell library, which mirrors both λ p and F p and reveals new connections to free applicative functors. All examples presented can be encoded in the Haskell implementation. We believe this paper is the first to study the combination of user-defined effect handlers and parallel computations, and it is our hope that it provides a basis for future designs and implementations of parallel algebraic effect handlers.", + "date": "2024-08-15", + "link": "https://doi.org/10.1145/3674651", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Toronto" + }, + { + "first_name": "Daniel", + "last_name": "Johnson", + "institution": "University of Toronto" + }, + { + "first_name": "Dougal", + "last_name": "Maclaurin", + "institution": "Google (United States)" + }, + { + "first_name": "Adam", + "last_name": "Paszke", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/Xie0MP24", + "venue": "icfp", + "year": 2024 + } +] \ No newline at end of file diff --git a/data/pl_conferences/icfp/2025.json b/data/pl_conferences/icfp/2025.json new file mode 100644 index 0000000..2101bad --- /dev/null +++ b/data/pl_conferences/icfp/2025.json @@ -0,0 +1,1105 @@ +[ + { + "paper_id": "10.1145/3747512", + "title": "Almost Fair Simulations", + "abstract": "It is well known that liveness properties cannot be proven using standard simulation arguments. This issue has been mitigated by extending standard notions of simulation for transition systems to fairness-preserving simulations for systems equipped with an additional fairness condition modeling liveness assumptions and/or liveness requirements. In the context of automated verification of finite-state systems, proofs by simulation are an appealing method as there exist efficient algorithms to find a simulation between two systems. However, applications of fair simulation to interactive verification have been much less studied. Perhaps one reason is that the definitions of fair simulation relations typically involve non-trivial nestings of inductive and coinductive relations, making them particularly difficult to use and to reason about. In this paper, we argue that in many cases, stronger notions of fair simulation involving more controlled alternations of fixed points are sufficient. Starting from known fair simulation techniques, we progressively build up a family of almost fair simulation relations for transition systems equipped with a Büchi fairness condition. The simulation relations we present can all be equipped with intuitive reasoning rules, leading to elegant deductive systems to prove fair trace inclusion. We mechanized our simulation relations and their associated deductive systems in the Rocq proof assistant, proved their soundness, and we demonstrate their use through a selection of examples.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747512", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Correnson", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Iona", + "last_name": "Kuhn", + "institution": "Saarland University" + }, + { + "first_name": "Bernd", + "last_name": "Finkbeiner", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "journals/pacmpl/CorrensonKF25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747539", + "title": "Call-Guarded Abstract Definitional Interpreters", + "abstract": "Over the last 15 years, several popular systematic abstraction frameworks have emerged---frameworks that allow a static analysis to be derived by systematically transforming a concrete semantics. These frameworks guarantee computability of the resulting artifact by the application of an a priori abstraction which induces a particular finitization in the execution space. While effective, this abstraction occurs without regard for program structure, subjecting each program point to the same fixed degree of context sensitivity. In this paper, we present CGADI, an enhancement to systematic abstraction frameworks based on definitional interpreters which defers abstraction until a parameterized safety property signals that it should be applied. We then examine this enhanced framework instantiated with two such safety properties: a simple reentrancy property which detects non-recursive portions of program execution, and a size change property which detects evaluation paths destined to converge by virtue of appropriately decreasing values along them. The result is that CGADI can operate in the fully-precise concrete space for portions of execution without forfeiting computability. Our evaluation demonstrates that CGADI is able to produce a higher number of precise results than a corresponding CFA at relatively low cost and that, with no special treatment, CGADI can handle many programming patterns targeted by specific analysis techniques.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747539", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kimball", + "last_name": "Germane", + "institution": "Brigham Young University" + } + ], + "dblp_key": "journals/pacmpl/Germane25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747520", + "title": "Truly Functional Solutions to the Longest Uptrend Problem (Functional Pearl)", + "abstract": "Solutions to the longest increasing subsequence problem are typically implemented imperatively, relying on arrays for constant-time lookups and updates. Replacing these arrays with functional sequences allows a purely functional solution with the same asymptotic running time, but with significantly worse practical performance. In this pearl, we present a purely functional approach that is not only asymptotically optimal, but also efficient in practice. The core idea is to exploit the interplay between search, lookup, and update operations through Huet's zipper. In addition, we improve the adaptive behaviour of imperative solutions commonly found in the literature.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747520", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Dinges", + "institution": "Rheinland-Pfälzische Technische Universität Kaiserslautern-Landau" + }, + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "Rheinland-Pfälzische Technische Universität Kaiserslautern-Landau" + } + ], + "dblp_key": "journals/pacmpl/DingesH25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747531", + "title": "Linear Types with Dynamic Multiplicities in Dependent Type Theory (Functional Pearl)", + "abstract": "We construct a linear type system inside dependent type theory. For this, we equip the output type of a program with a bag containing copies of each of the input variables. We call the number of copies of an input variable its multiplicity. We then characterise a dependent type which ensures that a program uses exactly the given multiplicity of each input variable. While our system is not closed under linear function types, we can program in the resulting system in a practical way using usual dependent functions, which we demonstrate by constructing standard programs on lists such as folds, unfolds and sorting algorithms. Since our linear type system is deeply embedded in a functional language, we can moreover dynamically compute multiplicities, which allows us to capture that a program uses a varying number of copies of some input depending on the other inputs. We can thereby give precise types to many functional programs that cannot be typed in systems with static multiplicities.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747531", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Maximilian", + "last_name": "Doré", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/Dore25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747540", + "title": "Big Steps in Higher-Order Mathematical Operational Semantics", + "abstract": "Small-step and big-step operational semantics are two fundamental styles of structural operational semantics (SOS), extensively used in practice. The former one is more fine-grained and is usually regarded as primitive, as it only defines a one-step reduction relation between a given program and its direct descendant under an ambient evaluation strategy. The latter one implements, in a self-contained manner, such a strategy directly by relating a program to the net result of the evaluation process. The agreement between these two styles of semantics is one of the key pillars in operational reasoning on programs; however, such agreement is typically proven from scratch every time on a case-by-case basis. A general, abstract mathematical argument behind this agreement is up till now missing. We cope with this issue within the framework of higher-order mathematical operational semantics by providing an abstract categorical notion of big-step SOS, complementing the existing notion of abstract higher-order GSOS. Moreover, we introduce a general construction for deriving the former from the latter, and prove an abstract equivalence result between the two.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747540", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sergey", + "last_name": "Goncharov", + "institution": "University of Birmingham" + }, + { + "first_name": "Pouya", + "last_name": "Partow", + "institution": "University of Birmingham" + }, + { + "first_name": "Stelios", + "last_name": "Tsampas", + "institution": "University of Southern Denmark" + } + ], + "dblp_key": "journals/pacmpl/0001P025", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747522", + "title": "SecRef*: Securely Sharing Mutable References between Verified and Unverified Code in F", + "abstract": "We introduce SecRef*, a secure compilation framework protecting stateful programs verified in F* against linked unverified code, with which the program dynamically shares ML-style mutable references. To ease program verification in this setting, we track which references are shareable with the unverified code, and which ones are not shareable and whose contents are thus guaranteed to be unchanged after calling into unverified code. This universal property of non-shareable references is exposed in the interface on which the verified program can rely when calling into unverified code. The remaining refinement types and pre- and post-conditions that the verified code expects from the unverified code are converted into dynamic checks about the shared references by using higher-order contracts. We prove formally in F* that this strategy ensures sound and secure interoperability with unverified code. Since SecRef* is built on top of the Monotonic State effect of F*, these proofs rely on the first monadic representation for this effect, which is a contribution of our work that can be of independent interest. Finally, we use SecRef* to build a simple cooperative multi-threading scheduler that is verified and that securely interacts with unverified threads.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747522", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cezar-Constantin", + "last_name": "Andrici", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "University of Tartu" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Ruxandra", + "last_name": "Icleanu", + "institution": "University of Edinburgh" + }, + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Exequiel", + "last_name": "Rivas", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Théo", + "last_name": "Winterhalter", + "institution": "Centre Inria de Saclay" + } + ], + "dblp_key": "journals/pacmpl/AndriciAHIMRW25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747510", + "title": "Verifying Graph Algorithms in Separation Logic: A Case for an Algebraic Approach", + "abstract": "Verifying graph algorithms has long been considered challenging in separation logic, mainly due to structural sharing between graph subcomponents. We show that these challenges can be effectively addressed by representing graphs as a partial commutative monoid (PCM), and by leveraging structure-preserving functions (PCM morphisms), including higher-order combinators. PCM morphisms are important because they generalize separation logic's principle of local reasoning. While traditional framing isolates relevant portions of the heap only at the top level of a specification, morphisms enable contextual localization: they distribute over monoid operations to isolate relevant subgraphs, even when nested deeply within a specification. We demonstrate the morphisms' effectiveness with novel and concise verifications of two canonical graph benchmarks: the Schorr-Waite graph marking algorithm and the union-find data structure.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747510", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Marcos", + "last_name": "Grandury", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Alexander", + "last_name": "Gryzlov", + "institution": "IMDEA Software Institute" + } + ], + "dblp_key": "journals/pacmpl/GranduryNG25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747518", + "title": "Multi-stage Programming with Splice Variables", + "abstract": "Multi-stage programming is a popular approach to typed meta-programming, reducing abstraction overhead and producing performant programs. However, the traditional quote-and-splice staging syntax, as introduced by Rowan Davies in 1996, can introduce complexities in managing expression evaluation, and also often necessitates sophisticated mechanisms for advanced features such as code pattern matching. This paper introduces λ○▷, a novel staging calculus featuring let-splice bindings, a construct that explicitly binds splice expressions to splice variables, providing flexibility in managing, sharing, and reusing splice computations. Inspired by contextual modal type theory, our type system associates types with a typing context to capture variables dependencies of splice variables. We demonstrate that this mechanism seamlessly scales to features like code pattern matching, by formalizing λ○▷, an extension of λ○▷ pat with code pattern matching and rewriting. We establish the syntactic type soundness of both calculi. Furthermore, we define a denotational semantics using a Kripke-style model, and prove adequacy results. All proofs have been fully mechanized using the Agda proof assistant.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747518", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Tsung-Ju", + "last_name": "Chiang", + "institution": "University of Toronto" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/ChiangX25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747505", + "title": "A Bargain for Mergesorts: How to Prove Your Mergesort Correct and Stable, Almost for Free", + "abstract": "We present a novel characterization of stable mergesort functions using relational parametricity, and show that it implies the functional correctness of mergesort. As a result, one can prove the correctness of several variations of mergesort (e.g., top-down, bottom-up, tail-recursive, non-tail-recursive, smooth, and non-smooth mergesorts) by proving the characteristic property for each variation. Thanks to our characterization and the parametricity translation, we deduced the correctness results, including stability, of various implementations of mergesort for lists, including highly optimized ones, in the Rocq Prover (formerly the Coq Proof Assistant).", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747505", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cyril", + "last_name": "Cohen", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Kazuhiko", + "last_name": "Sakaguchi", + "institution": "Université Claude Bernard Lyon 1" + } + ], + "dblp_key": "journals/pacmpl/CohenS25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747537", + "title": "Verified Interpreters for Dynamic Languages with Applications to the Nix Expression Language", + "abstract": "To study the semantics of a programming language, it is useful to consider different specification forms— e.g. , a substitution-based small-step operational semantics and an environment-based interpreter—because they have mutually exclusive benefits. Developing these specifications and proving correspondences is challenging for ‘dynamic’/‘scripting’ languages such as JavaScript, PHP and Bash. We study this challenge in the context of the Nix expression language, a dynamic language used in the eponymous package manager and operating system. Nix is a Turing-complete, untyped functional language designed for the manipulation of JSON-style attribute sets, with tricky features such as overloaded use of variables for lambda bindings and attribute members, subtle shadowing rules, a mixture of evaluation strategies, and tricky mechanisms for recursion. We show that our techniques are applicable beyond Nix by starting from the call-by-name lambda calculus, which we extend to a core lambda calculus with dynamically computed variable names and dynamic binder names, and finally to Nix. Our key novelty is the use of a form of deferred substitutions , which enables us to give a concise substitution-based semantics for dynamic variable binding. We develop corresponding environment-based interpreters, which we prove to be sound and complete (for terminating, faulty and diverging programs) w.r.t. our operational semantics based on deferred substitutions. We mechanize all our results in the Rocq prover and showcase a new feature of the Rocq-std++ library for representing syntax with maps in recursive positions. We use Rocq’s extraction mechanism to turn our Nix interpreter into executable OCaml code, which we apply to the official Nix language tests. Altogether this gives rise to the most comprehensive formal semantics for the Nix expression language to date.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747537", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Rutger", + "last_name": "Broekhoff", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/BroekhoffK25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747516", + "title": "Environment-Sharing Analysis and Caller-Provided Environments for Higher-Order Languages", + "abstract": "The representation of functions in higher-order languages includes both the function’s code and an environment structure that captures the bindings of the function’s free variables. This paper explores caller-provided environments, where instead of packaging the entirety of a function’s environment in its closure, a function can be provided with a portion of its environment by its caller. In higher-order languages, it is difficult to determine where functions are called, let alone what pieces of the function’s environment are available to be provided by the caller, thus we need a higher-order control-flow analysis to enable caller-provided environments. In this paper, we present a new abstract-interpretation-based analysis that discovers which pieces of a function’s environment are always shared between its definition and its callers. In such cases, the caller can provide the environment to the callee. Our analysis has been formalized in the Rocq proof assistant. We evaluate our analysis on a collection of programs demonstrating that it is both scalable and provides significantly better information over the common syntactic approach and better information than lightweight closure conversion . In fact, it yields the theoretical upper-bound for many programs. For caller-provided environments, deciding how to transform the program based on these revealed facts is also non-trivial and has the potential to incur extra runtime cost over standard strategies. We discuss how to make these decisions in a way that avoids the extra costs and how to transform a program accordingly. We also propose other uses of the analysis results beyond enabling caller-provided environments. We evaluate our transformation using an instrumented interpreter, showing that our approach is effective in reducing dynamic allocations for environments.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747516", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "J. A.", + "last_name": "Carr", + "institution": "University of Chicago" + }, + { + "first_name": "Benjamin", + "last_name": "Quiring", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "John", + "last_name": "Reppy", + "institution": "University of Chicago" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Northeastern University" + }, + { + "first_name": "Skye", + "last_name": "Soss", + "institution": "University of Chicago" + }, + { + "first_name": "Byron", + "last_name": "Zhong", + "institution": "University of Chicago" + } + ], + "dblp_key": "journals/pacmpl/CarrQRSSZ25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747527", + "title": "2-Functoriality of Initial Semantics, and Applications", + "abstract": "Initial semantics aims to model inductive structures and their properties, and to provide them with recursion principles respecting these properties. An ubiquitous example is the fold operator for lists. We are concerned with initial semantics that model languages with variable binding and their substitution structure, and that provide substitution-safe recursion principles. There are different approaches to implementing languages with variable binding depending on the choice of representation for contexts and free variables, such as unscoped syntax, or well-scoped syntax with finite or infinite contexts. Abstractly, each approach corresponds to choosing a different monoidal category to model contexts and binding, each choice yielding a different notion of \"model\" for the same abstract specification (or \"signature\"). In this work, we provide tools to compare and relate the models obtained from a signature for different choices of monoidal category. We do so by showing that initial semantics naturally has a 2-categorical structure when parametrized by the monoidal category modeling contexts. We thus can relate models obtained from different choices of monoidal categories provided the monoidal categories themselves are related. In particular, we use our results to relate the models of the different implementation - de Bruijn vs locally nameless, finite vs infinite contexts -, and to provide a generalized recursion principle for simply-typed syntax.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747527", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Benedikt", + "last_name": "Ahrens", + "institution": "Delft University of Technology" + }, + { + "first_name": "Ambroise", + "last_name": "Lafont", + "institution": "École Polytechnique" + }, + { + "first_name": "Thomas", + "last_name": "Lamiaux", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/AhrensLL25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747521", + "title": "A Haskell Adiabatic DSL: Solving Classical Optimization Problems on Quantum Hardware", + "abstract": "In physics and chemistry, quantum systems are typically modeled using energy constraints formulated as Hamiltonians. Investigations into such systems often focus on the evolution of the Hamiltonians under various initial conditions, an approach summarized as Adiabatic Quantum Computing (AQC). Although this perspective may initially seem foreign to functional programmers, we demonstrate that conventional functional programming abstractions—specifically, the Traversable and Monad type classes—naturally capture the essence of AQC. To illustrate this connection, we introduce EnQ, a functional programming library designed to express diverse optimization problems as energy constraint computations (ECC). The library comprises three core components: generating the solution space, associating energy costs with potential solutions, and searching for optimal or near-optimal solutions. Because EnQ is implemented using standard Haskell, it can be executed directly through conventional classical Haskell compilers. More interestingly, we develop and implement a process to compile EnQ programs into circuits executable on quantum hardware. We validate EnQ’s effectiveness through a number of case studies, demonstrating its capacity to express and solve classical optimization problems on quantum hardware, including search problems, type inference, number partitioning, clique finding, and graph coloring.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747521", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Liyi", + "last_name": "Li", + "institution": "Iowa State University" + }, + { + "first_name": "David", + "last_name": "Young", + "institution": "University of Kansas" + }, + { + "first_name": "James Bryan", + "last_name": "Graves", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Chandeepa", + "last_name": "Dissanayake", + "institution": "Iowa State University" + }, + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "journals/pacmpl/0002YGDS25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747511", + "title": "McTT: A Verified Kernel for a Proof Assistant", + "abstract": "Proof assistants based on type theories have been widely successful from verifying safety-critical software to establishing a new standard of rigour by formalizing mathematics. But these proof assistants and even their type-checking kernels are also complex pieces of software, and software invariably has bugs, so why should we trust such proof assistants? In this paper, we describe the McTT (Mechanized Type Theory) infrastructure to build a verified implementation of a kernel for a core Martin-Löf type theory (MLTT). McTT is implemented in Rocq and consists of two main components: In the theoretical component, we specify the type theory and prove theorems such as normalization, consistency and injectivity of type constructors of MLTT using an untyped domain model. In the algorithmic component, we relate the declarative specification of typing and the model of normalization in the theoretical component with a functional implementation within Rocq. From this algorithmic component, we extract an OCaml implementation and couple it with a front-end parser for execution. This extracted OCaml code is comparable to what a skilled human programmer would have written and we have successfully used it to type-check a series of small-scale examples. McTT provides a fully verified kernel for a core MLTT with a full cumulative universe hierarchy. Every step in the compilation pipeline is verified except for the lexer and pretty-printer. As a result, McTT serves both as a framework to explore the meta-theory of advanced type theories and to investigate optimizations of and extensions to the type-checking kernel.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747511", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Junyoung", + "last_name": "Jang", + "institution": "McGill University" + }, + { + "first_name": "Antoine", + "last_name": "Gaulin", + "institution": "McGill University" + }, + { + "first_name": "Jason Z. S.", + "last_name": "Hu", + "institution": "Amazon (United States)" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "journals/pacmpl/0001GHP25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747506", + "title": "Frex: Dependently Typed Algebraic Simplification", + "abstract": "We present a new design for an algebraic simplification library structured around concepts from universal algebra: theories, models, homomorphisms, and universal properties of free algebras and free extensions of algebras. The library's dependently typed interface guarantees that both built-in and user-defined simplification modules are terminating, sound, and complete with respect to a well-specified class of equations. We have implemented the design in the Idris 2 and Agda dependently typed programming languages and shown that it supports modular extension to new theories, proof extraction and certification, goal extraction via reflection, and interactive development.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747506", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Allais", + "institution": "University of Strathclyde" + }, + { + "first_name": "Edwin", + "last_name": "Brady", + "institution": "University of St Andrews" + }, + { + "first_name": "Nathan", + "last_name": "Corbyn", + "institution": "University of Oxford" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jeremy", + "last_name": "Yallop", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/AllaisBCKY25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747513", + "title": "Bialgebraic Reasoning on Stateful Languages", + "abstract": "Reasoning about program equivalence in imperative languages is notoriously challenging, as the presence of states (in the form of variable stores) fundamentally increases the observational power of program terms. The key desideratum for any notion of equivalence is compositionality, guaranteeing that subprograms can be safely replaced by equivalent subprograms regardless of the context. To facilitate compositionality proofs and avoid boilerplate work, one would hope to employ the abstract bialgebraic methods provided by Turi and Plotkin’s powerful theory of mathematical operational semantics (a.k.a. abstract GSOS) or its recent extension by Goncharov et al. to higher-order languages. However, multiple attempts to apply abstract GSOS to stateful languages have thus failed. We propose a novel approach to the operational semantics of stateful languages based on the formal distinction between readers (terms that expect an initial input store before being executed), and writers (running terms that have already been provided with a store). In contrast to earlier work, this style of semantics is fully compatible with abstract GSOS, and we can thus leverage the existing theory to obtain coinductive reasoning techniques. We demonstrate that our approach generates non-trivial compositionality results for stateful languages with first-order and higher-order store and that it flexibly applies to program equivalences at different levels of granularity, such as trace, cost, and natural equivalence.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747513", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Sergey", + "last_name": "Goncharov", + "institution": "University of Birmingham" + }, + { + "first_name": "Stefan", + "last_name": "Milius", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Lutz", + "last_name": "Schröder", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Stelios", + "last_name": "Tsampas", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Henning", + "last_name": "Urbat", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + } + ], + "dblp_key": "journals/pacmpl/0001MS0U25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747526", + "title": "Fulls Seldom Differ", + "abstract": "Many programs process lists by recursing in a wide variety of sequential and/or divide-and-conquer patterns. Reasoning about the correctness and completeness of these programs requires reasoning about the lengths of the lists, techniques for which are typically undecidable or at least NP-complete. In this paper we show how introducing a relatively simple (sub-)language for expressions describing list lengths, whilst not completely general, covers a great number of these patterns. It includes not only doubling but also exponentiation (iterated doubling), and moreover admits a simple length-checking algorithm that is complete over a predictable problem domain. We prove termination of the algorithm via category-theoretic pullbacks, formalized in Agda, as well as providing a more realistic implementation in Rocq, and a toy language Fulbourn with interpreter in Haskell.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747526", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Mark", + "last_name": "Koch", + "institution": "Cambridge Quantum Computing (United Kingdom)" + }, + { + "first_name": "Alan", + "last_name": "Lawrence", + "institution": "Cambridge Quantum Computing (United Kingdom)" + }, + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" + }, + { + "first_name": "Craig", + "last_name": "Roy", + "institution": "Cambridge Quantum Computing (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/KochLMR25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747517", + "title": "Polynomial-Time Program Equivalence for Machine Knitting", + "abstract": "We present an algorithm that canonicalizes the algebraic representations of the topological semantics of machine knitting programs. Machine knitting is a staple technology of modern textile production where hundreds of mechanical needles are manipulated to form yarn into interlocking loop structures. Our semantics are defined using a variant of a monoidal category, and they closely correspond to string diagrams. We formulate our canonicalization as an Abstract Rewriting System (ARS) over words in our category, and prove that our algorithm is correct and runs in polynomial time.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747517", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nathan", + "last_name": "Hurtig", + "institution": "University of Washington" + }, + { + "first_name": "Jenny", + "last_name": "Lin", + "institution": "University of Utah" + }, + { + "first_name": "Thomas S.", + "last_name": "Price", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Adriana", + "last_name": "Schulz", + "institution": "University of Washington" + }, + { + "first_name": "James", + "last_name": "McCann", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Gilbert", + "last_name": "Bernstein", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/HurtigLPSMB25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747508", + "title": "Normalization by Evaluation for Non-cumulativity", + "abstract": "Normalization by evaluation (NbE) based on an untyped domain model is a convenient and powerful way to normalize terms to their βη normal forms. It enables a concise technical setup and simplicity for mechanization. Nevertheless, to date, untyped NbE has only been studied for cumulative universe hierarchies, and its correctness proof critically relies on the cumulativity of the system. Therefore, we are faced with the question: whether untyped NbE applies to a non-cumulative universe hierarchy? Because such a universe hierarchy is also widely used by proof assistants like Agda and Lean, this question is of practical significance. Our work answers this question positively. One important property typically induced from non-cumulativity is uniqueness : every term has a unique type. To faithfully reflect the uniqueness property, we work with a Martin-L'of type theory with explicit universe levels ascribed in the syntactic judgments. On the semantic side, universe levels are also explicitly managed, which leads to more complex semantics compared with a cumulative universe hierarchy. We prove that the NbE algorithm is sound and complete, and confirm that NbE does work with non-cumulativity. Moreover, to better align with common practice, we also show that the explicit annotations of universe levels, though technically useful, are logically redundant: NbE remains applicable without these annotations. As such, we provide a mechanized foundation with NbE for non-cumulativity.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747508", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Shengyi", + "last_name": "Jiang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Jason Z. S.", + "last_name": "Hu", + "institution": "Amazon (United States)" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/JiangHO25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747507", + "title": "Robust Dynamic Embedding for Gradual Typing", + "abstract": "Gradual typing has long been advocated as a means to bridge the gap between static and dynamic typing disciplines, enabling a range of use cases such as the gradual migration of existing dynamically typed code to more statically typed code, as well as making advanced static typing disciplines more accessible. To assess whether a given gradual language can effectively support these use cases, several formal properties have been proposed, most notably the refined criteria set forth by Siek et al. One criterion asserts that the dynamic extreme of the spectrum should be expressible in the gradual language, formalized by the existence of an adequate embedding from the corresponding dynamic language. We observe that the existing dynamic embedding criterion does not capture the desirable property of being able to ascribe embedded code to a static type that it semantically satisfies, and ensure reliable interactions with other components within the gradual language. Specifically, we introduce the notion of robustness for gradual terms, meaning that when interacting with any gradual context, runtime failures that may occur ought to be caused by the context, not by the robust term itself. We then formulate the robust dynamic embedding criterion: if a dynamic component semantically satisfies a given static type, then its embedding subsequently ascribed to that static type should be a robust term. We demonstrate that robust dynamic embedding is not implied by any existing metatheoretical property from the literature, and is not upheld by various existing gradual languages. We show that robust dynamic embedding is achievable with a gradualized simply-typed language. All the results are formalized in the Rocq proof assistant. This novel criterion complements the set of criteria for gradual languages and opens several venues for further exploration, in particular for typing disciplines that enforce rich semantic properties.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747507", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Koen", + "last_name": "Jacobs", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/JacobsTTT25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747535", + "title": "Type Theory in Type Theory using a Strictified Syntax", + "abstract": "The metatheory of dependent types has seen a lot of progress in recent years. In particular, the development of categorical gluing finally lets us work with semantic presentations of type theory (such as categories with families) to establish fundamental properties of type theory such as canonicity and normalisation. However, proofs by gluing have yet to reach the stage of computer formalisation: formal proofs for the metatheory of dependent types are still stuck in the age of tedious syntactic proofs. The main reason for this is that semantic presentations of type theory are defined using sophisticated indexed inductive types, which are especially prone to \"transport hell\". In this paper, we introduce a new technique to work with CwFs in intensional type theory without getting stuck in transport hell. More specifically, we construct an alternative presentation of the initial CwF which encodes the substitutions as metatheoretical functions. This has the effect of strictifying all the equations that are involved in the substitution calculus, which greatly reduces the need for transports. As an application, we use our strictified initial CwF to give a short and elegant proof of canonicity for a type theory with dependent products and booleans with large elimination. The resulting proof is fully formalised in Agda.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747535", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ambrus", + "last_name": "Kaposi", + "institution": "Eötvös Loránd University" + }, + { + "first_name": "Loïc", + "last_name": "Pujet", + "institution": "Stockholm University" + } + ], + "dblp_key": "journals/pacmpl/KaposiP25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747533", + "title": "Teaching Software Specification (Experience Report)", + "abstract": "A course on software specification deserves a prominent place in the undergraduate curriculum. This report describes our experience teaching a first-year course that places software specification front and center. In support of the course, we created a pedagogic programming language with a focus on contracts and property-based testing. Assignments draw on real-world programs, from a variety of domains, that are intended to show how formal specification can increase confidence in the correctness of code. Interviews with students suggest that this approach successfully conveys how formal specification is relevant to software construction.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747533", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Cameron", + "last_name": "Moy", + "institution": "Northeastern University" + }, + { + "first_name": "Daniel", + "last_name": "Patterson", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/Moy025", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747529", + "title": "Multiple Resumptions and Local Mutable State, Directly", + "abstract": "While enabling use cases such as backtracking search and probabilistic programming, multiple resumptions have the reputation of being incompatible with efficient implementation techniques, such as stack switching. This paper sets out to resolve this conflict and thus bridge the gap between expressiveness and performance. To this end, we present a compilation strategy and runtime system for lexical effect handlers with support for multiple resumptions and stack-allocated mutable state. By building on garbage-free reference counting and associating stacks with stable prompts, our approach enables constant-time continuation capture and resumption when resumed exactly once, as well as constant-time state access. Nevertheless, we also support multiple resumptions by copying stacks when necessary. We practically evaluate our approach by implementing an LLVM backend for the Effekt language. A performance comparison with state-of-the-art systems, including dynamic and lexical effect handler implementations, suggests that our approach achieves competitive performance and the increased expressiveness only comes with limited overhead.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747529", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Serkan", + "last_name": "Muhcu", + "institution": "Technische Universität Berlin" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "Technische Universität Berlin" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/MuhcuSSB25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747525", + "title": "Functional Networking for Millions of Docker Desktops (Experience Report)", + "abstract": "Docker is a developer tool used by millions of developers to build, share and run software stacks. The Docker Desktop clients for Mac and Windows have long used a novel combination of virtualisation and OCaml unikernels to seamlessly run Linux containers on these non-Linux hosts. We reflect on a decade of shipping this functional OCaml code into production across hundreds of millions of developer desktops, and discuss the lessons learnt from our experiences in integrating OCaml deeply into the container architecture that now drives much of the global cloud. We conclude by observing just how good a fit for systems programming that the unikernel approach has been, particularly when combined with the OCaml module and type system.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747525", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Anil", + "last_name": "Madhavapeddy", + "institution": "University of Cambridge" + }, + { + "first_name": "David J.", + "last_name": "Scott", + "institution": "Wacker (United States)" + }, + { + "first_name": "Patrick", + "last_name": "Ferris", + "institution": "University of Cambridge" + }, + { + "first_name": "Ryan", + "last_name": "Gibb", + "institution": "University of Cambridge" + }, + { + "first_name": "Thomas", + "last_name": "Gazagnaire", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/MadhavapeddySFG25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747534", + "title": "Compiling with Generating Functions", + "abstract": "We present a new approach to scaling exact inference for probabilistic programs, using generating functions (GFs) as a compilation target. Existing methods that target representations like binary decision diagrams (BDDs) achieve strong state-of-the-art results. We show that a compiler targeting GFs can be similarly competitive—and, in some cases, more scalable—on a range of inference problems where BDD-based methods perform well. We present a formal model of this compiler, providing the first definition of GF compilation for a functional probabilistic language. We prove that this compiler is correct with respect to a denotational semantics. Our approach is implemented in a probabilistic programming system and evaluated on a range of inference problems. Our results establish GF compilation as a principled and powerful paradigm for exact inference: it offers strong scalability, good expressiveness, and a solid theoretical foundation.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747534", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Jianlin", + "last_name": "Li", + "institution": "University of Waterloo" + }, + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/Li025", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747536", + "title": "Pushing the Information-Theoretic Limits of Random Access Lists: Traversing Cons Lists in (1 + 1/𝜎 ) ⌊lg 𝑛⌋ + 𝜎 + 9 Steps", + "abstract": "Accessing an arbitrary element of a singly linked list or cons list requires traversing up to a linear number of pointers. The applicative random-access list is a data structure that behaves like a cons list except that accessing an arbitrary element traverses only a logarithmic number of pointers. Specifically, in a list of length n , an arbitrary element can be accessed by traversing at most 3⌈lg n ⌉−5 pointers. In this paper, we present a simple variation on random-access lists that improves this bound and requires traversing at most 2⌈lg( n +1)⌉− 3 pointers. We then present a more complicated variation that improves this bound to (1+1/σ)⌊lg n ⌋+σ+9 for any σ≥ 1. This shows that it is possible to get asymptotically close to the information-theoretically optimal bound of ⌈lg( n +1)⌉−1.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747536", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Edward", + "last_name": "Peters", + "institution": "Eugene Research Institute" + }, + { + "first_name": "Yong Qi", + "last_name": "Foo", + "institution": "National University of Singapore" + }, + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/PetersF025", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747532", + "title": "Type Universes as Kripke Worlds", + "abstract": "What are mutable references; what do they mean? The answers to these questions have spawned lots of important theoretical work and form the foundation of many impactful tools. However, existing semantics collapse a key distinction: which allocations does a reference depend on? In this paper, we deconstruct the space of mutable higher-order references. We formalize a novel distinction—splitting the design space of references not only into higher-order vs (full-)ground references, but also dependency of an allocation on past vs future allocations. This distinction is fundamental to a thorny issue that arises in constructing semantic models of mutable references—the type-world circularity. The issue disappears for what we call predicative references, those that only quantify over past, not future, allocations, and for non-higher-order impredicative references. We design a syntax and semantics for each point in our newly described space. The syntax relies on a type universe hierarchy, à la dependent type theory, to kind the types of allocated terms, and stratify allocations. Each type universe corresponds to a semantic Kripke world, giving a lightweight syntactic mechanism to design and restrict heap shapes. The semantics bear a resemblance to work on regions, and suggest some connection between universe systems and regions, which we describe in some detail.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747532", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Paulette", + "last_name": "Koronkevich", + "institution": "University of British Columbia" + }, + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/KoronkevichB25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747530", + "title": "First-Order Laziness", + "abstract": "In strict languages, laziness is typically modeled with explicit thunks that defer a computation until needed and memoize the result. Such thunks are implemented using a closure. Implementing lazy data structures using thunks thus has several disadvantages: closures cannot be printed or inspected during debugging; allocating closures requires additional memory, sometimes leading to poor performance; reasoning about the performance of such lazy data structures is notoriously subtle. These complications prevent wider adoption of lazy data structures, even in settings where they should shine. In this paper, we introduce lazy constructors as a simple first-order alternative to lazy thunks. Lazy constructors enable the thunks of a lazy data structure to be defunctionalized, yielding implementations of lazy data structures that are not only significantly faster but can easily be inspected for debugging.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747530", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Anton", + "last_name": "Lorenzen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wouter", + "last_name": "Swierstra", + "institution": "Utrecht University" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/LorenzenLSL25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747514", + "title": "Modular Reasoning about Error Bounds for Concurrent Probabilistic Programs", + "abstract": "We present Coneris, the first *higher-order concurrent separation logic* for reasoning about error probability bounds of higher-order concurrent probabilistic programs with higher-order state. To support modular reasoning about concurrent (non-probabilistic) program modules, state-of-the-art program logics internalize the classic notion of linearizability within the logic through the concept of *logical atomicity*. Coneris extends this idea to probabilistic concurrent program modules. Thus Coneris supports modular reasoning about probabilistic concurrent modules by capturing a novel notion of *randomized logical atomicity* within the logic. To do so, Coneris utilizes *presampling tapes* and a novel *probabilistic update modality* to describe how state is changed probabilistically at linearization points. We demonstrate this approach by means of smaller synthetic examples and larger case studies. All of the presented results, including the meta-theory, have been mechanized in the Rocq proof assistant and the Iris separation logic framework.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747514", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Kwing Hei", + "last_name": "Li", + "institution": "Aarhus University" + }, + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "New York University" + }, + { + "first_name": "Philipp G.", + "last_name": "Haselwarter", + "institution": "Aarhus University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/Li0GHTB25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747515", + "title": "Reasoning about Weak Isolation Levels in Separation Logic", + "abstract": "Consistency guarantees among concurrently executing transactions in local- and distributed systems, commonly referred to as isolation levels, have been formalized in a number of models. Thus far, no model can reason about executable implementations of databases or local transaction libraries providing weak isolation levels. Weak isolation levels are characterized by being highly concurrent and, unlike their stronger counterpart serializability, they are not equivalent to the consistency guarantees provided by a transaction library implemented using a global lock. Industrial-strength databases almost exclusively implement weak isolation levels as their default level. This calls for formalism as numerous bugs violating isolation have been detected in these databases. In this paper, we formalize three weak isolation levels in separation logic, namely read uncommitted , read committed , and snapshot isolation . We define modular separation logic specifications that are independent of the underlying transaction library implementation. Historically, isolation levels have been specified using examples of executions between concurrent transactions that are not allowed to occur, and we demonstrate that our specifications correctly prohibit such examples. To show that our specifications are realizable, we formally verify that an executable implementation of a key-value database running the multi-version concurrency control algorithm from the original snapshot isolation paper satisfies our specification of snapshot isolation. Moreover, we prove implications between the specifications—snapshot isolation implies read committed and read committed implies read uncommitted—and thus the verification effort of the database serves as proof that all of our specifications are realizable. All results are mechanized in the Rocq proof assistant on top of the Iris separation logic framework.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747515", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Anders Alnor", + "last_name": "Mathiasen", + "institution": "Aarhus University" + }, + { + "first_name": "Léon", + "last_name": "Gondelman", + "institution": "Aalborg University" + }, + { + "first_name": "Léon", + "last_name": "Ducruet", + "institution": "Aarhus University" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/MathiasenGDTB25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747528", + "title": "CRDT Emulation, Simulation, and Representation Independence", + "abstract": "Conflict-free replicated data types (CRDTs) are distributed data structures designed for fault tolerance and high availability. CRDTs have historically been taxonomized into state-based CRDTs, in which replicas apply updates locally and periodically broadcast their state to other replicas over the network, and operation-based (or op-based ) CRDTs, in which every state-updating operation is individually broadcast. In the literature, state-based and op-based CRDTs are considered equivalent due to the existence of algorithms that let them emulate each other, and verification techniques and results that apply to one kind of CRDT are said to apply to the other thanks to this equivalence. However, what it means for state-based and op-based CRDTs to emulate each other has never been made fully precise. Emulation is nontrivial since state-based and op-based CRDTs place different requirements on the underlying network with regard to both the causal ordering of message delivery, and the granularity of the messages themselves. We specify and formalize CRDT emulation in terms of simulation by modeling CRDTs and their interactions with the network as transition systems. We show that emulation can be understood as weak simulations between the transition systems of the original and emulating CRDT systems, thus closing a gap in the CRDT literature. We precisely characterize which properties of CRDT systems are preserved by our weak simulations, and therefore which properties can be said to be preserved by emulation algorithms. Finally, we leverage our emulation results to obtain a general representation independence result for CRDTs: intuitively, clients of a CRDT cannot tell whether they are interacting with a state-based or op-based CRDT in particular.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747528", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Nathan", + "last_name": "Liittschwager", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Jonathan", + "last_name": "Castello", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Stelios", + "last_name": "Tsampas", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "journals/pacmpl/LiittschwagerC025", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747538", + "title": "Relax! The Semilenient Core of Choreographic Programming (Functional Pearl)", + "abstract": "The past few years have seen a surge of interest in choreographic programming, a programming paradigm for concurrent and distributed systems. The paradigm allows programmers to implement a distributed interaction protocol with a single high-level program, called a choreography , and then mechanically project it into correct implementations of its participating processes. A choreography can be expressed as a λ-term parameterized by constructors for creating data “at” a process and for communicating data between processes. Through this lens, recent work has shown how one can add choreographies to mainstream languages like Java, or even embed choreographies as a DSL in languages like Haskell and Rust. These new choreographic languages allow programmers to write in applicative style (like in functional programming) and write higher-order choreographies for better modularity. But the semantics of functional choreographic languages is not well-understood. Whereas typical λ-calculi can have their operational semantics defined with just a few rules, existing models for choreographic λ-calculi have dozens of complex rules and no clear or agreed-upon evaluation strategy . We show that functional choreographic programming is simple. Beginning with the Chorλ model from previous work, we strip away inessential features to produce a “core” model called λ χ . We discover that underneath Chorλ’s apparently ad-hoc semantics lies a close connection to non-strict λ-calculi; we call the resulting evaluation strategy semilenient . Then, inspired by previous non-strict calculi, we develop a notion of choreographic evaluation contexts and a special commute rule to simplify and explain the unusual semantics of functional choreographic languages. The extra structure leads us to a presentation of λ χ with just ten rules, and a discovery of three missing rules in previous presentations of Chorλ. We also show how the extra structure comes with nice properties, which we use to simplify the correspondence proof between choreographies and their projections. Our model serves as both a principled foundation for functional choreographic languages and a good entry point for newcomers.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747538", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Dan", + "last_name": "Plyukhin", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Xueying", + "last_name": "Qin", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Fabrizio", + "last_name": "Montesi", + "institution": "University of Southern Denmark" + } + ], + "dblp_key": "journals/pacmpl/PlyukhinQM25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747524", + "title": "Correctness Meets Performance: From Agda to Futhark", + "abstract": "In this paper we demonstrate a technique for developing high performance applications with strong correctness guarantees. Using a theorem prover, we derive a high-level specification of the application that includes correctness invariants of our choice. After that, within the same theorem prover, we implement an extraction of the specified application into a high-performance language of our choice. Concretely, we are using Agda to specify a framework for automatic differentiation (reverse mode) that is focused on index-safe tensors. This framework comes with an optimiser for tensor expressions and the ability to translate these expressions into Futhark. We specify a canonical convolutional neural network within the proposed framework, compute the derivatives needed for the training phase and then demonstrate that the generated code approaches the performance of TensorFlow code when running on a GPU.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747524", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Artjoms", + "last_name": "Šinkarovs", + "institution": "University of Southampton" + }, + { + "first_name": "Troels", + "last_name": "Henriksen", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/SinkarovsH25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747519", + "title": "Fusing Session-Typed Concurrent Programming into Functional Programming", + "abstract": "We introduce FuSes, a Functional programming language that integrates Session-typed concurrent process calculus code. A functional layer sits on top of a session-typed process layer. To generate and reason about open session-typed processes, the functional layer uses the contextual box modality extended with linear channel contexts. Due to the fundamental differences between the operational semantics of the functional layer and the concurrent semantics of processes, we bridge the two layers using a set of primitives to run and observe the behavior of closed processes within the functional layer. In addition, FuSes supports code analysis and manipulation of open session-typed process code. To showcase its benefit to programmers we implement well-known optimizations as type-safe metaprograms over concurrent processes such as batch optimizations. Our technical contributions include a type system for FuSes, an operational semantics, a proof of its type safety, and its implementation.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747519", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Chuta", + "last_name": "Sano", + "institution": "McGill University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ryan", + "last_name": "Kavanagh", + "institution": "Université du Québec à Montréal" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + }, + { + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "University of Lisbon" + } + ], + "dblp_key": "journals/pacmpl/Sano0KPT25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747509", + "title": "Formal Semantics and Program Logics for a Fragment of OCaml", + "abstract": "This paper makes a first step towards a formal definition of OCaml and a foundational program verification environment for OCaml. We present a formal definition of OLang, a nontrivial sequential fragment of OCaml, which includes first-class functions, ordinary and extensible algebraic data types, pattern matching, references, exceptions, and effect handlers. We define the dynamic semantics of OLang as a monadic interpreter. This interpreter runs atop a custom monad where computations are internally represented as trees of operations and equipped with a small-step semantics. We define two program logics for OLang. A stateless Hoare Logic allows reasoning about so-called \"pure\" programs; an Iris-based Separation Logic allows reasoning about arbitrary programs. We present the construction of the two logics as well as some examples of their use.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747509", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Remy", + "last_name": "Seassau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Irene", + "last_name": "Yoon", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jean-Marie", + "last_name": "Madiot", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/Seassau0MP25", + "venue": "icfp", + "year": 2025 + }, + { + "paper_id": "10.1145/3747523", + "title": "Effectful Lenses: There and Back with Different Monads", + "abstract": "Bidirectional transformations (BXs) are a widely adopted approach for data synchronisation that is usually based on two functions, one from the source to the view and one back. Traditionally, these functions must not have side effects. While a few frameworks aim to lift this restriction by introducing monads into lenses, they are still quite limited, e.g., allowing only side effects in the backwards transformation. In this paper, we propose a much more general framework for effectful lenses. Our effectful lenses can have different effects in their two directions, and the effects need not be cancellable. We also define the round-trip relations and use them to generalise the two well-known round-trip properties to effectful lenses. Moreover, composition preserves the two well-known round-trip properties, and we also provide a rich combinator language, which enables compositional programming for effectful lenses. Finally, we present a case study to illustrate the flexibility and expressivity of our framework.", + "date": "2025-08-05", + "link": "https://doi.org/10.1145/3747523", + "conference_name": "ICFP", + "authors": [ + { + "first_name": "Ruifeng", + "last_name": "Xie", + "institution": "Peking University" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/XieS025", + "venue": "icfp", + "year": 2025 + } +] \ No newline at end of file From 3ca7295f68cf2361d57e99596c13965e969043c5 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:33:15 +0200 Subject: [PATCH 10/34] feat: harvest DBLP TOCs via static XML, falling back to search API MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit DBLP's search API at /search/publ/api throttles aggressively under sustained load — empirically a single venue's 40-year backfill can trip a 30+ minute IP-level rate limit that no exponential backoff works around. The static '.xml' TOC files at db/conf//.xml and db/journals/pacmpl/pacmpl.xml carry the same fields (DOI, title, authors, key, year, PACMPL number) and are not subject to the search-API rate limit. Parse the static XML for each TOC, convert to the search-API 'info' shape so the rest of the pipeline is unchanged, and fall back to the search API only if the static fetch fails. The on-disk cache key is shared between the two paths, so subsequent runs hit cache regardless of which path produced the data. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 188 +++++++++++++++++++++---- 1 file changed, 162 insertions(+), 26 deletions(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index 418a920..24a11fa 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -561,36 +561,58 @@ def _fetch_dblp_entries( yield info def _fetch_dblp_toc_papers(self, toc: TOCEntry) -> Iterator[dict[str, Any]]: - """Yield raw DBLP ``info`` dicts for a single TOC entry.""" + """Yield raw DBLP ``info`` dicts for a single TOC entry. + + Tries the static ``.xml`` TOC file first (it's served from a CDN + with no rate-limiting). Falls back to the search API only if the + static fetch fails — historically the search API is the first + thing DBLP throttles under load, so we keep it as a backup not + the primary path. + """ cache_key = self._dblp_toc_cache_key(toc) cached = self._cache_load(cache_key) if cached is not None: payload = cached - else: - # Query the search API faceted on the TOC. Add the PACMPL - # ``number`` token (e.g. "POPL") to disambiguate when the same - # TOC bundles several venues. - query_terms = [f"toc:{toc.bht}:"] - if toc.pacmpl_number is not None: - query_terms.append(toc.pacmpl_number) - url = "https://dblp.org/search/publ/api" - params = { - "q": " ".join(query_terms), - "format": "json", - "h": 1000, - "f": 0, - } - with _DBLP_CONCURRENCY: - _pace_dblp() - resp = _request_with_retries( - self._thread_session(), url, params=params, timeout=30 - ) - resp.raise_for_status() - if self.request_delay_s: - time.sleep(self.request_delay_s) - payload = resp.json() - self._cache_store(cache_key, payload) + yield from self._iter_search_api_hits(toc, payload) + return + + # Primary path: static XML TOC. Same DOIs, faster, no rate limit. + try: + yield from self._fetch_dblp_toc_papers_via_xml(toc) + return + except requests.RequestException as exc: + logger.warning( + "Static XML fetch failed for %s (%s); falling back to search API", + toc.bht, + exc, + ) + + # Fallback: search API. + query_terms = [f"toc:{toc.bht}:"] + if toc.pacmpl_number is not None: + query_terms.append(toc.pacmpl_number) + url = "https://dblp.org/search/publ/api" + params = { + "q": " ".join(query_terms), + "format": "json", + "h": 1000, + "f": 0, + } + with _DBLP_CONCURRENCY: + _pace_dblp() + resp = _request_with_retries( + self._thread_session(), url, params=params, timeout=30 + ) + resp.raise_for_status() + if self.request_delay_s: + time.sleep(self.request_delay_s) + payload = resp.json() + self._cache_store(cache_key, payload) + yield from self._iter_search_api_hits(toc, payload) + def _iter_search_api_hits( + self, toc: TOCEntry, payload: dict[str, Any] + ) -> Iterator[dict[str, Any]]: hits = payload.get("result", {}).get("hits", {}) total = int(hits.get("@total", 0)) sent = int(hits.get("@sent", 0)) @@ -598,7 +620,6 @@ def _fetch_dblp_toc_papers(self, toc: TOCEntry) -> Iterator[dict[str, Any]]: raise RuntimeError( f"DBLP returned {sent}/{total} hits for {toc.bht} — bump 'h' parameter." ) - for hit in hits.get("hit", []): info = hit.get("info", {}) # Defensive filter: PACMPL TOCs cover multiple venues, so the @@ -613,6 +634,39 @@ def _fetch_dblp_toc_papers(self, toc: TOCEntry) -> Iterator[dict[str, Any]]: continue yield info + def _fetch_dblp_toc_papers_via_xml(self, toc: TOCEntry) -> Iterator[dict[str, Any]]: + """Fetch the static ``.xml`` and yield search-API-shaped dicts. + + DBLP's static TOC XML files (``db/conf/.../*.xml`` and + ``db/journals/pacmpl/*.xml``) are not behind the search API's + rate limiter and are nearly always available even when the + search API is throttling. + """ + # The cache key is the same one the search-API path uses; store + # the converted entries under it so cache lookups on subsequent + # runs short-circuit either path. + xml_url = f"https://dblp.org/{toc.bht.removesuffix('.bht')}.xml" + with _DBLP_CONCURRENCY: + _pace_dblp() + resp = _request_with_retries(self._thread_session(), xml_url, timeout=30) + resp.raise_for_status() + if self.request_delay_s: + time.sleep(self.request_delay_s) + entries = list(_parse_dblp_toc_xml(resp.text, toc)) + # Convert to a search-API-shaped payload so the on-disk cache is + # interchangeable between the two paths. + synthetic_payload = { + "result": { + "hits": { + "@total": str(len(entries)), + "@sent": str(len(entries)), + "hit": [{"info": e} for e in entries], + } + } + } + self._cache_store(self._dblp_toc_cache_key(toc), synthetic_payload) + yield from entries + def _dblp_toc_cache_key(self, toc: TOCEntry) -> str: bht_safe = _safe_filename(toc.bht) suffix = toc.pacmpl_number or "main" @@ -814,6 +868,88 @@ def _reconstruct_abstract(inverted_index: dict[str, list[int]]) -> str: return " ".join(word for _, word in positions) +# Match a complete ... or +#
...
block. Pure regex (rather than ET) because +# the wrapper document is not strict XML — it embeds raw HTML elements +# like ``

``, ``

`` outside any namespace. +_DBLP_PAPER_RE = re.compile( + r"<(?Pinproceedings|article)\s+([^>]*?)>(?P.*?)", + re.IGNORECASE | re.DOTALL, +) + + +def _parse_dblp_toc_xml(xml_text: str, toc: TOCEntry) -> Iterator[dict[str, Any]]: + """Convert a DBLP static TOC XML into search-API-shaped ``info`` dicts. + + The static XML at ``db/conf//.xml`` and + ``db/journals/pacmpl/pacmpl.xml`` carries the same fields + we need (title, DOI, authors, key, year), but is served as files + rather than through the search API and is therefore not throttled. + + For PACMPL volumes, ``toc.pacmpl_number`` filters the multi-venue + bundle down to the requested venue (POPL/PLDI/ICFP/OOPSLA[12]). + + Returns dicts with the same shape ``_build_paper`` expects: + ``{title, doi, key, authors: {author: [{text}]}, year, number?}``. + """ + for m in _DBLP_PAPER_RE.finditer(xml_text): + attrs = _parse_xml_attrs(m.group(2)) + body = m.group("body") + + title_match = re.search( + r"(.*?)", body, re.DOTALL | re.IGNORECASE + ) + title = (title_match.group(1).strip() if title_match else "").rstrip(".") + + # Year/number/booktitle inform PACMPL discrimination. + year_match = re.search(r"(\d{4})", body, re.IGNORECASE) + year = year_match.group(1) if year_match else "" + number_match = re.search(r"([^<]+)", body, re.IGNORECASE) + number = number_match.group(1).strip() if number_match else None + booktitle_match = re.search( + r"([^<]+)", body, re.IGNORECASE + ) + booktitle = booktitle_match.group(1).strip() if booktitle_match else None + + # PACMPL TOCs bundle multiple venues. Restrict to the one we asked for. + if toc.pacmpl_number is not None and number != toc.pacmpl_number: + continue + + # First DOI , if any. + doi: str | None = None + for ee_match in re.finditer(r"]*>([^<]+)", body, re.IGNORECASE): + ee_url = ee_match.group(1).strip() + if ee_url.startswith("https://doi.org/"): + doi = ee_url[len("https://doi.org/") :] + break + if ee_url.startswith("http://doi.org/"): + doi = ee_url[len("http://doi.org/") :] + break + + authors: list[dict[str, str]] = [] + for author_match in re.finditer( + r"]*>([^<]+)", body, re.IGNORECASE + ): + name = author_match.group(1).strip() + if name: + authors.append({"text": name}) + + info: dict[str, Any] = { + "key": attrs.get("key", ""), + "title": title, + "year": year, + "authors": {"author": authors} if authors else {}, + } + if doi is not None: + info["doi"] = doi + if number is not None: + info["number"] = number + if booktitle is not None: + info["venue"] = booktitle + + yield info + + def _openalex_authors(work: dict[str, Any]) -> list[dict[str, str]]: out: list[dict[str, str]] = [] for authorship in work.get("authorships", []) or []: From 36c742c320ca2db490c921b7086286f578da6d4e Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:39:02 +0200 Subject: [PATCH 11/34] feat: ingest OOPSLA back-catalogue (1986-2008, partial) 23 of ~40 years of OOPSLA proceedings harvested. DBLP rate-limited the IP after 2008; remaining years (2009-2025) will follow in a subsequent commit once the rate limit clears. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/oopsla/1986.json | 971 +++++++++ data/pl_conferences/oopsla/1987.json | 959 +++++++++ data/pl_conferences/oopsla/1988.json | 727 +++++++ data/pl_conferences/oopsla/1989.json | 1080 ++++++++++ data/pl_conferences/oopsla/1990.json | 808 ++++++++ data/pl_conferences/oopsla/1991.json | 645 ++++++ data/pl_conferences/oopsla/1992.json | 879 ++++++++ data/pl_conferences/oopsla/1993.json | 968 +++++++++ data/pl_conferences/oopsla/1994.json | 949 +++++++++ data/pl_conferences/oopsla/1995.json | 1107 ++++++++++ data/pl_conferences/oopsla/1996.json | 978 +++++++++ data/pl_conferences/oopsla/1997.json | 814 ++++++++ data/pl_conferences/oopsla/1998.json | 789 +++++++ data/pl_conferences/oopsla/1999.json | 802 ++++++++ data/pl_conferences/oopsla/2000.json | 730 +++++++ data/pl_conferences/oopsla/2001.json | 738 +++++++ data/pl_conferences/oopsla/2002.json | 647 ++++++ data/pl_conferences/oopsla/2003.json | 2436 ++++++++++++++++++++++ data/pl_conferences/oopsla/2004.json | 2861 ++++++++++++++++++++++++++ data/pl_conferences/oopsla/2005.json | 898 ++++++++ data/pl_conferences/oopsla/2006.json | 937 +++++++++ data/pl_conferences/oopsla/2007.json | 994 +++++++++ data/pl_conferences/oopsla/2008.json | 1055 ++++++++++ 23 files changed, 23772 insertions(+) create mode 100644 data/pl_conferences/oopsla/1986.json create mode 100644 data/pl_conferences/oopsla/1987.json create mode 100644 data/pl_conferences/oopsla/1988.json create mode 100644 data/pl_conferences/oopsla/1989.json create mode 100644 data/pl_conferences/oopsla/1990.json create mode 100644 data/pl_conferences/oopsla/1991.json create mode 100644 data/pl_conferences/oopsla/1992.json create mode 100644 data/pl_conferences/oopsla/1993.json create mode 100644 data/pl_conferences/oopsla/1994.json create mode 100644 data/pl_conferences/oopsla/1995.json create mode 100644 data/pl_conferences/oopsla/1996.json create mode 100644 data/pl_conferences/oopsla/1997.json create mode 100644 data/pl_conferences/oopsla/1998.json create mode 100644 data/pl_conferences/oopsla/1999.json create mode 100644 data/pl_conferences/oopsla/2000.json create mode 100644 data/pl_conferences/oopsla/2001.json create mode 100644 data/pl_conferences/oopsla/2002.json create mode 100644 data/pl_conferences/oopsla/2003.json create mode 100644 data/pl_conferences/oopsla/2004.json create mode 100644 data/pl_conferences/oopsla/2005.json create mode 100644 data/pl_conferences/oopsla/2006.json create mode 100644 data/pl_conferences/oopsla/2007.json create mode 100644 data/pl_conferences/oopsla/2008.json diff --git a/data/pl_conferences/oopsla/1986.json b/data/pl_conferences/oopsla/1986.json new file mode 100644 index 0000000..1f317e4 --- /dev/null +++ b/data/pl_conferences/oopsla/1986.json @@ -0,0 +1,971 @@ +[ + { + "paper_id": "10.1145/28697.28702", + "title": "Encapsulation and Inheritance in Object-Oriented Programming Languages", + "abstract": "Object-oriented programming is a practical and useful programming methodology that encourages modular design and software reuse. Most object-oriented programming languages support data abstraction by preventing an object from being manipulated except via its defined external operations. In most languages, however, the introduction of inheritance severely compromises the benefits of this encapsulation. Furthermore, the use of inheritance itself is globally visible in most languages, so that changes to the inheritance hierarchy cannot be made safely. This paper examines the relationship between inheritance and encapsulation and develops requirements for full support of encapsulation with inheritance.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28702", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alan", + "last_name": "Snyder", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/Snyder86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28734", + "title": "A Diagram for Object-Oriented Programs", + "abstract": "We introduce a notation for diagramming the message sending dialogue that takes place between objects participating in an object-oriented computation. Our representation takes a global point of view which emphasizes the collaboration between objects implementing the behavior of individuals. We illustrate the diagram's usage with examples drawn from the Smalltalk-80™ virtual image. We also describe a mechanism for automatic construction of diagrams from Smalltalk code.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28734", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ward", + "last_name": "Cunningham", + "institution": "" + }, + { + "first_name": "Kent", + "last_name": "Beck", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/CunninghamB86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28698", + "title": "Object-Oriented Programming with Flavors", + "abstract": "This paper describes Symbolics' newly redesigned object-oriented programming system, Flavors. Flavors encourages program modularity, eases the development of large, complex programs, and provides high efficiency at run time. Flavors is integrated into Lisp and the Symbolics program development environment. This paper describes the philosophy and some of the major characteristics of Symbolics' Flavors and shows how the above goals are addressed. Full details of Flavors are left to the programmers' manual, Reference Guide to Symbolics Common Lisp. (5)", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28698", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David A.", + "last_name": "Moon", + "institution": "Association for Symbolic Logic" + } + ], + "dblp_key": "conf/oopsla/Moon86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28732", + "title": "A Simple Technique for Handling Multiple Polymorphism", + "abstract": "Certain situations arise in programming that lead to multiply polymorphic expressions, that is, expressions in which several terms may each be of variable type. In such situations, conventional object-oriented programming practice breaks down, leading to code which is not properly modular. This paper describes a simple approach to such problems which preserves all the benefits of good object-oriented programming style in the face of any degree of polymorphism. An example is given in Smalltalk-80 syntax, but the technique is relevant to all object-oriented languages.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28732", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel H. H.", + "last_name": "Ingalls", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/oopsla/Ingalls86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28724", + "title": "A Smalltalk System for Algebraic Manipulation", + "abstract": "This paper describes the design of an algebra system Views implemented in Smalltalk. Views contains facilities for dynamic creation and manipulation of computational domains, for viewing these domains as various categories such as groups, rings, or fields, and for expressing algorithms generically at the level of categories. The design of Views has resulted in the addition of some new abstractions to Smalltalk that are quite useful in their own right. Parameterized classes provide a means for run-time creation of new classes that exhibit generally very similar behavior, differing only in minor ways that can be described by different instantiations of certain parameters. Categories allow the abstraction of the common behavior of classes that derives from the class objects and operations satisfying certain laws independently of the implementation of those objects and operations. Views allow the run-time association of classes with categories (and of categories with other categories), facilitating the use of code written for categories with quite different interpretations of operations. Together, categories and views provide an additional mechanism for code sharing that is richer than both single and multiple inheritance. The paper gives algebraic as well as non-algebraic examples of the above-mentioned features.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28724", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "S. Kamal", + "last_name": "Abdali", + "institution": "" + }, + { + "first_name": "Guy W.", + "last_name": "Cherry", + "institution": "" + }, + { + "first_name": "Neil", + "last_name": "Soffer", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/AbdaliCS86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28711", + "title": "Quicktalk: A Smalltalk-80 Dialect for Defining Primitive Methods", + "abstract": "QUICKTALK is a dialect of Smalltalk-80 that can be compiled directly into native machine code, instead of virtual machine bytecodes. The dialect includes “hints” on the class of method arguments, instance variables, and class variables. We designed the dialect to describe primitive Smalltalk methods. QUICKTALK achieves improved performance over bytecodes by eliminating the interpreter loop on bytecode execution, by reducing the number of message send/returns via binding some target methods at compilation, and by eliminating redundant class checking. We identify changes to the Smalltalk-80 system and compiler to support the dialect, and give performance measurements.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28711", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mark B.", + "last_name": "Ballard", + "institution": "Oregon Social Learning Center" + }, + { + "first_name": "David", + "last_name": "Maier", + "institution": "Oregon Social Learning Center" + }, + { + "first_name": "Allen", + "last_name": "Wirfs-Brock", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BallardMW86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28728", + "title": "Type-Checking Smalltalk", + "abstract": "Although most attempts to speed-up Smalltalk have focused on providing more efficient interpreters, code optimization is probably necessary for further increases in speed. A type-system for Smalltalk is a prerequisite for building an optimizing compiler. Unfortunately, none of the type-systems so far proposed for Smalltalk are adequate; they either cause nearly all Smalltalk programs to be type incorrect, allow run-time type errors, or do not provide enough information for optimization. This paper presents a type-system for Smalltalk that is suitable for code optimization.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28728", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/Johnson86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28743", + "title": "Design of a Distributed Object Manager for the Smalltalk-80 System", + "abstract": "This paper describes the design of a distributed object manager which allows several Smalltalk-80 systems to share objects over a local-area network. This object manager is based on the following principles: location transparency and uniform object naming, unique object representation and use of symbolic links for remote access, possibility of object migration and distributed garbage collection. A version of the object manager has been implemented and is currently being integrated on a two nodes configuration.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28743", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dominique", + "last_name": "Decouchant", + "institution": "Université Grenoble Alpes" + } + ], + "dblp_key": "conf/oopsla/Decouchant86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28705", + "title": "Mach and Matchmaker: Kernel and Language Support for Object-Oriented Distributed Systems", + "abstract": "Mach, a multiprocessor operating system kernel providing capability-based interprocess communication, and Matchmaker, a language for specifying and automating the generation of multi-lingual interprocess communication interfaces, are presented. Their usage together providing a heterogeneous, distributed, object-oriented programming environment is described. Performance and usage statistics are presented. Comparisons are made between the Mach/Matchmaker environment and other related systems. Possible future directions are examined.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28705", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael B.", + "last_name": "Jones", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Richard F.", + "last_name": "Rashid", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/JonesR86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28719", + "title": "An Experience with a Prolog-based Object-Oriented Language", + "abstract": "This paper presents an experience with a programming language SPOOL which is based on the combination of object-oriented programming and logic programming. This language inherits the capability of knowledge base organization from object-oriented programming and its expressive power from logic programming.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28719", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Koichi", + "last_name": "Fukunaga", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Shinichi", + "last_name": "Hirose", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/FukunagaH86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28703", + "title": "An Object-Oriented Operating System Interface", + "abstract": "This paper discusses an object-oriented interface from the Smalltalk-80™ programming environment to a Unix-like operating system. This interface imposes an object-oriented paradigm on operating system facilities. We discuss some of the higher order abstractions that were created to make use of these facilities, and discuss difficulties we encountered implementing this interface. Several examples of cooperating Smalltalk and operating system processes are presented.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28703", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Juanita J.", + "last_name": "Ewing", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Ewing86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28706", + "title": "Object Structure in the Emerald System", + "abstract": "Emerald is an object-based language for the construction of distributed applications. The principal features of Emerald include a uniform object model appropriate for programming both private local objects and shared remote objects, and a type system that permits multiple user-defined and compiler-defined implementations. Emerald objects are fully mobile and can move from node to node within the network, even during an invocation. This paper discusses the structure, programming, and implementation of Emerald objects, and Emerald's use of abstract types.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28706", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew P.", + "last_name": "Black", + "institution": "University of Washington" + }, + { + "first_name": "Norman C.", + "last_name": "Hutchinson", + "institution": "University of Washington" + }, + { + "first_name": "Eric", + "last_name": "Jul", + "institution": "University of Washington" + }, + { + "first_name": "Henry M.", + "last_name": "Levy", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/BlackHJL86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28712", + "title": "Hurricane: An Optimizing Compiler for Smalltalk", + "abstract": "We discuss a recent attempt at providing a more efficient compilation system for the Smalltalk-80™ language than currently exists. The approach is unique in that it attempts to work within the existing semantics of the language. A type declaration and inference mechanism is developed in order to make the problem tractable. Details concerning the compiler implemented to date are given, as well as preliminary speed tests of compiled object code.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28712", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert", + "last_name": "Atkinson", + "institution": "Xerox (France)" + } + ], + "dblp_key": "conf/oopsla/Atkinson86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28716", + "title": "Intermedia: The Architecture and Construction of an Object-Oriented Hypermedia System and Applications Framework", + "abstract": "This article presents a case study of the development of the Intermedia system, a large, object-oriented hypermedia system and associated applications development framework providing sophisticated document linkages. First it presents the educational and technological objectives underlying the project. Subsequent sections capture the process of developing the Intermedia product and detail its architecture and construction, concentrating on the areas in which object-oriented technology has had a significant role. Finally, the successes and failures of the development approach are examined, and several areas of standardization and research that would enhance the process are proposed.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28716", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Norman", + "last_name": "Meyrowitz", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/oopsla/Meyrowitz86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28723", + "title": "An Object-Oriented Architecture for Intelligent Tutoring Systems", + "abstract": "We describe an object-oriented architecture for intelligent tutoring systems. The architecture is oriented around objects that represent the various knowledge elements that are to be taught by the tutor. Each of these knowledge elements, called bites, inherits both a knowledge organization describing the kind of knowledge represented and tutoring components that provide the functionality to accomplish standard tutoring tasks like diagnosis, student modeling, and task selection. We illustrate the approach with several tutors implemented in our lab.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28723", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeffrey", + "last_name": "Bonar", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Robert", + "last_name": "Cunningham", + "institution": "University of Pittsburgh" + }, + { + "first_name": "Jamie", + "last_name": "Schultz", + "institution": "University of Pittsburgh" + } + ], + "dblp_key": "conf/oopsla/BonarCS86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28720", + "title": "A Concurrent Object-Oriented Knowledge Representation Language Orient84/K: Its Features and Implementation", + "abstract": "Orient84/K is an object oriented concurrent programming language for describing knowledge systems. In Orient84/K, an object is composed of the behavior part, the knowledge-base part, and the monitor part, in order to provide object-oriented, logic-based, demon-oriented, and concurrent-programming paradigms in the object framework. Every object is capable of concurrent execution in Orient84/K.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28720", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yutaka", + "last_name": "Ishikawa", + "institution": "Keio University" + }, + { + "first_name": "Mario", + "last_name": "Tokoro", + "institution": "Keio University" + } + ], + "dblp_key": "conf/oopsla/IshikawaT86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28701", + "title": "Oaklisp: an Object-Oriented Scheme with First Class Types", + "abstract": "The Scheme papers demonstrated that lisp could be made simpler and more expressive by elevating functions to the level of first class objects. Oaklisp shows that a message based language can derive similar benefits from having first class types.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28701", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Lang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Barak A.", + "last_name": "Peralmutter", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/LangP86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28707", + "title": "Virtual Memory on a Narrow Machine for an Object-Oriented Language", + "abstract": "LOOM (Large Object-Oriented Memory) is a virtual memory implemented in software that supports the Smalltalk-80(™) programming language and environment on the Xerox Dorado computer. LOOM provides 8 billion bytes of secondary memory address space and is specifically designed to run on computers with a narrow word size (16-bit wide words). All storage is viewed as objects that contain fields. Objects may have an average size as small as 10 fields. LOOM swaps objects between primary and secondary memory, and addresses each of the two memories with a different sized object pointer. When objects are cached in primary memory, they are known only by their short pointers. On a narrow word size machine, the narrow object pointers in primary memory allow a program such as the Smalltalk-80 interpreter to enjoy a substantial speed advantage. Interesting design problems and solutions arise from the mapping between the two address spaces and the temporary nature of an object's short address. The paper explains why the unusual design choices in LOOM were made, and provides an interesting example of the process of designing an integrated virtual memory and storage management system.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28707", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ted", + "last_name": "Kaehler", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/oopsla/Kaehler86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28704", + "title": "A Probe-Based Monitoring Scheme for an Object-Oriented Distributed Operating System", + "abstract": "article Free Access Share on A probe-based monitoring scheme for an object-oriented distributed operating system Author: Partha Dasgupta Georgia Tech Georgia TechView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 21Issue 11Nov. 1986 pp 57–66https://doi.org/10.1145/960112.28704Online:01 June 1986Publication History 13citation436DownloadsMetricsTotal Citations13Total Downloads436Last 12 Months9Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28704", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Partha", + "last_name": "Dasgupta", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Dasgupta86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28727", + "title": "Virtual Instruments: Object-Oriented Program Synthesis", + "abstract": "Virtual Instruments1 is an experimental programming environment for developing electronic test and measurement (T&M) applications. Intended users are test engineers, who are not programmers, but computer literate domain specialists. Unlike traditional programming environments, that provide weak support for a broad range of applications, virtual instruments provides strong support for a specific application. The programming paradigm is bottom-up synthesis of layers of virtual machines — called virtual instruments — using human interface models from the application domain, so that software development occurs without writing code. The object-oriented view of the world has proven a natural fit. Implementation was in Berkeley Smalltalk on a SUN workstation.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28727", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "K. S.", + "last_name": "Bhaskar", + "institution": "" + }, + { + "first_name": "J. K.", + "last_name": "Pecol", + "institution": "" + }, + { + "first_name": "J. L.", + "last_name": "Beug", + "institution": "California Polytechnic State University" + } + ], + "dblp_key": "conf/oopsla/BhaskarPB86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28708", + "title": "SOAR: Smalltalk Without Bytecodes", + "abstract": "We have implemented Smalltalk-80 on an instruction-level simulator for a RISC microcomputer called SOAR. Measurements suggest that even a conventional computer can provide high performance for Smalltalk-80 by abandoning the 'Smalltalk Virtual Machine' in favor of compiling Smalltalk directly to SOAR machine code, linearizing the activation records on the machine stack, eliminating the object table, and replacing reference counting with a new technique called Generation Scavenging. In order to implement these techniques, we had to find new ways of hashing objects, accessing often-used objects, invoking blocks, referencing activation records, managing activation record stacks, and converting the virtual machine images.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28708", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "A. Dain", + "last_name": "Samples", + "institution": "University of California, Berkeley" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Stanford University" + }, + { + "first_name": "Paul", + "last_name": "Hilfinger", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/SamplesUH86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28738", + "title": "Genericity versus Inheritance", + "abstract": "Genericity, as in Ada or ML, and inheritance, as in object-oriented languages, are two alternative techniques for ensuring better extendibility, reusability, and compatibility of software components.This article is a comparative analysis of these two methods.It studies their similarities and differences and assesses to what extent each may be simulated in a language offering only the other.It shows what features are needed to successfully combine the two approaches in an object-oriented language that also features strong type checking.The discussion introduces the principal aspects of the language EiffePM whose design, resulting in part from this study, includes multiple inheritance and a limited form of genericity under full static typing. OVERVIEWDespite its name, today's software is usually not soft enough: adapting it to new uses turns out in most cases to be a harder endeavor than should be.It is thus essential to find ways of enhancing such software quality factors as extendibility (the ease", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28738", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bertrand", + "last_name": "Meyer", + "institution": "Design Interactive (United States)" + } + ], + "dblp_key": "conf/oopsla/Meyer86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28721", + "title": "Objects in Concurrent Logic Programming Languages", + "abstract": "Concurrent Prolog supports object-oriented programming with a clean semantics and additional programming constructs such as incomplete messages, unification, direct broadcasting, and concurrency synchronization [Shapiro 1983a]. While it provides excellent computational support, we claim it does not provide good notation for expressing the abstractions of object-oriented programming. We describe a preprocessor that remedies this problem. The resulting language, Vulcan, is then used as a behicle for exploring new variants of object-oriented programming which become possible in this framework.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28721", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ken", + "last_name": "Kahn", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Eric Dean", + "last_name": "Tribble", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Mark S.", + "last_name": "Miller", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Daniel G.", + "last_name": "Bobrow", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/KahnTMB86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28733", + "title": "Pi: A Case Study in Object-Oriented Programming", + "abstract": "Pi is a debugger written in C + +. This paper explains how object-oriented programming in C + + has influenced Pi's evolution. The motivation for object-oriented programming was to experiment with a browser-like graphical user interface. The first unforeseen benefit was in the symbol table: lazy construction of an abstract syntax-based tree gave a clean interface to the remainder of Pi, with an efficient and robust implementation. Next, though not in the original design, Pi was easily modified to control multiple processes simultaneously. Finally, Pi was extended to control processes executing across multiple heterogeneous target processors.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28733", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "T. A.", + "last_name": "Cargill", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/oopsla/Cargill86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28739", + "title": "Object Identity", + "abstract": "Identity is that property of an object which distinguishes each object from all others. Identity has been investigated almost independently in general-purpose programming languages and database languages. Its importance is growing as these two environments evolve and merge.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28739", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Setrag", + "last_name": "Khoshafian", + "institution": "" + }, + { + "first_name": "George P.", + "last_name": "Copeland", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KhoshafianC86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28736", + "title": "Language Support for Changeable Large Real Time Systems", + "abstract": "A set of concepts for modeling large real time systems is discussed informally. The concepts support the design of centralized as well as distributed systems. They are object oriented in that they correspond to entities of the 'real world', and they are 'change oriented' in that they support not only the first development stage of a system but also its continuous change and evolution. In particularly, the concepts give a promising solution to 'on the fly' changes of existing, active entities.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28736", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "Czech Academy of Sciences, Institute of Computer Science" + } + ], + "dblp_key": "conf/oopsla/Jacobson86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28740", + "title": "Boolean Classes", + "abstract": "We extend the notion of class so that any Boolean combinations of classes is also a class. Boolean classes allow greater precision and conciseness in naming the class of objects governed a particular method. A class can be viewed as a predicate which is either true or false of any given object. Unlike predicates however classes have an inheritance hierarchy which is known at compile time. Boolean classes extend the notion of class, making classes more like predicates, while preserving the compile time computable inheritance hierarchy.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28740", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "McAllester", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ramin", + "last_name": "Zabih", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/McAllesterZ86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28746", + "title": "Development of an Object-Oriented DBMS", + "abstract": "We describe the results of developing the GemStone object-oriented database server, which supports a model of objects similar to that of Smalltalk-80. We begin with a summary of the goals and requirements for the system: an extensible data model that captures behavioral semantics, no artificial bounds on the number or size of database objects, database amenities (concurrency, transactions, recovery, associative access, authorization) and an interactive development environment. Object-oriented languages, Smalltalk in particular, answer some of these requirements. We discuss satisfying the remaining requirements in an object oriented context, and report briefly on the status of the development efforts. This paper is directed at an audience familiar with object-oriented languages and their implementation, but perhaps unacquainted with the difficulties and techniques of database system development. It updates the original report on the project [CM], and expands upon a more recent article [MDP].", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28746", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Maier", + "institution": "" + }, + { + "first_name": "Jacob", + "last_name": "Stein", + "institution": "" + }, + { + "first_name": "Allen", + "last_name": "Otis", + "institution": "Applied Logic Laboratory (Hungary)" + }, + { + "first_name": "Alan", + "last_name": "Purdy", + "institution": "Applied Logic Laboratory (Hungary)" + } + ], + "dblp_key": "conf/oopsla/MaierSOP86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28710", + "title": "Swamp: A Fast Processor for Smalltalk-80", + "abstract": "A processor for the Smalltalk-80↑ programming language is described. This machine is implemented using a standard bit slice ALU and sequencer, TTL MSI, and NMOS LSI RAMS. It executes an instruction set similar to the Smalltalk-80 virtual machine instruction set. The data paths of the machine are optimized for rapid Smalltalk-80 execution by the inclusion of a context cache, tag checking, and a hardware method cache. Each context is only partly initialized when created, and has no memory allocated for it until a possibly non-LIFO reference to it is created. The machine is microprogrammed, and uses a simple next micro-address prediction strategy to obtain most of the performance of pipelining without the attendant complexity. The machine can execute simple instructions at over 7M bytecodes per second and has a predicted average throughput of 1.9M bytecodes per second.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28710", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David M.", + "last_name": "Lewis", + "institution": "University of Toronto" + }, + { + "first_name": "David R.", + "last_name": "Galloway", + "institution": "University of Toronto" + }, + { + "first_name": "Robert J.", + "last_name": "Francis", + "institution": "University of Toronto" + }, + { + "first_name": "Brian W.", + "last_name": "Thomson", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/oopsla/LewisGFT86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28735", + "title": "An Object-Oriented Approach to a Large Scientific Application", + "abstract": "We used an object-oriented design to build a large scientific application: simulation of radiation therapy treatments for cancer. We provide features familiar in the graphics workstation world, including graphic editing of the proposed treatment, multiple views of the treatment in different windows, and computations which proceed concurrently as the input data are being edited. To make our system practical for the typical clinic we used a popular minicomputer and the vendor's operating system and compiler. This paper describes how we implemented objects, inheritance, message passing, windows, and concurrency in (almost) standard Pascal on a VAX under VMS.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28735", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Jacky", + "institution": "University of Washington" + }, + { + "first_name": "Ira J.", + "last_name": "Kalet", + "institution": "Seattle University" + } + ], + "dblp_key": "conf/oopsla/JackyK86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28715", + "title": "Experience with Flamingo: A Distributed, Object-Oriented User Interface System", + "abstract": "The Flamingo Window Management System is based on a remote method invocation mechanism that provides separate processes running in a heterogeneous, distributed computing environment with complete access to Flamingo's objects and methods. This object-oriented interface has made Flamingo a kernel window manager into which device drivers, graphics libraries, window managers and user interfaces can be dynamically loaded. This paper discusses the strengths and weaknesses of Flamingo's system architecture, and introduces a new architecture which will provide a network-wide object space with object protection, migration, and garbage collection.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28715", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Anderson", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/Anderson86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28725", + "title": "Petri Net-Based Object-Oriented Modeling of Distributed Systems", + "abstract": "This paper presents an object-oriented approach for building distributed systems. An example taken from the field of computer integrated manufacturing systems is taken as a guideline. According to this approach a system is built up through three steps: control and synchronization aspects for each class of objects are treated first using PROT nets, which are a high-level extension to Petri nets; then data are introduced specifying the internal states of the objects as well as the messages they send each other; finally the connections between the objects are introduced by means of a data flow diagram between classes. The implementation uses ADA as the target language, exploiting its tasking and structuring mechanisms. The flexibility of the approach and the possibility of using a knowledge-based user interface promote rapid prototyping and reusability.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28725", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Giorgio", + "last_name": "Bruno", + "institution": "Polytechnic University of Turin" + }, + { + "first_name": "Alessandra", + "last_name": "Balsamo", + "institution": "Polytechnic University of Turin" + } + ], + "dblp_key": "conf/oopsla/BrunoB86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28742", + "title": "Augmentation of Object-Oriented Programming by Concepts of Abstract Data Type Theory: The ModPascal Experience", + "abstract": "Object-oriented programming and abstract data type (ADT) theory have emerged from the same origin of computer science: the inability to deal efficiently with 'programming in the large' during the early seventies. Each of the approaches has led to significant practical and theoretical results resp. Nevertheless it is still unsatisfactory that up to now the mutual influence seems to be limited to more or less syntactical issues (e.g. the provision of packages, clusters, forms).", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28742", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Walter", + "last_name": "Olthoff", + "institution": "University of Kaiserslautern" + } + ], + "dblp_key": "conf/oopsla/Olthoff86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28737", + "title": "Object Oriented Spreadsheets: The Analytic Spreadsheet Package", + "abstract": "The ASP package, a spreadsheet implemented in Smalltalk-80, is discussed. A description of the unique data manipulation features of ASP is given. A discussion of how these features arise from the Smalltalk-80 environment is included, with emphasis on features not common to all object oriented languages.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28737", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kurt W.", + "last_name": "Piersol", + "institution": "Xerox (France)" + } + ], + "dblp_key": "conf/oopsla/Piersol86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28713", + "title": "Virtual Copies - At the Boundary Between Classes and Instances", + "abstract": "Knowledge bases built in object-oriented systems use networks of interconnected objects in their representations. The mechanism described here provides a way to use such a network as a prototype by making virtual copies of it. The virtual copy is created incrementally. Values of instance variables in the virtual copy are inherited from the prototype until locally overridden in the copy, similar to inheritance of defaults between instances and classes in Loops. A virtual copy preserves the topology of the original network. Virtual copies can be made from virtual copies. Alternative implementations of virtual copies allow different tradeoffs in space and lookup time. Virtual copies can be used for building knowledge bases for design, for representing contexts in a problem solving system, and have other uses in ordinary programming.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28713", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sanja", + "last_name": "Mittal", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Daniel G.", + "last_name": "Bobrow", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Ken", + "last_name": "Kahn", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/MittalBK86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28741", + "title": "An Alternative to Subclassing", + "abstract": "Smalltalk-80 obtains some of its expressive power from arranging classes in a hierarchy. Inheritance is an important aspect of this hierarchy. An alternative organization of classes is proposed that emphasizes description instead of inheritance. This alternative can be used with compile-time type checking and retains the important characteristics of Smalltalk's hierarchy.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28741", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David E.", + "last_name": "Sandberg", + "institution": "Oregon State University" + } + ], + "dblp_key": "conf/oopsla/Sandberg86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28730", + "title": "The Design and Implementation of ConcurrentSmalltalk", + "abstract": "ConcurrentSmalltalk is a programming language/system which incorporates the facilities of concurrent programming in Smalltalk-801. Such facilities are realized by providing concurrent constructs and atomic objects. This paper first gives an outline of ConcurrentSmalltalk. Then, the design of ConcurrentSmalltalk is described. The implementation of ConcurrentSmalltalk is presented in detail.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28730", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yasuhiko", + "last_name": "Yokote", + "institution": "Keio University" + }, + { + "first_name": "Mario", + "last_name": "Tokoro", + "institution": "Keio University" + } + ], + "dblp_key": "conf/oopsla/YokoteT86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28745", + "title": "Moving Structures between Smalltalk Images", + "abstract": "There are a number of reasons why a user might want to move data structures between Smalltalk images. Unfortunately, the facilities for doing this in the standard Smalltalk image are inadequate: they do not handle circular structures properly, for example. We have implemented a collection of Smalltalk methods that handles circular structures; in addition, these methods have a number of other advantages over those provided in the standard image. This paper is largely a discussion of the issues that arose during their design, implementation, and use.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28745", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven R.", + "last_name": "Vegdahl", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Vegdahl86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28731", + "title": "Encapsulators: A New Software Paradigm in Smalltalk-80", + "abstract": "Certain situations arise in programming that lead to multiply polymorphic expressions, that is, expressions in which several terms may each be of variable type. In such situations, conventional object-oriented programming practice breaks down, leading to code which is not properly modular. This paper describes a simple approach to such problems which preserves all the benefits of good object-oriented programming style in the face of any degree of polymorphism. An example is given in Smalltalk-80 syntax, but the technique is relevant to all object-oriented languages.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28731", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Geoffrey A.", + "last_name": "Pascoe", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Pascoe86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28747", + "title": "The Management of Changing Types in an Object-Oriented Database", + "abstract": "We examine the problem of type evolution in an objectoriented database environment.Type definitions are persistent objects in the database and as such may be modified and shared.The effeets of changing a type extend to objects of the type and to programs that use objeets of the type.We propese a solution to the problem through an extension of the semantic data model.A ehange in the interfaee defined by a type may result in errors when programs use new or old objects of the type.Through the use of an abstraction of the type over time, timestamping and error handling mechanisms provide support for the type designer in creating compatible versions of the type.The mechanisms are incorporated Into the behavior defined by the type and are inherited via the type-lattice.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28747", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrea H.", + "last_name": "Skarra", + "institution": "Brown University" + }, + { + "first_name": "Stanley B.", + "last_name": "Zdonik", + "institution": "Brown University" + } + ], + "dblp_key": "conf/oopsla/SkarraZ86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28714", + "title": "Impulse-86: A Substrate for Object-Oriented Interface Design", + "abstract": "Impulse-86 provides a general and extensible substrate upon which to construct a wide variety of interactive user interfaces for developing, maintaining, and using knowledge-based systems. The system is based on five major building blocks: Editor, Editor Window, PropertyDisplay, Menu, and Operations. These building blocks are interconnected via a uniform framework and each has a well-defined set of responsibilities in an interface.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28714", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Reid G.", + "last_name": "Smith", + "institution": "Schlumberger (British Virgin Islands)" + }, + { + "first_name": "Rich", + "last_name": "Dinitz", + "institution": "Schlumberger (British Virgin Islands)" + }, + { + "first_name": "Paul", + "last_name": "Barth", + "institution": "Schlumberger (British Virgin Islands)" + } + ], + "dblp_key": "conf/oopsla/SmithDB86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28722", + "title": "Object-Oriented Concurrent Programming in ABCL/1", + "abstract": "An object-oriented computation model is presented which is designed for modelling and describing a wide variety of concurrent systems. In this model, three types of message passing are incorporated. An overview of a programming language called ABCL/1, whose semantics faithfully reflects this computation model, is also presented. Using ABCL/1, a simple scheme of distributed problem solving is illustrated. Furthermore, we discuss the reply destination mechanism and its applications. A distributed “same fringe” algorithm is presented as an illustration of both the reply destination mechanism and the future type message passing which is one of the three message passing types in our computation model.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28722", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Akinori", + "last_name": "Yonezawa", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Jean-Pierre", + "last_name": "Briot", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Etsuya", + "last_name": "Shibayama", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/YonezawaBS86", + "venue": "oopsla", + "year": 1986 + }, + { + "paper_id": "10.1145/28697.28744", + "title": "A Distributed Repository for Immutable Persistent Objects", + "abstract": "Jasmine is an object-oriented system for programming-in-the-large. Jasmine describes software using system model objects. These objects are persistent (they have lifetimes of days or decades) and immutable (since system models act as historical records). This paper describes JStore, a distributed, replicated repository for system model objects. JStore provides robust, transactional, write-once storage.", + "date": "1986-01-01", + "link": "https://doi.org/10.1145/28697.28744", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Douglas J.", + "last_name": "Wiebe", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/Wiebe86", + "venue": "oopsla", + "year": 1986 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1987.json b/data/pl_conferences/oopsla/1987.json new file mode 100644 index 0000000..4d8e588 --- /dev/null +++ b/data/pl_conferences/oopsla/1987.json @@ -0,0 +1,959 @@ +[ + { + "paper_id": "10.1145/38765.38847", + "title": "Combining Language and Database Advances in an Object-Oriented Development Environment", + "abstract": "Object-oriented languages generally lack support for persistent objects—that is objects that survive the process or programming session. On the other hand, database systems lack the expressibility of object-oriented languages. Both persistence and expressibility are necessary for production application development.This paper presents a brief overview of VBASE, an object-oriented development environment that combines a procedural object language and persistent objects into one integrated system. Language aspects of VBASE include strong datatyping, a block structured schema definition language, and parameterization, or the ability to type members of aggregate objects. Database aspects include system support for one-to-one, one-to-many, and many-to-many relationships between objects, an inverse mechanism, user control of object clustering in storage for space and retrieval efficiency, and support for trigger methods.Unique aspects of the system are its mechanisms for custom implementations of storage allocation and access methods of properties and types, and free operations, that is operations that are not dispatched according to any defined type.During the last several years, both languages and database systems have begun to incorporate object features. There are now many object-oriented programming languages. [Gol1983, Tes1985, Mey 1987, Cox 1986, Str 1986]. Object-oriented database management systems are not as prevalent yet, and sometimes tend to use different terms (Entity-Relationship, Semantic Data Model), but they are beginning to appear on the horizon [Cat1983, Cop1984, Ston1986, Mylo1980]. However, we are not aware of any system which combines both language and database features in a single object-oriented development platform. This is essential since a system must provide both complex data management and advanced programming language features if it is to be used to develop significant production software systems. Providing only one or the other is somewhat akin to providing half a bridge: it might be made structurally sound, perhaps, but it is not particularly useful to one interested in getting across the river safely.Object-oriented languages have been available for many years. The productivity increases achievable through the use of such languages are well recognized. However, few serious applications have been developed using them. One reason has been performance, though this drawback is being eliminated through the development of compiled object languages. The remaining major negative factor, in our view, is the lack of support for persistence; the lack of objects that survive the processing session and provide object sharing among multiple users of an application.Database management systems, in contrast, suffer from precisely the opposite problem. While having excellent facilities for managing large amounts of data stored on mass media, they generally support only limited expression capabilities, and no structuring facilities.Both language and database systems usually solve this problem by providing bridges between the systems. Thus the proliferation of 'embedded languages', allowing language systems to access database managers. These bridges are usually awkward, and still provide only restricted functionality. Both performance and safety can be enhanced through a tighter coupling between the data management and programming language facilities.It is this lack of a truly integrated system which provided our inspiration at Ontologic, Inc. This paper reviews Ontologic's VBASE Integrated Object System and describes how it combines language and database functionality.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38847", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Timothy", + "last_name": "Andrews", + "institution": "ChromoLogic (United States)" + }, + { + "first_name": "Craig", + "last_name": "Harris", + "institution": "ChromoLogic (United States)" + } + ], + "dblp_key": "conf/oopsla/AndrewsH87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38848", + "title": "Issues in the Design of Object-Oriented Database Programming Languages", + "abstract": "We see a trend toward extending object-oriented languages in the direction of databases, and, at the same time, toward extending database systems with object-oriented ideas. On the surface, these two activities seem to be moving in a consistent direction. However, at a deeper level, we see difficulties that may inhibit their ending up at the same point. We feel that many of these difficulties are a result of the underlying assumptions that are inherent in the fields of programming language and database systems research. Many of these assumptions are historical and contribute to a set of cultural biases that often prevent the two communities from interacting as effectively as possible.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38848", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Toby", + "last_name": "Bloom", + "institution": "" + }, + { + "first_name": "Stanley B.", + "last_name": "Zdonik", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/oopsla/BloomZ87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38821", + "title": "Concepts and Experiments in Computational Reflection", + "abstract": "This paper brings some perspective to various concepts in computational reflection. A definition of computational reflection is presented, the importance of computational reflection is discussed and the architecture of languages that support reflection is studied. Further, this paper presents a survey of some experiments in reflection which have been performed. Examples of existing procedural, logic-based and rule-based languages with an architecture for reflection are briefly presented. The main part of the paper describes an original experiment to introduce a reflective architecture in an object-oriented language. It stresses the contributions of this language to the field of object-oriented programming and illustrates the new programming style made possible. The examples show that a lot of programming problems that were previously handled on an ad hoc basis, can in a reflective architecture be solved more elegantly.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38821", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pattie", + "last_name": "Maes", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/oopsla/Maes87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38810", + "title": "Parallel Programming in a Virtual Object Space", + "abstract": "Sloop is a parallel language and environment that employs an object-oriented model for explicit parallel programming of MIMD multiprocessors. The Sloop runtime system transforms a network of processors into a virtual object space. A virtual object space contains a collection of objects that cooperate to solve a problem. Sloop encapsulates virtual object space semantics within the object type domain. This system-defined type provides an associative, asynchronous method by which one object gains access to another. It also provides an operation for specifying groups of objects that should, for efficiency, reside on the same physical processor, and supports exploitation of the topology of the underlying parallel machine. Domains also support the creation of indivisible objects, which provide implicit concurrency control. The encapsulation of these semantics within an object gives the programmer the power to construct an arbitrary hierarchy of virtual object spaces, facilitating debugging and program modularity. Sloop implementations are running on a bus-based multiprocessor, a hypercube multiprocessor, and on a heterogeneous network of workstations. The runtime system uses object relocation heuristics and coroutine scheduling to attain high performance.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38810", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Lucco", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/oopsla/Lucco87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38808", + "title": "Use of Object-Oriented Programming in a Time Series Analysis System", + "abstract": "We describe the use of object-oriented programming (OOP) in the design and implementation of TSA, a system for interactive time series and spectral analysis. We show how such features of OOP as inheritance, generic messages, and decomposition of the programming problem in terms of objects have contributed to our goal of providing an extensible data analysis system. We discuss the strengths and limitations of both OOP and the particular implementation we used (Flavors on a Symbolics Lisp Machine) for our particular problem.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38808", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "R. K.", + "last_name": "Kerr", + "institution": "University of Washington" + }, + { + "first_name": "Donald B.", + "last_name": "Percival", + "institution": "Seattle University" + } + ], + "dblp_key": "conf/oopsla/KerrP87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38845", + "title": "RAPID: Prototyping Control Panel Interfaces", + "abstract": "RAPID is a design environment to support human factors specialists in designing user interfaces for small control panels. RAPID permits modeling of both the appearance and behavior of operator interfaces. Its main goal is to allow exploration of a greater number of design alternatives by decreasing the time and effort required to generate and evaluate those alternatives. It is a graphically-based system intended to be used by non-programmers. RAPID is implemented in Smalltalk-80.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38845", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karl", + "last_name": "Freburger", + "institution": "Honeywell (United States)" + } + ], + "dblp_key": "conf/oopsla/Freburger87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38846", + "title": "Producer: A Tool for Translating Smalltalk-80 to Objective-C", + "abstract": "Source to source translation tools provide a way of integrating the strengths of production programming environments like C/UNIX™ with rapid prototyping environments like Smalltalk-80™ into a comprehensive hybrid environment that spans more of the software development life-spiral than ever before. This paper describes a tool-assisted process for translating Smalltalk-80 programs into Objective-C™, and shows how the tool, called Producer, is used in practice. To assist others in using this translation tool, we have made Producer publicly available without charge on USENET.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38846", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brad", + "last_name": "Cox", + "institution": "China Productivity Center" + }, + { + "first_name": "Kurt J.", + "last_name": "Schmucker", + "institution": "China Productivity Center" + } + ], + "dblp_key": "conf/oopsla/CoxS87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38825", + "title": "Using Objects To Design and Build Radar ESM Systems", + "abstract": "This paper describes the application of object-oriented programming to the design of a multiprocessor ESM testbed. The ESM testbed uses an object-oriented development environment which integrates Smalltalk and C language tools with the Harmony real-time operating system in a shared memory multiprocessor. All development for an application is done using personal computers which are themselves processors in the real-time testbed. We first discuss two aspects of the ESM testbed: a framework for investigating ESM signal processing algorithms based on an object-oriented emitter database and blackboard objects which implement probabilistic reasoning; and an object-oriented ESM simulation environment which illustrates the use of object-oriented techniques for the development of complex real-time systems. In the second part of the paper we describe our software engineering approach and tools. Throughout the paper, the role played by object-oriented programming in the design of hybrid multiprocessors is highlighted.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38825", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brian", + "last_name": "Barry", + "institution": "" + }, + { + "first_name": "John R.", + "last_name": "Altoft", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BarryATW87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38836", + "title": "The Design and Implementation of Distributed Smalltalk", + "abstract": "Distributed Smalltalk (DS) is an implementation of Smalltalk that allows objects on different machines to send and respond to messages. It also provides some capability for sharing objects among users. The distributed aspects of the system are largely user transparent and preserve the reactive quality of Smalltalk objects. Distributed Smalltalk is currently operational on a network of Sun workstations. The implementation includes an incremental distributed garbage collector and support for remote debugging, access control, and object mobility. This paper concentrates on the important design issues encountered and some of the more interesting implementation details. Performance measurements of the current implementation are included.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38836", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John K.", + "last_name": "Bennett", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/Bennett87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38833", + "title": "Painless Panes for Smalltalk Windows", + "abstract": "Current windowing systems (i.e., Macintosh, Smalltalk) give the user flexibility in the layout of their computer display, but tend to discourage construction of new window types. Glazier is a knowledge-based tool that allows users to construct and test novel or special purpose windows for Smalltalk applications.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38833", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James H.", + "last_name": "Alexander", + "institution": "Tektronix (United States)" + } + ], + "dblp_key": "conf/oopsla/Alexander87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38842", + "title": "OTM: Applying Objects to Tasks", + "abstract": "OTM is a concurrent object language presently being implemented at the University of Toronto. It provides a novel, simple and powerful way of structuring tasks or collections of operations. This paper describes the concurrency control features of OTM, which include external termination of tasks. An example demonstrates how the language can be used to cleanly and concisely control cooperating objects.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38842", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Hogg", + "institution": "University of Toronto" + }, + { + "first_name": "Steven", + "last_name": "Weiser", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/oopsla/HoggW87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38834", + "title": "Logical Composition of Object-Oriented Interfaces", + "abstract": "This paper describes an approach to object-oriented interface design that goes beyond mere object decomposition. In our user interface management system we use logic and filters to declaratively specify and control a space of ways that objects may be composed to create interfaces. A filter is a package of constraints and associated typed objects that express the relationship of data and representation objects.Conceptually our system is completely based on constraints. Filters provide the high bandwidth constraints to maintain the components of the direct-manipulation interface while the logic forms the low bandwidth constraints to combine and provide communication between these components. The use of Horn-clause logic to compose separate interface objects facilitates both the distribution of computation onto multiple processors and the generation of multiple views of data. Intelligent backtracking implemented in the logic allows for user- and system-initiated undo operations to correct errors and/or try alternative approaches to a problem. We illustrate the power and flexibility of this approach by describing a floor layout and design system.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38834", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mark", + "last_name": "Grossman", + "institution": "University of Hawaii at Hilo" + }, + { + "first_name": "Raimund K.", + "last_name": "Ege", + "institution": "Florida International University" + } + ], + "dblp_key": "conf/oopsla/GrossmanE87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38818", + "title": "Composite Object Support in an Object-Oriented Database System", + "abstract": "Many applications in such domains as computer-aided design require the capability to define, store and retrieve as a single unit a collection of related objects known as a composite object. A composite object explicitly captures and enforces the IS-PART-OF integrity constraint between child and parent pairs of objects in a hierarchical collection of objects. Further, it can be used as a unit of storage and retrieval to enhance the performance of a database system.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38818", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Won", + "last_name": "Kim", + "institution": "Monroe Community College" + }, + { + "first_name": "Jay", + "last_name": "Banerjee", + "institution": "Monroe Community College" + }, + { + "first_name": "Hong‐Tai", + "last_name": "Chou", + "institution": "Monroe Community College" + }, + { + "first_name": "Jorge F.", + "last_name": "Garza", + "institution": "Monroe Community College" + }, + { + "first_name": "Darrel", + "last_name": "Woelk", + "institution": "Monroe Community College" + } + ], + "dblp_key": "conf/oopsla/KimBCGW87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38830", + "title": "MELDing Data Flow and Object-Oriented Programming", + "abstract": "MELD combines concepts from data flow and object-oriented programming languages in a unique approach to tool reusability. MELD provides three units of abstraction — equations, classes and features — that together allow sufficient options for granularity and encapsulation to support the implementation of reusable tools and the composition of existing tools in parallel (i.e., interleaved) as well as in series.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38830", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gail E.", + "last_name": "Kaiser", + "institution": "Columbia University" + }, + { + "first_name": "David", + "last_name": "Garlan", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KaiserG87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38813", + "title": "An Object-Oriented Design System Shell", + "abstract": "We present a design system shell which can be used to experiment with principles of design and be used as a design tool where complex layers of information need to be specified about objects, such as in database design. The shell can be tailored to a variety of application areas. It is object-oriented in its implementation and structure. Objects and messages are used as the specification language. The basic ingredients of a rule-based production system are provided, with rules treated as objects and defined independently of the classes to which they are applied.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38813", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jim", + "last_name": "Diederich", + "institution": "University of California, Davis" + }, + { + "first_name": "Jack", + "last_name": "Milton", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/DiederichM87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38839", + "title": "BrouHaHa - A Portable Smalltalk Interpreter", + "abstract": "BrouHaHa is a portable implementation of the Smalltalk-80 virtual machine interpreter. It is a more efficient redesign of the standard Smalltalk specification, and is tailored to suit conventional 32 bit microprocessors. This paper presents the major design changes and optimization techniques used in the BrouHaHa interpreter. The interpreter runs at 30% of the speed of the Dorado on a Sun 3/160 workstation. The implementation is portable because it is written in C.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38839", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eliot", + "last_name": "Miranda", + "institution": "Universidad de Londres" + } + ], + "dblp_key": "conf/oopsla/Miranda87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38838", + "title": "Retrofitting Objects", + "abstract": "I present the results of an experiment in retrofitting objects into an existing system. I describe a technology, based on automatic redefinition of existing functions, that allowed alternative implementations of the fundamental data types of the KEE™ knowledge-based system building tool. This technology is applicable in environments where the system's procedures can be subject to programmatic manipulation. It allows the retrofitting of objects into the implementations of other existing systems. The experience of retrofitting objects into KEE provides insight into the issues of the interaction of semantic classes and data representation and granularity in object-based systems.1", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38838", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert E.", + "last_name": "Filman", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Filman87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38832", + "title": "CLAM - an Open System for Graphical User Interfaces", + "abstract": "CLAM is an object-oriented system designed to support the building of extensible graphical user interfaces. CLAM provides a basic windowing environment with the ability to extend its functions using dynamically loaded C++ classes. The dynamically loaded classes allow for performance tuning (by transparently loading the class in either the client or the CLAM server) and for sharing of new functions.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38832", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lisa A.", + "last_name": "Call", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "David L.", + "last_name": "Cohrs", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Barton P.", + "last_name": "Miller", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/oopsla/CallCM87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38824", + "title": "Object Oriented Development in an Industrial Environment", + "abstract": "Object-oriented programming is a promising approach to the industrialization of the software development process. However, it has not yet been incorporated in a development method for large systems. The approaches taken are merely extensions of well-known techniques when 'programming in the small' and do not stand on the firm experience of existing developments methods for large systems. One such technique called block design has been used within the telecommunication industry and relies on a similar paradigm as object-oriented programming. The two techniques together with a third technique, conceptual modeling used for requirement modeling of information systems, have been unified into a method for the development of large systems.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38824", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "Objective Solutions (China)" + } + ], + "dblp_key": "conf/oopsla/Jacobson87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38841", + "title": "Opus: A Smalltalk Production System", + "abstract": "Opus is a tool for rule-based programming which integrates a production system paradigm with the Smalltalk-80 environment. Opus currently provides a data-driven production system that allows the programmer considerable freedom, including access to the full functionality of the Smalltalk-80 language, and the ability to match rules with arbitrary objects in the environment. We present the goals for the design, a description of the system and its implementation, and discuss issues raised by this approach.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38841", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jane", + "last_name": "Laursen", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Robert", + "last_name": "Atkinson", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/LaursenA87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38843", + "title": "Some Experiments In Object-Oriented Simulation", + "abstract": "Discrete event simulation has been a constant source of inspiration for language designers. The present interest in Object-Oriented Programming (O.O.P.) can be traced back to the Simula 67 language. In return, simulation languages are currently getting back many advantages from the ongoing research in O.O.P. One of the main present research trends is the possibility of concurrently executing a simulation program composed of a set of interacting and communicating objects. Conditions which will make this possible are discussed together with some induced problems. More precisely this paper presents some experiments in object-oriented simulation that reveal the great flexibility of the Smalltalk-801 programming system for building evaluation environments.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38843", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jean", + "last_name": "Bézivín", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Bezivin87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38835", + "title": "ManiplIcons in ThinkerToy", + "abstract": "ThinkerToy is a graphical environment for modeling decision support problems. It provides a tableau on which such problems as landscape planning, service scheduling, and statistical analysis can be modeled and analyzed. Normally, complex mathematical and statistical modeling techniques are needed to perform meaningful analysis. ThinkerToy uses graphical icons with concrete physical properties to replace mathematical relationships and properties. The key construct in this methodology is the ManiplIcon: an icon which is not just a pictorial representation, but also a semantic tool for building models which homorphically represent semi-structured problems.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38835", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven H.", + "last_name": "Gutfreund", + "institution": "University of Massachusetts Boston" + } + ], + "dblp_key": "conf/oopsla/Gutfreund87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38822", + "title": "Metaclasses are First Class: the ObjVlisp Model", + "abstract": "This paper shows how an attempt at a uniform and re-flective definition resulted in an open-ended system sup-porting ObjVlisp, which we use to simulate object-oriented language extensions. We propose to unify Smalltalk classes and their terminal instances. This unification allows us to treat a class as a “first class citizen”, to give a circular definition of the first metaclass, to access to the metaclass level and finally to control the instantiation link. Because each object is an instance of another one and because a metaclass is a real class inheriting from another one, the metaclass links can be created indefinitely. This uniformity allows us to define the class variables at the metalevel thus suppressing the Smalltalk- ambiguity between class variables and instance variables: in our model the instance variables of a class are the class variables of its instances.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38822", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Cointe", + "institution": "Xerox (France)" + } + ], + "dblp_key": "conf/oopsla/Cointe87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38819", + "title": "An Information System Based on Distributed Objects", + "abstract": "The Telesophy system is intended to provide transparent access to all of a community's online information. The scale of the system requires that it be distributed across many machines via a network; the multiple types and formats of the information require that it be a multimedia system. We describe a prototype that uses objects to represent, query, display, and edit information. A two-level storage system is used to store the objects on multiple servers; queries are processed by indexing servers layered on top of the storage system. New media types and new indexing schemes can be added simply by defining new classes within the existing framework.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38819", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "M. A.", + "last_name": "Caplinger", + "institution": "Core Competence" + } + ], + "dblp_key": "conf/oopsla/Caplinger87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38809", + "title": "Teaching Object-Oriented Programming with the KEE System", + "abstract": "Successful learning of an object-oriented programming style is greatly facilitated by a flexible, window-oriented interface and a “step-by-step” instructional methodology. Specifically, students can benefit from a learning sequence moving from working with object hierarchies to working with objects with behavior to more complex problems (conditional or sequential message passing, automation of behavior). Within each area in turn, a step-by-step approach of learning by conceptualization, learning by analogy, learning by experience, and learning by reinforcement is suggested. This is demonstrated using examples from the training of the KEE® Knowledge Engineering Environment™.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38809", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Renate", + "last_name": "Kempf", + "institution": "Intel (United States)" + }, + { + "first_name": "Marilyn", + "last_name": "Stelzner", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/oopsla/KempfS87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38837", + "title": "Transparent Forwarding: First Steps", + "abstract": "Traditional object-oriented systems tend to be single-user. As we move from personal to interpersonal computing, we must look for ways to extend our programming paradigms. This research extends the Smalltalk-80 system to send messages transparently to objects residing on remote machines. We discuss two models for remote message sends, describe our current implementation, and suggest areas for future research.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38837", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul L.", + "last_name": "McCullough", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/McCullough87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38812", + "title": "Constraint Hierarchies", + "abstract": "Constraints describe relations that must be maintained, and provide a useful tool for such applications as interactive simulations, algorithm animation, and graphical user interface construction. We describe a major overhaul and extension to the constraint satisfaction mechanism in ThingLab, a constraint-oriented simulation laboratory written in the Smalltalk-80 language. First, a specification is presented of constraint hierarchies. Such hierarchies include both required constraints and default constraints of differing strengths, thus adding considerable expressive power to the system. Second, an algorithm for satisfying constraint hierarchies is described. The new satisfier is substantially faster than the previous version, even though it also includes new functionality.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38812", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alan", + "last_name": "Borning", + "institution": "Tektronix (United States)" + }, + { + "first_name": "Robert", + "last_name": "Duisberg", + "institution": "Tektronix (United States)" + }, + { + "first_name": "Bjorn", + "last_name": "Freeman‐Benson", + "institution": "Tektronix (United States)" + }, + { + "first_name": "Axel", + "last_name": "Krämer", + "institution": "Tektronix (United States)" + }, + { + "first_name": "Michael", + "last_name": "Woolf", + "institution": "Tektronix (United States)" + } + ], + "dblp_key": "conf/oopsla/BorningDFKW87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38811", + "title": "Mentat: An Object-Oriented Macro Data Flow System", + "abstract": "Mentat, an object-oriented macro data flow system designed to facilitate parallelism in distributed systems, is presented. The macro data flow model is a model of computation similar to the data flow model with two principal differences: the computational complexity of the actors is much greater than in traditional data flow systems, and there are persistent actors that maintain state information between executions. Mentat is a system that combines the object-oriented programming paradigm and the macro data flow model of computation. Mentat programs use a dynamic structure called a future list to represent the future of computations.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38811", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Grimshaw", + "institution": "University of Illinois System" + }, + { + "first_name": "Jane W. S.", + "last_name": "Liu", + "institution": "University of Illinois System" + } + ], + "dblp_key": "conf/oopsla/GrimshawL87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38816", + "title": "A Pragmatic System for Shared Persistent Objects", + "abstract": "This paper describes a system for sharing information in the form of objects among users of the Smalltalk-80 programming environment. The system, called Coral3, is pragmatic in that it was developed to meet the needs of specific applications. This paper describes the expectations for the system, presents factors influencing the design, outlines the implementation of Coral3, and raises questions about object-oriented database systems in general.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38816", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Merrow", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Jame", + "last_name": "Laursen", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/MerrowL87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38827", + "title": "Experience with CommonLoops", + "abstract": "CommonLoops is an object-oriented language embedded in Common Lisp. It is one of two such languages selected as starting points for the Common Lisp Object System (CLOS) which is currently being designed as a standard object-oriented extension to Common Lisp. This paper reports on experiences using the existing Portable CommonLoops (PCL) implementation of CommonLoops. The paper is divided into two parts: a report on the development of a window system application using the CommonLoops programming language, and a description of the implementation of another object-oriented language (CommonObjects) on top of the CommonLoops metaclass kernel, paralleling the two aspects of CommonLoops: the programming language and the metaclass kernel. Usage of the novel features in CommonLoops is measured quantitatively, and performance figures comparing CommonLoops, CommonObjects on CommonLoops, and the native Lisp implementation of CommonObjects are presented. The paper concludes with a discussion about the importance of quantitative assessment for programming language development.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38827", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James", + "last_name": "Kempf", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Warren", + "last_name": "Harris", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Roy", + "last_name": "D'Souza", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Alan", + "last_name": "Snyder", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/KempfHDS87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38820", + "title": "Delegation Is Inheritance", + "abstract": "Inheritance and delegation are alternate methods for incremental definition and sharing. It has commonly been believed that delegation provides a more powerful model. This paper demonstrates that there is a “natural” model of inheritance which captures all of the properties of delegation. Independently, certain constraints on the ability of delegation to capture inheritance are demonstrated. Finally, a new framework which fully captures both delegation and inheritance is outlined, and some of the ramifications of this hybrid model are explored.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38820", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lynn Andrea", + "last_name": "Stein", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/oopsla/Stein87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38817", + "title": "Class Modification in the GemStone Object-Oriented DBMS", + "abstract": "We are currently designing a class modification methodology for GemStone. We describe the current status of the design. We choose from two basic approaches and then introduce those aspects of GemStone necessary for an understanding of the paper. After defining a set of invariants for GemStone databases, we discuss specific class modification operations in terms of maintaining these invariants. We next discuss several issues that impact class modification. These issues include concurrency and authorization, and lead to difficult choices.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38817", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "D. Jason", + "last_name": "Penney", + "institution": "" + }, + { + "first_name": "Jacob", + "last_name": "Stein", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/PenneyS87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38829", + "title": "Active Objects in Hybrid", + "abstract": "Most object-oriented languages are strong on reusability or on strong-typing, but weak on concurrency. In response to this gap, we are developing Hybrid, an object-oriented language in which objects are the active entities. Objects in Hybrid are organized into domains, and concurrent executions into activities. All object communications are based on remote procedure-calls. Unstructured sends and accepts are forbidden. To this the mechanisms of delegation and delay queues are added to enable switching and triggering of activities. Concurrent subactivities and atomic actions provided for compactness and simplicity. We show how solutions to many important concurrent problems, such a pipelining, constraint management and “administration” can be compactly expressed using these mechanisms.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38829", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Oscar", + "last_name": "Nierstrasz", + "institution": "University of Geneva" + } + ], + "dblp_key": "conf/oopsla/Nierstrasz87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38831", + "title": "Modules and Type Checking in PL/LL", + "abstract": "The type system of a programming language system PL/LL is described. PL is a simple object oriented programming language and LL is a language for composing PL modules into programs. The goals of the PL/LL system are to enable the programming of efficient object-oriented computations and to provide the powerful linking language LL for facilitating the construction of large programs. The goal of the type system is to ensure efficient and secure object handling through a combination of static and dynamic type checking, and to preserve this property across module boundaries. The solution is based on (i) the module and linking concepts of LL, (ii) a language construct in PL for the safe creation of linked data structures, and (iii) a limited form of type polymorphism and type unification.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38831", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lars-Erik", + "last_name": "Thorelli", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Thorelli87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38826", + "title": "Object-Oriented Programming in Smalltalk and ADA", + "abstract": "Though Ada and Modula-2 are not object-oriented languages, an object-oriented viewpoint is crucial for effective use of their module facilities. It is therefore instructive to compare the capabilities of a modular language such as Ada with an archetypal object-oriented language such as Smalltalk. The comparison in this paper is in terms of the basic properties of encapsulation, inheritance and binding, with examples given in both languages. This comparison highlights the strengths and weaknesses of both types of languages from an object-oriented perspective. It also provides a basis for the application of experience from Smalltalk and other object-oriented languages to increasingly widely used modular languages such as Ada and Modula-2.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38826", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ed", + "last_name": "Seidewitz", + "institution": "Goddard Space Flight Center" + } + ], + "dblp_key": "conf/oopsla/Seidewitz87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38815", + "title": "The Trellis Programming Environment", + "abstract": "The Trellis programming environment supports programming in Trellis/Owl, an object-based language with multiple inheritance and compile-time type-checking. Trellis is composed of a number of integrated tools that share a common programming environment database. It is a highly interactive, easy-to-use programming environment, providing various programming aids, incremental compilation, and good debugging support. Trellis is both integrated and open-ended.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38815", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Patrick", + "last_name": "O’Brien", + "institution": "Digital Equipment (Germany)" + }, + { + "first_name": "Daniel C.", + "last_name": "Halbert", + "institution": "Digital Equipment (Germany)" + }, + { + "first_name": "Michael F.", + "last_name": "Kilian", + "institution": "Digital Equipment (Germany)" + } + ], + "dblp_key": "conf/oopsla/OBrienHK87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38850", + "title": "Relations as Semantic Constructs in an Object-Oriented Language", + "abstract": "The relation as a semantic construct in an object-oriented language clearly expresses associations and constraints among objects which would otherwise be buried in implementation code. The externalization of references between objects permits a symmetric, non-redundant conceptual model which merits its own special notation and predefined operations. The object-relation model, which combines the object-oriented model with the entity-relationship model from data base theory, is particularly useful for designing and partitioning systems of interrelated objects. Relations can be implemented efficiently using hash tables. The model proposed here has been fully implemented in an object-oriented language written by the author which has been used to implement several production applications.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38850", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James", + "last_name": "Rumbaugh", + "institution": "General Electric (Israel)" + } + ], + "dblp_key": "conf/oopsla/Rumbaugh87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38814", + "title": "An Object-Oriented Framework for Interactive Data Graphics", + "abstract": "Ida is an object-oriented framework for interactive data graphics. It can be used for independent data examination or integrated into application user interfaces. Ida's model of graphics is composed of five basic elements: Presentations, Assemblies, Data Sources, Data Displays, and Scales. Presentations and assemblies address display layout. A sharp distinction is maintained between drawing and the management of already drawn images. Data sources are responsible for drawing while data displays are image managers. Data displays are complex structures consisting of multiple layers that may be larger than the visible regions they underlie. Scales represent coordinate transformations. An object-oriented architecture proves valuable in supporting taxonomic hierarchies with inheritance, part-whole structures for composition, message passing implementation of graphic operations and late attribute binding.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38814", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert L.", + "last_name": "Young", + "institution": "Schlumberger (British Virgin Islands)" + } + ], + "dblp_key": "conf/oopsla/Young87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38849", + "title": "Intermedia: A Case Study of the Differences Between Relational and Object-Oriented Database Systems", + "abstract": "This paper compares two approaches to meeting the data handling requirements of Intermedia, a hypermedia sysfem developed at fhe institute for Research in information and Scholarship at Brown Universify. Intermedia, though wriffen using an object-oriented programming language, relies on a traditional relafional database management system for data storage and retrieval. We examine the ramifications of replacing the relational database with an object-oriented database. We begin by describing the important characteristics each database system. We then describe Intermedia and give an overview of its architecture and its dafa handling requirements. We explain why and how we used a relational database management system and the problems that we encountered with this system. We then present the design of art objectodenfed database schema for Intermedia and compare the relational and object-oriented dafabase management system approaches. 1. lNTRODUCTlON The Institute for Research in Information and", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38849", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karen E.", + "last_name": "Smith", + "institution": "John Brown University" + }, + { + "first_name": "Stanley B.", + "last_name": "Zdonik", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/oopsla/SmithZ87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38840", + "title": "INSIST: Interactive Simulation in Smalltalk", + "abstract": "A functional simulator/editor for VLSI design has been implemented in the Smalltalk-801 system. Users can explore their designs in an highly interactive and graphical manner with “close-to-reality” tools. The traditional sequence of editing, compiling and simulating the circuit is avoided. During editing, functional Modules can immediately respond to new connections. The simulator, called INSIST, strongly supports hierarchical simulation and design up to gate level. Hardware descriptions of the design can be generated for other CAD systems. From these descriptions layout has been generated. A RISC chip was entered and simulated at three hierarchical levels containing more than 50 Modules.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38840", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pieter S. van der", + "last_name": "Meulen", + "institution": "Philips (India)" + } + ], + "dblp_key": "conf/oopsla/Meulen87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38851", + "title": "A Law-Based Approach to Object-Oriented Programming", + "abstract": "The central idea behind this paper is that the discipline governing the exchange of messages between objects should be specifiable by the programmer in the form of an explicit law of the system. We show how, starting from a very primitive foundation, which presumes neither encapsulation nor inheritance, one can establish various forms of both, as well as other useful disciplines, simply by means of appropriate laws.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38851", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Naftaly H.", + "last_name": "Minsky", + "institution": "Rutgers Sexual and Reproductive Health and Rights" + }, + { + "first_name": "David", + "last_name": "Rozenshtein", + "institution": "Rutgers Sexual and Reproductive Health and Rights" + } + ], + "dblp_key": "conf/oopsla/MinskyR87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38823", + "title": "Dimensions of Object-Based Language Design", + "abstract": "The design space of object-based languages is characterized in terms of objects, classes, inheritance, data abstraction, strong typing, concurrency, and persistence. Language classes (paradigms) associated with interesting subsets of these features are identified and language design issues for selected paradigms are examined. Orthogonal dimensions that span the object-oriented design space are related to non-orthogonal features of real languages. The self-referential application of object-oriented methodology to the development of object-based language paradigms is demonstrated.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38823", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peter", + "last_name": "Wegner", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/oopsla/Wegner87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38828", + "title": "Self: The Power of Simplicity", + "abstract": "Self is a new object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single construct. This permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. Finally, because Self does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures. Self's simplicity and expressiveness offer new insights into object-oriented computation.", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38828", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Stanford University" + }, + { + "first_name": "Randall B.", + "last_name": "Smith", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/UngarS87", + "venue": "oopsla", + "year": 1987 + }, + { + "paper_id": "10.1145/38765.38844", + "title": "Experience and Evolution of ConcurrentSmalltalk", + "abstract": "ConcurrentSmalltalk is an object-oriented concurrent programming language/system which has been running since late 1985. ConcurrentSmalltalk has the following features:", + "date": "1987-12-01", + "link": "https://doi.org/10.1145/38765.38844", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yasuhiko", + "last_name": "Yokote", + "institution": "Keio University" + }, + { + "first_name": "Mario", + "last_name": "Tokoro", + "institution": "Keio University" + } + ], + "dblp_key": "conf/oopsla/YokoteT87", + "venue": "oopsla", + "year": 1987 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1988.json b/data/pl_conferences/oopsla/1988.json new file mode 100644 index 0000000..225423f --- /dev/null +++ b/data/pl_conferences/oopsla/1988.json @@ -0,0 +1,727 @@ +[ + { + "paper_id": "10.1145/62083.62086", + "title": "TS: An Optimizing Compiler for Smalltalk", + "abstract": "TS (Typed Smalltalk) is a portable optimizing compiler that produces native machine code for a typed variant of Smalltalk, making Smalltalk programs much faster. This paper describes the structure of TS, the kinds of optimizations that it performs, the constraints that it places upon Smalltalk, the constraints placed upon it by an interactive programming environment, and its performance.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62086", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Justin O.", + "last_name": "Graver", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Laurance W.", + "last_name": "Zurawski", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/JohnsonGZ88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62103", + "title": "An Interactive Environment for Object-Oriented Music Composition and Sound Synthesis", + "abstract": "Kyma is an object-oriented environment for music composition written in Smalltalk-80, which, in conjunction with a microprogrammable digital signal processor called the Platypus, provides the composer with a means for creating and manipulating Sound objects graphically with real-time sonic feedback via software synthesis. Kyma draws no distinctions between the materials and the structure of a composition; both are Sound objects. When a Sound object receives a message to play, it transforms itself into a microSound object, i.e. an object representation of itself in the microcode of the Platypus. Thus an object paradigm is used not only in the representation of Sound objects in Smalltalk-80 but also in the microcode representation of those Sound objects on the Platypus.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62103", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Carla", + "last_name": "Scaletti", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "R E", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/ScalettiJ88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62110", + "title": "How To Invent Distributed Implementation Schemes of an Object-Based Concurrent Language: A Transformational Approach", + "abstract": "A design and verification technique for implementation schemes of distributed software is presented. In this technique, first, the specification is modelled by a concurrent object system, that is, one which is constituted of computational agents with capability of concurrent execution and message passing. Then, such a concurrent object system is transformed into another concurrent object system, which models a sophisticated implementation scheme.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62110", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Etsuya", + "last_name": "Shibayama", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Shibayama88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62113", + "title": "Object-Oriented Programming: An Objective Sense of Style", + "abstract": "We introduce a simple, programming language independent rule (known in-house as the Law of Demeter™) which encodes the ideas of encapsulation and modularity in an easy to follow form for the object-oriented programmer. You tend to get the following related benefits when you follow the Law of Demeter while minimizing simultaneously code duplication, the number of method arguments and the number of methods per class: Easier software maintenance, less coupling between your methods, better information hiding, narrower interfaces, methods which are easier to reuse, and easier correctness proofs using structural induction. We discuss two important interpretations of the Law (strong and weak) and we prove that any object-oriented program can be transformed to satisfy the Law. We express the Law in several languages which support object-oriented programming, including Flavors, Smalltalk-80, CLOS, C++ and Eiffel.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62113", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karl", + "last_name": "Lieberherr", + "institution": "Northeastern University" + }, + { + "first_name": "Ian M.", + "last_name": "Holland", + "institution": "Northeastern University" + }, + { + "first_name": "A. J.", + "last_name": "Riel", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/LieberherrHR88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62104", + "title": "A Smalltalk Implementation of an Intelligent Operator's Associate", + "abstract": "This paper describes the use of Smalltalk in the design and implementation of OFMspert. OFMspert is an architecture for an intelligent operator's associate. In order to verify the architecture, an OFMspert was implemented to act as an assistant to an operator of a NASA satellite ground control system. OFMspert is a large system that utilizes a Smalltalk implementation of a knowledge-based problem solving method known as the blackboard architecture. The entire system was designed and implemented in Smalltalk/V™ and later ported to the Smalltalk-80™ system. The object-oriented paradigm in general, and Smalltalk‡ in particular, greatly facilitated the rapid design and implementation of this system. This paper summarizes the OFMspert architecture, emphasizing its implementation in an object-oriented paradigm.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62104", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kenneth S.", + "last_name": "Rubin", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Patricia M.", + "last_name": "Jones", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Christine", + "last_name": "Mitchell", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Theodore C.", + "last_name": "Goldstein", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/RubinJMG88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62097", + "title": "Integrating an Object-Oriented Programming System with a Database System", + "abstract": "There are two major issues to address to achieve integration of an object-oriented programming system with a database system. One is the language issue: an object-oriented programming language must be augmented with semantic data modeling concepts to provide a robust set of data modeling concepts to allow modeling of entities for important real-world applications. Another is the computational-model issue: application programmers should be able to access and manipulate objects as though the objects are in an infinite virtual memory; in other words, they should not have to be aware of the existence of a database system in their computations with the data structures the programming language allows. This paper discusses these issues and presents the solutions which we have incorporated into the ORION object-oriented database system at MCC.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62097", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Won Bae", + "last_name": "Kim", + "institution": "" + }, + { + "first_name": "Nat", + "last_name": "Ballou", + "institution": "" + }, + { + "first_name": "Jay", + "last_name": "Banerjee", + "institution": "Unisys (United States)" + }, + { + "first_name": "Hong‐Tai", + "last_name": "Chou", + "institution": "" + }, + { + "first_name": "Jorge G.", + "last_name": "Garza", + "institution": "" + }, + { + "first_name": "Darrell", + "last_name": "Woelk", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KimBCGWB88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62101", + "title": "GraphTrace - Understanding Object-Oriented Systems Using Concurrently Animated Views", + "abstract": "Object-Oriented programming is a powerful means of developing large complex systems. In this paper we address the need to understand the behavior of objects in order to facilitate code sharing and reusability. We describe GraphTrace, a tool we have developed that has allowed us to experiment with new ways of visualizing the dynamic behavior of object-oriented programs. Based on our experience with the GraphTrace tool we suggest that being able to present many different views of an object-oriented system and then animating these views concurrently represents a powerful means for understanding such systems.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62101", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael F.", + "last_name": "Kleyn", + "institution": "Schlumberger (United States)" + }, + { + "first_name": "Paul C.", + "last_name": "Gingrich", + "institution": "Schlumberger (United States)" + } + ], + "dblp_key": "conf/oopsla/KleynG88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62099", + "title": "Intensional Concepts in an Object Database Model", + "abstract": "There is a requirement for a stronger treatment of intentional concepts and more general inferential ability within database systems. A framework for achieving this will be described in terms of extensions to an object data model.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62099", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Beech", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/Beech88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62108", + "title": "Using Tuple Space Communication in Distributed Object-Oriented Languages", + "abstract": "When Object-Oriented languages are applied to distributed problem solving, the form of communication restricted to direct message sending is not flexible enough to naturally express complex interactions among the objects. We transformed the Tuple Space Communication Model[29] for better affinity with Object-Oriented computation, and integrated it as an alternative method of communication among the distributed objects. To avoid the danger of potential bottleneck, we formulated an algorithm that makes concurrent pattern matching activities within the Tuple Space possible.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62108", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Satoshi", + "last_name": "Matsuoka", + "institution": "Tokyo University of Information Sciences" + }, + { + "first_name": "Satoru", + "last_name": "Kawai", + "institution": "Tokyo University of Information Sciences" + } + ], + "dblp_key": "conf/oopsla/MatsuokaK88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62100", + "title": "Fabrik: A Visual Programming Environment", + "abstract": "Fabrik is a visual programming environment - a kit of computational and user-interface components that can be “wired” together to build new components and useful applications. Fabrik diagrams utilize bidirectional dataflow connections as a shorthand for multiple paths of flow. Built on object-oriented foundations. Fabrik components can compute arbitrary objects as outputs. Music and animation can be programmed in this way and the user interface can even be extended by generating graphical structures that depend on other data. An interactive type system guards against meaningless connections. As with simple dataflow, each Fabrik component can be compiled into an object with access methods corresponding to each of the possible paths of data propagation.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62100", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dan", + "last_name": "Ingalls", + "institution": "Apple (United States)" + }, + { + "first_name": "Scott", + "last_name": "Wallace", + "institution": "Apple (United States)" + }, + { + "first_name": "Yu-Ying", + "last_name": "Chow", + "institution": "Apple (United States)" + }, + { + "first_name": "Frank", + "last_name": "Ludolph", + "institution": "Apple (United States)" + }, + { + "first_name": "Ken", + "last_name": "Doyle", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/oopsla/IngallsWCLD88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62105", + "title": "Process Management and Exception Handling in Multiprocessor Operating Systems", + "abstract": "The programming of the interrupt handling mechanisms, process switching primitives, scheduling mechanism, and synchronization primitives of an operating system for a multiprocessor require both efficient code in order to support the needs of high- performance or real-time applications and careful organization to facilitate maintenance. Although many advantages have been claimed for object-oriented class hierarchical languages and their corresponding design methodologies, the application of these techniques to the design of the primitives within an operating system has not been widely demonstrated. To investigate the role of class hierarchical design in systems programming, the authors have constructed the Choices multiprocessor operating system architecture the C++ programming language. During the implementation, it was found that many operating system design concerns can be represented advantageously using a class hierarchical approach, including: the separation of mechanism and policy; the organization of an operating system into layers, each of which represents an abstract machine; and the notions of process and exception management. In this paper, we discuss an implementation of the low-level primitives of this system and outline the strategy by which we developed our solution.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62105", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vincent M.", + "last_name": "Russo", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gary", + "last_name": "Johnston", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Roy H.", + "last_name": "Campbell", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/RussoJC88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62112", + "title": "An Execution Model for Distributed Object-Oriented Computation", + "abstract": "This paper describes an execution model being developed for distributed object-oriented in a message-passing multiple-instruction/multiple-data-stream (MIMD) environment. The objective is to execute an object-oriented program as concurrently as possible. Some opportunities for concurrency can be identified explicitly by the programmer. Others can be identified at compile time. There are some opportunities for concurrency, however, that can only be discovered at runtime because they are data-dependent. The model of execution we describe attempts to discover and exploit the data-dependent concurrency that exists in a given program execution.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62112", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "E. H.", + "last_name": "Bensley", + "institution": "Mitre (United States)" + }, + { + "first_name": "Thomas J.", + "last_name": "Brando", + "institution": "Mitre (United States)" + }, + { + "first_name": "Myra Jean", + "last_name": "Prelle", + "institution": "Mitre (United States)" + } + ], + "dblp_key": "conf/oopsla/BensleyBP88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62092", + "title": "A Smalltalk Window System Based on Constraints", + "abstract": "We describe the design of a constraint-based window system for Smalltalk. This window system uses constraints to specify attributes of windows and relationships between them. Three classes of constraints are supported, one of which is implicit and not available for general use. The system extends the current Smalltalk system, providing support for both fixed-size and fixed-scale windows. It also provides the capability to dynamically reorganize the layout of a window. A goal of the design is to produce a system with real-time response that is fast enough to be substituted for the existing system. A prototype with response times of approximately 1/4 second has been implemented to demonstrate the feasibility of the design as well as to point out several important optimizations.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62092", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Danny", + "last_name": "Epstein", + "institution": "Carleton University" + }, + { + "first_name": "Wilf R.", + "last_name": "LaLonde", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/EpsteinL88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62114", + "title": "Transformation of Data Flow Analysis Models to Object-Oriented Design", + "abstract": "This paper describes a strategy to transform Data Flow Analysis into Object Oriented Design. This transformation is performed by extracting information from the Data Flow Model, by enriching with Design decision and by finally producing an Object Oriented Design Model. Semiformal transformation rules are described. Also a special notation is introduced to describe the Object Oriented Design Model. The Model used to represent Data Flow Analysis is the one originally proposed by Yourdon, complemented with Ward-Mellor's Real Time extensions (the “Essential Model”).", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62114", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bruno", + "last_name": "Alabiso", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/Alabiso88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62098", + "title": "A Performance Comparison of Object and Relational Databases Using the Sun Benchmark", + "abstract": "A general concern about object-oriented systems has been whether or not they are able to meet the performance demands required to be useful for the development of significant production software systems. Attempts to evaluate this assertion have been hampered by a lack of meaningful performance benchmarks that compare database operations across different kinds of databases.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62098", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Duhl", + "institution": "Aerodyne Research" + }, + { + "first_name": "Craig A.", + "last_name": "Damon", + "institution": "Aerodyne Research" + } + ], + "dblp_key": "conf/oopsla/DuhlD88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62087", + "title": "Fast Dispatch Mechanisms for Stock Hardware", + "abstract": "Article Fast dispatch mechanisms for stock hardware Share on Author: John R. Rose Sun Microsystems, Inc., 2550 Garcia Avenue, Mountain View, CA Sun Microsystems, Inc., 2550 Garcia Avenue, Mountain View, CAView Profile Authors Info & Claims OOPSLA '88: Conference proceedings on Object-oriented programming systems, languages and applicationsJanuary 1988 Pages 27–35https://doi.org/10.1145/62083.62087Online:01 January 1988Publication History 31citation346DownloadsMetricsTotal Citations31Total Downloads346Last 12 Months7Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62087", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John R.", + "last_name": "Rose", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/Rose88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62109", + "title": "Controlling Propagation of Operations Using Attributes on Relations", + "abstract": "Controlling the propagation of operations through a collection of objects connected by various relationships has been a problem both for the object-oriented and the data base communities. Operations such as copy, destroy, print, and save must propagate to some, but not all, of the objects in a collection. Such operations can be implemented using ad hoc methods on objects, at the cost of extra work and loss of clarity. The use of propagation attributes on the relationships between objects permits a concise, intuitive specification of the manner in which operations should propagate from one object to another. These concepts have been implemented in the object-oriented language DSM and have been used to write applications.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62109", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James", + "last_name": "Rumbaugh", + "institution": "General Electric (United States)" + } + ], + "dblp_key": "conf/oopsla/Rumbaugh88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62102", + "title": "AVANCE: An Object Management System", + "abstract": "AVANCE1 is an integrated application development and run-time system. It provides facilities for programming with shared and persistent objects, transactions and processes. The architecture is designed with decentralization in mind by having a large object identifier space and a remote procedure call interface to objects. Emphasis in this paper is on the programming language PAL and its relation with the underlying virtual machine.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62102", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anders", + "last_name": "Björnerstedt", + "institution": "Stockholm University" + }, + { + "first_name": "Stefan", + "last_name": "Britts", + "institution": "Stockholm University" + } + ], + "dblp_key": "conf/oopsla/BjornerstedtB88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62107", + "title": "Data Abstraction Mechanisms in SINA/ST", + "abstract": "This paper describes a new data abstraction mechanism in an object-oriented model of computing. The data abstraction mechanism described here has been devised in the context of the design of Sina/st language. In Sina/st no language constructs have been adopted for specifying inheritance or delegation, but rather, we introduce simpler mechanisms that can support a wide range of code sharing strategies without selecting one among them as a language feature. Sina/st also provides a stronger data encapsulation than most of the existing object-oriented languages. This language has been implemented on the SUN 3 workstation using Smalltalk.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62107", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mehmet", + "last_name": "Akşit", + "institution": "University of Twente" + }, + { + "first_name": "Anand", + "last_name": "Tripathi", + "institution": "University of Minnesota" + } + ], + "dblp_key": "conf/oopsla/AksitT88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62094", + "title": "Building a Backtracking Facility in Smalltalk Without Kernel Support", + "abstract": "Languages like Snobol, Prolog, and Icon were designed with backtracking facilities from the outset and these facilities are deeply intertwined with the implementation. Retrofitting a backtracking facility in a language that wasn't designed for it has never been achieved. We report on an experiment to retrofit Smalltalk with a backtracking facility. The facility is provided through a small number of primitives written in the language (no modifications to the kernel were made). The ability to do this is a direct result of the power provided by the objectification of contexts.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62094", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wilf R.", + "last_name": "LaLonde", + "institution": "Carleton University" + }, + { + "first_name": "Mark Van", + "last_name": "Gulik", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/LaLondeG88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62093", + "title": "Configuring Stand-Alone Smalltalk-80 Applications", + "abstract": "The Smalltalk-80™ programming environment, though powerful for prototyping applications, does not have any mechanisms for constructing a stand-alone version of an application. Traditionally, the application is bundled with an image including the entire development environment. Production applications frequently require that the only interface visible to the end user be that of the application. A common misperception among Smalltalk-80 application developers is that it is impossible to: develop and deliver applications containing proprietary algorithms,prevent inspection and modification of the application,separate the development environment from the delivered application,provide annotation of the application classes and methods without actually revealing the source code to the end user.In this paper, we introduce various techniques and mechanisms for meeting these requirements.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62093", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "S.", + "last_name": "Sridhar", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Sridhar88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62096", + "title": "Orwell - A Configuration Management System for Team Programming", + "abstract": "In this paper, we describe the design and implementation of Orwell, a configuration management tool for multiperson Smalltalk projects. Although the system described has been implemented for Smalltalk, the design is applicable to other languages such as C++, Objective-C or ADA. Smalltalk is well recognized as a productive programming environment for an individual programmer, but its lack of team support is currently a major obstacle in using Smalltalk for a large software project. To support multiperson Smalltalk programming, Orwell provides both source and object code sharing as well as version control on a network of personal workstations. Class ownership is used as the primary means for dividing work among programmers during the lifecycle of a project. Orwell also supports groups of programmers not physically connected to a common file server. We describe our implementation which preserves the productive exploratory environment of Smalltalk. Seamless integration and performance are essential for Orwell to be accepted and used by Smalltalk programmers.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62096", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dave", + "last_name": "Thomas", + "institution": "Carleton University" + }, + { + "first_name": "Kent A.", + "last_name": "Johnson", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/ThomasJ88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62088", + "title": "A User Interface Toolkit Based on Graphical Objects and Constraints", + "abstract": "One of the most difficult aspects of creating graphical, direct manipulation user interfaces is managing the relationships between the graphical objects on the screen and the application data structures that they represent. Coral (Constraint-based Object-oriented Relations And Language) is a new user interface toolkit under development that uses efficiently-implemented constraints to support these relationships. Using Coral, user interface designers can construct interaction techniques such as menus and scroll bars. More importantly, Coral makes it easy to construct direct-manipulation user interfaces specialized to particular applications. Unlike previous constraint-based toolkits, Coral supports defining constraints in the abstract, and then applying them to different object instances. In addition, it provides iteration constructs where lists of items (such as those used in menus) can be constrained as a group. Coral has two interfaces: a declarative interface that provides a convenient way to specify the desired constraints, and a procedural interface that will allow a graphical user interface management system (UIMS) to automatically create Coral calls.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62088", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pedro", + "last_name": "Szekely", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brad A.", + "last_name": "Myers", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/SzekelyM88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62085", + "title": "Tenuring Policies for Generation-Based Storage Reclamation", + "abstract": "One of the most promising automatic storage reclamation techniques, generation-based storage reclamation, suffers poor performance if many objects live for a fairly long time and then die. We have investigated the severity of this problem by simulating Generation Scavenging automatic storage reclamation from traces of actual four-hour sessions. There was a wide variation in the sample runs, with garbage-collection overhead ranging from insignificant, during the interactive runs, to severe, during a single non-interactive run. All runs demonstrated that performance could be improved with two techniques: segregating large bitmaps and strings, and mediating tenuring with demographic feedback. These two improvements deserve consideration for any generation-based storage reclamation strategy.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62085", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Stanford University" + }, + { + "first_name": "Frank", + "last_name": "Jackson", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/UngarJ88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62111", + "title": "Reflection in an Object-Oriented Concurrent Language", + "abstract": "Our work is along the line of the work of B. Smith and P. Maes. We first discuss our notion of reflection in object-oriented concurrent computation and then present a reflective object-oriented concurrent language ABCL/R. We give several illustrative examples of reflective programming such as (1) dynamic concurrent acquisition of “methods” from other objects, (2) monitoring the behavior of concurrently running objects, and (3) augmentation of the time warp mechanism to a concurrent system. Also the definition of a meta-circular interpreter of this language is given as the definition of a meta-object. The language ABCL/R has been implemented. All the examples given in this paper are running on our ABCL/R system.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62111", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Takuo", + "last_name": "Watanabe", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Akinori", + "last_name": "Yonezawa", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/WatanabeY88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62091", + "title": "An Integrated Color Smalltalk-80 System", + "abstract": "The Smalltalk-80™ user interface and graphics model are based on monochromatic graphics. One natural step in the evolution of the Smalltalk-80 system is the addition of color. This paper describes an implementation of color Smalltalk. Classes have been defined to manipulate visual color models and colored graphics objects. The extensive collaboration between classes which describe color, classes which perform basic graphics operations, and classes in the user interface is explored. Issues in the design and implementation are examined. Potential future directions for object-oriented color systems are discussed.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62091", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rebecca", + "last_name": "Wirfs-Brock", + "institution": "Tektronix (United States)" + } + ], + "dblp_key": "conf/oopsla/Wirfs-Brock88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62106", + "title": "An Object-Oriented Framework of Pattern Recognition Systems", + "abstract": "In this paper, we describe a purely object-oriented framework of pattern recognition systems. Its aim is in dealing with knowledge representation issues in pattern recognition. In our approach, everything works in an entirely autonomous and decentralized manner. Even a search procedure for sample-concept matching is distributed onto every concept object itself by being implemented in what we introduced as the recursive agent-blackboard model. We developed an experimental prototype of character recognition systems in Smalltalk-80, which proved the ability of the object-oriented framework and the cooperative search procedure.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62106", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Norihiko", + "last_name": "Yoshida", + "institution": "Kyushu University" + }, + { + "first_name": "Kouji", + "last_name": "Hino", + "institution": "Kyushu University" + } + ], + "dblp_key": "conf/oopsla/YoshidaH88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62090", + "title": "Transportable Applications Environment (TAE) Plus Experiences in "Object"-ively Modernizing a User Interface Environment", + "abstract": "This paper describes the evolution of the Transportable Applications Executive (TAE) (developed at NASA/Goddard Space Flight Center) from a traditional procedural menu and command-oriented system to an object-oriented, modeless user interface management system, known as TAE Plus. The impetus for developing this environment and early experiments which led to its current implementation are addressed. The current version of TAE Plus provides design and prototyping functions, working in tandem with a mature application management system. The main components are (1) a user interface designers' WorkBench that allows an application developer to interactively layout an application screen and define the static and/or dynamic areas of the screen; (2) an application programmer subroutine package that provides runtime services used to display and control WorkBench-designed “interaction objects” on the screen; and (3) an extension to the existing TAE command language that provides commands for displaying and manipulating interaction objects, thus providing a means to quickly prototype an application's user interface. During TAE Plus development, many design and implementation decisions were based on the state-of-the-art within graphics workstations, windowing systems and object-oriented programming languages, and this paper shares some of the problems and issues experienced during implementation. Some of the topics discussed include: lessons learned in using the Smalltalk™ language to prototype the initial WorkBench; why C++ was selected (over other languages) to build the WorkBench; and experiences in using X Window System™ and Stanford's InterViews object library. The paper concludes with open issues and a description of the next steps involved in implementing the “totally modern” TAE.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62090", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martha R.", + "last_name": "Szczur", + "institution": "Goddard Space Flight Center" + }, + { + "first_name": "Philip E.", + "last_name": "Miller", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SzczurM88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62095", + "title": "An Overview of Modular Smalltalk", + "abstract": "This paper introduces the programming language Modular Smalltalk, a descendant of the Smalltalk-80 programming language. Modular Smalltalk was designed to support teams of software engineers developing production application programs that can run independently of the environment in which they are developed. We first discuss our motivation for designing Modular Smalltalk. Specifically, we examine the properties of Smalltalk-80 that make it inappropriate for our purposes. We then present an overview of the design of Modular Smalltalk, with an emphasis on how it overcomes these weaknesses.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62095", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Allen", + "last_name": "Wirfs-Brock", + "institution": "" + }, + { + "first_name": "Brian", + "last_name": "Wilkerson", + "institution": "Tektronix (United States)" + } + ], + "dblp_key": "conf/oopsla/Wirfs-BrockW88", + "venue": "oopsla", + "year": 1988 + }, + { + "paper_id": "10.1145/62083.62089", + "title": "ET++ - An Object-Oriented Application Framework in C++", + "abstract": "ET++ is an object-oriented application framework implemented in C++ for a UNIX† environment and a conventional window system. The architecture of ET++ is based on MacApp and integrates a rich collection of user interface building blocks as well as basic data structures to form a homogeneous and extensible system. The paper describes the graphic model and its underlying abstract window system interface, shows composite objects as a substrate for declarative layout specification of complex dialogs, and presents a model for editable text allowing the integration of arbitrary interaction objects.", + "date": "1988-01-01", + "link": "https://doi.org/10.1145/62083.62089", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "André", + "last_name": "Weinand", + "institution": "University of Zurich" + }, + { + "first_name": "Erich", + "last_name": "Gamma", + "institution": "University of Zurich" + }, + { + "first_name": "Rudolf", + "last_name": "Marty", + "institution": "University of Zurich" + } + ], + "dblp_key": "conf/oopsla/WeinandGM88", + "venue": "oopsla", + "year": 1988 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1989.json b/data/pl_conferences/oopsla/1989.json new file mode 100644 index 0000000..71ce72d --- /dev/null +++ b/data/pl_conferences/oopsla/1989.json @@ -0,0 +1,1080 @@ +[ + { + "paper_id": "10.1145/74877.74901", + "title": "TICLOS: An Implementation of CLOS for the Explorer Family", + "abstract": "article Free Access Share on TICLOS: an implementation of CLOS for the explorer family Author: P. H. Dussud Lucid Inc. Lucid Inc.View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 24Issue 10Oct. 1989 pp 215–219https://doi.org/10.1145/74878.74901Published:01 September 1989Publication History 17citation311DownloadsMetricsTotal Citations17Total Downloads311Last 12 Months19Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74901", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Dussud", + "institution": "Lucid Technologies (United States)" + } + ], + "dblp_key": "conf/oopsla/Dussud89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74895", + "title": "Function Minimization and Automatic Differentiation Using C++", + "abstract": "Function minimization techniques often require values for the first partial derivatives of the function at a point. Certain techniques, such as Newton's method, require the values of the second partial derivatives as well. The methods commonly used to obtain these values have certain drawbacks which can be eliminated using a technique known as automatic differentiation. When this technique is implemented in an object oriented language with operator overloading capabilities, the problem of differentiation and minimization can be mapped into a code which fits well with the problem space.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74895", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Max E.", + "last_name": "Jerrell", + "institution": "Northern Arizona University" + } + ], + "dblp_key": "conf/oopsla/Jerrell89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74900", + "title": "A Fast Method Dispatcher for Compiled Languages with Multiple Inheritance", + "abstract": "This paper addresses the problem of an efficient dispatch mechanism in an object-oriented system with multiple inheritance. The solution suggested is a direct table indexed branch such as is used in C++. The table slot assignments are made using a coloring algorithm. The method is applicable to strongly typed languages such as C++ (with multiple inheritance added) and Eiffel, and in a slightly slower form to less strongly typed languages like Objective C.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74900", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "R.", + "last_name": "Dixon", + "institution": "4D Technology (United States)" + }, + { + "first_name": "Terry A.", + "last_name": "McKee", + "institution": "Wright State University" + }, + { + "first_name": "M.J.", + "last_name": "Vaughan", + "institution": "NCR (United States)" + }, + { + "first_name": "P.", + "last_name": "Schweizer", + "institution": "4D Technology (United States)" + } + ], + "dblp_key": "conf/oopsla/DixonMSV89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74924", + "title": "Interfaces for Strongly-Typed Object-Oriented Programming", + "abstract": "This paper develops a system of explicit interfaces for object-oriented programming. The system provides the benefits of module interfaces found in languages like Ada and Modula-2 while preserving the expressiveness that gives untyped object-oriented languages like Smalltalk their flexibility. Interfaces are interpreted as polymorphic types to make the system sufficiently powerful. We use interfaces to analyze the properties of inheritance, and identify three distinct kinds of inheritance in object-oriented programming, corresponding to objects, classes, and interfaces, respectively. Object interfaces clarify the distinction between interface containment and inheritance and give insight into limitations caused by equating the notions of type and class in many typed object-oriented programming languages. Interfaces also have practical consequences for design, specification, and maintenance of object-oriented systems.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74924", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peter S.", + "last_name": "Canning", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Walter L.", + "last_name": "Hill", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Walter", + "last_name": "Olthoff", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/CanningCHO89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74921", + "title": "Programming with Explicit Metaclasses in Smalltalk-80", + "abstract": "This paper discusses the introduction of explicit metaclasses á la ObjVlisp into the Smalltalk-80 language. The rigidity of Smalltalk metaclass architecture motivated this work. We decided to implement the ObjVlisp model into the standard Smalltalk-80 system. The resulting combination defines the Classtalk platform. This platform provides a full-size environment to experiment with class-oriented programming by combining implicit metaclasses á la Smalltalk and explicit metaclasses á la ObjVlisp. Obviously, these experiments are not limited to the Smalltalk world and will be useful to understand and practice the metaclass concept advocated by modern object-oriented languages such as ObjVlisp and CLOS.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74921", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jean-Pierre", + "last_name": "Briot", + "institution": "Sorbonne Université" + }, + { + "first_name": "Pierre", + "last_name": "Cointe", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "conf/oopsla/BriotC89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74919", + "title": "Virtual Classes: A Powerful Mechanism in Object-Oriented Programming", + "abstract": "The notions of class, subclass and virtual procedure are fairly well understood and recognized as some of the key concepts in object-oriented programming. The possibility of modifying a virtual procedure in a subclass is a powerful technique for specializing the general properties of the superclass.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74919", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ole Lehrmann", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Birger", + "last_name": "Møller-Pedersen", + "institution": "Norwegian Computing Center" + } + ], + "dblp_key": "conf/oopsla/MadsenM89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74910", + "title": "Computational Reflection in Class-Based Object-Oriented Languages", + "abstract": "This paper describes various models of computational reflection in class based object oriented language. Two different approaches are covered: the meta-object approach which supposes that every object can have a meta-object describing and monitoring its behavior, and the message reification approach which describes a message as an object. The meta-object approach is discussed more fully showing that it is important to differentiate between structural reflection and computational reflection. We will see that, whereas classes and metaclasses are very important for the former, they cannot cope adequately with the later. Therefore we introduce a model of computational reflection where meta-objects are instances of a class META-OBJECT or of one of its subclasses.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74910", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jacques", + "last_name": "Ferber", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "conf/oopsla/Ferber89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74904", + "title": "Prototyping a Real-Time Embedded System in Smalltalk", + "abstract": "This paper presents a case study of AMEP, a prototype ESM signal processor which has been implemented in Smalltalk using an actor-based design methodology, Arguments for choosing an OOPS for implementing such applications are reviewed. AMEP is a large system which includes both hard real-time and knowledge-based subsystems. Extensive software metrics are presented for each subsystem and used to compare the characteristics of code designed for different purposes. For example, analysis of this data suggests that knowledge-based applications may be more difficult to port to an object-based language such as Ada than hard real-time systems. Team programming, productivity, documentation standards and other software engineering issues are also addressed.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74904", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brian", + "last_name": "Barry", + "institution": "Department of National Defence" + } + ], + "dblp_key": "conf/oopsla/Barry89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74909", + "title": "Metaclass Compatibility", + "abstract": "Metaclasses provide control of object description, method compilation and more generally class behaviour. Consequently, they have been widely used in languages such as Smalltalk-80 or more recently CLOS by both users and implementers. Due to their powerful control of instances, careless inheritance of classes with different metaclasses can lead to unsound or inefficient implementations of instance methods. Using examples, we will pin-point these problems. Then we will introduce compatibility rules which need to be fulfilled by metaclasses of inherited classes in order to allow reasonable instance method description.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74909", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Graube", + "institution": "Xerox (France)" + } + ], + "dblp_key": "conf/oopsla/Graube89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74886", + "title": "Saving a Legacy With Objects", + "abstract": "Developers of application software must often work with “legacy systems.” These are systems that have evolved over many years and are considered irreplaceable, either because it is thought that duplicating their function would be too expensive, or because they are trusted by users. Because of their age, such systems are likely to have been implemented in a conventional language with limited use of data abstraction or encapsulation. The lack of abstraction complicates adding new applications to such systems and the lack of encapsulation impedes modifying the system because applications depend on system internals. We describe our experience providing and using an object-oriented interface to a legacy system.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74886", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Walter C.", + "last_name": "Dietrich", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Lee R.", + "last_name": "Nackman", + "institution": "IBM (United States)" + }, + { + "first_name": "F.", + "last_name": "Gracer", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/DietrichNG89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74906", + "title": "An Object Addressing Mechanism for Statically Types Languages with Multiple Inheritance", + "abstract": "In this paper we are concerned with addressing techniques for statically typed languages with multiple inheritance. The addressing techniques are responsible for the efficient implementation of record field selection. In object-oriented languages, this record selection is equivalent to the access of methods. Thus, the efficiency of these techniques greatly affects the overall performance of an object-oriented language. We will demonstrate that addresses, in such systems, cannot always be calculated statically and show how symbol tables have been used as address maps at run time. The essence of the paper is a new addressing technique that can statically calculate either the address of a field or the address of the address of the field. This technique is powerful enough to support an efficient implementation of multiple inheritance with implicit subtyping as described by Cardelli.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74906", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "R. C. H.", + "last_name": "Conner", + "institution": "University of St Andrews" + }, + { + "first_name": "Alan", + "last_name": "Dearle", + "institution": "University of St Andrews" + }, + { + "first_name": "Ron", + "last_name": "Morrison", + "institution": "University of St Andrews" + }, + { + "first_name": "A. L.", + "last_name": "Brown", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/oopsla/ConnorDMB89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74884", + "title": "An Efficient Implementation of SELF - a Dynamically-Typed Object-Oriented Language Based on Prototypes", + "abstract": "We have developed and implemented techniques that double the performance of dynamically-typed object-oriented languages. Our SELF implementation runs twice as fast as the fastest Smalltalk implementation, despite SELF's lack of classes and explicit variables.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74884", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Integrated Systems Solutions (United States)" + }, + { + "first_name": "E.", + "last_name": "Lee", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/ChambersUL89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74881", + "title": "Contributions to Teaching Object Oriented Design and Programming", + "abstract": "We provide a formal agenda for teaching the object-oriented paradigm in a programming language independent manner, and a tool which supports our teaching approach. Our proposal for a comprehensive study of the subject includes an ordered set of objectives designed to guide the uninitiated user from zero knowledge about object-oriented programming through class definitions, inheritance, subtyping, and the parameterization of classes. This set of graded objectives provides both a useful metric for gauging a student's progress, and a facility through which users can begin their studies at a level commensurate with their experience.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74881", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karl", + "last_name": "Lieberherr", + "institution": "Northeastern University" + }, + { + "first_name": "A. J.", + "last_name": "Riel", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/LieberherrR89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74922", + "title": "A Denotational Semantics of Inheritance and its Correctness", + "abstract": "This paper presents a denotational model of inheritance. The model is based on an intuitive motivation of the purpose of inheritance. The correctness of the model is demonstrated by proving it equivalent to an operational semantics of inheritance based upon the method-lookup algorithm of object-oriented languages. Although it was originally developed to explain inheritance in object-oriented languages, the model shows that inheritance is a general mechanism that may be applied to any form of recursive definition.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74922", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "Brown University" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/oopsla/CookP89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74893", + "title": "An Extended Frame Language", + "abstract": "This paper describes several extensions to the traditional frame based programming semantics. We generalize the treatment of slots to include frame-like semantics; in addition we allow slots to be referenced by complex terms, whereas previously described frame based systems typically allow only scalar slot references. The resulting frame system naturally accommodates complex data structures and provides an extremely powerful mechanism for specifying complex relationships between objects represented by frames.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74893", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "F. P.", + "last_name": "Block", + "institution": "AT&T (United States)" + }, + { + "first_name": "N. C.", + "last_name": "Chan", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/oopsla/BlockC89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74908", + "title": "OROS: Toward a Type Model for Software Development Environments", + "abstract": "Three important goals of next generation software development environments (SDEs) are extensibility, integration and broad scope. Our work on OROS is predicated on the hypothesis that a type model, incorporated into an environment's object manager, can contribute to achieving those goals. This paper reports on an attempt at applying object-oriented typing concepts in the domain of software development environments. We believe that the result is a type model that has properties of interest both to software environment builders and also to builders and users of object-oriented systems in general.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74908", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William R.", + "last_name": "Rosenblatt", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Jack C.", + "last_name": "Wileden", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Alexander L.", + "last_name": "Wolf", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/oopsla/RosenblattWW89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74891", + "title": "Playground: An Object-Oriented Simulation System With Agent Rules for Children of All Ages", + "abstract": "Programming languages for children have been limited by primitive control and data structures, indirect user interfaces, and artificial syntax. Playground is a child-oriented programming language that uses objects to structure data and has a modular control structure, a direct-manipulation user interface, and an English-like syntax. Integrating Playground into the curriculum of a classroom of 9- to 10-year-olds has given us valuable insights from the programs intended users, and confirmed many of our design decisions.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74891", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "J.", + "last_name": "Fenton", + "institution": "Apple (United States)" + }, + { + "first_name": "K.", + "last_name": "Beck", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/oopsla/FentonB89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74883", + "title": "Incremental Distribution of Timestamp Packets: A New Approach to Distributed Garbage Collection", + "abstract": "A new algorithm for distributed garbage collection is presented. This algorithm collects distributed garbage incrementally and concurrently with user activity. It is the first incremental algorithm that is capable of collecting cyclic distributed garbage. Computational and network communication overhead are acceptable. Hosts may be temporarily inaccessible and synchronization between hosts is not necessary. The algorithm is based on asynchronous distribution of timestamp packets each containing a list of last-access times of some relevant remotely referenced objects. Finally, the correctness and time complexity of the algorithm are discussed.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74883", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "M.", + "last_name": "Schelvis", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Schelvis89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74896", + "title": "Object-Oriented Programming for Linear Algebra", + "abstract": "Many numerical analysts and Lisp/Smalltalk programmers share the assumption that languages like Fortran are more appropriate for traditional, quantitative scientific programming than object-oriented languages. To show how straightforward application of object-oriented design to standard algorithms in numerical linear algebra improves clarity and expressiveness, without sacrificing speed or accuracy, I describe parts of Cactus, a system for numerical linear algebra and constrained optimization, implemented in Common Lisp and CLOS.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74896", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "J.A.", + "last_name": "McDonald", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/McDonald89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74916", + "title": "Controllable Delegation: An Exercise in Law-Governed Systems", + "abstract": "We believe that the regime governing the patterns of sharing between objects, and of exchange of messages between them, should not be “hard-wired” into a programming language, but should be specifiable by the builders of a system to fit its particular requirements. This thesis has been the primary motivation behind our general concept of law-governed system, which serves as the foundation for this paper.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74916", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Naftaly H.", + "last_name": "Minsky", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "E.", + "last_name": "Rozenshtein", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/oopsla/MinskyR89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74879", + "title": "A Laboratory for Teaching Object-Oriented Thinking", + "abstract": "It is difficult to introduce both novice and experienced procedural programmers to the anthropomorphic perspective necessary for object-oriented design. We introduce CRC cards, which characterize objects by class name, responsibilities, and collaborators, as a way of giving learners a direct experience of objects. We have found this approach successful in teaching novice programmers the concepts of objects, and in introducing experienced programmers to complicated existing designs.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74879", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "K.", + "last_name": "Beck", + "institution": "Apple (Germany)" + }, + { + "first_name": "Ward", + "last_name": "Cunningham", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BeckC89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74903", + "title": "The Use of Multimethods and Method Combination in a CLOS Based Window System Interface", + "abstract": "Solo is a portable window interface written in the Common Lisp Object System (CLOS) object-oriented programming language. Solo provides a virtual window machine which is targeted to a host window system by implementing a set of host window system specific classes and methods for Solo's host window system driver protocol. The interface presented by Solo to an application insulates it from differences in the host window system, facilitating application portability. Solo distinguishes itself from other object-oriented window systems by exploiting certain features of CLOS. CLOS method combination simplifies initialization of windows while preserving easy extensibility of the basic classes. Generic dispatch on multiple arguments, a feature unique to CLOS, allows a simpler and more flexible input event dispatching protocol. A powerful event description language simplifies the specification of keyboard and mouse events. A prototype implementation runs on the server based XII and NeWS host systems, and on the frame buffer based Lucid Window Toolkit.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74903", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hans", + "last_name": "Müller", + "institution": "Oracle (United States)" + }, + { + "first_name": "John R.", + "last_name": "Rose", + "institution": "Oracle (United States)" + }, + { + "first_name": "James", + "last_name": "Kempf", + "institution": "Oracle (United States)" + }, + { + "first_name": "T.", + "last_name": "Stansbury", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/MullerRKS89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74892", + "title": "Neural Agents - A Frame of Mind", + "abstract": "Several recent theories have been advanced to model complex heuristic behavior. From Minsky's Society of Mind to neural networks, these theories all share a common architecture consisting of many highly connected elements that together exhibit sophisticated macro behavior. This paper describes NeuralAgents, a framework developed in Smalltalk-80 that combines the high level interaction and collaboration of rule-based agents with the topological connectivity of neural nets. The Client-Facilitator-Consultant model for agencies will be presented, along with the object oriented design and implementation of the NeuralAgents system. PetWorld, an animated environment for the simulation of animal behavior is presented as an example application.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74892", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Samuel S.", + "last_name": "Adams", + "institution": "Knowledge Systems Institute" + }, + { + "first_name": "Afshan", + "last_name": "Nabi", + "institution": "Knowledge Systems Institute" + } + ], + "dblp_key": "conf/oopsla/AdamsN89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74887", + "title": "Good News, Bad News: Experience Building a Software Development Environment Using the Object-Oriented Paradigm", + "abstract": "This paper presents our experience building an extendible software development environment using the object-oriented paradigm. We have found that object instances provide a natural way to model program constructs, and to capture complex relationships between different aspects of a software system. The object-oriented paradigm can be efficiently implemented on standard hardware and software, and provides some degree of extendibility without requiring major modifications to the existing implementation.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74887", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William", + "last_name": "Harrison", + "institution": "IBM (United States)" + }, + { + "first_name": "P.", + "last_name": "Sweeney", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "John J.", + "last_name": "Shilling", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/HarrisonSS89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74898", + "title": "DSM: An Object-Relationship Modeling Language", + "abstract": "The Data Structure Manager (DSM) combines object-oriented programming with semantic data modeling concepts in the context of the C language. DSM is a full-featured object-oriented language which includes single and multiple inheritance, class descriptor objects, metaclasses, choice of method binding time, error handling, persistent objects, modularity, and an interactive interpreter in an efficient manner. In addition, DSM supports the association and aggregation relationships as part of the Object Modeling Technique (OMT) used for conceptual design. DSM has been used since 1986 to build a variety of research and production-quality software such as an advanced CAF/CAD system.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74898", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "A. V.", + "last_name": "Shah", + "institution": "" + }, + { + "first_name": "J. H.", + "last_name": "Hamel", + "institution": "General Electric (United States)" + }, + { + "first_name": "R. A.", + "last_name": "Borsari", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Rumbaugh", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ShahRHB89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74923", + "title": "Static Type Inference for Parametric Classes", + "abstract": "Central features of object-oriented programming are method inheritance and data abstraction attained through hierarchical organization of classes. Recent studies show that method inheritance can be nicely supported by ML style type inference when extended to labeled records. This is based on the fact that a function that selects a field ƒ of a record can be given a polymorphic type that enables it to be applied to any record which contains a field ƒ. Several type systems also provide data abstraction through abstract type declarations. However, these two features have not yet been properly integrated in a statically checked polymorphic type system. This paper proposes a static type system that achieves this integration in an ML-like polymorphic language by adding a class construct that allows the programmer to build a hierarchy of classes connected by multiple inheritance declarations. Moreover, classes can be parameterized by types allowing “generic” definitions. The type correctness of class declarations is statically checked by the type system. The type system also infers a principal scheme for any type correct program containing methods and objects defined in classes.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74923", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Peter", + "last_name": "Buneman", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/oopsla/OhoriB89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74915", + "title": "Rule-Based Delegation for Prototypes", + "abstract": "Arguments have been given recently for providing the functionality of prototypes in object-oriented languages. Prototypes allow more flexible sharing of code and data by delegating messages to parent objects without the rigid structure of a class hierarchy. Prototypes can implement classes, and delegation can be used to model both single and multiple inheritance. However, one drawback with delegation is the difficulty in enforcing the semantics that delegation is used to model. This paper proposes a novel mechanism to control the delegation of messages with rules. In this system, the delegation of messages is governed by a set of rules possessed by each object. Rules can be used to implement classical single inheritance and can implement various solutions to multiple inheritance. In addition, rules can be created dynamically to model application-specific semantics. This paper describes how rule-based delegation works and illustrates various rules for rule-based delegation that have been implemented.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74915", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "J.", + "last_name": "Almarode", + "institution": "The Graduate Center, CUNY" + } + ], + "dblp_key": "conf/oopsla/Almarode89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74902", + "title": "PCLOS: A Critical Review", + "abstract": "This paper uses the persistent object system PCLOS to survey some problems and benefits of object persistence. The system is analyzed along several relevant dimensions. PCLOS provides object persistence for an object-oriented language. The insights gained on desirable and detrimental components of the system are presented. The intent is to outline some of the expected and unexpected problems encountered in the construction of support for object persistence.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74902", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Paepcke", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/Paepcke89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74911", + "title": "Reflective Facilities in Smalltalk-80", + "abstract": "Computational reflection makes it easy to solve problems that are otherwise difficult to address in Smalltalk-80, such as the construction of monitors, distributed objects, and futures, and can allow experimentation with new inheritance, delegation, and protection schemes. Full reflection is expensive to implement. However, the ability to override method lookup can bring much of the power of reflection to languages like Smalltalk-80 at no cost in efficiency.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74911", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brian", + "last_name": "Foote", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "R. E.", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/FooteJ89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74897", + "title": "Vamp: The Aldus Application Framework", + "abstract": "This paper describes an application framework, called Vamp, which supports Interactive Compound Documents and applications as collections of Interactive Objects. Aldus developed Vamp as a practical experiment in solving several software engineering and project management problems including software reusability, portability, and management of large program teams. Vamp is written in C ++ to run on the Macintosh and Microsoft Windows. This paper discusses the decisions that led to the architecture of Vamp and what Aldus stands to gain by its use.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74897", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "P. J.", + "last_name": "Ferrel", + "institution": "Alderson Broaddus University" + }, + { + "first_name": "Reinhard", + "last_name": "Meyer", + "institution": "Alderson Broaddus University" + } + ], + "dblp_key": "conf/oopsla/FerrelM89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74918", + "title": "A Module Mechanism for Constraints in Smalltalk", + "abstract": "ThingLab II, a rewrite of ThingLab, provides two representations of objects: fully-exposed and interpreted Things, or hidden and compiled Modules. Both representations provide the full power of the ThingLab II constraint hierarchy (an ordering of constraint preferences), and both can be manipulated by the graphical user-interface. This paper briefly describes Modules and their environmental support in ThingLab II. It also describes the process by which the ModuleCompiler translates a collection of objects (a ThingLab II Thing) into a single object with compiled and optimized Smalltalk-80 methods (a Module).", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74918", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bjorn", + "last_name": "Freeman‐Benson", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/Freeman-Benson89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74888", + "title": "PROCOL - A Parallel Object Language with Protocols", + "abstract": "PROCOL is a parallel C-based object-oriented language with communication based on one-way synchronous messages. Objects execute in parallel unless engaged in communication. Communication partners are defined by object instance identifiers, or by type. Therefore send-receive mappings may be 1-1, n-1, or 1-n, though only 1 message is transferred. PROCOL controls object access by a novel concept: an explicit per-object protocol. This protocol is a specification of the occurrence and sequencing of the communication between the object and its partners. Thus protocols support structured, safer and potentially verifiable information exchange between objects. Protocols also act as a composition rule over client objects, thereby offering a 'part-of' hierarchy of these cooperating objects.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74888", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jan van den", + "last_name": "Bos", + "institution": "Leiden University" + }, + { + "first_name": "Chris", + "last_name": "Laffra", + "institution": "Leiden University" + } + ], + "dblp_key": "conf/oopsla/BosL89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74912", + "title": "An Environment for Literate Smalltalk Programming", + "abstract": "The programming environment described in this paper is an adaptation of Donald Knuth's concept of literate programming, applied to Smalltalk programs. The environment provides a multi-media document production system including media for Smalltalk class and method definitions.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74912", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Trygve", + "last_name": "Reenskaug", + "institution": "" + }, + { + "first_name": "A. L.", + "last_name": "Skaar", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ReenskaugS89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74920", + "title": "Extending Ordinary Inheritance Schemes to Include Generalization", + "abstract": "The arrangement of classes in a specialization hierarchy has proved to be a useful abstraction mechanism in class-based object oriented programming languages. The success of the mechanism is based on the high degree of code reuse that is offered, along with simple type conformance rules.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74920", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Claus Hougaard", + "last_name": "Pedersen", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/Pedersen89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74907", + "title": "An Object-Oriented Modeling Environment", + "abstract": "Many tools and techniques exist for the modeling and analysis of computer and communication systems. These tools are often complex and tailored to a narrow range of problems. The system analysis task often requires coordinated use of multiple tools and techniques which is not supported by currently available systems. The Tangram project goal is to develop an environment which makes a large set of tools and techniques readily accessible and is easily tailored to specialized applications.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74907", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas W.", + "last_name": "Page", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Steven", + "last_name": "Berson", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "W.", + "last_name": "Cheng", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Richard R.", + "last_name": "Muntz", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/oopsla/PageBCM89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74880", + "title": "Problem-Solution Mapping in Object-Oriented Design", + "abstract": "Six expert Smalltalk programmers and three expert procedural programmers were observed as they worked on a gourmet shopping design problem; they were asked to think aloud about what was going through their minds as they worked. These verbal protocols were recorded and examined for ways in which the programmers' understanding of the problem domain affected the design process; most of our examples are from the three Smalltalk programmers who focussed most on the mapping from problem to solution. We characterize the problem entities that did appear as solution objects, the active nature of the mapping process, and ways in which the resultant objects went beyond their problem analogs.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74880", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mary Beth", + "last_name": "Rosson", + "institution": "IBM (United States)" + }, + { + "first_name": "Eric", + "last_name": "Gold", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/RossonG89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74914", + "title": "Three Steps to Views: Extending the Object-Oriented Paradigm", + "abstract": "At the core of any sophisticated software development and maintenance environment is a large mass of complex data. The data (the central data of the environment) is composed of smaller sets of data that can be related in complicated and often subtle ways. The user or developer of the environment will be more effective if they are able to deal with conceptual slices, or views, of the large, complex structure. This paper presents an architectural building block for object-based software environments based on the views concept. The building block allows the construction of global abstractions that describe unified behavior of large sets of objects. The basis of the architecture relies on extending the object-oriented paradigm in three steps: (1) defining multiple interfaces in object classes; (2) controlling visibility of instance variables; and (3) allowing multiple copies of an instance variable to occur within an object instance. This paper focuses on the technical aspects of the views approach.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74914", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "J. J.", + "last_name": "Shiling", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "P.", + "last_name": "Sweeney", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ShillingS89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74885", + "title": "Object-Oriented Design: A Responsibility-Driven Approach", + "abstract": "Object-oriented programming languages support encapsulation, thereby improving the ability of software to be reused, refined, tested, maintained, and extended. The full benefit of this support can only be realized if encapsulation is maximized during the design process.We argue that design practices which take a data-driven approach fail to maximize encapsulation because they focus too quickly on the implementation of objects. We propose an alternative object-oriented design method which takes a responsibility-driven approach. We show how such an approach can increase the encapsulation by deferring implementation issues until a later stage.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74885", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rebecca", + "last_name": "Wirfs-Brock", + "institution": "Tektronix (United States)" + }, + { + "first_name": "Brian", + "last_name": "Wilkerson", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Wirfs-BrockW89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74913", + "title": "An Event-Driven Model-View-Controller Framework for Smalltalk", + "abstract": "The Smalltalk Model-View-Controller (MVC) user interface paradigm uses polling for its input control. The polling loops consume CPU cycles even when the user is not interacting with the interface. Applications using Smalltalk as their front-end often suffer unnecessary performance loss. This paper presents a prototype event-driven MVC framework to solve these problems. A solution to the compatibility problem is also provided to allow interface objects built under both polling and event-driven mechanisms to be used by each other with no modification and no performance penalty.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74913", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yen-Ping", + "last_name": "Shan", + "institution": "University of North Carolina at Chapel Hill" + } + ], + "dblp_key": "conf/oopsla/Shan89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74899", + "title": "Mandatory Security in Object-Oriented Database Systems", + "abstract": "A multilevel secure object-oriented data model (using the ORION data model) is proposed for which mandatory security issues in the context of a database system is discussed. In particular the following issues are dealt with: (1) the security policy for the system, (2) handling polyinstantiation, and (3) handling the inference problem.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74899", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Meena", + "last_name": "Thuraisingham", + "institution": "Mitre (United States)" + } + ], + "dblp_key": "conf/oopsla/Thuraisingham89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74917", + "title": "Constraint Technology fur User-Interface Construction in ThingLab II", + "abstract": "ThingLab II is an object-oriented constraint programming system designed specifically for interactive user interface construction and implemented in Smalltalk-80 For constraints to be effective in building user interfaces, they must not impede the responsiveness of the user interface either at run time or during construction. The necessary speed is attained in ThingLab II by making judicious tradeoffs between compilation and interpretation, and by using a fast, incremental algorithm for constraint satisfaction. The resulting system allows user interface components to be assembled, tested, and modified expediently while maintaining interactive responsiveness.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74917", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jules", + "last_name": "Moloney", + "institution": "" + }, + { + "first_name": "Alan", + "last_name": "Borning", + "institution": "" + }, + { + "first_name": "Bjorn", + "last_name": "Freeman‐Benson", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MaloneyBF89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74890", + "title": "Extending the Operating System to Support an Object-Oriented Environment", + "abstract": "Comandos is a project within the European Strategic Programme for Research on Information Technology - ESPRIT and it stems from the identified need of providing simpler and more integrated environments for application development in large distributed systems.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74890", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "José Alves", + "last_name": "Marques", + "institution": "" + }, + { + "first_name": "Paulo", + "last_name": "Guedes", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MarquesG89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74889", + "title": "Inheritance and Synchronization with Enabled Sets", + "abstract": "We discuss several issues related to the integration of inheritance and concurrency in an object-oriented language to support fine-grain parallel algorithms. We present a reflective extension of the actor model to implement inheritance mechanisms within the actor model. We demonstrate that a particularly expressive and inheritable synchronization mechanism must support local reasoning, be composable, be first-class, and allow parameterization based on message content. We present such a mechanism based on the concept of enabled-sets, and illustrate each property. We have implemented enabled-sets in the Rosette prototyping testbed.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74889", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "C.", + "last_name": "Tomlinson", + "institution": "Balcones Technologies (United States)" + }, + { + "first_name": "Vineet Kumar", + "last_name": "Singh", + "institution": "Balcones Technologies (United States)" + } + ], + "dblp_key": "conf/oopsla/TomlinsonS89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74894", + "title": "Strategies for Scientific Prototyping in Smalltalk", + "abstract": "This paper describes the design of a scientific prototyping environment in Smalltalk and discusses implementation strategies to achieve high performance interactive modeling of computationally intensive physical problems. Classes for scientific visualization, including contour plotting and 3D surface representations which incorporate the model-view-controller paradigm are presented. Techniques for inclusion of user primitives written in C to support computationally intense methods are described in detail in their current implementation on advanced Smalltalk workstations (SUN4, Ardent Titan, Tektronix 4317).", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74894", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sandra S.", + "last_name": "Walther", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Richard L.", + "last_name": "Peskin", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/oopsla/WaltherP89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74882", + "title": "Design of the Opportunistic Garbage Collector", + "abstract": "The Opportunistic Garbage Collector (OGC) is a generational garbage collector for stock hardware and operating systems. While incorporating important features of previous systems, the OGC includes several innovations. A new bucket brigade heap organization supports advancement thresholds between one and two scavenges, using only two or three spaces per generation, and without requiring per-object counts. Opportunistic scavenging decouples scavenging from the filling of available memory, in order to hide potentially disruptive scavenge pauses and improve efficiency. Card marking efficiently records which small areas of the heap may contain pointers into younger generations, and is supported by a refinement of the crossing map technique, to enable scanning of arbitrary cards.", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74882", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul R.", + "last_name": "Wilson", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Thomas G.", + "last_name": "Moher", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/oopsla/WilsonM89", + "venue": "oopsla", + "year": 1989 + }, + { + "paper_id": "10.1145/74877.74905", + "title": "Virtual Memory and Backing Storage Management in Multiprocessor Operating Systems Using Object-Oriented Design Techniques", + "abstract": "The Choices operating system architecture [?, ?, ?] uses class hierarchies and object-oriented programming to facilitate the construction of customized operating systems for shared memory and networked multiprocessors. The software is being used in the Tapestry Parallel Computing Laboratory at the University of Illinois to study the performance of algorithms, mechanisms, and policies for parallel systems. This paper describes the architectural design and class hierarchy of the Choices memory and secondary storage management system. The mechanisms and policies of a virtual memory system implement a memory hierarchy that exploits the trade-offs between response times and storage capacities. In Choices, the notion of a memory hierarchy is represented by layers in which abstract classes define interfaces between and internal to the layers. Concrete subclasses implement new algorithms or data structures or specializations of existing ones. This paper describes the motivation for an objecto...", + "date": "1989-09-01", + "link": "https://doi.org/10.1145/74877.74905", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vincent F.", + "last_name": "Russo", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Roy H.", + "last_name": "Campbell", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/RussoC89", + "venue": "oopsla", + "year": 1989 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1990.json b/data/pl_conferences/oopsla/1990.json new file mode 100644 index 0000000..8c5d7b0 --- /dev/null +++ b/data/pl_conferences/oopsla/1990.json @@ -0,0 +1,808 @@ +[ + { + "paper_id": "10.1145/97945.97950", + "title": "Graphical Specification of Object-Oriented Systems", + "abstract": "The graphical notation Objectcharts, introduced in this paper, allows a developer to precisely specify the behaviour of object classes and to reason about the behaviour of particular configurations of objects.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97950", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Bear", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Phillip", + "last_name": "Allen", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Derek", + "last_name": "Coleman", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Fiona", + "last_name": "Hayes", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/BearACH90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97969", + "title": "PCLOS: Stress Testing CLOS Experiencing the Metaobject Protocol", + "abstract": "This paper demonstrates that the CLOS metaobject protocol approach to defining and implementing an object model is very powerful. CLOS is an object-oriented language that is based on Common Lisp and is in the process of being standardized. Implementations of CLOS are themselves object-oriented with all major building blocks of the language being instances of system classes. A metaobject protocol provides a framework for CLOS implementations by specifying the hierarchy of these classes and the order and contents of the communication among their instances. This design has made CLOS both flexible and portable, two design goals that traditionally conflict. In support of this suggestion we present a detailed account of how we added object persistence to CLOS without modifying any of the language's implementation code.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97969", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Paepcke", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/Paepcke90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97978", + "title": "COOL: Kernel Support for Object-Oriented Environments", + "abstract": "The Chorus Object-Oriented Layer (COOL) is an extension of the facilities provided by the Chorus distributed operating system with additional functionality for the support of object-oriented environments. This functionality is realized by a layer built on top of the Chorus V3 Nucleus, which extends the Chorus interface with generic functions for object management: creation, deletion, storage, remote invocation and migration. One major goal of this approach was to explore the feasibility of general object management at the kernel level, with support of multiple object models at a higher level. We present the implementation of COOL and a first evaluation of this approach with a C++ environment using the COOL mechanisms.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97978", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sabine", + "last_name": "Habert", + "institution": "University of Washington" + }, + { + "first_name": "Laurence", + "last_name": "Mosseri", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/oopsla/HabertA90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97962", + "title": "Structured Analysis and Object Oriented Analysis (Panel)", + "abstract": "The object-oriented paradigm still faces an open challenge: Delivering huge software systems routinely and cost effectively. To quote Ed Yourdon: “A system composed of 100,000 lines of C++ is not be sneezed at, but we don't have that much trouble developing 100,000 lines of COBOL today. The real test of OOP will come when systems of 1 to 10 million lines of code are developed.”", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97962", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dennis de", + "last_name": "Champeaux", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Larry L.", + "last_name": "Constantine", + "institution": "" + }, + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "Objective Solutions (China)" + }, + { + "first_name": "Stephen J.", + "last_name": "Mellor", + "institution": "" + }, + { + "first_name": "Paul T.", + "last_name": "Ward", + "institution": "" + }, + { + "first_name": "Edward", + "last_name": "Yourdon", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ChampeauxCJMWY90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97983", + "title": "The Point of View Notion for Multiple Inheritance", + "abstract": "We examine several problems related to the preservation of the Independence Principle inheritance. This principle states that all the characteristics of independent superclasses must be inherited by subclasses, even if there are name conflicts. In this context, a conventional approach is to use explicit class selection. We show that this mechanism suffers from serious limitations, and leads to inhibition of refinement and genericity. Our experimental object-oriented language ROME introduces the “Point of View” notion (using an “as-expressions” mechanism) which solves these problems.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97983", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bernard", + "last_name": "Carré", + "institution": "Université d'Artois" + }, + { + "first_name": "Jean-Marc", + "last_name": "Geib", + "institution": "Université d'Artois" + } + ], + "dblp_key": "conf/oopsla/CarreG90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97960", + "title": "Message Pattern Specifications: A New Technique for Handling Errors in Parallel Object Oriented Systems", + "abstract": "As object oriented techniques enable the fabrication of ever more sophisticated systems, the need grows for a mechanism to ensure the consistent and 'correct' behaviour of each object at run-time. We describe a new, in-source specification mechanism, Message Pattern Specifications (MPS), to directly satisfy this need in a succinct, orthogonal and disciplined manner. Targeted for use in parallel object oriented systems, MPS allows programmers to enunciate the 'legal' patterns of run-time behaviour in which their objects may engage. Furthermore, it supports the definition of methods for object recovery or graceful failure in case these specifications are violated during execution.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97960", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jan A.", + "last_name": "Purchase", + "institution": "University College London" + }, + { + "first_name": "Russel", + "last_name": "Winder", + "institution": "University College London" + } + ], + "dblp_key": "conf/oopsla/PurchaseW90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97968", + "title": "When Objects Collide: Experiences with Reusing Multiple Class Hierarchies", + "abstract": "Well-designed reusable class libraries are often incompatible due to architectural mismatches such as error-handling and composition conventions. We identify five pragmatic dimensions along which combinations of subsystems must match, and present detailed examples of conflicts resulting from mismatches. Examples are drawn from our experiences of integrating five subsystem-level class hierarchies into an object-oriented hypertext platform. We submit that effective reuse will require that these pragmatic decisions be explicitly identified in descriptions of reusable software. Such descriptions will enable developers to identify and combine subsystems whose architectures are compatible.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97968", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lucy M.", + "last_name": "Berlin", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/Berlin90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97980", + "title": "Object-Oriented Real-Time Language Design: Constructs for Timing Constraints", + "abstract": "We propose a new object-oriented programming language called RTC++ for programming real-time applications. RTC++ is an extension of C++ and its features are to specify i) a real-time object which is an active entity, ii) timing constraints in an operation as well as in statements, and iii) a periodic task with rigid timing constraints.In this paper, we first discuss real-time programming issues and what language support should be provided for building real-time applications. Then, the key features of RTC++ are described. Some programming examples are shown to demonstrate RTC++'s expressive power. A comparison to other programming languages are also discussed.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97980", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yutaka", + "last_name": "Ishikawa", + "institution": "" + }, + { + "first_name": "Hideyuki", + "last_name": "Tokuda", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/IshikawaTM90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97981", + "title": "OOP in the Real World (Panel)", + "abstract": "Some advocates of OOP have promised that it will make all code reusable, shorten development cycles, remove the applications backlog, cure the common cold and plug the hole in the ozone layer.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97981", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rick", + "last_name": "DeNatale", + "institution": "IBM (United States)" + }, + { + "first_name": "Charles", + "last_name": "Irby", + "institution": "" + }, + { + "first_name": "John", + "last_name": "LaLonde", + "institution": "Extrel (United States)" + }, + { + "first_name": "Burton L.", + "last_name": "Leathers", + "institution": "" + }, + { + "first_name": "Reed B.", + "last_name": "Phillips", + "institution": "Knowledge Systems Institute" + } + ], + "dblp_key": "conf/oopsla/DeNataleILLP90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97947", + "title": "The Design of the C++ Booch Components", + "abstract": "This paper describes design issues encountered developing a reusable component library. The design applied encapsulation, inheritance, composition and type parameterization. The implementation uses various C++ mechanisms, including: virtual and static member functions, templates, and exceptions.The resulting library contains about 500 components (mostly template classes and functions) and an optional utility for instantiating templates. The components provide variations of basic collection/container abstractions with various time and space complexities.A key insight gained from this project: the design process centered on developing a “template for the templates” — designing a component framework and orderly process for generating the template classes.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97947", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Grady", + "last_name": "Booch", + "institution": "" + }, + { + "first_name": "Michael J.", + "last_name": "Vilot", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BoochV90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97967", + "title": "Contracts: Specifying Behavioural Compositions in Object-Oriented Systems", + "abstract": "Behavioral compositions, groups of interdependent objects cooperating to accomplish tasks, are an important feature of object-oriented systems. This paper introduces Contracts, a new technique for specifying behavioral compositions and the obligations on participating objects. Refinement and composition of contracts allows for the creation of large grain abstractions based on behavior, orthogonal to those provided by existing class constructs. Using contracts thus provides a basis and vocabulary for Interaction-Oriented design which greatly facilitates the early identification, abstraction and reuse of patterns of behavior in programs. Contracts differ from previous work in that they capture explicitly and abstractly the behavioral dependencies amongst cooperating objects. By explicitly stating these dependencies, contract also provide an effective aid for program understanding and reuse.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97967", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard F.", + "last_name": "Helm", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Ian M.", + "last_name": "Holland", + "institution": "Northeastern University" + }, + { + "first_name": "Dipayan", + "last_name": "Gangopadhyay", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/HelmHG90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97958", + "title": "A Logical Theory of Concurrent Objects", + "abstract": "A new theory of concurrent objects is presented. The theory has the important advantage of being based directly on a logic called rewriting logic in which concurrent object-oriented computation exactly corresponds to logical deduction. This deduction is performed by concurrent rewriting modulo structural axioms of associativity, commutativity and identity that capture abstractly the essential aspects of communication in a distributed object-oriented configuration made up of concurrent objects and messages. Thanks to this axiomatization, it becomes possible to study the behavior of concurrent objects by formal methods in a logic intrinsic to their computation. The relationship with Actors and with other models of concurrent computation is also discussed. A direct fruit of this theory is a new language, called Maude, to program concurrent object-oriented modules in an entirely declarative way using rewriting logic; modules written in this language are used to illustrate the main ideas with examples. Maude contains OBJ3 as a functional sublanguage and provides a simple and semantically rigorous integration of functional programming and concurrent object-oriented programming.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97958", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "José", + "last_name": "Meseguer", + "institution": "SRI International" + } + ], + "dblp_key": "conf/oopsla/Meseguer90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97974", + "title": "A Framework for Visualizing Object-Oriented Systems", + "abstract": "This paper describes a new approach to visualizing program systems within the object-oriented paradigm. This approach is based on a T E X-like notation which has been extended and generalized for specifying graphical layout of arbitrary objects. The CLOS meta-level architecture is used to associate visualization and application objects. We propose several useful techniques such as indirect values, slot and method demons, and instance-specific metaobjects. Our techniques require no modifications to the systems which are selected for visualization. We demonstrate the feasibility of our approach using application domains such as CLOS debugging and constraint systems. 1 Introduction Although programming has mostly been done in textual terms users have always had a notion of visualizing their programs. Programs have been entered as lines of text but soon users started to indent their programs and also used comments for separating or emphasizing particular program parts. Tools were develop...", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97974", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Volker", + "last_name": "Haarslev", + "institution": "Universität Hamburg" + }, + { + "first_name": "Ralf", + "last_name": "Möller", + "institution": "Universität Hamburg" + } + ], + "dblp_key": "conf/oopsla/HaarslevM90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97984", + "title": "Exception Handling and Object-Oriented Programming: Towards a Synthesis", + "abstract": "The paper presents a discussion and a specification of an exception handling system dedicated to object-oriented programming. We show how a full object-oriented representation of exceptions and of protocols to handle them, using meta-classes, makes the system powerful as well as extendible and solves many classical exception handling issues. We explain the interest for object-oriented programming of handlers attached to classes and to expressions. We propose an original algorithm for propagating exceptions along the invocation chain which takes into account, at each stack level, both kind of handlers. Any class can control which exceptions will be propagated out of its methods; any method can provide context-dependant answers to exceptional events. The whole specification and some keys of our Smalltalk implementation are presented in the paper.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97984", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christophe", + "last_name": "Dony", + "institution": "Xerox (France)" + } + ], + "dblp_key": "conf/oopsla/Dony90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97955", + "title": "Actors as a Special Case of Concurrent Constraint Programming", + "abstract": "Saraswat recently introduced the framework of concurrent constraint programming [14]. The essence of the framework is that computations consist of concurrent agents interacting by communicating constraints. Several concurrent constraint programming languages have been defined. They differ in the kinds of constraints that can be used as well as the kinds of operations on constraints which are available. In this paper we introduce a very simple concurrent constraint language we call Lucy, designed to closely mimic the actor model of computation. Agents can communicate only by the posting of constraints upon bags (un-ordered collections possibly with duplicate elements). This very impoverished concurrent constraint language is a syntactic subset of Janus, a concurrent constraint language which closely resembles concurrent logic programming languages such as Guarded Horn Clauses [21], Strand [5], Parlog [2] and Flat Concurrent Prolog [13]. By identifying the subset of Janus which is an actor language, we elucidate the relationship between actors and concurrent logic programming (and its generalization as concurrent constraint programming). Lucy is best not thought of as a unification of logic and constraint programming with actor and object-oriented programming, but as the missing link between these programming language genera.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97955", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ken", + "last_name": "Kahn", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Vijay", + "last_name": "Saraswat", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/KahnS90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97949", + "title": "An Iterative-Design Model for Reusable Object-Oriented Software", + "abstract": "We present an iterative-design approach for reusable object-oriented software that augments existing design methods by incorporating iteration into the design methodology and focuses on the set of problems within the domain, encouraging reuse of existing design information. The model has five separate stages which are described, before an example design is outlined using the model with sample code constructs in C++. Our results have shown a high degree of code reuse when using the model, directly attributable to two distinct design stages. An analysis of these results is also presented.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97949", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sanjiv", + "last_name": "Gossain", + "institution": "University of Essex" + }, + { + "first_name": "Bruce", + "last_name": "Anderson", + "institution": "University of Essex" + } + ], + "dblp_key": "conf/oopsla/GossainA90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97966", + "title": "A Parallel Object-Oriented Language with Inheritance and Subtyping", + "abstract": "This paper shows that inheritance and subtyping can be introduced advantageously into a parallel object-oriented language, POOL-I. These concepts are clearly distinguished, because they deal with different aspects of programming. In this way several problems traditionally adhering to inheritance can be solved. The language POOL-I is a parallel object-oriented language with a strong typing scheme which includes genericity and dynamic binding. A novel and particularly powerful mechanism offers the possibility to manipulate and analyse types dynamically.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97966", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pierre", + "last_name": "America", + "institution": "Philips (Netherlands)" + }, + { + "first_name": "Frank van der", + "last_name": "Linden", + "institution": "Philips (Netherlands)" + } + ], + "dblp_key": "conf/oopsla/AmericaL90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97982", + "title": "Mixin-based Inheritance", + "abstract": "The diverse inheritance mechanisms provided by Smalltalk, Beta, and CLOS are interpreted as different uses of a single underlying construct. Smalltalk and Beta differ primarily in the direction of class hierarchy growth. These inheritance mechanisms are subsumed in a new inheritance model based on composition of mixins, or abstract subclasses. This form of inheritance can also encode a CLOS multiple-inheritance hierarchy, although changes to the encoded hierarchy that would violate encapsulation are difficult. Practical application of mixin-based inheritance is illustrated in a sketch of an extension to Modula-3.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97982", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gilad", + "last_name": "Bracha", + "institution": "University of Utah" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/BrachaC90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97961", + "title": "Garbage Collection of Actors", + "abstract": "This paper considers the garbage collection of concurrent objects for which it is necessary to know not only “reachability,” the usual criterion for reclaiming data, but also the “state” (active or blocked) of the object. For the actor model, a more comprehensive definition than previously available is given for reclaimable actors. Two garbage collection algorithms, implementing a set of “coloring” rules, are presented and their computational complexity is analyzed. Extensions are briefly described to allow incremental, concurrent, distributed and real-time collection. It is argued that the techniques used for the actor model applies to other object-based concurrent models.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97961", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dennis", + "last_name": "Kafura", + "institution": "Virginia Tech" + }, + { + "first_name": "Doug", + "last_name": "Washabaugh", + "institution": "Digital Wave (United States)" + }, + { + "first_name": "Jeff", + "last_name": "Nelson", + "institution": "Digital Wave (United States)" + } + ], + "dblp_key": "conf/oopsla/KafuraWN90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97953", + "title": "LO and Behold! Concurrent Structured Processes", + "abstract": "We introduce a novel concurrent logic programming language, which we call LO, based on an extension of Horn logic. This language enhances the process view of objects implementable in Horn-based concurrent logic programming languages with powerful capabilities for knowledge structuring, leading to a flexible form of variable-structure inheritance. The main novelty about LO is a new kind of OR-concurrency which is dual to the usual AND-concurrency and provides us with the notion of structured process. Such OR-concurrency can be nicely characterized with a sociological metaphor as modelling the internal distribution of tasks inside a complex organization; this complements the external cooperation among different entities accounted for by AND-concurrency.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97953", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jean‐Marc", + "last_name": "Andreoli", + "institution": "" + }, + { + "first_name": "Remo", + "last_name": "Pareschi", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/AndreoliP90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97979", + "title": "The Performance of an Object-Oriented Threads Package", + "abstract": "Presto is an object-oriented threads package for writing parallel programs on a shared-memory multiprocessor. The system adds thread objects and synchronization objects to C++ to allow programmers to create and control parallelism. Presto's object-oriented structure, along with its user-level thread implementation, simplifies customization of thread management primitives to meet application-specific needs.The performance of thread primitives is crucial for parallel programs with fine-grained structure; therefore, the principal objective of this effort was to substantially improve Presto's performance under heavy loads without sacrificing the benefits of its object-oriented interface. We discuss design and implementation issues for shared-memory multiprocessors, and the performance impact of various designs is shown through measurements on a 20-processor Sequent Symmetry multiprocessor.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97979", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John E.", + "last_name": "Faust", + "institution": "University of Washington" + }, + { + "first_name": "Henry M.", + "last_name": "Levy", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/FaustL90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97973", + "title": "Issues in Object Database Management", + "abstract": "While the availability of commercial systems from several vendors indicates maturity in object database management technology, there are numerous issues which remain. This panel will attempt to expose and discuss several of these issues.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97973", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Stein", + "institution": "" + }, + { + "first_name": "Tim", + "last_name": "Andrews", + "institution": "" + }, + { + "first_name": "Bill", + "last_name": "Kent", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Kate", + "last_name": "Rotzell", + "institution": "" + }, + { + "first_name": "Dan", + "last_name": "Weinreb", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SteinAKRW90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97957", + "title": "Kaleidoscope: Mixing Objects, Constraints and Imperative Programming", + "abstract": "Kaleidoscope is an object-oriented language being designed to integrate the traditional imperative object-oriented paradigm with the less traditional declarative constraint paradigm. Imperative state changes provide sequencing while declarative constraints provide object relations. A variables as streams semantics enables the declarative-imperative integration. A running example is used to illustrate the language concepts—a reimplementation of the MacDraw II dashed-lines dialog box. The example is in three parts: the input channel, using imperative code to sequence through modes; the output channel, using constraints to update the display; and the internal relations, using constraints to maintain the data objects' consistency requirements. The last sections of the paper discuss views as a natural result of combining objects with constraints, as well as related and future work.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97957", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bjorn", + "last_name": "Freeman‐Benson", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/Freeman-Benson90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97970", + "title": "Reasoning about Object-Oriented Programs that Use Subtypes", + "abstract": "Programmers informally reason about object-oriented programs by using subtype relationships to classify the behavior of objects of different types and by letting supertypes stand for all their subtypes. We describe formal specification and verification techniques for such programs that mimic these informal ideas. Our techniques are modular and extend standard techniques for reasoning about programs that use abstract data types. Semantic restrictions on subtype relationships guarantee the soundness of these techniques.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97970", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gary T.", + "last_name": "Leavens", + "institution": "Iowa State University" + }, + { + "first_name": "William E.", + "last_name": "Weihl", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/LeavensW90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97952", + "title": "Viewing Objects as Patterns of Communicating Agents", + "abstract": "Following our own experience developing a concurrent object-oriented language as well of that of other researchers, we have identified several key problems in the design of a concurrency model compatible with the mechanisms of object-oriented programming. We propose an approach to language design in which an executable notation describing the behaviour of communicating agents is extended by syntactic patterns that encapsulate language constructs. We indicate how various language models can be accommodated, and how mechanisms such as inheritance can be modeled. Finally, we introduce a new notion of types that characterizes concurrent objects in terms of their externally visible behaviour.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97952", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Oscar", + "last_name": "Nierstrasz", + "institution": "University of Geneva" + }, + { + "first_name": "Michael", + "last_name": "Papathomas", + "institution": "University of Geneva" + } + ], + "dblp_key": "conf/oopsla/NierstraszP90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97964", + "title": "Strong Typing of Object-Oriented Languages Revisited", + "abstract": "This paper is concerned with the relation between subtyping and subclassing and their inuence on programming language design. Traditionally subclassing as introduced by Simula has also been used for dening a hierarchical type system. The type system of a language can be characterized as strong or weak and the type checking mechanism as static or dynamic. Parameterized classes in combination with a hierarchical type-system is an example of a language construct that is known to create complicated type checking situations. In this paper these situations are analyzed and several dierent solutions are found. It is argued that an approach with a combination of static and dynamic type checking gives a reasonable balance also here. It is also concluded that this approach makes it possible to base the type system on the class/subclass mechanism. 2 1 Introduction The purpose of this paper is to contribute to the clarication of typing issues in object-oriented languages. The is...", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97964", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ole Lehrmann", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Boris", + "last_name": "Magnusson", + "institution": "Lund University" + }, + { + "first_name": "Birger", + "last_name": "Mølier-Pedersen", + "institution": "Norwegian Computing Center" + } + ], + "dblp_key": "conf/oopsla/MadsenMM90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97956", + "title": "Beyond Schema Evolution to Database Reorganization", + "abstract": "While the contents of databases can be easily changed, their organization is typically extremely rigid. Some databases relax the rigidity of database organization somewhat by supporting simple changes to individual schemas. As described in this paper, OTGen supports not only more complex schema changes, but also database reorganization. A database administrator uses a declarative notation to describe mappings between objects created with old versions of schemas and their corresponding representations using new versions. OTGen generates a transformer that applies the mappings to update the database to the new definitions, thus facilitating improvements in performance, functionality, and usability of the database.1", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97956", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Barbara", + "last_name": "Lerner", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "A. N.", + "last_name": "Habermann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/LernerH90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97971", + "title": "Type Consistency of Queries in an Object-Oriented Database System", + "abstract": "Queries in object-oriented databases can return non-homogeneous sets of objects when no type restrictions are placed on the inputs to the query. The tradition has been to force homogeneity on the result by restricting the types of the inputs. This restricts the range of permissible, and possibly useful, queries. We propose a type consistency theory for queries in object-oriented databases which supports the existence of multiple types in the query result. The technique is illustrated by developing type inference rules for an object algebra. The main result is that the loss of type information associated with a query operation is reduced in most cases. We also show how type information is increased when queries are qualified by conjunctive predicates.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97971", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dave D.", + "last_name": "Straube", + "institution": "Banyan Biomarkers (United States)" + }, + { + "first_name": "M. Tamer", + "last_name": "Özsu", + "institution": "University of Alberta" + } + ], + "dblp_key": "conf/oopsla/StraubeO90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97965", + "title": "Type Substitution for Object-Oriented Programming", + "abstract": "Genericity allows the substitution of types in a class. This is usually obtained through parameterized classes, although they are inflexible since any class can be inherited but is not in itself parameterized. We suggest a new genericity mechanism, type substitution, which is a subclassing concept that complements inheritance: any class is generic, can be “instantiated” gradually without planning, and has all of its generic instances as subclasses.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97965", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Aarhus University" + }, + { + "first_name": "Michael I.", + "last_name": "Schwartzbach", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/oopsla/PalsbergS90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97985", + "title": "OOPSLA Distributed Object Management (Panel)", + "abstract": "article Free Access Share on OOPSLA distributed object management Authors: John R. Rymer Seybold Office Computing Group, Moderator Seybold Office Computing Group, ModeratorView Profile , Richard Mark Soley Vice President, Object Management Group Vice President, Object Management GroupView Profile , William Stephen Andreas Staff Software Engineer, Distributed Applications Architecture, Data General Staff Software Engineer, Distributed Applications Architecture, Data GeneralView Profile , Ian Fuller Project Manager, Distributed New Wave Application Architecture, Hewlett-Packard Project Manager, Distributed New Wave Application Architecture, Hewlett-PackardView Profile , Neal Jacobson Principal Engineer, Distributed Information Systems, Digital Equipment Corp. Principal Engineer, Distributed Information Systems, Digital Equipment Corp.View Profile , Richard A. Demers Distributed Data Management Architecture, IBM Distributed Data Management Architecture, IBMView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 25Issue 10Oct. 1990 pp 331–333https://doi.org/10.1145/97946.97985Published:01 September 1990Publication History 0citation229DownloadsMetricsTotal Citations0Total Downloads229Last 12 Months10Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97985", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John R.", + "last_name": "Rymer", + "institution": "" + }, + { + "first_name": "Richard Mark", + "last_name": "Soley", + "institution": "Object Computing (United States)" + }, + { + "first_name": "William Stephen", + "last_name": "Andreas", + "institution": "" + }, + { + "first_name": "Ian", + "last_name": "Fuller", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Neal", + "last_name": "Jacobson", + "institution": "Digital Equipment (Germany)" + }, + { + "first_name": "Richard A.", + "last_name": "Demers", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/RymerSAFJD90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97975", + "title": "Painting Multiple Views of Complex Objects", + "abstract": "This paper reviews and illustrates a direct manipulation approach to visualization of complex objects called painting multiple views. We describe a programming model for direct manipulation in general and for painting in particular, based on simple constraints between entities in an the underlying scientific database and the components of displays used to examine the data. With this model, the original notion of “brushing scatterplots” is easily extended.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97975", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John A.", + "last_name": "McDonald", + "institution": "University of Washington" + }, + { + "first_name": "Werner", + "last_name": "Stuetzle", + "institution": "University of Washington" + }, + { + "first_name": "Andreas", + "last_name": "Buja", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/McDonaldSB90", + "venue": "oopsla", + "year": 1990 + }, + { + "paper_id": "10.1145/97945.97976", + "title": "MoDE: A UIMS for Smalltalk", + "abstract": "While the Model-View-Controller (MVC) framework has contributed to many aspects of user interface development in Smalltalk, interfaces produced with MVC often have highly coupled model, view, and controller classes. This coupling and the effort required to use MVC make user interface creation a less effective aspect of Smalltalk.", + "date": "1990-09-01", + "link": "https://doi.org/10.1145/97945.97976", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yen-Ping", + "last_name": "Shan", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Shan90", + "venue": "oopsla", + "year": 1990 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1991.json b/data/pl_conferences/oopsla/1991.json new file mode 100644 index 0000000..2608cc9 --- /dev/null +++ b/data/pl_conferences/oopsla/1991.json @@ -0,0 +1,645 @@ +[ + { + "paper_id": "10.1145/117954.117971", + "title": "Communication as Fair Distribution of Knowledge", + "abstract": "Ve introduce an abstract form of interobject communication for object-oriented concurrent programming based on the proof theory of Linear Logic, a logic introduced to provide a theoretical basis for the study of concurrency. Such a form of communication, which we call forumbased communication, can be seen as a refinement of blackboard-based communication in terms of a more local notion of resource consumption.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117971", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jean‐Marc", + "last_name": "Andreoli", + "institution": "" + }, + { + "first_name": "Remo", + "last_name": "Pareschi", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/AndreoliP91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117970", + "title": "Towards a Metrics Suite for Object Oriented Design", + "abstract": "\"June 1991.\"", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117970", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shyam R.", + "last_name": "Chidamber", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Chris F.", + "last_name": "Kemerer", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ChidamberK91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117964", + "title": "A Static Type System for Message Passing", + "abstract": "Much research has been performed with the aim of isolating the basic notions of object-oriented languages and of describing them by basic operators which can be embedded in strongly-typed languages. In this context we define an atomic linguistic construct to capture the notion of message passing, and we define a static and strong type system, based on subtyping, for this construct. Message passing is modelled as the application of an overloaded function, whose behavior is determined only at compile-time on the basis of the class which created a distinguished argument, the object \"receiving\" the message. By embedding this mechanism in a strongly-typed language with subtyping and abstract data types we can obtain the full functionality of object-oriented languages. We show that this approach is strictly more expressive then the usual interpretation of message passing as selection plus application of a functional record field.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117964", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Giorgio", + "last_name": "Ghelli", + "institution": "University of Pisa" + } + ], + "dblp_key": "conf/oopsla/Ghelli91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117959", + "title": "Portia: AN Instance-Centered Environment for Smalltalk", + "abstract": "Smalltalk environments should accommodate programmers' conceptualizations of objects as independent, communicating agents by providing tools that allow them to work directly with instances. This paper discusses the requirements for such an environment, assesses the standard Smalltalk environment in this respect, and describes an enhanced Smalltalk environment called Portia which provides additional facilities for interacting with instances.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117959", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Gold", + "institution": "Interface (United States)" + }, + { + "first_name": "Mary Beth", + "last_name": "Rosson", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/GoldR91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117972", + "title": "The Kala Basket: A Semantic Primitive Unifying Object Transactions, Access Control, Versions, and Configurations", + "abstract": "Kala is an untyped persistent store for practical object-based systems, such as OODBMS, OMS, and object-oriented languages with persistence. Baskets are dynamic groupings of immutable data elements managed by Kala. Baskets synthesize transaction, configuration management, and access control semantics, and thus offer a platform for implementing arbitrary such models. In this article we introduce Kala baskets, their design motivations and goals. We then explain Kala's basket mechanism in some detail. Finally, we offer a few examples of how baskets are used to implement features of arbitrary transaction, configuration, and access models.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117972", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sergui S.", + "last_name": "Simmel", + "institution": "Samsung (United States)" + }, + { + "first_name": "Ivan", + "last_name": "Godard", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SimmelG91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117969", + "title": "An Empirical Study of the Object-Oriented Paradigm and Software Reuse", + "abstract": "Little or no empirical validation exists for many of software engineering's basic assumptions. While some of these assumptions are intuitive, the need for scientific experimentation remains clear. Several assumptions are made about the factors affecting software reuse, and in particular, the role of the object-oriented paradigm. This paper describes the preliminary results of a controlled experiment designed to evaluate the impact of the object-oriented paradigm on software reuse. The experiment concludes that (1) the object-oriented paradigm substantially improves productivity, although a significant part of this improvement is due to the effect of reuse, (2) reuse without regard to language paradigm improves productivity, (3) language differences are far more important when programmers reuse than when they do not, and (4) the object-oriented paradigm has a particular affinity to the reuse process.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117969", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John A.", + "last_name": "Lewis", + "institution": "Virginia Tech" + }, + { + "first_name": "Sallie M.", + "last_name": "Henry", + "institution": "Virginia Tech" + }, + { + "first_name": "Dennis G.", + "last_name": "Kafura", + "institution": "Virginia Tech" + }, + { + "first_name": "Robert S.", + "last_name": "Schulman", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/oopsla/LewisHKS91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117960", + "title": "Developing a GUIDE Using Object-Oriented Programming", + "abstract": "PICASSO is a graphical user interface development en-vironment built using the Common Lisp Object System (CLOS). This paper describes how CLOS features in-cluding multiple inheritance, instance methods, multi-methods, and method combinations were used to imple-ment the system. In addition, the benefits and draw-backs of CLOS development are discussed including code quality, maintainability and performance. 1.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117960", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph A.", + "last_name": "Konstan", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Lawrence A.", + "last_name": "Rowe", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/KonstanR91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117958", + "title": "Integrating Information Retrieval and Domain Specific Approaches for Browsing and Retrieval in Object-Oriented Class Libraries", + "abstract": "Article Integrating information retrieval and domain specific approaches for browsing and retrieval in object-oriented class libraries Share on Authors: Richard Helm I.B.M. Thomas J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY I.B.M. Thomas J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile , Yoëlle S. Maarek I.B.M. Thomas J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY I.B.M. Thomas J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile Authors Info & Claims OOPSLA '91: Conference proceedings on Object-oriented programming systems, languages, and applicationsNovember 1991 Pages 47–61https://doi.org/10.1145/117954.117958Online:01 November 1991Publication History 40citation526DownloadsMetricsTotal Citations40Total Downloads526Last 12 Months6Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117958", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard F.", + "last_name": "Helm", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Yoelle", + "last_name": "Maarek", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/HelmM91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117974", + "title": "The Economics of Software Reuse (Panel)", + "abstract": "article Free Access Share on The economics of software reuse Authors: Martin Griss Hewlett-Packard Laboratories Hewlett-Packard LaboratoriesView Profile , Sam S. Adams Knowledge Systems Corporation Knowledge Systems CorporationView Profile , Howard Baetjer Agorics Project, George Mason University Agorics Project, George Mason UniversityView Profile , Brad J. Cox Information Age Consulting Information Age ConsultingView Profile , Adele Goldberg ParcPlace Systems ParcPlace SystemsView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 11Nov. 1991 pp 264–270https://doi.org/10.1145/118014.117974Online:01 November 1991Publication History 4citation651DownloadsMetricsTotal Citations4Total Downloads651Last 12 Months26Last 6 weeks7 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117974", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Griss", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Sam S.", + "last_name": "Adams", + "institution": "Knowledge Systems Institute" + }, + { + "first_name": "Howard", + "last_name": "Baetjer", + "institution": "George Mason University" + }, + { + "first_name": "Brad", + "last_name": "Cox", + "institution": "" + }, + { + "first_name": "Adele", + "last_name": "Goldberg", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/GrissABCG91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117981", + "title": "OOP and AI (Panel)", + "abstract": "No abstract available.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117981", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel G.", + "last_name": "Bobrow", + "institution": "" + }, + { + "first_name": "Carl", + "last_name": "Hewitt", + "institution": "" + }, + { + "first_name": "Jean-François", + "last_name": "Perror", + "institution": "" + }, + { + "first_name": "R. E.", + "last_name": "Smith", + "institution": "" + }, + { + "first_name": "Howard", + "last_name": "Shrobe", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/IbrahimBHPSS91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117975", + "title": "Islands: Aliasing Protection in Object-Oriented Languages", + "abstract": "article Free Access Share on Islands: aliasing protection in object-oriented languages Author: John Hogg Bell-Northern Research, Ottawa, Ontario Bell-Northern Research, Ottawa, OntarioView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 11Nov. 1991 pp 271–285https://doi.org/10.1145/118014.117975Online:01 November 1991Publication History 211citation884DownloadsMetricsTotal Citations211Total Downloads884Last 12 Months30Last 6 weeks8 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117975", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Hogg", + "institution": "Bell (Canada)" + } + ], + "dblp_key": "conf/oopsla/Hogg91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117968", + "title": "Coherent Models for Object-Oriented Analysis", + "abstract": "Analysis is intended for the formulation and communication of domain descriptions.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117968", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fiona", + "last_name": "Hayes", + "institution": "Hewlett-Packard (United Kingdom)" + }, + { + "first_name": "Derek", + "last_name": "Coleman", + "institution": "Hewlett-Packard (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/HayesC91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117978", + "title": "Experiences in DBMS Implementation Using an Object-Oriented Persistent Programming Language and a Database Toolkit", + "abstract": "Article Free Access Share on Experiences in DBMS implementation using an object-oriented persistent programming language and a database toolkit Authors: Eric N. Hanson Artificial Intelligence Technology Office (WL/AAA-1), Air Force Wright Laboratory, Wright-Patterson AFB, OH and Wright State University Artificial Intelligence Technology Office (WL/AAA-1), Air Force Wright Laboratory, Wright-Patterson AFB, OH and Wright State UniversityView Profile , Tina M. Harvey 7th Communications Group/DOWI, The Pentagon, Washington DC and Department of Electrical and Computer Engineering, Air Force Institute of Technology 7th Communications Group/DOWI, The Pentagon, Washington DC and Department of Electrical and Computer Engineering, Air Force Institute of TechnologyView Profile , Mark A. Roth Department of Electrical and Computer Engineering (AFIT/ENG), Air Force Institute of Technology, Wright-Patterson AFB, OH Department of Electrical and Computer Engineering (AFIT/ENG), Air Force Institute of Technology, Wright-Patterson AFB, OHView Profile Authors Info & Claims OOPSLA '91: Conference proceedings on Object-oriented programming systems, languages, and applicationsNovember 1991 Pages 314–328https://doi.org/10.1145/117954.117978Published:01 November 1991Publication History 4citation718DownloadsMetricsTotal Citations4Total Downloads718Last 12 Months19Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117978", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric N.", + "last_name": "Hanson", + "institution": "Wright State University" + }, + { + "first_name": "Tina M.", + "last_name": "Harvey", + "institution": "U.S. Air Force Institute of Technology" + }, + { + "first_name": "Mark A.", + "last_name": "Roth", + "institution": "U.S. Air Force Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/HansonHR91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117965", + "title": "Object-Oriented Type Inference", + "abstract": "We present a new approach to inferring types in untyped object-oriented programs with inheritance, assignments, and late binding. It guarantees that all messages are understood, annotates the program with type information, allows polymorphic methods, and can be used as the basis of an optimizing compiler.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117965", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Aarhus University" + }, + { + "first_name": "Michael I.", + "last_name": "Schwartzbach", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/oopsla/PalsbergS91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117961", + "title": "Building Generic User Interface Tools: an Experience with Multiple Inheritance", + "abstract": "Article Free Access Share on Building generic user interface tools: an experience with multiple inheritance Author: Nuno Guimarães AT&T Bell Laboratories, NJ, IST/INESC, Lisbon, Portugal, R.Alves Redol, 9, 6o., 1000 Lisboa AT&T Bell Laboratories, NJ, IST/INESC, Lisbon, Portugal, R.Alves Redol, 9, 6o., 1000 LisboaView Profile Authors Info & Claims OOPSLA '91: Conference proceedings on Object-oriented programming systems, languages, and applicationsNovember 1991 Pages 89–96https://doi.org/10.1145/117954.117961Published:01 November 1991Publication History 4citation356DownloadsMetricsTotal Citations4Total Downloads356Last 12 Months21Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117961", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nuno", + "last_name": "Guimarães", + "institution": "Institute for Systems Engineering and Computers" + } + ], + "dblp_key": "conf/oopsla/Guimaraes91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117967", + "title": "Formal Techniques for OO Software Development (Panel)", + "abstract": "Article Free Access Share on Formal techniques for OO software development Authors: Pierre America Philips Research Laboratories Philips Research LaboratoriesView Profile , Derek Coleman HP-Lab Bristol HP-Lab BristolView Profile , Roger Duke University of Queensland University of QueenslandView Profile , Doug Lea Syracuse University & SUNY-Oswego Syracuse University & SUNY-OswegoView Profile , Gary Leavens Iowa State University Iowa State UniversityView Profile Authors Info & Claims OOPSLA '91: Conference proceedings on Object-oriented programming systems, languages, and applicationsNovember 1991 Pages 166–170https://doi.org/10.1145/117954.117967Published:01 November 1991Publication History 2citation376DownloadsMetricsTotal Citations2Total Downloads376Last 12 Months13Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117967", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pierre", + "last_name": "America", + "institution": "Philips (India)" + }, + { + "first_name": "Derek", + "last_name": "Coleman", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Roger", + "last_name": "Duke", + "institution": "University of Queensland" + }, + { + "first_name": "Doug", + "last_name": "Lea", + "institution": "Syracuse University" + }, + { + "first_name": "Gary T.", + "last_name": "Leavens", + "institution": "Iowa State University" + } + ], + "dblp_key": "conf/oopsla/ChampeauxACDLLH91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117955", + "title": "Making Pure Object-Oriented Languages Practical", + "abstract": "In the past, object-oriented language designers and programmers have been forced to choose between pure message passing and performance. Last year, our SELF system achieved close to half the speed of optimized C but suffered from impractically long compile times. Two new optimization techniques, deferred compilation of uncommon cases and non-backtracking splitting using path objects, have improved compilation speed by more than an order of magnitude. SELF now compiles about as fast as an optimizing C compiler and runs at over half the speed of optimized C. This new level of performance may make pure object-oriented languages practical. 1 Introduction In the past, object-oriented language designers and programmers have been forced to choose between purity and performance. In a pure object-oriented language, all computation, even low-level operations like variable accessing, arithmetic, and array indexing, is performed by sending messages to objects. Although a message send may cost o...", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117955", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/ChambersU91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117983", + "title": "How to Get Your Paper Accepted at OOPSLA", + "abstract": "No abstract available.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117983", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alan", + "last_name": "Snyder", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Snyder91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117979", + "title": "Symbolic and Spatial Database for Structural Biology", + "abstract": "article Free AccessSymbolic and spatial database for structural biology Share on Authors: Dan Benson Department of Electrical Engineering, FT-10, University of Washington/Seattle, WA Department of Electrical Engineering, FT-10, University of Washington/Seattle, WAView Profile , Greg Zick Department of Electrical Engineering, FT-10, University of Washington/Seattle, WA Department of Electrical Engineering, FT-10, University of Washington/Seattle, WAView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 11Nov. 1991 pp 329–339https://doi.org/10.1145/118014.117979Online:01 November 1991Publication History 3citation349DownloadsMetricsTotal Citations3Total Downloads349Last 12 Months3Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117979", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dan", + "last_name": "Benson", + "institution": "University of Washington" + }, + { + "first_name": "Greg", + "last_name": "Zick", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/BensonZ91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117982", + "title": "Managing the Transition to Object-Oriented Technology (Panel)", + "abstract": "No abstract available.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117982", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nelson", + "last_name": "Hazeltine", + "institution": "" + }, + { + "first_name": "Tim", + "last_name": "Higenberg", + "institution": "" + }, + { + "first_name": "Reed", + "last_name": "Philip", + "institution": "" + }, + { + "first_name": "David P.", + "last_name": "Taylor", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KorsonHHPT91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117957", + "title": "Using Key Object Opportunism to Collect Old Objects", + "abstract": "and deallocation data gathered for the Cedar system on Xerox Dorados supports the weak generational hypothesis! newly-created objects have a much lower survival rate than objects that are older.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117957", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Barry", + "last_name": "Hayes", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/Hayes91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117963", + "title": "Static Type Checking of Multi-Methods", + "abstract": "Multi-methods allow method selection to be based on the types of any number of arguments.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117963", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rakesh", + "last_name": "Agrawal", + "institution": "IBM Research - Almaden" + }, + { + "first_name": "Linda G.", + "last_name": "DeMichiel", + "institution": "IBM (United States)" + }, + { + "first_name": "Bruce G.", + "last_name": "Lindsay", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/AgrawalDL91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117962", + "title": "Composite Multimedia and Active Objects", + "abstract": "An object-oriented framework for composite multimedia is described. In analogy to constructing complex graphics entities from graphics primitives and geometric transformations, composite multimedia is constructed from multimedia primitives and temporal transformations. Active objects based on real-time processes are proposed as multimedia primitives. Their combination to form composite multimedia and the requisite temporal transformations are illustrated. 1. Introduction The improving capabilities of multimedia workstations, combined with the development of multimedia recording formats (for example, CD-I and DVI, see [14] for a recent description) is likely to increase the demand for applications involving multimedia. However the development of multimedia applications is presently hampered by two key problems: First, multimedia involves concepts from audio recording, video production, animation, and music -- concepts that are novel to many programmers. Second, multimedia operations of...", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117962", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Simon", + "last_name": "Gibbs", + "institution": "University of Geneva" + } + ], + "dblp_key": "conf/oopsla/Gibbs91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117977", + "title": "Object-Preserving Class Transformations", + "abstract": "Reorganization of classes for object-oriented programming and object-oriented database design has recently received considerable attention in the literature. In this paper a small set of primitive transformations is presented which forms an orthogonal basis for object-preserving class reorganizations. This set is proven to be correct, complete, and minimal. The primitive transformations help form a theoretical basis for class organization and are a powerful tool for reasoning about particular organizations. Keywords: Object-oriented programming and design, object-oriented database design, class library organization. 1 Introduction Reorganization of classes for object-oriented programming and object-oriented database design has recently received considerable attention in the literature: [BCG + 87], [LBSL90], [LBSL91], [AH87], [BMW86], [Cas89], [Cas90], [LM91], [Pir89], [PW89]. A number of researchers have suggested algorithms and hueristics to produce &quot;good&quot; class organizations. A ...", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117977", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul L.", + "last_name": "Bergstein", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/Bergstein91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117966", + "title": "Issues in Moving from C to C++ (Panel)", + "abstract": "article Free Access Share on Issues in moving from C to C++ Authors: David R. Reed Saber Software Inc., Saber Software Inc.,View Profile , Marty Cagan Interactive Development Environments Interactive Development EnvironmentsView Profile , Ted Goldstein Sun Laboratories Sun LaboratoriesView Profile , Barbara Moo AT&T AT&TView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 11Nov. 1991 pp 163–165https://doi.org/10.1145/118014.117966Online:01 November 1991Publication History 1citation357DownloadsMetricsTotal Citations1Total Downloads357Last 12 Months11Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117966", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David R.", + "last_name": "Reed", + "institution": "" + }, + { + "first_name": "Marty", + "last_name": "Cagan", + "institution": "Interactive Research and Development" + }, + { + "first_name": "Ted", + "last_name": "Goldstein", + "institution": "" + }, + { + "first_name": "Barbara E.", + "last_name": "Moo", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/oopsla/ReedCGM91", + "venue": "oopsla", + "year": 1991 + }, + { + "paper_id": "10.1145/117954.117976", + "title": "Equate: An Object-Oriented Constraint Solver", + "abstract": "This paper presents a constraint-solving method that obeys the principle of object encapsulation. Under this method, constraints are translated into procedures for achieving constraint satisfaction. Neither the constraints nor their procedural translations refer directly to an object's implementation; all object references are through the interfaces provided by classes. Translation is performed using definite-clause backward chaining, a technique borrowed from logic programming.", + "date": "1991-11-01", + "link": "https://doi.org/10.1145/117954.117976", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael R.", + "last_name": "Wilk", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/oopsla/Wilk91", + "venue": "oopsla", + "year": 1991 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1992.json b/data/pl_conferences/oopsla/1992.json new file mode 100644 index 0000000..fa61836 --- /dev/null +++ b/data/pl_conferences/oopsla/1992.json @@ -0,0 +1,879 @@ +[ + { + "paper_id": "10.1145/141936.141939", + "title": "Monotonic Conflict Resolution Mechanisms for Inheritance", + "abstract": "The main topic of this paper is multiple inheritance and conflict resolution methods in Object Oriented Programming. Our aim is to develop sound mechanisms easily understandable to any user. For this purpose, coherent behaviors of conflict resolution methods for multiple inheritance (such as supporting incrementality-monotonicity and stability under link subdivision) are introduced. We present interesting examples in which multiple inheritance known linearization algorithms (such as in CLOS [2] and LOOPS [19]) behave badly. Then we carefully study the conditions (on the inheritance graph) which assure good linearizations. We end with some suggestions for an incremental inheritance algorithm.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141939", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roland", + "last_name": "Ducournau", + "institution": "" + }, + { + "first_name": "Michel", + "last_name": "Habib", + "institution": "" + }, + { + "first_name": "Marianne", + "last_name": "Huchard", + "institution": "" + }, + { + "first_name": "Marie-Laure", + "last_name": "Mugnier", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/DucournauHHM92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141947", + "title": "Optimizing Method Search with Lookup Caches and Incremental Coloring", + "abstract": "An efficient mechanism for method lookup is csscntial in any reasonable implementation of a clussbased object-oriented language.One tcchniquc, static caches, provide constant time lookup, but consumes cxcessive memory.To alleviate the memory consumption problem many systems USC a coloring schcmc that allows cache rows to be shared and thus reduces the ovcrall cache size.This technique is easily implcmcntcd I'OI stongly typed languages such as C++ and Eiffcl, but not for languages such as CLOS or Smalltalk.This papct provides a solution to this latter problem: that of coloring for static caches in dynamically typed objcct-oricnted languages.Our solution is to use an incrcmcntal coloring algorithm to avoid the memory consumption problems of the naive approach. l-IntroductionObject-oriented programming is an attractive programming sub-paradigm for many reasons, not the lcast of which are: polymorphism, encapsulation, mcssagc", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141947", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pascal", + "last_name": "André", + "institution": "Droit et changement social" + }, + { + "first_name": "Jean-Claude", + "last_name": "Royer", + "institution": "Droit et changement social" + } + ], + "dblp_key": "conf/oopsla/AndreR92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141964", + "title": "Concurrency Annotations", + "abstract": "Widespread acceptance of concurrent objectoriented programming in the field can only be expected if smooth integration with sequential programming is achieved. This means that a common language base has to be used, where the concurrent syntax differs as little as possible from the sequential one but is associated with a \"natural\" concurrent semantics that makes library support for concurrency superfluous. In addition, not only should sequential classes be reusable in a concurrent context, but concurrent classes should also be reusable in a sequential context. It is suggested that cmcurrcmy nnnofutions be inserted into otherwise sequential code. They are ignored by a sequential compiler, but a compiler for the extended concurrent language will recognize them and generate the appropriate concurrent code, The concurrent version of the language supports active and concurrent objects and favours a declarative approach to synchronization and locking which solves typical concurrency problems in an easier and more readable way than previous approaches. Concurrency annotations are introduced using E@ieZ as the sequential base.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141964", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Klaus‐Peter", + "last_name": "Löhr", + "institution": "Freie Universität Berlin" + } + ], + "dblp_key": "conf/oopsla/Lohr92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141951", + "title": "ET++ Swaps Manager: Using Object Technology in the Financial Engineering Domain", + "abstract": "article ET++SwapsManager: using object technology in the financial engineering domain Share on Authors: Thomas Eggenschwiler View Profile , Erich Gamma View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 166–177https://doi.org/10.1145/141937.141951Online:31 October 1992Publication History 14citation402DownloadsMetricsTotal Citations14Total Downloads402Last 12 Months3Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141951", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Eggenschwiler", + "institution": "University of Zurich" + }, + { + "first_name": "Erich", + "last_name": "Gamma", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/EggenschwilerG92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141973", + "title": "Architectures with Pictures", + "abstract": "article Architectures with pictures Share on Authors: Raymond J. A. Buhr View Profile , Ronald S. Casselman View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 466–483https://doi.org/10.1145/141937.141973Online:31 October 1992Publication History 14citation395DownloadsMetricsTotal Citations14Total Downloads395Last 12 Months7Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141973", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "R. J. A.", + "last_name": "Buhr", + "institution": "" + }, + { + "first_name": "Ronald", + "last_name": "Casselman", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BuhrC92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141952", + "title": "Preliminary Defect Data from the Iterative Development of a Large C++ Program", + "abstract": "article Free Access Share on Preliminary defect data from the iterative development of a large C++ program (experience report) Author: James F. Walsh View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 178–183https://doi.org/10.1145/141937.141952Online:31 October 1992Publication History 4citation412DownloadsMetricsTotal Citations4Total Downloads412Last 12 Months18Last 6 weeks5 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141952", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James F.", + "last_name": "Walsh", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Walsh92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141938", + "title": "Interfaces and Specifications for the Smalltalk-80 Collection Classes", + "abstract": "The hierarchy of interfaces implicit in the Smalltalk-collection class library is computed and analyzed. The interface hierarchy is independent of the inheritance hierarchy because methods are frequently deleted by subclasses, and because unrelated classes sometimes implement the same messages.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141938", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/oopsla/Cook92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141942", + "title": "The Process of Object-Oriented Design", + "abstract": "The object-oriented design process is investigated within the classic software development classification of Analysis, Design, and Implementation. When all development is performed using object oriented methods, OOD is best characterized as a transformational process, mapping declarative descriptions of objects and classes to implementation plans.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141942", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dennis de", + "last_name": "Champeaux", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Doug", + "last_name": "Lea", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Penelope", + "last_name": "Faure", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/ChampeauxLF92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141948", + "title": "Object-Oriented Concurrent Reflective Languages can be Implemented Efficiently", + "abstract": "Computational reflection is beneficial in concurrent computing in offering a linguistic mechanism for incorporating user-specific policies. New challenges are (1) how to implement them, and (2) how to do so efficiently. We present efficient implementation schemes for object-oriented concurrent reflective languages using our language ABCL/R2 as an example. The schemes include: efficient lazy creation of metaobjects/meta-groups, partial compilation of scripts (methods), dynamic progression, self-reification, and light-weight objects, all appropriately integrated so that the user-level semantics remain consistent with the meta-circular definition so that the full power of reflection is retained, while achieving practical efficiency. ABCL/R2 exhibits two orders of magnitude speed improvement over its predecessor, ABCL/R, and in fact compares favorably to the ABCL/1 compiler and also C + Sun LWP, neither supporting reflection. 3 To be presented at ACM OOPSLA&apos;92, Vancouver, Canada, Oct. 199...", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141948", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hidehiko", + "last_name": "Masuhara", + "institution": "" + }, + { + "first_name": "Satoshi", + "last_name": "Matsuoka", + "institution": "" + }, + { + "first_name": "Takuo", + "last_name": "Watanabe", + "institution": "" + }, + { + "first_name": "Akinori", + "last_name": "Yonezawa", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MasuharaMWY92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141957", + "title": "Distributed Shared Memory with Versioned Objects", + "abstract": "Distributed Object Memory (DOM) is an abstraction that represents a distributed-memory system as a single shared container of language-level objects. The goal of DOM is to simplify programming of parallel applications for such systems. All accesses to shared memory are made relative to objects that reside in one or more node-local memories. For example, in Amber, a DOM system for a network of workstations, remote references are transparent at the language level and are implemented using either remote procedure call or object replication and migration. While DOM can greatly simplify distribution for many application classes, it is not well suited for all domains (parallel-scientific codes, in particular). To address the shortcomings of DOM for such domains, we introduce Versioned DOM (VDOM). In VDOM a version number is associated with each object. Multiple versions of objects can coexist and may be cached in local memories as needed to in- This work was supported in part by the Nationa...", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141957", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael J.", + "last_name": "Feeley", + "institution": "University of Washington" + }, + { + "first_name": "Henry M.", + "last_name": "Levy", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/FeeleyL92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141974", + "title": "The OO Software Development Process (Panel)", + "abstract": "Article Free Access Share on The OO software development process (panel) Authors: Dennis de Champeaux View Profile , Bob Balzer View Profile , Dave Bulman View Profile , Kathleen Culver-Lozo View Profile , Ivar Jacobson View Profile , Stephen J. Mellor View Profile Authors Info & Claims OOPSLA '92: Conference proceedings on Object-oriented programming systems, languages, and applicationsOctober 1992Pages 484–489https://doi.org/10.1145/141936.141974Published:31 October 1992Publication History 0citation383DownloadsMetricsTotal Citations0Total Downloads383Last 12 Months9Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141974", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dennis de", + "last_name": "Champeaux", + "institution": "" + }, + { + "first_name": "Bob", + "last_name": "Balzer", + "institution": "" + }, + { + "first_name": "D.M.", + "last_name": "Bulman", + "institution": "" + }, + { + "first_name": "Kathleen", + "last_name": "Culver-Lozo", + "institution": "AT&T (United States)" + }, + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "" + }, + { + "first_name": "Stephen J.", + "last_name": "Mellor", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ChampeauxBBCJM92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141965", + "title": "Obstacles in Object-Oriented Software Development", + "abstract": "No abstract available.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141965", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mehmet", + "last_name": "Akşit", + "institution": "University of Twente" + }, + { + "first_name": "Lodewijk", + "last_name": "Bergmans", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/AksitB92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141950", + "title": "The Object-Oriented Implementation of a Document Editor", + "abstract": "Traditional document editors are large and complex. Using first-class objects to represent individual characters in a document, we have implemented an editor that is much smaller and simpler than editors of comparable power. This editor, named \"Dot\", uses object sharing to reduce memory usage and an incremental update strategy to minimize screen redraw time.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141950", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "Calder", + "institution": "Flinders University" + }, + { + "first_name": "Mark", + "last_name": "Linton", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/CalderL92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141944", + "title": "What Contributes to Successful Object-Oriented Learning?", + "abstract": "There are many conjectures about what sort of person most readily lcams object-oriented tcchnology. While often provocative, none have been confirmed by reliable studies. We describe the first serious attempt to look for factors influencing successful object-oriented learning, by studying scvcral hundred students in introductory objcctoticntcd programming courses. Contrary to what some have asscrtcd, WC lind that scvcral mcasurcs of depth and breadth of programming background arc associated with success.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141944", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chamond", + "last_name": "Liu", + "institution": "IBM (United States)" + }, + { + "first_name": "Stephen", + "last_name": "Goetze", + "institution": "IBM (United States)" + }, + { + "first_name": "Bill", + "last_name": "Glynn", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/LiuGG92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141961", + "title": "Ensuring Semantic Integrity of Reusable Objects (Panel)", + "abstract": "article Free Access Share on Ensuring semantic integrity of reusable objects (panel) Authors: Webb Stacy View Profile , Richard Helm View Profile , Gail E. Kaiser View Profile , Bertrand Meyer View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 298–302https://doi.org/10.1145/141937.141961Online:31 October 1992Publication History 4citation292DownloadsMetricsTotal Citations4Total Downloads292Last 12 Months2Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141961", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Webb", + "last_name": "Stacy", + "institution": "Software (Spain)" + }, + { + "first_name": "Richard F.", + "last_name": "Helm", + "institution": "" + }, + { + "first_name": "Gail E.", + "last_name": "Kaiser", + "institution": "Columbia University" + }, + { + "first_name": "Bertrand", + "last_name": "Meyer", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/StacyHKM92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141955", + "title": "Constraint Patterns As a Basis for Object-Oriented Programming", + "abstract": "This paper describes a general abstraction mechanism called a constraint pattern, with which an object oriented language can be built. In such a language, constraint patterns play the roles of code and data abstractions, and subsume classes, instance variables, methods and control structures. Constraint patterns, a conceptual blend and extension of BETA's patterns and Bertrand's augmented term rewriting rules, use equation solving for constraint satisfaction, method generation, and compilation. Basing a language on this abstraction makes simple equational constraints available as a fundamental language feature, integrated with the semantics.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141955", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bruce", + "last_name": "Horn", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/Horn92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141954", + "title": "Prototype-Based Languages: From a New Taxonomy to Constructive Proposals and Their Validation", + "abstract": "Prototype-based languages are currently proposed as a substitute to class-based languages for a higher flexibility in manipulating objects. These languages are all based on a similar set of basic principles: object-centered representation, dynamic addition (deletion) of slots, cloning and message delegation. But they all differ in the precise interpretation of these principles and nobody has yet considered the semantic issues raised by their combination. In this paper, we propose a new taxonomy of prototypebased languages, enhancing the Treaty of Orlando by now discussing issues associated with the different semantics of the identified prototype-based languages.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141954", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christophe", + "last_name": "Dony", + "institution": "Institut de Mathématiques de Jussieu-Paris Rive Gauche" + }, + { + "first_name": "Jacques", + "last_name": "Malenfant", + "institution": "Institut Marcel Mauss" + }, + { + "first_name": "Pierre", + "last_name": "Cointe", + "institution": "Institut Marcel Mauss" + } + ], + "dblp_key": "conf/oopsla/DonyMC92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141969", + "title": "Lightweight Shared Objects in a 64-Bit Operating System", + "abstract": "Object-oriented models are a popular basis for supporting uniform sharing of data and services in operating systems, distributed programming systems, and database systems. We term systems that use objects for these purposes object sharing systems. Operating systems in common use have nonuniform addressing models, making the uniform object naming required by object sharing systems expensive and difficult to implement. We argue that emerging 64-bit architectures make it practical to support uniform naming at the virtual addressing level, eliminating a key implementation problem for object sharing systems. We describe facilities for object-based sharing of persistent data and services in Opal, an operating system we are developing for paged 64-bit architectures. The distinctive feature of Opal is that object This paper will appear in identical form in the proceedings of the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), October 1992. This work w...", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141969", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeffrey S.", + "last_name": "Chase", + "institution": "University of Washington" + }, + { + "first_name": "Henry M.", + "last_name": "Levy", + "institution": "University of Washington" + }, + { + "first_name": "Edward D.", + "last_name": "Lazowska", + "institution": "University of Washington" + }, + { + "first_name": "Miche", + "last_name": "Baker-Harvey", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/ChaseLLB92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141966", + "title": "Object-Oriented System Modeling with OMT", + "abstract": "We describe our experience with the object-oriented design methodology OMT [19] applied to a project in an undergraduate software engineering course at Carnegie Mellon University. The project involved 30 students previously unfamiliar with objectoriented modeling. They designed and implemented a system of 125 classes (27,000 lines of C++ and C code) in the relatively short time of 15 weeks. We describe the overall structure of the project and the system model, the usefulness of OMT and its impact on communication, and discuss some of the problems encountered during the development of the system.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141966", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bernd", + "last_name": "Bruegge", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jim", + "last_name": "Blythe", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jeffrey C.", + "last_name": "Jackson", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jeff", + "last_name": "Shufelt", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/BrueggeBJS92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141962", + "title": "Communication Mechanism on Autonomous Objects", + "abstract": "In the concurrent object-oriented programming methodology, a system is described by concurrent objects which communicate with each others by various communication facilities, i.e., synchronous/asynchronous(future) message passing.Those facilities help up to implement application programs based on the client/server model.It is, however, difficult to describe application programs such that concurrent objects may simultaneously initiate communication with each other.Such objects are called autonomous objects.In this paper, we propose the notion of the visible and intensive sets, and a communication mechanism using those sets which enables us to handle communication among autonomous objects safely and easily.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141962", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yutaka", + "last_name": "Ishikawa", + "institution": "Electrotechnical Institute" + } + ], + "dblp_key": "conf/oopsla/Ishikawa92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.290556", + "title": "OOP in Languages Providing Strong, Static Typing (Panel)", + "abstract": "No abstract available.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.290556", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Bulman", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BulmanTMNK92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141967", + "title": "Case Study of Object-Oriented Software Development", + "abstract": "article Free Access Share on Case study of object-oriented software development Authors: Dennis de Champeaux View Profile , Al Anderson View Profile , Ed Feldhousen View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 377–391https://doi.org/10.1145/141937.141967Online:31 October 1992Publication History 9citation893DownloadsMetricsTotal Citations9Total Downloads893Last 12 Months8Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141967", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dennis de", + "last_name": "Champeaux", + "institution": "" + }, + { + "first_name": "Al", + "last_name": "Anderson", + "institution": "" + }, + { + "first_name": "Ed", + "last_name": "Feldhousen", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ChampeauxAF92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141946", + "title": "A Comparative Performance Evaluation of Write Barrier Implementations", + "abstract": "article Free Access Share on A comparative performance evaluation of write barrier implementation Authors: Antony L. Hosking View Profile , J. Eliot B. Moss View Profile , Darko Stefanovic View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 92–109https://doi.org/10.1145/141937.141946Online:31 October 1992Publication History 66citation607DownloadsMetricsTotal Citations66Total Downloads607Last 12 Months12Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141946", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Antony L.", + "last_name": "Hosking", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Darko", + "last_name": "Stefanović", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/HoskingMS92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141958", + "title": "CACL: Efficient Fine-Grained Protection for Objects", + "abstract": "CACL is a protection scheme for objects that offers a simple and flexible model of protection and has an efficient, software-only implementation. The model, based on Access Control Lists (ACLs) integrated with the type system, allows owners to control who may invoke which methods on which objects, permits cooperation between mutually suspicious principals, allows ownership of objects to be transferred safely, prevents unwanted propagation of authority between principals, and allows changes to the authorization information to take effect on the next method invocation. The implementation, based on the integration of Capabilities with method dispatch, avoids the overhead of access checking in the majority of invocations, at the cost of space for extra dispatch vectors. CACL offers a viable mechanism for finegrained protection in an object-oriented database system.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141958", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joel E.", + "last_name": "Richardson", + "institution": "IBM Research - Almaden" + }, + { + "first_name": "Peter", + "last_name": "Schwarz", + "institution": "IBM Research - Almaden" + }, + { + "first_name": "Luis-Felipe", + "last_name": "Cabrera", + "institution": "IBM Research - Almaden" + } + ], + "dblp_key": "conf/oopsla/RichardsonSC92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141943", + "title": "Documenting Frameworks using Patterns", + "abstract": "The documentation for a framework must meet several requirements.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141943", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/Johnson92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141940", + "title": "Combination of Inheritance Hierarchies", + "abstract": "to existing systems is a critically important activity in object-oriented pro-existing application.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141940", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Harold", + "last_name": "Ossher", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "William", + "last_name": "Harrison", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/OssherH92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141972", + "title": "Tunable Formalism in Object-Oriented Systems Analysis: Meeting the Needs of Both Theoreticians and Practitioners", + "abstract": "article Free Access Share on Turnable formalism in object-oriented systems analysis: meeting the needs of both theoreticians and practitioners Authors: Stephen W. Clyde View Profile , David E. Embley View Profile , Scott N. Woodfield View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 452–465https://doi.org/10.1145/141937.141972Published:31 October 1992Publication History 17citation355DownloadsMetricsTotal Citations17Total Downloads355Last 12 Months10Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141972", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen W.", + "last_name": "Clyde", + "institution": "" + }, + { + "first_name": "David E.", + "last_name": "Embley", + "institution": "" + }, + { + "first_name": "Scott N.", + "last_name": "Woodfield", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ClydeEW92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141953", + "title": "Declarative Programming in a Prototype-Instance System: Object-Oriented Programming Without Writing Methods", + "abstract": "article Free Access Share on Declarative programming in a prototype-instance system: object-oriented programming without writing methods Authors: Brad A. Myers View Profile , Dario A. Giuse View Profile , Brad Vander Zanden View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 184–200https://doi.org/10.1145/141937.141953Online:31 October 1992Publication History 37citation558DownloadsMetricsTotal Citations37Total Downloads558Last 12 Months14Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141953", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brad A.", + "last_name": "Myers", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Dario A.", + "last_name": "Giuse", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brad Vander", + "last_name": "Zanden", + "institution": "University of Tennessee at Knoxville" + } + ], + "dblp_key": "conf/oopsla/MyersGZ92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141963", + "title": "A Formalism for Real-Time Concurrent Object-Oriented Computing", + "abstract": "We investigate a formal model for reasoning about real-time object-oriented computations. The model is an extension of CCS with the notion of time, called RtCCS(Real-time Calculus of Communication Systems). It can naturally model real-time concurrent objects as communicating processes and represent the timed properties of objects. We define two timed equivalences based on CCS's bisimulation and derive algebraic laws for reasoning about real-time processes. The equivalences provide a formal framework for analyzing the behavior and timing of real-time computations.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141963", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ichiro", + "last_name": "Satoh", + "institution": "Keio University" + }, + { + "first_name": "Mario", + "last_name": "Tokoro", + "institution": "Keio University" + } + ], + "dblp_key": "conf/oopsla/SatohT92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141971", + "title": "Issues in the Design and Documentation of Class Libraries", + "abstract": "The design and specification of an extensible class library presents a difficult challenge:", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141971", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gregor", + "last_name": "Kiczales", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "John", + "last_name": "Lamping", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/KiczalesL92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141941", + "title": "Reuse: Truth or Fiction (Panel)", + "abstract": "article Free Access Share on Reuse (panel): truth or fiction Authors: Paul McCollough View Profile , Bob Atkinson View Profile , Adele Goldberg View Profile , Martin Griss View Profile , John Morrison View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 41–44https://doi.org/10.1145/141937.141941Published:31 October 1992Publication History 2citation231DownloadsMetricsTotal Citations2Total Downloads231Last 12 Months9Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141941", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "McCollough", + "institution": "" + }, + { + "first_name": "Bob", + "last_name": "Atkinson", + "institution": "" + }, + { + "first_name": "Adele", + "last_name": "Goldberg", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Griss", + "institution": "" + }, + { + "first_name": "J.", + "last_name": "Morrison", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/McCulloughAGGM92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141970", + "title": "The Apertos Reflective Operating System: The Concept and its Implementation", + "abstract": "Article Free Access Share on The Apertos reflective operating system: the concept and its implementation Author: Yasuhiko Yokote View Profile Authors Info & Claims OOPSLA '92: Conference proceedings on Object-oriented programming systems, languages, and applicationsOctober 1992Pages 414–434https://doi.org/10.1145/141936.141970Published:31 October 1992Publication History 177citation925DownloadsMetricsTotal Citations177Total Downloads925Last 12 Months83Last 6 weeks11 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141970", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yasuhiko", + "last_name": "Yokote", + "institution": "Sony Computer Science Laboratories" + } + ], + "dblp_key": "conf/oopsla/Yokote92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141956", + "title": "Experimental Classification Facilities for Smalltalk", + "abstract": "There have been a number of attempts to blend objectoriented programming languages with techniques commonly employed for knowledge representation in artificial intelligence. In the main, such exercises have entailed the incorporation of rule-based programming ideas into object-oriented languages, or the imposition of object-oriented constructs on logical programming notations.", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141956", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philip M.", + "last_name": "Yelland", + "institution": "BT Group (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/Yelland92", + "venue": "oopsla", + "year": 1992 + }, + { + "paper_id": "10.1145/141936.141968", + "title": "Object-Oriented Megaprogramming (Panel)", + "abstract": "article Free Access Share on Object-oriented megaprogramming (panel) Authors: Peter Wegner View Profile , William Scherlis View Profile , James Purtilo View Profile , David Luckham View Profile , Ralph Johnson View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 392–396https://doi.org/10.1145/141937.141968Published:31 October 1992Publication History 1citation258DownloadsMetricsTotal Citations1Total Downloads258Last 12 Months9Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1992-10-31", + "link": "https://doi.org/10.1145/141936.141968", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peter", + "last_name": "Wegner", + "institution": "" + }, + { + "first_name": "William L.", + "last_name": "Scherlis", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Purtilo", + "institution": "" + }, + { + "first_name": "D", + "last_name": "Luckham", + "institution": "" + }, + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/WegnerSPLJ92", + "venue": "oopsla", + "year": 1992 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1993.json b/data/pl_conferences/oopsla/1993.json new file mode 100644 index 0000000..f01399f --- /dev/null +++ b/data/pl_conferences/oopsla/1993.json @@ -0,0 +1,968 @@ +[ + { + "paper_id": "10.1145/165854.165886", + "title": "Object-Oriented Execution of OPS5 Production Systems", + "abstract": "article Object-oriented execution of OPS5 production systems Share on Authors: Mohammed H. Odeh View Profile , Julian A. Padget View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 178–190https://doi.org/10.1145/167962.165886Online:01 October 1993Publication History 3citation301DownloadsMetricsTotal Citations3Total Downloads301Last 12 Months4Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165886", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mohammed", + "last_name": "Odeh", + "institution": "" + }, + { + "first_name": "Julián", + "last_name": "Padget", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/OdehP93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165865", + "title": "Safe and Decidable Type Checking in an Object-Oriented Language", + "abstract": "Over the last several years, much interesting work has been done in modelling object-oriented programming languages in terms of extensions of the bounded second-order lambda calculus, F . Unfortunately, it has recently been shown by Pierce ([Pie92]) that type checking F is undecidable. Moreover, he showed that the undecidability arises in the seemingly simpler problem of determining whether one type is a subtype of another. In [Bru93a, Bru93b], the first author introduced a statically-typed, functional, object-oriented programming language, TOOPL, which supports classes, objects, methods, instance variables, subtypes, and inheritance. The semantics of TOOPL is based on F , so the question arises whether type checking in this language is decidable. In this paper we show that type checking for TOOPLE, a minor variant of TOOPL (Typed Object-Oriented Programming Language), is decidable. The proof proceeds by showing that subtyping is decidable, that all terms of TOOPLE have minimum types...", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165865", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kim B.", + "last_name": "Bruce", + "institution": "Williams College" + }, + { + "first_name": "Jon", + "last_name": "Crabtree", + "institution": "Williams College" + }, + { + "first_name": "Thomas P.", + "last_name": "Murtagh", + "institution": "Williams College" + }, + { + "first_name": "R. H. van", + "last_name": "Gent", + "institution": "Williams College" + }, + { + "first_name": "Allyn", + "last_name": "Dimock", + "institution": "Harvard University Press" + }, + { + "first_name": "Robert", + "last_name": "Muller", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/oopsla/BruceCMGDM93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165893", + "title": "Strongtalk: Typechecking Smalltalk in a Production Environment", + "abstract": "article Free Access Share on Strongtalk: typechecking Smalltalk in a production environment Authors: Gilad Bracha View Profile , David Griswold View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 215–230https://doi.org/10.1145/167962.165893Online:01 October 1993Publication History 167citation673DownloadsMetricsTotal Citations167Total Downloads673Last 12 Months25Last 6 weeks13 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165893", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gilad", + "last_name": "Bracha", + "institution": "Safe Horizon" + }, + { + "first_name": "David", + "last_name": "Griswold", + "institution": "Safe Horizon" + } + ], + "dblp_key": "conf/oopsla/BrachaG93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165879", + "title": "Developing Software for Large-Scal Reuse (Panel)", + "abstract": "article Free Access Share on Developing software for large-scale reuse (panel) Authors: Ed Seidewitz View Profile , Brad Balfour View Profile , Sam S. Adams View Profile , David M. Wade View Profile , Brad Cox View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 137–143https://doi.org/10.1145/167962.165879Online:01 October 1993Publication History 0citation359DownloadsMetricsTotal Citations0Total Downloads359Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165879", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ed", + "last_name": "Seidewitz", + "institution": "Goddard Space Flight Center" + }, + { + "first_name": "Brad", + "last_name": "Balfour", + "institution": "SofTech (Italy)" + }, + { + "first_name": "Sam S.", + "last_name": "Adams", + "institution": "Knowledge Systems Institute" + }, + { + "first_name": "David M.", + "last_name": "Wade", + "institution": "" + }, + { + "first_name": "Brad", + "last_name": "Cox", + "institution": "George Mason University" + } + ], + "dblp_key": "conf/oopsla/SeidewitzBAWC93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165932", + "title": "Subject-Oriented Programming (A Critique of Pure Objects)", + "abstract": "Object-Oriented technology is often described in terms of an interwoven troika of themes: encapsulation, polymorphism, and inheritance. But these themes are firmly tied with the concept of identity. If object-oriented technology is to be successfully scaled from the development of independent applications to development of integrated suites of applications, it must relax its emphasis on the objecf. The technology must recognize more directly that a multiplicity of subjective views delocalizes the concept of object, and must emphasize more the binding concept of identity to tie them together. This paper explores this shift to a style of objectoriented technology that emphasizes the subjective views: Subject-", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165932", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William", + "last_name": "Harrison", + "institution": "IBM (United States)" + }, + { + "first_name": "Harold", + "last_name": "Ossher", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/HarrisonO93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165902", + "title": "Selector Table Indexing & Sparse Arrays", + "abstract": "article Free Access Share on Selector table indexing & sparse arrays Author: Karel Driesen View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 259–270https://doi.org/10.1145/167962.165902Published:01 October 1993Publication History 42citation378DownloadsMetricsTotal Citations42Total Downloads378Last 12 Months22Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165902", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karel", + "last_name": "Driesen", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/oopsla/Driesen93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165874", + "title": "CHARM++: A Portable Concurrent Object Oriented System Based On C++", + "abstract": "Article Free Access Share on CHARM++: a portable concurrent object oriented system based on C++ Authors: Laxmikant V. Kale View Profile , Sanjeev Krishnan View Profile Authors Info & Claims OOPSLA '93: Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applicationsOctober 1993 Pages 91–108https://doi.org/10.1145/165854.165874Published:01 October 1993Publication History 516citation1,794DownloadsMetricsTotal Citations516Total Downloads1,794Last 12 Months208Last 6 weeks21 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165874", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Laxmikant V.", + "last_name": "Kalé", + "institution": "National Center for Supercomputing Applications" + }, + { + "first_name": "Sanjeev", + "last_name": "Krishnan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/KaleK93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165919", + "title": "Visualizing the Behavior of Object-Oriented Systems", + "abstract": "Numerous classes, complex inheritance and containment hierarchies, and diverse patterns of dynamic interaction all contribute to difficulties in understanding, reusing, debugging, and tuning large object-oriented systems. To help overcome these difficulties, we introduce novel views of the behavior of object-oriented systems and an architecture for creating and animating these views. We describe platform-independent techniques for instrumenting object-oriented programs, a language-independent protocol for monitoring their execution, and a structure for decoupling the execution of a subject program from its visualization. Case studies involving tuning and debugging of real systems are presented to demonstrate the benefits of visualization. We believe that visualization will prove to be a valuable tool for object-oriented software development.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165919", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wim De", + "last_name": "Pauw", + "institution": "" + }, + { + "first_name": "Richard F.", + "last_name": "Helm", + "institution": "" + }, + { + "first_name": "Doug", + "last_name": "Kimelman", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Vlissides", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/PauwHKV93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165870", + "title": "A Framework for Dynamic Program Analyzers", + "abstract": "BEE++ is an object-oriented application framework for the dynamic analysis of distributed programs. The main objective of BEE++ is to provide a common platform for monitoring and debugging. BEE++'s class library consists of a rich set of classes for event processing to support a variety of visualization, monitoring and debugging needs. It also provides for customizability of event processing through inheritance. Users can derive customized graphical debugging and visualization systems from a set of base classes. BEE++'s other design goals are the support of dynamic program analysis for distributed heterogenous target applications at runtime with predictable overhead. The design is based a symmetric peer-peer architecture, including the ability to dynamically configure target appli,. cations and monitoring tools. The dynamic analysis tools can be distributed across nodes, which provides significant performance gains for visualization applications. In addition, the framework can be instantiated for a variety of communication protoco1s.A TCP/IP based instance of the framework has been ported to several machine architectures including Sun, Vax and Cray-YMP. BEE++ is based on BEEI 101, a portable platform for monitoring implemented in C but has been completely reengineered in C++ using the object-oriented design methodology OMT. Performance measurements indicate that the runtime overhead of the object-oriented version is not signilicant when com", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165870", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bernd", + "last_name": "Bruegge", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Tim", + "last_name": "Gottschalk", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Bin", + "last_name": "Luo", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/BrueggeGL93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165922", + "title": "Software Architecture: The Next Step for Object Technology (Panel)", + "abstract": "Architectures are the structuring paradigms, styles and patterns that make up our software systems. They are important in many ways: they allow us to talk usefully about systems without talking about their detail; a knowledge of them gives us design choices; attention to this level can make systems and families of systems have the non-functional properties we want, especially changeability. Each panelist will address the following issues: l What is architecture? l What is the value you have had so far from this concept? l What is the next step for you? l What is the next step for the community?", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165922", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bruce", + "last_name": "Anderson", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Mary", + "last_name": "Shaw", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Larry", + "last_name": "Best", + "institution": "" + }, + { + "first_name": "Kent", + "last_name": "Beck", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/AndersonSBB93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165907", + "title": "Object Fault Handling for Persistent Programming Languages: A Performance Evaluation", + "abstract": "A key mechanism of a persistent programming language is its ability to detect and handle references to non-resident objects. Ideally, this mechanism should be hidden from the programmer, allowing the transparent manipulation of all data regardless of its potential lifetime. We term such a mechanism object faulting, in a deliberate analogy with page faulting in virtual memory systems. This paper presents a number of mechanisms for detecting and handling references to persistent objects, and evaluates their relative performance within an implementation of Persistent Smalltalk.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165907", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Antony L.", + "last_name": "Hosking", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/HoskingM93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165931", + "title": "Building and Maintaining Analysis-Level Class Hierarchies Using Galois Lattices", + "abstract": "Existing 00 development methodologies (see e.g.[Rumbaugh9 1 a, Wirfs-Brock90a, Coad9 la]) prescribe that design builds on the basic class structure identified at the analysis level--one aspect of the much vaunted seamless transition--by adding high level (control) and low level (utility)", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165931", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert", + "last_name": "Godin", + "institution": "Université du Québec à Montréal" + }, + { + "first_name": "Hafedh", + "last_name": "Mili", + "institution": "Université du Québec à Montréal" + } + ], + "dblp_key": "conf/oopsla/GodinM93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165884", + "title": "Object Distribution in Orca using Compile-Time and Run-Time Techniques", + "abstract": "Orca is a language for parallel programming on distributed systems. Communication in Orca is based on shared data-objects, which is a form of distributed shared memory. The performance of Orca programs depends strongly on how shared dataobjects are distributed among the local physical memories of the processors. This paper studies a new and efficient solution to this problem, based on an integration of compile-time and run-time techniques. The Orca compiler has been extended to determine the access patterns of processes to shared objects. The compiler passes a summary of this information to the run-time system, which uses it to make good decisions about which objects to replicate and where to store nonreplicated objects. Measurements show that the new system gives better overall performance than any previous implementation of Orca. 3333333333333333 1 This research was supported in part by a PIONIER grant from the Netherlands Organization for Scientific Research (N.W.O.). 2 This re...", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165884", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Henri E.", + "last_name": "Bal", + "institution": "" + }, + { + "first_name": "M. Frans", + "last_name": "Kaashoek", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BalK93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165905", + "title": "Efficient Handling of Multiple Inheritance Hierarchies", + "abstract": "A key mechanism of a persistent programming language is its ability to detect and handle references to non-resident objects. Ideally, this mechanism should be hidden from the programmer, allowing the transparent manipulation of all data regardless of its potential lifetime. We term such a mechanism object faulting, in a deliberate analogy with page faulting in virtual memory systems. This paper presents a number of mechanisms for detecting and handling references to persistent objects, and evaluates their relative performance within an implementation of Persistent Smalltalk.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165905", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yves", + "last_name": "Caseau", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Caseau93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165918", + "title": "GROOP: An Object-Oriented Toolkit for Animated 3D Graphics", + "abstract": "Center 10.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165918", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Larry", + "last_name": "Koved", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Wayne L.", + "last_name": "Wooten", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KovedW93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165916", + "title": "Reconciling Objects and Multilevel Security (Panel)", + "abstract": "No abstract available.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165916", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "T.F.", + "last_name": "Keefe", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Keefe93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165934", + "title": "How to Get a Paper Accepted at OOPSLA (Panel)", + "abstract": "Article How to get a paper accepted at OOPSLA (panel) Share on Authors: Ralph E. Johnson View Profile , Kent Beck View Profile , Grady Booch View Profile , William Cook View Profile , Richard Gabriel View Profile , Rebecca Wirfs-Brock View Profile Authors Info & Claims OOPSLA '93: Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applicationsOctober 1993 Pages 429–436https://doi.org/10.1145/165854.165934Online:01 October 1993Publication History 5citation1,315DownloadsMetricsTotal Citations5Total Downloads1,315Last 12 Months35Last 6 weeks8 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165934", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "" + }, + { + "first_name": "Kent", + "last_name": "Beck", + "institution": "" + }, + { + "first_name": "Grady", + "last_name": "Booch", + "institution": "" + }, + { + "first_name": "William L.", + "last_name": "Cook", + "institution": "" + }, + { + "first_name": "Richard", + "last_name": "Gabriel", + "institution": "" + }, + { + "first_name": "Rebecca", + "last_name": "Wirfs-Brock", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/JohnsonBBCGW93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165891", + "title": "Typing the Specialization Interface", + "abstract": "all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165891", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Lamping", + "institution": "Association for Computing Machinery" + } + ], + "dblp_key": "conf/oopsla/Lamping93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165929", + "title": "Roles for Composite Objects in Object-Oriented Analysis and Design", + "abstract": "A method is presented for using composite objects which separates their role and meaning as models of relations between problem-domain concepts from their role and meaning as models of hierarchical sof'twarc structures.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165929", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Franco", + "last_name": "Civello", + "institution": "University of Brighton" + } + ], + "dblp_key": "conf/oopsla/Civello93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165867", + "title": "Tools for the Development of Application-Specific Virtual Memory Management", + "abstract": "The operating system's virtual memory management policy is increasingly important to application performance because gains in processing speed are far outstripping improvements in disk latency. Indeed, large applications can gain large performance benefits from using a virtual memory policy tuned to their specific memory access patterns rather than a general policy provided by the operating system. As a result, a number of schemes have been proposed to allow for application-specific extensions to virtual memory management. These schemes have the potential to improve performance; however, to realize this performance gain, application developers must implement their own virtual memory module, a non-trivial programming task. <p>Current operating systems and programming tools are inadequate for developing application-specific policies. Our work combines (i) an extensible user-level virtual memory system based on a metaobject protocol with (ii) an innovative graphical performance monitor to make the task of implementing a new application-specific page replacement policy considerably simpler. The techniques presented for opening up operating system virtual memory policy to user control are general; they could be used to build application-specific implementations of other operating system policies", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165867", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "K.", + "last_name": "Krueger", + "institution": "University of California, Berkeley" + }, + { + "first_name": "David", + "last_name": "Loftesness", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Amin", + "last_name": "Vahdat", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Thomas E.", + "last_name": "Anderson", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/KruegerLVA93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165936", + "title": "Strategies for Object-Oriented Technology Transfer (Panel)", + "abstract": "article Free Access Share on Strategies for object-oriented technology transfer (panel) Authors: Dennis de Champeaux View Profile , Andrew J. Baer View Profile , Brian Bernsen View Profile , Alan R. Korncoff View Profile , Tim Korson View Profile , Daniel S. Tkach View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 437–447https://doi.org/10.1145/167962.165936Online:01 October 1993Publication History 0citation354DownloadsMetricsTotal Citations0Total Downloads354Last 12 Months7Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165936", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dennis de", + "last_name": "Champeaux", + "institution": "Clemson University" + }, + { + "first_name": "Andrew J.", + "last_name": "Baer", + "institution": "Clemson University" + }, + { + "first_name": "Brian", + "last_name": "Bernsen", + "institution": "Boeing (Australia)" + }, + { + "first_name": "Alan R.", + "last_name": "Korncoff", + "institution": "Clemson University" + }, + { + "first_name": "Tim", + "last_name": "Korson", + "institution": "Clemson University" + }, + { + "first_name": "Daniel", + "last_name": "Tkach", + "institution": "Clemson University" + } + ], + "dblp_key": "conf/oopsla/ChampeauxBBKKT93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165882", + "title": "The Amadeus GRT - Generic Runtime Support for Distributed Persistent Programming", + "abstract": "Many object-oriented programming language implementations have been estcndcd to support persistence, dist,ribut,ion or atomicity by integrating the necessary a,dditional support, with t,he language's runt,ime library. We argue tha.t a better approach is to provide a.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165882", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vinny", + "last_name": "Cahill", + "institution": "" + }, + { + "first_name": "Seán", + "last_name": "Baker", + "institution": "" + }, + { + "first_name": "Chris", + "last_name": "Horn", + "institution": "Trinity College" + }, + { + "first_name": "Gradimir", + "last_name": "Starovic", + "institution": "Trinity College" + } + ], + "dblp_key": "conf/oopsla/CahillBHS93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165921", + "title": "Structural Active Object Systems for Simulation", + "abstract": "article Free Access Share on Structural active object systems for simulation Authors: Toshimi Minoura View Profile , Shirish S. Pargaonkar View Profile , Kurt Rehfuss View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 338–355https://doi.org/10.1145/167962.165921Published:01 October 1993Publication History 12citation301DownloadsMetricsTotal Citations12Total Downloads301Last 12 Months12Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165921", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Toshimi", + "last_name": "Minoura", + "institution": "" + }, + { + "first_name": "Shirish S.", + "last_name": "Pargaonkar", + "institution": "" + }, + { + "first_name": "Kurt", + "last_name": "Rehfuss", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MinouraPR93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165897", + "title": "On the Purpose of Object-Oriented Analysis", + "abstract": "The paper discusses the general purpose of analysis and evaluates OOA with respect to this, arguing that OOA does not deliver what it claims to do. The two major problems are that OOA often does not meet the full needs of the analysis phase, and that the transition to design is not always as easy as promised. The last point is illustrated by a solution to the OOPSLA conference registration problem. Due to the mentioned shortcomings, OOA/OOD was not found sufficient for forming the basis of a common development methodology for three Norwegian software producers in a technology transfer project with our university. The suggestion made is that OOA should become problem-oriented rather than target-oriented", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165897", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Geir Magne", + "last_name": "Høydalsvik", + "institution": "" + }, + { + "first_name": "Guttorm", + "last_name": "Sindre", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/HoydalsvikS93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165914", + "title": "Object Oriented Approach to MLS Database Application Design (Panel)", + "abstract": "No abstract available.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165914", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peter J.", + "last_name": "Sell", + "institution": "United States Department of Defense" + } + ], + "dblp_key": "conf/oopsla/Sell93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165863", + "title": "Specifications and Their Use in Defining Subtypes", + "abstract": "Specifications are useful because they allow reasoning about objects without concern for their implementations. Type hierarchies are useful because they allow types that share common properties to be designed as a family. This paper is concerned with the interaction between specifications and type hierarchies. We present a way of specifying types, and show how some extra information, in addition to specifications of the objects' methods, is needed to support reasoning.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165863", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jeannette M.", + "last_name": "Wing", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/LiskovW93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165873", + "title": "Status of Object-Oriented COBOL (Panel)", + "abstract": "No abstract available.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165873", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "J. G. Van", + "last_name": "Stee", + "institution": "IBM (United States)" + }, + { + "first_name": "Dan", + "last_name": "Clarke", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "David", + "last_name": "Filani", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Dmitry", + "last_name": "Lenkov", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Raymond", + "last_name": "Obin", + "institution": "Micro Focus (United States)" + } + ], + "dblp_key": "conf/oopsla/SteeCFLO93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165875", + "title": "Highly Efficient and Encapsulated Re-use of Synchronization Code in Concurrent Object-Oriented Languages", + "abstract": "Re-use of synchronization code in concurrent OOlanguages has been considered difficult due to inheritance anomaly, which we minimize with our new proposal. Designed with high practicality in mind, we propose language primitives (plus their implementation) with the following characteristics: (1) it allows multiple synchronization schemes---the language schemes for programming synchronization---to coexist and be integrated, (2) re-use of synchronization code is done similarly to sequential OO-languages for user familiarity, (3) it offers high degree of encapsulation---even synchronization schemes could be encapsulated in superclasses in many cases, and (4) it can be efficiently implemented on conventional MPPs. We demonstrate the effectiveness of our proposal with solutions to the example inheritance anomaly cases from [16]. We also give an overview of the implementation architecture, along with preliminary benchmarks. The proposed language primitives are being incorporated into our AB...", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165875", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Satoshi", + "last_name": "Matsuoka", + "institution": "" + }, + { + "first_name": "Kenjiro", + "last_name": "Taura", + "institution": "" + }, + { + "first_name": "Akinori", + "last_name": "Yonezawa", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MatsuokaTY93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165909", + "title": "Integrating Object-Oriented Technolgy and Security Technology: A Panel Discussion", + "abstract": "No abstract available.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165909", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bhavani", + "last_name": "Thuraisingham", + "institution": "Mitre (United States)" + } + ], + "dblp_key": "conf/oopsla/Thuraisingham93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165915", + "title": "Security for OODBMS (Or Systems) - Panel", + "abstract": "No abstract available.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165915", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ravi", + "last_name": "Sandhu", + "institution": "University of Tennessee System" + } + ], + "dblp_key": "conf/oopsla/Sandhu93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165889", + "title": "IRIS Inventor, A 3D Graphics Toolkit", + "abstract": "IRIS@ InventorTM is an object-oriented toolkit for developers of applications that incorporate interactive, threedimensional graphics. Encapsulation of data and methods in high-level graphical objects allows Inventor to provide a significant improvement in usability to developers, as compared to the standard, low-level set of graphics primitives provided in most other graphics libraries. Inventor's object-oriented framework also facilitates extensions, which are necessary in the diverse and rapidly changing field of 3D graphics.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165889", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul S.", + "last_name": "Strauss", + "institution": "Silicon Labs (United States)" + } + ], + "dblp_key": "conf/oopsla/Strauss93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165877", + "title": "Ada 9X: From Abstraction-Oriented to Object-Oriented", + "abstract": "article Ada 9X: from abstraction-oriented to object-oriented Share on Author: S. Tucker Taft View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 127–136https://doi.org/10.1145/167962.165877Online:01 October 1993Publication History 15citation278DownloadsMetricsTotal Citations15Total Downloads278Last 12 Months7Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165877", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "S. Tucker", + "last_name": "Taft", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Taft93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165925", + "title": "Impacts of Object-Oriented Technologies: Seven Years of SEL Studies", + "abstract": "article Free Access Share on Impacts of object-oriented technologies: seven years of SEL studies Author: Mike Stark View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 365–373https://doi.org/10.1145/167962.165925Published:01 October 1993Publication History 0citation317DownloadsMetricsTotal Citations0Total Downloads317Last 12 Months9Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165925", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mike", + "last_name": "Stark", + "institution": "Goddard Space Flight Center" + } + ], + "dblp_key": "conf/oopsla/Stark93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.167976", + "title": "Regular Types for Active Objects", + "abstract": "article Free Access Share on Regular types for active objects Author: Oscar Nierstrasz View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 1–15https://doi.org/10.1145/167962.167976Published:01 October 1993Publication History 141citation708DownloadsMetricsTotal Citations141Total Downloads708Last 12 Months18Last 6 weeks5 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.167976", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Oscar", + "last_name": "Nierstrasz", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Nierstrasz93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165899", + "title": "A Discussion of "On the Purpose of Object-Oriented Analysis" (Panel)", + "abstract": "Article Free Access Share on A discussion of On the Purpose of Object-Oriented Analysis Authors: Dave Thomas Object Technology International Object Technology InternationalView Profile , Adele Goldberg ParcPlace Systems ParcPlace SystemsView Profile , James Coplien Bell Labs Bell LabsView Profile , Peter Coad Apple, Inc. Apple, Inc.View Profile , Geir Magne Høydalsvik Univ. of Trondheim, Trondheim, Norway Univ. of Trondheim, Trondheim, NorwayView Profile Authors Info & Claims OOPSLA '93: Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applicationsOctober 1993Pages 256–258https://doi.org/10.1145/165854.165899Published:01 October 1993Publication History 1citation664DownloadsMetricsTotal Citations1Total Downloads664Last 12 Months15Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165899", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dave", + "last_name": "Thomas", + "institution": "" + }, + { + "first_name": "Adele", + "last_name": "Goldberg", + "institution": "" + }, + { + "first_name": "James O.", + "last_name": "Coplien", + "institution": "Bell (Canada)" + }, + { + "first_name": "Peter", + "last_name": "Coad", + "institution": "Apple (Israel)" + }, + { + "first_name": "Geir Magne", + "last_name": "Høydalsvik", + "institution": "Norwegian University of Science and Technology" + } + ], + "dblp_key": "conf/oopsla/ThomasGCCH93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165912", + "title": "Modeling Security Requirements for Applications (Panel)", + "abstract": "No abstract available.", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165912", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "T. C.", + "last_name": "Ting", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Ting93", + "venue": "oopsla", + "year": 1993 + }, + { + "paper_id": "10.1145/165854.165923", + "title": "Panel - Is Multiple Inheritance Essential to OOP?", + "abstract": "article Free Access Share on Is multiple inheritance essential to OOP? (panel) Authors: Yen-Ping Shan View Profile , Tom Cargill View Profile , Brad Cox View Profile , William Cook View Profile , Mary Loomis View Profile , Alan Snyder View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 28Issue 10Oct. 1, 1993 pp 360–363https://doi.org/10.1145/167962.165923Published:01 October 1993Publication History 3citation781DownloadsMetricsTotal Citations3Total Downloads781Last 12 Months30Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1993-10-01", + "link": "https://doi.org/10.1145/165854.165923", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yen-Ping", + "last_name": "Shan", + "institution": "" + }, + { + "first_name": "Tom", + "last_name": "Cargill", + "institution": "" + }, + { + "first_name": "Brad", + "last_name": "Cox", + "institution": "" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "" + }, + { + "first_name": "Mary E. S.", + "last_name": "Loomis", + "institution": "" + }, + { + "first_name": "Alan", + "last_name": "Snyder", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ShanCCCLS93", + "venue": "oopsla", + "year": 1993 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1994.json b/data/pl_conferences/oopsla/1994.json new file mode 100644 index 0000000..336faeb --- /dev/null +++ b/data/pl_conferences/oopsla/1994.json @@ -0,0 +1,949 @@ +[ + { + "paper_id": "10.1145/191080.191133", + "title": "Reducing Cross Domain Call Overhead using Batched Futures", + "abstract": "In many systems such as operating systems and databases it is important to run client code in a separate protection domain so that it cannot interfere with correct operation of the system. Clients communicate with the server by making cross domain calls, but these are expensive, often costing substantially more than running the call itself. This paper describes a new mechanism called batched futures that transparently batches possibly interrelated client calls. Batching makes domain crossings happen less often, thus substantially reducing the cost. We describe how the mechanism is implemented for the Thor object-oriented database system, and presents performance results showing the benefit of the mechanism on various benchmarks.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191133", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Phillip", + "last_name": "Bogle", + "institution": "" + }, + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BogleL94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191150", + "title": "Combining Contracts and Exemplar-Based Programming for Class Hiding and Customization", + "abstract": "For performance reasons, client applications often need to influence the implementation strategies of libraries whose services they use. If an object-oriented library contains multiple service classes customized for different usage patterns, applications can influence service implementations by instantiating the customized classes that match their needs. However, with many similar service classes, it can be difficult for applications to determine which classes to instantiate. Choosing the wrong class can result in very subtle errors since a customized class might use optimizations that work only over a restricted domain. In this paper, we show how client-side software contracts and exemplar-based class factories can be used to construct customized server objects. By expressing priorities and requirements in contracts, clients can delegate service class selection to the library and thereby avoid implicit dependencies on the library implementation. We have used this approach in the implementation of a real-time database system.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191150", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "V.B.", + "last_name": "Lortz", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Kang G.", + "last_name": "Shin", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/oopsla/LortzS94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191128", + "title": "Development of Distributed and Client/Server Object-Oriented Applications: Industry Solutions (Panel)", + "abstract": "The panel will discuss emerging “industrial” solutions that help programmers to develop distributed and client/server applications based on objects supporting so-called openness and heterogeneity.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191128", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lutz", + "last_name": "Heuser", + "institution": "Digital Equipment (Germany)" + }, + { + "first_name": "John", + "last_name": "Dilley", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Hari", + "last_name": "Madduri", + "institution": "IBM (United States)" + }, + { + "first_name": "Steven", + "last_name": "Rabin", + "institution": "" + }, + { + "first_name": "Shawn", + "last_name": "Woods", + "institution": "Digital Wave (United States)" + } + ], + "dblp_key": "conf/oopsla/HeuserDMRW94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191086", + "title": "Application of OOP Type Theory: State, Decidability, Integragtion", + "abstract": "Important strides toward developing expressive yet semantically sound type systems for object-oriented programming languages have recently been made by Cook, Bruce, Mitchell, and others. This paper focusses on how the theoretical work using F-bounded quantification may be brought more into the realm of actual language implementations while preserving rigorous soundness properties. We simultaneously address three of the more significant problems: adding a notion of global state, proving type-checking is decidable, and integrating the more widely implemented view that subclasses correspond to subtypes with the F-bounded view.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191086", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Eifrig", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Valery", + "last_name": "Trifonov", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Amy E.", + "last_name": "Zwarico", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/oopsla/EifrigSTZ94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191148", + "title": "Composition of Before/After Metaclasses in SOM", + "abstract": "In SOM, the IBM System Object Model, a class is a run-time object that defines the behavior of its instances by creating an instance method table. Because classes are objects, their behavior is defined by other classes (called metaclasses). For example, a “Before/After Metaclass” can be used to define the implementation of classes that, by suitable construction of their instance method tables, arrange for each invocation of a method to be preceded by execution of a “before method” and followed by execution of an “after method”. This paper introduces and solves the problem of composing different Before/After Metaclasses in the context of SOM. An enabling element in the solution is SOM's concept of derived metaclasses, i.e., at run-time a SOM system derives the appropriate metaclass of a class based on the classes of its parents and an optional metaclass constraint.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191148", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ira R.", + "last_name": "Forman", + "institution": "" + }, + { + "first_name": "Scott", + "last_name": "Danforth", + "institution": "" + }, + { + "first_name": "Hari", + "last_name": "Madduri", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FormanDM94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191112", + "title": "Extensible File Systems (ELFS): An Object-Oriented Approach to High Performance File I/O", + "abstract": "Scientific applications often manipulate very large sets of persistent data. Over the past decade, advances in disk storage device performance have consistently been outpaced by advances in the performance of the rest of the computer system. As a result, many scientific applications have become I/O-bound, i.e. their run-times are dominated by the time spent performing I/O operations. Consequently, the performance of I/O operations has become critical for high performance in these applications. The ELFS approach is designed to address the issue of high performance I/O by treating files as typed objects. Typed file objects can exploit knowledge about the file structure and type of data. Typed file objects can selectively apply techniques such as prefetching, parallel asynchronous file access, and caching to improve performance. Also, by typing objects, the interface to the user can be improved in two ways. First, the interface can be made easier to use by presenting file operations in a more natural manner to the user. Second, the interface can allow the user to provide an “oracle” about access patterns, that can allow the file object to improve performance. By combining these concepts with the object-oriented paradigm, the goal of the ELFS methodology is to create flexible, extensible file classes that are easy to use while achieving high performance. In this paper we present the ELFS approach and our experiences with the design and implementation of two file classes: a two dimensional dense matrix file class and a multidimensional range searching file class.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191112", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John F.", + "last_name": "Karpovich", + "institution": "University of Virginia" + }, + { + "first_name": "Andrew", + "last_name": "Grimshaw", + "institution": "University of Virginia" + }, + { + "first_name": "James C.", + "last_name": "French", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/oopsla/KarpovichGF94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191106", + "title": "Persistent Shared Object Support in the Guide System: Evaluation & Related Work", + "abstract": "The purpose of the Guide project is to explore the use of shared objects for communication in a distributed system, especially for applications that require cooperative work. Since 1986, two prototypes have been implemented respectively on top of Unix (Guide-1) and Mach 3.0 (Guide-2). They have been used for the development of distributed cooperative applications, allowing us to validate or reject many design choices in the system.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191106", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Hagimont", + "institution": "University of British Columbia" + }, + { + "first_name": "P.-Y.", + "last_name": "Chevalier", + "institution": "" + }, + { + "first_name": "A.", + "last_name": "Freyssinet", + "institution": "" + }, + { + "first_name": "Sacha", + "last_name": "Krakowiak", + "institution": "" + }, + { + "first_name": "S.", + "last_name": "Lacourte", + "institution": "" + }, + { + "first_name": "Jacques", + "last_name": "Mossière", + "institution": "" + }, + { + "first_name": "Xavier Rousset de", + "last_name": "Pina", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/HagimontCFKLMP94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191152", + "title": "How Do Teams Shape Objects ? - How Di Object Shape Teams ? (Panel)", + "abstract": "Teamwork is the most important key to success in almost all software projects. What makes a good team (roles, organization, education, communication bandwidth, management, process, etc.) remains an open question in many situations. To quote Gerald Weinberg from Understanding the Professional Programmer (Dorset House, 1988):", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191152", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "" + }, + { + "first_name": "Kent", + "last_name": "Beck", + "institution": "Kuehne + Nagel (United Kingdom)" + }, + { + "first_name": "Grady", + "last_name": "Booch", + "institution": "CAS Software (Germany)" + }, + { + "first_name": "Derek", + "last_name": "Coleman", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Jim", + "last_name": "Coplien", + "institution": "AT&T (United States)" + }, + { + "first_name": "Richard F.", + "last_name": "Helm", + "institution": "Nokia (United States)" + }, + { + "first_name": "Kenny", + "last_name": "Rubin", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FraserBBCCHR94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191149", + "title": "Reflections on Metaclass Rorgramming in SOM", + "abstract": "This paper reports on the evolution of metaclass programming in SOM (the IBM System Object Model). Initially, SOM's use of explicit metaclasses introduced metaclass incompatibilities. This was cured by having SOM dynamically derive an appropriate metaclass by interpreting the “metaclass declaration” as a constraint. In effect, inheritance is given a new dimension, because the constraint is also inherited. The derived metaclass is the least solution to all these constraints. Subsequently, this cure led to the possibility of metaclasses conflicting over the need to assign meaning to a method. The cure for this problem is a framework that facilitates the programming of metaclasses that cooperate on the assignment of meaning to methods.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191149", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Scott", + "last_name": "Danforth", + "institution": "IBM (United States)" + }, + { + "first_name": "Ira R.", + "last_name": "Forman", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/DanforthF94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191135", + "title": "Sifting Out the Gold", + "abstract": "Integrated, dynamically-typed object-oriented programming environments offer many advantages, but have trouble producing small, self-contained applications. Recent advances in type inference have made it possible to build an application extractor for Self. The extractor was able to extract a medium-sized application in a few minutes. The extracted application runs in a tenth the space of the original environment. Except for extracting reflection and sends with computed selectors, the extractor runs without human intervention and fully preserves the behavior of the application.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191135", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ole", + "last_name": "Agesen", + "institution": "Stanford University" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/AgesenU94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191088", + "title": "Type-Theoretic Foundations for Concurrent Object-Oriented Programming", + "abstract": "A number of attempts have been made to obtain type systems for object-oriented programming. The view that lies common is “object-oriented programming = λ-calculus + record.” Based on an analogous view “concurrent object-oriented programming = concurrent calculus + record,” we develop a static type system for concurrent object-oriented programming. We choose our own Higher-Order ACL as a basic concurrent calculus, and show that a concurrent object-oriented language can be easily encoded in the Higher-Order ACL extended with record operations. Since Higher-Order ACL has a strong type system with a polymorphic type inference mechanism, programs of the concurrent object-oriented language can be automatically type-checked by the encoding in Higher-Order ACL. Our approach can give clear accounts for complex mechanisms such as inheritance and method overriding within a simple framework.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191088", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "Tokyo University of Science" + }, + { + "first_name": "Akinori", + "last_name": "Yonezawa", + "institution": "Tokyo University of Science" + } + ], + "dblp_key": "conf/oopsla/KobayashiY94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191110", + "title": "Proposal for a Monotonic Multiple Inheritance Linearization", + "abstract": "Previous studies concerning multiple inheritance convinced us that a better analysis of conflict resolution mechanisms was necessary. In [DHHM92], we stated properties that a sound mechanism has to respect. Among them, a monotonicity principle plays a critical role, ensuring that the inheritance mechanism behaves “naturally” relative to the incremental design of the inheritance hierarchy. We focus here on linearizations and present an intrinsically monotonic linearization, whereas currently used linearizations are not. This paper describes the algorithm in detail, explains the design choices, and compares it to other linearizations, with LOOPS and CLOS taken as references. In particular, this new linearization extends CLOS and LOOPS linearizations, producing the same results when these linearizations are sound.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191110", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roland", + "last_name": "Ducournau", + "institution": "" + }, + { + "first_name": "Michel", + "last_name": "Habib", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + }, + { + "first_name": "Marianne", + "last_name": "Huchard", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + }, + { + "first_name": "Marie-Laure", + "last_name": "Mugnier", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + } + ], + "dblp_key": "conf/oopsla/DucournauHHM94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191125", + "title": "Timethread-Role Maps for Object-Oriented Design of Real-Time-and-Distributed Systems", + "abstract": "Object-oriented design methods and notations do not adequately address the concerns of real-time-and-distributed (RTD) systems. Issues critical to such systems, like performance, robustness, and concurrency are not seriously considered until detailed design. We propose an object-oriented approach that allows RTD design issues to be considered before detailed design. The approach revolves around timethread-role maps that present composite pictures of concurrent, interacting, end-to-end responsibility paths through a system. It is related to responsibility-driven design approaches, but extended for RTD systems. The paper illustrates by example how timethread-role maps can be used to explore, compare and explain different organizations for achieving the paths. The paper also illustrates how timethread-role maps may be used to represent dynamic structure.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191125", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "R. J. A.", + "last_name": "Buhr", + "institution": "Carleton University" + }, + { + "first_name": "Ronald", + "last_name": "Casselman", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/BuhrC94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191147", + "title": "A Status Report on the oo7 OODBMS Benchmarking Effort", + "abstract": "The OO7 Benchmark was first published in 1993, and has since found a home in the marketing literature of various object-oriented database management system (OODBMS) vendors. The OO7 Benchmark (as published) was the initial result of an ongoing OODBMS performance evaluation effort at the University of Wisconsin. This paper provides an update on the status of the effort on two fronts: single-user and multi-user. On the single-user front, we review and critique the design of the initial OO7 Benchmark. We discuss some of its faults, the reasons for those faults, and things that might be done to correct them. On the multi-user front, we describe our current work on the development of a multi-user benchmark for OODBMSs. This effort includes changes and extensions to the OO7 database and the design of a family of interesting multi-user workloads.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191147", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael J.", + "last_name": "Carey", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "David J.", + "last_name": "DeWitt", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Chander", + "last_name": "Kant", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Jeffrey F.", + "last_name": "Naughton", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/oopsla/CareyDKN94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191138", + "title": "Objects and Databases (Panel)", + "abstract": "No abstract available.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191138", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Atwood", + "institution": "" + }, + { + "first_name": "Jnan", + "last_name": "Dash", + "institution": "Oracle (United States)" + }, + { + "first_name": "Jacob", + "last_name": "Stein", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Stonebraker", + "institution": "" + }, + { + "first_name": "Mary E. S.", + "last_name": "Loomis", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/AtwoodeDSSL94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191140", + "title": "Persistent Storgage for a Workflow Tool Implemented in Smalltalk", + "abstract": "This paper describes a new workflow model and its implementation in Smalltalk. The paper also details problems with using a RDBMS as the persistent store for the workflow tool and the subsequent experiences in using an ODBMS for this purpose. The final solution was a coexistence approach, using the RDBMS for legacy corporate data and the ODBMS for the process description and workflow status data.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191140", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bob", + "last_name": "Beck", + "institution": "" + }, + { + "first_name": "Steve", + "last_name": "Hartley", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BeckH94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191117", + "title": "Optimizing Multi-Method Dispatch Using Compressed Dispatch Tables", + "abstract": "Optimizing method dispatch is a central issue in object-oriented language implementation. The dispatch table scheme, used for example by C++, is the only implementation of method dispatch that offers constant time performance. This property is the main asset of dispatch tables and a major requirement for some languages. However, the major drawback of dispatch tables is the space they require. Reducing the size of dispatch tables has been studied in the case of mono-methods with techniques such as coloring. In the case of multi-methods, dispatch tables are practically unusable as they grow as a power of the number of arguments. In this paper, we propose an algorithm to compress the dispatch tables of multi-methods by analyzing their signatures.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191117", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Amiel", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Olivier", + "last_name": "Gruber", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Eric", + "last_name": "Simon", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/oopsla/AmielGS94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191118", + "title": "Implementing Constraint Imperative Programming Languages: The Kaleidospace'93 Virtual Machine", + "abstract": "Constraint Imperative Programming (CIP) languages integrate declarative constraints with imperative state and destructive assignment, yielding a powerful new programming paradigm. However, CIP languages are difficult to implement efficiently due to complex interactions between the two donor paradigms. Neither the virtual machines for classical object-oriented languages, nor those for existing constraint languages, are suitable for implementing CIP languages, as each assumes a purely imperative or a purely declarative computation model. We have developed a new virtual machine for CIP languages, the K-machine, an imperative machine with an incremental constraint solver and a constraint-based, rather than value-based, data store. This virtual machine allows user-defined constraints to be defined using constraint constructor definitions which are the CIP analog to method definitions. Similar to methods, these constructors are able to reference variables indirectly through many levels of pointers. The K-machine maintains relations between objects in the presence of state change to these indirectly referenced objects. The K-machine is capable of supporting a wide variety of CIP languages, including our most recent: Kaleidoscope'93.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191118", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gus", + "last_name": "Lopez", + "institution": "University of Washington" + }, + { + "first_name": "Bjorn", + "last_name": "Freeman‐Benson", + "institution": "Carleton University" + }, + { + "first_name": "Alan", + "last_name": "Borning", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/LopezFB94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191111", + "title": "Interfaces, Protocols, and the Semi-Automatic Construction of Software Adaptors", + "abstract": "In this paper we show how to augment object-oriented application interfaces with enhanced specifications that include sequencing constraints called protocols. Protocols make explicit the relationship between messages (methods) supported by the application. These relationships are usually only given implicitly, either in the code or in textual comments. We define notions of interface compatibility based upon protocols and show how compatibility can be checked, discovering a class of errors that cannot be discovered via the type system alone. We then define software adaptors that can be used to bridge the difference between object-oriented applications that have functionally compatible but type incompatible interfaces. We discuss what it means for an adaptor to be well-formed. Leveraging the information provided by protocols, we show how adaptors can be automatically generated from a high-level description, called an interface mapping.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191111", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel M.", + "last_name": "Yellin", + "institution": "IBM (United States)" + }, + { + "first_name": "Robert E.", + "last_name": "Strom", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/YellinS94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191104", + "title": "A Distributed Garbage Collector for Active Objects", + "abstract": "This paper presents an algorithm that performs garbage collection in distributed systems of active objects (i.e., objects having their own threads of control). Our proposition extends the basic marking algorithm proposed by Kafura in [1] to a distributed environment. The proposed garbage collector is made up of a set of local garbage collectors, one per site, loosely coupled to a (logically centralized) global garbage collector that maintains a global snapshot of the system state relevant to garbage collection. The specific features of the proposed garbage collector are that local garbage collectors need not be synchronized with each other for detecting garbage objects, and that faulty sites and communication channels are tolerated. The paper describes the proposed garbage collector, together with its implementation and performance for a concurrent object-oriented language running on a local area network of workstations.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191104", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Isabelle", + "last_name": "Puaut", + "institution": "Institut National des Sciences Appliquées de Rennes" + } + ], + "dblp_key": "conf/oopsla/Puaut94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191146", + "title": "Experience with Representing C++ Program Information in an Object-Oriented Database", + "abstract": "Two major issues related to storing program information in an OODB are sharing and clustering. The former is important since it prevents the database from consuming excessive disk space, while the latter is crucial, since it keeps clients running without thrashing. In our database, objects are shared across multiple programs' translation units, and are clustered by combining three techniques, namely, birth-order, death-order, and sharing-oriented clusterings. An initial experiment shows that, for a medium-size application, the database consumes 3.5 times less disk space than in a conventional environment, and that the invocation of a client is almost instantaneous.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191146", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tamiya", + "last_name": "Onodera", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/Onodera94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191098", + "title": "Building Tailorable Hypermedia Systems: The Embedded-Interpreter Approach", + "abstract": "This paper discusses an approach for developing dynamically tailorable hypermedia systems in an object-oriented environment. The approach is aimed at making applications developed in compiled languages like Beta and C++ tailorable at run-time. The approach is based on use of: 1) a hypermedia application framework (DEVISE Hyper-media), and 2) an embeddable interpreter for the framework language. A specific hypermedia system is instantiated from the framework with the interpreter embedded in the executable. The specific hypermedia system has a number of “open points” which can be filled via the interpreter at run-time. These open points and the interpreter provide sufficient support to allow tailoring at run-time as well as compile-time. Among the types of tailoring supported are: 1) adding new media-types, 2) alternating editors for supported media-types, and 3) removing a supported media-type. The paper describes the framework and illustrates how the interpreter is integrated. It describes steps involved in tailoring a specific hypermedia system with a new drawing media-type, where graphical objects can be endpoints for links. Since the hypermedia framework uses a persistent object-store, a solution for handling persistent interpreted objects is presented. Finally, the approach is compared with other environments supporting tailoring.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191098", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kaj", + "last_name": "Grønbæk", + "institution": "Aarhus University" + }, + { + "first_name": "Jawahar", + "last_name": "Malhotra", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/GronbaekM94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191083", + "title": "Typechecking and Modules for Multi-Methods", + "abstract": "Two major obstacles hindering the wider acceptance of multi-methods are concerns over the lack of encapsulation and modularity and the absence of static typechecking in existing multi-method-based languages. This paper addresses both of these problems. We present a polynomial-time static typechecking algorithm that checks the conformance, completeness, and consistency of a group of method implementations with respect to declared message signatures. This algorithm improves on previous algorithms by handling separate type and inheritance hierarchies, abstract classes, and graph-based method lookup semantics. We also present a module system that enables independently-developed code to be fully encapsulated and statically typechecked on a per-module basis. To guarantee that potential conflicts between independently-developed modules have been resolved, a simple well-formedness condition on the modules comprising a program is checked at link-time. The typechecking algorithm and module system are applicable to a range of multi-method-based languages, but the paper uses the Cecil language as a concrete example of how they can be applied.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191083", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + }, + { + "first_name": "Gary T.", + "last_name": "Leavens", + "institution": "Iowa State University" + } + ], + "dblp_key": "conf/oopsla/ChambersL94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191116", + "title": "A Third-Generation SELF Implementation: Reconsiling Responsiveness with Performance", + "abstract": "Programming systems should be both responsive (to support rapid development) and efficient (to complete computations quickly). Pure object-oriented languages are harder to implement efficiently since they need optimization to achieve good performance. Unfortunately, optimization conflicts with interactive responsiveness because it tends to produce long compilation pauses, leading to unresponsive programming environments. Therefore, to achieve good responsiveness, existing exploratory programming environments such as the Smalltalk-80 environment rely on interpretation or non-optimizing dynamic compilation. But such systems pay a price for their interactiveness, since they may execute programs several times slower than an optimizing system.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191116", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Urs", + "last_name": "Hölzle", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/HolzleU94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191123", + "title": "Streamlining the Project Cycle With Object-Oriented Requirements", + "abstract": "We have succeeded in streamlining the product development cycle by incorporating object-oriented technology into the requirements definition phase. We have developed a general format, supporting tools and a methodology for describing requirements in an object-oriented fashion. We have validated our approach by incorporating it into the new object-oriented methods being applied to our current project and observing the benefits that resulted. We describe the problems with our earlier requirements specifications which make them unsuitable for developing good object-oriented systems and then explain our approach which eliminates these pitfalls.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191123", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard W.", + "last_name": "Jordan", + "institution": "AT&T (United States)" + }, + { + "first_name": "Ruth", + "last_name": "Smilan", + "institution": "AT&T (United States)" + }, + { + "first_name": "Alex Cherry", + "last_name": "Wilkinson", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/oopsla/JordanSW94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191120", + "title": "Complex Associations: Abstractions in Object-Oriented Modeling", + "abstract": "Objects model phenomena and a phenomenon is usually a component. Information characterizing a component is encapsulated and accessible only by its methods. The relations between components are modeled explicitly by means of associations or references. A relation is also a phenomenon and objects can model this type of phenomena too. Components are usually related conceptually in diverse and subtle ways: Some relations are implicitly given and some are local to other more basic relations. Such kinds of relations are important for understanding the organization and cooperation of objects and may be supported in object-oriented analysis, design, and programming: An implicit association describes a relation between an object and objects local to this enclosing object, and a complex association describes an explicit relation between local objects in different enclosing objects. Such associations are described by classes and the objects have the usual properties including methods and attributes.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191120", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bent Bruun", + "last_name": "Kristensen", + "institution": "Aalborg University" + } + ], + "dblp_key": "conf/oopsla/Kristensen94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191091", + "title": "ODE: A Self-Guided, Scenario-Based Learning Environment for Object-Oriented Design Principles", + "abstract": "ODE: A SELF-GUIDED, SCENARIO-BASED LEARNING ENVIRONMENT FOR OBJECT-ORIENTED DESIGN PRINCIPLES Scott P. Robertson,* John M. Carroll,* Robert L. Mack, Mary Beth Rosson,* Sherman R. Alpert, Jurgen Koenemann-Belliveau” IBM Research T. J. Watson Research Center 30 Saw Mill River Road Hawthorne, NY 10532 Internet:", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191091", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Scott P.", + "last_name": "Robertson", + "institution": "IBM (United States)" + }, + { + "first_name": "John M.", + "last_name": "Carroll", + "institution": "Virginia Tech" + }, + { + "first_name": "Robert L.", + "last_name": "Mack", + "institution": "IBM (United States)" + }, + { + "first_name": "Mary Beth", + "last_name": "Rosson", + "institution": "Virginia Tech" + }, + { + "first_name": "Sherman R.", + "last_name": "Alpert", + "institution": "IBM (United States)" + }, + { + "first_name": "Jürgen", + "last_name": "Koenenmann-Belliveau", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/oopsla/RobertsonCMRAK94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191114", + "title": "MI - An Object Oriented Environment for Integration of Scientific Applications", + "abstract": "Scientific and engineering software is often produced by integration of existing software components of the size of a whole program. However, on the average, scientific software was not developed for reusability and is quite distant from the user model of the application problem; integration and retrofitting is as such a costly process. An architecture, methodology and several C++ class libraries for supporting integration are introduced. The architecture separates a software component layer, and an integration layer. The latter in based on the concept of software model, that is an abstraction of components and a representation of the system differing from its actual physical structure. The methodology is based on matching needs with existing models. The C++ class libraries are explained in some detail. The application to two major systems is analysed and the ideas behind seven other systems are briefly outlined. Some lessons learned are summarised in the conclusions.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191114", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Spinelli", + "institution": "Istituto Sperimentale Modelli E Strutture" + }, + { + "first_name": "Paolo", + "last_name": "Salvaneschi", + "institution": "Istituto Sperimentale Modelli E Strutture" + }, + { + "first_name": "Mauro", + "last_name": "Cadei", + "institution": "Istituto Sperimentale Modelli E Strutture" + }, + { + "first_name": "Marino", + "last_name": "Rocca", + "institution": "Istituto Sperimentale Modelli E Strutture" + } + ], + "dblp_key": "conf/oopsla/SpinelliSCR94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191115", + "title": "Methodology Standards: Help or Hindrance?", + "abstract": "article Free Access Share on Methodology standards: help or hindrance? Authors: Grady Booch Rational Software Corporation Rational Software CorporationView Profile , Brian Henderson-Sellers University of Technology, Sydney University of Technology, SydneyView Profile , Ivar Jacobson Objective Systems AB Objective Systems ABView Profile , Steve Mellor Project Technology, Inc. Project Technology, Inc.View Profile , James Rumbaugh GE GEView Profile , Rebecca Wirfs-Brock Digitalk DigitalkView Profile , Chairman: David Monarchi University of Colorado, Boulder University of Colorado, BoulderView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 29Issue 10Oct. 1994 pp 223–228https://doi.org/10.1145/191081.191115Online:01 October 1994Publication History 5citation0DownloadsMetricsTotal Citations5Total Downloads0Last 12 Months0Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191115", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Grady", + "last_name": "Booch", + "institution": "Ratio" + }, + { + "first_name": "Brian", + "last_name": "Henderson‐Sellers", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "Objective Solutions (China)" + }, + { + "first_name": "Steve", + "last_name": "Mellor", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Rumbaugh", + "institution": "University of Colorado System" + }, + { + "first_name": "Rebecca", + "last_name": "Wirfs-Brock", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MonarchiBHJMRW94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191113", + "title": "Development of an OO Infrastructure for Mainframe Database Applications", + "abstract": "Large mainframe installations need and want to exploit the advantages of Object Technology (OT), but without totally abandoning their legacy environments. Implementing Object Orientation in such a COBOL/CICS/DB2 environment is a challenge: there is neither language support, nor development tools, nor execution infrastructure, nor testing utilities. Yet Object Orientation can be fully implemented, and a project can still meet rigorous performance requirements and tough delivery time scales. The key is to develop an infrastructure. This paper relates the lessons learned in designing and implementing such an OO infrastructure at British Telecom.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191113", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Darryl James", + "last_name": "Rothering", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Rothering94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191144", + "title": "Semantic Locking in Object-Oriented Database Systems", + "abstract": "Object-oriented databases are being increasingly used to model non-standard applications that emphasize modularity, composition, and rapid prototyping. A semantic locking protocol is presented for transaction management for such object-oriented databases. In particular, the protocol incorporates the semantics of complex objects, nested executions and dynamic conflicts resulting from referentially shared objects.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191144", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rodolfo F.", + "last_name": "Resende", + "institution": "" + }, + { + "first_name": "Divyakant", + "last_name": "Agrawal", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Amr El", + "last_name": "Abbadi", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/oopsla/ResendeAA94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191109", + "title": "Genericity versus Inheritance Reconsidered: Self-Reference Using Generics", + "abstract": "As shown by the work of Bertrand Meyer, it is possible to simulate genericity using inheritance, but not vice-versa. This is because genericity is a parameterization mechanism with no way to deal with the polymorphic typing introduced using inheritance. Nevertheless, if we focus on the use of inheritance as an implementation technique, its key feature is the dynamic binding of self-referential operation calls. This turns out to be basically a parameterization mechanism that can in fact be simulated using generics and static binding. And for some applications this approach may actually be of more than academic interest.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191109", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ed", + "last_name": "Seidewitz", + "institution": "Goddard Space Flight Center" + } + ], + "dblp_key": "conf/oopsla/Seidewitz94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191130", + "title": "Precise Concrete Type Inference for Object-Oriented Languages", + "abstract": "Concrete type information is invaluable for program optimization. The determination of concrete types in object-oriented languages is a flow sensitive global data flow problem. It is made difficult by dynamic dispatch (virtual function invocation) and first class functions (and selectors)—the very program structures for whose optimization its results are most critical. Previous work has shown that constraint-based type inference systems can be used to safely approximate concrete types [15], but their use can be expensive and their results imprecise.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191130", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Plevyak", + "institution": "Urbana University" + }, + { + "first_name": "Andrew A.", + "last_name": "Chien", + "institution": "Urbana University" + } + ], + "dblp_key": "conf/oopsla/PlevyakC94", + "venue": "oopsla", + "year": 1994 + }, + { + "paper_id": "10.1145/191080.191095", + "title": "Virtual Images: Interactive Visualization of Distributed Object-Oriented Systems", + "abstract": "In spite of growing needs in many areas, there is a lack of powerful graphical interfaces for interacting with large and complex sets of objects. Debugging, management and monitoring tools for object-oriented distributed systems or databases, for instance, need new interfaces that allow high quality visualization and interaction.", + "date": "1994-01-01", + "link": "https://doi.org/10.1145/191080.191095", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jean-Yves", + "last_name": "Vion-Dury", + "institution": "" + }, + { + "first_name": "Miguel", + "last_name": "Santana", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Vion-DuryS94", + "venue": "oopsla", + "year": 1994 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1995.json b/data/pl_conferences/oopsla/1995.json new file mode 100644 index 0000000..023efed --- /dev/null +++ b/data/pl_conferences/oopsla/1995.json @@ -0,0 +1,1107 @@ +[ + { + "paper_id": "10.1145/217838.217878", + "title": "Problem-Oriented Object Memory: Customizing Consistency", + "abstract": "This paper presents the notion of problem-oriented object memory, and its realization in a distributed object-based programming system, Penumbra. This system allows location transparent object invocation, object migration and caching. Its distinguishing feature, however, is its support for problem-oriented object sharing.Problem-oriented object memory is an object model that allows exploitation of application specific semantics by relaxing strict consistency in favour of performance.Our work addresses the problem of achieving scalability of shared write-intensive data in an environment of networked workstations. We have successfully applied the presented ideas to the management of a highly demanding telecoms application.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217878", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anders", + "last_name": "Kristensen", + "institution": "Bristol Laboratories (United Kingdom)" + }, + { + "first_name": "Colin", + "last_name": "Low", + "institution": "Bristol Laboratories (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/KristensenL95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217864", + "title": "Subject-Oriented Composition Rules", + "abstract": "Subject-oriented programming supports composition of object-oriented programs or program fragments called subjects. This paper presents an approach to the composition rules used to specify composition details. Rules can be generic, allowing different subrules to be \"plugged into\" higher-level rules, and they include a means of specifying exceptions to general rules. We give definitions of a number of useful, generic rules, including merge and override, as a first step towards a generally-useful composition rule library. We also outline an object-oriented framework for implementing rules, which we are currently building as part of our support for subject-oriented programming in C++.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217864", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Harold", + "last_name": "Ossher", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Matthew", + "last_name": "Kaplan", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "William", + "last_name": "Harrison", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Alexander", + "last_name": "Katz", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Vincent", + "last_name": "Kruskal", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/OssherKHKK95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217852", + "title": "Subtypes vs. Where Clauses: Constraining Parametric Polymorphism", + "abstract": "All object-oriented languages provide support for subtype polymorphism, which allows the writing of generic code that works for families of related types. There is also a need, however, to write code that is generic across types that have no real family relationship. To satisfy this need a programming language must provide a mechanism for parametric polymorphism, allowing for types as parameters to routines and types. We show that to support modular programming and separate compilation there must be a mechanism for constraining the actual parameters of the routine or type. We describe a simple and powerful constraint mechanism and compare it with constraint mechanisms in other languages in terms of both ease of use and semantic expressiveness. We also discuss the interaction between subtype and parametric polymorphism: we discuss the subtype relations that can exist between instantiations of parameterized types, and which of those relations are useful and can be implemented efficiently. We illustrate our points using examples in Theta, a new object-oriented language, and we describe the time- and space-efficient implementation of parametric polymorphism used in Theta.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217852", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mark", + "last_name": "Day", + "institution": "Rogers (United States)" + }, + { + "first_name": "Robert", + "last_name": "Gruber", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Barbara", + "last_name": "Liskov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/DayGLM95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217847", + "title": "Type Feedback vs. Concrete Type Inference: A Comparison of Optimization Techniques for Object-Oriented Languages", + "abstract": "Two promising optimization techniques for object-oriented languages are type feedback (profile-based receiver class prediction) and concrete type inference (static analysis). We directly compare the two techniques, evaluating their effectiveness on a suite of 23 SELF programs while keeping other factors constant.Our results show that both systems inline over 95% of all sends and deliver similar overall performance with one exception: SELF's automatic coercion of machine integers to arbitrary-precision integers upon overflow confounds type inference and slows down arithmetic-intensive benchmarks.We discuss several other issues which, given the comparable run-time performance, may influence the choice between type feedback and type inference.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217847", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ole", + "last_name": "Agesen", + "institution": "Stanford University" + }, + { + "first_name": "Urs", + "last_name": "Hölzle", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/oopsla/AgesenH95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217859", + "title": "Tailoring OO Analysis and Design Methods - Panel Session", + "abstract": "Existing formalisms of inheritance are not sufficient to model the complexities of the kind of multiple inheritance exemplified in C++. Any satisfactory formalism must model the complicating effects of virtual and nonvirtual base classes as well as virtual and non-virtual methods. By abstracting the implementational notion of a subobject and formalizing subobject selection, we develop a formalism to model this combination of features. Not intended as a formal semantics of C++, the resulting model should nevertheless provide an essential level of understanding for language theorists and implementors in their dealings with C++ and related languages.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217859", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Frank", + "last_name": "Armour", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Todd", + "last_name": "Cotton", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Geoff", + "last_name": "Hambrick", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Barbara E.", + "last_name": "Moo", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Dennis", + "last_name": "Mancl", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/oopsla/ManclAHM95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217851", + "title": "Minimizing Row Displacement Dispatch Tables", + "abstract": "Row displacement dispatch tables implement message dispatching for dynamically-typed languages with a run time overhead of one memory indirection plus an equality test. The technique is similar to virtual function table lookup, which is, however, restricted to statically typed languages like C++. We show how to reduce the space requirements of dispatch tables to approximately the same size as virtual function tables. The scheme is then generalized for multiple inheritance. Experiments on a number of class libraries from five different languages demonstrate that the technique is effective for a broad range of programs. Finally, we discuss optimizations of the row displacement algorithm that allow dispatch table construction of these large samples to take place in a few seconds.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217851", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karel", + "last_name": "Driesen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Urs", + "last_name": "Hölzle", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/oopsla/DriesenH95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217844", + "title": "Using a Prototype-based Language for User Interface: The Newton Project's Experience", + "abstract": "Object-oriented user interface frameworks are usually implemented in a class-based language. We chose instead to develop a prototype-based language, NewtonScript, for this purpose. We found that prototype inheritance has compelling advantages over classes in the domain of user interface programming, and can help overcome the memory constraints of a small machine.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217844", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Walter R.", + "last_name": "Smith", + "institution": "Apple (United States)" + } + ], + "dblp_key": "conf/oopsla/Smith95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217873", + "title": "Patterns in Practice", + "abstract": "Object-oriented systems often exhibit idiomatic and recurring structures of objects and classes that solve particular design problems and make systems more flexible, elegant, and ultimately reusable. Design patterns have been proposed as one way to represent, record and reuse these recurring design structures and associated design experience. Here we report on experiences in using design patterns during the design of object-oriented systems.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217873", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard F.", + "last_name": "Helm", + "institution": "McGill University" + } + ], + "dblp_key": "conf/oopsla/Helm95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217865", + "title": "How and Why to Encapsulate Class Trees", + "abstract": "classes. They form an abstract design and leave the implementation to concrete subclasses. The abstract design is instantiated by naming these subclasses. Unfortunately, this exposes implementation details like class names and class tree structures. The paper gives a rationale and a general metaobject protocol design that encapsulates whole class trees. Clients of an abstract design retrieve classes and create objects based on class semantics specifications. Using abstract classes as the only interface enhances information hiding and makes it easier both to evolve a system and to configure system variants. 1", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217865", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dirk", + "last_name": "Riehle", + "institution": "Universität Hamburg" + } + ], + "dblp_key": "conf/oopsla/Riehle95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217875", + "title": "A Framework for Network Protocol Software", + "abstract": "Writing software to control networks is important and difficult. It must be efficient, reliable, and flexible. Conduits+ is a framework for network software that has been used to implement the signalling system of a mullti-protocol ATM access switch. An earlier version was used to implement TCP/IP. It reduces the complexity of network software, makes it easier to extend or modify network protocols, and is sufficiently efficient. Conduits+ shows the power of a componentized object-oriented framework and of common object-oriented design patterns.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217875", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hermann", + "last_name": "Hüni", + "institution": "" + }, + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois at Springfield" + }, + { + "first_name": "R.", + "last_name": "Engel", + "institution": "Ascom (Switzerland)" + } + ], + "dblp_key": "conf/oopsla/HuniJE95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217866", + "title": "A Reflective Model for First Class Dependencies", + "abstract": "We propose a reflective model to express and to automatically manage dependencies between objects. This model describes reflective facilities which enable the changing of language semantics. Although the importance of inter-object dependencies is well accepted, there is only limited object-oriented language support for their specification and implementation. In response to this lack of expressiveness of object models, the FLO language integrates dependency management into the object oriented paradigm. Dependencies are described as first class objects and FLO automatically maintains the consistency of the dependency graph.In this paper, we first show how a user can declare dependencies and how the system maintains the consistency of the graph of expressed dependencies. In a second part, we focus on the implementation of this management by controlling the messages sent to linked objects. In order to make dependency management orthogonal to other application concerns, we propose an abstraction of message handling, implemented with meta-objects. We illustrate the extensibility of our language with different control behavior implementations, in particular we study different implementations of the global control of message propagation flow.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217866", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sté́phane", + "last_name": "Ducasse", + "institution": "Université Côte d'Azur" + }, + { + "first_name": "Mireille", + "last_name": "Blay–Fornarino", + "institution": "Université Côte d'Azur" + }, + { + "first_name": "Anne-Marie", + "last_name": "Pinna-Déry", + "institution": "Université Côte d'Azur" + } + ], + "dblp_key": "conf/oopsla/DucasseBP95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217868", + "title": "A Metaobject Protocol for C++", + "abstract": "This paper presents a metaobject protocol (MOP) for C . This MOP was designed to bring the power of meta-programming to C programmers. It avoids penalties on runtime performance by adopting a new meta-architecture in which the metaobjects control the compilation of programs instead of being active during program execution. This allows the MOP to be used to implement libraries of efficient, transparent language extensions. 1 Introduction A metaobject protocol (MOP) is an object-oriented interface for programmers to customize the behavior and implementation of programming languages and other system software. The usefulness of this kind of customizability has been argued elsewhere[11, 9, 10], and interesting MOPs have been included in languages such as Lisp[20], ABCL[21], and, to a lesser degree, Smalltalk[6]. The goal of our work is to bring the power of metaprogramming to the more mainstream language C , while respecting their performance concerns in that community. This paper pr...", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217868", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shigeru", + "last_name": "Chiba", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/Chiba95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217869", + "title": "Compiling Away the Meta-Level in Object-Oriented Concurrent Reflective Languages Using Partial Evaluation", + "abstract": "Meta-level programmability is beneficial for parallel/distributed object-oriented computing to improve performance, etc. The major problem, however, is interpretation overhead due to mta-circular interpretation. To solve this problem, we propose a compilation framework for object-oriented concurrent reflective languages using partial evaluation. Since traditional partial evaluators do not allow us to directly deal with meta-circular interpreters written with concurrent objects, we devised techniques such as pre-/post-processing, a new proposed preaction extension to partial evaluation in order to handle side-effects, etc. Benchmarks of a prototype compiler for our language ABCL/R3 indicate that (1) the meta-level interpretation is essentially 'compiled away,' and (2) mta-level optimizations in a parallel application, running on a Fujitsu MPP AP1000, exhibits only 10--30% overhead compared to the hand-crafted source-level optimization in a non-reflective language.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217869", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hidehiko", + "last_name": "Masuhara", + "institution": "Japan Society for the Promotion of Science London" + }, + { + "first_name": "Satoshi", + "last_name": "Matsuoka", + "institution": "The University of Tokyo" + }, + { + "first_name": "Kenichi", + "last_name": "Asai", + "institution": "Tokyo University of Science" + }, + { + "first_name": "Akinori", + "last_name": "Yonezawa", + "institution": "Tokyo University of Science" + } + ], + "dblp_key": "conf/oopsla/MasuharaMAY95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217848", + "title": "Profile-Guided Receiver Class Prediction", + "abstract": "The use of dynamically-dispatched procedure calls is a key mechanism for writing extensible and flexible code in object-oriented languages. Unfortunately, dynamic dispatching imposes a runtime performance penalty. Some recent implementations of pure object-oriented languages have utilized profile-guided receiver class prediction to reduce this performance penalty, and some researchers have argued for applying receiver class prediction in hybrid languages like C++. We performed a detailed examination of the dynamic profiles of eight large object-oriented applications written in C++ and Cecil, determining that the receiver class distributions are strongly peaked and stable across both inputs and program versions through time. We describe techniques for gathering and manipulating profile information at varying degrees of precision, particularly in the presence of optimizations such as inlining. Our implementation of profile-guided receiver class prediction improves the performance of large Cecil applications by more than a factor of two over solely static optimizations.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217848", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Grove", + "institution": "University of Washington" + }, + { + "first_name": "Jeffrey A.", + "last_name": "Dean", + "institution": "University of Washington" + }, + { + "first_name": "Charles", + "last_name": "Garrett", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/GroveDGC95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217874", + "title": "Interactive Visualization of Design Patterns Can Help in Framework Understanding", + "abstract": "Framework programming is regarded as one the main advantages of object-oriented software engineering, and is expected to increase software reuse. In exploiting frameworks, however, programmers often face difficulties caused by the complexity of the hidden architecture and the multiplicity of the design decisions that are embedded in a framework. Interactive visualization of design patterns occurring in a framework shows how the framework is operating, in a flexible yet structured way that contributes to the programmer's understanding of the underlying software architecture. In this way, programmers can explore and use frameworks efficiently even when they are distributed without vast amounts of documentation and source code.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217874", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Danny B.", + "last_name": "Lange", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Yuichi", + "last_name": "Nakamura", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/LangeN95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217850", + "title": "OO Testing in the Real World: Lessons for All - Panel Session", + "abstract": "No abstract available.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217850", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John D.", + "last_name": "McGregor", + "institution": "Clemson University" + }, + { + "first_name": "Ed", + "last_name": "Berard", + "institution": "" + }, + { + "first_name": "Don", + "last_name": "Firesmith", + "institution": "Knowledge Systems Institute" + }, + { + "first_name": "Brian", + "last_name": "Marick", + "institution": "Clemson University" + }, + { + "first_name": "Dave J.", + "last_name": "Thomson", + "institution": "Object Computing (United States)" + } + ], + "dblp_key": "conf/oopsla/McGregorBFMT95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217862", + "title": "On the Semantic Diversity of Delegation-Based Programming Languages", + "abstract": "The prototype-based programming model has always been difficult to characterize precisely. Its basic principle advocates concrete objects as the only mean to model concepts, yet current languages promote methodologies reintroducing abstract constructions to manage efficiently groups of similar objects. In this paper, we propose a rational reconstruction of delegation-based programming languages that identifies programming models going beyond traditional prototypes. We also introduce a new classification of delegation-based languages, which clarifies these models, and we discuss their relative merits. We finally bring to the fore the existence of more and more structured delegation-based languages forming a continuum between pure prototype-based languages and class-based ones.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217862", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jacques", + "last_name": "Malenfant", + "institution": "Université de Montréal" + } + ], + "dblp_key": "conf/oopsla/Malenfant95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217883", + "title": "Extending SQL-92 for OODB Access: Design and Implementation Experience", + "abstract": "This paper describes the design and implementation of a query engine that provides extended SQL-based access to the data managed by an object-oriented database system. This query engine allows extended SQL queries to be embedded in C++ programs or issued interactively as from a command line interface. The language supported by the engine is the complete SQL-92 select statement plus object extensions for navigating along paths and embedded structures, querying nested sets, and invoking member functions. In addition, an object-oriented SQL view facility is provided. Using this view facility, one can define object-oriented views; one can also define views that flatten complex OODB schemas, allowing direct access by existing tools designed to provide remote access to relational databases. The view facility also supports the definition of views that include reference and set-valued columns based on other views, thus allowing entire \"view schemas\" to be created. This paper describes the SQL-92 query and view extensions and discusses a number of issues that arose on the way to the implementation that is currently running on top of the ObjectStore OODB system.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217883", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jerry", + "last_name": "Kiernan", + "institution": "IBM (United States)" + }, + { + "first_name": "Michael J.", + "last_name": "Carey", + "institution": "IBM Research - Almaden" + } + ], + "dblp_key": "conf/oopsla/KiernanC95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217877", + "title": "SCONE: Using Concurrent Objects for Low-level Operating System Programming", + "abstract": "This paper proposes a methodology for making low-level system code of operating systems be replaceable at runtime. Our approach is to use concurrent objects as a basic programming unit for low-level system programs. To realize the different need for each type of system code and to execute these concurrent objects sufficiently efficient, we use a combination of dedicated system service layers and other implementation techniques. System service layers provide the most suitable primitive operations for each concurrent object. Under our programming model for low-level system code, which we call SCONE, it is possible to program low-level system code without hazardous operations such as explicit synchronization, direct scheduler manipulation, etc. We present the implementation of our methodology on the Apertos operating system and demonstrate its efficiency with performance evaluation.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217877", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jun-ichiro", + "last_name": "Itoh", + "institution": "Keio University" + }, + { + "first_name": "Yasuhiko", + "last_name": "Yokote", + "institution": "Sony Computer Science Laboratories" + }, + { + "first_name": "Mario", + "last_name": "Tokoro", + "institution": "Sony Computer Science Laboratories" + } + ], + "dblp_key": "conf/oopsla/ItohYT95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217867", + "title": "Systematic Software Reuse - Panel Session", + "abstract": "No abstract available.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217867", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Griss", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Ted J.", + "last_name": "Biggerstaff", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Sallie M.", + "last_name": "Henry", + "institution": "Virginia Tech" + }, + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "" + }, + { + "first_name": "Doug", + "last_name": "Lea", + "institution": "State University of New York at Oswego" + }, + { + "first_name": "Will", + "last_name": "Tracz", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/GrissBHJLT95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217846", + "title": "Managing Object Oriented Projects - Panel Session", + "abstract": "Projects using Object Oriented typically fall into one of two categories: either they are run with traditional project management techniques, or they are run by technology experts who don't use any project management techniques. This panel will attempt to give out some hints as to how to be more successful managing OO projects.Questions to be addressed include:• How is Object Oriented Project Management different? Is a paradigm shift required for project management?• What aspects of Object Oriented project management should be stressed? What are some tips, tricks or gotchas experienced by the panel members?• Does a project manager need to be more technical to lead an Object Oriented project? Should he/she have had previous experience with Object Oriented development?• What are some alternate organizational structures which would better support Object Oriented projects?• What is the nature of an Object Oriented life cycle and how is it different?• Is there a difference in techniques between different languages or between different domainsAudience members with relevant experience will be invited to sit on the panel in two guest seats.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217846", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Laura", + "last_name": "Hill", + "institution": "" + }, + { + "first_name": "Kenny", + "last_name": "Rubin", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Daniels", + "institution": "" + }, + { + "first_name": "Charles", + "last_name": "Berman", + "institution": "" + }, + { + "first_name": "James O.", + "last_name": "Coplien", + "institution": "" + }, + { + "first_name": "Doug", + "last_name": "Johnson", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/HillRDBCJ95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217871", + "title": "Object and Database Standards - Panel Session", + "abstract": "No abstract available.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217871", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "R. G. G.", + "last_name": "Cattell", + "institution": "" + }, + { + "first_name": "Frank", + "last_name": "Manola", + "institution": "TE Laboratories (Ireland)" + }, + { + "first_name": "Richard Mark", + "last_name": "Soley", + "institution": "" + }, + { + "first_name": "Jeff", + "last_name": "Sutherland", + "institution": "" + }, + { + "first_name": "Mary E. S.", + "last_name": "Loomis", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/LoomisCMSS95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217840", + "title": "Extending the Statechart Formalism: Event Scheduling & Disposition", + "abstract": "Statecharts are extended to deal with events when no applicable transition is available, and to resolve conflicts relative to event scheduling and response that can arise whenever multiple states can be active simultaneously. Event closure and event scheduling are achieved without having to clutter up a basic statechart. The extensions are effected by means of declarative event disposition rules. These rules, together with the statechart topology, determine the contents of one or more disposition matrices. These matrices are combined with the statechart state to determine the response of the event dispatcher to incoming events. The operation of the event dispatcher is also described. A detailed example illustrates these concepts, which are further characterized, for the benefit of working programmers, in the form of a behavioral design pattern. A tool called StateCraft embodies these notions.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217840", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Allen", + "institution": "" + }, + { + "first_name": "Dennis de", + "last_name": "Champeaux", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/AllenC95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217879", + "title": "Evolving to Objects - The Witches' Brew", + "abstract": "\"Double, double toil and trouble, fire burn and cauldron bubble\" … chant the witches of Macbeth. Take a corporation with a rich, decades-old history of providing on-line services on MVS mainframes, coupled with a vision of the future including OO design and programming, DCE for client-server infrastructure, heterogeneous platform mixes across the Unix and PC worlds, and plan to tie that back to the established systems - and you have a Witches' Brew of your own. The question for our project has been \"How to introduce OO technology into an existing project framework with the least effort and most benefit?\". Recent industry experience reports detailing the blending of OO and DCE indicate that this has not been easy; our experience confirms that, but our approach has allowed us to utilize the strengths of OO to minimize the complexities inherent in the mix.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217879", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Don", + "last_name": "Barton", + "institution": "Lexicon Pharmaceuticals (United States)" + }, + { + "first_name": "Tom", + "last_name": "Arnold", + "institution": "Lexicon Pharmaceuticals (United States)" + } + ], + "dblp_key": "conf/oopsla/BaronA95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217842", + "title": "Lessons from the Experiences of Leading-Edge Object Technology Projects in Hewlett Packard", + "abstract": "A study of leading-edge HP object technology projects was conducted to understand the current state of object-oriented practice, and projects' object-oriented analysis and design method needs. In this paper, we distill general best practices and pitfalls from the lessons learned in these projects. We also consider how the OOA/D methods support what the businesses have set out to accomplish, where they are deficient, and how they are being modified to better support project needs. We draw upon these lessons to point out areas where OOA/D methods and CASE tools require improvement.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217842", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ruth", + "last_name": "Malan", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Derek", + "last_name": "Coleman", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Reed", + "last_name": "Letsinger", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/MalanCL95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217882", + "title": "SmartFiles: An OO Approach to Data File Interoperabilty", + "abstract": "Data files for scientific and engineering codes typically consist of a series of raw data values whose description is buried in the programs that interact with these files. In this situation, making even minor changes in the file structure or sharing files between programs (interoperability) can only be done after careful examination of the data files and the I/O statements of the programs interacting with this file. In short, scientific data files lack self-description, and other self-describing data techniques are not always appropriate or useful for scientific data files. By applying an object-oriented methodology to data files, we can add the intelligence required to improve data interoperability and provide an elegant mechanism for supporting complex, evolving, or multidisciplinary applications, while still supporting legacy codes. As a result, scientists and engineers should be able to share datasets with far greater ease, simplifying multidisciplinary applications and greatly facilitating remote collaboration between scientists.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217882", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Haines", + "institution": "University of Wyoming" + }, + { + "first_name": "Piyush", + "last_name": "Mehrotra", + "institution": "Langley Research Center" + }, + { + "first_name": "John Van", + "last_name": "Rosendale", + "institution": "Langley Research Center" + } + ], + "dblp_key": "conf/oopsla/HainesMR95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.328566", + "title": "The Future of Distributed Object Computing - Panel Session", + "abstract": "No abstract available.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.328566", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bob", + "last_name": "Atkinson", + "institution": "Microsoft (Norway)" + }, + { + "first_name": "Chris", + "last_name": "Horn", + "institution": "Iona College" + }, + { + "first_name": "Hari", + "last_name": "Madduri", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/MarcusAHM95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217863", + "title": "Patterns: Cult to Culture? - Panel Session", + "abstract": "Article Free Access Share on Patterns: cult to culture? Authors: Steven Fraser BNR/Nortel (Moderator) BNR/Nortel (Moderator)View Profile , Grady Booch Rational RationalView Profile , Frank Buschmann Siemens SiemensView Profile , Jim Coplien AT&T AT&TView Profile , Norm Kerth Elite Systems Elite SystemsView Profile , Ivar Jacobson Objectory ObjectoryView Profile , Mary Beth Rosson Virginia Polytechnic Institute and State University Virginia Polytechnic Institute and State UniversityView Profile Authors Info & Claims OOPSLA '95: Proceedings of the tenth annual conference on Object-oriented programming systems, languages, and applicationsOctober 1995 Pages 231–234https://doi.org/10.1145/217838.217863Online:17 October 1995Publication History 3citation600DownloadsMetricsTotal Citations3Total Downloads600Last 12 Months19Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217863", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "Nortel (Canada)" + }, + { + "first_name": "Grady", + "last_name": "Booch", + "institution": "" + }, + { + "first_name": "Frank", + "last_name": "Buschmann", + "institution": "Siemens (Germany)" + }, + { + "first_name": "Jim", + "last_name": "Coplien", + "institution": "AT&T (United States)" + }, + { + "first_name": "Norm", + "last_name": "Kerth", + "institution": "" + }, + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "" + }, + { + "first_name": "Mary Beth", + "last_name": "Rosson", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/oopsla/FraserBBCJKR95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217880", + "title": "Release-to-Release Binary Compatibility in SOM", + "abstract": "SOM (IBM's System Object Model) removes a major impediment to reuse in Object-Oriented Programming by facilitating the programming of release-to-release binary compatible class libraries. This is accomplished by supporting a large number of compatibility preserving transformations. Taken together these transformations compose a discipline for programming evolving class libraries.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217880", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ira R.", + "last_name": "Forman", + "institution": "" + }, + { + "first_name": "Michael H.", + "last_name": "Conner", + "institution": "" + }, + { + "first_name": "Scott", + "last_name": "Danforth", + "institution": "" + }, + { + "first_name": "Larry K.", + "last_name": "Raper", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FormanCDR95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217870", + "title": "Towards a Methodology for Explicit Composition of MetaObjects", + "abstract": "Reflective programming languages are those where users' programs are allowed to customize in an organized way the behavior of the language to their own needs. For ten years now, most of the work on reflection revolved around the definition and the implementation of metaobject protocols which express this organization. No methodologies have been proposed for reflective programming per se. This paper proposes a first one aiming at the design of composable metaobjects. Given two independently developed reflective customizations, this methodology proposes principles to be observed in their design such that they can be composed using standard base-level aggregation or specialization. While this paper focuses on a simple MOP and illustrates the methodology on specific examples, this methodology can be generalized to other languages with different MOPs. For instance, we discuss how to adapt it to CLOS.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217870", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philippe", + "last_name": "Mulet", + "institution": "" + }, + { + "first_name": "Jacques", + "last_name": "Malenfant", + "institution": "Université de Montréal" + }, + { + "first_name": "Pierre", + "last_name": "Cointe", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MuletMC95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217858", + "title": "Sound Polymorphic Type Inference for Objects", + "abstract": "A polymorphic, constraint-based type inference algorithm for an object-oriented language is defined. A generalized form of type, polymorphic recursively constrained types, are inferred. These types are expressive enough for typing objects, since they generalize recursive types and F-bounded polymorphism. The well-known tradeoff between inheritance and subtyping is mitigated by the type inference mechanism. Soundness and completeness of type inference are established.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217858", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Eifrig", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Valery", + "last_name": "Trifonov", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/oopsla/EifrigST95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217872", + "title": "Objects and Domain Engineering - Panel Session", + "abstract": "Article Free Access Share on Objects and domain engineering (panel) Authors: Sanjiv Gossain Cambridge Technology Partners Cambridge Technology PartnersView Profile , Don Batory University of Texas at Austin University of Texas at AustinView Profile , Hassan Gomaa George Mason University George Mason UniversityView Profile , Mitch Lubars Scientific and Engineering Software Inc. Scientific and Engineering Software Inc.View Profile , Christopher Pidgeon Cambridge Technology Partners Cambridge Technology PartnersView Profile , Ed Seidewitz NASA Goddard Space Flight Center NASA Goddard Space Flight CenterView Profile Authors Info & Claims OOPSLA '95: Proceedings of the tenth annual conference on Object-oriented programming systems, languages, and applicationsOctober 1995Pages 333–336https://doi.org/10.1145/217838.217872Published:17 October 1995Publication History 1citation274DownloadsMetricsTotal Citations1Total Downloads274Last 12 Months19Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217872", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sanjiv", + "last_name": "Gossain", + "institution": "" + }, + { + "first_name": "Don", + "last_name": "Batory", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Hassan", + "last_name": "Gomaa", + "institution": "George Mason University" + }, + { + "first_name": "Mitch", + "last_name": "Lubars", + "institution": "" + }, + { + "first_name": "Christopher W.", + "last_name": "Pidgeon", + "institution": "" + }, + { + "first_name": "Ed", + "last_name": "Seidewitz", + "institution": "Goddard Space Flight Center" + } + ], + "dblp_key": "conf/oopsla/GossainBGLPS95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217876", + "title": "Creating the Architecture of a Manufacturing Framework by Design Patterns", + "abstract": "The class and interaction structure of object-oriented designs may become fairly complex, and consequently difficult to develop and understand. Design patterns allow to govern this complexity. This paper presents the design process of a domain-specific black-box framework for the control of automated manufacturing systems. The design is performed as a sequence of transformation steps, guided by the use of generative design patterns. Starting out from a domain-specific model. which does not provide a degree of reusability sufficiently high for a framework. the transformation steps increase the reusability until a satisfactory degree is reached. The resulting class and interaction structure allows to create each application of the considered manufacturing subdomain by selecting, configuring and parameterizing of the framework classes.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217876", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hans Albrecht", + "last_name": "Schmid", + "institution": "HTWG Hochschule Konstanz - Technik, Wirtschaft und Gestaltung" + } + ], + "dblp_key": "conf/oopsla/Schmidt95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217843", + "title": "The Self-4.0 User Interface: Manifesting a System-wide Vision of Concreteness, Uniformity and Flexibility", + "abstract": "Manipulating programs is hard, while manipulating objects in the physical world is often easy. Several attributes of the physical world help make it comprehensible and manipulable: concreteness, uniformity, and flexibility. The Self programming system attempts to apply these attributes to the world within the computer. The semantics of the language, the efficiency and fidelity of its implementation, and the architecture of its user interface conspire to make the experience of constructing programs in Self immediate and tangible. We describe the mechanisms used to achieve this goal, and illustrate those mechanisms within the context of an extended programming task.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217843", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Randall B.", + "last_name": "Smith", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Maloney", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Ungar", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SmithMU95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217849", + "title": "Bidirectional Object Layout for Separate Compilation", + "abstract": "Existing schemes for object layout and dispatch in the presence of multiple inheritance and separate compilation waste space and are slower than systems with single inheritance. This paper describes the bidirectional object layout, a new scheme for object layout that produces smaller objects and faster method invocations than existing schemes by automatically optimizing particular uses of multiple inheritance. The bidirectional object layout is used for the programming language Theta, and is applicable to languages like C++. This paper also demonstrates how to efficiently implement method dispatch when method signatures are allowed to change in subclasses. Most current statically compiled languages require identical signatures for efficiency. 1 Introduction Existing schemes for object memory layout and method dispatch in statically typed languages with multiple inheritance assume the use of multiple inheritance in its full generality. These schemes incur high per-object space overhea...", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217849", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Myers95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217841", + "title": "Object-Oriented State Machines: Subclassing, Composition, Delegation and Genericity", + "abstract": "Software specification and implementation techniques based on state machines simplify design, coding, and validation. However, large systems require complex state machines. Incremental construction techniques can control this complexity. In this paper, we present a construction technique that permits derivation of complex state machines from simpler state machines. The technique uses subclassing, composition, delegation, and genericity to incrementally modify and combine simpler machines.In addition, we present a novel implementation technique that uses exactly one table-lookup and one addition to dispatch events on derived state machines, no matter the depth of the derivation. As an example, we describe the derivation of a complicated distributed virtual memory scheme from a simple paging virtual memory scheme.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217841", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aamod", + "last_name": "Sane", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Roy H.", + "last_name": "Campbell", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/SaneC95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217860", + "title": "An Algebraic Semantics of Subobjects", + "abstract": "Existing formalisms of inheritance are not sufficient to model the complexities of the kind of multiple inheritance exemplified in C++. Any satisfactory formalism must model the complicating effects of virtual and nonvirtual base classes as well as virtual and non-virtual methods. By abstracting the implementational notion of a subobject and formalizing subobject selection, we develop a formalism to model this combination of features. Not intended as a formal semantics of C++, the resulting model should nevertheless provide an essential level of understanding for language theorists and implementors in their dealings with C++ and related languages. 1 Introduction The style of multiple inheritance first proposed for Simula by Krogdahl[21] and later developed into the C++ multiple inheritance system by Stroustrup[35, 15] exemplifies a particular kind of inheritance in which the underlying imperative is to maintain the integrity of subobjects. Subobjects are historically an implementation...", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217860", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan G.", + "last_name": "Rossie", + "institution": "" + }, + { + "first_name": "Daniel P.", + "last_name": "Friedman", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/RossieF95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217845", + "title": "Annotating Objects for Transport to Other Worlds", + "abstract": "In Self 4.0, people write programs by directly constructing webs of objects in a larger world of objects. But in order to save or share these programs, the objects must be moved to other worlds. However, a concrete, directly constructed program is incomplete, in particular missing five items of information: which module to use, whether to transport an actual value or a counterfactuaI initial value, whether to create a new object in the new world or to refer to an existing one, whether an object is immutable with respect to transportation, and whether an object should be created by a low-level, concrete expression or an abstract, type-specific expression. In Self 4.0, the programmer records this extra information in annotations and attributes. Any system that saves directly constructed programs will have to supply this missing information somehow.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217845", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Ungar", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/Ungar95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217881", + "title": "Lessons from the Battlefield", + "abstract": "The pragmatic aspects of deploying large scale Object Oriented (OO) applications are examined. The focus is on identifying some of the main obstacles that arise in typical large scale OO projects, and offering hints about effective solutions. This The topics are based on a number of actual large scale projects in which the author participated in a It significant capacity and solutions that he adopted or developed to deal with the problems encountered.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217881", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas P.", + "last_name": "Vayda", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Vajda95", + "venue": "oopsla", + "year": 1995 + }, + { + "paper_id": "10.1145/217838.217861", + "title": "Modular Reasoning in the Presence of Subclassing", + "abstract": "Considerable progress has been made in understanding how to use subtyping in a way that facilitates modular reasoning. However, using subclassing in a way that facilitates modular reasoning is not well understood. Often methods must be overriden as a group because of dependencies on instance variables, and the programmers of subclasses cannot tell which methods are grouped without looking at the code of superclasses. Also, the programmers of subclasses must look at the code of superclasses to tell what assumptions inherited methods make about the behavior of overriden methods.We present a systematic way to use subclassing that facilitates formal and informal modular reasoning. Separate specifications are given to programmers writing code that manipulates instances of a class and to programmers writing subclasses of the class. The specifications given to programmers of subclasses are divided, by division of labor specifications, into multiple parts. Subclasses may inherit or override entire parts, but not sub-parts. Reasoning about the implementation of each part is done independently of other parts.", + "date": "1995-10-17", + "link": "https://doi.org/10.1145/217838.217861", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Raymie", + "last_name": "Stata", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "John V.", + "last_name": "Guttag", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/StataG95", + "venue": "oopsla", + "year": 1995 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1996.json b/data/pl_conferences/oopsla/1996.json new file mode 100644 index 0000000..276ad43 --- /dev/null +++ b/data/pl_conferences/oopsla/1996.json @@ -0,0 +1,978 @@ +[ + { + "paper_id": "10.1145/236337.236346", + "title": "The Basic Object System: Supporting a Spectrum From Prototypes To Hardened Code", + "abstract": "BOS is a prototype-based, object-oriented toolkit aimed at better supporting evolutionary software development. BOS attempts to support a spectrum of activities in one environment---ranging from rapid prototyping to code hardening. Features enabling rapid prototyping include a prototype-based object model, an interpreted language, run-time argument constraints, position and keyword arguments, and a user interface toolkit. BOS also provides features for code hardening such as multi-methods, multiple inheritance, external code wrapping mechanisms, and interfaces to other packages such as database management systems. BOS thus enables the end-to-end programming of software in an integrated and unified environment. BOS has been used to develop several full-size applications which have been evaluated and delivered externally.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236346", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Allen H.", + "last_name": "Dutoit", + "institution": "Software Engineering Institute" + }, + { + "first_name": "Sean N.", + "last_name": "Levy", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Douglas", + "last_name": "Cunningham", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Robert", + "last_name": "Patrick", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/DutoitLCP96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236345", + "title": "Perspectives on Reuse (Panel Session)", + "abstract": "Reuse is about more than sharing code. As technology, standards and ideas evolve: so do the artifacts available for reuse. Our understanding of the non-technical issues associated with reuse also progresses. This panel will look at reuse from 5 different perspectives. We will look at the reuse of design patterns and of services in a service-based, distributed architecture as examples of artifacts relatively new to the corporate world. We will also focus on the psychological factors affecting the success of reuse programs along with organizational modifications and measurement techniques that will help make reuse work. Lastly, we will take a look at how certain kinds of reuse can affect the success of a project at the user level, and what this might imply for measuring the effectiveness of our reuse programs. The audience will leave with some concrete ideas about how to implement and measure reuse program as well as new thoughts on what artifacts may be reused.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236345", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lorette", + "last_name": "Cameron", + "institution": "" + }, + { + "first_name": "Charles", + "last_name": "Berman", + "institution": "Systems Technology (United States)" + }, + { + "first_name": "Brian", + "last_name": "Henderson‐Sellers", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Laura", + "last_name": "Hill", + "institution": "JPMorgan Chase & Co (United States)" + }, + { + "first_name": "Randall B.", + "last_name": "Smith", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Sanjiv", + "last_name": "Gossain", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/CameronBGHHS96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236380", + "title": "Architecture-Oriented Visualization", + "abstract": "Tracking the changing dynamics of object-oriented frameworks[5], design patterns[7], architectural styles[8], and subsystems during the development and reuse cycle can aid producing complex systems. Unfortunately, current object-oriented programming tools are relatively oblivious to the rich architectural abstractions in a system.This paper shows that architecture-oriented visualization, the graphical presentation of system statics and dynamics in terms of its architectural abstractions, is highly beneficial in designing complex systems. In addition, the paper presents architecture-aware instrumentation, a new technique for building efficient on-line instrumentation to support architectural queries. We demonstrate the effectiveness and performance of the scheme with case studies in the design of the Choices object-oriented operating system.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236380", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mohlalefi", + "last_name": "Sefika", + "institution": "National University of Lesotho" + }, + { + "first_name": "Aamod", + "last_name": "Sane", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Roy H.", + "last_name": "Campbell", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/SefikaSC96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236386", + "title": "Components on the Internet (Panel Session)", + "abstract": "The explosive emergence of the Internet forces us to rethink the traditional roles for client, server, and objects. Component technology has emerged as the way objects and frameworks are packaged for flexible object integration. In particular, components allow users who are not programmers to do their own integration. Up until now, components have mainly focused on object integration on end-users desktops and on a client: compound documents, application assembly, etc.Existing component models like OpenDoc and Microsoft's OLE/OCX/COM provide function for compound documents, persistence, scripting, inking, and code management (registration). A series of Internet scenarios are emerging that demand new kinds of components. These scenarios are thin clients (Internet terminals), virtual reality/rich multimedia clients, collaboration, and business data access. Each panelist will explore one of these scenarios for it's requirements on an Internet component model.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236386", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeffrey", + "last_name": "Bonar", + "institution": "" + }, + { + "first_name": "Nancy", + "last_name": "Lehrer", + "institution": "CSX (United States)" + }, + { + "first_name": "Kelly", + "last_name": "Looney", + "institution": "" + }, + { + "first_name": "Randy", + "last_name": "Schnier", + "institution": "University of Minnesota Rochester" + }, + { + "first_name": "J. C.", + "last_name": "Russel", + "institution": "" + }, + { + "first_name": "Ted", + "last_name": "Selker", + "institution": "IBM (United States)" + }, + { + "first_name": "Stewart", + "last_name": "Nickolas", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/BonarLLNRSS96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236343", + "title": "A Monotonic Superclass Linearization for Dylan", + "abstract": "Object-oriented languages with multiple inheritance and automatic conflict resolution typically use a linearization of superclasses to determine which version of a property to inherit when several superclasses provide definitions. Recent work has defined several desirable characteristics for linearizations, the most important being monotonicity, which prohibits inherited properties from skipping over direct superclasses. Combined with Dylan's sealing mechanism, a monotonic linearization enables some compile-time method selection that would otherwise be impossible in the absence of a closed-world assumption.The Dylan linearization is monotonic, easily described, strictly observes local precedence order, and produces the same ordering as CLOS when that is monotonic. We present an implementation based on merging and a survey of class heterarchies from several large programs, analyzing where commonly used linearizations differ.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236343", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kim", + "last_name": "Barrett", + "institution": "" + }, + { + "first_name": "Bob", + "last_name": "Cassels", + "institution": "" + }, + { + "first_name": "Paul", + "last_name": "Haahr", + "institution": "" + }, + { + "first_name": "David A.", + "last_name": "Moon", + "institution": "" + }, + { + "first_name": "Keith", + "last_name": "Playford", + "institution": "" + }, + { + "first_name": "P. Tucker", + "last_name": "Withington", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BarrettCHMPW96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236367", + "title": "Simple and Effective Analysis of Statically Typed Object-Oriented Programs", + "abstract": "To use modern hardware effectively, compilers need extensive control-flow information. Unfortunately, the frequent method invocations in object-oriented languages obscure control flow. In this paper, we describe and evaluate a range of analysis techniques to convert method invocations into direct calls for statically-typed object-oriented languages and thus improve control-flow information in object-oriented languages. We present simple algorithms for type hierarchy analysis, aggregate analysis, and interprocedural and intraprocedural type propagation. These algorithms are also fast, O(|procedures| * ∑pprocedure np * vp) worst case time (linear in practice) for our slowest analysis, where np is the size of procedure p and vp is the number of variables in procedure p, and are thus practical for use in a compiler. When they fail, we introduce cause analysis to reveal the source of imprecision and suggest where more powerful algorithms may be warranted. We show that our simple analyses perform almost as well as an oracle that resolves all method invocations that invoke only a single procedure.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236367", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/DiwanMM96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236360", + "title": "Soft Issues in Software Development (Panel Session)", + "abstract": "The key to making object technology work isn't technology. So what is it? This panel will cover a lot of the \"soft\" issues about dealing with people and teams. It's partly about managing software development, and mostly about doing it.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236360", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul S. R.", + "last_name": "Chisholm", + "institution": "" + }, + { + "first_name": "Larry L.", + "last_name": "Constantine", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Ward", + "last_name": "Cunningham", + "institution": "" + }, + { + "first_name": "Luke", + "last_name": "Hohmann", + "institution": "" + }, + { + "first_name": "Norman L.", + "last_name": "Kerth", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ChisholmCCHK96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236371", + "title": "Fast Static Analysis of C++ Virtual Function Calls", + "abstract": "Virtual functions make code easier for programmers to reuse but also make it harder for compilers to analyze. We investigate the ability of three static analysis algorithms to improve C++ programs by resolving virtual function calls, thereby reducing compiled code size and reducing program complexity so as to improve both human and automated program understanding and analysis. In measurements of seven programs of significant size (5000 to 20000 lines of code each) we found that on average the most precise of the three algorithms resolved 71% of the virtual function calls and reduced compiled code size by 25%. This algorithm is very fast: it analyzes 3300 source lines per second on an 80 MHz PowerPC 601. Because of its accuracy and speed, this algorithm is an excellent candidate for inclusion in production C++ compilers.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236371", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "Peter F.", + "last_name": "Sweeney", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/BaconS96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236342", + "title": "Code Reuse in an Optimizing Compiler", + "abstract": "This paper describes how the cmcc compiler reuses code---both internally (reuse between different modules) and externally (reuse between versions for different target machines). The key to reuse are the application frameworks developed for global data-flow analysis, code generation, instruction scheduling, and register allocation.The code produced by cmcc is as good as the code produced by the native compilers for the MIPS and SPARC, although significantly less resources have been spent on cmcc (overall, about 6 man years by 2.5 persons). cmcc is implemented in C++, which allowed for a compact expression of the frameworks as class hierarchies. The results support the claim that suitable frameworks facilitate reuse and thereby significantly improve developer effectiveness.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236342", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Guei-Yuan", + "last_name": "Lueh", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/Adl-TabatabaiGL96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236372", + "title": "Change Cases: Use Cases that Identify Future Requirements", + "abstract": "Evolution of software systems is prompted by all sorts of changes. This paper demonstrates how the use case, a well known construct in object-oriented analysis, is adapted to form the change case, to identify and articulate anticipated system changes. A change case provides the ability to identify and incorporate expected future change into a design to enhance the long-term robustness of that design. In this paper, we define change cases and demonstrate how change cases are captured by the analyst. We present examples to illustrate how change cases can influence present system design and point the way toward designs that more easily accommodate expected future changes. Change cases can be effectively employed in the context of any methodology that supports use cases and traceability links.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236372", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Earl F.", + "last_name": "Ecklund", + "institution": "" + }, + { + "first_name": "Lois", + "last_name": "Delcambre", + "institution": "Oregon Research Institute" + }, + { + "first_name": "Michael J.", + "last_name": "Freiling", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/EcklundDF96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236381", + "title": "A Framework for Run-Time Systems and its Visual Programming Language", + "abstract": "Frameworks and domain-specific visual languages are two different reuse techniques, the first targeted at expert programmers, the second at domain experts. In fact, these techniques are closely related. This paper shows how to develop a domain-specific visual language by first developing a white-box framework for the domain, then turning it into a black-box framework, and finally building a graphical front end for it. We used this technique in a compiler to specify run-time systems.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236381", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alan Mitchell", + "last_name": "Durham", + "institution": "Universidade de São Paulo" + }, + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois System" + } + ], + "dblp_key": "conf/oopsla/DurhamJ96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236361", + "title": "Automatic Inheritance Hierarchy Restructuring and Method Refactoring", + "abstract": "Most, object-oriented programs have imperfectly designed inheritance hierarchies and imperfectly factored methods, and these imperfections tend to increase with maintenance. Hence, even object-oriented programs are more expensive to maintain, harder to understand and larger than necessary. Automatic restructuring of inheritance hierarchies and refactoring of methods can improve the design of inheritance hierarchies, and the factoring of methods. This results in programs being smaller, having better code re-use and being more consistent. This paper describes Guru, a prototype tool for automatic inheritance hierarchy restructuring and method refactoring of Self programs. Results from realistic applications of the tool are presented.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236361", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivan", + "last_name": "Moore", + "institution": "University of Manchester" + } + ], + "dblp_key": "conf/oopsla/Moore96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236351", + "title": "Lessons Learned from Implementing the CORBA Persistent Object Service", + "abstract": "In this paper, the authors share their experiences gathered during the design and implementation of the CORBA Persistent Object Service. There are two problems related to a design and implementation of the Persistence Service: first, OMG intentionally leaves the functionality core of the Persistence Service unspecified; second, OMG encourages reuse of other Object Services without being specific enough in this respect. The paper identifies the key design issues implied both by the intentional lack of OMG specification and the limits of the implementation environment characteristics. At the same time, the paper discusses the benefits and drawbacks of reusing other Object Services, particularly the Relationship and Externalization Services, to support the Persistence Service. Surprisingly, the key lesson learned is that a direct reuse of these Object Services is impossible.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236351", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jan", + "last_name": "Kleindienst", + "institution": "Czech Academy of Sciences, Institute of Computer Science" + }, + { + "first_name": "František", + "last_name": "Plášil", + "institution": "Czech Academy of Sciences" + }, + { + "first_name": "Petr", + "last_name": "Tůma", + "institution": "Charles University" + } + ], + "dblp_key": "conf/oopsla/KleindienstPT96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236344", + "title": "Vortex: An Optimizing Compiler for Object-Oriented Languages", + "abstract": "Previously, techniques such as class hierarchy analysis and profile-guided receiver class prediction have been demonstrated to greatly improve the performance of applications written in pure object-oriented languages, but the degree to which these results are transferable to applications written in hybrid languages has been unclear. In part to answer this question, we have developed the Vortex compiler infrastructure, a language-independent optimizing compiler for object-oriented languages, with front-ends for Cecil, C++, Java, and Modula-3. In this paper, we describe the Vortex compiler's intermediate language, internal structure, and optimization suite, and then we report the results of experiments assessing the effectiveness of different combinations of optimizations on sizable applications across these four languages. We characterize the benchmark programs in terms of a collection of static and dynamic metrics, intended to quantify aspects of the \"object-orientedness\" of a program.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236344", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeffrey A.", + "last_name": "Dean", + "institution": "University of Washington" + }, + { + "first_name": "Greg", + "last_name": "DeFouw", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Grove", + "institution": "University of Washington" + }, + { + "first_name": "Vassily", + "last_name": "Litvinov", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/DeanDGLC96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236347", + "title": "Split Objects: a Disciplined Use of Delegation within Objects", + "abstract": "This paper's primary aim is to improve the understanding of the delegation mechanism as defined in [18]. We propose a new characterization of delegation based on the notions of name sharing, property sharing and value sharing. It allows us (1) to clearly differentiate delegation from class-inheritance in particular and more generally from other inheritance mechanisms and (2) to explain how a founded use of delegation relies on a correct semantics of variable property sharing between objects connected by a delegation link. We then describe a model of split objects which is proposed as an example of a disciplined and semantically founded use of delegation, where property sharing expresses viewpoints within objects.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236347", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Bardou", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + }, + { + "first_name": "Christophe", + "last_name": "Dony", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + } + ], + "dblp_key": "conf/oopsla/BardouD96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236376", + "title": "Formal Design Constraints", + "abstract": "Large software systems are often built on system platforms that support or enforce specific characteristics of the source code or actual design. These characteristics are either captured informally in design guideline documents or in specialized design and implementation languages.In our view, both approaches are unsatisfactory. Informal descriptions do not allow automated analysis and lead to vague constraint descriptions. The language-based approach leads to different languages for different platforms and even for different versions of the same basic platform.Our approach is to describe and name the constraints separately in a design constraint language called CDL, which is based on an extraordinarily concise logic of parse trees. Designs are then annotated with the names of the constraints they are supposed to satisfy.We discuss how the design constraint language is integrated into a design language environment. We exhibit industrial and experimental evidence that our choice of design constraint language allows us to formalize naturally and succinctly common design characteristics.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236376", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nils", + "last_name": "Klarlund", + "institution": "" + }, + { + "first_name": "Jari", + "last_name": "Koistinen", + "institution": "" + }, + { + "first_name": "Michael I.", + "last_name": "Schwartzbach", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KlarlundKS96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236366", + "title": "OO Anthropology: Crossing the Chasm (Panel Session)", + "abstract": "Anthropology is the study of civilization, particularly its societies, customs, structure, and evolution. Our premise is that there are cultureal \"chasms\" to be crossed to ensure the success of the technological beachhead established by innovators and early adopters of the OO paradigm. Our panelists will address the following questions:•What anthropological cultural factors have to be \"matured\" (and how?) to foster the success of the OO paradigm?•What mechanisms are required to facilitate communications between cultures of differing maturity?•What cultural chasms must be crossed to develop a successful organization/culture within the framework supported by the object-oriented paradigm (or more perrversely, is there anything \"special\" about the OO paradigm)?This panel will interest pracitioners as a forum to share and debate experiences related to our current-day software culture metamorphosis.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236366", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "Nortel (Canada)" + }, + { + "first_name": "Alistair", + "last_name": "Cockburn", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Jim", + "last_name": "Coplien", + "institution": "Nokia (United States)" + }, + { + "first_name": "Larry L.", + "last_name": "Constantine", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Dave", + "last_name": "West", + "institution": "University of St. Thomas - Minnesota" + }, + { + "first_name": "Leo", + "last_name": "Brajkovich", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FraserCBCCW96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236341", + "title": "A Flexible Operation Execution Model for Shared Distributed Objects", + "abstract": "Many parallel and distributed programming models are based on some form of shared objects, which may be represented in various ways (e.g., single-copy, replicated, and partitioned objects). Also, many different operation execution strategies have been designed for each representation. In programming systems that use multiple representations integrated in a single object model, one way to provide multiple execution strategies is to implement each strategy independently from the others. However, this leads to rigid systems and provides little opportunity for code reuse. Instead, we propose a flexible operation execution model that allows the implementation of many different strategies, which can even be changed at runtime. We present the model and a distributed implementation of it. Also, we describe how various execution strategies can be expressed using the model, and we look at applications that benefit from its flexibility. 1 Introduction Shared objects have become a popular model...", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236341", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Saniya Ben", + "last_name": "Hassen", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Irina", + "last_name": "Athanasiu", + "institution": "European Polytechnical University" + }, + { + "first_name": "Henri E.", + "last_name": "Bal", + "institution": "Vrije Universiteit Amsterdam" + } + ], + "dblp_key": "conf/oopsla/HassenAB96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236364", + "title": "On Automatic Class Insertion with Overloading", + "abstract": "Several algorithms [Cas92, MS89, Run92, DDHL94a, DDHL95, GMM95] have been proposed to automatically insert a class into an inheritance hierarchy. But actual hierarchies all include overriden and overloaded properties that these algorithms handle either very partially or not at all. Partially handled means handled provided there is a separate given function f able to compare overloaded properties [DDHL95, GMM95].In this paper, we describe a new version of our algorithm (named Ares) which handles automatic class insertion more efficiently using such a function f. Although impossible to fully define, this function can be computed for a number of well defined cases of overloading and overriding. We give a classification of such cases and describe the computation process for a well-defined set of nontrivial cases.The algorithm preserves these important properties:- preservation of the maximal factorization of properties- preservation of the underlying structure (Galois lattice) of the input hierarchy- conservation of relevant classes of the input hierarchy with their properties.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236364", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "H.", + "last_name": "Dicky", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + }, + { + "first_name": "Christophe", + "last_name": "Dony", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + }, + { + "first_name": "Marianne", + "last_name": "Huchard", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + }, + { + "first_name": "Thérèse", + "last_name": "Libourel", + "institution": "Laboratoire d'Informatique, de Robotique et de Microélectronique de Montpellier" + } + ], + "dblp_key": "conf/oopsla/DickyDHL96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236383", + "title": "Semantic-Based Visualization for Parallel Object-Oriented Programming", + "abstract": "We present a graphical environment for parallel object-oriented programming. It provides visual tools to develop and debug object-oriented programs as well as parallel or concurrent systems. This environment was derived from a structural operational semantics of an extension of the Eiffel language, Eiffel//. Object-related features of the language (inheritance, polymorphism) are formalized using a big-step semantics, while the interleaving model of concurrency is expressed with small-step semantics.Without user instrumentation, the interactive environment proposes features such as step-by-step animated executions, graphical visualization of object and process topology, futures and pending requests, control of interleaving, deadlock detection.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236383", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Isabelle", + "last_name": "Attali", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Denis", + "last_name": "Caromel", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Sidi Ould", + "last_name": "Ehmety", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Sylvain", + "last_name": "Lippi", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/oopsla/AttaliCEL96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236384", + "title": "Translation: Myth or Reality? (Panel Session)", + "abstract": "In the realm of OO methodologies there are two major schools of thought. Both schools claim to define mechanisms whereby software applications can be created that are reusable, maintainable, and robust. Moreover, both schools claim to use abstraction as a key mechanism for achieving these benefits. At issue is whether or not these two schools are fundamentally different, or just variations on an object-oriented theme.Shlaer and Mellor have dubbed one of these schools Translational. In the translational approach, two models are created. One is an abstract model of the application domain which is devoid of any design dependencies. The other model is an abstract model of the design which is devoid of any application dependencies. These two models are composed automatically to yield the code for the system.The other school - supported by Booch, Rumbaugh, Jacobson, and Martin - views the architecture of a system from several different perspectives of abstraction, e.g. logical, physical. These abstractions typically form a layer; abstractions in the logical sense manifest themselves as individual classes as well as collaborations of classes. There may be one layered model, at different layers of abstraction, or, especially given the Objectory view point, there may be multiple models, with an analysis model that's nearly independent from the design model.The panel will explore:• Is there a seamless transition between analysis and design?• Should there be a single model or should there be two - one for the analysis and one for the design?• If there are two models, how are they bridged?• What, if any, are the differences in process between the two schools?• How does architecture manifest itself!• Is there, in fact, a real difference between the two schools of thought?As a result of this exploration, we hope to answer the question: Is translation a myth or is it a reality?", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236384", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Grady", + "last_name": "Booch", + "institution": "Ratio" + }, + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "" + }, + { + "first_name": "Robert", + "last_name": "Martin", + "institution": "Mentor" + }, + { + "first_name": "Steven J.", + "last_name": "Mellor", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Lee", + "institution": "" + }, + { + "first_name": "Steven", + "last_name": "Garone", + "institution": "International Data Group (Sweden)" + }, + { + "first_name": "Martin", + "last_name": "Fowler", + "institution": "" + }, + { + "first_name": "Douglas C.", + "last_name": "Schmidt", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Marie A.", + "last_name": "Lenzi", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FraserMMLBGFSL96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236339", + "title": "An Equational Object-Oriented Data Model and its Data-Parallel Query Language", + "abstract": "This paper presents an equational formulation of an object-oriented data model. In this model, a database is represented as a system of equations over a set of oid's, and a database query is a transformation of a system of equations into another system of equations. During the query processing, our model maintains an equivalence relation over oid's that relates oid's corresponding to the same \"real-world entity.\" By this mechanism, the model achieves a declarative set-based query language and views for objects with identity. Moreover, the query primitives are designed so that queries including object traversal can be evaluated in a data-parallel fashion.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236339", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Susumu", + "last_name": "Nishimura", + "institution": "Kyoto University" + }, + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "Kyoto University" + }, + { + "first_name": "Keishi", + "last_name": "Tajima", + "institution": "Kobe University" + } + ], + "dblp_key": "conf/oopsla/NishimuraOT96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236358", + "title": "Environmental Acquisition - A New Inheritance-Like Abstraction Mechanism", + "abstract": "The class of an object is not necessarily the only determiner of its runtime behaviour. Often it is necessary to have an object behave differently depending upon the other objects to which it is connected. However, as it currently stands, object-oriented programming provides no support for this concept, and little recognition of its role in common, practical programming situations. This paper investigates a new programming paradigm, environmental acquisition in the context of object aggregation, in which objects acquire behaviour from their current containers at runtime. The key idea is that the behaviour of a component may depend upon its enclosing composite(s). In particular, we propose a form of feature sharing in which an object \"inherits\" features from the classes of objects in its environment. By examining the declaration of classes, it is possible to determine which kinds of classes may contain a component, and which components must be contained in a given kind of composite. These relationships are the basis for language constructs that supports acquisition. We develop the theory of acquisition that includes topics such as the kinds of links along which acquisition may occur, and the behaviour of routine (methods) and attribute features under acquisition. The proposed model for acquisition as a hierarchical abstraction mechanism is a strongly typed model that allows static type checking of programs exploiting this mechanism. We compare it to several other mechanisms including inheritance and delegation, and show that it is significantly different than these.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236358", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/GilL96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236369", + "title": "The Direct Cost of Virtual Function Calls in C++", + "abstract": "We study the direct cost of virtual function calls in C++ programs, assuming the standard implementation using virtual function tables. We measure this overhead experimentally for a number of large benchmark programs, using a combination of executable inspection and processor simulation. Our results show that the C++ programs measured spend a median of 5.2% of their time and 3.7% of their instructions in dispatch code. For \"all virtuals\" versions of the programs, the median overhead rises to 13.7% (13% of the instructions). The \"thunk\" variant of the virtual function table implementation reduces the overhead by a median of 21% relative to the standard implementation. On future processors, these overheads are likely to increase moderately.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236369", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karel", + "last_name": "Driesen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Urs", + "last_name": "Hölzle", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/oopsla/DriesenH96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236357", + "title": "A Functional Layer for Description Logics: Knowledge Representation Meets Object-Oriented Programing", + "abstract": "The paper motivates the facilities provided by Description Logics in an object-oriented programming scenario. It presents a unification approach of Description Logics and object-oriented programming that allows both views to be conveniently used for different subproblems in a modern software-engineering environment. The main thesis of this paper is that in order to use Description Logics in practical applications, a seamless integration with object-oriented system development methodologies must be realized.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236357", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Möller", + "institution": "Universität Hamburg" + } + ], + "dblp_key": "conf/oopsla/Moller96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236350", + "title": "Reorganizing Split Objects", + "abstract": "Object-based (i.e. classless) models are very effective for elucidating requirements from users, and they support exploratory programming and rapid prototyping, providing a direct manipulation approach. On the other hand, class-based models have powerful mechanisms to control redundancy, exploit sharing, express extension, and propagate changes to instances.The price object-based approaches pay is loss of control over change propagation, and potential redundancy. Two mechanisms to overcome this are sharing among objects and definition of objects as extension of others. We examine these mechanisms, and consider the effect that interacting policies for objects sharing and definition-by-extension have on change propagation and replication control. An implication is that, in absence of meta-objects or extra-language support, monolithic shared parts cannot coexist with prototypes represented as split objects.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236350", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hernán", + "last_name": "Astudillo", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/R96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236355", + "title": "Slicing Class Hierarchies in C++", + "abstract": "This paper describes an algorithm for slicing class hierarchies in C++ programs. Given a C++ class hierarchy (a collection of C++ classes and inheritance relations among them) and a program P that uses the hierarchy, the algorithm eliminates from the hierarchy those data members, member functions, classes, and inheritance relations that are unnecessary for ensuring that the semantics of P is maintained.Class slicing is especially useful when the program P is generated from a larger program P' by a statement slicing algorithm. Such an algorithm eliminates statements that are irrelevant to a set of slicing criteria---program points of particular interest. There has been considerable previous work on statement slicing, and it will not be the concern of this paper. However, the combination of statement slicing and class slicing for C++ has two principal applications: First, class slicing can enhance statement slicing's utility in program debugging and understanding applications, by eliminating both executable and declarative program components irrelevant to the slicing criteria. Second, the combination of the two slicing algorithms can be used to decrease the space requirements of programs that do not use all the components of a class hierarchy. Such a situation is particularly common in programs that use class libraries.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236355", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM (United States)" + }, + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "IBM (United States)" + }, + { + "first_name": "John K.", + "last_name": "Field", + "institution": "IBM (United States)" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/TipCFR96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236375", + "title": "Using Role Components to Implement Collaboration-Based Designs", + "abstract": "In this paper we present a method of code implementation that works in conjunction with collaboration and responsibility based analysis modeling techniques to achieve better code reuse and resilience to change. Our approach maintains a closer mapping from responsibilities in the analysis model to entities in the implementation. In so doing, it leverages the features of flexible design and design reuse found in collaboration-based design models to provide similar adaptability and reuse in the implementation. Our approach requires no special development tools and uses only standard features available in the C++ language. In an earlier paper we described the basic mechanisms used by our approach and discussed its advantages in comparison to the framework approach. In this paper we show how our approach combines code and design reuse, describing specific techniques that can be used in the development of larger applications.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236375", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "VanHilst", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Notkin", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/VanHilstN96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236363", + "title": "Reuse Contracts: Managing the Evolution of Reusable Assets", + "abstract": "A critical concern in the reuse of software is the propagation of changes made to reusable artifacts. Without techniques to manage these changes, multiple versions of these artifacts will propagate through different systems and reusers will not be able to benefit from improvements to the original artifact. We propose to codify the management of change in a software system by means of reuse contracts that record the protocol between managers and users of a reusable asset. Just as real world contracts can be extended, amended and customised, reuse contracts are subject to parallel changes encoded by formal reuse operators: extension, refinement and concretisation. Reuse contracts and their operators serve as structured documentation and facilitate the propagation of changes to reusable assets by indicating how much work is needed to update previously built applications, where and how to test and how to adjust these applications.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236363", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Steyaert", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Carine", + "last_name": "Lucas", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Kim", + "last_name": "Mens", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Theo", + "last_name": "D’Hondt", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/oopsla/SteyaertLMD96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236340", + "title": "Creating Host Compliance in a Portable Framework: A Study in the Use of Existing Design Patterns", + "abstract": "This report describes an experiment carried out at ParcPlace-Digitalk which sought to increase the look-and-feel compliance of portable applications built using the company's Smalltalk-based VisualWorks product. We outline the structure of the current VisualWorks user interface framework, and the precise requirements which the experimental system sought to fulfill. We go on to show how we were able to reuse design patterns from the literature in a generative fashion, to direct the evolution of the new framework. This contrasts with most pattern-related work to date, which has concentrated on discerning design patterns in existing systems. Finally, we draw generalizations from our experience concerning the evolution of software architecture using patterns.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236340", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Phillip M.", + "last_name": "Yelland", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/Yelland96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236377", + "title": "Objects on the Server: Are We Ready? (Panel Session)", + "abstract": "Object-oriented concepts such as reuse and encapsulation offer many benefits to application development, particularly in managing complexity and change. All the benefits of OO that apply to the client can apply equally well to the server. However, until recently, these concepts have proven to benefit only the client side. Could there be any intrinsic or conceptual reason for this? Or could it be a result of timing, the availability of the tools, and the conservative restraints that result from the mission-critical nature of server computing?This panel will explore the roles of objects on the server by examining the experiences of the panelists from a technology consumer's perspective. By doing so, we would like to provide insights for corporations that are making decisions on OO technology, point out pitfalls along the way, and identify potential opportunities for technology providers.All panelists have developed production level object servers. The panel will answer the question of whether we are ready for object servers by discussing the following issues:• Different server types: transactional server, data server, application server, web server, etc. Are they really that much different? Which one is the most important kind?• Experience in implementing and maintaining object systems on the server: the configurations of the systems and how they were arrived at; the tools and programming languages used.• Benefits and drawbacks of server object systems.• What's hard? What's easy?• What are the prerequisites for pervasive deployments of objects on the server? (e.g., standards, application types, customer situations, tools, and languages.)• What would be desirable for technology providers (researchers and vendors) to provide? (Tools, languages, execution environments that represents vendor opportunities.)• Practical advice to organizations interested in introducing objects to the server.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236377", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yen-Ping", + "last_name": "Shan", + "institution": "IBM (United States)" + }, + { + "first_name": "T. R.", + "last_name": "Morgan", + "institution": "" + }, + { + "first_name": "Phil", + "last_name": "Proudfoot", + "institution": "" + }, + { + "first_name": "Jim", + "last_name": "Thompson", + "institution": "Oil and Natural Gas Corporation (India)" + }, + { + "first_name": "John", + "last_name": "Tibetts", + "institution": "" + }, + { + "first_name": "Allen", + "last_name": "Woolfrey", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ShanMPTTW96", + "venue": "oopsla", + "year": 1996 + }, + { + "paper_id": "10.1145/236337.236353", + "title": "A Situated Evaluation of the Object Management Group's (OMG) Object Management Architecture (OMA)", + "abstract": "It has been difficult to objectively assess the real value or maturity of the Object Management Group's Object Management Architecture (OMA). While experience reports have appeared in the literature, these have focused more on the functionality of the end-system than on systematically exploring the strengths and weaknesses of the OMA, and providing practical guidelines on the effective use of the OMA for specific software-engineering problems. In this paper we describe a case study in the use of the OMA to integrate legacy software components into a distributed object system. We assess the OMA in this problem context, and indicate strengths and weaknesses of the specification and current implementations. We extrapolate our experience to a broader class of component-based software systems, and recommend an architectural strategy for the effective use of the OMA to this class of systems.", + "date": "1996-10-01", + "link": "https://doi.org/10.1145/236337.236353", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Evan", + "last_name": "Wallace", + "institution": "National Institute of Standards and Technology" + }, + { + "first_name": "Kurt", + "last_name": "Wallnau", + "institution": "Software Engineering Institute" + } + ], + "dblp_key": "conf/oopsla/WallaceW96", + "venue": "oopsla", + "year": 1996 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1997.json b/data/pl_conferences/oopsla/1997.json new file mode 100644 index 0000000..d7a3dd7 --- /dev/null +++ b/data/pl_conferences/oopsla/1997.json @@ -0,0 +1,814 @@ +[ + { + "paper_id": "10.1145/263698.263752", + "title": "Query-Based Debugging of Object-Oriented Programs", + "abstract": "Object relationships in modem software systems are becoming increasingly numerous and complex. Programmers who try to find violations of such relationships need new tools that allow them to explore objects in a large system more efficiently. Many existing debuggers present only a low-level, one-object-at-a-time view of objects and their relationships. We propose a new solution to overcome these problems: query-based debugging. The implementation of the query-based debugger described here offers programmers an effective query tool that allows efficient searching of large object spaces and quick verification of complex relationships. Even for programs that have large numbers of objects, the debugger achieves interactive response times for common queries by using a combination of fast searching primitives, query optimization, and incremental result delivery.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263752", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Raimondas", + "last_name": "Lencevicius", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Urs", + "last_name": "Hölzle", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Ambuj K.", + "last_name": "Singh", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/oopsla/LenceviciusHS97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263756", + "title": "Constraint Diagrams: Visualizing Assertions in Object-Oriented Models", + "abstract": "A new visual notation is proposed for precisely expressing constraints on object-oriented models, as an alternative to mathematical logic notation used in methods such as Syntropy and Catalysis. The notation is potentially intuitive, expressive, integrates well with existing visual notations, and has a clear and unambiguous semantics. It is reminiscent of informal diagrams used by mathematicians for illustrating relations, and borrows much from Venn diagrams. It may be viewed as a generalization of instance diagrams.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263756", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stuart", + "last_name": "Kent", + "institution": "University of Brighton" + } + ], + "dblp_key": "conf/oopsla/Kent97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263741", + "title": "Migrating Relational Data to an OODB: Strategies and Lessons from a Molecular Biology Experience", + "abstract": "The growing maturity of ODBMS technology is causing many enterprises to consider migrating relational databases to ODBIMS's. While data remapping is relatively straight-forward in most cases, greater challenges lie in economically and non-invasively adapting legacy application software. We report on a genetics laboratory database migration experiment, which was facilitated by both organization of the relational data in object-like form and a C++-framework designed to insulate application code from relational artifacts. Although this experiment was largely successful, we discovered to our surprise that the framework failed to encapsulate three subtle aspects of the relational implementation, thereby ''contaminating'' application code. We analyze the underlying issues, and offer cautionary guidance to future migrators.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263741", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jon", + "last_name": "Oler", + "institution": "University of Utah" + }, + { + "first_name": "Gary", + "last_name": "Lindstrom", + "institution": "University of Utah" + }, + { + "first_name": "Terence", + "last_name": "Critchlow", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/oopsla/OlerLC97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263737", + "title": "Tiling Design Patterns - A Case Study Using the Interpreter Pattern", + "abstract": "This paper explains how patterns can be used to describe the implementation of other patterns. It is demonstrated how certain design patterns can describe their own design. This is a fundamental reflexive relationship in pattern relationships. The process of assembling patterns by other patterns is named pattern tiling. Tiling enables us to interweave simple understood concepts of patterns into their complex real-life implementation. Several pattern tilings for the Interpreter design pattern are illustrated.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263737", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Lorenz97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263734", + "title": "The Design and Performance of a Hard Real-Time Object Event Service", + "abstract": "The CORBA Event Service provides a flexible model for asynchronous communication among objects. However, the standard CORBA Event Service specification lacks important features required by real-time applications. For instance, operational flight programs for fighter aircraft have complex real-time processing requirements. This paper describes the design and performance of an object-oriented, real-time implementation of the GORBA Event Service that is designed to meet these requirements.This paper makes three contributions to the design and performance measurement of object-oriented real-time systems. First, it illustrates how to extend the CORBA Event Service so that it is suitable for real-time systems. These extensions support periodic rate-based event processing and efficient event filtering and correlation. Second, it describes how to develop object-oriented event dispatching and scheduling mechanisms that can provide real-time guarantees. Finally, the paper presents benchmarks that demonstrate the performance tradeoffs of alternative concurrent dispatching mechanisms for real-time Event Services.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263734", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Timothy H.", + "last_name": "Harrison", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "David L.", + "last_name": "Levine", + "institution": "Washington University in St. Louis" + }, + { + "first_name": "Douglas C.", + "last_name": "Schmidt", + "institution": "Washington University in St. Louis" + } + ], + "dblp_key": "conf/oopsla/HarrisonLS97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.264352", + "title": "Call Graph Construction in Object-Oriented Languages", + "abstract": "Interprocedural analyses enable optimizing compilers to more precisely model the effects of non-inlined procedure calls, potentially resulting in substantial increases in application performance. Applying interprocedural analysis to programs written in object-oriented or functional languages is complicated by the difficulty of constructing an accurate program call graph. This paper presents a parameterized algorithmic framework for call graph construction in the presence of message sends and/or first class functions. We use this framework to describe and to implement a number of well-known and new algorithms. We then empirically assess these algorithms by applying them to a suite of medium-sized programs written in Cecil and Java, reporting on the relative cost of the analyses, the relative precision of the constructed call graphs, and the impact of this precision on the effectiveness of a number of interprocedural optimizations.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.264352", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Grove", + "institution": "University of Washington" + }, + { + "first_name": "Greg", + "last_name": "DeFouw", + "institution": "University of Washington" + }, + { + "first_name": "Jeffrey A.", + "last_name": "Dean", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/GroveDDC97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263739", + "title": "Composite Design Patterns", + "abstract": "Software design patterns are the core abstractions from successful recurring problem solutions in software design. Composite design patterns are the core abstractions from successful recurring frameworks. A composite design pattern is a pattern that is best described as the composition of further patterns the integration of which shows a synergy that makes the composition more than just the sum of its parts. This paper presents examples of composite patterns, discusses a role-based analysis and composition technique, and demonstrates that composite patterns extend the pattern idea from single problem solutions to object-oriented frameworks.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263739", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dirk", + "last_name": "Riehle", + "institution": "Union Bank of Switzerland" + } + ], + "dblp_key": "conf/oopsla/Riehle97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263720", + "title": "Adding Type Parameterization to the Java Language", + "abstract": "Although the Java programming language has achieved widespread acceptance, one feature that seems sorely missed is the ability to use type parameters (as in Ada generics, C++ templates, and ML polymorphic functions or data types) to allow a general concept to be instantiated to one or more specific types. In this paper, we propose parameterized classes and interfaces in which the type parameter may be constrained to either implement a given interface or extend a given class. This design allows the body of a parameterized class to refer to methods on objects of the parameter type, without introducing any new type relations into the language. We show that these Java extensions may be implemented by expanding parameterized classes at class load time, without any extension or modification to existing Java bytecode, verifier or bytecode interpreter.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263720", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ole", + "last_name": "Agesen", + "institution": "" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "Stanford University" + }, + { + "first_name": "John C.", + "last_name": "Mitchell", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/AgesenFM97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263732", + "title": "Changing the Engine of the Car? While Driving 60 Miles an Hour! (Panel)", + "abstract": "Most software development projects don't practice what is usually considered \"proper\" software engineering practices: well-documented, traceable requirements do not exist, formal inspections are non-existent, analysis and design inodels are incomplete or not even done at all, and so forth. We know that many of these projects fail, and it is easy to blame the failure of the project on the lack of good software engineering practices (\"If we only had well-documented requirements, a complete and thorough test plan, and formal schedules then we would have been successful!\")But many projects that do not practice what many consider to be good software engineering practices succeed, and succeed famously. Examples include the startup introducing a revolutionary new product, the skunkworks project of an established firm that succeeds in changing the status quo, and selecting a mission critical application as the first OO application of a group just beginning to make the transition to the new technology.Gaining a deeper understanding of success and failure on software projects is absolutely essential for the continued maturation of our industry, and object technology in particular.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263732", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jim", + "last_name": "Coplien", + "institution": "" + }, + { + "first_name": "Luke", + "last_name": "Hohmann", + "institution": "" + }, + { + "first_name": "Norm", + "last_name": "Kerth", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Rae-Grant", + "institution": "" + }, + { + "first_name": "Eileen", + "last_name": "Strider", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/CoplienHKRS97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263725", + "title": "A Framework for Scalbale Dissemination-Based Systems", + "abstract": "The dramatic improvements in global interconnectivity due to intranets, extranets, and the Internet has led to an explosion in the number and variety of new data-intensive applications. Along with the proliferation of these new applications have come increased problems of scale. This is demonstrated by frequent delays and service, disruptions when accessing networked data sources. Recently, push-based techniques have been proposed as a solution to scalability problems for distributed applications. This paper argues that push indeed has its place, but that it is just one aspect of a much larger design space for distributed information systems. We propose the notion of a Dissemination-Based Information System (DBIS) which integrates a variety of data delivery mechanisms and information broker hierarchies. We discuss the properties of such systems and provide some insight into the architectural imperatives that will influence their design. The DBIS framework can serve as the basis for development of a toolkit for constructing distributed information systems that better match the technology they employ to the characteristics of the applications they are intended to support.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263725", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael J.", + "last_name": "Franklin", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Stanley B.", + "last_name": "Zdonik", + "institution": "John Brown University" + } + ], + "dblp_key": "conf/oopsla/FranklinZ97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263740", + "title": "An Open Implementation Analysis and Design for Lightweight Threads", + "abstract": "Open Implementation Analysis and Design (OIA/D) has been introduced as a design methodology for object-oriented software systems, and in particular for substrate software. In this paper we detail our experiences with using OIA/D to design and implement a common substrate component for parallel language runtime systems: a lightweight threads package. We show how existing thread packages employ a \"black-box\" design, hiding crucial design decisions that drastically reduce their ability to be re-used. We detail these design decisions (dilemmas) and show how an implementation based on OIA/D principles results in a thread package that is flexible, efficient, portable, and re-usable.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263740", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Haines", + "institution": "University of Wyoming" + } + ], + "dblp_key": "conf/oopsla/Haines97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263757", + "title": "Beyond the Hype: Do Patterns and Frameworks Reduce Discovery Costs? (Panel)", + "abstract": "Patterns and frameworks are two approaches to the development of both new and evolving software systems. An implicit hypothesis is that are reduced by leveraging knowledge previously collected, analyzed, organized, and packaged. Discovery (or getting started costs) include both the costs of understanding the problem to be solved and the cost of understanding the tools, methods, existing software, etc. For large, multi-year development projects in industries such as defense or telecommunications, discovery costs can dominate the overall cost (and risk) of software development.This panel will share its experience and perspectives with the audience with a discussion initiated by the following questions:• Have patterns and frameworks really delivered on their claims for reducing discovery costs? Can current best-practices be characterized as meaningful or marginal (what are the measures)?• What are the discovery cost factors where frameworks and patterns appear to deliver the biggest bang for the buck?• While mature pattern languages and frameworks may reduce the learning curve, they do not, eliminate it. How much of a learning curve is required to develop a sufficient shared context with the authors of a set of patterns or a framework?", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263757", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "" + }, + { + "first_name": "Kent", + "last_name": "Beck", + "institution": "" + }, + { + "first_name": "Grady", + "last_name": "Booch", + "institution": "" + }, + { + "first_name": "Jim", + "last_name": "Coplien", + "institution": "" + }, + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois System" + }, + { + "first_name": "Bill", + "last_name": "Opdyke", + "institution": "Alcatel Lucent (Germany)" + } + ], + "dblp_key": "conf/oopsla/FraserbBCJO97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263724", + "title": "Looking for the Objects in Object-Relational DBMSs (Panel)", + "abstract": "The Relational Model first came into vogue in the early 1980's. It was based on the simplifying idea that all data could be modeled as mathematical relations (tables in \"normal form\"). Permissible operations on this table data structure were specified by the relation algebra and calculus. The Relational Model led to years of research in areas such as query languages, query optimization, transaction models, and database design methodologies. This research has dominated DBMS conferences for the last fifteen years and has also lead to major products offerings in wide-spread use in the computer industry today.While the Relational revolution was happening in the DBMS community there was a minority opinion emerging from the object community. This minority opinion surfaced in heated debates and panels at DBMS conferences where it was often pitted against \"relational purists.\" The object proponents wanted to discuss storing and retrieving complex objects and relationships in databases while the relational purists insisted on maintaining \"mathematical purity and simplicity\". These panels were often some of the most acrimonious (and entertaining) at these conferences and many thought there was no way to bridge the chasm between the two schools of thought.However times changes and so do the realities of the commercial world. Object languages such as C++, Smalltalk, and Java have become de facto standards. The Internet and the PC have increased the demand for complex data types. And the relational model is evolving to accommodate these realities.All of the major RDBMS vendors have announced plans for, or are already shipping, Object-Relational DBMS (ORDBMS) products. A natural question for the object community is how well these new products will address the well-known \"impedance mismatch\" between a pure object model and the relational model. For example, how does one make Java, Smalltalk, or C++ objects persist using an ORDBMS? Can one search for these objects in the database using their methods?The vendors for ORDBMS are claiming well-known OO features in their implementations, such as extensible data types, inheritance, object identity, and object language bindings. This panel will allow the major vendors to explain how those features match up with the kinds of object models that OO developers are accustomed to. The panel will consist of representatives from three of the major ORDBMS vendors as well as a representative of \"pure object think\". The vendor representatives will each present a brief overview of the object-related features of their products and will explain why OO programmers are going to have an easier time with these ORDBMSs. This will be followed by counterpoint discussion from the pure object thinker.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263724", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lougie", + "last_name": "Anderson", + "institution": "" + }, + { + "first_name": "Mike", + "last_name": "Carey", + "institution": "IBM Research - Almaden" + }, + { + "first_name": "Ken", + "last_name": "Jacobs", + "institution": "Oracle (United States)" + }, + { + "first_name": "Erin", + "last_name": "Kinikin", + "institution": "Inform (Germany)" + }, + { + "first_name": "David", + "last_name": "Maier", + "institution": "Oregon Research Institute" + } + ], + "dblp_key": "conf/oopsla/AndersonCJKM97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263702", + "title": "Analyzing and Measuring Reusability in Object-Oriented Designs", + "abstract": "In this paper, we present a technique to analyze and measure the reusability of object-oriented (OO) designs. The metrics can be incorporated into a design/development environment, so that reusability measurements, analysis, and improvements can be part of \"business as usual\" for an organization. Design reusability measurements also enable early identification of poor reuse potential, when it is still possible to modify/refine the design. The essential components of our approach are two reuse-specific characterizations of classes and hierarchies, and a set of metrics which objectively measures the dependencies among design components based on those reuse-specific characterizations.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263702", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Margaretha W.", + "last_name": "Price", + "institution": "" + }, + { + "first_name": "Steven A.", + "last_name": "Demurjian", + "institution": "University of Connecticut" + } + ], + "dblp_key": "conf/oopsla/PriceD97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263736", + "title": "UML: The Language of Blueprints for Software? (Panel)", + "abstract": "The Unified Method was launched by Grady Booch and Jim Rumbaugh at an OOPSLA'95 Conference Fringe meeting organised by Rational Software Corporation. In 1996 Unified Method was re-scoped to a notation, and renamed Unified Modeling Language (UML).Earlier this year, UML was submitted to Object Management Group for standardisation and has been endorsed by Microsoft, IBM, HP, Platinum Technologies, ObjectTime and many other corporations. No wonder UML is leading contender as de facto standard notation for object-oriented analysis and design.The panel will take a sanity check, and will go beyond hype and newsgroup flames and attempt to form an objective view of UML and its prospects.The members of panel have been working closely with UhL in many different roles, including that of UML language designer, end-user, consultant, CASE tool expert, and object-oriented methodologist. The discussion will focus on how LJML matches up in practice against one of its original. raisons d'etre as the language of blueprints for software.Specific issues to be addressed include:• What is advantage of UML over existing OOA/D notations?• Can UML be used on real projects today?• Is language sufficiently simple, and well-enough defined, to become de facto standard?• Will UML lead to improved OOA/D methods and CASE tools?• What is importance of meta-model in UML?", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263736", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Derek", + "last_name": "Coleman", + "institution": "University of London" + }, + { + "first_name": "Viktor", + "last_name": "Ohnjec", + "institution": "Genesis HealthCare" + }, + { + "first_name": "John", + "last_name": "Artim", + "institution": "" + }, + { + "first_name": "Erick", + "last_name": "Rivas", + "institution": "" + }, + { + "first_name": "Jim", + "last_name": "Rumbaugh", + "institution": "" + }, + { + "first_name": "Rebecca", + "last_name": "Wirfs-Brock", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ColemanAORRW97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263746", + "title": "The ODMG Object Model: Does it Make Sense?", + "abstract": "The ODMG Object Model is shown to have a number of problems. A major confusion is caused by the intended type of polymorphism and the way it is expressed in the Model. Dynamic type checking is required even in situations when static type checking is possible. There are situations in which there is no way that type checking can determine whether a particular construct is type correct or not. The model of persistence in the ODMG Standard is not orthogonal, which has undesirable pragmatic consequences on complex objects. The discrepancies between the ODMG Object Model and the particular language bindings of the ODMG Standard are non-trivial. This paper presents solutions to some of these problems together with the associated formal system. Without such a formal system the recommended ODMG bindings are open to a wide range of different, and sometimes confusing interpretations. The criticism expressed in the paper is intended to be helpful in developing future releases of the ODMG Standard.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263746", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Suad", + "last_name": "Alagić", + "institution": "Wichita State University" + } + ], + "dblp_key": "conf/oopsla/Alagic97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263733", + "title": "Ephemerons: A New Finalization Mechanism", + "abstract": "Finalization occurs when a garbage collector informs an application that an object is \"almost collectable.\" It is used to help an application maintain its invariants. To make finalization more useful, this paper defines \"almost collectable\" in terms of a new class of objects, called ephemerons. Ephemerons are similar to weak pairs, but an object in an ephemeron's key field may be classed as \"almost collectable\" even if it is reachable from the epehemeron's value fields.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263733", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Barry", + "last_name": "Hayes", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Hayes97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263701", + "title": "Maintaining the Consistency of Class Libraries During Their Evolution", + "abstract": "Two important problems of object-oriented reuse are the propagation of design and implementation specifics of the base software to the inheritors, and the protection of the inheritors against changes in the base software. In this paper, we argue that the simple inheritance rules of existing object-oriented languages are not sufficient for properly dealing with these problems. In the proposal presented in this paper, programmers are enabled to make metalevel declarations of the internal protocols and dependencies of their classes. Additionally, changes of the base module are automatically monitored to filter out information about the alterations that may invalidate already existing inheritors. Based on these informations, the subclassing semantics is adjusted such that the maintenance of the base module properties and the protection of the inheritor is ensured during their integration, In this way, language support is provided for keeping the behavior of reusable software consistent during its evolution.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263701", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "University of Siegen" + } + ], + "dblp_key": "conf/oopsla/Mezini97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263754", + "title": "Back to the Future: The Story of Squeak - A Usable Smalltalk Written in Itself", + "abstract": "Squeak is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to. debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks.Other noteworthy aspects of Squeak include: a compact object format that typically requires only a single word of overhead per object; a simple yet efficient incremental garbage collector for 32-bit direct pointers; efficient bulk-mutation of objects; extensions of BitBlt to handle color of any depth and anti-aliased image rotation and scaling; and real-time sound and music synthesis written entirely in Smalltalk.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263754", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dan", + "last_name": "Ingalls", + "institution": "Walt Disney (United States)" + }, + { + "first_name": "Ted", + "last_name": "Kaehler", + "institution": "Walt Disney (United States)" + }, + { + "first_name": "John", + "last_name": "Maloney", + "institution": "Walt Disney (United States)" + }, + { + "first_name": "Scott", + "last_name": "Wallace", + "institution": "Walt Disney (United States)" + }, + { + "first_name": "Alan", + "last_name": "Kay", + "institution": "Walt Disney (United States)" + } + ], + "dblp_key": "conf/oopsla/IngallsKMWK97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263721", + "title": "Parasitic Methods: An Implementation of Multi-Methods for Java", + "abstract": "In an object-oriented programming language, method selection is (usually) done at run-time using the class of the receiver. Some object-oriented languages (such as CLOS) have multi-methods which comprise several methods selected on the basis of the runtime classes of all the parameters, not just the receiver. Multi-methods permit intuitive and typesafe definition of binary methods such as structural equality, set inclusion and matrix multiplication, just to name a few. Java as currently defined does not support multimethods. This paper defines a simple extension to Java that enables the writing of \"encapsulated\" multi-methods through the use of parasitic methods, methods that \"attach\" themselves to other methods. Encapsulated multi-methods avoid some of the modularity problems that, arise with fully general multi-methods. Furthermore, this. extension yields for free both covariant and contravariant specialization of methods (besides Java's current invariant specialization).Programs using this extension. can be translated automatically at the source level into programs that do not; they are modular, type-safe, and allow separate compilation.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263721", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Boyland", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/oopsla/BoylandC97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263723", + "title": "Modeling Dynamic Collections of Interdependent Objects Using Path-Based Rules", + "abstract": "Standard object-oriented languages do not provide language support for modeling changing collections of interdependent objects. We propose that R++, an integration of the rule and objectoriented paradigms, provides a mechanism for easily implementing such models. R++ extends C++ by adding a new programming construct called the path-based rule. Such data-driven rules are restricted to follow pointers between objects, and are like &quot;automatic methods&quot; that are triggered by changes to monitored objects. Path-based rules encourage a more abstract level of programming, and unlike previous rule integrations, are not at odds with the object-oriented paradigm and offer performance advantages for natural applications. 1 Introduction Object-oriented languages have simplified the design and implementation of sophisticated applications. However, as application domains have become increasingly dynamic and complex, it has become necessary to model such domains using changing collections of interdep...", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263723", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Diane", + "last_name": "Litman", + "institution": "AT&T (United States)" + }, + { + "first_name": "Peter F.", + "last_name": "Patel‐Schneider", + "institution": "AT&T (United States)" + }, + { + "first_name": "Anil Kumar", + "last_name": "Mishra", + "institution": "AT&T (United States)" + } + ], + "dblp_key": "conf/oopsla/LitmanMP97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263748", + "title": "Class Hierarchy Specialization", + "abstract": "Class libraries are generally designed with an emphasis on versatility and extensibility. Applications that use a library typically exercise only part of the library's functionality. As a result, objects created by the application may contain unused members. We present an algorithm that specializes a class hierarchy with respect to its usage in a program P. That is, the algorithm analyzes the member access patterns for P's variables, and creates distinct classes for variables that access different members. Class hierarchy specialization reduces object size, and is hence primarily a space optimization. However, execution time may also be reduced through reduced object creation/destruction time, and caching/paging effects.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263748", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM (United States)" + }, + { + "first_name": "Peter F.", + "last_name": "Sweeney", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/TipS97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.264353", + "title": "Garbage Collecting the World: One Car at a Time", + "abstract": "A new garbage collection algorithm for distributed object systems, called DMOS (Distributed. Mature Object Space), is presented. It is derived from two previous algorithms, MOS (Mature Object Space), sometimes called the train algorithm, and PMOS (Persistent Mature Object Space). The contribution of DMOS is that it provides the following unique combination of properties for a distributed collector: safety, completeness, non-disruptiveness, incrementality, and scalability. Furthermore, the DMOS collector is non-blocking and does not use global tracing.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.264353", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard L.", + "last_name": "Hudson", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Ron", + "last_name": "Morrison", + "institution": "University of St Andrews" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "David S.", + "last_name": "Munro", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/oopsla/HudsonMMM97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263751", + "title": "The OT Life-cycle: From Eureka! to Shrink Wrap (Panel)", + "abstract": "Over the past years, the Object Technology community has seen the birth of a number of new technology ideas that have changed the way we do computing. These ideas have affected compiler design, analysis approaches, project management techniques, user interface design, deployment strategies and implementation tactics. But where do these ideas come from? And how do they evolve? Do they address the needs as specified by members of the Object Community? Is there a way we can nurture the introduction and assimilation of these ideas to and by the community at large? And what are the market forces that bend ideas to their will. This panel will look at new ideas in Object Technology from a variety of perspectives and will attempt to get to the heart of the way that we, as technologists, create, buy, sell and grow ideas.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263751", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Laura", + "last_name": "Hill", + "institution": "" + }, + { + "first_name": "Bruce", + "last_name": "Anderson", + "institution": "IBM (United States)" + }, + { + "first_name": "Adele Ε.", + "last_name": "Goldberg", + "institution": "" + }, + { + "first_name": "Gregor", + "last_name": "Kiczales", + "institution": "Palo Alto Research Center" + }, + { + "first_name": "Colin", + "last_name": "Scott", + "institution": "" + }, + { + "first_name": "Kevin", + "last_name": "Tyson", + "institution": "Engineering Associates (United States)" + } + ], + "dblp_key": "conf/oopsla/HillAGKST97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263730", + "title": "Efficient Type Inclusion Tests", + "abstract": "A type inclusion test determines whether one type is a subtype of another. Efficient type testing techniques exist for single subtyping, but not for languages with multiple subtyping. To date, the fast constant-time technique relies on a binary matrix encoding of the subtype relation with quadratic space requirements. In this paper, we present three new encodings of the subtype relation, the packed encoding, the bit-packed encoding and the compact encoding. These encodings have different characteristics. The bit-packed encoding delivers the best compression rates: on average 85% for real life programs. The packed encoding performs type inclusion tests in only 4 machine instructions. We present a fast algorithm for computing these encoding which runs in less than 13 milliseconds for PE and BPE, and 23 milliseconds for CE on an Alpha processor. Finally, we compare our results with other constant-time type inclusion tests on a suite of 11 large -benchmark hierarchies.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263730", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "University of Geneva" + }, + { + "first_name": "R. Nigel", + "last_name": "Horspool", + "institution": "University of Victoria" + }, + { + "first_name": "Andreas", + "last_name": "Krall", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/oopsla/VitekHK97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263749", + "title": "Declarative Specialization of Object-Oriented Programs", + "abstract": "Designing and implementing generic software components is encouraged by languages such as object-oriented ones and commonly advocated in most application areas. Generic software components have many advantages among which the most important is reusability. However, it comes at a price: genericity often incurs a loss of efficiency.This paper presents an approach aimed at reconciling genericity and efficiency. To do so, we introduce declarations to the Java language to enable a programmer to specify how generic programs should be specialized for a particular usage pattern. Our approach has been implemented as a compiler from our extended language into standard Java.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263749", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "E.-N.", + "last_name": "Volanschi", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Charles", + "last_name": "Consel", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gilles", + "last_name": "Muller", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Crispin", + "last_name": "Cowan", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "conf/oopsla/VolanschiCMC97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263704", + "title": "Reuse of Algorithms: Still a Challenge to Object-Oriented Programming", + "abstract": "This paper is about reusable, efficient implementations of complex algorithms and their integration into software packages. It seems that this problem is not yetwell understood, and that it is not at all clear how object-oriented and other approaches may contribute to a solution. We analyze the problem and try to reduce it to a few key design goals. Moreover, we discuss various existing approaches in light of these goals, and we briefly report experiences with experimental case studies, in which these goals were rigorously addressed.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263704", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karsten", + "last_name": "Weihe", + "institution": "University of Konstanz" + } + ], + "dblp_key": "conf/oopsla/Weihe97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263727", + "title": "Exploring Largebess, Complexity and Scalability from the OOT Perspective (Panel)", + "abstract": "This panel will lay the foundation for understanding the needs of Large Systems so that OO practitioners can:• appreciate the problems faced;• understand the issues involved; and• re-orient the approaches to provide a viable solution when participating in similar efforts.Specifically, this panel will establish the foundation for discussions on Large Systems by establishing concepts, exposing terminology, and highlighting the state-of-the art.Large applications are usually complex and display one or more of the following dimensions of largeness:• Processing power: requiring tens to hundreds of gigabytes of memory and hundreds of gigaflops performance• High connectivity: highly-connected, systems can show aggregate behavior with complex characteristics: they can become chaotic.• Online access: Archival of terabytes of information, with the need to provide online access to information• Archival and online retrieval: The two technologies (database and archival storage), however, currently do not interoperate. There is a need to develop interfaces to integrate these two technologies.• Data-intensive scientific applications: These involve constructing a data handling infrastructure that simplifies the effort required to maintain petabyte archives, identify relevant data sets within the archive, move, the data to processing platforms, and distribute the data sets across multiple nodes.• Internet access: Large applications often require simultaneous access of information by millions of users worldwide;they must provide acceptable response times.• Scaleable architecture: The systems must be prepared to support exponential growth of application load.Is OOT up to the task? OO practitioners will be encountering some of these application domains in the near future. Some may have already gained some experience in trying to solve these problems. However, the literature in OO does not provide sufficient evidence to believe that OO is ready for such large systems today. Part of the problem is the cross-disciplinary nature of these problems requires a steep learning curve for OO practitioners to be effective. The modeling of these problems with an OO approach is also a challenge. Current 00 methods do not do a good job of supporting multiple views of a domain, and multiple layers of a complex application domain.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263727", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bindu Rama", + "last_name": "Rao", + "institution": "" + }, + { + "first_name": "Chad", + "last_name": "Edwards", + "institution": "Jet Propulsion Laboratory" + }, + { + "first_name": "Ted", + "last_name": "Linden", + "institution": "West Coast University" + }, + { + "first_name": "Regan", + "last_name": "Moore", + "institution": "San Diego Supercomputer Center" + }, + { + "first_name": "Mark", + "last_name": "Seager", + "institution": "Lawrence Livermore National Laboratory" + } + ], + "dblp_key": "conf/oopsla/RaoELMS97", + "venue": "oopsla", + "year": 1997 + }, + { + "paper_id": "10.1145/263698.263728", + "title": "Efficient Dynamic Dispatch without Virtual Function Tables: The SmallEiffel Compiler", + "abstract": "SmallEiffel is an Eiffel compiler which uses a fast simple type inference mechanism to remove most late binding calls, replacing them by static bindings. Starting from the system's entry point, it compiles only statically living code, which saves compiling and then removing dead code. As the whole system is analyzed at compile time, multiple inheritance and genericity do not cause any overhead.SmallEiffel features a coding scheme which eliminates the need for virtual function tables. Dynamic dispatch is implemented without any array access but uses a simple static binary branch code. We show that this implementation makes it possible to use modern hardware very efficiently. It also allows us to inline more calls even when dynamic dispatch is required. Some more dispatch sites are removed after the type inference algorithm has been performed, if the different branches of a dispatch site lead to the same code.The advantage of this approach is that it greatly speeds up execution time and considerably decreases the amount of generated code.", + "date": "1997-10-09", + "link": "https://doi.org/10.1145/263698.263728", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Zendra", + "institution": "Centre de Recherche en Informatique" + }, + { + "first_name": "Dominique", + "last_name": "Colnet", + "institution": "Centre de Recherche en Informatique" + }, + { + "first_name": "Suzanne", + "last_name": "Collin", + "institution": "Centre de Recherche en Informatique" + } + ], + "dblp_key": "conf/oopsla/ZendraCC97", + "venue": "oopsla", + "year": 1997 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/1998.json b/data/pl_conferences/oopsla/1998.json new file mode 100644 index 0000000..6b014dc --- /dev/null +++ b/data/pl_conferences/oopsla/1998.json @@ -0,0 +1,789 @@ +[ + { + "paper_id": "10.1145/286936.286949", + "title": "Safe Metaclass Programming", + "abstract": "In a system where classes are treated as first class objects, classes are defined as instances of other classes called metaclasses. An important benefit of using metaclasses is the ability to assign properties to classes (e.g. being abstract, being final, tracing particular messages, supporting multiple inheritance), independently from the base-level code. However, when both inheritance and instantiation are explicitly and simultaneously involved, communication between classes and their instances raises the metaclass compatibility issue. Some languages (such as SMALLTALK) address this issue but do not easily allow the assignment of specific properties to classes. In contrast, other languages (such as CLOS) allow the assignment of specific properties to classes but do not tackle the compatibility issue well.In this paper, we describe a new model of metalevel organization, called the compatibility model, which overcomes this difficulty. It allows safe metaclass programming since it makes it possible to assign specific properties to classes while ensuring metaclass compatibility. Therefore, we can take advantage of the expressive power of metaclasses to build reliable software. We extend this compatibility model in order to enable safe reuse and composition of class specific properties. This extension is implemented in NEOCLASSTALK, a fully reflective SMALLTALK.", + "date": "1998-10-01", + "link": "https://doi.org/10.1145/286936.286949", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Noury M. N.", + "last_name": "Bouraqadi-Saâdani", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "Ledoux", + "institution": "" + }, + { + "first_name": "Fred", + "last_name": "Rivard", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Bouraqadi-SaadaniLR98", + "venue": "oopsla", + "year": 1998 + }, + { + "paper_id": "10.1145/286936.286965", + "title": "Extending the ODMG Object Model with Composite Objects", + "abstract": "In this paper we extend the ODMG object data model with composite objects. A composite object is an object built by aggregating other component objects. Exclusiveness and dependency constraints, as well as referential integrity, can be associated with composition relationships among objects. Our composite object model is developed in the framework of the ODMG object database standard data model, but can be used in both object-oriented and object-relational database systems. In the paper, we propose a language for defining composite objects and we define the semantics of update operations on composite objects. Keywords Object-oriented database systems, composite objects, integrity constraints, data models. INTRODUCTION Object-oriented DBMS (OODBMS) and object-relational DBMS (ORDBMS) are establishing themselves as the new generation DBMS. Object database systems overcome the limitations of relational systems with respect to several emerging data-intensive applications because of thei...", + "date": "1998-10-01", + "link": "https://doi.org/10.1145/286936.286965", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Elisa", + "last_name": "Bertino", + "institution": "University of Milan" + }, + { + "first_name": "Giovanna", + "last_name": "Guerrini", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/oopsla/BertinoG98", + "venue": "oopsla", + "year": 1998 + }, + { + "paper_id": "10.1145/286936.286960", + "title": "Question time! about Use Cases", + "abstract": "In Britain there is a very successful form of panel session, on a television program called “Question Time.” In this programme, four panelists, all public figures, are chosen to give a spectrum of viewpoints. There is always a figure from the two main political pTM Virtual Machine", + "abstract": "To date, systems offering multitasking for the Java™ programming language either use one process or one class loader for each application. Both approaches are unsatisfactory. Using operating system processes is expensive, scales poorly and does not fully exploit the protection features inherent in a safe language. Class loaders replicate application code, obscure the type system, and non-uniformly treat 'trusted' and 'untrusted' classes, which leads to subtle, but nevertheless, potentially harmful forms of undesirable inter-application interaction.In this paper we propose a novel, simple yet powerful solution. The new model improves on existing designs in terms of resource utilization while offering strong isolation among applications. The approach is applicable both on high-end servers and on small devices. The main idea is to maintain only one copy of every class, regardless of how many applications use it. Classes are transparently and automatically modified, so that each application has a separate copy of its static fields. Two prototypes are described and selected performance data is analyzed. Various aspects of the proposed architectural changes to the Java Virtual Machine are discussed.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353195", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Grzegorz", + "last_name": "Czajkowski", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/Czajkowski00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353182", + "title": "Parametric polymorphism in Java: an approach to translation based on reflective features", + "abstract": "The introduction of parametric polymorphism in Java with translation approaches has been shown to be of considerable interest, allowing the definition of extensions of Java on top of the existing Virtual Machines. Homogeneous translations furthermore, seem to be more useful than heterogeneous, avoiding the continuous increase of library code with redundant information. At this time however, homogeneous approaches aren't as flexible as heterogeneous, with extensions failing to integrate well with base language typing. In this paper, using some of the features of the Core Reflection of Java, we introduce a homogeneous translation in which run-time information about instantiation of type-parameters is carried, allowing full integration of parame-terized types with Java typing. Performance overhead is greatly decreased using a brand new translation technique based on the deferring of the management of type information at load-time. The same power and flexibility of previous heterogeneous approaches is obtained while maintaining homogeneous translation advantages.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353182", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mirko", + "last_name": "Viroli", + "institution": "University of Bologna" + }, + { + "first_name": "Antônio José", + "last_name": "Natali", + "institution": "University of Bologna" + } + ], + "dblp_key": "conf/oopsla/ViroliN00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353177", + "title": "Sealed calls in Java packages", + "abstract": "Ø�Ö��Ø×�ÙÖ�Ø�ÐÝÌ��ÔÖÓ�Ð�Ñ�×�×Ô���ÐÐÝ��ÆÙÐØ�ÓÖ �ÝÒ�Ñ�Ð�Ò�Ù���××Ù��×Â�Ú����Ù×�����Ø�ÓÒ�ÐØ�Ö��Ø × ��Ø�ÖÑ�Ò�Ò�Ø��ÔÓØ�ÒØ��ÐØ�Ö��Ø×Ó�Ú�ÖØÙ�ÐÑ�Ø�Ó��ÒÚÓ � Ø�ÓÒ×�×�××�ÒØ��Ð�ÓÖ�ÒØ�ÖÔÖÓ��ÙÖ�ÐÓÔØ�Ñ�Þ�Ø�ÓÒ×Ó�Ó���Ø ÓÖ��ÒØ��ÔÖÓ�Ö�Ñ×ÁØ�×��Ò�Ö�ÐÐÝ��Ö�ØÓ��Ø�ÖÑ�Ò�×Ù � Â�Ú�Ó���ØÓÖ��ÒØ��ÔÖÓ�Ö�ÑÑ�Ò��ÒØ�ÖÔÖÓ��ÙÖ�Ð�Ò�Ð �Ù���×Ö�Ô��Ø��ÐÝÚ�Ð���Ø�Ø��ÓÔØ�Ñ�Þ�Ø�ÓÒ×�ØÖÙÒØ�Ñ � Ø��Ø�Ò��Ð��ÒØ�ÖÔÖÓ��ÙÖ�ÐÓÔØ�Ñ�Þ�Ø�ÓÒ×�ÓÖ�ÝÒ�Ñ�Ð�Ò Ó�Ú�ÖØÙ�Ð�ÐÐ×Ñ�Ý�ÔÔ��Ö�ØÖÙÒØ�Ñ��ÙÖÖ�ÒØÑ���Ò�×Ñ × Ý×�×�ÐÐ��Ú�ÖØÙ�Ð�Þ�Ø�ÓÒÑ�Ø�Ó��ÒÐ�Ò�Ò�Ð�××���Ö�Ö�Ý �Ö�Ô��ÐÐ�Ö�Ô�×��Ð��Ô����� Ì��×Ô�Ô�Ö���Ö�××�×Ø��×ÔÖ����Ñ�ÒØ�ÝÔÖÓÔÓ×�Ò��ÒÓÚ�Ð Ø��Ò�ÕÙ��ÓÖÓÒ×�ÖÚ�Ø�Ú���Ú�ÖØÙ�Ð�Þ�Ø�ÓÒ�Ò�ÐÝ×�×Û�� � �ÔÔÐ��×ØÓ�×��Ò�¬�ÒØÒÙÑ��ÖÓ�Ú�ÖØÙ�Ð�ÐÐ×�ÒÂ�Ú�ÔÖÓ Ö�Ð�Ø��×�ÙÖ�ØÝ���ØÙÖ�Ó�Â�Ú�¬Ð��Ö��Ú�×ÇÒ�Ú�Ö���ÓÙÖ �Ö�Ñ×ÍÒÐ���ÔÖ�Ú�ÓÙ×ÛÓÖ�ÓÙÖØ��Ò�ÕÙ�Ö�ÕÙ�Ö�×Ò��Ø��Ö �Ö���×��ÓÒØ����Ø�ÖÑ�Ò�Ø�ÓÒÓ�Ø��ÔÓØ�ÒØ��ÐØ�Ö��Ø×Ó � ÁÒØ�ÖÔÖÓ��ÙÖ�ÐÓÔØ�Ñ�Þ�Ø�ÓÒ×Ó�Ó���ØÓÖ��ÒØ��ÔÖÓ�Ö�Ñ×", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353177", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ayal", + "last_name": "Zaks", + "institution": "IBM (United States)" + }, + { + "first_name": "Vitaly", + "last_name": "Feldman", + "institution": "IBM (United States)" + }, + { + "first_name": "Nava", + "last_name": "Aizikowitz", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/ZaksFA00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353194", + "title": "An Aristotelian understanding of object-oriented programming", + "abstract": "The folklore of the object-oriented programming community at times maintains that object-oriented programming has drawn inspiration from philosophy, specically that of Aristotle. We investigate this relation, first of all, in the hope of attaining a better understanding of object-oriented programming and, secondly, to explain aspects of Aristotelian logic to the computer science research community (since it differs from first order predicate calculus in a number of important ways). In both respects we endeavour to contribute to the theory of objects, albeit in a more philosophical than mathematical fashion.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353194", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Derek", + "last_name": "Rayside", + "institution": "University of Waterloo" + }, + { + "first_name": "Gerard T.", + "last_name": "Campbell", + "institution": "St. Jerome's University" + } + ], + "dblp_key": "conf/oopsla/RaysideC00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353180", + "title": "Middleware object query processing with deferred updates and autonomous sources", + "abstract": "This paper presents a query processing algorithm called DECAF for use in middleware object query systems that are based on the use of an object cache. The DECAF algorithm is designed to work correctly even in the presence of updates to the underlying databases that don't go through the object cache (i.e., even for autonomous data sources that can be updated through legacy applications that do not perform their updates through the middleware object layer). DECAF's query results are consistent with updates performed by such transactions; its results are also consistent with any deferred updates that are present in the object cache but not yet committed at the database server. The DECAF algorithm attempts to push down query predicates to the underlying DBMSs to take advantage of the query processing capabilities of these systems and to reduce the amount of data transferred from these systems to the object cache.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353180", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jerry", + "last_name": "Kiernan", + "institution": "IBM Research - Almaden" + }, + { + "first_name": "Michael J.", + "last_name": "Carey", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/KiernanC00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353174", + "title": "Object-oriented real-time concurrency", + "abstract": "The primary goal of a real-time system is predictability. Achieving this goal requires all levels of the system to work in concert to provide fixed worst-case execution-times. Un-fortunately, many real-time systems are overly restrictive, providing only ad-hoc scheduling facilities and basic concurrent functionality. Ad-hoc scheduling makes developing, verifying, and maintaining a real-time system extremely difficult and time consuming. Basic concurrent functionality forces programmers to develop complex concurrent programs without the aid of high-level concurrency features.Encouraging the use of sophisticated real-time theory and methodology, in conjunction with high-level concurrency features, requires flexibility and extensibility. Giving real-time programmers access to the underlying system data-structures makes it possible to interact with the system to incorporate new ideas and fine-tune specific applications. This paper explores this approach by examining its effect on a selection of crucial real-time issues: real-time monitors, timeouts, dynamic-priority scheduling and basic priority inheritance. The approach is implemented in μC++.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353174", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peter A.", + "last_name": "Buhr", + "institution": "University of Waterloo" + }, + { + "first_name": "Ashif S.", + "last_name": "Harji", + "institution": "University of Waterloo" + }, + { + "first_name": "Philipp E.", + "last_name": "Lim", + "institution": "University of Waterloo" + }, + { + "first_name": "Jiongxiong", + "last_name": "Chen", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/oopsla/BuhrHLC00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353191", + "title": "A study of devirtualization techniques for a JavaTM Just-In-Time compiler", + "abstract": "Many devirtualization techniques have been proposed to reduce the runtime overhead of dynamic method calls for various object-oriented languages, however, most of them are less effective or cannot be applied for Java in a straightforward manner. This is partly because Java is a statically-typed language and thus transforming a dynamic call to a static one does not make a tangible performance gain (owing to the low overhead of accessing the method table) unless it is inlined, and partly because the dynamic class loading feature of Java prohibits the whole program analysis and optimizations from being applied.We propose a new technique called direct devirtualization with the code patching mechanism. For a given dynamic call site, our compiler first determines whether the call can be devirtualized, by analyzing the current class hierarchy. When the call is devirtualizable and the target method is suitably sized, the compiler generates the inlined code of the method, together with the backup code of making the dynamic call. Only the inlined code is actually executed until our assumption about the devirtualization becomes invalidated, at which time the compiler performs code patching to make the backup code executed subsequently. Since the new technique prevents some code motions across the merge point between the inlined code and the backup code, we have furthermore implemented recently-known analysis techniques, such as type analysis and preexistence analysis, which allow the backup code to be completely eliminated. We made various experiments using 16 real programs to understand the effectiveness and characteristics of the devirtualization techniques in our Java Just-In-Time (JIT) compiler. In summary, we reduced the number of dynamic calls by ranging from 8.9% to 97.3% (the average of 40.2%), and we improved the execution performance by ranging from -1% to 133% (with the geometric mean of 16%).", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353191", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kazuaki", + "last_name": "Ishizaki", + "institution": "IBM (United States)" + }, + { + "first_name": "Motohiro", + "last_name": "Kawahito", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshiaki", + "last_name": "Yasue", + "institution": "IBM (United States)" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/IshizakiKYKN00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353193", + "title": "A formal specification of JavaTM class loading", + "abstract": "The Java Virtual Machine (JVM) has a novel and powerful mechanism to support lazy, dynamic class loading according to user-definable policies. Class loading directly impacts type safety, on which the security of Java applications is based. Conceptual bugs in the loading mechanism were found in earlier versions of the JVM that lead to type violations. A deeper understanding of the class loading mechanism, through such means as formal analysis, will improve our confidence that no additional bugs are present.The work presented in this paper provides a formal specification of (the relevant aspects of) class loading in the JVM and proves its type safety. Our approach to proving type safety is different from the usual ones since classes are dynamically loaded and full type information may not be statically available. In addition, we propose an improvement in the interaction between class loading and bytecode verification, which is cleaner and enables lazier loading.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353193", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhenyu", + "last_name": "Qian", + "institution": "Kestrel Institute" + }, + { + "first_name": "Allen", + "last_name": "Goldberg", + "institution": "Kestrel Institute" + }, + { + "first_name": "Alessandro", + "last_name": "Coglio", + "institution": "Kestrel Institute" + } + ], + "dblp_key": "conf/oopsla/QianGC00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353197", + "title": "Guava: a dialect of Java without data races", + "abstract": "We introduce Guava, a dialect of Java whose rules statically guarantee that parallel threads access shared data only through synchronized methods. Our dialect distinguishes three categories of classes: (1) monitors, which may be referenced from multiple threads, but whose methods are accessed serially; (2) values, which cannot be referenced and therefore are never shared; and (3) objects, which can have multiple references but only from within one thread, and therefore do not need to be synchronized. Guava circumvents the problems associated with today's Java memory model, which must define behavior when concurrent threads access shared memory without synchronization.We present an overview of the syntax and the semantic rules of Guava. We discuss how implementations of Guava can exploit these rules to re-enable compiler optimizations inhibited by standard Java. We discuss how compilers for certain multiprocessor architectures can automatically generate certain programming idioms, such as double-check reads, as optimizations of serialized monitors.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353197", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "Robert E.", + "last_name": "Strom", + "institution": "IBM (United States)" + }, + { + "first_name": "Ashis", + "last_name": "Tarafdar", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/BaconST00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353196", + "title": "An approach to safe object sharing", + "abstract": "It is essential for security to be able to isolate mistrusting programs from one another, and to protect the host platform from programs. Isolation is difficult in object-oriented systems because objects can easily become aliased. Aliases that cross program boundaries can allow programs to exchange information without using a system provided interface that could control information exchange. In Java, mistrusting programs are placed in distinct loader spaces but uncontrolled sharing of system classes can still lead to aliases between programs. This paper presents the object spaces protection model for an object-oriented system. The model decomposes an application into a set of spaces, and each object is assigned to one space. All method calls between objects in different spaces are mediated by a security policy. An implementation of the model in Java is presented.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353196", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ciarán", + "last_name": "Bryce", + "institution": "University of Geneva" + }, + { + "first_name": "Chrislain", + "last_name": "Razafimahefa", + "institution": "University of Geneva" + } + ], + "dblp_key": "conf/oopsla/BryceR00", + "venue": "oopsla", + "year": 2000 + }, + { + "paper_id": "10.1145/353171.353190", + "title": "Scalable propagation-based call graph construction algorithms", + "abstract": "Propagation-based call graph construction algorithms have been studied intensively in the 199Os, and differ primarily in the number of sets that are used to approximate run-time values of expressions. In practice, algorithms such as RTA that use a single set for the whole program scale well. The scalability of algorithms such as 0-CFA that use one set per expression remains doubtful.In this paper, we investigate the design space between RTA and 0-CFA. We have implemented various novel algorithms in the context of Jax, an application extractor for Java, and shown that they all scale to a 325,000-line program. A key property of these algorithms is that they do not analyze values on the run-time stack, which makes them efficient and easy to implement. Surprisingly, for detecting unreachable methods, the inexpensive RTA algorithm does almost as well as the seemingly more powerful algorithms. However, for determining call sites with a single target, one of our new algorithms obtains the current best tradeoff between speed and precision.", + "date": "2000-10-01", + "link": "https://doi.org/10.1145/353171.353190", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM (United States)" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/TipP00", + "venue": "oopsla", + "year": 2000 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2001.json b/data/pl_conferences/oopsla/2001.json new file mode 100644 index 0000000..3c17a35 --- /dev/null +++ b/data/pl_conferences/oopsla/2001.json @@ -0,0 +1,738 @@ +[ + { + "paper_id": "10.1145/504282.504294", + "title": "Incremental Computation of Complex Objects Queries", + "abstract": "The need for incremental algorithms for evaluating database queries is well known, but constructing algorithms that work on object-oriented databases (OODBs) has been difficult. The reason is that OODB query languages involve complex data types including composite objects and nested collections. As a result, existing algorithms have limitations in that the kinds of database updates are restricted, the operations found in many query languages are not supported, or the algorithms are too complex to be described precisely. We present an incremental computation algorithm that can handle any kind of database updates, can accept any expressions in complex query languages such as OQL, and can be described precisely. By translating primitive values and records into collections, we can reduce all query expressions comprehension. This makes the problems with incremental computation less complicated and thus allows us to decribe of two parts: one is to maintain the consistency in each comprehension occurrence and the other is to update the value of an entire expression. The algorithm is so flexible that we can use strict updates, lazy updates, and their combinations. By comparing the performance of applications built with our mechanism and that of equivalent hand written update programs, we show that our incremental algorithm can be iplemented efficiently.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504294", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hiroaki", + "last_name": "Nakamura", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/Nakamura01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504297", + "title": "Dynamic Optimistic Interprocedural Analysis: A Framework and an Application", + "abstract": "In this paper, we address the problem of dynamic optimistic interprocedural analysis. Our goal is to build on past work on static interprocedural analysis and dynamic optimization by combining their advantages. We present a framework for performing dynamic optimistic interprocedural analysis. the framework is designed to be used in the context of dynamic class loading and dynamic compilation, and includes mechanisms for event notification (on class loading and method compilation) and dependence tracking (to enable invalidation of optimistic assumptions). We illustrate the functionality of the framework by using it to be used in the context of dynamic class loading and dynamic compilation, and includes mechanisms for event notification (on class loading and method compilaton) and dependence tracking (to enable invalidation of optimistic assumptions). We illustrate the functionality of the framework by using it to implement a dynamic optimistic interprocedural type (DOIT) analysis algorithm. The DOIT algorithm uses a new global data structure called the Value Graph. The framework and DOIT analysis of the IBM Jalapeño Java virtual machine. Our experimental results for the SPECjvm benchmarks and two larger programs show promising benefits due to dynamic optimistic analysis. Compared to pessimistic analysis, the reduction in number of methods and fields analyzed was in the 2.7x-4.6x and 1.6-2.4x ranges respectively. The average fraction of polymorphic virtual calls decreased from 39.5% to 24.4% due to optimistic analysis, with a best-case decrease from 47.0% to 8.1%. The average fraction of polymorphic interface calls decreased from 96.4% to 36.2% due to optimistic analysis, with a best-case decrease from 100.0% to 0.0%. These benefits were obtained with a low dynamic analysis overhead in the range of 570-930 bytecode bytes/millisecond (about 2.5x-5.4x faster than the Jalapeño baseline compiler)", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504297", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Igor", + "last_name": "Pechtchanski", + "institution": "New York University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/PechtchanskiS01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504292", + "title": "Multitasking without Compromise: A Virtual Machine Evolution", + "abstract": "The multitasking virtual machine (called from now on simply MVM) is a modification of the Java virtual machine. It enables safe, secure, and scalable multitasking. Safety is achieved by strict isolation of application from one another. Resource control augment security by preventing some denial-of-service attacks. Improved scalability results from an aggressive application of the main design principle of MVM: share as much of the runtime as possible among applications and replicate everything else. The system can be described as a 'no compromise'approach --- all the known APIs and mechanisms of the Java programming language are available to applications. MVM is implemented as a series of carefully tuned modifications to the Java HotSpot virtual machine, including the dynamic compiler. this paper presents the design of MVM, focusing on several novel and general techniques: an in-runtime design of lightweight isolation, an extension of a copying, generational garbage collector to provide best-effort management of a portion of the heap space, and a transparent and automated mechanism for safe execution of user-level native code. MVM demonstrates that multitasking in a safe language can be accomplished with a high degree of protection, without constraining the language, and and with competitive performance characteristics", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504292", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Grzegorz", + "last_name": "Czajkowski", + "institution": "" + }, + { + "first_name": "Laurent", + "last_name": "Daynès", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/CzajkowskiD01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504288", + "title": "Object Race Detection", + "abstract": "We present an on-the-fly mechanism that detects access conflicts in executions of multi-threaded Java programs. Access conflicts are a conservative approximation of data races. The checker tracks access information at the level of objects (object races) rather than at the level of individual variables. This viewpoint allows the checker to exploit specific properties of object-oriented programs for optimization by restricting dynamic checks to those objects that are identified by escape analysis as potentially shared. The checker has been implemented in collaboration with an \"ahead-of-time\"Java compiler. The combination fo static program analysis (escape-analysis) and inline instrumentation during code generation allows us to reduce the runtime overhead of detecting access conflicts. This overhead amounts to about 16-129% in time and less than 25% in space for typical benchmark applications and compares favorably to previously published on-the-fly mechanism that incurred an overhead of about a factor of 2-80 in time and up to a factor of 2 in space.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504288", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christoph von", + "last_name": "Praun", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/PraunG01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504293", + "title": "Portable Resource Control in Java: The J-SEAL2 Approach", + "abstract": "Preventing abusive resource consumption is indispensable for all kinds of systems that execute untrusted mobile coee, such as mobile object sytems, extensible web servers, and web browsers. To implement the required defense mechanisms, some support for resource control must be available: accounting and limiting the usage of physical resources like CPU and memory, and of logical resources like threads. Java is the predominant implementation language for the kind of systems envisaged here, even though resource control is a missing feature on standard Java platforms. This paper describes the model and implementation mechanisms underlying the new resource-aware version of the J-SEAL2 mobile object kernel. Our fundamental objective is to achieve complete portability, and our approach is therefore based on Java bytecode transformations. Whereas resource control may be targeted towards the provision of quality of service or of usage-based billing, the focus of this paper is on security, and more specificlly on prevention of denial-of-service attacks orginating from hostile or poorly implemented mobile code.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504293", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "" + }, + { + "first_name": "Jane G.", + "last_name": "Hulaas", + "institution": "University of Geneva" + }, + { + "first_name": "Alex", + "last_name": "Villazón", + "institution": "University of Geneva" + } + ], + "dblp_key": "conf/oopsla/BinderHV01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504283", + "title": "Contract Soundness for Object-Oriented Languages", + "abstract": "Checking pre- and post-conditions of procedures and methods at runtime helps improve software reliability. In the procedural world, pre- and post-conditions have a straightforward interpretation. If a procedure's pre-condition doesn't hold, the caller failed to establish the proper context. If a post-condition doesn't hold, the caller failed to establish the proper context. If a post-condition doesn't hold, the procedure failed to compute the expected result.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504283", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Rice University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/FindlerF01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504291", + "title": "Efficient Implementation of Java Interfaces: Invokeinterface Considered Harmless", + "abstract": "Single superclass inheritance enables simple and efficient table-driven virtual method dispathc. However, virtual method table dispatch does not handle multiple inheritance and interfaces. This complication has led to a widespread misimpression that interface method dispatch is inherently inefficient. This paper argues that with proper implementation techniques, Java interfaces need not be a source of significant performance degradation.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504291", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bowen", + "last_name": "Alpern", + "institution": "IBM (United States)" + }, + { + "first_name": "Anthony", + "last_name": "Cocchi", + "institution": "IBM (United States)" + }, + { + "first_name": "Stephen J.", + "last_name": "Fink", + "institution": "IBM (United States)" + }, + { + "first_name": "David", + "last_name": "Grove", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/AlpernCFGL01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504289", + "title": "A Study of Exception Handling and Its Dynamic Optimization in Java", + "abstract": "ABSTRACT Optimizing exception handling is critical for programs that frequently throw exceptions. We observed that there are many such exception-intensive programs in various categories of Java programs. There are two commonly used exception handling techniques, stack unwinding and stack cutting. Stack unwinding optimizes the normal path, while stack cutting optimizes the exception handling path. However, there has been no single exception handling technique to optimize both paths. We propose a new technique called Exception-Directed Optimization (Edo), which optimizes exception-intensive programs without slowing down exception-minimal programs. Edo, a feedbackdirected dynamic optimization, consists of three steps, exception path profiling, exception path inlining, and throw elimination. Exception path profiling attempts to detect hot exception paths. Exception path inlining compiles the catching method in a hot exception path, inlining the rest of methods in the path. Throw elimination replaces a throw with the explicit control flow to the corresponding catch. We implemented Edo in IBM&apos;s production Justin-Time compiler, and obtained the experimental results, which show that, in SPECjvm98, it improved performance of exceptionintensive programs by up to 18.3 % without affecting performance of exception-minimal programs at all.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504289", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Takeshi", + "last_name": "Ogasawara", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/OgasawaraKN01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504284", + "title": "A Core Calculus for Java Exceptions", + "abstract": "In this paper we present a simple calculus (called CJE) in ourder to fully investigate the exception mechanism of Java, and in particular its interaction with inheritance, which turns out to be non trivial. Moreover, we show that the type system for the calculus directly dirven by the Java language specification (called FULL) uses too many types, in the sense that there are different types which rpovide exactly the same information. Hence, we obtain from FULL a simplified type system called MIN where equivalent types have been identified. We show that is useful both for type-checking optimization and for clarifying the static semantics of the language. The two type systems are proved to satisfy the subject reduction property", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504284", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Davide", + "last_name": "Ancona", + "institution": "University of Genoa" + }, + { + "first_name": "Giovanni", + "last_name": "Lagorio", + "institution": "University of Genoa" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/oopsla/AnconaLZ01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504301", + "title": "On Objects and Events", + "abstract": "This paper presents linguistic primitives for publish/subscribe programming using events and objects. We integrate our primitives into a strongly typed object-oriented language through four mechnisms: (1) serialization, (2) multiple subtyping, (3)closures, and (4) deferred code evaluation. We illustrate our primitives through Java, showing how we have overcome its respective lacks. A precompiler transforms statements based on our publish/subscribe primitives into calls to specifically generated typed adapters, which resemble the typed stubs and skeletons by the rmic precompiler for remote method invocations in Java", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504301", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Christian Heide", + "last_name": "Damm", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/oopsla/EugsterGD01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504300", + "title": "Encapsulating Objects with Confined Types", + "abstract": "Object-oriented languages provide little support for encapsulating objects. Reference semantics allows objects to escape their defining scope. The pervasive aliasing that ensues remains a major source of software defects. This paper introduces Kacheck/J a tool for inferring object encapulation properties in large Java programs. Our goal is to develop practical tools to assist software engineers, thus we focus on simple and scalable techniques. Kacheck/J is able to infer confinement for Java classes. A class and its sublasses are confined if all of their instances are encapsulated in their defining package. This simple property can be used to identify accidental leaks of sensitive objects. The analysis is scalable and efficient; Kacheck/J is able t infer confinement on a corpus of 46,000 classes (115 MB) in 6 minutes", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504300", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christian", + "last_name": "Grothoff", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/GrothoffPV01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504290", + "title": "Efficient Subtyping Tests with PQ-Encoding", + "abstract": "Subtyping tests, i.e., determining whether one type is a subtype of another, are a frequent operation during the execution of objectoriented programs. The challenge is in encoding the hierarchy in a small space, while simultaneously making sure that subtyping tests have efficient implementation. We present a new scheme for encoding multiple and single inheritance hierarchies, which, in the standardized hierarchies, reduces the footprint of all previously published schemes. The scheme is called PQ-encoding after PQ-trees, a data structure previously used in graph theory for finding the orderings that satisfy a collection of constraints. In particular, we show that in the traditional object layout model, the extra memory requirements for single inheritance hierarchies is zero. In the PQ-encoding subtyping tests are constant time, and use only two comparisons. Other than PQ-trees, PQ-encoding uses several novel optimization techniques. These techniques are applicable also in improving the performance of other, previously published, encoding schemes.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504290", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yoav", + "last_name": "Zibin", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ZibinG01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504286", + "title": "Points-To Analysis for Java using Annotated Constraints", + "abstract": "The goal of point-to analysis for Java is to determine the set of objects pointed by a reference variable or a reference object field. This information has a wide variety of client applications in optimizing compilers and software engineering tools. In this paper we present a point-to analysis for Java based on Andersen's point-to analysis for C [5]. We implement the analysis by using a constraint-based approach which employs annotated inclusion constraints. Constraint annotations allow us model precisely and efficiently the semantics of virtual calls and the flow of values through object fields. By solving systems of annotated inclusion constraints, we have been albe to perform practical and precies points-to analysis for Java", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504286", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Ana", + "last_name": "Milanova", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/oopsla/RountevMR01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504295", + "title": "Partial Method Compilation using Dynamic Profile Information", + "abstract": "The traditional tradeoff when performing dynamic compilation is that of fast compilation time versus fast code performance. Most dynamic compilation systems for Java perform selective compilation and/or optimization at a method granularity. This is the not the optimal granularity level. However, compiling at a sub-method granularity is thought to be too complicated to be practical. This paper describes a straightforward technique for performing compilation and optimizations at a finer, sub-method granularity. We utilize dynamic profile data to determine intra-method code regions that are rarely or never executed, and compile and optimize the code without those regions. If a branch that was predicted to be rare is actually taken at run time, we fall back to the interpreter or dynamically compile another version of the code. By avoiding compiling and optimizing code that is rarely executed, we are able to decrease compile time significantly, with little to no degradation in performance. Futhermore, ignoring rarely-executed code can open up more optimization opportunities on the common paths. We present two optimizations---partial dead code elimination and rare-path-sensitive pointer and escape analysis---that take advantage of rare path information. Using these optimizations, our technique is able to improve performance beyond the compile time improvements", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504295", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Whaley", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/Whaley01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504285", + "title": "The Java Syntactic Extender", + "abstract": "The ability to extend a language with new syntactic forms is a powerful tool. A sufficiently flexible macro system allows programmers to build from a common base towards a language designed specifically for their problem domain. However, macro facilities that are integrated, capable, and at the same time simple enough to be widely used have been limited to the Lisp family of languages to date. In this paper we introduce a macro facility, called the Java Syntactic Extender (JSE), with the superior power and ease of use of Lisp macro systems, but for Java, a language with a more conventional algebraic syntax. The design is based on the Dylan macro system, but exploits Java’s compilation model to offer a full procedural macro engine. In other words, syntax expanders may be implemented in, and so use all the facilities of, the full Java language. 1.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504285", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonthan", + "last_name": "Bachrach", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Keith", + "last_name": "Playford", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BachrachP01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504287", + "title": "A Parameterized Type System for Race-Free Java Programs", + "abstract": "... programs; any well-typed program in our system is free of data races. Our type system is significantly more expressive than previous such type systems. In particular, our system lets programmers write generic code to implement a class, then create dierent objects of the same class that have different protection mechanisms. This flexibility enables programmers to reduce the number of unnecessary synchronization operations in a program without risking data races. We also support default types which reduce the burden of writing the extra type annotations. Our experience indicates that our system provides a promising approach to make multithreaded programs more reliable and efficient.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504287", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chandrasekhar", + "last_name": "Boyapati", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/BoyapatiR01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504303", + "title": "Object-Oriented Composition Untangled", + "abstract": "Object-oriented languages come with pre-defined composition mechansims, such as inheritance, object composition, or delegation, each characterized by a certain set of composition properties, which do not themselves individually exist as abstractions at the language level. However, often non-standard composition semantics is needed, with a mixture of composition mechanisms. Such non-standard semantics are simulated by complicated architectures that are sensitive to requirement changes and cannot easily be adapted without invalidating existing clients. In this paper, we propose compound references, a new abstraction for object references, that allows us to provide explicit linguistic means for expressing and combining individual composition properties on-demand. The model is statically typed and allows the programmer to express a seamless spectrum of composition semantics in the interval between object composition and inheritance. The resulting programs are better understandable, due to explicity expressed design decisions, and less sensitive to requirement changes.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504303", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Siemens (Germany)" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/oopsla/OstermannM01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504302", + "title": "Visitor Combination and Traversal Control", + "abstract": "The Visitor design pattern allows the encapsulation of polymorphic behavior outside the class hierarchy on which it operates. A common application of Visitor is the encapsulation of tree traversals. A clean separation can be made between the generic parts of the combinator set and the parts that are specific to a particular class hierarchy. The generic parts form a reusable framework. The generic parts form a reusable framework. The specific parts can be generated from a (tree) grammar. Due to this separation, programming with visitor combinators becomes a form of generic programming with significant reuse of (visitor) code.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504302", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joost", + "last_name": "Visser", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/oopsla/Visser01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504304", + "title": "A Categorization of Classes based on the Visualization of their Internal Structure: The Class Blueprint", + "abstract": "The reengineering and reverse engineering of software systems is gaining importance in software industry, because the accelerated turnover in software industry, because the accelerated turnover in software companies creates legacy systems in a shorter period of time. Especially understanding classes is a key activity in object-oriented programming, since classes represent the primary abstractions from which applications are built. The main problem of this task is to quickly grasp the purpose of a class and its inner structure. To help the reverse engineers in their first contact with a foreign system, we propose a categorization of classes based on the visualization of their internal structure. The contributions of this paper are a novel categorization of classes and a visualization of the which we call the class blueprint. We have validated the categorization on several case studies, two of which we present here.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504304", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michele", + "last_name": "Lanza", + "institution": "" + }, + { + "first_name": "Sté́phane", + "last_name": "Ducasse", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/LanzaD01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504296", + "title": "A Dynamic Optimization Framework for a Java Just-In-Time Compiler", + "abstract": "The high performance implementation of Java Virtual Machines (JVM) and just-in-time (JIT) compilers is directed toward adaptive compilation optimizations on the basis of online runtime profile information. This paper describes the design and implementation of a dynamic optimization framework in a production-level Java JIT compiler. Our approach is to employ a mixed mode interpreter and a three level optimizing compiler, supporting quick, full, and special optimization, each of which has a different set of tradeoffs between compilation overhead and execution speed. a lightweight sampling profiler operates continuously during the entire program's exectuion. When necessary, detailed information on runtime behavior is collected by dynmiacally generating instrumentation code which can be installed to and uninstalled from the specified recompilation target code. Value profiling with this instrumentation mechanism allows fully automatic code specialization to be performed on the basis of specific parameter values or global data at the highest optimization level. The experimental results show that our approach offers high performance and a low code expansion ratio in both program startup and steady state measurements in comparison to the compile-only approach, and that the code specialization can also contribute modest performance improvement", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504296", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Toshio", + "last_name": "Suganuma", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshiaki", + "last_name": "Yasue", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Motohiro", + "last_name": "Kawahito", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/SuganumaYKKN01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504299", + "title": "Modular Mixin-Based Inheritance for Application Frameworks", + "abstract": "Mixin modules are proposed as an extension of a class-based programming language. Mixin modules combine parallel extension of classes, including extension of the self types for those classes, with mixin-based inheritance. For soundness of sybtyping purposes, they require an explicit distinction between mixin-based objects and class-based objects. Applications of mixin modules are in statically type-safe monad-based aspect-oriented programming, and in modular mixin-based Internet programming.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504299", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dominic", + "last_name": "Duggan", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Ching-Ching", + "last_name": "Techaubol", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/DugganT01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504309", + "title": "An On-the-Fly Reference Counting Garbage Collector for Java", + "abstract": "Reference counting is not naturally suitable for running on multiprocessors. The update of pointers and reference counts requires atomic and synchronized operations. We present a novel reference counting algorithm suitable for a multiprocessor that does not require any synchronized operation in its write barrier (not even a compare-and-swap type of synchronization). The algorithm is efficient and may complete with any tracing algorithm.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504309", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yossi", + "last_name": "Levanoni", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/LevanoniP01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504298", + "title": "Jiazzi: New-Age Components for Old-Fashioned Java", + "abstract": "We present Jiazzi, a system that enables the construction of large-scale binary components in Java. Jiazzi components can be thought of as generalizations of Java packages with added support for external linking and separate compilation. Jiazzi components are practical becuase they are constructed out of standard Java source code. Jiazzi requires neither extensions to the Java language nor special conventions for writing Java source code that will go inside a component. Our components are expressive becuase Jiazzi supports cyclic component linking and mixins, which are used together in an open class pattern that enables the modular addition of new features to existing classes. This paper describes Jiazzi, how it enhances Java with components, its implementation, and how type checking works. An implementation of Jiazzi is available for download.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504298", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sean", + "last_name": "McDirmid", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Wilson C.", + "last_name": "Hsieh", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/oopsla/McDirmidFH01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504307", + "title": "Pretenuring for Java", + "abstract": "Pretenuring can reduce copying costs in garbage collectors by allocating long-lived objects into regions that the garbage collector with rarely, if ever, collect. We extend previous work on pretenuring as follows. (1) We produce pretenuring advice that is neutral with respect to the garbage collector algorithm and configuration. We thus can and do combine advice from different applications. We find that predictions using object lifetimes at each allocation site in Java prgroams are accurate, which simplifies the pretenuring implementation. (2) We gather and apply advice to applications and the Jalapeño JVM, a compiler and run-time system for Java written in Java. Our results demonstrate that building combined advice into Jalapeño from different application executions improves performance regardless of the application Jalapeño is compiling and executing. This build-time advice thus gives user applications some benefits of pretenuring without any application profiling. No previous work pretenures in the run-time system. (3) We find that application-only advice also improves performance, but that the combination of build-time and application-specific advice is almost always noticeably better. (4) Our same advice improves the performance of generational and Older First colleciton, illustrating that it is collector neutral.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504307", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Sharad", + "last_name": "Singhai", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Matthew", + "last_name": "Hertz", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinely", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/BlackburnSHMM01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504306", + "title": "The Architecture of a UML Virtual Machine", + "abstract": "Current software development tools let developers model a software system and generate program code from the models to run the system. However, generating code and installing a non-trivial system induces a time delay between changing the model and executing it that makes rapid model prototyping awkard if not impossible. This paper presents the architecture of a virtual machine for UML that interprets UML models without any intermediate code-generation step. The paper shows how to embed UML in a metalevel architecture so that a key property of model-based systems, the casual connection between models and model instances, is guaranteed. With this architecture, changes to a model have immediate effects on its execution, providing users with rapid feedback about the model's structure and behavior. This approach supports model innovation better than today's code-generation approaches.", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504306", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dirk", + "last_name": "Riehle", + "institution": "Start International" + }, + { + "first_name": "Steven", + "last_name": "Fraleigh", + "institution": "Start International" + }, + { + "first_name": "Dirk", + "last_name": "Bucka-Lassen", + "institution": "" + }, + { + "first_name": "Nosa", + "last_name": "Omorogbe", + "institution": "Start International" + } + ], + "dblp_key": "conf/oopsla/RiehleFBO01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504308", + "title": "Controlling Garbage Collection and Heap Growth to Reduce the Execution Time of Java Applications", + "abstract": "In systems that support garbage collection a tension exists between collecting garbage too frequently and not collecting garbage frequently enough. Garbage collection that occurs too frequently may introduce unnecessary overheads at the risk of not collecting much garbage during each cycle. On the other hand, collecting garbage too infrequently can result in applications that execute with a large amount of virtual memory (i.e., with a large footprint) and suffer from increased execution times due to paging. In this paper we use a large collection of Java applications and the highly tuned and widely used BoehmDemers -Weiser conservative garbage collector to experimentally examine the extent to which the frequency of garbage collection impacts an application&apos;s execution time, footprint, and pause times. We use these results to devise some guidelines for controlling garbage collection and heap growth in a conservative garbage collector in order to minimize application execution times. Then we describe new strategies for controlling garbage collection and heap growth that impact not only the frequency with which garbage collection occurs but also the points at which garbage collection occurs. Experimental results demonstrate that when compared with the existing approach our new strategy can significantly reduce application execution times. 1", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504308", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tim", + "last_name": "Brecht", + "institution": "University of Waterloo" + }, + { + "first_name": "Eshrat", + "last_name": "Arjomandi", + "institution": "York University" + }, + { + "first_name": "Chang", + "last_name": "Li", + "institution": "York University" + }, + { + "first_name": "Hang", + "last_name": "Pham", + "institution": "York University" + } + ], + "dblp_key": "conf/oopsla/BrechtALP01", + "venue": "oopsla", + "year": 2001 + }, + { + "paper_id": "10.1145/504282.504305", + "title": "Regression Test Selection for Java Software", + "abstract": "Regression testing is applied to modified software to provide confidence that the changed parts behave as intended and that the unchanged parts have not been adversely affected by the modifications. To reduce the cost of regression testing, test cases are selected from the test suite that was used to test the original version of the software---this process is called regression test selection. A safe regressiontest -selection algorithm selects every test case in the test suite that may reveal a fault in the modified software. Safe regression-test-selection techniques can help to reduce the time required to perform regression testing because they select only a portion of the test suite for use in the testing but guarantee that the faults revealed by this subset will be the same as those revealed by running the entire test suite. This paper presents the first safe regression-test-selection technique that, based on the use of a suitable representation, handles the features of the Java language. Unlike other safe regression test selection techniques, the presented technique also handles incomplete programs. The technique can thus be safely applied in the (very common) case of Java software that uses external libraries or components", + "date": "2001-10-01", + "link": "https://doi.org/10.1145/504282.504305", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mary Jean", + "last_name": "Harrold", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "James A.", + "last_name": "Jones", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Tongyu", + "last_name": "Li", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Donglin", + "last_name": "Liang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Alessandro", + "last_name": "Orso", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Marinus", + "last_name": "Pennings", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Saurabh", + "last_name": "Sinha", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "S. Alexander", + "last_name": "Spoon", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Ashish M.", + "last_name": "Gujarathi", + "institution": "Citrix (Switzerland)" + } + ], + "dblp_key": "conf/oopsla/HarroldJLLOPSSG01", + "venue": "oopsla", + "year": 2001 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2002.json b/data/pl_conferences/oopsla/2002.json new file mode 100644 index 0000000..e1e6668 --- /dev/null +++ b/data/pl_conferences/oopsla/2002.json @@ -0,0 +1,647 @@ +[ + { + "paper_id": "10.1145/582419.582423", + "title": "BuddyCache: high-performance object storage for collaborative strong-consistency applications in a WAN", + "abstract": "Collaborative applications provide a shared work environment for groups of networked clients collaborating on a common task. They require strong consistency for shared persistent data and efficient access to fine-grained objects. These properties are difficult to provide in wide area networks because of high network latency.BuddyCache is a new transactional caching approach that improves the latency of access to shared persistent objects for collaborative strong-consistency applications in high-latency network environments. The challenge is to improve performance while providing the correctness and availability properties of a transactional caching protocol in the presence of node failures and slow peers.We have implemented a BuddyCache prototype and evaluated its performance. Analytical results, confirmed by measurements of the BuddyCache prototype using the multi-user 007 benchmark indicate that for typical Internet latencies, e.g. ranging from 40 to 80 milliseconds round trip time to the storage server, peers using BuddyCache can reduce by up to 50% the latency of access to shared objects compared to accessing the remote servers directly.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582423", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Magnus E.", + "last_name": "Bjornsson", + "institution": "Brandeis University" + }, + { + "first_name": "Liuba", + "last_name": "Shrira", + "institution": "Brandeis University" + } + ], + "dblp_key": "conf/oopsla/BjornssonS02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582444", + "title": "Incommunicado: efficient communication for isolates", + "abstract": "Executing computations in a single instance of safe language virtual machine can improve performance and overall platform scalability. It also poses various challenges. One of them is providing a fast inter-application communication mechanism. In addition to being efficient, such a mechanism should not violate any functional and non-functional properties of its environment, and should also support enforcement of application-specific security policies. This paper explores the design and implementation of a communication substrate for applications executing within a single Java virtual machine modified to enable safe and interference-free execution of isolated computations. Designing an efficient extension that does not break isolation properties and at the same time pragmatically offers an intuitive API has proven non-trivial. This paper demonstrates a set of techniques that lead to at least an eight-fold performance improvement over the in-process inter-application communication using standard mechanisms offered by the Java platform.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582444", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Krzysztof", + "last_name": "Palacz", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Grzegorz", + "last_name": "Czajkowski", + "institution": "" + }, + { + "first_name": "Laurent", + "last_name": "Daynas", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/PalaczVCD02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582439", + "title": "Write barrier removal by static analysis", + "abstract": "We present a new analysis for removing unnecessary write barriers in programs that use generational garbage collection. To our knowledge, this is the first static program analysis for this purpose. Our algorithm uses a pointer analysis to locate assignments that always create a reference from a younger object to an older object, then transforms the program to remove the write barriers normally associated with such assignments. We have implemented two transformations that reorder object allocations; these transformations can significantly increase the effectiveness of our write barrier removal algorithm.Our base technique assumes that the collector promotes objects in age order. We have developed an extension that enables the optimistic removal of write barriers, with the collector lazily adding each newly promoted object into a remembered set of objects whenever the compiler may have removed write barriers involving the object at statements that have yet to execute. This mechanism enables the application of our technique to virtually any memory management system that uses write barriers to enable generational garbage collection.Results from our implemented system show that our technique can remove substantial numbers of write barriers from the majority of the programs in our benchmark set, producing modest performance improvements of up to 6% of the overall execution time. Moreover, by dynamically instrumenting the executable, we are able to show that for six of our nine benchmark programs, our analysis is close to optimal in the sense that it removes the write barriers for almost all assignments that do not, in the observed execution, create a reference from an older object to a younger object. Finally, our results show that the overhead of our optimistic extension is negligible.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582439", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karen", + "last_name": "Zee", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ZeeR02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582436", + "title": "Design pattern implementation in Java and aspectJ", + "abstract": "AspectJ implementations of the GoF design patterns show modularity improvements in 17 of 23 cases. These improvements are manifested in terms of better code locality, reusability, composability, and (un)pluggability.The degree of improvement in implementation modularity varies, with the greatest improvement coming when the pattern solution structure involves crosscutting of some form, including one object playing multiple roles, many objects playing one role, or an object playing roles in multiple pattern instances.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582436", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jan", + "last_name": "Hannemann", + "institution": "University of British Columbia" + }, + { + "first_name": "Gregor", + "last_name": "Kiczales", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/oopsla/HannemannK02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582432", + "title": "Online feedback-directed optimization of Java", + "abstract": "This paper describes the implementation of an online feedback-directed optimization system. The system is fully automatic; it requires no prior (offline) profiling run. It uses a previously developed low-overhead instrumentation sampling framework to collect control flow graph edge profiles. This profile information is used to drive several traditional optimizations, as well as a novel algorithm for performing feedback-directed control flow graph node splitting. We empirically evaluate this system and demonstrate improvements in peak performance of up to 17% while keeping overhead low, with no individual execution being degraded by more than 2% because of instrumentation.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582432", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Michael", + "last_name": "Hind", + "institution": "IBM (United States)" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "conf/oopsla/ArnoldHR02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582430", + "title": "A constraint-based architecture for local search", + "abstract": "Combinatorial optimization problems are ubiquitous in numerous practical applications. Yet most of them are challenging, both from computational complexity and programming standpoints. Local search is one of the main approaches to address these problems. However, it often requires sophisticated incremental algorithms and data structures, and considerable experimentation. This paper proposes a constraint-based, object-oriented, architecture to reduce the development time of local search algorithms significantly. The architecture consists of declarative and search components. The declarative component includes invariants, which maintain complex expressions incrementally, and differentiable objects, which maintain properties that can be queried to evaluate the effect of local moves. Differentiable objects are high-level modeling concepts, such as constraints and functions, that capture combinatorial substructures arising in many applications. The search component supports various abstractions to specify heuristics and meta-heuristics. We illustrate the architecture with the language Comet and several applications, such as car sequencing and the progressive party problem. The applications indicate that the architecture allows for very high-level modeling of local search algorithms, while preserving excellent performance.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582430", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Laurent", + "last_name": "Michel", + "institution": "Brown University" + }, + { + "first_name": "Pascal Van", + "last_name": "Hentenryck", + "institution": "Brown University" + } + ], + "dblp_key": "conf/oopsla/MichelH02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582425", + "title": "Workflow enactment with continuation and future objects", + "abstract": "An increasing number of software developers are turning to workflow to separate the logic and the control aspects in their applications, thus making them more amenable to change. However, in spite of recent efforts to standardize and provide reusable workflow components, many developers build their own. This is a challenging endeavor and involves solving problems which seem incompatible with the object paradigm and current object-oriented programming languages. In the context of an object-oriented workflow framework, this paper demonstrates a novel approach that resolves this impedance mismatch with techniques drawn from programming language theory. This successful cross-pollination narrows the gap between the results of decades of research in programming languages and developers working hard to cope with change.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582425", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dragoş A.", + "last_name": "Manolescu", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Manolescu02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582441", + "title": "An analyzable annotation language", + "abstract": "The Alloy Annotation Language (AAL) is a language (under development) for annotating Java code based on the Alloy modeling language. It offers a syntax similar to the Java Modeling Language (JML), and the same opportunities for generation of run-time assertions. In addition, however, AAL offers the possibility of fully automatic compile-time analysis. Several kinds of analysis are supported, including: checking the code of a method against its specification; checking that the specification of a method in a subclass is compatible with the specification in the superclass; and checking properties relating method calls on different objects, such as that the equals methods of a class (and its overridings) induce an equivalence. Using partial models in place of code, it is also possible to analyze object-oriented designs in the abstract: investigating, for example, a view relationship amongst objects.The paper gives examples of annotations and such analyses. It presents (informally) a systematic translation of annotations into Alloy, a simple first-order logic with relational operators. By doing so, it makes Alloy's automatic analysis, which is based on state-of-the-art SAT solvers, applicable to the analysis of object-oriented programs, and demonstrates the power of a simple logic as the basis for an annotation language.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582441", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Darko", + "last_name": "Marinov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Daniel", + "last_name": "Jackson", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/KhurshidMJ02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582437", + "title": "Implementing distribution and persistence aspects with aspectJ", + "abstract": "This paper reports our experience using AspectJ, a generalpurpose aspect-oriented extension to Java, to implement distribution and persistence aspects in a web-based information system. This system was originally implemented in Java and restructured with AspectJ. Our main contribution is to show that AspectJ is useful for implementing several persistence and distribution concerns in the application considered, and other similar applications. We have also identified a few drawbacks in the language and suggest some minor modifications that could significantly improve similar implementations. Despite the drawbacks, we argue that the AspectJ implementation is superior to the pure Java implementation. Some of the aspects implemented in our experiment are abstract and constitute a simple aspect framework. The other aspects are application specific but we suggest that different implementations might follow the same aspect pattern. The framework and the pattern allow us to propose architecture-specific guidelines that provide practical advice for both restructuring and implementing certain kinds of persistent and distributed applications with AspectJ.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582437", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sérgio", + "last_name": "Soares", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Eduardo", + "last_name": "Laureano", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Paulo", + "last_name": "Borba", + "institution": "Universidade Federal de Pernambuco" + } + ], + "dblp_key": "conf/oopsla/SoaresLB02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582433", + "title": "Lock reservation: Java locks can mostly do without atomic operations", + "abstract": "Because of the built-in support for multi-threaded programming, Java programs perform many lock operations. Although the overhead has been significantly reduced in the recent virtual machines, One or more atomic operations are required for acquiring and releasing an object's lock even in the fastest cases.This paper presents a novel algorithm called lock reservation. It exploits thread locality of Java locks, which claims that the locking sequence of a Java lock contains a very long repetition of a specific thread. The algorithm allows locks to be reserved for threads. When a thread attempts to acquire a lock, it can do without any atomic operation if the lock is reserved for the thread. Otherwise, it cancels the reservation and falls back to a conventional locking algorithm.We have evaluated an implementation of lock reservation in IBM's production virtual machine and compiler. The results show that it achieved performance improvements up to 53% in real Java programs.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582433", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kiyokuni", + "last_name": "Kawachiya", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Akira", + "last_name": "Koseki", + "institution": "IBM (United States)" + }, + { + "first_name": "Tamiya", + "last_name": "Onodera", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/KawachiyaKO02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582443", + "title": "Performance and scalability of EJB applications", + "abstract": "We investigate the combined effect of application implementation method, container design, and efficiency of communication layers on the performance scalability of J2EE application servers by detailed measurement and profiling of an auction site server.We have implemented five versions of the auction site. The first version uses stateless session beans, making only minimal use of the services provided by the Enterprise JavaBeans (EJB) container. Two versions use entity beans, one with container-managed persistence and the other with bean-managed persistence. The fourth version applies the session fasade pattern, using session beans as a fasade to access entity beans. The last version uses EJB 2.0 local interfaces with the session fasade pattern. We evaluate these different implementations on two popular open-source EJB containers with orthogonal designs. JBoss uses dynamic proxies to generate the container classes at run time, making an extensive use of reflection. JOnAS pre-compiles classes during deployment, minimizing the use of reflection at run time. We also evaluate the communication optimizations provided by each of these EJB containers.The most important factor in determining performance is the application implementation method. EJB applications with session beans perform as well as a Java servlets-only implementation and an order-of-magnitude better than most of the implementations based on entity beans. The fine-granularity access exposed by the entity beans limits scalability. Use of session fasade beans improves performance for entity beans, but only if local communication is very efficient or EJB 2.0 local interfaces are used. Otherwise, session fasade beans degrade performance.For the implementation using session beans, communication cost forms the major component of the execution time on the EJB server. The design of the container has little effect on performance. With entity beans, the design of the container becomes important. In particular, the cost of reflection affects performance. For implementations using session fasade beans, local communication cost is critically important. EJB 2.0 local interfaces improve the performance by avoiding the communication layers for local communications.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582443", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emmanuel", + "last_name": "Cecchet", + "institution": "Centre Inria de l'Université Grenoble Alpes" + }, + { + "first_name": "Julie", + "last_name": "Marguerite", + "institution": "Rice University" + }, + { + "first_name": "Willy", + "last_name": "Zwaenepoel", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/CecchetMZ02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582440", + "title": "Ownership types for safe programming: preventing data races and deadlocks", + "abstract": "This paper presents a new static type system for multithreaded programs; well-typed programs in our system are guaranteed to be free of data races and deadlocks. Our type system allows programmers to partition the locks into a fixed number of equivalence classes and specify a partial order among the equivalence classes. The type checker then statically verifies that whenever a thread holds more than one lock, the thread acquires the locks in the descending order.Our system also allows programmers to use recursive tree-based data structures to describe the partial order. For example, programmers can specify that nodes in a tree must be locked in the tree order. Our system allows mutations to the data structure that change the partial order at runtime. The type checker statically verifies that the mutations do not introduce cycles in the partial order, and that the changing of the partial order does not lead to deadlocks. We do not know of any other sound static system for preventing deadlocks that allows changes to the partial order at runtime.Our system uses a variant of ownership types to prevent data races and deadlocks. Ownership types provide a statically enforceable way of specifying object encapsulation. Ownership types are useful for preventing data races and deadlocks because the lock that protects an object can also protect its encapsulated objects. This paper describes how to use our type system to statically enforce object encapsulation as well as prevent data races and deadlocks. The paper also contains a detailed discussion of different ownership type systems and the encapsulation guarantees they provide.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582440", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chandrasekhar", + "last_name": "Boyapati", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Robert", + "last_name": "Lee", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/BoyapatiLR02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582428", + "title": "Portable serialization of CORBA objects: a reflective approach", + "abstract": "The objective of this work is to define, implement and illustrate a portable serialization technique for CORBA objects. We propose an approach based on reflection: through open compilers facilities the internal state of CORBA objects is obtained and transformed into a language independent format using CORBA mechanisms. This state can be restored and used by objects developed using different languages and running on different software platforms. A tool was developed and applied to a Chat application as a case study. The proposed technique is used to exchange state information between a C++ and a Java incarnation of this CORBA service. An observer tool enables the object state to be displayed and analyzed by the user. The applicability of this technique to various domains is discussed. Beyond the interest of language reflection, we finally advocate that operating system and middleware reflection would also be powerful concepts to extend the work presented in this paper.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582428", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marc‐Olivier", + "last_name": "Killijian", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Juan–Carlos", + "last_name": "Ruiz", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jean-Charles", + "last_name": "Fabre", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/oopsla/KillijianRF02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582426", + "title": "Integrating independent components with on-demand remodularization", + "abstract": "This paper proposes language concepts that facilitate the separation of an application into independent reusable building blocks and the integration of pre-build generic software components into applications that have been developed by third party vendors. A key element of our approach are on-demand remodularizations, meaning that the abstractions and vocabulary of an existing code base are translated into the vocabulary understood by a set of components that are connected by a common collaboration interface. This general concept allows us to mix-and-match remodularizations and components on demand.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582426", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Siemens (Germany)" + } + ], + "dblp_key": "conf/oopsla/MeziniO02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582422", + "title": "Creating and preserving locality of java applications at allocation and garbage collection times", + "abstract": "The growing gap between processor and memory speeds is motivating the need for optimization strategies that improve data locality. A major challenge is to devise techniques suitable for pointer-intensive applications. This paper presents two techniques aimed at improving the memory behavior of pointer-intensive applications with dynamic memory allocation, such as those written in Java. First, we present an allocation time object placement technique based on the recently introduced notion of prolific (frequently instantiated) types. We attempt to co-locate, at allocation time, objects of prolific types that are connected via object references. Then, we present a novel locality based graph traversal technique. The benefits of this technique, when applied to garbage collection (GC), are twofold: (i) it improves the performance of GC due to better locality during a heap traversal and (ii) it restructures surviving objects in a way that enhances locality. On multiprocessors, this technique can further reduce overhead due to synchronization and false sharing. The experimental results, on a well-known suite of Java benchmarks (SPECjvm98 [26], SPECjbb2000 [27], and jOlden [4]), from an implementation of these techniques in the Jikes RVM [1], are very encouraging. The object co-allocation technique improves application performance by up to 21% (10% on average) in the Jikes RVM configured with a non-copying mark-and-sweep collector. The locality-based traversal technique reduces GC times by up to 20% (10% on average) and improves the performance of applications by up to 14% (6% on average) in the Jikes RVM configured with a copying semi-space collector. Both techniques combined can improve application performance by up to 22% (10% on average) in the Jikes RVM configured with a non-copying mark-and-sweep collector.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582422", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yefim", + "last_name": "Shuf", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Manish", + "last_name": "Gupta", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Hubertus", + "last_name": "Franke", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "Jaswinder", + "last_name": "Singh", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/oopsla/ShufGFAS02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582421", + "title": "Reconsidering custom memory allocation", + "abstract": "Programmers hoping to achieve performance improvements often use custom memory allocators. This in-depth study examines eight applications that use custom allocators. Surprisingly, for six of these applications, a state-of-the-art general-purpose allocator (the Lea allocator) performs as well as or better than the custom allocators. The two exceptions use regions, which deliver higher performance (improvements of up to 44%). Regions also reduce programmer burden and eliminate a source of memory leaks. However, we show that the inability of programmers to free individual objects within regions can lead to a substantial increase in memory consumption. Worse, this limitation precludes the use of regions for common programming idioms, reducing their usefulness.We present a generalization of general-purpose and region-based allocators that we call reaps. Reaps are a combination of regions and heaps, providing a full range of region semantics with the addition of individual object deletion. We show that our implementation of reaps provides high performance, outperforming other allocators with region-like semantics. We then use a case study to demonstrate the space advantages and software engineering benefits of reaps in practice. Our results indicate that programmers needing fast regions should use reaps, and that most programmers considering custom allocators should instead use the Lea allocator.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582421", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/BergerZM02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582434", + "title": "Fast algorithm for creating space efficient dispatching tables with application to multi-dispatching", + "abstract": "The dispatching problem can be solved very efficiently in the single-inheritance~(SI) setting. In this paper we show how to extend one such solution to the multiple-inheritance~(MI) setting. This generalization comes with an increase to the space requirement by a small factor of κ This factor can be thought of as a metric of the complexity of the topology of the inheritance hierarchy.On a data set of~35 hierarchies totaling some~64 thousand types, our dispatching data structure, based on a novel type slicing technique, exhibits very significant improvements over previous dispatching techniques, not only in terms of the time for creating the underlying data structure, but also in terms of total space used.The cost is in the dispatching time, which is no longer constant, but doubly logarithmic in the number of types. Conversely, by using a simple binary search, dispatching time is logarithmic in the number of different implementations. In practice dispatching uses one indirect branch and, on average, only~2.5 binary branches.Our results also have applications to the space-efficient implementation of the more general problem of dispatching multi-methods.A by-product of our type slicing technique is an incremental algorithm for constant-time subtyping tests with favorable memory requirements. (The incremental version of the subtyping problem is to maintain the subtyping data structure in presence of additions of types to the inheritance hierarchy.)", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582434", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yoav", + "last_name": "Zibin", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ZibinG02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582429", + "title": "Multiple instances and symbolic variables in executable sequence charts", + "abstract": "We extend live sequence charts (LSCs), a highly expressive variant of sequence diagrams, and provide the extension with an executable semantics. The extension involves support for instances that can bind to multiple objects and symbolic variables that can bind to arbitrary values. The result is a powerful executable language for expressing behavioral requirements on the level of inter-object interaction. The extension is implemented in full in our play-engine tool, with which one can execute the requirements directly without the need to build or synthesize an intra-object system model. It seems that in addition to many advantages in testing and requirements engineering, for some kinds of systems this could lead to the requirements actually serving as the final implementation.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582429", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rami", + "last_name": "Marelly", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "David", + "last_name": "Harel", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Hillel", + "last_name": "Kugler", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/oopsla/MarellyHK02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582451", + "title": "GCspy: an adaptable heap visualisation framework", + "abstract": "GCspy is an architectural framework for the collection, transmission, storage and replay of memory management behaviour. It makes new contributions to the understanding of the dynamic memory behaviour of programming languages (and especially object-oriented languages that make heavy demands on the performance of memory managers). GCspy's architecture allows easy incorporation into any memory management system: it is not limited to garbage-collected languages. It requires only small changes to the system in which it is incorporated but provides a simple to use yet powerful data-gathering API. GCspy scales to allow very large heaps to be visualised effectively and efficiently. It allows already-running, local or remote systems to be visualised and those systems to run at full speed outside the points at which data is gathered. GCspy's visualisation tool presents this information in a number of novel ways.Deep understanding of program behaviour is essential to the design of the next generation of garbage collectors and explicit allocators. Until now, no satisfactory tools have been available to assist the implementer in gaining an understanding of heap behaviour. GCspy has been demonstrated to be a practical solution to this dilemma. It has been used to analyse production Java virtual machines running applications of realistic sizes. Its use has revealed important insights into the interaction between application program and JVM and has led to the development of better garbage collectors.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582451", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tony", + "last_name": "Printezis", + "institution": "University of Glasgow" + }, + { + "first_name": "Richard", + "last_name": "Jones", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/oopsla/PrintezisJ02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582448", + "title": "Alias annotations for program understanding", + "abstract": "One of the primary challenges in building and evolving large object-oriented systems is understanding aliasing between objects. Unexpected aliasing can lead to broken invariants, mistaken assumptions, security holes, and surprising side effects, all of which may lead to software defects and complicate software evolution.This paper presents AliasJava, a capability-based alias annotation system for Java that makes alias patterns explicit in the source code, enabling developers to reason more effectively about the interactions in a complex system. We describe our implementation, prove the soundness of the annotation system, and give an algorithm for automatically inferring alias annotations. Our experience suggests that the annotation system is practical, that annotation inference is efficient and yields appropriate annotations, and that the annotations can express important invariants of data structures and of software architectures.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582448", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "University of Washington" + }, + { + "first_name": "Valentin", + "last_name": "Kostadinov", + "institution": "University of Washington" + }, + { + "first_name": "Craig", + "last_name": "Chambers", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/AldrichKC02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582445", + "title": "Sifting out the mud: low level C++ code reuse", + "abstract": "More and more computers are being incorporated in devices where the available amount of memory is limited. This contrasts with the increasing need for additional functionality and the need for rapid application development. While object-oriented programming languages, providing mechanisms such as inheritance and templates, allow fast development of complex applications, they have a detrimental effect on program size. This paper introduces new techniques to reuse the code of whole procedures at the binary level and a supporting technique for data reuse. These techniques benefit specifically from program properties originating from the use of templates and inheritance. Together with our previous work on code abstraction at lower levels of granularity, they achieve additional code size reductions of up to 38% on already highly optimized and compacted binaries, without sacrificing execution speed. We have incorporated these techniques in Squeeze++, a prototype link-time binary rewriter for the Alpha architecture, and extensively evaluate them on a suite of 8 real-life C++ applications. The total code size reductions achieved post link-time (i.e. without requiring any change to the compiler) range from 27 to 70%, averaging at around 43%.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582445", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bjorn De", + "last_name": "Sutter", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Bruno De", + "last_name": "Bus", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Koen De", + "last_name": "Bosschere", + "institution": "Ghent University Hospital" + } + ], + "dblp_key": "conf/oopsla/SutterBB02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582449", + "title": "Towards a formalization for COM part i: the primitive calculus", + "abstract": "We introduce in this paper a typed calculus intended to capture the execution model of COM. The innovation of this calculus is to model very low-level aspects of the COM framework, specifically the notion of interface pointers. This is handled by specifying an allocation semantics for the calculus, thereby modeling heap allocation of interfaces explicitly. Having an explicit way of talking about interface pointers allows us to model in a reasonable way the notions of interface sharing and object identity. We introduce a type system that can be used to disambiguate between specification and implementation of interfaces. The type system moreover can capture a notion of COM conformance, that is, the legality of COM components. We discuss extensions of the calculus to handle subtyping of interfaces, dynamic interface negotiation and aggregation.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582449", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Riccardo", + "last_name": "Pucella", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/oopsla/Pucella02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582452", + "title": "Access rights analysis for Java", + "abstract": "Java 2 has a security architecture that protects systems from unauthorized access by mobile or statically configured code. The problem is in manually determining the set of security access rights required to execute a library or application. The commonly used strategy is to execute the code, note authorization failures, allocate additional access rights, and test again. This process iterates until the code successfully runs for the test cases in hand. Test cases usually do not cover all paths through the code, so failures can occur in deployed systems. Conversely, a broad set of access rights is allocated to the code to prevent authorization failures from occurring. However, this often leads to a violation of the \"Principle of Least Privilege\"This paper presents a technique for computing the access rights requirements by using a context sensitive, flow sensitive, interprocedural data flow analysis. By using this analysis, we compute at each program point the set of access rights required by the code. We model features such as multi-threading, implicitly defined security policies, the semantics of the Permission.implies method and generation of a security policy description. We implemented the algorithms and present the results of our analysis on a set of programs. While the analysis techniques described in this paper are in the context of Java code, the basic techniques are applicable to access rights analysis issues in non-Java-based systems.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582452", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Larry", + "last_name": "Koved", + "institution": "IBM (United States)" + }, + { + "first_name": "Marco", + "last_name": "Pistoia", + "institution": "IBM (United States)" + }, + { + "first_name": "Aaron", + "last_name": "Kershenbaum", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/KovedPK02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582453", + "title": "Language-specific make technology for the Java programming language", + "abstract": "Keeping the code of a Java application consistent (code is consistent if all of the project classes can be recompiled together without errors) prevents late linking errors, and thus may significantly improve development turnaround time. In this paper we describe a make technology for the Java programming language, that is based on smart dependency checking, guarantees consistency of the project code, and at the same time reduces the number of source code recompilations to the minimum. After project code consistency is initially assured by complete recompilation, the information extracted from the binary classes is stored in a so-called project database. Whenever the source code for some class C is changed, its recompiled binary is compared to the old version of C preserved in the project database. As a result, we find a minimum subset of classes that depend on C and may be affected by the particular change made to it. These are recompiled in turn, and absence of compilation errors at this phase guarantees the consistency of the new project code. To determine which dependent classes to recompile, we categorize all source incompatible changes, and for each category establish a criterion for finding the smallest possible subset of dependent classes.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582453", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mikhail", + "last_name": "Dmitriev", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Dmitriev02", + "venue": "oopsla", + "year": 2002 + }, + { + "paper_id": "10.1145/582419.582447", + "title": "Ownership, encapsulation and the disjointness of type and effect", + "abstract": "Ownership types provide a statically enforceable notion of object-level encapsulation. We extend ownership types with computational effects to support reasoning about object-oriented programs. The ensuing system provides both access control and effects reporting. Based on this type system, we codify two formal systems for reasoning about aliasing and the disjointness of computational effects. The first can be used to prove that evaluation of two expressions will never lead to aliases, while the latter can be used to show the non-interference of two expressions.", + "date": "2002-01-01", + "link": "https://doi.org/10.1145/582419.582447", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dave", + "last_name": "Clarke", + "institution": "Utrecht University" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/ClarkeD02", + "venue": "oopsla", + "year": 2002 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2003.json b/data/pl_conferences/oopsla/2003.json new file mode 100644 index 0000000..20f5a67 --- /dev/null +++ b/data/pl_conferences/oopsla/2003.json @@ -0,0 +1,2436 @@ +[ + { + "paper_id": "10.1145/949344.949353", + "title": "Smart play-out", + "abstract": "We describe \"smart play-out\", a new method for executing and analyzing scenario based behavior, which is part of the Play-In/Play-Out methodology and the Play-Engine tool. Behavior is \"played in\" directly from the system's GUI, and as this is being done the Play-Engine continuously constructs Live Sequence Charts (LSCs), a powerful extension of sequence diagrams. Later, behavior can be \"played out\" freely from the GUI, and the tool executes the LSCs directly, thus driving the system's behavior. An inherent difficulty in constructing a ``play-out\" mechanism is how to resolve the nondeterminism allowed by the LSC specification in order to obtain an executable model. Smart play-out, is a recent strengthening of the play-out mechanism, which addresses this problem by using powerful verification methods, mainly model-checking, to execute and analyze the LSCs, helping the execution to avoid deadlocks and violations. Thus, smart play-out utilizes verification techniques to run programs, rather than to verify a program with respect to given requirements, as in traditional verification approaches. The ideas appear to be relevant in various stages of system development, including requirements specification and analysis, implementation and testing.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949353", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Harel", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Hillel", + "last_name": "Kugler", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Rami", + "last_name": "Marelly", + "institution": "Weizmann Institute of Science" + }, + { + "first_name": "Amir", + "last_name": "Pnueli", + "institution": "Weizmann Institute of Science" + } + ], + "dblp_key": "conf/oopsla/HarelKMP03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949374", + "title": "Building compilers for DirectX 9.0 compatible graphics processors", + "abstract": "Custom graphics processors or GPUs have been available for a few years now. Currently these graphics processors are slowing evolving to generalized stream processors. These custom vector processors [1] have special support for vector and matrix data types supported through \"packed arrays\". Recently, Microsoft and 3D Labs (Open GL ARB) have independently developed virtual execution environments to abstract these underlying graphics processors [2]. Additionally new languages including Cg [3], HLSL [4], and GLSlang [5] have been developed to target these graphics virtual machines. This paper explores the technical issues involved with building compilers that target DirectX 9.0 compatible programmable graphics processors.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949374", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yahya H.", + "last_name": "Mirza", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Mirza03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949370", + "title": "Jazz: a collaborative application development environment", + "abstract": "No abstract available.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949370", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Li-Te", + "last_name": "Cheng", + "institution": "Cambridge Scientific (United States)" + }, + { + "first_name": "Susanne", + "last_name": "Hupfer", + "institution": "Cambridge Scientific (United States)" + }, + { + "first_name": "Steven", + "last_name": "Ross", + "institution": "Cambridge Scientific (United States)" + }, + { + "first_name": "John", + "last_name": "Patterson", + "institution": "Cambridge Scientific (United States)" + }, + { + "first_name": "B. L.", + "last_name": "Clark", + "institution": "Clarkson University" + }, + { + "first_name": "Cleidson R. B. de", + "last_name": "Souza", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/oopsla/ChengHRPCS03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949393", + "title": "Teaching polymorphism with elementary design patterns", + "abstract": "Polymorphism is often treated as an advanced topic by educators. Many feel that if statements are in some sense more \"fundamental\" to computing. On the contrary, polymorphism is both fundamental to object programming and is an elementary topic that can be easily understood by students. Previous papers [1] have shown how role-play exercises can remind students that they already have a deep understanding of dynamic polymorphism. The question then becomes how do we find effective teaching techniques to present this topic when we move from the level of metaphor to that of programming. A few elementary patterns [2] can be used to teach this topic even before the student is introduced to ad-hoc selection with if statements. Teaching these patterns early has the added benefit that they are pervasive in the Java libraries, so understanding them eases the student's later work.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949393", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Bergin", + "institution": "Pace University" + } + ], + "dblp_key": "conf/oopsla/Bergin03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949376", + "title": "Time Conscious Objects", + "abstract": "In most business software systems the time dimension of business objects plays a significant role. Time is a crosscutting concern that is hard to separate from other business logic. We have developed a toolkit that allows existing business application systems to be extended with \"time-conscious\" behavior in a non-intrusive way by factoring out all aspects of time-related behavior into a framework and a set of classes that is distinct from the existing code base. The Time Conscious Objects™ (TCO™) toolkit is currently implemented in Java™, but through the use of generation technology the toolkit can easily be made available in any language that supports polymorphism.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949376", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jorn", + "last_name": "Bettin", + "institution": "" + }, + { + "first_name": "Jeff", + "last_name": "Hoare", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BettinH03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949359", + "title": "QuickUML: a tool to support iterative design and code development", + "abstract": "We demonstrate QuickUML, a tool which supports iterative design and code development by providing facilities to draw UML class diagrams, to generate Java code from such diagrams, and also to automatically generate a UML class diagram from a collection of Java source code files. We also discuss how use of the tool provides general support for teaching students the importance of design in software development.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949359", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Carl", + "last_name": "Alphonce", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Phil", + "last_name": "Ventura", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "conf/oopsla/AlphonceV03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949366", + "title": "A policy based system to incorporate self-managing behaviors in applications", + "abstract": "With the rapid increase in complexity of software systems and applications, it becomes necessary to develop tools to simplify the incorporation of self-managing features into applications. The use of object and component technologies, together with a policy system which externalizes business logic from an application, plays an important role in enabling systems with greater manageability and variability. In this presentation, we will show an approach to build policy based applications with much greater flexibility, expressiveness and reusability . The key concept in this approach is the separation of business logic expressed as policy or rules into its various sub-components and these sub-components are dynamically configurable.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949366", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hoi", + "last_name": "Chan", + "institution": "IBM (United States)" + }, + { + "first_name": "Bill T.", + "last_name": "Arnold", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/ChanA03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949380", + "title": "Program manipulation via interactive transformations", + "abstract": "Systematic large-scale modification of source code is tedious and error-prone, because developers use authoring and editing tools poorly suited to the program maintenance task. We combine the results from psychology of programming, software visualization, program analysis, and program transformation fields to create a novel environment that lets the programmers express operations on program source code at a level above text-oriented editing.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949380", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marat", + "last_name": "Boshernitsan", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/Boshernitsan03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949347", + "title": "An end-to-end domain-driven software development framework", + "abstract": "This paper presents a comprehensive, domain-driven framework for software development. It consists of a meta-programmable domain-specific modeling environment and a model transformation generator toolset based on graph transformations. The framework allows the creation of custom, domain-oriented programming environments that support end-user programmability. In addition, the framework could be considered an early, end-to-end implementation of the concepts advocated by the OMG's Model Driven Architecture initiative.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949347", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aditya", + "last_name": "Agrawal", + "institution": "Vanderbilt University" + }, + { + "first_name": "Gábor", + "last_name": "Karsai", + "institution": "Vanderbilt University" + }, + { + "first_name": "Ákos", + "last_name": "Lédeczi", + "institution": "Vanderbilt University" + } + ], + "dblp_key": "conf/oopsla/AgrawalKL03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949346", + "title": "Model driven development: the case for domain oriented programming", + "abstract": "In this paper, we offer an alternative vision for domain driven development (3D). Our approach is model driven and emphasizes the use of generic and specific domain oriented programming (DOP) languages. DOP uses strong specific languages, which directly incorporate domain abstractions, to allow knowledgeable end users to succinctly express their needs in the form of an application computation. Most domain driven development (3D) approaches and techniques are targeted at professional software engineers and computer scientists. We argue that DOP offers a promising alternative. Specifically we are focused on empowering application developers who have extensive domain knowledge as well as sound foundations in their professions, but may not be formally trained in computer science.We provide a brief survey of DOP experiences, which show that many of the best practices such as patterns, refactoring, and pair programming are naturally and ideally practiced in a Model Driven Development (MDD) setting. We compare and contrast our DOP with other popular approaches, most of which are deeply rooted in the OO community.Finally we highlight challenges and opportunities in the design and implementation of such languages.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949346", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dave", + "last_name": "Thomas", + "institution": "BC Research (Canada)" + }, + { + "first_name": "Brian", + "last_name": "Barry", + "institution": "BC Research (Canada)" + } + ], + "dblp_key": "conf/oopsla/ThomasB03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949356", + "title": "A demonstration of JPie: an environment for live software construction in Java", + "abstract": "JPie is a tightly integrated development environment supporting live object-oriented software construction in Java. JPie embodies the notion of a dynamic class whose signature and implementation can be modified at run time, with changes taking effect immediately upon existing instances of the class. The result is complete elimination of the edit-compile-test cycle. JPie users create and modify class definitions through direct manipulation of visual representations of program abstractions. This support is provided without modification of the language or run-time system. In this demonstration, we illustrate central features of JPie through the construction of a sample application. These include dynamic declaration of instance variables and methods, dynamic modification of method bodies and threads, dynamic user interface construction and event handling, and on-the-fly exception handling in JPie's integrated thread-oriented debugger.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949356", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kenneth J.", + "last_name": "Goldman", + "institution": "Washington University in St. Louis" + } + ], + "dblp_key": "conf/oopsla/Goldman03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949387", + "title": "Things they would not teach me of in college: what Microsoft developers learn later", + "abstract": "There has always been a gap between what college graduates in any field are taught and what they need to know to work in industry. However, today the gap in computer science has grown into a chasm. Current college hires who join Microsoft development teams only know a small fraction of their jobs and cannot be trusted to write new code until they have received months of in-depth training. The cause of this growing gap is a fundamental shift in the software industry, which now demands higher quality and greater attention to customer needs. This paper presents five new courses to add to computer science curriculums to help close this gap.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949387", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Brechner", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/Brechner03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949363", + "title": "Generative model transformer", + "abstract": "The Generative Model Transformer (GMT) project is an Open Source initiative to build a Model Driven Architecure™ tool that allows fully customisable Platform Independent Models, Platform Description Models, Texture Mappings, and Refinement Transformations. The project should result in (a) a tool that fulfils the MDA promise for faster/more accurate/better maintainable application development, (b) a tool for industrial use, and (c) MDA related research-which is encouraged and needed. A distinctive feature of GMT is the emphasis of model transformations as \"first-class model citizens\". The implementation of model transformations is envisaged to be in conformance with the future OMG modeling standard for Queries, Views, and Transformations (QVT).", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949363", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jorn", + "last_name": "Bettin", + "institution": "" + }, + { + "first_name": "Ghica van Emde", + "last_name": "Boas", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BettinB03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949368", + "title": "Redeveloping a high-Performance computing framework", + "abstract": "This paper describes our experience in redeveloping an object-oriented system. Experience working with the system along with new requirements that were introduced as the system matured motivated a significant redesign and reimplementation effort. The initial object-oriented design helped to allow extension as well as restructuring of system objects. Experience in integrating new objects into the system and reimplementing objects in different languages drove a refactoring process. The Web interface to the system was reimplemented as a Grid portal.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949368", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Scott", + "last_name": "Spetka", + "institution": "SUNY Polytechnic Institute" + }, + { + "first_name": "George", + "last_name": "Ramseyer", + "institution": "United States Air Force Research Laboratory" + }, + { + "first_name": "Richard", + "last_name": "Linderman", + "institution": "United States Air Force Research Laboratory" + } + ], + "dblp_key": "conf/oopsla/SpetkaRL03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949383", + "title": "MAS-ML: a multi-agent system modeling language", + "abstract": "A multi-agent system modeling language (MAS-ML) that extends the UML (Unified Modeling Language) is proposed here based on a conceptual framework (metamodel) called TAO (Taming Agents and Objects). The most important difference between our approach and others presented in the literature is our clear definition and representation of the abstractions and behavioral features that compose MASs. Extensive experimentation is being used to access the expressiveness of models represented in MAS-ML and the ease to implement a multi-agent system from a specification expressed in our notation.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949383", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Viviane Torres da", + "last_name": "Silva", + "institution": "Pontifical Catholic University of Rio de Janeiro" + }, + { + "first_name": "Carlos", + "last_name": "Lucena", + "institution": "Pontifical Catholic University of Rio de Janeiro" + } + ], + "dblp_key": "conf/oopsla/SilvaL03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949358", + "title": "Reuse learning objects through LOM and XML", + "abstract": "This document describes how the Norwegian education portal (www.utdanning.no) uses XML and the Learning Object Metadata standard (LOM) to integrate existing providers of learning objects into one common search portal. LOM is an IEEE standard (IEEE 1484.12.1) for categorizing and describing learning objects [1].", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949358", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lars Arne", + "last_name": "Skår", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "Heiberg", + "institution": "" + }, + { + "first_name": "Vidar", + "last_name": "Kongsli", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SkarHK03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949364", + "title": "Semantic software engineering tools", + "abstract": "Recently, the paradigm of software engineering has shifted significantly to service orientation based on Web services. Web Services Description Language interface specifications provide sufficient information to physically access a service. However, these interface descriptions are semantically bleak. This work introduces a number of tools, which were developed to augment strict syntactic service descriptions with semantic information in order to elucidate the meaning of processed data and provided functionality. Semantic Web technologies such as DAML+OIL were supplemented with natural language support for usability improvements both at design- and at runtime.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949364", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Paar", + "institution": "Karlsruhe University of Education" + } + ], + "dblp_key": "conf/oopsla/Paar03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949349", + "title": "XAspects: an extensible system for domain-specific aspect languages", + "abstract": "Current general aspect-oriented programming solutions fall short of helping the problem of separation of concerns for several concern domains. Because of this limitation good solutions for these concern domains do not get used and the opportunity to benefit from separation of these concerns is missed. By using XAspects, a plug-in mechanism for domain-specific aspect languages, separation of concerns can be achieved at a level beyond what is possible for object-oriented programming languages. As a result, XAspects allows for certain domain-specific solutions to be used as easily as a new language feature.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949349", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Macneil", + "last_name": "Shonle", + "institution": "University of California, San Diego" + }, + { + "first_name": "Karl", + "last_name": "Lieberherr", + "institution": "Northeastern University" + }, + { + "first_name": "Ankit", + "last_name": "Shah", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/ShonleLS03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949367", + "title": "Using events to debug Java programs backwards in time", + "abstract": "An \"Omniscient Debugger\" works by recording all state changes in the run of a program, and then allowing the programmer to explore the history of that program - effectively going \"backwards in time.\" Event analysis debuggers work by observing events as they occur, and allowing the programmer to write queries which will pause the program when matched - effectively highly sophisticated breakpoints.Recently we have integrated the two techniques to produce an omniscient debugger which can use event queries to search the history of a program interactively. The query mechanism is designed along the lines of an EMACS incremental search, where the query is typed into a \"minibuffer\" at the bottom of the debugger window, and the commands \"next match\" and \"previous match\" are single keystrokes. The result is instantaneous feedback with no danger of missing an interesting state by going too far.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949367", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bil", + "last_name": "Lewis", + "institution": "Menlo School" + }, + { + "first_name": "Mireille", + "last_name": "Ducassé", + "institution": "Institut National des Sciences Appliquées de Rennes" + } + ], + "dblp_key": "conf/oopsla/LewisD03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949348", + "title": "Software factories: assembling applications with patterns, models, frameworks and tools", + "abstract": "The confluence of component based development, model driven development and software product lines forms an approach to application development based on the concept of software factories. This approach promises greater gains in productivity and predictability than those produced by incremental improvements to the current paradigm of object orientation, which have not kept pace with innovation in platform technology. Software factories promise to make application assembly more cost effective through systematic reuse, enabling the formation of supply chains and opening the door to mass customization.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949348", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jack", + "last_name": "Greenfield", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Keith", + "last_name": "Short", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/GreenfieldS03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949375", + "title": "Visual SDLC: improving requirements engineering for object-oriented systems", + "abstract": "In theory, requirements engineering solves many of software engineering's fundamental problems. The stakeholders know what the developers are building, why they are building it, when they are building it, and even to some degree, how they are building it. If requirements engineering resolves some of the basic communication issues between IT and the business, why aren't more companies actively practicing this discipline? In practice, requirements engineering is almost impractical without a commercial automation tool. The critics argue that the current automation tools do not convincingly demonstrate its value proposition, or fulfill the longstanding promises of the leading requirements engineering experts. This paper describes how the enterprise software development lifecycle management solution, Visual SDLC, addresses some of the outstanding issues of the present requirements engineering tools.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949375", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marc", + "last_name": "Raygoza", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Raygoza03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949355", + "title": "Automated impact analysis of object-oriented software systems", + "abstract": "No abstract available.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949355", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael A.", + "last_name": "Hoffman", + "institution": "California State University, Long Beach" + } + ], + "dblp_key": "conf/oopsla/Hoffman03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949389", + "title": "Methodology first and language second: a way to teach object-oriented programming", + "abstract": "C++ is a very successful object-oriented language. It is a required language for more and more students. It takes great effort and practice for these students to learn how to program in C++ and how to make object-oriented programs. One potential failure is that they have learned programming in C++ but do not know how to program in an object-oriented (OO) style. To avoid such failures, this paper proposes that first an object-oriented methodology is taught, and then the language itself. A six-step approach to teach the OO methodology is presented, followed by some innovative ways to teach different mechanisms in C++. In this way, students can master both object-oriented programming and C++ programming. The proposed teaching method is applicable to teaching other languages like Java and C#.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949389", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haibin", + "last_name": "Zhu", + "institution": "Nipissing University" + }, + { + "first_name": "MengChu", + "last_name": "Zhou", + "institution": "New Jersey Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ZhuZ03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949373", + "title": "Variant management for embedded software product lines with pure: : consul and AspectC++", + "abstract": "No abstract available.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949373", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Danilo", + "last_name": "Beuche", + "institution": "" + }, + { + "first_name": "Olaf", + "last_name": "Spinczyk", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + } + ], + "dblp_key": "conf/oopsla/BeucheS03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949362", + "title": "ATCT: a Java framework that offers new approach to developing asynchronous processes", + "abstract": "The development of modern loosely coupled distributed applications requires extensive use of asynchronous processes. The ability to manipulate execution context could simplify development of such applications, helping to separate business logic from handling asynchrony.This paper describes a framework that implements Execution Context Reification for Java Virtual Machine (JVM). The framework uses built-in secondary bytecode interpreter that provides access to Execution Context as a first class serializable object. Asynchronous Transfer of Control Threading (ATCT) mechanism is used to manage the execution process using well-known thread semantics. The framework allows the process to be suspended for unlimited amount of time without locking system threads. Next, the process can be instructed to resume execution from the point where it was stopped. Described approach will allow to simplify development of asynchronous processes by enabling use of sequential programming style.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949362", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Serguei", + "last_name": "Mourachov", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Mourachov03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949354", + "title": "Visualizing and AspectJ-enabling eclipse plugins using bytecode instrumentation", + "abstract": "Bytecode instrumentation can be used effectively to (a) generate visualizations and (b) to modify the behavior of Eclipse plugins. In this demonstration, we will show two independent techniques that have in common that they obtain their results by modifying the binary representation of a given software system. In the first part of the demo, Chris Laffra will show experiments he performed on visualization of Eclipse plugins in the context of the JikesBT project. In the second part of the demo, Martin Lippert will show how to weave aspects into Eclipse plugins without having access to their source.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949354", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chris", + "last_name": "Laffra", + "institution": "IBM (Canada)" + }, + { + "first_name": "Martin", + "last_name": "Lippert", + "institution": "Universität Hamburg" + } + ], + "dblp_key": "conf/oopsla/LaffraL03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949384", + "title": "Aspect-oriented implementation method: progressive or non-progressive approach?", + "abstract": "Object-oriented programming languages provide effective means to achieve better reuse and extensibility levels, which increases development productivity. However, the object-oriented paradigm has several limitations, sometimes leading to tangled code and spread code. For example, business code tangled with presentation code or data access code, and distribution, concurrency control, and exception handling code spread over several classes. This decreases readability, and therefore, system maintainability. Some extensions of the object-oriented paradigm try to correct those limitations allowing reuse and maintenance in practical situations where the original paradigm does not offer an adequate support. However, in order to guarantee that those benefits will be achieved by those techniques it is necessary to use them together with an implementation method. Our objective is to adapt and to analyze an object-oriented implementation method to use aspect-oriented programming in order to implement several concerns to a family of object-oriented system. In particular, we are interested in implementing persistence, distribution, and concurrency control aspects. At the moment we are particularly interested to present some results and get feed back about a performed experiment to identify if and when a progressive approach is better than a non-progressive one. In a progressive approach, persistence, distribution, and concurrency control are not initially considered in the implementation activities, but are gradually introduced, preserving the application's functional requirements. This approach helps in dealing with the inherent complexity of the modern applications, through the support to gradual implementations and tests of the intermediate versions of the application.", + "date": "2003-01-01", + "link": "https://doi.org/10.1145/949344.949384", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sérgio", + "last_name": "Soares", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Paulo", + "last_name": "Borba", + "institution": "Universidade Federal de Pernambuco" + } + ], + "dblp_key": "conf/oopsla/SoaresB03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949390", + "title": "Rethinking computer science education from a test-first perspective", + "abstract": "Despite our best efforts and intentions as educators, student programmers continue to struggle in acquiring comprehension and analysis skills. Students believe that once a program runs on sample data, it is correct; most programming errors are reported by the compiler; when a program misbehaves, shuffling statements and tweaking expressions to see what happens is the best debugging approach. This paper presents a new vision for computer science education centered around the use of test-driven development in all programming assignments, from the beginning of CS1. A key element to the strategy is comprehensive, automated evaluation of student work, in terms of correctness, the thoroughness and validity of the student's tests, and an automatic coding style assessment performed using industrial-strength tools. By systematically applying the strategy across the curriculum as part of a student's regular programming activities, and by providing rapid, concrete, useful feedback that students find valuable, it is possible to induce a cultural shift in how students behave.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949390", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen H.", + "last_name": "Edwards", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/oopsla/Edwards03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949391", + "title": "Using graphics to support the teaching of fundamental object-oriented principles in CS1", + "abstract": "Teaching object-oriented programming in CS1 is hard. Keeping the attention of CS1 students is perhaps even harder. In our experience the former can be done successfully with very satisfying results by focusing on the fundamental principles of object-orientation, such as inheritance, polymorphism and encapsulation. The latter can be done by having students create graphical event-driven programs. Care must be taken, however, since teaching graphics can easily distract students and certainly takes time away from the fundamentals being taught. We use Java as a vehicle for OO instruction, but rather than expose CS1 students to the intricacies of Swing we employ an elegant and small graphics package called NGP. NGP allows students to create event-driven graphical programs using only inheritance and method overriding. We describe how we use NGP to enhance rather than detract from our teaching of fundamental OO principles.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949391", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Carl", + "last_name": "Alphonce", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Phil", + "last_name": "Ventura", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "conf/oopsla/AlphonceV03a", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949382", + "title": "Pattern-based model transformation", + "abstract": "Model Driven Architecture (MDA), which supports the development of software-intensive systems through the transformation of models to executable components and applications, requires a standard way to express transformations. The approach developed by this research focuses on defining pattern-based transformation at the metamodel level. This research has two primary objectives. The first objective is to support systematic application of patterns. The use of patterns as model building blocks (through pattern-based transformations) helps raise the level of abstraction at which systems are developed. The second research objective is to support controlled model evolution by specifying pattern-based transformations at the metamodel level.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949382", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sheena R.", + "last_name": "Judson", + "institution": "Louisiana State University" + } + ], + "dblp_key": "conf/oopsla/Judson03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949372", + "title": "Issues on building T++: a tool for web application development with C++", + "abstract": "As the demand for web applications grows, so does the demand for tools that support them. As a general rule, such tools extend general purpose programming languages, like Servlets/Jsp [2] does for Java [4], or define their own programming language, like PHP [3]. But there is no established engine for web applications written with C++. This work presents technical challenges that were faced when developing T++, an engine that supports web application development with C++.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949372", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Antonio", + "last_name": "Terceiro", + "institution": "Universidade Federal da Bahia" + }, + { + "first_name": "Christina", + "last_name": "Chávez", + "institution": "Universidade Federal da Bahia" + } + ], + "dblp_key": "conf/oopsla/TerceiroC03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949379", + "title": "Metamodel based model transformation language to facilitate domain specific model driven architecture", + "abstract": "The Model Driven Architecture (MDA) can have a greater impact by expanding its scope to Domain Specific MDA (DSMDA). This helps developers to represent their systems using familiar domain concepts. For each DSMDA, a transformer is needed to convert Domain Specific Platform Independent Models (DSPIM-s) to Domain Specific Platform Specific Models (DSPDM-s). Such model transformers are time consuming and error prone to develop and maintain. A high-level specification language to formally specify the behavior of model transformers is required. The language must also have an efficient execution framework. This research proposes to develop such a language and execution framework.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949379", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aditya", + "last_name": "Agrawal", + "institution": "Vanderbilt University" + } + ], + "dblp_key": "conf/oopsla/Agrawal03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949351", + "title": "Domain driven web development with WebJinn", + "abstract": "Web application development cuts across the HTTP protocol, the client-side presentation language (HTML, XML), the server-side technology (Servlets, JSP, ASP, PHP), and the underlying resource (files, database, information system). Consequently, web develop-ment concerns including functionality, presentation, control, and structure cross-cut, leading to tangled and scattered code that is hard to develop, maintain, and reuse. In this paper we analyze the cause, consequence, and remedy for this crosscutting. We dis-tinguish between intra-crosscutting that results in code tangling and inter-crosscutting that results in code scattering. To resolve inter-crosscutting, we present a new web application development model named XP that introduces extension points as place-holders for structure-dependent code. We present another model named DDD that incorporates XP into the Model-View-Controller (MVC)", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949351", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sergei", + "last_name": "Kojarski", + "institution": "Northeastern University" + }, + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/KojarskiL03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949361", + "title": "F-Script: smalltalk scripting for the Mac OS X object system", + "abstract": "F-Script is a Smalltalk-like interactive scripting language based on the Mac OS X object model. F-Script provides scripting and interactive access to Mac OS X frameworks and custom objects. It also introduces an innovative high-level object-oriented programming model based on APL-like array programming principles.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949361", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philippe", + "last_name": "Mougin", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Mougin03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949357", + "title": "Hardware/software codesign in neo smalltalk", + "abstract": "The processors normally used for low cost or embedded applications are not well suited for running Smalltalk, so we created our own using programmable circuits (FPGAs). By creating the software and hardware specifically to work with each other it was possible to simplify both to such a degree that the resulting system is competitive in terms of price/performance compared to solutions with traditional processors, despite the inefficiency of FPGAs relative to custom designs.Both a 16 bit and a 32 bit hardware implementation of Neo Smalltalk were created and illustrate the cost and performance tradeoffs possible in this kind of development. The hardware is defined in terms of objects exchanging messages down to the lowest level, which is an interesting contrast to the traditional bytecoded virtual machines used for Smalltalk, Java and similar languages.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949357", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jecel Mattos de", + "last_name": "Assumpccao", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Assumpccao03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949397", + "title": "A pair-programming experiment in a non-programming course", + "abstract": "Pair programming is a concept where two programmers work side by side at the same computer, writing code jointly. One of them, called the driver, is in control of the keyboard and mouse. The other, called the navigator, observes what the driver is doing and offers advice. It is the driver's job to write the code. The navigator has a chance to observe the larger picture, evaluating the driver's code for correctness of design and implementation. Studies have shown that pair programming is very effective. Two programmers can finish a task in little over half the elapsed time that a single programmer takes. And the quality of the code-measured in terms of absence of defects-is much higher.In the past few years, pair programming has made inroads into industry and into programming courses. However, it has not typically been used in courses that teach subjects other than programming or software engineering, nor has it been used in the analysis of experimental results. This paper reports on an experiment in a combined senior/masters-level computer architecture class, using Hennessy & Patterson's Computer Architecture: A Quantitative Approach as a text. Students were required to implement three projects simulating various aspects of a microarchitecture (cache, branch predictor, dynamic instruction scheduler). Then they engaged in an experimental analysis to find the best configuration in a design space. Students reported high levels of satisfaction with the experience of pair programming. Pair programmers obtained significantly higher grades on Project 1; however, differences on the other projects were not statistically significant.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949397", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Edward F.", + "last_name": "Gehringer", + "institution": "North Carolina State University" + } + ], + "dblp_key": "conf/oopsla/Gehringer03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949392", + "title": "Reality abstraction and OO pedagogy: results from 5 weeks in virtual reality", + "abstract": "A five week program which involved extensive exposure to a complex object-oriented virtual environment was evaluated for efficacy in learning fundamental object-oriented principles. Students (n=57) from two CS1 classes were asked to write essays on their knowledge of object-oriented programming concepts following their participation in the program. A systematic method for evaluating student knowledge was followed by rating the student's knowledge on a one-to-five rating scale. The results indicated that the students understood, by virtue of their ability to write intelligibly, the concepts of abstraction, inheritance and method override. Demonstrated knowledge of the concept of state was far less convincing.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949392", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John F.", + "last_name": "Towell", + "institution": "Carroll University" + }, + { + "first_name": "Elizabeth R.", + "last_name": "Towell", + "institution": "Carroll University" + } + ], + "dblp_key": "conf/oopsla/TowellT03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949385", + "title": "A language based formalism for domain driven development", + "abstract": "The evolution of programming languages (e.g. machine languages, assembly languages and high level languages) has been the driving force for the evolution of software development from the machine-centric to the application-centric. The 4th generation languages (4GLs), languages defined directly by the composition of domain features, serve as the language-based formalism for the emerging Domain Driven Development paradigm. The 4GLs are defined in Two-Level Grammar++ and can be compiled into 3GLs using the 4GL compiler framework.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949385", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wei", + "last_name": "Zhao", + "institution": "University of Alabama at Birmingham" + } + ], + "dblp_key": "conf/oopsla/Zhao03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949371", + "title": "Requirements use case tool (RUT)", + "abstract": "The Requirements Use case Tool (RUT) provides assistance to managers, customers, and developers in assessing the quality of use cases. In addition, RUT serves as a database repository for requirements developed as use cases. To ensure consistency, the tool provides a standard use case template to be used for all use case entry into the repository. Furthermore, RUT provides integration with Rational Rose, the industry-standard tool for developing UML diagrams. The tool also provides a series of metrics useful for calculating information about the relationships among the captured use cases. RUT performs use case evaluation by searching text and identifying risk indicators such as incomplete or weak phrases. The Requirements Use case Tool is a valuable resource for collecting, evaluating, and maintaining software requirements gathered as use cases.RUT is a web-based, multi-user application that provides project team members with the ability to create, view, and modify use cases and related information for a particular project. The \"dashboard\" view provided by the tool gives managers and others the ability to quickly ascertain the status of a project by viewing various use case metrics. The tool was developed using multi-platform, open source technologies (PHP and MySQL).All features of the Requirements Use case Tool described above will be demonstrated at the conference.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949371", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James R.", + "last_name": "McCoy", + "institution": "Goddard Space Flight Center" + } + ], + "dblp_key": "conf/oopsla/McCoy03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949378", + "title": "Static analysis of component systems using behavior protocols", + "abstract": "Static analysis of systems allows to discover errors at design time and to avoid run-time error detection techniques that negatively impact performance of the systems. In this paper, we present the consent operator, which allows (i) to capture errors resulting from incorrect composition of software components, (ii) to test conformance of behavior descriptions and (iii) to analyze whether conditions of a correct dynamic update are satisfied.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949378", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jiřı́", + "last_name": "Adámek", + "institution": "Charles University" + } + ], + "dblp_key": "conf/oopsla/Adamek03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949350", + "title": "The power of symmetry: unifying inheritance and generative programming", + "abstract": "I present the Ohmu language, a unified object model which allows a number of advanced techniques such as aspects, mixin layers, parametric polymorphism, and generative components to be implemented cleanly using two basic concepts: block structure and inheritance. I argue that conventional ways of defining classes and objects have created artificial distinctions which limit their expressiveness. The Ohmu model unifies functions, classes, instances, templates, and even aspects into a single construct - the structure. Function calls, instantiation, aspect-weaving, and inheritance are likewise unified into a single operation - the structure transformation. This simplification eliminates the distinction between classes and instances, and between compile-time and run-time code. Instead of being compiled, programs are reduced using partial evaluation, during which the interpreter is invoked at compile-time. Within this architecture, standard OO inheritance becomes a natural vehicle for creating meta-programs and automatic code generators - the key to a number of recent domain-driven programming methodologies.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949350", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "DeLesley", + "last_name": "Hutchins", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/oopsla/Hutchins03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949365", + "title": "MetaEdit+: defining and using domain-specific modeling languages and code generators", + "abstract": "MetaEdit+ is an environment that allows building modeling tools and generators fitting to application domains, without having to write a single line of code. The capability to define modeling tools and generators is relevant as it provides the ability to raise the abstraction of design work from code to domain concepts, and a raise in abstraction leads to an imminent raise in productivity, as illustrated by the past years' experiences.In domain-specific modeling and MetaEdit+, one expert defines a domain-specific language as a metamodel containing the domain concepts and rules, and specifies the mapping from that to code in a domain-specific code generator. For the method implementation, MetaEdit+ provides a metamodeling language and tool suite for defining the method concepts, their properties, associated rules, symbols, checking reports, and generators. Once the expert defines a modeling method, or even a partial prototype, the rest of the team can start to use it in MetaEdit+ to make models with the modeling language and the required code is automatically generated from those models. Based on the metamodel, MetaEdit+ automatically provides CASE tool functionality: diagramming editors, browsers, generators, multi-user/project/platform support, etc.The MetaEdit+ demo will focus on showing how the domain-specific languages and generators are made; complete with several examples of domain-specific methods and related code generators.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949365", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Juha‐Pekka", + "last_name": "Tolvanen", + "institution": "" + }, + { + "first_name": "Matti", + "last_name": "Rossi", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/TolvanenR03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949388", + "title": "An educational perspective on database management systems and object-oriented methodology: a 12 year journey", + "abstract": "Relational database management systems are an essential component of many data intensive applications. At USC, a course entitled \"File and Database Management\" introduces students to fundamental concepts in relational databases. Students are introduced to conceptual, logical and physical organization of data, use of both formal and commercial query languages, e.g., SQL, indexing techniques for efficient retrieval of data, the concept of a transaction, concurrency control and crash recovery techniques. This paper summarizes our experiences with this course and the challenges of educating students on use of object-oriented concepts and their mapping to tables.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949388", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shahram", + "last_name": "Ghandeharizadeh", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/oopsla/Ghandeharizadeh03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949394", + "title": "ProfessorJ: a gradual introduction to Java through language levels", + "abstract": "In the second-semester programming course at the University of Utah, we have observed that our students suffer unnecessarily from a mismatch between the course content and the programming environment. The course is typical, in that it exposes students to Java a little at a time. The programming environments are also typical, in that they report compilation and run-time errors in the jargon of professional programmers who use the full Java language. As a result, students rely heavily on teaching assistants to interpret error messages, and valuable classroom time is wasted on syntactic diversions.ProfessorJ is our new programming environment that remedies this problem. Like other pedagogical environments, such as BlueJ and DrJava, ProfessorJ presents the student with a simplified interface to the Java compiler and virtual machine. Unlike existing environments, ProfessorJ tailors the Java language and error messages to the students' needs. Since their needs evolve through the course, ProfessorJ offers several language levels, from Beginner Java to Full Java.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949394", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kathryn E.", + "last_name": "Gray", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/oopsla/GrayF03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949396", + "title": "Reuse of teaching components: a UML-based approach to delivering and managing academic courses", + "abstract": "In this paper we present a model for the representation of academic courses based on the organization and semantic relation of reusable teaching components using the unified modeling language. We describe an application of the model to cs101, but we believed that the model can be applied to any subject content of any discipline. Results indicate that by following this model, the knowledge of more experienced teachers can be stored in its representation and the course components are easier to be reused by less experienced teachers.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949396", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luis Palomino", + "last_name": "Ramírez", + "institution": "Tecnológico de Monterrey" + }, + { + "first_name": "Juan Antonio Vega", + "last_name": "Fernández", + "institution": "Tecnológico de Monterrey" + } + ], + "dblp_key": "conf/oopsla/RamirezF03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949411", + "title": "Object-oriented success stories: "learning from our failures"", + "abstract": "Beneath the buzz around methodologies, languages and technologies, the last seventeen years at OOPSLA have seen countless object-oriented success and failure stories, large and small. Last year at OOPSLA there was great enthusiasm over the telling of object-oriented success stories. However, we believe that one often learns more from failures than successes. This fishbowl will provide OOPSLA attendees to bear witness to these failure stories, and tell these tales at last.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949411", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph W.", + "last_name": "Yoder", + "institution": "" + }, + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois System" + }, + { + "first_name": "Steven R.", + "last_name": "Wingo", + "institution": "Southern Company (United States)" + }, + { + "first_name": "Ron", + "last_name": "Jeffries", + "institution": "" + }, + { + "first_name": "Linda", + "last_name": "Rising", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/YoderJWJR03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949412", + "title": "Reuse repositories and reuse: the realities", + "abstract": "This panel (part of the 2003 Onward! program) will discuss libraries, repositories, and reuse. While there is so much hype and noise about repositories and metadata - so little understood about how hard it is to design for reuse and to encourage systematic reuse.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949412", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dave", + "last_name": "Thomas", + "institution": "Carleton University" + }, + { + "first_name": "Brian", + "last_name": "Barry", + "institution": "" + }, + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "" + }, + { + "first_name": "Linda", + "last_name": "Northrop", + "institution": "Software Engineering Institute" + }, + { + "first_name": "Clemens", + "last_name": "Szyperski", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/ThomasBJNS03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949401", + "title": "Routine run-time code generation", + "abstract": "Run-time code generation (RTCG) would be used routinely if application programmers had a facility with which they could easily create their own run-time code generators, because it would offer benefits both in terms of the efficiency of the code that programmers would produce and the ease of producing it. Such a facility would necessarily have the following properties: it would not require that programmers know assembly language; programmers would have full control over the generated code; the code generator would operate entirely at the binary level. In this paper, we offer arguments and examples supporting these assertions. We briefly describe Jumbo, a system we have built for producing run-time code generators for Java..", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949401", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sam", + "last_name": "Kamin", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/Kamin03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949398", + "title": "A framework for building language interpreters", + "abstract": "This work presents an Object-Oriented framework for the implementation of language interpreters in an educational context. We use this framework to implement different programming language paradigms, including interpreters for the Functional, Object-Oriented and Logic paradigms. This framework focuses its structure on aiding the comprehension of the similarities and differences between the implementation of different paradigms.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949398", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alan Mitchell", + "last_name": "Durham", + "institution": "Universidade de São Paulo" + }, + { + "first_name": "Edson", + "last_name": "Sussumu", + "institution": "Universidade de São Paulo" + }, + { + "first_name": "Arlindo Flávio da", + "last_name": "Conceição", + "institution": "Universidade de São Paulo" + } + ], + "dblp_key": "conf/oopsla/DurhamSC03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949414", + "title": "Application servers: one size fits all ... not?", + "abstract": "In the beginning there was machine language, followed by assembly language, formula translation, and eventually procedural programming, to organize the chaos. And then objects were introduced, to hide information. Soon Client/Server and multi-tier applications were conceived to separate data concerns from business logic concerns and user interface concerns. Later, these objects were distributed geographically to optimize hardware resources. And now, we have application servers, to simplify scaling up a system for large volumes, improved response times, impeccable reliability, and high availability. Application servers house the business logic, operating on data from a different server, and responding to requests from any source. But these Application Servers come in all shapes, flavors, and sizes. What is a developer to do? This panel will explore issues comparing application server technologies and questions about their appropriate use in different contexts.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949414", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gail E.", + "last_name": "Harris", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Leibs", + "institution": "Oracle (United States)" + }, + { + "first_name": "Jeromy", + "last_name": "Carrière", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Fred", + "last_name": "Nagy", + "institution": "Contextual Change (United States)" + }, + { + "first_name": "John", + "last_name": "Crupi", + "institution": "Oracle (United States)" + }, + { + "first_name": "Martin", + "last_name": "Nally", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/HarrisLCNCN03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949405", + "title": "Meeting the challenge of software engineering education for working professionals in the 21st century", + "abstract": "Software engineering education for working professionals remains a challenge from the perspective of determining relevant content; identifying effective methods for delivery; and maintaining the focus and motivation of students. This panel brings together academic and industry professionals to share their perspectives and experiences. Anticipated points for discussion include: education/training delivery strategies, curriculum definition, certification challenges, marketing issues, collaboration strategies to engage industry sponsorship, value assessments for students and sponsoring organizations, and program success stories. This will be a highly interactive panel and the audience should come prepared to both ask and answer questions.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949405", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "" + }, + { + "first_name": "Ray", + "last_name": "Bareiss", + "institution": "University of the West" + }, + { + "first_name": "Barry", + "last_name": "Boehm", + "institution": "" + }, + { + "first_name": "Mark", + "last_name": "Hayes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Laura", + "last_name": "Hill", + "institution": "Oracle (United States)" + }, + { + "first_name": "Gabby", + "last_name": "Silberman", + "institution": "IBM (United States)" + }, + { + "first_name": "Dave", + "last_name": "Thomas", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/FraserBBHHST03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949395", + "title": "Preparing undergraduate students for Java certification", + "abstract": "Java certification promises to make our students more marketable once they graduate. The truth is that certifications in general offer significant advantages, but it is important not to overestimate their benefits. In this paper, we describe our experiences on teaching a workshop aimed at preparing undergraduate students for the Sun Certified Java Programmer exam. But first, we layout the real value of IT certifications and explain the different certification options available for Java technology.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949395", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ariel", + "last_name": "Ortiz", + "institution": "Tecnológico de Monterrey" + } + ], + "dblp_key": "conf/oopsla/Ortiz03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949407", + "title": "Discipline and practices of TDD: (test driven development)", + "abstract": "This panel brings together practitioners with experience in Agile and XP methodologies to discuss the approaches and benefits of applying Test Driven Development (TDD). The goal of TDD is clean code that works. The mantra of TDD is: write a test; make it run; and make it right. Open questions to be addressed by the panel include: - How are TDD approaches to be applied to databases, GUIs, and distributed systems? What are the quantitative benchmarks that can demonstrate the value of TDD, and what are the best approaches to solve the ubiquitous issue of scalability.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949407", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "" + }, + { + "first_name": "Dave", + "last_name": "Astels", + "institution": "" + }, + { + "first_name": "Kent", + "last_name": "Beck", + "institution": "Asante Three Rivers Medical Center" + }, + { + "first_name": "Barry", + "last_name": "Boehm", + "institution": "" + }, + { + "first_name": "John D.", + "last_name": "McGregor", + "institution": "Clemson University" + }, + { + "first_name": "James", + "last_name": "Newkirk", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Charlie", + "last_name": "Poole", + "institution": "Poole Hospital" + } + ], + "dblp_key": "conf/oopsla/FraserABBMNP03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949381", + "title": "A framework for using component redundancy for self-adapting and self-optimising component-based enterprise systems", + "abstract": "We propose a framework that uses component redundancy for enabling self-adaptation, self-optimisation and self-healing capabilities in component-based enterprise software systems.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949381", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ada", + "last_name": "Diaconescu", + "institution": "Dublin City University" + } + ], + "dblp_key": "conf/oopsla/Diaconescu03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949402", + "title": "Acceptability-oriented computing", + "abstract": "We discuss a new approach to the construction of software systems. Instead of attempting to build a system that is as free of errors as possible, the designer instead identifies key properties that the execution must satisfy to be acceptable to its users. Together, these properties define the acceptability envelope of the system: the region that it must stay within to remain acceptable. The developer then augments the system with a layered set of components, each of which enforces one of the acceptability properties. The potential advantages of this approach include more flexible, resilient systems that recover from errors and behave acceptably across a wide range of operating environments, an appropriately prioritized investment of engineering resources, and the ability to productively incorporate unreliable components into the final software system.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949402", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Rinard03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949417", + "title": "Time conscious objects: a domain-specific framework and generator", + "abstract": "In most business software systems the time dimension of business objects plays a significant role. Time is a crosscutting concern that is hard to separate from other business logic. We have developed a toolkit that allows existing business application systems to be extended with \"time-conscious\" behavior in a non-intrusive way by factoring out all aspects of time-related behavior into a framework and a set of classes that is distinct from the existing code base. The Time Conscious ObjectsTM (TCOTM) toolkit is currently implemented in JavaTM, but through the use of generation technology the toolkit can easily be made available in any language that supports polymorphism.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949417", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jorn", + "last_name": "Bettin", + "institution": "" + }, + { + "first_name": "Jeff", + "last_name": "Hoare", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BettinH03a", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949408", + "title": "Innovate!", + "abstract": "Freedom to innovate is one of the key motivators for many technical workers. Unfortunately, although innovation is often trumpeted as a key company attribute, it seems that many organizations struggle to provide the necessary environment - even those organizations whose original claim to fame lay in their ability to innovate. This panel will look at the barriers to innovation that occur in a variety of environments: large, well-established organizations, start-ups, academia, standards bodies and the open source community. Panelists will propose a set of technical and non-technical techniques that can be used to foster innovation in even the most lethargic or hostile environment.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949408", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Laura", + "last_name": "Hill", + "institution": "Microsystems (United Kingdom)" + }, + { + "first_name": "Dick", + "last_name": "Gabriel", + "institution": "Microsystems (United Kingdom)" + }, + { + "first_name": "Harlan", + "last_name": "Sexton", + "institution": "" + }, + { + "first_name": "Kevin", + "last_name": "Tyson", + "institution": "" + }, + { + "first_name": "D. R. F.", + "last_name": "West", + "institution": "New Mexico Highlands University" + } + ], + "dblp_key": "conf/oopsla/HillGSTW03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949403", + "title": "No name: just notes on software reuse", + "abstract": "In the beginning, so our myths and stories tell us, the programmer created the program from the eternal nothingness of the void. In this essay, we recognise that programs these days are like any other assemblage, and suggest that in fact programming has always been about reuse. We also explore the nature of reuse, and claim that Components themselves are not the most important consideration for reuse; it is the end product, the composition. The issues still involve value, investment, and return. But pervasive reuse promotes a change in the method of construction of the program, and in the program itself.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949403", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert", + "last_name": "Biddle", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Angela", + "last_name": "Martin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/oopsla/BiddleMN03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949419", + "title": "Generative model transformer: an open source MDA tool initiative", + "abstract": "The Generative Model Transformer (GMT) project is an Open Source initiative to build a Model Driven ArchitecureTM tool that allows fully customisable Platform Independent Models, Platform Description Models, Texture Mappings, and Refinement Transformations. The project should result in (a) a tool that fulfils the MDA promise for faster/more accurate/better maintainable application development, (b) a tool for industrial use, and (c) MDA related research-which is encouraged and needed. A distinctive feature of GMT is the emphasis of model transformations as \"first-class model citizens\". The implementation of model transformations is envisaged to be in conformance with the future OMG modeling standard for Queries, Views, and Transformations (QVT).", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949419", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jorn", + "last_name": "Bettin", + "institution": "" + }, + { + "first_name": "Ghica van Emde", + "last_name": "Boas", + "institution": "" + }, + { + "first_name": "Edward D.", + "last_name": "Willink", + "institution": "Thales (France)" + } + ], + "dblp_key": "conf/oopsla/BettinBW03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949413", + "title": "What's so eXtreme about doing things right?", + "abstract": "Methods are advocated as a way of producing better software. Advocates of agile methods suggest that practices such as keeping in close communication with your customers, frequent integration, and frequent assessment of project status will enable us to produce software that has value for the customer - quality software. It's hard to argue with that. But why is this any different than simply software development practice? Why does saying Scrum Agile or XP grab peoples' attention? Why does it take a name for useful practices to be accepted.This panel will help us understand the role of hype in getting useful practices accepted or rejected. We will explore why it is that these good ideas have not been more widely used. Some of the questions that the panel and the audience will explore are: Why do we ignore proven practices until we see them packaged as a method? Can we do something different in the workplace or in school to teach these practices? Or is it the case that these practices are not universally good?This panel talks about agility in a different context than what is typical: we won't just discuss what agile practices are. We will explore why they are not more widely adopted, especially when not packaged as part of a named method like XP. And we will discuss why projects suffer even when the methods that can help them are well known. This panel will provide an entertaining and thought provoking forum for discussing an issue that is ever present in the world of technology: the role of hype. We concentrate on agile practices, moving beyond simply enumerating them, to discussing why they are not more widely adopted.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949413", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steve", + "last_name": "Berczuk", + "institution": "" + }, + { + "first_name": "Neil B.", + "last_name": "Harrison", + "institution": "Avaya (Bermuda)" + }, + { + "first_name": "Kevlin", + "last_name": "Henney", + "institution": "" + }, + { + "first_name": "Joshua", + "last_name": "Kerievsky", + "institution": "" + }, + { + "first_name": "Linda", + "last_name": "Rising", + "institution": "" + }, + { + "first_name": "Ken", + "last_name": "Schwaber", + "institution": "Advanced Defence Materials (United Kingdom)" + }, + { + "first_name": "Bobby", + "last_name": "Woolf", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/BerczukHHKRSW03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949425", + "title": "*J: a tool for dynamic analysis of Java programs", + "abstract": "We describe a complete system for gathering, computing and presenting dynamic metrics from Java programs. The system itself was motivated from our real goals in understanding program behaviour as compiler/runtime developers, and so solves a number of practical and difficult problems related to metric gathering and analysis.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949425", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bruno", + "last_name": "Dufour", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + }, + { + "first_name": "Clark", + "last_name": "Verbrugge", + "institution": "McGill University" + } + ], + "dblp_key": "conf/oopsla/DufourHV03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949427", + "title": "Extracting domain- specific and domain-independent patterns", + "abstract": "There are no mature guidelines or methodologies exist for extracting patterns. Software Stability Model [2] can provide a base for extracting patterns. This poster presents the concept of extracting both domain-specific and domain- independent patterns from systems that are built using software stability concepts.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949427", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haitham S.", + "last_name": "Hamza", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Ahmed", + "last_name": "Mahdy", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Mohamed E.", + "last_name": "Fayad", + "institution": "San Jose State University" + }, + { + "first_name": "Marshall", + "last_name": "Cline", + "institution": "MTS Systems (United States)" + } + ], + "dblp_key": "conf/oopsla/HamzaMFC03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949428", + "title": "An approach to monitor application states for self-managing (autonomic) systems", + "abstract": "Autonomic Computing has gained widespread attention over the last few years for its vision of developing applications with autonomic or self-managing behaviors[1]. One of the most important aspects of building autonomic systems is the ability to monitor applications and generate corrective actions should exceptions occur. The problem lies in those applications where source code is not available and therefore it is virtually impossible to modify the application code to include monitoring functions, or the application code is too tangled with other components which make modification difficult. This hinders the inclusion of autonomic features in many of the legacy applications. In this report, we will describe an approach to build generic monitoring systems for legacy applications.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949428", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hoi", + "last_name": "Chan", + "institution": "IBM (United States)" + }, + { + "first_name": "Trieu C.", + "last_name": "Chieu", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/ChanC03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949423", + "title": "Dynamically updatable component-based system (DUCS)", + "abstract": "We present our framework called DUCS. DUCS supports on-the-fly updates of distributed component-based applications. DUCS has a layered architecture running on top of a virtual machine extended with a support for object unload and replacement. DUCS is a meta-level framework, so the impact on the application's implementation is minimal. It supports dynamic component replacement, state transfer among components, interface modifications, and automatic propagation of updates. The framework is expandable and can be applied to many programming languages as well as many hardware platforms.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949423", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert", + "last_name": "Bialek", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/oopsla/Bialek03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949416", + "title": "Visualizing class interfaces with formal concept analysis", + "abstract": "Our research promotes the use of a mathematical concept lattice as a novel visualization of the interfaces of Java classes. The binary relation of accesses between methods and fields, from which the lattice is constructed, serves as a heuristic for an automatic feature categorization. We demonstrate in a detailed real-life case study that such a lattice is valuable for understanding and reverse-engineering purposes, in that it helps reason about the interface and structure of the class and find errors in the absence of source code. We also show that if the source code of the class is available, then the lattice can be of assistance in selecting an efficient reading order.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949416", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Uri", + "last_name": "Dekel", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yossi", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/DekelG03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949421", + "title": "Implications of test-driven development: a pilot study", + "abstract": "A Spring 2003 experiment examines the claims that test-driven development or test-first programming improves software quality and programmer confidence. The results indicate support for these claims and inform larger future experiments.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949421", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Reid", + "last_name": "Kaufmann", + "institution": "" + }, + { + "first_name": "David S.", + "last_name": "Janzen", + "institution": "Bethel College - Kansas" + } + ], + "dblp_key": "conf/oopsla/KaufmannJ03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949432", + "title": "A modular QoS-enabled load management framework for component-based middleware", + "abstract": "We present a new QoS-enabled load management framework for component oriented middleware. It offers the possibility of selecting the optimal load distribution algorithms and changing the load metrics at runtime. The QoS service level agreements are made at user level, transparent to the managed application.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949432", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Octavian", + "last_name": "Ciuhandu", + "institution": "Dublin City University" + }, + { + "first_name": "John", + "last_name": "Murphy", + "institution": "Dublin City University" + } + ], + "dblp_key": "conf/oopsla/CiuhanduM03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949422", + "title": "Agile software development for component based software engineering", + "abstract": "Agile Software Development and Component Based Software Engineering are two fundamentally different methods to serve today's demands of software engineering. By combining the technical and organizational issues, we introduce an approach for a consequent integration to allow agile component development in the small and system engineering in the large, respectively.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949422", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wolfgang", + "last_name": "Radinger", + "institution": "TU Wien" + }, + { + "first_name": "Karl M.", + "last_name": "Goeschka", + "institution": "Frequentis (Austria)" + } + ], + "dblp_key": "conf/oopsla/RadingerG03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949409", + "title": "Model driven architecture: how far have we come, how far can we go?", + "abstract": "Model Driven Architecture (MDA) is a technology that has been in the process of evolution for many years. Today, many vendors are now producing products that support MDA. We are hearing more and more success stories that indicate that this technology is the \"real deal\". But, with the failed promises of CASE in the late 1980's, many people still have questions about how much of an application can really be generated from models and constraint languages. Is MDA really capable of generating enterprise applications? What are the technologies are available to implement MDA? This panel examines the technologies and tools behind Model Driven Architecture. Each panelist has been intricately involved in building the underlying foundations of Model Driven Architecture and implementation.There are many possible implementations of MDA including action semantics and the object constraint language. This panel will examine: What is the future of MDA? Will the \"model driven\" approach replace \"high-level\" languages as \"high-level\" languages replaced assembly languages? What are the challenges with using an MDA approach? How can a project get started using MDA?", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949409", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "G. G.", + "last_name": "Miller", + "institution": "Westmorland General Hospital" + }, + { + "first_name": "Andy", + "last_name": "Evans", + "institution": "" + }, + { + "first_name": "Ivar", + "last_name": "Jacobson", + "institution": "" + }, + { + "first_name": "Henrik", + "last_name": "Jondell", + "institution": "Westmorland General Hospital" + }, + { + "first_name": "Allan", + "last_name": "Kennedy", + "institution": "Carter Center" + }, + { + "first_name": "Stephen J.", + "last_name": "Mellor", + "institution": "" + }, + { + "first_name": "Dave", + "last_name": "Thomas", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MillerEJJKMT03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949435", + "title": "A metamodeling approach to model transformation", + "abstract": "The Model Driven Architecture (MDA) is a framework that is intended to support the development of software-intensive systems through the transformation of models to executable components and applications. A key facilitator of the MDA is a standard to express model transformations. This poster describes a rigorous approach to modeling pattern-based transformations at the metamodel level.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949435", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sheena R.", + "last_name": "Judson", + "institution": "Louisiana State University" + }, + { + "first_name": "Doris L.", + "last_name": "Carver", + "institution": "Louisiana State University" + }, + { + "first_name": "Robert B.", + "last_name": "France", + "institution": "Colorado State University" + } + ], + "dblp_key": "conf/oopsla/JudsonCF03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949429", + "title": "Model driven architecture development approach for pervasive computing", + "abstract": "This paper describes a model-based development approach for pervasive computing applications. The key concept introduced is the use of the Model Driven Architecture (MDA) for development of system families.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949429", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kai", + "last_name": "Hemme-Unger", + "institution": "Daimler (Germany)" + }, + { + "first_name": "Thomas", + "last_name": "Flór", + "institution": "Daimler (Germany)" + }, + { + "first_name": "Gabriel", + "last_name": "Vögler", + "institution": "Daimler (Germany)" + } + ], + "dblp_key": "conf/oopsla/Hemme-UngerFV03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949420", + "title": "Dynamic personal roles for ubiquitous computing", + "abstract": "This paper presents doctoral research on a key problem for ubiquitous computing: implementation of representatives for physical objects, particularly people. This poster outlines an approach to implementing dynamic personal roles suitable for a ubiquitous computing environment.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949420", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert E.", + "last_name": "McGrath", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "M. Dennis", + "last_name": "Mickunas", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/McGrathM03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949406", + "title": "Xtreme programming and agile coaching", + "abstract": "This panel brings together coaches to discuss all aspects of the practice - how to become a coach, choosing a coach, and describing what is to be an (in) effective coach. A coach watches, provides feedback, and suggests subtle direction. The coach may be more - for example - an architect or team lead. The panelists will describe their positions and offer feedback. Panelists were asked to offer responses to three questions:", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949406", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "" + }, + { + "first_name": "Rachel", + "last_name": "Reinitz", + "institution": "IBM (United States)" + }, + { + "first_name": "Jutta", + "last_name": "Eckstein", + "institution": "" + }, + { + "first_name": "Joshua", + "last_name": "Kerievsky", + "institution": "" + }, + { + "first_name": "Rob", + "last_name": "Mee", + "institution": "Pivotal (Canada)" + }, + { + "first_name": "Mary", + "last_name": "Poppendieck", + "institution": "Digital Research Alliance of Canada" + } + ], + "dblp_key": "conf/oopsla/FraserREKMP03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949410", + "title": "Agile management - an oxymoron?: who needs managers anyway?", + "abstract": "\"Self-directed team\" is one of the mantras of Agile Methodologies. Self-direction means that the team's manager is relegated to a facilitator role with little or no influence over day-to-day activities. For example, Kent Beck has written that the manager of an XP project can do four things: ask for estimates on cost and results, move people around among projects, ask for status reports, and cancel the project. Agile literature in general says that managers shouldn't be directly involved in analysis, design, coding, testing or integration. They may (but only occasionally!) facilitate the process between the customer and the developers - and it would be nice if they provided food and toys to keep the team happy. It appears, then, that the agile manger is expected to hover on the fringes of a project asking a few questions and throwing in goodies - but with ultimate power (cancellation) in her hip pocket.This scenario makes one wonder. Do managers really matter to the success of an agile project? Are they superfluous? What happens when managers step over the prescribed line - does it mean that the end of Agile Methodology as we know it and as handed down by the Agile Manifesto? The panel will explore this ticklish terrain by answering the following questions.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949410", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lougie", + "last_name": "Anderson", + "institution": "" + }, + { + "first_name": "Glen B.", + "last_name": "Alleman", + "institution": "Hill Engineering (United States)" + }, + { + "first_name": "Kent", + "last_name": "Beck", + "institution": "Asante Three Rivers Medical Center" + }, + { + "first_name": "Joe", + "last_name": "Blotner", + "institution": "" + }, + { + "first_name": "Ward", + "last_name": "Cunningham", + "institution": "" + }, + { + "first_name": "Mary", + "last_name": "Poppendieck", + "institution": "" + }, + { + "first_name": "Rebecca", + "last_name": "Wirfs-Brock", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/AndersonABBCPW03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949433", + "title": "An AspectJ-enabled eclipse core runtime platform", + "abstract": "Separation of concerns and modularity are key elements of software engineering. The work described here presents a combination of two proven techniques that help improve both of these elements: the Eclipse Core Runtime Platform, which introduces plugins to Java programming as a kind of module concept on top of packages, and aspect-oriented programming using AspectJ, which aims to improve the modularity of crosscutting concerns. The work presents a combination of these two technologies in an AspectJ-enabled version of the Eclipse Core Runtime Platform. Unlike the standard implementation of the Eclipse Core Runtime Platform, the AspectJ-enabled implementation allows aspects to modularize crosscutting concerns beyond the boundaries of plugins (without the need for recompilation across plugins). It allows crosscutting concerns to be modularized by means of aspects and plugins while using the enhanced but compatible version of the Eclipse Core Runtime Platform as promoted by the Eclipse project.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949433", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Lippert", + "institution": "Universität Hamburg" + } + ], + "dblp_key": "conf/oopsla/Lippert03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949424", + "title": "MAS-ML: a multi-agent system modeling language", + "abstract": "A multi-agent system modeling language (MAS-ML) that extends the UML (Unified Modeling Language) is proposed here based on a conceptual framework (metamodel) called TAO (Taming Agents and Objects). The most important difference between our approach and others presented in the literature is our clear definition and representation of the abstractions and behavioral features that compose MASs.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949424", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Viviane Torres da", + "last_name": "Silva", + "institution": "Pontifical Catholic University of Rio de Janeiro" + }, + { + "first_name": "Carlos", + "last_name": "Lucena", + "institution": "Pontifical Catholic University of Rio de Janeiro" + } + ], + "dblp_key": "conf/oopsla/SilvaL03a", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949430", + "title": "A framework to enable user directed component binding at run-time", + "abstract": "No abstract available.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949430", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Timothy J.", + "last_name": "Troup", + "institution": "University of Glasgow" + }, + { + "first_name": "Iain", + "last_name": "Darroch", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/oopsla/TroupD03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949448", + "title": "Metamodel based model transformation language", + "abstract": "The Model Driven Architecture (MDA) can have a greater impact by expanding its scope to Domain Specific MDA (DSMDA). DSMDA is the use of MDA for a particular domain. This helps developers to represent their systems using familiar domain concepts. For each DSMDA, a transformer is needed to convert Domain Specific Platform Independent Models (DSPIM -s) to Domain Specific Platform Specific Models (DSPDM-s). Such model transformers are time consuming and error prone to develop and maintain. Hence, a high-level specification language to formally specify the behavior of model transformers is required. The language must also have an execution framework, which can be used to execute the specifications in the language. This research proposes to develop such a language and execution framework that will help to considerably speed-up the development time for model transformers.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949448", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aditya", + "last_name": "Agrawal", + "institution": "Vanderbilt University" + } + ], + "dblp_key": "conf/oopsla/Agrawal03a", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949434", + "title": "A stable software model for MRI visual analyzer", + "abstract": "Selection of proper analysis and design methods is crucial to produce cost and time efficient applications. Effective strategies help developers to come up with more stable, reusable, and complete applications, which is the main purpose of software management. In order to express the importance of proper analysis and design methods, this poster compares two different modeling methods: traditional object oriented and software stability. The modeling methods are utilized for development of the same application: MRI visual analyzer (MRIVA).MRIVA is a computer application to help doctors gain a better understanding of Magnetic resonance image (MRI) pictures. It provides them the opportunity to access variant parts of the organ and study it from different points of view. The current poster shows the result of both methods; however, it is evident that SSM model is simpler and more complete. It offers a firm base for later reuses and is stable under changes over time or application area.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949434", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "E.", + "last_name": "Yavari", + "institution": "Santa Clara University" + }, + { + "first_name": "Mohamed E.", + "last_name": "Fayad", + "institution": "San Jose State University" + } + ], + "dblp_key": "conf/oopsla/YavariF03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949441", + "title": "Five years of framework building: lessons learned", + "abstract": "When developing large software systems, it is often difficult to foresee exactly which trade-offs are important, and which quality parameters will be of importance down the road. This paper reports experiences from a project in which a large application framework for B2B integration has been continuously developed and used over a five-year period. The framework has been the foundation for a variety of different concrete applications. Here we will report on our experiences from this endeavor.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949441", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kurt", + "last_name": "Madsen", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Madsen03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949436", + "title": "Multicodes: optimizing virtual machines using bytecode sequences", + "abstract": "A virtual machine optimization technique that makes use of bytecode sequences is introduced. The process of determining candidate sequences is discussed and performance gains achieved when applied to a Java interpreter are presented. The suitability of this optimization for JVMs that perform just-in-time compilation is also discussed.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949436", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben", + "last_name": "Stephenson", + "institution": "Western University" + }, + { + "first_name": "Wade", + "last_name": "Holst", + "institution": "Western University" + } + ], + "dblp_key": "conf/oopsla/StephensonH03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949431", + "title": "Teaching software testing: automatic grading meets test-first coding", + "abstract": "A new approach to teaching software testing is proposed: students use test-driven development on programming assignments, and an automated grading tool assesses their testing performance and provides feedback. The basics of the approach, screenshots of the sytem, and a discussion of industrial tool use for grading Java programs are discussed.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949431", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen H.", + "last_name": "Edwards", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/oopsla/Edwards03a", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949440", + "title": "Using AspectJ for component integration in middleware", + "abstract": "This report discusses experiences applying AspectJ [1] to modularize crosscutting concerns in a middleware product line at IBM®. Aspect oriented programming techniques were used to cleanly separate platform specific facilities for aspects such as error handling, performance monitoring and logging from base components, permitting those components to be reused in multiple environments. The initiative also guided the design of the AspectJ Development Tools (AJDT) for Eclipse, and influenced the technical direction of the AspectJ implementation.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949440", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adrian", + "last_name": "Colyer", + "institution": "IBM (United Kingdom)" + }, + { + "first_name": "Andy", + "last_name": "Clement", + "institution": "IBM (United Kingdom)" + }, + { + "first_name": "Ron", + "last_name": "Bodkin", + "institution": "" + }, + { + "first_name": "Jim", + "last_name": "Hugunin", + "institution": "Palo Alto Research Center" + } + ], + "dblp_key": "conf/oopsla/ColyerCBH03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949438", + "title": "Experience in developing the urbanSim system: tools and processes", + "abstract": "No abstract available.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949438", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bjorn", + "last_name": "Freeman‐Benson", + "institution": "University of Washington" + }, + { + "first_name": "Alan", + "last_name": "Borning", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/Freeman-BensonB03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949446", + "title": "Analyzing the use of interfaces in large OO projects", + "abstract": "Using partial interfaces, i.e. interfaces that cover only a subset of the total set of published methods of a class, has several advantages, among them being an increase in understandability of the code and extended substitutability of classes in frameworks. However, analysis of large frameworks such as the Java API suggests that partial interfaces are only sparsely used. We believe that this is partly due to the fact that introducing and maintaining partial interfaces is perceived as tedious by programmers [5]. Therefore, we have created a metrics suite and tool support to assist the developer in using partial interfaces.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949446", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philip", + "last_name": "Mayer", + "institution": "Leibniz University Hannover" + } + ], + "dblp_key": "conf/oopsla/Mayer03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949444", + "title": "The parks PDA: a handheld device for theme park guests in squeak", + "abstract": "The Parks PDA is a lightweight, handheld device for theme park guests that functions as a combination guidebook, map, and digital camera. Together with a small team of artists and designers, we created a prototype Parks PDA and content for a three hour guest experience, including a camera interface, a hyper-linked guide book, three games, an animal spotters guide, a cross-referenced map, animated movies with lip-synched sound, a ride reservation system, and more. Over 800 visitors to Disney's Animal Kingdom™ theme park tested the Parks PDA over a two week period.Developing the software for this test posed a number of challenges. The processor and memory of the target device were slow, the screen was small, and we had only three months of development time.We attacked these problems using Squeak, a highly-portable, open source Smalltalk implementation. We ported Squeak to the target device and used it to provide nearly bit-identical behavior across four different platforms. This supported a cross-platform development style that streamlined the production of both software and content. We created a tiny user interface and application framework for pen-based devices and implemented a simple card-stack media editor and player using it. We isolated and addressed several challenging performance issues.The project was completed on time and guest response was favorable. Looking back, we can identify seven aspects of Squeak that contributed to the success of the project. In fact, we feel that Squeak was the ideal tool for this job.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949444", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yoshiki", + "last_name": "Ohshima", + "institution": "" + }, + { + "first_name": "John", + "last_name": "Maloney", + "institution": "Human Media" + }, + { + "first_name": "Andy", + "last_name": "Ogden", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/OhshimaMO03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949400", + "title": "Beyond AOP: toward naturalistic programming", + "abstract": "Software understanding for documentation, maintenance or evolution is one of the longest-standing problems in Computer Science. The use of \"high-level\" programming paradigms and object-oriented languages helps, but fundamentally remains far from solving the problem. Most programming languages and systems have fallen prey to the assumption that they are supposed to capture idealized models of computation inspired by deceptively simple metaphors such as objects and mathematical functions. Aspect-oriented programming languages have made a significant breakthrough by noticing that, in many situations, humans think and describe in crosscutting terms. In this paper we suggest that the next breakthrough would require looking even closer to the way humans have been thinking and describing complex systems for thousand of years using natural languages. While natural languages themselves are not appropriate for programming, they contain a number of elements that make descriptions concise, effective and understandable. In particular, natural languages referentiality is a key factor in supporting powerful program organizations that can be easier understood by humans.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949400", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cristina Videira", + "last_name": "Lopes", + "institution": "University of California, Irvine" + }, + { + "first_name": "Paul", + "last_name": "Dourish", + "institution": "University of California, Irvine" + }, + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "Northeastern University" + }, + { + "first_name": "Karl", + "last_name": "Lieberherr", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/LopesDLL03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949443", + "title": "Programming with non-heap memory in the real time specification for Java", + "abstract": "The Real-Time Specification for Java (RTSJ) provides facilities for deterministic, real-time execution in a language that is otherwise subject to variable latencies in memory allocation and garbage collection. A major consequence of these facilities is that the normal Java practice of passing around references to objects in heap memory cannot be used in hard real-time activities. Instead, designers must think carefully about what type of non-heap memory to use and how to transfer data between components without violating RTSJ's memory-area assignment rules. This report explores the issues of programming with non-heap memory from a practitioner's view in designing and programming real-time control loops using a commercially available implementation of the RTSJ.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949443", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Greg", + "last_name": "Bollella", + "institution": "Oracle (United States)" + }, + { + "first_name": "Tim", + "last_name": "Canham", + "institution": "California Institute of Technology" + }, + { + "first_name": "Vanessa", + "last_name": "Carson", + "institution": "California Institute of Technology" + }, + { + "first_name": "Virgil", + "last_name": "Champlin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Daniel", + "last_name": "Dvorak", + "institution": "California Institute of Technology" + }, + { + "first_name": "Brian", + "last_name": "Giovannoni", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Mark", + "last_name": "Indictor", + "institution": "California Institute of Technology" + }, + { + "first_name": "K.", + "last_name": "Meyer", + "institution": "California Institute of Technology" + }, + { + "first_name": "Alex", + "last_name": "Murray", + "institution": "California Institute of Technology" + }, + { + "first_name": "Kirk", + "last_name": "Reinholtz", + "institution": "California Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/BollellaCCCDGIMMR03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949442", + "title": "Agile regression testing using record & playback", + "abstract": "There are times when it is not practical to hand-script automated tests for an existing system before one starts to modify it (whether to refactor it to permit automated testing or to add new functionality). In these circumstances, the use of \"record & playback\" testing may be a viable alternative to handwriting all the tests.This paper describes experiences using this approach and summarizes key learnings applicable to other projects.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949442", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gerard", + "last_name": "Meszaros", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Meszaros03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949418", + "title": "An introduction to fly: a smaller smalltalk", + "abstract": "Fly is a lightweight version of the Smalltalk programming environment. Fly attempts to preserve the benefits of Smalltalk as a development system while making it feasible to develop applications for embedded systems, PDAs, and other limited resource environments. Here we introduce the Fly project and its current and expected results.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949418", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Wrensch", + "institution": "University of the Pacific" + }, + { + "first_name": "Jonathan", + "last_name": "Schifman", + "institution": "University of the Pacific" + } + ], + "dblp_key": "conf/oopsla/WrenschS03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949439", + "title": "Experiences using an ODBMS for a high-volume internet banking system", + "abstract": "Few large corporate organizations make the decision to use an Object Database Management System (ODBMS) when developing high volume transactional eCommerce web sites. This report examines an application used to run a website that encompasses banking, online shopping, and the management of a Customer Loyalty Currency called eBucks. This system demonstrates that an ODBMS can be used in a high volume web based transactional system. While the choice of this technology has many merits, there are drawbacks. These drawbacks are examined along with the solutions that have been used at eBucks to either solve or ameliorate them.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949439", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vincent", + "last_name": "Coetzee", + "institution": "" + }, + { + "first_name": "Robert J.", + "last_name": "Walker", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/CoetzeeW03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949449", + "title": "A language based formalism for domain driven development", + "abstract": "The evolution of programming languages (e.g. machine languages, assembly languages and high level languages) has been the driving force for the evolution of software development from the machine-centric to the application-centric. The 4th generation languages (4GLs), languages defined directly by the composition of domain features, serve as the language-based formalism for the emerging Domain Driven Development paradigm. The 4GLs are defined in Two-Level Grammar++ and can be compiled into 3GLs using the 4GL compiler framework.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949449", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wei", + "last_name": "Zhao", + "institution": "University of Alabama at Birmingham" + } + ], + "dblp_key": "conf/oopsla/Zhao03a", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949453", + "title": "A self-optimizing application server design for enterprise Java beans applications", + "abstract": "We propose a self-optimizing application server design for EJB component technology. Optimizations are driven by the discovery of inter-component communication patterns and the application of corresponding container refactorings. Our solution attempts to address the impact the application server has on system performance.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949453", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mircea", + "last_name": "Trofin", + "institution": "Dublin City University" + } + ], + "dblp_key": "conf/oopsla/Trofin03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949452", + "title": "Issues on building T++, a tool for web application development with C++", + "abstract": "As the demand for web applications grows, so does the demand for tools that support them. As a general rule, such tools extend general purpose programming languages, like Servlets/Jsp[2] does for Java [4], or define their own programming language, like PHP[3]. But there is no established engine for web applications written with C++. This work presents technical challenges that were faced when developing T++, an engine that supports web application development with C++.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949452", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Antonio", + "last_name": "Terceiro", + "institution": "Universidade Federal da Bahia" + } + ], + "dblp_key": "conf/oopsla/Terceiro03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949451", + "title": "Program manipulation via interactive transformations", + "abstract": "Systematic large-scale modification of source code is tedious and error-prone, because developers use authoring and editing tools poorly suited to the program maintenance task. We combine the results from psychology of programming, software visualization, program analysis, and program transformation fields to create a novel environment that lets the programmers express operations on program source code at a level above text-oriented editing.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949451", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marat", + "last_name": "Boshernitsan", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/Boshernitsan03a", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949454", + "title": "Model consistency in the object oriented software development process", + "abstract": "Model Refinement is a relationship that relates two elements representing the same concept at different levels of abstraction. In UML, Refinement is described in an informal way.To avoid wrong model interpretations, we study a formalization of the refinement relation. This work provides an enhancement to the UML metamodel specification.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949454", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gabriela Alejandra", + "last_name": "Pérez", + "institution": "Universidad Nacional de La Plata" + } + ], + "dblp_key": "conf/oopsla/Perez03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949426", + "title": "Engineering and reusing stable atomic knowledge (SAK) patterns", + "abstract": "Reusing domain-independent knowledge might be hindered if such knowledge is presented as an integral part of domain specific components. This poster presents the concept of Stable Atomic Knowledge (SAK) patterns. A SAK pattern presents a domain-independent knowledge in such a way that makes this knowledge reusable whenever it is needed.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949426", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haitham S.", + "last_name": "Hamza", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Mohamed E.", + "last_name": "Fayad", + "institution": "San Jose State University" + } + ], + "dblp_key": "conf/oopsla/HamzaF03", + "venue": "oopsla", + "year": 2003 + }, + { + "paper_id": "10.1145/949344.949447", + "title": "A high-level view of Java applications", + "abstract": "Static analysis of object-oriented applications has become widespread over the last decade, mainly in the context of compile-time optimizations. The paper describes how static analysis of virtual method calls can be employed to provide a high-level view of Java applications. The result is a method call graph that can be built from either source or bytecode, and a graphical browser that enables the user to analyze control flow and the coupling between classes and packages in an intuitive fashion, thereby supporting application design as well as refactoring and debugging. In order to achieve the necessary bijection between source and bytecode representations of classes, we implement a new approach based on source code pre-processing.", + "date": "2003-10-26", + "link": "https://doi.org/10.1145/949344.949447", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/oopsla/Bodden03", + "venue": "oopsla", + "year": 2003 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2004.json b/data/pl_conferences/oopsla/2004.json new file mode 100644 index 0000000..5d3fdec --- /dev/null +++ b/data/pl_conferences/oopsla/2004.json @@ -0,0 +1,2861 @@ +[ + { + "paper_id": "10.1145/1028664.1028666", + "title": "Refactoring: to the rubicon... and beyond!", + "abstract": "We demonstrate a new approach to refactoring which involves the decomposition of familiar high-level refactorings such as Extract method into their components. By understanding all refactorings as the introduction or elimination of degrees of freedom we show how a large proportion of programming edits are in fact micro-refactorings, and gain an insight into how tools that support these micro-refactorings could have a dramatic impact on developer productivity.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028666", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roly", + "last_name": "Perera", + "institution": "At Bristol" + } + ], + "dblp_key": "conf/oopsla/Perera04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028669", + "title": "Advanced refactorings in eclipse", + "abstract": "We will demonstrate several advanced refactorings for Java that have been implemented in the context of the Eclipse development environment for Java (see www.eclipse.org). These refactorings are semantics-preserving program transformations that are typical of the sorts of transformations object-oriented programmers perform manually in order to improve the structure of existing code, and to promote reuse, clarity, and extensibility.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028669", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert M.", + "last_name": "Fuhrer", + "institution": "IBM (United States)" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM (United States)" + }, + { + "first_name": "Adam Kie", + "last_name": "un", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FuhrerTK04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028672", + "title": "Design snippets: partial design representations extracted from source code", + "abstract": "As software systems evolve, they often grow more brittle. Design snippets help software engineers detect brittleness and improve the ease of change of their software. By studying design snippets and code together, a software engineer can locate improvements that prevent costly changes in the long term.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028672", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vibha", + "last_name": "Sazawal", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Notkin", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/SazawalN04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028679", + "title": "Program transformations for re-engineering C++ components [OOPSLA/GPCE]", + "abstract": "Component-based software engineering enables applications to be assembled from component parts that adhere to a component-style specific interface specification and protocol. Components available for one style are not available for another. Component styles evolve, too, which can obsolete components using a legacy style. This creates a demand for migrating components from one style to another, which can require complex changes to the component source code. For a large component library, doing this manually is likely prohibitive. An alternative is to apply automated program transformations to carry out the changes.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028679", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert L.", + "last_name": "Akers", + "institution": "Semantic Designs (United States)" + }, + { + "first_name": "Ira D.", + "last_name": "Baxter", + "institution": "Semantic Designs (United States)" + }, + { + "first_name": "Michael", + "last_name": "Mehlich", + "institution": "Semantic Designs (United States)" + } + ], + "dblp_key": "conf/oopsla/AkersBM04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028667", + "title": "jMock: supporting responsibility-based design with mock objects", + "abstract": "In this demonstration we will show the flow of the Mock Object development process by pair-programming to develop a code example. During the session, we will introduce the declarative jMock API and show how we use it to describe relationships between objects when developing test-first. We will show how this approach helps developers concentrate on real requirements and how it encourages a design in which objects are focused with well-defined responsibilities. We will also show our practices for maintaining the readability of tests written using jUnit with jMock. This work is described in a Practitioner Report at this conference, \"Mock Roles, Not Objects\".", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028667", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steve", + "last_name": "Freeman", + "institution": "" + }, + { + "first_name": "Tim", + "last_name": "Mackinnon", + "institution": "" + }, + { + "first_name": "Nat", + "last_name": "Pryce", + "institution": "" + }, + { + "first_name": "Joe", + "last_name": "Walnes", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FreemanMPW04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028671", + "title": "Modeling event driven applications with a specification language (MEDASL)", + "abstract": "Radio Frequency Identification (RFID) technology provides the means to track any object, any time, anywhere with Electronic Product Codes (EPC). A major consequence of this technology is that the existing Information Technology systems, applications and processes have to be retrofitted to be EPC-aware. Many new systems and applications have to be developed while the technology and standards are still emerging. These will be driven by dynamic business processes and therefore have to be agile, and easy to use and modify by a business and sometimes non-IT savvy end user. We describe and use Distributed Application Specification Language (DASL) from Sun Microsystems, Inc., to model an enterprise application and deploy it directly on a target platform thus reducing the development lifecycle substantially. DASL provides for a rapid, intuitive modeling of enterprise applications. It abstracts application services such as persistence, tier'ing and messaging within the modeling language and enables a developer to focus more on the application domain. We discuss how we use DASL to model an application in the RFID domain, test for its correctness and proceed to deploy thus bringing about substantial efficiencies in the application development lifecycle.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028671", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Murali", + "last_name": "Kaundinya", + "institution": "Oracle (United States)" + }, + { + "first_name": "Ali", + "last_name": "Syed", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KaundinyaS04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028674", + "title": "JRA: offline analysis of runtime behaviour", + "abstract": "The JRockit Java virtual machine has a built-in capability to produce recordings of the runtime behaviour of an application environment. It is a light-weight system with a very low performance cost, which can give valuable insights as to how the JVM and application interact in production. The JRockit Runtime Analyzer (JRA) is a tool for analyzing these recordings by graphic visualization.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028674", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Helena Åberg", + "last_name": "Östlund", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Ostlund04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028678", + "title": "AJEER: an aspectJ-enabled eclipse runtime", + "abstract": "There are a number of technologies designed to improve modularity in software systems. The technique presented here combines two of them seamlessly to exploit their respective benefits: Eclipse plugins and AspectJ. The Eclipse runtime is based on the idea of plugins, enabling large systems to be built from smaller components. AspectJ is an AOP-enhanced version of the Java language that allows developers to modularize crosscutting concerns into aspects. While both technologies offer a number of interesting features, their seamless combination is not trivial. Several limitations make it impossible to exploit all the features of the combined technologies. AspectJ-Enabled Eclipse Runtime (AJEER) is designed to overcome these limitations. It integrates load-time weaving for AspectJ into the Eclipse runtime, thus allowing developers to implement aspects that modularize crosscutting concerns beyond the capability of individual plugins. In addition, the dynamic features of the OSGi-based Eclipse 3.0 runtime are preserved in this setting - making it possible to plug AspectJ aspects into and out of the running system dynamically.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028678", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Lippert", + "institution": "Universität Hamburg" + } + ], + "dblp_key": "conf/oopsla/Lippert04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028670", + "title": "JQuery: finding your way through tangled code", + "abstract": "A typical IDE based exploration of an OOP system will often involve multiple searches through class hierarchies, field accesses, method calls, regular expression matches and more. Developers who must follow connections between these disconnected views may find great difficulty in combining the capabilities of each view and may as well suffer significant disorientation due to loss of context while switching. toolname is a flexible, query-based source code browser that alleviates this disorientation by allowing the user to explore the various types of structural relationships between elements of the code without the distraction of switching tools. Using toolname, a developer can define his or her own top-level browsers on-the-fly by formulating logic queries and running them against the source code. Elements in the tree can then be queried individually in the same manner, allowing further exploration of the complex web of relationships that exist between scattered elements of code.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028670", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Edward J.", + "last_name": "McCormick", + "institution": "University of British Columbia" + }, + { + "first_name": "Kris De", + "last_name": "Volder", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/oopsla/McCormickV04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028675", + "title": "Modeling and building software product lines with eclipse", + "abstract": "No abstract available.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028675", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Olaf", + "last_name": "Spinczyk", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Danilo", + "last_name": "Beuche", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SpinczykB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028677", + "title": "Smell detection for eclipse", + "abstract": "Smells are architectural, rather than functional, flaws in software that tend to reduce maintainability, extensibility, modularity, testability, or other software quality measures. Common smells include overly-long method bodies, message chains, parallel inheritance, use of switch statements to implement polymorphic behavior, data clumps, overly specific variable types, and duplicated code. Code duplication in particular is a well-known source of maintenance problems. Because smells do not represent functional flaws, they can be remediated by behavior-preserving transformations (i.e. refactorings).", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028677", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arnab", + "last_name": "Bhattacharrya", + "institution": "" + }, + { + "first_name": "Robert M.", + "last_name": "Fuhrer", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/BhattacharryaF04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028673", + "title": "Meta-programming for the real world", + "abstract": "JeeWiz is a commercial tool for model-driven generation of enterprise-level systems. It can automate any part of the development process where repetitive work is required by meta-programming. JeeWiz is universal - being based on a meta modelling approach, it can describe and generate any software technology. It is used for both system-level generation (multi-tier J2EE,.NET, SOA systems) and design-level transformation (XMI to WSDL/XML Schema, and back). The most difficult problem we have confronted is the complexity of mapping from rich, high-level logical models to the detailed artifacts required in real-life systems. Some of the features JeeWiz provides to address this are: reusable architecture and technology layers; local flexibility and cross-tier patterns; and strategies for shielding application programmers from the complexity of infrastructures.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028673", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Fowler", + "institution": "Newable (United Kingdom)" + }, + { + "first_name": "Brahm van", + "last_name": "Niekerk", + "institution": "Newable (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/FowlerN04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028668", + "title": "Modeling and implementing software architecture with acme and archJava", + "abstract": "Software architecture describes the high-level organization of a software system, and is essential both for reasoning about system properties and for implementing and evolving code. This poster describes two architecture-related tools: AcmeStudio for architectural modeling and analysis, and ArchJava for ensuring consistency between architecture and implementation. AcmeStudio is an architectural design tool based on Eclipse, supporting graphical and textual descriptions of software architecture as well as various forms of architectural analysis. The poster shows an example of creating an architecture in Acme and checking it against the constraints of an architectural style such as pipe-and-filter. ArchJava extends the Java language to include explicit architectural modeling constructs, and uses type system techniques to ensure that the implementation conforms to the architecture. The poster shows how AcmeStudio can generate skeleton ArchJava code, how developers can fill in this architecture with an implementation using an Eclipse-based ArchJava IDE, and how ArchJava's type system can help the developer to maintain consistency between code and architecture.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028668", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "David", + "last_name": "Garlan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Bradley", + "last_name": "Schmerl", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Tony", + "last_name": "Tseng", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/AldrichGST04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028681", + "title": "The concern manipulation environment [OOPSLA/GPCE]", + "abstract": "The Concern Manipulation Environment (CME) aims to provide a set of open, extensible components and a set of tools that promote aspect-oriented software development (AOSD) throughout the software lifecycle. It has two main goals:", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028681", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peri", + "last_name": "Tarr", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "William", + "last_name": "Chung", + "institution": "IBM (United States)" + }, + { + "first_name": "William", + "last_name": "Harrison", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Vincent", + "last_name": "Kruskal", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Harold", + "last_name": "Ossher", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Stanley M.", + "last_name": "Sutton", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Andrew", + "last_name": "Clement", + "institution": "" + }, + { + "first_name": "Matthew George", + "last_name": "Chapman", + "institution": "" + }, + { + "first_name": "Helen", + "last_name": "Hawkins", + "institution": "" + }, + { + "first_name": "Sian", + "last_name": "January", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/TarrCHKOSCCHJ04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028680", + "title": "C-SAW and genAWeave: a two-level aspect weaving toolsuite", + "abstract": "This demonstration will feature overviews of the C-SAW and GenAWeave projects. The first half of the presentation will introduce the concept of two-level aspect weaving, which unites a model transformation tool with a program transformation engine. From models representing an avionics application, it will be shown how changes to model properties trigger corresponding adaptations to the related source code. The second half of the demonstration is focused on using a program transformation engine to perform the task of aspect weaving. In particular, several crosscutting concerns will be woven into an Object Pascal application.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028680", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Gray", + "institution": "University of Alabama at Birmingham" + }, + { + "first_name": "Jing", + "last_name": "Zhang", + "institution": "University of Alabama at Birmingham" + }, + { + "first_name": "Suman", + "last_name": "Roychoudhury", + "institution": "University of Alabama at Birmingham" + }, + { + "first_name": "Ira D.", + "last_name": "Baxter", + "institution": "Semantic Designs (United States)" + } + ], + "dblp_key": "conf/oopsla/GrayZRB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028676", + "title": "PRISM is research in aSpect mining", + "abstract": "No abstract available.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028676", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "University of Toronto" + }, + { + "first_name": "Hans‐Arno", + "last_name": "Jacobsen", + "institution": "University of Toronto" + } + ], + "dblp_key": "conf/oopsla/ZhangJ04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028682", + "title": "Performance explorer: understanding java application behavior", + "abstract": "This demonstration illustrates how the visualization tool, Performance Explorer (PE), can be used to understand the behavior of Java applications. PE allows the visualization of data over time in various graphical and tabular ways. In addition, PE allows the interactive creation and modification of visualizations. Most properties of the visualization are defined using expressions in a language similar to Java expressions. Finally, PE has an extensible trace format that allows flexible data acquisition and aggregation.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028682", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Hauswirth", + "institution": "University of Colorado System" + }, + { + "first_name": "Peter F.", + "last_name": "Sweeney", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Colorado System" + } + ], + "dblp_key": "conf/oopsla/HauswirthSD04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028686", + "title": "MetaEdit+: domain-specific modeling for full code generation demonstrated [GPCE]", + "abstract": "Domain-Specific Modeling (DSM) raises the level of abstraction beyond programming by specifying the solution directly using domain concepts. In many cases, the final products can be generated from these high-level specifications. This automation is possible because both the language and generators need fit the requirements of only one company and domain.This demonstration illustrates DSM by showing real world cases from various fields of software development. These cases describe how DSM, giving first class support for modeling, can prevent incorrect or unwanted designs at the early stages of development, and how full code can be generated from the modeler's point of view. Second part of the demonstration will show in an interactive manner both the design side and the use side of DSM languages and generators. Using MetaEdit+ tool for metamodeling, we define a DSM for a given domain and apply it to generate full code from high-level models.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028686", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Juha‐Pekka", + "last_name": "Tolvanen", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Tolvanen04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028688", + "title": "XIRC: cross-artifact information retrieval [GPCE]", + "abstract": "In large scale software development projects, in particular in the field of Component-Based Software Engineering (CBSE), different kinds of a project's artifacts are used and related information is spread over the different artifacts. E.g., the transaction attributes (Require, Requires-New,etc.) of methods of an Enterprise Java Bean are defined in the deployment descriptor while the method bodies are defined in a Java class. If we want to put these information into relation, e.g., to find all methods with a specific transaction attribute, we have to use different search engines and have to map the information manually. It is not possible to execute one that returns the desired result.XIRC is a platform that enables to define queries over a uniform representation of all artifacts of a software project. XIRC maps all artifacts of a project to XML representations and stores the documents in a database. The database can be queried using XQuery, a functional query language for XML documents. XIRC can be used as a sophisticated search engine, as a tool to check implementation restrictions, to find errors or as a basis for further tools for code generation and visualization.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028688", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Eichberg", + "institution": "" + }, + { + "first_name": "Thorsten", + "last_name": "Schäfer", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/EichbergS04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028687", + "title": "Implementing DSLs in metaOCaml", + "abstract": "No abstract available.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028687", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Miguel López", + "last_name": "Guerrero", + "institution": "Rice University" + }, + { + "first_name": "Edward", + "last_name": "Pizzi", + "institution": "Rice University" + }, + { + "first_name": "R. A.", + "last_name": "Rosenbaum", + "institution": "Rice University" + }, + { + "first_name": "Kedar N.", + "last_name": "Swadi", + "institution": "Rice University" + }, + { + "first_name": "Walid", + "last_name": "Taha", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/GuerreroPRST04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028683", + "title": "ConstrainedJava", + "abstract": "Interactive graphical applications implicitly contain a large number of constraints -- relationships between objects, such as widgets and the underlying model they control. Encapsulation, a fundamental principle of object-oriented programming, is only guaranteed in a very limited sense by most object-oriented languages. ConstrainedJava provides a constraint system built upon stronger encapsulation guarantees which allows constraints to depend on entire aggregated objects.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028683", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Donald C.", + "last_name": "Gordon", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Robert", + "last_name": "Biddle", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/GordonNB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028693", + "title": "A language-independent approach to software maintenance using grammar adapters", + "abstract": "A long-standing goal of software engineering is to construct software that is easily modified and extended. Recent advances in software design techniques, such as aspect-oriented software development and refactoring, have offered new approaches to address challenges of software evolution. Several tools and language extensions have been developed by others to enable these techniques in a few popular programming languages. However, software exists in a variety of languages. An unfortunate consequence of legacy system adaptation is that new software engineering tools are often developed from scratch without preserving and reusing the knowledge gained from the previous construction of the tool in a different language and platform context. To address this problem, this paper summarizes two core research ideas. First, the concept of extending several software reengineering techniques in disparate programming languages is explored. A core focus of this objective is the abstraction of transformation functions to enable design maintenance in legacy based systems. The second research objective extends the first goal to understand the fundamental science for constructing a generic platform using grammar adapters to enable language-independent software maintenance.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028693", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Suman", + "last_name": "Roychoudhury", + "institution": "University of Alabama at Birmingham" + } + ], + "dblp_key": "conf/oopsla/Roychoudhury04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028684", + "title": "Object-oriented, structural software configuration management", + "abstract": "Capturing the evolution of logical objects and structures in a software project is crucial to the development of a high-quality software. This research demonstration presents an object-oriented approach to managing the evolution of system objects at the logical level. Keys to our approach are its extensible, logical, and object-oriented system model and structure versioning framework in which types of logical objects and structures in a software system are extended from a small set of the system model's basic entities, allowing them to be versioned in a fine-grained manner and independent of the physical file structure. Changes to all logical objects and structures are captured and related to each other in a tightly connected and cohesive manner via the Molhado product versioning software configuration management (SCM) infrastructure. We also demonstrate our object-oriented SCM approach by applying it in different development paradigms such as UML-based object-oriented software development, architecture-based software development, and Web application development.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028684", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tien N.", + "last_name": "Nguyen", + "institution": "University of Wisconsin–Milwaukee" + }, + { + "first_name": "Ethan V.", + "last_name": "Munson", + "institution": "University of Wisconsin–Milwaukee" + }, + { + "first_name": "John", + "last_name": "Boyland", + "institution": "University of Wisconsin–Milwaukee" + } + ], + "dblp_key": "conf/oopsla/NguyenMB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028692", + "title": "Generic ownership: practical ownership control in programming languages", + "abstract": "This research abstract outlines the work I plan to do as part of my PhD. In particular, I propose to devise a practical way of integrating ownership control into existing programming languages in a way that will help with adoption of ownership in the general programming community.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028692", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Robert", + "last_name": "Biddle", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/oopsla/PotaninNB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028690", + "title": "Modeling dynamics of agile software development", + "abstract": "The primary objective of my dissertation is to develop an integrative view of agile software development to enhance our understanding and make predictions about the agile process. By modeling the dynamics of agile software development process, the applicability and effectiveness of agile methods will be investigated, and the impact of agile practices on project performance in terms of quality, schedule, cost, customer satisfaction will be examined.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028690", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lan", + "last_name": "Cao", + "institution": "Georgia State University" + } + ], + "dblp_key": "conf/oopsla/Cao04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028694", + "title": "Modular generics", + "abstract": "No abstract available.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028694", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Siek04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028695", + "title": "Efficient data race and deadlock prevention in concurrent object-oriented programs", + "abstract": "The main goal of this PhD thesis is to propose and implement a methodology for the construction of programs based on the SCOOP model, and for modular reasoning about their correctness and liveness properties. In particular, the set of correctness rules that guarantee the absence of data races will be refined and formalized; an augmented type system will be proposed to enforce these rules at compile time. Furthermore, an efficient methodology for deadlock prevention, avoidance, detection, and resolution will be developed. A working implementation of SCOOP will be provided. It will take into consideration the proposed mechanisms and serve as a basis for further refinements of the model.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028695", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Piotr", + "last_name": "Nienaltowski", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/Nienaltowski04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028696", + "title": "A framework for removing redundant context management services in enterprise javaBeans application servers", + "abstract": "We propose a framework for removing redundant context management services in contextual composition frameworks, with focus on Enterprise JavaBeans. It is expected that by applying our framework, performance can be improved without the loss of modularity.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028696", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mircea", + "last_name": "Trofin", + "institution": "Dublin City University" + } + ], + "dblp_key": "conf/oopsla/Trofin04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028697", + "title": "Refining designs along middleware-specific concern-dimensions at different MDA-levels of abstraction", + "abstract": "For the MDA approach to software development to become a reality for distributed enterprise systems, MDA needs to provide both modeling support for middleware-specific concerns and tool support for helping developers refine their designs along such concerndimensions at different MDA-levels of abstraction. In order to address these issues, the MDA-compliant Enterprise Fondue method proposes a hierarchy of UML profiles as a means for addressing middleware-specific concerns at different MDA-levels of abstraction, along with model transformations to incrementally refine existing design models according to the proposed profiles. Tool support is provided through the Parallax framework, which enables developers to modularize crosscutting concerns into aspectpromoting Eclipse plug-ins.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028697", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Raul", + "last_name": "Silaghi", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/Silaghi04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028685", + "title": "Towards domain-driven development: the smartTools software factory", + "abstract": "Nowadays, software needs to be more open, flexible, and capable of evolving quickly to meet new user or technology requirements. It should be easy to adapt, even by none computer-specialists. To tackle these challenges for DSL (Domain-Specific Language) tools, we have developed a software factory, named SmartTools.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028685", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Didier", + "last_name": "Parigot", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/oopsla/Parigot04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028703", + "title": "If i had a model, i'd model in the mornin'", + "abstract": "Despite the importance of modeling in producing high-quality software, modeling often receives scant attention in academic curricula. The recent (sometimes heated) discussion of the Object Management Group's Model-Driven Architecture (MDA) has created an opportunity and offered the motivation for making modeling a more central part of the study of software designs. This paper discusses the rationale for modeling, how modeling is currently taught in one graduate program in Management Information Systems and some experiences in the teaching of modeling to masters' level graduate students.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028703", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kurt D.", + "last_name": "Fenstermacher", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/oopsla/Fenstermacher04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028700", + "title": "Ancestor worship in CS1: on the primacy of arrays", + "abstract": "History has given us the array as the fundamental data structure to present to students within the CS1 curriculum. However, with the recent growth in popularity of object-oriented languages for CS1 (C++, Java, C#), and with that, the acceptance of the objects-first or objects-early approach to teaching CS1, it becomes imperative that we re-evaluate our long-held beliefs about what is appropriate to teach. It is our position that the first data structure that students are exposed to should not be arrays, but rather some other form of collection. We will give some examples of how to use java.util.HashMap and some of the other Java Collections classes in substitution of arrays. We also present data concerning the academic performance of students using arrays versus those using Java Collections for CS1 lab exercises.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028700", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Phil", + "last_name": "Ventura", + "institution": "University of West Georgia" + }, + { + "first_name": "Christopher A.", + "last_name": "Egert", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Adrienne", + "last_name": "Decker", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "conf/oopsla/VenturaED04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028705", + "title": "Abstract factories and the shape calculator", + "abstract": "The Shape Calculator is an assignment targeted at CS1 students in an objects-first curriculum. It can serve as a powerful yet entertaining example of the advantages of object-orientation.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028705", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Cheng", + "institution": "Rice University" + }, + { + "first_name": "Nguyễn Quang", + "last_name": "Dũng", + "institution": "Rice University" + }, + { + "first_name": "Mathias", + "last_name": "Ricken", + "institution": "Rice University" + }, + { + "first_name": "Stephen B.", + "last_name": "Wong", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/ChengNRW04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028701", + "title": "greenfoot: combining object visualisation with interaction", + "abstract": "The introduction of programming education with object-oriented languages slowly migrates down the curriculum and is now often introduced at the high school level. This migration requires teaching tools that are adequate for the intended target audience.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028701", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Poul", + "last_name": "Henriksen", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Michael", + "last_name": "Kölling", + "institution": "University of Southern Denmark" + } + ], + "dblp_key": "conf/oopsla/HenriksenK04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028706", + "title": "Using the game of life to introduce freshman students to the power and elegance of design patterns", + "abstract": "In this paper, we describe two programming assignments based on a refactoring of the classic Game of Life application. In particular, we use the Game of Life to help teach freshman students two important and widely applicable design patterns - Command and Visitor.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028706", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael R.", + "last_name": "Wick", + "institution": "University of Wisconsin–Eau Claire" + } + ], + "dblp_key": "conf/oopsla/Wick04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028702", + "title": "Examples that can do harm in learning programming", + "abstract": "Examples form an integral part of learning to program. In this paper we argue that the role of examples should go beyond merely illustrating concepts or principles and should \"sell\" concepts to new programmers. We identify four common pitfalls to avoid when designing examples for teaching programming. We show how examples that are too abstract or too complex can be harmful in explaining new concepts to students. We also show how some examples used to illustrate new concepts can undermine previously taught concepts by not applying these concepts consistently. Finally, we show how some examples can do harm by undermining the very concept they are introducing. The aim of this paper is to encourage educators to think critically about examples before using them.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028702", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Katherine M.", + "last_name": "Malan", + "institution": "University of South Africa" + }, + { + "first_name": "Ken", + "last_name": "Halland", + "institution": "University of South Africa" + } + ], + "dblp_key": "conf/oopsla/MalanH04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028708", + "title": "Marine biology simulation", + "abstract": "The Marine Biology Simulation is designed as a final project in an objects-first CS2 course. It provides an entertaining setting that serves as compelling example of the powers of object-oriented design and programming.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028708", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Cheng", + "institution": "Rice University" + }, + { + "first_name": "Dung", + "last_name": "Nguyen", + "institution": "Rice University" + }, + { + "first_name": "Mathias", + "last_name": "Ricken", + "institution": "Rice University" + }, + { + "first_name": "Stephen B.", + "last_name": "Wong", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/ChengNRW04a", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028704", + "title": "Event-driven programming facilitates learning standard programming concepts", + "abstract": "We have designed a CS 1 course that integrates event-driven programming from the very start. In cite BDMITiCSE1 we argued that event-driven programming is simple enough for CS 1 when introduced with the aid of a library that we have developed. In this paper we argue that early use of event-driven programming makes many of the standard topics of CS 1 much easier for students to learn by breaking them into smaller, more understandable concepts.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028704", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kim B.", + "last_name": "Bruce", + "institution": "Williams College" + }, + { + "first_name": "Andrea", + "last_name": "Danyluk", + "institution": "Williams College" + } + ], + "dblp_key": "conf/oopsla/BruceD04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028707", + "title": "From concrete to abstract: the power of generalization", + "abstract": "We describe an assignment for students in a software engineering class or advanced programming class with emphasis on design. In the assignment students are given a program that solves a maze, with a display that shows the steps toward the solution. The given program has three variations of an iterative search (implemented using the strategy pattern), depth-first search, breadth-first search, best-first search (the latter using a priority queue). The students are asked to disentangle the problem-specific aspects of this code from the search strategy so as to define an abstract problem solver that can be applied to any problem fitting the model of step-by-step searching of a solution space. This requires three steps: defining appropriate interfaces that specify the information about the problem needed by the abstract solver, defining the abstract solver to find a solution using these interfaces, and defining the maze problem so as to implement these interfaces. With the abstract solver created, students should also be able to implement other problems fitting this model, such as the word-ladder game or a search in a graph for a Hamiltonian circuit, so that the abstract solver can be applied to them. The assignment demonstrates the power of generalization using abstract classes and interfaces as a bridge between concrete problems and the solution algorithm. This assignment is intended for a course in software engineering or an advanced programming course with emphasis on design. Students should already be familiar with object-oriented programming, inheritance, abstract classes and interfaces.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028707", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Nevison", + "institution": "Colgate University" + } + ], + "dblp_key": "conf/oopsla/Nevison04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028710", + "title": "Notes on notes on postmodern programming: radio edit", + "abstract": "These notes have the status of letters written to ourselves: we wrote them down because, without doing so, we found ourselves making up new arguments over and over again. So began the abstract of our earlier paper Notes on Postmodern Programming. We now revisit the issue of postmodern programming, and attempt to address some of the questions raised by our exposition. To illustrate the nature of postmodernism we do not do this directly, but instead present a series of snapshots, parodies, and imagined conversations that we hope will help. What do you think of the abstract so far? Self-reference and a irreverent approach are part of this topic, so it's important to chill out and let things flow. We claim that computer science and software design grew up amid the unquestioned landscape of modernism, and that too often we cling to the otherwise ungrounded values, even as modernism itself is ever more compromised.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028710", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Robert", + "last_name": "Biddle", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/NobleB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028699", + "title": ""Objects first, interfaces next" or interfaces before inheritance", + "abstract": "Objects first is a pedagogy that tries to introduce the core concepts of object-oriented programming - classes, objects, and methods - as early as possible in a programming course, even before variables, types, assignments and control structures are explicitly introduced. The concept of a named interface is typically introduced at a much later stage, usually in connection with inheritance, polymorphism, and abstract classes. In this paper we point out that interfaces as a language mechanism can be introduced much earlier, even before inheritance. This way the concept of an explicit class interface can be decoupled from the more complicated issues of inheritance and subtype-polymorphism.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028699", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Axel", + "last_name": "Schmolitzky", + "institution": "Universität Hamburg" + } + ], + "dblp_key": "conf/oopsla/Schmolitzky04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028711", + "title": "Languages of the future", + "abstract": "This paper explores a new point in the design space of formal reasoning systems - part programming language, part logical framework. The system is built on a programming language where the user expresses equality constraints between types and the type checker then enforces these constraints. This simple extension to the type system allows the programmer to describe properties of his program in the types of witness objects which can be thought of as concrete evidence that the program has the property desired. These techniques and two other rich typing mechanisms, rank-N polymorphism and extensible kinds, create a powerful new programming idiom for writing programs whose types enforce semantic properties. This kind of synthesis between a practical programming language and a logic creates a foundation for the design of languages of the future.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028711", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "conf/oopsla/Sheard04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028713", + "title": "Example centric programming", + "abstract": "Programmers tend to understand programs by thinking of concrete examples. Example Centric Programming seeks to add IDE support for examples throughout the process of programming. Instead of programmers interpreting examples in their head, the examples are written down and the IDE interprets them automatically. Advanced UI techniques are used to present the results closely integrated with the code. Traditionally distinct programming tools (the editor, Read-Eval-Print-Loop, debugger, and test runner) are unified into a single tool that might be called an example-enlightened editor. This is expected to benefit a wide spectrum of programming activities, for both novice and experienced programmers. Some novel methods for testing and development are made possible. In the longer term, example centrism has implications for the design of future programming languages. A prototype has been implemented for Java in Eclipse.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028713", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Edwards", + "institution": "IIT@MIT" + } + ], + "dblp_key": "conf/oopsla/Edwards04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028691", + "title": "Interactive visualization of object-oriented programs", + "abstract": "We describe a novel approach to runtime visualization of object-oriented programs. Our approach features: visualizations of execution state and history; forward and reverse execution; interactive queries during program execution; and advanced drawing capabilities involving a combination of compile-time and runtime-analysis. Our methodology is realized in a software tool called JIVE, for Java Interactive Visualization Environment.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028691", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "Gestwicki", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "conf/oopsla/Gestwicki04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028714", + "title": "Methodology work is ontology work", + "abstract": "I argue that a successful switch from one methodology to another requires a switch from one ontology to another. Large-scale adoption of a new methodology means \"infecting\" people with new ideas about what sorts of things there are in the (software development) world and how those things hang together. The paper ends with some suggestions to methodology creators about how to design methodologies that encourage the needed \"gestalt switch.\"", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028714", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brian", + "last_name": "Marick", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Marick04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028715", + "title": "Looking for love: (in all the wrong places)", + "abstract": "This paper is an extended abstract of the presentation at OOPSLA '04 and the full paper that will appear in the December issue of SIGPLAN Notices.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028715", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David J.", + "last_name": "West", + "institution": "University of New Mexico" + } + ], + "dblp_key": "conf/oopsla/West04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028716", + "title": "Granule-oriented programming (extended abstract)", + "abstract": "Article Granule-oriented programming (extended abstract) Share on Author: Yinliang Zhao Xi'an Jiaotong University, Xi'an, P.R. China Xi'an Jiaotong University, Xi'an, P.R. ChinaView Profile Authors Info & Claims OOPSLA '04: Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applicationsOctober 2004 Pages 128–131https://doi.org/10.1145/1028664.1028716Online:23 October 2004Publication History 1citation364DownloadsMetricsTotal Citations1Total Downloads364Last 12 Months4Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028716", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yinliang", + "last_name": "Zhao", + "institution": "Xi'an Jiaotong University" + } + ], + "dblp_key": "conf/oopsla/Zhao04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028717", + "title": "Finding bugs is easy", + "abstract": "Many techniques have been developed over the years to automatically find bugs in software. Often, these techniques rely on formal methods and sophisticated program analysis. While these techniques are valuable, they can be difficult to apply, and they aren't always effective in finding real bugs.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028717", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Hovemeyer", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "William", + "last_name": "Pugh", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/HovemeyerP04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028720", + "title": "Software development: arts & crafts or math & science?", + "abstract": "We've have been proposing formal mathematical methods of software development for nearly as long as we've been developing software. CASE tools were a bust, and Gödel long ago nullified any hope of building a system that is both complete and consistent. Model-driven development gets trotted out in a new outfit once every decade as the next \"silver bullet,\" but we're still far from drawing pictures that generate code.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028720", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jim", + "last_name": "Haungs", + "institution": "IBM (United States)" + }, + { + "first_name": "Martin", + "last_name": "Fowler", + "institution": "" + }, + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Steve", + "last_name": "McConnell", + "institution": "Constructing Excellence" + }, + { + "first_name": "Richard", + "last_name": "Gabriel", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/HaungsFJMG04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028712", + "title": "Protocols for processes: programming in the large for open systems (extended abstract)", + "abstract": "The modeling and enactment of business processes is being recognized as key to modern information management. The expansion of Web services has increased the attention given to processes, because processes are how services are composed and put to good use. However, current approaches are inadequate for flexibly modeling and enacting processes. These approaches take a logically centralized view of processes, treating a process as an implementation of a composed service. They provide low-level scripting languages to specify how a service may be implemented, rather than what interactions are expected from it. Consequently, existing approaches fail to adequately accommodate the essential properties of the business partners in a process (the partners would be realized via services)---their autonomy (freedom of action), heterogeneity (freedom of design), and dynamism (freedom of configuration).", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028712", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Munindar P.", + "last_name": "Singh", + "institution": "North Carolina State University" + }, + { + "first_name": "Amit K.", + "last_name": "Chopra", + "institution": "North Carolina State University" + }, + { + "first_name": "Nirmit", + "last_name": "Desai", + "institution": "North Carolina State University" + }, + { + "first_name": "Ashok U.", + "last_name": "Mallya", + "institution": "North Carolina State University" + } + ], + "dblp_key": "conf/oopsla/SinghCDM04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028721", + "title": "The great J2EE vs. microsoft.NET shootout", + "abstract": "J2EE and Microsoft.NET have emerged as two major frameworks for software development. Are they more similar than different or are the differences significant? How do they stack up against each other? This panel will offer a lively discussion from leaders of Microsoft and J2EE technologies.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028721", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Fowler", + "institution": "" + }, + { + "first_name": "Don", + "last_name": "Box", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Anders", + "last_name": "Hejlsberg", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Alan", + "last_name": "Knight", + "institution": "" + }, + { + "first_name": "Rob", + "last_name": "High", + "institution": "IBM (United States)" + }, + { + "first_name": "John", + "last_name": "Crupi", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/FowlerBHKHC04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028724", + "title": "The view: the ultimate IT chat", + "abstract": "The world is changing; and this is also true for our IT business. Nicolai Josuttis talks with five international extraordinary female representatives of our IT business about the most important, thought-provoking, and funniest IT headlines and tendencies of the past year. Lean back and enjoy being a fly on the wall when the following participants chat in a pub-like atmosphere: Rebecca Wirfs-Brock, Linda Rising, Mary Lynn Manns, Jutta Eckstein, and Lise B. Hvatum.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028724", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nicolai M.", + "last_name": "Josuttis", + "institution": "" + }, + { + "first_name": "Jutta", + "last_name": "Eckstein", + "institution": "" + }, + { + "first_name": "Linda", + "last_name": "Rising", + "institution": "" + }, + { + "first_name": "Lise B.", + "last_name": "Hvatum", + "institution": "Schlumberger (British Virgin Islands)" + }, + { + "first_name": "Mary Lynn", + "last_name": "Manns", + "institution": "University of North Carolina at Asheville" + }, + { + "first_name": "Rebecca", + "last_name": "Wirfs-Brock", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/JosuttisERHMW04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028728", + "title": "An invitation to the dance of progress", + "abstract": "We evaluate events singly as gain or loss from status quo. We value sure gain, flee sure loss, assume progress cumulative. But progress relies on opportunism, taking advantage of tools and circumstances emerging through experience. Patterns, practices are superseded. Sometimes we refine, sometimes we invent, sometimes we stop using them.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028728", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lawrence R.", + "last_name": "Carleton", + "institution": "BAE Systems (Sweden)" + } + ], + "dblp_key": "conf/oopsla/Carleton04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028726", + "title": "QuA: building with reusable QoS-aware components", + "abstract": "The QuA project team at Simula Research Laboratory has prototyped an open source component middleware platform to support QoS sensitive applications. We are investigating the design of resuable QoS management components and tools to enable rapid construction of complex distributed systems.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028726", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Frank", + "last_name": "Eliassen", + "institution": "Simula Research Laboratory" + }, + { + "first_name": "Richard", + "last_name": "Staehli", + "institution": "Simula Research Laboratory" + }, + { + "first_name": "Gordon S.", + "last_name": "Blair", + "institution": "Lancaster University" + }, + { + "first_name": "Jan Øyvind", + "last_name": "Aagedal", + "institution": "SINTEF" + } + ], + "dblp_key": "conf/oopsla/EliassenSBO04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028719", + "title": "Model driven architecture: the realities, a year later", + "abstract": "Model Driven Architecture (MDA) is a technology that has been in the process of evolution for many years. We looked at this technology last year in a panel that raised the roof. Today, more vendors are now producing products that support MDA. And we still hear about the success stories that indicate that this technology is the \"real deal\". But, with the failed promises of CASE in the late 1980's, many people still have questions about how much of an application can be generated from models and constraint languages. Is MDA really capable of generating enterprise applications? What are the technologies are available to implement MDA? Are there really special skills needed to generate platform independent applications? How platform independent are they in practice? Here is your opportunity to ask the experts the questions that are necessary to convince you of the validity of this new technology. This time, we bring in the people who are shipping the technology.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028719", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "G. G.", + "last_name": "Miller", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Scott W.", + "last_name": "Ambler", + "institution": "" + }, + { + "first_name": "Steve", + "last_name": "Cook", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Stephen J.", + "last_name": "Mellor", + "institution": "Mentor" + }, + { + "first_name": "Karl H.", + "last_name": "Frank", + "institution": "Westmorland General Hospital" + }, + { + "first_name": "Jon", + "last_name": "Kern", + "institution": "Compuware (United States)" + } + ], + "dblp_key": "conf/oopsla/MillerACMFK04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028729", + "title": "OOLACA: an object oriented library for abstract and computational algebra", + "abstract": "Object oriented programming and design patterns introduce a high level of abstraction that allows us to implement and work with mathematical abstractions.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028729", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Virginia", + "last_name": "Niculescu", + "institution": "Babeș-Bolyai University" + }, + { + "first_name": "Grigoreta Sofia", + "last_name": "Moldovan", + "institution": "Babeș-Bolyai University" + } + ], + "dblp_key": "conf/oopsla/Niculescu04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028730", + "title": "Pseudo-classes: very simple and lightweight mockObject-like classes for unit-testing", + "abstract": "A simple alternative to MockObjects is presented. Given the interface of an object required by a class-under-test, a Pseudo-Class is created implementing all methods such that they immediately fail. A test-specific sub-class of the Pseudo-Class is created locally in the test (ex. as an anonymous inner-class in Java), over-riding only the methods required by the interaction between the object and the class-under-test for the test-scenario. Typically, the method implementations are extremely simple (a few lines, at most), and the number of methods overridden is small. This mechanism was found adequate for more than 90% of our unit-tests (in a 1000-class system with over 2000 test methods, we finally ended up with about four real MockObject classes and more than 40 Pseudo-Classes).", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028730", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Geoff", + "last_name": "Sobering", + "institution": "" + }, + { + "first_name": "Levi", + "last_name": "Cook", + "institution": "" + }, + { + "first_name": "Steve", + "last_name": "Anderson", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SoberingCA04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028723", + "title": "The role of the customer in software development: the XP customer - fad or fashion?", + "abstract": "One of the core XP (Xtreme Programming) practices is that of the \"on-site customer\". In the words of Kent Beck (2000) in his book \"eXtreme Programming Explained\" the intent is that a \"real customer must sit with the team, available to answer questions, resolve disputes, and set small-scale priorities\" … \"someone who will really use the system when it is in production\". This panel brings together practitioners and researchers to discuss and offer wisdom on the challenges and opportunities inherent in the practice.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028723", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "" + }, + { + "first_name": "Angela", + "last_name": "Martin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Robert", + "last_name": "Biddle", + "institution": "Carleton University" + }, + { + "first_name": "David", + "last_name": "Hussman", + "institution": "" + }, + { + "first_name": "G. G.", + "last_name": "Miller", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Mary", + "last_name": "Poppendieck", + "institution": "" + }, + { + "first_name": "Linda", + "last_name": "Rising", + "institution": "" + }, + { + "first_name": "Mark", + "last_name": "Striebeck", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FraserMBHMPRS04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028731", + "title": "Towards a framework for the general intensional programming compiler in the GIPSY", + "abstract": "In this paper, we describe a compiler framework to enable the automated generation of compiler components for the Lucid family of intensional programming languages.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028731", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joey", + "last_name": "Paquet", + "institution": "Concordia University" + }, + { + "first_name": "Aihua", + "last_name": "Wu", + "institution": "Concordia University" + }, + { + "first_name": "Peter", + "last_name": "Grogono", + "institution": "Concordia University" + } + ], + "dblp_key": "conf/oopsla/PaquetWG04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028722", + "title": "Challenges in outsourcing and global development: how will your job change?", + "abstract": "If you are a software professional, your job is changing. Outsourcing and global development affect many things in our work environment: what and where we build, how (and when) we communicate, and how we prepare ourselves for the future.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028722", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Fraser", + "institution": "" + }, + { + "first_name": "Lougie", + "last_name": "Anderson", + "institution": "" + }, + { + "first_name": "Ron", + "last_name": "Crocker", + "institution": "Motorola (United States)" + }, + { + "first_name": "Richard", + "last_name": "Gabriel", + "institution": "Oracle (United States)" + }, + { + "first_name": "Martin", + "last_name": "Fowler", + "institution": "" + }, + { + "first_name": "Ricardo D.", + "last_name": "Lopez", + "institution": "Qualcomm (United Kingdom)" + }, + { + "first_name": "Dave", + "last_name": "Thomas", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FraserACGFLT04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028733", + "title": "Modeling event driven applications with a specification language (MEDASL)", + "abstract": "Radio Frequency Identification (RFID) technology provides the means to track any object, any time, anywhere with Electronic Product Codes (EPC). A major consequence of this technology is that the existing Information Technology systems, applications and processes have to be retrofitted to be EPC-aware. Many new systems and applications have to be developed while the technology and standards are still emerging. These will be driven by dynamic business processes and therefore have to be agile, and easy to use and modify by a business and sometimes non-IT savvy end user. We describe and use Distributed Application Specification Language (DASL) from Sun Microsystems, Inc., to model an enterprise application and deploy it directly on a target platform thus reducing the development lifecycle substantially. DASL provides for a rapid, intuitive modeling of enterprise applications. It abstracts application services such as persistence, tier'ing and messaging within the modeling language and enables a developer to focus more on the application domain. We discuss how we use DASL to model an application in the RFID domain, test for its correctness and proceed to deploy thus bringing about substantial efficiencies in the application development lifecycle.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028733", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Murali", + "last_name": "Kaundinya", + "institution": "" + }, + { + "first_name": "Ali", + "last_name": "Syed", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KaundinyaS04a", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028735", + "title": "Bottleneck analysis in java applications using hardware performance monitors", + "abstract": "This poster presents MonitorMethod which helps Java programmers gain insight in the behavior of their applications. MonitorMethod instruments the Java application and relates hardware performance monitors (HPMs) to the methods in the Java application's source code. We present a detailed case study showing that linking microprocessor-level performance characteristics to the source code is helpful for identifying performance bottlenecks and their causes. In addition, we relate our work to a previously proposed time-based HPM profiling framework.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028735", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dries", + "last_name": "Buytaert", + "institution": "Ghent University" + }, + { + "first_name": "Andy", + "last_name": "Georges", + "institution": "Ghent University" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University" + }, + { + "first_name": "Koen De", + "last_name": "Bosschere", + "institution": "Ghent University" + } + ], + "dblp_key": "conf/oopsla/BuytaertGEB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028734", + "title": "Improving quality in conceptual modeling", + "abstract": "Quality of a conceptual model can be defined along three dimensions - syntax, semantics and pragmatic. Pragmatic quality has been improved in the literature through schema transformations. We suggest an approach that also improves the semantic quality by schema transformations. A semantic quality parameter 'extent of normalization' is defined. Based on this parameter and functional dependencies from problem domain, a set of rules is suggested to improve a given conceptual model. We also show that relational schema produced after these transformations is normalized up to 3NF at least.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028734", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tauqeer", + "last_name": "Hussain", + "institution": "Lahore University of Management Sciences" + }, + { + "first_name": "Shafay", + "last_name": "Shamail", + "institution": "Lahore University of Management Sciences" + }, + { + "first_name": "Mian Muhammad", + "last_name": "Awais", + "institution": "Lahore University of Management Sciences" + } + ], + "dblp_key": "conf/oopsla/HussainSA04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028736", + "title": "Mobile-D: an agile approach for mobile application development", + "abstract": "Mobile phones have been closed environments until recent years. The change brought by open platform technologies such as the Symbian operating system and Java technologies has opened up a significant business opportunity for anyone to develop application software such as games for mobile terminals. However, developing mobile applications is currently a challenging task due to the specific demands and technical constraints of mobile development. Furthermore, at the moment very little is known about the suitability of the different development processes for mobile application development. Due to these issues, we have developed an agile development approach called Mobile-D. The Mobile-D approach is briefly outlined here and the experiences gained from four case studies are discussed.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028736", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pekka", + "last_name": "Abrahamsson", + "institution": "VTT Technical Research Centre of Finland" + }, + { + "first_name": "Antti", + "last_name": "Hanhineva", + "institution": "VTT Technical Research Centre of Finland" + }, + { + "first_name": "Hanna", + "last_name": "Hulkko", + "institution": "VTT Technical Research Centre of Finland" + }, + { + "first_name": "Tuomas", + "last_name": "Ihme", + "institution": "VTT Technical Research Centre of Finland" + }, + { + "first_name": "Juho", + "last_name": "Jäälinoja", + "institution": "VTT Technical Research Centre of Finland" + }, + { + "first_name": "Mikko", + "last_name": "Korkala", + "institution": "University of Oulu" + }, + { + "first_name": "Juha", + "last_name": "Koskela", + "institution": "VTT Technical Research Centre of Finland" + }, + { + "first_name": "Pekka", + "last_name": "Kyllönen", + "institution": "VTT Technical Research Centre of Finland" + }, + { + "first_name": "Outi", + "last_name": "Salo", + "institution": "VTT Technical Research Centre of Finland" + } + ], + "dblp_key": "conf/oopsla/AbrahamssonHHIJKKKS04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028739", + "title": "AJEER: an aspectJ-enabled eclipse runtime", + "abstract": "There are a number of technologies designed to improve modularity in software systems. The technique presented here combines two of them seamlessly to exploit their respective benefits: Eclipse plugins and AspectJ. The Eclipse runtime is based on the idea of plugins, enabling large systems to be built from smaller components. AspectJ is an AOP-enhanced version of the Java language that allows developers to modularize crosscutting concerns into aspects. While both technologies offer a number of interesting features, their seamless combination is not trivial. Several limitations make it impossible to exploit all the features of the combined technologies. AspectJ-Enabled Eclipse Runtime (AJEER) is designed to overcome these limitations. It integrates load-time weaving for AspectJ into the Eclipse runtime, thus allowing developers to implement aspects that modularize crosscutting concerns beyond the capability of individual plugins. In addition, the dynamic features of the OSGi-based Eclipse 3.0 runtime are preserved in this setting - making it possible to plug AspectJ aspects into and out of the running system dynamically.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028739", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Lippert", + "institution": "Universität Hamburg" + } + ], + "dblp_key": "conf/oopsla/Lippert04a", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028741", + "title": "Design pattern integrated tool", + "abstract": "The use of design patterns in the mainstream has been limited due technical restrictions in supporting tools. We developed an integrated tool that supports language and platform independence, and facilitates cross-platform interoperability. The tool also assists in coding and design validating for quality assurance.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028741", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Somsak", + "last_name": "Phattarasukol", + "institution": "California State Polytechnic University" + }, + { + "first_name": "Daisy F.", + "last_name": "Sang", + "institution": "California State Polytechnic University" + } + ], + "dblp_key": "conf/oopsla/PhattarasukolS04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028732", + "title": "An aspect-oriented generative approach", + "abstract": "The integration of generative and aspect-oriented techniques is not a trivial task. This paper describes our experience in the definition of an aspect-oriented generative approach for the context of multi-agent systems. Our generative approach is composed of: (i) a domain-specific language called Agent-DSL, which allows to model crosscutting and non-crosscuting agent features; (ii) an aspect-oriented architecture that models a family of software agents; and (iii) a code generator that maps abstractions of the Agent-DSL to specific compositions of objects and aspects in specific implementations of agent architectures. The use of aspect-oriented techniques in the definition of our generative approach brought benefits to the modeling and code generation of crosscutting features since early design stages.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028732", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Uirá", + "last_name": "Kulesza", + "institution": "Pontifical Catholic University of Rio de Janeiro" + }, + { + "first_name": "Alessandro", + "last_name": "Garcia", + "institution": "Pontifical Catholic University of Rio de Janeiro" + }, + { + "first_name": "Carlos", + "last_name": "Lucena", + "institution": "Pontifical Catholic University of Rio de Janeiro" + } + ], + "dblp_key": "conf/oopsla/KuleszaGL04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028745", + "title": "A UML profile for service oriented architectures", + "abstract": "Service Oriented Computing is the new paradigm for Distributed computing and e-business processing that is changing the way software applications are designed, architected, delivered and consumed. Services are autonomous platform-independent computational elements that can be described, published, discovered, orchestrated and programmed using standard protocols for the purpose of building agile networks of collaborating business applications distributed within and across organizational boundaries. Engineering and modeling service-oriented architectures need extensions to existing modeling techniques and methodologies. In this paper, we propose a UML profile for service-oriented architectures.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028745", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rafik", + "last_name": "Amir", + "institution": "American University in Cairo" + }, + { + "first_name": "Amir", + "last_name": "Zeid", + "institution": "American University in Cairo" + } + ], + "dblp_key": "conf/oopsla/AmirZ04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028738", + "title": "Visualisation for learning OOP, using AOP and eclipse", + "abstract": "This paper outlines our project to help beginners learn to program by showing object visualisations driven by aspect- oriented programming, and presented as part of the Eclipse development platform. The aspect-oriented programming is part of the infrastructure we use to drive the visualisations that help students learn object-oriented programming. Aspect-oriented programming explicitly supports the kind of cross-cutting concerns that allows our system to drive visualisations that emphasise principles of object interaction. Our extensions to Eclipse allow us to provide this educational scaffolding to help learners, without altering the program, the programming language or the libraries.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028738", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rilla", + "last_name": "Khaled", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Anna Maria", + "last_name": "Luxton", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Leo", + "last_name": "Ferres", + "institution": "Carleton University" + }, + { + "first_name": "Judy", + "last_name": "Brown", + "institution": "Carleton University" + }, + { + "first_name": "Robert", + "last_name": "Biddle", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/KhaledLNFBB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028743", + "title": "J2EE for the public administration: a success story", + "abstract": "Our poster shows how J2EE technologies, well-known design patterns and standard methodologies have successfully been applied in building a complete, robust and well-documented accounting application. Our experience demonstrates that those three factors allow for easy maintenance and reuse of components. The application, whose development was initially outsourced, is now maintained by a CNR internal group and other Public Administrations have shown interest in adopting some of its components.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028743", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Maurizio", + "last_name": "Lancia", + "institution": "Italian Resuscitation Council" + }, + { + "first_name": "Paola", + "last_name": "Garzenini", + "institution": "Italian Resuscitation Council" + }, + { + "first_name": "R", + "last_name": "Puccinelli", + "institution": "National Research Council" + }, + { + "first_name": "Alessio", + "last_name": "Marchetti", + "institution": "National Research Council" + } + ], + "dblp_key": "conf/oopsla/LanciaGPM04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028744", + "title": "Meta: extending and unifying languages", + "abstract": "Meta is an ambitious research project whose overall purpose is to increase the utility and expressive power of a wide range of existing languages. Meta provides augmented versions of existing languages and guarantees support for aspects, components, language interoperability, visualization, reflection, various inheritance models, and many other extensions.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028744", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wade", + "last_name": "Holst", + "institution": "Western University" + } + ], + "dblp_key": "conf/oopsla/Holst04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028746", + "title": "An approach and tools to automate externalization of application logic", + "abstract": "Externalization of application logic from application objects has become pervasive in its use in many system, business and application components. Implementation of such systems typically focuses on the use of rules and rule engines, and has typically been closely integrated with the application objects themselves and application source code needs to be modified to include decision points to externalize the logic. This puts a burden on the developers if the application contains a large number of decision points. The problem is compounded by legacy applications where source code is not available and therefore it is virtually impossible to modify the application source code to include the decision points. This has limited the potential use of application logic externalization methodology. In this report, we will describe an approach and tools to automate the process of externalizing application logic for applications without modifying source code.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028746", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hoi", + "last_name": "Chan", + "institution": "IBM (United States)" + }, + { + "first_name": "Trieu C.", + "last_name": "Chieu", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/ChanC04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028737", + "title": "Dependable distributed systems", + "abstract": "Distributed software systems are the basis for many innovative applications. The key for achieving scalable and maintainable distributed systems is dependability, because otherwise the complexity of distribution would leave the system uncontrollable. Hence, our approach aims at a concept for optimizing dependability. Similar to other approaches we use replication as means to provide transparent fault-tolerance and persistence, but we especially focus on increasing availability by relaxing data integrity by using a mixture of asynchronous and synchronous replication techniques. This work contributes three main aspects: First, a description of the envisioned trade-off between availability and consistency, secondly with a mechanism to achieve this trade-off, and thirdly, with models that use this mechanism and can be transparently deployed by developers. This work aims at enabling a configurable and application-specific optimum of availability, possibly even controlled during runtime. A real-life telecommunication application serves as proof of concept.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028737", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "A.", + "last_name": "Szep", + "institution": "TU Wien" + }, + { + "first_name": "R.", + "last_name": "Smeikal", + "institution": "TU Wien" + }, + { + "first_name": "M.", + "last_name": "Jandl", + "institution": "TU Wien" + }, + { + "first_name": "Karl M.", + "last_name": "Goeschka", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/oopsla/SzepSJG04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028740", + "title": "An open model infrastructure for automotive software", + "abstract": "To accommodate the growing demand for complexity in the automotive industry, an approach for a cross-process information model is introduced: the infrastructure presented aims at storing and relating key development data from the various software engineering phases. The model can be harmonized with proprietary development methodologies by means of metamodeling and serves as the starting point for the traceability of requirements, global plausibility checks, and (semi-)automatic transformation of model elements. Based on the medini tool chain, the model infrastructure is open with respect to the models and tools used thanks to the consistent deployment of OMG standards and the benefit of metamodeling.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028740", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Vögler", + "institution": "Daimler (Germany)" + }, + { + "first_name": "Thomas", + "last_name": "Flór", + "institution": "Daimler (Germany)" + }, + { + "first_name": "Hajo", + "last_name": "Eichler", + "institution": "Fraunhofer Institute for Open Communication Systems" + }, + { + "first_name": "Matthias", + "last_name": "Kasprowicz", + "institution": "Furtwangen University" + } + ], + "dblp_key": "conf/oopsla/VoglerFEK04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028747", + "title": "Cona: aspects for contracts and contracts for aspects", + "abstract": "Design by Contract (DBC) and runtime enforcement of program assertions enables the construction of more robust software. It also enables the assignment of blame in error reporting. As of yet, no AOP implementation for the provision of DBC exists. We present an aspect-oriented DBC tool for Java named Cona. We also extend the use of DBC and assertions to AOP. Aspects are used in the implementation of contracts, and contracts are used for enforcing assertions on aspects.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028747", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Therapon", + "last_name": "Skotiniotis", + "institution": "Northeastern University" + }, + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/SkotiniotisL04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028748", + "title": "<CTRL>+<ALT>+<TOOL PARADIGM SHIFT>?", + "abstract": "Despite being laden with elaborate features and time-saving gadgetry, modern Integrated Development Environments (IDEs) continue to be little more than turbocharged text editors with loosely integrated compilers. Years of incremental evolution of these environments have created a species of large, lumbering, often incomprehensible products with little direct support for the day-to-day tasks that developers actually find themselves doing.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028748", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Russ", + "last_name": "Freeman", + "institution": "At Bristol" + }, + { + "first_name": "Phil", + "last_name": "Webb", + "institution": "At Bristol" + } + ], + "dblp_key": "conf/oopsla/FreemanW04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028742", + "title": "Advancements in multicode optimization", + "abstract": "In previous work, we have shown that multicodes can be used to improve the performance of Java applications. We extend that work by both implementing more multicodes and considering multicodes of greater length. This has resulted in significantly larger performance gains than those that have been achieved previously for some benchmarks.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028742", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben", + "last_name": "Stephenson", + "institution": "Western University" + }, + { + "first_name": "Wade", + "last_name": "Holst", + "institution": "Western University" + } + ], + "dblp_key": "conf/oopsla/StephensonH04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028750", + "title": "Deriving refactorings for aspectJ", + "abstract": "In this paper we present aspect-oriented programming laws that are useful for deriving refactorings for AspectJ. The laws help developers to verify if the transformations they define preserve behavior. We illustrate that by deriving several AspectJ refactorings. We also show that our laws are useful for restructuring two Java applications with the aim of using aspects to modularize common crosscutting concerns.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028750", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Leonardo", + "last_name": "Cole", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Paulo", + "last_name": "Borba", + "institution": "Universidade Federal de Pernambuco" + } + ], + "dblp_key": "conf/oopsla/ColeB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028749", + "title": "A search system for java programs by using extracted javaBeans components", + "abstract": "We propose a new component-extraction-based program search system. Our system analyses existing Java programs, acquires relationships among classes, and extracts JavaBeans components composed of classes. Moreover, our system generates indexes composed of divided type names and comments for newly extracted components. Using our system, the extracted components can be searched by keywords, and the result set can be viewed by a web browser such that the user can decide whether the query result component matches his/her requirements.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028749", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hironori", + "last_name": "Washizaki", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Yoshiaki", + "last_name": "Fukazawa", + "institution": "Waseda University" + } + ], + "dblp_key": "conf/oopsla/WashizakiF04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028751", + "title": "RUBiS revisited: why J2EE benchmarking is hard", + "abstract": "We have replicated the experiments of Cecchet et al detailed in \"Performance and Scalability of EJB Applications\" at OOPSLA '02. We report on our experiences configuring, deploying and tuning Enterprise software, and provide evidence that many of the conclusions of the original work are misleading or cannot be generalized.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028751", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bill", + "last_name": "Pugh", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jaime", + "last_name": "Spacco", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/PughS04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028752", + "title": "Mobile musical agents: the andante project", + "abstract": "We investigate the use of mobile agents for the creation of music within a distributed computing environment. We believe this technology has the potential to foster new ways of making music. This poster presents Andante, an object-oriented, open-source infrastructure for building distributed musical applications based on mobile agents.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028752", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Leo Kazuhiro", + "last_name": "Ueda", + "institution": "Universidade de São Paulo" + }, + { + "first_name": "Fábio", + "last_name": "Kon", + "institution": "Universidade de São Paulo" + } + ], + "dblp_key": "conf/oopsla/UedaK04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028753", + "title": "A core calculus of mixins and incomplete objects", + "abstract": "Our calculus combines class-based features with object-based ones, with the aim of fitting into a unified setting the \"best of both worlds\". In a mixin-based approach, mixins are seen as incomplete classes from which incomplete objects can be instantiated. Incomplete objects can be completed in an object-based fashion.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028753", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lorenzo", + "last_name": "Bettini", + "institution": "University of Florence" + }, + { + "first_name": "Viviana", + "last_name": "Bono", + "institution": "University of Turin" + }, + { + "first_name": "Silvia", + "last_name": "Likavec", + "institution": "University of Turin" + } + ], + "dblp_key": "conf/oopsla/BettiniBL04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028754", + "title": "RAIL: code instrumentation for .NET", + "abstract": "Code instrumentation is a mechanism that allows modules of programs to be completely rewritten at runtime. With the advent of virtual machines, this type of functionality is becoming more and more interesting because it allows the introduction of new functionality after an application has been deployed, easy implementation of aspect-oriented programming, performing security verifications, dynamic software upgrading, among others.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028754", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bruno", + "last_name": "Cabral", + "institution": "University of Coimbra" + }, + { + "first_name": "Paulo", + "last_name": "Marques", + "institution": "University of Coimbra" + }, + { + "first_name": "Luís R.", + "last_name": "Silva", + "institution": "University of Coimbra" + } + ], + "dblp_key": "conf/oopsla/CabralMS04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028757", + "title": "AOP as a first class reflective mechanism", + "abstract": "AOP is often perceived as a second class reflective mechanism, whereas reflection in OOP is considered first class. However, perceiving AOP as a first class language mechanism is conductive to developing a general AOP model, which can be a basis for an overall theory of AOP. We illustrate this view by comparing AOP with reflection and illustrating that both mechanisms are conceptually at the same level.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028757", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sergei", + "last_name": "Kojarski", + "institution": "Northeastern University" + }, + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/KojarskiL04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028758", + "title": "CoSMIC: addressing crosscutting deployment and configuration concerns of distributed real-time and embedded systems", + "abstract": "This paper describe a model-driven development (MDD) toolsuite called Component Synthesis using Model-Integrated Computing (CoSMIC), which configures and deploys distributed real-time and embedded (DRE) systems using quality of service (QoS)-enabled component middleware. We show how CoSMIC addresses crosscutting configuration and deployment concerns at multiple layers of middleware and applications in component-based DRE systems. We also discuss how CoSMIC leverages model checking and analysis tools to validate key properties for configured DRE systems.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028758", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aniruddha", + "last_name": "Gokhale", + "institution": "Vanderbilt University" + }, + { + "first_name": "Krishnakumar", + "last_name": "Balasubramanian", + "institution": "Vanderbilt University" + }, + { + "first_name": "Tao", + "last_name": "Lű", + "institution": "Vanderbilt University" + } + ], + "dblp_key": "conf/oopsla/GokhaleBL04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028756", + "title": "WSAgent: an agent based on web services to promote interoperability between heterogeneous systems in the health domain", + "abstract": "This paper describes a Software Agent called WSAgent, which combines technologies such as Web Services, Frameworks and Design Patterns in the construction of a bind to grant interoperability, reuse and flexibility between heterogeneous environments in the health domain.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028756", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Letícia Rafaela", + "last_name": "Rheinheimer", + "institution": "Universidade do Vale do Rio dos Sinos" + }, + { + "first_name": "Junior M.", + "last_name": "Martins", + "institution": "Universidade do Vale do Rio dos Sinos" + }, + { + "first_name": "Sérgio Crespo Coelho da Silva", + "last_name": "Pinto", + "institution": "Universidade do Vale do Rio dos Sinos" + } + ], + "dblp_key": "conf/oopsla/RheinheimerMP04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028755", + "title": "iXj: interactive source-to-source transformations for java", + "abstract": "Manual large-scale modification or generation of source code can be tedious and error-prone. Integrating scriptable source-to-source program transformations into development environments will assist developers with this overwhelming task. We discuss various usability issues of bringing such ad-hoc transformations to end-users and describe a developer-oriented interactive source code transformation tool for Java that we are building.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028755", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marat", + "last_name": "Boshernitsan", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Susan L.", + "last_name": "Graham", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/BoshernitsanG04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028759", + "title": "SODA: a stability-oriented domain analysis method", + "abstract": "In work to date, domain analysis methods do not explicitly emphasize stability. In this poster, we present the SODA (Stability-Oriented Domain Analysis) method, a domain analysis method that embraces stability as a driver for domain analysis. We give an overview and an example of the method.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028759", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haitham S.", + "last_name": "Hamza", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "conf/oopsla/Hamza04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028760", + "title": "Model synchronization as a problem of maximizing model dependencies", + "abstract": "During the course of its evolution, software is modified through models at different levels of abstraction, from the requirements specification to source code. To enable systematic development and maintenance, related models need to be kept synchronized. In order to establish and maintain consistency, we need to precisely define what it means for two models to be synchronized. In this paper, we present our view of model synchronization as a problem of maximizing model dependencies. Our conceptual view of software models is as graphs, and model transformations are viewed in terms of basic graph transformations such as node insertions and deletions. Based on this view, a set of transformations applied to one model is traced and propagated to the other by choosing, from a set of possible transformation paths, a path that maximizes underlying model dependencies.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028760", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Igor", + "last_name": "Ivkovic", + "institution": "University of Waterloo" + }, + { + "first_name": "Kostas", + "last_name": "Kontogiannis", + "institution": "Technical University of Crete" + } + ], + "dblp_key": "conf/oopsla/IvkovicK04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028762", + "title": "JIVE: Java Interactive Visualization Environment", + "abstract": "Jive represents a novel approach to runtime visualization and analysis of Java programs. It facilitates program understanding and interactive debugging, featuring: multiple, customizable views of object structure; representation of execution history via sequence diagrams; interactive queries on runtime behavior; forward and reverse interactive execution. JIVE uses standard JVM and compilers.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028762", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "Gestwicki", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Bharat", + "last_name": "Jayaraman", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "conf/oopsla/GestwickiJ04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028764", + "title": "The software architect: essence, intuition, and guiding principles", + "abstract": "Software architecture is a distinct and developing discipline in the software profession. Many practitioners have apparently entered the field with little effort; adding the word \"architect\" to a title is easy to do. However, beneath the surface appearance, distinct approaches and toolsets are required to succeed. Reports of IT overspending and project failures emphasize the fact that these skills must be leveraged and developed. The practical application of this growing body of knowledge will continue to play an important role in the maturing of our profession, and its ability to deliver effective solutions. The software architect possesses a unique perspective and mental framework that guides the development of software systems. Additionally, strong interpersonal skills are vital to the software architect's success. In this paper, I explore the unique approaches and characteristics of the successful software architect.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028764", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew R.", + "last_name": "McBride", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/McBride04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028761", + "title": "Reflective composition: the declarative composition of roles to unify objects, roles, and aspects", + "abstract": "As bases for object-orientation, both class-based and prototype-based organization have limitations. We argue that roles have significant benefits as a foundation for organizing objects. We further argue that these benefits can be realised most flexibly using logic meta-programming. Additional benefits from this approach are to reduce redundancy and subsume aspects.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028761", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Simon", + "last_name": "Holland", + "institution": "The Open University" + } + ], + "dblp_key": "conf/oopsla/Holland04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028766", + "title": "Comparison of UML and text based requirements engineering", + "abstract": "There appears to be a real dichotomy in the use of the UML vs. text based Use Case development for requirements elicitation and documentation, that is, on those projects where use cases are work products. Not only are there different processes in place for text and graphical use case modeling, but also there are a variety of approaches and philosophies in each camp. This paper will discuss the prose vs. graphical approaches to requirements elicitation, observed advantages and disadvantages of each, and suggest best practices for improving and/or creating effective processes for requirements elicitation.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028766", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brian", + "last_name": "Berenbach", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/oopsla/Berenbach04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028765", + "title": "Mock roles, objects", + "abstract": "Mock Objects is an extension to Test-Driven Development that supports good Object-Oriented design by guiding the discovery of a coherent system of types within a code base. It turns out to be less interesting as a technique for isolating tests from third-party libraries than is widely thought. This paper describes the process of using Mock Objects with an extended example and reports best and worst practices gained from experience of applying the process. It also introduces jMock, a Java framework that embodies our collective experience.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028765", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steve", + "last_name": "Freeman", + "institution": "" + }, + { + "first_name": "Tim", + "last_name": "Mackinnon", + "institution": "" + }, + { + "first_name": "Nat", + "last_name": "Pryce", + "institution": "" + }, + { + "first_name": "Joe", + "last_name": "Walnes", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FreemanMPW04a", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028767", + "title": "PIP: a product planning strategy for the whole family or... how we became the brady bunch", + "abstract": "As a small start-up company with a heavyweight client list, Sabrix found itself at a critical crossroads in its growth in the Spring of 2003. We were consuming all product development resources satisfying commitments made to existing customers, which seriously limited our ability to react to new requirements and improve our competitive edge in the market. In the face of this resource strain, we needed to add a series of smaller, plug-in type products to our existing offering. Of course, this environment required 100% focus on day-to-day tasks and tactical issues, leaving no time or energy for looking ahead.Compounding these problems were the same issues that every company faces. A lack of trust between functional groups, with Product Development on one side and Sales and Support on the other; and, very few people in the company knew what work was being done in Product Development. When stepping back from the situation, we realized that all of the problems could be grouped into three general categories - prioritization, collaboration and visibility.To improve each of these areas, we developed the Product Input and Planning (PIP) process. PIP is a cross-functional, cross-product way of building a roadmap by prioritizing work, balancing competitiveness and customer-driven requirements, and improving product-related communication in all directions within the company. The PIP Team is responsible for prioritizing and building an 18-month roadmap, focusing on the future direction of the company, while Product Management and Product Development focus on delivering the current releases.This paper is not what one would call a success story, though it unquestionably has a moral. The PIP process as described herein exists no longer. Several factors contributed to its morphing into a different kind of family. The lessons learned over the course of the lifetime of PIP, however, are applicable to almost any large-scale, cross-functional endeavor.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028767", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph A.", + "last_name": "Blotner", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Blotner04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028768", + "title": "eXtreme ISO ?!?", + "abstract": "This Report discusses how a web-based application development project adopted XP and passed its first ISO audit. The practitioners report will consist of background material, a discussion of XP-friendly practices that the development team adopted, a discussion of how ISO-friendly practices were incorporated, and a summary of the results of the ISO audit.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028768", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aki", + "last_name": "Namioka", + "institution": "Cisco Systems (United States)" + }, + { + "first_name": "Cary A.", + "last_name": "Bran", + "institution": "Cisco Systems (United States)" + } + ], + "dblp_key": "conf/oopsla/NamiokaB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028770", + "title": "Hard real-time: C++ versus RTSJ", + "abstract": "In the domain of hard real-time systems, which language is better: C++ or the Real-Time Specification for Java (RTSJ)? Although standard Java provides a more productive programming environment than C++ due to automatic memory management, that benefit does not apply to RTSJ when using NoHeapRealtimeThread and non-heap memory areas. As a result, RTSJ programmers must manage non-heap memory explicitly. Although that's a common practice in real-time applications, it's also a common source of programmer error, regardless of language. In an ironic role reversal, this paper shows that C++ is able to provide a safer programming environment than RTSJ (or C) for managing memory in a hard-real-time producer/consumer pattern. C++ accomplishes this via a reference-counting pointer. RTSJ (and C) cannot provide an equivalent mechanism because it lacks the necessary language features. Despite other attractive features of RTSJ, the relative simplicity and safety of the C++ programming model for this common pattern suggests that C++ will be a strong competitor to RTSJ in the domain of real-time mission-critical systems.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028770", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Dvorak", + "institution": "Jet Propulsion Laboratory" + }, + { + "first_name": "William K.", + "last_name": "Reinholtz", + "institution": "Jet Propulsion Laboratory" + } + ], + "dblp_key": "conf/oopsla/DvorakR04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028769", + "title": "Why reuse matters: ANI's digital archive system", + "abstract": "This practitioner report stems from a project, ANI's Digital Archive System. The report focuses on the benefits derived from a decision to ignore the popular wisdom of acquiring one of the many commercial-off-the-shelf (COTS) systems and build a document management system in-house instead. The approach, building on the existing set of object-oriented systems, provided the benefits of more specific features and total lower cost.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028769", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Antion", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Antion04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028771", + "title": "Traits: experience with a language feature", + "abstract": "This paper reports our experiences using traits, collections of pure methods designed to promote reuse and understandability in object-oriented programs. Traits had previously been used to refactor the Smalltalk collection hierarchy, but only by the creators of traits themselves. This experience report represents the first independent test of these language features. Murphy-Hill implemented a substantialmulti-class data structure called ropes that makes significant use of traits. We found that traits improved understandability and reduced the number of methods that needed to be written by 46%.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028771", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emerson", + "last_name": "Murphy-Hill", + "institution": "The Evergreen State College" + }, + { + "first_name": "Andrew P.", + "last_name": "Black", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "conf/oopsla/Murphy-HillB04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028773", + "title": "Migrating to simpler distributed applications", + "abstract": "In 1994 Wells Fargo Bank was the first large financial services company to invest heavily in distributed object-oriented applications for high-volume, mission-critical applications using version 1 of OMG's Common Object Request Broker Architecture. Wells Fargo continued to improve upon its distributed applications technology leadership by launching a Model Driven Architecture [MDA] initiative in 1999. The technology provided a consistent middle-tier for retail applications such as the award-winning Wells Internet Bank and various phone-bank applications.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028773", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joachim F.", + "last_name": "Kainz", + "institution": "Wells Fargo (United States)" + } + ], + "dblp_key": "conf/oopsla/Kainz04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028777", + "title": "NGMF: a generic framework for constructing graph-based systems", + "abstract": "Many branches of engineering and science rely on graphs for representing a wide variety of objects from electrical circuits to economic systems. It is therefore reasonable to have a framework for constructing this kind of applications that can manage a graph structure. Nebras Graph Management Framework (NGMF) is a layered client-server framework for rapid development of these applications. This framework allows developers to construct different applications that deal with a network of nodes and edges. For example a CASE tool that handles UML class diagrams, a subject manager (an application for business entity classification) or a system for managing hierarchal lists of all product components (Bill Of Materials or BOM) are some cases that can be designed through applying our proposed framework.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028777", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hadi", + "last_name": "Salimi", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Salimi04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028779", + "title": "A framework for removing redundant context management services in enterprise javaBeans application servers", + "abstract": "We propose a framework for removing redundant context management services in contextual composition frameworks, with focus on Enterprise JavaBeans. It is expected that by applying our framework, performance can be improved without the loss of modularity.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028779", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mircea", + "last_name": "Trofin", + "institution": "Dublin City University" + } + ], + "dblp_key": "conf/oopsla/Trofin04a", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028781", + "title": "A framework for detecting, assessing and visualizing performance antipatterns in component based systems", + "abstract": "Component-based enterprise systems often suffer from performance issues as a result of poor system design. In this paper, we propose a framework to automatically detect, assess and visualize poor system design, from a performance perspective, by analyzing run-time data using data mining techniques.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028781", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Trevor", + "last_name": "Parsons", + "institution": "Dublin City University" + } + ], + "dblp_key": "conf/oopsla/Parsons04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028783", + "title": "Enhancing distributed object middleware qualities", + "abstract": "No abstract available.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028783", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arvind S.", + "last_name": "Krishna", + "institution": "Vanderbilt University" + } + ], + "dblp_key": "conf/oopsla/Krishna04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028780", + "title": "A language-independent approach to software maintenance using grammar adapters", + "abstract": "A long-standing goal of software engineering is to construct software that is easily modified and extended. Recent advances in software design techniques, such as aspect-oriented software development and refactoring, have offered new approaches to address challenges of software evolution. Several tools and language extensions have been developed by others to enable these techniques in a few popular programming languages. However, software exists in a variety of languages. An unfortunate consequence of legacy system adaptation is that new software engineering tools are often developed from scratch without preserving and reusing the knowledge gained from the previous construction of the tool in a different language and platform context. To address this problem, this paper summarizes two core research ideas. First, the concept of extending several software reengineering techniques in disparate programming languages is explored. A core focus of this objective is the abstraction of transformation functions to enable design maintenance in legacy based systems. The second research objective extends the first goal to understand the fundamental science for constructing a generic platform using grammar adapters to enable language-independent software maintenance.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028780", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Suman", + "last_name": "Roychoudhury", + "institution": "University of Alabama at Birmingham" + } + ], + "dblp_key": "conf/oopsla/Roychoudhury04a", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028784", + "title": "Identification of reusable components within an object-oriented software system using algebraic graph theory", + "abstract": "A novel method for identifying dense communities of classes (clusters) within an Object-Oriented system has been developed. Such communities might possibly imply relevance of functionality and thus be used as Reusable Components. The term \"Reusable Components\" is used to refer to a set of interrelated classes that represent a module that can be used in different software systems. To accomplish this identification we employ Algebraic Graph Theory (Spectral Graph Partitioning Techniques). From a modified class diagram of the software system we create a graph in which classes stand for the nodes and the discrete messages exchanged between the classes stand for the edges. Our approach is based on an iterative method for partitioning the graph in order to identify possible reusable components within the system. The eigenvectors of the Laplacian matrix derived from the graph are used for the partitioning.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028784", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Spiros", + "last_name": "Xanthos", + "institution": "University of Macedonia" + } + ], + "dblp_key": "conf/oopsla/Xanthos04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028774", + "title": "Validating structural properties of nested objects", + "abstract": "Frameworks are widely used to facilitate software reuse and accelerate development time. However, there are currently no systematic mechanisms to enforce the explicit and implicit rules of these frameworks. This paper focuses on a class of framework rules that place restrictions on the properties of data structures in framework applications. We present a mechanism to enforce these rules by the use of a generic \"bad store template\" which can be customized for different rule instances. We demonstrate the use of this template to validate specific bad store rules within J2EE framework applications. Violations of these rules cause subtle defects which manifest themselves at runtime as data loss, data corruption, or race conditions. Our algorithm to detect \"bad stores\" is implemented in the Smart Analysis-Based Error Reduction (SABER) validation tool, where we pay special attention to facilitating problem understanding and remediation, by providing detailed problem explanations. We present experimental results on four commercially deployed e-commerce applications that show over 200 \"bad stores\".", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028774", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Darrell", + "last_name": "Reimer", + "institution": "IBM (United States)" + }, + { + "first_name": "Edith", + "last_name": "Schonberg", + "institution": "IBM (United States)" + }, + { + "first_name": "Kavitha", + "last_name": "Srinivas", + "institution": "IBM (United States)" + }, + { + "first_name": "Harini", + "last_name": "Srinivasan", + "institution": "IBM (United States)" + }, + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "IBM (United States)" + }, + { + "first_name": "Aaron", + "last_name": "Kershenbaum", + "institution": "IBM (United States)" + }, + { + "first_name": "Larry", + "last_name": "Koved", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/ReimerSSSDKK04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028778", + "title": "Supporting software evolution through model-driven program transformation", + "abstract": "Model-Driven Software Development (MDSD) techniques are being adopted with more frequency in the engineering of computer based systems, especially in the area of distributed real-time embedded (DRE) systems. This brief summary presents two research objectives for supporting software evolution in MDSD. First, the concept of model-driven program transformation is introduced to support evolution of large legacy software systems. The second research objective that is presented involves the application of a mature program transformation engine to automate model interpreter evolution in the presence of meta-model schema changes.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028778", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jing", + "last_name": "Zhang", + "institution": "University of Alabama at Birmingham" + } + ], + "dblp_key": "conf/oopsla/Zhang04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028772", + "title": "Second generation web services-oriented architecture in production in the finance industry", + "abstract": "Effective and affordable business process integration is a key concern in the finance industry. A large German joint-use centre, supplying services to 237 individual savings banks, enhanced the integration capabilities of its core banking system, consisting of more than 500 complex functions, through aggressive use of Web services.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028772", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Olaf", + "last_name": "Zimmermann", + "institution": "IBM (United States)" + }, + { + "first_name": "Sven", + "last_name": "Milinski", + "institution": "IBM (United States)" + }, + { + "first_name": "Michael", + "last_name": "Craes", + "institution": "" + }, + { + "first_name": "Frank", + "last_name": "Oellermann", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/ZimmermannMCO04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028776", + "title": "A lightweight LTL runtime verification tool for java", + "abstract": "Runtime verification is a special form of runtime testing, employing formal methods and languages. In this work, we utilize next-time free linear-time temporal logic (LTL\\textbackslash X) as formal framework. The discipline serves the purpose of asserting certain design-time assumptions about object-oriented (OO) entities such as objects, methods, and so forth. In this paper we propose a linear-time logic over joinpoints \\citeLaddad03AspectJ, and introduce a lightweight runtime veri\\-fication tool based on this logic, J2SE 5 metadata \\citeJSR175 and an AspectJ-based \\citeAspectJ runtime backend. Implementations have been proposed so far for imperative and functional languages \\citeHuchStolz04a. To our knowledge our approach is the first to allow addressing of entire sets of states, also over subclass boundaries, thus exploiting the OO nature.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028776", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "conf/oopsla/Bodden04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028785", + "title": "Automatic identification of common and special object-oriented unit tests", + "abstract": "Common and special test inputs can be created to exercise some common and special behavior of the class under test, respectively. Although manually created tests are valuable, programmers often overlook some special test inputs. If programmers write down specifications, special or common tests can be automatically generated and selected by tools. However, specifications are not commonly written in practice. This research develops a novel approach for automatically identifying common and special unit tests for a class without requiring any specification. Given a class, our approach automatically generates test inputs and identifies common and special tests among the generated tests. Programmers can inspect these identified tests and use them to augment existing (manual) tests. Our approach is based on statistical algebraic abstractions, program properties (in the form of algebraic specifications) dynamically inferred from test executions. We use statistical algebraic abstractions to characterize program behavior. A test is identified to be common if the test exercises a behavior that is universally or commonly exercised by generated tests, or to be special if the test violates a behavior that is commonly exercised by generated tests.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028785", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tao", + "last_name": "Xie", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/Xie04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028787", + "title": "Empirical investigation of the impact of extreme programming practices on software projects", + "abstract": "Extreme Programming (XP) is an agile software development methodology composed of several practices that purportedly yield high quality and high customer satisfaction. However, there has been little formal investigation of these claims. We conduct empirical, industrial case studies to evaluate XP. Results from two case studies are presented.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028787", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lucas", + "last_name": "Layman", + "institution": "North Carolina State University" + } + ], + "dblp_key": "conf/oopsla/Layman04", + "venue": "oopsla", + "year": 2004 + }, + { + "paper_id": "10.1145/1028664.1028786", + "title": "Reverse engineering of UML specifications from java programs", + "abstract": "In the present work, we outline a reverse engineering approach for UML specifications in form of class diagrams from Java bytecode. After a brief introduction to the subject we present some analyses which go beyond mere enumeration of methods and fields. A glance onto some related work shows that there seems to be no pat solution for the reverse engineering of the more difficult class diagram elements.", + "date": "2004-10-23", + "link": "https://doi.org/10.1145/1028664.1028786", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Keschenau", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "conf/oopsla/Keschenau04", + "venue": "oopsla", + "year": 2004 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2005.json b/data/pl_conferences/oopsla/2005.json new file mode 100644 index 0000000..ff5bc73 --- /dev/null +++ b/data/pl_conferences/oopsla/2005.json @@ -0,0 +1,898 @@ +[ + { + "paper_id": "10.1145/1094811.1094827", + "title": "Interaction-based programming with classages", + "abstract": "This paper presents Classages, a novel interaction-centric object-oriented language. Classes and objects in Classages are fully encapsulated, with explicit interfaces for all interactions they might be involved in. The design of Classages touches upon a wide range of language design topics, including encapsulation, object relationship representation, and object confinement. An encoding of Java's OO model in Classages is provided, showing how standard paradigms are supported. A prototype Classages compiler is described.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094827", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/oopsla/LiuS05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094832", + "title": "Refactoring support for class library migration", + "abstract": "As object-oriented class libraries evolve, classes are occasionally deprecated in favor of others with roughly the same functionality. In Java's standard libraries, for example, class Hashtable has been superseded by HashMap, and Iterator is now preferred over Enumeration. Migrating client applications to use the new idioms is often desirable, but making the required changes to declarations and allocation sites can be quite labor-intensive. Moreover, migration becomes complicated---and sometimes impossible---if an application interacts with external components, if a legacy class is not completely equivalent to its replacement, or if multiple interdependent classes must be migrated simultaneously. We present an approach in which mappings between legacy classes and their replacements are specified by the programmer. Then, an analysis based on type constraints determines where declarations and allocation sites can be updated. The method was implemented in Eclipse, and evaluated on a number of Java applications. On average, our tool could migrate more than 90% of the references to legacy classes.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094832", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ittai", + "last_name": "Balaban", + "institution": "New York University" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Robert M.", + "last_name": "Fuhrer", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/BalabanTF05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094823", + "title": "Parametric polymorphism for software component architectures", + "abstract": "Parametric polymorphism has become a common feature of mainstream programming languages, but software component architectures have lagged behind and do not support it. We examine the problem of providing parametric polymorphism with components combined from different programming languages. We have investigated how to resolve different binding times and parametrization semantics in a range of representative languages and have identified a common ground that can be suitably mapped to different language bindings. We present a generic component architecture extension that provides support for parameterized components and that can be easily adapted to work on top of various software component architectures in use today (e.g., corba, dcom, jni). We have implemented and tested this architecture on top of corba. We also present Generic Interface Definition Language (gidl), an extension to corba-idl supporting generic types and we describe language bindings for C++, Java and Aldor. We explain our implementation of gidl, consisting of a gidl to idl compiler and tools for generating linkage code under the language bindings. We demonstrate how this architecture can be used to access C++'s stl and Aldor's BasicMath libraries in a multi-language environment and discuss our mappings in the context of automatic library interface generation.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094823", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cosmin E.", + "last_name": "Oancea", + "institution": "Western University" + }, + { + "first_name": "Stephen M.", + "last_name": "Watt", + "institution": "Western University" + } + ], + "dblp_key": "conf/oopsla/OanceaW05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094830", + "title": "Fine-grained interoperability through mirrors and contracts", + "abstract": "As a value flows across the boundary between interoperating languages, it must be checked and converted to fit the types and representations of the target language. For simple forms of data, the checks and coercions can be immediate; for higher order data, such as functions and objects, some must be delayed until the value is used in a particular way. Typically, these coercions and checks are implemented by an ad-hoc mixture of wrappers, reflection, and dynamic predicates. We observe that 1) the wrapper and reflection operations fit the profile of mirrors, 2) the checks correspond to contracts, and 3) the timing and shape of mirror operations coincide with the timing and shape of contract operations. Based on these insights, we present a new model of interoperability that builds on the ideas of mirrors and contracts, and we describe an interoperable implementation of Java and Scheme that is guided by the model.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094830", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kathryn E.", + "last_name": "Gray", + "institution": "University of Utah" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "University of Chicago" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/oopsla/GrayFF05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094831", + "title": "Pluggable AOP: designing aspect mechanisms for third-party composition", + "abstract": "Studies of Aspect-Oriented Programming (AOP) usually focus on a language in which a specific aspect extension is integrated with a base language. Languages specified in this manner have a fixed, non-extensible AOP functionality. In this paper we consider the more general case of integrating a base language with a set of domain specific third-party aspect extensions for that language. We present a general mixin-based method for implementing aspect extensions in such a way that multiple, independently developed, dynamic aspect extensions can be subject to third-party composition and work collaboratively.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094831", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sergei", + "last_name": "Kojarski", + "institution": "University of Virginia" + }, + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/oopsla/KojarskiL05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094821", + "title": "ArchMatE: from architectural styles to object-oriented models through exploratory tool support", + "abstract": "Given the difficulties of conventional object technologies to deal with quality-attribute concerns, software architectures appear as an interesting approach to manage them better. A problem to make this approach feasible is the gap between architectural and object models. Succeeding in bridging these two worlds implies that those design decisions about quality attributes made at the architectural level should be reflected at the object level. Nonetheless, a given architecture usually admits multiple, different materializations. Furthermore, any materialization requires considerable design background and experience from the developer. In this paper, we describe a tool approach, called ArchMatE, to assist developers in the exploration of object-oriented solutions for grounding specific architectural models. An important aspect of the approach is that the materializations are accomplished by means of quality-oriented strategies, so that those concerns prescribed by the original architecture are mostly preserved.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094821", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "J. Andrés", + "last_name": "Díaz‐Pace", + "institution": "Consejo Nacional de Investigaciones Científicas y Técnicas" + }, + { + "first_name": "Marcelo", + "last_name": "Campo", + "institution": "Consejo Nacional de Investigaciones Científicas y Técnicas" + } + ], + "dblp_key": "conf/oopsla/PaceC05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094814", + "title": "Generalized algebraic data types and object-oriented programming", + "abstract": "Generalized algebraic data types (GADTs) have received much attention recently in the functional programming community. They generalize the (type) parameterized algebraic datatypes (PADTs) of ML and Haskell by permitting value constructors to return specific, rather than parametric, typeinstantiations of their own datatype. GADTs have a number of applications, including strongly-typed evaluators, generic pretty-printing, generic traversals and queries, and typed LR parsing. We show that existing object-oriented programming languages such as Java and C ♯ can express GADT definitions, and a large class of GADT-manipulating programs, through the use of generics, subclassing, and virtual dispatch. However, some programs can be written only through the use of redundant runtime casts. Moreover, instantiationspecific, yet safe, operations on ordinary PADTs only admit indirect cast-free implementations, via higher-order encodings. We propose a generalization of the type constraint mechanisms of C ♯ and Java to both avoid the need for casts in GADT programs and higher-order contortions in PADT programs; we present a Visitor pattern for GADTs, and describe a refined switch construct as an alternative to virtual dispatch on datatypes. We formalize both extensions and prove type soundness.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094814", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Kennedy", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Claudio", + "last_name": "Russo", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/KennedyR05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094818", + "title": "Deriving object typestates in the presence of inter-object references", + "abstract": "We are interested in static analysis of Java classes with the goal of discovering the preconditions under which a certain program point within a method may be reached, taking into account the effects of previous method calls on an object of that class. The information pertinent to this computation is represented as the object's typestate, which is a finite set of relevant predicates that abstract the object's actual state. The execution of a method depends on an object's current typestate as well as other input parameters; the object may transition to a different typestate during the method's execution.It is common for objects to contain references to other ob-jects. In such cases, an object's behavior may depend on, in addition to its own state, the state of objects it has a refer-ence to. The main contribution of this paper is to discover relevant object typestates, as well as transitions between typestates, in the presence of inter-object references. Our analysis first performs a combined predicate discovery and predicate abstraction to derive \"boolean\" versions of Java classes given as input. It then uses abstract interpretation to compute the typestate transitions caused by method calls. A novel aspect of this work is that a set of Java classes is analyzed in isolation, without any client program being pro-vided. To do this, the analysis simulates all possible client's actions via a synthetic heap, all of whose interesting config-urations are explored by our analysis.The information we compute can be put to use in several ways. It can be used in checking whether a given client code erroneously uses a set of Java classes in a way that can throw an exception. It can also be used in creating test drivers for Java classes in order to exercise all relevant code paths in the corresponding methods.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094818", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mangala Gowri", + "last_name": "Nanda", + "institution": "IBM (United States)" + }, + { + "first_name": "Christian", + "last_name": "Grothoff", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "IBM Research - India" + } + ], + "dblp_key": "conf/oopsla/NandaGC05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094819", + "title": "Micro patterns in Java code", + "abstract": "Micro patterns are similar to design patterns, except that micro patterns are stand at a lower, closer to the implementation, level of abstraction. Micro patterns are also unique in that they are mechanically recognizable, since each such pattern can be expressed as a formal condition on the structure of a class.This paper presents a catalog of 27 micro-patterns defined on Java classes and interfaces. The catalog captures a wide spectrum of common programming practices, including a particular and (intentionally restricted) use of inheritance, immutability, data management and wrapping, restricted creation, and emulation of procedural-, modular-, and even functional- programming paradigms with object oriented constructs. Together, the patterns present a set of prototypes after which a large portion of all Java classes and interfaces are modeled. We provide empirical indication that this portion is as high as 75%.A statistical analysis of occurrences of micro patterns in a large software corpus, spanning some 70,000 Java classes drawn from a rich set of application domains, shows, with high confidence level that the use of these patterns is not random. These results indicate consciousness and discernible design decisions, which are sustained in the software evolution. With high confidence level, we can also show that the use of these patterns is tied to the specification, or the purpose, that the software realizes.The traceability, abundance and the statistical significance of micro pattern occurrence raise the hope of using the classification of software into these patterns for a more founded appreciation of its design and code quality.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094819", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Itay", + "last_name": "Maman", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/GilM05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094828", + "title": "Javari: adding reference immutability to Java", + "abstract": "This paper describes a type system that is capable of expressing and enforcing immutability constraints. The specific constraint expressed is that the abstract state of the object to which an immutable reference refers cannot be modified using that reference. The abstract state is (part of) the transitively reachable state: that is, the state of the object and all state reachable from it by following references. The type system permits explicitly excluding fields from the abstract state of an object. For a statically type-safe language, the type system guarantees reference immutability. If the language is extended with immutability downcasts, then run-time checks enforce the reference immutability constraints.This research builds upon previous research in language support for reference immutability. Improvements that are new in this paper include distinguishing the notions of assignability and mutability; integration with Java 5's generic types and with multi-dimensional arrays; a mutability polymorphism approach to avoiding code duplication; type-safe support for reflection and serialization; and formal type rules and type soundness proof for a core calculus. Furthermore, it retains the valuable features of the previous dialect, including usability by humans (as evidenced by experience with 160,000 lines of Javari code) and interoperability with Java and existing JVMs.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094828", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew S.", + "last_name": "Tschantz", + "institution": "IIT@MIT" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "IIT@MIT" + } + ], + "dblp_key": "conf/oopsla/TschantzE05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094826", + "title": "Classbox/J: controlling the scope of change in Java", + "abstract": "Unanticipated changes to complex software systems can introduce anomalies such as duplicated code, suboptimal inheritance relationships and a proliferation of run-time downcasts. Refactoring to eliminate these anomalies may not be an option, at least in certain stages of software evolution. Classboxes are modules that restrict the visibility of changes to selected clients only, thereby offering more freedom in the way unanticipated changes may be implemented, and thus reducing the need for convoluted design anomalies. In this paper we demonstrate how classboxes can be implemented in statically-typed languages like Java. We also present an extended case study of Swing, a Java GUI package built on top of AWT, and we document the ensuing anomalies that Swing introduces. We show how Classbox/J, a prototype implementation of classboxes for Java, is used to provide a cleaner implementation of Swing using local refinement rather than subclassing.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094826", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexandre", + "last_name": "Bergel", + "institution": "University of Bern" + }, + { + "first_name": "Sté́phane", + "last_name": "Ducasse", + "institution": "University of Bern" + }, + { + "first_name": "Oscar", + "last_name": "Nierstrasz", + "institution": "University of Bern" + } + ], + "dblp_key": "conf/oopsla/BergelDN05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094813", + "title": "Associated types and constraint propagation for mainstream object-oriented generics", + "abstract": "Support for object-oriented programming has become an integral part of mainstream languages, and more recently generic programming has gained widespread acceptance as well. A natural question is how these two paradigms, and their underlying language mechanisms, should interact. One particular design option, that of using subtyping to constrain the type parameters of generic functions, has been chosen in the generics of Java and those planned for a future revision of C#.Certain shortcomings have previously been identified in using subtyping for constraining parametric polymorphism in the context of generic programming.To address these, we propose extending object-oriented interfaces and subtyping to include associated types and constraint propagation.Associated types are type members of interfaces and classes. Constraint propagation allows certain constraints on type parameters to be inferred from other constraints on those parameters and their use in base class type expressions.The paper demonstrates these extensions in the context of C# (with generics), describes a translation of the extended features to C#, and presents a formalism proving their safety. The formalism is applicable to other mainstream object-oriented languages supporting F-bounded polymorphism, such as Java.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094813", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jaakko", + "last_name": "Järvi", + "institution": "Texas A&M University" + }, + { + "first_name": "Jeremiah", + "last_name": "Willcock", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Andrew", + "last_name": "Lumsdaine", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/oopsla/JarviWL05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094815", + "title": "Scalable component abstractions", + "abstract": "We identify three programming language abstractions for the construction of re-usable components: abstract type members, explicit selftypes and symmetric mixin composition. Together, these abstractions enable us to transform an arbitrary assembly of static program parts with hard references between them into a system of re-usable components. The transformation maintains the structure of the original system. We demonstrate this approach in two case studies, a subject/observer framework and a compiler front-end.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094815", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Matthias", + "last_name": "Zenger", + "institution": "Google (Switzerland)" + } + ], + "dblp_key": "conf/oopsla/OderskyZ05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094817", + "title": "Demand-driven points-to analysis for Java", + "abstract": "We present a points-to analysis technique suitable for environments with small time and memory budgets, such as just-in-time (JIT) compilers and interactive development environments (IDEs). Our technique is demand-driven, performing only the work necessary to answer each query (a request for a variable's points-to information) issued by a client. In cases where even the demand-driven approach exceeds the time budget for a query, we employ early termination, i.e., stopping the analysis prematurely and returning an over-approximated result to the client. Our technique improves on previous demand-driven points-to analysis algorithms [17, 33] by achieving much higher precision under small time budgets and early termination.We formulate Andersen's analysis [5] for Java as a CFL-reachability problem [33]. This formulation shows that Andersen's analysis for Java is a balanced-parentheses problem, an insight that enables our new techniques. We exploit the balanced parentheses structure to approximate Andersen's analysis by regularizing the CFL-reachability problem, yielding an asymptotically cheaper algorithm. We also show how to regain most of the precision lost in the regular approximation as needed through refinement. Our evaluation shows that our regularization and refinement approach achieves nearly the precision of field-sensitive Andersen's analysis in time budgets as small as 2ms per query. Our technique can yield speedups of up to 16x over computing an exhaustive Andersen's analysis for some clients, with little to no precision loss.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094817", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Denis", + "last_name": "Gopan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Lexin", + "last_name": "Shan", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/SridharanGSB05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094822", + "title": "Modeling architectural patterns using architectural primitives", + "abstract": "Architectural patterns are a key point in architectural documentation. Regrettably, there is poor support for modeling architectural patterns, because the pattern elements are not directly matched by elements in modeling languages, and, at the same time, patterns support an inherent variability that is hard to model using a single modeling solution. This paper proposes tackling this problem by finding and representing architectural primitives, as the participants in the solutions that patterns convey. In particular, we examine a number of architectural patterns to discover those primitive abstractions that are common among the patterns, and at the same time demonstrate a degree of variability in each pattern. These abstractions belong in the components and connectors architectural view, though more abstractions can be found in other views. We have selected UML 2 as the language for representing these primitive abstractions as extensions of the standard UML elements. The added value of this approach is twofold: it proposes a generic and extensible approach for modeling architectural patterns by means of architectural primitives; it demonstrates an initial set of primitives that participate in several well-known architectural patterns.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094822", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Uwe", + "last_name": "Zdun", + "institution": "Vienna University of Economics and Business" + }, + { + "first_name": "Paris", + "last_name": "Avgeriou", + "institution": "Fraunhofer Institute for Secure Information Technology" + } + ], + "dblp_key": "conf/oopsla/ZdunA05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094824", + "title": "Using dependency models to manage complex software architecture", + "abstract": "An approach to managing the architecture of large software systems is presented. Dependencies are extracted from the code by a conventional static analysis, and shown in a tabular form known as the 'Dependency Structure Matrix' (DSM). A variety of algorithms are available to help organize the matrix in a form that reflects the architecture and highlights patterns and problematic dependencies. A hierarchical structure obtained in part by such algorithms, and in part by input from the user, then becomes the basis for 'design rules' that capture the architect's intent about which dependencies are acceptable. The design rules are applied repeatedly as the system evolves, to identify violations, and keep the code and its architecture in conformance with one another. The analysis has been implemented in a tool called LDM which has been applied in several commercial projects; in this paper, a case study application to Haystack, an information retrieval system, is described.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094824", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Neeraj", + "last_name": "Sangal", + "institution": "" + }, + { + "first_name": "Ev", + "last_name": "Jordan", + "institution": "" + }, + { + "first_name": "Vineet", + "last_name": "Sinha", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Daniel", + "last_name": "Jackson", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/SangalJSJ05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094841", + "title": "Relational queries over program traces", + "abstract": "Instrumenting programs with code to monitor runtime behavior is a common technique for profiling and debugging. In practice, instrumentation is either inserted manually by programmers, or automatically by specialized tools that monitor particular properties. We propose Program Trace Query Language (PTQL), a language based on relational queries over program traces, in which programmers can write expressive, declarative queries about program behavior. We also describe our compiler, Partiqle. Given a PTQL query and a Java program, Partiqle instruments the program to execute the query on-line. We apply several PTQL queries to a set of benchmark programs, including the Apache Tomcat Web server. Our queries reveal significant performance bugs in the jack SpecJVM98 benchmark, in Tomcat, and in the IBM Java class library, as well as some correct though uncomfortably subtle code in the Xerces XML parser. We present performance measurements demonstrating that our prototype system has usable performance.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094841", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Simon F.", + "last_name": "Goldsmith", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Robert", + "last_name": "O'Callahan", + "institution": "Micro Focus (United States)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/GoldsmithOA05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094834", + "title": "Automating vertical profiling", + "abstract": "Last year at OOPSLA we presented a methodology, vertical profiling, for understanding the performance of object-oriented programs. The key insight behind this methodology is that modern programs run on top of many layers (virtual machine, middleware, etc) and thus we need to collect and combine information from all layers in order to understand system performance. Although our methodology was able to explain previously unexplained performance phenomena, it was extremely labor intensive. In this paper we describe and evaluate techniques for automating two significant activities of vertical profiling: trace alignment and correlation. Trace alignment aligns traces obtained from separate runs so that one can reason across the traces. We are not aware of any prior approach that effectively and automatically aligns traces. Correlation sifts through hundreds of metrics to find ones that have a bearing on a performance anomaly of interest. In prior work we found that statistical correlation was only sometimes effective. We have identified highly-effective approaches for both activities.For aligning traces we explore dynamic time warping, and for correlation we explore eight correlators based on statistical correlation, distance measures, and piecewise linear segmentation. Although we explore these activities in the context of vertical profiling, both activities are widely applicable in the performance analysis area.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094834", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Hauswirth", + "institution": "University of Colorado System" + }, + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Colorado System" + }, + { + "first_name": "Peter F.", + "last_name": "Sweeney", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Michael C.", + "last_name": "Mozer", + "institution": "University of Colorado System" + } + ], + "dblp_key": "conf/oopsla/HauswirthDSM05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094849", + "title": "PolyD: a flexible dispatching framework", + "abstract": "The standard dispatching mechanisms built into programming languages are sometimes inadequate to the needs of the programmer. In the case of Java, the need for more flexibility has led to the development of a number of tools, including visitors and multi-method extensions, that each add some particular functionality, but lack the generality necessary to support user-defined dispatching mechanisms. In this paper we advocate a more modular approach to dispatching, and we present a tool, PolyD, that allows the programmer to design custom dispatching strategies and to parametrize many aspects of the dispatching process. PolyD exhibits excellent performance and compares well against existing tools.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094849", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Antonio", + "last_name": "Cunei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/CuneiV05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094843", + "title": "Formalising Java RMI with explicit code mobility", + "abstract": "This paper presents a Java-like core language with primitives for object-oriented distribution and explicit code mobility. We apply our formulation to prove the correctness of several optimisations for distributed programs. Our language captures crucial but often hidden aspects of distributed object-oriented programming, including object serialisation, dynamic class downloading and remote method invocation. It is defined in terms of an operational semantics that concisely models the behaviour of distributed programs using machinery from calculi of mobile processes. Type safety is established using invariant properties for distributed runtime configurations. We argue that primitives for explicit code mobility offer a programmer fine-grained control of type-safe code distribution, which is crucial for improving the performance and safety of distributed object-oriented applications.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094843", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Ahern", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/AhernY05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094844", + "title": "Lifting sequential graph algorithms for distributed-memory parallel computation", + "abstract": "This paper describes the process used to extend the Boost Graph Library (BGL) for parallel operation with distributed memory. The BGL consists of a rich set of generic graph algorithms and supporting data structures, but it was not originally designed with parallelism in mind. In this paper, we revisit the abstractions comprising the BGL in the context of distributed-memory parallelism, lifting away the implicit requirements of sequential execution and a single shared address space. We illustrate our approach by describing the process as applied to one of the core algorithms in the BGL, breadth-first search. The result is a generic algorithm that is unchanged from the sequential algorithm, requiring only the introduction of external (distributed) data structures for parallel execution. More importantly, the generic implementation retains its interface and semantics, such that other distributed algorithms can be built upon it, just as algorithms are layered in the sequential case. By characterizing these extensions as well as the extension process, we develop general principles and patterns for using (and reusing) generic, object-oriented parallel software libraries. We demonstrate that the resulting algorithm implementations are both efficient and scalable with performance results for several algorithms.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094844", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Douglas", + "last_name": "Gregor", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Andrew", + "last_name": "Lumsdaine", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/oopsla/GregorL05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094835", + "title": "Improving virtual machine performance using a cross-run profile repository", + "abstract": "Virtual machines for languages such as the Java programming language make extensive use of online profiling and dynamic optimization to improve program performance. But despite the important role that profiling plays in achieving high performance, current virtual machines discard a program's profile data at the end of execution, wasting the opportunity to use past knowledge to improve future performance. In this paper, we present a fully automated architecture for exploiting cross-run profile data in virtual machines. Our work addresses a number of challenges that previously limited the practicality of such an approach.We apply this architecture to address the problem of selective optimization, and describe our implementation in IBM's J9 Java virtual machine. Our results demonstrate substantial performance improvements on a broad suite of Java programs, with the average performance ranging from 8.8% -- 16.6% depending on the execution scenario.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094835", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Adam", + "last_name": "Welc", + "institution": "IBM (United States)" + }, + { + "first_name": "V. T.", + "last_name": "Rajan", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/ArnoldWR05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094837", + "title": "Runtime specialization with optimistic heap analysis", + "abstract": "We describe a highly practical program specializer for Java programs. The specializer is powerful, because it specializes optimistically, using (potentially transient) constants in the heap; it is precise, because it specializes using data structures that are only partially invariant; it is deployable, because it is hidden in a JIT compiler and does not require any user annotations or offline preprocessing; it is simple, because it uses existing JIT compiler ingredients; and it is fast, because it specializes programs in under 1s.These properties are the result of (1) a new algorithm for selecting specializable code fragments, based on a notion of influence; (2) a precise store profile for identifying constant heap locations; and (3) an efficient invalidation mechanism for monitoring optimistic assumptions about heap constants. Our implementation of the specializer in the Jikes RVM has low overhead, selects specialization points that would be chosen manually, and produces speedups ranging from a factor of 1.2 to 6.4, comparable with annotation-guided specializers.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094837", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ajeet", + "last_name": "Shankar", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Shiva", + "last_name": "Sastry", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of California, Berkeley" + }, + { + "first_name": "James E.", + "last_name": "Smith", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/oopsla/ShankarSBS05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094851", + "title": "Subtext: uncovering the simplicity of programming", + "abstract": "Representing programs as text strings makes programming harder then it has to be. The source text of a program is far removed from its behavior. Bridging this conceptual gulf is what makes programming so inhumanly difficult -- we are not compilers. Subtext is a new medium in which the representation of a program is the same thing as its execution. Like a spreadsheet, a program is visible and alive, constantly executing even as it is edited. Program edits are coherent semantic transformations.The essence of this new medium is copying. Programs are constructed by copying and executed by copy flow: the projection of changes through copies. The simple idea of copying develops into a rich theory of higher-order continual copying of trees. Notably absent are symbolic names, the workhorse of textual notation, replaced by immediately-bound explicit relationships. Subtext unifies traditionally distinct programming tools and concepts, and enables some novel ones. Ancestral structures are a new primitive data type that combines the features of lists and records, along with unproblematic multiple inheritance. Adaptive conditionals use first-class program edits to dynamically adapt behavior.A prototype implementation shows promise, but calls for much further research. Subtext suggests that we can make programming radically easier, if we are willing to be radical.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094851", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Edwards", + "institution": "IIT@MIT" + } + ], + "dblp_key": "conf/oopsla/Edwards05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094854", + "title": "A simple model of agile software processes - or - extreme programming annealed", + "abstract": "Article Share on A simple model of agile software processes -- or -- extreme programming annealed Author: Glenn Vanderburg Plano, TX Plano, TXView Profile Authors Info & Claims OOPSLA '05: Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applicationsOctober 2005Pages 539–545https://doi.org/10.1145/1094811.1094854Published:12 October 2005Publication History 6citation3,363DownloadsMetricsTotal Citations6Total Downloads3,363Last 12 Months12Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094854", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Glenn", + "last_name": "Vanderburg", + "institution": "Plano Cancer Institute" + } + ], + "dblp_key": "conf/oopsla/Vanderburg05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094836", + "title": "Quantifying the performance of garbage collection vs. explicit memory management", + "abstract": "Garbage collection yields numerous software engineering benefits, but its quantitative impact on performance remains elusive. One can compare the cost of conservative garbage collection to explicit memory management in C/C++ programs by linking in an appropriate collector. This kind of direct comparison is not possible for languages designed for garbage collection (e.g., Java), because programs in these languages naturally do not contain calls to free. Thus, the actual gap between the time and space performance of explicit memory management and precise, copying garbage collection remains unknown.We introduce a novel experimental methodology that lets us quantify the performance of precise garbage collection versus explicit memory management. Our system allows us to treat unaltered Java programs as if they used explicit memory management by relying on oracles to insert calls to free. These oracles are generated from profile information gathered in earlier application runs. By executing inside an architecturally-detailed simulator, this \"oracular\" memory manager eliminates the effects of consulting an oracle while measuring the costs of calling malloc and free. We evaluate two different oracles: a liveness-based oracle that aggressively frees objects immediately after their last use, and a reachability-based oracle that conservatively frees objects just after they are last reachable. These oracles span the range of possible placement of explicit deallocation calls.We compare explicit memory management to both copying and non-copying garbage collectors across a range of benchmarks using the oracular memory manager, and present real (non-simulated) runs that lend further validity to our results. These results quantify the time-space tradeoff of garbage collection: with five times as much memory, an Appel-style generational collector with a non-copying mature space matches the performance of reachability-based explicit memory management. With only three times as much memory, the collector runs on average 17% slower than explicit memory management. However, with only twice as much memory, garbage collection degrades performance by nearly 70%. When physical memory is scarce, paging causes garbage collection to run an order of magnitude slower than explicit memory management.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094836", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Hertz", + "institution": "Canisius College" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/HertzB05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094839", + "title": "Adding trace matching with free variables to AspectJ", + "abstract": "An aspect observes the execution of a base program; when certain actions occur, the aspect runs some extra code of its own. In the AspectJ language, the observations that an aspect can make are confined to the current action: it is not possible to directly observe the history of a computation.Recently, there have been several interesting proposals for new history-based language features, most notably by Douence et al. and by Walker and Viggers. In this paper, we present a new history-based language feature called tracematches that enables the programmer to trigger the execution of extra code by specifying a regular pattern of events in a computation trace. We have fully designed and implemented tracematches as a seamless extension of AspectJ.A key innovation in our tracematch approach is the introduction of free variables in the matching patterns. This enhancement enables a whole new class of applications in which events can be matched not only by the event kind, but also by the values associated with the free variables. We provide several examples of applications enabled by this feature.After introducing and motivating the idea of tracematches via examples, we present a detailed semantics of our language design, and we derive an implementation from that semantics. The implementation has been realised as an extension of the abc compiler for AspectJ.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094839", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chris", + "last_name": "Allan", + "institution": "University of Oxford" + }, + { + "first_name": "Pavel", + "last_name": "Avgustinov", + "institution": "University of Oxford" + }, + { + "first_name": "Aske Simon", + "last_name": "Christensen", + "institution": "Aarhus University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + }, + { + "first_name": "Sascha", + "last_name": "Kuzins", + "institution": "University of Oxford" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "McGill University" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + }, + { + "first_name": "Damien", + "last_name": "Sereni", + "institution": "University of Oxford" + }, + { + "first_name": "Ganesh", + "last_name": "Sittampalam", + "institution": "University of Oxford" + }, + { + "first_name": "Julian", + "last_name": "Tibble", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/oopsla/AllanACHKLMSST05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094848", + "title": "Incrementalization across object abstraction", + "abstract": "Object abstraction supports the separation of what operations are provided by systems and components from how the operations are implemented, and is essential in enabling the construction of complex systems from components. Unfortunately, clear and modular implementations have poor performance when expensive query operations are repeated, while efficient implementations that incrementally maintain these query results are much more difficult to develop and to understand, because the code blows up significantly, and is no longer clear or modular.This paper describes a powerful and systematic method that first allows the \"what\" of each component to be specified in a clear and modular fashion and implemented straightforwardly in an object-oriented language; then analyzes the queries and updates, across object abstraction, in the straightforward implementation; and finally derives the sophisticated and efficient \"how\" of each component by incrementally maintaining the results of repeated expensive queries with respect to updates to their parameters. Our implementation and experimental results for example applications in query optimization, role-based access control, etc. demonstrate the effectiveness and benefit of the method.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094848", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yanhong A.", + "last_name": "Liu", + "institution": "Stony Brook University" + }, + { + "first_name": "Scott D.", + "last_name": "Stoller", + "institution": "State University of New York" + }, + { + "first_name": "Michael", + "last_name": "Gorbovitski", + "institution": "State University of New York" + }, + { + "first_name": "Tom", + "last_name": "Rothamel", + "institution": "State University of New York" + }, + { + "first_name": "Yanni Ellen", + "last_name": "Liu", + "institution": "State University of New York" + } + ], + "dblp_key": "conf/oopsla/LiuSGRL05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094840", + "title": "Finding application errors and security flaws using PQL: a program query language", + "abstract": "A number of effective error detection tools have been built in recent years to check if a program conforms to certain design rules. An important class of design rules deals with sequences of events asso-ciated with a set of related objects. This paper presents a language called PQL (Program Query Language) that allows programmers to express such questions easily in an application-specific context. A query looks like a code excerpt corresponding to the shortest amount of code that would violate a design rule. Details of the tar-get application's precise implementation are abstracted away. The programmer may also specify actions to perform when a match is found, such as recording relevant information or even correcting an erroneous execution on the fly.We have developed both static and dynamic techniques to find solutions to PQL queries. Our static analyzer finds all potential matches conservatively using a context-sensitive, flow-insensitive, inclusion-based pointer alias analysis. Static results are also use-ful in reducing the number of instrumentation points for dynamic analysis. Our dynamic analyzer instruments the source program to catch all violations precisely as the program runs and to optionally perform user-specified actions.We have implemented the techniques described in this paper and found 206 errors in 6 large real-world open-source Java applica-tions containing a total of nearly 60,000 classes. These errors are important security flaws, resource leaks, and violations of consis-tency invariants. The combination of static and dynamic analysis proves effective at addressing a wide range of debugging and pro-gram comprehension queries. We have found that dynamic analysis is especially suitable for preventing errors such as security vulner-abilities at runtime.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094840", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael C.", + "last_name": "Martin", + "institution": "Stanford University" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Stanford University" + }, + { + "first_name": "Monica S.", + "last_name": "Lam", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/MartinLL05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094845", + "title": "Safe futures for Java", + "abstract": "A future is a simple and elegant abstraction that allows concurrency to be expressed often through a relatively small rewrite of a sequential program. In the absence of side-effects, futures serve as benign annotations that mark potentially concurrent regions of code. Unfortunately, when computation relies heavily on mutation as is the case in Java, its meaning is less clear, and much of its intended simplicity lost.This paper explores the definition and implementation of safe futures for Java. One can think of safe futures as truly transparent annotations on method calls, which designate opportunities for concurrency. Serial programs can be made concurrent simply by replacing standard method calls with future invocations. Most significantly, even though some parts of the program are executed concurrently and may indeed operate on shared data, the semblance of serial execution is nonetheless preserved. Thus, program reasoning is simplified since data dependencies present in a sequential program are not violated in a version augmented with safe futures.Besides presenting a programming model and API for safe futures, we formalize the safety conditions that must be satisfied to ensure equivalence between a sequential Java program and its future-annotated counterpart. A detailed implementation study is also provided. Our implementation exploits techniques such as object versioning and task revocation to guarantee necessary safety conditions. We also present an extensive experimental evaluation of our implementation to quantify overheads and limitations. Our experiments indicate that for programs with modest mutation rates on shared data, applications can use futures to profitably exploit parallelism, without sacrificing safety.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094845", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adam", + "last_name": "Welc", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Antony L.", + "last_name": "Hosking", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/WelcJH05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094847", + "title": "Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations", + "abstract": "Ever since their invention 30 years ago, checked exceptions have been a point of much discussion. On the one hand, they increase the robustness of software by preventing the manifestation of unanticipated checked exceptions at run-time. On the other hand, they decrease the adaptability of software because they must be propagated explicitly, and must often be handled even if they cannot be signalled.We show that the problems with checked exceptions are caused by a lack of expressiveness of the exceptional return type of a method, which currently dictates a copy & paste style. We add the required expressiveness by introducing anchored exception declarations, which allow the exceptional behavior of a method to be declared relative to that of others. We present the formal semantics of anchored exception declarations, along with the necessary rules for ensuring compile-time safety, and give a proof of soundness. We show that anchored exception declarations do not violate the principle of information hiding when used properly, and provide a guideline for when to use them.We have implemented anchored exception declarations in Cappuccino, which is an extension to the ClassicJava programming language.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094847", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marko van", + "last_name": "Dooren", + "institution": "KU Leuven" + }, + { + "first_name": "Eric", + "last_name": "Steegmans", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/oopsla/DoorenS05", + "venue": "oopsla", + "year": 2005 + }, + { + "paper_id": "10.1145/1094811.1094852", + "title": "X10: an object-oriented approach to non-uniform cluster computing", + "abstract": "It is now well established that the device scaling predicted by Moore's Law is no longer a viable option for increasing the clock frequency of future uniprocessor systems at the rate that had been sustained during the last two decades. As a result, future systems are rapidly moving from uniprocessor to multiprocessor configurations, so as to use parallelism instead of frequency scaling as the foundation for increased compute capacity. The dominant emerging multiprocessor structure for the future is a Non-Uniform Cluster Computing (NUCC) system with nodes that are built out of multi-core SMP chips with non-uniform memory hierarchies, and interconnected in horizontally scalable cluster configurations such as blade servers. Unlike previous generations of hardware evolution, this shift will have a major impact on existing software. Current OO language facilities for concurrent and distributed programming are inadequate for addressing the needs of NUCC systems because they do not support the notions of non-uniform data access within a node, or of tight coupling of distributed nodes.We have designed a modern object-oriented programming language, X10, for high performance, high productivity programming of NUCC systems. A member of the partitioned global address space family of languages, X10 highlights the explicit reification of locality in the form of places}; lightweight activities embodied in async, future, foreach, and ateach constructs; a construct for termination detection (finish); the use of lock-free synchronization (atomic blocks); and the manipulation of cluster-wide global data structures. We present an overview of the X10 programming model and language, experience with our reference implementation, and results from some initial productivity comparisons between the X10 and Java™ languages.", + "date": "2005-10-12", + "link": "https://doi.org/10.1145/1094811.1094852", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philippe", + "last_name": "Charles", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Christian", + "last_name": "Grothoff", + "institution": "UCLA Health" + }, + { + "first_name": "Vijay", + "last_name": "Saraswat", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Christopher", + "last_name": "Donawa", + "institution": "IBM (Canada)" + }, + { + "first_name": "Allan", + "last_name": "Kielstra", + "institution": "IBM (Canada)" + }, + { + "first_name": "Kemal", + "last_name": "Ebci̇oğlu", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Christoph von", + "last_name": "Praun", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/CharlesGSDKEPS05", + "venue": "oopsla", + "year": 2005 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2006.json b/data/pl_conferences/oopsla/2006.json new file mode 100644 index 0000000..5b68229 --- /dev/null +++ b/data/pl_conferences/oopsla/2006.json @@ -0,0 +1,937 @@ +[ + { + "paper_id": "10.1145/1167473.1167479", + "title": "A framework for implementing pluggable type systems", + "abstract": "Pluggable types have been proposed to support multiple type systems in the same programming language. We have designed and implemented JavaCOP, a program constraint system for implementing practical pluggable type systems for Java. JavaCOP enforces user-defined typing constraints written in a declarative and expressive rule language. We have validated our design by (re)implementing a range of type systems and program checkers. By using a program constraint system to implement pluggable types, programmers are able to check that their programs will operate correctly in restricted environments, adhere to strict programming rules, avoid null pointer errors or scoped memory exceptions, and meet style guidelines, while programming language researchers can easily experiment with novel type systems.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167479", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chris", + "last_name": "Andreae", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Shane", + "last_name": "Markstrum", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/oopsla/AndreaeNMM06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167475", + "title": "Eliminating distinctions of class: using prototypes to model virtual classes", + "abstract": "In mainstream OO languages, inheritance can be used to add new methods, or to override existing methods. Virtual classes and feature oriented programming are techniques which extend the mechanism of inheritance so that it is possible to refine nested classes as well. These techniques are attractive for programming in the large, because inheritance becomes a tool for manipulating whole class hierarchies rather than individual classes. Nevertheless, it has proved difficult to design static type systems for virtual classes, because virtual classes introduce dependent types. The compile-time type of an expression may depend on the run-time values of objects in that expression.We present a formal object calculus which implements virtual classes in a type-safe manner. Our type system uses a novel technique based on prototypes, which blur the distinction between compile-time and run-time. At run-time, prototypes act as objects, and they can be used in ordinary computations. At compile-time, they act as types. Prototypes are similar in power to dependent types, and subtyping is shown to be a form of partial evaluation. We prove that prototypes are type-safe but undecidable, and briefly outline a decidable semi-algorithm for dealing with them.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167475", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "DeLesley", + "last_name": "Hutchins", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/oopsla/Hutchins06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167485", + "title": "Uniform proxies for Java", + "abstract": "The proxy abstraction has a longlasting tradition in object settings. From design pattern to inherent language support, from remote method invocations to simple forms of behavioral reflection - incarnations as well as applications of proxies are innumerable.Since version 1.3, Java supports the concept of dynamic proxy. Such an object conforms to a set of types specified by the program and can be used wherever an expression of any of these types is expected, yet reifies invocations performed on it. Dynamic proxies have been applied to implement paradigms as diverse as behavioral reflection, structural conformance, or multi-methods. Alas, these proxies are only available \"for interfaces\". The case of creating dynamic proxies for a set of types including a class type has not been considered, meaning that it is currently not possible to create a dynamic proxy mimicking an instance of a given class. This weakness strongly limits any application of dynamic proxies.In this paper we unfold the current support for dynamic proxies in Java, assessing it in the light of a set of generic criteria for proxy implementations. We present an approach to supporting dynamic proxies \"for classes\" in Java, consisting in transformations performed on classes at load-time, including a generic scheme for enforcing encapsulation upon field accesses. These transformations seemlessly extend the scope of the current support for dynamic proxies. We discuss the precise benefits and costs of our extension in terms of the criteria introduced, and illustrate the usefulness of uniformly available proxies by implementing future method invocations both safely and transparently.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167485", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/Eugster06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167493", + "title": "Replay compilation: improving debuggability of a just-in-time compiler", + "abstract": "The performance of Java has been tremendously improved by the advance of Just-in-Time (JIT) compilation technologies. However, debugging such a dynamic compiler is much harder than a static compiler. Recompiling the problematic method to produce a diagnostic output does not necessarily work as expected, because the compilation of a method depends on runtime information at the time of compilation.In this paper, we propose a new approach, called replay JIT compilation, which can reproduce the same compilation remotely by using two compilers, the state-saving compiler and the replaying compiler. The state-saving compiler is used in a normal run, and, while compiling a method, records into a log all of the input for the compiler. The replaying compiler is then used in a debugging run with the system dump, to recompile a method with the options for diagnostic output. We reduced the overhead to save the input by using the system dump and by categorizing the input based on how its value changes. In our experiment, the increase of the compilation time for saving the input was only 1%, and the size of the additional memory needed for saving the input was only 10% of the compiler-generated code.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167493", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kazunori", + "last_name": "Ogata", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Tamiya", + "last_name": "Onodera", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Kiyokuni", + "last_name": "Kawachiya", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Hideaki", + "last_name": "Komatsu", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/OgataOKKN06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167489", + "title": "Virgil: objects on the head of a pin", + "abstract": "Embedded microcontrollers are becoming increasingly prolific, serving as the primary or auxiliary processor in products and research systems from microwaves to sensor networks. Microcontrollers represent perhaps the most severely resource-constrained embedded processors, often with as little as a few bytes of memory and a few kilobytes of code space. Language and compiler technology has so far been unable to bring the benefits of modern object-oriented languages to such processors. In this paper, I will present the design and implementation of Virgil, a lightweight object-oriented language designed with careful consideration for resource-limited domains. Virgil explicitly separates initialization time from runtime, allowing an application to build complex data structures during compilation and then run directly on the bare hardware without a virtual machine or any language runtime. This separation allows the entire program heap to be available at compile time and enables three new data-sensitive optimizations: reachable members analysis, reference compression, and ROM-ization. Experi-mental results demonstrate that Virgil is well suited for writing microcontroller programs, with five demonstrative applications fitting in less than 256 bytes of RAM with fewer than 50 bytes of metadata. Further results show that the optimizations presented in this paper reduced code size between 20% and 80% and RAM size by as much as 75%.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167489", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben L.", + "last_name": "Titzer", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/oopsla/Titzer06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167476", + "title": "J&: nested intersection for scalable software composition", + "abstract": "This paper introduces a programming language that makes it convenient to compose large software systems, combining their features in a modular way. J& supports nested intersection, building on earlier work on nested inheritance in the language Jx. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection enables composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. The utility of J& is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167476", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nathaniel", + "last_name": "Nystrom", + "institution": "Cornell University" + }, + { + "first_name": "Xin", + "last_name": "Qi", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/oopsla/NystromQM06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167495", + "title": "A flexible framework for implementing software transactional memory", + "abstract": "We describe DSTM2, a Java™ software library that provides a flexible framework for implementing object-based software transactional memory (STM). The library uses transactional factories to transform sequential (unsynchronized) classes into atomic (transactionally synchronized) ones, providing a substantial improvement over the awkward programming interface of our previous DSTM library. Furthermore, researchers can experiment with alternative STM mechanisms by providing their own factories. We demonstrate this flexibility by presenting two factories: one that uses essentially the same mechanisms as the original DSTM (with some enhancements),and another that uses a completely different approach.Because DSTM2 is packaged as a Java library, a wide range of programmers can easily try it out, and the community can begin to gain experience with transactional programming. Furthermore, researchers will be able to use the body of transactional programs that arises from this community experience to test and evaluate different STM mechanisms simply by supplying new transactional factories. We believe that this flexible approach will help to build consensus about the best ways to implement transactions, and will avoid the premature \"lock-in\" that may arise if STM mechanisms are baked into compilers before such experimentation is done.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167495", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Maurice", + "last_name": "Herlihy", + "institution": "John Brown University" + }, + { + "first_name": "Victor", + "last_name": "Luchangco", + "institution": "" + }, + { + "first_name": "Mark", + "last_name": "Moir", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/HerlihyLM06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167483", + "title": "Adapting virtual machine techniques for seamless aspect support", + "abstract": "Current approaches to compiling aspect-oriented programs are in-efficient. This inefficiency has negative effects on the productiv-ity of the development process and is especially prohibitive for dynamic aspect deployment. In this work, we present how well-known virtual machine techniques can be used with only slight modifications to support fast aspect deployment while retaining runtime performance. Our implementation accelerates dynamic as-pect deployment by several orders of magnitude relative to main-stream aspect-oriented environments. We also provide a detailed comparison of alternative implementations of execution environ-ments with support for dynamic aspect deployment.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167483", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christoph", + "last_name": "Bockisch", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Tom", + "last_name": "Dinkelaker", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/oopsla/BockischADM06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167480", + "title": "Design fragments make using frameworks easier", + "abstract": "Object oriented frameworks impose additional burdens on programmers that libraries did not, such as requiring the programmer to understand the method callback sequence, respecting behavior constraints within these methods, and devising solutions within a constrained solution space. To overcome these burdens, we express the repeated patterns of engagement with the framework as a design fragment. We analyzed the 20 demo applets provided by Sun and created a representative catalog of design fragments of conventional best practice. By evaluating 36 applets pulled from the internet we show that these design fragments are common, many applets copied the structure of the Sun demos, and that creation of a catalog of design fragments is practical. Design fragments give programmers immediate benefit through tool-based conformance assurance and long-term benefit through expression of design intent.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167480", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "George", + "last_name": "Fairbanks", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "David", + "last_name": "Garlan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "William L.", + "last_name": "Scherlis", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/FairbanksGS06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167491", + "title": "Declarative, formal, and extensible syntax definition for aspectJ", + "abstract": "A Case for Scannerless Generalized-LR Parsing Aspect-Oriented Programming (AOP) is attracting attention from both research and industry, as illustrated by the ever-growing popularity of AspectJ, the de facto standard AOP extension of Java. From a compiler construction perspective, AspectJ is interesting as it is a typical example of a compositional language, i.e. a language composed of a number of separate languages with different syntactical styles: in addition to plain Java, AspectJ includes a language for defining pointcuts and one for defining advices. Language composition represents a non-trivial challenge for conventional parsing techniques. First, combining several languages with different lexical syntax leads to considerable complexity in the lexical states to be processed. Second, as new language features for AOP are being explored, many research proposals are concerned with further extending the AspectJ language, resulting in a need for an extensible syntax definition. This paper shows how scannerless parsing elegantly addresses the issues encountered by conventional techniques when parsing AspectJ. We present the design of a modular, extensible, and formal definition of the lexical and context-free aspects of the AspectJ syntax in the Syntax Definition Formalism SDF, which is implemented by a scannerless, generalized-LR parser (SGLR). We introduce grammar mixins as a novel application of SDF’s modularity features, which allows the declarative definition of different keyword policies and combination of extensions. We illustrate the modular extensibility of our definition with syntax extensions taken from current research on aspect languages. Finally, benchmarks show the reasonable performance of scannerless generalized-LR parsing for this grammar.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167491", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Bravenboer", + "institution": "Utrecht University" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/oopsla/BravenboerTV06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167487", + "title": "Javana: a system for building customized Java program analysis tools", + "abstract": "Understanding the behavior of applications running on high-level language virtual machines, as is the case in Java, is non-trivial because of the tight entanglement at the lowest execution level between the application and the virtual machine. This paper proposes Javana, a system for building Java program analysis tools. Javana provides an easy-to-use instrumentation infrastructure that allows for building customized profiling tools very quickly.Javana runs a dynamic binary instrumentation tool underneath the virtual machine. The virtual machine communicates with the instrumentation layer through an event handling mechanism for building a vertical map that links low-level native instruction pointers and memory addresses to high-level language concepts such as objects, methods, threads, lines of code, etc. The dynamic binary instrumentation tool then intercepts all memory accesses and instructions executed and provides the Javana end user with high-level language information for all memory accesses and natively executed instructions.We demonstrate the power of Javana through a number of applications: memory address tracing, vertical cache simulation and object lifetime computation. For each of these applications, the instrumentation specification requires only a small number of lines of code. Developing similarly powerful profiling tools within a virtual machine (as done in current practice) is both time-consuming and error-prone; in addition, the accuracy of the obtained profiling results might be questionable as we show in this paper.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167487", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonas", + "last_name": "Maebe", + "institution": "Ghent University" + }, + { + "first_name": "Dries", + "last_name": "Buytaert", + "institution": "Ghent University" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University" + }, + { + "first_name": "Koen De", + "last_name": "Bosschere", + "institution": "Ghent University" + } + ], + "dblp_key": "conf/oopsla/MaebeBEB06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167492", + "title": "Method-specific dynamic compilation using logistic regression", + "abstract": "Determining the best set of optimizations to apply to a program has been a long standing problem for compiler writers. To reduce the complexity of this task, existing approaches typically apply the same set of optimizations to all procedures within a program, without regard to their particular structure. This paper develops a new method-specific approach that automatically selects the best optimizations on a per method basis within a dynamic compiler. Our approach uses the machine learning technique of logistic regression to automatically derive a predictive model that determines which optimizations to apply based on the features of a method. This technique is implemented in the Jikes RVM Java JIT compiler. Using this approach we reduce the average total execution time of the SPECjvm98 benchmarks by 29%. When the same heuristic is applied to the DaCapo+ benchmark suite, we obtain an average 33% reduction over the default level O2 setting.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167492", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Cavazos", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/oopsla/CavazosO06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167488", + "title": "The DaCapo benchmarks: java benchmarking development and analysis", + "abstract": "Since benchmarks drive computer science research and industry product development, which ones we use and how we evaluate them are key questions for the community. Despite complex runtime tradeoffs due to dynamic compilation and garbage collection required for Java programs, many evaluations still use methodologies developed for C, C++, and Fortran. SPEC, the dominant purveyor of benchmarks, compounded this problem by institutionalizing these methodologies for their Java benchmark suite. This paper recommends benchmarking selection and evaluation methodologies, and introduces the DaCapo benchmarks, a set of open source, client-side Java benchmarks. We demonstrate that the complex interactions of (1) architecture, (2) compiler, (3) virtual machine, (4) memory management, and (5) application require more extensive evaluation than C, C++, and Fortran which stress (4) much less, and do not require (3). We use and introduce new value, time-series, and statistical metrics for static and dynamic properties such as code complexity, code size, heap composition, and pointer mutations. No benchmark suite is definitive, but these metrics show that DaCapo improves over SPEC Java in a variety of ways, including more complex code, richer object behaviors, and more demanding memory system requirements. This paper takes a step towards improving methodologies for choosing and evaluating benchmarks to foster innovation in system design and implementation for Java and other managed languages.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167488", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Intel (United States)" + }, + { + "first_name": "Robin", + "last_name": "Garner", + "institution": "Australian National University" + }, + { + "first_name": "Chris", + "last_name": "Hoffmann", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Asjad M.", + "last_name": "Khang", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Rotem", + "last_name": "Bentzur", + "institution": "" + }, + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Colorado System" + }, + { + "first_name": "Daniel", + "last_name": "Feinberg", + "institution": "" + }, + { + "first_name": "Daniel", + "last_name": "Frampton", + "institution": "Australian National University" + }, + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "IBM (United States)" + }, + { + "first_name": "Antony L.", + "last_name": "Hosking", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Maria", + "last_name": "Jump", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Han", + "last_name": "Lee", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Aashish", + "last_name": "Phansalkar", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Darko", + "last_name": "Stefanović", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "VanDrunen", + "institution": "Wheaton College - Illinois" + }, + { + "first_name": "Daniel von", + "last_name": "Dincklage", + "institution": "University of Colorado System" + }, + { + "first_name": "Ben", + "last_name": "Wiedermann", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/BlackburnGHKMBDFFGHHJLMPSVDW06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167481", + "title": "JTL: the Java tools language", + "abstract": "We present an overview of JTL (the Java Tools Language, pronounced \"Gee-tel\"), a novel language for querying JAVA [8] programs. JTL was designed to serve the development of source code software tools for JAVA, and as a small language which to aid programming language extensions to JAVA. Applications include definition of pointcuts for aspect-oriented programming, fixing type constraints for generic programming, specification of encapsulation policies, definition of micro-patterns, etc. We argue that the JTL expression of each of these is systematic, concise, intuitive and general.JTL relies on a simply-typed relational database for program representation, rather than an abstract syntax tree. The underlying semantics of the language is restricted to queries formulated in First Order Predicate Logic augmented with transitive closure (FOPL).Special effort was taken to ensure terse, yet readable expression of logical conditions. The JTL pattern public abstract class, for example, matches all abstract classes which are publicly accessible, while class (public clone();) matches all classes in which method clone is public. To this end, JTL relies on a DATALOG-like syntax and semantics, enriched with quantifiers and pattern matching which all but entirely eliminate the need for recursive calls.JTL's query analyzer gives special attention to the fragility of the \"closed world assumption\" in examining JAVA software, and determines whether a query relies on such an assumption.The performance of the JTL interpreter is comparable to that of JQuery after it generated its database cache, and at least an order of magnitude faster when the cache has to be rebuilt.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167481", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tal", + "last_name": "Cohen", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Itay", + "last_name": "Maman", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/CohenGM06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167477", + "title": "Statically scoped object adaptation with expanders", + "abstract": "This paper introduces the expander, a new object-oriented (OO) programming language construct designed to support object adaptation. Expanders allow existing classes to be noninvasively updated with new methods, fields, and superinterfaces. Each client can customize its view of a class by explicitly importing any number of expanders. This view then applies to all instances of that class, including objects passed to the client from other components. A form of expander overriding allows expanders to interact naturally with OO-style inheritance.We describe the design, implementation, and evaluation of eJava, an extension to Java supporting expanders. We illustrate eJava's syntax and semantics through several examples. The statically scoped nature of expander usage allows for a modular static type system that prevents several important classes of errors. We describe this modular static type system informally, formalize eJava and its type system in an extension to Featherweight Java, and prove a type soundness theorem for the formalization. We also describe a modular compilation strategy for eJava, which we have implemented using the Polyglot extensible compiler framework. Finally, we illustrate the practical benefits of eJava by using this compiler in two experiments.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167477", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alessandro", + "last_name": "Warth", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Milan", + "last_name": "Stanojević", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/oopsla/WarthSM06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167484", + "title": "Efficient control flow quantification", + "abstract": "Aspect-oriented programming (AOP) is increasingly gaining in popularity. However, the focus of aspect-oriented language research has been mostly on language design issues; efficient implementation techniques have been less popular. As a result, the performance of certain AOP constructs is still poor. This is in particular true for constructs that rely on dynamic properties of the execution (e.g., the cflow construct).In this paper, we present efficient implementation techniques for cflow that exploit direct access to internal structures of the virtual machine running an application, such as the call stack, as well as the integration of these techniques into the just-in-time compiler code generation process.Our results show that AOP has the potential to make programs that need to define control flow-dependent behavior not only more modular but also more efficient. By making means for control flow-dependent behavior part of the language, AOP opens the possibility of applying sophisticated compiler optimizations that are out of reach for application programmers.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167484", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christoph", + "last_name": "Bockisch", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Sebastian", + "last_name": "Kanthak", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Michael", + "last_name": "Haupt", + "institution": "Hasso Plattner Institute" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technische Universität Darmstadt" + } + ], + "dblp_key": "conf/oopsla/BockischKHAM06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167496", + "title": "Eliminating synchronization-related atomic operations with biased locking and bulk rebiasing", + "abstract": "The Java TM programming language contains built-in synchronization primitives for use in constructing multithreaded programs. Efficient implementation of these synchronization primitives is necessary in order to achieve high performance. Recent research [9, 12, 10, 3, 7] has focused on the run-time elimination of the atomic operations required to implement object monitor synchronization primitives. This paper describes a novel technique called store-free biased locking which eliminates all synchronization-related atomic operations on uncontended object monitors. The technique supports the bulk transfer of object ownership from one thread to another, and the selective disabling of the optimization where unprofitable, using epoch-based bulk rebiasing and revocation. It has been implemented in the production version of the Java HotSpot TM VM and has yielded significant performance improvements on a range of benchmarks and applications. The technique is applicable to any virtual machine-based programming language implementation with mostly block-structured locking primitives.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167496", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "K.D.", + "last_name": "Russell", + "institution": "Microsystems (United Kingdom)" + }, + { + "first_name": "David", + "last_name": "Detlefs", + "institution": "Moscow Institute of Thermal Technology" + } + ], + "dblp_key": "conf/oopsla/RussellD06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167502", + "title": "A formal framework for component deployment", + "abstract": "Software deployment is a complex process, and industrial-strength frameworks such as .NET, Java, and CORBA all provide explicit support for component deployment. However, these frameworks are not built around fundamental principles as much as they are engineering efforts closely tied to particulars of the respective systems. Here we aim to elucidate the fundamental principles of software deployment, in a platform-independent manner. Issues that need to be addressed include deployment unit design, when, where and how to wire components together, versioning, version dependencies, and hot-deployment of components. We define the application buildbox as the place where software is developed and deployed, and define a formal Labeled Transition System (LTS) on the buildbox with transitions for deployment operations that include build, install, ship, and update. We establish formal properties of the LTS, including the fact that if a component is shipped with a certain version dependency, then at run time that dependency must be satisfied with a compatible version. Our treatment of deployment is both platform- and vendor-independent, and we show how it models the core mechanisms of the industrial-strength deployment frameworks.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167502", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/oopsla/LiuS06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167500", + "title": "Generic ownership for generic Java", + "abstract": "Ownership types enforce encapsulation in object-oriented programs by ensuring that objects cannot be leaked beyond object(s) that own them. Existing ownership programming languages either do not support parametric polymorphism (type genericity) or attempt to add it on top of ownership restrictions. Generic Ownership provides per-object ownership on top of a sound generic imperative language. The resulting system not only provides ownership guarantees comparable to established systems, but also requires few additional language mechanisms due to full reuse of parametric polymorphism. We formalise the core of Generic Ownership, highlighting that only restriction of this calls and owner subtype preservation are required to achieve deep ownership. Finally we describe how Ownership Generic Java (OGJ) was implemented as a minimal extension to Generic Java in the hope of bringing ownership types into mainstream programming.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167500", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Dave", + "last_name": "Clarke", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Robert", + "last_name": "Biddle", + "institution": "Carleton University" + } + ], + "dblp_key": "conf/oopsla/PotaninNCB06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167499", + "title": "Concepts: linguistic support for generic programming in C++", + "abstract": "Generic programming has emerged as an important technique for the development of highly reusable and efficient software libraries. In C++, generic programming is enabled by the flexibility of templates, the C++ type parametrization mechanism. However, the power of templates comes with a price: generic (template) libraries can be more difficult to use and develop than non-template libraries and their misuse results in notoriously confusing error messages. As currently defined in C++98, templates are unconstrained, and type-checking of templates is performed late in the compilation process, i.e., after the use of a template has been combined with its definition. To improve the support for generic programming in C++, we introduce concepts to express the syntactic and semantic behavior of types and to constrain the type parameters in a C++ template. Using concepts, type-checking of template definitions is separated from their uses, thereby making templates easier to use and easier to compile. These improvements are achieved without limiting the flexibility of templates or decreasing their performance - in fact their expressive power is increased. This paper describes the language extensions supporting concepts, their use in the expression of the C++ Standard Template Library, and their implementation in the ConceptGCC compiler. Concepts are candidates for inclusion in the upcoming revision of the ISO C++ standard, C++0x.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167499", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Douglas", + "last_name": "Gregor", + "institution": "Indiana University" + }, + { + "first_name": "Jaakko", + "last_name": "Järvi", + "institution": "" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Rice University" + }, + { + "first_name": "Bjarne", + "last_name": "Stroustrup", + "institution": "" + }, + { + "first_name": "Gabriel Dos", + "last_name": "Reis", + "institution": "" + }, + { + "first_name": "Andrew", + "last_name": "Lumsdaine", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/oopsla/GregorJSSRL06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167511", + "title": "Intentional software", + "abstract": "Wysiwyg editors simplified document creation by separating the document contents from the looks and by automating the re-application of the looks to changing contents. In the same way Intentional Software simplifies software creation by separating the software contents in terms of their various domains from the implementation of the software and by enabling automatic re-generation of the software as the contents change. This way, domain experts can work in parallel with programmers in their respective areas of expertise; and the repeated intermingling can be automated. Intentional Software is supported by a Domain Workbench tool where multiple domains can be defined, created, edited, transformed and integrated during software creation. Key features include a uniform representation of multiple interrelated domains, the ability to project the domains in multiple editable notations, and simple access for a program generator.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167511", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Charles", + "last_name": "Simonyi", + "institution": "" + }, + { + "first_name": "Magnus", + "last_name": "Christerson", + "institution": "" + }, + { + "first_name": "Shane", + "last_name": "Clifford", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SimonyiCC06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167510", + "title": "Conscientious software", + "abstract": "Software needs to grow up and become responsible for itself and its own future by participating in its own installation and customization, maintaining its own health, and adapting itself to new circumstances, new users, and new uses. To create such software will require us to change some of our underlying assumptions about how we write programs. A promising approach seems to be to separate software that does the work (allopoietic)from software that keeps the system alive (autopoietic).", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167510", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard P.", + "last_name": "Gabriel", + "institution": "" + }, + { + "first_name": "Ron", + "last_name": "Goldman", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/GabrielG06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167498", + "title": "A flow-based approach for variant parametric types", + "abstract": "A promising approach for type-safe generic codes in the object-oriented paradigm is variant parametric type, which allows covari-ant and contravariant subtyping on fields where appropriate. Pre-vious approaches formalise variant type as a special case of the existential type system. In this paper, we present a new framework based on flow analysis and modular type checking to provide a sim-ple but accurate model for capturing generic types. Our scheme stands to benefit from past (and future) advances in flow analysis and subtyping constraints. Furthermore, it fully supports casting for variant types with a special reflection mechanism, called cast capture, to handle objects with unknown types. We have built a constraint-based type checker and have proven its soundness. We have also successfully annotated a suite of Java libraries and client code with our flow-based variant type system.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167498", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + }, + { + "first_name": "Florin", + "last_name": "Crăciun", + "institution": "National University of Singapore" + }, + { + "first_name": "Siau‐Cheng", + "last_name": "Khoo", + "institution": "National University of Singapore" + }, + { + "first_name": "Corneliu", + "last_name": "Popeea", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/oopsla/ChinCKP06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167513", + "title": "On system design", + "abstract": "In this essay, I consider some of the factors that are making it more and more difficult to expend the effort necessary to do system design. Because of changes in the economics of the field in both industry and research, we have become less able to take the time needed to do real system design, and to train the next generation of designers. Because of the intellectual property landscape, we are less able to discuss system design. The end result is that we do less good system design than we used to, at least in those environments where system design used to be most common. But there are reasons to be optimistic about the future of system design, which appears to be happening in non-traditional ways and in non-traditional venues.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167513", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jim", + "last_name": "Waldo", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/Waldo06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167504", + "title": "Efficient software model checking of data structure properties", + "abstract": "This paper presents novel language and analysis techniques that significantly speed up software model checking of data structure properties. Consider checking a red-black tree implementation. Traditional software model checkers systematically generate all red-black tree states (within some given bounds) and check every red-black tree operation (such as insert, delete, or lookup) on every red-black tree state. Our key idea is as follows. As our checker checks a red-black tree operation o on a red-black tree state s, it uses program analysis techniques to identify other red-black tree states s'1, s'2, ..., s'k on which the operation o behaves similarly. Our analyses guarantee that if o executes correctly on s, then o will execute correctly on every s'i. Our checker therefore does not need to check o on any s'i once it checks o on s. It thus safely prunes those state transitions from its search space, while still achieving complete test coverage within the bounded domain. Our preliminary results show orders of magnitude improvement over previous approaches. We believe our techniques can make model checking significantly faster, and thus enable checking of much larger programs and complex program properties than currently possible.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167504", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul T.", + "last_name": "Darga", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Chandrasekhar", + "last_name": "Boyapati", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/oopsla/DargaB06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167507", + "title": "Understanding the shape of Java software", + "abstract": "Large amounts of Java software have been written since the language's escape into unsuspecting software ecology more than ten years ago. Surprisingly little is known about the structure of Java programs in the wild: about the way methods are grouped into classes and then into packages, the way packages relate to each other, or the way inheritance and composition are used to put these programs together. We present the results of the first in-depth study of the structure of Java programs. We have collected a number of Java programs and measured their key structural attributes. We have found evidence that some relationships follow power-laws, while others do not. We have also observed variations that seem related to some characteristic of the application itself. This study provides important information for researchers who can investigate how and why the structural relationships we find may have originated, what they portend, and how they can be managed.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167507", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "G. J.", + "last_name": "Baxter", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Marcus", + "last_name": "Frean", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Mark", + "last_name": "Rickerby", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Hayden P.", + "last_name": "Smith", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Matt", + "last_name": "Visser", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Hayden", + "last_name": "Melton", + "institution": "University of Auckland" + }, + { + "first_name": "Ewan", + "last_name": "Tempero", + "institution": "University of Auckland" + } + ], + "dblp_key": "conf/oopsla/BaxterFNRSVMT06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167503", + "title": "An operational semantics and type safety prooffor multiple inheritance in C++", + "abstract": "We present an operational semantics and type safety proof for multiple inheritance in C++. The semantics models the behaviour of method calls, field accesses, and two forms of casts in C++ class hierarchies exactly, and the type safety proof was formalized and machine-checked in Isabelle/HOL. Our semantics enables one, for the first time, to understand the behaviour of operations on C++ class hierarchies without referring to implementation-level artifacts such as virtual function tables. Moreover, it can - as the semantics is executable - act as a reference for compilers, and it can form the basis for more advanced correctness proofs of, e.g., automated program transformations. The paper presents the semantics and type safety proof, and a discussion of the many subtleties that we encountered in modeling the intricate multiple inheritance model of C++.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167503", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Wasserrab", + "institution": "University of Passau" + }, + { + "first_name": "Tobias", + "last_name": "Nipkow", + "institution": "Technical University of Munich" + }, + { + "first_name": "Gregor", + "last_name": "Snelting", + "institution": "University of Passau" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/WasserrabNST06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167508", + "title": "XSnippet: mining For sample code", + "abstract": "It is common practice for software developers to use examples to guide development efforts. This largely unwritten, yet standard, practice of \"develop by example\" is often supported by examples bundled with library or framework packages, provided in textbooks, and made available for download on both official and unofficial web sites. However, the vast number of examples that are embedded in the billions of lines of already developed library and framework code are largely untapped. We have developed XSnippet, a context-sensitive code assistant framework that allows developers to query a sample repository for code snippets that are relevant to the programming task at hand. In particular, our work makes three primary contributions. First, a range of queries is provided to allow developers to switch between a context-independent retrieval of code snippets to various degrees of context-sensitive retrieval for object instantiation queries. Second, a novel graph-based code mining algorithm is provided to support the range of queries and enable mining within and across method boundaries. Third, an innovative context-sensitive ranking heuristic is provided that has been experimentally proven to provide better ranking for best-fit code snippets than context-independent heuristics such as shortest path and frequency. Our experimental evaluation has shown that XSnippet has significant potential to assist developers, and provides better coverage of tasks and better rankings for best-fit snippets than other code assistant systems.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167508", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Naiyana", + "last_name": "Sahavechaphan", + "institution": "National Electronics and Computer Technology Center" + }, + { + "first_name": "Kajal", + "last_name": "Claypool", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/SahavechaphanC06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167506", + "title": "Isolating and relating concerns in requirements using latent semantic analysis", + "abstract": "Aspect-oriented requirements analysis involves the identification of concerns that behaviorally influence other concerns. Such concerns are described in requirements called emphaspectual requirements: requirements that detail the influence of one concern over another. The current state of the art for aspect-oriented requirements analysis is Theme/Doc, which allows lexical analysis of requirements based on a set of developer-chosen keywords. It provides a graphical depiction of how concerns relate to requirements, and affords identification of potential aspectual requirements. In addition, clusters of requirements and concerns are identified to arrive at a more useful set of concerns than those initially identified.Because of the lexical nature of the Theme/Doc approach, aspectual requirements are missed, or wrongly identified. Additionally, requirements may be wrongly clustered if they contain ambiguous terms.In this work we explored whether the use of a statistical approach for textual analysis, Latent Semantic Analysis (LSA), would improve upon the lexical approach used by Theme/Doc. We found that LSA helps identify useful concern clusters, and helps reduce the number of falsely identified aspectual requirements.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167506", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lo Kwun", + "last_name": "Kit", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Chan Kwun", + "last_name": "Man", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Elisa", + "last_name": "Baniassad", + "institution": "Chinese University of Hong Kong" + } + ], + "dblp_key": "conf/oopsla/KitMB06", + "venue": "oopsla", + "year": 2006 + }, + { + "paper_id": "10.1145/1167473.1167514", + "title": "The paradoxical success of aspect-oriented programming", + "abstract": "Aspect-oriented programming is considered a promising new technology. As object-oriented programming did before, it is beginning to pervade all areas of software engineering. With its growing popularity, practitioners and academics alike are wondering whether they should start looking into it, or otherwise risk having missed an important development. The author of this essay finds that much of aspect-oriented programming's success seems to be based on the conception that it improves both modularity and the structure of code, while in fact, it works against the primary purposes of the two, namely independent development and understandability of programs. Not seeing any way of fixing this situation, he thinks the success of aspect-oriented programming to be paradoxical.", + "date": "2006-10-16", + "link": "https://doi.org/10.1145/1167473.1167514", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Friedrich", + "last_name": "Steimann", + "institution": "University of Hagen" + } + ], + "dblp_key": "conf/oopsla/Steimann06", + "venue": "oopsla", + "year": 2006 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2007.json b/data/pl_conferences/oopsla/2007.json new file mode 100644 index 0000000..96b9031 --- /dev/null +++ b/data/pl_conferences/oopsla/2007.json @@ -0,0 +1,994 @@ +[ + { + "paper_id": "10.1145/1297027.1297037", + "title": "Variant path types for scalable extensibility", + "abstract": "Much recent work in the design of object-oriented programming languages has been focusing on identifying suitable features to support so-called scalable extensibility, where the usual extension mechanism by inheritance works in different scales of software components-that is, classes, groups of classes, groups of groups and so on. Its typing issues has usually been addressed by means of dependent type systems, where nested types are seen as properties of objects. In this work, we seek instead for a different solution, which can bemore easily applied to Java-like languages, in which nested types are considered properties of classe.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297037", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + }, + { + "first_name": "Mirko", + "last_name": "Viroli", + "institution": "University of Bologna" + } + ], + "dblp_key": "conf/oopsla/IgarashiV07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297046", + "title": "The causes of bloat, the limits of health", + "abstract": "Applications often have large runtime memory requirements. In some cases, large memory footprint helps accomplish an important functional, performance, or engineering requirement. A large cache,for example, may ameliorate a pernicious performance problem. In general, however, finding a good balance between memory consumption and other requirements is quite challenging. To do so, the development team must distinguish effective from excessive use of memory.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297046", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nick", + "last_name": "Mitchell", + "institution": "IBM (United States)" + }, + { + "first_name": "Gary", + "last_name": "Sevitsky", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/MitchellS07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297029", + "title": "The jastadd extensible java compiler", + "abstract": "The JastAdd Extensible Java Compiler is a high quality Java compiler that is easy to extend in order to build static analysis tools for Java, and to extend Java with new language constructs. It is built modularly, with a Java 1.4 compiler that is extended to a Java 5 compiler. Example applications that are built as extensions include an alternative backend that generates Jimple, an extension of Java with AspectJ constructs, and the implementation of a pluggable type system for non-null checking and inferenc.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297029", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Torbjörn", + "last_name": "Ekman", + "institution": "University of Oxford" + }, + { + "first_name": "Görel", + "last_name": "Hedin", + "institution": "Lund University" + } + ], + "dblp_key": "conf/oopsla/EkmanH07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297048", + "title": "Webrb: evaluating a visual domain-specific language for building relational web-applications", + "abstract": "Many web-applications can be characterized as relational. In this paper we introduce and evaluate WebRB, a visualdomain-specific language for building such applications. WebRB addresses the limitations of the conventional imperative-embedding approach typically used to build relational web-applications. We describe the WebRB language, present extended examples of its use, and discuss the WebRB visual editor, libraries, and runtime. We then evaluate WebRB by comparing it to alternative approaches, and demonstrate its effectiveness in building relational web-applications.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297048", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Avraham", + "last_name": "Leff", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "James T.", + "last_name": "Rayfield", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/LeffR07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297034", + "title": "Microphase: an approach to proactively invoking garbage collection for improved performance", + "abstract": "To date, the most commonly used criterion for invoking garbage collection (GC) is based on heap usage; that is, garbage collection is invoked when the heap or an area inside the heap is full. This approach can suffer from two performance shortcomings: untimely garbage collection invocations and large volumes of surviving objects. In this work, we explore a new GC triggering approach called MicroPhase that exploits two observations: (i) allocation requests occur in phases and (ii) phase boundaries coincide with times when most objects also die. Thus, proactively invoking garbage collection at these phase boundaries can yield high efficiency. We extended the HotSpot virtual machine from Sun Microsystems to support MicroPhase and conducted experiments using 20 benchmarks. The experimental results indicate that our technique can reduce the GC times in 19 applications. The differences in GC overhead range from an increase of 1% to a decrease of 26% when the heap is set to twice the maximum live-size. As a result, MicroPhase can improve the overall performance of 13 benchmarks. The performance differences range from a degradation of 2.5% to an improvement of 14%.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297034", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Feng", + "last_name": "Xian", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Witawas", + "last_name": "Srisa‐an", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Hong", + "last_name": "Jiang", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "conf/oopsla/XianSJ07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297033", + "title": "Statistically rigorous java performance evaluation", + "abstract": "Java performance is far from being trivial to benchmark because it is affected by various factors such as the Java application, its input, the virtual machine, the garbage collector, the heap size, etc. In addition, non-determinism at run-time causes the execution time of a Java program to differ from run to run. There are a number of sources of non-determinism such as Just-In-Time (JIT) compilation and optimization in the virtual machine (VM) driven by timer-based method sampling, thread scheduling, garbage collection, and various.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297033", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andy", + "last_name": "Georges", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Dries", + "last_name": "Buytaert", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University Hospital" + } + ], + "dblp_key": "conf/oopsla/GeorgesBE07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297042", + "title": "Transactions with isolation and cooperation", + "abstract": "We present the TIC (Transactions with Isolation and Cooperation) model for concurrent programming. TIC adds to standard transactional memory the ability for a transaction to observe the effects of other threads at selected points. This allows transactions to cooperate, as well as to invoke nonrepeatable or irreversible operations, such as I/O. Cooperating transactions run the danger of exposing intermediate state and of having other threads change the transaction's state. The TIC model protects against unanticipated interference by having the type system keep track of all operations that may (transitively) violate the atomicity of a transaction and require the programmer to establish consistency at appropriate points. The result is a programming model that is both general and simple. We have used the TIC model to re-engineer existing lock-based applications including a substantial multi-threaded web mail server and a memory allocator with coarse-grained locking. Our experience confirms the features of the TIC model: It is convenient for the programmer, while maintaining the benefits of transactional memory.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297042", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "University of Oregon" + }, + { + "first_name": "Anthony", + "last_name": "Kay", + "institution": "University of Oregon" + }, + { + "first_name": "Reimer", + "last_name": "Behrends", + "institution": "University of Oregon" + }, + { + "first_name": "Michal", + "last_name": "Young", + "institution": "University of Oregon" + } + ], + "dblp_key": "conf/oopsla/SmaragdakisKBY07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297031", + "title": "Ilea: inter-language analysis across java and c", + "abstract": "Java bug finders perform static analysis to find implementation mistakes that can lead to exploits and failures; Java compilers perform static analysis for optimization.allIf Java programs contain foreign function calls to C libraries, however, static analysis is forced to make either optimistic or pessimistic assumptions about the foreign function calls, since models of the C libraries are typically not available.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297031", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Boston College" + }, + { + "first_name": "Greg", + "last_name": "Morrisett", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/oopsla/TanM07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297039", + "title": "Component nextgen: a sound and expressive component framework for java", + "abstract": "Developing a general component system for a statically typed, object-oriented language is a challenging design problem for two reasons. First, mutually recursive references across components are common in object-oriented programs-an issue that has proven troublesome in the context of component systems for functional and procedural languages. Second, inheritance across component boundaries can cause accidental method overrides. Our recent research shows that a component framework can be constructed for a nominally typed object-oriented language supporting first-class generic types simply by adding appropriate annotations, syntactic sugar, and component-level type-checking. The fundamental semantic building blocks for constructing, type-checking and manipulating components are provided by the underlying first-class generic type system. To demonstrate the simplicity and utility of this approach we have designed and implemented an extension of Java called Component NEXTGEN (CGEN). CGEN, which is based on the Sun Java 5.0 javac compiler, is backwards compatible with existing Java binary code and runs on current Java Virtual Machines. The primary contribution of this paper is a technical analysis of the subtle design issues involved in building a component framework for a nominally typed object-oriented language supporting first-class generics. In contrast to component systems for structurally typed languages, mutual recursion among components is accommodated in the type system and semantics without incorporating any special machinery. Our analysis includes a presentation of Core CGEN (CCG), a small, core language modeling the CGEN framework. It is based on Featherweight GJ and incorporates some ideas from MIXGEN. CCG adds the essential features to support components, but nothing more. Our discussion includes the type rules and semantics for CCG, as well as a proof of type safety.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297039", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James", + "last_name": "Sasitorn", + "institution": "Rice University" + }, + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/SasitornC07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297030", + "title": "Jeannie: granting java native interface developers their wishes", + "abstract": "Higher-level languages interface with lower-level languages such as C to access platform functionality, reuse legacy libraries, or improve performance. This raises the issue of how to best integrate different languages while also reconciling productivity, safety, portability, and efficiency. This paper presents Jeannie, a new language design for integrating Java with C. In Jeannie, both Javaand C code are nested within each other in the same file and compile down to JNI, the Java platform's standard foreign function interface. By combining the two languages' syntax and semantics, Jeannie eliminates verbose boiler-plate code, enables static error detection across the language boundary, and simplifies dynamic resource management. We describe the Jeannie language and its compiler, while also highlighting lessons from composing two mature programming languages.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297030", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "IBM (United States)" + }, + { + "first_name": "Robert", + "last_name": "Grimm", + "institution": "New York University" + } + ], + "dblp_key": "conf/oopsla/HirzelG07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297043", + "title": "Streamflex: high-throughput stream programming in java", + "abstract": "The stream programming paradigm aims to expose coarsegrained parallelism in applications that must process continuous sequences of events.The appeal of stream programming comes from its conceptual simplicity.A program is a collection of independent filters which communicate by the means of uni-directional data channels.This model lends itself naturally to concurrent and efficient implementations on modern multiprocessors.As the output behavior of filters is determined by the state of their input channels, stream programs have fewer opportunities for the errors (such as data races and deadlocks) that plague shared memory concurrent programming.This paper introduces STREAMFLEX, an extension to Java which marries streams with objects and thus enables to combine, in the same Java virtual machine, stream processing code with traditional object-oriented components.STREAMFLEX targets high-throughput low-latency applications with stringent quality-of-service requirements.To achieve these goals, it must, at the same time, extend and restrict Java.To allow for program optimization and provide latency guarantees, the STREAMFLEX compiler restricts Java by imposing a stricter typing discipline on filters.On the other hand, STREAMFLEX extends the Java virtual machine with real-time capabilities, transactional memory and type-safe region-based allocation.The result is a rich and expressive language that can be implemented efficiently.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297043", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jesper Honig", + "last_name": "Spring", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Jean", + "last_name": "Privat", + "institution": "" + }, + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SpringPGV07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297035", + "title": "Probabilistic calling context", + "abstract": "Calling context enhances program understanding and dynamic analyses by providing a rich representation of program location. Compared to imperative programs, object-oriented programs use more interprocedural and less intraprocedural control flow, increasing the importance of context sensitivity for analysis. However, prior online methods for computing calling context, such as stack-walking or maintaining the current location in a calling context tree, are expensive in time and space. This paper introduces a new online approach called probabilistic calling context (PCC) that continuously maintains a probabilistically unique value representing the current calling context. For millions of unique contexts, a 32-bit PCC value has few conflicts. Computing the PCC value adds 3% average overhead to a Java virtual machine. PCC is well-suited to clients that detect new or anomalous behavior since PCC values from training and production runs can be compared easily to detect new context-sensitive behavior; clients that query the PCC value at every system call, Java utility call, and Java API call add 0-9% overhead on average. PCC adds space overhead proportional to the distinct contexts stored by the client (one word per context). Our results indicate PCC is efficient and accurate enough to use in deployed software for residual testing, bug detection, and intrusion detection.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297035", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/BondM07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297040", + "title": "User-changeable visibility: resolving unanticipated name clashes in traits", + "abstract": "A trait is a unit of behaviour that can be composed with other traits and used by classes. Traits offer an alternative to multiple inheritance. Conflict resolution of traits, while flexible, does not completely handle accidental method name conflicts: if a trait with method m is composed with another trait defining a different method m then resolving the conflict may prove delicate or infeasible in cases where both versions of m are still needed. In this paper we present freezeable traits, which provide an expressive composition mechanism to support unanticipated method composition conflicts. Our solution introduces private trait methods and lets the class composer change method visibility at composition time (from public to private and vice versa). Moreover two class composers may use different composition policies for the same trait, something which is not possible in mainstream languages. This approach respects the two main design principles of traits: the class composer is empowered and traits can be flattened away. We present an implementation of freezable traits in Smalltalk. As a side-effect of this implementation we introduced private (early-bound and invisible) methods to Smalltalk by distinguishing object-sends from self-sends. Our implementation uses compile-time bytecode manipulation and, as such, introduces no run-time penalties.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297040", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sté́phane", + "last_name": "Ducasse", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Roel", + "last_name": "Wuyts", + "institution": "Université Libre de Bruxelles" + }, + { + "first_name": "Alexandre", + "last_name": "Bergel", + "institution": "Hasso Plattner Institute" + }, + { + "first_name": "Oscar", + "last_name": "Nierstrasz", + "institution": "University of Bern" + } + ], + "dblp_key": "conf/oopsla/DucasseWBN07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297044", + "title": "Can programming be liberated from the two-level style: multi-level programming with deepjava", + "abstract": "Since the introduction of object-oriented programming few programming languages have attempted to provide programmers with more than objects and classes, i.e., more than two levels. Those that did, almost exclusively aimed at describing language properties-i.e., their metaclasses exert linguistic control on language concepts and mechanisms-often in order to make the language extensible. In terms of supporting logical domain classification levels, however, they are still limited to two levels.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297044", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Kühne", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Daniel K.", + "last_name": "Schreiber", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/oopsla/KuhneS07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297038", + "title": "Dependent classes", + "abstract": "Virtual classes allow nested classes to be refined in subclasses. In this way nested classes can be seen as dependent abstractions of the objects of the enclosing classes. Expressing dependency via nesting, however, has two limitations: Abstractions that depend on more than one object cannot be modeled and a class must know all classes that depend on its objects. This paper presents dependent classes, a generalization of virtual classes that expresses similar semantics by parameterization rather than by nesting. This increases expressivity of class variations as well as the flexibility of their modularization. Besides, dependent classes complement multimethods in scenarios where multi-dispatched abstractions rather than multi-dispatched methods are needed. They can also be used to express more precise signatures of multimethods and even extend their dispatch semantics. We present a formal semantics of dependent classes and a machine-checked type soundness proof in Isabelle/HOL [29], the first of this kind for a language with virtual classes and path-dependent types.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297038", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vaidas", + "last_name": "Gasiūnas", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/oopsla/GasiunasMO07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297047", + "title": "Notation and representation in collaborative object-oriented design: an observational study", + "abstract": "Software designers in the object-oriented paradigm can make use of modeling tools and standard notations such as UML. Nevertheless, casual observations from collocated design collaborations suggest that teams tend to use physical mediums to sketch a plethora of informal diagrams in varied representations that often diverge from UML. To better understand such collaborations and support them with tools, we need to understand the origins, roles, uses, and implications of these alternate representations. To this end we conducted observational studies of collaborative design exercises, in which we focused on representation use. Our primary finding is that teams intentionally improviserepresentations and organize design information in responseto ad-hoc needs, which arise from the evolution of the design, and which are difficult to meet with fixed standard notations. This behavior incurs orientation and grounding difficulties for which teams compensate by relying on memory, other communication mediums, and contextual cues. Without this additional information the artifacts are difficult to interpret and have limited documentation potential. Collaborative design tools and processes should therefore focus on preserving contextual information while permitting unconstrained mixing and improvising of notations.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297047", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Uri", + "last_name": "Dekel", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "James D.", + "last_name": "Herbsleb", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/DekelH07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297051", + "title": "Type qualifier inference for java", + "abstract": "Java's type system provides programmers with strong guarantees of type and memory safety, but there are many important properties not captured by standard Java types. We describe JQual, a tool that adds user-defined type qualifiers to Java, allowing programmers to quickly and easily incorporateextra lightweight, application-specific type checking into their programs. JQual provides type qualifier inference, so that programmers need only add a few key qualifier annotations to their program, and then JQual infers any remaining qualifiers and checks their consistency. We explore two applications of JQual. First, we introduce opaque and enumqualifiers to track C pointers and enumerations that flow through Java code via the JNI. In our benchmarks we found that these C values are treated correctly, but there are some places where a client could potentially violate safety. Second,we introduce a read only qualifier for annotating references that cannot be used to modify the objects they refer to. We found that JQual is able to automatically infer read only in many places on method signatures. These results suggest that type qualifiers and type qualifier inference are a useful addition to Java.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297051", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Greenfieldboyce", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/GreenfieldboyceF07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297050", + "title": "Modular typestate checking of aliased objects", + "abstract": "Objects often define usage protocols that clients must follow inorder for these objects to work properly. Aliasing makes itnotoriously difficult to check whether clients and implementations are compliant with such protocols. Accordingly, existing approaches either operate globally or severely restrict aliasing.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297050", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Bierhoff", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/BierhoffA07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297052", + "title": "Establishing object invariants with delayed types", + "abstract": "Mainstream object-oriented languages such as C# and Java provide an initialization model for objects that does not guarantee programmer controlled initialization of fields. Instead, all fields are initialized to default values (0 for scalars and null for non-scalars) on allocation. This is in stark contrast to functional languages, where all parts of an allocation are initialized to programmer-provided values. These choices have a direct impact on two main issues: 1) the prevalence of null in object oriented languages (and its general absence in functional languages), and 2) the ability to initialize circular data structures. This paper explores connections between these differing approaches and proposes a fresh look at initialization. Delayed types are introduced to express and formalize prevalent initialization patterns in object-oriented languages.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297052", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Songtao", + "last_name": "Xia", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/FahndrichX07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297059", + "title": "Inferring aliasing and encapsulation properties for java", + "abstract": "There are many proposals for language techniques to control aliasing and encapsulation in object oriented programs, typically based on notions of object ownership and pointer uniqueness. Most of these systems require extensive manual annotations, and thus there is little experience with these properties in large, existing Java code bases. To remedy this situation, we present Uno, a novel static analysis for automatically inferring ownership, uniqueness, and other aliasing and encapsulation properties in Java. Our analysis requires no annotations, and combines an intraprocedural points-to analysis with an interprocedural, demand-driven predicate resolution algorithm. We have applied Uno to a variety of Java applications and found that some aliasing properties, such as temporarily lending a reference to a method, are common, while others, in particular field and argument ownership, are relatively uncommon. As a result, we believe that Uno can be a valuable tool for discovering and understanding aliasing and encapsulation in Java programs.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297059", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kin-Keung", + "last_name": "Ma", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/MaF07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297057", + "title": "Tracking bad apples: reporting the origin of null and undefined value errors", + "abstract": "Programs sometimes crash due to unusable values, for example, when Java and C# programs dereference null pointers and when C and C++ programs use undefined values to affect program behavior. A stack trace produced on such a crash identifies the effect of the unusable value, not its cause, and is often not much help to the programmer.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297057", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Nicholas", + "last_name": "Nethercote", + "institution": "Data61" + }, + { + "first_name": "Stephen W.", + "last_name": "Kent", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "Tufts University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/BondNKGM07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297060", + "title": "Multiple ownership", + "abstract": "Existing ownership type systems require objects to have precisely one primary owner, organizing the heap into an ownership tree. Unfortunately, a tree structure is too restrictive for many programs, and prevents many common design patterns where multiple objects interact.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297060", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nicholas", + "last_name": "Cameron", + "institution": "Imperial College London" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Matthew J.", + "last_name": "Smith", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/CameronDNS07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297061", + "title": "Ownership transfer in universe types", + "abstract": "Ownership simplifies reasoning about object-oriented programs by controlling aliasing and modifications of objects. Several type systems have been proposed to express and check ownership statically. For ownership systems to be practical, they must allow objects to migrate from one owner to another. This ownership transfer is common and occurs, for instance, during the initialization of data structures and when data structures are merged. However, existing ownership type systems either do not support ownership transfer at all or they are too restrictive, give rather weak static guarantees, or require a high annotation overhead. In this paper, we present UTT, an extension of Universe Types that supports ownership transfer. UTT combines ownership type checking with a modular static analysis to control references to transferable objects. UTT is very flexible because it permits temporary aliases, even across certain method calls. Nevertheless, it guarantees statically that a cluster of objects is externally-unique when it is transferred and, thus, that ownership transfer is type safe. UTT provides the same encapsulation as Universe Types and requires only negligible annotation overhead.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297061", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arsenii", + "last_name": "Rudich", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/MullerR07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297053", + "title": "Modular verification of higher-order methods with mandatory calls specified by model programs", + "abstract": "What we call a''higher-order method\" (HOM) is a method that makes mandatory calls to other dynamically-dispatched methods. Examples include template methods as in the Template method design pattern and notify methods in the Observer pattern. HOMs are particularly difficult to reason about, because standard pre- and postcondition specifications cannot describe the mandatory calls. For reasoning about such methods, existing approaches use either higher order logic or traces, but both are complex and verbose.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297053", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steve M.", + "last_name": "Shaner", + "institution": "Iowa State University" + }, + { + "first_name": "Gary T.", + "last_name": "Leavens", + "institution": "Iowa State University" + }, + { + "first_name": "David A.", + "last_name": "Naumann", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ShanerLN07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297063", + "title": "Lost in translation: formalizing proposed extensions to c#", + "abstract": "Current real-world software applications typically involve heavy use of relational and XML data and their query languages. Unfortunately object-oriented languages and database query languages are based on different semantic foundations and optimization strategies. The resulting ''ROX (Relations, Objects, XML) impedance mismatc'' makes life very difficult for developers.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297063", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Mads", + "last_name": "Torgersen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/BiermanMT07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297064", + "title": "The java module system: core design and semantic definition", + "abstract": "Java has no module system. Its packages only subdivide the class name space, allowing only a very limited form of component-level information hiding and reuse. Two Java Community Processes have started addressing this problem: one describes the runtime system and has reached an early draft stage, while the other considers the developer's view and only has a straw-man proposal. Both are natural language documents, which inevitably contain ambiguities.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297064", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rok", + "last_name": "Strniša", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/oopsla/StrniaaSP07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297055", + "title": "Using early phase termination to eliminate load imbalances at barrier synchronization points", + "abstract": "We present a new technique, early phase termination, for eliminating idle processors in parallel computations that use barrier synchronization. This technique simply terminates each parallel phase as soon as there are too few remaining tasks to keep all of the processors busy. Although this technique completely eliminates the idling that would otherwise occur at barrier synchronization points, it may also change the computation and therefore the result that the computation produces. We address this issue by providing probabilistic distortion models that characterize how the use of early phase termination distorts the result that the computation produces. Our experimental results show that for our set of benchmark applications, 1) early phase termination can improve the performance of the parallel computation, 2) the distortion is small (or can be made to be small with the use of an appropriate compensation technique) and 3) the distortion models provide accurate and tight distortion bounds. These bounds can enable users to evaluate the effect of early phase termination and confidently accept results from parallel computations that use this technique if they find the distortion bounds to be acceptable. Finally, we identify a general computational pattern that works well with early phase termination and explain why computations that exhibit this pattern can tolerate the early termination of parallel tasks without producing unacceptable results.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297055", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Rinard07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297056", + "title": "Starc: static analysis for efficient repair of complex data", + "abstract": "Data structure corruptions are insidious bugs that reduce the reliability of software systems. Constraint-based datastructure repair promises to help programs recover from potentially crippling corruption errors. Prior work repairs a variety of relatively small data structures, usually with hundreds of nodes.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297056", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bassem", + "last_name": "Elkarablieh", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Duy", + "last_name": "Vu", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/ElkarabliehKVM07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297065", + "title": "Awesome: an aspect co-weaving system for composing multiple aspect-oriented extensions", + "abstract": "Domain specific aspect-oriented language extensions offer unique capabilities to deal with a variety of cross cutting concerns. Ideally, one should be able to use several of these extensions together in a single program. Unfortunately, each extension generally implements its own specialized weaver and the different weavers are incompatible. Even if the weavers were compatible, combining them is a difficult problem to solve in general, because each extension definesits own language with new semantics. In this paper we present a practical composition framework, named Awesome, for constructing a multi-extension weaver by plugging together independently developed aspect mechanisms. The framework has a component-based and aspect-oriented architecture that facilitates the development and integration of aspect weavers. To be scalable, the framework provides a default resolution of feature interactions in the composition. To be general, the framework provides means for customizing the composition behavior. Furthermore, to be practically useful, there is no framework-associated overhead on the runtime performance of compiled aspect programs. To illustrate the Awesome framework concretely, we demonstrate the construction of a weaver for a multi-extension AOP language that combines Cool and AspectJ. However, the composition method is not exclusive to Cool and AspectJ-it can be applied to combine any comparable reactive aspect mechanisms.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297065", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sergei", + "last_name": "Kojarski", + "institution": "Northeastern University" + }, + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "Open University of Israel" + } + ], + "dblp_key": "conf/oopsla/KojarskiL07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297069", + "title": "Mop: an efficient and generic runtime verification framework", + "abstract": "Monitoring-Oriented Programming (MOP1) [21, 18, 22, 19] is a formal framework for software development and analysis, in which the developer specifies desired properties using definable specification formalisms, along with code to execute when properties are violated or validated. The MOP framework automatically generates monitors from the specified properties and then integrates them together with the user-defined code into the original system. The previous design of MOP only allowed specifications without parameters, so it could not be used to state and monitor safety properties referring to two or more related objects. In this paper we propose a parametric specification formalism-independent extension of MOP, together with an implementation of JavaMOP that supports parameters. In our current implementation, parametric specifications are translated into AspectJ code and then weaved into the application using off-the-shelf AspectJ compilers; hence, MOP specifications can be seen as formal or logical aspects. Our JavaMOP implementation was extensively evaluated on two benchmarks, Dacapo [14] and Tracematches [8], showing that runtime verification in general and MOP in particular are feasible. In some of the examples, millions of monitor instances are generated, each observing a set of related objects. To keep the runtime overhead of monitoring and event observation low, we devised and implemented a decentralized indexing optimization. Less than 8% of the experiments showed more than 10% runtime overhead; in most cases our tool generates monitoring code as efficient as the hand-optimized code. Despite its genericity, JavaMOP is empirically shown to be more efficient than runtime verification systems specialized and optimized for particular specification formalisms. Many property violations were detected during our experiments; some of them are benign, others indicate defects in programs. Many of these are subtle and hard to find by ordinary testing.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297069", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Feng", + "last_name": "Chen", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/ChenR07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297072", + "title": "Living in the comfort zone", + "abstract": "A comfort zone is a tested region of a system's input space within which it has been observed to behave acceptably. To keep systems operating within their comfort zones, we advocate the interposition of rectifiers between systems and their input sources. Rectifiers are designed to transform inputs to ensure that they are within the comfort zone before they are presented to the system. Rectifiers enforce a highly constrained input format and, if necessary, discard information to force inputs to conform to this format. Potential benefits of this approach include the elimination of errors and vulnerabilities, the excision of undesirable excess functionality from large, complex systems, and a simplification of the computing environment.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297072", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Rinard07a", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297067", + "title": "Scalable omniscient debugging", + "abstract": "Omniscient debuggers make it possible to navigate backwards in time within a program execution trace, drastically improving the task of debugging complex applications. Still, they are mostly ignored in practice due to the challenges raised by the potentially huge size of the execution traces. This paper shows that omniscient debugging can be realistically realized through the use of different techniques addressing efficiency, scalability and usability. We present TOD, a portable Trace-Oriented Debugger for Java, which combines an efficient instrumentation for event generation, a specialized distributed database for scalable storage and efficient querying, support for partial traces in order to reduce the trace volume to relevant events, and innovative interface components for interactive trace navigation and analysis in the development environment. Provided a reasonable infrastructure, the performance of TOD allows a responsive debugging experience in the face of large programs.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297067", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Pothier", + "institution": "University of Chile" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "José", + "last_name": "Piquer", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/oopsla/PothierTP07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297068", + "title": "Using hpm-sampling to drive dynamic compilation", + "abstract": "All high-performance production JVMs employ an adaptive strategy for program execution. Methods are first executed unoptimized and then an online profiling mechanism is used to find a subset of methods that should be optimized during the same execution. This paper empirically evaluates the design space of several profilers for initiating dynamic compilation and shows that existing online profiling schemes suffer from several limitations. They provide an insufficient number of samples, are untimely, and have limited accuracy at determining the frequently executed methods. We describe and comprehensively evaluate HPM-sampling, a simple but effective profiling scheme for finding optimization candidates using hardware performance monitors (HPMs) that addresses the aforementioned limitations. We show that HPM-sampling is more accurate; has low overhead; and improves performance by 5.7% on average and up to 18.3% when compared to the default system in Jikes RVM, without changing the compiler.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297068", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dries", + "last_name": "Buytaert", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Andy", + "last_name": "Georges", + "institution": "Ghent University" + }, + { + "first_name": "Michael", + "last_name": "Hind", + "institution": "IBM (United States)" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University" + }, + { + "first_name": "Koen De", + "last_name": "Bosschere", + "institution": "Ghent University" + } + ], + "dblp_key": "conf/oopsla/BuytaertGHAEB07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297075", + "title": "No ifs, ands, or buts: uncovering the simplicity of conditionals", + "abstract": "Schematic tables are a new representation for conditionals. Roughly a cross between decision tables and data flowgraphs, they represent computation and decision-making orthogonally. They unify the full range of conditional constructs, from if statements through pattern matching to polymorphic predicate dispatch. Program logic is maintained in a declarative canonical form that enforces completeness and disjointness among choices. Schematic tables can beused either as a code specification/generation tool, or as a self-contained diagrammatic programming language. They give program logic the clarity of truth tables, and support high-level direct manipulation of that logic, avoiding much of the mental computation demanded by conventional conditionals.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297075", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Edwards", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Edwards07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297080", + "title": "The transactional memory / garbage collection analogy", + "abstract": "This essay presents remarkable similarities between transactional memory and garbage collection. The connections are fascinating in their own right, and they let us better understand one technology by thinking about the corresponding issues for the other.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297080", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/Grossman07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297078", + "title": "Confessions of a used programming language salesman", + "abstract": "For many years I had been fruitlessly trying to sell functional programming and Haskell to solve real world problems such as scripting and data-intensive three-tier distributed web applications. The lack of widespread adoption of Haskell is a real pity. Functional programming concepts are key to curing many of the headaches that plague the majority of programmers, who today are forced to use imperative languages. If the mountain won't come to Mohammed, Mohammed must go to the mountain, and so I left academia to join industry. Instead of trying to convince imperative programmers to forget everything they already know and learn something completely new, I decided to infuse existing imperative object-oriented programming languages with functional programming features. As a result, functional programming has finally reached the masses, except that it is called Visual Basic 9 instead of Haskell 98.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297078", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/Meijer07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297076", + "title": "Epi-aspects: aspect-oriented conscientious software", + "abstract": "Conscientious software is a recently proposed paradigm for developing reliable, self-sustaining software systems. Conscientious software systems consist of an allopoietic part, which encapsulates application functionality, and an autopoietic part that is responsible for keeping the system alive by monitoring the application and adapting it to environmental changes. Practical application of the conscientious software paradigm requires solutions to two open problems: The design of suitable autopoietic programming languages and the proposal of concrete architectures for combining the autopoietic and allopoietic parts. In this paper, we tackle the second challenge, and propose a concrete, aspect-oriented architecture for realizing conscientious software. Here, we introduce epi-aspects, a construct for upgrading new and existing applications into conscientious software. This paper provides the architectural design of epi-aspects, an autopoietic simulator, and a concrete framework for developing epi-aspects in Java. The framework and the simulator are used to conduct a case study in which we develop and test a conscientious Java application.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297076", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Fleissner", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Elisa", + "last_name": "Baniassad", + "institution": "Chinese University of Hong Kong" + } + ], + "dblp_key": "conf/oopsla/FleissnerB07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297070", + "title": "Making trace monitors feasible", + "abstract": "A trace monitor observes an execution trace at runtime; when it recognises a specified sequence of events, the monitor runs extra code. In the aspect-oriented programming community, the idea originatedas a generalisation of the advice-trigger mechanism: instead of matchingon single events (joinpoints), one matches on a sequence of events. The runtime verification community has been investigating similar mechanisms for a number of years, specifying the event patterns in terms of temporal logic, and applying the monitors to hardware and software.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297070", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Avgustinov", + "institution": "University of Oxford" + }, + { + "first_name": "Julian", + "last_name": "Tibble", + "institution": "University of Oxford" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/oopsla/AvgustinovTM07", + "venue": "oopsla", + "year": 2007 + }, + { + "paper_id": "10.1145/1297027.1297073", + "title": "Living it up with a live programming language", + "abstract": "A dynamic language promotes ease of use through flexible typing, a focus on high-level programming, and by streamlining the edit-compile-debug cycle. Live languages go beyond dynamic languages with more ease of use features. A live language supports live programming that provides programmers with responsive and continuous feedback about how their edits affect program execution. A live language is also based on high-level constructs such as declarative rules so that programmers can write less code. A live language could also provide programmers with responsive semantic feedback to enable time-saving services such as code completion. This paper describes the design of a textual live language that is based on reactive data-flow values known as signals and dynamic inheritance. Our language, SuperGlue, supports live programming with responsive semantic feedback, which we demonstrate with a working prototype.", + "date": "2007-10-21", + "link": "https://doi.org/10.1145/1297027.1297073", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sean", + "last_name": "McDirmid", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/McDirmid07", + "venue": "oopsla", + "year": 2007 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2008.json b/data/pl_conferences/oopsla/2008.json new file mode 100644 index 0000000..1824593 --- /dev/null +++ b/data/pl_conferences/oopsla/2008.json @@ -0,0 +1,1055 @@ +[ + { + "paper_id": "10.1145/1449764.1449771", + "title": "Whiteoak: introducing structural typing into java", + "abstract": "This paper presents WHITEOAK: a JAVA extension that introduces structural type equivalence and subtyping into the language. We argue that structural subtyping addresses common software design problems, and promotes the development of loosely coupled modules without compromising type safety.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449771", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Itay", + "last_name": "Maman", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/GilM08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449782", + "title": "jStar: towards practical verification for java", + "abstract": "In this paper we introduce a novel methodology for verifying a large set of Java programs which builds on recent theoretical developments in program verification: it combines the idea of abstract predicate families and the idea of symbolic execution and abstraction using separation logic. The proposed technology has been implemented in a new automatic verification system, called jStar, which combines theorem proving and abstract interpretation techniques. We demonstrate the effectiveness of our methodology by using jStar to verify example programs implementing four popular design patterns (subject/observer, visitor, factory, and pooling). Although these patterns are extensively used by object-oriented developers in real-world applications, so far they have been highly challenging for existing object-oriented verification techniques.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449782", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dino", + "last_name": "Distefano", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Matthew J. Parkinson", + "last_name": "J", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/oopsla/DistefanoP08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449772", + "title": "Mixing source and bytecode: a case for compilation by normalization", + "abstract": "Language extensions increase programmer productivity by providing concise, often domain-specific syntax, and support for static verification of correctness, security, and style constraints. Language extensions can often be realized through translation to the base language, supported by preprocessors and extensible compilers. However, various kinds of extensions require further adaptation of a base compiler's internal stages and components, for example to support separate compilation or to make use of low-level primitives of the platform (e.g., jump instructions or unbalanced synchronization). To allow for a more loosely coupled approach, we propose an open compiler model based on normalization steps from a high-level language to a subset of it, the core language. We developed such a compiler for a mixed Java and (core) bytecode language, and evaluate its effectiveness for composition mechanisms such as traits, as well as statement-level and expression-level language extensions.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449772", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lennart C.L.", + "last_name": "Kats", + "institution": "Delft University of Technology" + }, + { + "first_name": "Martin", + "last_name": "Bravenboer", + "institution": "University of Oregon" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/oopsla/KatsBV08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449786", + "title": "The impact of static-dynamic coupling on remodularization", + "abstract": "We explore the concept of static-dynamic coupling--the degree to which changes in a program's static modular structure imply changes to its dynamic structure. This paper investigates the impact of static-dynamic coupling in a programming language on the effort required to evolve the coarse modular structure of programs written in that language. We performed a series of remodularization case studies in both Java and SubjectJ. SubjectJ is designed to be similar to Java, but have strictly less static-dynamic coupling. Our results include quantitative measures-time taken and number of bugs introduced--as well as a more subjective qualitative analysis of the remodularization process. All results point in the same direction and suggest that static-dynamic coupling causes substantial accidental complexity for the remodularization of Java programs.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449786", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rick", + "last_name": "Chern", + "institution": "University of British Columbia" + }, + { + "first_name": "Kris De", + "last_name": "Volder", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/oopsla/ChernV08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449776", + "title": "QVM: an efficient runtime for detecting defects in deployed systems", + "abstract": "Coping with software defects that occur in the post-deployment stage is a challenging problem: bugs may occur only when the system uses a specific configuration and only under certain usage scenarios. Nevertheless, halting production systems until the bug is tracked and fixed is often impossible. Thus, developers have to try to reproduce the bug in laboratory conditions. Often the reproduction of the bug consists of the lion share of the debugging effort.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449776", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "IBM (United States)" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/ArnoldVY08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449770", + "title": "Join patterns for visual basic", + "abstract": "We describe an extension of Visual Basic 9.0 with asynchronous concurrency constructs- join patterns- based on the join calculus. Our design of Concurrent Basic (CB) builds on earlier work on Polyphonic C # and Cω. Since that work, the need for language-integrated concurrency has only grown, both due to the arrival of commodity, multi-core hardware, and the trend for Rich Internet Applications that rely on asynchronous client-server communication to hide latency. Unlike its predecessors, CB adopts an event-like syntax that should be familiar to existing VB programmers. Coupled with Generics, CB allows one to declare re-useable concurrency abstractions that were clumsy to express previously. CB removes its ancestors ’ inconvenient inheritance restriction, while providing new extensibility points useful in practical applications that must co-exist with or want to exploit alternative threading models available on the platform. CB is implemented as an extension of the production VB 9.0 compiler. Categories and Subject Descriptors D.3.3 [Programming Languages]: Language constructs and features—Concurrent programming structures;control structures; classes and objects", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449770", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Claudio", + "last_name": "Russo", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/Russo08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449775", + "title": "Jolt: lightweight dynamic analysis and removal of object churn", + "abstract": "It has been observed that component-based applications exhibit object churn, the excessive creation of short-lived objects, often caused by trading performance for modularity. Because churned objects are short-lived, they appear to be good candidates for stack allocation. Unfortunately, most churned objects escape their allocating function, making escape analysis ineffective.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449775", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ajeet", + "last_name": "Shankar", + "institution": "Berkeley College" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Berkeley College" + } + ], + "dblp_key": "conf/oopsla/ShankarAB08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449766", + "title": "Caching and incrementalisation in the java query language", + "abstract": "Many contemporary object-oriented programming languages support first-class queries or comprehensions. These language extensions make it easier for programmers to write queries, but are generally implemented no more efficiently than the code using collections, iterators, and loops that they replace. Crucially, whenever a query is re-executed, it is recomputed from scratch. We describe a general approach to optimising queries over mutable objects: query results are cached, and those caches are incrementally maintained whenever the collections and objects underlying those queries are updated. We hope that the performance benefits of our optimisations may encourage more general adoption of first-class queries by object-oriented programmers.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449766", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Darren", + "last_name": "Willis", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "David J.", + "last_name": "Pearce", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/oopsla/WillisPN08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449767", + "title": "Interprocedural query extraction for transparent persistence", + "abstract": "Transparent persistence promises to integrate programming languages and databases by allowing programs to access persistent data with the same ease as non-persistent data. In this work we demonstrate the feasibility of optimizing transparently persistent programs by extracting queries to efficiently prefetch required data. A static analysis derives query structure and conditions across methods that access persistent data. Using the static analysis, our system transforms the program to execute explicit queries. The transformed program composes queries across methods to handle method calls that return persistent data. We extend an existing Java compiler to implement the static analysis and program transformation, handling recursion and parameterized queries. We evaluate the effectiveness of query extraction on the OO7 and TORPEDO benchmarks. This work is focused on programs written in the current version of Java, without languages changes. However, the techniques developed here may also be of value in conjunction with object-oriented languages extended with high-level query syntax.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449767", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben", + "last_name": "Wiedermann", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ali", + "last_name": "Ibrahim", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/WiedermannIC08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449778", + "title": "Contention-aware scheduler: unlocking execution parallelism in multithreaded java programs", + "abstract": "In multithreaded programming, locks are frequently used as mechanism for synchronization. Because today's operating systems do not consider lock usage as scheduling criterion, scheduling decisions can be unfavorable to multithreaded applications, leading to performance issues such as convoying and heavy lock contention in systems with multiple processors. Previous efforts to address these issues (e.g., transactional memory, lock-free data structure) often treat scheduling decisions as a fact of life, and therefore these solutions try to cope with the consequences of undesirable scheduling instead of dealing with the problem directly. In this paper, we introduce Contention-Aware Scheduler (CA-Scheduler), which is designed to support efficient execution of large multithreaded Java applications in multiprocessor systems. Our proposed scheduler employs scheduling policy that reduces lock contention. As will be shown in this paper, our prototype implementation of the CA-Scheduler in Linux and Sun HotSpot virtual machine only incurs 3.5% runtime overhead, while the overall performance differences, when compared with system with no contention awareness, range from degradation of 3% in small multithreaded benchmark to an improvement of 15% in large Java application server benchmark.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449778", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Feng", + "last_name": "Xian", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Witawas", + "last_name": "Srisa‐an", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Hong", + "last_name": "Jiang", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "conf/oopsla/XianSJ08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449768", + "title": "Deep typechecking and refactoring", + "abstract": "Large software systems are typically composed of multiple layers, written in different languages and loosely coupled using a string-based interface. For example, in modern web-applications, a server written in Java communicates with a database back-end by passing in query strings. This widely prevalent approach is unsafe as the analyses developed for the individual layers are oblivious to the semantics of the dynamically constructed strings, making it impossible to statically reason about the correctness of the interaction. Further, even simple refactoring in such systems is daunting and error prone as the changes must also be applied to isolated string fragments scattered across the code base.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449768", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Chris", + "last_name": "Tucker", + "institution": "UC San Diego Health System" + }, + { + "first_name": "David", + "last_name": "Shuffelton", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "UC San Diego Health System" + } + ], + "dblp_key": "conf/oopsla/TatlockTSJL08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449774", + "title": "Tolerating memory leaks", + "abstract": "Type safety and garbage collection in managed languages eliminate memory errors such as dangling pointers, double frees, and leaks of unreachable objects. Unfortunately, a program still leaks memory if it maintains references to objects it will never use again. Leaked objects decrease program locality and increase garbage collection frequency and workload. A growing leak will eventually exhaust memory and crash the program.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449774", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/BondM08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449780", + "title": "Design and implementation of transactional constructs for C/C++", + "abstract": "This paper presents a software transactional memory system that introduces first-class C++ language constructs for transactional programming. We describe new C++ language extensions, a production-quality optimizing C++ compiler that translates and optimizes these extensions, and a high-performance STM runtime library. The transactional language constructs support C++ language features including classes, inheritance, virtual functions, exception handling, and templates. The compiler automatically instruments the program for transactional execution and optimizes TM overheads. The runtime library implements multiple execution modes and implements a novel STM algorithm that supports both optimistic and pessimistic concurrency control. The runtime switches a transaction's execution mode dynamically to improve performance and to handle calls to precompiled functions and I/O libraries. We present experimental results on 8 cores (two quad-core CPUs) running a set of 20 non-trivial parallel programs. Our measurements show that our system scales well as the numbers of cores increases and that our compiler and runtime optimizations improve scalability.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449780", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yang", + "last_name": "Ni", + "institution": "Intel (United States)" + }, + { + "first_name": "Adam", + "last_name": "Welc", + "institution": "Intel (United States)" + }, + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Intel (United States)" + }, + { + "first_name": "Moshe", + "last_name": "Bach", + "institution": "Israel Electric (Israel)" + }, + { + "first_name": "Sion", + "last_name": "Berkowits", + "institution": "Intel (Israel)" + }, + { + "first_name": "James H.", + "last_name": "Cownie", + "institution": "Intel (United Kingdom)" + }, + { + "first_name": "Robert", + "last_name": "Geva", + "institution": "Intel (United States)" + }, + { + "first_name": "Sergey", + "last_name": "Kozhukow", + "institution": "" + }, + { + "first_name": "Ravi", + "last_name": "Narayanaswamy", + "institution": "Intel (United States)" + }, + { + "first_name": "Jeffrey", + "last_name": "Olivier", + "institution": "Intel (United States)" + }, + { + "first_name": "Serguei V.", + "last_name": "Preis", + "institution": "" + }, + { + "first_name": "Bratin", + "last_name": "Saha", + "institution": "Intel (United States)" + }, + { + "first_name": "Ady", + "last_name": "Tal", + "institution": "Israel Electric (Israel)" + }, + { + "first_name": "Xinmin", + "last_name": "Tian", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/oopsla/NiWABBCGKNOPSTT08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449783", + "title": "Verifying correct usage of atomic blocks and typestate", + "abstract": "The atomic block, a synchronization primitive provided to programmers in transactional memory systems, has the potential to greatly ease the development of concurrent software. However, atomic blocks can still be used incorrectly, and race conditions can still occur at the level of application logic. In this paper, we present a intraprocedural static analysis, formalized as a type system and proven sound, that helps programmers use atomic blocks correctly. Using access permissions, which describe how objects are aliased and modified, our system statically prevents race conditions and enforces typestate properties in concurrent programs. We have implemented a prototype static analysis for the Java language based on our system and have used it to verify several realistic examples.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449783", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nels E.", + "last_name": "Beckman", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Kevin", + "last_name": "Bierhoff", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/BeckmanBA08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449784", + "title": "Enforcing object protocols by combining static and runtime analysis", + "abstract": "In this paper, we consider object protocols that constrain interactions between objects in a program. Several such protocols have been proposed in the literature. For many APIs (such as JDOM, JDBC), API designers constrain how API clients interact with API objects. In practice, API clients violate such constraints, as evidenced by postings in discussion forums for these APIs. Thus, it is important that API designers specify constraints using appropriate object protocols and enforce them. The goal of an object protocol is expressed as a protocol invariant. Fundamental properties such as ownership can be expressed as protocol invariants. We present a language, PROLANG, to specify object protocols along with their protocol invariants, and a tool, INVCOP++, to check if a program satisfies a protocol invariant. INVCOP++ separates the problem of checking if a protocol satisfies its protocol invariant (called protocol correctness), from the problem of checking if a program conforms to a protocol (called program conformance). The former is solved using static analysis, and the latter using runtime analysis. Due to this separation (1) errors made in protocol design are detected at a higher level of abstraction, independent of the program's source code, and (2) performance of conformance checking is improved as protocol correctness has been verified statically. We present theoretical guarantees about the way we combine static and runtime analysis, and empirical evidence that our tool INVCOP++ finds usage errors in widely used APIs. We also show that statically checking protocol correctness greatly optimizes the overhead of checking program conformance, thus enabling API clients to test whether their programs use the API as intended by the API designer.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449784", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Madhu", + "last_name": "Gopinathan", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Sriram K.", + "last_name": "Rajamani", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/oopsla/GopinathanR08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449779", + "title": "Dynamic optimization for efficient strong atomicity", + "abstract": "Transactional memory (TM) is a promising concurrency control alternative to locks. Recent work has highlighted important memory model issues regarding TM semantics and exposed problems in existing TM implementations. For safe, managed languages such as Java, there is a growing consensus towards strong atomicity semantics as a sound, scalable solution. Strong atomicity has presented a challenge to implement efficiently because it requires instrumentation of non-transactional memory accesses, incurring significant overhead even when a program makes minimal or no use of transactions. To minimize overhead, existing solutions require either a sophisticated type system, specialized hardware, or static whole-program analysis. These techniques do not translate easily into a production setting on existing hardware. In this paper, we present novel dynamic optimizations that significantly reduce strong atomicity overheads and make strong atomicity practical for dynamic language environments. We introduce analyses that optimistically track which non-transactional memory accesses can avoid strong atomicity instrumentation, and we describe a lightweight speculation and recovery mechanism that applies these analyses to generate speculatively-optimized but safe code for strong atomicity in a dynamically-loaded environment. We show how to implement these mechanisms efficiently by leveraging existing dynamic optimization infrastructure in a Java system. Measurements on a set of transactional and non-transactional Java workloads demonstrate that our techniques substantially reduce the overhead of strong atomicity from a factor of 5x down to 10% or less over an efficient weak atomicity baseline.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449779", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Florian", + "last_name": "Schneider", + "institution": "ETH Zurich" + }, + { + "first_name": "Vijay", + "last_name": "Menon", + "institution": "Google (United States)" + }, + { + "first_name": "Tatiana", + "last_name": "Shpeisman", + "institution": "Intel (United States)" + }, + { + "first_name": "Ali-Reza", + "last_name": "Adl-Tabatabai", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/oopsla/SchneiderMSA08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449788", + "title": "Annotation refactoring: inferring upgrade transformations for legacy applications", + "abstract": "Since annotations were added to the Java language, many frameworks have moved to using annotated Plain Old Java Objects (POJOs) in their newest releases. Legacy applications are thus forced to undergo extensive restructuring in order to migrate from old framework versions to new versions based on annotations (Version Lock-in). Additionally, because annotations are embedded in the application code, changing between framework vendors may also entail largescale manual changes (Vendor Lock-in).", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449788", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wesley", + "last_name": "Tansey", + "institution": "Virginia Tech" + }, + { + "first_name": "Eli", + "last_name": "Tilevich", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/oopsla/TanseyT08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449792", + "title": "Typestate-like analysis of multiple interacting objects", + "abstract": "This paper presents a static analysis of typestate-like temporal specifications of groups of interacting objects, which are expressed using tracematches. Whereas typestate expresses a temporal specification of one object, a tracematch state may change due to operations on any of a set of related objects bound by the tracematch. The paper proposes a lattice-based operational semantics equivalent to the original tracematch semantics but better suited to static analysis. The paper defines a static analysis that computes precise local points-to sets and tracks the flow of individual objects, thereby enabling strong updates of the tracematch state. The analysis has been proved sound with respect to the semantics. A context-sensitive version of the analysis has been implemented as instances of the IFDS and IDE algorithms. The analysis was evaluated on tracematches used in earlier work and found to be very precise. Remaining imprecisions could be eliminated with more precise modeling of references from the heap and of exceptional control flow.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449792", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nomair A.", + "last_name": "Naeem", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/oopsla/NaeemL08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449787", + "title": "Sound and extensible renaming for java", + "abstract": "Descriptive names are crucial to understand code. However, good names are notoriously hard to choose and manually changing a globally visible name can be a maintenance nightmare. Hence, tool support for automated renaming is an essential aid for developers and widely supported by popular development environments.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449787", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Max", + "last_name": "Schäfer", + "institution": "University of Oxford" + }, + { + "first_name": "Torbjörn", + "last_name": "Ekman", + "institution": "University of Oxford" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/oopsla/SchaferEM08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449790", + "title": "Enabling static analysis for partial java programs", + "abstract": "Software engineering tools often deal with the source code of programs retrieved from the web or source code repositories. Typically, these tools only have access to a subset of a program's source code (one file or a subset of files) which makes it difficult to build a complete and typed intermediate representation (IR). Indeed, for incomplete object-oriented programs, it is not always possible to completely disambiguate the syntactic constructs and to recover the declared type of certain expressions because the declaration of many types and class members are not accessible.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449790", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Barthélémy", + "last_name": "Dagenais", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/oopsla/DagenaisH08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449795", + "title": "Analysis and reduction of memory inefficiencies in Java strings", + "abstract": "This paper describes a novel approach to reduce the memory consumption of Java programs, by focusing on their \"string memory inefficiencies\". In recent Java applications, string data occupies a large amount of the heap area. For example, about 40% of the live heap area is used for string data when a production J2EE application server is running. By investigating the string data in the live heap, we identified two types of memory inefficiencies -- \"duplication\" and \"unused literals\". In the heap, there are many string objects that have the same values. There also exist many string literals whose values are not actually used by the application. Since these inefficiencies exist as live objects, they cannot be eliminated by existing garbage collection techniques, which only remove dead objects. Quantitative analysis of Java heaps in real applications revealed that more than 50% of the string data in the live heap is wasted by these inefficiencies. To reduce the string memory inefficiencies, this paper proposes two techniques at the Java virtual machine level, \"StringGC\" for eliminating duplicated strings at the time of garbage collection, and \"Lazy Body Creation\" for delaying part of the literal instantiation until the literal's value is actually used. We also present an interesting technique at the Java program level, which we call \"BundleConverter\", for preventing unused message literals from being instantiated. Prototype implementations on a production Java virtual machine have achieved about 18% reduction of the live heap in the production application server. The proposed techniques could also reduce the live heap of standard Java benchmarks by 11.6% on average, without noticeable performance degradation.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449795", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kiyokuni", + "last_name": "Kawachiya", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Kazunori", + "last_name": "Ogata", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Tamiya", + "last_name": "Onodera", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/KawachiyaOO08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449804", + "title": "Java type inference is broken: can we fix it?", + "abstract": "Java 5, the most recent major update to the Java Programming Language, introduced a number of sophisticated features, including a major extension to the type system. While the technical details of these new features are complex, much of this complexity is hidden from the typical Java developer by an ambitious type inference mechanism. Unfortunately, the extensions to the Java 5 type system were so novel that their technical details had not yet been thoroughly investigated in the research literature. As a result, the Java 5 compiler includes a pragmatic but flawed type inference algorithm that is, by design, neither sound nor locally complete. The language specification points out that neither of these failures is catastrophic: the correctness of potentially-unsound results must be verified during type checking; and incompleteness can usually be worked around by manually providing the method type parameter bindings for a given call site. This paper dissects the type inference algorithm of Java 5 and proposes a signficant revision that is sound and able to calculate correct results where the Java 5 algorithm fails. The new algorithm is locally complete with the exception of a difficult corner case. Moreover, the new algorithm demonstrates that several arbitrary restrictions in the Java type system---most notably the ban on lower-bounded type parameter declarations and the limited expressibility of intersection types---are unnecessary. We hope that this work will spur the evolution of a more coherent, more comprehensive generic type system for Java.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449804", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Smith", + "institution": "Rice University" + }, + { + "first_name": "Robert", + "last_name": "Cartwright", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/SmithC08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449791", + "title": "Safer unsafe code for .NET", + "abstract": "The.NET intermediate language (MSIL) allows expressing both statically verifiable memory and type safe code (typi-cally called managed), as well as unsafe code using direct pointer manipulations. Unsafe code can be expressed in C# by marking regions of code as unsafe. Writing unsafe code can be useful where the rules of managed code are too strict. The obvious drawback of unsafe code is that it opens the door to programming errors typical of C and C++, namely memory access errors such as buffer overruns. Worse, a sin-gle piece of unsafe code may corrupt memory and destabi-lize the entire runtime or allow attackers to compromise the security of the platform. We present a new static analysis based on abstract in-terpretation to check memory safety for unsafe code in the.NET framework. The core of the analysis is a new numeri-cal abstract domain, Strp, which is used to efficiently com-pute memory invariants. Strp is combined with lightweight abstract domains to raise the precision, yet achieving scala-bility. We implemented this analysis in Clousot, a generic static analyzer for.NET. In combination with contracts ex-pressed in FoxTrot, an MSIL based annotation language for.NET, our analysis provides static safety guarantees on memory accesses in unsafe code. We tested it on all the as-semblies of the.NET framework. We compare our results with those obtained using existing domains, showing how they are either too imprecise (e.g., Intervals or Octagons) or too expensive (Polyhedra) to be used in practice.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449791", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pietro", + "last_name": "Ferrara", + "institution": "École Polytechnique" + }, + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/FerraraLF08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449794", + "title": "Java performance evaluation through rigorous replay compilation", + "abstract": "A managed runtime environment, such as the Java virtual machine, is non-trivial to benchmark. Java performance is affected in various complex ways by the application and its input, as well as by the virtual machine (JIT optimizer, garbage collector, thread scheduler, etc.). In addition, non-determinism due to timer-based sampling for JIT optimization, thread scheduling, and various system effects further complicate the Java performance benchmarking process.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449794", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andy", + "last_name": "Georges", + "institution": "Ghent University" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University" + }, + { + "first_name": "Dries", + "last_name": "Buytaert", + "institution": "Ghent University" + } + ], + "dblp_key": "conf/oopsla/GeorgesEB08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449808", + "title": "Multiple dispatch in practice", + "abstract": "Multiple dispatch uses the run time types of more than one argument to a method call to determine which method body to run. While several languages over the last 20 years have provided multiple dispatch, most object-oriented languages still support only single dispatch forcing programmers to implement multiple dispatch manually when required. This paper presents an empirical study of the use of multiple dispatch in practice, considering six languages that support multiple dispatch, and also investigating the potential for multiple dispatch in Java programs. We hope that this study will help programmers understand the uses and abuses of multiple dispatch; virtual machine implementors optimise multiple dispatch; and language designers to evaluate the choice of providing multiple dispatch in new programming languages.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449808", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Radu", + "last_name": "Muschevici", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Ewan", + "last_name": "Tempero", + "institution": "University of Auckland" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/oopsla/MuscheviciPTN08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449796", + "title": "Analyzing the performance of code-copying virtual machines", + "abstract": "Many popular programming languages use interpreter-based execution for portability, supporting dynamic or reflective properties, and ease of implementation. Code-copying is an optimization technique for interpreters that reduces the performance gap between interpretation and JIT compilation, offering significant speedups over direct-threading interpretation. Due to varying language features and virtual machine design, however, not all languages benefit from codecopying to the same extent. We consider here properties of interpreted languages, and in particular bytecode and virtual machine construction that enhance or reduce the impact of code-copying. We implemented code-copying and compared performance with the original direct-threading virtual machines for three languages, Java (SableVM), OCaml, and Ruby (Yarv), examining performance on three different architectures, ia32 (Pentium 4), x86_64 (AMD64) and PowerPC (G5). Best speedups are achieved on ia32 by OCaml (maximum 4.88 times, 2.81 times on average), where a small and simple bytecode design facilitates improvements to branch prediction brought by code-copying. Yarv only slightly improves over direct-threading; large working sizes of bytecodes, and a relatively small fraction of time spent in the actual interpreter loop both limit the application of codecopying and its overall net effect. We are able to show that simple ahead of time analysis of VM and execution properties can help determine the suitability of code-copying for a particular VM before an implementation of code-copying is even attempted.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449796", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gregory B.", + "last_name": "Prokopski", + "institution": "McGill University" + }, + { + "first_name": "Clark", + "last_name": "Verbrugge", + "institution": "McGill University" + } + ], + "dblp_key": "conf/oopsla/ProkopskiV08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449799", + "title": "The visitor pattern as a reusable, generic, type-safe component", + "abstract": "The VISITOR design pattern shows how to separate the structure of an object hierarchy from the behaviour of traversals over that hierarchy. The pattern is very flexible; this very flexibility makes it difficult to capture the pattern as anything more formal than prose, pictures and prototypes.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449799", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Oxford" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Oxford" + }, + { + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/oopsla/OliveiraWG08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449803", + "title": "Efficient software model checking of soundness of type systems", + "abstract": "This paper presents novel techniques for checking the soundness of a type system automatically using a software model checker. Our idea is to systematically generate every type correct intermediate program state (within some finite bounds), execute the program one step forward if possible using its small step operational semantics, and then check that the resulting intermediate program state is also type correct--but do so efficiently by detecting similarities in this search space and pruning away large portions of the search space. Thus, given only a specification of type correctness and the small step operational semantics for a language, our system automatically checks type soundness by checking that the progress and preservation theorems hold for the language (albeit for program states of at most some finite size). Our preliminary experimental results on several languages--including a language of integer and boolean expressions, a simple imperative programming language, an object-oriented language which is a subset of Java, and a language with ownership types--indicate that our approach is feasible and that our search space pruning techniques do indeed significantly reduce what is otherwise an extremely large search space. Our paper thus makes contributions both in the area of checking soundness of type systems, and in the area of reducing the state space of a software model checker.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449803", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Roberson", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Melanie", + "last_name": "Harries", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Paul T.", + "last_name": "Darga", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Chandrasekhar", + "last_name": "Boyapati", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/oopsla/RobersonHDB08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449800", + "title": "Constrained types for object-oriented languages", + "abstract": "X10 is a modern object-oriented language designed for productivity and performance in concurrent and distributed systems. In this setting, dependent types offer significant opportunities for detecting design errors statically, documenting design decisions, eliminating costly run-time checks (e.g., for array bounds, null values), and improving the quality of generated code.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449800", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nathaniel", + "last_name": "Nystrom", + "institution": "IBM (United States)" + }, + { + "first_name": "Vijay", + "last_name": "Saraswat", + "institution": "IBM (United States)" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "UCLA Health" + }, + { + "first_name": "Christian", + "last_name": "Grothoff", + "institution": "University of Denver" + } + ], + "dblp_key": "conf/oopsla/NystromSPG08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449802", + "title": "Efficient local type inference", + "abstract": "Inference of static types for local variables in Java bytecode is the first step of any serious tool that manipulates bytecode, be it for decompilation, transformation or analysis. It is important, therefore, to perform that step as accurately and efficiently as possible. Previous work has sought to give solutions with good worst-case complexity.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449802", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben", + "last_name": "Bellamy", + "institution": "University of Oxford" + }, + { + "first_name": "Pavel", + "last_name": "Avgustinov", + "institution": "University of Oxford" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + }, + { + "first_name": "Damien", + "last_name": "Sereni", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/oopsla/BellamyAMS08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449807", + "title": "A theory of aspects as latent topics", + "abstract": "After more than 10 years, Aspect-Oriented Programming (AOP) is still a controversial idea. While the concept of aspects appeals to everyone's intuitions, concrete AOP solutions often fail to convince researchers and practitioners alike. This discrepancy results in part from a lack of an adequate theory of aspects, which in turn leads to the development of AOP solutions that are useful in limited situations.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449807", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Baldi", + "institution": "University of California, Irvine" + }, + { + "first_name": "Cristina Videira", + "last_name": "Lopes", + "institution": "University of California, Irvine" + }, + { + "first_name": "Erik", + "last_name": "Linstead", + "institution": "University of California, Irvine" + }, + { + "first_name": "Sushil", + "last_name": "Bajracharya", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/oopsla/BaldiLLB08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449806", + "title": "Delegation-based semantics for modularizing crosscutting concerns", + "abstract": "We describe semantic mappings of four high-level programming languages to our delegation-based machine model for aspect-oriented programming. One of the languages is a class-based object-oriented one. The other three represent extensions thereof that support various approaches to modularizing crosscutting concerns. We explain informally that an operational semantics expressed in terms of the model's concepts preserves the behavior of a program written in one of the high-level languages. We hence argue our model to be semantically sound in that sense, as well as sufficiently expressive in order to correctly support features such as class-based object-oriented programming, the open-classes and pointcut-and-advice flavors of aspect-oriented programming, and dynamic layers. For the latter, being a core feature of context-oriented programming, we also provide a formal semantics.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449806", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hans", + "last_name": "Schippers", + "institution": "University of Antwerp" + }, + { + "first_name": "Dirk", + "last_name": "Janssens", + "institution": "University of Antwerp" + }, + { + "first_name": "Michael", + "last_name": "Haupt", + "institution": "Hasso Plattner Institute" + }, + { + "first_name": "Robert", + "last_name": "Hirschfeld", + "institution": "Hasso Plattner Institute" + } + ], + "dblp_key": "conf/oopsla/SchippersJHH08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449813", + "title": "Designed as designer", + "abstract": "Conceptual integrity arises not (simply) from one mind or from a small number of agreeing resonant minds, but from sometimes hidden co-authors and the thing designed itself.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449813", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard P.", + "last_name": "Gabriel", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/Gabriel08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449810", + "title": "A tag-based approach for the design and composition of information processing applications", + "abstract": "In the realm of component-based software systems, pursuers of the holy grail of automated application composition face many significant challenges. In this paper we argue that, while the general problem of automated composition in response to high-level goal statements is indeed very difficult to solve, we can realize composition in a restricted context, supporting varying degrees of manual to automated assembly for specific types of applications. We propose a novel paradigm for composition in flow-based information processing systems, where application design and component development are facilitated by the pervasive use of faceted, tag-based descriptions of processing goals, of component capabilities, and of structural patterns of families of application. The facets and tags represent different dimensions of both data and processing, where each facet is modeled as a finite set of tags that are defined in a controlled folksonomy. All data flowing through the system, as well as the functional capabilities of components are described using tags. A customized AI planner is used to automatically build an application, in the form of a flow of components, given a high-level goal specification in the form of a set of tags. End-users use an automatically populated faceted search and navigation mechanism to construct these high-level goals. We also propose a novel software engineering methodology to design and develop a set of reusable, well-described components that can be assembled into a variety of applications. With examples from a case study in the Financial Services domain, we demonstrate that composition using a faceted, tag-based application design is not only possible, but also extremely useful in helping end-users create situational applications from a wide variety of available components.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449810", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Bouillet", + "institution": "IBM (United States)" + }, + { + "first_name": "Mark", + "last_name": "Feblowitz", + "institution": "Cambridge Scientific (United States)" + }, + { + "first_name": "Zhen", + "last_name": "Liu", + "institution": "IBM (United States)" + }, + { + "first_name": "Anand", + "last_name": "Ranganathan", + "institution": "IBM (United States)" + }, + { + "first_name": "Anton", + "last_name": "Riabov", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/BouilletFLRR08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449811", + "title": "Towards adaptive programming: integrating reinforcement learning into a programming language", + "abstract": "Current programming languages and software engineering paradigms are proving insufficient for building intelligent multi-agent systems--such as interactive games and narratives--where developers are called upon to write increasingly complex behavior for agents in dynamic environments. A promising solution is to build adaptive systems; that is, to develop software written specifically to adapt to its environment by changing its behavior in response to what it observes in the world. In this paper we describe a new programming language, An Adaptive Behavior Language (A2BL), that implements adaptive programming primitives to support partial programming, a paradigm in which a programmer need only specify the details of behavior known at code-writing time, leaving the run-time system to learn the rest. Partial programming enables programmers to more easily encode software agents that are difficult to write in existing languages that do not offer language-level support for adaptivity. We motivate the use of partial programming with an example agent coded in a cutting-edge, but non-adaptive agent programming language (ABL), and show how A2BL can encode the same agent much more naturally.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449811", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Simpkins", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Sooraj", + "last_name": "Bhat", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Charles L.", + "last_name": "Isbell", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Mateas", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/oopsla/SimpkinsBIM08", + "venue": "oopsla", + "year": 2008 + }, + { + "paper_id": "10.1145/1449764.1449798", + "title": "Generics of a higher kind", + "abstract": "With Java 5 and C# 2.0, first-order parametric polymorphism was introduced in mainstream object-oriented programming languages under the name of generics. Although the first-order variant of generics is very useful, it also imposes some restrictions: it is possible to abstract over a type, but the resulting type constructor cannot be abstracted over. This can lead to code duplication. We removed this restriction in Scala, by allowing type constructors as type parameters and abstract type members. This paper presents the design and implementation of the resulting type constructor polymorphism. Furthermore, we study how this feature interacts with existing object-oriented constructs, and show how it makes the language more expressive.", + "date": "2008-10-19", + "link": "https://doi.org/10.1145/1449764.1449798", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adriaan", + "last_name": "Moors", + "institution": "KU Leuven" + }, + { + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/MoorsPO08", + "venue": "oopsla", + "year": 2008 + } +] \ No newline at end of file From 244482ea155aaf598de4277ee6ed58897eb9876d Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:39:08 +0200 Subject: [PATCH 12/34] feat: ingest ESOP back-catalogue (1992-1992, partial) Only ESOP 1992 survived the no-abstract filter so far for pre-2010 Springer DOIs (OpenAlex/Semantic Scholar abstracts are sparse for old Springer LNCS). Will resume harvesting after DBLP rate limit clears. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/esop/1992.json | 48 ++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 data/pl_conferences/esop/1992.json diff --git a/data/pl_conferences/esop/1992.json b/data/pl_conferences/esop/1992.json new file mode 100644 index 0000000..42e4fb8 --- /dev/null +++ b/data/pl_conferences/esop/1992.json @@ -0,0 +1,48 @@ +[ + { + "paper_id": "10.1007/3-540-55253-7_2", + "title": "SIGNAL as a Model for Real-Time and Hybrid Systems", + "abstract": "Hybrid Systems axe models of systems operating in real-time and handling events as well as “continuous” computations. The Signal formalism for Hybrid Systems is presented in this extended abstract. Its expressive power is discussed, and a general method to associate various formal systems with it is presented and illustrated on deriving the present Signal compiler.", + "date": "1992-01-01", + "link": "https://doi.org/10.1007/3-540-55253-7_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Albert", + "last_name": "Benveniste", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Michel Le", + "last_name": "Borgne", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Paul Le", + "last_name": "Guernic", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/BenvenisteBG92", + "venue": "esop", + "year": 1992 + }, + { + "paper_id": "10.1007/3-540-55253-7_25", + "title": "A Provably Correct Compiler Generator", + "abstract": "We have designed, implemented, and proved the correctness of a compiler generator that accepts action semantic descriptions of imperative programming languages. The generated compilers emit absolute code for an abstract RISC machine language that currently is assembled into code for the SPARC and the HP Precision Architecture. Our machine language needs no run-time type-checking and is thus more realistic than those considered in previous compiler proofs. We use solely algebraic specifications; proofs are given in the initial model.", + "date": "1992-01-01", + "link": "https://doi.org/10.1007/3-540-55253-7_25", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/esop/Palsberg92", + "venue": "esop", + "year": 1992 + } +] \ No newline at end of file From 110beb0a1a1a68af7d75a9ef400f3b399ba42a91 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:40:22 +0200 Subject: [PATCH 13/34] feat: roll DBLP requests across mirrors on rate limit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit dblp.org throttles aggressively under sustained load — even after moving to the static XML TOCs, sustained harvesting can hit a 30+ minute IP-level block. dblp publishes two long-running mirrors at dblp.uni-trier.de and dblp.dagstuhl.de that serve the same content under separate quotas. Round-robin DBLP requests across all three on each retry attempt, so a primary outage doesn't stall the bulk ingest. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 39 +++++++++++++++++++++++--- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index 24a11fa..fc08e92 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -317,6 +317,29 @@ def _pace_dblp() -> None: time.sleep(sleep_for) +# DBLP runs three publicly-listed mirrors. If the primary throttles or +# blocks our IP, we transparently retry against the mirrors before +# giving up. They serve the same content. Order matters: dblp.org +# first, then the long-running aliases. +_DBLP_MIRRORS = ( + "https://dblp.org", + "https://dblp.uni-trier.de", + "https://dblp.dagstuhl.de", +) + + +def _dblp_alt_urls(url: str) -> list[str]: + """If ``url`` is a DBLP URL, return ``[url, mirror1, mirror2, ...]``; + otherwise return ``[url]``. Used to roll over to a sibling host when + the primary rate-limits the IP. + """ + for primary in _DBLP_MIRRORS: + if url.startswith(primary + "/"): + tail = url[len(primary) :] + return [primary + tail] + [m + tail for m in _DBLP_MIRRORS if m != primary] + return [url] + + def _request_with_retries( session: requests.Session, url: str, @@ -325,19 +348,27 @@ def _request_with_retries( timeout: int = 30, max_attempts: int = 6, ) -> requests.Response: - """GET with exponential backoff on transient errors (429/5xx/connection).""" + """GET with exponential backoff on transient errors (429/5xx/connection). + + For DBLP URLs the request rolls across mirrors before each retry, + so a primary-host outage doesn't block progress. + """ + candidate_urls = _dblp_alt_urls(url) attempt = 0 backoff = 3.0 while True: attempt += 1 + # Round-robin across mirrors so successive retries don't keep + # hammering the throttling primary. + target = candidate_urls[(attempt - 1) % len(candidate_urls)] try: - resp = session.get(url, params=params, timeout=timeout) + resp = session.get(target, params=params, timeout=timeout) except requests.RequestException as exc: if attempt >= max_attempts: raise logger.warning( "Request to %s failed (%s); retry %d/%d in %.1fs", - url, + target, exc, attempt, max_attempts, @@ -351,7 +382,7 @@ def _request_with_retries( wait = float(retry_after) if retry_after else backoff logger.warning( "Request to %s returned %s; retry %d/%d in %.1fs", - url, + target, resp.status_code, attempt, max_attempts, From 5634dabb800d11b622352a705e4f3d07092da933 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:42:31 +0200 Subject: [PATCH 14/34] feat: ingest OOPSLA back-catalogue (2009-2025) Completes the OOPSLA back-catalogue. 17 more years (2009-2025) harvested via the static-XML path with mirror rollover. Combined with the earlier 1986-2008 commit, OOPSLA spans 1986 to 2025. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/oopsla/2009.json | 961 ++++ data/pl_conferences/oopsla/2010.json | 1803 +++++++ data/pl_conferences/oopsla/2011.json | 1893 +++++++ data/pl_conferences/oopsla/2012.json | 1789 +++++++ data/pl_conferences/oopsla/2013.json | 1472 ++++++ data/pl_conferences/oopsla/2014.json | 1613 ++++++ data/pl_conferences/oopsla/2015.json | 1586 ++++++ data/pl_conferences/oopsla/2016.json | 1563 ++++++ data/pl_conferences/oopsla/2017.json | 2100 ++++++++ data/pl_conferences/oopsla/2018.json | 1922 +++++++ data/pl_conferences/oopsla/2019.json | 2416 +++++++++ data/pl_conferences/oopsla/2020.json | 3589 +++++++++++++ data/pl_conferences/oopsla/2021.json | 2505 +++++++++ data/pl_conferences/oopsla/2022.json | 3013 +++++++++++ data/pl_conferences/oopsla/2023.json | 3912 ++++++++++++++ data/pl_conferences/oopsla/2024.json | 5026 ++++++++++++++++++ data/pl_conferences/oopsla/2025.json | 7345 ++++++++++++++++++++++++++ 17 files changed, 44508 insertions(+) create mode 100644 data/pl_conferences/oopsla/2009.json create mode 100644 data/pl_conferences/oopsla/2010.json create mode 100644 data/pl_conferences/oopsla/2011.json create mode 100644 data/pl_conferences/oopsla/2012.json create mode 100644 data/pl_conferences/oopsla/2013.json create mode 100644 data/pl_conferences/oopsla/2014.json create mode 100644 data/pl_conferences/oopsla/2015.json create mode 100644 data/pl_conferences/oopsla/2016.json create mode 100644 data/pl_conferences/oopsla/2017.json create mode 100644 data/pl_conferences/oopsla/2018.json create mode 100644 data/pl_conferences/oopsla/2019.json create mode 100644 data/pl_conferences/oopsla/2020.json create mode 100644 data/pl_conferences/oopsla/2021.json create mode 100644 data/pl_conferences/oopsla/2022.json create mode 100644 data/pl_conferences/oopsla/2023.json create mode 100644 data/pl_conferences/oopsla/2024.json create mode 100644 data/pl_conferences/oopsla/2025.json diff --git a/data/pl_conferences/oopsla/2009.json b/data/pl_conferences/oopsla/2009.json new file mode 100644 index 0000000..dc208eb --- /dev/null +++ b/data/pl_conferences/oopsla/2009.json @@ -0,0 +1,961 @@ +[ + { + "paper_id": "10.1145/1640089.1640106", + "title": "The design of a task parallel library", + "abstract": "The Task Parallel Library (TPL) is a library for .NET that makes it easy to take advantage of potential parallelism in a program. The library relies heavily on generics and delegate expressions to provide custom control structures expressing structured parallelism such as map-reduce in user programs. The library implementation is built around the notion of a task as a finite CPU-bound computation. To capture the ubiquitous apply-to-all pattern the library also introduces the novel concept of a replicable task. Tasks and replicable tasks are assigned to threads using work stealing techniques, but unlike traditional implementations based on the THE protocol, the library uses a novel data structure called a 'duplicating queue'. A surprising feature of duplicating queues is that they have sequentially inconsistent behavior on architectures with weak memory models, but capture this non-determinism in a benign way by sometimes duplicating elements. TPL ships as part of the Microsoft Parallel Extensions for the .NET framework 4.0, and forms the foundation of Parallel LINQ queries (however, note that the productized TPL library may differ in significant ways from the basic design described in this article).", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640106", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wolfram", + "last_name": "Schulte", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/LeijenSB09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640108", + "title": "Strictly declarative specification of sophisticated points-to analyses", + "abstract": "We present the DOOP framework for points-to analysis of Java programs. DOOP builds on the idea of specifying pointer analysis algorithms declaratively, using Datalog: a logic-based language for defining (recursive) relations. We carry the declarative approach further than past work by describing the full end-to-end analysis in Datalog and optimizing aggressively using a novel technique specifically targeting highly recursive Datalog programs.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640108", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Bravenboer", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/BravenboerS09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640100", + "title": "How a Java VM can get more from a hardware performance monitor", + "abstract": "This paper describes our sampling-based profiler that exploits a processor's HPM (Hardware Performance Monitor) to collect information on running Java applications for use by the Java VM. Our profiler provides two novel features: Java-level event profiling and lightweight context-sensitive event profiling. For Java events, we propose new techniques to leverage the sampling facility of the HPM to generate object creation profiles and lock activity profiles. The HPM sampling is the key to achieve a smaller overhead compared to profilers that do not rely on hardware helps. To sample the object creations with the HPM, which can only sample hardware events such as executed instructions or cache misses, we correlate the object creations with the store instructions for Java object headers. For the lock activity profile, we introduce an instrumentation-based technique, called ProbeNOP, which uses a special NOP instruction whose executions are counted by the HPM. For the context-sensitive event profiling, we propose a new technique called CallerChaining, which detects the calling context of HPM events based on the call stack depth (the value of the stack frame pointer). We show that it can detect the calling contexts in many programs including a large commercial application. Our proposed techniques enable both programmers and runtime systems to get more valuable information from the HPM to understand and optimize the programs without adding significant runtime overhead.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640100", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hiroshi", + "last_name": "Inoue", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/InoueN09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640102", + "title": "Inferred call path profiling", + "abstract": "Prior work has found call path profiles to be useful for optimizers and programmer-productivity tools. Unfortunately, previous approaches for collecting path profiles are expensive: they need to either execute additional instructions (to track calls and returns) or they need to walk the stack. The state-of-the-art techniques for call path profiling slow down the program by 7% (for C programs) and 20% (for Java programs). This paper describes an innovative technique that collects minimal information from the running program and later (offline) infers the full call paths from this information.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640102", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Devin", + "last_name": "Coughlin", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/oopsla/MytkowiczCD09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640095", + "title": "Parallel programming with object assemblies", + "abstract": "We present Chorus, a high-level parallel programming model suitable for irregular, heap-manipulating applications like mesh refinement and epidemic simulations, and JChorus, an implementation of the model on top of Java. One goal of Chorus is to express the dynamic and instance-dependent patterns of memory access that are common in typical irregular applications. Its other focus is locality of effects: the property that in many of the same applications, typical imperative commands only affect small, local regions in the shared heap.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640095", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roberto", + "last_name": "Lublinerman", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Pavol", + "last_name": "Černý", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/oopsla/LublinermanCC09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640110", + "title": "Profile-guided static typing for dynamic scripting languages", + "abstract": "Many popular scripting languages such as Ruby, Python, and Perl include highly dynamic language constructs, such as an eval method that evaluates a string as program text. While these constructs allow terse and expressive code, they have traditionally obstructed static analysis. In this paper we present PRuby, an extension to Diamondback Ruby (DRuby), a static type inference system for Ruby. PRuby augments DRuby with a novel dynamic analysis and transformation that allows us to precisely type uses of highly dynamic constructs. PRuby's analysis proceeds in three steps. First, we use run-time instrumentation to gather per-application profiles of dynamic feature usage. Next, we replace dynamic features with statically analyzable alternatives based on the profile. We also add instrumentation to safely handle cases when subsequent runs do not match the profile. Finally, we run DRuby's static type inference on the transformed code to enforce type safety.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640110", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Furr", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jong-hoon", + "last_name": "An", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/FurrAF09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640109", + "title": "Self type constructors", + "abstract": "Bruce and Foster proposed the language LOOJ, an extension of Java with the notion of MyType, which represents the type of a self reference and changes its meaning along with inheritance. MyType is useful to write extensible yet type-safe classes for objects with recursive interfaces, that is, ones with methods that take or return objects of the same type as the receiver.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640109", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chieri", + "last_name": "Saito", + "institution": "Kyoto University" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/oopsla/SaitoI09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640105", + "title": "Debug all your code: portable mixed-environment debugging", + "abstract": "Programmers build large-scale systems with multiple languages to reuse legacy code and leverage languages best suited to their problems. For instance, the same program may use Java for ease-of-programming and C to interface with the operating system. These programs pose significant debugging challenges, because programmers need to understand and control code across languages, which may execute in different environments. Unfortunately, traditional multilingual debuggers require a single execution environment.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640105", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Byeongcheol", + "last_name": "Lee", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "IBM (United States)" + }, + { + "first_name": "Robert", + "last_name": "Grimm", + "institution": "New York University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/LeeHGM09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640101", + "title": "A concurrent dynamic analysis framework for multicore hardware", + "abstract": "Software has spent the bounty of Moore's law by solving harder problems and exploiting abstractions, such as high-level languages, virtual machine technology, binary rewriting, and dynamic analysis. Abstractions make programmers more productive and programs more portable, but usually slow them down. Since Moore's law is now delivering multiple cores instead of faster processors, future systems must either bear a relatively higher cost for abstractions or use some cores to help tolerate abstraction costs.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640101", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jung-Woo", + "last_name": "Ha", + "institution": "University of Southern California" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/HaABM09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640097", + "title": "A type and effect system for deterministic parallel Java", + "abstract": "Today's shared-memory parallel programming models are complex and error-prone.While many parallel programs are intended to be deterministic, unanticipated thread interleavings can lead to subtle bugs and nondeterministic semantics. In this paper, we demonstrate that a practical type and effect system can simplify parallel programming by guaranteeing deterministic semantics with modular, compile-time type checking even in a rich, concurrent object-oriented language such as Java. We describe an object-oriented type and effect system that provides several new capabilities over previous systems for expressing deterministic parallel algorithms.We also describe a language called Deterministic Parallel Java (DPJ) that incorporates the new type system features, and we show that a core subset of DPJ is sound. We describe an experimental validation showing thatDPJ can express a wide range of realistic parallel programs; that the new type system features are useful for such programs; and that the parallel programs exhibit good performance gains (coming close to or beating equivalent, nondeterministic multithreaded programs where those are available).", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640097", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert L.", + "last_name": "Bocchino", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Danny", + "last_name": "Dig", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Sarita V.", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Stephen", + "last_name": "Heumann", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Rakesh", + "last_name": "Komuravelli", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Jeffrey", + "last_name": "Overbey", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Patrick", + "last_name": "Simmons", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Hyojin", + "last_name": "Sung", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Mohsen", + "last_name": "Vakilian", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/BocchinoADAHKOSSV09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640096", + "title": "Grace: safe multithreaded programming for C/C++", + "abstract": "The shift from single to multiple core architectures means that programmers must write concurrent, multithreaded programs in order to increase application performance. Unfortunately, multithreaded applications are susceptible to numerous errors, including deadlocks, race conditions, atomicity violations, and order violations. These errors are notoriously difficult for programmers to debug.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640096", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Ting", + "last_name": "Yang", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Tongping", + "last_name": "Liu", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Gene", + "last_name": "Novark", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/BergerYLN09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640092", + "title": "CZ: multiple inheritance without diamonds", + "abstract": "Multiple inheritance has long been plagued with the \"diamond\" inheritance problem, leading to solutions that restrict expressiveness, such as mixins and traits. Instead, we address the diamond problem directly, considering two difficulties it causes: ensuring a correct semantics for object initializers, and typechecking multiple dispatch in a modular fashion-the latter problem arising even with multiple interface inheritance. We show that previous solutions to these problems are either unsatisfactory or cumbersome, and suggest a novel approach: supporting multiple inheritance but forbidding diamond inheritance. Expressiveness is retained through two features: a \"requires\" construct that provides a form of subtyping without inheritance (inspired by Scala), and a dynamically-dispatched \"super\" call similar to that found in traits. Through examples, we illustrate that inheritance diamonds can be eliminated via a combination of \"requires\" and ordinary inheritance. We provide a sound formal model for our language and demonstrate its modularity and expressiveness.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640092", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Donna", + "last_name": "Malayeri", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/MalayeriA09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640093", + "title": "Empirical assessment of object-oriented implementations with multiple inheritance and static typing", + "abstract": "Object-oriented languages involve a threefold tradeoff between runtime efficiency, expressiveness (multiple inheritance), and modularity, i.e. open-world assumption (OWA). Runtime efficiency is conditioned by both the implementation technique and compilation scheme. The former specifies the data structures that support method invocation, attribute access and subtype testing. The latter consists of the production line of an executable from the source code. Many implementation techniques have been proposed and several compilation schemes can be considered from fully global compilation under the closed-world assumption (CWA) to separate compilation with dynamic loading under the OWA, with midway solutions. This article reviews a significant subset of possible combinations and presents a systematic, empirical comparison of their respective efficiencies with all other things being equal. The testbed consists of the Prm compiler that has been designed for this purpose. The considered techniques include C++ subobjects, coloring, perfect hashing, binary tree dispatch and caching. A variety of processors were considered. Qualitatively, these first results confirm the intuitive or theoretical abstract assessments of the tested approaches. As expected, efficiency increases as CWA strengthens. From a quantitative standpoint, the results are the first to precisely compare the efficiency of techniques that are closely associated with specific languages like C++ and Eiffel. They also confirm that perfect hashing should be considered for implementing Java and .Net interfaces.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640093", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roland", + "last_name": "Ducournau", + "institution": "Université de Montpellier" + }, + { + "first_name": "Floréal", + "last_name": "Morandat", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jean", + "last_name": "Privat", + "institution": "Université du Québec à Montréal" + } + ], + "dblp_key": "conf/oopsla/DucournauMP09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640104", + "title": "Accelerating the creation of customized, language-Specific IDEs in Eclipse", + "abstract": "Full-featured integrated development environments have become critical to the adoption of new programming languages. Key to the success of these IDEs is the provision of services tailored to the languages. However, modern IDEs are large and complex, and the cost of constructing one from scratch can be prohibitive. Generators that work from language specifications reduce costs but produce environments that do not fully reflect distinctive language characteristics.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640104", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philippe", + "last_name": "Charles", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Robert M.", + "last_name": "Fuhrer", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Stanley M.", + "last_name": "Sutton", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Evelyn", + "last_name": "Duesterwald", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Jurgen", + "last_name": "Vinju", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/oopsla/CharlesFSDV09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640091", + "title": "Flapjax: a programming language for Ajax applications", + "abstract": "This paper presents Flapjax, a language designed for contemporary Web applications. These applications communicate with servers and have rich, interactive interfaces. Flapjax provides two key features that simplify writing these applications. First, it provides event streams, a uniform abstraction for communication within a program as well as with external Web services. Second, the language itself is reactive: it automatically tracks data dependencies and propagates updates along those dataflows. This allows developers to write reactive interfaces in a declarative and compositional style.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640091", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Leo A.", + "last_name": "Meyerovich", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "Brown University" + }, + { + "first_name": "Jacob", + "last_name": "Baskin", + "institution": "Google (United States)" + }, + { + "first_name": "Gregory H.", + "last_name": "Cooper", + "institution": "Google (United States)" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Aleks", + "last_name": "Bromfield", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "conf/oopsla/MeyerovichGBCGBK09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640098", + "title": "Thorn: robust, concurrent, extensible scripting on the JVM", + "abstract": "Scripting languages enjoy great popularity due to their support for rapid and exploratory development. They typically have lightweight syntax, weak data privacy, dynamic typing, powerful aggregate data types, and allow execution of the completed parts of incomplete programs. The price of these features comes later in the software life cycle. Scripts are hard to evolve and compose, and often slow. An additional weakness of most scripting languages is lack of support for concurrency - though concurrency is required for scalability and interacting with remote services. This paper reports on the design and implementation of Thorn, a novel programming language targeting the JVM. Our principal contributions are a careful selection of features that support the evolution of scripts into industrial grade programs - e.g., an expressive module system, an optional type annotation facility for declarations, and support for concurrency based on message passing between lightweight, isolated processes. On the implementation side, Thorn has been designed to accommodate the evolution of the language itself through a compiler plugin mechanism and target the Java virtual machine.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640098", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bard", + "last_name": "Bloom", + "institution": "IBM (United States)" + }, + { + "first_name": "John K.", + "last_name": "Field", + "institution": "IBM (United States)" + }, + { + "first_name": "Nathaniel", + "last_name": "Nystrom", + "institution": "The University of Texas at Arlington" + }, + { + "first_name": "Johan", + "last_name": "Östlund", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Gregor", + "last_name": "Richards", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Rok", + "last_name": "Strniša", + "institution": "University of Cambridge" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Stockholm University" + } + ], + "dblp_key": "conf/oopsla/BloomFNORSVW09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640112", + "title": "Enhancing source-level programming tools with an awareness of transparent program transformations", + "abstract": "Programs written in managed languages are compiled to a platform-independent intermediate representation, such as Java bytecode. The relative high level of Java bytecode has engendered a widespread practice of changing the bytecode directly, without modifying the maintained version of the source code. This practice, called bytecode engineering or enhancement, has become indispensable in introducing various concerns, including persistence, distribution, and security, transparently. For example, transparent persistence architectures help avoid the entanglement of business and persistence logic in the source code by changing the bytecode directly to synchronize objects with stable storage. With functionality added directly at the bytecode level, the source code reflects only partial semantics of the program. Specifically, the programmer can neither ascertain the program's runtime behavior by browsing its source code, nor map the runtime behavior back to the original source code.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640112", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Myoungkyu", + "last_name": "Song", + "institution": "Virginia Tech" + }, + { + "first_name": "Eli", + "last_name": "Tilevich", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/oopsla/SongT09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640117", + "title": "NUMA-aware memory manager with dominant-thread-based copying GC", + "abstract": "We propose a novel online method of identifying the preferred NUMA nodes for objects with negligible overhead during the garbage collection time as well as object allocation time. Since the number of CPUs (or NUMA nodes) is increasing recently, it is critical for the memory manager of the runtime environment of an object-oriented language to exploit the low latency of local memory for high performance. To locate the CPU of a thread that frequently accesses an object, prior research uses the runtime information about memory accesses as sampled by the hardware. However, the overhead of this approach is high for a garbage collector.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640117", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Takeshi", + "last_name": "Ogasawara", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/Ogasawara09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640120", + "title": "Optimizing programs with intended semantics", + "abstract": "Modern object-oriented languages have complex features that cause programmers to overspecify their programs. This overspecification hinders automatic optimizers, since they must preserve the overspecified semantics. If an optimizer knew which semantics the programmer intended, it could do a better job.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640120", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel von", + "last_name": "Dincklage", + "institution": "Google (United States)" + }, + { + "first_name": "Amer", + "last_name": "Diwan", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/oopsla/DincklageD09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640125", + "title": "Design pattern density defined", + "abstract": "Design pattern density is a metric that measures how much of an object-oriented design can be understood and represented as instances of design patterns. Expert developers have long believed that a high design pattern density implies a high maturity of the design under inspection. This paper presents a quantifiable and observable definition of this metric. The metric is illustrated and qualitatively validated using four real-world case studies. We present several hypotheses of the metric's meaning and their implications, including the one about design maturity. We propose that the design pattern density of a maturing framework has a fixed point and we show that if software design patterns make learning frameworks easier, a framework's design pattern density is a measure of how much easier it will become.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640125", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dirk", + "last_name": "Riehle", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Riehle09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640126", + "title": "Writing code for other people: cognitive psychology and the fundamentals of good software design principles", + "abstract": "This paper demonstrates how the cognitive model of the mind can explain the core fundamentals behind widely accepted design principles. The conclusion is that software design is largely a task of chunking analogies and presents a theory that is detailed enough to be accessible to even the most inexperienced programmer. The corollary of which is a pedagogical approach to understanding design principles rather than the necessity of years of software development experience.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640126", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Mullen", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/Mullen09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640113", + "title": "Static extraction and conformance analysis of hierarchical runtime architectural structure using annotations", + "abstract": "An object diagram makes explicit the object structures that are only implicit in a class diagram. An object diagram may be missing and must extracted from the code. Alternatively, an existing diagram may be inconsistent with the code, and must be analyzed for conformance with the implementation. One can generalize the global object diagram of a system into a runtime architecture which abstracts objects into components, represents how those components interact, and can decompose a component into a nested sub-architecture.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640113", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marwan", + "last_name": "Abi-Antoun", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/Abi-AntounA09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640128", + "title": "pi: a pattern language", + "abstract": "Current programming languages and techniques realize many features which allow their users to extend these languages on a semantic basis: classes, functions, interfaces, aspects and other entities can be defined. However, there is a lack of modern programming languages which are both semantically and syntactically extensible from within the language itself, i.e., with no additional tool or meta-language. In this paper we present π as an approach that aims to overcome this lack. π provides an abstraction mechanism based on parameterized symbols which is capable of semantically and syntactically unifying programming concepts like variables, control-structures, procedures and functions into one concept: the pattern. We have evaluated the abstraction potential and the syntactic extensibility of π by successfully creating patterns for the aforementioned programming concepts. π could serve as a tool for designing new experimental languages and might generally influence the view we have on current programming concepts.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640128", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roman", + "last_name": "Knöll", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/oopsla/KnollM09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640118", + "title": "Executing code in the past: efficient in-memory object graph versioning", + "abstract": "Object versioning refers to how an application can have access to previous states of its objects. Implementing this mechanism is hard because it needs to be efficient in space and time, and well integrated with the programming language. This paper presents HistOOry, an object versioning system that uses an efficient data structure to store and retrieve past states. It needs only three primitives, and existing code does not need to be modified to be versioned. It provides fine-grained control over what parts of objects are versioned and when. It stores all states, past and present, in memory. Code can be executed in the past of the system and will see the complete system at that point in time. We have implemented our model in Smalltalk and used it for three applications that need versioning: checked postconditions, stateful execution tracing and a planar point location implementation. Benchmarks are provided to asses the practical complexity of our implementation.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640118", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Frédéric", + "last_name": "Pluquet", + "institution": "Université Libre de Bruxelles" + }, + { + "first_name": "Stefan", + "last_name": "Langerman", + "institution": "Université Libre de Bruxelles" + }, + { + "first_name": "Roel", + "last_name": "Wuyts", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/oopsla/PluquetLW09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640130", + "title": "Software evolution and the moving picture metaphor", + "abstract": "Software systems evolve over time. Currently we do not do a good job of documenting this evolution. This essay discusses the need to better document software evolution and introduces the Moving Picture Metaphor. Source Control Management systems are more like collections of still photographs than moving pictures. Still photography is not ideal when trying to capture evolutional changes. Moving pictures do a much better job. A storyteller can use moving pictures to tell compelling stories that are easier to digest than traditional documentation. We can learn a great deal from watching stories that document a system's evolution.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640130", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mark", + "last_name": "Mahoney", + "institution": "Carthage College" + } + ], + "dblp_key": "conf/oopsla/Mahoney09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640127", + "title": "Regrowing a language: refactoring tools allow programming languages to evolve", + "abstract": "Successful programming languages change as they age. They tend to become more complex, and eventually some features become outdated or are rarely used. Programming tools for these languages become more complex as well, since they have to support archaic features. Old programs are hard to maintain, since these archaic features are unfamiliar to modern programmers. These problems can be solved by refactoring tools that can transform programs to use the modern form. We show that refactoring tools can ease the cost of program evolution by examining the evolution of two languages, Fortran and Java, and showing that each change corresponds to an automatable refactoring.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640127", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeffrey", + "last_name": "Overbey", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Ralph E.", + "last_name": "Johnson", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/OverbeyJ09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640114", + "title": "Demystifying model transformations: an approach based on automated rule inference", + "abstract": "Model-driven development (MDD) is widely used to develop modern business applications. MDD involves creating models at different levels of abstractions. Starting with models of domain concepts, these abstractions are successively refined, using transforms, to design-level models and, eventually, code-level artifacts. Although many tools exist that support transform creation and verification, tools that help users in understanding and using transforms are rare. In this paper, we present an approach for assisting users in understanding model transformations and debugging their input models. We use automated program-analysis techniques to analyze the transform code and compute constraints under which a transformation may fail or be incomplete. These code-level constraints are mapped to the input model elements to generate model-level rules. The rules can be used to validate whether an input model violates transform constraints, and to support general user queries about a transformation. We have implemented the analysis in a tool called XYLEM. We present empirical results, which indicate that (1) our approach can be effective in inferring useful rules, and (2) the rules let users efficiently diagnose a failing transformation without examining the transform source code.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640114", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mangala Gowri", + "last_name": "Nanda", + "institution": "IBM Research - India" + }, + { + "first_name": "Senthil", + "last_name": "Mani", + "institution": "IBM Research - India" + }, + { + "first_name": "Vibha Singhal", + "last_name": "Sinha", + "institution": "IBM Research - India" + }, + { + "first_name": "Saurabh", + "last_name": "Sinha", + "institution": "IBM Research - India" + } + ], + "dblp_key": "conf/oopsla/NandaMSS09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640131", + "title": "Agile anthropology and Alexander's architecture: an essay in three voices", + "abstract": "During its formative decades the software community looked twice to the theories of Christopher Alexander for inspiration, both times failing to completely master the architect's most useful insights. Now a third opportunity presents itself with Alexander's recent publication, The Nature of Order. Serious apprenticeship, however, imposes a prerequisite of sober self-reflection and evaluation. What, really, is the nature of the developer's tasks? Under what philosophical umbrella has the software community matured until now? Do other philosophical traditions offer alternative and perhaps more pertinent epistemologies? What voices, besides Alexander's, might contribute to the community's evolution? We address these questions along with theory building, ethnography, weak links, design heuristics, agility, and complex systems, all of which combine with Alexander's new theories to suggest different ways of doing what we do, better.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640131", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jenny", + "last_name": "Quillien", + "institution": "Museum of Indian Arts and Culture" + }, + { + "first_name": "Pam", + "last_name": "Rostal", + "institution": "" + }, + { + "first_name": "Dave", + "last_name": "West", + "institution": "New Mexico Highlands University" + } + ], + "dblp_key": "conf/oopsla/QuillienRW09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640116", + "title": "Allocation wall: a limiting factor of Java applications on emerging multi-core platforms", + "abstract": "Multi-core processors are widely used in computer systems. As the performance of microprocessors greatly exceeds that of memory, the memory wall becomes a limiting factor. It is important to understand how the large disparity of speed between processor and memory influences the performance and scalability of Java applications on emerging multi-core platforms.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640116", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yi", + "last_name": "Zhao", + "institution": "IBM Research (China)" + }, + { + "first_name": "Jin", + "last_name": "Shi", + "institution": "Tsinghua University" + }, + { + "first_name": "Kai", + "last_name": "Zheng", + "institution": "IBM Research (China)" + }, + { + "first_name": "Haichuan", + "last_name": "Wang", + "institution": "IBM Research (China)" + }, + { + "first_name": "Haibo", + "last_name": "Lin", + "institution": "IBM Research (China)" + }, + { + "first_name": "Ling", + "last_name": "Shao", + "institution": "IBM Research (China)" + } + ], + "dblp_key": "conf/oopsla/ZhaoSZWLS09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640122", + "title": "Providing rapid feedback in generated modular language environments: adding error recovery to scannerless generalized-LR parsing", + "abstract": "Integrated development environments (IDEs) increase programmer productivity, providing rapid, interactive feedback based on the syntax and semantics of a language. A heavy burden lies on developers of new languages to provide adequate IDE support. Code generation techniques provide a viable, efficient approach to semi-automatically produce IDE plugins. Key components for the realization of plugins are the language's grammar and parser. For embedded languages and language extensions, constituent IDE plugin modules and their grammars can be combined. Unlike conventional parsing algorithms, scannerless generalized-LR parsing supports the full set of context-free grammars, which is closed under composition, and hence can parse language embeddings and extensions composed from separate grammar modules. To apply this algorithm in an interactive environment, this paper introduces a novel error recovery mechanism, which allows it to be used with files with syntax errors -- common in interactive editing. Error recovery is vital for providing rapid feedback in case of syntax errors, as most IDE services depend on the parser from syntax highlighting to semantic analysis and cross-referencing. We base our approach on the principles of island grammars, and derive permissive grammars with error recovery productions from normal SDF grammars. To cope with the added complexity of these grammars, we adapt the parser to support backtracking. We evaluate the recovery quality and performance of our approach using a set of composed languages, based on Java and Stratego.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640122", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lennart C.L.", + "last_name": "Kats", + "institution": "Delft University of Technology" + }, + { + "first_name": "M. de", + "last_name": "Jonge", + "institution": "Delft University of Technology" + }, + { + "first_name": "Emma", + "last_name": "Nilsson-Nyman", + "institution": "Lund University" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/oopsla/KatsJNV09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640121", + "title": "Minimizing dependencies within generic classes for faster and smaller programs", + "abstract": "Generic classes can be used to improve performance by allowing compile-time polymorphism. But the applicability of compile-time polymorphism is narrower than that of runtime polymorphism, and it might bloat the object code. We advocate a programming principle whereby a generic class should be implemented in a way that minimizes the dependencies between its members (nested types, methods) and its generic type parameters. Conforming to this principle (1) reduces the bloat and (2) gives rise to a previously unconceived manner of using the language that expands the applicability of compile-time polymorphism to a wider range of problems. Our contribution is thus a programming technique that generates faster and smaller programs. We apply our ideas to GCC's STL containers and iterators, and we demonstrate notable speedups and reduction in object code size (real application runs 1.2x to 2.1x faster and STL code is 1x to 25x smaller). We conclude that standard generic APIs (like STL) should be amended to reflect the proposed principle in the interest of efficiency and compactness. Such modifications will not break old code, simply increase flexibility. Our findings apply to languages like C++, C#, and D, which realize generic programming through multiple instantiations.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640121", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dan", + "last_name": "Tsafrir", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Robert W.", + "last_name": "Wisniewski", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Bjarne", + "last_name": "Stroustrup", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/oopsla/TsafrirWBS09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640133", + "title": "On understanding data abstraction, revisited", + "abstract": "In 1985 Luca Cardelli and Peter Wegner, my advisor, published an ACM Computing Surveys paper called \"On understanding types, data abstraction, and polymorphism\". Their work kicked off a flood of research on semantics and type theory for object-oriented programming, which continues to this day. Despite 25 years of research, there is still widespread confusion about the two forms of data abstraction, abstract data types and objects. This essay attempts to explain the differences and also why the differences matter.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640133", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/Cook09", + "venue": "oopsla", + "year": 2009 + }, + { + "paper_id": "10.1145/1640089.1640132", + "title": "An exploration of program as language", + "abstract": "In this paper we explore the idea that the code that constitutes a program actually forms a higher-level, program specific language. The symbols of the language are the abstractions of the program, and the grammar of the language is the set of (generally unwritten) rules about the allowable combinations of those abstractions. As such, a program is both a language definition, and the only use of that language. This specificity means that reading a never-before encountered program involves learning a new natural language, and that porting code from one program to another requires translation from one natural language into another. We suggest that the complexity and depth of the program language is affected by the gap between the program semantics (what the program is meant to do) and the code semantics (the way in which the machine runs). We believe that in seeing that programs are languages, we gain new insight into our own experience as programmers, and are able to gain new perspective on the intense complexity of code and its creation.", + "date": "2009-10-25", + "link": "https://doi.org/10.1145/1640089.1640132", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Elisa", + "last_name": "Baniassad", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "C. E.", + "last_name": "Myers", + "institution": "Chinese University of Hong Kong" + } + ], + "dblp_key": "conf/oopsla/BaniassadM09", + "venue": "oopsla", + "year": 2009 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2010.json b/data/pl_conferences/oopsla/2010.json new file mode 100644 index 0000000..a05546b --- /dev/null +++ b/data/pl_conferences/oopsla/2010.json @@ -0,0 +1,1803 @@ +[ + { + "paper_id": "10.1145/1869459.1869539", + "title": "The case for evolvable software", + "abstract": "As programmers, we like to think of software as the product of our intelligent design, carefully crafted to meet well-specified goals. In reality, software evolves inadvertently through the actions of many individual programmers, often leading to unanticipated consequences. Large complex software systems are subject to constraints similar to those faced by evolving biological systems, and we have much to gain by viewing software through the lens of evolutionary biology. The talk will highlight recent research that applies the mechanisms of evolution quite directly to the problem of repairing software bugs.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869539", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Forrest", + "institution": "University of New Mexico" + } + ], + "dblp_key": "conf/oopsla/Forrest10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869461", + "title": "Efficient modular glass box software model checking", + "abstract": "Glass box software model checking incorporates novel techniques to identify similarities in the state space of a model checker and safely prune large numbers of redundant states without explicitly checking them. It is significantly more efficient than other software model checking approaches for checking certain kinds of programs and program properties.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869461", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Roberson", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Chandrasekhar", + "last_name": "Boyapati", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/oopsla/RobersonB10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869462", + "title": "An experiment about static and dynamic type systems: doubts about the positive impact of static type systems on development time", + "abstract": "Although static type systems are an essential part in teach-ing and research in software engineering and computer science, there is hardly any knowledge about what the impact of static type systems on the development time or the resulting quality for a piece of software is. On the one hand there are authors that state that static type systems decrease an application's complexity and hence its development time (which means that the quality must be improved since developers have more time left in their projects). On the other hand there are authors that argue that static type systems increase development time (and hence decrease the code quality) since they restrict developers to express themselves in a desired way. This paper presents an empirical study with 49 subjects that studies the impact of a static type system for the development of a parser over 27 hours working time. In the experiments the existence of the static type system has neither a positive nor a negative impact on an application's development time (under the conditions of the experiment).", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869462", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Hanenberg", + "institution": "University of Duisburg-Essen" + } + ], + "dblp_key": "conf/oopsla/Hanenberg10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869540", + "title": "Art, science, and fear", + "abstract": "Scientists and artists share a conviction that key elements of their work-creativity, craft, analysis, intuition--are somehow deeply similar. Most Onward! participants will have a clear sense of the scientific variants of these qualities, and of what it takes to manifest them in our day-to-day work as researchers and software designers. This talk looks at how ideas are developed and refined in the making of visual art, how the same qualities--especially creativity, the most ineffable--come into play, and how artists and scientists grapple with the various fears that beset creative work.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869540", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/oopsla/Pierce10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869466", + "title": "G-Finder: routing programming questions closer to the experts", + "abstract": "Programming forums are becoming the primary tools for programmers to find answers for their programming problems. Our empirical study of popular programming forums shows that the forum users experience long waiting period for answers and a small number of experts are often overloaded with questions. To improve the usage experience, we have designed and implemented G-Finder, both an algorithm and a tool that makes intelligent routing decisions as to which participant is the expert for answering a particular programming question. Our main approach is to leverage the source code information of the software systems that forums are dedicated to, and discover latent relationships between forums users. Our algorithms construct the concept networks and the user networks from the program source and the forum data. We use programming questions to dynamically integrate these two networks and present an adaptive ranking of the potential experts. Our evaluation of G-Finder, using the data from three large programming forums, takes a retrospective view to check if G-Finder can correctly predict the experts who provided answers to programming questions. The evaluation results show that G-Finder improves the prediction precision by 25% to 74%, compared to related approaches.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869466", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wei", + "last_name": "Li", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Songlin", + "last_name": "Hu", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "conf/oopsla/LiZH10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869469", + "title": "Lime: a Java-compatible and synthesizable language for heterogeneous architectures", + "abstract": "The halt in clock frequency scaling has forced architects and language designers to look elsewhere for continued improvements in performance. We believe that extracting maximum performance will require compilation to highly heterogeneous architectures that include reconfigurable hardware.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869469", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Auerbach", + "institution": "IBM (United States)" + }, + { + "first_name": "David F.", + "last_name": "Bacon", + "institution": "IBM (United States)" + }, + { + "first_name": "Perry", + "last_name": "Cheng", + "institution": "IBM (United States)" + }, + { + "first_name": "Rodric", + "last_name": "Rabbah", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/AuerbachBCR10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869473", + "title": "Composable specifications for structured shared-memory communication", + "abstract": "In this paper we propose a communication-centric approach to specifying and checking how multithreaded programs use shared memory to perform inter-thread communication. Our approach complements past efforts for improving the safety of multithreaded programs such as race detection and atomicity checking. Unlike prior work, we focus on what pieces of code are allowed to communicate with one another, as opposed to declaring what data items are shared or what code blocks should be atomic. We develop a language that supports composable specifications at multiple levels of abstraction and that allows libraries to specify whether or not shared-memory communication is exposed to clients. The precise meaning of a specification is given with a formal semantics we present. We have developed a dynamic-analysis tool for Java that observes program execution to see if it obeys a specification. We report results for using the tool on several benchmark programs to which we added specifications, concluding that our approach matches the modular structure of multithreaded applications and that our tool is performant enough for use in development and testing.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869473", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benjamin P.", + "last_name": "Wood", + "institution": "University of Washington" + }, + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/WoodSCG10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869470", + "title": "From OO to FPGA: fitting round objects into square hardware?", + "abstract": "Consumer electronics today such as cell phones often have one or more low-power FPGAs to assist with energyintensive operations in order to reduce overall energy consumption and increase battery life. However, current techniques for programming FPGAs require people to be specially trained to do so. Ideally, software engineers can more readily take advantage of the benefits FPGAs offer by being able to program them using their existing skills, a common one being object-oriented programming. However, traditional techniques for compiling object-oriented languages are at odds with today's FPGA tools, which support neither pointers nor complex data structures. Open until now is the problem of compiling an object-oriented language to an FPGA in a way that harnesses this potential for huge energy savings. In this paper, we present a new compilation technique that feeds into an existing FPGA tool chain and produces FPGAs with up to almost an order of magnitude in energy savings compared to a low-power microprocessor while still retaining comparable performance and area usage.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869470", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Kou", + "institution": "UCLA Health" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "UCLA Health" + } + ], + "dblp_key": "conf/oopsla/KouP10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869477", + "title": "A study of Java's non-Java memory", + "abstract": "A Java application sometimes raises an out-of-memory ex-ception. This is usually because it has exhausted the Java heap. However, a Java application can raise an out-of-memory exception when it exhausts the memory used by Java that is not in the Java heap. We call this area non-Java memory. For example, an out-of-memory exception in the non-Java memory can happen when the JVM attempts to load too many classes. Although it is relatively rare to ex-haust the non-Java memory compared to exhausting the Java heap, a Java application can consume a considerable amount of non-Java memory.This paper presents a quantitative analysis of non-Java memory. To the best of our knowledge, this is the first in-depth analysis of the non-Java memory. To do this we cre-ated a tool called Memory Analyzer for Redundant, Unused, and String Areas (MARUSA), which gathers memory statis-tics from both the OS and the Java virtual machine, break-ing down and visualizing the non-Java memory usage.We studied the use of non-Java memory for a wide range of Java applications, including the DaCapo benchmarks and Apache DayTrader. Our study is based on the IBM J9 Java Virtual Machine for Linux. Although some of our results may be specific to this combination, we believe that most of our observations are applicable to other platforms as well.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869477", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kazunori", + "last_name": "Ogata", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Dai", + "last_name": "Mikurube", + "institution": "" + }, + { + "first_name": "Kiyokuni", + "last_name": "Kawachiya", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Scott", + "last_name": "Trent", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Tamiya", + "last_name": "Onodera", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/OgataMKTO10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869541", + "title": "To achieve our highest goals, we must be willing to abandon them", + "abstract": "Someday computer scientists may build systems of astronomical complexity that provide profound benefit to humanity. However, the question today is how such feats will ultimately be achieved. As is common with technology, present limitations to modern approaches challenge our imagination to search for new paradigms and organizing principles. To examine the prerequisites to achieving our most ambitious objectives, this talk will contemplate the implications of recent counterintuitive results from experiments with evolutionary algorithms that suggest that search (which is a metaphor for innovation in general) is sometimes most effective when it is not explicitly seeking an objective. In particular, through several experiments in interactive evolution and with an algorithm called \"novelty search,\" a picture of innovation is emerging in which objectives can help to guide us one stepping-stone away from our present understanding, yet ultimately become handcuffs that also blind us to essential orthogonal discoveries on the road to long-term innovation. While the implications of these insights for reaching our highest goals are in part sobering, the silver lining is that much can be gained by liberating ourselves from the temptation to frame all our projects in terms of what they ultimately aim to achieve. Instead, with evidence in hand, we can exploit the structure of the unknown by orienting ourselves towards discovery and away from the shackles of mandated outcomes.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869541", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kenneth O.", + "last_name": "Stanley", + "institution": "University of Central Florida" + } + ], + "dblp_key": "conf/oopsla/Stanley10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869471", + "title": "An input-centric paradigm for program dynamic optimizations", + "abstract": "Accurately predicting program behaviors (e.g., locality, dependency, method calling frequency) is fundamental for program optimizations and runtime adaptations. Despite decades of remarkable progress, prior studies have not systematically exploited program inputs, a deciding factor for program behaviors.Triggered by the strong and predictive correlations between program inputs and behaviors that recent studies have uncovered, this work proposes to include program inputs into the focus of program behavior analysis, cultivating a new paradigm named input-centric program behavior analysis. This new approach consists of three components, forming a three-layer pyramid. At the base is program input characterization, a component for resolving the complexity in program raw inputs and the extraction of important features. In the middle is input-behavior modeling, a component for recognizing and modeling the correlations between characterized input features and program behaviors. These two components constitute input-centric program behavior analysis, which (ideally) is able to predict the large-scope behaviors of a program's execution as soon as the execution starts. The top layer of the pyramid is input-centric adaptation, which capitalizes on the novel opportunities that the first two components create to facilitate proactive adaptation for program optimizations.By centering on program inputs, the new approach resolves a proactivity-adaptivity dilemma inherent in previous techniques. Its benefits are demonstrated through proactive dynamic optimizations and version selection, yielding significant performance improvement on a set of Java and C programs.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869471", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kai", + "last_name": "Tian", + "institution": "William & Mary" + }, + { + "first_name": "Yunlian", + "last_name": "Jiang", + "institution": "William & Mary" + }, + { + "first_name": "Eddy Z.", + "last_name": "Zhang", + "institution": "Williams (United States)" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "Williams (United States)" + } + ], + "dblp_key": "conf/oopsla/TianJZS10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869474", + "title": "Do I use the wrong definition?: DeFuse: definition-use invariants for detecting concurrency and sequential bugs", + "abstract": "Software bugs, such as concurrency, memory and semantic bugs, can significantly affect system reliability. Although much effort has been made to address this problem, there are still many bugs that cannot be detected, especially concurrency bugs due to the complexity of concurrent programs. Effective approaches for detecting these common bugs are therefore highly desired.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869474", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yao", + "last_name": "Shi", + "institution": "Tsinghua University" + }, + { + "first_name": "Soyeon", + "last_name": "Park", + "institution": "University of California San Diego" + }, + { + "first_name": "Zuoning", + "last_name": "Yin", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Yuanyuan", + "last_name": "Zhou", + "institution": "University of California San Diego" + }, + { + "first_name": "Wenguang", + "last_name": "Chen", + "institution": "Tsinghua University" + }, + { + "first_name": "Weimin", + "last_name": "Zheng", + "institution": "Tsinghua University" + } + ], + "dblp_key": "conf/oopsla/ShiPYLZCZ10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869467", + "title": "Agility in context", + "abstract": "Evangelists for Agile methods strongly encourage all projects to follow every practice of their chosen method. Based on a Grounded Theory study involving 40 participants at 16 organizations, and corroborated by 4 independent case studies, we argue that development methods and practices must be adapted to fit their contexts. Understanding Agility in context will help development teams, their managers, and Agile coaches to adapt development processes to fit their projects' contexts.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869467", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rashina", + "last_name": "Hoda", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Philippe", + "last_name": "Kruchten", + "institution": "University of British Columbia" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Stuart", + "last_name": "Marshall", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/oopsla/HodaKNM10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869475", + "title": "Scalable and systematic detection of buggy inconsistencies in source code", + "abstract": "Software developers often duplicate source code to replicate functionality. This practice can hinder the maintenance of a software project: bugs may arise when two identical code segments are edited inconsistently. This paper presents DejaVu, a highly scalable system for detecting these general syntactic inconsistency bugs.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869475", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mark", + "last_name": "Gabel", + "institution": "University of California, Davis" + }, + { + "first_name": "Junfeng", + "last_name": "Yang", + "institution": "Columbia University" + }, + { + "first_name": "Yuan", + "last_name": "Yu", + "institution": "Silicon Valley Community Foundation" + }, + { + "first_name": "Moisés", + "last_name": "Goldszmidt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/GabelYYGS10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869465", + "title": "A domain-specific approach to architecturing error handling in pervasive computing", + "abstract": "The challenging nature of error handling constantly escalates as a growing number of environments consists of networked devices and software components. In these environments, errors cover a uniquely large spectrum of situations related to each layer ranging from hardware to distributed platforms, to software components. Handling errors becomes a daunting task for programmers, whose outcome is unpredictable. Scaling up error handling requires to raise the level of abstraction beyond the code level and the try-catch construct, approaching error handling at the software architecture level.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869465", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Julien", + "last_name": "Mercadal", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Quentin", + "last_name": "Enard", + "institution": "Thales (France)" + }, + { + "first_name": "Charles", + "last_name": "Consel", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Nicolas", + "last_name": "Loriant", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/oopsla/MercadalECL10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869463", + "title": "A simple inductive synthesis methodology and its applications", + "abstract": "Given a high-level specification and a low-level programming language, our goal is to automatically synthesize an efficient program that meets the specification. In this paper, we present a new algorithmic methodology for inductive synthesis that allows us to do this.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869463", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/oopsla/ItzhakyGIS10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869478", + "title": "Hera-JVM: a runtime system for heterogeneous multi-core architectures", + "abstract": "Heterogeneous multi-core processors, such as the IBM Cell processor, can deliver high performance. However, these processors are notoriously difficult to program: different cores support different instruction set architectures, and the processor as a whole does not provide coherence between the different cores’ local memories.<p> We present Hera-JVM, an implementation of the Java Virtual Machine which operates over the Cell processor, thereby making this platforms more readily accessible to mainstream developers. Hera-JVM supports the full Java language; threads from an unmodified Java application can be simultaneously executed on both the main PowerPC-based core and on the additional SPE accelerator cores. Migration of threads between these cores is transparent from the point of view of the application, requiring no modification to Java source code or bytecode. Hera-JVM supports the existing Java Memory Model, even though the underlying hardware does not provide cache coherence between the different core types.</p> We examine Hera-JVM’s performance under a series of real-world Java benchmarks from the SpecJVM, Java Grande and Dacapo benchmark suites. These benchmarks show a wide variation in relative performance on the different core types of the Cell processor, depending upon the nature of their workload. Execution of these benchmarks on Hera-JVM can achieve speedups of up to 2.25x by using one of the Cell processor’s SPE accelerator cores, compared to execution on the main PowerPC-based core. When all six SPE cores are exploited, parallel workloads can achieve speedups of up to 13x compared to execution on the single PowerPC core.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869478", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ross", + "last_name": "McIlroy", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Joe", + "last_name": "Sventek", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/oopsla/McIlroyS10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869485", + "title": "Specifying and implementing refactorings", + "abstract": "Modern IDEs for object-oriented languages like Java provide support for a basic set of simple automated refactorings whose behaviour is easy to describe intuitively. It is, however, surprisingly difficult to specify their behaviour in detail. In particular, the popular precondition-based approach tends to produce somewhat unwieldy descriptions if advanced features of the object language are taken into account. This has resulted in refactoring implementations that are complex, hard to understand, and even harder to maintain, yet these implementations themselves are the only precise specification of many refactorings. We have in past work advocated a different approach based on several complementary notions of dependencies that guide the implementation, and on the concept of microrefactorings that structure it. We show in this work that these concepts are powerful enough to provide high-level specifications of many of the refactorings implemented in Eclipse. These specifications are precise enough to serve as the basis of a clean-room reimplementation of these refactorings that is very compact, yet matches Eclipse's for features and outperforms it in terms of correctness.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869485", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Max", + "last_name": "Schaefer", + "institution": "University of Oxford" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/oopsla/SchaferM10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869487", + "title": "Component adaptation and assembly using interface relations", + "abstract": "Software's expense owes partly to frequent reimplementation of similar functionality and partly to maintenance of patches, ports or components targeting evolving interfaces. More modular non-invasive approaches are unpopular because they entail laborious wrapper code. We propose Cake, a rule-based language describing compositions using interface relations. To evaluate it, we compare several existing wrappers with reimplemented Cake versions, finding the latter to be simpler and better modularised.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869487", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Kell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/oopsla/Kell10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869483", + "title": "Monitor optimization via stutter-equivalent loop transformation", + "abstract": "There has been significant interest in equipping programs with runtime checks aimed at detecting errors to improve fault detection during testing and in the field. Recent work in this area has studied methods for efficiently monitoring a program execution's conformance to path property specifications, e.g., such as those captured by a finite state automaton. These techniques show great promise, but their broad applicability is hampered by the fact that for certain combinations of programs and properties the overhead of checking can slow the program down by up to 3500%.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869483", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rahul", + "last_name": "Purandare", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Matthew B.", + "last_name": "Dwyer", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Sebastian", + "last_name": "Elbaum", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "conf/oopsla/PurandareDE10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869481", + "title": "Instrumentation and sampling strategies for cooperative concurrency bug isolation", + "abstract": "Fixing concurrency bugs (or crugs) is critical in modern software systems. Static analyses to find crugs such as data races and atomicity violations scale poorly, while dynamic approaches incur high run-time overheads. Crugs manifest only under specific execution interleavings that may not arise during in-house testing, thereby demanding a lightweight program monitoring technique that can be used post-deployment. We present Cooperative Crug Isolation (CCI), a lowoverhead instrumentation framework to diagnose productionrun failures caused by crugs. CCI tracks specific thread interleavings at run-time, and uses statistical models to identify strong failure predictors among these. We offer a varied suite of predicates that represent different trade-offs between complexity and fault isolation capability. We also develop variant random sampling strategies that suit different types of predicates and help keep the run-time overhead low. Experiments with 9 real-world bugs in 6 non-trivial C applications show that these schemes span a wide spectrum of performance and diagnosis capabilities, each suitable for different usage scenarios.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869481", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guoliang", + "last_name": "Jin", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aditya", + "last_name": "Thakur", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/oopsla/JinTLL10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869479", + "title": "Cross-language, type-safe, and transparent object sharing for co-located managed runtimes", + "abstract": "As software becomes increasingly complex and difficult to analyze, it is more and more common for developers to use high-level, type-safe, object-oriented (OO) programming languages and to architect systems that comprise multiple components. Different components are often implemented in different programming languages. In state-of-the-art multicomponent, multi-language systems, cross-component communication relies on remote procedure calls (RPC) and message passing. As components are increasingly co-located on the same physical machine to ensure high utilization of multi-core systems, there is a growing potential for using shared memory for cross-language cross-runtime communication.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869479", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michał", + "last_name": "Węgiel", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Chandra", + "last_name": "Krintz", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "conf/oopsla/WegielK10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869482", + "title": "What can the GC compute efficiently?: a language for heap assertions at GC time", + "abstract": "We present the DeAL language for heap assertions that are efficiently evaluated during garbage collection time. DeAL is a rich, declarative, logic-based language whose programs are guaranteed to be executable with good whole-heap locality, i.e., within a single traversal over every live object on the heap and a finite neighborhood around each object. As a result, evaluating DeAL programs incurs negligible cost: for simple assertion checking at each garbage collection, the end-to-end execution slowdown is below 2%. DeAL is integrated into Java as a VM extension and we demonstrate its efficiency and expressiveness with several applications and properties from the past literature.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869482", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christoph", + "last_name": "Reichenbach", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Edward", + "last_name": "Aftandilian", + "institution": "Tufts University" + }, + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/oopsla/ReichenbachISAG10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869489", + "title": "Type classes as objects and implicits", + "abstract": "Type classes were originally developed in Haskell as a disciplined alternative to ad-hoc polymorphism. Type classes have been shown to provide a type-safe solution to important challenges in software engineering and programming languages such as, for example, retroactive extension of programs. They are also recognized as a good mechanism for concept-based generic programming and, more recently, have evolved into a mechanism for type-level computation.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869489", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "Seoul National University" + }, + { + "first_name": "Adriaan", + "last_name": "Moors", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/OliveiraMO10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869486", + "title": "A graph-based approach to API usage adaptation", + "abstract": "Reusing existing library components is essential for reducing the cost of software development and maintenance. When library components evolve to accommodate new feature requests, to fix bugs, or to meet new standards, the clients of software libraries often need to make corresponding changes to correctly use the updated libraries. Existing API usage adaptation techniques support simple adaptation such as replacing the target of calls to a deprecated API, however, cannot handle complex adaptations such as creating a new object to be passed to a different API method, or adding an exception handling logic that surrounds the updated API method calls. This paper presents LIBSYNC that guides developers in adapting API usage code by learning complex API usage adaptation patterns from other clients that already migrated to a new library version (and also from the API usages within the library’s test code). LIBSYNC uses several graph-based techniques (1) to identify changes to API declarations by comparing two library versions, (2) to extract associated API usage skeletons before and after library migration, and (3) to compare the extracted API usage skeletons to recover API usage adaptation patterns. Using the learned adaptation patterns, LIBSYNC recommends the locations and edit operations for adapting API usages. The evaluation of LIBSYNC on real-world software systems shows that it is highly correct and useful with a precision of 100 % and a recall of 91%.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869486", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hoan Anh", + "last_name": "Nguyen", + "institution": "Iowa State University" + }, + { + "first_name": "Tung", + "last_name": "Nguyen", + "institution": "Iowa State University" + }, + { + "first_name": "Gary", + "last_name": "Wilson", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Anh Tuan", + "last_name": "Nguyen", + "institution": "Iowa State University" + }, + { + "first_name": "Miryung", + "last_name": "Kim", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Tien N.", + "last_name": "Nguyen", + "institution": "Iowa State University" + } + ], + "dblp_key": "conf/oopsla/NguyenNWNKN10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869498", + "title": "MetaFJig: a meta-circular composition language for Java-like classes", + "abstract": "We propose a Java-like language where class definitions are first class values and new classes can be derived from existing ones by exploiting the full power of the language itself, used on top of a small set of primitive composition operators, instead of using a fixed mechanism like inheritance.Hence, compilation requires to perform (meta-)reduction steps, by a process that we call compile-time execution. This approach differs from meta-programming techniques available in mainstream languages since it is meta-circular, hence programmers are not required to learn new syntax and idioms.Compile-time execution is guaranteed to be sound (not to get stuck) by a lightweight technique, where class composition errors are detected dynamically, and conventional typing errors are detected by interleaving typechecking with meta-reduction steps. This allows for a modular approach, that is, compile-time execution is defined, and can be implemented, on top of typechecking and execution of the underlying language. Moreover, programmers can handle errors due to composition operators.Besides soundness, our technique ensures an additional important property called meta-level soundness, that is, typing errors never originate from (meta-)code in already compiled programs.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869498", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marco", + "last_name": "Servetto", + "institution": "University of Genoa" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/oopsla/ServettoZ10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869499", + "title": "Modular logic metaprogramming", + "abstract": "In logic metaprogramming, programs are not stored as plain textfiles but rather derived from a deductive database. While the benefits of this approach for metaprogramming are obvious, its incompatibility with separate checking limits its applicability to large-scale projects. We analyze the problems inhibiting separate checking and propose a class of logics that reconcile logic metaprogramming and separate checking. We have formalized the resulting module system and have proven the soundness of separate checking. We validate its feasibility by presenting the design and implementation of a specific logic that is able to express many metaprogramming examples from the literature.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869499", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karl", + "last_name": "Klose", + "institution": "Aarhus University" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Philipps University of Marburg" + } + ], + "dblp_key": "conf/oopsla/KloseO10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869501", + "title": "Reasoning about multiple related abstractions with MultiStar", + "abstract": "Encapsulated abstractions are fundamental in object-oriented programming. A single class may employ multiple abstractions to achieve its purpose. Such abstractions are often related and combined in disciplined ways. This paper explores ways to express, verify and rely on logical relationships between abstractions. It introduces two general specification mechanisms: export clauses for relating abstractions in individual classes, and axiom clauses for relating abstractions in a class and all its descendants. MultiStar, an automatic verification tool based on separation logic and abstract predicate families, implements these mechanisms in a multiple inheritance setting. Several verified examples illustrate MultiStar's underlying logic. To demonstrate the flexibility of our approach, we also used MultiStar to verify the core iterator hierarchy of a popular data structure library.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869501", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephan van", + "last_name": "Staden", + "institution": "ETH Zurich" + }, + { + "first_name": "Cristiano", + "last_name": "Calcagno", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/StadenC10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869493", + "title": "Symbolic heap abstraction with demand-driven axiomatization of memory invariants", + "abstract": "Many relational static analysis techniques for precise reasoning about heap contents perform an explicit case analysis of all possible heaps that can arise. We argue that such precise relational reasoning can be obtained in a more scalable and economical way by enforcing the memory invariant that every concrete memory location stores one unique value directly on the heap abstraction. Our technique combines the strengths of analyses for precise reasoning about heap contents with approaches that prioritize axiomatization of memory invariants, such as the theory of arrays. Furthermore, by avoiding an explicit case analysis, our technique is scalable and powerful enough to analyze real-world programs with intricate use of arrays and pointers; in particular, we verify the absence of buffer overruns, incorrect casts, and null pointer dereferences in OpenSSH (over 26,000 lines of code) after fixing 4 previously undiscovered bugs found by our system. Our experiments also show that the combination of reasoning about heap contents and enforcing existence and uniqueness invariants is crucial for this level of precision. Copyright © 2010 ACM.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869493", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/DilligDA10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869490", + "title": "Supporting dynamic, third-party code customizations in JavaScript using aspects", + "abstract": "Web sites and web browsers have recently evolved into platforms on top of which entire applications are delivered dynamically, mostly as JavaScript source code. This delivery format has sparked extremely enthusiastic efforts to customize both individual web sites and entire browsers in ways the original authors never expected or accommodated. Such customizations take the form of yet more script dynamically injected into the application, and the current idioms to do so exploit arcane JavaScript features and are extremely brittle. In this work, we accept the popularity of extensions and seek better linguistic mechanisms to support them.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869490", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benjamin S.", + "last_name": "Lerner", + "institution": "University of Washington" + }, + { + "first_name": "Herman", + "last_name": "Venter", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/LernerVG10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869491", + "title": "Dynamic parallelization of recursive code: part 1: managing control flow interactions with the continuator", + "abstract": "While most approaches to automatic parallelization focus on compilation approaches for parallelizing loop iterations, we advocate the need for new virtual machines that can parallelize the execution of recursive programs. In this paper, we show that recursive programs can be effectively parallelized when arguments to procedures are evaluated concurrently and branches of conditional statements are speculatively executed in parallel. We introduce the continuator concept, a runtime structure that tracks and manages the control dependences between such concurrently spawned tasks, ensuring adherence to the sequential semantics of the parallelized program. As a proof of concept, we discuss the details of a parallel interpreter for Scheme (implemented in Common Lisp) based on these ideas, and show the results from executing the Clinger benchmark suite for Scheme.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869491", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Charlotte", + "last_name": "Herzeel", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Pascal", + "last_name": "Costanza", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/oopsla/HerzeelC10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869495", + "title": "Parallel inclusion-based points-to analysis", + "abstract": "Inclusion-based points-to analysis provides a good trade-off between precision of results and speed of analysis, and it has been incorporated into several production compilers including gcc. There is an extensive literature on how to speed up this algorithm using heuristics such as detecting and collapsing cycles of pointer-equivalent variables. This paper describes a complementary approach based on exploiting parallelism. Our implementation exploits two key insights. First, we show that inclusion-based points-to analysis can be formulated entirely in terms of graphs and graph rewrite rules. This exposes the amorphous data-parallelism in this algorithm and makes it easier to develop a parallel implementation. Second, we show that this graph-theoretic formulation reveals certain key properties of the algorithm that can be exploited to obtain an efficient parallel implementation. Our parallel implementation achieves a scaling of up to 3x on a 8-core machine for a suite of ten large C programs. For all but the smallest benchmarks, the parallel analysis outperforms a state-of-the-art, highly optimized, serial implementation of the same algorithm. To the best of our knowledge, this is the first parallel implementation of a points-to analysis.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869495", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mario", + "last_name": "Méndez-Lojo", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Augustine", + "last_name": "Mathew", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/Mendez-LojoMP10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869502", + "title": "Homogeneous family sharing", + "abstract": "Recent work has introduced class sharing as a mechanism for adapting a family of related classes with new functionality. This paper introduces homogeneous family sharing, implemented in the J&h language, in which the sharing mechanism is lifted from class-level sharing to true family-level sharing. Compared to the original (heterogeneous) class sharing mechanism, homogeneous family sharing provides useful new functionality and substantially reduces the annotation burden on programmers by eliminating the need for masked types and sharing declarations. This is achieved through a new mechanism, shadow classes, which permit homogeneous sharing of all related classes in shared families. The new sharing mechanism has a straightforward semantics, which is formalized in the J&h calculus. The soundness of the J&h type system is proved. The J&h language is implemented as an extension to the J& language. To demonstrate the effectiveness of family sharing, the Polyglot compiler framework is ported to J&h.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869502", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xin", + "last_name": "Qi", + "institution": "Meta (United States)" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/oopsla/QiM10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869497", + "title": "The spoofax language workbench: rules for declarative specification of languages and IDEs", + "abstract": "Spoofax is a language workbench for efficient, agile development of textual domain-specific languages with state-of-the-art IDE support. Spoofax integrates language processing techniques for parser generation, meta-programming, and IDE development into a single environment. It uses concise, declarative specifications for languages and IDE services. In this paper we describe the architecture of Spoofax and introduce idioms for high-level specifications of language semantics using rewrite rules, showing how analyses can be reused for transformations, code generation, and editor services such as error marking, reference resolving, and content completion. The implementation of these services is supported by language-parametric editor service classes that can be dynamically loaded by the Eclipse IDE, allowing new languages to be developed and used side-by-side in the same Eclipse environment.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869497", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lennart C.L.", + "last_name": "Kats", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/oopsla/KatsV10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869494", + "title": "A dynamic evaluation of the precision of static heap abstractions", + "abstract": "The quality of a static analysis of heap-manipulating programs is largely determined by its heap abstraction. Object allocation sites are a commonly-used abstraction, but are too coarse for some clients. The goal of this paper is to investigate how various refinements of allocation sites can improve precision. In particular, we consider abstractions that use call stack, object recency, and heap connectivity information. We measure the precision of these abstractions dynamically for four different clients motivated by concurrency and on nine Java programs chosen from the DaCapo benchmark suite. Our dynamic results shed new light on aspects of heap abstractions that matter for precision, which allows us to more effectively navigate the large space of possible heap abstractions", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869494", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Percy", + "last_name": "Liang", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Intel (United States)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/oopsla/LiangTNS10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869507", + "title": "Back to the futures: incremental parallelization of existing sequential runtime systems", + "abstract": "Many language implementations, particularly for high-level and scripting languages, are based on carefully honed runtime systems that have an internally sequential execution model. Adding support for parallelism in the usual form -- as threads that run arbitrary code in parallel -- would require a major revision or even a rewrite to add safe and efficient locking and communication. We describe an alternative approach to incremental parallelization of runtime systems. This approach can be applied inexpensively to many sequential runtime systems, and we demonstrate its effectiveness in the Racket runtime system and Parrot virtual machine. Our evaluation assesses both the performance benefits and the developer effort needed to implement our approach. We find that incremental parallelization can provide useful, scalable parallelism on commodity multicore processors at a fraction of the effort required to implement conventional parallel threads.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869507", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "J. M.", + "last_name": "Swaine", + "institution": "Northwestern University" + }, + { + "first_name": "Kevin", + "last_name": "Tew", + "institution": "University of Utah" + }, + { + "first_name": "Peter A.", + "last_name": "Dinda", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/oopsla/SwaineTDFF10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869510", + "title": "Tribal ownership", + "abstract": "Tribal Ownership unifies class nesting and object ownership. Tribal Ownership is based on Tribe, a language with nested classes and object families. In Tribal Ownership, a program's runtime object ownership structure is characterised by the lexical nesting structure of its classes.We build on a variant of Tribe to present a descriptive ownership system, using object nesting to describe heap partitions, but without imposing any restrictions on programming disciplines. We then demonstrate how a range of different prescriptive ownership policies can be supported on top of the descriptive Tribal Ownership mechanism; including a novel owners-as-local-dominators policy. We formalise our type system and prove soundness and several ownership invariants. The resulting system requires strikingly few annotations, and uses well-understood encapsulation techniques to create ownership systems that should be intuitive for programmers.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869510", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nicholas", + "last_name": "Cameron", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/oopsla/CameronNW10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869506", + "title": "The two-state solution: native and serializable continuations accord", + "abstract": "Continuation-based Web servers provide advantages over traditional Web application development through the increase of expressive power they allow. This leads to fewer errors and more productivity for the programmers that adopt them. Unfortunately, existing implementation techniques force a hard choice between scalability and expressiveness.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869506", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jay", + "last_name": "McCarthy", + "institution": "Brigham Young University" + } + ], + "dblp_key": "conf/oopsla/McCarthy10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869513", + "title": "Automatic atomic region identification in shared memory SPMD programs", + "abstract": "This paper presents TransFinder, a compile-time tool that automatically determines which statements of an unsynchronized multithreaded program must be enclosed in atomic regions to enforce conflict-serializability. Unlike previous tools, TransFinder requires no programmer input (beyond the program) and is more efficient in both time and space.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869513", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gautam", + "last_name": "Upadhyaya", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Samuel P.", + "last_name": "Midkiff", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Vijay S.", + "last_name": "Pai", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/UpadhyayaMP10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869503", + "title": "Mostly modular compilation of crosscutting concerns by contextual predicate dispatch", + "abstract": "The modularity of aspect-oriented programming (AOP) has been a controversial issue. To investigate this issue compared with object-oriented programming (OOP), we propose a simple language providing AOP mechanisms, which are enhanced traditional OOP mechanisms. We also present its formal system and then show that programs in this language can be only mostly modularly (i.e. separately) typechecked and compiled.We mention a source of this unmodularity and discuss whether or not it is appropriate to claim that AOP breaks modularity compared with OOP.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869503", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shigeru", + "last_name": "Chiba", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + }, + { + "first_name": "Salikh", + "last_name": "Zakirov", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ChibaIZ10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869519", + "title": "Performance analysis of idle programs", + "abstract": "This paper presents an approach for performance analysis of modern enterprise-class server applications. In our experience, performance bottlenecks in these applications differ qualitatively from bottlenecks in smaller, stand-alone systems. Small applications and benchmarks often suffer from CPU-intensive hot spots. In contrast, enterprise-class multi-tier applications often suffer from problems that manifest not as hot spots, but as idle time, indicating a lack of forward motion. Many factors can contribute to undesirable idle time, including locking problems, excessive system-level activities like garbage collection, various resource constraints, and problems driving load.We present the design and methodology for WAIT, a tool to diagnosis the root cause of idle time in server applications. Given lightweight samples of Java activity on a single tier, the tool can often pinpoint the primary bottleneck on a multi-tier system. The methodology centers on an informative abstraction of the states of idleness observed in a running program. This abstraction allows the tool to distinguish, for example, between hold-ups on a database machine, insufficient load, lock contention in application code, and a conventional bottleneck due to a hot method. To compute the abstraction, we present a simple expert system based on an extensible set of declarative rules.WAIT can be deployed on the fly, without modifying or even restarting the application. Many groups in IBM have applied the tool to diagnosis performance problems in commercial systems, and we present a number of examples as case studies.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869519", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Erik", + "last_name": "Altman", + "institution": "IBM (United States)" + }, + { + "first_name": "Matthew", + "last_name": "Arnold", + "institution": "IBM (United States)" + }, + { + "first_name": "Stephen J.", + "last_name": "Fink", + "institution": "IBM (United States)" + }, + { + "first_name": "Nick", + "last_name": "Mitchell", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/AltmanAFM10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869521", + "title": "Registration-based language abstractions", + "abstract": "Programming language innovation has been hindered by the difficulty of making changes to existing languages. A key source of difficulty is the tyrannical nature of existing approaches to realizing languages -- adding a new language construct means that any tool, document or programmer that works with the language must be prepared to deal with that construct.A registration-based approach makes it possible to define language constructs that are not tyrannical. They are instead transient -- the program appears to be written using the constructs only so long as a given programmer wants to see it that way. This approach may have the potential to greatly facilitate programming language innovation.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869521", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Samuel", + "last_name": "Davis", + "institution": "University of British Columbia" + }, + { + "first_name": "Gregor", + "last_name": "Kiczales", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/oopsla/DavisK10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869505", + "title": "Random testing for higher-order, stateful programs", + "abstract": "Testing is among the most effective tools available for finding bugs. Still, we know of no automatic technique for generating test cases that expose bugs involving a combination of mutable state and callbacks, even though objects and method overriding set up exactly that combination. For such cases, a test generator must create callbacks or subclasses that aggressively exercise side-effecting operations using combinations of generated objects.This paper presents a new algorithm for randomly testing programs that use state and callbacks. Our algorithm exploits a combination of contracts and environment bindings to guide the test-case generator toward interesting inputs. Our prototype implementation for Racket (formerly PLT Scheme) - which has a Java-like class system, but with first-class classes as well as gbeta-like augmentable methods - uncovered dozens of bugs in a well-tested and widely used text-editor library.We describe our approach in a precise, formal notation, borrowing the techniques used to describe operational semantics and type systems. The formalism enables us to provide a compact and self-contained explanation of the core of our technique without the ambiguity usually present in pseudo-code descriptions.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869505", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Casey", + "last_name": "Klein", + "institution": "Northwestern University" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/oopsla/KleinFF10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869509", + "title": "Ownership and immutability in generic Java", + "abstract": "The Java language lacks the important notions of ownership (an object owns its representation to prevent unwanted aliasing) and immutability (the division into mutable, immutable, and readonly data and references). Programmers are prone to design errors, such as representation exposure or violation of immutability contracts. This paper presents Ownership Immutability Generic Java (OIGJ), a backward-compatible purely-static language extension supporting ownership and immutability. We formally defined a core calculus for OIGJ, based on Featherweight Java, and proved it sound. We also implemented OIGJ and performed case studies on 33,000 lines of code.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869509", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yoav", + "last_name": "Zibin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Paley", + "last_name": "Li", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Mahmood", + "last_name": "Ali", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/ZibinPLAE10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869511", + "title": "A time-aware type system for data-race protection and guaranteed initialization", + "abstract": "We introduce a type system based on intervals, objects representing the time in which a block of code will execute. The type system can verify time-based properties such as when a field will be accessed or a method will be invoked. One concrete application of our type system is data-race protection: For fields which are initialized during one phase of the program and constant thereafter, users can designate the interval during which the field is mutable. Code which happens after this initialization interval can safely read the field in parallel. We also support fields guarded by a lock and even the use of dynamic race detectors. Another use for intervals is to designate different phases in the object’s lifetime, such as a constructor phase. The type system then ensures that only appropriate methods are invoked in each phase.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869511", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nicholas D.", + "last_name": "Matsakis", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/MatsakisG10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869514", + "title": "Task types for pervasive atomicity", + "abstract": "Atomic regions are an important concept in correct concurrent programming: since atomic regions can be viewed as having executed in a single step, atomicity greatly reduces the number of possible interleavings the programmer needs to consider. This paper describes a method for building atomicity into a programming language in an organic fashion. We take the view that atomicity holds for whole threads by default, and a division into smaller atomic regions occurs only at points where an explicit need for sharing is needed and declared. A corollary of this view is every line of code is part of some atomic region. We define a polymorphic type system, Task Types, to enforce most of the desired atomicity properties statically. We show the reasonableness of our type system by proving that type soundness, isolation invariance, and atomicity enforcement properties hold at run time. We also present initial results of a Task Types implementation built on Java", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869514", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aditya", + "last_name": "Kulkarni", + "institution": "Binghamton University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/oopsla/KulkarniLS10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869518", + "title": "Refactoring references for library migration", + "abstract": "Automated refactoring is a key feature of modern IDEs. Existing refactorings rely on the transformation of source code declarations, in which references may also be transformed as a side effect. However, there exist situations in which a declaration is not available for refactoring or would be inappropriate to transform, for example, in the presence of dangling references or where a set of references should be retargeted to a different declaration.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869518", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Puneet", + "last_name": "Kapur", + "institution": "University of Calgary" + }, + { + "first_name": "Brad", + "last_name": "Cossette", + "institution": "University of Calgary" + }, + { + "first_name": "Robert J.", + "last_name": "Walker", + "institution": "University of Calgary" + } + ], + "dblp_key": "conf/oopsla/KapurCW10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869517", + "title": "SPUR: a trace-based JIT compiler for CIL", + "abstract": "Tracing just-in-time compilers (TJITs) determine frequently executed traces (hot paths and loops) in running programs and focus their optimization effort by emitting optimized machine code specialized to these traces. Prior work has established this strategy to be especially beneficial for dynamic languages such as JavaScript, where the TJIT interfaces with the interpreter and produces machine code from the JavaScript trace.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869517", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Bebenita", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Florian", + "last_name": "Brandner", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wolfram", + "last_name": "Schulte", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nikolai", + "last_name": "Tillmann", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Herman", + "last_name": "Venter", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/BebenitaBFLSTV10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869523", + "title": "Concurrency by modularity: design patterns, a case in point", + "abstract": "General purpose object-oriented programs typically aren't embarrassingly parallel. For these applications, finding enough concurrency remains a challenge in program design. To address this challenge, in the Panini project we are looking at reconciling concurrent program design goals with modular program design goals. The main idea is that if programmers improve the modularity of their programs they should get concurrency for free. In this work we describe one of our directions to reconcile these two goals by enhancing Gang-of-Four (GOF) object-oriented design patterns. GOF patterns are commonly used to improve the modularity of object-oriented software. These patterns describe strategies to decouple components in design space and specify how these components should interact. Our hypothesis is that if these patterns are enhanced to also decouple components in execution space applying them will concomitantly improve the design and potentially available concurrency in software systems. To evaluate our hypothesis we have studied all 23 GOF patterns. For 18 patterns out of 23, our hypothesis has held true. Another interesting preliminary result reported here is that for 17 out of these 18 studied patterns, concurrency and synchronization concerns were completely encapsulated in our concurrent design pattern framework.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869523", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hridesh", + "last_name": "Rajan", + "institution": "Iowa State University" + }, + { + "first_name": "Steven M.", + "last_name": "Kautz", + "institution": "Iowa State University" + }, + { + "first_name": "Wayne", + "last_name": "Rowcliffe", + "institution": "Iowa State University" + } + ], + "dblp_key": "conf/oopsla/RajanKR10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869522", + "title": "Pinocchio: bringing reflection to life with first-class interpreters", + "abstract": "To support development tools like debuggers, runtime systems need to provide a meta-programming interface to alter their semantics and access internal data. Reflective capabilities are typically fixed by the Virtual Machine (VM). Unanticipated reflective features must either be simulated by complex program transformations, or they require the development of a specially tailored VM. We propose a novel approach to behavioral reflection that eliminates the barrier between applications and the VM by manipulating an explicit tower of first-class interpreters. Pinocchio is a proof-of-concept implementation of our approach which enables radical changes to the interpretation of programs by explicitly instantiating subclasses of the base interpreter. We illustrate the design of Pinocchio through non-trivial examples that extend runtime semantics to support debugging, parallel debugging, and back-in-time object-flow debugging. Although performance is not yet addressed, we also discuss numerous opportunities for optimization, which we believe will lead to a practical approach to behavioral reflection.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869522", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "T.", + "last_name": "Verwaest", + "institution": "University of Bern" + }, + { + "first_name": "Camillo", + "last_name": "Bruni", + "institution": "University of Bern" + }, + { + "first_name": "David", + "last_name": "Gurtner", + "institution": "University of Bern" + }, + { + "first_name": "Adrian", + "last_name": "Lienhard", + "institution": "University of Bern" + }, + { + "first_name": "Oscar", + "last_name": "Niestrasz", + "institution": "University of Bern" + } + ], + "dblp_key": "conf/oopsla/VerwaestBGLN10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869533", + "title": "Better science through art", + "abstract": "How do artists and scientists work? The same.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869533", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard P.", + "last_name": "Gabriel", + "institution": "IBM (United States)" + }, + { + "first_name": "Kevin", + "last_name": "Sullivan", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/oopsla/GabrielS10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869534", + "title": "Rubber ducks, nightmares, and unsaturated predicates: proto-scientific schemata are good for agile", + "abstract": "Fine-grain case studies of scientific inquiry, lessons from linguistics on metaphoric thinking, the epistemology of Charles Sanders Peirce, recent work on architectural image-schemata, along with the computer world's own theorist, Peter Naur, all suggest that software developers (frequently dulled and desiccated from overdosing on 'Cartesian' methodologies) could benefit from imbibing a little 'mysticism' not the wave-your-hands woo-woo kind but the more ineffable hunch and gut side of human cognition. Scholarly publications in their final polished forms rarely admit that stories, jokes, eroticism, and dreams were the fertile seeds that germinated into 'serious' results. This essay looks to these 'closet' sources, non-reductionist, non-self conscious, metaphorical, aformal modes of thought as the salvation of a profession gone awry. It is notably proto-scientific image-schemata that retain our attention as a pragmatic tool for improving the fecundity of Agile methodology, at its roots, so to speak. The necessary context is provided by Peter Naur's fundamental insights about software development as 'theory building' coupled with an elaboration of the Agile concept of storytelling.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869534", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jenny", + "last_name": "Quillien", + "institution": "New Mexico Highlands University" + }, + { + "first_name": "Dave", + "last_name": "West", + "institution": "New Mexico Highlands University" + } + ], + "dblp_key": "conf/oopsla/QuillienW10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869525", + "title": "Patterns and statistical analysis for understanding reduced resource computing", + "abstract": "We present several general, broadly applicable mechanisms that enable computations to execute with reduced resources, typically at the cost of some loss in the accuracy of the result they produce.We identify several general computational patterns that interact well with these resource reduction mechanisms, present a concrete manifestation of these patterns in the form of simple model programs, perform simulationbased explorations of the quantitative consequences of applying these mechanisms to our model programs, and relate the model computations (and their interaction with the resource reduction mechanisms) to more complex benchmark applications drawn from a variety of fields.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869525", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Henry", + "last_name": "Hoffmann", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Stelios", + "last_name": "Sidiroglou", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/RinardHMS10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869526", + "title": "Programming with time: cyber-physical programming with impromptu", + "abstract": "The act of computer programming is generally considered to be temporally removed from a computer program's execution. In this paper we discuss the idea of programming as an activity that takes place within the temporal bounds of a real-time computational process and its interactions with the physical world. We ground these ideas within the con- text of livecoding -- a live audiovisual performance practice. We then describe how the development of the programming environment \"Impromptu\" has addressed our ideas of programming with time and the notion of the programmer as an agent in a cyber-physical system.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869526", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Sorensen", + "institution": "Australian National University" + }, + { + "first_name": "Henry", + "last_name": "Gardner", + "institution": "Australian National University" + } + ], + "dblp_key": "conf/oopsla/SorensenG10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869536", + "title": "Faith, hope, and love: an essay on software science's neglect of human factors", + "abstract": "Research in the area of programming languages has different facets -- from formal reasoning about new programming language constructs (such as type soundness proofs for new type systems) over inventions of new abstractions, up to performance measurements of virtual machines. A closer look into the underlying research methods reveals a distressing characteristic of programming language research: developers, which are the main audience for new language constructs, are hardly considered in the research process. As a consequence, it is simply not possible to state whether a new construct that requires some kind of interaction with the developer has any positive impact on the construction of software. This paper argues for appropriate research methods in programming language research that rely on studies of developers -- and argues that the introduction of corresponding empirical methods not only requires a new understanding of research but also a different view on how to teach software science to students.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869536", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Hanenberg", + "institution": "University of Duisburg-Essen" + } + ], + "dblp_key": "conf/oopsla/Hanenberg10a", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869537", + "title": "The Tower of Babel did not fail", + "abstract": "Fred Brooks' retelling of the biblical story of the Tower of Babel offers many insights into what makes building software difficult. The difficulty, according to common interpretations, comes from the communication and organizational problems in software development. But the story contains one more important lesson that people tend to miss: one cannot accomplish impossible goals, which programmers are often asked to do. Software engineering, as a discipline, can overcome poor communication; but as long as we attempt to live up to impossible expectations, we will always fail.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869537", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "Adamczyk", + "institution": "Booz Allen Hamilton (United States)" + }, + { + "first_name": "Munawar", + "last_name": "Hafiz", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/AdamczykH10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869527", + "title": "Language virtualization for heterogeneous parallel computing", + "abstract": "As heterogeneous parallel systems become dominant, application developers are being forced to turn to an incompatiblemix of low level programming models (e.g. OpenMP, MPI, CUDA, OpenCL). However, these models do little to shield developers from the difficult problems of parallelization, data decomposition and machine-specific details. Most programmersare having a difficult time using these programming models effectively. To provide a programming modelthat addresses the productivity and performance requirements for the average programmer, we explore a domainspecificapproach to heterogeneous parallel programming.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869527", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hassan", + "last_name": "Chafi", + "institution": "Stanford University" + }, + { + "first_name": "Zach", + "last_name": "DeVito", + "institution": "Stanford University" + }, + { + "first_name": "Adriaan", + "last_name": "Moors", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Arvind K.", + "last_name": "Sujeeth", + "institution": "Stanford University" + }, + { + "first_name": "Pat", + "last_name": "Hanrahan", + "institution": "Stanford University" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/ChafiDMRSHOO10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869529", + "title": "Flexible modeling tools for pre-requirements analysis: conceptual architecture and research challenges", + "abstract": "A serious tool gap exists at the start of the software lifecy-cle, before requirements formulation. Pre-requirements analysts gather information, organize it to gain insight, en-vision possible futures, and present insights and recom-mendations to stakeholders. They typically use office tools, which give great freedom, but no help with consistency management, change propagation, or information migration to downstream tools. Despite these downsides, office tools are still favored over modeling tools, which are constrain-ing and difficult to use. We introduce the notion of flexible modeling tools, which blend the advantages of office and modeling tools. We propose a conceptual architecture for such tools, and outline research challenges to be met in realizing them. We briefly describe the Business Insight Toolkit, a prototype tool embodying this architecture.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869529", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Harold", + "last_name": "Ossher", + "institution": "IBM (United States)" + }, + { + "first_name": "Rachel", + "last_name": "Bellamy", + "institution": "IBM (United States)" + }, + { + "first_name": "Ian", + "last_name": "Simmonds", + "institution": "IBM (United States)" + }, + { + "first_name": "David", + "last_name": "Amid", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Ateret", + "last_name": "Anaby-Tavor", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Matthew", + "last_name": "Callery", + "institution": "IBM (United States)" + }, + { + "first_name": "Michael", + "last_name": "Desmond", + "institution": "IBM (United States)" + }, + { + "first_name": "Jacqueline de", + "last_name": "Vries", + "institution": "IBM (United States)" + }, + { + "first_name": "Amit", + "last_name": "Fisher", + "institution": "IBM Research - Haifa" + }, + { + "first_name": "Sophia", + "last_name": "Krasikov", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/OssherBSAACDVFK10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869531", + "title": "Managing ambiguity in programming by finding unambiguous examples", + "abstract": "We propose a new way to raise the level of discourse in the programming process: permit ambiguity, but manage it by linking it to unambiguous examples. This allows programming environments to work with high-level descriptions that lack precise semantics, such as natural language descriptions or conceptual diagrams, without requiring programmers to formulate their ideas in a formal language first. As an example of this idea, we present Zones, a code search and reuse interface that connects code with ambiguous natural language annotations about its purpose. The backend, called ProcedureSpace, induces relationships between these purpose annotations, static code analysis features, and a variety of natural language background knowledge. ProcedureSpace can search for code given purpose descriptions or vice versa, and can even find code that was never annotated or commented. Since completed Zones searches become annotations, the system learns from user interaction. Users in a preliminary study found that reasoning jointly over natural language and programming language helped them reuse code.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869531", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kenneth C.", + "last_name": "Arnold", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Henry", + "last_name": "Lieberman", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ArnoldL10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869530", + "title": "To upgrade or not to upgrade: impact of online upgrades across multiple administrative domains", + "abstract": "Online software upgrades are often plagued by runtime behaviors that are poorly understood and difficult to ascertain. For example, the interactions among multiple versions of the software expose the system to race conditions that can introduce latent errors or data corruption. Moreover, industry trends suggest that online upgrades are currently needed in large-scale enterprise systems, which often span multiple administrative domains (e.g., Web 2.0 applications that rely on AJAX client-side code or systems that lease cloud-computing resources). In such systems, the enterprise does not control all the tiers of the system and cannot coordinate the upgrade process, making existing techniques inadequate to prevent mixed-version races. In this paper, we present an analytical framework for impact assessment, which allows system administrators to directly compare the risk of following an online-upgrade plan with the risk of delaying or canceling the upgrade. We also describe an executable model that implements our formal impact assessment and enables a systematic approach for deciding whether an online upgrade is appropriate. Our model provides a method of last resort for avoiding undesirable program behaviors, in situations where mixed-version races cannot be avoided through other technical means.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869530", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tudor", + "last_name": "Dumitraş", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Priya", + "last_name": "Narasimhan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Eli", + "last_name": "Tilevich", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/oopsla/DumitrasNT10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869535", + "title": "Pure and declarative syntax definition: paradise lost and regained", + "abstract": "Syntax definitions are pervasive in modern software systems, and serve as the basis for language processing tools like parsers and compilers. Mainstream parser generators pose restrictions on syntax definitions that follow from their implementation algorithm. They hamper evolution, maintainability, and compositionality of syntax definitions. The pureness and declarativity of syntax definitions is lost. We analyze how these problems arise for different aspects of syntax definitions, discuss their consequences for language engineers, and show how the pure and declarative nature of syntax definitions can be regained.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869535", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lennart C.L.", + "last_name": "Kats", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + }, + { + "first_name": "Guido", + "last_name": "Wachsmuth", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/oopsla/KatsVW10", + "venue": "oopsla", + "year": 2010 + }, + { + "paper_id": "10.1145/1869459.1869515", + "title": "Concurrent programming with revisions and isolation types", + "abstract": "Building applications that are responsive and can exploit parallel hardware while remaining simple to write, understand, test, and maintain, poses an important challenge for developers. In particular, it is often desirable to enable various tasks to read or modify shared data concurrently without requiring complicated locking schemes that may throttle concurrency and introduce bugs.", + "date": "2010-10-17", + "link": "https://doi.org/10.1145/1869459.1869515", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Alexandro", + "last_name": "Baldassin", + "institution": "Universidade Estadual de Campinas (UNICAMP)" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/BurckhardtBL10", + "venue": "oopsla", + "year": 2010 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2011.json b/data/pl_conferences/oopsla/2011.json new file mode 100644 index 0000000..daee228 --- /dev/null +++ b/data/pl_conferences/oopsla/2011.json @@ -0,0 +1,1893 @@ +[ + { + "paper_id": "10.1145/2048066.2048077", + "title": "Kind analysis for MATLAB", + "abstract": "MATLAB is a popular dynamic programming language used for scientific and numerical programming. As a language, it has evolved from a small scripting language intended as an interactive interface to numerical libraries, to a very popular language supporting many language features and libraries. The overloaded syntax and dynamic nature of the language, plus the somewhat organic addition of language features over the years, makes static analysis of modern MATLAB quite challenging. A fundamental problem in MATLAB is determining the kind of an identifier. Does an identifier refer to a variable, a named function or a prefix? Although this is a trivial problem for most programming languages, it was not clear how to do this properly in MATLAB. Furthermore, there was no simple explanation of kind analysis suitable for MATLAB programmers, nor a publicly-available implementation suitable for compiler researchers.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048077", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jesse", + "last_name": "Doherty", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + }, + { + "first_name": "Soroush", + "last_name": "Radpour", + "institution": "McGill University" + } + ], + "dblp_key": "conf/oopsla/DohertyHR11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048081", + "title": "Catch me if you can: performance bug detection in the wild", + "abstract": "Profilers help developers to find and fix performance problems. But do they find performance bugs -- performance problems that real users actually notice? In this paper we argue that -- especially in the case of interactive applications -- traditional profilers find irrelevant problems but fail to find relevant bugs.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048081", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Milan", + "last_name": "Jovic", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Andrea", + "last_name": "Adamoli", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Matthias", + "last_name": "Hauswirth", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/oopsla/JovicAH11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048070", + "title": "SHERIFF: precise detection and automatic mitigation of false sharing", + "abstract": "False sharing is an insidious problem for multithreaded programs running on multicore processors, where it can silently degrade performance and scalability. Previous tools for detecting false sharing are severely limited: they cannot distinguish false sharing from true sharing, have high false positive rates, and provide limited assistance to help programmers locate and resolve false sharing.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048070", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tongping", + "last_name": "Liu", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/LiuB11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048080", + "title": "Integrated language definition testing: enabling test-driven language development", + "abstract": "The reliability of compilers, interpreters, and development environments for programming languages is essential for effective software development and maintenance. They are often tested only as an afterthought. Languages with a smaller scope, such as domain-specific languages, often remain untested. General-purpose testing techniques and test case generation methods fall short in providing a low-threshold solution for test-driven language development. In this paper we introduce the notion of a language-parametric testing language (LPTL) that provides a reusable, generic basis for declaratively specifying language definition tests. We integrate the syntax, semantics, and editor services of a language under test into the LPTL for writing test inputs. This paper describes the design of an LPTL and the tool support provided for it, shows use cases using examples, and describes our implementation in the form of the Spoofax testing language.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048080", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lennart C.L.", + "last_name": "Kats", + "institution": "Delft University of Technology" + }, + { + "first_name": "Rob", + "last_name": "Vermaas", + "institution": "" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/oopsla/KatsVV11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048082", + "title": "PREFAIL: a programmable tool for multiple-failure injection", + "abstract": "As hardware failures are no longer rare in the era of cloud computing, cloud software systems must \"prevail\" against multiple, diverse failures that are likely to occur. Testing software against multiple failures poses the problem of combinatorial explosion of multiple failures. To address this problem, we present PreFail, a programmable failure-injection tool that enables testers to write a wide range of policies to prune down the large space of multiple failures. We integrate PreFail to three cloud software systems (HDFS, Cassandra, and ZooKeeper), show a wide variety of useful pruning policies that we can write for them, and evaluate the speed-ups in testing time that we obtain by using the policies. In our experiments, our testing approach with appropriate policies found all the bugs that one can find using exhaustive testing while spending 10X--200X less time than exhaustive testing.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048082", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pallavi", + "last_name": "Joshi", + "institution": "Berkeley College" + }, + { + "first_name": "Haryadi S.", + "last_name": "Gunawi", + "institution": "Berkeley College" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/JoshiGS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048072", + "title": "SOS: saving time in dynamic race detection with stationary analysis", + "abstract": "Data races are subtle and difficult to detect errors that arise during concurrent program execution. Traditional testing techniques fail to find these errors, but recent research has shown that targeted dynamic analysis techniques can be developed to precisely detect races (i.e., no false race reports are generated) that occur during program execution. Unfortunately, precise race detection is still too expensive to be used in practice. State-of-the-art techniques still slow down program execution by a factor of eight or more. In this paper, we incorporate an optimization technique based on the observation that many thread-shared objects are written early in their lifetimes and then become read-only for the remainder of their lifetimes; these are known as stationary objects. The main contribution of our work is the insight that once a stationary object becomes thread-shared, races cannot occur. Therefore, our proposed approach does not monitor access to these objects. As such, our system only incurs an average overhead of 45% of that of an implementation of FastTrack, a low-overhead dynamic race detector. We then compared the effectiveness of our approach to de- tect races in deployed environments with that of Pacer, a sampling based race detector based on FastTrack. We found that our approach can detect over five times more races than Pacer when we budget 50% for runtime overhead.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048072", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Canbing", + "last_name": "Li", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Witawas", + "last_name": "Srisa‐an", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Matthew B.", + "last_name": "Dwyer", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "conf/oopsla/LiSD11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048086", + "title": "Automatic fine-grain locking using shape properties", + "abstract": "We present a technique for automatically adding fine-grain locking to an abstract data type that is implemented using a dynamic forest -i.e., the data structures may be mutated, even to the point of violating forestness temporarily during the execution of a method of the ADT. Our automatic technique is based on Domination Locking, a novel locking protocol. Domination locking is designed specifically for software concurrency control, and in particular is designed for object-oriented software with destructive pointer updates. Domination locking is a strict generalization of existing locking protocols for dynamically changing graphs. We show our technique can successfully add fine-grain locking to libraries where manually performing locking is extremely challenging. We show that automatic fine-grain locking is more efficient than coarse-grain locking, and obtains similar performance to hand-crafted fine-grain locking.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048086", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guy", + "last_name": "Golan-Gueta", + "institution": "Tel Aviv University" + }, + { + "first_name": "Nathan", + "last_name": "Bronson", + "institution": "Palo Alto University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Palo Alto University" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/Golan-GuetaBARSY11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048076", + "title": "Synthesis of first-order dynamic programming algorithms", + "abstract": "To solve a problem with a dynamic programming algorithm, one must reformulate the problem such that its solution can be formed from solutions to overlapping subproblems. Because overlapping subproblems may not be apparent in the specification, it is desirable to obtain the algorithm directly from the specification. We describe a semi-automatic synthesizer of linear-time dynamic programming algorithms. The programmer supplies a declarative specification of the problem and the operators that might appear in the solution. The synthesizer obtains the algorithm by searching a space of candidate algorithms; internally, the search is implemented with constraint solving. The space of candidate algorithms is defined with a program template reusable across all linear-time dynamic programming algorithms, which we characterize as first-order recurrences. This paper focuses on how to write the template so that the constraint solving process scales to real-world linear-time dynamic programming algorithms. We show how to reduce the space with (i)~symmetry reduction and (ii)~domain knowledge of dynamic programming algorithms. We have synthesized algorithms for variants of maximal substring matching, an assembly-line optimization, and the extended Euclid algorithm. We have also synthesized a problem outside the class of first-order recurrences, by composing three instances of the algorithm template.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048076", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yewen", + "last_name": "Pu", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Berkeley College" + }, + { + "first_name": "Saurabh", + "last_name": "Srivastava", + "institution": "Berkeley College" + } + ], + "dblp_key": "conf/oopsla/PuBS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048083", + "title": "Synthesizing method sequences for high-coverage testing", + "abstract": "High-coverage testing is challenging. Modern object-oriented programs present additional challenges for testing. One key difficulty is the generation of proper method sequences to construct desired objects as method parameters. In this paper, we cast the problem as an instance of program synthesis that automatically generates candidate programs to satisfy a user-specified intent. In our setting, candidate programs are method sequences, and desired object states specify an intent. Automatic generation of desired method sequences is difficult due to its large search space---sequences often involve methods from multiple classes and require specific primitive values. This paper introduces a novel approach, called Seeker, to intelligently navigate the large search space. Seeker synergistically combines static and dynamic analyses: (1) dynamic analysis generates method sequences to cover branches; (2) static analysis uses dynamic analysis information for not-covered branches to generate candidate sequences; and (3) dynamic analysis explores and eliminates statically generated sequences. For evaluation, we have implemented Seeker and demonstrate its effectiveness on four subject applications totalling 28K LOC. We show that Seeker achieves higher branch coverage and def-use coverage than existing state-of-the-art approaches. We also show that Seeker detects 34 new defects missed by existing tools.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048083", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Suresh", + "last_name": "Thummalapenta", + "institution": "IBM Research - India" + }, + { + "first_name": "Tao", + "last_name": "Xie", + "institution": "North Carolina State University" + }, + { + "first_name": "Nikolai", + "last_name": "Tillmann", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jonathan de", + "last_name": "Halleux", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/ThummalapentaXTHS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048068", + "title": "The sequential prison", + "abstract": "We are trapped in a sequential prison. We use sequential character strings to write sequential programs to control sequential computers. No wonder concurrency remains elusive. How did we come to be here? The high cost of vacuum tube logic forced sequence upon early computer builders. Sequential character strings were the economic way to describe what sequential computers should do. Sequential programs controlled the expensive part of the machine, namely logic. The lethargic pace of logic circuits masked the cost of moving data over distance, allowing programming languages to ignore the cost of communication. Today, the time delay and energy cost of communicating over distance dominate modern computers; logic is essentially free. Why then, do programming languages continue to control logic and largely ignore communication? It will take a broad effort to escape our sequential prison, requiring changes in hardware, programming notations and the ways in which they are expressed. Most importantly, it will require recognizing that we are in sequential prison, and planning for an escape.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048068", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivan E.", + "last_name": "Sutherland", + "institution": "Portland State University" + } + ], + "dblp_key": "conf/oopsla/Sutherland11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048071", + "title": "Accentuating the positive: atomicity inference and enforcement using correct executions", + "abstract": "Concurrency bugs are often due to inadequate synchronization that fail to prevent specific (undesirable) thread interleavings. Such errors, often referred to as Heisenbugs, are difficult to detect, prevent, and repair. In this paper, we present a new technique to increase program robustness against Heisenbugs. We profile correct executions from provided test suites to infer fine-grained atomicity properties. Additional deadlock-free locking is injected into the program to guarantee these properties hold on production runs. Notably, our technique does not rely on witnessing or analyzing erroneous executions. The end result is a scheme that only permits executions which are guaranteed to preserve the atomicity properties derived from the profile. Evaluation results on large, real-world, open-source programs show that our technique can effectively suppress subtle concurrency bugs, with small runtime overheads (typically less than 15%).", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048071", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dasarath", + "last_name": "Weeratunge", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jaganathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/WeeratungeZJ11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048078", + "title": "Tool-supported refactoring for JavaScript", + "abstract": "Refactoring is a popular technique for improving the structure of existing programs while maintaining their behavior. For statically typed programming languages such as Java, a wide variety of refactorings have been described, and tool support for performing refactorings and ensuring their correctness is widely available in modern IDEs. For the JavaScript programming language, however, existing refactoring tools are less mature and often unable to ensure that program behavior is preserved. Refactoring algorithms that have been developed for statically typed languages are not applicable to JavaScript because of its dynamic nature. We propose a framework for specifying and implementing JavaScript refactorings based on pointer analysis. We describe novel refactorings motivated by best practice recommendations for JavaScript programming, and demonstrate how they can be described concisely in terms of queries provided by our framework. Experiments performed with a prototype implementation on a suite of existing applications show that our approach is well-suited for developing practical refactoring tools for JavaScript.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048078", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Asger", + "last_name": "Feldthaus", + "institution": "Aarhus University" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Max", + "last_name": "Schäfer", + "institution": "University of Oxford" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/FeldthausMMST11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048087", + "title": "Safe parallel programming using dynamic dependence hints", + "abstract": "Speculative parallelization divides a sequential program into possibly parallel tasks and permits these tasks to run in parallel if and only if they show no dependences with each other. The parallelization is safe in that a speculative execution always produces the same output as the sequential execution.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048087", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chuanle", + "last_name": "Ke", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Lei", + "last_name": "Liu", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Chao", + "last_name": "Zhang", + "institution": "Intel (United States)" + }, + { + "first_name": "Tongxin", + "last_name": "Bai", + "institution": "University of Rochester" + }, + { + "first_name": "Bryan", + "last_name": "Jacobs", + "institution": "University of Rochester" + }, + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/oopsla/KeLZBJD11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048073", + "title": "Testing atomicity of composed concurrent operations", + "abstract": "We address the problem of testing atomicity of composed concurrent operations. Concurrent libraries help programmers exploit parallel hardware by providing scalable concurrent operations with the illusion that each operation is executed atomically. However, client code often needs to compose atomic operations in such a way that the resulting composite operation is also atomic while preserving scalability. We present a novel technique for testing the atomicity of client code composing scalable concurrent operations. The challenge in testing this kind of client code is that a bug may occur very rarely and only on a particular interleaving with a specific thread configuration. Our technique is based on modular testing of client code in the presence of an adversarial environment; we use commutativity specifications to drastically reduce the number of executions explored to detect a bug. We implemented our approach in a tool called COLT, and evaluated its effectiveness on a range of 51 real-world concurrent Java programs. Using COLT, we found 56 atomicity violations in Apache Tomcat, Cassandra, MyFaces Trinidad, and other applications.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048073", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ohad", + "last_name": "Shacham", + "institution": "Tel Aviv University" + }, + { + "first_name": "Nathan", + "last_name": "Bronson", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ShachamBASVY11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048085", + "title": "HAWKEYE: effective discovery of dataflow impediments to parallelization", + "abstract": "Parallelization transformations are an important vehicle for improving the performance and scalability of a software system. Utilizing concurrency requires that the developer first identify a suitable parallelization scope: one that poses as a performance bottleneck, and at the same time, exhibits considerable available parallelism. However, having identified a candidate scope, the developer still needs to ensure the correctness of the transformation. This is a difficult undertaking, where a major source of complication lies in tracking down sequential dependencies that inhibit parallelization and addressing them.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048085", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "Tel Aviv University" + }, + { + "first_name": "Greta", + "last_name": "Yorsh", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "John K.", + "last_name": "Field", + "institution": "Google (United States)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/oopsla/TrippYFS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048075", + "title": "Data-driven synthesis for object-oriented frameworks", + "abstract": "Software construction today often involves the use of large frameworks. The challenge in this type of programming is that object-oriented frameworks tend to grow exceedingly intricate; they spread functionality among numerous classes, and any use of the framework requires knowledge of many interacting components. We present a system named MATCHMAKER that from a simple query synthesizes code that interacts with the framework. The query consists of names of two framework classes, and our system produces code enabling interaction between them. MATCHMAKER relies on a database of dynamic program traces called DELIGHT that uses novel abstraction-based indexing techniques to answer queries about the evolution of heap connectivity in a matter of seconds.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048075", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kuat", + "last_name": "Yessenov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Zhilei", + "last_name": "Xu", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/YessenovXS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048088", + "title": "Sprint: speculative prefetching of remote data", + "abstract": "Remote data access latency is a significant performance bottleneck in many modern programs that use remote databases and web services. We present Sprint - a run-time system for optimizing such programs by prefetching and caching data from remote sources in parallel to the execution of the original program. Sprint separates the concerns of exposing potentially-independent data accesses from the mechanism for executing them efficiently in parallel or in a batch. In contrast to prior work, Sprint can efficiently prefetch data in the presence of irregular or input-dependent access patterns, while preserving the semantics of the original program.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048088", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arun", + "last_name": "Raman", + "institution": "Princeton University" + }, + { + "first_name": "Greta", + "last_name": "Yorsh", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/RamanYVY11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048090", + "title": "Asynchronous assertions", + "abstract": "Assertions are a familiar and widely used bug detection technique. Traditional assertion checking, however, is performed synchronously, imposing its full cost on the runtime of the program. As a result, many useful kinds of checks, such as data structure invariants and heap analyses, are impractical because they lead to extreme slowdowns. We present a solution that decouples assertion evaluation from program execution: assertions are checked asynchronously by separate checking threads while the program continues to execute. Our technique guarantees that asynchronous evaluation always produces the same result as synchronous evaluation, even if the program concurrently modifies the program state. The checking threads evaluate each assertion on a consistent snapshot of the program state as it existed at the moment the assertion started.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048090", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Edward", + "last_name": "Aftandilian", + "institution": "Google (United States)" + }, + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "Tufts University" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "IBM Research - Zurich" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/AftandilianGVY11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048103", + "title": "A step towards transparent integration of input-consciousness into dynamic program optimizations", + "abstract": "Dynamic program optimizations are critical for the efficiency of applications in managed programming languages and scripting languages. Recent studies have shown that exploitation of program inputs may enhance the effectiveness of dynamic optimizations significantly. However, current solutions for enabling the exploitation require either programmers' annotations or intensive offline profiling, impairing the practical adoption of the techniques.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048103", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kai", + "last_name": "Tian", + "institution": "William & Mary" + }, + { + "first_name": "Eddy", + "last_name": "Zhang", + "institution": "William & Mary" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "Williams (United States)" + } + ], + "dblp_key": "conf/oopsla/TianZS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048095", + "title": "JET: exception checking in the Java native interface", + "abstract": "Java's type system enforces exception-checking rules that stipulate a checked exception thrown by a method must be declared in the throws clause of the method. Software written in Java often invokes native methods through the use of the Java Native Interface (JNI). Java's type system, however, cannot enforce the same exception-checking rules on Java exceptions raised in native methods. This gap makes Java software potentially buggy and often difficult to debug when an exception is raised in native code. In this paper, we propose a complete static-analysis framework called JET to extend exception-checking rules even on native code. The framework has a two-stage design where the first stage throws away a large portion of irrelevant code so that the second stage, a fine-grained analysis, can concentrate on a small set of code for accurate bug finding. This design achieves both high efficiency and accuracy. We have applied JET on a set of benchmark programs with a total over 227K lines of source code and identified 12 inconsistent native-method exception declarations.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048095", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Si‐Liang", + "last_name": "Li", + "institution": "Lehigh University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Lehigh University" + } + ], + "dblp_key": "conf/oopsla/LiT11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048091", + "title": "Ribbons: a partially shared memory programming model", + "abstract": "The need for programs to execute subcomponents in isolation from each other or with lower privileges is prevalent among today's systems. We introduce ribbons: a shared memory programming model that allows for more implicit sharing of memory than processes but is more restrictive than threads. Ribbons structure the heap into protection domains. Privileges between these protection domains are carefully controlled in order to confine computation. We propose RibbonJ, a backwards-compatible extension of Java, to easily create or port programs to use the ribbons model. We study the progress and isolation properties of a subset of the language. Building on JikesRVM we implement ribbons by leveraging existing memory protection mechanisms in modern hardware and operating systems, avoiding the overhead of inline security checks and read or write barriers. We evaluate efficiency via microbenchmarks and the DaCapo suite, observing minor overhead. Additionally, we refactor Apache Tomcat to use ribbons for application isolation, discuss the refactoring's design and complexity, and evaluate performance using the SPECweb2009 benchmark.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048091", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Hoffman", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Harrison", + "last_name": "Metzger", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/HoffmanME11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048092", + "title": "Why nothing matters: the impact of zeroing", + "abstract": "Memory safety defends against inadvertent and malicious misuse of memory that may compromise program correctness and security. A critical element of memory safety is zero initialization. The direct cost of zero initialization is surprisingly high: up to 12.7%, with average costs ranging from 2.7 to 4.5% on a high performance virtual machine on IA32 architectures. Zero initialization also incurs indirect costs due to its memory bandwidth demands and cache displacement effects. Existing virtual machines either: a) minimize direct costs by zeroing in large blocks, or b) minimize indirect costs by zeroing in the allocation sequence, which reduces cache displacement and bandwidth. This paper evaluates the two widely used zero initialization designs, showing that they make different tradeoffs to achieve very similar performance. Our analysis inspires three better designs: (1) bulk zeroing with cache-bypassing (non-temporal) instructions to reduce the direct and indirect zeroing costs simultaneously, (2) concurrent non-temporal bulk zeroing that exploits parallel hardware to move work off the application's critical path, and (3) adaptive zeroing, which dynamically chooses between (1) and (2) based on available hardware parallelism. The new software strategies offer speedups sometimes greater than the direct overhead, improving total performance by 3% on average. Our findings invite additional optimizations and microarchitectural support.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048092", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xi", + "last_name": "Yang", + "institution": "Australian National University" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Daniel", + "last_name": "Frampton", + "institution": "Australian National University" + }, + { + "first_name": "Jennifer B.", + "last_name": "Sartor", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/YangBFSM11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048094", + "title": "Trustworthy numerical computation in Scala", + "abstract": "Modern computing has adopted the floating point type as a default way to describe computations with real numbers. Thanks to dedicated hardware support, such computations are efficient on modern architectures, even in double precision. However, rigorous reasoning about the resulting programs remains difficult. This is in part due to a large gap between the finite floating point representation and the infinite-precision real-number semantics that serves as the developers' mental model. Because programming languages do not provide support for estimating errors, some computations in practice are performed more and some less precisely than needed.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048094", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eva", + "last_name": "Darulová", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/DarulovaK11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048099", + "title": "SugarJ: library-based syntactic language extensibility", + "abstract": "Existing approaches to extend a programming language with syntactic sugar often leave a bitter taste, because they cannot be used with the same ease as the main extension mechanism of the programming language - libraries. Sugar libraries are a novel approach for syntactically extending a programming language within the language. A sugar library is like an ordinary library, but can, in addition, export syntactic sugar for using the library. Sugar libraries maintain the composability and scoping properties of ordinary libraries and are hence particularly well-suited for embedding a multitude of domain-specific languages into a host language. They also inherit self-applicability from libraries, which means that sugar libraries can provide syntactic extensions for the definition of other sugar libraries. To demonstrate the expressiveness and applicability of sugar libraries, we have developed SugarJ, a language on top of Java, SDF and Stratego, which supports syntactic extensibility. SugarJ employs a novel incremental parsing technique, which allows changing the syntax within a source file. We demonstrate SugarJ by five language extensions, including embeddings of XML and closures in Java, all available as sugar libraries. We illustrate the utility of self-applicability by embedding XML Schema, a metalanguage to define XML languages.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048099", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Tillmann", + "last_name": "Rendel", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Christian", + "last_name": "Kästner", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Philipps University of Marburg" + } + ], + "dblp_key": "conf/oopsla/ErdwegRKO11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048098", + "title": "Hybrid partial evaluation", + "abstract": "Hybrid partial evaluation (HPE) is a pragmatic approach to partial evaluation that borrows ideas from both online and offline partial evaluation. HPE performs offline-style specialization using an online approach without static binding time analysis. The goal of HPE is to provide a practical and predictable level of optimization for programmers, with an implementation strategy that fits well within existing compilers or interpreters. HPE requires the programmer to specify where partial evaluation should be applied. It provides no termination guarantee and reports errors in situations that violate simple binding time rules, or have incorrect use of side effects in compile-time code. We formalize HPE for a small imperative object-oriented language and describe Civet, a straightforward implementation of HPE as a relatively simple extension of a Java compiler. Code optimized by Civet performs as well as the output of a state-of-the-art offline partial evaluator.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048098", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Amin", + "last_name": "Shali", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/ShaliC11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048096", + "title": "Immutable specifications for more concise and precise verification", + "abstract": "In the current work, we investigate the benefits of immutability guarantees for allowing more flexible handling of aliasing, as well as more precise and concise specifications. Our approach supports finer levels of control that can mark data structures as being immutable through the use of immutability annotations. By using such annotations to encode immutability guarantees, we expect to obtain better specifications that can more accurately describe the intentions, as well as prohibitions, of the method. Ultimately, our goal is improving the precision of the verification process, as well as making the specifications more readable, more precise and as an enforceable program documentation. We have designed and implemented a new entailment procedure to formally and automatically reason about immutability enhanced specifications. We have also formalised the soundness for our new procedure through an operational semantics with mutability assertions on the heap. Lastly, we have carried out a set of experiments to both validate and affirm the utility of our current proposal on immutability enhanced specification mechanism.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048096", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cristina", + "last_name": "David", + "institution": "National University of Singapore" + }, + { + "first_name": "Wei-Ngan", + "last_name": "Chin", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/oopsla/DavidC11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048100", + "title": "Reactive imperative programming with dataflow constraints", + "abstract": "Dataflow languages provide natural support for specifying constraints between objects in dynamic applications, where programs need to react efficiently to changes of their environment. Researchers have long investigated how to take advantage of dataflow constraints by embedding them into procedural languages. Previous mixed imperative/dataflow systems, however, require syntactic extensions or libraries of ad hoc data types for binding the imperative program to the dataflow solver. In this paper we propose a novel approach that smoothly combines the two paradigms without placing undue burden on the programmer. In our framework, programmers can define ordinary statements of the imperative host language that enforce constraints between objects stored in special memory locations designated as \"reactive\". Differently from previous approaches, reactive objects can be of any legal type in the host language, including primitive data types, pointers, arrays, and structures. Statements defining constraints are automatically re-executed every time their input memory locations change, letting a program behave like a spreadsheet where the values of some variables depend upon the values of other variables. The constraint solving mechanism is handled transparently by altering the semantics of elementary operations of the host language for reading and modifying objects. We provide a formal semantics and describe a concrete embodiment of our technique into C/C++, showing how to implement it efficiently in conventional platforms using off-the-shelf compilers. We discuss common coding idioms and relevant applications to reactive scenarios, including incremental computation, observer design pattern, and data structure repair. The performance of our implementation is compared to ad hoc problem-specific change propagation algorithms, as well as to language-centric approaches such as self-adjusting computation and subject/observer communication mechanisms, showing that the proposed approach is efficient in practice.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048100", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Camil", + "last_name": "Demetrescu", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Irene", + "last_name": "Finocchi", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Andrea", + "last_name": "Ribichini", + "institution": "Sapienza University of Rome" + } + ], + "dblp_key": "conf/oopsla/DemetrescuFR11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048106", + "title": "Oracle scheduling: controlling granularity in implicitly parallel languages", + "abstract": "A classic problem in parallel computing is determining whether to execute a task in parallel or sequentially. If small tasks are executed in parallel, the task-creation overheads can be overwhelming. If large tasks are executed sequentially, processors may spin idle. This granularity problem, however well known, is not well understood: broadly applicable solutions remain elusive.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048106", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Mike", + "last_name": "Rainey", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/oopsla/AcarCR11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048108", + "title": "Kismet: parallel speedup estimates for serial programs", + "abstract": "Software engineers now face the difficult task of refactoring serial programs for parallel execution on multicore processors. Currently, they are offered little guidance as to how much benefit may come from this task, or how close they are to the best possible parallelization. This paper presents Kismet, a tool that creates parallel speedup estimates for unparallelized serial programs. Kismet differs from previous approaches in that it does not require any manual analysis or modification of the program. This difference allows quick analysis of many programs, avoiding wasted engineering effort on those that are fundamentally limited. To accomplish this task, Kismet builds upon the hierarchical critical path analysis (HCPA) technique, a recently developed dynamic analysis that localizes parallelism to each of the potentially nested regions in the target program. It then uses a parallel execution time model to compute an approximate upper bound for performance, modeling constraints that stem from both hardware parameters and internal program structure.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048108", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dong‐Hwan", + "last_name": "Jeon", + "institution": "University of California, San Diego" + }, + { + "first_name": "Saturnino", + "last_name": "Garcia", + "institution": "University of California, San Diego" + }, + { + "first_name": "Chris", + "last_name": "Louie", + "institution": "University of California, San Diego" + }, + { + "first_name": "Michael", + "last_name": "Taylor", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/oopsla/JeonGLT11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048104", + "title": "Enhancing locality for recursive traversals of recursive structures", + "abstract": "While there has been decades of work on developing automatic, locality-enhancing transformations for regular programs that operate over dense matrices and arrays, there has been little investigation of such transformations for irregular programs, which operate over pointer-based data structures such as graphs, trees and lists. In this paper, we argue that, for a class of irregular applications we call traversal codes, there exists substantial data reuse and hence opportunity for locality exploitation. We develop a novel optimization called point blocking, inspired by the classic tiling loop transformation, and show that it can substantially enhance temporal locality in traversal codes. We then present a transformation and optimization framework called TreeTiler that automatically detects opportunities for applying point blocking and applies the transformation. TreeTiler uses autotuning techniques to determine appropriate parameters for the transformation. For a series of traversal algorithms drawn from real-world applications, we show that TreeTiler is able to deliver performance improvements of up to 245% over an optimized (but non-transformed) parallel baseline, and in several cases, significantly better scalability.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048104", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Youngjoon", + "last_name": "Jo", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/JoK11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048101", + "title": "Two for the price of one: a model for parallel and incremental computation", + "abstract": "Parallel or incremental versions of an algorithm can significantly outperform their counterparts, but are often difficult to develop. Programming models that provide appropriate abstractions to decompose data and tasks can simplify parallelization. We show in this work that the same abstractions can enable both parallel and incremental execution. We present a novel algorithm for parallel self-adjusting computation. This algorithm extends a deterministic parallel programming model (concurrent revisions) with support for recording and repeating computations. On record, we construct a dynamic dependence graph of the parallel computation. On repeat, we reexecute only parts whose dependencies have changed.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048101", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Caitlin", + "last_name": "Sadowski", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Jaeheon", + "last_name": "Yi", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/BurckhardtLSYB11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048105", + "title": "Flow-sensitive type recovery in linear-log time", + "abstract": "The flexibility of dynamically typed languages such as JavaScript, Python, Ruby, and Scheme comes at the cost of run-time type checks. Some of these checks can be eliminated via control-flow analysis. However, traditional control-flow analysis (CFA) is not ideal for this task as it ignores flow-sensitive information that can be gained from dynamic type predicates, such as JavaScript's 'instanceof' and Scheme's 'pair?', and from type-restricted operators, such as Scheme's 'car'. Yet, adding flow-sensitivity to a traditional CFA worsens the already significant compile-time cost of traditional CFA. This makes it unsuitable for use in just-in-time compilers. In response, we have developed a fast, flow-sensitive type-recovery algorithm based on the linear-time, flow-insensitive sub-0CFA. The algorithm has been implemented as an experimental optimization for the commercial Chez Scheme compiler, where it has proven to be effective, justifying the elimination of about 60% of run-time type checks in a large set of benchmarks. The algorithm processes on average over 100,000 lines of code per second and scales well asymptotically, running in only O(n log n) time. We achieve this compile-time performance and scalability through a novel combination of data structures and algorithms.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048105", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Andrew W.", + "last_name": "Keep", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Jan", + "last_name": "Midtgaard", + "institution": "Aarhus University" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "Arun", + "last_name": "Chauhan", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "R. Kent", + "last_name": "Dybvig", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/oopsla/AdamsKMMCD11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048111", + "title": "Scalable join patterns", + "abstract": "Coordination can destroy scalability in parallel programming. A comprehensive library of scalable synchronization primitives is therefore an essential tool for exploiting parallelism. Unfortunately, such primitives do not easily combine to yield solutions to more complex problems. We demonstrate that a concurrency library based on Fournet and Gonthier's join calculus can provide declarative and scalable coordination. By declarative, we mean that the programmer needs only to write down the constraints of a coordination problem, and the library will automatically derive a correct solution. By scalable, we mean that the derived solutions deliver robust performance both as the number of processors increases, and as the complexity of the coordination problem grows. We validate our claims empirically on seven coordination problems, comparing our generic solution to specialized algorithms from the literature.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048111", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Northeastern University" + }, + { + "first_name": "Claudio", + "last_name": "Russo", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/TuronR11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048114", + "title": "Gradual typing for generics", + "abstract": "Gradual typing is a framework to combine static and dynamic typing in a single programming language. In this paper, we develop a gradual type system for class-based object-oriented languages with generics. We introduce a special type to denote dynamically typed parts of a program; unlike dynamic types introduced to C# 4.0, however, our type system allows for more seamless integration of dynamically and statically typed code.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048114", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lintaro", + "last_name": "Ina", + "institution": "Kyoto University" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/oopsla/InaI11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048115", + "title": "A theory of substructural types and control", + "abstract": "Exceptions are invaluable for structured error handling in high-level languages, but they are at odds with linear types. More generally, control effects may delete or duplicate portions of the stack, which, if we are not careful, can invalidate all substructural usage guarantees for values on the stack. We have developed a type-and-effect system that tracks control effects and ensures that values on the stack are never wrongly duplicated or dropped. We present the system first with abstract control effects and prove its soundness. We then give examples of three instantiations with particular control effects, including exceptions and delimited continuations, and show that they meet the soundness criteria for specific control effects.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048115", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jesse A.", + "last_name": "Tov", + "institution": "Northeastern University" + }, + { + "first_name": "Riccardo", + "last_name": "Pucella", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/TovP11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048110", + "title": "Exploiting coarse-grain speculative parallelism", + "abstract": "Speculative execution at coarse granularities (e.g., code-blocks, methods, algorithms) offers a promising programming model for exploiting parallelism on modern architectures. In this paper we present Anumita, a framework that includes programming constructs and a supporting runtime system to enable the use of coarse-grain speculation to improve program performance, without burdening the programmer with the complexity of creating, managing and retiring speculations. Speculations may be composed by specifying surrogate code blocks at any arbitrary granularity, which are then executed concurrently, with a single winner ultimately modifying program state. Anumita provides expressive semantics for winner selection that go beyond time to solution to include user-defined notions of quality of solution. Anumita can be used to improve the performance of hard to parallelize algorithms whose performance is highly dependent on input data. Anumita is implemented as a user-level runtime with programming interfaces to C, C++, Fortran and as an OpenMP extension. Performance results from several applications show the efficacy of using coarse-grain speculation to achieve (a) robustness when surrogates fail and (b) significant speedup over static algorithm choices.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048110", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hari K.", + "last_name": "Pyla", + "institution": "Virginia Tech" + }, + { + "first_name": "Calvin J.", + "last_name": "Ribbens", + "institution": "Virginia Tech" + }, + { + "first_name": "Srinidhi", + "last_name": "Varadarajan", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/oopsla/PylaRV11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048113", + "title": "Product lines of theorems", + "abstract": "Mechanized proof assistants are powerful verification tools, but proof development can be difficult and time-consuming. When verifying a family of related programs, the effort can be reduced by proof reuse. In this paper, we show how to engineer product lines with theorems and proofs built from feature modules. Each module contains proof fragments which are composed together to build a complete proof of correctness for each product. We consider a product line of programming languages, where each variant includes metatheory proofs verifying the correctness of its semantic definitions. This approach has been realized in the Coq proof assistant, with the proofs of each feature independently certifiable by Coq. These proofs are composed for each language variant, with Coq mechanically verifying that the composite proofs are correct. As validation, we formalize a core calculus for Java in Coq which can be extended with any combination of casts, interfaces, or generics.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048113", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Don", + "last_name": "Batory", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/DelawareCB11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048109", + "title": "Efficiently speeding up sequential computation through the n-way programming model", + "abstract": "With core counts on the rise, the sequential components of applications are becoming the major bottleneck in performance scaling as predicted by Amdahl's law. We are therefore faced with the simultaneous problems of occupying an increasing number of cores and speeding up sequential sections. In this work, we reconcile these two seemingly incompatible problems with a novel programming model called N-way. The core idea behind N-way is to benefit from the algorithmic diversity available to express certain key computational steps. By simultaneously launching in parallel multiple ways to solve a given computation, a runtime can just-in-time pick the best (for example the fastest) way and therefore achieve speedup.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048109", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Romain", + "last_name": "Clédat", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Tushar", + "last_name": "Kumar", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/CledatKP11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048123", + "title": "Cedalion: a language for language oriented programming", + "abstract": "Language Oriented Programming (LOP) is a paradigm that puts domain specific programming languages (DSLs) at the center of the software development process. Currently, there are three main approaches to LOP: (1) the use of internal DSLs, implemented as libraries in a given host language; (2) the use of external DSLs, implemented as interpreters or compilers in an external language; and (3) the use of language workbenches, which are integrated development environments (IDEs) for defining and using external DSLs. In this paper, we contribute: (4) a novel language-oriented approach to LOP for defining and using internal DSLs. While language workbenches adapt internal DSL features to overcome some of the limitations of external DSLs, our approach adapts language workbench features to overcome some of the limitations of internal DSLs. We introduce Cedalion, an LOP host language for internal DSLs, featuring static validation and projectional editing. To validate our approach we present a case study in which Cedalion was used by biologists in designing a DNA microarray for molecular Biology research.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048123", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David H.", + "last_name": "Lorenz", + "institution": "Open University of Israel" + }, + { + "first_name": "Boaz", + "last_name": "Rosenan", + "institution": "Open University of Israel" + } + ], + "dblp_key": "conf/oopsla/LorenzR11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048126", + "title": "JIT compilation policy for modern machines", + "abstract": "Dynamic or Just-in-Time (JIT) compilation is crucial to achieve acceptable performance for applications (written in managed languages, such as Java and C#) distributed as intermediate language binary codes for a virtual machine (VM) architecture. Since it occurs at runtime, JIT compilation needs to carefully tune its compilation policy to make effective decisions regarding 'if' and 'when' to compile different program regions to achieve the best overall program performance. Past research has extensively tuned JIT compilation policies, but mainly for VMs with a single compiler thread and for execution on single-processor machines.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048126", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Prasad A.", + "last_name": "Kulkarni", + "institution": "University of Kansas" + } + ], + "dblp_key": "conf/oopsla/Kulkarni11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048122", + "title": "First-class state change in plaid", + "abstract": "Objects model the world, and state is fundamental to a faithful modeling. Engineers use state machines to understand and reason about state transitions, but programming languages provide little support for building software based on state abstractions. We propose Plaid, a language in which objects are modeled not just in terms of classes, but in terms of changing abstract states. Each state may have its own representation, as well as methods that may transition the object into a new state. A formal model precisely defines the semantics of core Plaid constructs such as state transition and trait-like state composition. We evaluate Plaid through a series of examples taken from the Plaid compiler and the standard libraries of Smalltalk and Java. These examples show how Plaid can more closely model state-based designs, enhancing understandability, enhancing dynamic error checking, and providing reuse benefits.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048122", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Sunshine", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Karl", + "last_name": "Naden", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sven", + "last_name": "Stork", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/oopsla/SunshineNSAT11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048119", + "title": "Automated construction of JavaScript benchmarks", + "abstract": "1 JavaScript is a highly dynamic language for web-based appli-cations. Innovative implementation techniques for improving its speed and responsiveness have been developed in recent years. In-dustry benchmarks such as WebKit SunSpider are often cited as a measure of the efficacy of these techniques. However, recent stud-ies have shown that these benchmarks fail to accurately represent the dynamic nature of modern JavaScript applications, and so may be poor predictors of real-world performance. Worse, they may guide the development of optimizations which are unhelpful for real applications. Our goal is to develop a tool and techniques to automate the creation of realistic and representative benchmarks from existing web applications. We propose a record-and-replay approach to capture JavaScript sessions which has sufficient fidelity to accurately recreate key characteristics of the original applica-tion, and at the same time is sufficiently flexible that a recording produced on one platform can be replayed on a different one. We describe JSBENCH, a flexible tool for workload capture and bench-mark generation, and demonstrate its use in creating eight bench-marks based on popular sites. Using a variety of runtime metrics collected with instrumented versions of Firefox, Internet Explorer, and Safari, we show that workloads created by JSBENCH match the behavior of the original web applications. 1.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048119", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gregor", + "last_name": "Richards", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Andreas", + "last_name": "Gal", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Brendan", + "last_name": "Eich", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/RichardsGEV11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048117", + "title": "Benefits and barriers of user evaluation in software engineering research", + "abstract": "In this paper, we identify trends about, benefits from, and barriers to performing user evaluations in software engineering research. From a corpus of over 3,000 papers spanning ten years, we report on various subtypes of user evaluations (e.g., coding tasks vs. questionnaires) and relate user evaluations to paper topics (e.g., debugging vs. technology transfer). We identify the external measures of impact, such as best paper awards and citation counts, that are correlated with the presence of user evaluations. We complement this with a survey of over 100 researchers from over 40 different universities and labs in which we identify a set of perceived barriers to performing user evaluations.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048117", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Raymond P.L.", + "last_name": "Buse", + "institution": "University of Virginia" + }, + { + "first_name": "Caitlin", + "last_name": "Sadowski", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Westley", + "last_name": "Weimer", + "institution": "University of Virginia" + } + ], + "dblp_key": "conf/oopsla/BuseSW11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048121", + "title": "Declaratively programming the mobile web with Mobl", + "abstract": "A new generation of mobile touch devices, such as the iPhone, iPad and Android devices, are equipped with powerful, modern browsers. However, regular websites are not optimized for the specific features and constraints of these devices, such as limited screen estate, unreliable Internet access, touch-based interaction patterns, and features such as GPS. While recent advances in web technology enable web developers to build web applications that take advantage of the unique properties of mobile devices, developing such applications exposes a number of problems, specifically: developers are required to use many loosely coupled languages with limited tool support and application code is often verbose and imperative. We introduce mobl, a new language designed to declaratively construct mobile web applications. Mobl integrates languages for user interface design, styling, data modeling, querying and application logic into a single, unified language that is flexible, expressive, enables early detection of errors, and has good IDE support.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048121", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zef", + "last_name": "Hemel", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/oopsla/HemelV11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048118", + "title": "Da capo con scala: design and analysis of a scala benchmark suite for the java virtual machine", + "abstract": "Originally conceived as the target platform for Java alone, the Java Virtual Machine (JVM) has since been targeted by other languages, one of which is Scala. This trend, however, is not yet reflected by the benchmark suites commonly used in JVM research. In this paper, we thus present the design and analysis of the first full-fledged benchmark suite for Scala. We furthermore compare the benchmarks contained therein with those from the well-known DaCapo 9.12 benchmark suite and show where the differences are between Scala and Java code---and where not.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048118", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Sewe", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Aibek", + "last_name": "Sarimbekov", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/oopsla/SeweMSB11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048124", + "title": "Self-adjusting stack machines", + "abstract": "Self-adjusting computation offers a language-based approach to writing programs that automatically respond to dynamically changing data. Recent work made significant progress in developing sound semantics and associated implementations of self-adjusting computation for high-level, functional languages. These techniques, however, do not address issues that arise for low-level languages, i.e., stack-based imperative languages that lack strong type systems and automatic memory management. In this paper, we describe techniques for self-adjusting computation which are suitable for low-level languages. Necessarily, we take a different approach than previous work: instead of starting with a high-level language with additional primitives to support self-adjusting computation, we start with a low-level intermediate language, whose semantics is given by a stack-based abstract machine. We prove that this semantics is sound: it always updates computations in a way that is consistent with full reevaluation. We give a compiler and runtime system for the intermediate language used by our abstract machine. We present an empirical evaluation that shows that our approach is efficient in practice, and performs favorably compared to prior proposals.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048124", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Georg", + "last_name": "Neis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Yan", + "last_name": "Chen", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/oopsla/HammerNCA11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048127", + "title": "Reducing trace selection footprint for large-scale Java applications without performance loss", + "abstract": "When optimizing large-scale applications, striking the balance between steady-state performance, start-up time, and code size has always been a grand challenge. While recent advances in trace compilation have significantly improved the steady-state performance of trace JITs for large-scale Java applications, the size control aspect of a trace compilation system remains largely overlooked. For instance, using the DaCapo 9.12 benchmarks, we observe that 40% of traces selected by a state-of-the-art trace selection algorithm are short-lived and, on average, each selected basic block is replicated 13 times in the trace cache.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048127", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peng", + "last_name": "Wu", + "institution": "IBM (United States)" + }, + { + "first_name": "Hiroshige", + "last_name": "Hayashizaki", + "institution": "IBM (United States)" + }, + { + "first_name": "Hiroshi", + "last_name": "Inoue", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/WuHIN11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048129", + "title": "Safe and atomic run-time code evolution for Java and its application to dynamic AOP", + "abstract": "Dynamic updates to running programs improve development productivity and reduce downtime of long-running applications. This feature is however severely limited in current virtual machines for object-oriented languages. In particular, changes to classes often apply only to methods invoked after a class change, but not to active methods on the call stack of threads. Additionally, adding and removing methods as well as fields is often not supported.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048129", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Würthinger", + "institution": "Johannes Kepler University of Linz" + }, + { + "first_name": "Danilo", + "last_name": "Ansaloni", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Christian", + "last_name": "Wimmer", + "institution": "University of California, Irvine" + }, + { + "first_name": "Hanspeter", + "last_name": "Mössenböck", + "institution": "Johannes Kepler University of Linz" + } + ], + "dblp_key": "conf/oopsla/WurthingerABWM11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048128", + "title": "Variability-aware parsing in the presence of lexical macros and conditional compilation", + "abstract": "In many projects, lexical preprocessors are used to manage different variants of the project (using conditional compilation) and to define compile-time code transformations (using macros). Unfortunately, while being a simple way to implement variability, conditional compilation and lexical macros hinder automatic analysis, even though such analysis is urgently needed to combat variability-induced complexity. To analyze code with its variability, we need to parse it without preprocessing it. However, current parsing solutions use unsound heuristics, support only a subset of the language, or suffer from exponential explosion. As part of the TypeChef project, we contribute a novel variability-aware parser that can parse almost all unpreprocessed code without heuristics in practicable time. Beyond the obvious task of detecting syntax errors, our parser paves the road for further analysis, such as variability-aware type checking. We implement variability-aware parsers for Java and GNU C and demonstrate practicability by parsing the product line MobileMedia and the entire X86 architecture of the Linux kernel with 6065 variable features.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048128", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christian", + "last_name": "Kästner", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Paolo G.", + "last_name": "Giarrusso", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Tillmann", + "last_name": "Rendel", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Thorsten", + "last_name": "Berger", + "institution": "Leipzig University" + } + ], + "dblp_key": "conf/oopsla/KastnerGREOB11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048131", + "title": "A simple abstraction for complex concurrent indexes", + "abstract": "Indexes are ubiquitous. Examples include associative arrays, dictionaries, maps and hashes used in applications such as databases, file systems and dynamic languages. Abstractly, a sequential index can be viewed as a partial function from keys to values. Values can be queried by their keys, and the index can be mutated by adding or removing mappings. Whilst appealingly simple, this abstract specification is insufficient for reasoning about indexes accessed concurrently. We present an abstract specification for concurrent indexes. We verify several representative concurrent client applications using our specification, demonstrating that clients can reason abstractly without having to consider specific underlying implementations. Our specification would, however, mean nothing if it were not satisfied by standard implementations of concurrent indexes. We verify that our specification is satisfied by algorithms based on linked lists, hash tables and B-Link trees. The complexity of these algorithms, in particular the B-Link tree algorithm, can be completely hidden from the client's view by our abstract specification.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048131", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pedro da Rocha", + "last_name": "Pinto", + "institution": "Imperial College London" + }, + { + "first_name": "Thomas", + "last_name": "Dinsdale-Young", + "institution": "Imperial College London" + }, + { + "first_name": "Mike", + "last_name": "Dodds", + "institution": "University of Cambridge" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + }, + { + "first_name": "Mark", + "last_name": "Wheelhouse", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/PintoDDGW11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048132", + "title": "Composable, nestable, pessimistic atomic statements", + "abstract": "In this paper we introduce a new method for pessimistically implementing composable, nestable atomic statements. Our mechanism, called shelters, is inspired by the synchronization strategy used in the Jade programming language. Unlike previous lock-based pessimistic approaches, our mechanism does not require a whole-program analysis that computes a global lock order. Further, this mechanism frees us to implement several optimizations, impossible with automatically inserted locks, that are necessary for scaling on recent multi-core systems. Additionally we show how our basic mechanism can be extended to support both open- and closed-nesting of atomic statements, something that, to our knowledge, has not yet been implemented fully-pessimistically in this context. Unlike optimistic, transactional-memory-based approaches, programmers using our mechanism do not have to write compensating actions for open-nesting, or worry about the possibly awkward semantics and performance impact of aborted transactions.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048132", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Anderson", + "institution": "ETH Zurich" + }, + { + "first_name": "David", + "last_name": "Gay", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/oopsla/AndersonG11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048133", + "title": "Delegated isolation", + "abstract": "Isolation---the property that a task can access shared data without interference from other tasks---is one of the most basic concerns in parallel programming. In this paper, we present Aida, a new model of isolated execution for parallel programs that perform frequent, irregular accesses to pointer-based shared data structures. The three primary benefits of Aida are dynamism, safety and liveness guarantees, and programmability. First, Aida allows tasks to dynamically select and modify, in an isolated manner, arbitrary fine-grained regions in shared data structures, all the while maintaining a high level of concurrency. Consequently, the model can achieve scalable parallelization of regular as well as irregular shared-memory applications. Second, the model offers freedom from data races, deadlocks, and livelocks. Third, no extra burden is imposed on programmers, who access the model via a simple, declarative isolation construct that is similar to that for transactional memory. The key new insight in Aida is a notion of delegation among concurrent isolated tasks (known in Aida as assemblies). Each assembly A is equipped with a region in the shared heap that it owns---the only objects accessed by A are those it owns, guaranteeing race-freedom. The region owned by A can grow or shrink flexibly---however, when A needs to own a datum owned by B, A delegates itself, as well as its owned region, to B. From now on, B has the responsibility of re-executing the task A set out to complete. Delegation as above is the only inter-assembly communication primitive in Aida. In addition to reducing contention in a local, data-driven manner, it guarantees freedom from deadlocks and livelocks.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048133", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roberto", + "last_name": "Lublinerman", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Jisheng", + "last_name": "Zhao", + "institution": "Rice University" + }, + { + "first_name": "Zoran", + "last_name": "Budimlić", + "institution": "Rice University" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/LublinermanZBCS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048134", + "title": "AC: composable asynchronous IO for native languages", + "abstract": "This paper introduces AC, a set of language constructs for composable asynchronous IO in native languages such as C/C++. Unlike traditional synchronous IO interfaces, AC lets a thread issue multiple IO requests so that they can be serviced concurrently, and so that long-latency operations can be overlapped with computation. Unlike traditional asynchronous IO interfaces, AC retains a sequential style of programming without requiring code to use multiple threads, and without requiring code to be \"stack-ripped\" into chains of callbacks. AC provides an \"async\" statement to identify opportunities for IO operations to be issued concurrently, a \"do..finish\" block that waits until any enclosed \"async\" work is complete, and a \"cancel\" statement that requests cancellation of unfinished IO within an enclosing \"do..finish\". We give an operational semantics for a core language. We describe and evaluate implementations that are integrated with message passing on the Barrelfish research OS, and integrated with asynchronous file and network IO on Microsoft Windows. We show that AC offers comparable performance to existing C/C++ interfaces for asynchronous IO, while providing a simpler programming model.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048134", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tim", + "last_name": "Harris", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Rebecca", + "last_name": "Isaacs", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ross", + "last_name": "McIlroy", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/oopsla/HarrisAIM11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048145", + "title": "F4F: taint analysis of framework-based web applications", + "abstract": "This paper presents F4F (Framework For Frameworks), a system for effective taint analysis of framework-based web applications. Most modern web applications utilize one or more web frameworks, which provide useful abstractions for common functionality. Due to extensive use of reflective language constructs in framework implementations, existing static taint analyses are often ineffective when applied to framework-based applications. While previous work has included ad hoc support for certain framework constructs, adding support for a large number of frameworks in this manner does not scale from an engineering standpoint.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048145", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Shay", + "last_name": "Artzi", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Marco", + "last_name": "Pistoia", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Salvatore", + "last_name": "Guarnieri", + "institution": "IBM (United States)" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "IBM (United States)" + }, + { + "first_name": "Ryan", + "last_name": "Berg", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/SridharanAPGTB11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048137", + "title": "Backstage Java: making a difference in metaprogramming", + "abstract": "We propose Backstage Java (BSJ), a Java language extension which allows algorithmic, contextually-aware generation and transformation of code. BSJ explicitly and concisely represents design patterns and other encodings by employing compile-time metaprogramming: a practice in which the programmer writes instructions which are executed over the program's AST during compilation. While compile-time metaprogramming has been successfully used in functional languages such as Template Haskell, a number of language properties (scope, syntactic structure, mutation, etc.) have thus far prevented this theory from translating to the imperative world. BSJ uses the novel approach of difference-based metaprogramming to provide an imperative programming style amenable to the Java community and to enforce that metaprograms are consistent and semantically unambiguous. To make the feasibility of BSJ metaprogramming evident, we have developed a compiler implementation and numerous working code examples.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048137", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Palmer", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/oopsla/PalmerS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048136", + "title": "Virtual values for language extension", + "abstract": "This paper focuses on extensibility, the ability of a programmer using a particular language to extend the expressiveness of that language. This paper explores how to provide an interesting notion of extensibility by virtualizing the interface between code and data. A virtual value is a special value that supports behavioral intercession. When a primitive operation is applied to a virtual value, it invokes a trap on that virtual value. A virtual value contains multiple traps, each of which is a user-defined function that describes how that operation should behave on that value. This paper formalizes the semantics of virtual values, and shows how they enable the definition of a variety of language extensions, including additional numeric types; delayed evaluation; taint tracking; contracts; revokable membranes; and units of measure. We report on our experience implementing virtual values for Javascript within an extension for the Firefox browser.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048136", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas H.", + "last_name": "Austin", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Tim", + "last_name": "Disney", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/oopsla/AustinDF11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048140", + "title": "Type checking modular multiple dispatch with parametric polymorphism and multiple inheritance", + "abstract": "In previous work, we presented rules for defining overloaded functions that ensure type safety under symmetric multiple dispatch in an object-oriented language with multiple inheritance, and we showed how to check these rules without requiring the entire type hierarchy to be known, thus supporting modularity and extensibility. In this work, we extend these rules to a language that supports parametric polymorphism on both classes and functions.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048140", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric E.", + "last_name": "Allen", + "institution": "Oracle (United States)" + }, + { + "first_name": "Justin", + "last_name": "Hilburn", + "institution": "Oracle (United States)" + }, + { + "first_name": "Scott E.", + "last_name": "Kilpatrick", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Victor", + "last_name": "Luchangco", + "institution": "Oracle (United States)" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "David", + "last_name": "Chase", + "institution": "Oracle (United States)" + }, + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/oopsla/AllenHKLRCS11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048138", + "title": "Flexible object layouts: enabling lightweight language extensions by intercepting slot access", + "abstract": "Programming idioms, design patterns and application libraries often introduce cumbersome and repetitive boilerplate code to a software system. Language extensions and external DSLs (domain specific languages) are sometimes introduced to reduce the need for boilerplate code, but they also complicate the system by introducing the need for language dialects and inter-language mediation. To address this, we propose to extend the structural reflective model of the language with object layouts, layout scopes and slots. Based on the new reflective language model we can 1) provide behavioral hooks to object layouts that are triggered when the fields of an object are accessed and 2) simplify the implementation of state-related language extensions such as stateful traits. By doing this we show how many idiomatic use cases that normally require boilerplate code can be more effectively supported.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048138", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "T.", + "last_name": "Verwaest", + "institution": "University of Bern" + }, + { + "first_name": "Camillo", + "last_name": "Bruni", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Mircea", + "last_name": "Lungu", + "institution": "" + }, + { + "first_name": "Oscar", + "last_name": "Nierstrasz", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/VerwaestBLN11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048142", + "title": "Freedom before commitment: a lightweight type system for object initialisation", + "abstract": "One of the main purposes of object initialisation is to establish invariants such as a field being non-null or an immutable data structure containing specific values. These invariants are then implicitly assumed by the rest of the implementation, for instance, to ensure that a field may be safely dereferenced or that immutable data may be accessed concurrently. Consequently, letting an object escape from its constructor is dangerous; the escaping object might not yet satisfy its invariants, leading to errors in code that relies on them. Nevertheless, preventing objects entirely from escaping from their constructors is too restrictive; it is often useful to call auxiliary methods on the object under initialisation or to pass it to another constructor to set up mutually-recursive structures.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048142", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "ETH Zurich" + }, + { + "first_name": "Peter", + "last_name": "Mueller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/SummersM11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048141", + "title": "A syntactic type system for recursive modules", + "abstract": "A practical type system for ML-style recursive modules should address at least two technical challenges. First, it needs to solve the double vision problem, which refers to an inconsistency between external and internal views of recursive modules. Second, it needs to overcome the tension between practical decidability and expressivity which arises from the potential presence of cyclic type definitions caused by recursion between modules. Although type systems in previous proposals solve the double vision problem and are also decidable, they fail to typecheck common patterns of recursive modules, such as functor fixpoints, that are essential to the expressivity of the module system and the modular development of recursive modules. This paper proposes a novel type system for recursive modules that solves the double vision problem and typechecks common patterns of recursive modules including functor fixpoints. First, we design a type system with a type equivalence based on weak bisimilarity, which does not lend itself to practical implementation in general, but accommodates a broad range of cyclic type definitions. Then, we identify a practically implementable fragment using a type equivalence based on type normalization, which is expressive enough to typecheck typical uses of recursive modules. Our approach is purely syntactic and the definition of the type system is ready for use in an actual implementation.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048141", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hyeonseung", + "last_name": "Im", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Keiko", + "last_name": "Nakata", + "institution": "Tallinn University of Technology" + }, + { + "first_name": "Jacques", + "last_name": "Garrigue", + "institution": "Nagoya University" + }, + { + "first_name": "Sungwoo", + "last_name": "Park", + "institution": "Pohang University of Science and Technology" + } + ], + "dblp_key": "conf/oopsla/ImNGP11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048144", + "title": "Null dereference verification via over-approximated weakest pre-conditions analysis", + "abstract": "Null dereferences are a bane of programming in languages such as Java. In this paper we propose a sound, demand-driven, inter-procedurally context-sensitive dataflow analysis technique to verify a given dereference as safe or potentially unsafe. Our analysis uses an abstract lattice of formulas to find a pre-condition at the entry of the program such that a null-dereference can occur only if the initial state of the program satisfies this pre-condition. We use a simplified domain of formulas, abstracting out integer arithmetic, as well as unbounded access paths due to recursive data structures. For the sake of precision we model aliasing relationships explicitly in our abstract lattice, enable strong updates, and use a limited notion of path sensitivity. For the sake of scalability we prune formulas continually as they get propagated, reducing to true conjuncts that are less likely to be useful in validating or invalidating the formula. We have implemented our approach, and present an evaluation of it on a set of ten real Java programs. Our results show that the set of design features we have incorporated enable the analysis to (a) explore long, inter-procedural paths to verify each dereference, with (b) reasonable accuracy, and (c) very quick response time per dereference, making it suitable for use in desktop development environments.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048144", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ravichandhran", + "last_name": "Madhavan", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Raghavan", + "last_name": "Komondoor", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/oopsla/MadhavanK11", + "venue": "oopsla", + "year": 2011 + }, + { + "paper_id": "10.1145/2048066.2048146", + "title": "RoleCast: finding missing security checks when you do not know what checks are", + "abstract": "Web applications written in languages such as PHP and JSP are notoriously vulnerable to accidentally omitted authorization checks and other security bugs. Existing techniques that find missing security checks in library and system code assume that (1) security checks can be recognized syntactically and (2) the same pattern of checks applies universally to all programs. These assumptions do not hold for Web applications. Each Web application uses different variables and logic to check the user's permissions. Even within the application, security logic varies based on the user's role, e.g., regular users versus administrators. This paper describes ROLECAST, the first system capable of statically identifying security logic that mediates security-sensitive events (such as database writes) in Web applications, rather than taking a specification of this logic as input. We observe a consistent software engineering pattern-the code that implements distinct user role functionality and its security logic resides in distinct methods and files-and develop a novel algorithm for discovering this pattern in Web applications. Our algorithm partitions the set of file contexts (a coarsening of calling contexts) on which security-sensitive events are control dependent into roles. Roles are based on common functionality and security logic. ROLECAST identifies security-critical variables and applies rolespecific variable consistency analysis to find missing security checks. ROLECAST discovered 13 previously unreported, remotely exploitable vulnerabilities in 11 substantial PHP and JSP applications, with only 3 false positives.", + "date": "2011-10-22", + "link": "https://doi.org/10.1145/2048066.2048146", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sooel", + "last_name": "Son", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vitaly", + "last_name": "Shmatikov", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/SonMS11", + "venue": "oopsla", + "year": 2011 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2012.json b/data/pl_conferences/oopsla/2012.json new file mode 100644 index 0000000..f0c570b --- /dev/null +++ b/data/pl_conferences/oopsla/2012.json @@ -0,0 +1,1789 @@ +[ + { + "paper_id": "10.1145/2384616.2384618", + "title": "Type-based safe resource deallocation for shared-memory concurrency", + "abstract": "We propose a type system to guarantee safe resource deallocation for shared-memory concurrent programs by extending the previous type system based on fractional ownerships. Here, safe resource deallocation means that memory cells, locks, or threads are not left allocated when a program terminates. Our framework supports (1) fork/join parallelism, (2) synchronization with locks, and (3) dynamically allocated memory cells and locks. The type system is proved to be sound. We also provide a type inference algorithm for the type system and a prototype implementation of the algorithm.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384618", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kohei", + "last_name": "Suenaga", + "institution": "Kyoto University" + }, + { + "first_name": "R.", + "last_name": "Fukuda", + "institution": "Kyoto University" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/oopsla/SuenagaFI12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384624", + "title": "Reducing the barriers to writing verified specifications", + "abstract": "Formally verifying a program requires significant skill not only because of complex interactions between program subcomponents, but also because of deficiencies in current verification interfaces. These skill barriers make verification economically unattractive by preventing the use of less-skilled (less-expensive) workers and distributed workflows (i.e., crowdsourcing). This paper presents VeriWeb, a web-based IDE for verification that decomposes the task of writing verifiable specifications into manageable subproblems. To overcome the information loss caused by task decomposition, and to reduce the skill required to verify a program, VeriWeb incorporates several innovative user interface features: drag and drop condition construction, concrete counterexamples, and specification inlining.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384624", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Todd W.", + "last_name": "Schiller", + "institution": "University of Washington" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SchillerE12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384628", + "title": "Mitigating the compiler optimization phase-ordering problem using machine learning", + "abstract": "Today's compilers have a plethora of optimizations to choose from, and the correct choice of optimizations can have a significant impact on the performance of the code being optimized. Furthermore, choosing the correct order in which to apply those optimizations has been a long standing problem in compilation research. Each of these optimizations interacts with the code and in turn with all other optimizations in complicated ways. Traditional compilers typically apply the same set of optimization in a fixed order to all functions in a program, without regard the code being optimized.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384628", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sameer G.", + "last_name": "Kulkarni", + "institution": "University of Delaware" + }, + { + "first_name": "John", + "last_name": "Cavazos", + "institution": "University of Delaware" + } + ], + "dblp_key": "conf/oopsla/KulkarniC12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384623", + "title": "Predicate abstraction of Java programs with collections", + "abstract": "Our goal is to develop precise and scalable verification techniques for Java programs that use collections and properties that depend on their content. We apply the popular approach of predicate abstraction to Java programs and collections. The main challenge in this context is precise and compact modeling of collections that enables practical verification. We define a predicate language for modeling the observable state of Java collections at the interface level. Changes of the state by API methods are captured by weakest preconditions. We adapt existing techniques for construction of abstract programs. Most notably, we designed optimizations based on specific features of the predicate language. We evaluated our approach on Java programs that use collections in advanced ways. Our results show that interesting properties, such as consistency between multiple collections, can be verified using our approach. The properties are specified using logic formulas that involve predicates introduced by our language.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384623", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Parízek", + "institution": "University of Waterloo" + }, + { + "first_name": "OndYej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/oopsla/ParizekL12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384621", + "title": "Towards a practical secure concurrent language", + "abstract": "We demonstrate that a practical concurrent language can be extended in a natural way with information security mechanisms that provably enforce strong information security guarantees. We extend the X10 concurrent programming language with coarse-grained information-flow control. Central to X10 concurrency abstractions is the notion of a place: a container for data and computation. We associate a security level with each place, and restrict each place to store only data appropriate for that security level. When places interact only with other places at the same security level, then our security mechanisms impose no restrictions. When places of differing security levels interact, our information security analysis prevents potentially dangerous information flows, including information flow through covert scheduling channels. The X10 concurrency mechanisms simplify reasoning about information flow in concurrent programs. We present a static analysis that enforces a noninterference-based extensional information security condition in a calculus that captures the key aspects of X10's place abstraction and async-finish parallelism. We extend this security analysis to support many of X10's language features, and have implemented a prototype compiler for the resulting language.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384621", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stefan K.", + "last_name": "Muller", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/oopsla/MullerC12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384626", + "title": "Modular and verified automatic program repair", + "abstract": "We study the problem of suggesting code repairs at design time, based on the warnings issued by modular program verifiers. We introduce the concept of a verified repair, a change to a program's source that removes bad execution traces while increasing the number of good traces, where the bad/good traces form a partition of all the traces of a program. Repairs are property-specific. We demonstrate our framework in the context of warnings produced by the modular cccheck (a.k.a. Clousot) abstract interpreter, and generate repairs for missing contracts, incorrect locals and objects initialization, wrong conditionals, buffer overruns, arithmetic overflow and incorrect floating point comparisons. We report our experience with automatically generating repairs for the .NET framework libraries, generating verified repairs for over 80% of the warnings generated by cccheck.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384626", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Thomas", + "last_name": "Ball", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/LogozzoB12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384620", + "title": "Safe compiler-driven transaction checkpointing and recovery", + "abstract": "Several studies have shown that a large fraction of the work performed inside memory transactions in representative programs is wasted due to the transaction experiencing a conflict and aborting. Aborts inside long running transactions are especially influential to performance and the simplicity of the TM programming model (relative to using finegrained locking) in synchronizing large critical sections means that large transactions are common and this exacerbates the problem of wasted work. In this paper we present a practical transaction checkpoint and recovery scheme in which transactions that experience a conflict can restore their state (including the local context in which they were executing) to some dynamic program point before this access and begin execution from that point. This state saving and restoration is implemented by checkpoint operations that are generated by a compiler into the transaction's body and are also optimized to reduce the amount of state that is saved and restored. We also describe a runtime system that manages these checkpointed states and orchestrates the restoration of the right checkpointed state for a conflict on a particular transactional access. Moreover the synthesis of these save and restore operations, their optimization and invocation at runtime are completely transparent to the programmer. We have implemented the checkpoint generation and optimization scheme in the LLVM compiler and runtime support for the TL2 STM system. Our experiments indicate that for many parallel programs using such checkpoint recovery schemes can result in upto several orders of magnitude reduction in number of aborts and significant execution time speedups relative to plain transactional programs for the same number of threads.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384620", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jaswanth", + "last_name": "Sreeram", + "institution": "Intel (United States)" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/SreeramP12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384629", + "title": "Optimization coaching: optimizers learn to communicate with programmers", + "abstract": "Optimizing compilers map programs in high-level languages to high-performance target language code. To most programmers, such a compiler constitutes an impenetrable black box whose inner workings are beyond their understanding. Since programmers often must understand the workings of their compilers to achieve their desired performance goals, they typically resort to various forms of reverse engineering, such as examining compiled code or intermediate forms. Instead, optimizing compilers should engage programmers in a dialog. This paper introduces one such possible form of dialog: optimization coaching. An optimization coach watches while a program is compiled, analyzes the results, generates suggestions for enabling further compiler optimization in the source program, and presents a suitable synthesis of its results to the programmer. We present an evaluation based on case studies, which illustrate how an optimization coach can help programmers achieve optimizations resulting in substantial performance improvements.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384629", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vincent", + "last_name": "St-Amour", + "institution": "Northeastern University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/St-AmourTF12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384635", + "title": "Kitsune: efficient, general-purpose dynamic software updating for C", + "abstract": "Dynamic software updating (DSU) systems allow programs to be updated while running, thereby permitting developers to add features and fix bugs without downtime. This paper introduces Kitsune, a new DSU system for C whose design has three notable features. First, Kitsune's updating mechanism updates the whole program, not individual functions. This mechanism is more flexible than most prior approaches and places no restrictions on data representations or allowed compiler optimizations. Second, Kitsune makes the important aspects of updating explicit in the program text, making the program's semantics easy to understand while minimizing programmer effort. Finally, the programmer can write simple specifications to direct Kitsune to generate code that traverses and transforms old-version state for use by new code; such state transformation is often necessary, and is significantly more difficult in prior DSU systems. We have used Kitsune to update five popular, open-source, single- and multi-threaded programs, and find that few program changes are required to use Kitsune, and that it incurs essentially no performance overhead.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384635", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christopher M.", + "last_name": "Hayden", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Edward K.", + "last_name": "Smith", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michail", + "last_name": "Denchev", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/HaydenSDHF12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384625", + "title": "GPUVerify: a verifier for GPU kernels", + "abstract": "We present a technique for verifying race- and divergence-freedom of GPU kernels that are written in mainstream kernel programming languages such as OpenCL and CUDA. Our approach is founded on a novel formal operational semantics for GPU programming termed synchronous, delayed visibility (SDV) semantics. The SDV semantics provides a precise definition of barrier divergence in GPU kernels and allows kernel verification to be reduced to analysis of a sequential program, thereby completely avoiding the need to reason about thread interleavings, and allowing existing modular techniques for program verification to be leveraged. We describe an efficient encoding for data race detection and propose a method for automatically inferring loop invariants required for verification. We have implemented these techniques as a practical verification tool, GPUVerify, which can be applied directly to OpenCL and CUDA source code. We evaluate GPUVerify with respect to a set of 163 kernels drawn from public and commercial sources. Our evaluation demonstrates that GPUVerify is capable of efficient, automatic verification of a large number of real-world kernels.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384625", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adam", + "last_name": "Betts", + "institution": "Imperial College London" + }, + { + "first_name": "Nathan", + "last_name": "Chong", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Paul", + "last_name": "Thomson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/BettsCDQT12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384631", + "title": "On the benefits and pitfalls of extending a statically typed language JIT compiler for dynamic scripting languages", + "abstract": "Whenever the need to compile a new dynamically typed language arises, an appealing option is to repurpose an existing statically typed language Just-In-Time (JIT) compiler (repurposed JIT compiler). Existing repurposed JIT compilers (RJIT compilers), however, have not yet delivered the hoped-for performance boosts. The performance of JVM languages, for instance, often lags behind standard interpreter implementations. Even more customized solutions that extend the internals of a JIT compiler for the target language compete poorly with those designed specifically for dynamically typed languages. Our own Fiorano JIT compiler is an example of this problem. As a state-of-the-art, RJIT compiler for Python, the Fiorano JIT compiler outperforms two other RJIT compilers (Unladen Swallow and Jython), but still shows a noticeable performance gap compared to PyPy, today's best performing Python JIT compiler. In this paper, we discuss techniques that have proved effective in the Fiorano JIT compiler as well as limitations of our current implementation. More importantly, this work offers the first in-depth look at benefits and limitations of the repurposed JIT compiler approach. We believe the most common pitfall of existing RJIT compilers is not focusing sufficiently on specialization, an abundant optimization opportunity unique to dynamically typed languages. Unfortunately, the lack of specialization cannot be overcome by applying traditional optimizations.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384631", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "José G.", + "last_name": "Castaños", + "institution": "IBM (United States)" + }, + { + "first_name": "David", + "last_name": "Edelsohn", + "institution": "IBM (United States)" + }, + { + "first_name": "Kazuaki", + "last_name": "Ishizaki", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Priya", + "last_name": "Nagpurkar", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Takeshi", + "last_name": "Ogasawara", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Peng", + "last_name": "Wu", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/CastanosEINNOW12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384619", + "title": "Uniqueness and reference immutability for safe parallelism", + "abstract": "A key challenge for concurrent programming is that side-effects (memory operations) in one thread can affect the behavior of another thread. In this paper, we present a type system to restrict the updates to memory to prevent these unintended side-effects. We provide a novel combination of immutable and unique (isolated) types that ensures safe parallelism (race freedom and deterministic execution). The type system includes support for polymorphism over type qualifiers, and can easily create cycles of immutable objects. Key to the system's flexibility is the ability to recover immutable or externally unique references after violating uniqueness without any explicit alias tracking. Our type system models a prototype extension to C# that is in active use by a Microsoft team. We describe their experiences building large systems with this extension. We prove the soundness of the type system by an embedding into a program logic.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384619", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "University of Washington" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Jared", + "last_name": "Parsons", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aleks", + "last_name": "Bromfield", + "institution": "Microsoft (United States)" + }, + { + "first_name": "J.M.", + "last_name": "Duffy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/GordonPPBD12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384634", + "title": "Refactoring android Java code for on-demand computation offloading", + "abstract": "Computation offloading is a promising way to improve the performance as well as reducing the battery power consumption of a smartphone application by executing some parts of the application on a remote server. Supporting such capability is not easy for smartphone application developers due to (1) correctness: some code, e.g., that for GPS, gravity, and other sensors, can run only on the smartphone so that developers have to identify which parts of the application cannot be offloaded; (2) effectiveness: the reduced execution time must be greater than the network delay caused by computation offloading so that developers need to calculate which parts are worth offloading; (3) adaptability: smartphone applications often face changes of user requirements and runtime environments so that developers need to implement the adaptation on offloading. More importantly, considering the large number of today's smartphone applications, solutions applicable for legacy applications will be much more valuable. In this paper, we present a tool, named DPartner, that automatically refactors Android applications to be the ones with computation offloading capability. For a given Android application, DPartner first analyzes its bytecode for discovering the parts worth offloading, then rewrites the bytecode to implement a special program structure supporting on-demand offloading, and finally generates two artifacts to be deployed onto an Android phone and the server, respectively. We evaluated DPartner on three real-world Android applications, demonstrating the reduction of execution time by 46%-97% and battery power consumption by 27%-83%.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384634", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ying", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Gang", + "last_name": "Huang", + "institution": "Institute of Software" + }, + { + "first_name": "Xuanzhe", + "last_name": "Liu", + "institution": "Institute of Software" + }, + { + "first_name": "Wei", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Hong", + "last_name": "Mei", + "institution": "Institute of Software" + }, + { + "first_name": "Shunxiang", + "last_name": "Yang", + "institution": "Peking University" + } + ], + "dblp_key": "conf/oopsla/Zhang0LZMY12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384636", + "title": "Automating object transformations for dynamic software updating", + "abstract": "Dynamic software updating (DSU) systems eliminate costly downtime by dynamically fixing bugs and adding features to executing programs. Given a static code patch, most DSU systems construct runtime code changes automatically. However, a dynamic update must also specify how to change the running program's execution state, e.g., the stack and heap, to make it compatible with the new code. Constructing such state transformations correctly and automatically remains an open problem. This paper presents a solution called Targeted Object Synthesis (TOS). TOS first executes the same tests on the old and new program versions separately, observing the program heap state at a few corresponding points. Given two corresponding heap states, TOS matches objects in the two versions using key fields that uniquely identify objects and correlate old and new-version objects. Given example object pairs, TOS then synthesizes the simplest-possible function that transforms an old-version object to its new-version counterpart. We show that TOS is effective on updates to four open-source server programs for which it generates non-trivial transformation functions that use conditionals, operate on collections, and fix memory leaks. These transformations help programmers understand their changes and apply dynamic software updates.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384636", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "S.", + "last_name": "Magill", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Suriya", + "last_name": "Subramanian", + "institution": "Intel (United States)" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/MagillHSM12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384633", + "title": "An abstract interpretation framework for refactoring with application to extract methods with contracts", + "abstract": "Method extraction is a common refactoring feature provided by most modern IDEs. It replaces a user-selected piece of code with a call to an automatically generated method. We address the problem of automatically inferring contracts (precondition, postcondition) for the extracted method. We require the inferred contract: (a) to be valid for the extracted method (validity); (b) to guard the language and programmer assertions in the body of the extracted method by an opportune precondition (safety); (c) to preserve the proof of correctness of the original code when analyzing the new method separately (completeness); and (d) to be the most general possible (generality). These requirements rule out trivial solutions (e.g., inlining, projection, etc). We propose two theoretical solutions to the problem. The first one is simple and optimal. It is valid, safe, complete and general but unfortunately not effectively computable (except for unrealistic finiteness/decidability hypotheses). The second one is based on an iterative forward/backward method. We show it to be valid, safe, and, under reasonable assumptions, complete and general. We prove that the second solution subsumes the first. All justifications are provided with respect to a new, set-theoretic version of Hoare logic (hence without logic), and abstractions of Hoare logic, revisited to avoid surprisingly unsound inference rules.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384633", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" + }, + { + "first_name": "Radhia", + "last_name": "Cousot", + "institution": "Laboratoire de Géologie de l’École Normale Supérieure" + }, + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Michael P.", + "last_name": "Barnett", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/CousotCLB12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384630", + "title": "Adaptive multi-level compilation in a trace-based Java JIT compiler", + "abstract": "This paper describes our multi-level compilation techniques implemented in a trace-based Java JIT compiler (trace-JIT). Like existing multi-level compilation for method-based compilers, we start JIT compilation with a small compilation scope and a low optimization level so the program can start running quickly. Then we identify hot paths with a timer-based sampling profiler, generate long traces that capture the hot paths, and recompile them with a high optimization level to improve the peak performance. A key to high performance is selecting long traces that effectively capture the entire hot paths for upgrade recompilations. To do this, we introduce a new technique to generate a directed graph representing the control flow, a TTgraph, and use the TTgraph in the trace selection engine to efficiently select long traces. We show that our multi-level compilation improves the peak performance of programs by up to 58.5% and 22.2% on average compared to compiling all of the traces only at a low optimization level. Comparing the performance with our multi-level compilation to the performance when compiling all of the traces at a high optimization level, our technique can reduce the startup times of programs by up to 61.1% and 31.3% on average without significant reduction in the peak performance. Our results show that our adaptive multi-level compilation can balance the peak performance and startup time by taking advantage of different optimization levels.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384630", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hiroshi", + "last_name": "Inoue", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Hiroshige", + "last_name": "Hayashizaki", + "institution": "IBM Research - Tokyo" + }, + { + "first_name": "Peng", + "last_name": "Wu", + "institution": "IBM (United States)" + }, + { + "first_name": "Toshio", + "last_name": "Nakatani", + "institution": "IBM Research - Tokyo" + } + ], + "dblp_key": "conf/oopsla/InoueHWN12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384640", + "title": "Molecule: using monadic and streaming I/O to compose process networks on the JVM", + "abstract": "Molecule is a domain specific language library embedded in Scala for easing the creation of scalable and modular concurrent applications on the JVM. Concurrent applications are modeled as parallel process networks that exchange information over mobile and type-safe messaging interfaces. In this paper, we present a concurrent programming environment that combines functional and imperative programming. Using a monad, we structure the sequential or parallel coordination of user-level threads, without JVM modifications or compiler support. Our mobile channel interfaces expose reusable and parallelizable higher-order functions, as if they were streams in a lazily evaluated functional programming language. The support for graceful termination of entire process networks is simplified by integrating channel poisoning with monadic exceptions and resource control. Our runtime and system-level interfaces leverage message batching and a novel flow parallel scheduler to limit expensive context switches in multicore environments. We illustrate the expressiveness and performance benefits on a 24-core AMD Opteron machine with three classical examples: a thread ring, a genuine prime sieve and a chameneos-redux.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384640", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sébastien", + "last_name": "Bocq", + "institution": "Nokia (United States)" + }, + { + "first_name": "Koen", + "last_name": "Daenen", + "institution": "Nokia (United States)" + } + ], + "dblp_key": "conf/oopsla/BocqD12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384638", + "title": "Exploring multi-threaded Java application performance on multicore hardware", + "abstract": "While there have been many studies of how to schedule applications to take advantage of increasing numbers of cores in modern-day multicore processors, few have focused on multi-threaded managed language applications which are prevalent from the embedded to the server domain. Managed languages complicate performance studies because they have additional virtual machine threads that collect garbage and dynamically compile, closely interacting with application threads. Further complexity is introduced as modern multicore machines have multiple sockets and dynamic frequency scaling options, broadening opportunities to reduce both power and running time.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384638", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jennfer B.", + "last_name": "Sartor", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University Hospital" + } + ], + "dblp_key": "conf/oopsla/SartorE12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384639", + "title": "Work-stealing without the baggage", + "abstract": "Work-stealing is a promising approach for effectively exploiting software parallelism on parallel hardware. A programmer who uses work-stealing explicitly identifies potential parallelism and the runtime then schedules work, keeping otherwise idle hardware busy while relieving overloaded hardware of its burden. Prior work has demonstrated that work-stealing is very effective in practice. However, work-stealing comes with a substantial overhead: as much as 2x to 12x slowdown over orthodox sequential code.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384639", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vivek", + "last_name": "Kumar", + "institution": "Australian National University" + }, + { + "first_name": "Daniel", + "last_name": "Frampton", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "David", + "last_name": "Grove", + "institution": "" + }, + { + "first_name": "Olivier", + "last_name": "Tardieu", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/KumarFBGT12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384644", + "title": "Elixir: a system for synthesizing concurrent graph programs", + "abstract": "Algorithms in new application areas like machine learning and network analysis use \"irregular\" data structures such as graphs, trees and sets. Writing efficient parallel code in these problem domains is very challenging because it requires the programmer to make many choices: a given problem can usually be solved by several algorithms, each algorithm may have many implementations, and the best choice of algorithm and implementation can depend not only on the characteristics of the parallel platform but also on properties of the input data such as the structure of the graph. One solution is to permit the application programmer to experiment with different algorithms and implementations without writing every variant from scratch. Auto-tuning to find the best variant is a more ambitious solution. These solutions require a system for automatically producing efficient parallel implementations from high-level specifications. Elixir, the system described in this paper, is the first step towards this ambitious goal. Application programmers write specifications that consist of an operator, which describes the computations to be performed, and a schedule for performing these computations. Elixir uses sophisticated inference techniques to produce efficient parallel code from such specifications.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384644", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dimitrios", + "last_name": "Prountzos", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Roman", + "last_name": "Manevich", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/PrountzosMP12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384648", + "title": "Bolt: on-demand infinite loop escape in unmodified binaries", + "abstract": "We present Bolt, a novel system for escaping from infinite and long-running loops. Directed by a user, Bolt can attach to a running process and determine if the program is executing an infinite loop. If so, Bolt can deploy multiple strategies to escape the loop, restore the responsiveness of the program, and enable the program to deliver useful output.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384648", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Kling", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/KlingMCR12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384653", + "title": "Taming MATLAB", + "abstract": "MATLAB is a dynamic scientific language used by scientists, engineers and students worldwide. Although MATLAB is very suitable for rapid prototyping and development, MATLAB users often want to convert their final MATLAB programs to a static language such as FORTRAN. This paper presents an extensible object-oriented toolkit for supporting the generation of static programs from dynamic MATLAB programs. Our open source toolkit, called the MATLAB Tamer, identifies a large tame subset of MATLAB, supports the generation of a specialized Tame IR for that subset, provides a principled approach to handling the large number of builtin MATLAB functions, and supports an extensible interprocedural value analysis for estimating MATLAB types and call graphs.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384653", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anton", + "last_name": "Dubrau", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/oopsla/DubrauH12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384655", + "title": "Higher-order symbolic execution via contracts", + "abstract": "We present a new approach to automated reasoning about higher-order programs by extending symbolic execution to use behavioral contracts as symbolic values, thus enabling symbolic approximation of higher-order behavior.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384655", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Northeastern University" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/Tobin-HochstadtH12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384649", + "title": "LEAN: simplifying concurrency bug reproduction via replay-supported execution reduction", + "abstract": "Debugging concurrent programs is known to be difficult due to scheduling non-determinism. The technique of multiprocessor deterministic replay substantially assists debugging by making the program execution reproducible. However, facing the huge replay traces and long replay time, the debugging task remains stunningly challenging for long running executions. We present a new technique, LEAN, on top of replay, that significantly reduces the complexity of the replay trace and the length of the replay time without losing the determinism in reproducing concurrency bugs. The cornerstone of our work is a redundancy criterion that characterizes the redundant computation in a buggy trace. Based on the redundancy criterion, we have developed two novel techniques to automatically identify and remove redundant threads and instructions in the bug reproduction execution. Our evaluation results with several real world concurrency bugs in large complex server programs demonstrate that LEAN is able to reduce the size, the number of threads, and the number of thread context switches of the replay trace by orders of magnitude, and accordingly greatly shorten the replay time.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384649", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/oopsla/HuangZ12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384651", + "title": "Maple: a coverage-driven testing tool for multithreaded programs", + "abstract": "Testing multithreaded programs is a hard problem, because it is challenging to expose those rare interleavings that can trigger a concurrency bug. We propose a new thread interleaving coverage-driven testing tool called Maple that seeks to expose untested thread interleavings as much as possible. It memoizes tested interleavings and actively seeks to expose untested interleavings for a given test input to increase interleaving coverage. We discuss several solutions to realize the above goal. First, we discuss a coverage metric based on a set of interleaving idioms. Second, we discuss an online technique to predict untested interleavings that can potentially be exposed for a given test input. Finally, the predicted untested interleavings are exposed by actively controlling the thread schedule while executing for the test input. We discuss our experiences in using the tool to expose several known and unknown bugs in real-world applications such as Apache and MySQL.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384651", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jie", + "last_name": "Yu", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Cristiano", + "last_name": "Pereira", + "institution": "Intel (United States)" + }, + { + "first_name": "Gilles", + "last_name": "Pokam", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/oopsla/YuNPP12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384641", + "title": "A black-box approach to understanding concurrency in DaCapo", + "abstract": "Increasing levels of hardware parallelism are one of the main challenges for programmers and implementers of managed runtimes. Any concurrency or scalability improvements must be evaluated experimentally. However, application benchmarks available today may not reflect the highly concurrent applications we anticipate in the future. They may also behave in ways that VM developers do not expect. We provide a set of platform independent concurrency related metrics and an in-depth observational study of current state of the art benchmarks, discovering how concurrent they really are, how they scale the work and how they synchronise and communicate via shared memory.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384641", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tomáš", + "last_name": "Kalibera", + "institution": "University of Kent" + }, + { + "first_name": "Matthew", + "last_name": "Mole", + "institution": "University of Kent" + }, + { + "first_name": "Richard", + "last_name": "Jones", + "institution": "University of Kent" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/KaliberaMJV12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384645", + "title": "From clarity to efficiency for distributed algorithms", + "abstract": "This paper describes a very high-level language for clear description of distributed algorithms and optimizations necessary for generating efficient implementations. The language supports high-level control flows where complex synchronization conditions can be expressed using high-level queries, especially logic quantifications, over message history sequences. Unfortunately, the programs would be extremely inefficient, including consuming unbounded memory, if executed straightforwardly.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384645", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yanhong A.", + "last_name": "Liu", + "institution": "State University of New York" + }, + { + "first_name": "Scott D.", + "last_name": "Stoller", + "institution": "Stony Brook University" + }, + { + "first_name": "Bo", + "last_name": "Lin", + "institution": "State University of New York" + }, + { + "first_name": "Michael", + "last_name": "Gorbovitski", + "institution": "State University of New York" + } + ], + "dblp_key": "conf/oopsla/LiuSLG12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384643", + "title": "Automatically enhancing locality for tree traversals with traversal splicing", + "abstract": "Generally applicable techniques for improving temporal locality in irregular programs, which operate over pointer-based data structures such as trees and graphs, are scarce. Focusing on a subset of irregular programs, namely, tree traversal algorithms like Barnes-Hut and nearest neighbor, previous work has proposed point blocking, a technique analogous to loop tiling in regular programs, to improve locality. However point blocking is highly dependent on point sorting, a technique to reorder points so that consecutive points will have similar traversals. Performing this a priori sort requires an understanding of the semantics of the algorithm and hence highly application specific techniques. In this work, we propose traversal splicing, a new, general, automatic locality optimization for irregular tree traversal codes, that is less sensitive to point order, and hence can deliver substantially better performance, even in the absence of semantic information. For six benchmark algorithms, we show that traversal splicing can deliver single-thread speedups of up to 9.147 (geometric mean: 3.095) over baseline implementations, and up to 4.752 (geometric mean: 2.079) over point-blocked implementations. Further, we show that in many cases, automatically applying traversal splicing to a baseline implementation yields performance that is better than carefully hand-optimized implementations.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384643", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Youngjoon", + "last_name": "Jo", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/JoK12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384646", + "title": "Program extrapolation with jennisys", + "abstract": "The desired behavior of a program can be described using an abstract model. Compiling such a model into executable code requires advanced compilation techniques known as synthesis. This paper presents an object-based language, called Jennisys, where programming is done by introducing an abstract model, defining a concrete data representation for the model, and then being aided by automatic synthesis to produce executable code. The paper also presents a synthesis technique for the language. The technique is built on an automatic program verifier that, via an underlying SMT solver, is capable of providing concrete models to failed verifications. The technique proceeds by obtaining sample input/output values from concrete models and then extrapolating programs from the sample points. The synthesis aims to produce code with assignments, branching structure, and possibly recursive calls. It is the first to synthesize code that creates and uses objects in dynamic data structures or aggregate objects. A prototype of the language and synthesis technique has been implemented.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384646", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "K. Rustan M.", + "last_name": "Leino", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aleksandar", + "last_name": "Milićević", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/LeinoM12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384650", + "title": "IFRit: interference-free regions for dynamic data-race detection", + "abstract": "We propose a new algorithm for dynamic data-race detection. Our algorithm reports no false positives and runs on arbitrary C and C++ code. Unlike previous algorithms, we do not have to instrument every memory access or track a full happens-before relation. Our data-race detector, which we call IFRit, is based on a run-time abstraction called an interference-free region (IFR). An IFR is an interval of one thread's execution during which any write to a specific variable by a different thread is a data race. We insert instrumentation at compile time to monitor active IFRs at run-time. If the runtime observes overlapping IFRs for conflicting accesses to the same variable in two different threads, it reports a race. The static analysis aggregates information for multiple accesses to the same variable, avoiding the expense of having to instrument every memory access in the program.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384650", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Laura", + "last_name": "Effinger-Dean", + "institution": "University of Washington" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Hewlett-Packard (United States)" + } + ], + "dblp_key": "conf/oopsla/Effinger-DeanLCGB12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384659", + "title": "Dependent types for JavaScript", + "abstract": "We present Dependent JavaScript (DJS), a statically typed dialect of the imperative, object-oriented, dynamic language. DJS supports the particularly challenging features such as run-time type-tests, higher-order functions, extensible objects, prototype inheritance, and arrays through a combination of nested refinement types, strong updates to the heap, and heap unrolling to precisely track prototype hierarchies. With our implementation of DJS, we demonstrate that the type system is expressive enough to reason about a variety of tricky idioms found in small examples drawn from several sources, including the popular book JavaScript: The Good Parts and the SunSpider benchmark suite.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384659", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of California, San Diego" + }, + { + "first_name": "David", + "last_name": "Herman", + "institution": "Mozilla Foundation" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/oopsla/ChughHJ12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384654", + "title": "Scaling symbolic execution using ranged analysis", + "abstract": "This paper introduces a novel approach to scale symbolic execution --- a program analysis technique for systematic exploration of bounded execution paths---for test input generation. While the foundations of symbolic execution were developed over three decades ago, recent years have seen a real resurgence of the technique, specifically for systematic bug finding. However, scaling symbolic execution remains a primary technical challenge due to the inherent complexity of the path-based exploration that lies at core of the technique.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384654", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Junaid Haroon", + "last_name": "Siddiqui", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/SiddiquiK12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384656", + "title": "Checking reachability using matching logic", + "abstract": "This paper presents a verification framework that is parametric in a (trusted) operational semantics of some programming language. The underlying proof system is language-independent and consists of eight proof rules. The proof system is proved partially correct and relatively complete (with respect to the programming language configuration model). To show its practicality, the generic framework is instantiated with a fragment of C and evaluated with encouraging results.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384656", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Andrei", + "last_name": "Ștefănescu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/RosuS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384661", + "title": "Formal specification of a JavaScript module system", + "abstract": "The JavaScript programming language, originally developed as a simple scripting language, is now the language of choice for web applications. All the top 100 sites on the web use JavaScript and its use outside web pages is rapidly growing. However, JavaScript is not yet ready for programming in the large: it does not support a module system. Lack of namespaces introduces module patterns, and makes it difficult to use multiple JavaScript frameworks together.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384661", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Seong-Hoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "conf/oopsla/KangR12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384660", + "title": "Eval begone!: semi-automated removal of eval from javascript programs", + "abstract": "International audience", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384660", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fadi", + "last_name": "Meawad", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Gregor", + "last_name": "Richards", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Floréal", + "last_name": "Morandat", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/MeawadRMV12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384668", + "title": "Software data-triggered threads", + "abstract": "The data-triggered threads (DTT) programming and execution model can increase parallelism and eliminate redundant computation. However, the initial proposal requires significant architecture support, which impedes existing applications and architectures from taking advantage of this model. This work proposes a pure software solution that supports the DTT model without any hardware support. This research uses a prototype compiler and runtime libraries running on top of existing machines. Several enhancements to the initial software implementation are presented, which further improve the performance.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384668", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hung‐Wei", + "last_name": "Tseng", + "institution": "University of California, San Diego" + }, + { + "first_name": "Dean M.", + "last_name": "Tullsen", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/oopsla/TsengT12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384658", + "title": "The HipHop compiler for PHP", + "abstract": "Scripting languages are widely used to quickly accomplish a variety of tasks because of the high productivity they enable. Among other reasons, this increased productivity results from a combination of extensive libraries, fast development cycle, dynamic typing, and polymorphism. The dynamic features of scripting languages are traditionally associated with interpreters, which is the approach used to implement most scripting languages. Although easy to implement, interpreters are generally slow, which makes scripting languages prohibitive for implementing large, CPU-intensive applications. This efficiency problem is particularly important for PHP given that it is the most commonly used language for server-side web development. This paper presents the design, implementation, and an evaluation of the HipHop compiler for PHP. HipHop goes against the standard practice and implements a very dynamic language through static compilation. After describing the most challenging PHP features to support through static compilation, this paper presents HipHop's design and techniques that support almost all PHP features. We then present a thorough evaluation of HipHop running both standard benchmarks and the Facebook web site. Overall, our experiments demonstrate that HipHop is about 5.5x faster than standard, interpreted PHP engines. As a result, HipHop has reduced the number of servers needed to run Facebook and other web sites by a factor between 4 and 6, thus drastically cutting operating costs.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384658", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haiping", + "last_name": "Zhao", + "institution": "Meta (United States)" + }, + { + "first_name": "Iain", + "last_name": "Proctor", + "institution": "Meta (United States)" + }, + { + "first_name": "Minghui", + "last_name": "Yang", + "institution": "Meta (United States)" + }, + { + "first_name": "Xin", + "last_name": "Qi", + "institution": "Meta (United States)" + }, + { + "first_name": "Mark", + "last_name": "Williams", + "institution": "Meta (United States)" + }, + { + "first_name": "Qi", + "last_name": "Gao", + "institution": "Menlo School" + }, + { + "first_name": "Guilherme", + "last_name": "Ottoni", + "institution": "Meta (United States)" + }, + { + "first_name": "Andrew", + "last_name": "Paroski", + "institution": "Menlo School" + }, + { + "first_name": "Scott", + "last_name": "MacVicar", + "institution": "Menlo School" + }, + { + "first_name": "J. L.", + "last_name": "Evans", + "institution": "Meta (United States)" + }, + { + "first_name": "Stephen", + "last_name": "Tu", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ZhaoPYQWGOPMET12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384669", + "title": "Efficiently combining parallel software using fine-grained, language-level, hierarchical resource management policies", + "abstract": "This paper presents Poli-C, a language extension, runtime library, and system daemon enabling fine-grained, language-level, hierarchical resource management policies. Poli-C is suitable for use in applications that compose parallel libraries, frameworks, and programs. In particular, we have added a powerful new statement to C for expressing resource limits and guarantees in such a way that programmers can set resource management policies even when the source code of parallel libraries and frameworks is not available. Poli-C enables application programmers to manage any resource exposed by the underlying OS, for example cores or IO bandwidth. Additionally, we have developed a domain-specific language for defining high-level resource management policies, and a facility for extending the kinds of resources that can be managed with our language extension. Finally, through a number of useful variations, our design offers a high degree of composability. We evaluate Poli-C by way of three case-studies: a scientific application, an image processing webserver, and a pair of parallel database join implementations. We found that using Poli-C yields efficiency gains that require the addition of only a few lines of code to applications.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384669", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Anderson", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/Anderson12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384665", + "title": "Speculative analysis of integrated development environment recommendations", + "abstract": "Modern integrated development environments make recommendations and automate common tasks, such as refactorings, auto-completions, and error corrections. However, these tools present little or no information about the consequences of the recommended changes. For example, a rename refactoring may: modify the source code without changing program semantics; modify the source code and (incorrectly) change program semantics; modify the source code and (incorrectly) create compilation errors; show a name collision warning and require developer input; or show an error and not change the source code. Having to compute the consequences of a recommendation -- either mentally or by making source code changes -- puts an extra burden on the developers. This paper aims to reduce this burden with a technique that informs developers of the consequences of code transformations. Using Eclipse Quick Fix as a domain, we describe a plug-in, Quick Fix Scout, that computes the consequences of Quick Fix recommendations. In our experiments, developers completed compilation-error removal tasks 10% faster when using Quick Fix Scout than Quick Fix, although the sample size was not large enough to show statistical significance.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384665", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kıvanç", + "last_name": "Muşlu", + "institution": "University of Washington" + }, + { + "first_name": "Yuriy", + "last_name": "Brun", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Reid", + "last_name": "Holmes", + "institution": "University of Waterloo" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + }, + { + "first_name": "David", + "last_name": "Notkin", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/MusluBHEN12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384664", + "title": "Talk versus work: characteristics of developer collaboration on the jazz platform", + "abstract": "IBM's Jazz initiative offers a state-of-the-art collaborative development environment (CDE) facilitating developer interactions around interdependent units of work. In this paper, we analyze development data across two versions of a major IBM product developed on the Jazz platform, covering in total 19 months of development activity, including 17,000+ work items and 61,000+ comments made by more than 190 developers in 35 locations. By examining the relation between developer talk and work, we find evidence that developers maintain a reasonably high level of connectivity with peer developers with whom they share work dependencies, but the span of a developer's communication goes much beyond the known dependencies of his/her work items. Using multiple linear regression models, we find that the number of defects owned by a developer is impacted by the number of other developers (s)he is connected through talk, his/her interpersonal influence in the network of work dependencies, the number of work items (s)he comments on, and the number work items (s)he owns. These effects are maintained even after controlling for workload, role, work dependency, and connection related factors. We discuss the implications of our results for collaborative software development and project governance.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384664", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Subhajit", + "last_name": "Datta", + "institution": "IBM Research - India" + }, + { + "first_name": "Renuka", + "last_name": "Sindhgatta", + "institution": "IBM Research - India" + }, + { + "first_name": "Bikram", + "last_name": "Sengupta", + "institution": "IBM Research - India" + } + ], + "dblp_key": "conf/oopsla/DattaSS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384663", + "title": "AutoMan: a platform for integrating human-based and digital computation", + "abstract": "Humans can perform many tasks with ease that remain difficult or impossible for computers. Crowdsourcing platforms like Amazon's Mechanical Turk make it possible to harness human-based computational power at an unprecedented scale. However, their utility as a general-purpose computational platform remains limited. The lack of complete automation makes it difficult to orchestrate complex or interrelated tasks. Scheduling more human workers to reduce latency costs real money, and jobs must be monitored and rescheduled when workers fail to complete their tasks. Furthermore, it is often difficult to predict the length of time and payment that should be budgeted for a given task. Finally, the results of human-based computations are not necessarily reliable, both because human skills and accuracy vary widely, and because workers have a financial incentive to minimize their effort.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384663", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel W.", + "last_name": "Barowy", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Charlie", + "last_name": "Curtsinger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Andrew", + "last_name": "McGregor", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/BarowyCBM12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384676", + "title": "Energy types", + "abstract": "This paper presents a novel type system to promote and facilitate energy-aware programming. Energy Types is built upon a key insight into today's energy-efficient systems and applications: despite the popular perception that energy and power can only be described in joules and watts, real-world energy management is often based on discrete phases and modes, which in turn can be reasoned about by type systems very effectively. A phase characterizes a distinct pattern of program workload, and a mode represents an energy state the program is expected to execute in. This paper describes a programming model where phases and modes can be intuitively specified by programmers or inferred by the compiler as type information. It demonstrates how a type-based approach to reasoning about phases and modes can help promote energy efficiency. The soundness of our type system and the invariants related to inter-phase and inter-mode interactions are rigorously proved. Energy Types is implemented as the core of a prototyped object-oriented language ET for smartphone programming. Preliminary studies show ET can lead to significant energy savings for Android Apps.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384676", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael E.", + "last_name": "Cohen", + "institution": "Binghamton University" + }, + { + "first_name": "Haitao", + "last_name": "Zhu", + "institution": "Binghamton University" + }, + { + "first_name": "Emgin Ezgi", + "last_name": "Senem", + "institution": "Binghamton University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + } + ], + "dblp_key": "conf/oopsla/CohenZSL12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384666", + "title": "An empirical study of the influence of static type systems on the usability of undocumented software", + "abstract": "Abstract Although the study of static and dynamic type systems plays a major role in research, relatively little is known about the impact of type systems on software development. Perhaps one of the more common arguments for static type systems in languages such as Java or C++ is that they require developers to annotate their code with type names, which is thus claimed to improve the documentation of software. In contrast, one common argument against static type systems is that they decrease flexibility, which may make them harder to use. While these arguments are found in the literature, rigorous empirical evidence is lacking. We report on a controlled experiment where 27 subjects performed programming tasks on an undocumented API with a static type system (requiring type annotations) as well as a dynamic type system (which does not). Our results show that for some tasks, programmers had faster completion times using a static type system, while for others, the opposite held. We conduct an exploratory study to try and theorize why.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384666", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Clemens", + "last_name": "Mayer", + "institution": "University of Duisburg-Essen" + }, + { + "first_name": "Stefan", + "last_name": "Hanenberg", + "institution": "University of Duisburg-Essen" + }, + { + "first_name": "Romain", + "last_name": "Robbes", + "institution": "University of Chile" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Andreas", + "last_name": "Stefik", + "institution": "Southern Illinois University Edwardsville" + } + ], + "dblp_key": "conf/oopsla/MayerHRTS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384670", + "title": "Execution privatization for scheduler-oblivious concurrent programs", + "abstract": "Making multithreaded execution less non-deterministic is a promising solution to address the difficulty of concurrent programming plagued by the non-deterministic thread scheduling. In fact, a vast category of concurrent programs are scheduler-oblivious: their execution is deterministic, regardless of the scheduling behavior. We present and formally prove a fundamental observation of the privatizability property for scheduler-oblivious programs, that paves the theoretical foundation for privatizing shared data accesses on a path segment. With privatization, the non-deterministic thread interleavings on the privatized accesses are isolated and as the consequence many concurrency problems are alleviated. We further present a path and context sensitive privatization algorithm that safely privatizes the program without introducing any additional program behavior. Our evaluation results show that the privatization opportunity pervasively exists in real world large complex concurrent systems. Through privatization, several real concurrency bugs are fixed and notable performance improvements are also achieved on benchmarks.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384670", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/oopsla/HuangZ12a", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384671", + "title": "Integrating task parallelism with actors", + "abstract": "This paper introduces a unified concurrent programming model combining the previously developed Actor Model (AM) and the task-parallel Async-Finish Model (AFM). With the advent of multi-core computers, there is a renewed interest in programming models that can support a wide range of parallel programming patterns. The proposed unified model shows how the divide-and-conquer approach of the AFM and the no-shared mutable state and event-driven philosophy of the AM can be combined to solve certain classes of problems more efficiently and productively than either of the aforementioned models individually. The unified model adds actor creation and coordination to the AFM, while also enabling parallelization within actors. This paper describes two implementations of the unified model as extensions of Habanero-Java and Habanero-Scala. The unified model adds to the foundations of parallel programs, and to the tools available for the programmer to aid in productivity and performance while developing parallel software.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384671", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shams", + "last_name": "Imam", + "institution": "Rice University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/ImamS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384674", + "title": "Gradual typing for first-class classes", + "abstract": "Dynamic type-checking and object-oriented programming often go hand-in-hand; scripting languages such as Python, Ruby, and JavaScript all embrace object-oriented (OO) programming. When scripts written in such languages grow and evolve into large programs, the lack of a static type discipline reduces maintainability. A programmer may thus wish to migrate parts of such scripts to a sister language with a static type system. Unfortunately, existing type systems neither support the flexible OO composition mechanisms found in scripting languages nor accommodate sound interoperation with untyped code. In this paper, we present the design of a gradual typing system that supports sound interaction between statically- and dynamically-typed units of class-based code. The type system uses row polymorphism for classes and thus supports mixin-based OO composition. To protect migration of mixins from typed to untyped components, the system employs a novel form of contracts that partially seal classes. The design comes with a theorem that guarantees the soundness of the type system even in the presence of untyped components.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384674", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Asumu", + "last_name": "Takikawa", + "institution": "Northeastern University" + }, + { + "first_name": "T. Stephen", + "last_name": "Strickland", + "institution": "Northeastern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northeastern University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/TakikawaSDTF12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384673", + "title": "A variability-aware module system", + "abstract": "Module systems enable a divide and conquer strategy to software development. To implement compile-time variability in software product lines, modules can be composed in different combinations. However, this way, variability dictates a dominant decomposition. As an alternative, we introduce a variability-aware module system that supports compile-time variability inside a module and its interface. So, each module can be considered a product line that can be type checked in isolation. Variability can crosscut multiple modules. The module system breaks with the antimodular tradition of a global variability model in product-line development and provides a path toward software ecosystems and product lines of product lines developed in an open fashion. We discuss the design and implementation of such a module system on a core calculus and provide an implementation for C as part of the TypeChef project. Our implementation supports variability inside modules from #ifdef preprocessor directives and variable linking at the composition level. With our implementation, we type check all configurations of all modules of the open source product line Busybox with 811~compile-time options, perform linker check of all configurations, and report found type and linker errors -- without resorting to a brute-force strategy.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384673", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christian", + "last_name": "Kästner", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Philipps University of Marburg" + } + ], + "dblp_key": "conf/oopsla/KastnerOE12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384675", + "title": "Constrained kinds", + "abstract": "Modern object-oriented languages such as X10 require a rich framework for types capable of expressing both value-dependency and genericity, and supporting pluggable, domain-specific extensions. In earlier work, we presented a framework for constrained types in object-oriented languages, parametrized by an underlying constraint system. Types are viewed as formulas C{c} where C is the name of a class or an interface and c is a constraint on the immutable instance state (the properties) of C. Constraint systems are a very expressive framework for partial information. Many (value-)dependent type systems for object-oriented languages can be viewed as constrained types.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384675", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Tardieu", + "institution": "IBM (United States)" + }, + { + "first_name": "Nathaniel", + "last_name": "Nystrom", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Igor", + "last_name": "Peshansky", + "institution": "Google (United States)" + }, + { + "first_name": "Vijay", + "last_name": "Saraswat", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/TardieuNPS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384679", + "title": "k-Calling context profiling", + "abstract": "Calling context trees are one of the most fundamental data structures for representing the interprocedural control flow of a program, providing valuable information for program understanding and optimization. Nodes of a calling context tree associate performance metrics to whole distinct paths in the call graph starting from the root function. However, no explicit information is provided for detecting short hot sequences of activations, which may be a better optimization target in large modular programs where groups of related functions are reused in many different parts of the code. Furthermore, calling context trees can grow prohibitively large in some scenarios. Another classical approach, called edge profiling, collects performance metrics for caller-callee pairs in the call graph, allowing it to detect hot paths of fixed length one. We study a generalization of edge and context-sensitive profiles by introducing a novel data structure called k-calling context forest (k-CCF). Nodes in a k-CCF associate performance metrics to paths of length at most k that lead to each distinct routine of the program, providing edge profiles for k=1, full context-sensitive profiles for k equal to infinity, as well as any other intermediate point in the spectrum. We study the properties of the k-CCF both theoretically and experimentally on a large suite of prominent Linux applications, showing how to construct it efficiently and discussing its relationships with the calling context tree. Our experiments show that the k-CCF can provide effective space-accuracy tradeoffs for interprocedural contextual profiling, yielding useful clues to the hot spots of a program that may be hidden in a calling context tree and using less space for small values of k, which appear to be the most interesting in practice.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384679", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Giorgio", + "last_name": "Ausiello", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Camil", + "last_name": "Demetrescu", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Irene", + "last_name": "Finocchi", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Donatella", + "last_name": "Firmani", + "institution": "Sapienza University of Rome" + } + ], + "dblp_key": "conf/oopsla/AusielloDFF12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384680", + "title": "Reim & ReImInfer: checking and inference of reference immutability and method purity", + "abstract": "Reference immutability ensures that a reference is not used to modify the referenced object, and enables the safe sharing of object structures. A pure method does not cause side-effects on the objects that existed in the pre-state of the method execution. Checking and inference of reference immutability and method purity enables a variety of program analyses and optimizations. We present ReIm, a type system for reference immutability, and ReImInfer, a corresponding type inference analysis. The type system is concise and context-sensitive. The type inference analysis is precise and scalable, and requires no manual annotations. In addition, we present a novel application of the reference immutability type system: method purity inference.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384680", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wei", + "last_name": "Huang", + "institution": "Rensselaer Polytechnic Institute" + }, + { + "first_name": "Ana", + "last_name": "Milanova", + "institution": "Rensselaer Polytechnic Institute" + }, + { + "first_name": "Werner", + "last_name": "Dietl", + "institution": "University of Washington" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/HuangMDE12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384678", + "title": "Exploiting inter-sequence correlations for program behavior prediction", + "abstract": "Prediction of program dynamic behaviors is fundamental to program optimizations, resource management, and architecture reconfigurations. Most existing predictors are based on locality of program behaviors, subject to some inherent limitations. In this paper, we revisit the design philosophy and systematically explore a second source of clues: statistical correlations between the behavior sequences of different program entities. Concentrated on loops, it examines the correlations' existence, strength, and values in enhancing the design of program behavior predictors. It creates the first taxonomy of program behavior sequence patterns. It develops a new form of predictors, named sequence predictors, to effectively translate the correlations into large-scope, proactive predictions of program behavior sequences. It demonstrates the usefulness of the prediction in dynamic version selection and loop importance estimation, showing 19% average speedup on a number of real-world utility applications. By taking scope and timing of behavior prediction as the first-order design objectives, the new approach overcomes limitations of existing program behavior predictors, opening up many new opportunities for runtime optimizations at various layers of computing.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384678", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bo", + "last_name": "Wu", + "institution": "William & Mary" + }, + { + "first_name": "Zhijia", + "last_name": "Zhao", + "institution": "William & Mary" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "Williams (United States)" + }, + { + "first_name": "Yunlian", + "last_name": "Jiang", + "institution": "Google (United States)" + }, + { + "first_name": "Yaoqing", + "last_name": "Gao", + "institution": "IBM (Canada)" + }, + { + "first_name": "Raúl", + "last_name": "Silvera", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/oopsla/WuZSJGS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384685", + "title": "Chaperones and impersonators: run-time support for reasonable interposition", + "abstract": "Chaperones and impersonators provide run-time support for interposing on primitive operations such as function calls, array access and update, and structure field access and update. Unlike most interposition support, chaperones and impersonators are restricted so that they constrain the behavior of the interposing code to reasonable interposition, which in practice preserves the abstraction mechanisms and reasoning that programmers and compiler analyses rely on.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384685", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "T. Stephen", + "last_name": "Strickland", + "institution": "Northeastern University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Northeastern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/oopsla/StricklandTFF12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384688", + "title": "Understanding the behavior of database operations under program control", + "abstract": "Applications that combine general program logic with persistent databases (e.g., three-tier applications) often suffer large performance penalties from poor use of the database. We introduce a program analysis technique that combines information flow in the program with commutativity analysis of its database operations to produce a unified dependency graph for database statements, which provides programmers with a high-level view of how costly database operations are and how they are connected in the program. As an example application of our analysis we describe three optimizations that can be discovered by examining the structure of the dependency graph; each helps remove communication latency from the critical path of a multi-tier system. We implement our technique in a tool for Java applications using JDBC and experimentally validate it using the multi-tier component of the Dacapo benchmark.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384688", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Juan M.", + "last_name": "Tamayo", + "institution": "Stanford Medicine" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford Medicine" + }, + { + "first_name": "Nathan", + "last_name": "Bronson", + "institution": "Stanford Medicine" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/oopsla/TamayoABS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384681", + "title": "White box sampling in uncertain data processing enabled by program analysis", + "abstract": "Sampling is a very important and low-cost approach to uncertain data processing, in which output variations caused by input errors are sampled. Traditional methods tend to treat a program as a blackbox. In this paper, we show that through program analysis, we can expose the internals of sample executions so that the process can become more selective and focused. In particular, we develop a sampling runtime that can selectively sample in input error bounds to expose discontinuity in output functions. It identifies all the program factors that can potentially lead to discontinuity and hash the values of such factors during execution in a cost-effective way. The hash values are used to guide the sampling process. Our results show that the technique is very effective for real-world programs. It can achieve the precision of a high sampling rate with the cost of a lower sampling rate.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384681", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tao", + "last_name": "Bao", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yunhui", + "last_name": "Zheng", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/BaoZZ12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384683", + "title": "Detecting problematic message sequences and frequencies in distributed systems", + "abstract": "Testing the components of a distributed system is challenging as it requires consideration of not just the state of a component, but also the sequence of messages it may receive from the rest of the system or the environment. Such messages may vary in type and content, and more particularly, in the frequency at which they are generated. All of these factors, in the right combination, may lead to faulty behavior. In this paper we present an approach to address these challenges by systematically analyzing a component in a distributed system to identify specific message sequences and frequencies at which a failure can occur. At the core of the analysis is the generation of a test driver that defines the space of message sequences to be generated, the exploration of that space through the use of dynamic symbolic execution, and the timing and analysis of the generated tests to identify problematic frequencies. We implemented our approach in the context of the popular Robotic Operating System and investigated its application to three systems of increasing complexity.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384683", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Charles", + "last_name": "Lucas", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Sebastian", + "last_name": "Elbaum", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "David S.", + "last_name": "Rosenblum", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/oopsla/LucasER12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384686", + "title": "Open and efficient type switch for C++", + "abstract": "Selecting operations based on the run-time type of an object is key to many object-oriented and functional programming techniques. We present a technique for implementing open and efficient type switching on hierarchical extensible data types. The technique is general and copes well with C++ multiple inheritance. To simplify experimentation and gain realistic performance using production-quality compilers and tool chains, we implement a type switch construct as an ISO C++11 library, called Mach7. This library-only implementation provides concise notation and outperforms the visitor design pattern, commonly used for case analysis on types in object-oriented programming. For closed sets of types, its performance roughly equals equivalent code in functional languages, such as OCaml and Haskell. The type-switching code is easier to use and is more expressive than hand-coded visitors are. The library is non-intrusive and circumvents most of the extensibility restrictions typical of the visitor design pattern. It was motivated by applications involving large, typed, abstract syntax trees.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384686", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuriy", + "last_name": "Solodkyy", + "institution": "Texas A&M University" + }, + { + "first_name": "Gabriel Dos", + "last_name": "Reis", + "institution": "Texas A&M University" + }, + { + "first_name": "Bjarne", + "last_name": "Stroustrup", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/oopsla/SolodkyyRS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384684", + "title": "Reusing debugging knowledge via trace-based bug search", + "abstract": "Some bugs, among the millions that exist, are similar to each other. One bug-fixing tactic is to search for similar bugs that have been reported and resolved in the past. A fix for a similar bug can help a developer understand a bug, or even directly fix it. Studying bugs with similar symptoms, programmers may determine how to detect or resolve them. To speed debugging, we advocate the systematic capture and reuse of debugging knowledge, much of which is currently wasted. The core challenge here is how to search for similar bugs. To tackle this problem, we exploit semantic bug information in the form of execution traces, which precisely capture bug semantics. This paper introduces novel tool and language support for semantically querying and analyzing bugs. We describe OSCILLOSCOPE, an Eclipse plugin, that uses a bug trace to exhaustively search its database for similar bugs and return their bug reports. OSCILLOSCOPE displays the traces of the bugs it returns against the trace of the target bug, so a developer can visually examine the quality of the matches. OSCILLOSCOPE rests on our bug query language (BQL), a flexible query language over traces. To realize OSCILLOSCOPE, we developed an open infrastructure that consists of a trace collection engine, BQL, a Hadoop-based query engine for BQL, a trace-indexed bug database, as well as a web-based frontend. OSCILLOSCOPE records and uploads bug traces to its infrastructure; it does so automatically when a JUnit test fails. We evaluated OSCILLOSCOPE on bugs collected from popular open-source projects. We show that OSCILLOSCOPE accurately and efficiently finds similar bugs, some of which could have been immediately used to fix open bugs.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384684", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhongxian", + "last_name": "Gu", + "institution": "University of California, Davis" + }, + { + "first_name": "Earl T.", + "last_name": "Barr", + "institution": "University of California, Davis" + }, + { + "first_name": "Drew", + "last_name": "Schleck", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/GuBSS12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384689", + "title": "Typestate-based semantic code search over partial programs", + "abstract": "We present a novel code search approach for answering queries focused on API-usage with code showing how the API should be used. To construct a search index, we develop new techniques for statically mining and consolidating temporal API specifications from code snippets. In contrast to existing semantic-based techniques, our approach handles partial programs in the form of code snippets. Handling snippets allows us to consume code from various sources such as parts of open source projects, educational resources (e.g. tutorials), and expert code sites. To handle code snippets, our approach (i) extracts a possibly partial temporal specification from each snippet using a relatively precise static analysis tracking a generalized notion of typestate, and (ii) consolidates the partial temporal specifications, combining consistent partial information to yield consolidated temporal specifications, each of which captures a full(er) usage scenario.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384689", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alon", + "last_name": "Mishne", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Academic College of Tel Aviv-Yafo" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/MishneSY12", + "venue": "oopsla", + "year": 2012 + }, + { + "paper_id": "10.1145/2384616.2384690", + "title": "Finding reusable data structures", + "abstract": "A big source of run-time performance problems in large-scale, object-oriented applications is the frequent creation of data structures (by the same allocation site) whose lifetimes are disjoint, and whose shapes and data content are always the same. Constructing these data structures and computing the same data values many times is expensive; significant performance improvements can be achieved by reusing their instances, shapes, and/or data values rather than reconstructing them. This paper presents a run-time technique that can be used to help programmers find allocation sites that create such data structures to improve performance. At the heart of the technique are three reusability definitions and novel summarization approaches that compute summaries for data structures based on these definitions. The computed summaries are used subsequently to find data structures that have disjoint lifetimes, and/or that have the same shapes and content. We have implemented this technique in the Jikes RVM and performed extensive studies on large-scale, real-world programs. We describe our experience using six case studies, in which we have achieved large performance gains by fixing problems reported by our tool.", + "date": "2012-10-19", + "link": "https://doi.org/10.1145/2384616.2384690", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/oopsla/Xu12", + "venue": "oopsla", + "year": 2012 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2013.json b/data/pl_conferences/oopsla/2013.json new file mode 100644 index 0000000..12b901e --- /dev/null +++ b/data/pl_conferences/oopsla/2013.json @@ -0,0 +1,1472 @@ +[ + { + "paper_id": "10.1145/2509136.2509538", + "title": "Effective race detection for event-driven programs", + "abstract": "Like shared-memory multi-threaded programs, event-driven programs such as client-side web applications are susceptible to data races that are hard to reproduce and debug. Race detection for such programs is hampered by their pervasive use of ad hoc synchronization, which can lead to a prohibitive number of false positives. Race detection also faces a scalability challenge, as a large number of short-running event handlers can quickly overwhelm standard vector-clock-based techniques.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509538", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/RaychevVS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509531", + "title": "Storage strategies for collections in dynamically typed languages", + "abstract": "Dynamically typed language implementations often use more memory and execute slower than their statically typed cousins, in part because operations on collections of elements are unoptimised. This paper describes storage strategies, which dynamically optimise collections whose elements are instances of the same primitive type. We implement storage strategies in the PyPy virtual machine, giving a performance increase of 18% on wide-ranging benchmarks of real Python programs. We show that storage strategies are simple to implement, needing only 1500LoC in PyPy, and have applicability to a wide range of virtual machines.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509531", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Carl Friedrich", + "last_name": "Bolz", + "institution": "Heinrich Heine University Düsseldorf" + }, + { + "first_name": "Lukas", + "last_name": "Diekmann", + "institution": "Heinrich Heine University Düsseldorf" + }, + { + "first_name": "Laurence", + "last_name": "Tratt", + "institution": "King's College London" + } + ], + "dblp_key": "conf/oopsla/BolzDT13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509515", + "title": "Empirical analysis of programming language adoption", + "abstract": "Some programming languages become widely popular while others fail to grow beyond their niche or disappear altogether. This paper uses survey methodology to identify the factors that lead to language adoption. We analyze large datasets, including over 200,000 SourceForge projects, 590,000 projects tracked by Ohloh, and multiple surveys of 1,000-13,000 programmers.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509515", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Leo A.", + "last_name": "Meyerovich", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Ariel", + "last_name": "Rabkin", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/oopsla/MeyerovichR13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509536", + "title": "Python: the full monty", + "abstract": "We present a small-step operational semantics for the Python programming language. We present both a core language for Python, suitable for tools and proofs, and a translation process for converting Python source to this core. We have tested the composition of translation and evaluation of the core for conformance with the primary Python implementation, thereby giving confidence in the fidelity of the semantics. We briefly report on the engineering of these components. Finally, we examine subtle aspects of the language, identifying scope as a pervasive concern that even impacts features that might be considered orthogonal.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509536", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joe Gibbs", + "last_name": "Politz", + "institution": "Providence College" + }, + { + "first_name": "Alejandro", + "last_name": "Martínez", + "institution": "Hospital Italiano La Plata" + }, + { + "first_name": "Mae", + "last_name": "Milano", + "institution": "Providence College" + }, + { + "first_name": "Sumner", + "last_name": "Warren", + "institution": "Providence College" + }, + { + "first_name": "Daniel", + "last_name": "Patterson", + "institution": "Providence College" + }, + { + "first_name": "Junsong", + "last_name": "Li", + "institution": "Jingdong (China)" + }, + { + "first_name": "Anand", + "last_name": "Chitipothu", + "institution": "" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Providence College" + } + ], + "dblp_key": "conf/oopsla/PolitzMMWPLCK13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509514", + "title": "CDSchecker: checking concurrent data structures written with C/C++ atomics", + "abstract": "Writing low-level concurrent software has traditionally required intimate knowledge of the entire toolchain and often has involved coding in assembly. New language standards have extended C and C++ with support for low-level atomic operations and a weak memory model, enabling developers to write portable and efficient multithreaded code.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509514", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brian", + "last_name": "Norris", + "institution": "University of California, Irvine" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/oopsla/NorrisD13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509543", + "title": "Interacting with dead objects", + "abstract": "Debugging and analyzing a snapshot of a crashed program's memory is far more difficult than working with a live program, because debuggers can no longer execute code to help make sense of the program state. We present an architecture that supports the restricted execution of ordinary code starting from the snapshot, as if the dead objects within it had been restored, but without access to their original external environment. We demonstrate the feasibility of this approach via an implementation for Java that does not require a custom virtual machine, show that it performs competitively with live execution, and use it to diagnose an unresolved memory leak in a mature mainstream application.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509543", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robin", + "last_name": "Salkeld", + "institution": "University of British Columbia" + }, + { + "first_name": "Gregor", + "last_name": "Kiczales", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/oopsla/SalkeldK13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509547", + "title": "Instant pickles: generating object-oriented pickler combinators for fast and extensible serialization", + "abstract": "As more applications migrate to the cloud, and as \"big data\" edges into even more production environments, the performance and simplicity of exchanging data between compute nodes/devices is increasing in importance. An issue central to distributed programming, yet often under-considered, is serialization or pickling, i.e., persisting runtime objects by converting them into a binary or text representation. Pickler combinators are a popular approach from functional programming; their composability alleviates some of the tedium of writing pickling code by hand, but they don't translate well to object-oriented programming due to qualities like open class hierarchies and subtyping polymorphism. Furthermore, both functional pickler combinators and popular, Java-based serialization frameworks tend to be tied to a specific pickle format, leaving programmers with no choice of how their data is persisted. In this paper, we present object-oriented pickler combinators and a framework for generating them at compile-time, called scala/pickling, designed to be the default serialization mechanism of the Scala programming language. The static generation of OO picklers enables significant performance improvements, outperforming Java and Kryo in most of our benchmarks. In addition to high performance and the need for little to no boilerplate, our framework is extensible: using the type class pattern, users can provide both (1) custom, easily interchangeable pickle formats and (2) custom picklers, to override the default behavior of the pickling framework. In benchmarks, we compare scala/pickling with other popular industrial frameworks, and present results on time, memory usage, and size when pickling/unpickling a number of data types used in real-world, large-scale distributed applications and frameworks.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509547", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Heather", + "last_name": "Miller", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Philipp", + "last_name": "Haller", + "institution": "" + }, + { + "first_name": "Eugene", + "last_name": "Burmako", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/MillerHBO13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509510", + "title": "Efficient context sensitivity for dynamic analyses via calling context uptrees and customized memory management", + "abstract": "State-of-the-art dynamic bug detectors such as data race and memory leak detectors report program locations that are likely causes of bugs. However, programmers need more than static program locations to understand the behavior of increasingly complex and concurrent software. Dynamic calling context provides additional information, but it is expensive to record calling context frequently, e.g., at every read and write. Context-sensitive dynamic analyses can build and maintain a calling context tree (CCT) to track calling context--but in order to reuse existing nodes, CCT-based approaches require an expensive lookup.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509510", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jipeng", + "last_name": "Huang", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/oopsla/HuangB13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509553", + "title": "Steering symbolic execution to less traveled paths", + "abstract": "Symbolic execution is a promising testing and analysis methodology. It systematically explores a program's execution space and can generate test cases with high coverage. One significant practical challenge for symbolic execution is how to effectively explore the enormous number of program paths in real-world programs. Various heuristics have been proposed for guiding symbolic execution, but they are generally inefficient and ad-hoc. In this paper, we introduce a novel, unified strategy to guide symbolic execution to less explored parts of a program. Our key idea is to exploit a specific type of path spectra, namely the length-n subpath program spectra, to systematically approximate full path information for guiding path exploration. In particular, we use frequency distributions of explored length-n subpaths to prioritize \"less traveled\" parts of the program to improve test coverage and error detection. We have implemented our general strategy in KLEE, a state-of-the-art symbolic execution engine. Evaluation results on the GNU Coreutils programs show that (1) varying the length n captures program-specific information and exhibits different degrees of effectiveness, and (2) our general approach outperforms traditional strategies in both coverage and error detection.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509553", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "You", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + } + ], + "dblp_key": "conf/oopsla/LiSWL13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509527", + "title": "Taking off the gloves with reference counting Immix", + "abstract": "Despite some clear advantages and recent advances, reference counting remains a poor cousin to high-performance tracing garbage collectors. The advantages of reference counting include a) immediacy of reclamation, b) incrementality, and c) local scope of its operations. After decades of languishing with hopelessly bad performance, recent work narrowed the gap between reference counting and the fastest tracing collectors to within 10%. Though a major advance, this gap remains a substantial barrier to adoption in performance-conscious application domains.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509527", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rifat", + "last_name": "Shahriyar", + "institution": "Australian National University" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Xi", + "last_name": "Yang", + "institution": "Australian National University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/ShahriyarBYM13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509512", + "title": "Resurrector: a tunable object lifetime profiling technique for optimizing real-world programs", + "abstract": "Modern object-oriented applications commonly suffer from severe performance problems that need to be optimized away for increased efficiency and user satisfaction. Many existing optimization techniques (such as object pooling and pretenuring) require precise identification of object lifetimes. However, it is particularly challenging to obtain object lifetimes both precisely and efficiently: precise profiling techniques such as Merlin introduce several hundred times slowdown even for small programs while efficient approximation techniques often sacrifice precision and produce less useful lifetime information. This paper presents a tunable profiling technique, called Resurrector, that explores the middle ground between high precision and high efficiency to find the precision-efficiency sweetspot for various livenessbased optimization techniques. Our evaluation shows that Resurrector is both more precise and more efficient than the GC-based approximation, and it is orders-of-magnitude faster than Merlin. To demonstrate Resurrector's usefulness, we have developed client analyses to find allocation sites that create large data structures with disjoint lifetimes. By inspecting program source code and reusing data structures created from these allocation sites, we have achieved significant performance gains. We have also improved the precision of an existing optimization technique using the lifetime information collected by Resurrector.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509512", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/oopsla/Xu13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509535", + "title": "Forsaking inheritance: supercharged delegation in DelphJ", + "abstract": "We propose DelphJ: a Java-based OO language that eschews inheritance completely, in favor of a combination of class morphing and (deep) delegation. Compared to past delegation approaches, the novel aspect of our design is the ability to emulate the best aspects of inheritance while retaining maximum flexibility: using morphing, a class can select any of the methods of its delegatee and export them (if desired) or transform them (e.g., to add extra arguments or modify type signatures), yet without needing to name these methods explicitly and handle them one-by-one. Compared to past work on morphing, our approach adopts and adapts advanced delegation mechanisms, in order to add late binding capabilities and, thus, provide a full substitute of inheritance. Additionally, we explore complex semantic issues in the interaction of delegation with late binding. We present our language design both informally, with numerous examples, and formally in a core calculus.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509535", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Prodromos", + "last_name": "Gerakios", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Aggelos", + "last_name": "Biboudis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/oopsla/GerakiosBS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509537", + "title": "Miniboxing: improving the speed to code size tradeoff in parametric polymorphism translations", + "abstract": "Parametric polymorphism enables code reuse and type safety. Underneath the uniform interface exposed to programmers, however, its low level implementation has to cope with inherently non-uniform data: value types of different sizes and semantics (bytes, integers, floating point numbers) and reference types (pointers to heap objects). On the Java Virtual Machine, parametric polymorphism is currently translated to bytecode using two competing approaches: homogeneous and heterogeneous. Homogeneous translation requires boxing, and thus introduces indirect access delays. Heterogeneous translation duplicates and adapts code for each value type individually, producing more bytecode. Therefore bytecode speed and size are at odds with each other. This paper proposes a novel translation that significantly reduces the bytecode size without affecting the execution speed. The key insight is that larger value types (such as integers) can hold smaller ones (such as bytes) thus reducing the duplication necessary in heterogeneous translations. In our implementation, on the Scala compiler, we encode all primitive value types in long integers. The resulting bytecode approaches the performance of monomorphic code, matches the performance of the heterogeneous translation and obtains speedups of up to 22x over the homogeneous translation, all with modest increases in size.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509537", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vlad", + "last_name": "Ureche", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Cristian", + "last_name": "Talau", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/UrecheTO13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509546", + "title": "Verifying quantitative reliability for programs that execute on unreliable hardware", + "abstract": "Emerging high-performance architectures are anticipated to contain unreliable components that may exhibit soft errors, which silently corrupt the results of computations. Full detection and masking of soft errors is challenging, expensive, and, for some applications, unnecessary. For example, approximate computing applications (such as multimedia processing, machine learning, and big data analytics) can often naturally tolerate soft errors.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509546", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/CarbinMR13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509524", + "title": "Set-based pre-processing for points-to analysis", + "abstract": "We present set-based pre-analysis: a virtually universal optimization technique for flow-insensitive points-to analysis. Points-to analysis computes a static abstraction of how object values flow through a program's variables. Set-based pre-analysis relies on the observation that much of this reasoning can take place at the set level rather than the value level. Computing constraints at the set level results in significant optimization opportunities: we can rewrite the input program into a simplified form with the same essential points-to properties. This rewrite results in removing both local variables and instructions, thus simplifying the subsequent value-based points-to computation. Effectively, set-based pre-analysis puts the program in a normal form optimized for points-to analysis.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509524", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "George", + "last_name": "Balatsouras", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "George", + "last_name": "Kastrinis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/oopsla/SmaragdakisBK13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509554", + "title": "MrCrypt: static analysis for secure cloud computations", + "abstract": "In a common use case for cloud computing, clients upload data and computation to servers that are managed by a third-party infrastructure provider. We describe MrCrypt, a system that provides data confidentiality in this setting by executing client computations on encrypted data. MrCrypt statically analyzes a program to identify the set of operations on each input data column, in order to select an appropriate homomorphic encryption scheme for that column, and then transforms the program to operate over encrypted data. The encrypted data and transformed program are uploaded to the server and executed as usual, and the result of the computation is decrypted on the client side. We have implemented MrCrypt for Java and illustrate its practicality on three standard benchmark suites for the Hadoop MapReduce framework. We have also formalized the approach and proven several soundness and security guarantees.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509554", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sai Deep", + "last_name": "Tetali", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/oopsla/TetaliLMM13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509520", + "title": "Semi-automatic rename refactoring for JavaScript", + "abstract": "Modern IDEs support automated refactoring for many programming languages, but support for JavaScript is still primitive. To perform renaming, which is one of the fundamental refactorings, there is often no practical alternative to simple syntactic search-and-replace. Although more sophisticated alternatives have been developed, they are limited by whole-program assumptions and poor scalability.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509520", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Asger", + "last_name": "Feldthaus", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/oopsla/FeldthausM13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509521", + "title": "Ball-Larus path profiling across multiple loop iterations", + "abstract": "Identifying the hottest paths in the control flow graph of a routine can direct optimizations to portions of the code where most resources are consumed. This powerful methodology, called path profiling, was introduced by Ball and Larus in the mid 90's [4] and has received considerable attention in the last 15 years for its practical relevance. A shortcoming of the Ball-Larus technique was the inability to profile cyclic paths, making it difficult to mine execution patterns that span multiple loop iterations. Previous results, based on rather complex algorithms, have attempted to circumvent this limitation at the price of significant performance losses even for a small number of iterations. In this paper, we present a new approach to multi-iteration path profiling, based on data structures built on top of the original Ball-Larus numbering technique. Our approach allows the profiling of all executed paths obtained as a concatenation of up to k Ball-Larus acyclic paths, where k is a user-defined parameter. We provide examples showing that this method can reveal optimization opportunities that acyclic-path profiling would miss. An extensive experimental investigation on a large variety of Java benchmarks on the Jikes RVM shows that our approach can be even faster than Ball-Larus due to fewer operations on smaller hash tables, producing compact representations of cyclic paths even for large values of k.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509521", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniele Cono", + "last_name": "D’Elia", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Camil", + "last_name": "Demetrescu", + "institution": "Sapienza University of Rome" + } + ], + "dblp_key": "conf/oopsla/DEliaD13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509528", + "title": "Do developers benefit from generic types?: an empirical comparison of generic and raw types in java", + "abstract": "Type systems that permit developers to express themselves more precisely are one of the primary topics in programming language research, as well as in industrial software development. While it seems plausible that an expressive static type system increases developer productivity, there is little empirical evidence for or against this hypothesis. Generic types in Java are an example: as an extension of Java's original type system, some claim that Java 1.5 improves the type system's \"expressiveness.\" Even if this claim is true, there exists little empirical evidence that claimed expressiveness leads to a measurable increase in developer productivity. This paper introduces an experiment where generic types (in comparison to raw types) have been evaluated in three different directions: (1) the documentation impact on undocumented APIs, (2) the time required for fixing type errors, and (3) the extensibility of a generic type hierarchy. The results of the experiment suggest that generic types improve documentation and reduce extensibility -- without revealing a difference in the time required for fixing type errors.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509528", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Hoppe", + "institution": "University of Duisburg-Essen" + }, + { + "first_name": "Stefan", + "last_name": "Hanenberg", + "institution": "University of Duisburg-Essen" + } + ], + "dblp_key": "conf/oopsla/HoppeH13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509545", + "title": "Language support for dynamic, hierarchical data partitioning", + "abstract": "Applications written for distributed-memory parallel architectures must partition their data to enable parallel execution. As memory hierarchies become deeper, it is increasingly necessary that the data partitioning also be hierarchical to match. Current language proposals perform this hierarchical partitioning statically, which excludes many important applications where the appropriate partitioning is itself data dependent and so must be computed dynamically. We describe Legion, a region-based programming system, where each region may be partitioned into subregions. Partitions are computed dynamically and are fully programmable. The division of data need not be disjoint and subregions of a region may overlap, or alias one another. Computations use regions with certain privileges (e.g., expressing that a computation uses a region read-only) and data coherence (e.g., expressing that the computation need only be atomic with respect to other operations on the region), which can be controlled on a per-region (or subregion) basis.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509545", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sean", + "last_name": "Treichler", + "institution": "Stanford University" + }, + { + "first_name": "Michael", + "last_name": "Bauer", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/TreichlerBA13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509525", + "title": "Multiverse: efficiently supporting distributed high-level speculation", + "abstract": "Algorithmic speculation or high-level speculation is a promising programming paradigm which allows programmers to speculatively branch an execution into multiple independent parallel sections and then choose the best (perhaps fastest) amongst them. The continuing execution after the speculatively branched section sees only the modifications made by the best one. This programming paradigm allows programmers to harness parallelism and can provide dramatic performance improvements.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509525", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kaushik", + "last_name": "Ravichandran", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/RavichandranP13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509550", + "title": "Ironclad C++: a library-augmented type-safe subset of c++", + "abstract": "The C++ programming language remains widely used, despite inheriting many unsafe features from C---features that often lead to failures of type or memory safety that manifest as buffer overflows, use-after-free vulnerabilities, or abstraction violations. Malicious attackers can exploit such violations to compromise application and system security.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509550", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christian", + "last_name": "DeLozier", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Peter-Michael", + "last_name": "Osera", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Milo M. K.", + "last_name": "Martin", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/oopsla/DeLozierENOMZ13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509529", + "title": "Bottle graphs: visualizing scalability bottlenecks in multi-threaded applications", + "abstract": "Understanding and analyzing multi-threaded program performance and scalability is far from trivial, which severely complicates parallel software development and optimization. In this paper, we present bottle graphs, a powerful analysis tool that visualizes multi-threaded program performance, in regards to both per-thread parallelism and execution time. Each thread is represented as a box, with its height equal to the share of that thread in the total program execution time, its width equal to its parallelism, and its area equal to its total running time. The boxes of all threads are stacked upon each other, leading to a stack with height equal to the total program execution time. Bottle graphs show exactly how scalable each thread is, and thus guide optimization towards those threads that have a smaller parallel component (narrower), and a larger share of the total execution time (taller), i.e. to the 'neck' of the bottle.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509529", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kristof Du", + "last_name": "Bois", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Jennifer B.", + "last_name": "Sartor", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Stijn", + "last_name": "Eyerman", + "institution": "Ghent University" + }, + { + "first_name": "Lieven", + "last_name": "Eeckhout", + "institution": "Ghent University Hospital" + } + ], + "dblp_key": "conf/oopsla/BoisSEE13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509544", + "title": "Refactoring with synthesis", + "abstract": "Refactoring has become an integral part of modern software development, with wide support in popular integrated development environments (IDEs). Modern IDEs provide a fixed set of supported refactorings, listed in a refactoring menu. But with IDEs supporting more and more refactorings, it is becoming increasingly difficult for programmers to discover and memorize all their names and meanings. Also, since the set of refactorings is hard-coded, if a programmer wants to achieve a slightly different code transformation, she has to either apply a (possibly non-obvious) sequence of several built-in refactorings, or just perform the transformation by hand.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509544", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Max", + "last_name": "Schäfer", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "IBM (United States)" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/RaychevSSV13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509542", + "title": "Flexible access control for javascript", + "abstract": "Providing security guarantees for systems built out of untrusted components requires the ability to define and enforce access control policies over untrusted code. In Web 2.0 applications, JavaScript code from different origins is often combined on a single page, leading to well-known vulnerabilities. We present a security infrastructure which allows users and content providers to specify access control policies over subsets of a JavaScript program by leveraging the concept of delimited histories with revocation. We implement our proposal in WebKit and evaluate it with three policies on 50 widely used websites with no changes to their JavaScript code and report performance overheads and violations.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509542", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gregor", + "last_name": "Richards", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Christian", + "last_name": "Hammer", + "institution": "Saarland University" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/RichardsHNJV13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509557", + "title": "Fully concurrent garbage collection of actors on many-core machines", + "abstract": "Disposal of dead actors in actor-model languages is as important as disposal of unreachable objects in object-oriented languages. In current practice, programmers are required to either manually terminate actors, or they have to rely on garbage collection systems that monitor actor mutation through write barriers, thread coordination through locks etc. These techniques, however, prevent the collector from being fully concurrent.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509557", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sylvan", + "last_name": "Clebsch", + "institution": "Imperial College London" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/ClebschD13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509509", + "title": "Data-driven equivalence checking", + "abstract": "We present a data driven algorithm for equivalence checking of two loops. The algorithm infers simulation relations using data from test runs. Once a candidate simulation relation has been obtained, off-the-shelf SMT solvers are used to check whether the simulation relation actually holds. The algorithm is sound: insufficient data will cause the proof to fail. We demonstrate a prototype implementation, called DDEC, of our algorithm, which is the first sound equivalence checker for loops written in x86 assembly.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509509", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Eric", + "last_name": "Schkufza", + "institution": "Stanford University" + }, + { + "first_name": "Berkeley", + "last_name": "Churchill", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/0001SCA13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509513", + "title": "Code optimizations using formally verified properties", + "abstract": "Formal program verification offers strong assurance of correctness, backed by the strength of mathematical proof. Constructing these proofs requires humans to identify program invariants, and show that they are always maintained. These invariants are then used to prove that the code adheres to its specification.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509513", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yao", + "last_name": "Shi", + "institution": "Data61" + }, + { + "first_name": "Bernard", + "last_name": "Blackham", + "institution": "UNSW Sydney" + }, + { + "first_name": "Gernot", + "last_name": "Heiser", + "institution": "Data61" + } + ], + "dblp_key": "conf/oopsla/ShiBH13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509555", + "title": "Synthesis modulo recursive functions", + "abstract": "We describe techniques for synthesis and verification of recursive functional programs over unbounded domains. Our techniques build on top of an algorithm for satisfiability modulo recursive functions, a framework for deductive synthesis, and complete synthesis procedures for algebraic data types. We present new counterexample-guided algorithms for constructing verified programs. We have implemented these algorithms in an integrated environment for interactive verification and synthesis from relational specifications. Our system was able to synthesize a number of useful recursive functions that manipulate unbounded numbers and data structures.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509555", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Etienne", + "last_name": "Kneuss", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ivan", + "last_name": "Kuraj", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Philippe", + "last_name": "Suter", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/KneussKKS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509530", + "title": "Class hierarchy complementation: soundly completing a partial type graph", + "abstract": "We present the problem of class hierarchy complementation: given a partially known hierarchy of classes together with subtyping constraints (\"A has to be a transitive subtype of B\") complete the hierarchy so that it satisfies all constraints. The problem has immediate practical application to the analysis of partial programs--e.g., it arises in the process of providing a sound handling of \"phantom classes\" in the Soot program analysis framework. We provide algorithms to solve the hierarchy complementation problem in the single inheritance and multiple inheritance settings. We also show that the problem in a language such as Java, with single inheritance but multiple subtyping and distinguished class vs. interface types, can be decomposed into separate single- and multiple-subtyping instances. We implement our algorithms in a tool, JPhantom, which complements partial Java bytecode programs so that the result is guaranteed to satisfy the Java verifier requirements. JPhantom is highly scalable and runs in mere seconds even for large input applications and complex constraints (with a maximum of 14s for a 19MB binary).", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509530", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "George", + "last_name": "Balatsouras", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/oopsla/BalatsourasS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509548", + "title": "Option contracts", + "abstract": "Many languages support behavioral software contracts so that programmers can describe a component's obligations and promises via logical assertions in its interface. The contract system monitors program execution, checks whether the assertions hold, and, if not, blames the guilty component. Pinning down the violator gets the debugging process started in the right direction. Quality contracts impose a serious run-time cost, however, and programmers therefore compromise in many ways. Some turn off contracts for deployment, but then contracts and code quickly get out of sync during maintenance. Others test contracts randomly or probabilistically. In all cases, programmers have to cope with lack of blame information when the program eventually fails.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509548", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Harvard University Press" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/oopsla/DimoulasFF13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509511", + "title": "Inductive invariant generation via abductive inference", + "abstract": "This paper presents a new method for generating inductive loop invariants that are expressible as boolean combinations of linear integer constraints. The key idea underlying our technique is to perform a backtracking search that combines Hoare-style verification condition generation with a logical abduction procedure based on quantifier elimination to speculate candidate invariants. Starting with true, our method iteratively strengthens loop invariants until they are inductive and strong enough to verify the program. A key feature of our technique is that it is lazy: It only infers those invariants that are necessary for verifying program correctness. Furthermore, our technique can infer arbitrary boolean combinations (including disjunctions) of linear invariants. We have implemented the proposed approach in a tool called HOLA. Our experiments demonstrate that HOLA can infer interesting invariants that are beyond the reach of existing state-of-the-art invariant generation tools.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509511", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "University College London" + }, + { + "first_name": "Boyang", + "last_name": "Li", + "institution": "Williams (United States)" + }, + { + "first_name": "Ken", + "last_name": "McMillan", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/DilligDLM13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509533", + "title": "Turning nondeterminism into parallelism", + "abstract": "Nondeterminism is a useful and prevalent concept in the design and implementation of software systems. An important property of nondeterminism is its latent parallelism: A nondeterministic action can evaluate to multiple behaviors. If at least one of these behaviors does not conflict with concurrent tasks, then there is an admissible execution of the action in parallel with these tasks. Unfortunately, existing implementations of the atomic paradigm - optimistic as well as pessimistic - are unable to fully exhaust the parallelism potential of nondeterministic actions, lacking the means to guide concurrent tasks toward nondeterministic choices that minimize interference.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509533", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "Tel Aviv University" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "New York University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/oopsla/TrippKS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509508", + "title": "Input-covering schedules for multithreaded programs", + "abstract": "We propose constraining multithreaded execution to small sets of input-covering schedules, which we define as follows: given a program P, we say that a set of schedules ∑ covers all inputs of program P if, when given any input, P's execution can be constrained to some schedule in ∑ and still produce a semantically valid result.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509508", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tom", + "last_name": "Bergan", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/BerganCG13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509534", + "title": "Isolation for nested task parallelism", + "abstract": "Isolation--the property that a task can access shared data without interference from other tasks--is one of the most basic concerns in parallel programming. Whilethere is a large body of past work on isolated task-parallelism, the integration of isolation, task-parallelism, and nesting of tasks has been a difficult and unresolved challenge. In this pa- per, we present a programming and execution model called Otello where isolation is extended to arbitrarily nested parallel tasks with irregular accesses to heap data. At the same time, no additional burden is imposed on the programmer, who only exposes parallelism by creating and synchronizing parallel tasks, leaving the job of ensuring isolation to the underlying compiler and runtime system.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509534", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jisheng", + "last_name": "Zhao", + "institution": "Rice University" + }, + { + "first_name": "Roberto", + "last_name": "Lublinerman", + "institution": "Google (United States)" + }, + { + "first_name": "Zoran", + "last_name": "Budimlić", + "institution": "Rice University" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "Rice University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/ZhaoLBCS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509516", + "title": "River trail: a path to parallelism in JavaScript", + "abstract": "JavaScript is the most popular language on the web and is a crucial component of HTML5 applications and services that run on consumer platforms ranging from desktops to phones. However, despite ample amount of hardware parallelism available to web applications on such platforms, JavaScript web applications remain predominantly sequential. Common parallel programming solutions accepted by other programming languages failed to transfer themselves to JavaScript due to differences in programming models, the additional requirements of the web and different developer expectations.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509516", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephan", + "last_name": "Herhut", + "institution": "Intel (United States)" + }, + { + "first_name": "Richard L.", + "last_name": "Hudson", + "institution": "Intel (United States)" + }, + { + "first_name": "Tatiana", + "last_name": "Shpeisman", + "institution": "Intel (United States)" + }, + { + "first_name": "Jaswanth", + "last_name": "Sreeram", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/oopsla/HerhutHSS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509552", + "title": "Guided GUI testing of android apps with minimal restart and approximate learning", + "abstract": "Smartphones and tablets with rich graphical user interfaces (GUI) are becoming increasingly popular. Hundreds of thousands of specialized applications, called apps, are available for such mobile platforms. Manual testing is the most popular technique for testing graphical user interfaces of such apps. Manual testing is often tedious and error-prone. In this paper, we propose an automated technique, called Swift-Hand, for generating sequences of test inputs for Android apps. The technique uses machine learning to learn a model of the app during testing, uses the learned model to generate user inputs that visit unexplored states of the app, and uses the execution of the app on the generated inputs to refine the model. A key feature of the testing algorithm is that it avoids restarting the app, which is a significantly more expensive operation than executing the app on a sequence of inputs. An important insight behind our testing algorithm is that we do not need to learn a precise model of an app, which is often computationally intensive, if our goal is to simply guide test execution into unexplored parts of the state space. We have implemented our testing algorithm in a publicly available tool for Android apps written in Java. Our experimental results show that we can achieve significantly better coverage than traditional random testing and L*-based testing in a given time budget. Our algorithm also reaches peak coverage faster than both random and L*-based testing.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509552", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wontae", + "last_name": "Choi", + "institution": "University of California, Berkeley" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/ChoiNS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509522", + "title": "Combining concern input with program analysis for bloat detection", + "abstract": "Framework based software tends to get bloated by accumulating optional features (or concerns) just-in-case they are needed. The good news is that such feature bloat need not always cause runtime execution bloat. The bad news is that often enough, only a few statements from an optional concern may cause execution bloat that may result in as much as 50% runtime overhead.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509522", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Suparna", + "last_name": "Bhattacharya", + "institution": "IBM Research - India" + }, + { + "first_name": "K.", + "last_name": "Gopinath", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Mangala Gowri", + "last_name": "Nanda", + "institution": "IBM Research - India" + } + ], + "dblp_key": "conf/oopsla/BhattacharyaGN13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509517", + "title": "Barrier invariants: a shared state abstraction for the analysis of data-dependent GPU kernels", + "abstract": "Data-dependent GPU kernels, whose data or control flow are dependent on the input of the program, are difficult to verify because they require reasoning about shared state manipulated by many parallel threads. Existing verification techniques for GPU kernels achieve soundness and scalability by using a two-thread reduction and making the contents of the shared state nondeterministic each time threads synchronise at a barrier, to account for all possible thread interactions. This coarse abstraction prohibits verification of data-dependent kernels. We present barrier invariants, a novel abstraction technique which allows key properties about the shared state of a kernel to be preserved across barriers during formal reasoning. We have integrated barrier invariants with the GPUVerify tool, and present a detailed case study showing how they can be used to verify three prefix sum algorithms, allowing efficient modular verification of a stream compaction kernel, a key building block for GPU programming. This analysis goes significantly beyond what is possible using existing verification techniques for GPU kernels.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509517", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nathan", + "last_name": "Chong", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Paul H. J.", + "last_name": "Kelly", + "institution": "Imperial College London" + }, + { + "first_name": "Jeroen", + "last_name": "Ketema", + "institution": "Imperial College London" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/ChongDKKQ13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509549", + "title": "Targeted and depth-first exploration for systematic testing of android apps", + "abstract": "Systematic exploration of Android apps is an enabler for a variety of app analysis and testing tasks. Performing the exploration while apps run on actual phones is essential for exploring the full range of app capabilities. However, exploring real-world apps on real phones is challenging due to non-determinism, non-standard control flow, scalability and overhead constraints. Relying on end-users to conduct the exploration might not be very effective: we performed a 7-use study on popular Android apps, and found that the combined 7-use coverage was 30.08% of the app screens and 6.46% of the app methods. Prior approaches for automated exploration of Android apps have run apps in an emulator or focused on small apps whose source code was available. To address these problems, we present A3E, an approach and tool that allows substantial Android apps to be explored systematically while running on actual phones, yet without requiring access to the app's source code. The key insight of our approach is to use a static, taint-style, dataflow analysis on the app bytecode in a novel way, to construct a high-level control flow graph that captures legal transitions among activities (app screens). We then use this graph to develop an exploration strategy named Targeted Exploration that permits fast, direct exploration of activities, including activities that would be difficult to reach during normal use. We also developed a strategy named Depth-first Exploration that mimics user actions for exploring activities and their constituents in a slower, but more systematic way. To measure the effectiveness of our techniques, we use two metrics: activity coverage (number of screens explored) and method coverage. Experiments with using our approach on 25 popular Android apps including BBC News, Gas Buddy, Amazon Mobile, YouTube, Shazam Encore, and CNN, show that our exploration techniques achieve 59.39--64.11% activity coverage and 29.53--36.46% method coverage.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509549", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tanzirul", + "last_name": "Azim", + "institution": "University of California, Riverside" + }, + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/oopsla/AzimN13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509541", + "title": "The latency, accuracy, and battery (LAB) abstraction: programmer productivity and energy efficiency for continuous mobile context sensing", + "abstract": "Emerging mobile applications that sense context are poised to delight and entertain us with timely news and events, health tracking, and social connections. Unfortunately, sensing algorithms quickly drain the phone's battery. Developers can overcome battery drain by carefully optimizing context sensing but that makes programming with context arduous and ties applications to current sensing hardware. These types of applications embody a twist on the classic tension between programmer productivity and performance due to their combination of requirements.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509541", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aman", + "last_name": "Kansal", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Scott", + "last_name": "Saponas", + "institution": "Microsoft (United States)" + }, + { + "first_name": "A. J. Bernheim", + "last_name": "Brush", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ryder", + "last_name": "Ziola", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/KansalSBMMZ13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509518", + "title": "Online feedback-directed optimizations for parallel Java code", + "abstract": "The performance of parallel code significantly depends on the parallel task granularity (PTG). If the PTG is too coarse, performance suffers due to load imbalance; if the PTG is too fine, performance suffers from the overhead that is induced by parallel task creation and scheduling.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509518", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Albert", + "last_name": "Noll", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/NollG13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509519", + "title": "OCTET: capturing and controlling cross-thread dependences efficiently", + "abstract": "Parallel programming is essential for reaping the benefits of parallel hardware, but it is notoriously difficult to develop and debug reliable, scalable software systems. One key challenge is that modern languages and systems provide poor support for ensuring concurrency correctness properties - atomicity, sequential consistency, and multithreaded determinism - because all existing approaches are impractical. Dynamic, software-based approaches slow programs by up to an order of magnitude because capturing and controlling cross-thread dependences (i.e., conflicting accesses to shared memory) requires synchronization at virtually every access to potentially shared memory.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509519", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Man", + "last_name": "Cao", + "institution": "The Ohio State University" + }, + { + "first_name": "Minjia", + "last_name": "Zhang", + "institution": "The Ohio State University" + }, + { + "first_name": "Meisam Fathi", + "last_name": "Salmi", + "institution": "The Ohio State University" + }, + { + "first_name": "Swarnendu", + "last_name": "Biswas", + "institution": "The Ohio State University" + }, + { + "first_name": "Aritra", + "last_name": "Sengupta", + "institution": "The Ohio State University" + }, + { + "first_name": "Jipeng", + "last_name": "Huang", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/oopsla/BondKCZSBSH13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509540", + "title": "On-the-fly capacity planning", + "abstract": "When resolving performance problems, a simple histogram of hot call stacks does not cut it, especially given the highly fluid nature of modern deployments. Why bother tuning, when adding a few CPUs via the management console will quickly resolve the problem? The findings of these tools are also presented without any sense of context: e.g. string conversion may be expensive, but only matters if it contributes greatly to the response time of user logins.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509540", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nick", + "last_name": "Mitchell", + "institution": "IBM (United States)" + }, + { + "first_name": "Peter F.", + "last_name": "Sweeney", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "conf/oopsla/MitchellS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509556", + "title": "Bounded partial-order reduction", + "abstract": "Eliminating concurrency errors is increasingly important as systems rely more on parallelism for performance. Exhaustively exploring the state-space of a program's thread interleavings finds concurrency errors and provides coverage guarantees, but suffers from exponential state-space explosion. Two prior approaches alleviate state-space explosion. (1) Dynamic partial-order reduction (DPOR) provides full coverage and explores only one interleaving of independent transitions. (2) Bounded search provides bounded coverage by enumerating interleavings that do not exceed a bound. In particular, we focus on preemption-bounding. Combining partial-order reduction with preemption-bounding had remained an open problem.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509556", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Katherine E.", + "last_name": "Coons", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Madan", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/CoonsMM13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509523", + "title": "Detecting API documentation errors", + "abstract": "When programmers encounter an unfamiliar API library, they often need to refer to its documentations, tutorials, or discussions on development forums to learn its proper usage. These API documents contain valuable information, but may also mislead programmers as they may contain errors (e.g., broken code names and obsolete code samples). Although most API documents are actively maintained and updated, studies show that many new and latent errors do exist. It is tedious and error-prone to find such errors manually as API documents can be enormous with thousands of pages. Existing tools are ineffective in locating documentation errors because traditional natural language (NL) tools do not understand code names and code samples, and traditional code analysis tools do not understand NL sentences. In this paper, we propose the first approach, DOCREF, specifically designed and developed to detect API documentation errors. We formulate a class of inconsistencies to indicate potential documentation errors, and combine NL and code analysis techniques to detect and report such inconsistencies. We have implemented DOCREF and evaluated its effectiveness on the latest documentations of five widely-used API libraries. DOCREF has detected more than 1,000 new documentation errors, which we have reported to the authors. Many of the errors have already been confirmed and fixed, after we reported them.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509523", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hao", + "last_name": "Zhong", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/ZhongS13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509532", + "title": "Relaxed separation logic: a program logic for C11 concurrency", + "abstract": "We introduce relaxed separation logic (RSL), the first program logic for reasoning about concurrent programs running under the C11 relaxed memory model. From a user's perspective, RSL is an extension of concurrent separation logic (CSL) with proof rules for the various kinds of C11 atomic accesses. As in CSL, individual threads are allowed to access non-atomically only the memory that they own, thus preventing data races. Ownership can, however, be transferred via certain atomic accesses. For SC-atomic accesses, we permit arbitrary ownership transfer; for acquire/release atomic accesses, we allow ownership transfer only in one direction; whereas for relaxed atomic accesses, we rule out ownership transfer completely. We illustrate RSL with a few simple examples and prove its soundness directly over the axiomatic C11 weak memory model.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509532", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Chinmay", + "last_name": "Narayan", + "institution": "Indian Institute of Technology Delhi" + } + ], + "dblp_key": "conf/oopsla/VafeiadisN13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509539", + "title": "Efficient concurrency-bug detection across inputs", + "abstract": "In the multi-core era, it is critical to efficiently test multi-threaded software and expose concurrency bugs before software release. Previous work has made significant progress in detecting and validating concurrency bugs under a given input. Unfortunately, software testing always faces large sets of test inputs, and existing techniques are still too expensive to be applied to every test input in practice.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509539", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dongdong", + "last_name": "Deng", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Wei", + "last_name": "Zhang", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/oopsla/Deng0L13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509551", + "title": "Injecting mechanical faults to localize developer faults for evolving software", + "abstract": "This paper presents a novel methodology for localizing faults in code as it evolves. Our insight is that the essence of failure-inducing edits made by the developer can be captured using mechanical program transformations (e.g., mutation changes). Based on the insight, we present the FIFL framework, which uses both the spectrum information of edits (obtained using the existing FaultTracer approach) as well as the potential impacts of edits (simulated by mutation changes) to achieve more accurate fault localization. We evaluate FIFL on real-world repositories of nine Java projects ranging from 5.7KLoC to 88.8KLoC. The experimental results show that FIFL is able to outperform the state-of-the-art FaultTracer technique for localizing failure-inducing program edits significantly. For example, all 19 FIFL strategies that use both the spectrum information and simulated impact information for each edit outperform the existing FaultTracer approach statistically at the significance level of 0.01. In addition, FIFL with its default settings outperforms FaultTracer by 2.33% to 86.26% on 16 of the 26 studied version pairs, and is only inferior than FaultTracer on one version pair.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509551", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lingming", + "last_name": "Zhang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Lu", + "last_name": "Zhang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/Zhang0K13", + "venue": "oopsla", + "year": 2013 + }, + { + "paper_id": "10.1145/2509136.2509526", + "title": "On-the-fly detection of instability problems in floating-point program execution", + "abstract": "The machine representation of floating point values has limited precision such that errors may be introduced during execution. These errors may get propagated and magnified by the following operations, leading to instability problems, e.g., control flow path may be undesirably altered and faulty output may be emitted. In this paper, we develop an on-the-fly efficient monitoring technique that can predict if an execution is stable. The technique does not explicitly compute errors as doing so incurs high overhead. Instead, it detects possible places where an error becomes substantially inflated regarding the corresponding value, and then tags the value with one bit to denote that it has an inflated error. It then tracks inflation bit propagation, taking care of operations that may cut off such propagation. It reports instability if any inflation bit reaches a critical execution point, such as a predicate, where the inflated error may induce substantial execution difference, such as different execution paths. Our experiment shows that with appropriate thresholds, the technique can correctly detect that over 99.999996% of the inputs of all the programs we studied are stable while a traditional technique relying solely on inflation detection mistakenly classifies majority of the inputs as unstable for some of the programs. Compared to the state of the art technique that is based on high precision computation and causes several hundred times slowdown, our technique only causes 7.91 times slowdown on average and can report all the true unstable executions with the appropriate thresholds.", + "date": "2013-10-23", + "link": "https://doi.org/10.1145/2509136.2509526", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tao", + "last_name": "Bao", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/BaoZ13", + "venue": "oopsla", + "year": 2013 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2014.json b/data/pl_conferences/oopsla/2014.json new file mode 100644 index 0000000..dfe40b3 --- /dev/null +++ b/data/pl_conferences/oopsla/2014.json @@ -0,0 +1,1613 @@ +[ + { + "paper_id": "10.1145/2660193.2660215", + "title": "Checking correctness of TypeScript interfaces for JavaScript libraries", + "abstract": "The TypeScript programming language adds optional types to JavaScript, with support for interaction with existing JavaScript libraries via interface declarations. Such declarations have been written for hundreds of libraries, but they can be difficult to write and often contain errors, which may affect the type checking and misguide code completion for the application code in IDEs.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660215", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Asger", + "last_name": "Feldthaus", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/oopsla/FeldthausM14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660209", + "title": "Tardis: affordable time-travel debugging in managed runtimes", + "abstract": "Developers who set a breakpoint a few statements too late or who are trying to diagnose a subtle bug from a single core dump often wish for a time-traveling debugger. The ability to rewind time to see the exact sequence of statements and program values leading to an error has great intuitive appeal but, due to large time and space overheads, time traveling debuggers have seen limited adoption. A managed runtime, such as the Java JVM or a JavaScript engine, has already paid much of the cost of providing core features - type safety, memory management, and virtual IO - that can be reused to implement a low overhead time-traveling debugger. We leverage this insight to design and build affordable time-traveling debuggers for managed languages. Tardis realizes our design: it provides affordable time-travel with an average overhead of only 7% during normal execution, a rate of 0.6MB/s of history logging, and a worst-case 0.68s time-travel latency on our benchmark applications. Tardis can also debug optimized code using time-travel to reconstruct state. This capability, coupled with its low overhead, makes Tardis suitable for use as the default debugger for managed languages, promising to bring time-traveling debugging into the mainstream and transform the practice of debugging.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660209", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Earl T.", + "last_name": "Barr", + "institution": "University College London" + }, + { + "first_name": "Mark", + "last_name": "Marron", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/BarrM14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660214", + "title": "Determinacy in static analysis for jQuery", + "abstract": "Static analysis for JavaScript can potentially help programmers find errors early during development. Although much progress has been made on analysis techniques, a major obstacle is the prevalence of libraries, in particular jQuery, which apply programming patterns that have detrimental consequences on the analysis precision and performance. Previous work on dynamic determinacy analysis has demonstrated how information about program expressions that always resolve to a fixed value in some call context may lead to significant scalability improvements of static analysis for such code. We present a static dataflow analysis for JavaScript that infers and exploits determinacy information on-the-fly, to enable analysis of some of the most complex parts of jQuery. The analysis combines selective context and path sensitivity, constant propagation, and branch pruning, based on a systematic investigation of the main causes of analysis imprecision when using a more basic analysis.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660214", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Esben", + "last_name": "Andreasen", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/oopsla/AndreasenM14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660198", + "title": "Fast conservative garbage collection", + "abstract": "Garbage collectors are exact or conservative. An exact collector identifies all references precisely and may move referents and update references, whereas a conservative collector treats one or more of stack, register, and heap references as ambiguous. Ambiguous references constrain collectors in two ways. (1) Since they may be pointers, the collectors must retain referents. (2) Since they may be values, the collectors cannot modify them, pinning their referents.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660198", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rifat", + "last_name": "Shahriyar", + "institution": "Australian National University" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/ShahriyarBM14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660206", + "title": "SurveyMan: programming and automatically debugging surveys", + "abstract": "Surveys can be viewed as programs, complete with logic, control flow, and bugs. Word choice or the order in which questions are asked can unintentionally bias responses. Vague, confusing, or intrusive questions can cause respondents to abandon a survey. Surveys can also have runtime errors: inattentive respondents can taint results. This effect is especially problematic when deploying surveys in uncontrolled settings, such as on the web or via crowdsourcing platforms. Because the results of surveys drive business decisions and inform scientific conclusions, it is crucial to make sure they are correct.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660206", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emma", + "last_name": "Tosch", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/ToschB14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660203", + "title": "Refactoring Java generics by inferring wildcards, in practice", + "abstract": "Wildcard annotations can improve the generality of Java generic libraries, but require heavy manual effort. We present an algorithm for refactoring and inferring more general type instantiations of Java generics using wildcards. Compared to past approaches, our work is practical and immediately applicable: we assume no changes to the Java type system, while taking into account all its intricacies. Our system allows users to select declarations (variables, method parameters, return types, etc.) to generalize and considers declarations not declared in available source code. It then performs an inter-procedural flow analysis and a method body analysis, in order to generalize type signatures. We evaluate our technique on six Java generic libraries. We find that 34% of available declarations of variant type signatures can be generalized - i.e., relaxed with more general wildcard types. On average, 146 other declarations need to be updated when a declaration is generalized, showing that this refactoring would be too tedious and error-prone to perform manually.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660203", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Altidor", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/oopsla/AltidorS14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660236", + "title": "StreamJIT: a commensal compiler for high-performance stream programming", + "abstract": "There are many domain libraries, but despite the performance benefits of compilation, domain-specific languages are comparatively rare due to the high cost of implementing an optimizing compiler. We propose commensal compilation, a new strategy for compiling embedded domain-specific languages by reusing the massive investment in modern language virtual machine platforms. Commensal compilers use the host language's front-end, use host platform APIs that enable back-end optimizations by the host platform JIT, and use an autotuner for optimization selection. The cost of implementing a commensal compiler is only the cost of implementing the domain-specific optimizations. We demonstrate the concept by implementing a commensal compiler for the stream programming language StreamJIT atop the Java platform. Our compiler achieves performance 2.8 times better than the StreamIt native code (via GCC) compiler with considerably less implementation effort.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660236", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeffrey", + "last_name": "Bosboom", + "institution": "" + }, + { + "first_name": "Sumanaruban", + "last_name": "Rajadurai", + "institution": "National University of Singapore" + }, + { + "first_name": "Weng‐Fai", + "last_name": "Wong", + "institution": "National University of Singapore" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/BosboomRWA14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660225", + "title": "Rate types for stream programs", + "abstract": "We introduce RATE TYPES, a novel type system to reason about and optimize data-intensive programs. Built around stream languages, RATE TYPES performs static quantitative reasoning about stream rates -- the frequency of data items in a stream being consumed, processed, and produced. Despite the fact that streams are fundamentally dynamic, we find two essential concepts of stream rate control -- throughput ratio and natural rate -- are intimately related to the program structure itself and can be effectively reasoned about by a type system. RATE TYPES is proven to correspond with a time-aware and parallelism-aware operational semantics. The strong correspondence result tolerates arbitrary schedules, and does not require any synchronization between stream filters.We further implement RATE TYPES, demonstrating its effectiveness in predicting stream data rates in real-world stream programs.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660225", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas W.", + "last_name": "Bartenstein", + "institution": "Binghamton University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + } + ], + "dblp_key": "conf/oopsla/BartensteinL14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660226", + "title": "Using web corpus statistics for program analysis", + "abstract": "Several program analysis tools - such as plagiarism detection and bug finding - rely on knowing a piece of code's relative semantic importance. For example, a plagiarism detector should not bother reporting two programs that have an identical simple loop counter test, but should report programs that share more distinctive code. Traditional program analysis techniques (e.g., finding data and control dependencies) are useful, but do not say how surprising or common a line of code is. Natural language processing researchers have encountered a similar problem and addressed it using an n-gram model of text frequency, derived from statistics computed over text corpora.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660226", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chun-Hung", + "last_name": "Hsiao", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Michael", + "last_name": "Cafarella", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/oopsla/HsiaoCN14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660220", + "title": "Rubah: DSU for Java on a stock JVM", + "abstract": "This paper presents Rubah, the first dynamic software updating system for Java that: is portable, implemented via libraries and bytecode rewriting on top of a standard JVM; is efficient, imposing essentially no overhead on normal, steady-state execution; is flexible, allowing nearly arbitrary changes to classes between updates; and isnon-disruptive, employing either a novel eager algorithm that transforms the program state with multiple threads, or a novel lazy algorithm that transforms objects as they are demanded, post-update. Requiring little programmer effort, Rubah has been used to dynamically update five long-running applications: the H2 database, the Voldemort key-value store, the Jake2 implementation of the Quake 2 shooter game, the CrossFTP server, and the JavaEmailServer.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660220", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luís", + "last_name": "Pina", + "institution": "University of Lisbon" + }, + { + "first_name": "Luís", + "last_name": "Veiga", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/PinaVH14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660222", + "title": "Confined gradual typing", + "abstract": "Gradual typing combines static and dynamic typing flexibly and safely in a single programming language. To do so, gradually typed languages implicitly insert casts where needed, to ensure at runtime that typing assumptions are not violated by untyped code. However, the implicit nature of cast insertion, especially on higher-order values, can jeopardize reliability and efficiency: higher-order casts can fail at any time, and are costly to execute. We propose Confined Gradual Typing, which extends gradual typing with two new type qualifiers that let programmers control the flow of values between the typed and the untyped worlds, and thereby trade some flexibility for more reliability and performance. We formally develop two variants of Confined Gradual Typing that capture different flexibility/guarantee tradeoffs. We report on the implementation of Confined Gradual Typing in Gradualtalk, a gradually-typed Smalltalk, which confirms the performance advantage of avoiding unwanted higher-order casts and the low overhead of the approach.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660222", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Esteban", + "last_name": "Allende", + "institution": "University of Chile" + }, + { + "first_name": "Johan", + "last_name": "Fabry", + "institution": "University of Chile" + }, + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/oopsla/AllendeFGT14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660244", + "title": "Region-based memory management for GPU programming languages: enabling rich data structures on a spartan host", + "abstract": "Graphics processing units (GPUs) can effectively accelerate many applications, but their applicability has been largely limited to problems whose solutions can be expressed neatly in terms of linear algebra. Indeed, most GPU programming languages limit the user to simple data structures - typically only multidimensional rectangular arrays of scalar values. Many algorithms are more naturally expressed using higher level language features, such as algebraic data types (ADTs) and first class procedures, yet building these structures in a manner suitable for a GPU remains a challenge. We present a region-based memory management approach that enables rich data structures in Harlan, a language for data parallel computing. Regions enable rich data structures by providing a uniform representation for pointers on both the CPU and GPU and by providing a means of transferring entire data structures between CPU and GPU memory. We demonstrate Harlan's increased expressiveness on several example programs and show that Harlan performs well on more traditional data-parallel problems.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660244", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Holk", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Andrew", + "last_name": "Lumsdaine", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/oopsla/HolkNSL14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660208", + "title": "Smten with satisfiability-based search", + "abstract": "Satisfiability (SAT) and Satisfiability Modulo Theories (SMT) have been used in solving a wide variety of important and challenging problems, including automatic test generation, model checking, and program synthesis. For these applications to scale to larger problem instances, developers cannot rely solely on the sophistication of SAT and SMT solvers to efficiently solve their queries; they must also optimize their own orchestration and construction of queries. We present Smten, a high-level language for orchestrating and constructing satisfiability-based search queries. We show that applications developed using Smten require significantly fewer lines of code and less developer effort to achieve results comparable to standard SMT-based tools.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660208", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Richard", + "last_name": "Uhler", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Nirav", + "last_name": "Dave", + "institution": "SRI International" + } + ], + "dblp_key": "conf/oopsla/UhlerD14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660216", + "title": "Foundations of path-dependent types", + "abstract": "A scalable programming language is one in which the same concepts can describe small as well as large parts. Towards this goal, Scala unifies concepts from object and module systems. An essential ingredient of this unification is the concept of objects with type members, which can be referenced through path-dependent types. Unfortunately, path-dependent types are not well-understood, and have been a roadblock in grounding the Scala type system on firm theory.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660216", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Oracle (United States)" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/AminRO14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660233", + "title": "EventBreak: analyzing the responsiveness of user interfaces through performance-guided test generation", + "abstract": "Event-driven user interface applications typically have a single thread of execution that processes event handlers in response to input events triggered by the user, the network, or other applications. Programmers must ensure that event handlers terminate after a short amount of time because otherwise, the application may become unresponsive. This paper presents EventBreak, a performance-guided test generation technique to identify and analyze event handlers whose execution time may gradually increase while using the application. The key idea is to systematically search for pairs of events where triggering one event increases the execution time of the other event. For example, this situation may happen because one event accumulates data that is processed by the other event. We implement the approach for JavaScript-based web applications and apply it to three real-world applications. EventBreak discovers events with an execution time that gradually increases in an unbounded way, which makes the application unresponsive, and events that, if triggered repeatedly, reveal a severe scalability problem, which makes the application unusable. The approach reveals two known bugs and four previously unknown responsiveness problems. Furthermore, we show that EventBreak helps in testing that event handlers avoid such problems by bounding a handler's execution time.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660233", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Parker", + "last_name": "Schuh", + "institution": "University of California, Berkeley" + }, + { + "first_name": "George C.", + "last_name": "Necula", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/oopsla/PradelSNS14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660212", + "title": "Phosphor: illuminating dynamic data flow in commodity jvms", + "abstract": "Dynamic taint analysis is a well-known information flow analysis problem with many possible applications. Taint tracking allows for analysis of application data flow by assigning labels to data, and then propagating those labels through data flow. Taint tracking systems traditionally compromise among performance, precision, soundness, and portability. Performance can be critical, as these systems are often intended to be deployed to production environments, and hence must have low overhead. To be deployed in security-conscious settings, taint tracking must also be sound and precise. Dynamic taint tracking must be portable in order to be easily deployed and adopted for real world purposes, without requiring recompilation of the operating system or language interpreter, and without requiring access to application source code.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660212", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Bell", + "institution": "Columbia University" + }, + { + "first_name": "Gail E.", + "last_name": "Kaiser", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/oopsla/BellK14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660196", + "title": "An experimental survey of energy management across the stack", + "abstract": "Modern demand for energy-efficient computation has spurred research at all levels of the stack, from devices to microarchitecture, operating systems, compilers, and languages. Unfortunately, this breadth has resulted in a disjointed space, with technologies at different levels of the system stack rarely compared, let alone coordinated.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660196", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Melanie", + "last_name": "Kambadur", + "institution": "Columbia University" + }, + { + "first_name": "Martha A.", + "last_name": "Kim", + "institution": "Columbia University" + } + ], + "dblp_key": "conf/oopsla/KambadurK14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660240", + "title": "Distributed REScala: an update algorithm for distributed reactive programming", + "abstract": "Reactive programming improves the design of reactive applications by relocating the logic for managing dependencies between dependent values away from the application logic to the language implementation. Many distributed applications are reactive. Yet, existing change propagation algorithms are not suitable in a distributed setting.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660240", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joscha", + "last_name": "Drechsler", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Ragnar", + "last_name": "Mogk", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/oopsla/DrechslerSMM14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660210", + "title": "Continuously measuring critical section pressure with the free-lunch profiler", + "abstract": "Today, Java is regularly used to implement large multi-threaded server-class applications that use locks to protect access to shared data. However, understanding the impact of locks on the performance of a system is complex, and thus the use of locks can impede the progress of threads on configurations that were not anticipated by the developer, during specific phases of the execution.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660210", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Florian", + "last_name": "David", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Gaël", + "last_name": "Thomas", + "institution": "Sorbonne Université" + }, + { + "first_name": "Julia", + "last_name": "Lawall", + "institution": "Sorbonne Université" + }, + { + "first_name": "Gilles", + "last_name": "Muller", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/oopsla/DavidTLM14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660242", + "title": "i3QL: language-integrated live data views", + "abstract": "An incremental computation updates its result based on a change to its input, which is often an order of magnitude faster than a recomputation from scratch. In particular, incrementalization can make expensive computations feasible for settings that require short feedback cycles, such as interactive systems, IDEs, or (soft) real-time systems.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660242", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Mitschke", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mirko", + "last_name": "Köhler", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/oopsla/MitschkeEKMS14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660224", + "title": "Atlas: leveraging locks for non-volatile memory consistency", + "abstract": "Non-volatile main memory, such as memristors or phase change memory, can revolutionize the way programs persist data. In-memory objects can themselves be persistent without the need for a separate persistent data storage format. However, the challenge is to ensure that such data remains consistent if a failure occurs during execution.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660224", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dhruva R.", + "last_name": "Chakrabarti", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Google (United States)" + }, + { + "first_name": "Kumud", + "last_name": "Bhandari", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/ChakrabartiBB14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660238", + "title": "Multithreaded test synthesis for deadlock detection", + "abstract": "Designing and implementing thread-safe multithreaded libraries can be a daunting task as developers of these libraries need to ensure that their implementations are free from concurrency bugs, including deadlocks. The usual practice involves employing software testing and/or dynamic analysis to detect deadlocks. Their effectiveness is dependent on well-designed multithreaded test cases. Unsurprisingly, developing multithreaded tests is significantly harder than developing sequential tests for obvious reasons.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660238", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Malavika", + "last_name": "Samak", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Murali Krishna", + "last_name": "Ramanathan", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/oopsla/SamakR14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660235", + "title": "Understanding energy behaviors of thread management constructs", + "abstract": "Java programmers are faced with numerous choices in managing concurrent execution on multicore platforms. These choices often have different trade-offs (e.g., performance, scalability, and correctness guarantees). This paper analyzes an additional dimension, energy consumption. It presents an empirical study aiming to illuminate the relationship between the choices and settings of thread management constructs and energy consumption. We consider three important thread management constructs in concurrent programming: explicit thread creation, fixed-size thread pooling, and work stealing. We further shed light on the energy/performance trade-off of three ``tuning knobs'' of these constructs: the number of threads, the task division strategy, and the characteristics of processed data. Through an extensive experimental space exploration over real-world Java programs, we produce a list of findings about the energy behaviors of concurrent programs, which are not always obvious. The study serves as a first step toward improving energy efficiency of concurrent programs on parallel architectures.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660235", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gustavo", + "last_name": "Pinto", + "institution": "Hospital das Clínicas da Universidade Federal de Pernambuco" + }, + { + "first_name": "Fernando", + "last_name": "Castor", + "institution": "Hospital das Clínicas da Universidade Federal de Pernambuco" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + } + ], + "dblp_key": "conf/oopsla/PintoCL14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660231", + "title": "Chisel: reliability- and accuracy-aware optimization of approximate computational kernels", + "abstract": "The accuracy of an approximate computation is the distance between the result that the computation produces and the corresponding fully accurate result. The reliability of the computation is the probability that it will produce an acceptably accurate result. Emerging approximate hardware platforms provide approximate operations that, in return for reduced energy consumption and/or increased performance, exhibit reduced reliability and/or accuracy.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660231", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "" + }, + { + "first_name": "Sara", + "last_name": "Achour", + "institution": "" + }, + { + "first_name": "Zichao", + "last_name": "Qi", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/MisailovicCAQR14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660195", + "title": "Fast splittable pseudorandom number generators", + "abstract": "We describe a new algorithm SplitMix for an object-oriented and splittable pseudorandom number generator (PRNG) that is quite fast: 9 64-bit arithmetic/logical operations per 64 bits generated. A conventional linear PRNG object provides a generate method that returns one pseudorandom value and updates the state of the PRNG, but a splittable PRNG object also has a second operation, split, that replaces the original PRNG object with two (seemingly) independent PRNG objects, by creating and returning a new such object and updating the state of the original object. Splittable PRNG objects make it easy to organize the use of pseudorandom numbers in multithreaded programs structured using fork-join parallelism. No locking or synchronization is required (other than the usual memory fence immediately after object creation). Because the generate method has no loops or conditionals, it is suitable for SIMD or GPU implementation.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660195", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "Oracle (United States)" + }, + { + "first_name": "Doug", + "last_name": "Lea", + "institution": "State University of New York at Oswego" + }, + { + "first_name": "Christine H.", + "last_name": "Flood", + "institution": "Red Hat (United States)" + } + ], + "dblp_key": "conf/oopsla/SteeleLF14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660217", + "title": "Flint: fixing linearizability violations", + "abstract": "Writing concurrent software while achieving both correctness and efficiency is a grand challenge. To facilitate this task, concurrent data structures have been introduced into the standard library of popular languages like Java and C#. Unfortunately, while the operations exposed by concurrent data structures are atomic (or linearizable), compositions of these operations are not necessarily atomic. Recent studies have found many erroneous implementations of composed concurrent operations.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660217", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peng", + "last_name": "Liu", + "institution": "State Key Laboratory of Software Engineering" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "IBM (United States)" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/LiuTZ14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660197", + "title": "Late data layout: unifying data representation transformations", + "abstract": "Values need to be represented differently when interacting with certain language features. For example, an integer has to take an object-based representation when interacting with erased generics, although, for performance reasons, the stack-based value representation is better. To abstract over these implementation details, some programming languages choose to expose a unified high-level concept (the integer) and let the compiler choose its exact representation and insert coercions where necessary.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660197", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vlad", + "last_name": "Ureche", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Eugene", + "last_name": "Burmako", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/UrecheBO14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660200", + "title": "Symbolic execution of multithreaded programs from arbitrary program contexts", + "abstract": "We describe an algorithm to perform symbolic execution of a multithreaded program starting from an arbitrary program context. We argue that this can enable more efficient symbolic exploration of deep code paths in multithreaded programs by allowing the symbolic engine to jump directly to program contexts of interest.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660200", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tom", + "last_name": "Bergan", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/BerganGC14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660207", + "title": "CheckCell: data debugging for spreadsheets", + "abstract": "Testing and static analysis can help root out bugs in programs, but not in data. This paper introduces data debugging, an approach that combines program analysis and statistical analysis to automatically find potential data errors. Since it is impossible to know a priori whether data are erroneous, data debugging instead locates data that has a disproportionate impact on the computation. Such data is either very important, or wrong. Data debugging is especially useful in the context of data-intensive programming environments that intertwine data with programs in the form of queries or formulas.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660207", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel W.", + "last_name": "Barowy", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Dimitar", + "last_name": "Gochev", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/BarowyGB14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660237", + "title": "From object algebras to attribute grammars", + "abstract": "Oliveira and Cook (2012) and Oliveira et al. (2013) have recently introduced object algebras as a program structuring technique to improve the modularity and extensibility of programs. We analyze the relationship between object algebras and attribute grammars (AGs), a formalism to augment context-free grammars with attributes. We present an extension of the object algebra technique with which the full class of L-attributed grammars - an important class of AGs that corresponds to one-pass compilers - can be encoded in Scala. The encoding is modular (attributes can be defined and type-checked separately), scalable (the size of the encoding is linear in the size of the AG specification) and compositional (each AG artifact is represented as a semantic object of the host language). To evaluate these claims, we have formalized the encoding and re-implemented a one-pass compiler for a subset of C with our technique. We also discuss how advanced features of modern AG systems, such as higher-order and parameterized attributes, reference attributes, and forwarding can be supported.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660237", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tillmann", + "last_name": "Rendel", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "Philipps University of Marburg" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "Philipps University of Marburg" + } + ], + "dblp_key": "conf/oopsla/RendelBO14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660230", + "title": "Finding minimum type error sources", + "abstract": "Automatic type inference is a popular feature of functional programming languages. If a program cannot be typed, the compiler typically reports a single program location in its error message. This location is the point where the type inference failed, but not necessarily the actual source of the error. Other potential error sources are not even considered. Hence, the compiler often misses the true error source, which increases debugging time for the programmer. In this paper, we present a general framework for automatic localization of type errors. Our algorithm finds all minimum error sources, where the exact definition of minimum is given in terms of a compiler-specific ranking criterion. Compilers can use minimum error sources to produce more meaningful error reports, and for automatic error correction. Our approach works by reducing the search for minimum error sources to an optimization problem that we formulate in terms of weighted maximum satisfiability modulo theories (MaxSMT). The reduction to weighted MaxSMT allows us to build on SMT solvers to support rich type systems and at the same time abstract from the concrete criterion that is used for ranking the error sources. We have implemented an instance of our framework targeted at Hindley-Milner type systems and evaluated it on existing OCaml benchmarks for type error localization. Our evaluation shows that our approach has the potential to significantly improve the quality of type error reports produced by state of the art compilers.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660230", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zvonimir", + "last_name": "Pavlinovic", + "institution": "New York University" + }, + { + "first_name": "Tim L.", + "last_name": "King", + "institution": "New York University" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "conf/oopsla/PavlinovicKW14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660218", + "title": "MIX10: compiling MATLAB to X10 for high performance", + "abstract": "MATLAB is a popular dynamic array-based language commonly used by students, scientists and engineers who appreciate the interactive development style, the rich set of array operators, the extensive builtin library, and the fact that they do not have to declare static types. Even though these users like to program in MATLAB, their computations are often very compute-intensive and are better suited for emerging high performance computing systems. This paper reports on MIX10, a source-to-source compiler that automatically translates MATLAB programs to X10, a language designed for \"Performance and Productivity at Scale\"; thus, helping scientific programmers make better use of high performance computing systems.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660218", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vineet", + "last_name": "Kumar", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/oopsla/KumarH14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660234", + "title": "Statistical debugging for real-world performance problems", + "abstract": "Design and implementation defects that lead to inefficient computation widely exist in software. These defects are difficult to avoid and discover. They lead to severe performance degradation and energy waste during production runs, and are becoming increasingly critical with the meager increase of single-core hardware performance and the increasing concerns about energy constraints. Effective tools that diagnose performance problems and point out the inefficiency root cause are sorely needed.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660234", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Linhai", + "last_name": "Song", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/oopsla/SongL14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660202", + "title": "Adaptive LL(*) parsing: the power of dynamic analysis", + "abstract": "Despite the advances made by modern parsing strategies such as PEG, LL(*), GLR, and GLL, parsing is not a solved problem. Existing approaches suffer from a number of weaknesses, including difficulties supporting side-effecting embedded actions, slow and/or unpredictable performance, and counter-intuitive matching strategies. This paper introduces the ALL(*) parsing strategy that combines the simplicity, efficiency, and predictability of conventional top-down LL(k) parsers with the power of a GLR-like mechanism to make parsing decisions. The critical innovation is to move grammar analysis to parse-time, which lets ALL(*) handle any non-left-recursive context-free grammar. ALL(*) is O(n4) in theory but consistently performs linearly on grammars used in practice, outperforming general strategies such as GLL and GLR by orders of magnitude. ANTLR 4 generates ALL(*) parsers and supports direct left-recursion through grammar rewriting. Widespread ANTLR 4 use (5000 downloads/month in 2013) provides evidence that ALL(*) is effective for a wide variety of applications.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660202", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Terence", + "last_name": "Parr", + "institution": "University of San Francisco" + }, + { + "first_name": "Sam", + "last_name": "Harwell", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/oopsla/ParrHF14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660239", + "title": "Automated migration of build scripts using dynamic analysis and search-based refactoring", + "abstract": "The efficiency of a build system is an important factor for developer productivity. As a result, developer teams have been increasingly adopting new build systems that allow higher build parallelization. However, migrating the existing legacy build scripts to new build systems is a tedious and error-prone process. Unfortunately, there is insufficient support for automated migration of build scripts, making the migration more problematic.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660239", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Milos", + "last_name": "Gligoric", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Wolfram", + "last_name": "Schulte", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Chandra", + "last_name": "Prasad", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Danny van", + "last_name": "Velzen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Iman", + "last_name": "Narasamdya", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/GligoricSPVNL14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660223", + "title": "Accelerating iterators in optimizing AST interpreters", + "abstract": "Generators offer an elegant way to express iterators. However, their performance has always been their Achilles heel and has prevented widespread adoption. We present techniques to efficiently implement and optimize generators.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660223", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wei", + "last_name": "Zhang", + "institution": "University of California, Irvine" + }, + { + "first_name": "Per", + "last_name": "Larsen", + "institution": "University of California, Irvine" + }, + { + "first_name": "Stefan", + "last_name": "Brunthaler", + "institution": "University of California, Irvine" + }, + { + "first_name": "Michael", + "last_name": "Franz", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/oopsla/ZhangLBF14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660232", + "title": "Bounded exhaustive test input generation from hybrid invariants", + "abstract": "We present a novel technique for producing bounded exhaustive test suites from hybrid invariants, i.e., invariants that are expressed imperatively, declaratively, or as a combination of declarative and imperative predicates. Hybrid specifications are processed using known mechanisms for the imperative and declarative parts, but combined in a way that enables us to exploit information from the declarative side, such as tight bounds computed from the declarative specification, to improve the search both on the imperative and declarative sides. Moreover, our technique automatically evaluates different possible ways of processing the imperative side, and the alternative settings (imperative or declarative) for parts of the invariant available both declaratively and imperatively, to decide the most convenient invariant configuration with respect to efficiency in test generation. This is achieved by transcoping, i.e., by assessing the efficiency of the different alternatives on small scopes (where generation times are negligible), and then extrapolating the results to larger scopes.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660232", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nicolás", + "last_name": "Rosner", + "institution": "University of Buenos Aires" + }, + { + "first_name": "Valeria", + "last_name": "Bengolea", + "institution": "" + }, + { + "first_name": "Pablo", + "last_name": "Ponzio", + "institution": "" + }, + { + "first_name": "Shadi Abdul", + "last_name": "Khalek", + "institution": "Google (United States)" + }, + { + "first_name": "Nazareno", + "last_name": "Aguirre", + "institution": "National University of Río Cuarto" + }, + { + "first_name": "Marcelo F.", + "last_name": "Frias", + "institution": "Buenos Aires Institute of Technology" + }, + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/RosnerBPKAFK14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660241", + "title": "Staged parser combinators for efficient data processing", + "abstract": "Parsers are ubiquitous in computing, and many applications depend on their performance for decoding data efficiently. Parser combinators are an intuitive tool for writing parsers: tight integration with the host language enables grammar specifications to be interleaved with processing of parse results. Unfortunately, parser combinators are typically slow due to the high overhead of the host language abstraction mechanisms that enable composition.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660241", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Manohar", + "last_name": "Jonnalagedda", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Thierry", + "last_name": "Coppey", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Sandro", + "last_name": "Stucki", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/JonnalageddaCSRO14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660245", + "title": "Abstract semantic differencing via speculative correlation", + "abstract": "We address the problem of computing semantic differences between a program and a patched version of the program. Our goal is to obtain a precise characterization of the difference between program versions, or establish their equivalence. We focus on infinite-state numerical programs, and use abstract interpretation to compute an over-approximation of program differences.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660245", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nimrod", + "last_name": "Partush", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/PartushY14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660211", + "title": "Natural proofs for asynchronous programs using almost-synchronous reductions", + "abstract": "We consider the problem of provably verifying that an asynchronous message-passing system satisfies its local assertions. We present a novel reduction scheme for asynchronous event-driven programs that finds almost-synchronous invariants - invariants consisting of global states where message buffers are close to empty. The reduction finds almost-synchronous invariants and simultaneously argues that they cover all local states. We show that asynchronous programs often have almost-synchronous invariants and that we can exploit this to build natural proofs that they are correct. We implement our reduction strategy, which is sound and complete, and show that it is more effective in proving programs correct as well as more efficient in finding bugs in several programs, compared to current search strategies which almost always diverge. The high point of our experiments is that our technique can prove the Windows Phone USB Driver written in P [9]correct for the responsiveness property, which was hitherto not provable using state-of-the-art model-checkers.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660211", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ankush", + "last_name": "Desai", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Pranav", + "last_name": "Garg", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/Desai0M14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660221", + "title": "Call sequence prediction through probabilistic calling automata", + "abstract": "Predicting a sequence of upcoming function calls is important for optimizing programs written in modern managed languages (e.g., Java, Javascript, C#.) Existing function call predictions are mainly built on statistical patterns, suitable for predicting a single call but not a sequence of calls. This paper presents a new way to enable call sequence prediction, which exploits program structures through Probabilistic Calling Automata (PCA), a new program representation that captures both the inherent ensuing relations among function calls, and the probabilistic nature of execution paths. It shows that PCA-based prediction outperforms existing predictions, yielding substantial speedup when being applied to guide Just-In-Time compilation. By enabling accurate, efficient call sequence prediction for the first time, PCA-based predictors open up many new opportunities for dynamic program optimizations.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660221", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhijia", + "last_name": "Zhao", + "institution": "Williams (United States)" + }, + { + "first_name": "Bo", + "last_name": "Wu", + "institution": "Colorado School of Mines" + }, + { + "first_name": "Mingzhou", + "last_name": "Zhou", + "institution": "William & Mary" + }, + { + "first_name": "Yufei", + "last_name": "Ding", + "institution": "North Carolina State University" + }, + { + "first_name": "Jianhua", + "last_name": "Sun", + "institution": "Williams (United States)" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + }, + { + "first_name": "Youfeng", + "last_name": "Wu", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/oopsla/ZhaoWZDSSW14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660243", + "title": "GPS: navigating weak memory with ghosts, protocols, and separation", + "abstract": "Weak memory models formalize the inconsistent behaviors that one can expect to observe in multithreaded programs running on modern hardware. In so doing, however, they complicate the already-difficult task of reasoning about correctness of concurrent code. Worse, they render impotent the sophisticated formal methods that have been developed to tame concurrency, which almost universally assume a strong (i.e. sequentially consistent) memory model.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660243", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Turon", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/oopsla/TuronVD14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660219", + "title": "Static analysis for independent app developers", + "abstract": "Mobile app markets have lowered the barrier to market entry for software producers. As a consequence, an increasing number of independent app developers offer their products, and recent platforms such as the MIT App Inventor and Microsoft's TouchDevelop enable even lay programmers to develop apps and distribute them in app markets.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660219", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lucas", + "last_name": "Brutschy", + "institution": "ETH Zurich" + }, + { + "first_name": "Pietro", + "last_name": "Ferrara", + "institution": "IBM (United States)" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/BrutschyF014", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660201", + "title": "Compiler verification meets cross-language linking via data abstraction", + "abstract": "Many real programs are written in multiple different programming languages, and supporting this pattern creates challenges for formal compiler verification. We describe our Coq verification of a compiler for a high-level language, such that the compiler correctness theorem allows us to derive partial-correctness Hoare-logic theorems for programs built by linking the assembly code output by our compiler and assembly code produced by other means. Our compiler supports such tricky features as storable cross-language function pointers, without giving up the usual benefits of being able to verify different compiler phases (including, in our case, two classic optimizations) independently. The key technical innovation is a mixed operational and axiomatic semantics for the source language, with a built-in notion of abstract data types, such that compiled code interfaces with other languages only through axiomatically specified methods that mutate encapsulated private data, represented in whatever formats are most natural for those languages.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660201", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peng", + "last_name": "Wang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Santiago", + "last_name": "Cuéllar", + "institution": "Princeton University" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/WangCC14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660194", + "title": "Alembic: automatic locality extraction via migration", + "abstract": "Partitioned Global Address Space (PGAS) environments simplify writing parallel code for clusters because they make data movement implicit - dereferencing global pointers automatically moves data around. However, it does not free the programmer from needing to reason about locality - poor placement of data can lead to excessive and even unnecessary communication. For this reason, modern PGAS languages such as X10, Chapel, and UPC allow programmers to express data-layout constraints and explicitly move computation. This places an extra burden on the programmer, and is less effective for applications with limited or data-dependent locality (e.g., graph analytics).", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660194", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brandon Alexander", + "last_name": "Holt", + "institution": "University of Washington" + }, + { + "first_name": "Preston", + "last_name": "Briggs", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + }, + { + "first_name": "Mark", + "last_name": "Oskin", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/HoltBCO14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660199", + "title": "The hiphop virtual machine", + "abstract": "The HipHop Virtual Machine (HHVM) is a JIT compiler and runtime for PHP. While PHP values are dynamically typed, real programs often have latent types that are useful for optimization once discovered. Some types can be proven through static analysis, but limitations in the ahead-of-time approach leave some types to be discovered at run time. And even though many values have latent types, PHP programs can also contain polymorphic variables and expressions, which must be handled without catastrophic slowdown.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660199", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Keith", + "last_name": "Adams", + "institution": "Meta (United States)" + }, + { + "first_name": "J. L.", + "last_name": "Evans", + "institution": "Menlo School" + }, + { + "first_name": "Bertrand A.", + "last_name": "Maher", + "institution": "Menlo School" + }, + { + "first_name": "Guilherme", + "last_name": "Ottoni", + "institution": "Menlo School" + }, + { + "first_name": "Andrew", + "last_name": "Paroski", + "institution": "Menlo School" + }, + { + "first_name": "Brett", + "last_name": "Simmers", + "institution": "Menlo School" + }, + { + "first_name": "Edwin", + "last_name": "Smith", + "institution": "Meta (United States)" + }, + { + "first_name": "Owen", + "last_name": "Yamauchi", + "institution": "Meta (United States)" + } + ], + "dblp_key": "conf/oopsla/AdamsEMOPSSY14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660229", + "title": "Space-efficient multi-versioning for input-adaptive feedback-driven program optimizations", + "abstract": "Function versioning is an approach to addressing input-sensitivity of program optimizations. A major side effect of it is notable code size increase, which has been hindering its broad applications to large code bases and space-stringent environments. In this paper, we initiate a systematic exploration into the problem, providing answers to some fundamental questions: Given a space constraint, to which function we should apply versioning? How many versions of a function should we include in the final executable? Is the optimal selection feasible to do in polynomial time? This study proves selecting the best set of versions under a space constraint is NP-complete and proposes a heuristic algorithm named CHoGS which yields near optimal results in quadratic time. We implement the algorithm and conduct experiments through the IBM XL compilers. We observe significant performance enhancement with only slight code size increase; the results from CHoGS show factors of higher space efficiency than those from traditional hotness-based methods.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660229", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mingzhou", + "last_name": "Zhou", + "institution": "Williams (United States)" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + }, + { + "first_name": "Yaoqing", + "last_name": "Gao", + "institution": "IBM (Canada)" + }, + { + "first_name": "Graham", + "last_name": "Yiu", + "institution": "IBM (Canada)" + } + ], + "dblp_key": "conf/oopsla/ZhouSGY14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660205", + "title": "Validation of memory accesses through symbolic analyses", + "abstract": "The C programming language does not prevent out-of-bounds memory accesses. There exist several techniques to secure C programs; however, these methods tend to slow down these programs substantially, because they populate the binary code with runtime checks. To deal with this problem, we have designed and tested two static analyses - symbolic region and range analysis - which we combine to remove the majority of these guards. In addition to the analyses themselves, we bring two other contributions. First, we describe live range splitting strategies that improve the efficiency and the precision of our analyses. Secondly, we show how to deal with integer overflows, a phenomenon that can compromise the correctness of static algorithms that validate memory accesses. We validate our claims by incorporating our findings into AddressSanitizer. We generate SPEC CINT 2006 code that is 17% faster and 9% more energy efficient than the code produced originally by this tool. Furthermore, our approach is 50% more effective than Pentagons, a state-of-the-art analysis to sanitize memory accesses.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660205", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Henrique", + "last_name": "Nazaré", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Izabela Karennina Travizani", + "last_name": "Maffra", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Willer", + "last_name": "Santos", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Leonardo Valentino Soares", + "last_name": "Barbosa", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Laure", + "last_name": "Gonnord", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/oopsla/NazareMSBGP14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660227", + "title": "ASPIRE: exploiting asynchronous parallelism in iterative algorithms using a relaxed consistency based DSM", + "abstract": "Many vertex-centric graph algorithms can be expressed using asynchronous parallelism by relaxing certain read-after-write data dependences and allowing threads to compute vertex values using stale (i.e., not the most recent) values of their neighboring vertices. We observe that on distributed shared memory systems, by converting synchronous algorithms into their asynchronous counterparts, algorithms can be made tolerant to high inter-node communication latency. However, high inter-node communication latency can lead to excessive use of stale values causing an increase in the number of iterations required by the algorithms to converge. Although by using bounded staleness we can restrict the slowdown in the rate of convergence, this also restricts the ability to tolerate communication latency. In this paper we design a relaxed memory consistency model and consistency protocol that simultaneously tolerate communication latency and minimize the use of stale values. This is achieved via a coordinated use of best effort refresh policy and bounded staleness. We demonstrate that for a range of asynchronous graph algorithms and PDE solvers, on an average, our approach outperforms algorithms based upon: prior relaxed memory models that allow stale values by at least 2.27x; and Bulk Synchronous Parallel (BSP) model by 4.2x. We also show that our approach frequently outperforms GraphLab, a popular distributed graph processing framework.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660227", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Keval", + "last_name": "Vora", + "institution": "University of California, Riverside" + }, + { + "first_name": "Sai Charan", + "last_name": "Koduru", + "institution": "University of California, Riverside" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/oopsla/VoraKG14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660213", + "title": "Efficient subcubic alias analysis for C", + "abstract": "Inclusion-based alias analysis for C can be formulated as a context-free language (CFL) reachability problem. It is well known that the traditional cubic CFL-reachability algorithm does not scale well in practice. We present a highly scalable and efficient CFL-reachability-based alias analysis for C. The key novelty of our algorithm is to propagate reachability information along only original graph edges and bypass a large portion of summary edges, while the traditional CFL-reachability algorithm propagates along all summary edges. We also utilize the Four Russians' Trick - a key enabling technique in the subcubic CFL-reachability algorithm - in our alias analysis. We have implemented our subcubic alias analysis and conducted extensive experiments on widely-used C programs from the pointer analysis literature. The results demonstrate that our alias analysis scales extremely well in practice. In particular, it can analyze the recent Linux kernel (which consists of 10M SLOC) in about 30 seconds.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660213", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Xiao", + "last_name": "Xiao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Hao", + "last_name": "Yuan", + "institution": "" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/ZhangXZYS14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660228", + "title": "Translating imperative code to MapReduce", + "abstract": "We present an approach for automatic translation of sequential, imperative code into a parallel MapReduce framework. Automating such a translation is challenging: imperative updates must be translated into a functional MapReduce form in a manner that both preserves semantics and enables parallelism. Our approach works by first translating the input code into a functional representation, with loops succinctly represented by fold operations. Then, guided by rewrite rules, our system searches a space of equivalent programs for an effective MapReduce implementation. The rules include a novel technique for handling irregular loop-carried dependencies using group-by operations to enable greater parallelism. We have implemented our technique in a tool called Mold. It translates sequential Java code into code targeting the Apache Spark runtime. We evaluated Mold on several real-world kernels and found that in most cases Mold generated the desired MapReduce program, even for codes with complex indirect updates.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660228", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cosmin", + "last_name": "Radoi", + "institution": "University of Illinois System" + }, + { + "first_name": "Stephen J.", + "last_name": "Fink", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Rodric", + "last_name": "Rabbah", + "institution": "IBM (United States)" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "Samsung (United States)" + } + ], + "dblp_key": "conf/oopsla/RadoiFRS14", + "venue": "oopsla", + "year": 2014 + }, + { + "paper_id": "10.1145/2660193.2660204", + "title": "Cybertron: pushing the limit on I/O reduction in data-parallel programs", + "abstract": "I/O reduction has been a major focus in optimizing data-parallel programs for big-data processing. While the current state-of-the-art techniques use static program analysis to reduce I/O, Cybertron proposes a new direction that incorporates runtime mechanisms to push the limit further on I/O reduction. In particular, Cybertron tracks how data is used in the computation accurately at runtime to filter unused data at finer granularity dynamically, beyond what current static-analysis based mechanisms are capable of, and to facilitate a new mechanism called constraint based encoding for more efficient encoding. Cybertron has been implemented and applied to production data-parallel programs; our extensive evaluations on real programs and real data have shown its effectiveness on I/O reduction over the existing mechanisms at reasonable CPU cost, and its improvement on end-to-end performance in various network environments.", + "date": "2014-10-15", + "link": "https://doi.org/10.1145/2660193.2660204", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tian", + "last_name": "Xiao", + "institution": "Tsinghua University" + }, + { + "first_name": "Zhenyu", + "last_name": "Guo", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Hucheng", + "last_name": "Zhou", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Jiaxing", + "last_name": "Zhang", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Xu", + "last_name": "Zhao", + "institution": "University of Toronto" + }, + { + "first_name": "Chencheng", + "last_name": "Ye", + "institution": "Huazhong University of Science and Technology" + }, + { + "first_name": "Xi", + "last_name": "Wang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Wei", + "last_name": "Lin", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wenguang", + "last_name": "Chen", + "institution": "Tsinghua University" + }, + { + "first_name": "Lidong", + "last_name": "Zhou", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/XiaoGZZZYWLCZ14", + "venue": "oopsla", + "year": 2014 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2015.json b/data/pl_conferences/oopsla/2015.json new file mode 100644 index 0000000..47a3753 --- /dev/null +++ b/data/pl_conferences/oopsla/2015.json @@ -0,0 +1,1586 @@ +[ + { + "paper_id": "10.1145/2814270.2814297", + "title": "SATCheck: SAT-directed stateless model checking for SC and TSO", + "abstract": "Writing low-level concurrent code is well known to be challenging and error prone. The widespread deployment of multi-core hardware and the shift towards using low-level concurrent data structures has moved the problem into the mainstream. Finding bugs in such code may require finding a specific bug-revealing thread interleaving out of a huge space of parallel executions. Model-checking is a powerful technique for exhaustively testing code. However, scaling model checking presents a significant challenge. In this paper we present a new and more scalable technique for model checking concurrent code, based on concrete execution. Our technique observes concrete behaviors, builds a model of these behaviors, encodes the model in SAT, and leverages SAT solver technology to find executions that reveal new behaviors. It then runs the new execution, incorporates the newly observed behavior, and repeats the process until it has explored all reachable behaviors. We have implemented a prototype of our approach in the SATCheck tool. Our tool supports both the Total Store Ordering (TSO) and Sequentially Consistent (SC) memory models. We evaulate SATCheck by testing several concurrent data structure implementations and comparing its performance to the original DPOR stateless model checking algorithm implemented in CDSChecker, the source DPOR algorithm implemented in Nidhugg, and CheckFence. Our experiments show that SATCheck scales better than previous approaches while at the same time operating on concrete executions.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814297", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + }, + { + "first_name": "Patrick", + "last_name": "Lam", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/oopsla/DemskyL15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814306", + "title": "Reasoning about the POSIX file system: local update and global pathnames", + "abstract": "We introduce a program logic for specifying a core sequential subset of the POSIX file system and for reasoning abstractly about client programs working with the file system. The challenge is to reason about the combination of local directory update and global pathname traversal (including '..' and symbolic links) which may overlap the directories being updated. Existing reasoning techniques are either based on first-order logic and do not scale, or on separation logic and can only handle linear pathnames (no '..' or symbolic links). We introduce fusion logic for reasoning about local update and global pathname traversal, introducing a novel effect frame rule to propagate the effect of a local update on overlapping pathnames. We apply our reasoning to the standard recursive remove utility (rm -r), discovering bugs in well-known implementations.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814306", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gian", + "last_name": "Ntzik", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/NtzikG15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814298", + "title": "Automatic memory reclamation for lock-free data structures", + "abstract": "Lock-free data-structures are widely employed in practice, yet designing lock-free memory reclamation for them is notoriously difficult. In particular, all known lock-free reclamation schemes are ``manual'' in the sense that the developer has to specify when nodes have retired and may be reclaimed. Retiring nodes adequately is non-trivial and often requires the modification of the original lock-free algorithm. In this paper we present an automatic lock-free reclamation scheme for lock-free data-structures in the spirit of a mark-sweep garbage collection. The proposed algorithm works with any normalized lock-free algorithm and with no need for the programmer to retire nodes or make changes to the algorithm. Evaluation of the proposed scheme on a linked-list and a hash table shows that it performs similarly to the best manual (lock-free) memory reclamation scheme.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814298", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nachshon", + "last_name": "Cohen", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/CohenP15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814310", + "title": "FlashMeta: a framework for inductive program synthesis", + "abstract": "Inductive synthesis, or programming-by-examples (PBE) is gaining prominence with disruptive applications for automating repetitive tasks in end-user programming. However, designing, developing, and maintaining an effective industrial-quality inductive synthesizer is an intellectual and engineering challenge, requiring 1-2 man-years of effort. Our novel observation is that many PBE algorithms are a natural fall-out of one generic meta-algorithm and the domain-specific properties of the operators in the underlying domain-specific language (DSL). The meta-algorithm propagates example-based constraints on an expression to its subexpressions by leveraging associated witness functions, which essentially capture the inverse semantics of the underlying operator. This observation enables a novel program synthesis methodology called data-driven domain-specific deduction (D4), where domain-specific insight, provided by the DSL designer, is separated from the synthesis algorithm. Our FlashMeta framework implements this methodology, allowing synthesizer developers to generate an efficient synthesizer from the mere DSL definition (if properties of the DSL operators have been modeled). In our case studies, we found that 10+ existing industrial-quality mass-market applications based on PBE can be cast as instances of D4. Our evaluation includes reimplementation of some prior works, which in FlashMeta become more efficient, maintainable, and extensible. As a result, FlashMeta-based PBE tools are deployed in several industrial products, including Microsoft PowerShell 3.0 for Windows 10, Azure Operational Management Suite, and Microsoft Cortana digital assistant.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814310", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Oleksandr", + "last_name": "Polozov", + "institution": "University of Washington" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/PolozovG15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814292", + "title": "Valor: efficient, software-only region conflict exceptions", + "abstract": "Data races complicate programming language semantics, and a data race is often a bug. Existing techniques detect data races and define their semantics by detecting conflicts between synchronization-free regions (SFRs). However, such techniques either modify hardware or slow programs dramatically, preventing always-on use today. This paper describes Valor, a sound, precise, software-only region conflict detection analysis that achieves high performance by eliminating the costly analysis on each read operation that prior approaches require. Valor instead logs a region's reads and lazily detects conflicts for logged reads when the region ends. As a comparison, we have also developed FastRCD, a conflict detector that leverages the epoch optimization strategy of the FastTrack data race detector. We evaluate Valor, FastRCD, and FastTrack, showing that Valor dramatically outperforms FastRCD and FastTrack. Valor is the first region conflict detector to provide strong semantic guarantees for racy program executions with under 2X slowdown. Overall, Valor advances the state of the art in always-on support for strong behavioral guarantees for data races.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814292", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Swarnendu", + "last_name": "Biswas", + "institution": "The Ohio State University" + }, + { + "first_name": "Minjia", + "last_name": "Zhang", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/BiswasZBL15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814282", + "title": "Stateless model checking of event-driven applications", + "abstract": "Modern event-driven applications, such as, web pages and mobile apps, rely on asynchrony to ensure smooth end-user experience. Unfortunately, even though these applications are executed by a single event-loop thread, they can still exhibit nondeterministic behaviors depending on the execution order of interfering asynchronous events. As in classic shared-memory concurrency, this nondeterminism makes it challenging to discover errors that manifest only in specific schedules of events. In this work we propose the first stateless model checker for event-driven applications, called R4. Our algorithm systematically explores the nondeterminism in the application and concisely exposes its overall effect, which is useful for bug discovery. The algorithm builds on a combination of three key insights: (i) a dynamic partial order reduction (DPOR) technique for reducing the search space, tailored to the domain of event-driven applications, (ii) conflict-reversal bounding based on a hypothesis that most errors occur with a small number of event reorderings, and (iii) approximate replay of event sequences, which is critical for separating harmless from harmful nondeterminism. We instantiate R4 for the domain of client-side web applications and use it to analyze event interference in a number of real-world programs. The experimental results indicate that the precision and overall exploration capabilities of our system significantly exceed that of existing techniques.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814282", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Casper S.", + "last_name": "Jensen", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Dimitar", + "last_name": "Dimitrov", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/JensenMRDV15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814323", + "title": "Programming with enumerable sets of structures", + "abstract": "We present an efficient, modular, and feature-rich framework for automated generation and validation of complex structures, suitable for tasks that explore a large space of structured values. Our framework is capable of exhaustive, incremental, parallel, and memoized enumeration from not only finite but also infinite domains, while providing fine-grained control over the process. Furthermore, the framework efficiently supports the inverse of enumeration (checking whether a structure can be generated and fast-forwarding to this structure to continue the enumeration) and lazy enumeration (achieving exhaustive testing without generating all structures). The foundation of efficient enumeration lies in both direct access to encoded structures, achieved with well-known and new pairing functions, and dependent enumeration, which embeds constraints into the enumeration to avoid backtracking. Our framework defines an algebra of enumerators, with combinators for their composition that preserve exhaustiveness and efficiency. We have implemented our framework as a domain-specific language in Scala. Our experiments demonstrate better performance and shorter specifications by up to a few orders of magnitude compared to existing approaches.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814323", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivan", + "last_name": "Kuraj", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "Laboratoire d'Informatique Fondamentale de Lille" + }, + { + "first_name": "Daniel", + "last_name": "Jackson", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/KurajKJ15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814279", + "title": "Scrap your boilerplate with object algebras", + "abstract": "Traversing complex Abstract Syntax Trees (ASTs) typically requires large amounts of tedious boilerplate code. For many operations most of the code simply walks the structure, and only a small portion of the code implements the functionality that motivated the traversal in the first place. This paper presents a type-safe Java framework called Shy that removes much of this boilerplate code. In Shy object algebras are used to describe complex and extensible AST structures. Using Java annotations Shy generates generic boilerplate code for various types of traversals. For a concrete traversal, users of Shy can then inherit from the generated code and override only the interesting cases. Consequently, the amount of code that users need to write is significantly smaller. Moreover, traversals using the Shy framework are also much more structure shy, becoming more adaptive to future changes or extensions to the AST structure. To prove the effectiveness of the approach, we applied Shy in the implementation of a domain-specific questionnaire language. Our results show that for a large number of traversals there was a significant reduction in the amount of user-defined code.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814279", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haoyuan", + "last_name": "Zhang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Zewei", + "last_name": "Chu", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Tijs van der", + "last_name": "Storm", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/oopsla/ZhangCOS15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814316", + "title": "A sound and optimal incremental build system with dynamic dependencies", + "abstract": "Build systems are used in all but the smallest software projects to invoke the right build tools on the right files in the right order. A build system must be sound (after a build, generated files consistently reflect the latest source files) and efficient (recheck and rebuild as few build units as possible). Contemporary build systems provide limited efficiency because they lack support for expressing fine-grained file dependencies. We present a build system called pluto that supports the definition of reusable, parameterized, interconnected builders. When run, a builder notifies the build system about dynamically required and produced files as well as about other builders whose results are needed. To support fine-grained file dependencies, we generalize the traditional notion of time stamps to allow builders to declare their actual requirements on a file's content. pluto collects the requirements and products of a builder with their stamps in a build summary. This enables pluto to provides provably sound and optimal incremental rebuilding. To support dynamic dependencies, our rebuild algorithm interleaves dependency analysis and builder execution and enforces invariants on the dependency graph through a dynamic analysis. We have developed pluto as a Java API and used it to implement more than 25 builders. We describe our experience with migrating a larger Ant build script to pluto and compare the respective build times.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814316", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Moritz", + "last_name": "Lichter", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Manuel", + "last_name": "Weiel", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/oopsla/ErdwegLW15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814286", + "title": "AutoMO: automatic inference of memory order parameters for C/C++11", + "abstract": "Many concurrent data structures are initially designed for the sequential consistency (SC) memory model. Developers often implement these data structures on real-world systems with weaker memory models by adding sufficient fences to ensure that their implementation on the weak memory model exhibits the same executions as the SC memory model. Recently, the C11 and C++11 standards have added a weak memory model to the C and C++ languages. Developing and debugging code for weak memory models can be extremely challenging. We present AutoMO, a framework to support porting data structures designed for the SC memory model to the C/C++11 memory model. AutoMO provides support across the porting process: (1) it automatically infers initial settings for the memory order parameters, (2) it detects whether a C/C++11 execution is equivalent to some SC execution, and (3) it simplifies traces to make them easier to understand. We have used AutoMO to successfully infer memory order parameters for a range of data structures and to check whether executions of several concurrent data structure implementations are SC.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814286", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peizhao", + "last_name": "Ou", + "institution": "University of California, Irvine" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/oopsla/OuD15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814291", + "title": "Synthesis of layout engines from relational constraints", + "abstract": "We present an algorithm for synthesizing efficient document layout engines from compact relational specifications. These specifications are compact in that a single specification can produce multiple engines, each for a distinct layout situation, i.e., a different combination of known vs. unknown attributes. Technically, our specifications are relational attribute grammars, while our engines are functional attribute grammars. By synthesizing functions from relational constraints, we obviate the need for constraint solving at runtime, because functional attribute grammars can be easily evaluated according to a fixed schedule, sidestepping the backtracking search performed by constraint solvers. Our experiments show that we can generate layout engines for non-trivial data visualizations, and that our synthesized engines are between 39- and 200-times faster than general-purpose constraint solvers. Relational specifications of layout give rise to synthesis problems that have previously proved intractable. Our algorithm exploits the hierarchical, grammar-based structure of the specification, decomposing the specification into smaller subproblems, which can be tackled with off-the-shelf synthesis procedures. The new synthesis problem then becomes the composition of the functions thus generated into a correct attribute grammar, which might be recursive. We show how to solve this problem by efficient reduction to an SMT problem.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814291", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thibaud", + "last_name": "Hottelier", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/HottelierB15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814293", + "title": "Selective control-flow abstraction via jumping", + "abstract": "We present jumping, a form of selective control-flow abstraction useful for improving the scalability of goal-directed static analyses. Jumping is useful for analyzing programs with complex control-flow such as event-driven systems. In such systems, accounting for orderings between certain events is important for precision, yet analyzing the product graph of all possible event orderings is intractable. Jumping solves this problem by allowing the analysis to selectively abstract away control-flow between events irrelevant to a goal query while preserving information about the ordering of relevant events. We present a framework for designing sound jumping analyses and create an instantiation of the framework for per- forming precise inter-event analysis of Android applications. Our experimental evaluation showed that using jumping to augment a precise goal-directed analysis with inter-event reasoning enabled our analysis to prove 90–97% of dereferences safe across our benchmarks.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814293", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sam", + "last_name": "Blackshear", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "Samsung (United States)" + } + ], + "dblp_key": "conf/oopsla/BlackshearCS15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814304", + "title": "Automating grammar comparison", + "abstract": "We consider from a practical perspective the problem of checking equivalence of context-free grammars. We present techniques for proving equivalence, as well as techniques for finding counter-examples that establish non-equivalence. Among the key building blocks of our approach is a novel algorithm for efficiently enumerating and sampling words and parse trees from arbitrary context-free grammars; the algorithm supports polynomial time random access to words belonging to the grammar. Furthermore, we propose an algorithm for proving equivalence of context-free grammars that is complete for LL grammars, yet can be invoked on any context-free grammar, including ambiguous grammars. Our techniques successfully find discrepancies between different syntax specifications of several real-world languages, and are capable of detecting fine-grained incremental modifications performed on grammars. Our evaluation shows that our tool improves significantly on the existing available state of the art tools. In addition, we used these algorithms to develop an online tutoring system for grammars that we then used in an undergraduate course on computer language processing. On questions involving grammar constructions, our system was able to automatically evaluate the correctness of 95% of the solutions submitted by students: it disproved 74% of cases and proved 21% of them.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814304", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ravichandhran", + "last_name": "Madhavan", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Mikaël", + "last_name": "Mayer", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/MadhavanMGK15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814302", + "title": "Protocol-based verification of message-passing parallel programs", + "abstract": "We present ParTypes, a type-based methodology for the verification of Message Passing Interface (MPI) programs written in the C programming language. The aim is to statically verify programs against protocol specifications, enforcing properties such as fidelity and absence of deadlocks. We develop a protocol language based on a dependent type system for message-passing parallel programs, which includes various communication operators, such as point-to-point messages, broadcast, reduce, array scatter and gather. For the verification of a program against a given protocol, the protocol is first translated into a representation read by VCC, a software verifier for C. We successfully verified several MPI programs in a running time that is independent of the number of processes or other input parameters. This contrasts with alternative techniques, notably model checking and runtime verification, that suffer from the state-explosion problem or that otherwise depend on parameters to the program itself. We experimentally evaluated our approach against state-of-the-art tools for MPI to conclude that our approach offers a scalable solution.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814302", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hugo A.", + "last_name": "López", + "institution": "" + }, + { + "first_name": "Eduardo R. B.", + "last_name": "Marques", + "institution": "University of Lisbon" + }, + { + "first_name": "Francisco", + "last_name": "Martins", + "institution": "University of Lisbon" + }, + { + "first_name": "Nicholas", + "last_name": "Ng", + "institution": "Imperial College London" + }, + { + "first_name": "César", + "last_name": "Santos", + "institution": "University of Lisbon" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/LopezMMNSVY15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814288", + "title": "Detecting redundant CSS rules in HTML5 applications: a tree rewriting approach", + "abstract": "HTML5 applications normally have a large set of CSS (Cascading Style Sheets) rules for data display. Each CSS rule consists of a node selector and a declaration block (which assigns values to selected nodes' display attributes). As web applications evolve, maintaining CSS files can easily become problematic. Some CSS rules will be replaced by new ones, but these obsolete (hence redundant) CSS rules often remain in the applications. Not only does this “bloat” the applications – increasing the bandwidth requirement – but it also significantly increases web browsers' processing time. Most works on detecting redundant CSS rules in HTML5 applications do not consider the dynamic behaviours of HTML5 (specified in JavaScript); in fact, the only proposed method that takes these into account is dynamic analysis, which cannot soundly prove redundancy of CSS rules. In this paper, we introduce an abstraction of HTML5 applications based on monotonic tree-rewriting and study its \"redundancy problem\". We establish the precise complexity of the problem and various subproblems of practical importance (ranging from P to EXP). In particular, our algorithm relies on an efficient reduction to an analysis of symbolic pushdown systems (for which highly optimised solvers are available), which yields a fast method for checking redundancy in practice. We implemented our algorithm and demonstrated its efficacy in detecting redundant CSS rules in HTML5 applications.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814288", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "University of London" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "Yale-NUS College" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/oopsla/HagueLO15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814278", + "title": "Conditionally correct superoptimization", + "abstract": "The aggressive optimization of heavily used kernels is an important problem in high-performance computing. However, both general purpose compilers and highly specialized tools such as superoptimizers often do not have sufficient static knowledge of restrictions on program inputs that could be exploited to produce the very best code. For many applications, the best possible code is conditionally correct: the optimized kernel is equal to the code that it replaces only under certain preconditions on the kernel's inputs. The main technical challenge in producing conditionally correct optimizations is in obtaining non-trivial and useful conditions and proving conditional equivalence formally in the presence of loops. We combine abstract interpretation, decision procedures, and testing to yield a verification strategy that can address both of these problems. This approach yields a superoptimizer for x86 that in our experiments produces binaries that are often multiple times faster than those produced by production compilers.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814278", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Eric", + "last_name": "Schkufza", + "institution": "Stanford University" + }, + { + "first_name": "Berkeley", + "last_name": "Churchill", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/0001SCA15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814303", + "title": "Scalable race detection for Android applications", + "abstract": "We present a complete end-to-end dynamic analysis system for finding data races in mobile Android applications. The capabilities of our system significantly exceed the state of the art: our system can analyze real-world application interactions in minutes rather than hours, finds errors inherently beyond the reach of existing approaches, while still (critically) reporting very few false positives. Our system is based on three key concepts: (i) a thorough happens-before model of Android-specific concurrency, (ii) a scalable analysis algorithm for efficiently building and querying the happens-before graph, and (iii) an effective set of domain-specific filters that reduce the number of reported data races by several orders of magnitude. We evaluated the usability and performance of our system on 354 real-world Android applications (e.g., Facebook). Our system analyzes a minute of end-user interaction with the application in about 24 seconds, while current approaches take hours to complete. Inspecting the results for 8 large open-source applications revealed 15 harmful bugs of diverse kinds. Some of the bugs we reported were confirmed and fixed by developers.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814303", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pavol", + "last_name": "Bielik", + "institution": "ETH Zurich" + }, + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/BielikRV15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814274", + "title": "Interactively verifying absence of explicit information flows in Android apps", + "abstract": "App stores are increasingly the preferred mechanism for distributing software, including mobile apps (Google Play), desktop apps (Mac App Store and Ubuntu Software Center), computer games (the Steam Store), and browser extensions (Chrome Web Store). The centralized nature of these stores has important implications for security. While app stores have unprecedented ability to audit apps, users now trust hosted apps, making them more vulnerable to malware that evades detection and finds its way onto the app store. Sound static explicit information flow analysis has the potential to significantly aid human auditors, but it is handicapped by high false positive rates. Instead, auditors currently rely on a combination of dynamic analysis (which is unsound) and lightweight static analysis (which cannot identify information flows) to help detect malicious behaviors. We propose a process for producing apps certified to be free of malicious explicit information flows. In practice, imprecision in the reachability analysis is a major source of false positive information flows that are difficult to understand and discharge. In our approach, the developer provides tests that specify what code is reachable, allowing the static analysis to restrict its search to tested code. The app hosted on the store is instrumented to enforce the provided specification (i.e., executing untested code terminates the app). We use abductive inference to minimize the necessary instrumentation, and then interact with the developer to ensure that the instrumentation only cuts unreachable code. We demonstrate the effectiveness of our approach in verifying a corpus of 77 Android apps—our interactive verification process successfully discharges 11 out of the 12 false positives.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814274", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "Stanford University" + }, + { + "first_name": "Saswat", + "last_name": "Anand", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/BastaniAA15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814296", + "title": "ShamDroid: gracefully degrading functionality in the presence of limited resource access", + "abstract": "Given a program whose functionality depends on access to certain external resources, we investigate the question of how to gracefully degrade functionality when a subset of those resources is unavailable. The concrete setting motivating this problem statement is mobile applications, which rely on contextual data (e.g., device identifiers, user location and contacts, etc.) to fulfill their functionality. In particular, we focus on the Android platform, which mediates access to resources via an installation-time permission model. On the one hand, granting an app the permission to access a resource (e.g., the device ID) entails privacy threats (e.g., releasing the device ID to advertising servers). On the other hand, denying access to a resource could render the app useless (e.g., if inability to read the device ID is treated as an error state). Our goal is to specialize an existing Android app in such a way that it is disabled from accessing certain sensitive resources (or contextual data) as specified by the user, while still being able to execute functionality that does not depend on those resources. We present ShamDroid, a program transformation algorithm, based on specialized forms of program slicing, backwards static analysis and constraint solving, that enables the use of Android apps with partial permissions. We rigorously state the guarantees provided by ShamDroid w.r.t. functionality maximization. We provide an evaluation over the top 500 Google Play apps and report on an extensive comparative evaluation of ShamDroid against three other state-of-the-art solutions (APM, XPrivacy, and Google App Ops) that mediate resource access at the system (rather than app) level. ShamDroid performs better than all of these tools by a significant margin, leading to abnormal behavior in only 1 out of 27 apps we manually investigated, compared to the other solutions, which cause crashes and abnormalities in 9 or more of the apps. This demonstrates the importance of performing app-sensitive mocking.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814296", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lucas", + "last_name": "Brutschy", + "institution": "ETH Zurich" + }, + { + "first_name": "Pietro", + "last_name": "Ferrara", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "IBM Research - Austin" + }, + { + "first_name": "Marco", + "last_name": "Pistoia", + "institution": "IBM Research - Austin" + } + ], + "dblp_key": "conf/oopsla/BrutschyFTP15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814319", + "title": "Finding deep compiler bugs via guided stochastic program mutation", + "abstract": "Compiler testing is important and challenging. Equivalence Modulo Inputs (EMI) is a recent promising approach for compiler validation. It is based on mutating the unexecuted statements of an existing program under some inputs to produce new equivalent test programs w.r.t. these inputs. Orion is a simple realization of EMI by only randomly deleting unexecuted statements. Despite its success in finding many bugs in production compilers, Orion’s effectiveness is still limited by its simple, blind mutation strategy. To more effectively realize EMI, this paper introduces a guided, advanced mutation strategy based on Bayesian optimization. Our goal is to generate diverse programs to more thoroughly exercise compilers. We achieve this with two techniques: (1) the support of both code deletions and insertions in the unexecuted regions, leading to a much larger test program space; and (2) the use of an objective function that promotes control-flow-diverse programs for guiding Markov Chain Monte Carlo (MCMC) optimization to explore the search space. Our technique helps discover deep bugs that require elaborate mutations. Our realization, Athena, targets C compilers. In 19 months, Athena has found 72 new bugs — many of which are deep and important bugs — in GCC and LLVM. Developers have confirmed all 72 bugs and fixed 68 of them.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814319", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vu", + "last_name": "Le", + "institution": "University of California, Davis" + }, + { + "first_name": "C. P.", + "last_name": "Sun", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/LeSS15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814318", + "title": "Declarative fence insertion", + "abstract": "Previous work has shown how to insert fences that enforce sequential consistency. However, for many concurrent algorithms, sequential consistency is unnecessarily strong and can lead to high execution overhead. The reason is that, often, correctness relies on the execution order of a few specific pairs of instructions. Algorithm designers can declare those execution orders and thereby enable memory-model-independent reasoning about correctness and also ease implementation of algorithms on multiple platforms. The literature has examples of such reasoning, while tool support for enforcing the orders has been lacking until now. In this paper we present a declarative approach to specify and enforce execution orders. Our fence insertion algorithm first identifies the execution orders that a given memory model enforces automatically, and then inserts fences that enforce the rest. Our benchmarks include three off-the-shelf transactional memory algorithms written in C/C++ for which we specify suitable execution orders. For those benchmarks, our experiments with the x86 and ARMv7 memory models show that our tool inserts fences that are competitive with those inserted by the original authors. Our tool is the first to insert fences into transactional memory algorithms and it solves the long-standing problem of how to easily port such algorithms to a novel memory model.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814318", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Bender", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/oopsla/BenderLP15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814320", + "title": "Versatile yet lightweight record-and-replay for Android", + "abstract": "Recording and replaying the execution of smartphone apps is useful in a variety of contexts, from reproducing bugs to profiling and testing. Achieving effective record-and-replay is a balancing act between accuracy and overhead. On smartphones, the act is particularly complicated, because smartphone apps receive a high-bandwidth stream of input (e.g., network, GPS, camera, microphone, touchscreen) and concurrency events, but the stream has to be recorded and replayed with minimal overhead, to avoid interfering with app execution. Prior record-and-replay approaches have focused on replaying machine instructions or system calls, which is not a good fit on smartphones. We propose a novel, stream-oriented record-and-replay approach which achieves high-accuracy and low-overhead by aiming at a sweet spot: recording and replaying sensor and network input, event schedules, and inter-app communication via intents. To demonstrate the versatility of our approach, we have constructed a tool named VALERA that supports record-and-replay on the Android platform. VALERA works with apps running directly on the phone, and does not require access to the app source code. Through an evaluation on 50 popular Android apps, we show that: VALERA's replay fidelity far exceeds current record-and-replay approaches for Android; VALERA's precise timing control and low overhead (about 1% for either record or replay) allows it to replay high-throughput, timing-sensitive apps such as video/audio capture and recognition; and VALERA's support for event schedule replay enables the construction of useful analyses, such as reproducing event-driven race bugs.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814320", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yongjian", + "last_name": "Hu", + "institution": "University of California, Riverside" + }, + { + "first_name": "Tanzirul", + "last_name": "Azim", + "institution": "University of California, Riverside" + }, + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/oopsla/HuAN15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814272", + "title": "Static analysis of event-driven Node.js JavaScript applications", + "abstract": "Many JavaScript programs are written in an event-driven style. In particular, in server-side Node.js applications, op-erations involving sockets, streams, and files are typically performed in an asynchronous manner, where the execution of listeners is triggered by events. Several types of program-ming errors are specific to such event-based programs (e.g., unhandled events, and listeners that are registered too late). We present the event-based call graph, a program represen-tation that can be used to detect bugs related to event han-dling. We have designed and implemented three analyses for constructing event-based call graphs. Our results show that these analyses are capable of detecting problems reported on StackOverflow. Moreover, we show that the number of false positives reported by the analysis on a suite of small Node.js applications is manageable.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814272", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "University of Waterloo" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Samsung (United States)" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/oopsla/MadsenTL15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814307", + "title": "Giga-scale exhaustive points-to analysis for Java in under a minute", + "abstract": "Computing a precise points-to analysis for very large Java programs remains challenging despite the large body of research on points-to analysis. Any approach must solve an underlying dynamic graph reachability problem, for which the best algorithms have near-cubic worst-case runtime complexity, and, hence, previous work does not scale to programs with millions of lines of code. In this work, we present a novel approach for solving the field-sensitive points-to problem for Java with the means of (1) a transitive-closure data-structure, and (2) a pre-computed set of potentially matching load/store pairs to accelerate the fix-point calculation. Experimentation on Java benchmarks validates the superior performance of our approach over the standard context-free language reachability implementations. Our approach computes a points-to index for the OpenJDK with over 1.5 billion tuples in under a minute.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814307", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jens", + "last_name": "Dietrich", + "institution": "Massey University" + }, + { + "first_name": "Nicholas", + "last_name": "Hollingum", + "institution": "University of Sydney" + }, + { + "first_name": "Bernhard", + "last_name": "Scholz", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/DietrichHS15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814295", + "title": "Synthesizing Java expressions from free-form queries", + "abstract": "We present a new code assistance tool for integrated development environments. Our system accepts as input free-form queries containing a mixture of English and Java, and produces Java code expressions that take the query into account and respect syntax, types, and scoping rules of Java, as well as statistical usage patterns. In contrast to solutions based on code search, the results returned by our tool need not directly correspond to any previously seen code fragment. As part of our system we have constructed a probabilistic context free grammar for Java constructs and library invocations, as well as an algorithm that uses a customized natural language processing tool chain to extract information from free-form text queries. We present the results on a number of examples showing that our technique (1) often produces the expected code fragments, (2) tolerates much of the flexibility of natural language, and (3) can repair incorrect Java expressions that use, for example, the wrong syntax or missing arguments.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814295", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tihomir", + "last_name": "Gvero", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/GveroK15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814322", + "title": "Cross-layer memory management for managed language applications", + "abstract": "Performance and energy efficiency in memory have become critically important for a wide range of computing domains. However, it is difficult to control and optimize memory power and performance because these effects depend upon activity across multiple layers of the vertical execution stack. To address this challenge, we construct a novel and collaborative framework that employs object placement, cross-layer communication, and page-level management to effectively distribute application objects in the DRAM hardware to achieve desired power/performance goals. In this work, we describe the design and implementation of our framework, which is the first to integrate automatic object profiling and analysis at the application layer with fine-grained management of memory hardware resources in the operating system. We demonstrate the utility of our framework by employing it to more effectively control memory power consumption. We design a custom memory-intensive workload to show the potential of our approach. Next, we develop sampling and profiling-based analyses and modify the code generator in the HotSpot VM to understand object usage patterns and automatically determine and control the placement of hot and cold objects in a partitioned VM heap. This information is communicated to the operating system, which uses it to map the logical application pages to the appropriate DRAM ranks according to user-defined provisioning goals. We evaluate our framework and find that it achieves our test goal of significant DRAM energy savings across a variety of workloads, without any source code modifications or recompilations.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814322", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael R.", + "last_name": "Jantz", + "institution": "University of Tennessee at Knoxville" + }, + { + "first_name": "Forrest J.", + "last_name": "Robinson", + "institution": "University of Kansas" + }, + { + "first_name": "Prasad A.", + "last_name": "Kulkarni", + "institution": "University of Kansas" + }, + { + "first_name": "Kshitij", + "last_name": "Doshi", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/oopsla/JantzRKD15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814301", + "title": "Probability type inference for flexible approximate programming", + "abstract": "In approximate computing, programs gain efficiency by allowing occasional errors. Controlling the probabilistic effects of this approximation remains a key challenge. We propose a new approach where programmers use a type system to communicate high-level constraints on the degree of approximation. A combination of type inference, code specialization, and optional dynamic tracking makes the system expressive and convenient. The core type system captures the probability that each operation exhibits an error and bounds the probability that each expression deviates from its correct value. Solver-aided type inference lets the programmer specify the correctness probability on only some variables—program outputs, for example—and automatically fills in other types to meet these specifications. An optional dynamic type helps cope with complex run-time behavior where static approaches are insufficient. Together, these features interact to yield a high degree of programmer control while offering a strong soundness guarantee. We use existing approximate-computing benchmarks to show how our language, DECAF, maintains a low annotation burden. Our constraint-based approach can encode hardware details, such as finite degrees of reliability, so we also use DECAF to examine implications for approximate hardware design. We find that multi-level architectures can offer advantages over simpler two-level machines and that solver-aided optimization improves efficiency.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814301", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brett", + "last_name": "Boston", + "institution": "University of Washington" + }, + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Luís", + "last_name": "Ceze", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/BostonSGC15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814294", + "title": "Fast, multicore-scalable, low-fragmentation memory allocation through large virtual memory and global data structures", + "abstract": "We demonstrate that general-purpose memory allocation involving many threads on many cores can be done with high performance, multicore scalability, and low memory consumption. For this purpose, we have designed and implemented scalloc, a concurrent allocator that generally performs and scales in our experiments better than other allocators while using less memory, and is still competitive otherwise. The main ideas behind the design of scalloc are: uniform treatment of small and big objects through so-called virtual spans, efficiently and effectively reclaiming free memory through fast and scalable global data structures, and constant-time (modulo synchronization) allocation and deallocation operations that trade off memory reuse and spatial locality without being subject to false sharing.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814294", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Aigner", + "institution": "University of Salzburg" + }, + { + "first_name": "Christoph", + "last_name": "Kirsch", + "institution": "University of Salzburg" + }, + { + "first_name": "Michael", + "last_name": "Lippautz", + "institution": "University of Salzburg" + }, + { + "first_name": "Ana", + "last_name": "Sokolova", + "institution": "University of Salzburg" + } + ], + "dblp_key": "conf/oopsla/0003KLS15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814273", + "title": "Vectorization of apply to reduce interpretation overhead of R", + "abstract": "R is a popular dynamic language designed for statistical computing. Despite R's huge user base, the inefficiency in R's language implementation becomes a major pain-point in everyday use as well as an obstacle to apply R to solve large scale analytics problems. The two most common approaches to improve the performance of dynamic languages are: implementing more efficient interpretation strategies and extending the interpreter with Just-In-Time (JIT) compiler. However, both approaches require significant changes to the interpreter, and complicate the adoption by development teams as a result. This paper presents a new approach to improve execution efficiency of R programs by vectorizing the widely used Apply class of operations. Apply accepts two parameters: a function and a collection of input data elements. The standard implementation of Apply iteratively invokes the input function with each element in the data collection. Our approach combines data transformation and function vectorization to convert the looping-over-data execution of the standard Apply into a single invocation of a vectorized function that contains a sequence of vector operations over the input data. This conversion can significantly speed-up the execution of Apply operations in R by reducing the number of interpretation steps. We implemented the vectorization transformation as an R package. To enable the optimization, all that is needed is to invoke the package, and the user can use a normal R interpreter without any changes. The evaluation shows that the proposed method delivers significant performance improvements for a collection of data analysis algorithm benchmarks. This is achieved without any native code generation and using only a single-thread of execution.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814273", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haichuan", + "last_name": "Wang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Peng", + "last_name": "Wu", + "institution": "Huawei Technologies (United States)" + } + ], + "dblp_key": "conf/oopsla/WangPW15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814284", + "title": "EXPLORER : query- and demand-driven exploration of interprocedural control flow properties", + "abstract": "This paper describes a general framework and its implementation in a tool called EXPLORER for statically answering a class of interprocedural control flow queries about Java programs. EXPLORER allows users to formulate queries about feasible callstack configurations using regular expressions, and it employs a precise, demand-driven algorithm for answering such queries. Specifically, EXPLORER constructs an automaton A that is iteratively refined until either the language accepted by A is empty (meaning that the query has been refuted) or until no further refinement is possible based on a precise, context-sensitive abstraction of the program. We evaluate EXPLORER by applying it to three different program analysis tasks, namely, (1) analysis of the observer design pattern in Java, (2) identification of a class of performance bugs, and (3) analysis of inter-component communication in Android applications. Our evaluation shows that EXPLORER is both efficient and precise.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814284", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Calvin", + "last_name": "Lin", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/FengWDL15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814281", + "title": "Accurate profiling in the presence of dynamic compilation", + "abstract": "Many profilers based on bytecode instrumentation yield wrong results in the presence of an optimizing dynamic compiler, either due to not being aware of optimizations such as stack allocation and method inlining, or due to the inserted code disrupting such optimizations. To avoid such perturbations, we present a novel technique to make any profiler implemented at the bytecode level aware of optimizations performed by the dynamic compiler. We implement our approach in a state-of-the-art Java virtual machine and demonstrate its significance with concrete profilers. We quantify the impact of escape analysis on allocation profiling, object life-time analysis, and the impact of method inlining on callsite profiling. We illustrate how our approach enables new kinds of profilers, such as a profiler for non-inlined callsites, and a testing framework for locating performance bugs in dynamic compiler implementations.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814281", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yudi", + "last_name": "Zheng", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Lubomír", + "last_name": "Bulej", + "institution": "Charles University" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/oopsla/ZhengBB15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814308", + "title": "Galois transformers and modular abstract interpreters: reusable metatheory for program analysis", + "abstract": "The design and implementation of static analyzers has become increasingly systematic. Yet for a given language or analysis feature, it often requires tedious and error prone work to implement an analyzer and prove it sound. In short, static analysis features and their proofs of soundness do not compose well, causing a dearth of reuse in both implementation and metatheory. We solve the problem of systematically constructing static analyzers by introducing Galois transformers: monad transformers that transport Galois connection properties. In concert with a monadic interpreter, we define a library of monad transformers that implement building blocks for classic analysis parameters like context, path, and heap (in)sensitivity. Moreover, these can be composed together independent of the language being analyzed. Significantly, a Galois transformer can be proved sound once and for all, making it a reusable analysis component. As new analysis features and abstractions are developed and mixed in, soundness proofs need not be reconstructed, as the composition of a monad transformer stack is sound by virtue of its constituents. Galois transformers provide a viable foundation for reusable and composable metatheory for program analysis. Finally, these Galois transformers shift the level of abstraction in analysis design and implementation to a level where non-specialists have the ability to synthesize sound analyzers over a number of parameters.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814308", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Darais", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/DaraisMH15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814309", + "title": "Learning a strategy for adapting a program analysis via bayesian optimisation", + "abstract": "Building a cost-effective static analyser for real-world programs is still regarded an art. One key contributor to this grim reputation is the difficulty in balancing the cost and the precision of an analyser. An ideal analyser should be adaptive to a given analysis task, and avoid using techniques that unnecessarily improve precision and increase analysis cost. However, achieving this ideal is highly nontrivial, and it requires a large amount of engineering efforts. In this paper we present a new approach for building an adaptive static analyser. In our approach, the analyser includes a sophisticated parameterised strategy that decides, for each part of a given program, whether to apply a precision-improving technique to that part or not. We present a method for learning a good parameter for such a strategy from an existing codebase via Bayesian optimisation. The learnt strategy is then used for new, unseen programs. Using our approach, we developed partially flow- and context-sensitive variants of a realistic C static analyser. The experimental results demonstrate that using Bayesian optimisation is crucial for learning from an existing codebase. Also, they show that among all program queries that require flow- or context-sensitivity, our partially flow- and context-sensitive analysis answers the 75% of them, while increasing the analysis cost only by 3.3x of the baseline flow- and context-insensitive analysis, rather than 40x or more of the fully sensitive version.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814309", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/oopsla/OhYY15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814285", + "title": "Runtime pointer disambiguation", + "abstract": "To optimize code effectively, compilers must deal with memory dependencies. However, the state-of-the-art heuristics available in the literature to track memory dependencies are inherently imprecise and computationally expensive. Consequently, the most advanced code transformations that compilers have today are ineffective when applied on real-world programs. The goal of this paper is to solve this conundrum through dynamic disambiguation of pointers. We provide different ways to determine at runtime when two memory locations can overlap. We then produce two versions of a code region: one that is aliasing-free - hence, easy to optimize - and another that is not. Our checks let us safely branch to the optimizable region. We have applied these ideas on Polly-LLVM, a loop optimizer built on top of the LLVM compilation infrastructure. Our experiments indicate that our method is precise, effective and useful: we can disambiguate every pair of pointer in the loop intensive Polybench benchmark suite. The result of this precision is code quality: the binaries we generate are 10% faster than those that Polly-LLVM produces without our optimization, at the -O3 optimization level of LLVM.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814285", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Péricles", + "last_name": "Alves", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fabian M.", + "last_name": "Gruber", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Johannes", + "last_name": "Doerfert", + "institution": "Saarland University" + }, + { + "first_name": "Alexandros", + "last_name": "Lamprineas", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "ETH Zurich" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/oopsla/AlvesGDLGRP15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814290", + "title": "Performance problems you can fix: a dynamic analysis of memoization opportunities", + "abstract": "Performance bugs are a prevalent problem and recent research proposes various techniques to identify such bugs. This paper addresses a kind of performance problem that often is easy to address but difficult to identify: redundant computations that may be avoided by reusing already computed results for particular inputs, a technique called memoization. To help developers find and use memoization opportunities, we present MemoizeIt, a dynamic analysis that identifies methods that repeatedly perform the same computation. The key idea is to compare inputs and outputs of method calls in a scalable yet precise way. To avoid the overhead of comparing objects at all method invocations in detail, MemoizeIt first compares objects without following any references and iteratively increases the depth of exploration while shrinking the set of considered methods. After each iteration, the approach ignores methods that cannot benefit from memoization, allowing it to analyze calls to the remaining methods in more detail. For every memoization opportunity that MemoizeIt detects, it provides hints on how to implement memoization, making it easy for the developer to fix the performance issue. Applying MemoizeIt to eleven real-world Java programs reveals nine profitable memoization opportunities, most of which are missed by traditional CPU time profilers, conservative compiler optimizations, and other existing approaches for finding performance bugs. Adding memoization as proposed by MemoizeIt leads to statistically significant speedups by factors between 1.04x and 12.93x.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814290", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luca Della", + "last_name": "Toffola", + "institution": "ETH Zurich" + }, + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/ToffolaPG15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814299", + "title": "RAIVE: runtime assessment of floating-point instability by vectorization", + "abstract": "Floating point representation has limited precision and inputs to floating point programs may also have errors. Consequently, during execution, errors are introduced, propagated, and accumulated, leading to unreliable outputs. We call this the instability problem. We propose RAIVE, a technique that identifies output variations of a floating point execution in the presence of instability. RAIVE transforms every floating point value to a vector of multiple values – the values added to create the vector are obtained by introducing artifi- cial errors that are upper bounds of actual errors. The propagation of artificial errors models the propagation of actual errors. When values in vectors result in discrete execution differences (e.g., following different paths), the execution is forked to capture the resulting output variations. Our evaluation shows that RAIVE can precisely capture output variations. Its overhead (340%) is 2.43 times lower than the state of the art", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814299", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wen‐Chuan", + "last_name": "Lee", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tao", + "last_name": "Bao", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yunhui", + "last_name": "Zheng", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Keval", + "last_name": "Vora", + "institution": "University of California, Riverside" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/oopsla/LeeBZZVG15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814300", + "title": "How scale affects structure in Java programs", + "abstract": "Many internal software metrics and external quality attributes of Java programs correlate strongly with program size. This knowledge has been used pervasively in quantitative studies of software through practices such as normalization on size metrics. This paper reports size-related super- and sublinear effects that have not been known before. Findings obtained on a very large collection of Java programs -- 30,911 projects hosted at Google Code as of Summer 2011 -- unveils how certain characteristics of programs vary disproportionately with program size, sometimes even non-monotonically. Many of the specific parameters of nonlinear relations are reported. This result gives further insights for the differences of ``programming in the small'' vs. ``programming in the large.'' The reported findings carry important consequences for OO software metrics, and software research in general: metrics that have been known to correlate with size can now be properly normalized so that all the information that is left in them is size-independent.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814300", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cristina Videira", + "last_name": "Lopes", + "institution": "University of California, Irvine" + }, + { + "first_name": "Joel", + "last_name": "Ossher", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/oopsla/LopesO15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814271", + "title": "Automating ad hoc data representation transformations", + "abstract": "To maximize run-time performance, programmers often specialize their code by hand, replacing library collections and containers by custom objects in which data is restructured for efficient access. However, changing the data representation is a tedious and error-prone process that makes it hard to test, maintain and evolve the source code. We present an automated and composable mechanism that allows programmers to safely change the data representation in delimited scopes containing anything from expressions to entire class definitions. To achieve this, programmers define a transformation and our mechanism automatically and transparently applies it during compilation, eliminating the need to manually change the source code. Our technique leverages the type system in order to offer correctness guarantees on the transformation and its interaction with object-oriented language features, such as dynamic dispatch, inheritance and generics. We have embedded this technique in a Scala compiler plugin and used it in four very different transformations, ranging from improving the data layout and encoding, to retrofitting specialization and value class status, and all the way to collection deforestation. On our benchmarks, the technique obtained speedups between 1.8x and 24.5x.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814271", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vlad", + "last_name": "Ureche", + "institution": "Laboratoire d'Informatique Fondamentale de Lille" + }, + { + "first_name": "Aggelos", + "last_name": "Biboudis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "Laboratoire d'Informatique Fondamentale de Lille" + } + ], + "dblp_key": "conf/oopsla/UrecheBSO15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814313", + "title": "Use at your own risk: the Java unsafe API in the wild", + "abstract": "Java is a safe language. Its runtime environment provides strong safety guarantees that any Java application can rely on. Or so we think. We show that the runtime actually does not provide these guarantees---for a large fraction of today's Java code. Unbeknownst to many application developers, the Java runtime includes a \"backdoor\" that allows expert library and framework developers to circumvent Java's safety guarantees. This backdoor is there by design, and is well known to experts, as it enables them to write high-performance \"systems-level\" code in Java. For much the same reasons that safe languages are preferred over unsafe languages, these powerful---but unsafe---capabilities in Java should be restricted. They should be made safe by changing the language, the runtime system, or the libraries. At the very least, their use should be restricted. This paper is a step in that direction. We analyzed 74 GB of compiled Java code, spread over 86,479 Java archives, to determine how Java's unsafe capabilities are used in real-world libraries and applications. We found that 25% of Java bytecode archives depend on unsafe third-party Java code, and thus Java's safety guarantees cannot be trusted. We identify 14 different usage patterns of Java's unsafe capabilities, and we provide supporting evidence for why real-world code needs these capabilities. Our long-term goal is to provide a foundation for the design of new language features to regain safety in Java.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814313", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luis", + "last_name": "Mastrangelo", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Luca", + "last_name": "Ponzanelli", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Andrea", + "last_name": "Mocci", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Michele", + "last_name": "Lanza", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Matthias", + "last_name": "Hauswirth", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Nathaniel", + "last_name": "Nystrom", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/oopsla/MastrangeloPMLH15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814312", + "title": "Optimizing hash-array mapped tries for fast and lean immutable JVM collections", + "abstract": "The data structures under-pinning collection API (e.g. lists, sets, maps) in the standard libraries of programming languages are used intensively in many applications. The standard libraries of recent Java Virtual Machine languages, such as Clojure or Scala, contain scalable and well-performing immutable collection data structures that are implemented as Hash-Array Mapped Tries (HAMTs). HAMTs already feature efficient lookup, insert, and delete operations, however due to their tree-based nature their memory footprints and the runtime performance of iteration and equality checking lag behind array-based counterparts. This particularly prohibits their application in programs which process larger data sets. In this paper, we propose changes to the HAMT design that increase the overall performance of immutable sets and maps. The resulting general purpose design increases cache locality and features a canonical representation. It outperforms Scala’s and Clojure’s data structure implementations in terms of memory footprint and runtime efficiency of iteration (1.3–6.7x) and equality checking (3–25.4x).", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814312", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael J.", + "last_name": "Steindorfer", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Jurgen", + "last_name": "Vinju", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/oopsla/SteindorferV15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814275", + "title": "Tracing vs. partial evaluation: comparing meta-compilation approaches for self-optimizing interpreters", + "abstract": "Tracing and partial evaluation have been proposed as meta-compilation techniques for interpreters to make just-in-time compilation language-independent. They promise that programs executing on simple interpreters can reach performance of the same order of magnitude as if they would be executed on state-of-the-art virtual machines with highly optimizing just-in-time compilers built for a specific language. Tracing and partial evaluation approach this meta-compilation from two ends of a spectrum, resulting in different sets of tradeoffs. This study investigates both approaches in the context of self-optimizing interpreters, a technique for building fast abstract-syntax-tree interpreters. Based on RPython for tracing and Truffle for partial evaluation, we assess the two approaches by comparing the impact of various optimizations on the performance of an interpreter for SOM, an object-oriented dynamically-typed language. The goal is to determine whether either approach yields clear performance or engineering benefits. We find that tracing and partial evaluation both reach roughly the same level of performance. SOM based on meta-tracing is on average 3x slower than Java, while SOM based on partial evaluation is on average 2.3x slower than Java. With respect to the engineering, tracing has however significant benefits, because it requires language implementers to apply fewer optimizations to reach the same level of performance.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814275", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Marr", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Sté́phane", + "last_name": "Ducasse", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/oopsla/MarrD15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814311", + "title": "Checks and balances: constraint solving without surprises in object-constraint programming languages", + "abstract": "Object-constraint programming systems integrate declarative constraint solving with imperative, object-oriented languages, seamlessly providing the power of both paradigms. However, experience with object-constraint systems has shown that giving too much power to the constraint solver opens up the potential for solutions that are surprising and unintended as well as for complex interactions between constraints and imperative code. On the other hand, systems that overly limit the power of the solver, for example by disallowing constraints involving mutable objects, object identity, or polymorphic message sends, run the risk of excluding the core object-oriented features of the language from the constraint part, and consequently not being able to express declaratively a large set of interesting problem solutions. In this paper we present design principles that tame the power of the constraint solver in object-constraint languages to avoid difficult corner cases and surprising solutions while retaining the key features of the approach, including constraints over mutable objects, constraints involving object identity, and constraints on the results of message sends. We present our solution concretely in the context of the Babelsberg object-constraint language framework, providing both an informal description of the resulting language and a formal semantics for a core subset of it. We validate the utility of this semantics with an executable version that allows us to run test programs and to verify that they provide the same results as existing implementations of Babelsberg in JavaScript, Ruby, and Smalltalk.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814311", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tim", + "last_name": "Felgentreff", + "institution": "" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Alan", + "last_name": "Borning", + "institution": "University of Washington" + }, + { + "first_name": "Robert", + "last_name": "Hirschfeld", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/FelgentreffMBH15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814314", + "title": "Approximate computation with outlier detection in Topaz", + "abstract": "We present Topaz, a new task-based language for computations that execute on approximate computing platforms that may occasionally produce arbitrarily inaccurate results. Topaz maps tasks onto the approximate hardware and integrates the generated results into the main computation. To prevent unacceptably inaccurate task results from corrupting the main computation, Topaz deploys a novel outlier detection mechanism that recognizes and precisely reexecutes outlier tasks. Outlier detection enables Topaz to work effectively with approximate hardware platforms that have complex fault characteristics, including platforms with bit pattern dependent faults (in which the presence of faults may depend on values stored in adjacent memory cells). Our experimental results show that, for our set of benchmark applications, outlier detection enables Topaz to deliver acceptably accurate results (less than 1% error) on our target approximate hardware platforms. Depending on the application and the hardware platform, the overall energy savings range from 5 to 13 percent. Without outlier detection, only one of the applications produces acceptably accurate results.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814314", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sara", + "last_name": "Achour", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/AchourR15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814276", + "title": "Using C language extensions for developing embedded software: a case study", + "abstract": "We report on an industrial case study on developing the embedded software for a smart meter using the C programming language and domain-specific extensions of C such as components, physical units, state machines, registers and interrupts. We find that the extensions help significantly with managing the complexity of the software. They improve testability mainly by supporting hardware-independent testing, as illustrated by low integration efforts. The extensions also do not incur significant overhead regarding memory consumption and performance. Our case study relies on mbeddr, an extensible version of C. mbeddr, in turn, builds on the MPS language workbench which supports modular extension of languages and IDEs.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814276", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Markus", + "last_name": "Voelter", + "institution": "" + }, + { + "first_name": "Arie van", + "last_name": "Deursen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Bernd", + "last_name": "Kolb", + "institution": "" + }, + { + "first_name": "Stephan", + "last_name": "Eberle", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/VoelterDKE15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814305", + "title": "Incremental computation with names", + "abstract": "Over the past thirty years, there has been significant progress in developing general-purpose, language-based approaches to incremental computation, which aims to efficiently update the result of a computation when an input is changed. A key design challenge in such approaches is how to provide efficient incremental support for a broad range of programs. In this paper, we argue that first-class names are a critical linguistic feature for efficient incremental computation. Names identify computations to be reused across differing runs of a program, and making them first class gives programmers a high level of control over reuse. We demonstrate the benefits of names by presenting Nominal Adapton, an ML-like language for incremental computation with names. We describe how to use Nominal Adapton to efficiently incrementalize several standard programming patterns---including maps, folds, and unfolds---and show how to build efficient, incremental probabilistic trees and tries. Since Nominal Adapton's implementation is subtle, we formalize it as a core calculus and prove it is from-scratch consistent, meaning it always produces the same answer as simply re-running the computation. Finally, we demonstrate that Nominal Adapton can provide large speedups over both from-scratch computation and Adapton, a previous state-of-the-art incremental computation system.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814305", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "University of British Columbia" + }, + { + "first_name": "Kyle", + "last_name": "Headley", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Nicholas", + "last_name": "Labich", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/oopsla/HammerDHLFHH15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814283", + "title": "Remote-scope promotion: clarified, rectified, and verified", + "abstract": "Modern accelerator programming frameworks, such as OpenCL, organise threads into work-groups. Remote-scope promotion (RSP) is a language extension recently proposed by AMD researchers that is designed to enable applications, for the first time, both to optimise for the common case of intra-work-group communication (using memory scopes to provide consistency only within a work-group) and to allow occasional inter-work-group communication (as required, for instance, to support the popular load-balancing idiom of work stealing). We present the first formal, axiomatic memory model of OpenCL extended with RSP. We have extended the Herd memory model simulator with support for OpenCL kernels that exploit RSP, and used it to discover bugs in several litmus tests and a work-stealing queue, that have been used previously in the study of RSP. We have also formalised the proposed GPU implementation of RSP. The formalisation process allowed us to identify bugs in the description of RSP that could result in well-synchronised programs experiencing memory inconsistencies. We present and prove sound a new implementation of RSP that incorporates bug fixes and requires less non-standard hardware than the original implementation. This work, a collaboration between academia and industry, clearly demonstrates how, when designing hardware support for a new concurrent language feature, the early application of formal tools and techniques can help to prevent errors, such as those we have found, from making it into silicon.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814283", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + }, + { + "first_name": "Bradford M.", + "last_name": "Beckmann", + "institution": "Advanced Micro Devices (United States)" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/oopsla/WickersonBBD15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814289", + "title": "Effectively mapping linguistic abstractions for message-passing concurrency to threads on the Java virtual machine", + "abstract": "Efficient mapping of message passing concurrency (MPC) abstractions to Java Virtual Machine (JVM) threads is critical for performance, scalability, and CPU utilization; but tedious and time consuming to perform manually. In general, this mapping cannot be found in polynomial time, but we show that by exploiting the local characteristics of MPC abstractions and their communication patterns this mapping can be determined effectively. We describe our MPC abstraction to thread mapping technique, its realization in two frame- works (Panini and Akka), and its rigorous evaluation using several benchmarks from representative MPC frameworks. We also compare our technique against four default mapping techniques: thread-all, round-robin-task-all, random-task-all and work-stealing. Our evaluation shows that our mapping technique can improve the performance by 30%-60% over default mapping techniques. These improvements are due to a number of challenges addressed by our technique namely: i) balancing the computations across JVM threads, ii) reducing the communication overheads, iii) utilizing information about cache locality, and iv) mapping MPC abstractions to threads in a way that reduces the contention between JVM threads.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814289", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ganesha", + "last_name": "Upadhyaya", + "institution": "Iowa State University" + }, + { + "first_name": "Hridesh", + "last_name": "Rajan", + "institution": "Iowa State University" + } + ], + "dblp_key": "conf/oopsla/UpadhyayaR15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814321", + "title": "Partial evaluation of machine code", + "abstract": "This paper presents an algorithm for off-line partial evaluation of machine code. The algorithm follows the classical two-phase approach of binding-time analysis (BTA) followed by specialization. However, machine-code partial evaluation presents a number of new challenges, and it was necessary to devise new techniques for use in each phase.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814321", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Venkatesh", + "last_name": "Srinivasan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/oopsla/SrinivasanR15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814277", + "title": "A co-contextual formulation of type rules and its application to incremental type checking", + "abstract": "Type rules associate types to expressions given a typing context. As the type checker traverses the expression tree top-down, it extends the typing context with additional context information that becomes available. This way, the typing context coordinates type checking in otherwise independent subexpressions, which inhibits parallelization and incrementalization of type checking. We propose a co-contextual formulation of type rules that only take an expression as input and produce a type and a set of context requirements. Co-contextual type checkers traverse an expression tree bottom-up and merge context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. Using our method, we derive incremental type checkers for PCF and for extensions that introduce records, parametric polymorphism, and subtyping. Our performance evaluation shows that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814277", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Edlira", + "last_name": "Kuci", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Matthias", + "last_name": "Krebs", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Lancaster University" + } + ], + "dblp_key": "conf/oopsla/ErdwegBKKM15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814317", + "title": "Automated backward error analysis for numerical code", + "abstract": "Numerical code uses floating-point arithmetic and necessarily suffers from roundoff and truncation errors. Error analysis is the process to quantify such uncertainty in the solution to a problem. Forward error analysis and backward error analysis are two popular paradigms of error analysis. Forward error analysis is more intuitive and has been explored and automated by the programming languages (PL) community. In contrast, although backward error analysis is more preferred by numerical analysts and the foundation for numerical stability, it is less known and unexplored by the PL community. To fill the gap, this paper presents an automated backward error analysis for numerical code to empower both numerical analysts and application developers. In addition, we use the computed backward error results to also compute the condition number, an important quantity recognized by numerical analysts for measuring how sensitive a function is to changes or errors in the input. Experimental results on Intel X87 FPU functions and widely-used GNU C Library functions demonstrate that our analysis is effective at analyzing the accuracy of floating-point programs.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814317", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhoulai", + "last_name": "Fu", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhaojun", + "last_name": "Bai", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/FuBS15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814315", + "title": "Customizable gradual polymorphic effects for Scala", + "abstract": "Despite their obvious advantages in terms of static reasoning, the adoption of effect systems is still rather limited in practice. Recent advances such as generic effect systems, lightweight effect polymorphism, and gradual effect checking, all represent promising steps towards making effect systems suitable for widespread use. However, no existing system combines these approaches: the theory of gradual polymorphic effects has not been developed, and there are no implementations of gradual effect checking. In addition, a limiting factor in the adoption of effect systems is their unsuitability for localized and customized effect disciplines. This paper addresses these issues by presenting the first implementation of gradual effect checking, for Scala, which supports both effect polymorphism and a domain-specific language called Effscript to declaratively define and customize effect disciplines. We report on the theory, implementation, and practical application of the system.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814315", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/oopsla/ToroT15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814280", + "title": "Disjointness domains for fine-grained aliasing", + "abstract": "Aliasing is crucial for supporting useful implementation patterns, but it makes reasoning about programs difficult. To deal with this problem, numerous type-based aliasing control mechanisms have been proposed, expressing properties such as uniqueness. Uniqueness, however, is black-and-white: either a reference is unique or it can be arbitrarily aliased; and global: excluding aliases throughout the entire system, making code brittle to changing requirements. Disjointness domains, a new approach to alias control, address this problem by enabling more graduations between uniqueness and arbitrary reference sharing. They allow expressing aliasing constraints local to a certain set of variables (either stack variables or fields) for instance that no aliasing occurs between variables within some set of variables but between such sets or the opposite, that aliasing occurs within that set but not between different sets. A hierarchy of disjointness domains controls the flow of references through a program, helping the programmer reason about disjointness and enforce local alias invariants. The resulting system supports fine-grained control of aliasing between both variables and objects, making aliasing explicit to programmers, compilers, and tooling. This paper presents a formal account of disjointness domains along with examples. Disjointness domains provide novel means of expressing may-alias kinds of constraints, which may prove useful in compiler optimisation and verification.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814280", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephan", + "last_name": "Brandauer", + "institution": "Uppsala University" + }, + { + "first_name": "Dave", + "last_name": "Clarke", + "institution": "Uppsala University" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/oopsla/BrandauerCW15", + "venue": "oopsla", + "year": 2015 + }, + { + "paper_id": "10.1145/2814270.2814287", + "title": "The chemical approach to typestate-oriented programming", + "abstract": "We study a novel approach to typestate-oriented programming based on the chemical metaphor: state and operations on objects are molecules of messages and state transformations are chemical reactions. This approach allows us to investigate typestate in an inherently concurrent setting, whereby objects can be accessed and modified concurrently by several processes, each potentially changing only part of their state. We introduce a simple behavioral type theory to express in a uniform way both the private and the public interfaces of objects, to describe and enforce structured object protocols consisting of possibilities, prohibitions, and obligations, and to control object sharing.", + "date": "2015-10-23", + "link": "https://doi.org/10.1145/2814270.2814287", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Silvia", + "last_name": "Crafà", + "institution": "University of Padua" + }, + { + "first_name": "Luca", + "last_name": "Padovani", + "institution": "University of Turin" + } + ], + "dblp_key": "conf/oopsla/CrafaP15", + "venue": "oopsla", + "year": 2015 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2016.json b/data/pl_conferences/oopsla/2016.json new file mode 100644 index 0000000..571481d --- /dev/null +++ b/data/pl_conferences/oopsla/2016.json @@ -0,0 +1,1563 @@ +[ + { + "paper_id": "10.1145/2983990.2984035", + "title": "Automatic parallelization of pure method calls via conditional future synthesis", + "abstract": "We introduce a novel approach for using futures to automatically parallelize the execution of pure method calls. Our approach is built on three new techniques to address the challenge of automatic parallelization via future synthesis: candidate future synthesis, parallelism benefit analysis, and threshold expression synthesis. During candidate future synthesis, our system annotates pure method calls as async expressions and synthesizes a parallel program with future objects and their type declarations. Next, the system performs a parallel benefit analysis to determine which async expressions may need to be executed sequentially due to overhead reasons, based on execution profile information collected from multiple test inputs. Finally, threshold expression synthesis uses the output from parallelism benefit analysis to synthesize predicate expressions that can be used to determine at runtime if a specific pure method call should be executed sequentially or in parallel.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984035", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rishi", + "last_name": "Surendran", + "institution": "Rice University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + } + ], + "dblp_key": "conf/oopsla/SurendranS16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984013", + "title": "Parallel incremental whole-program optimizations for Scala.js", + "abstract": "Whole-program optimizations are powerful tools that can dramatically improve performance, size and other aspects of programs. Because they depend on global knowledge, they must typically be reapplied to the whole program when small changes are made, which makes them too slow for the development cycle. This is an issue for some environments that require, or benefit a lot from, whole-program optimizations, such as compilation to JavaScript or to the Dalvik VM, because their development cycle is slowed down either by the lack of optimizations, or by the time spent on applying them.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984013", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sébastien", + "last_name": "Doeraene", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tobias", + "last_name": "Schlatter", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/DoeraeneS16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984042", + "title": "LaCasa: lightweight affinity and object capabilities in Scala", + "abstract": "Aliasing is a known source of challenges in the context of imperative object-oriented languages, which have led to important advances in type systems for aliasing control. However, their large-scale adoption has turned out to be a surprisingly difficult challenge. While new language designs show promise, they do not address the need of aliasing control in existing languages.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984042", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philipp", + "last_name": "Haller", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Alex", + "last_name": "Loiko", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/HallerL16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984033", + "title": "Modeling and analysis of remote memory access programming", + "abstract": "Recent advances in networking hardware have led to a new generation of Remote Memory Access (RMA) networks in which processors from different machines can communicate directly, bypassing the operating system and allowing higher performance. Researchers and practitioners have proposed libraries and programming models for RMA to enable the development of applications running on these networks,", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984033", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrei", + "last_name": "Dan", + "institution": "ETH Zurich" + }, + { + "first_name": "Patrick", + "last_name": "Lam", + "institution": "University of Waterloo" + }, + { + "first_name": "Torsten", + "last_name": "Hoefler", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/DanLHV16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983999", + "title": "Hoare-style specifications as correctness conditions for non-linearizable concurrent objects", + "abstract": "Designing efficient concurrent objects often requires abandoning the standard specification technique of linearizability in favor of more relaxed correctness conditions. However, the variety of alternatives makes it difficult to choose which condition to employ, and how to compose them when using objects specified by different conditions.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983999", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "University College London" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "IMDEA Software" + }, + { + "first_name": "Germán Andrés", + "last_name": "Delbianco", + "institution": "IMDEA Software" + } + ], + "dblp_key": "conf/oopsla/SergeyNBD16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984009", + "title": "Gentrification gone too far? affordable 2nd-class values for fun and (co-)effect", + "abstract": "First-class functions dramatically increase expressiveness, at the expense of static guarantees. In ALGOL or PASCAL, functions could be passed as arguments but never escape their defining scope. Therefore, function arguments could serve as temporary access tokens or capabilities, enabling callees to perform some action, but only for the duration of the call. In modern languages, such programming patterns are no longer available.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984009", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Leo", + "last_name": "Osvald", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Grégory M.", + "last_name": "Essertel", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xilun", + "last_name": "Wu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Lilliam I. González", + "last_name": "Alayón", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/OsvaldEWAR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984032", + "title": "Portable inter-workgroup barrier synchronisation for GPUs", + "abstract": "Despite the growing popularity of GPGPU programming, there is not yet a portable and formally-specified barrier that one can use to synchronise across workgroups. Moreover, the occupancy-bound execution model of GPUs breaks assumptions inherent in traditional software execution barriers, exposing them to deadlock. We present an occupancy discovery protocol that dynamically discovers a safe estimate of the occupancy for a given GPU and kernel, allowing for a starvation-free (and hence, deadlock-free) inter-workgroup barrier by restricting the number of workgroups according to this estimate. We implement this idea by adapting an existing, previously non-portable, GPU inter-workgroup barrier to use OpenCL 2.0 atomic operations, and prove that the barrier meets its natural specification in terms of synchronisation.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984032", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + }, + { + "first_name": "Ganesh", + "last_name": "Gopalakrishnan", + "institution": "University of Utah" + }, + { + "first_name": "Zvonimir", + "last_name": "Rakamarić", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/oopsla/SorensenDBGR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984010", + "title": "Automated reasoning for web page layout", + "abstract": "Web pages define their appearance using Cascading Style Sheets, a modular language for layout of tree-structured documents. In principle, using CSS is easy: the developer specifies declarative constraints on the layout of an HTML document (such as the positioning of nodes in the HTML tree), and the browser solves the constraints to produce a box-based rendering of that document. In practice, however, the subtleties of CSS semantics make it difficult to develop stylesheets that produce the intended layout across different user preferences and browser settings.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984010", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Washington" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/PanchekhaT16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984021", + "title": "Extensible access control with authorization contracts", + "abstract": "Existing programming language access control frameworks do not meet the needs of all software components. We propose an expressive framework for implementing access control monitors for components. The basis of the framework is a novel concept: the authority environment. An authority environment associates rights with an execution context. The building blocks of access control monitors in our framework are authorization contracts: software contracts that manage authority environments. We demonstrate the expressiveness of our framework by implementing a diverse set of existing access control mechanisms and writing custom access control monitors for three realistic case studies.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984021", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Scott", + "last_name": "Moore", + "institution": "Harvard University Press" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Harvard University Press" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/oopsla/MooreDFFC16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984030", + "title": "FIDEX: filtering spreadsheet data using examples", + "abstract": "Data filtering in spreadsheets is a common problem faced by millions of end-users. The task of data filtering requires a computational model that can separate intended positive and negative string instances. We present a system, FIDEX, that can efficiently learn desired data filtering expressions from a small set of positive and negative string examples.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984030", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/WangGS16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984015", + "title": "A compiler for throughput optimization of graph algorithms on GPUs", + "abstract": "Writing high-performance GPU implementations of graph algorithms can be challenging. In this paper, we argue that three optimizations called throughput optimizations are key to high-performance for this application class. These optimizations describe a large implementation space making it unrealistic for programmers to implement them by hand.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984015", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sreepathi", + "last_name": "Pai", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/PaiP16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984027", + "title": "Semantics-based program verifiers for all languages", + "abstract": "We present a language-independent verification framework that can be instantiated with an operational semantics to automatically generate a program verifier. The framework treats both the operational semantics and the program correctness specifications as reachability rules between matching logic patterns, and uses the sound and relatively complete reachability logic proof system to prove the specifications using the semantics. We instantiate the framework with the semantics of one academic language, KernelC, as well as with three recent semantics of real-world languages, C, Java, and JavaScript, developed independently of our verification infrastructure. We evaluate our approach empirically and show that the generated program verifiers can check automatically the full functional correctness of challenging heap-manipulating programs implementing operations on list and tree data structures, like AVL trees. This is the first approach that can turn the operational semantics of real-world languages into correct-by-construction automatic verifiers.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984027", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrei", + "last_name": "Ștefănescu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Daejun", + "last_name": "Park", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Shijiao", + "last_name": "Yuwen", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Yilong", + "last_name": "Li", + "institution": "Runtime Verification (United States)" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/oopsla/StefanescuPYLR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983993", + "title": "Deriving divide-and-conquer dynamic programming algorithms using solver-aided transformations", + "abstract": "We introduce a framework allowing domain experts to manipulate computational terms in the interest of deriving better, more efficient implementations.It employs deductive reasoning to generate provably correct efficient implementations from a very high-level specification of an algorithm, and inductive constraint-based synthesis to improve automation. Semantic information is encoded into program terms through the use of refinement types.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983993", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Rohit", + "last_name": "Singh", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Kuat", + "last_name": "Yessenov", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Yongquan", + "last_name": "Lu", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Charles E.", + "last_name": "Leiserson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Rezaul", + "last_name": "Chowdhury", + "institution": "Stony Brook University" + } + ], + "dblp_key": "conf/oopsla/Itzhaky0SYLLC16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983997", + "title": "An operational semantics for C/C++11 concurrency", + "abstract": "The C/C++11 concurrency model balances two goals: it is relaxed enough to be efficiently implementable and (leaving aside the ``thin-air'' problem) it is strong enough to give useful guarantees to programmers. It is mathematically precise and has been used in verification research and compiler testing. However, the model is expressed in an axiomatic style, as predicates on complete candidate executions. This suffices for computing the set of allowed executions of a small litmus test, but it does not directly support the incremental construction of executions of larger programs. It is also at odds with conventional operational semantics, as used implicitly in the rest of the C/C++ standards.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983997", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kyndylan", + "last_name": "Nienhuis", + "institution": "University of Cambridge" + }, + { + "first_name": "Kayvan", + "last_name": "Memarian", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/oopsla/NienhuisMS16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984034", + "title": "Incremental forest: a DSL for efficiently managing filestores", + "abstract": "File systems are often used to store persistent application data, but manipulating file systems using standard APIs can be difficult for programmers. Forest is a domain-specific language that bridges the gap between the on-disk and in-memory representations of file system data. Given a high-level specification of the structure, contents, and properties of a collection of directories, files, and symbolic links, the Forest compiler generates tools for loading, storing, and validating that data. Unfortunately, the initial implementation of Forest offered few mechanisms for controlling cost-e.g., the run-time system could load gigabytes of data, even if only a few bytes were needed. This paper introduces Incremental Forest (iForest), an extension to Forest with an explicit delay construct that programmers can use to precisely control costs. We describe the design of iForest using a series of running examples, present a formal semantics in a core calculus, and define a simple cost model that accurately characterizes the resources needed to use a given specification. We propose skins, which allow programmers to modify the delay structure of a specification in a compositional way, and develop a static type system for ensuring compatibility between specifications and skins. We prove the soundness and completeness of the type system and a variety of algebraic properties of skins. We describe an OCaml implementation and evaluate its performance on applications developed in collaboration with watershed hydrologists.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984034", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "DiLorenzo", + "institution": "Cornell University" + }, + { + "first_name": "Richard", + "last_name": "Zhang", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "E.", + "last_name": "Menzies", + "institution": "Cornell University" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/oopsla/DiLorenzoZMFF16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984006", + "title": "Speeding up machine-code synthesis", + "abstract": "Machine-code synthesis is the problem of searching for an instruction sequence that implements a semantic specification, given as a formula in quantifier-free bit-vector logic (QFBV). Instruction sets like Intel's IA-32 have around 43,000 unique instruction schemas; this huge instruction pool, along with the exponential cost inherent in enumerative synthesis, results in an enormous search space for a machine-code synthesizer: even for relatively small specifications, the synthesizer might take several hours or days to find an implementation. In this paper, we present several improvements to the algorithms used in a state-of-the-art machine-code synthesizer McSynth. In addition to a novel pruning heuristic, our improvements incorporate a number of ideas known from the literature, which we adapt in novel ways for the purpose of speeding up machine-code synthesis. Our experiments for Intel's IA-32 instruction set show that our improvements enable synthesis of code for 12 out of 14 formulas on which McSynth times out, speeding up the synthesis time by at least 1981X, and for the remaining formulas, speeds up synthesis by 3X.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984006", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Venkatesh", + "last_name": "Srinivasan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Tushar", + "last_name": "Sharma", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "GrammaTech (United States)" + } + ], + "dblp_key": "conf/oopsla/SrinivasanSR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984018", + "title": "Purposes, concepts, misfits, and a redesign of git", + "abstract": "Git is a widely used version control system that is powerful but complicated. Its complexity may not be an inevitable consequence of its power but rather evidence of flaws in its design. To explore this hypothesis, we analyzed the design of Git using a theory that identifies concepts, purposes, and misfits. Some well-known difficulties with Git are described, and explained as misfits in which underlying concepts fail to meet their intended purpose. Based on this analysis, we designed a reworking of Git (called Gitless) that attempts to remedy these flaws.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984018", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Santiago Perez De", + "last_name": "Rosso", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Daniel", + "last_name": "Jackson", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/RossoJ16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984016", + "title": "Dependent partitioning", + "abstract": "A key problem in parallel programming is how data is partitioned: divided into subsets that can be operated on in parallel and, in distributed memory machines, spread across multiple address spaces.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984016", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sean", + "last_name": "Treichler", + "institution": "Stanford University" + }, + { + "first_name": "Michael", + "last_name": "Bauer", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Stanford University" + }, + { + "first_name": "Elliott", + "last_name": "Slaughter", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/oopsla/TreichlerBSSA16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984000", + "title": "Asserting reliable convergence for configuration management scripts", + "abstract": "The rise of elastically scaling applications that frequently deploy new machines has led to the adoption of DevOps practices across the cloud engineering stack. So-called configuration management tools utilize scripts that are based on declarative resource descriptions and make the system converge to the desired state. It is crucial for convergent configurations to be able to gracefully handle transient faults, e.g., network outages when downloading and installing software packages. In this paper we introduce a conceptual framework for asserting reliable convergence in configuration management. Based on a formal definition of configuration scripts and their resources, we utilize state transition graphs to test whether a script makes the system converge to the desired state under different conditions. In our generalized model, configuration actions are partially ordered, often resulting in prohibitively many possible execution orders. To reduce this problem space, we define and analyze a property called preservation, and we show that if preservation holds for all pairs of resources, then convergence holds for the entire configuration. Our implementation builds on Puppet, but the approach is equally applicable to other frameworks like Chef, Ansible, etc. We perform a comprehensive evaluation based on real world Puppet scripts and show the effectiveness of the approach. Our tool is able to detect all idempotence and convergence related issues in a set of existing Puppet scripts with known issues as well as some hitherto undiscovered bugs in a large random sample of scripts.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984000", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Oliver", + "last_name": "Hanappi", + "institution": "TU Wien" + }, + { + "first_name": "Waldemar", + "last_name": "Hummer", + "institution": "TU Wien" + }, + { + "first_name": "Schahram", + "last_name": "Dustdar", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/oopsla/HanappiHD16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984031", + "title": "Apex: automatic programming assignment error explanation", + "abstract": "This paper presents Apex, a system that can automatically generate explanations for programming assignment bugs, regarding where the bugs are and how the root causes led to the runtime failures. It works by comparing the passing execution of a correct implementation (provided by the instructor) and the failing execution of the buggy implementation (submitted by the student). The technique overcomes a number of technical challenges caused by syntactic and semantic differences of the two implementations. It collects the symbolic traces of the executions and matches assignment statements in the two execution traces by reasoning about symbolic equivalence. It then matches predicates by aligning the control dependences of the matched assignment statements, avoiding direct matching of path conditions which are usually quite different. Our evaluation shows that Apex is every effective for 205 buggy real world student submissions of 4 programming assignments, and a set of 15 programming assignment type of buggy programs collected from stackoverflow.com, precisely pinpointing the root causes and capturing the causality for 94.5% of them. The evaluation on a standard benchmark set with over 700 student bugs shows similar results. A user study in the classroom shows that Apex has substantially improved student productivity.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984031", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dohyeong", + "last_name": "Kim", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yonghwi", + "last_name": "Kwon", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Peng", + "last_name": "Liu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "I. Luk", + "last_name": "Kim", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "David Mitchel", + "last_name": "Perry", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Gustavo", + "last_name": "Rodriguez-Rivera", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/oopsla/KimK0KPZR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984023", + "title": "Accelerating program analyses by cross-program training", + "abstract": "Practical programs share large modules of code. However, many program analyses are ineffective at reusing analysis results for shared code across programs. We present POLYMER, an analysis optimizer to address this problem. POLYMER runs the analysis offline on a corpus of training programs and learns analysis facts over shared code. It prunes the learnt facts to eliminate intermediate computations and then reuses these pruned facts to accelerate the analysis of other programs that share code with the training corpus. We have implemented POLYMER to accelerate analyses specified in Datalog, and apply it to optimize two analyses for Java programs: a call-graph analysis that is flow- and context-insensitive, and a points-to analysis that is flow- and context-sensitive. We evaluate the resulting analyses on ten programs from the DaCapo suite that share the JDK library. POLYMER achieves average speedups of 2.6× for the call- graph analysis and 5.2× for the points-to analysis.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984023", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sulekha", + "last_name": "Kulkarni", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Ravi", + "last_name": "Mangal", + "institution": "Atlanta Technical College" + }, + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Atlanta Technical College" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "Atlanta Technical College" + } + ], + "dblp_key": "conf/oopsla/KulkarniMZN16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984040", + "title": "Directed synthesis of failing concurrent executions", + "abstract": "Detecting concurrency-induced bugs in multithreaded libraries can be challenging due to the intricacies associated with their manifestation. This includes invocation of multiple methods, synthesis of inputs to the methods to reach the failing location, and crafting of thread interleavings that cause the erroneous behavior. Neither fuzzing-based testing techniques nor over-approximate static analyses are well positioned to detect such subtle defects while retaining high accuracy alongside satisfactory coverage.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984040", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Malavika", + "last_name": "Samak", + "institution": "" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "Google (United States)" + }, + { + "first_name": "Murali", + "last_name": "Ramanathan", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/SamakTR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984036", + "title": "Stateless model checking with data-race preemption points", + "abstract": "Stateless model checking is a powerful technique for testing concurrent programs, but suffers from exponential state space explosion when the test input parameters are too large. Several reduction techniques can mitigate this explosion, but even after pruning equivalent interleavings, the state space size is often intractable. Most prior tools are limited to preempting only on synchronization APIs, which reduces the space further, but can miss unsynchronized thread communication bugs. Data race detection, another concurrency testing approach, focuses on suspicious memory access pairs during a single test execution. It avoids concerns of state space size, but may report races that do not lead to observable failures, which jeopardizes a user’s willingness to use the analysis.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984036", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben", + "last_name": "Blum", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Garth A.", + "last_name": "Gibson", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/BlumG16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984002", + "title": "Automatic enforcement of expressive security policies using enclaves", + "abstract": "Hardware-based enclave protection mechanisms, such as Intel's SGX, ARM's TrustZone, and Apple's Secure Enclave, can protect code and data from powerful low-level attackers. In this work, we use enclaves to enforce strong application-specific information security policies.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984002", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anitha", + "last_name": "Gollamudi", + "institution": "Harvard University Press" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/oopsla/GollamudiC16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983995", + "title": "Chain: tasks and channels for reliable intermittent programs", + "abstract": "Energy harvesting computers enable general-purpose computing using energy collected from their environment. Energy-autonomy of such devices has great potential, but their intermittent power supply poses a challenge. Intermittent program execution compromises progress and leaves state inconsistent. This work describes Chain: a new model for programming intermittent devices.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983995", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexei", + "last_name": "Colin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/oopsla/ColinL16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984026", + "title": "Parsing with first-class derivatives", + "abstract": "Brzozowski derivatives, well known in the context of regular expressions, have recently been rediscovered to give a simplified explanation to parsers of context-free languages. We add derivatives as a novel first-class feature to a standard parser combinator language. First-class derivatives enable an inversion of the control flow, allowing to implement modular parsers for languages that previously required separate pre-processing steps or cross-cutting modifications of the parsers. We show that our framework offers new opportunities for reuse and supports a modular definition of interesting use cases of layout-sensitive parsing.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984026", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Tillmann", + "last_name": "Rendel", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/oopsla/BrachthauserRO16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983991", + "title": "Call graphs for languages with parametric polymorphism", + "abstract": "The performance of contemporary object oriented languages depends on optimizations such as devirtualization, inlining, and specialization, and these in turn depend on precise call graph analysis. Existing call graph analyses do not take advantage of the information provided by the rich type systems of contemporary languages, in particular generic type arguments. Many existing approaches analyze Java bytecode, in which generic types have been erased. This paper shows that this discarded information is actually very useful as the context in a context-sensitive analysis, where it significantly improves precision and keeps the running time small. Specifically, we propose and evaluate call graph construction algorithms in which the contexts of a method are (i) the type arguments passed to its type parameters, and (ii) the static types of the arguments passed to its term parameters. The use of static types from the caller as context is effective because it allows more precise dispatch of call sites inside the callee.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983991", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dmitry", + "last_name": "Petrashko", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Vlad", + "last_name": "Ureche", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/PetrashkoULO16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984017", + "title": "Type inference for static compilation of JavaScript", + "abstract": "We present a type system and inference algorithm for a rich subset of JavaScript equipped with objects, structural subtyping, prototype inheritance, and first-class methods. The type system supports abstract and recursive objects, and is expressive enough to accommodate several standard benchmarks with only minor workarounds. The invariants enforced by the types enable an ahead-of-time compiler to carry out optimizations typically beyond the reach of static compilers for dynamic languages. Unlike previous inference techniques for prototype inheritance, our algorithm uses a combination of lower and upper bound propagation to infer types and discover type errors in all code, including uninvoked functions. The inference is expressed in a simple constraint language, designed to leverage off-the-shelf fixed point solvers. We prove soundness for both the type system and inference algorithm. An experimental evaluation showed that the inference is powerful, handling the aforementioned benchmarks with no manual type annotation, and that the inferred types enable effective static compilation.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984017", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "Samsung (United States)" + }, + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "Drexel University" + }, + { + "first_name": "Jean-Baptiste", + "last_name": "Jeannin", + "institution": "Samsung (United States)" + }, + { + "first_name": "Cole", + "last_name": "Schlesinger", + "institution": "Samsung (United States)" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "Samsung (United States)" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Northeastern University" + }, + { + "first_name": "Youngil", + "last_name": "Choi", + "institution": "Samsung (South Korea)" + } + ], + "dblp_key": "conf/oopsla/0001GJSSTC16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984025", + "title": "Maximal causality reduction for TSO and PSO", + "abstract": "Verifying concurrent programs is challenging due to the exponentially large thread interleaving space. The problem is exacerbated by relaxed memory models such as Total Store Order (TSO) and Partial Store Order (PSO) which further explode the interleaving space by reordering instructions. A recent advance, Maximal Causality Reduction (MCR), has shown great promise to improve verification effectiveness by maximally reducing redundant explorations. However, the original MCR only works for the Sequential Consistency (SC) memory model, but not for TSO and PSO. In this paper, we develop novel extensions to MCR by solving two key problems under TSO and PSO: 1) generating interleavings that can reach new states by encoding the operational semantics of TSO and PSO with first-order logical constraints and solving them with SMT solvers, and 2) enforcing TSO and PSO interleavings by developing novel replay algorithms that allow executions out of the program order. We show that our approach successfully enables MCR to effectively explore TSO and PSO interleavings. We have compared our approach with a recent Dynamic Partial Order Reduction (DPOR) algorithm for TSO and PSO and a SAT-based stateless model checking approach. Our results show that our approach is much more effective than the other approaches for both state-space exploration and bug finding – on average it explores 5-10X fewer executions and finds many bugs that the other tools cannot find.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984025", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shiyou", + "last_name": "Huang", + "institution": "Texas A&M University" + }, + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/oopsla/Huang016", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984024", + "title": "Precise and maximal race detection from incomplete traces", + "abstract": "We present RDIT, a novel dynamic technique to detect data races in multithreaded programs with incomplete trace information, i.e., in the presence of missing events. RDIT is both precise and maximal: it does not report any false alarms and it detects a maximal set of true traces from the observed incomplete trace. RDIT is underpinned by a sound BarrierPair model that abstracts away the missing events by capturing the invocation data of their enclosing methods. By making the least conservative abstraction that a missing method introduces synchronization only when it has a memory address in scope that overlaps with other events or other missing methods, and by formulating maximal thread causality as logical constraints, RDIT guarantees to precisely detect races with maximal capability. RDIT has been applied in seven real-world large concurrent systems and has detected dozens of true races with zero false alarms. Comparatively, existing algorithms such as Happens-Before, Causal- Precedes, and Maximal-Causality which are known to be precise all report many false alarms when missing synchronizations.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984024", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + }, + { + "first_name": "Arun K.", + "last_name": "Rajagopalan", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/oopsla/HuangR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984039", + "title": "GEMs: shared-memory parallel programming for Node.js", + "abstract": "JavaScript is the most popular programming language for client-side Web applications, and Node.js has popularized the language for server-side computing, too. In this domain, the minimal support for parallel programming remains however a major limitation. In this paper we introduce a novel parallel programming abstraction called Generic Messages (GEMs). GEMs allow one to combine message passing and shared-memory parallelism, extending the classes of parallel applications that can be built with Node.js. GEMs have customizable semantics and enable several forms of thread safety, isolation, and concurrency control. GEMs are designed as convenient JavaScript abstractions that expose high-level and safe parallelism models to the developer. Experiments show that GEMs outperform equivalent Node.js applications thanks to their usage of shared memory.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984039", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniele", + "last_name": "Bonetta", + "institution": "" + }, + { + "first_name": "Luca", + "last_name": "Salucci", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Stefan", + "last_name": "Marr", + "institution": "" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/oopsla/BonettaSMB16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984003", + "title": "An improved algorithm for slicing machine code", + "abstract": "Machine-code slicing is an important primitive for building binary analysis and rewriting tools, such as taint trackers, fault localizers, and partial evaluators. However, it is not easy to create a machine-code slicer that exhibits a high level of precision. Moreover, the problem of creating such a tool is compounded by the fact that a small amount of local imprecision can be amplified via cascade effects.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984003", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Venkatesh", + "last_name": "Srinivasan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/oopsla/SrinivasanR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984022", + "title": "OrcO: a concurrency-first approach to objects", + "abstract": "The majority of modern programming languages provide concurrency and object-orientation in some form. However, object-oriented concurrency remains cumbersome in many situations. We introduce the language OrcO, Orc with concurrent Objects, which enables a flexible style of concurrent object-oriented programming. OrcO extends the Orc programming language by adding abstractions for programming-in-the-large; namely objects, classes, and inheritance. OrcO objects are designed to be orthogonal to concurrency, allowing the concurrent structure and object structure of a program to evolve independently. This paper describes OrcO's goals and design and provides examples of how OrcO can be used to deftly handle events, object management, and object composition.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984022", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Peters", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "David", + "last_name": "Kitchin", + "institution": "Google (United States)" + }, + { + "first_name": "John A.", + "last_name": "Thywissen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/oopsla/PetersKTC16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983992", + "title": "Semantic subtyping for imperative object-oriented languages", + "abstract": "Semantic subtyping is an approach for defining sound and complete procedures to decide subtyping for expressive types, including union and intersection types; although it has been exploited especially in functional languages for XML based programming, recently it has been partially investigated in the context of object-oriented languages, and a sound and complete subtyping algorithm has been proposed for record types, but restricted to immutable fields, with union and recursive types interpreted coinductively to support cyclic objects. In this work we address the problem of studying semantic subtyping for imperative object-oriented languages, where fields can be mutable; in particular, we add read/write field annotations to record types, and, besides union, we consider intersection types as well, while maintaining coinductive interpretation of recursive types. In this way, we get a richer notion of type with a flexible subtyping relation, able to express a variety of type invariants useful for enforcing static guarantees for mutable objects. The addition of these features radically changes the defi- nition of subtyping, and, hence, the corresponding decision procedure, and surprisingly invalidates some subtyping laws that hold in the functional setting. We propose an intuitive model where mutable record val- ues contain type information to specify the values that can be correctly stored in fields. Such a model, and the correspond- ing subtyping rules, require particular care to avoid circularity between coinductive judgments and their negations which, by duality, have to be interpreted inductively. A sound and complete subtyping algorithm is provided, together with a prototype implementation.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983992", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Davide", + "last_name": "Ancona", + "institution": "University of Genoa" + }, + { + "first_name": "Andrea", + "last_name": "Corradi", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/oopsla/AnconaC16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984001", + "title": "Efficient and thread-safe objects for dynamically-typed languages", + "abstract": "We are in the multi-core era. Dynamically-typed languages are in widespread use, but their support for multithreading still lags behind. One of the reasons is that the sophisticated techniques they use to efficiently represent their dynamic object models are often unsafe in multithreaded environments.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984001", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benoit", + "last_name": "Daloze", + "institution": "" + }, + { + "first_name": "Stefan", + "last_name": "Marr", + "institution": "" + }, + { + "first_name": "Daniele", + "last_name": "Bonetta", + "institution": "" + }, + { + "first_name": "Hanspeter", + "last_name": "Mössenböck", + "institution": "" + } + ], + "dblp_key": "conf/oopsla/DalozeMBM16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983996", + "title": "The missing link: explaining ELF static linking, semantically", + "abstract": "Beneath the surface, software usually depends on complex linker behaviour to work as intended. Even linking hello_world.c is surprisingly involved, and systems software such as libc and operating system kernels rely on a host of linker features. But linking is poorly understood by working programmers and has largely been neglected by language researchers. In this paper we survey the many use-cases that linkers support and the poorly specified linker speak by which they are controlled: metadata in object files, command-line options, and linker-script language. We provide the first validated formalisation of a realistic executable and linkable format (ELF), and capture aspects of the Application Binary Interfaces for four mainstream platforms (AArch64, AMD64, Power64, and IA32). Using these, we develop an executable specification of static linking, covering (among other things) enough to link small C programs (we use the example of bzip2) into a correctly running executable. We provide our specification in Lem and Isabelle/HOL forms. This is the first formal specification of mainstream linking. We have used the Isabelle/HOL version to prove a sample correctness property for one case of AMD64 ABI relocation, demonstrating that the specification supports formal proof, and as a first step towards the much more ambitious goal of verified linking. Our work should enable several novel strands of research, including linker-aware verified compilation and program analysis, and better languages for controlling linking.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983996", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Kell", + "institution": "University of Cambridge" + }, + { + "first_name": "Dominic P.", + "last_name": "Mulligan", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/oopsla/KellMS16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984008", + "title": "Type soundness for dependent object types (DOT)", + "abstract": "Scala’s type system unifies aspects of ML modules, object- oriented, and functional programming. The Dependent Object Types (DOT) family of calculi has been proposed as a new theoretic foundation for Scala and similar expressive languages. Unfortunately, type soundness has only been established for restricted subsets of DOT. In fact, it has been shown that important Scala features such as type refinement or a subtyping relation with lattice structure break at least one key metatheoretic property such as environment narrowing or invertible subtyping transitivity, which are usually required for a type soundness proof. The main contribution of this paper is to demonstrate how, perhaps surprisingly, even though these properties are lost in their full generality, a rich DOT calculus that includes recursive type refinement and a subtyping lattice with intersection types can still be proved sound. The key insight is that subtyping transitivity only needs to be invertible in code paths executed at runtime, with contexts consisting entirely of valid runtime objects, whereas inconsistent subtyping contexts can be permitted for code that is never executed.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984008", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/oopsla/RompfA16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984041", + "title": "Probabilistic model for code with decision trees", + "abstract": "In this paper we introduce a new approach for learning precise and general probabilistic models of code based on decision tree learning. Our approach directly benefits an emerging class of statistical programming tools which leverage probabilistic models of code learned over large codebases (e.g., GitHub) to make predictions about new programs (e.g., code completion, repair, etc).", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984041", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Veselin", + "last_name": "Raychev", + "institution": "ETH Zurich" + }, + { + "first_name": "Pavol", + "last_name": "Bielik", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/oopsla/RaychevBV16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984029", + "title": "Hybrid STM/HTM for nested transactions on OpenJDK", + "abstract": "Transactional memory (TM) has long been advocated as a promising pathway to more automated concurrency control for scaling concurrent programs running on parallel hardware. Software TM (STM) has the benefit of being able to run general transactional programs, but at the significant cost of overheads imposed to log memory accesses, mediate access conflicts, and maintain other transaction metadata. Recently, hardware manufacturers have begun to offer commodity hardware TM (HTM) support in their processors wherein the transaction metadata is maintained \"for free\" in hardware. However, HTM approaches are only best-effort: they cannot successfully run all transactional programs, whether because of hardware capacity issues (causing large transactions to fail), or compatibility restrictions on the processor instructions permitted within hardware transactions (causing transactions that execute those instructions to fail). In such cases, programs must include failure-handling code to attempt the computation by some other software means, since retrying the transaction would be futile. Thus, a canonical use of HTM is lock elision: replacing lock regions with transactions, retrying some number of times in the case of conflicts, but falling back to locking when HTM fails for other reasons.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984029", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Keith", + "last_name": "Chapman", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Antony L.", + "last_name": "Hosking", + "institution": "Australian National University" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/ChapmanHM16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984028", + "title": "Prioritized garbage collection: explicit GC support for software caches", + "abstract": "Programmers routinely trade space for time to increase performance, often in the form of caching or memoization. In managed languages like Java or JavaScript, however, this space-time tradeoff is complex. Using more space translates into higher garbage collection costs, especially at the limit of available memory. Existing runtime systems provide limited support for space-sensitive algorithms, forcing programmers into difficult and often brittle choices about provisioning.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984028", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Diogenes", + "last_name": "Nunez", + "institution": "Tufts University" + }, + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "Tufts University" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "conf/oopsla/NunezGB16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984019", + "title": "Makalu: fast recoverable allocation of non-volatile memory", + "abstract": "Byte addressable non-volatile memory (NVRAM) is likely to supplement, and perhaps eventually replace, DRAM. Applications can then persist data structures directly in memory instead of serializing them and storing them onto a durable block device. However, failures during execution can leave data structures in NVRAM unreachable or corrupt. In this paper, we present Makalu, a system that addresses non-volatile memory management. Makalu offers an integrated allocator and recovery-time garbage collector that maintains internal consistency, avoids NVRAM memory leaks, and is efficient, all in the face of failures.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984019", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kumud", + "last_name": "Bhandari", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Dhruva R.", + "last_name": "Chakrabarti", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Hans‐J.", + "last_name": "Boehm", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/oopsla/BhandariCB16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984007", + "title": "Computing repair alternatives for malformed programs using constraint attribute grammars", + "abstract": "Attribute grammars decorate the nodes of a program's parse tree with attributes whose values are defined by equations encoding the (static) semantics of a programming language. We show how replacing the equations of an attribute grammar with equivalent constraints that can be solved by a constraint solver allows us to compute repairs of a malformed program solely from a specification that was originally designed for checking its well-formedness. We present two repair modes --- shallow and deep fixing --- whose computed repair alternatives are guaranteed to repair every error on which they are invoked. While shallow fixing may introduce new errors, deep fixing never does; to make it tractable, we implement it using neighborhood search. We demonstrate the feasibility of our approach by implementing it on top of ExtendJ, an attribute grammar based Java compiler, and by applying it to an example from the Java EE context, detecting and fixing well-formedness errors (both real and injected) in a body of 14 open-source subject programs.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984007", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Friedrich", + "last_name": "Steimann", + "institution": "University of Hagen" + }, + { + "first_name": "Jörg", + "last_name": "Hagemann", + "institution": "University of Hagen" + }, + { + "first_name": "Bastian", + "last_name": "Ulke", + "institution": "University of Hagen" + } + ], + "dblp_key": "conf/oopsla/SteimannHU16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984012", + "title": "Scalable verification of border gateway protocol configurations with an SMT solver", + "abstract": "Internet Service Providers (ISPs) use the Border Gateway Protocol (BGP) to announce and exchange routes for delivering packets through the internet. ISPs must carefully configure their BGP routers to ensure traffic is routed reliably and securely. Correctly configuring BGP routers has proven challenging in practice, and misconfiguration has led to worldwide outages and traffic hijacks.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984012", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Konstantin", + "last_name": "Weitz", + "institution": "University of Washington" + }, + { + "first_name": "Doug", + "last_name": "Woos", + "institution": "University of Washington" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + }, + { + "first_name": "Arvind", + "last_name": "Krishnamurthy", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/oopsla/WeitzWTEKT16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984020", + "title": "Ringer: web automation by demonstration", + "abstract": "With increasing amounts of data available on the web and a diverse range of users interested in programmatically accessing that data, web automation must become easier. Automation helps users complete many tedious interactions, such as scraping data, completing forms, or transferring data between websites. However, writing web automation scripts typically requires an expert programmer because the writer must be able to reverse engineer the target webpage. We have built a record and replay tool, Ringer, that makes web automation accessible to non-coders. Ringer takes a user demonstration as input and creates a script that interacts with the page as a user would. This approach makes Ringer scripts more robust to webpage changes because user-facing interfaces remain relatively stable compared to the underlying webpage implementations. We evaluated our approach on benchmarks recorded on real webpages and found that it replayed 4x more benchmarks than a state-of-the-art replay tool.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984020", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shaon", + "last_name": "Barman", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/oopsla/BarmanCBG16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983994", + "title": "A practical framework for type inference error explanation", + "abstract": "Many languages have support for automatic type inference. But when inference fails, the reported error messages can be unhelpful, highlighting a code location far from the source of the problem. Several lines of work have emerged proposing error reports derived from correcting sets: a set of program points that, when fixed, produce a well-typed program. Unfortunately, these approaches are tightly tied to specific languages; targeting a new language requires encoding a type inference algorithm for the language in a custom constraint system specific to the error reporting tool.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983994", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Calvin", + "last_name": "Loncaric", + "institution": "University of Washington" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "Samsung (United States)" + }, + { + "first_name": "Cole", + "last_name": "Schlesinger", + "institution": "Samsung (United States)" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "Samsung (United States)" + } + ], + "dblp_key": "conf/oopsla/Loncaric0SS16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984038", + "title": "Finding compiler bugs via live code mutation", + "abstract": "Validating optimizing compilers is challenging because it is hard to generate valid test programs (i.e., those that do not expose any undefined behavior). Equivalence Modulo Inputs (EMI) is an effective, promising methodology to tackle this problem. Given a test program with some inputs, EMI mutates the program to derive variants that are semantically equivalent w.r.t. these inputs. The state-of-the-art instantiations of EMI are Orion and Athena, both of which rely on deleting code from or inserting code into code regions that are not executed under the inputs. Although both have demonstrated their ability in finding many bugs in GCC and LLVM, they are still limited due to their mutation strategies that operate only on dead code regions.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984038", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "C. P.", + "last_name": "Sun", + "institution": "University of California, Davis" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "University of California, Davis" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "University of California, Davis" + } + ], + "dblp_key": "conf/oopsla/SunLS16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2983998", + "title": "Dynamically diagnosing type errors in unsafe code", + "abstract": "Existing approaches for detecting type errors in unsafe languages are limited. Static analysis methods are imprecise, and often require source-level changes, while most dynamic methods check only memory properties (bounds, liveness, etc.), owing to a lack of run-time type information. This paper describes libcrunch, a system for binary-compatible run-time type checking of unmodified unsafe code, currently focusing on C. Practical experience shows that our prototype implementation is easily applicable to many real codebases without source-level modification, correctly flags programmer errors with a very low rate of false positives, offers a very low run-time overhead, and covers classes of error caught by no previously existing tool.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2983998", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Kell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/oopsla/Kell16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984004", + "title": "Java and scala's type systems are unsound: the existential crisis of null pointers", + "abstract": "We present short programs that demonstrate the unsoundness of Java and Scala's current type systems. In particular, these programs provide parametrically polymorphic functions that can turn any type into any type without (down)casting. Fortunately, parametric polymorphism was not integrated into the Java Virtual Machine (JVM), so these examples do not demonstrate any unsoundness of the JVM. Nonetheless, we discuss broader implications of these findings on the field of programming languages.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984004", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/oopsla/AminT16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984037", + "title": "First-class effect reflection for effect-guided programming", + "abstract": "This paper introduces a novel type-and-effect calculus, first-class effects, where the computational effect of an expression can be programmatically reflected, passed around as values, and analyzed at run time. A broad range of designs \"hard-coded\" in existing effect-guided analyses — from thread scheduling, version-consistent software updating, to data zeroing — can be naturally supported through the programming abstractions. The core technical development is a type system with a number of features, including a hybrid type system that integrates static and dynamic effect analyses, a refinement type system to verify application-specific effect management properties, a double-bounded type system that computes both over-approximation of effects and their under-approximation. We introduce and establish a notion of soundness called trace consistency, defined in terms of how the effect and trace correspond. The property sheds foundational insight on \"good\" first-class effect programming.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984037", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuheng", + "last_name": "Long", + "institution": "Iowa State University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + }, + { + "first_name": "Hridesh", + "last_name": "Rajan", + "institution": "Iowa State University" + } + ], + "dblp_key": "conf/oopsla/LongLR16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984011", + "title": "Finding resume and restart errors in Android applications", + "abstract": "Smartphone apps create and handle a large variety of ``instance'' data that has to persist across runs, such as the current navigation route, workout results, antivirus settings, or game state. Due to the nature of the smartphone platform, an app can be paused, sent into background, or killed at any time. If the instance data is not saved and restored between runs, in addition to data loss, partially-saved or corrupted data can crash the app upon resume or restart. While smartphone platforms offer API support for data-saving and data-retrieving operations, the use of this API is ad-hoc: left to the programmer, rather than enforced by the compiler. We have observed that several categories of bugs---including data loss, failure to resume/restart or resuming/restarting in the wrong state---are due to incorrect handling of instance data and are easily triggered by just pressing the `Home' or `Back' buttons. To help address this problem, we have constructed a tool chain for Android (the KREfinder static analysis and the KREreproducer input generator) that helps find and reproduce such incorrect handling. We have evaluated our approach by running the static analysis on 324 apps, of which 49 were further analyzed manually. Results indicate that our approach is (i) effective, as it has discovered 49 bugs, including in popular Android apps, and (ii) efficient, completing on average in 61 seconds per app. More generally, our approach helps determine whether an app saves too much or too little state.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984011", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhiyong", + "last_name": "Shan", + "institution": "University of Central Missouri" + }, + { + "first_name": "Tanzirul", + "last_name": "Azim", + "institution": "University of California, Riverside" + }, + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "New Jersey Institute of Technology" + } + ], + "dblp_key": "conf/oopsla/ShanAN16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984005", + "title": "Low-overhead and fully automated statistical debugging with abstraction refinement", + "abstract": "Cooperative statistical debugging is an effective approach for diagnosing production-run failures. To quickly identify failure predictors from the huge program predicate space, existing techniques rely on random or heuristics-guided predicate sampling at the user side. However, none of them can satisfy the requirements of low cost, low diagnosis latency, and high diagnosis quality simultaneously, which are all indispensable for statistical debugging to be practical.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984005", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhiqiang", + "last_name": "Zuo", + "institution": "University of California, Irvine" + }, + { + "first_name": "Lu", + "last_name": "Fang", + "institution": "University of California, Irvine" + }, + { + "first_name": "Siau‐Cheng", + "last_name": "Khoo", + "institution": "National University of Singapore" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Irvine" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/oopsla/ZuoFKXL16", + "venue": "oopsla", + "year": 2016 + }, + { + "paper_id": "10.1145/2983990.2984014", + "title": "To be precise: regression aware debugging", + "abstract": "Bounded model checking based debugging solutions search for mutations of program expressions that produce the expected output for a currently failing test. However, the current localization tools are not regression aware: they do not use information from the passing tests in their localization formula. On the other hand, the current repair tools attempt to guarantee regression freedom: when provided with a set of passing tests, they guarantee that none of these tests can break due to the suggested repair patch, thereby constructing a large repair formula.", + "date": "2016-10-19", + "link": "https://doi.org/10.1145/2983990.2984014", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rohan", + "last_name": "Bavishi", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Awanish", + "last_name": "Pandey", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Subhajit", + "last_name": "Roy", + "institution": "Indian Institute of Technology Kanpur" + } + ], + "dblp_key": "conf/oopsla/BavishiPR16", + "venue": "oopsla", + "year": 2016 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2017.json b/data/pl_conferences/oopsla/2017.json new file mode 100644 index 0000000..04be25a --- /dev/null +++ b/data/pl_conferences/oopsla/2017.json @@ -0,0 +1,2100 @@ +[ + { + "paper_id": "10.1145/3133869", + "title": "SAVI objects: sharing and virtuality incorporated", + "abstract": "Direct sharing and storing of memory objects allows high-performance and low-overhead collaboration between parallel processes or application workflows with loosely coupled programs. However, sharing of objects is hindered by the inability to use subtype polymorphism which is common in object-oriented programming languages. That is because implementations of subtype polymorphism in modern compilers rely on using virtual tables stored at process-specific locations, which makes objects unusable in processes other than the creating process. In this paper, we present SAVI Objects, objects with Sharing and Virtuality Incorporated. SAVI Objects support subtype polymorphism but can still be shared across processes and stored in persistent data structures. We propose two different techniques to implement SAVI Objects and evaluate the tradeoffs between them. The first technique is virtual table duplication which adheres to the virtual-table-based implementation of subtype polymorphism, but duplicates virtual tables for shared objects to fixed memory addresses associated with each shared memory region. The second technique is hashing-based dynamic dispatch which re-implements subtype polymorphism using hashing-based look-ups to a global virtual table. Our results show that SAVI Objects enable direct sharing and storing of memory objects that use subtype polymorphism by adding modest overhead costs to object construction and dynamic dispatch time. SAVI Objects thus enable faster inter-process communication, improving the overall performance of production applications that share polymorphic objects.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133869", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Izzat El", + "last_name": "Hajj", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Thomas B.", + "last_name": "Jablin", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Dejan", + "last_name": "Milojičić", + "institution": "Hewlett-Packard (United States)" + }, + { + "first_name": "Wen‐mei", + "last_name": "Hwu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/HajjJMH17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133873", + "title": "A volatile-by-default JVM for server applications", + "abstract": "A *memory consistency model* (or simply *memory model*) defines the possible values that a shared-memory read may return in a multithreaded programming language. Choosing a memory model involves an inherent performance-programmability tradeoff. The Java language has adopted a *relaxed* (or *weak*) memory model that is designed to admit most traditional compiler optimizations and obviate the need for hardware fences on most shared-memory accesses. The downside, however, is that programmers are exposed to a complex and unintuitive semantics and must carefully declare certain variables as `volatile` in order to enforce program orderings that are necessary for proper behavior. This paper proposes a simpler and stronger memory model for Java through a conceptually small change: *every* variable has `volatile` semantics by default, but the language allows a programmer to tag certain variables, methods, or classes as `relaxed` and provides the current Java semantics for these portions of code. This *volatile-by-default* semantics provides *sequential consistency* (SC) for all programs by default. At the same time, expert programmers retain the freedom to build performance-critical libraries that violate the SC semantics. At the outset, it is unclear if the `volatile`-by-default semantics is practical for Java, given the cost of memory fences on today's hardware platforms. The core contribution of this paper is to demonstrate, through comprehensive empirical evaluation, that the `volatile`-by-default semantics is arguably acceptable for a predominant use case for Java today -- server-side applications running on Intel x86 architectures. We present VBD-HotSpot, a modification to Oracle's widely used HotSpot JVM that implements the `volatile`-by-default semantics for x86. To our knowledge VBD-HotSpot is the first implementation of SC for Java in the context of a modern JVM. VBD-HotSpot incurs an average overhead versus the baseline HotSpot JVM of 28% for the Da Capo benchmarks, which is significant though perhaps less than commonly assumed. Further, VBD-HotSpot incurs average overheads of 12% and 19% respectively on standard benchmark suites for big-data analytics and machine learning in the widely used Spark framework.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133873", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lun", + "last_name": "Liu", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Madanlal", + "last_name": "Musuvathi", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/LiuMM17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133870", + "title": "A simple soundness proof for dependent object types", + "abstract": "Dependent Object Types (DOT) is intended to be a core calculus for modelling Scala. Its distinguishing feature is abstract type members, fields in objects that hold types rather than values. Proving soundness of DOT has been surprisingly challenging, and existing proofs are complicated, and reason about multiple concepts at the same time (e.g. types, values, evaluation). To serve as a core calculus for Scala, DOT should be easy to experiment with and extend, and therefore its soundness proof needs to be easy to modify. This paper presents a simple and modular proof strategy for reasoning in DOT. The strategy separates reasoning about types from other concerns. It is centred around a theorem that connects the full DOT type system to a restricted variant in which the challenges and paradoxes caused by abstract type members are eliminated. Almost all reasoning in the proof is done in the intuitive world of this restricted type system. Once we have the necessary results about types, we observe that the other aspects of DOT are mostly standard and can be incorporated into a soundness proof using familiar techniques known from other calculi.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133870", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marianna", + "last_name": "Rapoport", + "institution": "University of Waterloo" + }, + { + "first_name": "Ifaz", + "last_name": "Kabir", + "institution": "University of Waterloo" + }, + { + "first_name": "Paul", + "last_name": "He", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/RapoportKHL17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133877", + "title": "Model checking copy phases of concurrent copying garbage collection with various memory models", + "abstract": "Modern concurrent copying garbage collection (GC), in particular, real-time GC, uses fine-grained synchronizations with a mutator, which is the application program that mutates memory, when it moves objects in its copy phase. It resolves a data race using a concurrent copying protocol, which is implemented as interactions between the collector threads and the read and write barriers that the mutator threads execute. The behavioral effects of the concurrent copying protocol rely on the memory model of the CPUs and the programming languages in which the GC is implemented. It is difficult, however, to formally investigate the behavioral properties of concurrent copying protocols against various memory models. To address this problem, we studied the feasibility of the bounded model checking of concurrent copying protocols with memory models. We investigated a correctness-related behavioral property of copying protocols of various concurrent copying GC algorithms, including real-time GC Stopless, Clover, Chicken, Staccato, and Schism against six memory models, total store ordering (TSO), partial store ordering (PSO), relaxed memory ordering (RMO), and their variants, in addition to sequential consistency (SC) using bounded model checking. For each combination of a protocol and memory model, we conducted model checking with a model of a mutator. In this wide range of case studies, we found faults in two GC algorithms, one of which is relevant to the memory model. We fixed these faults with the great help of counterexamples. We also modified some protocols so that they work under some memory models weaker than those for which the original protocols were designed, and checked them using model checking. We believe that bounded model checking is a feasible approach to investigate behavioral properties of concurrent copying protocols under weak memory models.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133877", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tomoharu", + "last_name": "Ugawa", + "institution": "Kochi University of Technology" + }, + { + "first_name": "Tatsuya", + "last_name": "Abe", + "institution": "Chiba Institute of Technology" + }, + { + "first_name": "Toshiyuki", + "last_name": "Maeda", + "institution": "Chiba Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/UgawaAM17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133879", + "title": "The VM already knew that: leveraging compile-time knowledge to optimize gradual typing", + "abstract": "Programmers in dynamic languages wishing to constrain and understand the behavior of their programs may turn to gradually-typed languages, which allow types to be specified optionally and check values at the boundary between dynamic and static code. Unfortunately, the performance cost of these run-time checks can be severe, slowing down execution by at least 10x when checks are present. Modern virtual machines (VMs) for dynamic languages use speculative techniques to improve performance: If a particular value was seen once, it is likely that similar values will be seen in the future. They combine optimization-relevant properties of values into cacheable “shapes”, then use a single shape check to subsume checks for each property. Values with the same memory layout or the same field types have the same shape. This greatly reduces the amount of type checking that needs to be performed at run-time to execute dynamic code. While very valuable to the VM’s optimization, these checks do little to benefit the programmer aside from improving performance. We present in this paper a design for intrinsic object contracts, which makes the obligations of gradually-typed languages’ type checks an intrinsic part of object shapes, and thus can subsume run-time type checks into existing shape checks, eliminating redundant checks entirely. With an implementation on a VM for JavaScript used as a target for SafeTypeScript’s soundness guarantees, we demonstrate slowdown averaging 7% in fully-typed code relative to unchecked code, and no more than 45% in pessimal configurations.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133879", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gregor", + "last_name": "Richards", + "institution": "University of Waterloo" + }, + { + "first_name": "Ellen", + "last_name": "Arteca", + "institution": "University of Waterloo" + }, + { + "first_name": "Alexi", + "last_name": "Turcotte", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/RichardsAT17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133875", + "title": "Skip blocks: reusing execution history to accelerate web scripts", + "abstract": "With more and more web scripting languages on offer, programmers have access to increasing language support for web scraping tasks. However, in our experiences collaborating with data scientists, we learned that two issues still plague long-running scraping scripts: i) When a network or website goes down mid-scrape, recovery sometimes requires restarting from the beginning, which users find frustratingly slow. ii) Websites do not offer atomic snapshots of their databases; they update their content so frequently that output data is cluttered with slight variations of the same information — e.g. , a tweet from profile 1 that is retweeted on profile 2 and scraped from both profiles, once with 52 responses then later with 53 responses. We introduce the skip block , a language construct that addresses both of these disparate problems. Programmers write lightweight annotations to indicate when the current object can be considered equivalent to a previously scraped object and direct the program to skip over the scraping actions in the block. The construct is hierarchical, so programs can skip over long or short script segments, allowing adaptive reuse of prior work. After network and server failures, skip blocks accelerate failure recovery by 7.9x on average. Even scripts that do not encounter failures benefit; because sites display redundant objects, skipping over them accelerates scraping by up to 2.1x. For longitudinal scraping tasks that aim to fetch only new objects, the second run exhibits an average speedup of 5.2x. Our small user study reveals that programmers can quickly produce skip block annotations.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133875", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/ChasinsB17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133878", + "title": "Sound gradual typing: only mostly dead", + "abstract": "While gradual typing has proven itself attractive to programmers, many systems have avoided sound gradual typing due to the run time overhead of enforcement. In the context of sound gradual typing, both anecdotal and systematic evidence has suggested that run time costs are quite high, and often unacceptable, casting doubt on the viability of soundness as an approach. We show that these overheads are not fundamental, and that with appropriate improvements, just-in-time compilers can greatly reduce the overhead of sound gradual typing . Our study takes benchmarks published in a recent paper on gradual typing performance in Typed Racket (Takikawa et al., POPL 2016) and evaluates them using a experimental tracing JIT compiler for Racket, called Pycket. On typical benchmarks, Pycket is able to eliminate more than 90% of the gradual typing overhead. While our current results are not the final word in optimizing gradual typing, we show that the situation is not dire, and where more work is needed. Pycket's performance comes from several sources, which we detail and measure individually. First, we apply a sophisticated tracing JIT compiler and optimizer, automatically generated in Pycket using the RPython framework originally created for PyPy. Second, we focus our optimization efforts on the challenges posed by run time checks, implemented in Racket by chaperones and impersonators . We introduce representation improvements, including a novel use of hidden classes to optimize these data structures.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133878", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Spenser", + "last_name": "Bauman", + "institution": "Indiana University" + }, + { + "first_name": "Carl Friedrich", + "last_name": "Bolz-Tereick", + "institution": "King's College London" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/BaumanBST17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133881", + "title": "Effective interactive resolution of static analysis alarms", + "abstract": "We propose an interactive approach to resolve static analysis alarms. Our approach synergistically combines a sound but imprecise analysis with precise but unsound heuristics, through user interaction. In each iteration, it solves an optimization problem to find a set of questions for the user such that the expected payoff is maximized. We have implemented our approach in a tool, Ursa, that enables interactive alarm resolution for any analysis specified in the declarative logic programming language Datalog. We demonstrate the effectiveness of Ursa on a state-of-the-art static datarace analysis using a suite of 8 Java programs comprising 41-194 KLOC each. Ursa is able to eliminate 74% of the false alarms per benchmark with an average payoff of 12× per question. Moreover, Ursa prioritizes user effort effectively by posing questions that yield high payoffs earlier.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133881", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Radu", + "last_name": "Grigore", + "institution": "University of Kent" + }, + { + "first_name": "Xujie", + "last_name": "Si", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/ZhangGSN17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3138818", + "title": "Learning to blame: localizing novice type errors with data-driven diagnosis", + "abstract": "Localizing type errors is challenging in languages with global type inference, as the type checker must make assumptions about what the programmer intended to do. We introduce Nate, a data-driven approach to error localization based on supervised learning. Nate analyzes a large corpus of training data -- pairs of ill-typed programs and their \"fixed\" versions -- to automatically learn a model of where the error is most likely to be found. Given a new ill-typed program, Nate executes the model to generate a list of potential blame assignments ranked by likelihood. We evaluate Nate by comparing its precision to the state of the art on a set of over 5,000 ill-typed OCaml programs drawn from two instances of an introductory programming course. We show that when the top-ranked blame assignment is considered, Nate's data-driven model is able to correctly predict the exact sub-expression that should be changed 72% of the time, 28 points higher than OCaml and 16 points higher than the state-of-the-art SHErrLoc tool. Furthermore, Nate's accuracy surpasses 85% when we consider the top two locations and reaches 91% if we consider the top three.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3138818", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric L.", + "last_name": "Seidel", + "institution": "University of California, San Diego" + }, + { + "first_name": "Huma", + "last_name": "Sibghat", + "institution": "University of California, San Diego" + }, + { + "first_name": "Kamalika", + "last_name": "Chaudhuri", + "institution": "University of California, San Diego" + }, + { + "first_name": "Westley", + "last_name": "Weimer", + "institution": "University of Virginia" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/SeidelSCWJ17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133883", + "title": "Evaluating and improving semistructured merge", + "abstract": "While unstructured merge tools rely only on textual analysis to detect and resolve conflicts, semistructured merge tools go further by partially exploiting the syntactic structure and semantics of the involved artifacts. Previous studies compare these merge approaches with respect to the number of reported conflicts, showing, for most projects and merge situations, reduction in favor of semistructured merge. However, these studies do not investigate whether this reduction actually leads to integration effort reduction (productivity) without negative impact on the correctness of the merging process (quality). To analyze that, and better understand how merge tools could be improved, in this paper we reproduce more than 30,000 merges from 50 open source projects, identifying conflicts incorrectly reported by one approach but not by the other (false positives), and conflicts correctly reported by one approach but missed by the other (false negatives). Our results and complementary analysis indicate that, in the studied sample, the number of false positives is significantly reduced when using semistructured merge. We also find evidence that its false positives are easier to analyze and resolve than those reported by unstructured merge. However, we find no evidence that semistructured merge leads to fewer false negatives, and we argue that they are harder to detect and resolve than unstructured merge false negatives. Driven by these findings, we implement an improved semistructured merge tool that further combines both approaches to reduce the false positives and false negatives of semistructured merge. We find evidence that the improved tool, when compared to unstructured merge in our sample, reduces the number of reported conflicts by half, has no additional false positives, has at least 8% fewer false negatives, and is not prohibitively slower.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133883", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guilherme", + "last_name": "Cavalcanti", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Paulo", + "last_name": "Borba", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Paola", + "last_name": "Accioly", + "institution": "Universidade Federal de Pernambuco" + } + ], + "dblp_key": "journals/pacmpl/CavalcantiBA17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133880", + "title": "Sound gradual typing is nominally alive and well", + "abstract": "Recent research has identified significant performance hurdles that sound gradual typing needs to overcome. These performance hurdles stem from the fact that the run-time checks gradual type systems insert into code can cause significant overhead. We propose that designing a type system for a gradually typed language hand in hand with its implementation from scratch is a possible way around these and several other hurdles on the way to efficient sound gradual typing. Such a design process also highlights the type-system restrictions required for efficient composition with gradual typing. We formalize the core of a nominal object-oriented language that fulfills a variety of desirable properties for gradually typed languages, and present evidence that an implementation of this language suffers minimal overhead even in adversarial benchmarks identified in earlier work.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133880", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Muehlboeck", + "institution": "Cornell University" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/MuehlboeckT17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133874", + "title": "Static placement of computation on heterogeneous devices", + "abstract": "Heterogeneous architectures characterize today hardware ranging from super-computers to smartphones. However, in spite of this importance, programming such systems is still challenging. In particular, it is challenging to map computations to the different processors of a heterogeneous device. In this paper, we provide a static analysis that mitigates this problem. Our contributions are two-fold: first, we provide a semi-context-sensitive algorithm, which analyzes the program's call graph to determine the best processor for each calling context. This algorithm is parameterized by a cost model, which takes into consideration processor's characteristics and data transfer time. Second, we show how to use simulated annealing to calibrate this cost model for a given heterogeneous architecture. We have used our ideas to build Etino, a tool that annotates C programs with OpenACC or OpenMP 4.0 directives. Etino generates code for a CPU-GPU architecture without user intervention. Experiments on classic benchmarks reveal speedups of up to 75x. Moreover, our calibration process lets avoid slowdowns of up to 720x which trivial parallelization approaches would yield.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133874", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Poesia", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Breno Campos Ferreira", + "last_name": "Guimarães", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fabrício", + "last_name": "Ferracioli", + "institution": "" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "journals/pacmpl/PoesiaGFP17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133871", + "title": "Unifying typing and subtyping", + "abstract": "In recent years dependent types have become a hot topic in programming language research. A key reason why dependent types are interesting is that they allow unifying types and terms, which enables both additional expressiveness and economy of concepts . Unfortunately there has been much less work on dependently typed calculi for object-oriented programming. This is partly because it is widely acknowledged that the combination between dependent types and subtyping is particularly challenging. This paper presents λ I ≤ , which is a dependently typed generalization of System F ≤ . The resulting calculus follows the style of Pure Type Systems, and contains a single unified syntactic sort that accounts for expressions, types and kinds. To address the challenges posed by the combination of dependent types and subtyping, λ I ≤ employs a novel technique that unifies typing and subtyping . In λ I ≤ there is only a judgement that is akin to a typed version of subtyping. Both the typing relation, as well as type well-formedness are just special cases of the subtyping relation. The resulting calculus has a rich metatheory and enjoys of several standard and desirable properties, such as subject reduction , transitivity of subtyping , narrowing as well as standard substitution lemmas . All the metatheory of λ I ≤ is mechanically proved in the Coq theorem prover. Furthermore, (and as far as we are aware) λ I ≤ is the first dependently typed calculus that completely subsumes System F ≤ , while preserving various desirable properties.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133871", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yanpeng", + "last_name": "Yang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/YangO17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133876", + "title": "Virtual machine warmup blows hot and cold", + "abstract": "Virtual Machines (VMs) with Just-In-Time (JIT) compilers are traditionally thought to execute programs in two phases: the initial warmup phase determines which parts of a program would most benefit from dynamic compilation, before JIT compiling those parts into machine code; subsequently the program is said to be at a steady state of peak performance. Measurement methodologies almost always discard data collected during the warmup phase such that reported measurements focus entirely on peak performance. We introduce a fully automated statistical approach, based on changepoint analysis, which allows us to determine if a program has reached a steady state and, if so, whether that represents peak performance or not. Using this, we show that even when run in the most controlled of circumstances, small, deterministic, widely studied microbenchmarks often fail to reach a steady state of peak performance on a variety of common VMs. Repeating our experiment on 3 different machines, we found that at most 43.5% of <VM, Benchmark> pairs consistently reach a steady state of peak performance.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133876", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Edd", + "last_name": "Barrett", + "institution": "King's College London" + }, + { + "first_name": "Carl Friedrich", + "last_name": "Bolz-Tereick", + "institution": "King's College London" + }, + { + "first_name": "Rebecca", + "last_name": "Killick", + "institution": "Lancaster University" + }, + { + "first_name": "Sarah", + "last_name": "Mount", + "institution": "King's College London" + }, + { + "first_name": "Laurence", + "last_name": "Tratt", + "institution": "King's College London" + } + ], + "dblp_key": "journals/pacmpl/BarrettBKMT17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133872", + "title": "Fast and precise type checking for JavaScript", + "abstract": "In this paper we present the design and implementation of Flow, a fast and precise type checker for JavaScript that is used by thousands of developers on millions of lines of code at Facebook every day. Flow uses sophisticated type inference to understand common JavaScript idioms precisely. This helps it find non-trivial bugs in code and provide code intelligence to editors without requiring significant rewriting or annotations from the developer. We formalize an important fragment of Flow's analysis and prove its soundness. Furthermore, Flow uses aggressive parallelization and incrementalization to deliver near-instantaneous response times. This helps it avoid introducing any latency in the usual edit-refresh cycle of rapid JavaScript development. We describe the algorithms and systems infrastructure that we built to scale Flow's analysis.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133872", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Avik", + "last_name": "Chaudhuri", + "institution": "Meta (United States)" + }, + { + "first_name": "Panagiotis", + "last_name": "Vekris", + "institution": "University of California San Diego" + }, + { + "first_name": "Sam", + "last_name": "Goldman", + "institution": "Meta (United States)" + }, + { + "first_name": "Marshall", + "last_name": "Roch", + "institution": "Meta (United States)" + }, + { + "first_name": "Gabriel", + "last_name": "Levi", + "institution": "Meta (United States)" + } + ], + "dblp_key": "journals/pacmpl/ChaudhuriVGRL17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133882", + "title": "Abridging source code", + "abstract": "In this paper, we consider the problem of source code abridgment, where the goal is to remove statements from a source code in order to display the source code in a small space, while at the same time leaving the ``important'' parts of the source code intact, so that an engineer can read the code and quickly understand purpose of the code. To this end, we develop an algorithm that looks at a number of examples, human-created source code abridgments, and learns how to remove lines from the code in order to mimic the human abridger. The learning algorithm takes into account syntactic features of the code, as well as semantic features such as control flow and data dependencies. Through a comprehensive user study, we show that the abridgments that our system produces can decrease the time that a user must look at code in order to understand its functionality, as well as increase the accuracy of the assessment, while displaying the code in a greatly reduced area.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133882", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Binhang", + "last_name": "Yuan", + "institution": "Rice University" + }, + { + "first_name": "Vijayaraghavan", + "last_name": "Murali", + "institution": "Rice University" + }, + { + "first_name": "Christopher", + "last_name": "Jermaine", + "institution": "Rice University" + } + ], + "dblp_key": "journals/pacmpl/YuanMJ17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133885", + "title": "Model-assisted machine-code synthesis", + "abstract": "Binary rewriters are tools that are used to modify the functionality of binaries lacking source code. Binary rewriters can be used to rewrite binaries for a variety of purposes including optimization, hardening, and extraction of executable components. To rewrite a binary based on semantic criteria, an essential primitive to have is a machine-code synthesizer---a tool that synthesizes an instruction sequence from a specification of the desired behavior, often given as a formula in quantifier-free bit-vector logic (QFBV). However, state-of-the-art machine-code synthesizers such as McSynth++ employ naive search strategies for synthesis: McSynth++ merely enumerates candidates of increasing length without performing any form of prioritization. This inefficient search strategy is compounded by the huge number of unique instruction schemas in instruction sets (e.g., around 43,000 in Intel's IA-32) and the exponential cost inherent in enumeration. The effect is slow synthesis: even for relatively small specifications, McSynth++ might take several minutes or a few hours to find an implementation. In this paper, we describe how we use machine learning to make the search in McSynth++ smarter and potentially faster. We converted the linear search in McSynth++ into a best-first search over the space of instruction sequences. The cost heuristic for the best-first search comes from two models---used together---built from a corpus of 〈QFBV-formula, instruction-sequence〉 pairs: (i) a language model that favors useful instruction sequences, and (ii) a regression model that correlates features of instruction sequences with features of QFBV formulas, and favors instruction sequences that are more likely to implement the input formula. Our experiments for IA-32 showed that our model-assisted synthesizer enables synthesis of code for 6 out of 50 formulas on which McSynth++ times out, speeding up the synthesis time by at least 549X, and for the remaining formulas, speeds up synthesis by 4.55X.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133885", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Venkatesh", + "last_name": "Srinivasan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ara", + "last_name": "Vartanian", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "GrammaTech (United States)" + } + ], + "dblp_key": "journals/pacmpl/SrinivasanVR17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133886", + "title": "Synthesis of data completion scripts using finite tree automata", + "abstract": "In application domains that store data in a tabular format, a common task is to fill the values of some cells using values stored in other cells. For instance, such data completion tasks arise in the context of missing value imputation in data science and derived data computation in spreadsheets and relational databases. Unfortunately, end-users and data scientists typically struggle with many data completion tasks that require non-trivial programming expertise. This paper presents a synthesis technique for automating data completion tasks using programming-by-example (PBE) and a very lightweight sketching approach. Given a formula sketch (e.g., AVG(? 1 , ? 2 )) and a few input-output examples for each hole, our technique synthesizes a program to automate the desired data completion task. Towards this goal, we propose a domain-specific language (DSL) that combines spatial and relational reasoning over tabular data and a novel synthesis algorithm that can generate DSL programs that are consistent with the input-output examples. The key technical novelty of our approach is a new version space learning algorithm that is based on finite tree automata (FTA). The use of FTAs in the learning algorithm leads to a more compact representation that allows more sharing between programs that are consistent with the examples. We have implemented the proposed approach in a tool called DACE and evaluate it on 84 benchmarks taken from online help forums. We also illustrate the advantages of our approach by comparing our technique against two existing synthesizers, namely Prose and Sketch.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133886", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/WangDS17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133888", + "title": "Synthesizing configuration file specifications with association rule learning", + "abstract": "System failures resulting from configuration errors are one of the major reasons for the compromised reliability of today's software systems. Although many techniques have been proposed for configuration error detection, these approaches can generally only be applied after an error has occurred. Proactively verifying configuration files is a challenging problem, because 1) software configurations are typically written in poorly structured and untyped “languages”, and 2) specifying rules for configuration verification is challenging in practice. This paper presents ConfigV, a verification framework for general software configurations. Our framework works as follows: in the pre-processing stage, we first automatically derive a specification. Once we have a specification, we check if a given configuration file adheres to that specification. The process of learning a specification works through three steps. First, ConfigV parses a training set of configuration files (not necessarily all correct) into a well-structured and probabilistically-typed intermediate representation. Second, based on the association rule learning algorithm, ConfigV learns rules from these intermediate representations. These rules establish relationships between the keywords appearing in the files. Finally, ConfigV employs rule graph analysis to refine the resulting rules. ConfigV is capable of detecting various configuration errors, including ordering errors, integer correlation errors, type errors, and missing entry errors. We evaluated ConfigV by verifying public configuration files on GitHub, and we show that ConfigV can detect known configuration errors in these files.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133888", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mark", + "last_name": "Santolucito", + "institution": "Yale University" + }, + { + "first_name": "Ennan", + "last_name": "Zhai", + "institution": "Yale University" + }, + { + "first_name": "Rahul M.", + "last_name": "Dhodapkar", + "institution": "" + }, + { + "first_name": "Aaron", + "last_name": "Shim", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/SantolucitoZDSP17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133892", + "title": "Heaps don't lie: countering unsoundness with heap snapshots", + "abstract": "Static analyses aspire to explore all possible executions in order to achieve soundness. Yet, in practice, they fail to capture common dynamic behavior. Enhancing static analyses with dynamic information is a common pattern, with tools such as Tamiflex. Past approaches, however, miss significant portions of dynamic behavior, due to native code, unsupported features (e.g., invokedynamic or lambdas in Java), and more. We present techniques that substantially counteract the unsoundness of a static analysis, with virtually no intrusion to the analysis logic. Our approach is reified in the HeapDL toolchain and consists in taking whole-heap snapshots during program execution, that are further enriched to capture significant aspects of dynamic behavior, regardless of the causes of such behavior. The snapshots are then used as extra inputs to the static analysis. The approach exhibits both portability and significantly increased coverage. Heap information under one set of dynamic inputs allows a static analysis to cover many more behaviors under other inputs. A HeapDL-enhanced static analysis of the DaCapo benchmarks computes 99.5% (median) of the call-graph edges of unseen dynamic executions (vs. 76.9% for the Tamiflex tool).", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133892", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "University of Malta" + }, + { + "first_name": "George", + "last_name": "Fourtounis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Adrian", + "last_name": "Francalanza", + "institution": "University of Malta" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/GrechFFS17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133894", + "title": "Familia: unifying interfaces, type classes, and family polymorphism", + "abstract": "Parametric polymorphism and inheritance are both important, extensively explored language mechanisms for providing code reuse and extensibility. But harmoniously integrating these apparently distinct mechanisms—and powerful recent forms of them, including type classes and family polymorphism—in a single language remains an elusive goal. In this paper, we show that a deep unification can be achieved by generalizing the semantics of interfaces and classes. The payoff is a significant increase in expressive power with little increase in programmer-visible complexity. Salient features of the new programming language include retroactive constraint modeling, underpinning both object-oriented programming and generic programming, and module-level inheritance with further-binding, allowing family polymorphism to be deployed at large scale. The resulting mechanism is syntactically light, and the more advanced features are transparent to the novice programmer. We describe the design of a programming language that incorporates this mechanism; using a core calculus, we show that the type system is sound. We demonstrate that this language is highly expressive by illustrating how to use it to implement highly extensible software and by showing that it can not only concisely model state-of-the-art features for code reuse, but also go beyond them.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133894", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "Cornell University" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/ZhangM17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133891", + "title": "Efficient logging in non-volatile memory by exploiting coherency protocols", + "abstract": "Non-volatile memory technologies such as PCM, ReRAM and STT-RAM allow data to be saved to persistent storage significantly faster than hard drives or SSDs. Many of the use cases for non-volatile memory requires persistent logging since it enables a set of operations to execute in an atomic manner. However, a logging protocol must handle reordering, which causes a write to reach the non-volatile memory before a previous write operation. In this paper, we show that reordering results from two parts of the system: the out-of-order execution in the CPU and the cache coherence protocol. By carefully considering the properties of these reorderings, we present a logging protocol that requires only one round trip to non-volatile memory while avoiding expensive computations, thus increasing performance. We also show how the logging protocol can be extended to building a durable set (hash map) that also requires a single round trip to non-volatile memory for inserting, updating, or deleting operations.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133891", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nachshon", + "last_name": "Cohen", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Michal", + "last_name": "Friedman", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/CohenFL17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133893", + "title": "Instrumentation bias for dynamic data race detection", + "abstract": "This paper presents Fast Instrumentation Bias (FIB), a sound and complete dynamic data race detection algorithm that improves performance by reducing or eliminating the costs of analysis atomicity. In addition to checking for errors in target programs, dynamic data race detectors must introduce synchronization to guard against metadata races that may corrupt analysis state and compromise soundness or completeness. Pessimistic analysis synchronization can account for nontrivial performance overhead in a data race detector. The core contribution of FIB is a novel cooperative ownership-based synchronization protocol whose states and transitions are derived purely from preexisting analysis metadata and logic in a standard data race detection algorithm. By exploiting work already done by the analysis, FIB ensures atomicity of dynamic analysis actions with zero additional time or space cost in the common case. Analysis of temporally thread-local or read-shared accesses completes safely with no synchronization. Uncommon write-sharing transitions require synchronous cross-thread coordination to ensure common cases may proceed synchronization-free. We implemented FIB in the Jikes RVM Java virtual machine. Experimental evaluation shows that FIB eliminates nearly all instrumentation atomicity costs on programs where data often experience windows of thread-local access. Adaptive extensions to the ownership policy effectively eliminate high coordination costs of the core ownership protocol on programs with high rates of serialized sharing. FIB outperforms a naive pessimistic synchronization scheme by 50% on average. Compared to a tuned optimistic metadata synchronization scheme based on conventional fine-grained atomic compare-and-swap operations, FIB is competitive overall, and up to 17% faster on some programs. Overall, FIB effectively exploits latent analysis and program invariants to bring strong integrity guarantees to an otherwise unsynchronized data race detection algorithm at minimal cost.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133893", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benjamin P.", + "last_name": "Wood", + "institution": "Wellesley College" + }, + { + "first_name": "Man", + "last_name": "Cao", + "institution": "Google (United States)" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/WoodCBG17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133887", + "title": "SQLizer: query synthesis from natural language", + "abstract": "This paper presents a new technique for automatically synthesizing SQL queries from natural language (NL). At the core of our technique is a new NL-based program synthesis methodology that combines semantic parsing techniques from the NLP community with type-directed program synthesis and automated program repair. Starting with a program sketch obtained using standard parsing techniques, our approach involves an iterative refinement loop that alternates between probabilistic type inhabitation and automated sketch repair. We use the proposed idea to build an end-to-end system called SQLIZER that can synthesize SQL queries from natural language. Our method is fully automated, works for any database without requiring additional customization, and does not require users to know the underlying database schema. We evaluate our approach on over 450 natural language queries concerning three different databases, namely MAS, IMDB, and YELP. Our experiments show that the desired query is ranked within the top 5 candidates in close to 90% of the cases and that SQLIZER outperforms NALIR, a state-of-the-art tool that won a best paper award at VLDB'14.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133887", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Navid", + "last_name": "Yaghmazadeh", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Thomas", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/Yaghmazadeh0DD17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133896", + "title": "Orca: GC and type system co-design for actor languages", + "abstract": "ORCA is a concurrent and parallel garbage collector for actor programs, which does not require any STW steps, or synchronization mechanisms, and that has been designed to support zero-copy message passing and sharing of mutable data. ORCA is part of a runtime for actor-based languages, which was co-designed with the Pony programming language, and in particular, with its data race free type system. By co-designing an actor language with its runtime, it was possible to exploit certain language properties in order to optimize performance of garbage collection. Namely, ORCA relies on the guarantees of absence of race conditions in order to avoid read/write barriers, and it leverages the actor message passing, for synchronization among actors. In this paper we briefly describe Pony and its type system. We use pseudo-code in order to introduce how ORCA allocates and deallocates objects, how it shares mutable data without requiring barriers upon data mutation, and how can immutability be used to further optimize garbage collection. Moreover, we discuss the advantages of co-designing an actor language with its runtime, and we demonstrate that ORCA can be implemented in a performant and scalable way through a set of micro-benchmarks, including a comparison with other well-known collectors.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133896", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sylvan", + "last_name": "Clebsch", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Juliana", + "last_name": "Franco", + "institution": "Imperial College London" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + }, + { + "first_name": "Albert Mingkun", + "last_name": "Yang", + "institution": "Uppsala University" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/ClebschFDYWV17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133895", + "title": "Static stages for heterogeneous programming", + "abstract": "Heterogeneous hardware is central to modern advances in performance and efficiency. Mainstream programming models for heterogeneous architectures, however, sacrifice safety and expressiveness in favor of low-level control over performance details. The interfaces between hardware units consist of verbose, unsafe APIs; hardware-specific languages make it difficult to move code between units; and brittle preprocessor macros complicate the task of specializing general code for efficient accelerated execution. We propose a unified low-level programming model for heterogeneous systems that offers control over performance, safe communication constructs, cross-device code portability, and hygienic metaprogramming for specialization. The language extends constructs from multi-stage programming to separate code for different hardware units, to communicate between them, and to express compile-time code optimization. We introduce static staging, a different take on multi-stage programming that lets the compiler generate all code and communication constructs ahead of time. To demonstrate our approach, we use static staging to implement BraidGL, a real-time graphics programming language for CPU-GPU systems. Current real-time graphics software in OpenGL uses stringly-typed APIs for communication and unsafe preprocessing to generate specialized GPU code variants. In BraidGL, programmers instead write hybrid CPU-GPU software in a unified language. The compiler statically generates target-specific code and guarantees safe communication between the CPU and the graphics pipeline stages. Example scenes demonstrate the language's productivity advantages: BraidGL eliminates the safety and expressiveness pitfalls of OpenGL and makes common specialization techniques easy to apply. The case study demonstrates how static staging can express core placement and specialization in general heterogeneous programming.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133895", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "Cornell University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Google (United States)" + }, + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/SampsonMM17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133890", + "title": "Practical initialization race detection for JavaScript web applications", + "abstract": "Event races are a common source of subtle errors in JavaScript web applications. Several automated tools for detecting event races have been developed, but experiments show that their accuracy is generally quite low. We present a new approach that focuses on three categories of event race errors that often appear during the initialization phase of web applications: form-input-overwritten errors, late-event-handler-registration errors, and access-before-definition errors. The approach is based on a dynamic analysis that uses a combination of adverse and approximate execution. Among the strengths of the approach are that it does not require browser modifications, expensive model checking, or static analysis. In an evaluation on 100 widely used websites, our tool InitRacer reports 1085 initialization races, while providing informative explanations of their causes and effects. A manual study of 218 of these reports shows that 111 of them lead to uncaught exceptions and at least 47 indicate errors that affect the functionality of the websites.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133890", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christoffer Quist", + "last_name": "Adamsen", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/AdamsenMT17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133889", + "title": "Natural synthesis of provably-correct data-structure manipulations", + "abstract": "This paper presents natural synthesis, which generalizes the proof-theoretic synthesis technique to support very expressive logic theories. This approach leverages the natural proof methodology and reduces an intractable, unbounded-size synthesis problem to a tractable, bounded-size synthesis problem, which is amenable to be handled by modern inductive synthesis engines. The synthesized program admits a natural proof and is a provably-correct solution to the original synthesis problem. We explore the natural synthesis approach in the domain of imperative data-structure manipulations and present a novel syntax-guided synthesizer based on natural synthesis. The input to our system is a program template together with a rich functional specification that the synthesized program must meet. Our system automatically produces a program implementation along with necessary proof artifacts, namely loop invariants and ranking functions, and guarantees the total correctness with a natural proof. Experiments show that our natural synthesizer can efficiently produce provably-correct implementations for sorted lists and binary search trees. To our knowledge, this is the first system that can automatically synthesize these programs, their functional correctness and their termination in tandem from bare-bones control flow skeletons.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133889", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/QiuS17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133897", + "title": "Monadic composition for deterministic, parallel batch processing", + "abstract": "Achieving determinism on real software systems remains difficult. Even a batch-processing job, whose task is to map input bits to output bits, risks nondeterminism from thread scheduling, system calls, CPU instructions, and leakage of environmental information such as date or CPU model. In this work, we present a system for achieving low-overhead deterministic execution of batch-processing programs that read and write the file system—turning them into pure functions on files. We allow multi-process executions where a permissions system prevents races on the file system. Process separation enables different processes to enforce permissions and enforce determinism using distinct mechanisms. Our prototype, DetFlow, allows a statically-typed coordinator process to use shared-memory parallelism, as well as invoking process-trees of sandboxed legacy binaries. DetFlow currently implements the coordinator as a Haskell program with a restricted I/O type for its main function: a new monad we call DetIO. Legacy binaries launched by the coordinator run concurrently, but internally each process schedules threads sequentially, allowing dynamic determinism-enforcement with predictably low overhead. We evaluate DetFlow by applying it to bioinformatics data pipelines and software build systems. DetFlow enables determinizing these data-processing workflows by porting a small amount of code to become a statically-typed coordinator. This hybrid approach of static and dynamic determinism enforcement permits freedom where possible but restrictions where necessary.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133897", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ryan G.", + "last_name": "Scott", + "institution": "Indiana University" + }, + { + "first_name": "Omar S. Navarro", + "last_name": "Leija", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Joseph", + "last_name": "Devietti", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/ScottLDN17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133898", + "title": "GLORE: generalized loop redundancy elimination upon LER-notation", + "abstract": "This paper presents GLORE, a novel approach to enabling the detection and removal of large-scoped redundant computations in nested loops. GLORE works on LER-notation, a new representation of computations in both regular and irregular loops. Together with a set of novel algorithms, it makes GLORE able to systematically consider computation reordering at both the expression level and the loop level in a unified manner. GLORE shows an applicability much broader than prior methods have, and frequently lowers the computational complexities of some nested loops that are elusive to prior optimization techniques, producing significantly larger speedups.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133898", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yufei", + "last_name": "Ding", + "institution": "North Carolina State University" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + } + ], + "dblp_key": "journals/pacmpl/DingS17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133899", + "title": "Verifying spatial properties of array computations", + "abstract": "Arrays computations are at the core of numerical modelling and computational science applications. However, low-level manipulation of array indices is a source of program error. Many practitioners are aware of the need to ensure program correctness, yet very few of the techniques from the programming research community are applied by scientists. We aim to change that by providing targetted lightweight verification techniques for scientific code. We focus on the all too common mistake of array offset errors as a generalisation of off-by-one errors. Firstly, we report on a code analysis study on eleven real-world computational science code base, identifying common idioms of array usage and their spatial properties. This provides much needed data on array programming idioms common in scientific code. From this data, we designed a lightweight declarative specification language capturing the majority of array access patterns via a small set of combinators. We detail a semantic model, and the design and implementation of a verification tool for our specification language, which both checks and infers specifications. We evaluate our tool on our corpus of scientific code. Using the inference mode, we found roughly 87,000 targets for specification across roughly 1.1 million lines of code, showing that the vast majority of array computations read from arrays in a pattern with a simple, regular, static shape. We also studied the commit logs of one of our corpus packages, finding past bug fixes for which our specification system distinguishes the change and thus could have been applied to detect such bugs.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133899", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + }, + { + "first_name": "Mistral", + "last_name": "Contrastin", + "institution": "University of Cambridge" + }, + { + "first_name": "Matthew", + "last_name": "Danish", + "institution": "University of Cambridge" + }, + { + "first_name": "Andrew", + "last_name": "Rice", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/OrchardCDR17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133901", + "title": "The tensor algebra compiler", + "abstract": "Tensor algebra is a powerful tool with applications in machine learning, data analytics, engineering and the physical sciences. Tensors are often sparse and compound operations must frequently be computed in a single kernel for performance and to save memory. Programmers are left to write kernels for every operation of interest, with different mixes of dense and sparse tensors in different formats. The combinations are infinite, which makes it impossible to manually implement and optimize them all. This paper introduces the first compiler technique to automatically generate kernels for any compound tensor algebra operation on dense and sparse tensors. The technique is implemented in a C++ library called taco. Its performance is competitive with best-in-class hand-optimized kernels in popular libraries, while supporting far more tensor operations.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133901", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Shoaib", + "last_name": "Kamil", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Stephen Y.", + "last_name": "Chou", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "David", + "last_name": "Lugato", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KjolstadKCLA17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133902", + "title": "Seam: provably safe local edits on graphs", + "abstract": "Algorithms that create and mutate graph data structures are challenging to implement correctly. However, verifying even basic properties of low-level implementations, such as referential integrity and memory safety, remains non-trivial. Furthermore, any extension to such a data structure multiplies the complexity of its implementation, while compounding the challenges in reasoning about correctness. We take a language design approach to this problem. We propose Seam, a language for expressing local edits to graph-like data structures, based on a relational data model, and such that data integrity can be verified automatically. We present a verification method that leverages an SMT solver, and prove it sound and precise (complete modulo termination of the SMT solver). We evaluate the verification capabilities of Seam empirically, and demonstrate its applicability to a variety of examples, most notably a new class of verification tasks derived from geometric remeshing operations used in scientific simulation and computer graphics. We describe our prototype implementation of a Seam compiler that generates low-level code, which can then be integrated into larger applications. We evaluate our compiler on a sample application, and demonstrate competitive execution time, compared to hand-written implementations.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133902", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Manolis", + "last_name": "Papadakis", + "institution": "Stanford University" + }, + { + "first_name": "Gilbert", + "last_name": "Bernstein", + "institution": "Stanford University" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + }, + { + "first_name": "Pat", + "last_name": "Hanrahan", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/PapadakisB0AH17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133900", + "title": "TreeFuser: a framework for analyzing and fusing general recursive tree traversals", + "abstract": "Series of traversals of tree structures arise in numerous contexts: abstract syntax tree traversals in compiler passes, rendering traversals of the DOM in web browsers, kd-tree traversals in computational simulation codes. In each of these settings, a tree is traversed multiple times to compute various values and modify various portions of the tree. While it is relatively easy to write these traversals as separate small updates to the tree, for efficiency reasons, traversals are often manually fused to reduce the number of times that each portion of the tree is traversed: by performing multiple operations on the tree simultaneously, each node of the tree can be visited fewer times, increasing opportunities for optimization and decreasing cache pressure and other overheads. This fusion process is often done manually, requiring careful understanding of how each of traversals of the tree interact. This paper presents an automatic approach to traversal fusion: tree traversals can be written independently, and then our framework analyzes the dependences between the traversals to determine how they can be fused to reduce the number of visits to each node in the tree. A critical aspect of our framework is that it exploits two opportunities to increase the amount of fusion: i) it automatically integrates code motion, and ii) it supports partial fusion, where portions of one traversal can be fused with another, allowing for a reduction in node visits without requiring that two traversals be fully fused. We implement our framework in Clang, and show across several case studies that we can successfully fuse complex tree traversals, reducing the overall number of traversals and substantially improving locality and performance.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133900", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Laith", + "last_name": "Sakka", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kirshanthan", + "last_name": "Sundararajah", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/SakkaS017", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133904", + "title": "FairSquare: probabilistic verification of program fairness", + "abstract": "With the range and sensitivity of algorithmic decisions expanding at a break-neck speed, it is imperative that we aggressively investigate fairness and bias in decision-making programs. First, we show that a number of recently proposed formal definitions of fairness can be encoded as probabilistic program properties. Second, with the goal of enabling rigorous reasoning about fairness, we design a novel technique for verifying probabilistic properties that admits a wide class of decision-making programs. Third, we present FairSquare, the first verification tool for automatically certifying that a program meets a given fairness property. We evaluate FairSquare on a range of decision-making programs. Our evaluation demonstrates FairSquare’s ability to verify fairness for a range of different programs, which we show are out-of-reach for state-of-the-art program analysis techniques.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133904", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Samuel", + "last_name": "Drews", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aditya V.", + "last_name": "Nori", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/AlbarghouthiDDN17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133905", + "title": "Reasoning on divergent computations with coaxioms", + "abstract": "Coaxioms have been recently introduced to enhance the expressive power of inference systems, by supporting interpretations which are neither purely inductive, nor coinductive. This paper proposes a novel approach based on coaxioms to capture divergence in semantic definitions by allowing inductive and coinductive semantic rules to be merged together for defining a unique semantic judgment. In particular, coinduction is used to derive a special result which models divergence. In this way, divergent, terminating, and stuck computations can be properly distinguished even in semantic definitions where this is typically difficult, as in big-step style. We show how the proposed approach can be applied to several languages; in particular, we first illustrate it on the paradigmatic example of the λ-calculus, then show how it can be adopted for defining the big-step semantics of a simple imperative Java-like language. We provide proof techniques to show classical results, including equivalence with small-step semantics, and type soundness for typed versions of both languages.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133905", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Davide", + "last_name": "Ancona", + "institution": "University of Genoa" + }, + { + "first_name": "Francesco", + "last_name": "Dagnino", + "institution": "University of Genoa" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "journals/pacmpl/AnconaDZ17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133906", + "title": "Restricting grammars with tree automata", + "abstract": "Precedence and associativity declarations in systems like yacc resolve ambiguities in context-free grammars (CFGs) by specifying restrictions on allowed parses. However, they are special purpose and do not handle the grammatical restrictions that language designers need in order to resolve ambiguities like dangling else, the interactions between binary operators and functional if expressions in ML, and the interactions between object allocation and function calls in JavaScript. Often, language designers resort to restructuring their grammars in order to encode these restrictions, but this obfuscates the designer's intent and can make grammars more difficult to read, write, and maintain. In this paper, we show how tree automata can modularly and concisely encode such restrictions. We do this by reinterpreting CFGs as tree automata and then intersecting them with tree automata encoding the desired restrictions. The results are then reinterpreted back into CFGs that encode the specified restrictions. This process can be used as a preprocessing step before other CFG manipulations and is well behaved. It performs well in practice and never introduces ambiguities or LR( k ) conflicts.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133906", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/0001M17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133907", + "title": "Exploiting implicit beliefs to resolve sparse usage problem in usage-based specification mining", + "abstract": "Frameworks and libraries provide application programming interfaces (APIs) that serve as building blocks in modern software development. As APIs present the opportunity of increased productivity, it also calls for correct use to avoid buggy code. The usage-based specification mining technique has shown great promise in solving this problem through a data-driven approach. These techniques leverage the use of the API in large corpora to understand the recurring usages of the APIs and infer behavioral specifications (preconditions and postconditions) from such usages. A challenge for such technique is thus inference in the presence of insufficient usages, in terms of both frequency and richness. We refer to this as a \"sparse usage problem.\" This paper presents the first technique to solve the sparse usage problem in usage-based precondition mining. Our key insight is to leverage implicit beliefs to overcome sparse usage. An implicit belief (IB) is the knowledge implicitly derived from the fact about the code. An IB about a program is known implicitly to a programmer via the language's constructs and semantics, and thus not explicitly written or specified in the code. The technical underpinnings of our new precondition mining approach include a technique to analyze the data and control flow in the program leading to API calls to infer preconditions that are implicitly present in the code corpus, a catalog of 35 code elements in total that can be used to derive implicit beliefs from a program, and empirical evaluation of all of these ideas. We have analyzed over 350 millions lines of code and 7 libraries that suffer from the sparse usage problem. Our approach realizes 6 implicit beliefs and we have observed that adding single-level context sensitivity can further improve the result of usage based precondition mining. The result shows that we achieve overall 60% in precision and 69% in recall and the accuracy is relatively improved by 32% in precision and 78% in recall compared to base usage-based mining approach for these libraries.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133907", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Samantha Syeda", + "last_name": "Khairunnesa", + "institution": "Iowa State University" + }, + { + "first_name": "Hoan Anh", + "last_name": "Nguyen", + "institution": "Iowa State University" + }, + { + "first_name": "Tien N.", + "last_name": "Nguyen", + "institution": "" + }, + { + "first_name": "Hridesh", + "last_name": "Rajan", + "institution": "Iowa State University" + } + ], + "dblp_key": "journals/pacmpl/SamanthaNNR17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133908", + "title": "DéjàVu: a map of code duplicates on GitHub", + "abstract": "Previous studies have shown that there is a non-trivial amount of duplication in source code. This paper analyzes a corpus of 4.5 million non-fork projects hosted on GitHub representing over 428 million files written in Java, C++, Python, and JavaScript. We found that this corpus has a mere 85 million unique files. In other words, 70% of the code on GitHub consists of clones of previously created files. There is considerable variation between language ecosystems. JavaScript has the highest rate of file duplication, only 6% of the files are distinct. Java, on the other hand, has the least duplication, 60% of files are distinct. Lastly, a project-level analysis shows that between 9% and 31% of the projects contain at least 80% of files that can be found elsewhere. These rates of duplication have implications for systems built on open source software as well as for researchers interested in analyzing large code bases. As a concrete artifact of this study, we have created DéjàVu, a publicly available map of code duplicates in GitHub repositories.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133908", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cristina Videira", + "last_name": "Lopes", + "institution": "University of California, Irvine" + }, + { + "first_name": "Petr", + "last_name": "Maj", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Pedro", + "last_name": "Martins", + "institution": "University of California, Irvine" + }, + { + "first_name": "Vaibhav", + "last_name": "Saini", + "institution": "University of California, Irvine" + }, + { + "first_name": "Di", + "last_name": "Yang", + "institution": "University of California, Irvine" + }, + { + "first_name": "Žitný", + "last_name": "Jakub", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Hitesh", + "last_name": "Sajnani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/LopesMMSYZSV17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133909", + "title": "Understanding the use of lambda expressions in Java", + "abstract": "Java 8 retrofitted lambda expressions, a core feature of functional programming, into a mainstream object-oriented language with an imperative paradigm. However, we do not know how Java developers have adapted to the functional style of thinking, and more importantly, what are the reasons motivating Java developers to adopt functional programming. Without such knowledge, researchers miss opportunities to improve the state of the art, tool builders use unrealistic assumptions, language designers fail to improve upon their designs, and developers are unable to explore efficient and effective use of lambdas. We present the first large-scale, quantitative and qualitative empirical study to shed light on how imperative programmers use lambda expressions as a gateway into functional thinking. Particularly, we statically scrutinize the source code of 241 open-source projects with 19,770 contributors, to study the characteristics of 100,540 lambda expressions. Moreover, we investigate the historical trends and adoption rates of lambdas in the studied projects. To get a complementary perspective, we seek the underlying reasons on why developers introduce lambda expressions, by surveying 97 developers who are introducing lambdas in their projects, using the firehouse interview method. Among others, our findings revealed an increasing trend in the adoption of lambdas in Java: in 2016, the ratio of lambdas introduced per added line of code increased by 54% compared to 2015. Lambdas were used for various reasons, including but not limited to (i) making existing code more succinct and readable, (ii) avoiding code duplication, and (iii) simulating lazy evaluation of functions. Interestingly, we found out that developers are using Java's built-in functional interfaces inefficiently, i.e., they prefer to use general functional interfaces over the specialized ones, overlooking the performance overheads that might be imposed. Furthermore, developers are not adopting techniques from functional programming, e.g., currying. Finally, we present the implications of our findings for researchers, tool builders, language designers, and developers.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133909", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Davood", + "last_name": "Mazinanian", + "institution": "Concordia University" + }, + { + "first_name": "Ameya", + "last_name": "Ketkar", + "institution": "Oregon State University" + }, + { + "first_name": "Nikolaos", + "last_name": "Tsantalis", + "institution": "Concordia University" + }, + { + "first_name": "Danny", + "last_name": "Dig", + "institution": "Oregon State University" + } + ], + "dblp_key": "journals/pacmpl/MazinanianKTD17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133911", + "title": "A verified messaging system", + "abstract": "We present a concurrent-read exclusive-write buffer system with strong correctness and security properties. Our motivating application for this system is the distribution of sensor values in a multicomponent vehicle-control system, where some components are unverified and possibly malicious, and other components are vehicle-control-critical and must be verified. Valid participants are guaranteed correct communication (i.e., the writer is always able to write to an unused buffer, and readers always read the most recently published value), while invalid readers or writers cannot compromise the correctness or liveness of valid participants. There is only one writer, all operations are wait-free, and there is no extra process or thread mediating communication. We prove the correctness of the system with valid participants by formally verifying a C implementation of the system in Coq, using the Verified Software Toolchain extended with an atomic exchange operation. The result is the first C-level mechanized verification of a nonblocking communication protocol.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133911", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William", + "last_name": "Mansky", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + }, + { + "first_name": "Aleksey", + "last_name": "Nogin", + "institution": "HRL Laboratories (United States)" + } + ], + "dblp_key": "journals/pacmpl/ManskyAN17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133912", + "title": "Who guards the guards? formal validation of the Arm v8-m architecture specification", + "abstract": "Software and hardware are increasingly being formally verified against specifications, but how can we verify the specifications themselves? This paper explores what it means to formally verify a specification. We solve three challenges: (1) How to create a secondary, higher-level specification that can be effectively reviewed by processor designers who are not experts in formal verification; (2) How to avoid common-mode failures between the specifications; and (3) How to automatically verify the two specifications against each other. One of the most important specifications for software verification is the processor specification since it defines the behaviour of machine code and of hardware protection features used by operating systems. We demonstrate our approach on ARM's v8-M Processor Specification, which is intended to improve the security of Internet of Things devices. Thus, we focus on establishing the security guarantees the architecture is intended to provide. Despite the fact that the ARM v8-M specification had previously been extensively tested, we found twelve bugs (including two security bugs) that have all been fixed by ARM.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133912", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alastair", + "last_name": "Reid", + "institution": "ARM (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/Reid17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133910", + "title": "A model for reasoning about JavaScript promises", + "abstract": "In JavaScript programs, asynchrony arises in situations such as web-based user-interfaces, communicating with servers through HTTP requests, and non-blocking I/O. Event-based programming is the most popular approach for managing asynchrony, but suffers from problems such as lost events and event races, and results in code that is hard to understand and debug. Recently, ECMAScript 6 has added support for promises, an alternative mechanism for managing asynchrony that enables programmers to chain asynchronous computations while supporting proper error handling. However, promises are complex and error-prone in their own right, so programmers would benefit from techniques that can reason about the correctness of promise-based code. Since the ECMAScript 6 specification is informal and intended for implementers of JavaScript engines, it does not provide a suitable basis for formal reasoning. This paper presents λ p , a core calculus that captures the essence of ECMAScript 6 promises. Based on λ p , we introduce the promise graph, a program representation that can assist programmers with debugging of promise-based code. We then report on a case study in which we investigate how the promise graph can be helpful for debugging errors related to promises in code fragments posted to the StackOverflow website.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133910", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/MadsenLT17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133913", + "title": "Robust and compositional verification of object capability patterns", + "abstract": "In scenarios such as web programming, where code is linked together from multiple sources, object capability patterns (OCPs) provide an essential safeguard, enabling programmers to protect the private state of their objects from corruption by unknown and untrusted code. However, the benefits of OCPs in terms of program verification have never been properly formalized. In this paper, building on the recently developed Iris framework for concurrent separation logic, we develop OCPL, the first program logic for compositionally specifying and verifying OCPs in a language with closures, mutable state, and concurrency. The key idea of OCPL is to account for the interface between verified and untrusted code by adopting a well-known idea from the literature on security protocol verification, namely robust safety . Programs that export only properly wrapped values to their environment can be proven robustly safe, meaning that their untrusted environment cannot violate their internal invariants. We use OCPL to give the first general, compositional, and machine-checked specs for several commonly-used OCPs—including the dynamic sealing , membrane , and caretaker patterns—which we then use to verify robust safety for representative client code. All our results are fully mechanized in the Coq proof assistant.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133913", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Swasey", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/Swasey0D17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133914", + "title": "Type test scripts for TypeScript testing", + "abstract": "TypeScript applications often use untyped JavaScript libraries. To support static type checking of such applications, the typed APIs of the libraries are expressed as separate declaration files. This raises the challenge of checking that the declaration files are correct with respect to the library implementations. Previous work has shown that mismatches are frequent and cause TypeScript's type checker to misguide the programmers by rejecting correct applications and accepting incorrect ones. This paper shows how feedback-directed random testing, which is an automated testing technique that has mostly been used for testing Java libraries, can be adapted to effectively detect such type mismatches. Given a JavaScript library with a TypeScript declaration file, our tool TSTEST generates a \"type test script\", which is an application that interacts with the library and tests that it behaves according to the type declarations. Compared to alternative solutions that involve static analysis, this approach finds significantly more mismatches in a large collection of real-world JavaScript libraries with TypeScript declaration files, and with fewer false positives. It also has the advantage that reported mismatches are easily reproducible with concrete executions, which aids diagnosis and debugging.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133914", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Erik Krogh", + "last_name": "Kristensen", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/KristensenM17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133915", + "title": "A solver-aided language for test input generation", + "abstract": "Developing a small but useful set of inputs for tests is challenging. We show that a domain-specific language backed by a constraint solver can help the programmer with this process. The solver can generate a set of test inputs and guarantee that each input is different from other inputs in a way that is useful for testing. This paper presents Iorek: a tool that empowers the programmer with the ability to express to any SMT solver what it means for inputs to be different. The core of Iorek is a rich language for constraining the set of inputs, which includes a novel bounded enumeration mechanism that makes it easy to define and encode a flexible notion of difference over a recursive structure. We demonstrate the flexibility of this mechanism for generating strings. We use Iorek to test real services and find that it is effective at finding bugs. We also build Iorek into a random testing tool and show that it increases coverage.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133915", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Talia", + "last_name": "Ringer", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Daniel", + "last_name": "Schwartz‐Narbonne", + "institution": "Amazon (United States)" + }, + { + "first_name": "Serdar", + "last_name": "Taşiran", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/RingerGST17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133916", + "title": "Transforming programs and tests in tandem for fault localization", + "abstract": "Localizing failure-inducing code is essential for software debugging. Manual fault localization can be quite tedious, error-prone, and time-consuming. Therefore, a huge body of research e orts have been dedicated to automated fault localization. Spectrum-based fault localization, the most intensively studied fault localization approach based on test execution information, may have limited effectiveness, since a code element executed by a failed tests may not necessarily have impact on the test outcome and cause the test failure. To bridge the gap, mutation-based fault localization has been proposed to transform the programs under test to check the impact of each code element for better fault localization. However, there are limited studies on the effectiveness of mutation-based fault localization on sufficient number of real bugs. In this paper, we perform an extensive study to compare mutation-based fault localization techniques with various state-of-the-art spectrum-based fault localization techniques on 357 real bugs from the Defects4J benchmark suite. The study results firstly demonstrate the effectiveness of mutation-based fault localization, as well as revealing a number of guidelines for further improving mutation-based fault localization. Based on the learnt guidelines, we further transform test outputs/messages and test code to obtain various mutation information. Then, we propose TraPT, an automated Learning-to-Rank technique to fully explore the obtained mutation information for effective fault localization. The experimental results show that TraPT localizes 65.12% and 94.52% more bugs within Top-1 than state-of-the-art mutation and spectrum based techniques when using the default setting of LIBSVM.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133916", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xia", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Lingming", + "last_name": "Zhang", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/LiZ17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133917", + "title": "Automated testing of graphics shader compilers", + "abstract": "We present an automated technique for finding defects in compilers for graphics shading languages. key challenge in compiler testing is the lack of an oracle that classifies an output as correct or incorrect; this is particularly pertinent in graphics shader compilers where the output is a rendered image that is typically under-specified. Our method builds on recent successful techniques for compiler validation based on metamorphic testing, and leverages existing high-value graphics shaders to create sets of transformed shaders that should be semantically equivalent. Rendering mismatches are then indicative of shader compilation bugs. Deviant shaders are automatically minimized to identify, in each case, a minimal change to an original high-value shader that induces a shader compiler bug. We have implemented the approach as a tool, GLFuzz, targeting the OpenGL shading language, GLSL. Our experiments over a set of 17 GPU and driver configurations, spanning the main 7 GPU designers, have led to us finding and reporting more than 60 distinct bugs, covering all tested configurations. As well as defective rendering, these issues identify security-critical vulnerabilities that affect WebGL, including a significant remote information leak security bug where a malicious web page can capture the contents of other browser tabs, and a bug whereby visiting a malicious web page can lead to a ``blue screen of death'' under Windows 10. Our findings show that shader compiler defects are prevalent, and that metamorphic testing provides an effective means for detecting them automatically.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133917", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Hugues", + "last_name": "Evrard", + "institution": "Imperial College London" + }, + { + "first_name": "Andrei", + "last_name": "Lascu", + "institution": "Imperial College London" + }, + { + "first_name": "Paul", + "last_name": "Thomson", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/DonaldsonELT17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133903", + "title": "TiML: a functional language for practical complexity analysis with invariants", + "abstract": "We present TiML (Timed ML), an ML-like functional language with time-complexity annotations in types. It uses indexed types to express sizes of data structures and upper bounds on running time of functions; and refinement kinds to constrain these indices, expressing data-structure invariants and pre/post-conditions. Indexed types are flexible enough that TiML avoids a built-in notion of ≴size,≵ and the programmer can choose to index user-defined datatypes in any way that helps her analysis. TiML's distinguishing characteristic is supporting highly automated time-bound verification applicable to data structures with nontrivial invariants. The programmer provides type annotations, and the typechecker generates verification conditions that are discharged by an SMT solver. Type and index inference are supported to lower annotation burden, and, furthermore, big-O complexity can be inferred from recurrences generated during typechecking by a recurrence solver based on heuristic pattern matching (e.g. using the Master Theorem to handle divide-and-conquer-like recurrences). We have evaluated TiML's usability by implementing a broad suite of case-study modules, demonstrating that TiML, though lacking full automation and theoretical completeness, is versatile enough to verify worst-case and/or amortized complexities for algorithms and data structures like classic list operations, merge sort, Dijkstra's shortest-path algorithm, red-black trees, Braun trees, functional queues, and dynamic tables with bounds like m n log n . The learning curve and annotation burden are reasonable, as we argue with empirical results on our case studies. We formalized TiML's type-soundness proof in Coq.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133903", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peng", + "last_name": "Wang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Peking University" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/WangWC17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133918", + "title": "Bounded exhaustive test-input generation on GPUs", + "abstract": "Bounded exhaustive testing is an effective methodology for detecting bugs in a wide range of applications. A well-known approach for bounded exhaustive testing is Korat. It generates all test inputs, up to a given small size, based on a formal specification that is written as an executable predicate and characterizes properties of desired inputs. Korat uses the predicate's executions on candidate inputs to implement a backtracking search based on pruning to systematically explore the space of all possible inputs and generate only those that satisfy the specification. This paper presents a novel approach for speeding up test generation for bounded exhaustive testing using Korat. The novelty of our approach is two-fold. One, we introduce a new technique for writing the specification predicate based on an abstract representation of candidate inputs, so that the predicate executes directly on these abstract structures and each execution has a lower cost. Two, we use the abstract representation as the basis to define the first technique for utilizing GPUs for systematic test generation using executable predicates. Moreover, we present a suite of optimizations that enable effective utilization of the computational resources offered by modern GPUs. We use our prototype tool KoratG to experimentally evaluate our approach using a suite of 7 data structures that were used in prior studies on bounded exhaustive testing. Our results show that our abstract representation can speed up test generation by 5.68 times on a standard CPU, while execution on a GPU speeds up the execution, on average, by 17.46 times.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133918", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ahmet", + "last_name": "Çelik", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sreepathi", + "last_name": "Pai", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Milos", + "last_name": "Gligoric", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/CelikPKG17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3141879", + "title": "Project snowflake: non-blocking safe manual memory management in .NET", + "abstract": "Garbage collection greatly improves programmer productivity and ensures memory safety. Manual memory management on the other hand often delivers better performance but is typically unsafe and can lead to system crashes or security vulnerabilities. We propose integrating safe manual memory management with garbage collection in the .NET runtime to get the best of both worlds. In our design, programmers can choose between allocating objects in the garbage collected heap or the manual heap. All existing applications run unmodified, and without any performance degradation, using the garbage collected heap. Our programming model for manual memory management is flexible: although objects in the manual heap can have a single owning pointer, we allow deallocation at any program point and concurrent sharing of these objects amongst all the threads in the program. Experimental results from our .NET CoreCLR implementation on real-world applications show substantial performance gains especially in multithreaded scenarios: up to 3x savings in peak working sets and 2x improvements in runtime.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3141879", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dimitrios", + "last_name": "Vytiniotis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Kapil", + "last_name": "Vaswani", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Manuel", + "last_name": "Costa", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Pantazis", + "last_name": "Deligiannis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dylan", + "last_name": "McDermott", + "institution": "University of Cambridge" + }, + { + "first_name": "Aaron", + "last_name": "Blankstein", + "institution": "Princeton University" + }, + { + "first_name": "Jonathan", + "last_name": "Balkind", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/ParkinsonVVCDMB17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133920", + "title": "Alpaca: intermittent execution without checkpoints", + "abstract": "The emergence of energy harvesting devices creates the potential for batteryless sensing and computing devices. Such devices operate only intermittently, as energy is available, presenting a number of challenges for software developers. Programmers face a complex design space requiring reasoning about energy, memory consistency, and forward progress. This paper introduces Alpaca, a low-overhead programming model for intermittent computing on energy-harvesting devices. Alpaca programs are composed of a sequence of user-defined tasks. The Alpaca runtime preserves execution progress at the granularity of a task. The key insight in Alpaca is the privatization of data shared between tasks. Shared values written in a task are detected using idempotence analysis and copied into a buffer private to the task. At the end of the task, modified values from the private buffer are atomically committed to main memory, ensuring that data remain consistent despite power failures. Alpaca provides a familiar programming interface, a highly efficient runtime model, and places fewer restrictions on a target device's hardware architecture. We implemented a prototype of Alpaca as an extension to C with an LLVM compiler pass. We evaluated Alpaca, and directly compared to two systems from prior work. Alpaca eliminates checkpoints, which improves performance up to 15x, and avoids static multi-versioning, which improves memory consumption by up to 5.5x.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133920", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kiwan", + "last_name": "Maeng", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Alexei", + "last_name": "Colin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/MaengCL17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133923", + "title": "IDEal: efficient and precise alias-aware dataflow analysis", + "abstract": "Program analyses frequently track objects throughout a program, which requires reasoning about aliases. Most dataflow analysis frameworks, however, delegate the task of handling aliases to the analysis clients, which causes a number of problems. For instance, custom-made extensions for alias analysis are complex and cannot easily be reused. On the other hand, due to the complex interfaces involved, off-the-shelf alias analyses are hard to integrate precisely into clients. Lastly, for precision many clients require strong updates, and alias abstractions supporting strong updates are often relatively inefficient. In this paper, we present IDEal, an alias-aware extension to the framework for Interprocedural Distributive Environment (IDE) problems. IDEal relieves static-analysis authors completely of the burden of handling aliases by automatically resolving alias queries on-demand, both efficiently and precisely. IDEal supports a highly precise analysis using strong updates by resorting to an on-demand, flow-sensitive, and context-sensitive all-alias analysis. Yet, it achieves previously unseen efficiency by propagating aliases individually, creating highly reusable per-pointer summaries. We empirically evaluate IDEal by comparing TSf, a state-of-the-art typestate analysis, to TSal, an IDEal-based typestate analysis. Our experiments show that the individual propagation of aliases within IDEal enables TSal to propagate 10.4x fewer dataflow facts and analyze 10.3x fewer methods when compared to TSf. On the DaCapo benchmark suite, TSal is able to efficiently compute precise results.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133923", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Späth", + "institution": "Fraunhofer Institute for Mechatronic Systems Design" + }, + { + "first_name": "Karim", + "last_name": "Ali", + "institution": "University of Alberta" + }, + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Paderborn University" + } + ], + "dblp_key": "journals/pacmpl/SpathAB17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3138224", + "title": "Reliable and automatic composition of language extensions to C: the ableC extensible language framework", + "abstract": "This paper describes an extensible language framework, ableC, that allows programmers to import new, domain-specific, independently-developed language features into their programming language, in this case C. Most importantly, this framework ensures that the language extensions will automatically compose to form a working translator that does not terminate abnormally. This is possible due to two modular analyses that extension developers can apply to their language extension to check its composability. Specifically, these ensure that the composed concrete syntax specification is non-ambiguous and the composed attribute grammar specifying the semantics is well-defined. This assurance and the expressiveness of the supported extensions is a distinguishing characteristic of the approach. The paper describes a number of techniques for specifying a host language, in this case C at the C11 standard, to make it more amenable to language extension. These include techniques that make additional extensions pass these modular analyses, refactorings of the host language to support a wider range of extensions, and the addition of semantic extension points to support, for example, operator overloading and non-local code transformations.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3138224", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ted", + "last_name": "Kaminski", + "institution": "University of Minnesota" + }, + { + "first_name": "Lucas", + "last_name": "Kramer", + "institution": "University of Minnesota" + }, + { + "first_name": "Travis", + "last_name": "Carlson", + "institution": "University of Minnesota" + }, + { + "first_name": "Eric Van", + "last_name": "Wyk", + "institution": "University of Minnesota" + } + ], + "dblp_key": "journals/pacmpl/KaminskiKCW17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133921", + "title": "An auditing language for preventing correlated failures in the cloud", + "abstract": "Today's cloud services extensively rely on replication techniques to ensure availability and reliability. In complex datacenter network architectures, however, seemingly independent replica servers may inadvertently share deep dependencies (e.g., aggregation switches). Such unexpected common dependencies may potentially result in correlated failures across the entire replication deployments, invalidating the efforts. Although existing cloud management and diagnosis tools have been able to offer post-failure forensics, they, nevertheless, typically lead to quite prolonged failure recovery time in the cloud-scale systems. In this paper, we propose a novel language framework, named RepAudit, that manages to prevent correlated failure risks before service outages occur, by allowing cloud administrators to proactively audit the replication deployments of interest. In particular, RepAudit consists of three new components: 1) a declarative domain-specific language, RAL, for cloud administrators to write auditing programs expressing diverse auditing tasks; 2) a high-performance RAL auditing engine that generates the auditing results by accurately and efficiently analyzing the underlying structures of the target replication deployments; and 3) an RAL-code generator that can automatically produce complex RAL programs based on easily written specifications. Our evaluation result shows that RepAudit uses 80x less lines of code than state-of-the-art efforts in expressing the auditing task of determining the top-20 critical correlated-failure root causes. To the best of our knowledge, RepAudit is the first effort capable of simultaneously offering expressive, accurate and efficient correlated failure auditing to the cloud-scale replication systems.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133921", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ennan", + "last_name": "Zhai", + "institution": "Yale University" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + }, + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Columbia University" + }, + { + "first_name": "Xun", + "last_name": "Lao", + "institution": "Yale University" + }, + { + "first_name": "Wang", + "last_name": "Xi", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/ZhaiPGLW17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133925", + "title": "Automatically generating features for learning program analysis heuristics for C-like languages", + "abstract": "We present a technique for automatically generating features for data-driven program analyses. Recently data-driven approaches for building a program analysis have been developed, which mine existing codebases and automatically learn heuristics for finding a cost-effective abstraction for a given analysis task. Such approaches reduce the burden of the analysis designers, but they do not remove it completely; they still leave the nontrivial task of designing so called features to the hands of the designers. Our technique aims at automating this feature design process. The idea is to use programs as features after reducing and abstracting them. Our technique goes through selected program-query pairs in codebases, and it reduces and abstracts the program in each pair to a few lines of code, while ensuring that the analysis behaves similarly for the original and the new programs with respect to the query. Each reduced program serves as a boolean feature for program-query pairs. This feature evaluates to true for a given program-query pair when (as a program) it is included in the program part of the pair. We have implemented our approach for three real-world static analyses. The experimental results show that these analyses with automatically-generated features are cost-effective and consistently perform well on a wide range of programs.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133925", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kwonsoo", + "last_name": "Chae", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + }, + { + "first_name": "Kihong", + "last_name": "Heo", + "institution": "Seoul National University" + }, + { + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/ChaeOHY17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133924", + "title": "Data-driven context-sensitivity for points-to analysis", + "abstract": "We present a new data-driven approach to achieve highly cost-effective context-sensitive points-to analysis for Java. While context-sensitivity has greater impact on the analysis precision and performance than any other precision-improving techniques, it is difficult to accurately identify the methods that would benefit the most from context-sensitivity and decide how much context-sensitivity should be used for them. Manually designing such rules is a nontrivial and laborious task that often delivers suboptimal results in practice. To overcome these challenges, we propose an automated and data-driven approach that learns to effectively apply context-sensitivity from codebases. In our approach, points-to analysis is equipped with a parameterized and heuristic rules, in disjunctive form of properties on program elements, that decide when and how much to apply context-sensitivity. We present a greedy algorithm that efficiently learns the parameter of the heuristic rules. We implemented our approach in the Doop framework and evaluated using three types of context-sensitive analyses: conventional object-sensitivity, selective hybrid object-sensitivity, and type-sensitivity. In all cases, experimental results show that our approach significantly outperforms existing techniques.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133924", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sehun", + "last_name": "Jeong", + "institution": "Korea University" + }, + { + "first_name": "Minseok", + "last_name": "Jeon", + "institution": "Korea University" + }, + { + "first_name": "Sungdeok", + "last_name": "Cha", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/JeongJCO17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133926", + "title": "P/Taint: unified points-to and taint analysis", + "abstract": "Static information-flow analysis (especially taint-analysis) is a key technique in software security, computing where sensitive or untrusted data can propagate in a program. Points-to analysis is a fundamental static program analysis, computing what abstract objects a program expression may point to. In this work, we propose a deep unification of information-flow and points-to analysis. We observe that information-flow analysis is not a mere high-level client of points-to information, but it is indeed identical to points-to analysis on artificial abstract objects that represent different information sources. The very same algorithm can compute, simultaneously, two interlinked but separate results (points-to and information-flow values) with changes only to its initial conditions. The benefits of such a unification are manifold. We can use existing points-to analysis implementations, with virtually no modification (only minor additions of extra logic for sanitization) to compute information flow concepts, such as value tainting. The algorithmic enhancements of points-to analysis (e.g., different flavors of context sensitivity) can be applied transparently to information-flow analysis. Heavy engineering work on points-to analysis (e.g., handling of the reflection API for Java) applies to information-flow analysis without extra effort. We demonstrate the benefits in a realistic implementation that leverages the Doop points-to analysis framework (including its context-sensitivity and reflection analysis features) to provide an information-flow analysis with excellent precision (over 91%) and recall (over 99%) for standard Java information-flow benchmarks. The analysis comfortably scales to large, real-world Android applications, analyzing the Facebook Messenger app with more than 55 K classes in under 7 hours.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133926", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/GrechS17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133928", + "title": "Detecting argument selection defects", + "abstract": "Identifier names are often used by developers to convey additional information about the meaning of a program over and above the semantics of the programming language itself. We present an algorithm that uses this information to detect argument selection defects, in which the programmer has chosen the wrong argument to a method call in Java programs. We evaluate our algorithm at Google on 200 million lines of internal code and 10 million lines of predominantly open-source external code and find defects even in large, mature projects such as OpenJDK, ASM, and the MySQL JDBC. The precision and recall of the algorithm vary depending on a sensitivity threshold. Higher thresholds increase precision, giving a true positive rate of 85%, reporting 459 true positives and 78 false positives. Lower thresholds increase recall but lower the true positive rate, reporting 2,060 true positives and 1,207 false positives. We show that this is an order of magnitude improvement on previous approaches. By analyzing the defects found, we are able to quantify best practice advice for API design and show that the probability of an argument selection defect increases markedly when methods have more than five arguments.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133928", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Rice", + "institution": "University of Cambridge" + }, + { + "first_name": "Edward", + "last_name": "Aftandilian", + "institution": "Google (United States)" + }, + { + "first_name": "Ciera", + "last_name": "Jaspan", + "institution": "Google (United States)" + }, + { + "first_name": "Emily", + "last_name": "Johnston", + "institution": "Google (United States)" + }, + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Yulissa", + "last_name": "Arroyo-Paredes", + "institution": "Columbia University" + } + ], + "dblp_key": "journals/pacmpl/RiceAJJPA17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3143359", + "title": "Deadlock avoidance in parallel programs with futures: why parallel tasks should not wait for strangers", + "abstract": "Futures are an elegant approach to expressing parallelism in functional programs. However, combining futures with imperative programming (as in C++ or in Java) can lead to pernicious bugs in the form of data races and deadlocks, as a consequence of uncontrolled data flow through mutable shared memory. In this paper we introduce the Known Joins (KJ) property for parallel programs with futures, and relate it to the Deadlock Freedom (DF) and the Data-Race Freedom (DRF) properties. Our paper offers two key theoretical results: 1) DRF implies KJ, and 2) KJ implies DF. These results show that data-race freedom is sufficient to guarantee deadlock freedom in programs with futures that only manipulate unsynchronized shared variables. To the best of our knowledge, these are the first theoretical results to establish sufficient conditions for deadlock freedom in imperative parallel programs with futures, and to characterize the subset of data races that can trigger deadlocks (those that violate the KJ property). From result 2), we developed a tool that avoids deadlocks in linear time and space when KJ holds, i.e., when there are no data races among references to futures. When KJ fails, the tool reports the data race and optionally falls back to a standard deadlock avoidance algorithm by cycle detection. Our tool verified a dataset of ∼2,300 student’s homework solutions and found one deadlocked program. The performance results obtained from our tool are very encouraging: a maximum slowdown of 1.06× on a 16-core machine, always outperforming deadlock avoidance via cycle-detection. Proofs of the two main results were formalized using the Coq proof assistant.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3143359", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tiago", + "last_name": "Cogumbreiro", + "institution": "Rice University" + }, + { + "first_name": "Rishi", + "last_name": "Surendran", + "institution": "Rice University" + }, + { + "first_name": "Francisco", + "last_name": "Martins", + "institution": "University of Lisbon" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + }, + { + "first_name": "Max", + "last_name": "Grossman", + "institution": "Rice University" + } + ], + "dblp_key": "journals/pacmpl/CogumbreiroSMSV17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133929", + "title": "How type errors were fixed and what students did?", + "abstract": "Providing better supports for debugging type errors has been an active research area in the last three decades. Numerous approaches from different perspectives have been developed. Most approaches work well under certain conditions only, for example, when type errors are caused by single leaves and when type annotations are correct. However, the research community is still unaware of which conditions hold in practice and what the real debugging situations look like. We address this problem with a study of 3 program data sets, which were written in different years, using different compilers, and were of diverse sizes. They include more than 55,000 programs, among which more than 2,700 are ill typed. We investigated all the ill-typed programs, and our results indicate that current error debugging support is far from sufficient in practice since only about 35% of all type errors were caused by single leaves. In addition, type annotations cannot always be trusted in error debuggers since about 30% of the time type errors were caused by wrong type annotations. Our study also provides many insights about the debugging behaviors of students in functional programming, which could be exploited for developing more effective error debuggers.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133929", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Baijun", + "last_name": "Wu", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WuC17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133930", + "title": "Learning user friendly type-error messages", + "abstract": "Type inference is convenient by allowing programmers to elide type annotations, but this comes at the cost of often generating very confusing and opaque type error messages that are of little help to fix type errors. Though there have been many successful attempts at making type error messages better in the past thirty years, many classes of errors are still difficult to fix. In particular, current approaches still generate imprecise and uninformative error messages for type errors arising from errors in grouping constructs like parentheses and brackets. Worse, a recent study shows that these errors usually take more than 10 steps to fix and occur quite frequently (around 45% to 60% of all type errors) in programs written by students learning functional programming. We call this class of errors, nonstructural errors . We solve this problem by developing Learnskell, a type error debugger that uses machine learning to help diagnose and deliver high quality error messages, for programs that contain nonstructural errors. While previous approaches usually report type errors on typing constraints or on the type level, Learnskell generates suggestions on the expression level. We have performed an evaluation on more than 1,500 type errors, and the result shows that Learnskell is quite precise. It can correctly capture 86% of all nonstructural errors and locate the error cause with a precision of 63%/87% with the first 1/3 messages, respectively. This is several times more than the precision of state-of-the-art compilers and debuggers. We have also studied the performance of Learnskell and found out that it scales to large programs.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133930", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Baijun", + "last_name": "Wu", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "John Peter", + "last_name": "Campora", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WuCC17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133931", + "title": "Geo-distribution of actor-based services", + "abstract": "Many service applications use actors as a programming model for the middle tier, to simplify synchronization, fault-tolerance, and scalability. However, efficient operation of such actors in multiple, geographically distant datacenters is challenging, due to the very high communication latency. Caching and replication are essential to hide latency and exploit locality; but it is not a priori clear how to combine these techniques with the actor programming model. We present Geo, an open-source geo-distributed actor system that improves performance by caching actor states in one or more datacenters, yet guarantees the existence of a single latest version by virtue of a distributed cache coherence protocol. Geo's programming model supports both volatile and persistent actors, and supports updates with a choice of linearizable and eventual consistency. Our evaluation on several workloads shows substantial performance benefits, and confirms the advantage of supporting both replicated and single-instance coherence protocols as configuration choices. For example, replication can provide fast, always-available reads and updates globally, while batching of linearizable storage accesses at a single location can boost the throughput of an order processing workload by 7x.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133931", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philip A.", + "last_name": "Bernstein", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sergey", + "last_name": "Bykov", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Natacha", + "last_name": "Crooks", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Jose M.", + "last_name": "Faleiro", + "institution": "Yale University" + }, + { + "first_name": "Gabriel", + "last_name": "Kliot", + "institution": "Google (United States)" + }, + { + "first_name": "Alok", + "last_name": "Kumbhare", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Muntasir Raihan", + "last_name": "Rahman", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vivek", + "last_name": "Shah", + "institution": "University of Copenhagen" + }, + { + "first_name": "Adriana", + "last_name": "Szekeres", + "institution": "University of Washington" + }, + { + "first_name": "Jørgen", + "last_name": "Thelin", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/BernsteinBBCFKK17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133933", + "title": "Verifying strong eventual consistency in distributed systems", + "abstract": "Data replication is used in distributed systems to maintain up-to-date copies of shared data across multiple computers in a network. However, despite decades of research, algorithms for achieving consistency in replicated systems are still poorly understood. Indeed, many published algorithms have later been shown to be incorrect, even some that were accompanied by supposed mechanised proofs of correctness. In this work, we focus on the correctness of Conflict-free Replicated Data Types (CRDTs), a class of algorithm that provides strong eventual consistency guarantees for replicated data. We develop a modular and reusable framework in the Isabelle/HOL interactive proof assistant for verifying the correctness of CRDT algorithms. We avoid correctness issues that have dogged previous mechanised proofs in this area by including a network model in our formalisation, and proving that our theorems hold in all possible network behaviours. Our axiomatic network model is a standard abstraction that accurately reflects the behaviour of real-world computer networks. Moreover, we identify an abstract convergence theorem, a property of order relations, which provides a formal definition of strong eventual consistency. We then obtain the first machine-checked correctness theorems for three concrete CRDTs: the Replicated Growable Array, the Observed-Remove Set, and an Increment-Decrement Counter. We find that our framework is highly reusable, developing proofs of correctness for the latter two CRDTs in a few hours and with relatively little CRDT-specific code.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133933", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Victor B. F.", + "last_name": "Gomes", + "institution": "University of Cambridge" + }, + { + "first_name": "Martin", + "last_name": "Kleppmann", + "institution": "University of Cambridge" + }, + { + "first_name": "Dominic P.", + "last_name": "Mulligan", + "institution": "University of Cambridge" + }, + { + "first_name": "Alastair R.", + "last_name": "Beresford", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/GomesKMB17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3133934", + "title": "Verifying distributed programs via canonical sequentialization", + "abstract": "We introduce canonical sequentialization, a new approach to verifying unbounded, asynchronous, message-passing programs at compile-time. Our approach builds upon the following observation: due the combinatorial explosion in complexity, programmers do not reason about their systems by case-splitting over all the possible execution orders. Instead, correct programs tend to be well-structured so that the programmer can reason about a small number of representative executions, which we call the program’s canonical sequentialization. We have implemented our approach in a tool called Brisk that synthesizes canonical sequentializations for programs written in Haskell, and evaluated it on a wide variety of distributed systems including benchmarks from the literature and implementations of MapReduce, two-phase commit, and a version of the Disco distributed file-system. We show that unlike model checking, which gets prohibitively slow with just 10 processes Brisk verifies the unbounded versions of the benchmarks in tens of milliseconds, yielding the first concurrency verification tool that is fast enough to be integrated into a design-implement-check cycle.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3133934", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Bakst", + "institution": "University of California, San Diego" + }, + { + "first_name": "Klaus von", + "last_name": "Gleissenthall", + "institution": "University of California, San Diego" + }, + { + "first_name": "Rami Gökhan", + "last_name": "Kıcı", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/BakstGKJ17", + "venue": "oopsla", + "year": 2017 + }, + { + "paper_id": "10.1145/3140568", + "title": "Paxos made EPR: decidable reasoning about distributed protocols", + "abstract": "Distributed protocols such as Paxos play an important role in many computer systems. Therefore, a bug in a distributed protocol may have tremendous effects. Accordingly, a lot of effort has been invested in verifying such protocols. However, checking invariants of such protocols is undecidable and hard in practice, as it requires reasoning about an unbounded number of nodes and messages. Moreover, protocol actions and invariants involve both quantifier alternations and higher-order concepts such as set cardinalities and arithmetic. This paper makes a step towards automatic verification of such protocols. We aim at a technique that can verify correct protocols and identify bugs in incorrect protocols. To this end, we develop a methodology for deductive verification based on effectively propositional logic (EPR)—a decidable fragment of first-order logic (also known as the Bernays-Schönfinkel-Ramsey class). In addition to decidability, EPR also enjoys the finite model property, allowing to display violations as finite structures which are intuitive for users. Our methodology involves modeling protocols using general (uninterpreted) first-order logic, and then systematically transforming the model to obtain a model and an inductive invariant that are decidable to check. The steps of the transformations are also mechanically checked, ensuring the soundness of the method. We have used our methodology to verify the safety of Paxos, and several of its variants, including Multi-Paxos, Vertical Paxos, Fast Paxos, Flexible Paxos and Stoppable Paxos. To the best of our knowledge, this work is the first to verify these protocols using a decidable logic, and the first formal verification of Vertical Paxos, Fast Paxos and Stoppable Paxos.", + "date": "2017-10-12", + "link": "https://doi.org/10.1145/3140568", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Tel Aviv University" + }, + { + "first_name": "Giuliano", + "last_name": "Losa", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/PadonLSS17", + "venue": "oopsla", + "year": 2017 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2018.json b/data/pl_conferences/oopsla/2018.json new file mode 100644 index 0000000..aabb63d --- /dev/null +++ b/data/pl_conferences/oopsla/2018.json @@ -0,0 +1,1922 @@ +[ + { + "paper_id": "10.1145/3276477", + "title": "Thread-safe reactive programming", + "abstract": "The execution of an application written in a reactive language involves transfer of data and control flow between imperative and reactive abstractions at well-defined points. In a multi-threaded environment, multiple such interactions may execute concurrently, potentially causing data races and event ordering ambiguities. Existing RP languages either disable multi-threading or handle it at the cost of reducing expressiveness or weakening consistency. This paper proposes a model for thread-safe reactive programming (RP) that ensures abort-free strict serializability under concurrency while sacrificing neither expressiveness nor consistency. We also propose an architecture for integrating a corresponding scheduler into the RP language runtime, such that thread-safety is provided \"out-of-the-box\" to the applications. We show the feasibility of our proposal by providing and evaluating a ready-to-use implementation integrated into the REScala programming language. The scheduling algorithm is formally proven correct. A thorough empirical evaluation shows that reactive applications build on top of it scale with multiple threads, while the scheduler incurs acceptable performance overhead in a single-threaded configuration. The scalability enabled by our scheduler is roughly on-par with that of hand-crafted application-specific locking and better than the scalability enabled by a scheduler using an off-the-shelf software transactional memory library.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276477", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joscha", + "last_name": "Drechsler", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Ragnar", + "last_name": "Mogk", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "journals/pacmpl/DrechslerMSM18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276480", + "title": "goSLP: globally optimized superword level parallelism framework", + "abstract": "Modern microprocessors are equipped with single instruction multiple data (SIMD) or vector instruction sets which allow compilers to exploit superword level parallelism (SLP), a type of fine-grained parallelism. Current SLP auto-vectorization techniques use heuristics to discover vectorization opportunities in high-level language code. These heuristics are fragile, local and typically only present one vectorization strategy that is either accepted or rejected by a cost model. We present goSLP, a novel SLP auto-vectorization framework which solves the statement packing problem in a pairwise optimal manner. Using an integer linear programming (ILP) solver, goSLP searches the entire space of statement packing opportunities for a whole function at a time, while limiting total compilation time to a few minutes. Furthermore, goSLP optimally solves the vector permutation selection problem using dynamic programming. We implemented goSLP in the LLVM compiler infrastructure, achieving a geometric mean speedup of 7.58% on SPEC2017fp, 2.42% on SPEC2006fp and 4.07% on NAS benchmarks compared to LLVM’s existing SLP auto-vectorizer.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276480", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/MendisA18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276483", + "title": "Julia subtyping: a rational reconstruction", + "abstract": "Programming languages that support multiple dispatch rely on an expressive notion of subtyping to specify method applicability. In these languages, type annotations on method declarations are used to select, out of a potentially large set of methods, the one that is most appropriate for a particular tuple of arguments. Julia is a language for scientific computing built around multiple dispatch and an expressive subtyping relation. This paper provides the first formal definition of Julia's subtype relation and motivates its design. We validate our specification empirically with an implementation of our definition that we compare against the existing Julia implementation on a collection of real-world programs. Our subtype implementation differs on 122 subtype tests out of 6,014,476. The first 120 differences are due to a bug in Julia that was fixed once reported; the remaining 2 are under discussion.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276483", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Northeastern University" + }, + { + "first_name": "Julia", + "last_name": "Belyakova", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Artem", + "last_name": "Pelenitsyn", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Benjamin", + "last_name": "Chung", + "institution": "Northeastern University" + }, + { + "first_name": "Jeff", + "last_name": "Bezanson", + "institution": "" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/NardelliBPCBV18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276485", + "title": "A derivation framework for dependent security label inference", + "abstract": "Dependent security labels (security labels that depend on program states) in various forms have been introduced to express rich information flow policies. They are shown to be essential in the verification of real-world software and hardware systems such as conference management systems, Android Apps, a MIPS processor and a TrustZone-like architecture. However, most work assumes that all (complex) labels are provided manually, which can both be error-prone and time-consuming. In this paper, we tackle the problem of automatic label inference for static information flow analyses with dependent security labels. In particular, we propose the first general framework to facilitate the design and validation (in terms of soundness and/or completeness) of inference algorithms. The framework models label inference as constraint solving and offers guidelines for sound and/or complete constraint solving. Under the framework, we propose novel constraint solving algorithms that are both sound and complete. Evaluation result on sets of constraints generated from secure and insecure variants of a MIPS processor suggests that the novel algorithms improve the performance of an existing algorithm by orders of magnitude and offers better scalability.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276485", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peixuan", + "last_name": "Li", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/LiZ18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276482", + "title": "Empowering union and intersection types with integrated subtyping", + "abstract": "Union and intersection types are both simple and powerful but have seen limited adoption. The problem is that, so far, subtyping algorithms for type systems extended with union and intersections have typically been either unreliable or insufficiently expressive. We present a simple and composable framework for empowering union and intersection types so that they interact with the rest of the type system in an intuitive and yet still decidable manner. We demonstrate the utility of this framework by illustrating the impact it has made throughout the design of the Ceylon programming language developed by Red Hat.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276482", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Muehlboeck", + "institution": "Cornell University" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/MuehlboeckT18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276492", + "title": "One tool, many languages: language-parametric transformation with incremental parametric syntax", + "abstract": "We present a new approach for building source-to-source transformations that can run on multiple programming languages, based on a new way of representing programs called incremental parametric syntax. We implement this approach in Haskell in our Cubix system, and construct incremental parametric syntaxes for C, Java, JavaScript, Lua, and Python. We demonstrate a whole-program refactoring tool that runs on all of them, along with three smaller transformations that each run on several. Our evaluation shows that (1) once a transformation is written, little work is required to configure it for a new language (2) transformations built this way output readable code which preserve the structure of the original, according to participants in our human study, and (3) our transformations can still handle language corner-cases, as validated on compiler test suites.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276492", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James", + "last_name": "Koppel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Varot", + "last_name": "Premtoon", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KoppelPS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276491", + "title": "GraphIt: a high-performance graph DSL", + "abstract": "The performance bottlenecks of graph applications depend not only on the algorithm and the underlying hardware, but also on the size and structure of the input graph. As a result, programmers must try different combinations of a large set of techniques, which make tradeoffs among locality, work-efficiency, and parallelism, to develop the best implementation for a specific algorithm and type of graph. Existing graph frameworks and domain specific languages (DSLs) lack flexibility, supporting only a limited set of optimizations. This paper introduces GraphIt, a new DSL for graph computations that generates fast implementations for algorithms with different performance characteristics running on graphs with different sizes and structures. GraphIt separates what is computed (algorithm) from how it is computed (schedule). Programmers specify the algorithm using an algorithm language, and performance optimizations are specified using a separate scheduling language. The algorithm language simplifies expressing the algorithms, while exposing opportunities for optimizations. We formulate graph optimizations, including edge traversal direction, data layout, parallelization, cache, NUMA, and kernel fusion optimizations, as tradeoffs among locality, parallelism, and work-efficiency. The scheduling language enables programmers to easily search through this complicated tradeoff space by composing together a large set of edge traversal, vertex data layout, and program structure optimizations. The separation of algorithm and schedule also enables us to build an autotuner on top of GraphIt to automatically find high-performance schedules. The compiler uses a new scheduling representation, the graph iteration space, to model, compose, and ensure the validity of the large number of optimizations. We evaluate GraphIt’s performance with seven algorithms on graphs with different structures and sizes. GraphIt outperforms the next fastest of six state-of-the-art shared-memory frameworks (Ligra, Green-Marl, GraphMat, Galois, Gemini, and Grazelle) on 24 out of 32 experiments by up to 4.8×, and is never more than 43% slower than the fastest framework on the other experiments. GraphIt also reduces the lines of code by up to an order of magnitude compared to the next fastest framework.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276491", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yunming", + "last_name": "Zhang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Mengjiao", + "last_name": "Yang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Riyadh", + "last_name": "Baghdadi", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Shoaib", + "last_name": "Kamil", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Julian", + "last_name": "Shun", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ZhangYBKSA18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276479", + "title": "Virtual machine design for parallel dynamic programming languages", + "abstract": "To leverage the benefits of modern hardware, dynamic languages must support parallelism, and parallelism requires a virtual machine (VM) capable of parallel execution — a parallel VM. However, unrestricted concurrency and the dynamism of dynamic languages pose great challenges to the implementation of parallel VMs. In a dynamic language, a program changing itself is part of the language model. To help the VM, languages often choose memory models (MM) that weaken consistency guarantees. With lesser guarantees, local program state cannot be affected by every concurrent state change. And less interference allows a VM to make local assumptions about the program state which are not immediately violated. These local assumptions are essential for a VM’s just-in-time compiler for delivering state-of-the-art VM performance. Unfortunately, some dynamic languages employ MMs that give exceedingly strong consistency guarantees and thereby hinder the development of parallel VMs. Such is the case in particular for languages that depend on a global interpreter lock, which mandates a MM with sequential consistency and instruction atomicity. In this paper, we reflect on a first implementation of the Parallel RPython execution model, which facilitates the development of parallel VMs by decoupling language semantics from the synchronization mechanism used within the VM. The implementation addresses the challenges imposed by strong MMs through strict isolation of concurrent computations. This isolation builds on transactional parallel worlds, which are implemented with a novel combination of software techniques and the capabilities of modern hardware. We evaluate a set of parallel Python programs on a parallel VM that relies on Parallel RPython’s implementation. Compared with a serial baseline VM that relies on a global interpreter lock, the parallel VM achieves speedups of up to 7.5× on 8 CPU cores. The evaluation shows that our realization of Parallel RPython meets the challenges of dynamic languages, and that it can serve as a solid foundation for the construction of parallel dynamic language VMs.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276479", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Remigius", + "last_name": "Meier", + "institution": "ETH Zurich" + }, + { + "first_name": "Armin", + "last_name": "Rigo", + "institution": "" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/MeierRG18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276489", + "title": "AnyDSL: a partial evaluation framework for programming high-performance libraries", + "abstract": "This paper advocates programming high-performance code using partial evaluation. We present a clean-slate programming system with a simple, annotation-based, online partial evaluator that operates on a CPS-style intermediate representation. Our system exposes code generation for accelerators (vectorization/parallelization for CPUs and GPUs) via compiler-known higher-order functions that can be subjected to partial evaluation. This way, generic implementations can be instantiated with target-specific code at compile time. In our experimental evaluation we present three extensive case studies from image processing, ray tracing, and genome sequence alignment. We demonstrate that using partial evaluation, we obtain high-performance implementations for CPUs and GPUs from one language and one code base in a generic way. The performance of our codes is mostly within 10%, often closer to the performance of multi man-year, industry-grade, manually-optimized expert codes that are considered to be among the top contenders in their fields.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276489", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roland", + "last_name": "Leißa", + "institution": "Saarland University" + }, + { + "first_name": "Klaas", + "last_name": "Boesche", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + }, + { + "first_name": "Arsène", + "last_name": "Pérard‐Gayot", + "institution": "Saarland University" + }, + { + "first_name": "Richard", + "last_name": "Membarth", + "institution": "Saarland University" + }, + { + "first_name": "Philipp", + "last_name": "Slusallek", + "institution": "Saarland University" + }, + { + "first_name": "André C.", + "last_name": "Müller", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Bertil", + "last_name": "Schmidt", + "institution": "Johannes Gutenberg University Mainz" + } + ], + "dblp_key": "journals/pacmpl/LeissaBHPMSMS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276481", + "title": "Effect handlers for the masses", + "abstract": "Effect handlers are a program structuring paradigm with rising popularity in the functional programming language community and can express many advanced control flow abstractions. We present the first implementation of effect handlers for Java - an imperative, object oriented programming language. Our framework consists of three core components: A type selective CPS transformation via JVM bytecode transformation, an implementation of delimited continuations on top of the bytecode transformation and finally a library for effect handlers in terms of delimited continuations.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276481", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/BrachthauserSO18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276478", + "title": "Parallelization of dynamic languages: synchronizing built-in collections", + "abstract": "Dynamic programming languages such as Python and Ruby are widely used, and much effort is spent on making them efficient. One substantial research effort in this direction is the enabling of parallel code execution. While there has been significant progress, making dynamic collections efficient, scalable, and thread-safe is an open issue. Typical programs in dynamic languages use few but versatile collection types. Such collections are an important ingredient of dynamic environments, but are difficult to make safe, efficient, and scalable. In this paper, we propose an approach for efficient and concurrent collections by gradually increasing synchronization levels according to the dynamic needs of each collection instance. Collections reachable only by a single thread have no synchronization, arrays accessed in bounds have minimal synchronization, and for the general case, we adopt the Layout Lock paradigm and extend its design with a lightweight version that fits the setting of dynamic languages. We apply our approach to Ruby's Array and Hash collections. Our experiments show that our approach has no overhead on single-threaded benchmarks, scales linearly for Array and Hash accesses, achieves the same scalability as Fortran and Java for classic parallel algorithms, and scales better than other Ruby implementations on Ruby workloads.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276478", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benoit", + "last_name": "Daloze", + "institution": "" + }, + { + "first_name": "Arie", + "last_name": "Tal", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Stefan", + "last_name": "Marr", + "institution": "University of Kent" + }, + { + "first_name": "Hanspeter", + "last_name": "Mössenböck", + "institution": "" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/DalozeTMMP18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276488", + "title": "Secure serverless computing using dynamic information flow control", + "abstract": "The rise of serverless computing provides an opportunity to rethink cloud security. We present an approach for securing serverless systems using a novel form of dynamic information flow control (IFC). We show that in serverless applications, the termination channel found in most existing IFC systems can be arbitrarily amplified via multiple concurrent requests, necessitating a stronger termination-sensitive non-interference guarantee, which we achieve using a combination of static labeling of serverless processes and dynamic faceted labeling of persistent data. We describe our implementation of this approach on top of JavaScript for AWS Lambda and OpenWhisk serverless platforms, and present three realistic case studies showing that it can enforce important IFC security properties with modest overhead.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276488", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kalev", + "last_name": "Alpernas", + "institution": "Tel Aviv University" + }, + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Sadjad", + "last_name": "Fouladi", + "institution": "Stanford University" + }, + { + "first_name": "Leonid", + "last_name": "Ryzhyk", + "institution": "Kitware (United States)" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Thomas", + "last_name": "Schmitz", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Keith", + "last_name": "Winstein", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/AlpernasFFRSSW18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276486", + "title": "MadMax: surviving out-of-gas conditions in Ethereum smart contracts", + "abstract": "Ethereum is a distributed blockchain platform, serving as an ecosystem for smart contracts: full-fledged inter-communicating programs that capture the transaction logic of an account. Unlike programs in mainstream languages, a gas limit restricts the execution of an Ethereum smart contract: execution proceeds as long as gas is available. Thus, gas is a valuable resource that can be manipulated by an attacker to provoke unwanted behavior in a victim's smart contract (e.g., wasting or blocking funds of said victim). Gas-focused vulnerabilities exploit undesired behavior when a contract (directly or through other interacting contracts) runs out of gas. Such vulnerabilities are among the hardest for programmers to protect against, as out-of-gas behavior may be uncommon in non-attack scenarios and reasoning about it is far from trivial. In this paper, we classify and identify gas-focused vulnerabilities, and present MadMax: a static program analysis technique to automatically detect gas-focused vulnerabilities with very high confidence. Our approach combines a control-flow-analysis-based decompiler and declarative program-structure queries. The combined analysis captures high-level domain-specific concepts (such as \"dynamic data structure storage\" and \"safely resumable loops\") and achieves high precision and scalability. MadMax analyzes the entirety of smart contracts in the Ethereum blockchain in just 10 hours (with decompilation timeouts in 8% of the cases) and flags contracts with a (highly volatile) monetary value of over $2.8B as vulnerable. Manual inspection of a sample of flagged contracts shows that 81% of the sampled warnings do indeed lead to vulnerabilities, which we report on in our experiment.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276486", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "University of Malta" + }, + { + "first_name": "Michael", + "last_name": "Kong", + "institution": "University of Sydney" + }, + { + "first_name": "Anton", + "last_name": "Jurisevic", + "institution": "University of Sydney" + }, + { + "first_name": "Lexi", + "last_name": "Brent", + "institution": "University of Sydney" + }, + { + "first_name": "Bernhard", + "last_name": "Scholz", + "institution": "University of Sydney" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/GrechKJBSS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276487", + "title": "Faster variational execution with transparent bytecode transformation", + "abstract": "Variational execution is a novel dynamic analysis technique for exploring highly configurable systems and accurately tracking information flow. It is able to efficiently analyze many configurations by aggressively sharing redundancies of program executions. The idea of variational execution has been demonstrated to be effective in exploring variations in the program, especially when the configuration space grows out of control. Existing implementations of variational execution often require heavy lifting of the runtime interpreter, which is painstaking and error-prone. Furthermore, the performance of this approach is suboptimal. For example, the state-of-the-art variational execution interpreter for Java, VarexJ, slows down executions by 100 to 800 times over a single execution for small to medium size Java programs. Instead of modifying existing JVMs, we propose to transform existing bytecode to make it variational, so it can be executed on an unmodified commodity JVM. Our evaluation shows a dramatic improvement on performance over the state-of-the-art, with a speedup of 2 to 46 times, and high efficiency in sharing computations.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276487", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chu-Pan", + "last_name": "Wong", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jens", + "last_name": "Meinicke", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Lukas", + "last_name": "Lazarek", + "institution": "Northwestern University" + }, + { + "first_name": "Christian", + "last_name": "Kästner", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/WongMLK18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276490", + "title": "Julia: dynamism and performance reconciled by design", + "abstract": "Julia is a programming language for the scientific community that combines features of productivity languages, such as Python or MATLAB, with characteristics of performance-oriented languages, such as C++ or Fortran. Julia's productivity features include: dynamic typing, automatic memory management, rich type annotations, and multiple dispatch. At the same time, Julia allows programmers to control memory layout and leverages a specializing just-in-time compiler to eliminate much of the overhead of those features. This paper details the design choices made by the creators of Julia and reflects on the implications of those choices for performance and usability.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276490", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Bezanson", + "institution": "" + }, + { + "first_name": "Jiahao", + "last_name": "Chen", + "institution": "Capital One (United States)" + }, + { + "first_name": "Benjamin", + "last_name": "Chung", + "institution": "Northeastern University" + }, + { + "first_name": "Stefan", + "last_name": "Karpinski", + "institution": "" + }, + { + "first_name": "Viral B.", + "last_name": "Shah", + "institution": "" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + }, + { + "first_name": "Lionel", + "last_name": "Zoubritzky", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/BezansonCCKSVZ18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276493", + "title": "Format abstraction for sparse tensor algebra compilers", + "abstract": "This paper shows how to build a sparse tensor algebra compiler that is agnostic to tensor formats (data layouts). We develop an interface that describes formats in terms of their capabilities and properties, and show how to build a modular code generator where new formats can be added as plugins. We then describe six implementations of the interface that compose to form the dense, CSR/CSF, COO, DIA, ELL, and HASH tensor formats and countless variants thereof. With these implementations at hand, our code generator can generate code to compute any tensor algebra expression on any combination of the aforementioned formats. To demonstrate our technique, we have implemented it in the taco tensor algebra compiler. Our modular code generator design makes it simple to add support for new tensor formats, and the performance of the generated code is competitive with hand-optimized implementations. Furthermore, by extending taco to support a wider range of formats specialized for different application and data characteristics, we can improve end-user application performance. For example, if input data is provided in the COO format, our technique allows computing a single matrix-vector multiplication directly with the data in COO, which is up to 3.6× faster than by first converting the data to CSR.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276493", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen Y.", + "last_name": "Chou", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ChouKA18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276494", + "title": "ShareJIT: JIT code cache sharing across processes and its practical implementation", + "abstract": "Just-in-time (JIT) compilation coupled with code caching are widely used to improve performance in dynamic programming language implementations. These code caches, along with the associated profiling data for the hot code, however, consume significant amounts of memory. Furthermore, they incur extra JIT compilation time for their creation. On Android, the current standard JIT compiler and its code caches are not shared among processes—that is, the runtime system maintains a private code cache, and its associated data, for each runtime process. However, applications running on the same platform tend to share multiple libraries in common. Sharing cached code across multiple applications and multiple processes can lead to a reduction in memory use. It can directly reduce compile time. It can also reduce the cumulative amount of time spent interpreting code. All three of these effects can improve actual runtime performance. In this paper, we describe ShareJIT, a global code cache for JITs that can share code across multiple applications and multiple processes. We implemented ShareJIT in the context of the Android Runtime (ART), a widely used, state-of-the-art system. To increase sharing, our implementation constrains the amount of context that the JIT compiler can use to optimize the code. This exposes a fundamental tradeoff: increased specialization to a single process’ context decreases the extent to which the compiled code can be shared. In ShareJIT, we limit some optimization to increase shareability. To evaluate the ShareJIT, we tested 8 popular Android apps in a total of 30 experiments. ShareJIT improved overall performance by 9% on average, while decreasing memory consumption by 16% on average and JIT compilation time by 37% on average.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276494", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xiaoran", + "last_name": "Xu", + "institution": "Rice University" + }, + { + "first_name": "Keith D.", + "last_name": "Cooper", + "institution": "Rice University" + }, + { + "first_name": "Jacob", + "last_name": "Brock", + "institution": "University of Rochester" + }, + { + "first_name": "Yan", + "last_name": "Zhang", + "institution": "" + }, + { + "first_name": "Handong", + "last_name": "Ye", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/XuCBZY18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276484", + "title": "Scopes as types", + "abstract": "Scope graphs are a promising generic framework to model the binding structures of programming languages, bridging formalization and implementation, supporting the definition of type checkers and the automation of type safety proofs. However, previous work on scope graphs has been limited to simple, nominal type systems. In this paper, we show that viewing scopes as types enables us to model the internal structure of types in a range of non-simple type systems (including structural records and generic classes) using the generic representation of scopes. Further, we show that relations between such types can be expressed in terms of generalized scope graph queries. We extend scope graphs with scoped relations and queries. We introduce Statix, a new domain-specific meta-language for the specification of static semantics, based on scope graphs and constraints. We evaluate the scopes as types approach and the Statix design in case studies of the simply-typed lambda calculus with records, System F, and Featherweight Generic Java.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276484", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hendrik van", + "last_name": "Antwerpen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Arjen", + "last_name": "Rouvoet", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/AntwerpenPRV18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276497", + "title": "Bidirectional evaluation with direct manipulation", + "abstract": "We present an evaluation update (or simply, update) algorithm for a full-featured functional programming language, which synthesizes program changes based on output changes. Intuitively, the update algorithm retraces the steps of the original evaluation, rewriting the program as needed to reconcile differences between the original and updated output values. Our approach, furthermore, allows expert users to define custom lenses that augment the update algorithm with more advanced or domain-specific program updates. To demonstrate the utility of evaluation update, we implement the algorithm in Sketch-n-Sketch, a novel direct manipulation programming system for generating HTML documents. In Sketch-n-Sketch, the user writes an ML-style functional program to generate HTML output. When the user directly manipulates the output using a graphical user interface, the update algorithm reconciles the changes. We evaluate bidirectional evaluation in Sketch-n-Sketch by authoring ten examples comprising approximately 1400 lines of code in total. These examples demonstrate how a variety of HTML documents and applications can be developed and edited interactively in Sketch-n-Sketch, mitigating the tedious edit-run-view cycle in traditional programming environments.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276497", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mikaël", + "last_name": "Mayer", + "institution": "University of Chicago" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of Chicago" + } + ], + "dblp_key": "journals/pacmpl/MayerKC18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276495", + "title": "Reconciling high-level optimizations and low-level code in LLVM", + "abstract": "LLVM miscompiles certain programs in C, C++, and Rust that use low-level language features such as raw pointers in Rust or conversion between integers and pointers in C or C++. The problem is that it is difficult for the compiler to implement aggressive, high-level memory optimizations while also respecting the guarantees made by the programming languages to low-level programs. A deeper problem is that the memory model for LLVM's intermediate representation (IR) is informal and the semantics of corner cases are not always clear to all compiler developers. We developed a novel memory model for LLVM IR and formalized it. The new model requires a handful of problematic IR-level optimizations to be removed, but it also supports the addition of new optimizations that were not previously legal. We have implemented the new model and shown that it fixes known memory-model-related miscompilations without impacting the quality of generated code.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276495", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Juneyoung", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Zhengyang", + "last_name": "Liu", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + }, + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/LeeHJLRL18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276498", + "title": "BioScript: programming safe chemistry on laboratories-on-a-chip", + "abstract": "This paper introduces BioScript, a domain-specific language (DSL) for programmable biochemistry which executes on emerging microfluidic platforms. The goal of this research is to provide a simple, intuitive, and type-safe DSL that is accessible to life science practitioners. The novel feature of the language is its syntax, which aims to optimize human readability; the technical contributions of the paper include the BioScript type system and relevant portions of its compiler. The type system ensures that certain types of errors, specific to biochemistry, do not occur, including the interaction of chemicals that may be unsafe. The compiler includes novel optimizations that place biochemical operations to execute concurrently on a spatial 2D array platform on the granularity of a control flow graph, as opposed to individual basic blocks. Results are obtained using both a cycle-accurate microfluidic simulator and a software interface to a real-world platform.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276498", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jason", + "last_name": "Ott", + "institution": "University of California, Riverside" + }, + { + "first_name": "Tyson", + "last_name": "Loveless", + "institution": "University of California, Riverside" + }, + { + "first_name": "Chris", + "last_name": "Curtis", + "institution": "University of California, Riverside" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Riverside" + }, + { + "first_name": "Philip", + "last_name": "Brisk", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "journals/pacmpl/OttLCLB18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276496", + "title": "An empirical study of the effect of source-level loop transformations on compiler stability", + "abstract": "Modern compiler optimization is a complex process that offers no guarantees to deliver the fastest, most efficient target code. For this reason, compilers struggle to produce a stable performance from versions of code that carry out the same computation and only differ in the order of operations. This instability makes compilers much less effective program optimization tools and often forces programmers to carry out a brute force search when tuning for performance. In this paper, we analyze the stability of the compilation process and the performance headroom of three widely used general purpose compilers: GCC, ICC, and Clang. For the study, we extracted over 1,000 <pre>for</pre> loop nests from well-known benchmarks, libraries, and real applications; then, we applied sequences of source-level loop transformations to these loop nests to create numerous semantically equivalent mutations ; finally, we analyzed the impact of transformations on code quality in terms of locality, dynamic instruction count, and vectorization. Our results show that, by applying source-to-source transformations and searching for the best vectorization setting, the percentage of loops sped up by at least 1.15x is 46.7% for GCC, 35.7% for ICC, and 46.5% for Clang, and on average the potential for performance improvement is estimated to be at least 23.7% for GCC, 18.1% for ICC, and 26.4% for Clang. Our stability analysis shows that, under our experimental setup, the average coefficient of variation of the execution time across all mutations is 18.2% for GCC, 19.5% for ICC, and 16.9% for Clang, and the highest coefficient of variation for a single loop nest reaches 118.9% for GCC, 124.3% for ICC, and 110.5% for Clang. We conclude that the evaluated compilers need further improvements to claim they have stable behavior.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276496", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhangxiaowen", + "last_name": "Gong", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Zhi", + "last_name": "Chen", + "institution": "University of California, Irvine" + }, + { + "first_name": "Justin", + "last_name": "Szaday", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Wong", + "institution": "Intel (United States)" + }, + { + "first_name": "Zehra", + "last_name": "Sura", + "institution": "IBM (United States)" + }, + { + "first_name": "Neftali", + "last_name": "Watkinson", + "institution": "University of California, Irvine" + }, + { + "first_name": "Saeed", + "last_name": "Maleki", + "institution": "Microsoft (United States)" + }, + { + "first_name": "David", + "last_name": "Padua", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Alexander V.", + "last_name": "Veidenbaum", + "institution": "University of California, Irvine" + }, + { + "first_name": "Alexandru", + "last_name": "Nicolau", + "institution": "University of California, Irvine" + }, + { + "first_name": "Josep", + "last_name": "Torrellas", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/GongCS0SWMPVNT18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276499", + "title": "Distributed system development with ScalaLoci", + "abstract": "Distributed applications are traditionally developed as separate modules, often in different languages, which react to events, like user input, and in turn produce new events for the other modules. Separation into components requires time-consuming integration. Manual implementation of communication forces programmers to deal with low-level details. The combination of the two results in obscure distributed data flows scattered among multiple modules, hindering reasoning about the system as a whole. The ScalaLoci distributed programming language addresses these issues with a coherent model based on placement types that enables reasoning about distributed data flows, supporting multiple software architectures via dedicated language features and abstracting over low-level communication details and data conversions. As we show, ScalaLoci simplifies developing distributed systems, reduces error-prone communication code and favors early detection of bugs.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276499", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mirko", + "last_name": "Köhler", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "journals/pacmpl/WeisenburgerKS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276504", + "title": "The root cause of blame: contracts for intersection and union types", + "abstract": "Gradual typing has emerged as the tonic for programmers with a thirst for a blend of static and dynamic typing. Contracts provide a lightweight form of gradual typing as they can be implemented as a library, rather than requiring a gradual type system. Intersection and union types are well suited to static and dynamic languages: intersection encodes overloaded functions; union encodes uncertain data arising from branching code. We extend the untyped lambda calculus with contracts for monitoring higher-order intersection and union types, for the first time giving a uniform treatment to both. Each operator requires a single reduction rule that does not depend on the constituent types or the context of the operator. We present a new method for defining contract satisfaction based on blame behaviour. A value positively satisfies a type if applying a contract of that type can never elicit positive blame. A continuation negatively satisfies a type if applying a contract of that type can never elicit negative blame. We supplement our definition of satisfaction with a series of monitoring properties that satisfying values and continuations should have.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276504", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jack M.", + "last_name": "Williams", + "institution": "University of Edinburgh" + }, + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Kansas" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/WilliamsMW18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276502", + "title": "Gradual liquid type inference", + "abstract": "Refinement types allow for lightweight program verification by enriching types with logical predicates. Liquid typing provides a decidable refinement inference mechanism that is convenient but subject to two major issues: (1) inference is global and requires top-level annotations, making it unsuitable for inference of modular code components and prohibiting its applicability to library code, and (2) inference failure results in obscure error messages. These difficulties seriously hamper the migration of existing code to use refinements. This paper shows that gradual liquid type inference –a novel combination of liquid inference and gradual refinement types–addresses both issues. Gradual refinement types, which support imprecise predicates that are optimistically interpreted, can be used in argument positions to constrain liquid inference so that the global inference process effectively infers modular specifications usable for library components. Dually, when gradual refinements appear as the result of inference, they signal an inconsistency in the use of static refinements. Because liquid refinements are drawn from a finite set of predicates, in gradual liquid type inference we can enumerate the textitsafe concretizations of each imprecise refinement, i.e., the static refinements that justify why a program is gradually well-typed. This enumeration is useful for static liquid type error explanation, since the safe concretizations exhibit all the potential inconsistencies that lead to static type errors. We develop the theory of gradual liquid type inference and explore its pragmatics in the setting of Liquid Haskell. To demonstrate the utility of our approach, we develop an interactive tool, GuiLT, for gradual liquid type inference in Liquid Haskell that both infers modular types and explores safe concretizations of gradual refinements. We report on the use of GuiLT for error reporting and discuss a case study on the migration of three commonly-used Haskell list manipulation libraries into Liquid Haskell.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276502", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/VazouTH18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276505", + "title": "Optimal stateless model checking under the release-acquire semantics", + "abstract": "We present a framework for the efficient application of stateless model checking (SMC) to concurrent programs running under the Release-Acquire (RA) fragment of the C/C++11 memory model. Our approach is based on exploring the possible program orders, which define the order in which instructions of a thread are executed, and read-from relations, which specify how reads obtain their values from writes. This is in contrast to previous approaches, which also explore the possible coherence orders, i.e., orderings between conflicting writes. Since unexpected test results such as program crashes or assertion violations depend only on the read-from relation, we avoid a potentially significant source of redundancy. Our framework is based on a novel technique for determining whether a particular read-from relation is feasible under the RA semantics. We define an SMC algorithm which is provably optimal in the sense that it explores each program order and read-from relation exactly once. This optimality result is strictly stronger than previous analogous optimality results, which also take coherence order into account. We have implemented our framework in the tool Tracer. Experiments show that Tracer can be significantly faster than state-of-the-art tools that can handle the RA semantics.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276505", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Bengt", + "last_name": "Jönsson", + "institution": "Uppsala University" + }, + { + "first_name": "Tuan Phong", + "last_name": "Ngo", + "institution": "Uppsala University" + } + ], + "dblp_key": "journals/pacmpl/AbdullaAJN18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276503", + "title": "Collapsible contracts: fixing a pathology of gradual typing", + "abstract": "The promise of gradual typing is that programmers should get the best of both worlds: the static guarantees of static types, and the dynamic flexibility of untyped programming. This is an enticing benefit, but one that, in practice, may carry significant costs. Significant enough, in fact, to threaten the very practicality of gradual typing; slowdowns as high as 120x are reported as arising from gradual typing. If one examines these results closely, though, it becomes clear that the costs of gradual typing are not evenly distributed. Indeed, while mixing typed and untyped code almost invariably carries non-trivial costs, many truly deal-breaking slowdowns exhibit pathological performance. Unfortunately, the very presence of these pathological cases---and therefore the possibility of hitting them during development---makes gradual typing a risky proposition in any setting that even remotely cares about performance. This work attacks one source of large overheads in these pathological cases: an accumulation of contract wrappers that perform redundant checks. The work introduces a novel strategy for contract checking---collapsible contracts---which eliminates this redundancy for function and vector contracts and drastically reduces the overhead of contract wrappers. We implemented this checking strategy as part of the Racket contract system, which is used in the Typed Racket gradual typing system. Our experiments show that our strategy successfully brings a class of pathological cases in line with normal cases, while not introducing an undue overhead to any of the other cases. Our results also show that the performance of gradual typing in Racket remains prohibitive for many programs, but that collapsible contracts are one essential ingredient in reducing the cost of gradual typing.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276503", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Feltey", + "institution": "Northwestern University" + }, + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Northeastern University" + }, + { + "first_name": "Christophe", + "last_name": "Scholliers", + "institution": "Ghent University Hospital" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Vincent", + "last_name": "St-Amour", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/FelteyGSFS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276501", + "title": "Horn-ICE learning for synthesizing invariants and contracts", + "abstract": "We design learning algorithms for synthesizing invariants using Horn implication counterexamples (Horn-ICE), extending the ICE-learning model. In particular, we describe a decision-tree learning algorithm that learns from nonlinear Horn-ICE samples, works in polynomial time, and uses statistical heuristics to learn small trees that satisfy the samples. Since most verification proofs can be modeled using nonlinear Horn clauses, Horn-ICE learning is a more robust technique to learn inductive annotations that prove programs correct. Our experiments show that an implementation of our algorithm is able to learn adequate inductive invariants and contracts efficiently for a variety of sequential and concurrent programs.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276501", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "P.", + "last_name": "Ezudheen", + "institution": "" + }, + { + "first_name": "Daniel", + "last_name": "Neider", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "D'Souza", + "institution": "" + }, + { + "first_name": "Pranav", + "last_name": "Garg", + "institution": "" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/EzudheenND0M18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276500", + "title": "Concurrency-aware object-oriented programming with roles", + "abstract": "Object-oriented Programming has been effective in reducing code complexity in sequential programs, but in current practice, concurrent programs still present a number of challenges. We present here a model of object-oriented programming that identifies concurrent tasks and the relationship between objects and tasks , effectively making objects concurrency-aware . This awareness is formalized in a parallel programming model where every object plays a role in every task (e.g., the readonly role). When an object is shared with a new task, it adapts to the new sharing pattern by changing its roles, and therefore its behavior, i.e., the operations that can be performed with this object. This mechanism can be leveraged to prevent interfering accesses from concurrently executing tasks, and therefore makes parallel execution deterministic. To this end, we present a role-based programming language that includes several novel concepts (role transitions, guarding, slicing) to enable practical, object-oriented deterministic parallel programming. We show that this language can be used to safely implement programs with a range of different parallel patterns. The implementations to 8 widely used programming problems achieve substantial parallel speedups and demonstrate that this approach delivers performance roughly on par with manually synchronized implementations.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276500", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Faes", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas R.", + "last_name": "Gross", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/FaesG18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276507", + "title": "Persistence semantics for weak memory: integrating epoch persistency with the TSO memory model", + "abstract": "Emerging non-volatile memory (NVM) technologies promise the durability of disks with the performance of volatile memory (RAM). To describe the persistency guarantees of NVM, several memory persistency models have been proposed in the literature. However, the formal semantics of such persistency models in the context of existing mainstream hardware has been unexplored to date. To close this gap, we integrate the buffered epoch persistency model with the 'total-store-order' (TSO) memory model of the x86 and SPARC architectures. We thus develop the PTSO ('persistent' TSO) model and formalise its semantics both operationally and declaratively. We demonstrate that the two characterisations of PTSO are equivalent. We then formulate the notion of persistent linearisability to establish the correctness of library implementations in the context of persistent memory. To showcase our formalism, we develop two persistent implementations of a queue library, and apply persistent linearisability to show their correctness.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276507", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RaadV18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276506", + "title": "Towards understanding the costs of avoiding out-of-thin-air results", + "abstract": "Eliminating so-called “out-of-thin-air” (OOTA) results is an open problem with many existing programming language memory models including Java, C, and C++. OOTA behaviors are problematic in that they break both formal and informal modular reasoning about program behavior. Defining memory model semantics that are easily understood, allow existing optimizations, and forbid OOTA results remains an open problem. This paper explores two simple solutions to this problem that forbid OOTA results. One solution is targeted towards C/C++-like memory models in which racing operations are explicitly labeled as atomic operations and a second solution is targeted towards Java-like languages in which all memory operations may create OOTA executions. Our solutions provide a per-candidate execution criterion that makes it possible to examine a single execution and determine whether the memory model permits the execution. We implemented and evaluated both solutions in the LLVM compiler framework. Our results show that on an ARMv8 processor the first solution has no overhead on average and a maximum overhead of 6.3% on 43 concurrent data structures, and that the second solution has an average overhead of 3.1% and a maximum overhead of 17.6% on the SPEC CPU2006 C/C++ benchmarks.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276506", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peizhao", + "last_name": "Ou", + "institution": "University of California, Irvine" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "journals/pacmpl/OuD18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276508", + "title": "Identifying refactoring opportunities for replacing type code with subclass and state", + "abstract": "Refactoring is a program transformation that restructures existing code without altering its behaviour and is a key practice in popular software design movements, such as Agile. Identification of potential refactoring opportunities is an important step in the refactoring process. In large systems, manual identification of useful refactoring opportunities requires a lot of effort and time. Hence, there is a need for automatic identification of refactoring opportunities. However, this problem has not been addressed well for many non-trivial refactorings. Two such non-trivial, yet popular refactorings are “Replace Type Code with Subclass” (SC) and “Replace Type Code with State” (ST) refactorings. In this paper, we present new approaches to identify SC and ST refactoring opportunities. Our proposed approach is based around the notion of control-fields . A control-field is a field of a class that exposes the different underlying behaviors of the class. Each control-field can lead to a possible SC/ST refactoring of the associated/interacting classes. We first present a formal definition of control-fields and then present algorithms to identify and prune them; each of these pruned control-fields represents a refactoring opportunity. Further, we present a novel flow- and context-sensitive analysis to classify each of these refactoring opportunities into one of the SC and ST opportunities. We have implemented our proposed approach in a tool called Auto-SCST, and demonstrated its effectiveness by evaluating it against eight open-source Java applications.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276508", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jyothi", + "last_name": "Vedurada", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "journals/pacmpl/VeduradaN18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276509", + "title": "Incrementalizing lattice-based program analyses in Datalog", + "abstract": "Program analyses detect errors in code, but when code changes frequently as in an IDE, repeated re-analysis from-scratch is unnecessary: It leads to poor performance unless we give up on precision and recall. Incremental program analysis promises to deliver fast feedback without giving up on precision or recall by deriving a new analysis result from the previous one. However, Datalog and other existing frameworks for incremental program analysis are limited in expressive power: They only support the powerset lattice as representation of analysis results, whereas many practically relevant analyses require custom lattices and aggregation over lattice values. To this end, we present a novel algorithm called DRedL that supports incremental maintenance of recursive lattice-value aggregation in Datalog. The key insight of DRedL is to dynamically recognize increasing replacements of old lattice values by new ones, which allows us to avoid the expensive deletion of the old value. We integrate DRedL into the analysis framework IncA and use IncA to realize incremental implementations of strong-update points-to analysis and string analysis for Java. As our performance evaluation demonstrates, both analyses react to code changes within milliseconds.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276509", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tamás", + "last_name": "Szabó", + "institution": "Delft University of Technology" + }, + { + "first_name": "Gábor", + "last_name": "Bergmann", + "institution": "Budapest University of Technology and Economics" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Delft University of Technology" + }, + { + "first_name": "Markus", + "last_name": "Voelter", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/SzaboBEV18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276520", + "title": "FlashProfile: a framework for synthesizing data profiles", + "abstract": "We address the problem of learning a syntactic profile for a collection of strings, i.e. a set of regex-like patterns that succinctly describe the syntactic variations in the strings. Real-world datasets, typically curated from multiple sources, often contain data in various syntactic formats. Thus, any data processing task is preceded by the critical step of data format identification. However, manual inspection of data to identify the different formats is infeasible in standard big-data scenarios. Prior techniques are restricted to a small set of pre-defined patterns (e.g. digits, letters, words etc.), and provide no control over granularity of profiles. We define syntactic profiling as a problem of clustering strings based on syntactic similarity, followed by identifying patterns that succinctly describe each cluster. We present a technique for synthesizing such profiles over a given language of patterns, that also allows for interactive refinement by requesting a desired number of clusters. Using a state-of-the-art inductive synthesis framework, PROSE, we have implemented our technique as FlashProfile. Across 153 tasks over 75 large real datasets, we observe a median profiling time of only ∼ 0.7s. Furthermore, we show that access to syntactic profiles may allow for more accurate synthesis of programs, i.e. using fewer examples, in programming-by-example (PBE) workflows such as Flash Fill.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276520", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Saswat", + "last_name": "Padhi", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Prateek", + "last_name": "Jain", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Daniel", + "last_name": "Perelman", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Oleksandr", + "last_name": "Polozov", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/PadhiJPPGM18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276513", + "title": "Every data structure deserves lock-free memory reclamation", + "abstract": "Memory-management support for lock-free data structures is well known to be a tough problem. Recent work has successfully reduced the overhead of such schemes. However, applying memory-management support to a data structure remains complex and, in many cases, requires redesigning the data structure. In this paper, we present the first lock-free memory-management scheme that is applicable to general (arbitrary) lock-free data structures and that can be applied automatically via a compiler plug-in. In addition to the simplicity of incorporating to data structures, this scheme provides low overhead and does not rely on the lock freedom of any OS services.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276513", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nachshon", + "last_name": "Cohen", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/Cohen18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276511", + "title": "Precision-guided context sensitivity for pointer analysis", + "abstract": "Context sensitivity is an essential technique for ensuring high precision in Java pointer analyses. It has been observed that applying context sensitivity partially, only on a select subset of the methods, can improve the balance between analysis precision and speed. However, existing techniques are based on heuristics that do not provide much insight into what characterizes this method subset. In this work, we present a more principled approach for identifying precision-critical methods, based on general patterns of value flows that explain where most of the imprecision arises in context-insensitive pointer analysis. Accordingly, we provide an efficient algorithm to recognize these flow patterns in a given program and exploit them to yield good tradeoffs between analysis precision and speed. Our experimental results on standard benchmark and real-world programs show that a pointer analysis that applies context sensitivity partially, only on the identified precision-critical methods, preserves effectively all (98.8%) of the precision of a highly-precise conventional context-sensitive pointer analysis (2-object-sensitive with a context-sensitive heap), with a substantial speedup (on average 3.4X, and up to 9.2X).", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276511", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Aarhus University" + }, + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/LiTMS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276519", + "title": "Finding code that explodes under symbolic evaluation", + "abstract": "Solver-aided tools rely on symbolic evaluation to reduce programming tasks, such as verification and synthesis, to satisfiability queries. Many reusable symbolic evaluation engines are now available as part of solver-aided languages and frameworks, which have made it possible for a broad population of programmers to create and apply solver-aided tools to new domains. But to achieve results for real-world problems, programmers still need to write code that makes effective use of the underlying engine, and understand where their code needs careful design to elicit the best performance. This task is made difficult by the all-paths execution model of symbolic evaluators, which defies both human intuition and standard profiling techniques. This paper presents symbolic profiling, a new approach to identifying and diagnosing performance bottlenecks in programs under symbolic evaluation. To help with diagnosis, we develop a catalog of common performance anti-patterns in solver-aided code. To locate these bottlenecks, we develop SymPro, a new profiling technique for symbolic evaluation. SymPro identifies bottlenecks by analyzing two implicit resources at the core of every symbolic evaluation engine: the symbolic heap and symbolic evaluation graph. These resources form a novel performance model of symbolic evaluation that is general (encompassing all forms of symbolic evaluation), explainable (providing programmers with a conceptual framework for understanding symbolic evaluation), and actionable (enabling precise localization of bottlenecks). Performant solver-aided code carefully manages the shape of these implicit structures; SymPro makes their evolution explicit to the programmer. To evaluate SymPro, we implement profilers for the Rosette solver-aided language and the Jalangi program analysis framework. Applying SymPro to 15 published solver-aided tools, we discover 8 previously undiagnosed performance issues. Repairing these issues improves performance by orders of magnitude, and our patches were accepted by the tools' developers. We also conduct a small user study with Rosette programmers, finding that SymPro helps them both understand what the symbolic evaluator is doing and identify performance issues they could not otherwise locate.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276519", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "James", + "last_name": "Bornholt", + "institution": "University of Washington" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/BornholtT18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276514", + "title": "RacerD: compositional static race detection", + "abstract": "Automatic static detection of data races is one of the most basic problems in reasoning about concurrency. We present RacerD—a static program analysis for detecting data races in Java programs which is fast, can scale to large code, and has proven effective in an industrial software engineering scenario. To our knowledge, RacerD is the first inter-procedural, compositional data race detector which has been shown to have non-trivial precision and impact. Due to its compositionality, it can analyze code changes quickly, and this allows it to perform continuous reasoning about a large, rapidly changing codebase as part of deployment within a continuous integration ecosystem. In contrast to previous static race detectors, its design favors reporting high-confidence bugs over ensuring their absence. RacerD has been in deployment for over a year at Facebook, where it has flagged over 2500 issues that have been fixed by developers before reaching production. It has been important in enabling the development of new code as well as fixing old code: it helped support conversion of part of the main Facebook Android app from a single-threaded to a multi-threaded architecture. In this paper we describe RacerD’s design, implementation, deployment and impact.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276514", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sam", + "last_name": "Blackshear", + "institution": "Meta (United States)" + }, + { + "first_name": "Nikos", + "last_name": "Gorogiannis", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "University College London" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "Yale-NUS College" + } + ], + "dblp_key": "journals/pacmpl/BlackshearGOS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276518", + "title": "ExceLint: automatically finding spreadsheet formula errors", + "abstract": "Spreadsheets are one of the most widely used programming environments, and are widely deployed in domains like finance where errors can have catastrophic consequences. We present a static analysis specifically designed to find spreadsheet formula errors. Our analysis directly leverages the rectangular character of spreadsheets. It uses an information-theoretic approach to identify formulas that are especially surprising disruptions to nearby rectangular regions. We present ExceLint, an implementation of our static analysis for Microsoft Excel. We demonstrate that ExceLint is fast and effective: across a corpus of 70 spreadsheets, ExceLint takes a median of 8 seconds per spreadsheet, and it significantly outperforms the state of the art analysis.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276518", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel W.", + "last_name": "Barowy", + "institution": "Williams College" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Benjamin G.", + "last_name": "Zorn", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/BarowyBZ18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276512", + "title": "Refinement in object-sensitivity points-to analysis via slicing", + "abstract": "Object sensitivity analysis is a well-known form of context-sensitive points-to analysis. This analysis is parameterized by a bound on the names of symbolic objects associated with each allocation site. In this paper, we propose a novel approach based on object sensitivity analysis that takes as input a set of client queries, and tries to answer them using an initial round of inexpensive object sensitivity analysis that uses a low object-name length bound at all allocation sites. For the queries that are answered unsatisfactorily, the approach then pin points \"bad\" points-to facts, which are the ones that are responsible for the imprecision. It then employs a form of program slicing to identify allocation sites that are potentially causing these bad points-to facts to be generated. The approach then runs object sensitivity analysis once again, this time using longer names for just these allocation sites, with the objective of resolving the imprecision in this round. We describe our approach formally, prove its completeness, and describe a Datalog-based implementation of it on top of the Petablox framework. Our evaluation of our approach on a set of large Java benchmarks, using two separate clients, reveals that our approach is more precise than the baseline object sensitivity approach, by around 29% for one of the clients and by around 19% for the other client. Our approach is also more precise on most large benchmarks than a recently proposed approach that uses SAT solvers to identify allocation sites to refine.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276512", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Girish Maskeri", + "last_name": "Rama", + "institution": "Infosys (India)" + }, + { + "first_name": "Raghavan", + "last_name": "Komondoor", + "institution": "" + }, + { + "first_name": "Himanshu", + "last_name": "Sharma", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/RamaKS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276510", + "title": "Precise and scalable points-to analysis via data-driven context tunneling", + "abstract": "We present context tunneling, a new approach for making k -limited context-sensitive points-to analysis precise and scalable. As context-sensitivity holds the key to the development of precise and scalable points-to analysis, a variety of techniques for context-sensitivity have been proposed. However, existing approaches such as k -call-site-sensitivity or k -object-sensitivity have a significant weakness that they unconditionally update the context of a method at every call-site, allowing important context elements to be overwritten by more recent, but not necessarily more important, context elements. In this paper, we show that this is a key limiting factor of existing context-sensitive analyses, and demonstrate that remarkable increase in both precision and scalability can be gained by maintaining important context elements only. Our approach, called context tunneling, updates contexts selectively and decides when to propagate the same context without modification. We attain context tunneling via a data-driven approach. The effectiveness of context tunneling is very sensitive to the choice of important context elements. Even worse, precision is not monotonically increasing with respect to the ordering of the choices. As a result, manually coming up with a good heuristic rule for context tunneling is extremely challenging and likely fails to maximize its potential. We address this challenge by developing a specialized data-driven algorithm, which is able to automatically search for high-quality heuristics over the non-monotonic space of context tunneling. We implemented our approach in the Doop framework and applied it to four major flavors of context-sensitivity: call-site-sensitivity, object-sensitivity, type-sensitivity, and hybrid context-sensitivity. In all cases, 1-context-sensitive analysis with context tunneling far outperformed deeper context-sensitivity with k =2 in both precision and scalability.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276510", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Minseok", + "last_name": "Jeon", + "institution": "Korea University" + }, + { + "first_name": "Sehun", + "last_name": "Jeong", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/JeonJO18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276516", + "title": "Sound deadlock prediction", + "abstract": "For a concurrent program, a prediction tool maps the history of a single run to a prediction of bugs in an exponential number of other runs. If all those bugs can occur, then the tool is sound. This is the case for some data race tools like RVPredict, but was, until now, not the case for deadlock tools. We present the first sound tool for predicting deadlocks in Java. Unlike previous work, we use request events and a novel form of executability constraints that enable sound and effective deadlock prediction. We model prediction as a general decision problem, which we show is decidable and can be instantiated to both deadlocks and data races. Our proof of decidability maps the decision problem to an equivalent constraint problem that we solve using an SMT-solver. Our experiments show that our tool finds real deadlocks effectively, including some missed by DeadlockFuzzer, which verifies each deadlock candidate by re-executing the input program. Our experiments also show that our tool can be used to predict more, real data races than RVPredict.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276516", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christian Gram", + "last_name": "Kalhauge", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/KalhaugeP18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276517", + "title": "DeepBugs: a learning approach to name-based bug detection", + "abstract": "Natural language elements in source code, e.g., the names of variables and functions, convey useful information. However, most existing bug detection tools ignore this information and therefore miss some classes of bugs. The few existing name-based bug detection approaches reason about names on a syntactic level and rely on manually designed and tuned algorithms to detect bugs. This paper presents DeepBugs, a learning approach to name-based bug detection, which reasons about names based on a semantic representation and which automatically learns bug detectors instead of manually writing them. We formulate bug detection as a binary classification problem and train a classifier that distinguishes correct from incorrect code. To address the challenge that effectively learning a bug detector requires examples of both correct and incorrect code, we create likely incorrect code examples from an existing corpus of code through simple code transformations. A novel insight learned from our work is that learning from artificially seeded bugs yields bug detectors that are effective at finding bugs in real-world code. We implement our idea into a framework for learning-based and name-based bug detection. Three bug detectors built on top of the framework detect accidentally swapped function arguments, incorrect binary operators, and incorrect operands in binary operations. Applying the approach to a corpus of 150,000 JavaScript files yields bug detectors that have a high accuracy (between 89% and 95%), are very efficient (less than 20 milliseconds per analyzed file), and reveal 102 programming mistakes (with 68% true positive rate) in real-world code.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276517", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/PradelS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276515", + "title": "What happens-after the first race? enhancing the predictive power of happens-before based dynamic race detection", + "abstract": "Dynamic race detection is the problem of determining if an observed program execution reveals the presence of a data race in a program. The classical approach to solving this problem is to detect if there is a pair of conflicting memory accesses that are unordered by Lamport’s happens-before (HB) relation. HB based race detection is known to not report false positives, i.e., it is sound. However, the soundness guarantee of HB only promises that the first pair of unordered, conflicting events is a schedulable data race. That is, there can be pairs of HB-unordered conflicting data accesses that are not schedulable races because there is no reordering of the events of the execution, where the events in race can be executed immediately after each other. We introduce a new partial order, called schedulable happens-before (SHB) that exactly characterizes the pairs of schedulable data races — every pair of conflicting data accesses that are identified by SHB can be scheduled, and every HB-race that can be scheduled is identified by SHB. Thus, the SHB partial order is truly sound. We present a linear time, vector clock algorithm to detect schedulable races using SHB. Our experiments demonstrate the value of our algorithm for dynamic race detection — SHB incurs only little performance overhead and can scale to executions from real-world software applications without compromising soundness.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276515", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Dileep", + "last_name": "Kini", + "institution": "Capital University" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MathurK018", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276523", + "title": "Object-oriented recovery for non-volatile memory", + "abstract": "New non-volatile memory (NVM) technologies enable direct, durable storage of data in an application's heap. Durable, randomly accessible memory facilitates the construction of applications that do not lose data at system shutdown or power failure. Existing NVM programming frameworks provide mechanisms to consistently capture a running application's state. They do not, however, fully support object-oriented languages or ensure that the persistent heap is consistent with the environment when the application is restarted. In this paper, we propose a new NVM language extension and runtime system that supports object-oriented NVM programming and avoids the pitfalls of prior approaches. At the heart of our technique is object reconstruction, which transparently restores and reconstructs a persistent object's state during program restart. It is implemented in NVMReconstruction, a Clang/LLVM extension and runtime library that provides: (i) transient fields in persistent objects, (ii) support for virtual functions and function pointers, (iii) direct representation of persistent pointers as virtual addresses, and (iv) type-specific reconstruction of a persistent object during program restart. In addition, NVMReconstruction supports updating an application's code, even if this causes objects to expand, by providing object migration. NVMReconstruction also can compact the persistent heap to reduce fragmentation. In experiments, we demonstrate the versatility and usability of object reconstruction and its low runtime performance cost.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276523", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nachshon", + "last_name": "Cohen", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "David T.", + "last_name": "Aksun", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "James R.", + "last_name": "Larus", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/CohenAL18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276522", + "title": "Reactive caching for composed services: polling at the speed of push", + "abstract": "Sometimes, service clients repeat requests in a polling loop in order to refresh their view. However, such polling may be slow to pick up changes, or may increase the load unacceptably, in particular for composed services that disperse over many components. We present an alternative reactive polling API and reactive caching algorithm that combines the conceptual simplicity of polling with the efficiency of push-based change propagation. A reactive cache contains a summary of a distributed read-only operation and maintains a connection to its dependencies so changes can be propagated automatically. We first formalize the setting using an abstract calculus for composed services. Then we present a fault-tolerant distributed algorithm for reactive caching that guarantees eventual consistency. Finally, we implement and evaluate our solution by extending the Orleans actor framework, and perform experiments on two benchmarks in a distributed cloud deployment. The results show that our solution provides superior performance compared to polling, at a latency that comes close to hand-written change notifications.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276522", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tim", + "last_name": "Coppieters", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "journals/pacmpl/BurckhardtC18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276521", + "title": "Cross-component garbage collection", + "abstract": "Embedding a modern language runtime as a component in a larger software system is popular these days. Communication between these systems often requires keeping references to each others' objects. In this paper we present and discuss the problem of cross-component memory management where reference cycles across component boundaries may lead to memory leaks and premature reclamation of objects may lead to dangling cross-component references. We provide a generic algorithm for effective, efficient, and safe garbage collection over component boundaries, which we call cross-component tracing. We designed and implemented cross-component tracing in the Chrome web browser where the JavaScript virtual machine V8 is embedded into the rendering engine Blink. Cross-component tracing from V8's JavaScript heap to Blink's C++ heap improves garbage collection latency and eliminates long-standing memory leaks for real websites in Chrome. We show how cross-component tracing can help web developers to reason about reachability and retainment of objects spanning both V8 and Blink components based on Chrome's heap snapshot memory tool. Cross-component tracing was enabled by default for all websites in Chrome version 57 and is also deployed in other widely used software systems such as Opera, Cobalt, and Electron.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276521", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ulan", + "last_name": "Degenbaev", + "institution": "" + }, + { + "first_name": "Jochen", + "last_name": "Eisinger", + "institution": "" + }, + { + "first_name": "Kentaro", + "last_name": "Hara", + "institution": "" + }, + { + "first_name": "Marcel", + "last_name": "Hlopko", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Lippautz", + "institution": "" + }, + { + "first_name": "Hannes", + "last_name": "Payer", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/DegenbaevEHHLP18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276524", + "title": "Software multiplexing: share your libraries and statically link them too", + "abstract": "We describe a compiler strategy we call “ Software Multiplexing ” that achieves many benefits of both statically linked and dynamically linked libraries, and adds some additional advantages. Specifically, it achieves the code size benefits of dynamically linked libraries while eliminating the major disadvantages: unexpected failures due to missing dependences, slow startup times, reduced execution performance due to indirect references to globals, and the potential for security vulnerabilities. We design Software Multiplexing so that it works even in the common case where application build systems support only dynamic and not static linking; we have automatically built thousands of Linux software packages in this way. Software Multiplexing combines two ideas: Automatic Multicall , i.e., where multiple independent programs are automatically merged into a single executable, and Static Linking of Shared Libraries , which works by linking an IR-level version of application code and all its libraries, even if the libraries are normally compiled as shared, before native code generation. The benefits are achieved primarily through deduplication of libraries across the multiplexed programs, while using static linking, and secondly through more effective unused code elimination for statically linked shared libraries. Compared with equivalent dynamically linked programs, <span>allmux-optimized programs start more quickly and even have slightly lower memory usage and total disk size. Compared with equivalent statically linked programs, <span>allmux-optimized programs are much smaller in both aggregate size and memory usage, and have similar startup times and execution performance. We have implemented Software Multiplexing in a tool called <span>allmux, part of the open-source ALLVM project. Example results show that when the LLVM Compiler Infrastructure is optimized using allmux, the resulting binaries and libraries are 18.3% smaller and 30% faster than the default production version. For 74 other packages containing 2–166 programs each, multiplexing each package into one static binary reduces the aggregate package size by 39% (geometric mean) compared with dynamic linking.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276524", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Will", + "last_name": "Dietz", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/DietzA18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276525", + "title": "Relational program synthesis", + "abstract": "This paper proposes relational program synthesis, a new problem that concerns synthesizing one or more programs that collectively satisfy a relational specification. As a dual of relational program verification, relational program synthesis is an important problem that has many practical applications, such as automated program inversion and automatic generation of comparators. However, this relational synthesis problem introduces new challenges over its non-relational counterpart due to the combinatorially larger search space. As a first step towards solving this problem, this paper presents a synthesis technique that combines the counterexample-guided inductive synthesis framework with a novel inductive synthesis algorithm that is based on relational version space learning. We have implemented the proposed technique in a framework called Relish, which can be instantiated to different application domains by providing a suitable domain-specific language and the relevant relational specification. We have used the Relish framework to build relational synthesizers to automatically generate string encoders/decoders as well as comparators, and we evaluate our tool on several benchmarks taken from prior work and online forums. Our experimental results show that the proposed technique can solve almost all of these benchmarks and that it significantly outperforms EUSolver, a generic synthesis framework that won the general track of the most recent SyGuS competition.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276525", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/0001WD18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276526", + "title": "Robust relational layout synthesis from examples for Android", + "abstract": "We present a novel approach for synthesizing robust relational layouts from examples. Given an application design consisting of a set of views and their location on the screen, we synthesize a relational layout that when rendered, places the components at that same location. We present an end-to-end system, called InferUI, that addresses the above challenge in the context of Android. The system is based on the following technical contributions: (i) a formalization of the latest and most efficient ConstraintLayout class, capturing a rich set of relational constraints, (ii) a set of robustness properties designed to prevent common layout generalization errors, (iii) a synthesis algorithm that produces relational layouts that generalize across multiple screen sizes and resolutions, and (iv) a probabilistic model of constraints that guides the synthesizer towards layouts preferred by developers. Our evaluation shows that InferUI is practically effective: it successfully synthesizes real world complex layouts obtained from top 500 GitHub and top 500 Google Play Store applications, succeeds in 100% of the cases when synthesizing layouts for a single device, and correctly generalizes 92% of the views across multiple devices, all without requiring additional specifications.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276526", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pavol", + "last_name": "Bielik", + "institution": "ETH Zurich" + }, + { + "first_name": "Marc", + "last_name": "Fischer", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/BielikFV18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276527", + "title": "Speeding up symbolic reasoning for relational queries", + "abstract": "The ability to reason about relational queries plays an important role across many types of database applications, such as test data generation, query equivalence checking, and computer-assisted query authoring. Unfortunately, symbolic reasoning about relational queries can be challenging because relational tables are multisets (bags) of tuples, and the underlying languages, such as SQL, can introduce complex computation among tuples. We propose a space refinement algorithm that soundly reduces the space of tables such applications need to consider. The refinement procedure, independent of the specific dataset application, uses the abstract semantics of the query language to exploit the provenance of tuples in the query output to prune the search space. We implemented the refinement algorithm and evaluated it on SQL using three reasoning tasks: bounded query equivalence checking, test generation for applications that manipulate relational data, and concolic testing of database applications. Using real world benchmarks, we show that our refinement algorithm significantly speeds up (up to 100×) the SQL solver when reasoning about a large class of challenging SQL queries, such as those with aggregations.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276527", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chenglong", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of Washington" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/WangCB18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276530", + "title": "Randomized testing of distributed systems with probabilistic guarantees", + "abstract": "Several recently proposed randomized testing tools for concurrent and distributed systems come with theoretical guarantees on their success. The key to these guarantees is a notion of bug depth—the minimum length of a sequence of events sufficient to expose the bug—and a characterization of d -hitting families of schedules—a set of schedules guaranteed to cover every bug of given depth d . Previous results show that in certain cases the size of a d -hitting family can be significantly smaller than the total number of possible schedules. However, these results either assume shared-memory multithreading, or that the underlying partial ordering of events is known statically and has special structure. These assumptions are not met by distributed message-passing applications. In this paper, we present a randomized scheduling algorithm for testing distributed systems. In contrast to previous approaches, our algorithm works for arbitrary partially ordered sets of events revealed online as the program is being executed. We show that for partial orders of width at most w and size at most n (both statically unknown), our algorithm is guaranteed to sample from at most w 2 n d −1 schedules, for every fixed bug depth d . Thus, our algorithm discovers a bug of depth d with probability at least 1 / ( w 2 n d −1 ). As a special case, our algorithm recovers a previous randomized testing algorithm for multithreaded programs. Our algorithm is simple to implement, but the correctness arguments depend on difficult combinatorial results about online dimension and online chain partitioning of partially ordered sets. We have implemented our algorithm in a randomized testing tool for distributed message-passing programs. We show that our algorithm can find bugs in distributed systems such as Zookeeper and Cassandra, and empirically outperforms naive random exploration while providing theoretical guarantees.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276530", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Burcu Kulahcioglu", + "last_name": "Ozkan", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Filip", + "last_name": "Niksic", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Mitra Tabaei", + "last_name": "Befrouei", + "institution": "TU Wien" + }, + { + "first_name": "Georg", + "last_name": "Weißenbacher", + "institution": "TU Wien" + } + ], + "dblp_key": "journals/pacmpl/OzkanMNBW18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276529", + "title": "Compositional programming and testing of dynamic distributed systems", + "abstract": "A real-world distributed system is rarely implemented as a standalone monolithic system. Instead, it is composed of multiple independent interacting components that together ensure the desired system-level specification. One can scale systematic testing to large, industrial-scale implementations by decomposing the system-level testing problem into a collection of simpler component-level testing problems. This paper proposes techniques for compositional programming and testing of distributed systems with two central contributions: (1) We propose a module system based on the theory of compositional trace refinement for dynamic systems consisting of asynchronously-communicating state machines, where state machines can be dynamically created, and communication topology of the existing state machines can change at runtime; (2) We present ModP, a programming system that implements our module system to enable compositional reasoning (assume-guarantee) of distributed systems. We demonstrate the efficacy of our framework by building two practical fault-tolerant distributed systems, a transaction-commit service and a replicated hash-table. ModP helps implement these systems modularly and validate them via compositional testing. We empirically demonstrate that the abstraction-based compositional reasoning approach helps amplify the coverage during testing and scale it to real-world distributed systems. The distributed services built using ModP achieve performance comparable to open-source equivalents.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276529", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ankush", + "last_name": "Desai", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Amar", + "last_name": "Phanishayee", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shaz", + "last_name": "Qadeer", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sanjit A.", + "last_name": "Seshia", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/DesaiPQS18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276532", + "title": "Finding broken promises in asynchronous JavaScript programs", + "abstract": "Recently, promises were added to ECMAScript 6, the JavaScript standard, in order to provide better support for the asynchrony that arises in user interfaces, network communication, and non-blocking I/O. Using promises, programmers can avoid common pitfalls of event-driven programming such as event races and the deeply nested counterintuitive control ow referred to as “callback hell”. Unfortunately, promises have complex semantics and the intricate control– and data- ow present in promise-based code hinders program comprehension and can easily lead to bugs. The promise graph was proposed as a graphical aid for understanding and debugging promise-based code. However, it did not cover all promise-related features in ECMAScript 6, and did not present or evaluate any technique for constructing the promise graphs. In this paper, we extend the notion of promise graphs to include all promise-related features in ECMAScript 6, including default reactions, exceptions, and the synchronization operations race and all. Furthermore, we report on the construction and evaluation of PromiseKeeper, which performs a dynamic analysis to create promise graphs and infer common promise anti-patterns. We evaluate PromiseKeeper by applying it to 12 open source promise-based Node.js applications. Our results suggest that the promise graphs constructed by PromiseKeeper can provide developers with valuable information about occurrences of common anti-patterns in their promise-based code, and that promise graphs can be constructed with acceptable run-time overhead.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276532", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Saba", + "last_name": "Alimadadi", + "institution": "Northeastern University" + }, + { + "first_name": "Di", + "last_name": "Zhong", + "institution": "Northeastern University" + }, + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aalborg University" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/AlimadadiZMT18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276528", + "title": "Automatic diagnosis and correction of logical errors for functional programming assignments", + "abstract": "We present FixML, a system for automatically generating feedback on logical errors in functional programming assignments. As functional languages have been gaining popularity, the number of students enrolling functional programming courses has increased significantly. However, the quality of feedback, in particular for logical errors, is hardly satisfying. To provide personalized feedback on logical errors, we present a new error-correction algorithm for functional languages, which combines statistical error-localization and type-directed program synthesis enhanced with components reduction and search space pruning using symbolic execution. We implemented our algorithm in a tool, called FixML, and evaluated it with 497 students’ submissions from 13 exercises, including not only introductory but also more advanced problems. Our experimental results show that our tool effectively corrects various and complex errors: it fixed 43% of the 497 submissions in 5.4 seconds on average and managed to fix a hard-to-find error in a large submission, consisting of 154 lines. We also performed user study with 18 undergraduate students and confirmed that our system actually helps students to better understand their programming errors.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276528", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Junho", + "last_name": "Lee", + "institution": "Korea University" + }, + { + "first_name": "Dowon", + "last_name": "Song", + "institution": "Korea University" + }, + { + "first_name": "Sunbeom", + "last_name": "So", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/LeeSSO18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276533", + "title": "Leto: verifying application-specific hardware fault tolerance with programmable execution models", + "abstract": "Researchers have recently designed a number of application-specific fault tolerance mechanisms that enable applications to either be naturally resilient to errors or include additional detection and correction steps that can bring the overall execution of an application back into an envelope for which an acceptable execution is eventually guaranteed. A major challenge to building an application that leverages these mechanisms, however, is to verify that the implementation satisfies the basic invariants that these mechanisms require---given a model of how faults may manifest during the application's execution. To this end we present Leto, an SMT-based automatic verification system that enables developers to verify their applications with respect to an execution model specification. Namely, Leto enables software and platform developers to programmatically specify the execution semantics of the underlying hardware system as well as verify assertions about the behavior of the application's resulting execution. In this paper, we present the Leto programming language and its corresponding verification system. We also demonstrate Leto on several applications that leverage application-specific fault tolerance", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276533", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Brett", + "last_name": "Boston", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Zoe", + "last_name": "Gong", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BostonGC18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276531", + "title": "Test generation for higher-order functions in dynamic languages", + "abstract": "Test generation has proven to provide an effective way of identifying programming errors. Unfortunately, current test generation techniques are challenged by higher-order functions in dynamic languages, such as JavaScript functions that receive callbacks. In particular, existing test generators suffer from the unavailability of statically known type signatures, do not provide functions or provide only trivial functions as inputs, and ignore callbacks triggered by the code under test. This paper presents LambdaTester, a novel test generator that addresses the specific problems posed by higher-order functions in dynamic languages. The approach automatically infers at what argument position a method under test expects a callback, generates and iteratively improves callback functions given as input to this method, and uses novel test oracles that check whether and how callback functions are invoked. We apply LambdaTester to test 43 higher-order functions taken from 13 popular JavaScript libraries. The approach detects unexpected behavior in 12 of the 13 libraries, many of which are missed by a state-of-the-art test generator.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276531", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marija", + "last_name": "Selakovic", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Rezwana", + "last_name": "Karim", + "institution": "" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/SelakovicPKT18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276535", + "title": "Verified three-way program merge", + "abstract": "Even though many programmers rely on 3-way merge tools to integrate changes from different branches, such tools can introduce subtle bugs in the integration process. This paper aims to mitigate this problem by defining a semantic notion of conflict-freedom, which ensures that the merged program does not introduce new unwanted behaviors. We also show how to verify this property using a novel, compositional algorithm that combines lightweight summarization for shared program fragments with precise relational reasoning for the modifications. Towards this goal, our method uses a 4-way differencing algorithm on abstract syntax trees to represent different program versions as edits applied to a shared program with holes. This representation allows our verification algorithm to reason about different edits in isolation and compose them to obtain an overall proof of conflict freedom. We have implemented the proposed technique in a new tool called SafeMerge for Java and evaluate it on 52 real-world merge scenarios obtained from Github. The experimental results demonstrate the benefits of our approach over syntactic conflict-freedom and indicate that SafeMerge is both precise and practical.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276535", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marcelo", + "last_name": "Sousa", + "institution": "University of Oxford" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/SousaDL18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276534", + "title": "Safe replication through bounded concurrency verification", + "abstract": "High-level data types are often associated with semantic invariants that must be preserved by any correct implementation. While having implementations enforce strong guarantees such as linearizability or serializability can often be used to prevent invariant violations in concurrent settings, such mechanisms are impractical in geo-distributed replicated environments, the platform of choice for many scalable Web services. To achieve high-availability essential to this domain, these environments admit various forms of weak consistency that do not guarantee all replicas have a consistent view of an application's state. Consequently, they often admit difficult-to-understand anomalous behaviors that violate a data type's invariants, but which are extremely challenging, even for experts, to understand and debug. In this paper, we propose a novel programming framework for replicated data types (RDTs) equipped with an automatic (bounded) verification technique that discovers and fixes weak consistency anomalies. Our approach, implemented in a tool called Q9, involves systematically exploring the state space of an application executing on top of an eventually consistent data store, under an unrestricted consistency model but with a finite concurrency bound. Q9 uncovers anomalies (i.e., invariant violations) that manifest as finite counterexamples, and automatically generates repairs for such anamolies by selectively strengthening consistency guarantees for specific operations. Using Q9, we have uncovered a range of subtle anomalies in implementations of well-known benchmarks, and have been able to apply the repairs it mandates to effectively eliminate them. Notably, these benchmarks were written adopting best practices suggested to manage distributed replicated state (e.g., they are composed of provably convergent RDTs (CRDTs), avoid mutable state, etc.). While the safety guarantees offered by our technique are constrained by the concurrency bound, we show that in practice, proving bounded safety guarantees typically generalize to the unbounded case.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276534", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kapil", + "last_name": "Earanky", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "University of Cambridge" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/KakiESJ18", + "venue": "oopsla", + "year": 2018 + }, + { + "paper_id": "10.1145/3276536", + "title": "Conflict resolution for structured merge via version space algebra", + "abstract": "Resolving conflicts is the main challenge for software merging. The existing merge tools usually rely on the developer to manually resolve conflicts. This is of course inefficient. We propose an interactive approach for resolving merge conflicts. To the best of our knowledge, this is the first attempt for conflict resolution of structured merge. To represent the possibly very large set of candidate programs, we propose an expressive and efficient representation by version space algebra. We also design a simple mechanism for ranking resolutions in the program space, such that the top-ranked resolution is very likely to meet the developer's expectation. We prototype our approach as a merge tool AutoMerge, and evaluate it on 244 real-world conflicts arising from 10 open-source projects. Results show great practicality of our approach.", + "date": "2018-10-24", + "link": "https://doi.org/10.1145/3276536", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fengmin", + "last_name": "Zhu", + "institution": "Tsinghua University" + }, + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + } + ], + "dblp_key": "journals/pacmpl/ZhuH18", + "venue": "oopsla", + "year": 2018 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2019.json b/data/pl_conferences/oopsla/2019.json new file mode 100644 index 0000000..08f6ecc --- /dev/null +++ b/data/pl_conferences/oopsla/2019.json @@ -0,0 +1,2416 @@ +[ + { + "paper_id": "10.1145/3360547", + "title": "Modular verification of heap reachability properties in separation logic", + "abstract": "The correctness of many algorithms and data structures depends on reachability properties, that is, on the existence of chains of references between objects in the heap. Reasoning about reachability is difficult for two main reasons. First, any heap modification may affect an unbounded number of reference chains, which complicates modular verification, in particular, framing. Second, general graph reachability is not supported by first-order SMT solvers, which impedes automatic verification. In this paper, we present a modular specification and verification technique for reachability properties in separation logic. For each method, we specify reachability only locally within the fragment of the heap on which the method operates. We identify relative convexity, a novel relation between the heap fragments of a client and a callee, which enables (first-order) reachability framing, that is, extending reachability properties from the heap fragment of a callee to the larger fragment of its client, enabling precise procedure-modular reasoning. Our technique supports practically important heap structures, namely acyclic graphs with a bounded outdegree as well as (potentially cyclic) graphs with at most one path (modulo cycles) between each pair of nodes. The integration into separation logic allows us to reason about reachability and other properties in a uniform way, to verify concurrent programs, and to automate our technique via existing separation logic verifiers. We demonstrate that our verification technique is amenable to SMT-based verification by encoding a number of benchmark examples into the Viper verification infrastructure.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360547", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arshavir", + "last_name": "Ter-Gabrielyan", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/Ter-GabrielyanS19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360555", + "title": "Modular verification for almost-sure termination of probabilistic programs", + "abstract": "In this work, we consider the almost-sure termination problem for probabilistic programs that asks whether a given probabilistic program terminates with probability 1. Scalable approaches for program analysis often rely on modularity as their theoretical basis. In non-probabilistic programs, the classical variant rule (V-rule) of Floyd-Hoare logic provides the foundation for modular analysis. Extension of this rule to almost-sure termination of probabilistic programs is quite tricky, and a probabilistic variant was proposed by Fioriti and Hermanns in POPL 2015. While the proposed probabilistic variant cautiously addresses the key issue of integrability, we show that the proposed modular rule is still not sound for almost-sure termination of probabilistic programs. Besides establishing unsoundness of the previous rule, our contributions are as follows: First, we present a sound modular rule for almost-sure termination of probabilistic programs. Our approach is based on a novel notion of descent supermartingales. Second, for algorithmic approaches, we consider descent supermartingales that are linear and show that they can be synthesized in polynomial time. Finally, we present experimental results on a variety of benchmarks and several natural examples that model various types of nested while loops in probabilistic programs and demonstrate that our approach is able to efficiently prove their almost-sure termination property.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360555", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mingzhang", + "last_name": "Huang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "East China Normal University" + }, + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "journals/pacmpl/Huang0CG19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360552", + "title": "Staged abstract interpreters: fast and modular whole-program analysis via meta-programming", + "abstract": "It is well known that a staged interpreter is a compiler: specializing an interpreter to a given program produces an equivalent executable that runs faster. This connection is known as the first Futamura projection. It is even more widely known that an abstract interpreter is a program analyzer: tweaking an interpreter to run on abstract domains produces a sound static analysis. What happens when we combine these two ideas, and apply specialization to an abstract interpreter? In this paper, we present a unifying framework that naturally extends the first Futamura projection from concrete interpreters to abstract interpreters. Our approach derives a sound staged abstract interpreter based on a generic interpreter with type-level binding-time abstractions and monadic abstractions. By using different instantiations of these abstractions, the generic interpreter can flexibly behave in one of four modes: as an unstaged concrete interpreter, a staged concrete interpreter, an unstaged abstract interpreter, or a staged abstract interpreter. As an example of abstraction without regret, the overhead of these abstraction layers is eliminated in the generated code after staging. We show that staging abstract interpreters is practical and useful to optimize static analysis, all while requiring less engineering effort and without compromising soundness. We conduct three case studies, including a comparison with Boucher and Feeley’s abstract compilation, applications to various control-flow analyses, and a demonstration for modular analysis. We also empirically evaluate the effect of staging on the execution time. The experiment shows an order of magnitude speedup with staging for control-flow analyses.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360552", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yuxuan", + "last_name": "Chen", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WeiCR19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360557", + "title": "Refinement kinds: type-safe programming with practical type-level computation", + "abstract": "This work introduces the novel concept of kind refinement , which we develop in the context of an explicitly polymorphic ML-like language with type-level computation. Just as type refinements embed rich specifications by means of comprehension principles expressed by predicates over values in the type domain, kind refinements provide rich kind specifications by means of predicates over types in the kind domain. By leveraging our powerful refinement kind discipline, types in our language are not just used to statically classify program expressions and values, but also conveniently manipulated as tree-like data structures, with their kinds refined by logical constraints on such structures. Remarkably, the resulting typing and kinding disciplines allow for powerful forms of type reflection, ad-hoc polymorphism and type-directed meta-programming, which are often found in modern software development, but not typically expressible in a type-safe manner in general purpose languages. We validate our approach both formally and pragmatically by establishing the standard meta-theoretical results of type safety and via a prototype implementation of a kind checker, type checker and interpreter for our language.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360557", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luı́s", + "last_name": "Caires", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "University of Lisbon" + } + ], + "dblp_key": "journals/pacmpl/CairesT19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360551", + "title": "Seq: a high-performance language for bioinformatics", + "abstract": "-mer manipulation, sequence pattern matching and large genomic index queries. On equivalent CPython code, Seq attains a performance improvement of up to two orders of magnitude, and a 160× improvement once domain-specific language features and optimizations are used. With parallelism, we demonstrate up to a 650× improvement. Compared to optimized C++ code, which is already difficult for most biologists to produce, Seq frequently attains up to a 2× improvement, and with shorter, cleaner code. Thus, Seq opens the door to an age of democratization of highly-optimized bioinformatics software.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360551", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ariya", + "last_name": "Shajii", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ibrahim", + "last_name": "Numanagić", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Riyadh", + "last_name": "Baghdadi", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Bonnie", + "last_name": "Berger", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ShajiiNBBA19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360556", + "title": "IVT: an efficient method for sharing subtype polymorphic objects", + "abstract": "Shared memory provides the fastest form of inter-process communication. Sharing polymorphic objects between different address spaces requires solving the issue of sharing pointers. In this paper, we propose a method, named Indexed Virtual Tables (IVT for short), to share polymorphic objects efficiently. On object construction, the virtual table pointers are replaced with indexes, which are used to find the actual virtual table pointers on dynamic dispatch. Only a few addition and load instructions are needed for both operations. Experimental results show that the IVT can outperform prior techniques on both object construction time and dynamic dispatch time. We also apply the proposed IVT technique to several practical scenarios, resulting the improvement of overall performance.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360556", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yu-Ping", + "last_name": "Wang", + "institution": "Tsinghua University" + }, + { + "first_name": "Xu-Qiang", + "last_name": "Hu", + "institution": "Tsinghua University" + }, + { + "first_name": "Zi–Xin", + "last_name": "Zou", + "institution": "Tsinghua University" + }, + { + "first_name": "Wende", + "last_name": "Tan", + "institution": "Tsinghua University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/0001HZTT19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360550", + "title": "Value-centric dynamic partial order reduction", + "abstract": "The verification of concurrent programs remains an open challenge, as thread interaction has to be accounted for, which leads to state-space explosion. Stateless model checking battles this problem by exploring traces rather than states of the program. As there are exponentially many traces, dynamic partial-order reduction (DPOR) techniques are used to partition the trace space into equivalence classes, and explore a few representatives from each class. The standard equivalence that underlies most DPOR techniques is the happens-before equivalence, however recent works have spawned a vivid interest towards coarser equivalences. The efficiency of such approaches is a product of two parameters: (i) the size of the partitioning induced by the equivalence, and (ii) the time spent by the exploration algorithm in each class of the partitioning. In this work, we present a new equivalence, called value-happens-before and show that it has two appealing features. First, value-happens-before is always at least as coarse as the happens-before equivalence, and can be even exponentially coarser. Second, the value-happens-before partitioning is efficiently explorable when the number of threads is bounded. We present an algorithm called value-centric DPOR ( VCDPOR ), which explores the underlying partitioning using polynomial time per class. Finally, we perform an experimental evaluation of VCDPOR on various benchmarks, and compare it against other state-of-the-art approaches. Our results show that value-happens-before typically induces a significant reduction in the size of the underlying partitioning, which leads to a considerable reduction in the running time for exploring the whole partitioning.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360550", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Toman", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "journals/pacmpl/ChatterjeePT19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360554", + "title": "Efficient lock-free durable sets", + "abstract": "Non-volatile memory is expected to co-exist or replace DRAM in upcoming architectures. Durable concurrent data structures for non-volatile memories are essential building blocks for constructing adequate software for use with these architectures. In this paper, we propose a new approach for durable concurrent sets and use this approach to build the most efficient durable hash tables available today. Evaluation shows a performance improvement factor of up to 3.3x over existing technology.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360554", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yoav", + "last_name": "Zuriel", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Michal", + "last_name": "Friedman", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Gali", + "last_name": "Sheffi", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Nachshon", + "last_name": "Cohen", + "institution": "" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ZurielFSCP19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360543", + "title": "CLOTHO: directed test generation for weakly consistent database systems", + "abstract": "Relational database applications are notoriously difficult to test and debug. Concurrent execution of database transactions may violate complex structural invariants that constraint how changes to the contents of one (shared) table affect the contents of another. Simplifying the underlying concurrency model is one way to ameliorate the difficulty of understanding how concurrent accesses and updates can affect database state with respect to these sophisticated properties. Enforcing serializable execution of all transactions achieves this simplification, but it comes at a significant price in performance, especially at scale, where database state is often replicated to improve latency and availability. To address these challenges, this paper presents a novel testing framework for detecting serializability violations in (SQL) database-backed Java applications executing on weakly-consistent storage systems. We manifest our approach in a tool, CLOTHO, that combines a static analyzer and model checker to generate abstract executions, discover serializability violations in these executions, and translate them back into concrete test inputs suitable for deployment in a test environment. To the best of our knowledge, CLOTHO, is the first automated test generation facility for identifying serializability anomalies of Java applications intended to operate in geo-replicated distributed environments. An experimental evaluation on a set of industry-standard benchmarks demonstrates the utility of our approach.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360543", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kia", + "last_name": "Rahmani", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kartik", + "last_name": "Nagar", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/RahmaniNDJ19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360544", + "title": "Probabilistic verification of fairness properties via concentration", + "abstract": "As machine learning systems are increasingly used to make real world legal and financial decisions, it is of paramount importance that we develop algorithms to verify that these systems do not discriminate against minorities. We design a scalable algorithm for verifying fairness specifications. Our algorithm obtains strong correctness guarantees based on adaptive concentration inequalities; such inequalities enable our algorithm to adaptively take samples until it has enough data to make a decision. We implement our algorithm in a tool called VeriFair, and show that it scales to large machine learning models, including a deep recurrent neural network that is more than five orders of magnitude larger than the largest previously-verified neural network. While our technique only gives probabilistic guarantees due to the use of random samples, we show that we can choose the probability of error to be extremely small.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360544", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/Bastani0S19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360558", + "title": "Program synthesis with algebraic library specifications", + "abstract": "A key challenge in program synthesis is synthesizing programs that use libraries, which most real-world software does. The current state of the art is to model libraries with mock library implementations that perform the same function in a simpler way. However, mocks may still be large and complex, and must include many implementation details, both of which could limit synthesis performance. To address this problem, we introduce JLibSketch, a Java program synthesis tool that allows library behavior to be described with algebraic specifications, which are rewrite rules for sequences of method calls, e.g., encryption followed by decryption (with the same key) is the identity. JLibSketch implements rewrite rules by compiling JLibSketch problems into problems for the Sketch program synthesis tool. More specifically, after compilation, library calls are represented by abstract data types (ADTs), and rewrite rules manipulate those ADTs. We formalize compilation and prove it sound and complete if the rewrite rules are ordered and non-unifiable. We evaluated JLibSketch by using it to synthesize nine programs that use libraries from three domains: data structures, cryptography, and file systems. We found that algebraic specifications are, on average, about half the size of mocks. We also found that algebraic specifications perform better than mocks on seven of the nine programs, sometimes significantly so, and perform equally well on the last two programs. Thus, we believe that JLibSketch takes an important step toward synthesis of programs that use libraries.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360558", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Mariano", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Josh", + "last_name": "Reese", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Siyuan", + "last_name": "Xu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "ThanhVu", + "last_name": "Nguyen", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "Xiaokang", + "last_name": "Qiu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "Tufts University" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/MarianoRXNQFS19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360545", + "title": "Verifying safety and accuracy of approximate parallel programs via canonical sequentialization", + "abstract": "We present Parallely, a programming language and a system for verification of approximations in parallel message-passing programs. Parallely's language can express various software and hardware level approximations that reduce the computation and communication overheads at the cost of result accuracy. Parallely's safety analysis can prove the absence of deadlocks in approximate computations and its type system can ensure that approximate values do not interfere with precise values. Parallely's quantitative accuracy analysis can reason about the frequency and magnitude of error. To support such analyses, Parallely presents an approximation-aware version of canonical sequentialization, a recently proposed verification technique that generates sequential programs that capture the semantics of well-structured parallel programs (i.e., ones that satisfy a symmetric nondeterminism property). To the best of our knowledge, Parallely is the first system designed to analyze parallel approximate programs. We demonstrate the effectiveness of Parallely on eight benchmark applications from the domains of graph analytics, image processing, and numerical analysis. We also encode and study five approximation mechanisms from literature. Our implementation of Parallely automatically and efficiently proves type safety, reliability, and accuracy properties of the approximate benchmarks.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360545", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vimuth", + "last_name": "Fernando", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Keyur", + "last_name": "Joshi", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/FernandoJM19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360549", + "title": "TLA+ model checking made symbolic", + "abstract": "TLA+ is a language for formal specification of all kinds of computer systems. System designers use this language to specify concurrent, distributed, and fault-tolerant protocols, which are traditionally presented in pseudo-code. TLA+ is extremely concise yet expressive: The language primitives include Booleans, integers, functions, tuples, records, sequences, and sets thereof, which can be also nested. This is probably why the only model checker for TLA+ (called TLC) relies on explicit enumeration of values and states. In this paper, we present APALACHE -- a first symbolic model checker for TLA+. Like TLC, it assumes that all specification parameters are fixed and all states are finite structures. Unlike TLC, APALACHE translates the underlying transition relation into quantifier-free SMT constraints, which allows us to exploit the power of SMT solvers. Designing this translation is the central challenge that we address in this paper. Our experiments show that APALACHE outperforms TLC on examples with large state spaces.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360549", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Igor", + "last_name": "Konnov", + "institution": "Laboratoire Lorrain de Recherche en Informatique et ses Applications" + }, + { + "first_name": "Jure", + "last_name": "Kukovec", + "institution": "TU Wien" + }, + { + "first_name": "Thanh-Hai", + "last_name": "Tran", + "institution": "TU Wien" + } + ], + "dblp_key": "journals/pacmpl/0001KT19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360548", + "title": "Complete monitors for gradual types", + "abstract": "In the context of gradual typing, type soundness guarantees the safety of typed code. When untyped code fails to respect types, a runtime check finds the discrepancy. As for untyped code, type soundness makes no promises; it does not protect untyped code from mistakes in type specifications and unwarranted blame. To address the asymmetry, this paper adapts complete monitoring from the contract world to gradual typing. Complete monitoring strengthens plain soundness into a guarantee that catches problems with faulty type specifications. Furthermore, a semantics that satisfies complete monitoring can easily pinpoint the conflict between a type specification and a value. For gradual typing systems that fail complete monitoring, the technical framework provides a source-of-truth to assess the quality of blame.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360548", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/GreenmanFD19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360553", + "title": "Derivative grammars: a symbolic approach to parsing with derivatives", + "abstract": "We present a novel approach to context-free grammar parsing that is based on generating a sequence of grammars called derivative grammars from a given context-free grammar and input string. The generation of the derivative grammars is described by a few simple inference rules. We present an O ( n 2 ) space and O ( n 3 ) time recognition algorithm, which can be extended to generate parse trees in O ( n 3 ) time and O ( n 2 log n ) space. Derivative grammars can be viewed as a symbolic approach to implementing the notion of derivative languages , which was introduced by Brzozowski. Might and others have explored an operational approach to implementing derivative languages in which the context-free grammar is encoded as a collection of recursive algebraic data types in a functional language like Haskell. Functional language implementation features like knot-tying and lazy evaluation are exploited to ensure that parsing is done correctly and efficiently in spite of complications like left-recursion. In contrast, our symbolic approach using inference rules can be implemented easily in any programming language and we obtain better space bounds for parsing. Reifying derivative languages by encoding them symbolically as grammars also enables formal connections to be made for the first time between the derivatives approach and classical parsing methods like the Earley and LL/LR parsers. In particular, we show that the sets of Earley items maintained by the Earley parser implicitly encode derivative grammars and we give a procedure for producing derivative grammars from these sets. Conversely, we show that our derivative grammar recognizer can be transformed into the Earley recognizer by optimizing some of its bookkeeping. These results suggest that derivative grammars may provide a new foundation for context-free grammar recognition and parsing.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360553", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ian", + "last_name": "Henriksen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Gianfranco", + "last_name": "Bilardi", + "institution": "University of Padua" + }, + { + "first_name": "Keshav", + "last_name": "Pingali", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/HenriksenBP19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360546", + "title": "Qubit allocation as a combination of subgraph isomorphism and token swapping", + "abstract": "In 2016, the first quantum processors have been made available to the general public. The possibility of programming an actual quantum device has elicited much enthusiasm. Yet, such possibility also brought challenges. One challenge is the so called Qubit Allocation problem: the mapping of a virtual quantum circuit into an actual quantum architecture. There exist solutions to this problem; however, in our opinion, they fail to capitalize on decades of improvements on graph theory. In contrast, this paper shows how to model qubit allocation as the combination of Subgraph Isomorphism and Token Swapping. This idea has been made possible by the publication of an approximative solution to the latter problem in 2016. We have compared our algorithm against five other qubit allocators, all independently designed in the last two years, including the winner of the IBM Challenge. When evaluated in \"Tokyo\", a quantum architecture with 20 qubits, our technique outperforms these state-of-the-art approaches in terms of the quality of the solutions that it finds and the amount of memory that it uses, while showing practical runtime.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360546", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marcos Yukio", + "last_name": "Siraichi", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Vinícius F. dos", + "last_name": "Santos", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Caroline", + "last_name": "Collange", + "institution": "Université de Rennes" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "journals/pacmpl/SiraichiSCP19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360559", + "title": "Weakening WebAssembly", + "abstract": "WebAssembly (Wasm) is a safe, portable virtual instruction set that can be hosted in a wide range of environments, such as a Web browser. It is a low-level language whose instructions are intended to compile directly to bare hardware. While the initial version of Wasm focussed on single-threaded computation, a recent proposal extends it with low-level support for multiple threads and atomic instructions for synchronised access to shared memory. To support the correct compilation of concurrent programs, it is necessary to give a suitable specification of its memory model. Wasm's language definition is based on a fully formalised specification that carefully avoids undefined behaviour. We present a substantial extension to this semantics, incorporating a relaxed memory model, along with a few proposed extensions. Wasm's memory model is unique in that its linear address space can be dynamically grown during execution, while all accesses are bounds-checked. This leads to the novel problem of specifying how observations about the size of the memory can propagate between threads. We argue that, considering desirable compilation schemes, we cannot give a sequentially consistent semantics to memory growth. We show that our model provides sequential consistency for data-race-free executions (SC-DRF). However, because Wasm is to run on the Web, we must also consider interoperability of its model with that of JavaScript. We show, by counter-example, that JavaScript's memory model is not SC-DRF, in contrast to what is claimed in its specification. We propose two axiomatic conditions that should be added to the JavaScript model to correct this difference. We also describe a prototype SMT-based litmus tool which acts as an oracle for our axiomatic model, visualising its behaviours, including memory resizing.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360559", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Conrad", + "last_name": "Watt", + "institution": "University of Cambridge" + }, + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/WattRP19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360560", + "title": "Generating a fluent API with syntax checking from an LR grammar", + "abstract": "This paper proposes a fluent API generator for Scala, Haskell, and C++. It receives a grammar definition and generates a code skeleton of the library in the host programming language. The generated library is accessed through a chain of method calls; this style of API is called a fluent API. The library uses the host-language type checker to detect an invalid chain of method calls. Each method call is regarded as a lexical token in the embedded domain specific language implemented by that library. A sequence of the lexical tokens is checked and, if the sequence is not acceptable by the grammar, a type error is reported during compilation time. A contribution of this paper is to present an algorithm for generating the code-skeleton for a fluent API that reports a type error when a chain of method calls to the library does not match the given LR grammar. Our algorithm works in Scala, Haskell, and C++. To encode LR parsing, it uses the method/function overloading available in those languages. It does not need an advanced type system, or exponential compilation time or memory consumption. This paper also presents our implementation of the proposed generator.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360560", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tetsuro", + "last_name": "Yamazaki", + "institution": "The University of Tokyo" + }, + { + "first_name": "Tomoki", + "last_name": "Nakamaru", + "institution": "The University of Tokyo" + }, + { + "first_name": "Kazuhiro", + "last_name": "Ichikawa", + "institution": "The University of Tokyo" + }, + { + "first_name": "Shigeru", + "last_name": "Chiba", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "journals/pacmpl/YamazakiNIC19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360563", + "title": "BDA: practical dependence analysis for binary executables by unbiased whole-program path sampling and per-path abstract interpretation", + "abstract": "Binary program dependence analysis determines dependence between instructions and hence is important for many applications that have to deal with executables without any symbol information. A key challenge is to identify if multiple memory read/write instructions access the same memory location. The state-of-the-art solution is the value set analysis (VSA) that uses abstract interpretation to determine the set of addresses that are possibly accessed by memory instructions. However, VSA is conservative and hence leads to a large number of bogus dependences and then substantial false positives in downstream analyses such as malware behavior analysis. Furthermore, existing public VSA implementations have difficulty scaling to complex binaries. In this paper, we propose a new binary dependence analysis called BDA enabled by a randomized abstract interpretation technique. It features a novel whole program path sampling algorithm that is not biased by path length, and a per-path abstract interpretation avoiding precision loss caused by merging paths in traditional analyses. It also provides probabilistic guarantees. Our evaluation on SPECINT2000 programs shows that it can handle complex binaries such as gcc whereas VSA implementations from the-state-of-art platforms have difficulty producing results for many SPEC binaries. In addition, the dependences reported by BDA are 75 and 6 times smaller than Alto, a scalable binary dependence analysis tool, and VSA, respectively, with only 0.19% of true dependences observed during dynamic execution missed (by BDA). Applying BDA to call graph generation and malware analysis shows that BDA substantially supersedes the commercial tool IDA in recovering indirect call targets and outperforms a state-of-the-art malware analysis tool Cuckoo by disclosing 3 times more hidden payloads.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360563", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhuo", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Wei", + "last_name": "You", + "institution": "Renmin University of China" + }, + { + "first_name": "Guanhong", + "last_name": "Tao", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yonghwi", + "last_name": "Kwon", + "institution": "University of Virginia" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/ZhangYTWK019", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360564", + "title": "Asphalion: trustworthy shielding against Byzantine faults", + "abstract": "Byzantine fault-tolerant state-machine replication (BFT-SMR) is a technique for hardening systems to tolerate arbitrary faults. Although robust, BFT-SMR protocols are very costly in terms of the number of required replicas (3f+1 to tolerate f faults) and of exchanged messages. However, with \"hybrid\" architectures, where \"normal\" components trust some \"special\" components to provide properties in a trustworthy manner, the cost of using BFT can be dramatically reduced. Unfortunately, even though such hybridization techniques decrease the message/time/space complexity of BFT protocols, they also increase their structural complexity. Therefore, we introduce Asphalion, the first theorem prover-based framework for verifying implementations of hybrid systems and protocols. It relies on three novel languages: (1) HyLoE: a Hybrid Logic of Events to reason about hybrid fault models; (2) MoC: a Monadic Component language to implement systems as collections of interacting hybrid components; and (3) LoCK: a sound Logic of events-based Calculus of Knowledge to reason about both homogeneous and hybrid systems at a high-level of abstraction (thereby allowing reusing proofs, and capturing the high-level logic of distributed systems). In addition, Asphalion supports compositional reasoning, e.g., through mechanisms to lift properties about trusted-trustworthy components, to the level of the distributed systems they are integrated in. As a case study, we have verified crucial safety properties (e.g., agreement) of several implementations of hybrid protocols.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360564", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivana", + "last_name": "Vukotic", + "institution": "University of Luxembourg" + }, + { + "first_name": "Vincent", + "last_name": "Rahli", + "institution": "University of Birmingham" + }, + { + "first_name": "Paulo", + "last_name": "Esteves-Veríssimo", + "institution": "University of Luxembourg" + } + ], + "dblp_key": "journals/pacmpl/VukoticRV19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360562", + "title": "DeepSEA: a language for certified system software", + "abstract": "Writing certifiably correct system software is still very labor-intensive, and current programming languages are not well suited for the task. Proof assistants work best on programs written in a high-level functional style, while operating systems need low-level control over the hardware. We present DeepSEA, a language which provides support for layered specification and abstraction refinement, effect encapsulation and composition, and full equational reasoning. A single DeepSEA program is automatically compiled into a certified ``layer'' consisting of a C program (which is then compiled into assembly by CompCert), a low-level functional Coq specification, and a formal (Coq) proof that the C program satisfies the specification. Multiple layers can be composed and interleaved with manual proofs to ascribe a high-level specification to a program by stepwise refinement. We evaluate the language by using it to reimplement two existing verified programs: a SHA-256 hash function and an OS kernel page table manager. This new style of programming language design can directly support the development of correct-by-construction system software.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360562", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vilhelm", + "last_name": "Sjöberg", + "institution": "Yale University" + }, + { + "first_name": "Yuyang", + "last_name": "Sang", + "institution": "Yale University" + }, + { + "first_name": "Shu-Chun", + "last_name": "Weng", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/SjobergSWS19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360565", + "title": "Automatic repair of regular expressions", + "abstract": "We introduce RFixer, a tool for repairing complex regular expressions using examples and only consider regular expressions without non-regular operators (e.g., negative lookahead). Given an incorrect regular expression and sets of positive and negative examples, RFixer synthesizes the closest regular expression to the original one that is consistent with the examples. Automatically repairing regular expressions requires exploring a large search space because practical regular expressions: i) are large, ii) operate over very large alphabets---e.g., UTF-16 and ASCII---and iii) employ complex constructs---e.g., character classes and numerical quantifiers. RFixer's repair algorithm achieves scalability by taking advantage of structural properties of regular expressions to effectively prune the search space, and it employs satisfiability modulo theory solvers to efficiently and symbolically explore the sets of possible character classes and numerical quantifiers. RFixer could successfully compute minimal repairs for regular expressions collected from a variety of sources, whereas existing tools either failed to produce any repair or produced overly complex repairs.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360565", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rong", + "last_name": "Pan", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Qinheping", + "last_name": "Hu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Gaowei", + "last_name": "Xu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/PanHXD19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360566", + "title": "Static analysis with demand-driven value refinement", + "abstract": "Static analysis tools for JavaScript must strike a delicate balance, achieving the level of precision required by the most complex features of target programs without incurring prohibitively high analysis time. For example, reasoning about dynamic property accesses sometimes requires precise relational information connecting the object, the dynamically-computed property name, and the property value. Even a minor precision loss at such critical program locations can result in a proliferation of spurious dataflow that renders the analysis results useless. We present a technique by which a conventional non-relational static dataflow analysis can be combined soundly with a value refinement mechanism to increase precision on demand at critical locations. Crucially, our technique is able to incorporate relational information from the value refinement mechanism into the non-relational domain of the dataflow analysis. We demonstrate the feasibility of this approach by extending an existing JavaScript static analysis with a demand-driven value refinement mechanism that relies on backwards abstract interpretation. Our evaluation finds that precise analysis of widely used JavaScript utility libraries depends heavily on the precision at a small number of critical locations that can be identified heuristically, and that backwards abstract interpretation is an effective mechanism to provide that precision on demand.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360566", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "B.", + "last_name": "Stein", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Benjamin Barslev", + "last_name": "Nielsen", + "institution": "Aarhus University" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/SteinNCM19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360561", + "title": "Weak persistency semantics from the ground up: formalising the persistency semantics of ARMv8 and transactional models", + "abstract": "Emerging non-volatile memory (NVM) technologies promise the durability of disks with the performance of volatile memory (RAM). To describe the persistency guarantees of NVM, several memory persistency models have been proposed in the literature. However, the formal persistency semantics of mainstream hardware is unexplored to date. To close this gap, we present a formal declarative framework for describing concurrency models in the NVM context, and then develop the PARMv8 persistency model as an instance of our framework, formalising the persistency semantics of the ARMv8 architecture for the first time. To facilitate correct persistent programming, we study transactions as a simple abstraction for concurrency and persistency control. We thus develop the PSER (persistent serialisability) persistency model, formalising transactional semantics in the NVM context for the first time, and demonstrate that PSER correctly compiles to PARMv8. This then enables programmers to write correct, concurrent and persistent programs, without having to understand the low-level architecture-specific persistency semantics of the underlying hardware.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360561", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RaadWV19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360573", + "title": "Leveraging rust types for modular specification and verification", + "abstract": "Rust's type system ensures memory safety: well-typed Rust programs are guaranteed to not exhibit problems such as dangling pointers, data races, and unexpected side effects through aliased references. Ensuring correctness properties beyond memory safety, for instance, the guaranteed absence of assertion failures or more-general functional correctness, requires static program verification. For traditional system programming languages, formal verification is notoriously difficult and requires complex specifications and logics to reason about pointers, aliasing, and side effects on mutable state. This complexity is a major obstacle to the more-widespread verification of system software. In this paper, we present a novel verification technique that leverages Rust's type system to greatly simplify the specification and verification of system software written in Rust. We analyse information from the Rust compiler and synthesise a corresponding core proof for the program in a flavour of separation logic tailored to automation. To verify correctness properties beyond memory safety, users can annotate Rust programs with specifications at the abstraction level of Rust expressions; our technique weaves them into the core proof to verify modularly whether these specifications hold. Crucially, our proofs are constructed and checked automatically without exposing the underlying formal logic, allowing users to work exclusively at the level of abstraction of the programming language. As such, our work enables a new kind of verification tool, with the potential to impact a wide audience and allow the Rust community to benefit from state-of-the-art verification techniques. We have implemented our techniques for a subset of Rust; our evaluation on several thousand functions from widely-used Rust crates demonstrates its effectiveness.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360573", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vytautas", + "last_name": "Astrauskas", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Federico", + "last_name": "Poli", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/Astrauskas0PS19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360570", + "title": "A fault-tolerant programming model for distributed interactive applications", + "abstract": "Ubiquitous connectivity of web, mobile, and IoT computing platforms has fostered a variety of distributed applications with decentralized state. These applications execute across multiple devices with varying reliability and connectivity. Unfortunately, there is no declarative fault-tolerant programming model for distributed interactive applications with an inherently decentralized system model. We present a novel approach to automating fault tolerance using high-level programming abstractions tailored to the needs of distributed interactive applications. Specifically, we propose a calculus that enables formal reasoning about applications' dataflow within and across individual devices. Our calculus reinterprets the functional reactive programming model to seamlessly integrate its automated state change propagation with automated crash recovery of device-local dataflow and disconnection-tolerant distribution with guaranteed automated eventual consistency semantics based on conflict-free replicated datatypes. As a result, programmers are relieved of handling intricate details of distributing change propagation and coping with distribution failures in the presence of interactivity. We also provides proofs of our claims, an implementation of our calculus, and an empirical evaluation using a common interactive application.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360570", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ragnar", + "last_name": "Mogk", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Joscha", + "last_name": "Drechsler", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "journals/pacmpl/MogkDSM19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360572", + "title": "Reliable and fast DWARF-based stack unwinding", + "abstract": "Debug information, usually encoded in the DWARF format, is a hidden and obscure component of our computing infrastructure. Debug information is obviously used by debuggers, but it also plays a key role in program analysis tools, and, most surprisingly, it can be relied upon by the runtime of high-level programming languages. For instance the C++ runtime leverages DWARF stack unwind tables to implement exceptions! Alas, generating debug information adds significant burden to compiler implementations, and the debug information itself can be pervaded by subtle bugs, making the whole infrastructure unreliable. Additionally, interpreting the debug tables is a time-consuming task and, for some applications as sampling profilers, it turns out to be a performance bottleneck. In this paper we focus on the DWARF .eh_frame table, that enables stack unwinding in absence of frame-pointers. We will describe two techniques to perform validation and synthesis of the DWARF stack unwinding tables, and their implementation for the x86_64 architecture. The validation tool has proven effective for compiler and inline assembly testing, while the synthesis tool can generate DWARF unwind tables for arbitrary binaries lacking debug information. Additionally, we report on a technique to precompile unwind tables into native x86_64 code, which we have implemented and integrated into libunwind, resulting in 11x-25x DWARF-based unwind speedups.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360572", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Théophile", + "last_name": "Bastian", + "institution": "École Normale Supérieure - PSL" + }, + { + "first_name": "Stephen", + "last_name": "Kell", + "institution": "University of Kent" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Laboratoire de l'Informatique du Parallélisme" + } + ], + "dblp_key": "journals/pacmpl/BastianKN19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360571", + "title": "A path to DOT: formalizing fully path-dependent types", + "abstract": "The Dependent Object Types (DOT) calculus aims to formalize the Scala programming language with a focus on path-dependent types — types such as x . a 1 … a n . T that depend on the runtime value of a path x . a 1 … a n to an object. Unfortunately, existing formulations of DOT can model only types of the form x . A which depend on variables rather than general paths. This restriction makes it impossible to model nested module dependencies. Nesting small components inside larger ones is a necessary ingredient of a modular, scalable language. DOT’s variable restriction thus undermines its ability to fully formalize a variety of programming-language features including Scala’s module system, family polymorphism, and covariant specialization. This paper presents the pDOT calculus, which generalizes DOT to support types that depend on paths of arbitrary length, as well as singleton types to track path equality. We show that naive approaches to add paths to DOT make it inherently unsound, and present necessary conditions for such a calculus to be sound. We discuss the key changes necessary to adapt the techniques of the DOT soundness proofs so that they can be applied to pDOT. Our paper comes with a Coq-mechanized type-safety proof of pDOT. With support for paths of arbitrary length, pDOT can realize DOT’s full potential for formalizing Scala-like calculi.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360571", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marianna", + "last_name": "Rapoport", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/RapoportL19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360569", + "title": "On the fly synthesis of edit suggestions", + "abstract": "When working with a document, users often perform context-specific repetitive edits – changes to the document that are similar but specific to the contexts at their locations. Programming by demonstration/examples (PBD/PBE) systems automate these tasks by learning programs to perform the repetitive edits from demonstration or examples. However, PBD/PBE systems are not widely adopted, mainly because they require modal UIs – users must enter a special mode to give the demonstration/examples. This paper presents Blue-Pencil, a modeless system for synthesizing edit suggestions on the fly. Blue-Pencil observes users as they make changes to the document, silently identifies repetitive changes, and automatically suggests transformations that can apply at other locations. Blue-Pencil is parameterized – it allows the ”plug-and-play” of different PBE engines to support different document types and different kinds of transformations. We demonstrate this parameterization by instantiating Blue-Pencil to several domains – C# and SQL code, markdown documents, and spreadsheets – using various existing PBE engines. Our evaluation on 37 code editing sessions shows that Blue-Pencil synthesized edit suggestions with a precision of 0.89 and a recall of 1.0, and took 199 ms to return suggestions on average. Finally, we report on several improvements based on feedback gleaned from a field study with professional programmers to investigate the use of Blue-Pencil during long code editing sessions. Blue-Pencil has been integrated with Visual Studio IntelliCode to power the IntelliCode refactorings feature.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360569", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anders", + "last_name": "Miltner", + "institution": "Princeton University" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Alan", + "last_name": "Leung", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gustavo", + "last_name": "Soares", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Abhishek", + "last_name": "Udupa", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/MiltnerGLLRSTU19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360567", + "title": "Relational verification using reinforcement learning", + "abstract": "Relational verification aims to prove properties that relate a pair of programs or two different runs of the same program. While relational properties (e.g., equivalence, non-interference) can be verified by reducing them to standard safety, there are typically many possible reduction strategies, only some of which result in successful automated verification. Motivated by this problem, we propose a novel relational verification algorithm that learns useful reduction strategies using reinforcement learning. Specifically, we show how to formulate relational verification as a Markov Decision Process (MDP) and use reinforcement learning to synthesize an optimal policy for the underlying MDP. The learned policy is then used to guide the search for a successful verification strategy. We have implemented this approach in a tool called Coeus and evaluate it on two benchmark suites. Our evaluation shows that Coeus solves significantly more problems within a given time limit compared to multiple baselines, including two state-of-the-art relational verification tools.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360567", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jia", + "last_name": "Chen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Jiayi", + "last_name": "Wei", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/ChenWFBD19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360568", + "title": "A formalization of Java's concurrent access modes", + "abstract": "Java's memory model was recently updated and expanded with new access modes. The accompanying documentation for these access modes is intended to make strong guarantees about program behavior that the Java compiler must enforce, yet the documentation is frequently unclear. This makes the intended program behavior ambiguous, impedes discussion of key design decisions, and makes it impossible to prove general properties about the semantics of the access modes. In this paper we present the first formalization of Java's access modes. We have constructed an axiomatic model for all of the modes using the Herd modeling tool. This allows us to give precise answers to questions about the behavior of example programs, called litmus tests. We have validated our model using a large suite of litmus tests from existing research which helps to shed light on the relationship with other memory models. We have also modeled the semantics in Coq and proven several general theorems including a DRF guarantee, which says that if a program is properly synchronized then it will exhibit sequentially consistent behavior. Finally, we use our model to prove that the unusual design choice of a partial order among writes to the same location is unobservable in any program.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360568", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Bender", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/BenderP19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360574", + "title": "Precision-preserving yet fast object-sensitive pointer analysis with partial context sensitivity", + "abstract": "Object-sensitivity is widely used as a context abstraction for computing the points-to information context-sensitively for object-oriented languages like Java. Due to the combinatorial explosion of contexts in large programs, k -object-sensitive pointer analysis (under k -limiting), denoted k -obj, is scalable only for small values of k , where k ⩽2 typically. A few recent solutions attempt to improve its efficiency by instructing k -obj to analyze only some methods in the program context-sensitively, determined heuristically by a pre-analysis. While already effective, these heuristics-based pre-analyses do not provide precision guarantees, and consequently, are limited in the efficiency gains achieved. We introduce a radically different approach, Eagle, that makes k -obj run significantly faster than the prior art while maintaining its precision. The novelty of Eagle is to enable k -obj to analyze a method with partial context-sensitivity, i.e., context-sensitively for only some of its selected variables/allocation sites. Eagle makes these selections during a lightweight pre-analysis by reasoning about context-free-language (CFL) reachability at the level of variables/objects in the program, based on a new CFL-reachability formulation of k -obj. We demonstrate the advances made by Eagle by comparing it with the prior art in terms of a set of popular Java benchmarks and applications.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360574", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jingbo", + "last_name": "Lu", + "institution": "UNSW Sydney" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "journals/pacmpl/LuX19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360575", + "title": "Formal foundations of serverless computing", + "abstract": "Serverless computing (also known as functions as a service) is a new cloud computing abstraction that makes it easier to write robust, large-scale web services. In serverless computing, programmers write what are called serverless functions, which are programs that respond to external events. When demand for the serverless function spikes, the platform automatically allocates additional hardware and manages load-balancing; when demand falls, the platform silently deallocates idle resources; and when the platform detects a failure, it transparently retries affected requests. In 2014, Amazon Web Services introduced the first serverless platform, AWS Lambda, and similar abstractions are now available on all major cloud computing platforms. Unfortunately, the serverless computing abstraction exposes several low-level operational details that make it hard for programmers to write and reason about their code. This paper sheds light on this problem by presenting λ λ , an operational semantics of the essence of serverless computing. Despite being a small (half a page) core calculus, λ λ models all the low-level details that serverless functions can observe. To show that λ λ is useful, we present three applications. First, to ease reasoning about code, we present a simplified naive semantics of serverless execution and precisely characterize when the naive semantics and λ λ coincide. Second, we augment λ λ with a key-value store to allow reasoning about stateful serverless functions. Third, since a handful of serverless platforms support serverless function composition, we show how to extend λ λ with a composition language and show that our implementation can outperform prior work.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360575", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Abhinav", + "last_name": "Jangda", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Donald", + "last_name": "Pinckney", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Yuriy", + "last_name": "Brun", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "journals/pacmpl/JangdaPBG19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360576", + "title": "Optimal stateless model checking for reads-from equivalence under sequential consistency", + "abstract": "We present a new approach for stateless model checking (SMC) of multithreaded programs under Sequential Consistency (SC) semantics. To combat state-space explosion, SMC is often equipped with a partial-order reduction technique, which defines an equivalence on executions, and only needs to explore one execution in each equivalence class. Recently, it has been observed that the commonly used equivalence of Mazurkiewicz traces can be coarsened but still cover all program crashes and assertion violations. However, for this coarser equivalence, which preserves only the reads-from relation from writes to reads, there is no SMC algorithm which is (i) optimal in the sense that it explores precisely one execution in each reads-from equivalence class, and (ii) efficient in the sense that it spends polynomial effort per class. We present the first SMC algorithm for SC that is both optimal and efficient in practice , meaning that it spends polynomial time per equivalence class on all programs that we have tried. This is achieved by a novel test that checks whether a given reads-from relation can arise in some execution. We have implemented the algorithm by extending Nidhugg, an SMC tool for C/C++ programs, with a new mode called rfsc. Our experimental results show that Nidhugg/rfsc, although slower than the fastest SMC tools in programs where tools happen to examine the same number of executions, always scales similarly or better than them, and outperforms them by an exponential factor in programs where the reads-from equivalence is coarser than the standard one. We also present two non-trivial use cases where the new equivalence is particularly effective, as well as the significant performance advantage that Nidhugg/rfsc offers compared to state-of-the-art SMC and systematic concurrency testing tools.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360576", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Bengt", + "last_name": "Jönsson", + "institution": "Uppsala University" + }, + { + "first_name": "Magnus", + "last_name": "Lång", + "institution": "Uppsala University" + }, + { + "first_name": "Tuan Phong", + "last_name": "Ngo", + "institution": "Uppsala University" + }, + { + "first_name": "Konstantinos", + "last_name": "Sagonas", + "institution": "Uppsala University" + } + ], + "dblp_key": "journals/pacmpl/AbdullaAJLNS19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360577", + "title": "Modular verification of web page layout", + "abstract": "Automated verification can ensure that a web page satisfies accessibility, usability, and design properties regardless of the end user's device, preferences, and assistive technologies. However, state-of-the-art verification tools for layout properties do not scale to large pages because they rely on whole-page analyses and must reason about the entire page using the complex semantics of the browser layout algorithm. This paper introduces and formalizes modular layout proofs. A modular layout proof splits a monolithic verification problem into smaller verification problems, one for each component of a web page. Each component specification can use rely/guarantee-style preconditions to make it verifiable independently of the rest of the page and enabling reuse across multiple pages. Modular layout proofs scale verification to pages an order of magnitude larger than those supported by previous approaches. We prototyped these techniques in a new proof assistant, Troika. In Troika, a proof author partitions a page into components and writes specifications for them. Troika then verifies the specifications, and uses those specifications to verify whole-page properties. Troika also enables the proof author to verify different component specifications with different verification tools, leveraging the strengths of each. In a case study, we use Troika to verify a large web page and demonstrate a speed-up of 13--1469x over existing tools, taking verification time from hours to seconds. We develop a systematic approach to writing Troika proofs and demonstrate it on 8 proofs of properties from prior work to show that modular layout proofs are short, easy to write, and provide benefits over existing tools.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360577", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Utah" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Shoaib", + "last_name": "Kamil", + "institution": "Adobe Systems (United States)" + } + ], + "dblp_key": "journals/pacmpl/PanchekhaETK19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360579", + "title": "On the design, implementation, and use of laziness in R", + "abstract": "The R programming language has been lazy for over twenty-five years. This paper presents a review of the design and implementation of call-by-need in R, and a data-driven study of how generations of programmers have put laziness to use in their code. We analyze 16,707 packages and observe the creation of 270.9 B promises. Our data suggests that there is little supporting evidence to assert that programmers use laziness to avoid unnecessary computation or to operate over infinite data structures. For the most part R code appears to have been written without reliance on, and in many cases even knowledge of, delayed argument evaluation. The only significant exception is a small number of packages which leverage call-by-need for meta-programming.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360579", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aviral", + "last_name": "Goel", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Vitek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/GoelV19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360580", + "title": "Mergeable replicated data types", + "abstract": "Programming geo-replicated distributed systems is challenging given the complexity of reasoning about different evolving states on different replicas. Existing approaches to this problem impose significant burden on application developers to consider the effect of how operations performed on one replica are witnessed and applied on others. To alleviate these challenges, we present a fundamentally different approach to programming in the presence of replicated state. Our insight is based on the use of invertible relational specifications of an inductively-defined data type as a mechanism to capture salient aspects of the data type relevant to how its different instances can be safely merged in a replicated environment. Importantly, because these specifications only address a data type's (static) structural properties, their formulation does not require exposing low-level system-level details concerning asynchrony, replication, visibility, etc. As a consequence, our framework enables the correct-by-construction synthesis of rich merge functions over arbitrarily complex (i.e., composable) data types. We show that the use of a rich relational specification language allows us to extract sufficient conditions to automatically derive merge functions that have meaningful non-trivial convergence properties. We incorporate these ideas in a tool called Quark, and demonstrate its utility via a detailed evaluation study on real-world benchmarks.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360580", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Swarn", + "last_name": "Priya", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/KakiPSJ19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360578", + "title": "Aroma: code recommendation via structural code search", + "abstract": "Programmers often write code that has similarity to existing code written somewhere. A tool that could help programmers to search such similar code would be immensely useful. Such a tool could help programmers to extend partially written code snippets to completely implement necessary functionality, help to discover extensions to the partial code which are commonly included by other programmers, help to cross-check against similar code written by other programmers, or help to add extra code which would fix common mistakes and errors. We propose Aroma, a tool and technique for code recommendation via structural code search. Aroma indexes a huge code corpus including thousands of open-source projects, takes a partial code snippet as input, searches the corpus for method bodies containing the partial code snippet, and clusters and intersects the results of the search to recommend a small set of succinct code snippets which both contain the query snippet and appear as part of several methods in the corpus. We evaluated Aroma on 2000 randomly selected queries created from the corpus, as well as 64 queries derived from code snippets obtained from Stack Overflow, a popular website for discussing code. We implemented Aroma for 4 different languages, and developed an IDE plugin for Aroma. Furthermore, we conducted a study where we asked 12 programmers to complete programming tasks using Aroma, and collected their feedback. Our results indicate that Aroma is capable of retrieving and recommending relevant code snippets efficiently.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360578", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sifei", + "last_name": "Luan", + "institution": "Meta (United States)" + }, + { + "first_name": "Di", + "last_name": "Yang", + "institution": "University of California, Irvine" + }, + { + "first_name": "Celeste", + "last_name": "Barnaby", + "institution": "Meta (United States)" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "Meta (United States)" + } + ], + "dblp_key": "journals/pacmpl/LuanYBS019", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360581", + "title": "Compiler fuzzing: how much does it matter?", + "abstract": "Despite much recent interest in randomised testing (fuzzing) of compilers, the practical impact of fuzzer-found compiler bugs on real-world applications has barely been assessed. We present the first quantitative and qualitative study of the tangible impact of miscompilation bugs in a mature compiler. We follow a rigorous methodology where the bug impact over the compiled application is evaluated based on (1) whether the bug appears to trigger during compilation; (2) the extent to which generated assembly code changes syntactically due to triggering of the bug; and (3) whether such changes cause regression test suite failures, or whether we can manually find application inputs that trigger execution divergence due to such changes. The study is conducted with respect to the compilation of more than 10 million lines of C/C++ code from 309 Debian packages, using 12% of the historical and now fixed miscompilation bugs found by four state-of-the-art fuzzers in the Clang/LLVM compiler, as well as 18 bugs found by human users compiling real code or as a by-product of formal verification efforts. The results show that almost half of the fuzzer-found bugs propagate to the generated binaries for at least one package, in which case only a very small part of the binary is typically affected, yet causing two failures when running the test suites of all the impacted packages. User-reported and formal verification bugs do not exhibit a higher impact, with a lower rate of triggered bugs and one test failure. The manual analysis of a selection of the syntactic changes caused by some of our bugs (fuzzer-found and non fuzzer-found) in package assembly code, shows that either these changes have no semantic impact or that they would require very specific runtime circumstances to trigger execution divergence.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360581", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michaël", + "last_name": "Marcozzi", + "institution": "Imperial College London" + }, + { + "first_name": "Qiyi", + "last_name": "Tang", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Cristian", + "last_name": "Cadar", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/MarcozziTDC19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360583", + "title": "Precise reasoning with structured time, structured heaps, and collective operations", + "abstract": "Despite decades of progress, static analysis tools still have great difficulty dealing with programs that combine arithmetic, loops, dynamic memory allocation, and linked data structures. In this paper we draw attention to two fundamental reasons for this difficulty: First, typical underlying program abstractions are low-level and inherently scalar, characterizing compound entities like data structures or results computed through iteration only indirectly. Second, to ensure termination, analyses typically project away the dimension of time, and merge information per program point, which incurs a loss in precision. As a remedy, we propose to make collective operations first-class in program analysis – inspired by Σ-notation in mathematics, and also by the success of high-level intermediate languages based on @map/reduce@ operations in program generators and aggressive optimizing compilers for domain-specific languages (DSLs). We further propose a novel structured heap abstraction that preserves a symbolic dimension of time, reflecting the program’s loop structure and thus unambiguously correlating multiple temporal points in the dynamic execution with a single point in the program text. This paper presents a formal model, based on a high-level intermediate analysis language, a practical realization in a prototype tool that analyzes C code, and an experimental evaluation that demonstrates competitive results on a series of benchmarks. Remarkably, our implementation achieves these results in a fully semantics-preserving strongest-postcondition model, which is a worst-case for analysis/verification. The underlying ideas, however, are not tied to this model and would equally apply in other settings, e.g., demand-driven invariant inference in a weakest-precondition model. Given its semantics-preserving nature, our implementation is not limited to analysis for verification, but can also check program equivalence, and translate legacy C code to high-performance DSLs.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360583", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Grégory M.", + "last_name": "Essertel", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/EssertelWR19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360589", + "title": "Scala implicits are everywhere: a large-scale study of the use of Scala implicits in the wild", + "abstract": "The Scala programming language offers two distinctive language features implicit parameters and implicit conversions, often referred together as implicits. Announced without fanfare in 2004, implicits have quickly grown to become a widely and pervasively used feature of the language. They provide a way to reduce the boilerplate code in Scala programs. They are also used to implement certain language features without having to modify the compiler. We report on a large-scale study of the use of implicits in the wild. For this, we analyzed 7,280 Scala projects hosted on GitHub, spanning over 8.1M call sites involving implicits and 370.7K implicit declarations across 18.7M lines of Scala code.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360589", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Filip", + "last_name": "Křikava", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Heather", + "last_name": "Miller", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/KrikavaMV19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360586", + "title": "Generating precise error specifications for C: a zero shot learning approach", + "abstract": "In C programs, error specifications, which specify the value range that each function returns to indicate failures, are widely used to check and propagate errors for the sake of reliability and security. Various kinds of C analyzers employ error specifications for different purposes, e.g., to detect error handling bugs, yet a general approach for generating precise specifications is still missing. This limits the applicability of those tools. In this paper, we solve this problem by developing a machine learning-based approach named MLPEx. It generates error specifications by analyzing only the source code, and is thus general. We propose a novel machine learning paradigm based on transfer learning, enabling MLPEx to require only one-time minimal data labeling from us (as the tool developers) and zero manual labeling efforts from users. To improve the accuracy of generated error specifications, MLPEx extracts and exploits project-specific information. We evaluate MLPEx on 10 projects, including 6 libraries and 4 applications. An investigation of 3,443 functions and 17,750 paths reveals that MLPEx generates error specifications with a precision of 91% and a recall of 94%, significantly higher than those of state-of-the-art approaches. To further demonstrate the usefulness of the generated error specifications, we use them to detect 57 bugs in 5 tested projects.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360586", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bai-Jun", + "last_name": "Wu", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "John Peter", + "last_name": "Campora", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Yi", + "last_name": "He", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Alexander", + "last_name": "Schlecht", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WuCHS019", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360585", + "title": "Getafix: learning to fix bugs automatically", + "abstract": "Static analyzers help find bugs early by warning about recurring bug categories. While fixing these bugs still remains a mostly manual task in practice, we observe that fixes for a specific bug category often are repetitive. This paper addresses the problem of automatically fixing instances of common bugs by learning from past fixes. We present Getafix, an approach that produces human-like fixes while being fast enough to suggest fixes in time proportional to the amount of time needed to obtain static analysis results in the first place. Getafix is based on a novel hierarchical clustering algorithm that summarizes fix patterns into a hierarchy ranging from general to specific patterns. Instead of an expensive exploration of a potentially large space of candidate fixes, Getafix uses a simple yet effective ranking technique that uses the context of a code change to select the most appropriate fix for a given bug. Our evaluation applies Getafix to 1,268 bug fixes for six bug categories reported by popular static analyzers for Java, including null dereferences, incorrect API calls, and misuses of particular language constructs. The approach predicts exactly the human-written fix as the top-most suggestion between 12% and 91% of the time, depending on the bug category. The top-5 suggestions contain fixes for 526 of the 1,268 bugs. Moreover, we report on deploying the approach within Facebook, where it contributes to the reliability of software used by billions of people. To the best of our knowledge, Getafix is the first industrially-deployed automated bug-fixing tool that learns fix patterns from past, human-written fixes to produce human-like fixes.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360585", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Bader", + "institution": "Meta (United States)" + }, + { + "first_name": "Andrew", + "last_name": "Scott", + "institution": "Meta (Israel)" + }, + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "Meta (United States)" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "Meta (United States)" + } + ], + "dblp_key": "journals/pacmpl/BaderSP019", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360584", + "title": "Casting about in the dark: an empirical study of cast operations in Java programs", + "abstract": "The main goal of a static type system is to prevent certain kinds of errors from happening at run time. A type system is formulated as a set of constraints that gives any expression or term in a program a well-defined type. Yet mainstream programming languages are endowed with type systems that provide the means to circumvent their constraints through casting. We want to understand how and when developers escape the static type system to use dynamic typing. We empirically study how casting is used by developers in more than seven thousand Java projects. We find that casts are widely used (8.7% of methods contain at least one cast) and that 50% of casts we inspected are not guarded locally to ensure against potential run-time errors. To help us better categorize use cases and thus understand how casts are used in practice, we identify 25 cast-usage patterns---recurrent programming idioms using casts to solve a specific issue. This knowledge can be: (a) a recommendation for current and future language designers to make informed decisions (b) a reference for tool builders, e.g., by providing more precise or new refactoring analyses, (c) a guide for researchers to test new language features, or to carry out controlled programming experiments, and (d) a guide for developers for better practices.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360584", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luis", + "last_name": "Mastrangelo", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Matthias", + "last_name": "Hauswirth", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Nathaniel", + "last_name": "Nystrom", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "journals/pacmpl/MastrangeloHN19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360588", + "title": "Improving bug detection via context-based code representation learning and attention-based neural networks", + "abstract": "Bug detection has been shown to be an effective way to help developers in detecting bugs early, thus, saving much effort and time in software development process. Recently, deep learning-based bug detection approaches have gained successes over the traditional machine learning-based approaches, the rule-based program analysis approaches, and mining-based approaches. However, they are still limited in detecting bugs that involve multiple methods and suffer high rate of false positives. In this paper, we propose a combination approach with the use of contexts and attention neural network to overcome those limitations. We propose to use as the global context the Program Dependence Graph (PDG) and Data Flow Graph (DFG) to connect the method under investigation with the other relevant methods that might contribute to the buggy code. The global context is complemented by the local context extracted from the path on the AST built from the method’s body. The use of PDG and DFG enables our model to reduce the false positive rate, while to complement for the potential reduction in recall, we make use of the attention neural network mechanism to put more weights on the buggy paths in the source code. That is, the paths that are similar to the buggy paths will be ranked higher, thus, improving the recall of our model. We have conducted several experiments to evaluate our approach on a very large dataset with +4.973M methods in 92 different project versions. The results show that our tool can have a relative improvement up to 160% on F-score when comparing with the state-of-the-art bug detection approaches. Our tool can detect 48 true bugs in the list of top 100 reported bugs, which is 24 more true bugs when comparing with the baseline approaches. We also reported that our representation is better suitable for bug detection and relatively improves over the other representations up to 206% in accuracy.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360588", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yi", + "last_name": "Li", + "institution": "New Jersey Institute of Technology" + }, + { + "first_name": "Shaohua", + "last_name": "Wang", + "institution": "New Jersey Institute of Technology" + }, + { + "first_name": "Tien N.", + "last_name": "Nguyen", + "institution": "" + }, + { + "first_name": "Son", + "last_name": "Nguyen", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/LiWNN19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360582", + "title": "DProf: distributed profiler with strong guarantees", + "abstract": "Performance analysis of a distributed system is typically achieved by collecting profiles whose underlying events are timestamped with unsynchronized clocks of multiple machines in the system. To allow comparison of timestamps taken at different machines, several timestamp synchronization algorithms have been developed. However, the inaccuracies associated with these algorithms can lead to inaccuracies in the final results of performance analysis. To address this problem, in this paper, we develop a system for constructing distributed performance profiles called DProf. At the core of DProf is a new timestamp synchronization algorithm, FreeZer, that tightly bounds the inaccuracy in a converted timestamp to a time interval. This not only allows timestamps from different machines to be compared, it also enables maintaining strong guarantees throughout the comparison which can be carefully transformed into guarantees for analysis results. To demonstrate the utility of DProf, we use it to implement dCSP and dCOZ that are accuracy bounded distributed versions of Context Sensitive Profiles and Causal Profiles developed for shared memory systems. While dCSP enables user to ascertain existence of a performance bottleneck, dCOZ estimates the expected performance benefit from eliminating that bottleneck. Experiments with three distributed applications on a cluster of heterogeneous machines validate that inferences via dCSP and dCOZ are highly accurate. Moreover, if FreeZer is replaced by two existing timestamp algorithms (linear regression & convex hull), the inferences provided by dCSP and dCOZ are severely degraded.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360582", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Benavides", + "institution": "University of California, Riverside" + }, + { + "first_name": "Keval", + "last_name": "Vora", + "institution": "Simon Fraser University" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "journals/pacmpl/BenavidesV019", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360593", + "title": "Language-integrated privacy-aware distributed queries", + "abstract": "Distributed query processing is an effective means for processing large amounts of data. To abstract from the technicalities of distributed systems, algorithms for operator placement automatically distribute sequential data queries over the available processing units. However, current algorithms for operator placement focus on performance and ignore privacy concerns that arise when handling sensitive data. We present a new methodology for privacy-aware operator placement that both prevents leakage of sensitive information and improves performance. Crucially, our approach is based on an information-flow type system for data queries to reason about the sensitivity of query subcomputations. Our solution unfolds in two phases. First, placement space reduction generates deployment candidates based on privacy constraints using a syntax-directed transformation driven by the information-flow type system. Second, constraint solving selects the best placement among the candidates based on a cost model that maximizes performance. We verify that our algorithm preserves the sequential behavior of queries and prevents leakage of sensitive data. We implemented the type system and placement algorithm for a new query language SecQL and demonstrate significant performance improvements in benchmarks.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360593", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Mirko", + "last_name": "Köhler", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Daniel", + "last_name": "Sokolowski", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Philipp", + "last_name": "Haller", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "journals/pacmpl/SalvaneschiKSHE19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360590", + "title": "Optimization of swift protocols", + "abstract": "Swift, an increasingly-popular programming language, advocates the use of protocols, which define a set of required methods and properties for conforming types. Protocols are commonly used in Swift programs for abstracting away implementation details; e.g., in a large industrial app from Uber, they are heavily used to enable mock objects for unit testing. Unfortunately, heavy use of protocols can result in significant performance overhead. Beyond the dynamic dispatch often associated with such a feature, Swift allows for both value and reference types to conform to a protocol, leading to significant boxing and unboxing overheads. In this paper, we describe three new optimizations and transformations to reduce the overhead of Swift protocols. Within a procedure, we define LocalVar, a dataflow analysis and transformation to remove both dynamic dispatch and boxing overheads. We also describe Param, which optimizes the case of protocol-typed method parameters using specialization. Finally, we describe SoleType, a transformation that injects casts when a global analysis (like type-hierarchy analysis) discovers some protocol variable must have some concrete type. We also describe how these optimizations work fruitfully together and with existing Swift optimizations to deliver further speedups. We perform elaborate experimentation and demonstrate that our optimizations deliver an average 1.56x speedup on a suite of Swift benchmarks that use protocols. Further, we applied the optimizations to a production iOS Swift application from Uber used by millions of customers daily. For a set of performance spans defined by the developers of the application, the optimized version showed speedups ranging from 6.9% to 55.49%. A version of our optimizations has been accepted as part of the official Swift compiler distribution.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360590", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rajkishore", + "last_name": "Barik", + "institution": "Uber AI (United States)" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "University of California, Riverside" + }, + { + "first_name": "Murali", + "last_name": "Ramanathan", + "institution": "Uber AI (United States)" + }, + { + "first_name": "Milind", + "last_name": "Chabbi", + "institution": "Uber AI (United States)" + } + ], + "dblp_key": "journals/pacmpl/BarikSRC19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360597", + "title": "Certifying graph-manipulating C programs via localizations within data structures", + "abstract": "We develop powerful and general techniques to mechanically verify realistic programs that manipulate heap-represented graphs. These graphs can exhibit well-known organization principles, such as being a directed acyclic graph or a disjoint-forest; alternatively, these graphs can be totally unstructured. The common thread for such structures is that they exhibit deep intrinsic sharing and can be expressed using the language of graph theory. We construct a modular and general setup for reasoning about abstract mathematical graphs and use separation logic to define how such abstract graphs are represented concretely in the heap. We develop a Localize rule that enables modular reasoning about such programs, and show how this rule can support existential quantifiers in postconditions and smoothly handle modified program variables. We demonstrate the generality and power of our techniques by integrating them into the Verified Software Toolchain and certifying the correctness of seven graph-manipulating programs written in CompCert C, including a 400-line generational garbage collector for the CertiCoq project. While doing so, we identify two places where the semantics of C is too weak to define generational garbage collectors of the sort used in the OCaml runtime. Our proofs are entirely machine-checked in Coq.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360597", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shengyi", + "last_name": "Wang", + "institution": "National University of Singapore" + }, + { + "first_name": "Qinxiang", + "last_name": "Cao", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Anshuman", + "last_name": "Mohan", + "institution": "National University of Singapore" + }, + { + "first_name": "Aquinas", + "last_name": "Hobor", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/WangCMH19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360594", + "title": "AutoPandas: neural-backed generators for program synthesis", + "abstract": "Developers nowadays have to contend with a growing number of APIs. While in the long-term they are very useful to developers, many modern APIs have an incredibly steep learning curve, due to their hundreds of functions handling many arguments, obscure documentation, and frequently changing semantics. For APIs that perform data transformations, novices can often provide an I/O example demonstrating the desired transformation, but may be stuck on how to translate it to the API. A programming-by-example synthesis engine that takes such I/O examples and directly produces programs in the target API could help such novices. Such an engine presents unique challenges due to the breadth of real-world APIs, and the often-complex constraints over function arguments. We present a generator-based synthesis approach to contend with these problems. This approach uses a program candidate generator, which encodes basic constraints on the space of programs. We introduce neural-backed operators which can be seamlessly integrated into the program generator. To improve the efficiency of the search, we simply use these operators at non-deterministic decision points, instead of relying on domain-specific heuristics. We implement this technique for the Python pandas library in AutoPandas. AutoPandas supports 119 pandas dataframe transformation functions. We evaluate AutoPandas on 26 real-world benchmarks and find it solves 17 of them.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360594", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rohan", + "last_name": "Bavishi", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Caroline", + "last_name": "Lemieux", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Roy", + "last_name": "Fox", + "institution": "University of California, Irvine" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Ion", + "last_name": "Stoica", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/BavishiLFSS19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360596", + "title": "IntelliMerge: a refactoring-aware software merging technique", + "abstract": "In modern software development, developers rely on version control systems like Git to collaborate in the branch-based development workflow. One downside of this workflow is the conflicts occurred when merging contributions from different developers: these conflicts are tedious and error-prone to be correctly resolved, reducing the efficiency of collaboration and introducing potential bugs. The situation becomes even worse, with the popularity of refactorings in software development and evolution, because current merging tools (usually based on the text or tree structures of source code) are unaware of refactorings. In this paper, we present IntelliMerge, a graph-based refactoring-aware merging algorithm for Java programs. We explicitly enhance this algorithm's ability in detecting and resolving refactoring-related conflicts. Through the evaluation on 1,070 merge scenarios from 10 popular open-source Java projects, we show that IntelliMerge reduces the number of merge conflicts by 58.90% comparing with GitMerge (the prevalent unstructured merging tool) and 11.84% comparing with jFSTMerge (the state-of-the-art semi-structured merging tool) without sacrificing the auto-merging precision (88.48%) and recall (90.22%). Besides, the evaluation of performance shows that IntelliMerge takes 539 milliseconds to process one merge scenario on the median, which indicates its feasibility in real-world applications.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360596", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bo", + "last_name": "Shen", + "institution": "Peking University" + }, + { + "first_name": "Wei", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Haiyan", + "last_name": "Zhao", + "institution": "Peking University" + }, + { + "first_name": "Guangtai", + "last_name": "Liang", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Zhi", + "last_name": "Jin", + "institution": "Peking University" + }, + { + "first_name": "Qianxiang", + "last_name": "Wang", + "institution": "Huawei Technologies (China)" + } + ], + "dblp_key": "journals/pacmpl/ShenZZLJW19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360587", + "title": "Specifying concurrent programs in separation logic: morphisms and simulations", + "abstract": "In addition to pre- and postconditions, program specifications in recent separation logics for concurrency have employed an algebraic structure of resources —a form of state transition systems—to describe the state-based program invariants that must be preserved, and to record the permissible atomic changes to program state. In this paper we introduce a novel notion of resource morphism , i.e. structure-preserving function on resources, and show how to effectively integrate it into separation logic, using an associated notion of morphism-specific simulation . We apply morphisms and simulations to programs verified under one resource, to compositionally adapt them to operate under another resource, thus facilitating proof reuse.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360587", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Software" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "IMDEA Software" + }, + { + "first_name": "Germán Andrés", + "last_name": "Delbianco", + "institution": "Institut de Recherche en Informatique Fondamentale" + }, + { + "first_name": "Ignacio", + "last_name": "Fábregas", + "institution": "IMDEA Software" + } + ], + "dblp_key": "journals/pacmpl/Nanevski0DF19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360592", + "title": "System FR: formalized foundations for the stainless verifier", + "abstract": "We present the design, implementation, and foundation of a verifier for higher-order functional programs with generics and recursive data types. Our system supports proving safety and termination using preconditions, postconditions and assertions. It supports writing proof hints using assertions and recursive calls. To formalize the soundness of the system we introduce System FR, a calculus supporting System F polymorphism, dependent refinement types, and recursive types (including recursion through contravariant positions of function types). Through the use of sized types, System FR supports reasoning about termination of lazy data structures such as streams. We formalize a reducibility argument using the Coq proof assistant and prove the soundness of a type-checker with respect to call-by-value semantics, ensuring type safety and normalization for typeable programs. Our program verifier is implemented as an alternative verification-condition generator for the Stainless tool, which relies on the Inox SMT-based solver backend for automation. We demonstrate the efficiency of our approach by verifying a collection of higher-order functional programs comprising around 14000 lines of polymorphic higher-order Scala code, including graph search algorithms, basic number theory, monad laws, functional data structures, and assignments from popular Functional Programming MOOCs.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360592", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jad", + "last_name": "Hamza", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Nicolas", + "last_name": "Voirol", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/HamzaVK19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360591", + "title": "On the complexity of checking transactional consistency", + "abstract": "Transactions simplify concurrent programming by enabling computations on shared data that are isolated from other concurrent computations and are resilient to failures. Modern databases provide different consistency models for transactions corresponding to different tradeoffs between consistency and availability. In this work, we investigate the problem of checking whether a given execution of a transactional database adheres to some consistency model. We show that consistency models like read committed, read atomic, and causal consistency are polynomial-time checkable while prefix consistency and snapshot isolation are NP-complete in general. These results complement a previous NP-completeness result concerning serializability. Moreover, in the context of NP-complete consistency models, we devise algorithms that are polynomial time assuming that certain parameters in the input executions, e.g., the number of sessions, are fixed. We evaluate the scalability of these algorithms in the context of several production databases.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360591", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ranadeep", + "last_name": "Biswas", + "institution": "Université Paris Cité" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/BiswasE19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360595", + "title": "Ryū revisited: printf floating point conversion", + "abstract": "Ryū Printf is a new algorithm to convert floating-point numbers to decimal strings according to the printf %f, %e, and %g formats: %f generates ‘full’ output (integer part of the input, dot, configurable number of digits), %e generates scientific output (one leading digit, dot, configurable number of digits, exponent), and %g generates the shorter of the two. Ryū Printf is based on the Ryū algorithm, which converts binary floating-point numbers to the shortest equivalent decimal floating-point representation. We provide quantitative evidence that Ryū Printf is between 3.8 and 55 times faster than existing printf implementations. Furthermore, we show that both Ryū and Ryū Printf generalize to arbitrary number bases. This finding implies the existence of a fast algorithm to convert from base-10 to base-2, as long as the maximum precision of the input is known a priori.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360595", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ulf", + "last_name": "Adams", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/Adams19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360598", + "title": "Duet: an expressive higher-order language and linear type system for statically enforcing differential privacy", + "abstract": "During the past decade, differential privacy has become the gold standard for protecting the privacy of individuals. However, verifying that a particular program provides differential privacy often remains a manual task to be completed by an expert in the field. Language-based techniques have been proposed for fully automating proofs of differential privacy via type system design, however these results have lagged behind advances in differentially-private algorithms, leaving a noticeable gap in programs which can be automatically verified while also providing state-of-the-art bounds on privacy. We propose Duet, an expressive higher-order language, linear type system and tool for automatically verifying differential privacy of general-purpose higher-order programs. In addition to general purpose programming, Duet supports encoding machine learning algorithms such as stochastic gradient descent, as well as common auxiliary data analysis tasks such as clipping, normalization and hyperparameter tuning - each of which are particularly challenging to encode in a statically verified differential privacy framework. We present a core design of the Duet language and linear type system, and complete key proofs about privacy for well-typed programs. We then show how to extend Duet to support realistic machine learning applications and recent variants of differential privacy which result in improved accuracy for many practical differentially private algorithms. Finally, we implement several differentially private machine learning algorithms in Duet which have never before been automatically verified by a language-based tool, and we present experimental results which demonstrate the benefits of Duet's language design in terms of accuracy of trained machine learning models.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360598", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph P.", + "last_name": "Near", + "institution": "University of Vermont" + }, + { + "first_name": "David", + "last_name": "Darais", + "institution": "University of Vermont" + }, + { + "first_name": "Chiké", + "last_name": "Abuah", + "institution": "University of Vermont" + }, + { + "first_name": "Tim J.", + "last_name": "Stevens", + "institution": "University of Vermont" + }, + { + "first_name": "Pranav", + "last_name": "Gaddamadugu", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Lun", + "last_name": "Wang", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Neel", + "last_name": "Somani", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mu", + "last_name": "Zhang", + "institution": "University of Utah" + }, + { + "first_name": "Nikhil", + "last_name": "Sharma", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alex", + "last_name": "Shan", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Dawn", + "last_name": "Song", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/NearDASGWSZSSS19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360599", + "title": "Effective lock handling in stateless model checking", + "abstract": "Stateless Model Checking (SMC) is a verification technique for concurrent programs that checks for safety violations by exploring all possible thread interleavings. SMC is usually coupled with Partial Order Reduction (POR), which exploits the independence of instructions to avoid redundant explorations when an equivalent one has already been considered. While effective POR techniques have been developed for many different memory models, they are only able to exploit independence at the instruction level , which makes them unsuitable for programs with coarse-grained synchronization mechanisms such as locks . We present a lock-aware POR algorithm, LAPOR , that exploits independence at both instruction and critical section levels . This enables LAPOR to explore exponentially fewer interleavings than the state-of-the-art techniques for programs that use locks conservatively. Our algorithm is sound, complete, and optimal, and can be used for verifying programs under several different memory models. We implement LAPOR in a tool and show that it can be exponentially faster than the state-of-the-art model checkers.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360599", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/Kokologiannakis19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360600", + "title": "FuzzFactory: domain-specific fuzzing with waypoints", + "abstract": "Coverage-guided fuzz testing has gained prominence as a highly effective method of finding security vulnerabilities such as buffer overflows in programs that parse binary data. Recently, researchers have introduced various specializations to the coverage-guided fuzzing algorithm for different domain-specific testing goals, such as finding performance bottlenecks, generating valid inputs, handling magic-byte comparisons, etc. Each such solution can require non-trivial implementation effort and produces a distinct variant of a fuzzing tool. We observe that many of these domain-specific solutions follow a common solution pattern. In this paper, we present FuzzFactory, a framework for developing domain-specific fuzzing applications without requiring changes to mutation and search heuristics. FuzzFactory allows users to specify the collection of dynamic domain-specific feedback during test execution, as well as how such feedback should be aggregated. FuzzFactory uses this information to selectively save intermediate inputs, called waypoints, to augment coverage-guided fuzzing. Such waypoints always make progress towards domain-specific multi-dimensional objectives. We instantiate six domain-specific fuzzing applications using FuzzFactory: three re-implementations of prior work and three novel solutions, and evaluate their effectiveness on benchmarks from Google's fuzzer test suite. We also show how multiple domains can be composed to perform better than the sum of their parts. For example, we combine domain-specific feedback about strict equality comparisons and dynamic memory allocations, to enable the automatic generation of LZ4 bombs and PNG bombs.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360600", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rohan", + "last_name": "Padhye", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Caroline", + "last_name": "Lemieux", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Laurent", + "last_name": "Simon", + "institution": "Samsung (United States)" + }, + { + "first_name": "Hayawardh", + "last_name": "Vijayakumar", + "institution": "Samsung (United States)" + } + ], + "dblp_key": "journals/pacmpl/PadhyeLSSV19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360601", + "title": "AL: autogenerating supervised learning programs", + "abstract": "We present AL, a novel automated machine learning system that learns to generate new supervised learning pipelines from an existing corpus of supervised learning programs. In contrast to existing automated machine learning tools, which typically implement a search over manually selected machine learning functions and classes, AL learns to identify the relevant classes in an API by analyzing dynamic program traces that use the target machine learning library. AL constructs a conditional probability model from these traces to estimate the likelihood of the generated supervised learning pipelines and uses this model to guide the search to generate pipelines for new datasets. Our evaluation shows that AL can produce successful pipelines for datasets that previous systems fail to process and produces pipelines with comparable predictive performance for datasets that previous systems process successfully.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360601", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "José", + "last_name": "Cambronero", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/CambroneroR19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360602", + "title": "Sound and reusable components for abstract interpretation", + "abstract": "Abstract interpretation is a methodology for defining sound static analysis. Yet, building sound static analyses for modern programming languages is difficult, because these static analyses need to combine sophisticated abstractions for values, environments, stores, etc. However, static analyses often tightly couple these abstractions in the implementation, which not only complicates the implementation, but also makes it hard to decide which parts of the analyses can be proven sound independently from each other. Furthermore, this coupling makes it hard to combine soundness lemmas for parts of the analysis to a soundness proof of the complete analysis. To solve this problem, we propose to construct static analyses modularly from reusable analysis components . Each analysis component encapsulates a single analysis concern and can be proven sound independently from the analysis where it is used. We base the design of our analysis components on arrow transformers , which allows us to compose analysis components. This composition preserves soundness, which guarantees that a static analysis is sound, if all its analysis components are sound. This means that analysis developers do not have to worry about soundness as long as they reuse sound analysis components. To evaluate our approach, we developed a library of 13 reusable analysis components in Haskell. We use these components to define a k -CFA analysis for PCF and an interval and reaching definition analysis for a While language.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360602", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sven", + "last_name": "Keidel", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Johannes Gutenberg University Mainz" + } + ], + "dblp_key": "journals/pacmpl/KeidelE19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360605", + "title": "Dependence-aware, unbounded sound predictive race detection", + "abstract": "Data races are a real problem for parallel software, yet hard to detect. Sound predictive analysis observes a program execution and detects data races that exist in some other, unobserved execution. However, existing predictive analyses miss races because they do not scale to full program executions or do not precisely incorporate data and control dependence. This paper introduces two novel, sound predictive approaches that incorporate data and control dependence and handle full program executions. An evaluation using real, large Java programs shows that these approaches detect more data races than the closest related approaches, thus advancing the state of the art in sound predictive race detection.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360605", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kaan", + "last_name": "Genç", + "institution": "The Ohio State University" + }, + { + "first_name": "Jake", + "last_name": "Roemer", + "institution": "The Ohio State University" + }, + { + "first_name": "XU", + "last_name": "Yu-fan", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + } + ], + "dblp_key": "journals/pacmpl/GencRXB19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360603", + "title": "Design, implementation, and application of GPU-based Java bytecode interpreters", + "abstract": "We present the design and implementation of GVM, the first system for executing Java bytecode entirely on GPUs. GVM is ideal for applications that execute a large number of short-living tasks, which share a significant fraction of their codebase and have similar execution time. GVM uses novel algorithms, scheduling, and data layout techniques to adapt to the massively parallel programming and execution model of GPUs. We apply GVM to generate and execute tests for Java projects. First, we implement a sequence-based test generation on top of GVM and design novel algorithms to avoid redundant test sequences. Second, we use GVM to execute randomly generated test cases. We evaluate GVM by comparing it with two existing Java bytecode interpreters (Oracle JVM and Java Pathfinder), as well as with the Oracle JVM with just-in-time (JIT) compiler, which has been engineered and optimized for over twenty years. Our evaluation shows that sequence-based test generation on GVM outperforms both Java Pathfinder and Oracle JVM interpreter. Additionally, our results show that GVM performs as well as running our parallel sequence-based test generation algorithm using JVM with JIT with many CPU threads. Furthermore, our evaluation on several classes from open-source projects shows that executing randomly generated tests on GVM outperforms sequential execution on JVM interpreter and JVM with JIT.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360603", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ahmet", + "last_name": "Çelik", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Pengyu", + "last_name": "Nie", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Christopher J.", + "last_name": "Rossbach", + "institution": "Kitware (United States)" + }, + { + "first_name": "Milos", + "last_name": "Gligoric", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/CelikNRG19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360604", + "title": "Specification and inference of trace refinement relations", + "abstract": "The modern software engineering process is evolutionary, with commits/patches begetting new versions of code, progressing steadily toward improved systems. In recent years, program analysis and verification tools have exploited version-based reasoning, where new code can be seen in terms of how it has changed from the previous version. When considering program versions, refinement seems a natural fit and, in recent decades, researchers have weakened classical notions of concrete refinement and program equivalence to capture similarities as well as differences between programs. For example, Benton, Yang and others have worked on state-based refinement relations . In this paper, we explore a form of weak refinement based on trace relations rather than state relations. The idea begins by partitioning traces of a program C 1 into trace classes, each identified via a restriction r 1 . For each class, we specify similar behavior in the other program C 2 via a separate restriction r 2 on C 2 . Still, these two trace classes may not yet be equivalent so we further permit a weakening via a binary relation A on traces, that allows one to, for instance disregard unimportant events, relate analogous atomic events, etc. We address several challenges that arise. First, we explore one way to specify trace refinement relations by instantiating the framework to Kleene Algebra with Tests (KAT) due to Kozen. We use KAT intersection for restriction, KAT hypotheses for A , KAT inclusion for refinement, and have proved compositionality. Next, we present an algorithm for automatically synthesizing refinement relations, based on a mixture of semantic program abstraction, KAT inclusion, a custom edit-distance algorithm on counterexamples, and case-analysis on nondeterministic branching. We have proved our algorithm to be sound. Finally, we implemented our algorithm as a tool called Knotical, on top of Interproc and Symkat. We demonstrate promising first steps in synthesizing trace refinement relations across a hand-crafted collection of 37 benchmarks that include changing fragments of array programs, models of systems code, and examples inspired by the thttpd and Merecat web servers.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360604", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Timos", + "last_name": "Antonopoulos", + "institution": "Yale University" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Ton Chanh", + "last_name": "Le", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AntonopoulosKL19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360607", + "title": "Coverage guided, property based testing", + "abstract": "Property-based random testing, exemplified by frameworks such as Haskell's QuickCheck, works by testing an executable predicate (a property) on a stream of randomly generated inputs. Property testing works very well in many cases, but not always. Some properties are conditioned on the input satisfying demanding semantic invariants that are not consequences of its syntactic structure---e.g., that an input list must be sorted or have no duplicates. Most randomly generated inputs fail to satisfy properties with such sparse preconditions, and so are simply discarded. As a result, much of the target system may go untested. We address this issue with a novel technique called coverage guided, property based testing (CGPT). Our approach is inspired by the related area of coverage guided fuzzing, exemplified by tools like AFL. Rather than just generating a fresh random input at each iteration, CGPT can also produce new inputs by mutating previous ones using type-aware, generic mutator operators. The target program is instrumented to track which control flow branches are executed during a run and inputs whose runs expand control-flow coverage are retained for future mutations. This means that, when sparse conditions in the target are satisfied and new coverage is observed, the input that triggered them will be retained and used as a springboard to go further. We have implemented CGPT as an extension to the QuickChick property testing tool for Coq programs; we call our implementation FuzzChick. We evaluate FuzzChick on two Coq developments for abstract machines that aim to enforce flavors of noninterference, which has a (very) sparse precondition. We systematically inject bugs in the machines' checking rules and use FuzzChick to look for counterexamples to the claim that they satisfy a standard noninterference property. We find that vanilla QuickChick almost always fails to find any bugs after a long period of time, as does an earlier proposal for combining property testing and fuzzing. In contrast, FuzzChick often finds them within seconds to minutes. Moreover, FuzzChick is almost fully automatic; although highly tuned, hand-written generators can find the bugs faster, they require substantial amounts of insight and manual effort.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360607", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/Lampropoulos0P19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360608", + "title": "PlanAlyzer: assessing threats to the validity of online experiments", + "abstract": "Online experiments have become a ubiquitous aspect of design and engineering processes within Internet firms. As the scale of experiments has grown, so has the complexity of their design and implementation. In response, firms have developed software frameworks for designing and deploying online experiments. Ensuring that experiments in these frameworks are correctly designed and that their results are trustworthy---referred to as internal validity---can be difficult. Currently, verifying internal validity requires manual inspection by someone with substantial expertise in experimental design. We present the first approach for statically checking the internal validity of online experiments. Our checks are based on well-known problems that arise in experimental design and causal inference. Our analyses target PlanOut, a widely deployed, open-source experimentation framework that uses a domain-specific language to specify and run complex experiments. We have built a tool called PlanAlyzer that checks PlanOut programs for a variety of threats to internal validity, including failures of randomization, treatment assignment, and causal sufficiency. PlanAlyzer uses its analyses to automatically generate contrasts, a key type of information required to perform valid statistical analyses over the results of these experiments. We demonstrate PlanAlyzer's utility on a corpus of PlanOut scripts deployed in production at Facebook, and we evaluate its ability to identify threats to validity on a mutated subset of this corpus. PlanAlyzer has both precision and recall of 92% on the mutated corpus, and 82% of the contrasts it generates match hand-specified data.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360608", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emma", + "last_name": "Tosch", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Eytan", + "last_name": "Bakshy", + "institution": "Meta (United States)" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "David D.", + "last_name": "Jensen", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "J. Eliot B.", + "last_name": "Moss", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "journals/pacmpl/ToschBBJM19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360610", + "title": "Initialize once, start fast: application initialization at build time", + "abstract": "Arbitrary program extension at run time in language-based VMs, e.g., Java's dynamic class loading, comes at a startup cost: high memory footprint and slow warmup. Cloud computing amplifies the startup overhead. Microservices and serverless cloud functions lead to small, self-contained applications that are started often. Slow startup and high memory footprint directly affect the cloud hosting costs, and slow startup can also break service-level agreements. Many applications are limited to a prescribed set of pre-tested classes, i.e., use a closed-world assumption at deployment time. For such Java applications, GraalVM Native Image offers fast startup and stable performance. GraalVM Native Image uses a novel iterative application of points-to analysis and heap snapshotting, followed by ahead-of-time compilation with an optimizing compiler. Initialization code can run at build time, i.e., executables can be tailored to a particular application configuration. Execution at run time starts with a pre-populated heap, leveraging copy-on-write memory sharing. We show that this approach improves the startup performance by up to two orders of magnitude compared to the Java HotSpot VM, while preserving peak performance. This allows Java applications to have a better startup performance than Go applications and the V8 JavaScript VM.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360610", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christian", + "last_name": "Wimmer", + "institution": "Oracle (United States)" + }, + { + "first_name": "Codruţ", + "last_name": "Stancu", + "institution": "Oracle (United States)" + }, + { + "first_name": "Peter", + "last_name": "Höfer", + "institution": "" + }, + { + "first_name": "Vojin", + "last_name": "Jovanović", + "institution": "" + }, + { + "first_name": "Paul", + "last_name": "Wögerer", + "institution": "" + }, + { + "first_name": "Peter B.", + "last_name": "Kessler", + "institution": "Oracle (United States)" + }, + { + "first_name": "Oleg", + "last_name": "Pliss", + "institution": "Oracle (United States)" + }, + { + "first_name": "Thomas", + "last_name": "Würthinger", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/WimmerSHJWKPW19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360609", + "title": "I/O dependent idempotence bugs in intermittent systems", + "abstract": "Intermittently-powered, energy-harvesting devices operate on energy collected from their environment and must operate intermittently as energy is available. Runtime systems for such devices often rely on checkpoints or redo-logs to save execution state between power cycles, causing arbitrary code regions to re-execute on reboot. Any non-idempotent program behavior—behavior that can change on each execution—can lead to incorrect results. This work investigates non-idempotent behavior caused by repeating I/O operations, not addressed by prior work. If such operations affect a control statement or address of a memory update, they can cause programs to take different paths or write to different memory locations on re-executions, resulting in inconsistent memory states. We provide the first characterization of input-dependent idempotence bugs and develop IBIS-S, a program analysis tool for detecting such bugs at compile time, and IBIS-D, a dynamic information flow tracker to detect bugs at runtime. These tools use taint propagation to determine the reach of input. IBIS-S searches for code patterns leading to inconsistent memory updates, while IBIS-D detects concrete memory inconsistencies. We evaluate IBIS on embedded system drivers and applications. IBIS can detect I/O-dependent idempotence bugs, giving few (IBIS-S) or no (IBIS-D) false positives and providing actionable bug reports. These bugs are common in sensor-driven applications and are not fixed by existing intermittent systems.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360609", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Milijana", + "last_name": "Surbatovich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/SurbatovichJL19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360606", + "title": "Trace aware random testing for distributed systems", + "abstract": "Distributed and concurrent applications often have subtle bugs that only get exposed under specific schedules. While these schedules may be found by systematic model checking techniques, in practice, model checkers do not scale to large systems. On the other hand, naive random exploration techniques often require a very large number of runs to find the specific interactions needed to expose a bug. In recent years, several random testing algorithms have been proposed that, on the one hand, exploit state-space reduction strategies from model checking and, on the other, provide guarantees on the probability of hitting bugs of certain kinds. These existing techniques exploit two orthogonal strategies to reduce the state space: partial-order reduction and bug depth. Testing algorithms based on partial order techniques, such as RAPOS or POS, ensure non-redundant exploration of independent interleavings among system events by imposing an equivalence relation on schedules and ideally exploring only one schedule from each equivalence class. Techniques based on bug depth, such as PCT, exploit the empirical observation that many bugs are exposed by the clever scheduling of a small number of key events. They bias the sample space of schedules to only cover all executions of small depth, rather than the much larger space of all schedules. At this point, there is no random testing algorithm that combines the power of both approaches. In this paper, we provide such an algorithm. Our algorithm, trace-aware PCT (taPCTCP), extends and unifies several different algorithms in the random testing literature. It samples the space of low-depth executions by constructing a schedule online, while taking dependencies among events into account. Moreover, the algorithm comes with a theoretical guarantee on the probability of sampling a trace of low depth---the probability grows exponentially with the depth but only polynomially with the number of racy events explored. We further show that the guarantee is optimal among a large class of techniques. We empirically compare our algorithm with several state-of-the-art random testing approaches for concurrent software on two large-scale distributed systems, Zookeeper and Cassandra, and show that our approach is effective in uncovering subtle bugs and usually outperforms related random testing algorithms.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360606", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Burcu Kulahcioglu", + "last_name": "Ozkan", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Simin", + "last_name": "Oraee", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/OzkanMO19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360611", + "title": "Safer smart contract programming with Scilla", + "abstract": "The rise of programmable open distributed consensus platforms based on the blockchain technology has aroused a lot of interest in replicated stateful computations, aka smart contracts. As blockchains are used predominantly in financial applications, smart contracts frequently manage millions of dollars worth of virtual coins. Since smart contracts cannot be updated once deployed, the ability to reason about their correctness becomes a critical task. Yet, the de facto implementation standard, pioneered by the Ethereum platform, dictates smart contracts to be deployed in a low-level language, which renders independent audit and formal verification of deployed code infeasible in practice. We report an ongoing experiment held with an industrial blockchain vendor on designing, evaluating, and deploying Scilla, a new programming language for safe smart contracts. Scilla is positioned as an intermediate-level language, suitable to serve as a compilation target and also as an independent programming framework. Taking System F as a foundational calculus, Scilla offers strong safety guarantees by means of type soundness. It provides a clean separation between pure computational, state-manipulating, and communication aspects of smart contracts, avoiding many known pitfalls due to execution in a byzantine environment. We describe the motivation, design principles, and semantics of Scilla, and we report on Scilla use cases provided by the developer community. Finally, we present a framework for lightweight verification of Scilla programs, and showcase it with two domain-specific analyses on a suite of real-world use cases.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360611", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + }, + { + "first_name": "Vaivaswatha", + "last_name": "Nagaraj", + "institution": "" + }, + { + "first_name": "Jacob", + "last_name": "Johannsen", + "institution": "" + }, + { + "first_name": "Amrit", + "last_name": "Kumar", + "institution": "" + }, + { + "first_name": "Anton", + "last_name": "Trunov", + "institution": "" + }, + { + "first_name": "Ken Chan Guan", + "last_name": "Hao", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/SergeyNJ0TH19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360612", + "title": "ApproxHPVM: a portable compiler IR for accuracy-aware optimizations", + "abstract": "We propose ApproxHPVM, a compiler IR and system designed to enable accuracy-aware performance and energy tuning on heterogeneous systems with multiple compute units and approximation methods. ApproxHPVM automatically translates end-to-end application-level quality metrics into accuracy requirements for individual operations. ApproxHPVM uses a hardware-agnostic accuracy-tuning phase to do this translation that provides greater portability across heterogeneous hardware platforms and enables future capabilities like accuracy-aware dynamic scheduling and design space exploration. ApproxHPVM incorporates three main components: (a) a compiler IR with hardware-agnostic approximation metrics, (b) a hardware-agnostic accuracy-tuning phase to identify error-tolerant computations, and (c) an accuracy-aware hardware scheduler that maps error-tolerant computations to approximate hardware components. As ApproxHPVM does not incorporate any hardware-specific knowledge as part of the IR, it can serve as a portable virtual ISA that can be shipped to all kinds of hardware platforms. We evaluate our framework on nine benchmarks from the deep learning domain and five image processing benchmarks. Our results show that our framework can offload chunks of approximable computations to special-purpose accelerators that provide significant gains in performance and energy, while staying within user-specified application-level quality metrics with high probability. Across the 14 benchmarks, we observe from 1-9x performance speedups and 1.1-11.3x energy reduction for very small reductions in accuracy.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360612", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hashim", + "last_name": "Sharif", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Prakalp", + "last_name": "Srivastava", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Muhammad", + "last_name": "Huzaifa", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Maria", + "last_name": "Kotsifakou", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Keyur", + "last_name": "Joshi", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Yasmin", + "last_name": "Sarita", + "institution": "Cornell University" + }, + { + "first_name": "Nathan", + "last_name": "Zhao", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Sarita V.", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/SharifSHKJSZAMA19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360613", + "title": "Reflection-aware static regression test selection", + "abstract": "Regression test selection (RTS) aims to speed up regression testing by rerunning only tests that are affected by code changes. RTS can be performed using static or dynamic analysis techniques. Our prior study showed that static and dynamic RTS perform similarly for medium-sized Java projects. However, the results of that prior study also showed that static RTS can be unsafe, missing to select tests that dynamic RTS selects, and that reflection was the only cause of unsafety observed among the evaluated projects. In this paper, we investigate five techniques—three purely static techniques and two hybrid static-dynamic techniques—that aim to make static RTS safe with respect to reflection. We implement these reflection-aware (RA) techniques by extending the reflection-unaware (RU) class-level static RTS technique in a tool called STARTS. To evaluate these RA techniques, we compare their end-to-end times with RU, and with RetestAll, which reruns all tests after every code change. We also compare safety and precision of the RA techniques with Ekstazi, a state-of-the-art dynamic RTS technique; precision is a measure of unaffected tests selected. Our evaluation on 1173 versions of 24 open-source Java projects shows negative results. The RA techniques improve the safety of RU but at very high costs. The purely static techniques are safe in our experiments but decrease the precision of RU, with end-to-end time at best 85.8% of RetestAll time, versus 69.1% for RU. One hybrid static-dynamic technique improves the safety of RU but at high cost, with end-to-end time that is 91.2% of RetestAll. The other hybrid static-dynamic technique provides better precision, is safer than RU, and incurs lower end-to-end time—75.8% of RetestAll, but it can still be unsafe in the presence of test-order dependencies. Our study highlights the challenges involved in making static RTS safe with respect to reflection.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360613", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "August", + "last_name": "Shi", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Milica", + "last_name": "Hadzi-Tanovic", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Lingming", + "last_name": "Zhang", + "institution": "" + }, + { + "first_name": "Darko", + "last_name": "Marinov", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Owolabi", + "last_name": "Legunsen", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/ShiHZML19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360614", + "title": "Automatic and scalable detection of logical errors in functional programming assignments", + "abstract": "We present a new technique for automatically detecting logical errors in functional programming assignments. Compared to syntax or type errors, detecting logical errors remains largely a manual process that requires hand-made test cases. However, designing proper test cases is nontrivial and involves a lot of human effort. Furthermore, manual test cases are unlikely to catch diverse errors because instructors cannot predict all corner cases of diverse student submissions. We aim to reduce this burden by automatically generating test cases for functional programs. Given a reference program and a student's submission, our technique generates a counter-example that captures the semantic difference of the two programs without any manual effort. The key novelty behind our approach is the counter-example generation algorithm that combines enumerative search and symbolic verification techniques in a synergistic way. The experimental results show that our technique is able to detect 88 more errors not found by mature test cases that have been improved over the past few years, and performs better than the existing property-based testing techniques. We also demonstrate the usefulness of our technique in the context of automated program repair, where it effectively helps to eliminate test-suite-overfitted patches.", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360614", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dowon", + "last_name": "Song", + "institution": "Korea University" + }, + { + "first_name": "Myungho", + "last_name": "Lee", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/SongLO19", + "venue": "oopsla", + "year": 2019 + }, + { + "paper_id": "10.1145/3360615", + "title": "Detecting nondeterministic payment bugs in Ethereum smart contracts", + "abstract": "The term “smart contracts” has become ubiquitous to describe an enormous number of programs uploaded to the popular Ethereum blockchain system. Despite rapid growth of the smart contract ecosystem, errors and exploitations have been constantly reported from online contract systems, which has put financial stability at risk with losses totaling millions of US dollars. Most existing research focuses on pinpointing specific types of vulnerabilities using known patterns. However, due to the lack of awareness of the inherent nondeterminism in the Ethereum blockchain system and how it affects the funds transfer of smart contracts, there can be unknown vulnerabilities that may be exploited by attackers to access numerous online smart contracts. In this paper, we introduce a methodical approach to understanding the inherent nondeterminism in the Ethereum blockchain system and its (unwanted) influence on contract payments. We show that our new focus on nondeterminism-related smart contract payment bugs captures the root causes of many common vulnerabilities without relying on any known patterns and also encompasses recently disclosed issues that are not handled by existing research. To do so, we introduce techniques to systematically model components in the contract execution context and to expose various nondeterministic factors that are not yet fully understood. We further study how these nondeterministic factors impact contract funds transfer using information flow tracking. The technical challenge of detecting nondeterministic payments lies in discovering the contract global variables subtly affected by read-write hazards because of unpredictable transaction scheduling and external callee behavior. We show how to augment and instrument a contract program into a representation that simulates the execution of a large subset of the contract behavior. The instrumented code is then analyzed to flag nondeterministic global variables using off-the-shelf model checkers. We implement the proposed techniques as a practical tool named NPChecker (Nondeterministic Payment Checker) and evaluate it on 30K online contracts (3,075 distinct) collected from the Ethereum mainnet. NPChecker has successfully detected nondeterministic payments in 1,111 online contracts with reasonable cost. Further investigation reports high precision of NPChecker (only four false positives in a manual study of 50 contracts). We also show that NPChecker unveils contracts vulnerable to recently-disclosed attack vectors. NPChecker can identify all six new vulnerabilities or variants of common smart contract vulnerabilities that are missed by existing research relying on a “contract vulnerability checklist.”", + "date": "2019-10-10", + "link": "https://doi.org/10.1145/3360615", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shuai", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Chengyu", + "last_name": "Zhang", + "institution": "East China Normal University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/WangZS19", + "venue": "oopsla", + "year": 2019 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2020.json b/data/pl_conferences/oopsla/2020.json new file mode 100644 index 0000000..185d43e --- /dev/null +++ b/data/pl_conferences/oopsla/2020.json @@ -0,0 +1,3589 @@ +[ + { + "paper_id": "10.1145/3428194", + "title": "Effects as capabilities: effect handlers and lightweight effect polymorphism", + "abstract": "Effect handlers have recently gained popularity amongst programming language researchers. Existing type- and effect systems for effect handlers are often complicated and potentially hinder a wide-spread adoption. We present the language Effekt with the goal to close the gap between research languages with effect handlers and languages for working programmers. The design of Effekt revolves around a different view of effects and effect types. Traditionally, effect types express which side effects a computation might have. In Effekt, effect types express which capabilities a computation requires from its context. While this new point in the design space of effect systems impedes reasoning about purity, we demonstrate that it simplifies the treatment of effect polymorphism and the related issues of effect parametricity and effect encapsulation. To guarantee effect safety, we separate functions from values and treat all functions as second-class. We define the semantics of Effekt as a translation to System Xi, a calculus in explicit capability-passing style.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428194", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/BrachthauserSO20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428201", + "title": "Assertion-based optimization of Quantum programs", + "abstract": "Quantum computers promise to perform certain computations exponentially faster than any classical device. Precise control over their physical implementation and proper shielding from unwanted interactions with the environment become more difficult as the space/time volume of the computation grows. Code optimization is thus crucial in order to reduce resource requirements to the greatest extent possible. Besides manual optimization, previous work has adapted classical methods such as constant-folding and common subexpression elimination to the quantum domain. However, such classically-inspired methods fail to exploit certain optimization opportunities across subroutine boundaries, limiting the effectiveness of software reuse. To address this insufficiency, we introduce an optimization methodology which employs annotations that describe how subsystems are entangled in order to exploit these optimization opportunities. We formalize our approach, prove its correctness, and present benchmarks: Without any prior manual optimization, our methodology is able to reduce, e.g., the qubit requirements of a 64-bit floating-point subroutine by 34×.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428201", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Häner", + "institution": "ETH Zurich" + }, + { + "first_name": "Torsten", + "last_name": "Hoefler", + "institution": "ETH Zurich" + }, + { + "first_name": "Matthias", + "last_name": "Troyer", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/HanerHT20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428196", + "title": "Proving highly-concurrent traversals correct", + "abstract": "Modern highly-concurrent search data structures, such as search trees, obtain multi-core scalability and performance by having operations traverse the data structure without any synchronization. As a result, however, these algorithms are notoriously difficult to prove linearizable, which requires identifying a point in time in which the traversal's result is correct. The problem is that traversing the data structure as it undergoes modifications leads to complex behaviors, necessitating intricate reasoning about all interleavings of reads by traversals and writes mutating the data structure. In this paper, we present a general proof technique for proving unsynchronized traversals correct in a significantly simpler manner, compared to typical concurrent reasoning and prior proof techniques. Our framework relies only on sequential properties of traversals and on a conceptually simple and widely-applicable condition about the ways an algorithm's writes mutate the data structure. Establishing that a target data structure satisfies our condition requires only simple concurrent reasoning, without considering interactions of writes and reads. This reasoning can be further simplified by using our framework. To demonstrate our technique, we apply it to prove several interesting and challenging concurrent binary search trees: the logical-ordering AVL tree, the Citrus tree, and the full contention-friendly tree. Both the logical-ordering tree and the full contention-friendly tree are beyond the reach of previous approaches targeted at simplifying linearizability proofs.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428196", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yotam M. Y.", + "last_name": "Feldman", + "institution": "Tel Aviv University" + }, + { + "first_name": "Artem", + "last_name": "Khyzha", + "institution": "Tel Aviv University" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Adam", + "last_name": "Morrison", + "institution": "Tel Aviv University" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "IMDEA Food" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/FeldmanKE0NRS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428204", + "title": "How do programmers use unsafe rust?", + "abstract": "Rust’s ownership type system enforces a strict discipline on how memory locations are accessed and shared. This discipline allows the compiler to statically prevent memory errors, data races, inadvertent side effects through aliasing, and other errors that frequently occur in conventional imperative programs. However, the restrictions imposed by Rust’s type system make it difficult or impossible to implement certain designs, such as data structures that require aliasing (e.g. doubly-linked lists and shared caches). To work around this limitation, Rust allows code blocks to be declared as unsafe and thereby exempted from certain restrictions of the type system, for instance, to manipulate C-style raw pointers. Ensuring the safety of unsafe code is the responsibility of the programmer. However, an important assumption of the Rust language, which we dub the Rust hypothesis , is that programmers use Rust by following three main principles: use unsafe code sparingly, make it easy to review, and hide it behind a safe abstraction such that client code can be written in safe Rust. Understanding how Rust programmers use unsafe code and, in particular, whether the Rust hypothesis holds is essential for Rust developers and testers, language and library designers, as well as tool developers. This paper studies empirically how unsafe code is used in practice by analysing a large corpus of Rust projects to assess the validity of the Rust hypothesis and to classify the purpose of unsafe code. We identify queries that can be answered by automatically inspecting the program’s source code, its intermediate representation MIR, as well as type information provided by the Rust compiler; we complement the results by manual code inspection. Our study supports the Rust hypothesis partially: While most unsafe code is simple and well-encapsulated, unsafe features are used extensively, especially for interoperability with other languages.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428204", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vytautas", + "last_name": "Astrauskas", + "institution": "ETH Zurich" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "ETH Zurich" + }, + { + "first_name": "Federico", + "last_name": "Poli", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/AstrauskasMP0S20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428197", + "title": "Certified and efficient instruction scheduling: application to interlocked VLIW processors", + "abstract": "CompCert is a moderately optimizing C compiler with a formal, machine-checked, proof of correctness: after successful compilation, the assembly code has a behavior faithful to the source code. Previously, it only supported target instruction sets with sequential semantics, and did not attempt reordering instructions for optimization. We present here a CompCert backend for a VLIW core ( i.e. with explicit parallelism at the instruction level), the first CompCert backend providing scalable and efficient instruction scheduling. Furthermore, its highly modular implementation can be easily adapted to other VLIW or non-VLIW pipelined processors.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428197", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cyril", + "last_name": "Six", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Sylvain", + "last_name": "Boulmé", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "David", + "last_name": "Monniaux", + "institution": "Institut polytechnique de Grenoble" + } + ], + "dblp_key": "journals/pacmpl/SixBM20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428198", + "title": "Enabling accuracy-aware Quantum compilers using symbolic resource estimation", + "abstract": "Approximation errors must be taken into account when compiling quantum programs into a low-level gate set. We present a methodology that tracks such errors automatically and then optimizes accuracy parameters to guarantee a specified overall accuracy while aiming to minimize the implementation cost in terms of quantum gates. The core idea of our approach is to extract functions that specify the optimization problem directly from the high-level description of the quantum program. Then, custom compiler passes optimize these functions, turning them into (near-)symbolic expressions for (1) the total error and (2) the implementation cost (e.g., total quantum gate count). All unspecified parameters of the quantum program will show up as variables in these expressions, including accuracy parameters. After solving the corresponding optimization problem, a circuit can be instantiated from the found solution. We develop two prototype implementations, one in C++ based on Clang/LLVM, and another using the Q# compiler infrastructure. We benchmark our prototypes on typical quantum computing programs, including the quantum Fourier transform, quantum phase estimation, and Shor's algorithm.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428198", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Giulia", + "last_name": "Meuli", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Mathias", + "last_name": "Soeken", + "institution": "Microsoft (Switzerland)" + }, + { + "first_name": "Martin", + "last_name": "Roetteler", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Thomas", + "last_name": "Häner", + "institution": "Microsoft (Switzerland)" + } + ], + "dblp_key": "journals/pacmpl/MeuliSRH20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428208", + "title": "Scaling exact inference for discrete probabilistic programs", + "abstract": "Probabilistic programming languages (PPLs) are an expressive means of representing and reasoning about probabilistic models. The computational challenge of probabilistic inference remains the primary roadblock for applying PPLs in practice. Inference is fundamentally hard, so there is no one-size-fits all solution. In this work, we target scalable inference for an important class of probabilistic programs: those whose probability distributions are discrete . Discrete distributions are common in many fields, including text analysis, network verification, artificial intelligence, and graph analysis, but they prove to be challenging for existing PPLs. We develop a domain-specific probabilistic programming language called Dice that features a new approach to exact discrete probabilistic program inference. Dice exploits program structure in order to factorize inference, enabling us to perform exact inference on probabilistic programs with hundreds of thousands of random variables. Our key technical contribution is a new reduction from discrete probabilistic programs to weighted model counting (WMC). This reduction separates the structure of the distribution from its parameters, enabling logical reasoning tools to exploit that structure for probabilistic inference. We (1) show how to compositionally reduce Dice inference to WMC, (2) prove this compilation correct with respect to a denotational semantics, (3) empirically demonstrate the performance benefits over prior approaches, and (4) analyze the types of structure that allow Dice to scale to large probabilistic programs.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428208", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Steven", + "last_name": "Holtzen", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Guy Van den", + "last_name": "Broeck", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/HoltzenBM20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428199", + "title": "Semiring optimizations: dynamic elision of expressions with identity and absorbing elements", + "abstract": "This paper describes a compiler optimization to eliminates dynamic occurrences of expressions in the format a ← a ⊕ b ⊗ c . The operation ⊕ must admit an identity element z , such that a ⊕ z = a . Also, z must be the absorbing element of ⊗, such that b ⊗ z = z ⊗ c = z . Semirings where ⊕ is the additive operator and ⊗ is the multiplicative operator meet this contract. This pattern is common in high-performance benchmarks—its canonical representative being the multiply-add operation a ← a + b × c . However, several other expressions involving arithmetic and logic operations satisfy the required algebra. We show that the runtime elimination of such assignments can be implemented in a performance-safe way via online profiling. The elimination of dynamic redundancies involving identity and absorbing elements in 35 programs of the LLVM test suite that present semiring patterns brings an average speedup of 1.19x (total optimized time over total unoptimized time) on top of clang -O3. When projected onto the entire test suite (259 programs) the optimization leads to a speedup of 1.025x. Once added onto clang, semiring optimizations approximates it to TACO, a specialized tensor compiler.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428199", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guilherme", + "last_name": "Leobas", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "journals/pacmpl/LeobasP20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428195", + "title": "A systematic approach to deriving incremental type checkers", + "abstract": "Static typing can guide programmers if feedback is immediate. Therefore, all major IDEs incrementalize type checking in some way. However, prior approaches to incremental type checking are often specialized and hard to transfer to new type systems. In this paper, we propose a systematic approach for deriving incremental type checkers from textbook-style type system specifications. Our approach is based on compiling inference rules to Datalog, a carefully limited logic programming language for which incremental solvers exist. The key contribution of this paper is to discover an encoding of the infinite typing relation as a finite Datalog relation in a way that yields efficient incremental updates. We implemented the compiler as part of a type system DSL and show that it supports simple types, some local type inference, operator overloading, universal types, and iso-recursive types.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428195", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "André", + "last_name": "Pacak", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Tamás", + "last_name": "Szabó", + "institution": "Johannes Gutenberg University Mainz" + } + ], + "dblp_key": "journals/pacmpl/PacakES20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428203", + "title": "Automated policy synthesis for system call sandboxing", + "abstract": "System call whitelisting is a powerful sandboxing approach that can significantly reduce the capabilities of an attacker if an application is compromised. Given a policy that specifies which system calls can be invoked with what arguments, a sandboxing framework terminates any execution that violates the policy. While this mechanism greatly reduces the attack surface of a system, manually constructing these policies is time-consuming and error-prone. As a result, many applications —including those that take untrusted user input— opt not to use a system call sandbox. Motivated by this problem, we propose a technique for automatically constructing system call whitelisting policies for a given application and policy DSL. Our method combines static code analysis and program synthesis to construct sound and precise policies that never erroneously terminate the application, while restricting the program’s system call usage as much as possible. We have implemented our approach in a tool called Abhayaand experimentally evaluate it 493 Linux and OpenBSD applications by automatically synthesizing Seccomp-bpfand Pledgepolicies. Our experimental results indicate that Abhayacan efficiently generate useful and precise sandboxes for real-world applications.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428203", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Hovav", + "last_name": "Shacham", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/Pailoor0SD20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428202", + "title": "Multiparty motion coordination: from choreographies to robotics programs", + "abstract": "We present a programming model and typing discipline for complex multi-robot coordination programming. Our model encompasses both synchronisation through message passing and continuous-time dynamic motion primitives in physical space. We specify continuous-time motion primitives in an assume-guarantee logic that ensures compatibility of motion primitives as well as collision freedom. We specify global behaviour of programs in a choreographic type system that extends multiparty session types with jointly executed motion primitives, predicated refinements, as well as a separating conjunction that allows reasoning about subsets of interacting robots. We describe a notion of well-formedness for global types that ensures motion and communication can be correctly synchronised and provide algorithms for checking well-formedness, projecting a type, and local type checking. A well-typed program is communication safe , motion compatible , and collision free . Our type system provides a compositional approach to ensuring these properties. We have implemented our model on top of the ROS framework. This allows us to program multi-robot coordination scenarios on top of commercial and custom robotics hardware platforms. We show through case studies that we can model and statically verify quite complex manoeuvres involving multiple manipulators and mobile robots---such examples are beyond the scope of previous approaches.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428202", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + }, + { + "first_name": "Damien", + "last_name": "Zufferey", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/MajumdarYZ20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428200", + "title": "Can advanced type systems be usable? An empirical study of ownership, assets, and typestate in Obsidian", + "abstract": "Some blockchain programs (smart contracts) have included serious security vulnerabilities. Obsidian is a new typestate-oriented programming language that uses a strong type system to rule out some of these vulnerabilities. Although Obsidian was designed to promote usability to make it as easy as possible to write programs, strong type systems can cause a language to be difficult to use. In particular, ownership, typestate, and assets, which Obsidian uses to provide safety guarantees, have not seen broad adoption together in popular languages and result in significant usability challenges. We performed an empirical study with 20 participants comparing Obsidian to Solidity, which is the language most commonly used for writing smart contracts today. We observed that Obsidian participants were able to successfully complete more of the programming tasks than the Solidity participants. We also found that the Solidity participants commonly inserted asset-related bugs, which Obsidian detects at compile time.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428200", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Coblenz", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brad A.", + "last_name": "Myers", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Joshua", + "last_name": "Sunshine", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/CoblenzAMS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428207", + "title": "Handling bidirectional control flow", + "abstract": "Pressed by the difficulty of writing asynchronous, event-driven code, mainstream languages have recently been building in support for a variety of advanced control-flow features. Meanwhile, experimental language designs have suggested effect handlers as a unifying solution to programmer-defined control effects, subsuming exceptions, generators, and async–await. However, despite these trends, complex control flow—in particular, control flow that exhibits a bidirectional pattern—remains challenging to manage. We introduce bidirectional algebraic effects, a new programming abstraction that supports bidirectional control transfer in a more natural way. Handlers of bidirectional effects can raise further effects to transfer control back to the site where the initiating effect was raised, and can use themselves to handle their own effects. We present applications of this expressive power, which falls out naturally as we push toward the unification of effectful programming with object-oriented programming. We pin down the mechanism and the unification formally using a core language that makes generalizations to effect operations and effect handlers. The usual propagation semantics of control effects such as exceptions conflicts with modular reasoning in the presence of effect polymorphism—it breaks parametricity. Bidirectionality exacerbates the problem. Hence, we set out to show the core language, which builds on the existing tunneling semantics for algebraic effects, is not only type-safe (no effects go unhandled), but also abstraction-safe (no effects are accidentally handled). We devise a step-indexed logical-relations model, and construct its parametricity and soundness proofs. These core results are fully mechanized in Coq. While a full-featured compiler is left to future work, experiments show that as a first-class language feature, bidirectional handlers can be implemented efficiently.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428207", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "University of St. Gallen" + }, + { + "first_name": "Andrew C.", + "last_name": "Myers", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/ZhangSM20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428206", + "title": "Mossad: defeating software plagiarism detection", + "abstract": "Automatic software plagiarism detection tools are widely used in educational settings to ensure that submitted work was not copied. These tools have grown in use together with the rise in enrollments in computer science programs and the widespread availability of code on-line. Educators rely on the robustness of plagiarism detection tools; the working assumption is that the effort required to evade detection is as high as that required to actually do the assigned work. This paper shows this is not the case. It presents an entirely automatic program transformation approach, MOSSAD, that defeats popular software plagiarism detection tools. MOSSAD comprises a framework that couples techniques inspired by genetic programming with domain-specific knowledge to effectively undermine plagiarism detectors. MOSSAD is effective at defeating four plagiarism detectors, including Moss and JPlag. MOSSAD is both fast and effective: it can, in minutes, generate modified versions of programs that are likely to escape detection. More insidiously, because of its non-deterministic approach, MOSSAD can, from a single program, generate dozens of variants, which are classified as no more suspicious than legitimate assignments. A detailed study of MOSSAD across a corpus of real student assignments demonstrates its efficacy at evading detection. A user study shows that graduate student assistants consistently rate MOSSAD-generated code as just as readable as authentic student code. This work motivates the need for both research on more robust plagiarism detection tools and greater integration of naturally plagiarism-resistant methodologies like code review into computer science education.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428206", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Breanna", + "last_name": "Devore-McDonald", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Emery D.", + "last_name": "Berger", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "journals/pacmpl/Devore-McDonald20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428205", + "title": "Learning semantic program embeddings with graph interval neural network", + "abstract": "Learning distributed representations of source code has been a challenging task for machine learning models. Earlier works treated programs as text so that natural language methods can be readily applied. Unfortunately, such approaches do not capitalize on the rich structural information possessed by source code. Of late, Graph Neural Network (GNN) was proposed to learn embeddings of programs from their graph representations. Due to the homogeneous (i.e. do not take advantage of the program-specific graph characteristics) and expensive (i.e. require heavy information exchange among nodes in the graph) message-passing procedure, GNN can suffer from precision issues, especially when dealing with programs rendered into large graphs. In this paper, we present a new graph neural architecture, called Graph Interval Neural Network (GINN), to tackle the weaknesses of the existing GNN. Unlike the standard GNN, GINN generalizes from a curated graph representation obtained through an abstraction method designed to aid models to learn. In particular, GINN focuses exclusively on intervals (generally manifested in looping construct) for mining the feature representation of a program, furthermore, GINN operates on a hierarchy of intervals for scaling the learning to large graphs. We evaluate GINN for two popular downstream applications: variable misuse prediction and method name prediction. Results show in both cases GINN outperforms the state-of-the-art models by a comfortable margin. We have also created a neural bug detector based on GINN to catch null pointer deference bugs in Java code. While learning from the same 9,000 methods extracted from 64 projects, GINN-based bug detector significantly outperforms GNN-based bug detector on 13 unseen test projects. Next, we deploy our trained GINN-based bug detector and Facebook Infer, arguably the state-of-the-art static analysis tool, to scan the codebase of 20 highly starred projects on GitHub. Through our manual inspection, we confirm 38 bugs out of 102 warnings raised by GINN-based bug detector compared to 34 bugs out of 129 warnings for Facebook Infer. We have reported 38 bugs GINN caught to developers, among which 11 have been fixed and 12 have been confirmed (fix pending). GINN has shown to be a general, powerful deep neural network for learning precise, semantic program embeddings.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428205", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yu", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "Visa (United States)" + }, + { + "first_name": "Fengjuan", + "last_name": "Gao", + "institution": "Nanjing University" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/WangWGW20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428193", + "title": "Fixpoints for the masses: programming with first-class Datalog constraints", + "abstract": "Datalog is a declarative logic programming language that has been used in a variety of applications, including big-data analytics, language processing, networking and distributed systems, and program analysis. In this paper, we propose first-class Datalog constraints as a mechanism to construct, compose, and solve Datalog programs at run time. The benefits are twofold: We gain the full power of a functional programming language to operate on Datalog constraints-as-values, while simultaneously we can use Datalog where it really shines: to declaratively express and solve fixpoint problems. We present an extension of the lambda calculus with first-class Datalog constraints, including its semantics and a type system with row polymorphism based on Hindley-Milner. We prove soundness of the type system and implement it as an extension of the Flix programming language.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428193", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/MadsenL20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428209", + "title": "Formulog: Datalog for SMT-based static analysis", + "abstract": "Satisfiability modulo theories (SMT) solving has become a critical part of many static analyses, including symbolic execution, refinement type checking, and model checking. We propose Formulog, a domain-specific language that makes it possible to write a range of SMT-based static analyses in a way that is both close to their formal specifications and amenable to high-level optimizations and efficient evaluation. Formulog extends the logic programming language Datalog with a first-order functional language and mechanisms for representing and reasoning about SMT formulas; a novel type system supports the construction of expressive formulas, while ensuring that neither normal evaluation nor SMT solving goes wrong. Our case studies demonstrate that a range of SMT-based analyses can naturally and concisely be encoded in Formulog, and that — thanks to this encoding — high-level Datalog-style optimizations can be automatically and advantageously applied to these analyses.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428209", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Bembenek", + "institution": "Harvard University Press" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Pomona College" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "journals/pacmpl/Bembenek0C20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428210", + "title": "Precise inference of expressive units of measurement types", + "abstract": "Ensuring computations are unit-wise consistent is an important task in software development. Numeric computations are usually performed with primitive types instead of abstract data types, which results in very weak static guarantees about correct usage and conversion of units. This paper presents PUnits, a pluggable type system for expressive units of measurement types and a precise, whole-program inference approach for these types. PUnits can be used in three modes: (1) modularly check the correctness of a program, (2) ensure a possible unit typing exists, and (3) annotate a program with units. Annotation mode allows human inspection and is essential since having a valid typing does not guarantee that the inferred specification expresses design intent. PUnits is the first units type system with this capability. Compared to prior work, PUnits strikes a novel balance between expressiveness, inference complexity, and annotation effort. We implement PUnits for Java and evaluate it by specifying the correct usage of frequently used JDK methods. We analyze 234k lines of code from eight open-source scientific computing projects with PUnits. We compare PUnits against an encapsulation-based units API (the javax.measure package) and discovered unit errors that the API failed to find. PUnits infers 90 scientific units for five of the projects and generates well-specified applications. The experiments show that PUnits is an effective, sound, and scalable alternative to using encapsulation-based units APIs, enabling Java developers to reap the performance benefits of using primitive types instead of abstract data types for unit-wise consistent scientific computations.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428210", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tongtong", + "last_name": "Xiang", + "institution": "University of Waterloo" + }, + { + "first_name": "Jeff Y.", + "last_name": "Luo", + "institution": "University of Waterloo" + }, + { + "first_name": "Werner", + "last_name": "Dietl", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/XiangLD20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428211", + "title": "WATCHER: in-situ failure diagnosis", + "abstract": "Diagnosing software failures is important but notoriously challenging. Existing work either requires extensive manual effort, imposing a serious privacy concern (for in-production systems), or cannot report sufficient information for bug fixes. This paper presents a novel diagnosis system, named WATCHER, that can pinpoint root causes of program failures within the failing process (\"in-situ\"), eliminating the privacy concern. It combines identical record-and-replay, binary analysis, dynamic analysis, and hardware support together to perform the diagnosis without human involvement. It further proposes two optimizations to reduce the diagnosis time and diagnose failures with control flow hijacks. WATCHER can be easily deployed, without requiring custom hardware or operating system, program modification, or recompilation. We evaluate WATCHER with 24 program failures in real-world deployed software, including large-scale applications, such as Memcached, SQLite, and OpenJPEG. Experimental results show that WATCHER can accurately identify the root causes in only a few seconds.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428211", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hongyu", + "last_name": "Liu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Sam", + "last_name": "Silvestro", + "institution": "The University of Texas at San Antonio" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jian", + "last_name": "Huang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Tongping", + "last_name": "Liu", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "journals/pacmpl/LiuSZHL20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428212", + "title": "A model for detecting faults in build specifications", + "abstract": "Incremental and parallel builds are crucial features of modern build systems. Parallelism enables fast builds by running independent tasks simultaneously, while incrementality saves time and computing resources by processing the build operations that were affected by a particular code change. Writing build definitions that lead to error-free incremental and parallel builds is a challenging task. This is mainly because developers are often unable to predict the effects of build operations on the file system and how different build operations interact with each other. Faulty build scripts may seriously degrade the reliability of automated builds, as they cause build failures, and non-deterministic and incorrect outputs. To reason about arbitrary build executions, we present BuildFS, a generally-applicable model that takes into account the specification (as declared in build scripts) and the actual behavior (low-level file system operation) of build operations. We then formally define different types of faults related to incremental and parallel builds in terms of the conditions under which a file system operation violates the specification of a build operation. Our testing approach, which relies on the proposed model, analyzes the execution of single full build, translates it into BuildFS, and uncovers faults by checking for corresponding violations. We evaluate the effectiveness, efficiency, and applicability of our approach by examining 612 Make and Gradle projects. Notably, thanks to our treatment of build executions, our method is the first to handle JVM-oriented build systems. The results indicate that our approach is (1) able to uncover several important issues (247 issues found in 47 open-source projects have been confirmed and fixed by the upstream developers), and (2) much faster than a state-of-the-art tool for Make builds (the median and average speedup is 39X and 74X respectively).", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428212", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thodoris", + "last_name": "Sotiropoulos", + "institution": "Athens University of Economics and Business" + }, + { + "first_name": "Stefanos", + "last_name": "Chaliasos", + "institution": "Athens University of Economics and Business" + }, + { + "first_name": "Dimitris", + "last_name": "Mitropoulos", + "institution": "Athens University of Economics and Business" + }, + { + "first_name": "Diomidis", + "last_name": "Spinellis", + "institution": "Athens University of Economics and Business" + } + ], + "dblp_key": "journals/pacmpl/SotiropoulosCMS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428213", + "title": "Guided linking: dynamic linking without the costs", + "abstract": "Dynamic linking is extremely common in modern software systems, thanks to the flexibility and space savings it offers. However, this flexibility comes at a cost: it’s impossible to perform interprocedural optimizations that involve calls to a dynamic library. The basic problem is that the run-time behavior of the dynamic linker can’t be predicted at compile time, so the compiler can make no assumptions about how such calls will behave. This paper introduces guided linking , a technique for optimizing dynamically linked software when some information about the dynamic linker’s behavior is known in advance. The developer provides an arbitrary set of programs, libraries, and plugins to our tool, along with constraints that limit the possible dynamic linking behavior of the software. By taking advantage of the constraints, our tool enables any existing optimization to be applied across dynamic linking boundaries. For example, the NoOverride constraint can be applied to a function when the developer knows it will never be overridden with a different definition at run time; guided linking then enables the function to be inlined into its callers in other libraries. We also introduce a novel code size optimization that deduplicates identical functions even across different parts of the software set. By applying guided linking to the Python interpreter and its dynamically loaded modules, supplying the constraint that no other programs or modules will be used, we increase speed by an average of 9%. By applying guided linking to a dynamically linked distribution of Clang and LLVM, and using the constraint that no other software will use the LLVM libraries, we can increase speed by 5% and reduce file size by 13%. If we relax the constraint to allow other software to use the LLVM libraries, we can still increase speed by 5% and reduce file size by 5%. If we use guided linking to combine 11 different versions of the Boost library, using minimal constraints, we can reduce the total library size by 57%.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428213", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sean", + "last_name": "Bartell", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Will", + "last_name": "Dietz", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Vikram", + "last_name": "Adve", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/BartellDA20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428217", + "title": "Featherweight go", + "abstract": "We describe a design for generics in Go inspired by previous work on Featherweight Java by Igarashi, Pierce, and Wadler. Whereas subtyping in Java is nominal, in Go it is structural, and whereas generics in Java are defined via erasure, in Go we use monomorphisation. Although monomorphisation is widely used, we are one of the first to formalise it. Our design also supports a solution to The Expression Problem.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428217", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert", + "last_name": "Griesemer", + "institution": "Google (United States)" + }, + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "University of Hertfordshire" + }, + { + "first_name": "Wen", + "last_name": "Kokke", + "institution": "University of Edinburgh" + }, + { + "first_name": "Julien", + "last_name": "Lange", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Ian Lance", + "last_name": "Taylor", + "institution": "Google (United States)" + }, + { + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "University of Lisbon" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "University of Edinburgh" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/GriesemerHKLTTW20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428219", + "title": "Persistent Owicki-Gries reasoning: a program logic for reasoning about persistent programs on Intel-x86", + "abstract": "The advent of non-volatile memory (NVM) technologies is expected to transform how software systems are structured fundamentally, making the task of correct programming significantly harder. This is because ensuring that memory stores persist in the correct order is challenging, and requires low-level programming to flush the cache at appropriate points. This has in turn resulted in a noticeable verification gap . To address this, we study the verification of NVM programs, and present Persistent Owicki-Gries (POG), the first program logic for reasoning about such programs. We prove the soundness of POG over the recent Intel-x86 model, which formalises the out-of-order persistence of memory stores and the semantics of the Intel cache line flush instructions. We then use POG to verify several programs that interact with NVM.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428219", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RaadLV20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428216", + "title": "Statically verified refinements for multiparty protocols", + "abstract": "With distributed computing becoming ubiquitous in the modern era, safe distributed programming is an open challenge. To address this, multiparty session types (MPST) provide a typing discipline for message-passing concurrency, guaranteeing communication safety properties such as deadlock freedom. While originally MPST focus on the communication aspects, and employ a simple typing system for communication payloads, communication protocols in the real world usually contain constraints on the payload. We introduce refined multiparty session types (RMPST), an extension of MPST, that express data dependent protocols via refinement types on the data types. We provide an implementation of RMPST, in a toolchain called Session*, using Scribble, a toolchain for multiparty protocols, and targeting F*, a verification-oriented functional programming language. Users can describe a protocol in Scribble and implement the endpoints in F* using refinement-typed APIs generated from the protocol. The F* compiler can then statically verify the refinements. Moreover, we use a novel approach of callback-styled API generation, providing static linearity guarantees with the inversion of control. We evaluate our approach with real world examples and show that it has little overhead compared to a naive implementation, while guaranteeing safety properties from the underlying theory.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428216", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fangyi", + "last_name": "Zhou", + "institution": "Imperial College London" + }, + { + "first_name": "Francisco", + "last_name": "Ferreira", + "institution": "Imperial College London" + }, + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "University of Hertfordshire" + }, + { + "first_name": "Rumyana", + "last_name": "Neykova", + "institution": "Brunel University of London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/00020HNY20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428214", + "title": "Satune: synthesizing efficient SAT encoders", + "abstract": "Modern SAT solvers are extremely efficient at solving boolean satisfiability problems, enabling a wide spectrum of techniques for checking, verifying, and validating real-world programs. What remains challenging, though, is how to encode a domain problem (e.g., model checking) into a SAT formula because the same problem can have multiple distinct encodings, which can yield performance results that are orders-of-magnitude apart, regardless of the underlying solvers used. We develop Satune, a tool that can automatically synthesize SAT encoders for different problem domains. Satune employs a DSL that allows developers to express domain problems at a high level and a search algorithm that can effectively find efficient solutions. The search process is guided by observations made over example encodings and their performance for the domain and hence Satune can quickly synthesize a high-performance encoder by incorporating patterns from examples that yield good performance. A thorough evaluation with JMCR, SyPet, Dirk, Hexiom, Sudoku, and KillerSudoku demonstrates that Satune can easily synthesize high-performance encoders for different domains including model checking, synthesis, and games. These encoders generate constraint problems that are often several orders of magnitude faster to solve than the original encodings used by the tools.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428214", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hamed", + "last_name": "Gorjiara", + "institution": "University of California, Irvine" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "journals/pacmpl/GorjiaraXD20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428218", + "title": "Projection-based runtime assertions for testing and debugging Quantum programs", + "abstract": "In this paper, we propose Proq, a runtime assertion scheme for testing and debugging quantum programs on a quantum computer. The predicates in Proq are represented by projections (or equivalently, closed subspaces of the state space), following Birkhoff-von Neumann quantum logic. The satisfaction of a projection by a quantum state can be directly checked upon a small number of projective measurements rather than a large number of repeated executions. On the theory side, we rigorously prove that checking projection-based assertions can help locate bugs or statistically assure that the semantic function of the tested program is close to what we expect, for both exact and approximate quantum programs. On the practice side, we consider hardware constraints and introduce several techniques to transform the assertions, making them directly executable on the measurement-restricted quantum computers. We also propose to achieve simplified assertion implementation using local projection technique with soundness guaranteed. We compare Proq with existing quantum program assertions and demonstrate the effectiveness and efficiency of Proq by its applications to assert two sophisticated quantum algorithms, the Harrow-Hassidim-Lloyd algorithm and Shor’s algorithm.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428218", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gushu", + "last_name": "Li", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Li", + "last_name": "Zhou", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Nengkun", + "last_name": "Yu", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Yufei", + "last_name": "Ding", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Yuan", + "last_name": "Xie", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "journals/pacmpl/LiZYDY020", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428221", + "title": "DiffStream: differential output testing for stream processing programs", + "abstract": "High performance architectures for processing distributed data streams, such as Flink, Spark Streaming, and Storm, are increasingly deployed in emerging data-driven computing systems. Exploiting the parallelism afforded by such platforms, while preserving the semantics of the desired computation, is prone to errors, and motivates the development of tools for specification, testing, and verification. We focus on the problem of differential output testing for distributed stream processing systems, that is, checking whether two implementations produce equivalent output streams in response to a given input stream. The notion of equivalence allows reordering of logically independent data items, and the main technical contribution of the paper is an optimal online algorithm for checking this equivalence. Our testing framework is implemented as a library called DiffStream in Flink. We present four case studies to illustrate how our framework can be used to (1) correctly identify bugs in a set of benchmark MapReduce programs, (2) facilitate the development of difficult-to-parallelize high performance applications, and (3) monitor an application for a long period of time with minimal performance overhead.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428221", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Κωνσταντίνος", + "last_name": "Καλλάς", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Filip", + "last_name": "Niksic", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Caleb", + "last_name": "Stanford", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/KallasNSA20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428223", + "title": "CAMP: cost-aware multiparty session protocols", + "abstract": "This paper presents CAMP, a new static performance analysis framework for message-passing concurrent and distributed systems, based on the theory of multiparty session types (MPST). Understanding the run-time performance of concurrent and distributed systems is of great importance for the identification of bottlenecks and optimisation opportunities. In the message-passing setting, these bottlenecks are generally communication overheads and synchronisation times. Despite its importance, reasoning about these intensional properties of software, such as performance, has received little attention, compared to verifying extensional properties, such as correctness. Behavioural protocol specifications based on sessions types capture not only extensional, but also intensional properties of concurrent and distributed systems. CAMP augments MPST with annotations of communication latency and local computation cost, defined as estimated execution times, that we use to extract cost equations from protocol descriptions. CAMP is also extendable to analyse asynchronous communication optimisation built on a recent advance of session type theories. We apply our tool to different existing benchmarks and use cases in the literature with a wide range of communication protocols, implemented in C, MPI-C, Scala, Go, and OCaml. Our benchmarks show that, in most of the cases, we predict an upper-bound on the real execution costs with < 15% error.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428223", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Castro-Perez", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/Castro-PerezY20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428222", + "title": "Polymorphic types and effects with Boolean unification", + "abstract": "We present a simple, practical, and expressive type and effect system based on Boolean constraints. The effect system extends the Hindley-Milner type system, supports parametric polymorphism, and preserves principal types modulo Boolean equivalence. We show how to support type inference by extending Algorithm W with Boolean unification based on the successive variable elimination algorithm. We implement the type and effect system in the Flix programming language. We perform an in-depth evaluation on the impact of Boolean unification on type inference time and end-to-end compilation time. While the computational complexity of Boolean unification is NP-hard, the experimental results demonstrate that it works well in practice. We find that the impact on type inference time is on average a 1.4x slowdown and the overall impact on end-to-end compilation time is a 1.1x slowdown.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428222", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Jaco van de", + "last_name": "Pol", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/MadsenP20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428224", + "title": "The anchor verifier for blocking and non-blocking concurrent software", + "abstract": "Verifying the correctness of concurrent software with subtle synchronization is notoriously challenging. We present the Anchor verifier, which is based on a new formalism for specifying synchronization disciplines that describes both (1) what memory accesses are permitted, and (2) how each permitted access commutes with concurrent operations of other threads (to facilitate reduction proofs). Anchor supports the verification of both lock-based blocking and cas-based non-blocking algorithms. Experiments on a variety concurrent data structures and algorithms show that Anchor significantly reduces the burden of concurrent verification.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428224", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "Williams College" + } + ], + "dblp_key": "journals/pacmpl/FlanaganF20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428215", + "title": "Exposing cache timing side-channel leaks through out-of-order symbolic execution", + "abstract": "As one of the fundamental optimizations in modern processors, the out-of-order execution boosts the pipeline throughput by executing independent instructions in parallel rather than in their program orders. However, due to the side effects introduced by such microarchitectural optimization to the CPU cache, secret-critical applications may suffer from timing side-channel leaks. This paper presents a symbolic execution-based technique, named SymO 3 , for exposing cache timing leaks under the context of out-of-order execution. SymO 3 proposes new components that address the modeling, reduction, and reasoning challenges of accommodating program analysis to the software code out-of-order analysis. We implemented SymO 3 upon KLEE and conducted three evaluations on it. Experimental results show that SymO 3 successfully uncovers a set of cache timing leaks in five real-world programs. Also, SymO 3 finds that, in general, program transformation from compiler optimizations shrink the surface to timing leaks. Furthermore, augmented with a speculative execution modeling, SymO 3 identifies five more leaky programs based on the compound analysis.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428215", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shengjian", + "last_name": "Guo", + "institution": "" + }, + { + "first_name": "Yueqi", + "last_name": "Chen", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Jiyong", + "last_name": "Yu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Meng", + "last_name": "Wu", + "institution": "" + }, + { + "first_name": "Zhiqiang", + "last_name": "Zuo", + "institution": "Nanjing University" + }, + { + "first_name": "Peng", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Yueqiang", + "last_name": "Cheng", + "institution": "" + }, + { + "first_name": "Huibo", + "last_name": "Wang", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/GuoCYW0LCW20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428220", + "title": "Igloo: soundly linking compositional refinement and separation logic for distributed system verification", + "abstract": "Lighthouse projects like CompCert, seL4, IronFleet, and DeepSpec have demonstrated that full system verification is feasible by establishing a refinement between an abstract system specification and an executable implementation. Existing approaches however impose severe restrictions on the abstract system specifications due to their limited expressiveness or versatility, or on the executable code due to their use of suboptimal code extraction or inexpressive program logics. We propose a novel methodology that combines the compositional refinement of event-based models of distributed systems with the verification of full-fledged program code using expressive separation logics, which support features of realistic programming languages like heap data structures and concurrency. Our main technical contribution is a formal framework that soundly relates event-based system models to program specifications in separation logics. This enables protocol development tools to soundly interoperate with program verifiers to establish a refinement between the model and the code. We formalized our framework, Igloo, in Isabelle/HOL. We report on three case studies, a leader election protocol, a replication protocol, and a security protocol, for which we refine formal requirements into program specifications that we implement in Java and Python and prove correct using the VeriFast and Nagini tools.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428220", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christoph", + "last_name": "Sprenger", + "institution": "ETH Zurich" + }, + { + "first_name": "Tobias", + "last_name": "Klenze", + "institution": "ETH Zurich" + }, + { + "first_name": "Marco", + "last_name": "Eilers", + "institution": "ETH Zurich" + }, + { + "first_name": "Felix A.", + "last_name": "Wolf", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Clochard", + "institution": "ETH Zurich" + }, + { + "first_name": "David", + "last_name": "Basin", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/0001KEW0CB20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428225", + "title": "Automatic and efficient variability-aware lifting of functional programs", + "abstract": "A software analysis is a computer program that takes some representation of a software product as input and produces some useful information about that product as output. A software product line encompasses many software product variants, and thus existing analyses can be applied to each of the product variations individually, but not to the entire product line as a whole. Enumerating all product variants and analyzing them one by one is usually intractable due to the combinatorial explosion of the number of product variants with respect to product line features. Several software analyses (e.g., type checkers, model checkers, data flow analyses) have been redesigned/re-implemented to support variability. This usually requires a lot of time and effort, and the variability-aware version of the analysis might have new errors/bugs that do not exist in the original one. Given an analysis program written in a functional language based on PCF, in this paper we present two approaches to transforming (lifting) it into a semantically equivalent variability-aware analysis. A light-weight approach (referred to as shallow lifting ) wraps the analysis program into a variability-aware version, exploring all combinations of its input arguments. Deep lifting, on the other hand, is a program rewriting mechanism where the syntactic constructs of the input program are rewritten into their variability-aware counterparts. Compositionally this results in an efficient program semantically equivalent to the input program, modulo variability. We present the correctness criteria for functional program lifting, together with correctness proof sketches of shallow lifting. We evaluate our approach on a set of program analyses applied to the BusyBox C-language product line.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428225", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ramy", + "last_name": "Shahin", + "institution": "University of Toronto" + }, + { + "first_name": "Marsha", + "last_name": "Chećhik", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/ShahinC20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428226", + "title": "A sparse iteration space transformation framework for sparse tensor algebra", + "abstract": "We address the problem of optimizing sparse tensor algebra in a compiler and show how to define standard loop transformations---split, collapse, and reorder---on sparse iteration spaces. The key idea is to track the transformation functions that map the original iteration space to derived iteration spaces. These functions are needed by the code generator to emit code that maps coordinates between iteration spaces at runtime, since the coordinates in the sparse data structures remain in the original iteration space. We further demonstrate that derived iteration spaces can tile both the universe of coordinates and the subset of nonzero coordinates: the former is analogous to tiling dense iteration spaces, while the latter tiles sparse iteration spaces into statically load-balanced blocks of nonzeros. Tiling the space of nonzeros lets the generated code efficiently exploit heterogeneous compute resources such as threads, vector units, and GPUs. We implement these concepts by extending the sparse iteration theory implementation in the TACO system. The associated scheduling API can be used by performance engineers or it can be the target of an automatic scheduling system. We outline one heuristic autoscheduling system, but other systems are possible. Using the scheduling API, we show how to optimize mixed sparse-dense tensor algebra expressions on CPUs and GPUs. Our results show that the sparse transformations are sufficient to generate code with competitive performance to hand-optimized implementations from the literature, while generalizing to all of the tensor algebra.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428226", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Senanayake", + "institution": "Reservoir Labs (United States)" + }, + { + "first_name": "Changwan", + "last_name": "Hong", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ziheng", + "last_name": "Wang", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Amalee", + "last_name": "Wilson", + "institution": "Stanford University" + }, + { + "first_name": "Stephen Y.", + "last_name": "Chou", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Shoaib", + "last_name": "Kamil", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/SenanayakeHWWCK20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428227", + "title": "Programming with a read-eval-synth loop", + "abstract": "A frequent programming pattern for small tasks, especially expressions, is to repeatedly evaluate the program on an input as its editing progresses. The Read-Eval-Print Loop (REPL) interaction model has been a successful model for this programming pattern. We present the new notion of Read-Eval-Synth Loop (RESL) that extends REPL by providing in-place synthesis on parts of the expression marked by the user. RESL eases programming by synthesizing parts of a required solution. The underlying synthesizer relies on a partial solution from the programmer and a few examples. RESL hinges on bottom-up synthesis with general predicates and sketching, generalizing programming by example. To make RESL practical, we present a formal framework that extends observational equivalence to non-example specifications. We evaluate RESL by conducting a controlled within-subjects user-study on 19 programmers from 8 companies, where programmers are asked to solve a small but challenging set of competitive programming problems. We find that programmers using RESL solve these problems with far less need to edit the code themselves and by browsing documentation far less. In addition, they are less likely to leave a task unfinished and more likely to be correct.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428227", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hila", + "last_name": "Peleg", + "institution": "University of California, San Diego" + }, + { + "first_name": "Roi", + "last_name": "Gabay", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/PelegGIY20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428228", + "title": "LiveDroid: identifying and preserving mobile app state in volatile runtime environments", + "abstract": "Mobile operating systems, especially Android, expose apps to a volatile runtime environment. The app state that reflects past user interaction and system environment updates (e.g., battery status changes) can be destroyed implicitly, in response to runtime configuration changes (e.g., screen rotations) or memory pressure. Developers are therefore responsible for identifying app state affected by volatility and preserving it across app lifecycles. When handled inappropriately, the app may lose state or end up in an inconsistent state after a runtime configuration change or when users return to the app. To free developers from this tedious and error-prone task, we propose a systematic solution, LiveDroid, which precisely identifies the necessary part of the app state that needs to be preserved across app lifecycles, and automatically saves and restores it. LiveDroid consists of: (i) a static analyzer that reasons about app source code and resource files to pinpoint the program variables and GUI properties that represent the necessary app state, and (ii) a runtime system that manages the state saving and recovering. We implemented LiveDroid as a plugin in Android Studio and a patching tool for APKs. Our evaluation shows that LiveDroid can be successfully applied to 966 Android apps. A focused study with 36 Android apps shows that LiveDroid identifies app state much more precisely than an existing solution that includes all mutable program variables but ignores GUI properties. As a result, on average, LiveDroid is able to reduce the costs of state saving and restoring by 16.6X (1.7X - 141.1X) and 9.5X (1.1X - 43.8X), respectively. Furthermore, compared with the manual state handling performed by developers, our analysis reveals a set of 46 issues due to incomplete state saving/restoring, all of which can be successfully eliminated by LiveDroid.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428228", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Umar", + "last_name": "Farooq", + "institution": "University of California, Riverside" + }, + { + "first_name": "Zhijia", + "last_name": "Zhao", + "institution": "University of California, Riverside" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "University of California, Riverside" + }, + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "New Jersey Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/00020SN20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428229", + "title": "Towards a unified proof framework for automated fixpoint reasoning using matching logic", + "abstract": "Automation of fixpoint reasoning has been extensively studied for various mathematical structures, logical formalisms, and computational domains, resulting in specialized fixpoint provers for heaps, for streams, for term algebras, for temporal properties, for program correctness, and for many other formal systems and inductive and coinductive properties. However, in spite of great theoretical and practical interest, there is no unified framework for automated fixpoint reasoning. Although several attempts have been made, there is no evidence that such a unified framework is possible, or practical. In this paper, we propose a candidate based on matching logic, a formalism recently shown to theoretically unify the above mentioned formal systems. Unfortunately, the (Knaster-Tarski) proof rule of matching logic, which enables inductive reasoning, is not syntax-driven. Worse, it can be applied at any step during a proof, making automation seem hopeless. Inspired by recent advances in automation of inductive proofs in separation logic, we propose an alternative proof system for matching logic, which is amenable for automation. We then discuss our implementation of it, which although not superior to specialized state-of-the-art automated provers for specific domains, we believe brings some evidence and hope that a unified framework for automated reasoning is not out of reach.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428229", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xiaohong", + "last_name": "Chen", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Minh-Thai", + "last_name": "Trinh", + "institution": "Advanced Digital Sciences Center" + }, + { + "first_name": "Nishant", + "last_name": "Rodrigues", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Lucas", + "last_name": "Peña", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/0002TRPR20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428233", + "title": "Testing differential privacy with dual interpreters", + "abstract": "Applying differential privacy at scale requires convenient ways to check that programs computing with sensitive data appropriately preserve privacy. We propose here a fully automated framework for testing differential privacy, adapting a well-known “pointwise” technique from informal proofs of differential privacy. Our framework, called DPCheck, requires no programmer annotations, handles all previously verified or tested algorithms, and is the first fully automated framework to distinguish correct and buggy implementations of PrivTree, a probabilistically terminating algorithm that has not previously been mechanically checked. We analyze the probability of DPCheck mistakenly accepting a non-private program and prove that, theoretically, the probability of false acceptance can be made exponentially small by suitable choice of test size. We demonstrate DPCheck’s utility empirically by implementing all benchmark algorithms from prior work on mechanical verification of differential privacy, plus several others and their incorrect variants, and show DPCheck accepts the correct implementations and rejects the incorrect variants. We also demonstrate how DPCheck can be deployed in a practical workflow to test differentially privacy for the 2020 US Census Disclosure Avoidance System (DAS).", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428233", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hengchu", + "last_name": "Zhang", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Edo", + "last_name": "Roth", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Andreas", + "last_name": "Haeberlen", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Aaron", + "last_name": "Roth", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/ZhangRHP020", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428234", + "title": "Verifying and improving Halide's term rewriting system with program synthesis", + "abstract": "Halide is a domain-specific language for high-performance image processing and tensor computations, widely adopted in industry. Internally, the Halide compiler relies on a term rewriting system to prove properties of code required for efficient and correct compilation. This rewrite system is a collection of handwritten transformation rules that incrementally rewrite expressions into simpler forms; the system requires high performance in both time and memory usage to keep compile times low, while operating over the undecidable theory of integers. In this work, we apply formal techniques to prove the correctness of existing rewrite rules and provide a guarantee of termination. Then, we build an automatic program synthesis system in order to craft new, provably correct rules from failure cases where the compiler was unable to prove properties. We identify and fix 4 incorrect rules as well as 8 rules which could give rise to infinite rewriting loops. We demonstrate that the synthesizer can produce better rules than hand-authored ones in five bug fixes, and describe four cases in which it has served as an assistant to a human compiler engineer. We further show that it can proactively improve weaknesses in the compiler by synthesizing a large number of rules without human supervision and showing that the enhanced ruleset lowers peak memory usage of compiled code without appreciably increasing compilation times.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428234", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Julie L.", + "last_name": "Newcomb", + "institution": "University of Washington" + }, + { + "first_name": "Andrew", + "last_name": "Adams", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Steven", + "last_name": "Johnson", + "institution": "Google (United States)" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + }, + { + "first_name": "Shoaib", + "last_name": "Kamil", + "institution": "Adobe Systems (United States)" + } + ], + "dblp_key": "journals/pacmpl/NewcombAJBK20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428230", + "title": "Adversarial examples for models of code", + "abstract": "Neural models of code have shown impressive results when performing tasks such as predicting method names and identifying certain kinds of bugs. We show that these models are vulnerable to adversarial examples , and introduce a novel approach for attacking trained models of code using adversarial examples. The main idea of our approach is to force a given trained model to make an incorrect prediction, as specified by the adversary, by introducing small perturbations that do not change the program’s semantics, thereby creating an adversarial example. To find such perturbations, we present a new technique for Discrete Adversarial Manipulation of Programs (DAMP). DAMP works by deriving the desired prediction with respect to the model’s inputs , while holding the model weights constant, and following the gradients to slightly modify the input code. We show that our DAMP attack is effective across three neural architectures: code2vec, GGNN, and GNN-FiLM, in both Java and C#. Our evaluations demonstrate that DAMP has up to 89% success rate in changing a prediction to the adversary’s choice (a targeted attack) and a success rate of up to 94% in changing a given prediction to any incorrect prediction (a non-targeted attack). To defend a model against such attacks, we empirically examine a variety of possible defenses and discuss their trade-offs. We show that some of these defenses can dramatically drop the success rate of the attacker, with a minor penalty of 2% relative degradation in accuracy when they are not performing under attack. Our code, data, and trained models are available at <a>https://github.com/tech-srl/adversarial-examples</a> .", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428230", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Noam", + "last_name": "Yefet", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Uri", + "last_name": "Alon", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/Yefet0Y20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428235", + "title": "Dynamic dispatch of context-sensitive optimizations", + "abstract": "Academia has spent much effort into making context-sensitive analyses practical, with great profit. However, the implementation of context-sensitive optimizations , in contrast to analyses, is still not practical, due to code-size explosion. This growth happens because current technology requires the cloning of full paths in the Calling Context Tree. In this paper, we present a solution to this problem. We combine finite state machines and dynamic dispatching to allow fully context-sensitive specialization while cloning only functions that are effectively optimized. This technique makes it possible to apply very liberal optimizations, such as context-sensitive constant propagation, in large programs—something that could not have been easily done before. We demonstrate the viability of our idea by formalizing it in Prolog, and implementing it in LLVM. As a proof of concept, we have used our state machines to implement context-sensitive constant propagation in LLVM. The binaries produced by traditional full cloning are 2.63 times larger than the binaries that we generate with our state machines. When applied on Mozilla Firefox, our optimization increases binary size from 7.2MB to 9.2MB. Full cloning, in contrast, yields a binary of 34MB.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428235", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Poesia", + "institution": "Stanford University" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "journals/pacmpl/PoesiaP20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428232", + "title": "Compiling symbolic execution with staging and algebraic effects", + "abstract": "Building effective symbolic execution engines poses challenges in multiple dimensions: an engine must correctly model the program semantics, provide flexibility in symbolic execution strategies, and execute them efficiently. This paper proposes a principled approach to building correct, flexible, and efficient symbolic execution engines, directly rooted in the semantics of the underlying language in terms of a high-level definitional interpreter. The definitional interpreter induces algebraic effects to abstract over semantic variants of symbolic execution, e.g., collecting path conditions as a state effect and path exploration as a nondeterminism effect. Different handlers of these effects give rise to different symbolic execution strategies, making execution strategies orthogonal to the symbolic execution semantics, thus improving flexibility. Furthermore, by annotating the symbolic definitional interpreter with binding-times and specializing it to the input program via the first Futamura projection, we obtain a \"symbolic compiler\", generating efficient instrumented code having the symbolic execution semantics. Our work reconciles the interpretation- and instrumentation-based approaches to building symbolic execution engines in a uniform framework. We illustrate our approach on a simple imperative language step-by-step and then scale up to a significant subset of LLVM IR. We also show effect handlers for common path selection strategies. Evaluating our prototype's performance shows speedups of 10~30x over the unstaged counterpart, and ~2x over KLEE, a state-of-the-art symbolic interpreter for LLVM IR.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428232", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Shangyin", + "last_name": "Tan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WeiBTR20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428237", + "title": "Build scripts with perfect dependencies", + "abstract": "Build scripts for most build systems describe the actions to run, and the dependencies between those actions - but often build scripts get those dependencies wrong. Most build scripts have both too few dependencies (leading to incorrect build outputs) and too many dependencies (leading to excessive rebuilds and reduced parallelism). Any programmer who has wondered why a small change led to excess compilation, or who resorted to a clean step, has suffered the ill effects of incorrect dependency specification. We outline a build system where dependencies are not specified, but instead captured by tracing execution. The consequence is that dependencies are always correct by construction and build scripts are easier to write. The simplest implementation of our approach would lose parallelism, but we are able to recover parallelism using speculation.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428237", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sarah", + "last_name": "Spall", + "institution": "Indiana University" + }, + { + "first_name": "Neil", + "last_name": "Mitchell", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/SpallMT20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428236", + "title": "Eliminating abstraction overhead of Java stream pipelines using ahead-of-time program optimization", + "abstract": "Java 8 introduced streams that allow developers to work with collections of data using functional-style operations. Streams are often used in pipelines of operations for processing the data elements, which leads to concise and elegant program code. However, the declarative data processing style comes at a cost. Compared to processing the data with traditional imperative language mechanisms, constructing stream pipelines requires extra heap objects and virtual method calls, which often results in significant run-time overheads. In this work we investigate how to mitigate these overheads to enable processing data in the declarative style without sacrificing performance. We argue that ahead-of-time bytecode-to-bytecode transformation is a suitable approach to optimization of stream pipelines, and we present a static analysis that is designed to guide such transformations. Experimental results show a significant performance gain, and that the technique works for realistic stream pipelines. For 10 of 11 micro-benchmarks, the optimizer is able to produce bytecode that is as effective as hand-written imperative-style code. Additionally, 77% of 6879 stream pipelines found in real-world Java programs are optimized successfully.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428236", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Oskar Haarklou", + "last_name": "Veileborg", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/MollerV20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428238", + "title": "Deductive optimization of relational data storage", + "abstract": "Optimizing the physical data storage and retrieval of data are two key database management problems. In this paper, we propose a language that can express both a relational query and the layout of its data. Our language can express a wide range of physical database layouts, going well beyond the row- and column-based methods that are widely used in database management systems. We use deductive program synthesis to turn a high-level relational representation of a database query into a highly optimized low-level implementation which operates on a specialized layout of the dataset. We build an optimizing compiler for this language and conduct experiments using a popular database benchmark, which shows that the performance of our specialized queries is better than a state-of-the-art in memory compiled database system while achieving an order-of-magnitude reduction in memory use.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428238", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Feser", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Samuel", + "last_name": "Madden", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Nan", + "last_name": "Tang", + "institution": "Qatar Cardiovascular Research Center" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/FeserM0S20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428239", + "title": "Program equivalence for assisted grading of functional programs", + "abstract": "In courses that involve programming assignments, giving meaningful feedback to students is an important challenge. Human beings can give useful feedback by manually grading the programs but this is a time-consuming, labor intensive, and usually boring process. Automatic graders can be fast and scale well but they usually provide poor feedback. Although there has been research on improving automatic graders, research on scaling and improving human grading is limited. We propose to scale human grading by augmenting the manual grading process with an equivalence algorithm that can identify the equivalences between student submissions. This enables human graders to give targeted feedback for multiple student submissions at once. Our technique is conservative in two aspects. First, it identifies equivalence between submissions that are algorithmically similar, e.g., it cannot identify the equivalence between quicksort and mergesort. Second, it uses formal methods instead of clustering algorithms from the machine learning literature. This allows us to prove a soundness result that guarantees that submissions will never be clustered together in error. Despite only reporting equivalence when there is algorithmic similarity and the ability to formally prove equivalence, we show that our technique can significantly reduce grading time for thousands of programming submissions from an introductory functional programming course.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428239", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Clune", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Vijay", + "last_name": "Ramamurthy", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ruben", + "last_name": "Martins", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/CluneRMA20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428241", + "title": "Geometry types for graphics programming", + "abstract": "In domains that deal with physical space and geometry, programmers need to track the coordinate systems that underpin a computation. We identify a class of geometry bugs that arise from confusing which coordinate system a vector belongs to. These bugs are not ruled out by current languages for vector-oriented computing, are difficult to check for at run time, and can generate subtly incorrect output that can be hard to test for. We introduce a type system and language that prevents geometry bugs by reflecting the coordinate system for each geometric object. A value's geometry type encodes its reference frame, the kind of geometric object (such as a point or a direction), and the coordinate representation (such as Cartesian or spherical coordinates). We show how these types can rule out geometrically incorrect operations, and we show how to use them to automatically generate correct-by-construction code to transform vectors between coordinate systems. We implement a language for graphics programming, Gator, that checks geometry types and compiles to OpenGL's shading language, GLSL. Using case studies, we demonstrate that Gator can raise the level of abstraction for shader programming and prevent common errors without inducing significant annotation overhead or performance cost.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428241", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dietrich", + "last_name": "Geisler", + "institution": "Cornell University" + }, + { + "first_name": "Irene", + "last_name": "Yoon", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Aditi", + "last_name": "Kabra", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Horace", + "last_name": "He", + "institution": "Cornell University" + }, + { + "first_name": "Yinnon", + "last_name": "Sanders", + "institution": "Cornell University" + }, + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/GeislerYKHSS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428240", + "title": "A modular cost analysis for probabilistic programs", + "abstract": "We present a novel methodology for the automated resource analysis of non-deterministic, probabilistic imperative programs, which gives rise to a modular approach . Program fragments are analysed in full independence. Moreover, the established results allow us to incorporate sampling from dynamic distributions , making our analysis applicable to a wider class of examples, for example the Coupon Collector’s problem . We have implemented our contributions in the tool , exploiting a constraint-solver over iterative refineable cost functions facilitated by off-the-shelf SMT solvers. We provide ample experimental evidence of the prototype’s algorithmic power. Our experiments show that our tool runs typically at least one order of magnitude faster than comparable tools. On more involved examples, it may even be the case that execution times of seconds become milliseconds. At the same time we retain the precision of existing tools. The extensions in applicability and the greater efficiency of our prototype, yield scalability of sorts. This effects into a wider class of examples, whose expected cost analysis can be thus be performed fully automatically.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428240", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Avanzini", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Georg", + "last_name": "Moser", + "institution": "Universität Innsbruck" + }, + { + "first_name": "Michael", + "last_name": "Schaper", + "institution": "Universität Innsbruck" + } + ], + "dblp_key": "journals/pacmpl/AvanziniMS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428242", + "title": "Hidden inheritance: an inline caching design for TypeScript performance", + "abstract": "TypeScript is a dynamically typed language widely used to develop large-scale applications nowadays. These applications are usually designed with complex class or interface hierarchies and have highly polymorphic behaviors. These object-oriented (OO) features will lead to inefficient inline caches (ICs) or trigger deoptimizations, which impact the performance of TypeScript applications. To address this problem, we introduce an inline caching design called hidden inheritance (HI). The basic idea of HI is to cache the static information of class or interface hierarchies into hidden classes, which are leveraged to generate efficient inline caches for improving the performance of OO-style TypeScript programs. The HI design is implemented in a TypeScript engine STSC (Static TypeScript Compiler) including a static compiler and a runtime system. STSC statically generates hidden classes and enhanced inline caches, which are applied to generate specialized machine code via ahead-of-time compilation (AOTC) or just-in-time compilation (JITC). To evaluate the efficiency of this technique, we implement STSC on a state-of-the-art JavaScript virtual machine V8 and demonstrate its performance improvements on industrial benchmarks and applications.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428242", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhefeng", + "last_name": "Wu", + "institution": "Alibaba Group (China)" + }, + { + "first_name": "Zhe", + "last_name": "Li", + "institution": "Alibaba Group (China)" + }, + { + "first_name": "Kai", + "last_name": "Gong", + "institution": "Alibaba Group (China)" + }, + { + "first_name": "Lingyun", + "last_name": "Chen", + "institution": "Alibaba Group (China)" + }, + { + "first_name": "Bin", + "last_name": "Liao", + "institution": "Alibaba Group (China)" + }, + { + "first_name": "Yihua", + "last_name": "Jin", + "institution": "Alibaba Group (China)" + } + ], + "dblp_key": "journals/pacmpl/WuSGCLJ20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428243", + "title": "A type-and-effect system for object initialization", + "abstract": "Every newly created object goes through several initialization states: starting from a state where all fields are uninitialized until all of them are assigned. Any operation on the object during its initialization process, which usually happens in the constructor via this , has to observe the initialization states of the object for correctness, i.e. only initialized fields may be used. Checking safe usage of this statically, without manual annotation of initialization states in the source code, is a challenge, due to aliasing and virtual method calls on this . Mainstream languages either do not check initialization errors, such as Java, C++, Scala, or they defend against them by not supporting useful initialization patterns, such as Swift. In parallel, past research has shown that safe initialization can be achieved for varying degrees of expressiveness but by sacrificing syntactic simplicity. We approach the problem by upholding local reasoning about initialization which avoids whole-program analysis, and we achieve typestate polymorphism via subtyping. On this basis, we put forward a novel type-and-effect system that can effectively ensure initialization safety while allowing flexible initialization patterns. We implement an initialization checker in the Scala 3 compiler and evaluate on several real-world projects.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428243", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fengyun", + "last_name": "Liu", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "Aggelos", + "last_name": "Biboudis", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Paolo G.", + "last_name": "Giarrusso", + "institution": "Delft University of Technology" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/LiuLBGO20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428245", + "title": "Dataflow-based pruning for speeding up superoptimization", + "abstract": "Superoptimization is a compilation strategy that uses search to improve code quality, rather than relying on a canned sequence of transformations, as traditional optimizing compilers do. This search can be seen as a program synthesis problem: from unoptimized code serving as a specification, the synthesis procedure attempts to create a more efficient implementation. An important family of synthesis algorithms works by enumerating candidates and then successively checking if each refines the specification, using an SMT solver. The contribution of this paper is a pruning technique which reduces the enumerative search space using fast dataflow-based techniques to discard synthesis candidates that contain symbolic constants and uninstantiated instructions. We demonstrate the effectiveness of this technique by improving the runtime of an enumerative synthesis procedure in the Souper superoptimizer for the LLVM intermediate representation. The techniques presented in this paper eliminate 65% of the solver calls made by Souper, making it 2.32x faster (14.54 hours vs 33.76 hours baseline, on a large multicore) at solving all 269,113 synthesis problems that Souper encounters when optimizing the C and C++ programs from SPEC CPU 2017.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428245", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Manasij", + "last_name": "Mukherjee", + "institution": "University of Utah" + }, + { + "first_name": "Pranav", + "last_name": "Kant", + "institution": "University of Utah" + }, + { + "first_name": "Zhengyang", + "last_name": "Liu", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/MukherjeeKLR20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428244", + "title": "Sound garbage collection for C using pointer provenance", + "abstract": "Garbage collection (GC) support for unmanaged languages can reduce programming burden in reasoning about liveness of dynamic objects. It also avoids temporal memory safety violations and memory leaks. Sound GC for weakly-typed languages such as C/C++, however, remains an unsolved problem. Current value-based GC solutions examine values of memory locations to discover the pointers, and the objects they point to. The approach is inherently unsound in the presence of arbitrary type casts and pointer manipulations, which are legal in C/C++. Such language features are regularly used, especially in low-level systems code. In this paper, we propose Dynamic Pointer Provenance Tracking to realize sound GC. We observe that pointers cannot be created out-of-thin-air, and they must have provenance to at least one valid allocation. Therefore, by tracking pointer provenance from the source (e.g., malloc) through both explicit data-flow and implicit control-flow, our GC has sound and precise information to compute the set of all reachable objects at any program state. We discuss several static analysis optimizations, that can be employed during compilation aided with profiling, to significantly reduce the overhead of dynamic provenance tracking from nearly 8× to 16% for well-behaved programs that adhere to the C standards. Pointer provenance based sound GC invocation is also 13% faster and reclaims 6% more memory on average, compared to an unsound value-based GC.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428244", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Subarno", + "last_name": "Banerjee", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "David", + "last_name": "Devecsery", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Peter M.", + "last_name": "Chen", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Satish", + "last_name": "Narayanasamy", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "journals/pacmpl/BanerjeeDCN20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428247", + "title": "Learning graph-based heuristics for pointer analysis without handcrafting application-specific features", + "abstract": "We present Graphick, a new technique for automatically learning graph-based heuristics for pointer analysis. Striking a balance between precision and scalability of pointer analysis requires designing good analysis heuristics. For example, because applying context sensitivity to all methods in a real-world program is impractical, pointer analysis typically uses a heuristic to employ context sensitivity only when it is necessary. Past research has shown that exploiting the program's graph structure is a promising way of developing cost-effective analysis heuristics, promoting the recent trend of ``graph-based heuristics'' that work on the graph representations of programs obtained from a pre-analysis. Although promising, manually developing such heuristics remains challenging, requiring a great deal of expertise and laborious effort. In this paper, we aim to reduce this burden by learning graph-based heuristics automatically, in particular without hand-crafted application-specific features. To do so, we present a feature language to describe graph structures and an algorithm for learning analysis heuristics within the language. We implemented Graphick on top of Doop and used it to learn graph-based heuristics for object sensitivity and heap abstraction. The evaluation results show that our approach is general and can generate high-quality heuristics. For both instances, the learned heuristics are as competitive as the existing state-of-the-art heuristics designed manually by analysis experts.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428247", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Minseok", + "last_name": "Jeon", + "institution": "Korea University" + }, + { + "first_name": "Myungho", + "last_name": "Lee", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/JeonLO20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428246", + "title": "FlowCFL: generalized type-based reachability analysis: graph reduction and equivalence of CFL-based and type-based reachability", + "abstract": "Reachability analysis is a fundamental program analysis with a wide variety of applications. We present FlowCFL, a type-based reachability analysis that accounts for mutable heap data. The underlying semantics of FlowCFL is Context-Free-Language (CFL)-reachability. We make three contributions. First, we define a dynamic semantics that captures the notion of flow commonly used in reachability analysis. Second, we establish correctness of CFL-reachability over graphs with inverse edges (inverse edges are necessary for the handling of mutable heap data). Our approach combines CFL-reachability with reference immutability to avoid the addition of certain inverse edges, which results in graph reduction and precision improvement. The key contribution of our work is the formal account of correctness, which extends to the case when inverse edges are removed. Third, we present a type-based reachability analysis and establish equivalence between a certain CFL-reachability analysis and the type-based analysis, thus proving correctness of the type-based analysis.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428246", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ana", + "last_name": "Milanova", + "institution": "Rensselaer Polytechnic Institute" + } + ], + "dblp_key": "journals/pacmpl/Milanova20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428248", + "title": "Knowing when to ask: sound scheduling of name resolution in type checkers derived from declarative specifications", + "abstract": "There is a large gap between the specification of type systems and the implementation of their type checkers, which impedes reasoning about the soundness of the type checker with respect to the specification. A vision to close this gap is to automatically obtain type checkers from declarative programming language specifications. This moves the burden of proving correctness from a case-by-case basis for concrete languages to a single correctness proof for the specification language. This vision is obstructed by an aspect common to all programming languages: name resolution. Naming and scoping are pervasive and complex aspects of the static semantics of programming languages. Implementations of type checkers for languages with name binding features such as modules, imports, classes, and inheritance interleave collection of binding information (i.e., declarations, scoping structure, and imports) and querying that information. This requires scheduling those two aspects in such a way that query answers are stable—i.e., they are computed only after all relevant binding structure has been collected. Type checkers for concrete languages accomplish stability using language-specific knowledge about the type system. In this paper we give a language-independent characterization of necessary and sufficient conditions to guarantee stability of name and type queries during type checking in terms of critical edges in an incomplete scope graph . We use critical edges to give a formal small-step operational semantics to a declarative specification language for type systems, that achieves soundness by delaying queries that may depend on missing information. This yields type checkers for the specified languages that are sound by construction—i.e., they schedule queries so that the answers are stable, and only accept programs that are name- and type-correct according to the declarative language specification. We implement this approach, and evaluate it against specifications of a small module and record language, as well as subsets of Java and Scala.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428248", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arjen", + "last_name": "Rouvoet", + "institution": "Delft University of Technology" + }, + { + "first_name": "Hendrik van", + "last_name": "Antwerpen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/RouvoetAPKV20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428249", + "title": "Designing types for R, empirically", + "abstract": "The R programming language is widely used in a variety of domains. It was designed to favor an interactive style of programming with minimal syntactic and conceptual overhead. This design is well suited to data analysis, but a bad fit for tools such as compilers or program analyzers. In particular, R has no type annotations, and all operations are dynamically checked at run-time. The starting point for our work are the two questions: what expressive power is needed to accurately type R code? and which type system is the R community willing to adopt? Both questions are difficult to answer without actually experimenting with a type system. The goal of this paper is to provide data that can feed into that design process. To this end, we perform a large corpus analysis to gain insights in the degree of polymorphism exhibited by idiomatic R code and explore potential benefits that the R community could accrue from a simple type system. As a starting point, we infer type signatures for 25,215 functions from 412 packages among the most widely used open source R libraries. We then conduct an evaluation on 8,694 clients of these packages, as well as on end-user code from the Kaggle data science competition website.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428249", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexi", + "last_name": "Turcotte", + "institution": "Northeastern University" + }, + { + "first_name": "Aviral", + "last_name": "Goel", + "institution": "Northeastern University" + }, + { + "first_name": "Filip", + "last_name": "Křikava", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Czech Technical University in Prague" + } + ], + "dblp_key": "journals/pacmpl/TurcotteGKV20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428250", + "title": "Shiftry: RNN inference in 2KB of RAM", + "abstract": "Traditionally, IoT devices send collected sensor data to an intelligent cloud where machine learning (ML) inference happens. However, this course is rapidly changing and there is a recent trend to run ML on the edge IoT devices themselves. An intelligent edge is attractive because it saves network round trip (efficiency) and keeps user data at the source (privacy). However, the IoT devices are much more resource constrained than the cloud, which makes running ML on them challenging. Specifically, consider Arduino Uno, a commonly used board, that has 2KB of RAM and 32KB of read-only Flash memory. Although recent breakthroughs in ML have created novel recurrent neural network (RNN) models that provide good accuracy with KB-sized models, deploying them on tiny devices with such hard memory requirements has remained elusive. We provide, Shiftry, an automatic compiler from high-level floating-point ML models to fixed-point C-programs with 8-bit and 16-bit integers, which have significantly lower memory requirements. For this conversion, Shiftry uses a data-driven float-to-fixed procedure and a RAM management mechanism. These techniques enable us to provide first empirical evaluation of RNNs running on tiny edge devices. On simpler ML models that prior work could handle, Shiftry-generated code has lower latency and higher accuracy.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428250", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aayan", + "last_name": "Kumar", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Vivek", + "last_name": "Seshadri", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "journals/pacmpl/KumarS020", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428251", + "title": "StreamQL: a query language for processing streaming time series", + "abstract": "Real-time data analysis applications increasingly rely on complex streaming computations over time-series data. We propose StreamQL, a language that facilitates the high-level specification of complex analyses over streaming time series. StreamQL is designed as an algebra of stream transformations and provides a collection of combinators for composing them. It integrates three language-based approaches for data stream processing: relational queries, dataflow composition, and temporal formalisms. The relational constructs are useful for specifying simple transformations, aggregations, and the partitioning of data into key-based groups or windows. The dataflow abstractions enable the modular description of a computation as a pipeline of stages or, more generally, as a directed graph of independent tasks. Finally, temporal constructs can be used to specify complex temporal patterns and time-varying computations. These constructs can be composed freely to describe complex streaming computations. We provide a formal denotational semantics for StreamQL using a class of monotone functions over streams. We have implemented StreamQL as a lightweight Java library, which we use to experimentally evaluate our approach. The experiments show that the throughput of our implementation is competitive compared to state-of-the-art streaming engines such as RxJava and Reactor.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428251", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lingkun", + "last_name": "Kong", + "institution": "Rice University" + }, + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + } + ], + "dblp_key": "journals/pacmpl/KongM20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428231", + "title": "Towards a formal foundation of intermittent computing", + "abstract": "Intermittently powered devices enable new applications in harsh or inaccessible environments, such as space or in-body implants, but also introduce problems in programmability and correctness. Researchers have developed programming models to ensure that programs make progress and do not produce erroneous results due to memory inconsistencies caused by intermittent executions. As the technology has matured, more and more features are added to intermittently powered devices, such as I/O. Prior work has shown that all existing intermittent execution models have problems with repeated device or sensor inputs (RIO). RIOs could leave intermittent executions in an inconsistent state. Such problems and the proliferation of existing intermittent execution models necessitate a formal foundation for intermittent computing. In this paper, we formalize intermittent execution models, their correctness properties with respect to memory consistency and inputs, and identify the invariants needed to prove systems correct. We prove equivalence between several existing intermittent systems. To address RIO problems, we define an algorithm for identifying variables affected by RIOs that need to be restored after reboot and prove the algorithm correct. Finally, we implement the algorithm in a novel intermittent runtime system that is correct with respect to input operations and evaluate its performance.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428231", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Milijana", + "last_name": "Surbatovich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/SurbatovichL020", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428252", + "title": "Incremental predicate analysis for regression verification", + "abstract": "Software products are evolving during their life cycles. Ideally, every revision need be formally verified to ensure software quality. Yet repeated formal verification requires significant computing resources. Verifying each and every revision can be very challenging. It is desirable to ameliorate regression verification for practical purposes. In this paper, we regard predicate analysis as a process of assertion annotation. Assertion annotations can be used as a certificate for the verification results. It is thus a waste of resources to throw them away after each verification. We propose to reuse the previously-yielded assertion annotation in regression verification. A light-weight impact-analysis technique is proposed to analyze the reusability of assertions. A novel assertion strengthening technique is furthermore developed to improve reusability of annotation. With these techniques, we present an incremental predicate analysis technique for regression verification. Correctness of our incremental technique is formally proved. We performed comprehensive experiments on revisions of Linux kernel device drivers. Our technique outperforms the state-of-the-art program verification tool CPAchecker by getting 2.8x speedup in total time and solving additional 393 tasks.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428252", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qianshan", + "last_name": "Yu", + "institution": "Tsinghua University" + }, + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + }, + { + "first_name": "Bow-Yaw", + "last_name": "Wang", + "institution": "Academia Sinica" + } + ], + "dblp_key": "journals/pacmpl/Yu0W20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428254", + "title": "Fuzzing channel-based concurrency runtimes using types and effects", + "abstract": "Modern programming languages support concurrent programming based on channels and processes. Channels enable synchronous and asynchronous message-passing between independent light-weight processes making it easy to express common concurrency patterns. The implementation of channels and processes in compilers and language runtimes is a difficult task that relies heavily on traditional and error-prone low-level concurrency primitives, raising concerns about correctness and reliability. In this paper, we present an automatic program generation technique to test such programming language implementations. We define a type and effect system for programs that communicate over channels and where every execution is guaranteed to eventually terminate. We can generate and run such programs, and if a program fails to terminate, we have found a bug in the programming language implementation. We implement such an automatic program generator and apply it to Go, Kotlin, Crystal, and Flix. We find two new bugs in Flix, and reproduce two bugs; one in Crystal and one in Kotlin.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428254", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Quentin", + "last_name": "Stiévenart", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/StievenartM20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428253", + "title": "Perfectly parallel fairness certification of neural networks", + "abstract": "Recently, there is growing concern that machine-learned software, which currently assists or even automates decision making, reproduces, and in the worst case reinforces, bias present in the training data. The development of tools and techniques for certifying fairness of this software or describing its biases is, therefore, critical. In this paper, we propose a perfectly parallel static analysis for certifying fairness of feed-forward neural networks used for classification of tabular data. When certification succeeds, our approach provides definite guarantees, otherwise, it describes and quantifies the biased input space regions. We design the analysis to be sound, in practice also exact, and configurable in terms of scalability and precision, thereby enabling pay-as-you-go certification. We implement our approach in an open-source tool called Libra and demonstrate its effectiveness on neural networks trained on popular datasets.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428253", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Caterina", + "last_name": "Urban", + "institution": "Université Paris Sciences et Lettres" + }, + { + "first_name": "Maria", + "last_name": "Christakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Valentin", + "last_name": "Wüstholz", + "institution": "ConsenSys (United States)" + }, + { + "first_name": "Fuyuan", + "last_name": "Zhang", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/UrbanCWZ20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428256", + "title": "Rethinking safe consistency in distributed object-oriented programming", + "abstract": "Large scale distributed systems require to embrace the trade off between consistency and availability, accepting lower levels of consistency to guarantee higher availability. Existing programming languages are, however, agnostic to this compromise, resulting in consistency guarantees that are the same for the whole application and are implicitly adopted from the middleware or hardcoded in configuration files. In this paper, we propose to integrate availability in the design of an object-oriented language, allowing developers to specify different consistency and isolation constraints in the same application at the granularity of single objects. We investigate how availability levels interact with object structure and define a type system that preserves correct program behavior. Our evaluation shows that our solution performs efficiently and improves the design of distributed applications.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428256", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mirko", + "last_name": "Köhler", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Nafise", + "last_name": "Eskandani", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Alessandro", + "last_name": "Margara", + "institution": "Politecnico di Milano" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "University of St. Gallen" + } + ], + "dblp_key": "journals/pacmpl/KohlerEWMS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428255", + "title": "Detecting locations in JavaScript programs affected by breaking library changes", + "abstract": "JavaScript libraries are widely used and evolve rapidly. When adapting client code to non-backwards compatible changes in libraries, a major challenge is how to locate affected API uses in client code, which is currently a difficult manual task. In this paper we address this challenge by introducing a simple pattern language for expressing API access points and a pattern-matching tool based on lightweight static analysis. Experimental evaluation on 15 popular npm packages shows that typical breaking changes are easy to express as patterns. Running the static analysis on 265 clients of these packages shows that it is accurate and efficient: it reveals usages of breaking APIs with only 14% false positives and no false negatives, and takes less than a second per client on average. In addition, the analysis is able to report its confidence, which makes it easier to identify the false positives. These results suggest that the approach, despite its simplicity, can reduce the manual effort of the client developers.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428255", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Benjamin Barslev", + "last_name": "Nielsen", + "institution": "Aarhus University" + }, + { + "first_name": "Martin Toldam", + "last_name": "Torp", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/MollerNT20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428257", + "title": "DynamiTe: dynamic termination and non-termination proofs", + "abstract": "There is growing interest in termination reasoning for nonlinear programs and, meanwhile, recent dynamic strategies have shown they are able to infer invariants for such challenging programs. These advances led us to hypothesize that perhaps such dynamic strategies for nonlinear invariants could be adapted to learn recurrent sets (for non-termination) and/or ranking functions (for termination). In this paper, we exploit dynamic analysis and draw termination and non-termination as well as static and dynamic strategies closer together in order to tackle nonlinear programs. For termination, our algorithm infers ranking functions from concrete transitive closures, and, for non-termination, the algorithm iteratively collects executions and dynamically learns conditions to refine recurrent sets. Finally, we describe an integrated algorithm that allows these algorithms to mutually inform each other, taking counterexamples from a failed validation in one endeavor and crossing both the static/dynamic and termination/non-termination lines, to create new execution samples for the other one. We have implemented these algorithms in a new tool called DynamiTe. For nonlinear programs, there are currently no SV-COMP termination benchmarks so we created new sets of 38 terminating and 39 non-terminating programs. Our empirical evaluation shows that we can effectively guess (and sometimes even validate) ranking functions and recurrent sets for programs with nonlinear behaviors. Furthermore, we show that counterexamples from one failed validation can be used to generate executions for a dynamic analysis of the opposite property. Although we are focused on nonlinear programs, as a point of comparison, we compare DynamiTe's performance on linear programs with that of the state-of-the-art tool, Ultimate. Although DynamiTe is an order of magnitude slower it is nonetheless somewhat competitive and sometimes finds ranking functions where Ultimate was unable to. Ultimate cannot, however, handle the nonlinear programs in our new benchmark suite.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428257", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ton Chanh", + "last_name": "Le", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Timos", + "last_name": "Antonopoulos", + "institution": "Yale University" + }, + { + "first_name": "Parisa", + "last_name": "Fathololumi", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "ThanhVu", + "last_name": "Nguyen", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "journals/pacmpl/LeAFKN20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428258", + "title": "Precise static modeling of Ethereum "memory"", + "abstract": "Static analysis of smart contracts as-deployed on the Ethereum blockchain has received much recent attention. However, high-precision analyses currently face significant challenges when dealing with the Ethereum VM (EVM) execution model. A major such challenge is the modeling of low-level, transient “memory” (as opposed to persistent, on-blockchain “storage”) that smart contracts employ. Statically understanding the usage patterns of memory is non-trivial, due to the dynamic allocation nature of in-memory buffers. We offer an analysis that models EVM memory, recovering high-level concepts (e.g., arrays, buffers, call arguments) via deep modeling of the flow of values. Our analysis opens the door to Ethereum static analyses with drastically increased precision. One such analysis detects the extraction of ERC20 tokens by unauthorized users. For another practical vulnerability (redundant calls, possibly used as an attack vector), our memory modeling yields analysis precision of 89%, compared to 16% for a state-of-the-art tool without precise memory modeling. Additionally, precise memory modeling enables the static computation of a contract’s gas cost. This gas-cost analysis has recently been instrumental in the evaluation of the impact of the EIP-1884 repricing (in terms of gas costs) of EVM operations, leading to a reward and significant publicity from the Ethereum Foundation.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428258", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sifis", + "last_name": "Lagouvardos", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Ilias", + "last_name": "Tsatiris", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/LagouvardosGTS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428259", + "title": "Taming type annotations in gradual typing", + "abstract": "Gradual typing provides a methodology to integrate static and dynamic typing, harmonizing their often conflicting advantages in a single language. When a user wants to enjoy the advantages of static typing, most gradual languages require that they add type annotations. Many nontrivial tasks must be undertaken while adding type annotations, including understanding program behaviors and invariants. Unfortunately, if this is done incorrectly then the added type annotations can be wrong–leading to inconsistencies between the program and the type annotations. Gradual typing implementations detect such inconsistencies at runtime, raise cast errors, and generate messages. However, solely relying on such error messages for understanding and fixing inconsistencies and their resulting cast errors is often insufficient for multiple reasons. One reason is that while such messages cover inconsistencies in one execution path, fixing them often requires reconciling information from multiple paths. Another is that users may add many wrong type annotations that they later find difficult to identify and fix, when considering all added annotations. Recent studies provide evidence that type annotations added during program migration are often wrong and that many programmers prefer compile-time warnings about wrong annotations. Motivated by these results, we develop exploratory typing to help with the static detection, understanding, and fixing of inconsistencies. The key idea of exploratory typing is that it systematically removes dynamic types and explores alternative types for static type annotations that can remedy inconsistencies. To demonstrate the feasibility of exploratory typing, we have implemented it in PyHound, which targets programs written in Reticulated Python, a gradual variant of Python. We have evaluated PyHound on a set of Python programs, and the evaluation results demonstrate that our idea can effectively detect inconsistencies in 98% of the tested programs and fix 93% of inconsistencies, significantly outperforming pytype, a widely used Python tool for enforcing type annotations.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428259", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John Peter", + "last_name": "Campora", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + } + ], + "dblp_key": "journals/pacmpl/Campora020", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428260", + "title": "Inter-theory dependency analysis for SMT string solvers", + "abstract": "Solvers in the framework of Satisfiability Modulo Theories (SMT) have been widely successful in practice. Recently there has been an increasing interest in solvers for string constraints to address security issues in web programming, for example. To be practically useful, the solvers need to support an expressive constraint language over unbounded strings, and in particular, over string lengths. Satisfiability checking for these formulas, especially in the SMT context, is very hard; it is generally undecidable for a rich fragment. In this paper, we propose a form of dependency analysis for a rich fragment of string constraints including high-level operations such as length, contains to deal with their inter-theory interaction so as to solve them more efficiently. We implement our dependency analysis in the string theory of the Z3 solver to obtain a new one, called S3N. Finally, we demonstrate the superior performance of S3N over state-of-the-art string solvers such as Z3str3, CVC4, S3P, and Z3 on several large industrial-strength benchmarks.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428260", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Minh-Thai", + "last_name": "Trinh", + "institution": "Advanced Digital Sciences Center" + }, + { + "first_name": "Duc-Hiep", + "last_name": "Chu", + "institution": "National University of Singapore" + }, + { + "first_name": "Joxan", + "last_name": "Jaffar", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/TrinhCJ20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428262", + "title": "Pomsets with preconditions: a simple model of relaxed memory", + "abstract": "Relaxed memory models must simultaneously achieve efficient implementability and thread-compositional reasoning. Is that why they have become so complicated? We argue that the answer is no: It is possible to achieve these goals by combining an idea from the 60s (preconditions) with an idea from the 80s (pomsets), at least for X64 and ARMv8. We show that the resulting model (1) supports compositional reasoning for temporal safety properties, (2) supports all expected sequential compiler optimizations, (3) satisfies the DRF-SC criterion, and (4) compiles to X64 and ARMv8 microprocessors without requiring extra fences on relaxed accesses.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428262", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Radha", + "last_name": "Jagadeesan", + "institution": "DePaul University" + }, + { + "first_name": "Alan", + "last_name": "Jeffrey", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Riely", + "institution": "DePaul University" + } + ], + "dblp_key": "journals/pacmpl/JagadeesanJR20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428261", + "title": "On the unusual effectiveness of type-aware operator mutations for testing SMT solvers", + "abstract": "We propose type-aware operator mutation, a simple, but unusually effective approach for testing SMT solvers. The key idea is to mutate operators of conforming types within the seed formulas to generate well-typed mutant formulas. These mutant formulas are then used as the test cases for SMT solvers. We realized type-aware operator mutation within the OpFuzz tool and used it to stress-test Z3 and CVC4, two state-of-the-art SMT solvers. Type-aware operator mutations are unusually effective: During one year of extensive testing with OpFuzz, we reported 1092 bugs on Z3’s and CVC4’s respective GitHub issue trackers, out of which 819 unique bugs were confirmed and 685 of the confirmed bugs were fixed by the developers. The detected bugs are highly diverse — we found bugs of many different types (soundness bugs, invalid model bugs, crashes, etc.), logics and solver configurations. We have further conducted an in-depth study of the bugs found by OpFuzz. The study results show that the bugs found by OpFuzz are of high quality. Many of them affect core components of the SMT solvers’ codebases, and some required major changes for the developers to fix. Among the 819 confirmed bugs found by OpFuzz,184 were soundness bugs, the most critical bugs in SMT solvers,and 489 were in the default modes of the solvers. Notably, OpFuzz found 27 critical soundness bugs in CVC4, which has proved to be a very stable SMT solver.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428261", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dominik", + "last_name": "Winterer", + "institution": "ETH Zurich" + }, + { + "first_name": "Chengyu", + "last_name": "Zhang", + "institution": "East China Normal University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/WintererZS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428264", + "title": "Random testing for C and C++ compilers with YARPGen", + "abstract": "Compilers should not crash and they should not miscompile applications. Random testing is an effective method for finding compiler bugs that have escaped other kinds of testing. This paper presents Yet Another Random Program Generator (YARPGen), a random test-case generator for C and C++ that we used to find and report more than 220 bugs in GCC, LLVM, and the Intel® C++ Compiler. Our research contributions include a method for generating expressive programs that avoid undefined behavior without using dynamic checks, and generation policies, a mechanism for increasing diversity of generated code and for triggering more optimizations. Generation policies decrease the testing time to find hard-to-trigger compiler bugs and, for the kinds of scalar optimizations YARPGen was designed to stress-test, increase the number of times these optimizations are applied by the compiler by an average of 20% for LLVM and 40% for GCC. We also created tools for automating most of the common tasks related to compiler fuzzing; these tools are also useful for fuzzers other than ours.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428264", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vsevolod", + "last_name": "Livinskii", + "institution": "University of Utah" + }, + { + "first_name": "Dmitry", + "last_name": "Babokin", + "institution": "Intel (United States)" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/LivinskiiBR20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428263", + "title": "Fast linear programming through transprecision computing on small and sparse data", + "abstract": "A plethora of program analysis and optimization techniques rely on linear programming at their heart. However, such techniques are often considered too slow for production use. While today’s best solvers are optimized for complex problems with thousands of dimensions, linear programming, as used in compilers, is typically applied to small and seemingly trivial problems, but to many instances in a single compilation run. As a result, compilers do not benefit from decades of research on optimizing large-scale linear programming. We design a simplex solver targeted at compilers. A novel theory of transprecision computation applied from individual elements to full data-structures provides the computational foundation. By carefully combining it with optimized representations for small and sparse matrices and specialized small-coefficient algorithms, we (1) reduce memory traffic, (2) exploit wide vectors, and (3) use low-precision arithmetic units effectively. We evaluate our work by embedding our solver into a state-of-the-art integer set library and implement one essential operation, coalescing, on top of our transprecision solver. Our evaluation shows more than an order-of-magnitude speedup on the core simplex pivot operation and a mean speedup of 3.2x (vs. GMP) and 4.6x (vs. IMath) for the optimized coalescing operation. Our results demonstrate that our optimizations exploit the wide SIMD instructions of modern microarchitectures effectively. We expect our work to provide foundations for a future integer set library that uses transprecision arithmetic to accelerate compiler analyses.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428263", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Edinburgh" + }, + { + "first_name": "Theodoros", + "last_name": "Theodoridis", + "institution": "ETH Zurich" + }, + { + "first_name": "Maximilian", + "last_name": "Falkenstein", + "institution": "ETH Zurich" + }, + { + "first_name": "Arjun", + "last_name": "Pitchanathan", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Michael", + "last_name": "Kruse", + "institution": "Argonne National Laboratory" + }, + { + "first_name": "Manuel", + "last_name": "Rigger", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + }, + { + "first_name": "Torsten", + "last_name": "Hoefler", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/GrosserTFPKRSH20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428267", + "title": "Termination analysis for evolving programs: an incremental approach by reusing certified modules", + "abstract": "Research on program termination has a long tradition. However, most of the existing techniques target a single program only. We propose in this paper an incremental termination analysis approach by reusing certified modules across different program versions. A transformation-based procedure is further developed to increase the reusability of certified modules. The proposed approach has wide applicability, applicable to various program changes. The proposed technique, to the best of our knowledge, represents a novel attempt to the termination analysis of evolving programs. We implemented the approach on top of Ultimate Automizer. Experimental results show dramatic improvement of our approach over the state-of-the-art tool.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428267", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + }, + { + "first_name": "Jitao", + "last_name": "Han", + "institution": "Tsinghua University" + } + ], + "dblp_key": "journals/pacmpl/0001H20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428265", + "title": "CompCertELF: verified separate compilation of C programs into ELF object files", + "abstract": "We present CompCertELF, the first extension to CompCert that supports verified compilation from C programs all the way to a standard binary file format, i.e., the ELF object format. Previous work on Stack-Aware CompCert provides a verified compilation chain from C programs to assembly programs with a realistic machine memory model. We build CompCertELF by modifying and extending this compilation chain with a verified assembler which further transforms assembly programs into ELF object files. CompCert supports large-scale verification via verified separate compilation: C modules can be written and compiled separately, and then linked together to get a target program that refines the semantics of the program linked from the source modules. However, verified separate compilation in CompCert only works for compilation to assembly programs, not to object files. For the latter, the main difficulty is to bridge the two different views of linking: one for CompCert's programs that allows arbitrary shuffling of global definitions by linking and the other for object files that treats blocks of encoded definitions as indivisible units. We propose a lightweight approach that solves the above problem without any modification to CompCert's framework for verified separate compilation: by introducing a notion of syntactical equivalence between programs and proving the commutativity between syntactical equivalence and the two different kinds of linking, we are able to transit from the more abstract linking operation in CompCert to the more concrete one for ELF object files. By applying this approach to CompCertELF, we obtain the first compiler that supports verified separate compilation of C programs into ELF object files.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428265", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuting", + "last_name": "Wang", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Xiangzhe", + "last_name": "Xu", + "institution": "Nanjing University" + }, + { + "first_name": "Pierre", + "last_name": "Wilke", + "institution": "CentraleSupélec" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/WangXWS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428268", + "title": "Programming and reasoning with partial observability", + "abstract": "Computer programs are increasingly being deployed in partially-observable environments. A partially observable environment is an environment whose state is not completely visible to the program, but from which the program receives partial observations. Developers typically deal with partial observability by writing a state estimator that, given observations, attempts to deduce the hidden state of the environment. In safety-critical domains, to formally verify safety properties developers may write an environment model. The model captures the relationship between observations and hidden states and is used to prove the software correct. In this paper, we present a new methodology for writing and verifying programs in partially observable environments. We present belief programming , a programming methodology where developers write an environment model that the program runtime automatically uses to perform state estimation. A belief program dynamically updates and queries a belief state that captures the possible states the environment could be in. To enable verification, we present Epistemic Hoare Logic that reasons about the possible belief states of a belief program the same way that classical Hoare logic reasons about the possible states of a program. We develop these concepts by defining a semantics and a program logic for a simple core language called BLIMP. In a case study, we show how belief programming could be used to write and verify a controller for the Mars Polar Lander in BLIMP. We present an implementation of BLIMP called CBLIMP and evaluate it to determine the feasibility of belief programming.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428268", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Atkinson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AtkinsonC20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428266", + "title": "Scalable and serializable networked multi-actor programming", + "abstract": "A major challenge in writing applications that execute across hosts, such as distributed online services, is to reconcile (a) parallelism (i.e., allowing components to execute independently on disjoint tasks), and (b)cooperation (i.e., allowing components to work together on common tasks). A good compromise between the two is vital to scalability, a core concern in distributed networked applications. The actor model of computation is a widely promoted programming model for distributed applications, as actors can execute in individual threads (parallelism) across different hosts and interact via asynchronous message passing (collaboration). However, this makes it hard for programmers to reason about combinations of messages as opposed to individual messages, which is essential in many scenarios. This paper presents a pragmatic variant of the actor model in which messages can be grouped into units that are executed in a serializable manner, whilst still retaining a high degree of parallelism. In short, our model is based on an orchestration of actors along a directed acyclic graph that supports efficient decentralized synchronization among actors based on their actual interaction. We present the implementation of this model, based on a dynamic DAG-inducing referencing discipline, in the actor-based programming language AEON. We argue serializability and the absence of deadlocks in our model, and demonstrate its scalability and usability through extensive evaluation and case studies of wide-ranging applications.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428266", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bo", + "last_name": "Sang", + "institution": "" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Gustavo", + "last_name": "Petri", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Srivatsan", + "last_name": "Ravi", + "institution": "University of Southern California" + }, + { + "first_name": "Pierre-Louis", + "last_name": "Roman", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "journals/pacmpl/SangEPRR20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428269", + "title": "Interactive synthesis of temporal specifications from examples and natural language", + "abstract": "Motivated by applications in robotics, we consider the task of synthesizing linear temporal logic (LTL) specifications based on examples and natural language descriptions. While LTL is a flexible, expressive, and unambiguous language to describe robotic tasks, it is often challenging for non-expert users. In this paper, we present an interactive method for synthesizing LTL specifications from a single example trace and a natural language description. The interaction is limited to showing a small number of behavioral examples to the user who decides whether or not they exhibit the original intent. Our approach generates candidate LTL specifications and distinguishing examples using an encoding into optimization modulo theories problems. Additionally, we use a grammar extension mechanism and a semantic parser to generalize synthesized specifications to parametric task descriptions for subsequent use. Our implementation in the tool LtlTalk starts with a domain-specific language that maps to a fragment of LTL and expands it through example-based user interactions, thus enabling natural language-like robot programming, while maintaining the expressive power and precision of a formal language. Our experiments show that the synthesis method is precise, quick, and asks only a few questions to the users, and we demonstrate in a case study how LtlTalk generalizes from the synthesized tasks to other, yet unseen, tasks.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428269", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivan", + "last_name": "Gavran", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Eva", + "last_name": "Darulová", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/GavranDM20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428270", + "title": "A large-scale longitudinal study of flaky tests", + "abstract": "Flaky tests are tests that can non-deterministically pass or fail for the same code version. These tests undermine regression testing efficiency, because developers cannot easily identify whether a test fails due to their recent changes or due to flakiness. Ideally, one would detect flaky tests right when flakiness is introduced, so that developers can then immediately remove the flakiness. Some software organizations, e.g., Mozilla and Netflix, run some tools—detectors—to detect flaky tests as soon as possible. However, detecting flaky tests is costly due to their inherent non-determinism, so even state-of-the-art detectors are often impractical to be used on all tests for each project change. To combat the high cost of applying detectors, these organizations typically run a detector solely on newly added or directly modified tests, i.e., not on unmodified tests or when other changes occur (including changes to the test suite, the code under test, and library dependencies). However, it is unclear how many flaky tests can be detected or missed by applying detectors in only these limited circumstances. To better understand this problem, we conduct a large-scale longitudinal study of flaky tests to determine when flaky tests become flaky and what changes cause them to become flaky. We apply two state-of-theart detectors to 55 Java projects, identifying a total of 245 flaky tests that can be compiled and run in the code version where each test was added. We find that 75% of flaky tests (184 out of 245) are flaky when added, indicating substantial potential value for developers to run detectors specifically on newly added tests. However, running detectors solely on newly added tests would still miss detecting 25% of flaky tests. The percentage of flaky tests that can be detected does increase to 85% when detectors are run on newly added or directly modified tests. The remaining 15% of flaky tests become flaky due to other changes and can be detected only when detectors are always applied to all tests. Our study is the first to empirically evaluate when tests become flaky and to recommend guidelines for applying detectors in the future.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428270", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wing", + "last_name": "Lam", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Stefan", + "last_name": "Winter", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Anjiang", + "last_name": "Wei", + "institution": "Peking University" + }, + { + "first_name": "Tao", + "last_name": "Xie", + "institution": "Peking University" + }, + { + "first_name": "Darko", + "last_name": "Marinov", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Jonathan", + "last_name": "Bell", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/Lam0W0M020", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428271", + "title": "Differentially-private software frequency profiling under linear constraints", + "abstract": "Differential privacy has emerged as a leading theoretical framework for privacy-preserving data gathering and analysis. It allows meaningful statistics to be collected for a population without revealing ``too much'' information about any individual member of the population. For software profiling, this machinery allows profiling data from many users of a deployed software system to be collected and analyzed in a privacy-preserving manner. Such a solution is appealing to many stakeholders, including software users, software developers, infrastructure providers, and government agencies. We propose an approach for differentially-private collection of frequency vectors from software executions. Frequency information is reported with the addition of random noise drawn from the Laplace distribution. A key observation behind the design of our scheme is that event frequencies are closely correlated due to the static code structure. Differential privacy protections must account for such relationships; otherwise, a seemingly-strong privacy guarantee is actually weaker than it appears. Motivated by this observation, we propose a novel and general differentially-private profiling scheme when correlations between frequencies can be expressed through linear inequalities. Using a linear programming formulation, we show how to determine the magnitude of random noise that should be added to achieve meaningful privacy protections under such linear constraints. Next, we develop an efficient instance of this general machinery for an important subclass of constraints. Instead of LP, our solution uses a reachability analysis of a constraint graph. As an exemplar, we employ this approach to implement differentially-private method frequency profiling for Android apps. Any differentially-private scheme has to balance two competing aspects: privacy and accuracy. Through an experimental study to characterize these trade-offs, we (1) show that our proposed randomization achieves much higher accuracy compared to related prior work, (2) demonstrate that high accuracy and high privacy protection can be achieved simultaneously, and (3) highlight the importance of linear constraints in the design of the randomization. These promising results provide evidence that our approach is a good candidate for privacy-preserving frequency profiling of deployed software.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428271", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hailong", + "last_name": "Zhang", + "institution": "Fordham University" + }, + { + "first_name": "Yu", + "last_name": "Hao", + "institution": "The Ohio State University" + }, + { + "first_name": "Sufian", + "last_name": "Latif", + "institution": "The Ohio State University" + }, + { + "first_name": "Raef", + "last_name": "Bassily", + "institution": "The Ohio State University" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + } + ], + "dblp_key": "journals/pacmpl/0006HLBR20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428272", + "title": "Do you have space for dessert? a verified space cost semantics for CakeML programs", + "abstract": "Garbage collectors relieve the programmer from manual memory management, but lead to compiler-generated machine code that can behave differently (e.g. out-of-memory errors) from the source code. To ensure that the generated code behaves exactly like the source code, programmers need a way to answer questions of the form: what is a sufficient amount of memory for my program to never reach an out-of-memory error? This paper develops a cost semantics that can answer such questions for CakeML programs. The work described in this paper is the first to be able to answer such questions with proofs in the context of a language that depends on garbage collection. We demonstrate that positive answers can be used to transfer liveness results proved for the source code to liveness guarantees about the generated machine code. Without guarantees about space usage, only safety results can be transferred from source to machine code. Our cost semantics is phrased in terms of an abstract intermediate language of the CakeML compiler, but results proved at that level map directly to the space cost of the compiler-generated machine code. All of the work described in this paper has been developed in the HOL4 theorem prover.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428272", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Gómez-Londoño", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Johannes Åman", + "last_name": "Pohjola", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Hira", + "last_name": "Syeda", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Yong Kiam", + "last_name": "Tan", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/Gomez-LondonoPS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428273", + "title": "Digging for fold: synthesis-aided API discovery for Haskell", + "abstract": "We present Hoogle+, a web-based API discovery tool for Haskell. A Hoogle+ user can specify a programming task using either a type, a set of input-output tests, or both. Given a specification, the tool returns a list of matching programs composed from functions in popular Haskell libraries, and annotated with automatically-generated examples of their behavior. These features of Hoogle+ are powered by three novel techniques. First, to enable efficient type-directed synthesis from tests only, we develop an algorithm that infers likely type specifications from tests . Second, to return high-quality programs even with ambiguous specifications, we develop a technique that automatically eliminates meaningless and repetitive synthesis results . Finally, we show how to extend this elimination technique to automatically generate informative inputs that can be used to demonstrate program behavior to the user. To evaluate the effectiveness of Hoogle+ compared with traditional API search techniques, we perform a user study with 30 participants of varying Haskell proficiency. The study shows that programmers equipped with Hoogle+ generally solve tasks faster and were able to solve 50% more tasks overall.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428273", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael B.", + "last_name": "James", + "institution": "University of California, San Diego" + }, + { + "first_name": "Zheng", + "last_name": "Guo", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ziteng", + "last_name": "Wang", + "institution": "University of California, San Diego" + }, + { + "first_name": "Shivani", + "last_name": "Doshi", + "institution": "University of California, San Diego" + }, + { + "first_name": "Hila", + "last_name": "Peleg", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/JamesGWDPJP20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428274", + "title": "Resolution as intersection subtyping via Modus Ponens", + "abstract": "Resolution and subtyping are two common mechanisms in programming languages. Resolution is used by features such as type classes or Scala-style implicits to synthesize values automatically from contextual type information. Subtyping is commonly used to automatically convert the type of a value into another compatible type. So far the two mechanisms have been considered independently of each other. This paper shows that, with a small extension, subtyping with intersection types can subsume resolution. This has three main consequences. Firstly, resolution does not need to be implemented as a separate mechanism. Secondly, the interaction between resolution and subtyping becomes apparent. Finally, the integration of resolution into subtyping enables first-class (implicit) environments. The extension that recovers the power of resolution via subtyping is the modus ponens rule of propositional logic. While it is easily added to declarative subtyping, significant care needs to be taken to retain desirable properties, such as transitivity and decidability of algorithmic subtyping, and coherence. To materialize these ideas we develop λ i MP , a calculus that extends a iprevious calculus with disjoint intersection types, and develop its metatheory in the Coq theorem prover.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428274", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Koar", + "last_name": "Marntirosian", + "institution": "KU Leuven" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Georgios", + "last_name": "Karachalias", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/MarntirosianSOK20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428275", + "title": "World age in Julia: optimizing method dispatch in the presence of eval", + "abstract": "Dynamic programming languages face semantic and performance challenges in the presence of features, such as eval, that can inject new code into a running program. The Julia programming language introduces the novel concept of world age to insulate optimized code from one of the most disruptive side-effects of eval: changes to the definition of an existing function. This paper provides the first formal semantics of world age in a core calculus named juliette, and shows how world age enables compiler optimizations, such as inlining, in the presence of eval. While Julia also provides programmers with the means to bypass world age, we found that this mechanism is not used extensively: a static analysis of over 4,000 registered Julia packages shows that only 4-9% of packages bypass world age. This suggests that Julia's semantics aligns with programmer expectations.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428275", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Julia", + "last_name": "Belyakova", + "institution": "Northeastern University" + }, + { + "first_name": "Benjamin", + "last_name": "Chung", + "institution": "Northeastern University" + }, + { + "first_name": "Jack", + "last_name": "Gelinas", + "institution": "Northeastern University" + }, + { + "first_name": "Jameson", + "last_name": "Nash", + "institution": "" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/BelyakovaCGNTV20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428276", + "title": "ιDOT: a DOT calculus with object initialization", + "abstract": "The Dependent Object Types (DOT) calculus serves as a foundation of the Scala programming language, with a machine-verified soundness proof. However, Scala's type system has been shown to be unsound due to null references, which are used as default values of fields of objects before they have been initialized. This paper proposes ιDOT, an extension of DOT for ensuring safe initialization of objects. DOT was previously extended to κDOT with the addition of mutable fields and constructors. To κDOT, ιDOT adds an initialization effect system that statically prevents the possibility of reading a null reference from an uninitialized object. To design ιDOT, we have reformulated the Freedom Before Commitment object initialization scheme in terms of disjoint subheaps to make it easier to formalize in an effect system and prove sound. Soundness of ιDOT depends on the interplay of three systems of rules: a type system close to that of DOT, an effect system to ensure definite assignment of fields in each constructor, and an initialization system that tracks the initialization status of objects in a stack of subheaps. We have proven the overall system sound and verified the soundness proof using the Coq proof assistant.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428276", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ifaz", + "last_name": "Kabir", + "institution": "University of Alberta" + }, + { + "first_name": "Yu-Feng", + "last_name": "Li", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/KabirLL20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428278", + "title": "Testing consensus implementations using communication closure", + "abstract": "Large scale production distributed systems are difficult to design and test. Correctness must be ensured when processes run asynchronously, at arbitrary rates relative to each other, and in the presence of failures, e.g., process crashes or message losses. These conditions create a huge space of executions that is difficult to explore in a principled way. Current testing techniques focus on systematic or randomized exploration of all executions of an implementation while treating the implemented algorithms as black boxes. On the other hand, proofs of correctness of many of the underlying algorithms often exploit semantic properties that reduce reasoning about correctness to a subset of behaviors. For example, the communication-closure property, used in many proofs of distributed consensus algorithms, shows that every asynchronous execution of the algorithm is equivalent to a lossy synchronous execution, thus reducing the burden of proof to only that subset. In a lossy synchronous execution, processes execute in lock-step rounds, and messages are either received in the same round or lost forever—such executions form a small subset of all asynchronous ones. We formulate the communication-closure hypothesis , which states that bugs in implementations of distributed consensus algorithms will already manifest in lossy synchronous executions and present a testing algorithm based on this hypothesis. We prioritize the search space based on a bound on the number of failures in the execution and the rate at which these failures are recovered. We show that a random testing algorithm based on sampling lossy synchronous executions can empirically find a number of bugs—including previously unknown ones—in production distributed systems such as Zookeeper, Cassandra, and Ratis, and also produce more understandable bug traces.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428278", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cezara", + "last_name": "Drăgoi", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Burcu Kulahcioglu", + "last_name": "Ozkan", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Filip", + "last_name": "Niksic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/DragoiEOMN20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428277", + "title": "Taming callbacks for smart contract modularity", + "abstract": "Callbacks are an effective programming discipline for implementing event-driven programming, especially in environments like Ethereum which forbid shared global state and concurrency. Callbacks allow a callee to delegate the execution back to the caller. Though effective, they can lead to subtle mistakes principally in open environments where callbacks can be added in a new code. Indeed, several high profile bugs in smart contracts exploit callbacks. We present the first static technique ensuring modularity in the presence of callbacks and apply it to verify prominent smart contracts. Modularity ensures that external calls to other contracts cannot affect the behavior of the contract. Importantly, modularity is guaranteed without restricting programming. In general, checking modularity is undecidable—even for programs without loops. This paper describes an effective technique for soundly ensuring modularity harnessing SMT solvers. The main idea is to define a constructive version of modularity using commutativity and projection operations on program segments. We believe that this approach is also accessible to programmers, since counterexamples to modularity can be generated automatically by the SMT solvers, allowing programmers to understand and fix the error. We implemented our approach in order to demonstrate the precision of the modularity analysis and applied it to real smart contracts, including a subset of the 150 most active contracts in Ethereum. Our implementation decompiles bytecode programs into an intermediate representation and then implements the modularity checking using SMT queries. Overall, we argue that our experimental results indicate that the method can be applied to many realistic contracts, and that it is able to prove modularity where other methods fail.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428277", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Elvira", + "last_name": "Albert", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Shelly", + "last_name": "Grossman", + "institution": "Tel Aviv University" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Clara", + "last_name": "Rodríguez-Núñez", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Albert", + "last_name": "Rubio", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/AlbertGRRRS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428279", + "title": "Finding bugs in database systems via query partitioning", + "abstract": "Logic bugs in Database Management Systems (DBMSs) are bugs that cause an incorrect result for a given query, for example, by omitting a row that should be fetched. These bugs are critical, since they are likely to go unnoticed by users. We propose Query Partitioning, a general and effective approach for finding logic bugs in DBMSs. The core idea of Query Partitioning is to, starting from a given original query, derive multiple, more complex queries (called partitioning queries), each of which computes a partition of the result. The individual partitions are then composed to compute a result set that must be equivalent to the original query's result set. A bug in the DBMS is detected when these result sets differ. Our intuition is that due to the increased complexity, the partitioning queries are more likely to stress the DBMS and trigger a logic bug than the original query. As a concrete instance of a partitioning strategy, we propose Ternary Logic Partitioning (TLP), which is based on the observation that a boolean predicate p can either evaluate to TRUE, FALSE, or NULL. Accordingly, a query can be decomposed into three partitioning queries, each of which computes its result on rows or intermediate results for which p, NOT p, and p IS NULL hold. This technique is versatile, and can be used to test WHERE, GROUP BY, as well as HAVING clauses, aggregate functions, and DISTINCT queries. As part of an extensive testing campaign, we found 175 bugs in widely-used DBMSs such as MySQL, TiDB, SQLite, and CockroachDB, 125 of which have been fixed. Notably, 77 of these were logic bugs, while the remaining were error and crash bugs. We expect that the effectiveness and wide applicability of Query Partitioning will lead to its broad adoption in practice, and the formulation of additional partitioning strategies.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428279", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Rigger", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/RiggerS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428280", + "title": "Structure interpretation of text formats", + "abstract": "Data repositories often consist of text files in a wide variety of standard formats, ad-hoc formats, as well as mixtures of formats where data in one format is embedded into a different format. It is therefore a significant challenge to parse these files into a structured tabular form, which is important to enable any downstream data processing. We present Unravel, an extensible framework for structure interpretation of ad-hoc formats. Unravel can automatically, with no user input, extract tabular data from a diverse range of standard, ad-hoc and mixed format files. The framework is also easily extensible to add support for previously unseen formats, and also supports interactivity from the user in terms of examples to guide the system when specialized data extraction is desired. Our key insight is to allow arbitrary combination of extraction and parsing techniques through a concept called partial structures . Partial structures act as a common language through which the file structure can be shared and refined by different techniques. This makes Unravel more powerful than applying the individual techniques in parallel or sequentially. Further, with this rule-based extensible approach, we introduce the novel notion of re-interpretation where the variety of techniques supported by our system can be exploited to improve accuracy while optimizing for particular quality measures or restricted environments. On our benchmark of 617 text files gathered from a variety of sources, Unravel is able to extract the intended table in many more cases compared to state-of-the-art techniques.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428280", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ivan", + "last_name": "Radiček", + "institution": "" + }, + { + "first_name": "Mohammad", + "last_name": "Raza", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/GulwaniLRRR20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428282", + "title": "Actor concurrency bugs: a comprehensive study on symptoms, root causes, API usages, and differences", + "abstract": "Actor concurrency is becoming increasingly important in the development of real-world software systems. Although actor concurrency may be less susceptible to some multithreaded concurrency bugs, such as low-level data races and deadlocks, it comes with its own bugs that may be different. However, the fundamental characteristics of actor concurrency bugs, including their symptoms, root causes, API usages, examples, and differences when they come from different sources are still largely unknown. Actor software development can significantly benefit from a comprehensive qualitative and quantitative understanding of these characteristics, which is the focus of this work, to foster better API documentation, development practices, testing, debugging, repairing, and verification frameworks. To conduct this study, we take the following major steps. First, we construct a set of 186 real-world Akka actor bugs from Stack Overflow and GitHub via manual analysis of 3,924 Stack Overflow questions, answers, and comments and 3,315 GitHub commits, messages, original and modified code snippets, issues, and pull requests. Second, we manually study these actor bugs and their fixes to understand and classify their symptoms, root causes, and API usages. Third, we study the differences between the commonalities and distributions of symptoms, root causes, and API usages of our Stack Overflow and GitHub actor bugs. Fourth, we discuss real-world examples of our actor bugs with these symptoms and root causes. Finally, we investigate the relation of our findings with those of previous work and discuss their implications. A few findings of our study are: (1) symptoms of our actor bugs can be classified into five categories, with Error as the most common symptom and Incorrect Exceptions as the least common, (2) root causes of our actor bugs can be classified into ten categories, with Logic as the most common root cause and Untyped Communication as the least common, (3) a small number of Akka API packages are responsible for most of API usages by our actor bugs, and (4) our Stack Overflow and GitHub actor bugs can differ significantly in commonalities and distributions of their symptoms, root causes, and API usages. While some of our findings agree with those of previous work, others sharply contrast.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428282", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mehdi", + "last_name": "Bagherzadeh", + "institution": "Oakland University" + }, + { + "first_name": "Nicholas", + "last_name": "Fireman", + "institution": "Oakland University" + }, + { + "first_name": "Anas", + "last_name": "Shawesh", + "institution": "Oakland University" + }, + { + "first_name": "Raffi", + "last_name": "Khatchadourian", + "institution": "City University of New York" + } + ], + "dblp_key": "journals/pacmpl/0001FSK20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428281", + "title": "Programming at the edge of synchrony", + "abstract": "Synchronization primitives for fault-tolerant distributed systems that ensure an effective and efficient cooperation among processes are an important challenge in the programming languages community. We present a new programming abstraction, ReSync, for implementing benign and Byzantine fault-tolerant protocols. ReSync has a new round structure that offers a simple abstraction for group communication, like it is customary in synchronous systems, but also allows messages to be received one by one, like in the asynchronous systems. This extension allows implementing network and algorithm-specific policies for the message reception, which is not possible in classic round models. The execution of ReSync programs is based on a new generic round switch protocol that generalizes the famous theoretical result about consensus in the presence of partial synchrony by of Dwork, Lynch, and Stockmeyer. We evaluate experimentally the performance of ReSync’s execution platform, by comparing consensus implementations in ReSync with LibPaxos3, etcd, and Bft-SMaRt, three consensus libraries tolerant to benign, resp. byzantine faults.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428281", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cezara", + "last_name": "Drăgoi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Josef", + "last_name": "Widder", + "institution": "TU Wien" + }, + { + "first_name": "Damien", + "last_name": "Zufferey", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/DragoiWZ20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428283", + "title": "A structural model for contextual code changes", + "abstract": "We address the problem of predicting edit completions based on a learned model that was trained on past edits. Given a code snippet that is partially edited, our goal is to predict a completion of the edit for the rest of the snippet . We refer to this task as the EditCompletion task and present a novel approach for tackling it. The main idea is to directly represent structural edits. This allows us to model the likelihood of the edit itself, rather than learning the likelihood of the edited code. We represent an edit operation as a path in the program’s Abstract Syntax Tree (AST), originating from the source of the edit to the target of the edit. Using this representation, we present a powerful and lightweight neural model for the EditCompletion task. We conduct a thorough evaluation, comparing our approach to a variety of representation and modeling approaches that are driven by multiple strong models such as LSTMs, Transformers, and neural CRFs. Our experiments show that our model achieves a 28% relative gain over state-of-the-art sequential models and 2× higher accuracy than syntactic models that learn to generate the edited code , as opposed to modeling the edits directly. Our code, dataset, and trained models are publicly available at <a>https://github.com/tech-srl/c3po/</a> .", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428283", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shaked", + "last_name": "Brody", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Uri", + "last_name": "Alon", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/Brody0Y20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428284", + "title": "Verifying replicated data types with typeclass refinements in Liquid Haskell", + "abstract": "This paper presents an extension to Liquid Haskell that facilitates stating and semi-automatically proving properties of typeclasses. Liquid Haskell augments Haskell with refinement types —our work allows such types to be attached to typeclass method declarations, and ensures that instance implementations respect these types. The engineering of this extension is a modular interaction between GHC, the Glasgow Haskell Compiler, and Liquid Haskell’s core proof infrastructure. The design sheds light on the interplay between modular proofs and typeclass resolution, which in Haskell is coherent by default (meaning that resolution always selects the same implementation for a particular instantiating type), but in other dependently typed languages is not. We demonstrate the utility of our extension by using Liquid Haskell to modularly verify that 34 instances satisfy the laws of five standard typeclasses. More substantially, we implement a framework for programming distributed applications based on replicated data types (RDTs). We define a typeclass whose Liquid Haskell type captures the mathematical properties RDTs should satisfy; prove in Liquid Haskell that these properties are sufficient to ensure that replicas’ states converge despite out-of-order update delivery; implement (and prove correct) several instances of our RDT typeclass; and use them to build two realistic applications, a multi-user calendar event planner and a collaborative text editor.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428284", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yiyun", + "last_name": "Liu", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "James", + "last_name": "Parker", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Patrick", + "last_name": "Redmond", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "IMDEA Software Institute" + } + ], + "dblp_key": "journals/pacmpl/LiuPRK0V20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428285", + "title": "Unifying execution of imperative generators and declarative specifications", + "abstract": "We present Deuterium---a framework for implementing Java methods as executable contracts. Deuterium introduces a novel, type-safe way to write method contracts entirely in Java, as a combination of imperative generators and declarative specifications (written in a first-order relational logic with transitive closure). Existing approaches are typically based on encoding both the specification and the program heap into a constraint language, and then using an off-the-shelf constraint solver---without any additional guidance---to search for a new program heap that satisfies the specification. Deuterium takes advantage of user-provided generators to prune the search space and reduce incurred overhead of constraint solving. Deuterium supports two ways of solving declarative constraints: SAT-based and search-based with in-memory state exploration. We evaluate our approach on a suite of data structures, established as a standard benchmark by prior work. Furthermore, we use random and sequence-based test generation to create a new benchmark designed to mimic realistic execution scenarios. Our results show that generators improve the performance of executable contracts and that in-memory state exploration is the algorithm of choice when heap sizes are small.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428285", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pengyu", + "last_name": "Nie", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Marinela", + "last_name": "Parovic", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Zhiqiang", + "last_name": "Zang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Aleksandar", + "last_name": "Milićević", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Milos", + "last_name": "Gligoric", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/NiePZKMG20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428286", + "title": "Regex matching with counting-set automata", + "abstract": "We propose a solution to the problem of efficient matching regular expressions (regexes) with bounded repetition, such as (ab){1,100}, using deterministic automata. For this, we introduce novel counting-set automata (CsAs) , automata with registers that can hold sets of bounded integers and can be manipulated by a limited portfolio of constant-time operations. We present an algorithm that compiles a large sub-class of regexes to deterministic CsAs. This includes (1) a novel Antimirov-style translation of regexes with counting to counting automata (CAs) , nondeterministic automata with bounded counters, and (2) our main technical contribution, a determinization of CAs that outputs CsAs. The main advantage of this workflow is that the size of the produced CsAs does not depend on the repetition bounds used in the regex (while the size of the DFA is exponential to them). Our experimental results confirm that deterministic CsAs produced from practical regexes with repetition are indeed vastly smaller than the corresponding DFAs. More importantly, our prototype matcher based on CsA simulation handles practical regexes with repetition regardless of sizes of counter bounds. It easily copes with regexes with repetition where state-of-the-art matchers struggle.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428286", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lenka", + "last_name": "Turoňová", + "institution": "Brno University of Technology" + }, + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" + }, + { + "first_name": "Ondřej", + "last_name": "Lengál", + "institution": "Brno University of Technology" + }, + { + "first_name": "Olli", + "last_name": "Saarikivi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tomáš", + "last_name": "Vojnar", + "institution": "Brno University of Technology" + } + ], + "dblp_key": "journals/pacmpl/TuronovaHLSVV20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428287", + "title": "Feedback-driven semi-supervised synthesis of program transformations", + "abstract": "While editing code, it is common for developers to make multiple related repeated edits that are all instances of a more general program transformation. Since this process can be tedious and error-prone, we study the problem of automatically learning program transformations from past edits, which can then be used to predict future edits. We take a novel view of the problem as a semi-supervised learning problem: apart from the concrete edits that are instances of the general transformation, the learning procedure also exploits access to additional inputs (program subtrees) that are marked as positive or negative depending on whether the transformation applies on those inputs. We present a procedure to solve the semi-supervised transformation learning problem using anti-unification and programming-by-example synthesis technology. To eliminate reliance on access to marked additional inputs, we generalize the semi-supervised learning procedure to a feedback-driven procedure that also generates the marked additional inputs in an iterative loop. We apply these ideas to build and evaluate three applications that use different mechanisms for generating feedback. Compared to existing tools that learn program transformations from edits, our feedback-driven semi-supervised approach is vastly more effective in successfully predicting edits with significantly lesser amounts of past edit data.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428287", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xiang", + "last_name": "Gao", + "institution": "National University of Singapore" + }, + { + "first_name": "Shraddha", + "last_name": "Barke", + "institution": "University of California, San Diego" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gustavo", + "last_name": "Soares", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Alan", + "last_name": "Leung", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nachiappan", + "last_name": "Nagappan", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/GaoBRSGLN020", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428288", + "title": "Contextual dispatch for function specialization", + "abstract": "In order to generate efficient code, dynamic language compilers often need information, such as dynamic types, not readily available in the program source. Leveraging a mixture of static and dynamic information, these compilers speculate on the missing information. Within one compilation unit, they specialize the generated code to the previously observed behaviors, betting that past is prologue. When speculation fails, the execution must jump back to unoptimized code. In this paper, we propose an approach to further the specialization, by disentangling classes of behaviors into separate optimization units. With contextual dispatch, functions are versioned and each version is compiled under different assumptions. When a function is invoked, the implementation dispatches to a version optimized under assumptions matching the dynamic context of the call. As a proof-of-concept, we describe a compiler for the R language which uses this approach. Our implementation is, on average, 1.7× faster than the GNU R reference implementation. We evaluate contextual dispatch on a set of benchmarks and measure additional speedup, on top of traditional speculation with deoptimization techniques. In this setting contextual dispatch improves the performance of 18 out of 46 programs in our benchmark suite.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428288", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Flückiger", + "institution": "Northeastern University" + }, + { + "first_name": "Guido", + "last_name": "Chari", + "institution": "" + }, + { + "first_name": "Ming‐Ho", + "last_name": "Yee", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Ječmen", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Jakob", + "last_name": "Hain", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/FluckigerCYJHV20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428290", + "title": "Adding interactive visual syntax to textual code", + "abstract": "Many programming problems call for turning geometrical thoughts into code: tables, hierarchical structures, nests of objects, trees, forests, graphs, and so on. Linear text does not do justice to such thoughts. But, it has been the dominant programming medium for the past and will remain so for the foreseeable future. This paper proposes a novel mechanism for conveniently extending textual programming languages with problem-specific visual syntax. It argues the necessity of this language feature, demonstrates the feasibility with a robust prototype, and sketches a design plan for adapting the idea to other languages.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428290", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Leif", + "last_name": "Andersen", + "institution": "Northeastern University" + }, + { + "first_name": "Michael", + "last_name": "Ballantyne", + "institution": "Northeastern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/AndersenBF20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428289", + "title": "Counterexample-guided correlation algorithm for translation validation", + "abstract": "Automatic translation validation across the unoptimized intermediate representation (IR) of the original source code and the optimized executable assembly code is a desirable capability, and has the potential to compete with existing approaches to verified compilation such as CompCert. A difficult subproblem is the automatic identification of the correlations across the transitions between the two programs' respective locations. We present a counterexample-guided algorithm to identify these correlations in a robust and scalable manner. Our algorithm has both theoretical and empirical advantages over prior work in this problem space.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428289", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shubhani", + "last_name": "Gupta", + "institution": "Indian Institute of Technology Delhi" + }, + { + "first_name": "Abhishek", + "last_name": "Rose", + "institution": "Indian Institute of Technology Delhi" + }, + { + "first_name": "Sorav", + "last_name": "Bansal", + "institution": "Indian Institute of Technology Delhi" + } + ], + "dblp_key": "journals/pacmpl/GuptaRB20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428291", + "title": "Revisiting iso-recursive subtyping", + "abstract": "The Amber rules are well-known and widely used for subtyping iso-recursive types. They were first briefly and informally introduced in 1985 by Cardelli in a manuscript describing the Amber language. Despite their use over many years, important aspects of the metatheory of the iso-recursive style Amber rules have not been studied in depth or turn out to be quite challenging to formalize. This paper aims to revisit the problem of subtyping iso-recursive types. We start by introducing a novel declarative specification that we believe captures the “spirit” of Amber-style iso-recursive subtyping. Informally, the specification states that two recursive types are subtypes if all their finite unfoldings are subtypes . The Amber rules are shown to be sound with respect to this declarative specification. We then derive a sound , complete and decidable algorithmic formulation of subtyping that employs a novel double unfolding rule. Compared to the Amber rules, the double unfolding rule has the advantage of: 1) being modular; 2) not requiring reflexivity to be built in; and 3) leading to an easy proof of transitivity of subtyping. This work sheds new insights on the theory of subtyping iso-recursive types, and the new double unfolding rule has important advantages over the original Amber rules for both implementations and metatheoretical studies involving recursive types. All results are mechanically formalized in the Coq theorem prover. As far as we know, this is the first comprehensive treatment of iso-recursive subtyping dealing with unrestricted recursive types in a theorem prover.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428291", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yaoda", + "last_name": "Zhou", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Jinxu", + "last_name": "Zhao", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/ZhouOZ20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428292", + "title": "Guiding dynamic programing via structural probability for accelerating programming by example", + "abstract": "Programming by example (PBE) is an important subproblem of program synthesis, and PBE techniques have been applied to many domains. Though many techniques for accelerating PBE systems have been explored, the scalability remains one of the main challenges: There is still a gap between the performances of state-of-the-art synthesizers and the industrial requirement. To further speed up solving PBE tasks, in this paper, we propose a novel PBE framework MaxFlash. MaxFlash uses a model based on structural probability, named topdown prediction models, to guide a search based on dynamic programming, such that the search will focus on subproblems that form probable programs, and avoid improbable programs. Our evaluation shows that MaxFlash achieves × 4.107− × 2080 speed-ups against state-of-the-art solvers on 244 real-world tasks.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428292", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ruyi", + "last_name": "Ji", + "institution": "Peking University" + }, + { + "first_name": "Yican", + "last_name": "Sun", + "institution": "Peking University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/JiS0H20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428295", + "title": "Just-in-time learning for bottom-up enumerative synthesis", + "abstract": "A key challenge in program synthesis is the astronomical size of the search space the synthesizer has to explore. In response to this challenge, recent work proposed to guide synthesis using learned probabilistic models. Obtaining such a model, however, might be infeasible for a problem domain where no high-quality training data is available. In this work we introduce an alternative approach to guided program synthesis: instead of training a model ahead of time we show how to bootstrap one just in time, during synthesis, by learning from partial solutions encountered along the way. To make the best use of the model, we also propose a new program enumeration algorithm we dub guided bottom-up search, which extends the efficient bottom-up search with guidance from probabilistic models. We implement this approach in a tool called Probe, which targets problems in the popular syntax-guided synthesis (SyGuS) format. We evaluate Probe on benchmarks from the literature and show that it achieves significant performance gains both over unguided bottom-up search and over a state-of-the-art probability-guided synthesizer, which had been trained on a corpus of existing solutions. Moreover, we show that these performance gains do not come at the cost of solution quality: programs generated by Probe are only slightly more verbose than the shortest solutions and perform no unnecessary case-splitting.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428295", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shraddha", + "last_name": "Barke", + "institution": "University of California, San Diego" + }, + { + "first_name": "Hila", + "last_name": "Peleg", + "institution": "University of California, San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "journals/pacmpl/BarkePP20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428297", + "title": "Macros for domain-specific languages", + "abstract": "Macros provide a powerful means of extending languages. They have proven useful in both general-purpose and domain-specific programming contexts. This paper presents an architecture for implementing macro-extensible DSLs on top of macro-extensible host languages. The macro expanders of these DSLs inherit the syntax system, hygienic expansion, and more from the host. They transform the extensible DSL syntax into a DSL core language. This arrangement has several important consequences. It becomes straightforward to integrate the syntax of various DSLs and the host language when their expanders share these inherited components. Also, a DSL compiler may be designed around a fixed core language, even for an extensible DSL. Finally, macros empower programmers to safely grow DSLs on their own and tailor them to their needs.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428297", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Ballantyne", + "institution": "Northeastern University" + }, + { + "first_name": "Alexis C.", + "last_name": "King", + "institution": "Northwestern University" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/BallantyneKF20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428296", + "title": "Gradual verification of recursive heap data structures", + "abstract": "Current static verification techniques do not provide good support for incrementality, making it difficult for developers to focus on specifying and verifying the properties and components that are most important. Dynamic verification approaches support incrementality, but cannot provide static guarantees. To bridge this gap, prior work proposed gradual verification, which supports incrementality by allowing every assertion to be complete, partial, or omitted, and provides sound verification that smoothly scales from dynamic to static checking. The prior approach to gradual verification, however, was limited to programs without recursive data structures. This paper extends gradual verification to programs that manipulate recursive, mutable data structures on the heap. We address several technical challenges, such as semantically connecting iso- and equi-recursive interpretations of abstract predicates, and supporting gradual verification of heap ownership. This work thus lays the foundation for future tools that work on realistic programs and support verification within an engineering process in which cost-benefit trade-offs can be made.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428296", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jenna", + "last_name": "Wise", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Johannes", + "last_name": "Bader", + "institution": "The Jane Goodall Institute" + }, + { + "first_name": "Cameron", + "last_name": "Wong", + "institution": "The Jane Goodall Institute" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Joshua", + "last_name": "Sunshine", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/WiseBWATS20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428294", + "title": "Foundations of empirical memory consistency testing", + "abstract": "Modern memory consistency models are complex, and it is difficult to reason about the relaxed behaviors that current systems allow. Programming languages, such as C and OpenCL, offer a memory model interface that developers can use to safely write concurrent applications. This abstraction provides functional portability across any platform that implements the interface, regardless of differences in the underlying systems. This powerful abstraction hinges on the ability of the system to correctly implement the interface. Many techniques for memory consistency model validation use empirical testing, which has been effective at uncovering undocumented behaviors and even finding bugs in trusted compilation schemes. Memory model testing consists of small concurrent unit tests called “litmus tests”. In these tests, certain observations, including potential bugs , are exceedingly rare, as they may only be triggered by precise interleaving of system steps in a complex processor, which is probabilistic in nature. Thus, each test must be run many times in order to provide a high level of confidence in its coverage. In this work, we rigorously investigate empirical memory model testing. In particular, we propose methodologies for navigating complex stressing routines and analyzing large numbers of testing observations. Using these insights, we can more efficiently tune stressing parameters, which can lead to higher confidence results at a faster rate. We emphasize the need for such approaches by performing a meta-study of prior work, which reveals results with low reproducibility and inefficient use of testing time. Our investigation is presented alongside empirical data. We believe that OpenCL targeting GPUs is a pragmatic choice in this domain as there exists a variety of different platforms to test, from large HPC servers to power-efficient edge devices. The tests presented in the work span 3 GPUs from 3 different vendors. We show that our methodologies are applicable across the GPUs, despite significant variances in the results. Concretely, our results show: lossless speedups of more than 5× in tuning using data peeking; a definition of portable stressing parameters which loses only 12% efficiency when generalized across our domain; a priority order of litmus tests for tuning. We stress test a conformance test suite for the OpenCL 2.0 memory model and discover a bug in Intel’s compiler. Our methods are evaluated on the other two GPUs using mutation testing. We end with recommendations for official memory model conformance tests.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428294", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jake", + "last_name": "Kirkham", + "institution": "Princeton University" + }, + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Esin", + "last_name": "Türeci", + "institution": "Princeton University" + }, + { + "first_name": "Margaret", + "last_name": "Martonosi", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/Kirkham0TM20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428293", + "title": "Neural reverse engineering of stripped binaries using augmented control flow graphs", + "abstract": "We address the problem of reverse engineering of stripped executables, which contain no debug information. This is a challenging problem because of the low amount of syntactic information available in stripped executables, and the diverse assembly code patterns arising from compiler optimizations. We present a novel approach for predicting procedure names in stripped executables. Our approach combines static analysis with neural models. The main idea is to use static analysis to obtain augmented representations of call sites; encode the structure of these call sites using the control-flow graph (CFG) and finally, generate a target name while attending to these call sites. We use our representation to drive graph-based, LSTM-based and Transformer-based architectures. Our evaluation shows that our models produce predictions that are difficult and time consuming for humans, while improving on existing methods by 28% and by 100% over state-of-the-art neural textual models that do not use any static analysis. Code and data for this evaluation are available at https://github.com/tech-srl/Nero.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428293", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yaniv", + "last_name": "David", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Uri", + "last_name": "Alon", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Yahav", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/David0Y20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428301", + "title": "Flow2Vec: value-flow-based precise code embedding", + "abstract": "Code embedding, as an emerging paradigm for source code analysis, has attracted much attention over the past few years. It aims to represent code semantics through distributed vector representations, which can be used to support a variety of program analysis tasks (e.g., code summarization and semantic labeling). However, existing code embedding approaches are intraprocedural, alias-unaware and ignoring the asymmetric transitivity of directed graphs abstracted from source code, thus they are still ineffective in preserving the structural information of code. This paper presents Flow2Vec, a new code embedding approach that precisely preserves interprocedural program dependence (a.k.a value-flows). By approximating the high-order proximity, i.e., the asymmetric transitivity of value-flows, Flow2Vec embeds control-flows and alias-aware data-flows of a program in a low-dimensional vector space. Our value-flow embedding is formulated as matrix multiplication to preserve context-sensitive transitivity through CFL reachability by filtering out infeasible value-flow paths. We have evaluated Flow2Vec using 32 popular open-source projects. Results from our experiments show that Flow2Vec successfully boosts the performance of two recent code embedding approaches codevec and codeseq for two client applications, i.e., code classification and code summarization. For code classification, Flow2Vec improves codevec with an average increase of 21.2%, 20.1% and 20.7% in precision, recall and F1, respectively. For code summarization, Flow2Vec outperforms codeseq by an average of 13.2%, 18.8% and 16.0% in precision, recall and F1, respectively.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428301", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Xiao", + "last_name": "Cheng", + "institution": "Beijing University of Posts and Telecommunications" + }, + { + "first_name": "Guanqin", + "last_name": "Zhang", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Haoyu", + "last_name": "Wang", + "institution": "Beijing University of Posts and Telecommunications" + } + ], + "dblp_key": "journals/pacmpl/SuiCZ020", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428298", + "title": "Learning-based controlled concurrency testing", + "abstract": "Concurrency bugs are notoriously hard to detect and reproduce. Controlled concurrency testing (CCT) techniques aim to offer a solution, where a scheduler explores the space of possible interleavings of a concurrent program looking for bugs. Since the set of possible interleavings is typically very large, these schedulers employ heuristics that prioritize the search to “interesting” subspaces. However, current heuristics are typically tuned to specific bug patterns, which limits their effectiveness in practice. In this paper, we present QL, a learning-based CCT framework where the likelihood of an action being selected by the scheduler is influenced by earlier explorations. We leverage the classical Q-learning algorithm to explore the space of possible interleavings, allowing the exploration to adapt to the program under test, unlike previous techniques. We have implemented and evaluated QL on a set of microbenchmarks, complex protocols, as well as production cloud services. In our experiments, we found QL to consistently outperform the state-of-the-art in CCT.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428298", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Suvam", + "last_name": "Mukherjee", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Pantazis", + "last_name": "Deligiannis", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arpita", + "last_name": "Biswas", + "institution": "" + }, + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "journals/pacmpl/MukherjeeDBL20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428300", + "title": "Koord: a language for programming and verifying distributed robotics application", + "abstract": "A robot’s code needs to sense the environment, control the hardware, and communicate with other robots. Current programming languages do not provide suitable abstractions that are independent of hardware platforms. Currently, developing robot applications requires detailed knowledge of signal processing, control, path planning, network protocols, and various platform-specific details. Further, porting applications across hardware platforms remains tedious. We present Koord—a domain specific language for distributed robotics—which abstracts platform-specific functions for sensing, communication, and low-level control. Koord makes the platform-independent control and coordination code portable and modularly verifiable. Koord raises the level of abstraction in programming by providing distributed shared memory for coordination and port interfaces for sensing and control. We have developed the formal executable semantics of Koord in the K framework. With this symbolic execution engine, we can identify assumptions (proof obligations) needed for gaining high assurance from Koord applications. We illustrate the power of Koord through three applications: formation flight, distributed delivery, and distributed mapping. We also use the three applications to demonstrate how platform-independent proof obligations can be discharged using the Koord Prover while platform-specific proof obligations can be checked by verifying the obligations using physics-based models and hybrid verification tools.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428300", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ritwika", + "last_name": "Ghosh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Chiao", + "last_name": "Hsieh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Sayan", + "last_name": "Mitra", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/GhoshHMM20", + "venue": "oopsla", + "year": 2020 + }, + { + "paper_id": "10.1145/3428299", + "title": "TacTok: semantics-aware proof synthesis", + "abstract": "Formally verifying software correctness is a highly manual process. However, because verification proof scripts often share structure, it is possible to learn from existing proof scripts to fully automate some formal verification. The goal of this paper is to improve proof script synthesis and enable fully automating more verification. Interactive theorem provers, such as the Coq proof assistant, allow programmers to write partial proof scripts, observe the semantics of the proof state thus far, and then attempt more progress. Knowing the proof state semantics is a significant aid. Recent research has shown that the proof state can help predict the next step. In this paper, we present TacTok, the first technique that attempts to fully automate proof script synthesis by modeling proof scripts using both the partial proof script written thus far and the semantics of the proof state. Thus, TacTok more completely models the information the programmer has access to when writing proof scripts manually. We evaluate TacTok on a benchmark of 26 software projects in Coq, consisting of over 10 thousand theorems. We compare our approach to five tools. Two prior techniques, CoqHammer, the state-of-the-art proof synthesis technique, and ASTactic, a proof script synthesis technique that models proof state. And three new proof script synthesis technique we create ourselves, SeqOnly, which models only the partial proof script and the initial theorem being proven, and WeightedRandom and WeightedGreedy, which use metaheuristic search biased by frequencies of proof tactics in existing, successful proof scripts. We find that TacTok outperforms WeightedRandom and WeightedGreedy, and is complementary to CoqHammer and ASTactic: for 24 out of the 26 projects, TacTok can synthesize proof scripts for some theorems the prior tools cannot. Together with TacTok, 11.5% more theorems can be proven automatically than by CoqHammer alone, and 20.0% than by ASTactic alone. Compared to a combination of CoqHammer and ASTactic, TacTok can prove an additional 3.6% more theorems, proving 115 theorems no tool could previously prove. Overall, our experiments provide evidence that partial proof script and proof state semantics, together, provide useful information for proof script modeling, and that metaheuristic search is a promising direction for proof script synthesis. TacTok is open-source and we make public all our data and a replication package of our experiments.", + "date": "2020-11-13", + "link": "https://doi.org/10.1145/3428299", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emily", + "last_name": "First", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Yuriy", + "last_name": "Brun", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "University of Massachusetts Amherst" + } + ], + "dblp_key": "journals/pacmpl/FirstBG20", + "venue": "oopsla", + "year": 2020 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2021.json b/data/pl_conferences/oopsla/2021.json new file mode 100644 index 0000000..d93b4c1 --- /dev/null +++ b/data/pl_conferences/oopsla/2021.json @@ -0,0 +1,2505 @@ +[ + { + "paper_id": "10.1145/3485493", + "title": "Data-driven abductive inference of library specifications", + "abstract": "Programmers often leverage data structure libraries that provide useful and reusable abstractions. Modular verification of programs that make use of these libraries naturally rely on specifications that capture important properties about how the library expects these data structures to be accessed and manipulated. However, these specifications are often missing or incomplete, making it hard for clients to be confident they are using the library safely. When library source code is also unavailable, as is often the case, the challenge to infer meaningful specifications is further exacerbated. In this paper, we present a novel data-driven abductive inference mechanism that infers specifications for library methods sufficient to enable verification of the library's clients. Our technique combines a data-driven learning-based framework to postulate candidate specifications, along with SMT-provided counterexamples to refine these candidates, taking special care to prevent generating specifications that overfit to sampled tests. The resulting specifications form a minimal set of requirements on the behavior of library implementations that ensures safety of a particular client program. Our solution thus provides a new multi-abduction procedure for precise specification inference of data structure libraries guided by client-side verification tasks. Experimental results on a wide range of realistic OCaml data structure programs demonstrate the effectiveness of the approach.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485493", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Z.", + "last_name": "Zhou", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Robert", + "last_name": "Dickerson", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/ZhouDDJ21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485518", + "title": "Interpretable noninterference measurement and its application to processor designs", + "abstract": "Noninterference measurement quantifies the secret information that might leak to an adversary from what the adversary can observe and influence about the computation. Static and high-fidelity noninterference measurement has been difficult to scale to complex computations, however. This paper scales a recent framework for noninterference measurement to the open-source RISC-V BOOM core as specified in Verilog, through three key innovations: logically characterizing the core’s execution incrementally, applying specific optimizations between each cycle; permitting information to be declassified, to focus leakage measurement to only secret information that cannot be inferred from the declassified information; and interpreting leakage measurements for the analyst in terms of simple rules that characterize when leakage occurs. Case studies on cache-based side channels generally, and on specific instances including Spectre attacks, show that the resulting toolchain, called DINoMe, effectively scales to this modern processor design.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485518", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ziqiao", + "last_name": "Zhou", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Michael K.", + "last_name": "Reiter", + "institution": "Duke University" + } + ], + "dblp_key": "journals/pacmpl/ZhouR21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485505", + "title": "Compilation of sparse array programming models", + "abstract": "This paper shows how to compile sparse array programming languages. A sparse array programming language is an array programming language that supports element-wise application, reduction, and broadcasting of arbitrary functions over dense and sparse arrays with any fill value. Such a language has great expressive power and can express sparse and dense linear and tensor algebra, functions over images, exclusion and inclusion filters, and even graph algorithms. Our compiler strategy generalizes prior work in the literature on sparse tensor algebra compilation to support any function applied to sparse arrays, instead of only addition and multiplication. To achieve this, we generalize the notion of sparse iteration spaces beyond intersections and unions. These iteration spaces are automatically derived by considering how algebraic properties annotated onto functions interact with the fill values of the arrays. We then show how to compile these iteration spaces to efficient code. When compared with two widely-used Python sparse array packages, our evaluation shows that we generate built-in sparse array library features with a performance of 1.4× to 53.7× when measured against PyData/Sparse for user-defined functions and between 0.98× and 5.53× when measured against SciPy/Sparse for sparse array slicing. Our technique outperforms PyData/Sparse by 6.58× to 70.3×, and (where applicable) performs between 0.96× and 28.9× that of a dense NumPy implementation, on end-to-end sparse array applications. We also implement graph linear algebra kernels in our system with a performance of between 0.56× and 3.50× compared to that of the hand-optimized SuiteSparse:GraphBLAS library.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485505", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rawn", + "last_name": "Henry", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Olivia", + "last_name": "Hsu", + "institution": "Stanford University" + }, + { + "first_name": "Rohan", + "last_name": "Yadav", + "institution": "Stanford University" + }, + { + "first_name": "Stephen Y.", + "last_name": "Chou", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Kunle", + "last_name": "Olukotun", + "institution": "Stanford University" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/HenryHYCOAK21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485513", + "title": "Copy-and-patch compilation: a fast compilation algorithm for high-level languages and bytecode", + "abstract": "Fast compilation is important when compilation occurs at runtime, such as query compilers in modern database systems and WebAssembly virtual machines in modern browsers. We present copy-and-patch, an extremely fast compilation technique that also produces good quality code. It is capable of lowering both high-level languages and low-level bytecode programs to binary code, by stitching together code from a large library of binary implementation variants. We call these binary implementations stencils because they have holes where missing values must be inserted during code generation. We show how to construct a stencil library and describe the copy-and-patch algorithm that generates optimized binary code. We demonstrate two use cases of copy-and-patch: a compiler for a high-level C-like language intended for metaprogramming and a compiler for WebAssembly. Our high-level language compiler has negligible compilation cost: it produces code from an AST in less time than it takes to construct the AST. We have implemented an SQL database query compiler on top of this metaprogramming system and show that on TPC-H database benchmarks, copy-and-patch generates code two orders of magnitude faster than LLVM -O0 and three orders of magnitude faster than higher optimization levels. The generated code runs an order of magnitude faster than interpretation and 14% faster than LLVM -O0. Our WebAssembly compiler generates code 4.9X-6.5X faster than Liftoff, the WebAssembly baseline compiler in Google Chrome. The generated code also outperforms Liftoff's by 39%-63% on the Coremark and PolyBenchC WebAssembly benchmarks.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485513", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haoran", + "last_name": "Xu", + "institution": "Stanford University" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/XuK21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485530", + "title": "LooPy: interactive program synthesis with control structures", + "abstract": "One vision for program synthesis, and specifically for programming by example (PBE), is an interactive programmer's assistant, integrated into the development environment. To make program synthesis practical for interactive use, prior work on Small-Step Live PBE has proposed to limit the scope of synthesis to small code snippets, and enable the users to provide local specifications for those snippets. This paradigm, however, does not work well in the presence of loops. We present LooPy, a synthesizer integrated into a live programming environment, which extends Small-Step Live PBE to work inside loops and scales it up to synthesize larger code snippets, while remaining fast enough for interactive use. To allow users to effectively provide examples at various loop iterations, even when the loop body is incomplete, LooPy makes use of live execution , a technique that leverages the programmer as an oracle to step over incomplete parts of the loop. To enable synthesis of loop bodies at interactive speeds, LooPy introduces Intermediate State Graph , a new data structure, which compactly represents a large space of code snippets composed of multiple assignment statements and conditionals. We evaluate LooPy empirically using benchmarks from competitive programming and previous synthesizers, and show that it can solve a wide variety of synthesis tasks at interactive speeds. We also perform a small qualitative user study which shows that LooPy's block-level specifications are easy for programmers to provide.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485530", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kasra", + "last_name": "Ferdowsi", + "institution": "University of California San Diego" + }, + { + "first_name": "Shraddha", + "last_name": "Barke", + "institution": "University of California San Diego" + }, + { + "first_name": "Hila", + "last_name": "Peleg", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/FerdowsifardBPL21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485479", + "title": "Efficient compilation of algebraic effect handlers", + "abstract": "The popularity of algebraic effect handlers as a programming language feature for user-defined computational effects is steadily growing. Yet, even though efficient runtime representations have already been studied, most handler-based programs are still much slower than hand-written code. This paper shows that the performance gap can be drastically narrowed (in some cases even closed) by means of type-and-effect directed optimising compilation. Our approach consists of source-to-source transformations in two phases of the compilation pipeline. Firstly, elementary rewrites, aided by judicious function specialisation, exploit the explicit type and effect information of the compiler’s core language to aggressively reduce handler applications. Secondly, after erasing the effect information further rewrites in the backend of the compiler emit tight code. This work comes with a practical implementation: an optimising compiler from Eff, an ML style language with algebraic effect handlers, to OCaml. Experimental evaluation with this implementation demonstrates that in a number of benchmarks, our approach eliminates much of the overhead of handlers, outperforms capability-passing style compilation and yields competitive performance compared to hand-written OCaml code as well Multicore OCaml’s dedicated runtime support.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485479", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Georgios", + "last_name": "Karachalias", + "institution": "" + }, + { + "first_name": "Filip", + "last_name": "Koprivec", + "institution": "University of Ljubljana" + }, + { + "first_name": "Matija", + "last_name": "Pretnar", + "institution": "University of Ljubljana" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/KarachaliasKPS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485521", + "title": "VESPA: static profiling for binary optimization", + "abstract": "Over the past few years, there has been a surge in the popularity of binary optimizers such as BOLT, Propeller, Janus and HALO. These tools use dynamic profiling information to make optimization decisions. Although effective, gathering runtime data presents developers with inconveniences such as unrepresentative inputs, the need to accommodate software modifications, and longer build times. In this paper, we revisit the static profiling technique proposed by Calder et al. in the late 90’s, and investigate its application to drive binary optimizations, in the context of the BOLT binary optimizer, as a replacement for dynamic profiling. A few core modifications to Calder et al.’s original proposal, consisting of new program features and a new regression model, are sufficient to enable some of the gains obtained through runtime profiling. An evaluation of BOLT powered by our static profiler on four large benchmarks (clang, GCC, MySQL and PostgreSQL) yields binaries that are 5.47 % faster than the executables produced by clang -O3.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485521", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Angélica Aparecida", + "last_name": "Moreira", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Guilherme", + "last_name": "Ottoni", + "institution": "Meta (United States)" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "journals/pacmpl/MoreiraOP21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485502", + "title": "What we eval in the shadows: a large-scale study of eval in R programs", + "abstract": "Most dynamic languages allow users to turn text into code using various functions, often named <tt>eval</tt>, with language-dependent semantics. The widespread use of these reflective functions hinders static analysis and prevents compilers from performing optimizations. This paper aims to provide a better sense of why programmers use <tt>eval</tt>. Understanding why <tt>eval</tt> is used in practice is key to finding ways to mitigate its negative impact. We have reasons to believe that reflective feature usage is language and application domain-specific; we focus on data science code written in R and compare our results to previous work that analyzed web programming in JavaScript. We analyze 49,296,059 calls to <tt>eval</tt> from 240,327 scripts extracted from 15,401 R packages. We find that <tt>eval</tt> is indeed in widespread use; R’s <tt>eval</tt> is more pervasive and arguably dangerous than what was previously reported for JavaScript.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485502", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aviral", + "last_name": "Goel", + "institution": "Northeastern University" + }, + { + "first_name": "Pierre", + "last_name": "Donat-Bouillud", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Filip", + "last_name": "Křikava", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Christoph M.", + "last_name": "Kirsch", + "institution": "University of Salzburg" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/GoelDKKV21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485484", + "title": "ECROs: building global scale systems from sequential code", + "abstract": "To ease the development of geo-distributed applications, replicated data types (RDTs) offer a familiar programming interface while ensuring state convergence, low latency, and high availability. However, RDTs are still designed exclusively by experts using ad-hoc solutions that are error-prone and result in brittle systems. Recent works statically detect conflicting operations on existing data types and coordinate those at runtime to guarantee convergence and preserve application invariants. However, these approaches are too conservative, imposing coordination on a large number of operations. In this work, we propose a principled approach to design and implement efficient RDTs taking into account application invariants. Developers extend sequential data types with a distributed specification, which together form an RDT. We statically analyze the specification to detect conflicts and unravel their cause. This information is then used at runtime to serialize concurrent operations safely and efficiently. Our approach derives a correct RDT from any sequential data type without changes to the data type's implementation and with minimal coordination. We implement our approach in Scala and develop an extensive portfolio of RDTs. The evaluation shows that our approach provides performance similar to conflict-free replicated data types for commutative operations, and considerably improves the performance of non-commutative operations, compared to existing solutions.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485484", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kevin De", + "last_name": "Porre", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Carla", + "last_name": "Ferreira", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Nuno", + "last_name": "Preguiça", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Elisa Gonzalez", + "last_name": "Boix", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "journals/pacmpl/PorreFPB21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485474", + "title": "Much ADO about failures: a fault-aware model for compositional verification of strongly consistent distributed systems", + "abstract": "Despite recent advances, guaranteeing the correctness of large-scale distributed applications without compromising performance remains a challenging problem. Network and node failures are inevitable and, for some applications, careful control over how they are handled is essential. Unfortunately, existing approaches either completely hide these failures behind an atomic state machine replication (SMR) interface, or expose all of the network-level details, sacrificing atomicity. We propose a novel, compositional, atomic distributed object (ADO) model for strongly consistent distributed systems that combines the best of both options. The object-oriented API abstracts over protocol-specific details and decouples high-level correctness reasoning from implementation choices. At the same time, it intentionally exposes an abstract view of certain key distributed failure cases, thus allowing for more fine-grained control over them than SMR-like models. We demonstrate that proving properties even of composite distributed systems can be straightforward with our Coq verification framework, Advert, thanks to the ADO model. We also show that a variety of common protocols including multi-Paxos and Chain Replication refine the ADO semantics, which allows one to freely choose among them for an application's implementation without modifying ADO-level correctness proofs.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485474", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wolf", + "last_name": "Honoré", + "institution": "Yale University" + }, + { + "first_name": "Jieung", + "last_name": "Kim", + "institution": "Yale University" + }, + { + "first_name": "Ji-Yong", + "last_name": "Shin", + "institution": "Northeastern University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/HonoreKSS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485519", + "title": "Reconciling optimization with secure compilation", + "abstract": "Software protections against side-channel and physical attacks are essential to the development of secure applications. Such protections are meaningful at machine code or micro-architectural level, but they typically do not carry observable semantics at source level. This renders them susceptible to miscompilation, and security engineers embed input/output side-effects to prevent optimizing compilers from altering them. Yet these side-effects are error-prone and compiler-dependent. The current practice involves analyzing the generated machine code to make sure security or privacy properties are still enforced. These side-effects may also be too expensive in fine-grained protections such as control-flow integrity. We introduce observations of the program state that are intrinsic to the correct execution of security protections, along with means to specify and preserve observations across the compilation flow. Such observations complement the input/output semantics-preservation contract of compilers. We introduce an opacification mechanism to preserve and enforce a partial ordering of observations. This approach is compatible with a production compiler and does not incur any modification to its optimization passes. We validate the effectiveness and performance of our approach on a range of benchmarks, expressing the secure compilation of these applications in terms of observations to be made at specific program points.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485519", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Son Tuan", + "last_name": "Vu", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "" + }, + { + "first_name": "Arnaud de", + "last_name": "Grandmaison", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Christophe", + "last_name": "Guillon", + "institution": "STMicroelectronics (Switzerland)" + }, + { + "first_name": "Karine", + "last_name": "Heydemann", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/VuCGGH21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485517", + "title": "Static detection of silent misconfigurations with deep interaction analysis", + "abstract": "The behavior of large systems is guided by their configurations: users set parameters in the configuration file to dictate which corresponding part of the system code is executed. However, it is often the case that, although some parameters are set in the configuration file, they do not influence the system runtime behavior, thus failing to meet the user’s intent. Moreover, such misconfigurations rarely lead to an error message or raising an exception. We introduce the notion of silent misconfigurations which are prohibitively hard to identify due to (1) lack of feedback and (2) complex interactions between configurations and code. This paper presents ConfigX, the first tool for the detection of silent misconfigurations. The main challenge is to understand the complex interactions between configurations and the code that they affected. Our goal is to derive a specification describing non-trivial interactions between the configuration parameters that lead to silent misconfigurations. To this end, ConfigX uses static analysis to determine which parts of the system code are associated with configuration parameters. ConfigX then infers the connections between configuration parameters by analyzing their associated code blocks. We design customized control- and data-flow analysis to derive a specification of configurations. Additionally, we conduct reachability analysis to eliminate spurious rules to reduce false positives. Upon evaluation on five real-world datasets across three widely-used systems, Apache, vsftpd, and PostgreSQL, ConfigX detected more than 2200 silent misconfigurations. We additionally conducted a user study where we ran ConfigX on misconfigurations reported on user forums by real-world users. ConfigX easily detected issues and suggested repairs for those misconfigurations. Our solutions were accepted and confirmed in the interaction with the users, who originally posted the problems.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485517", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jialu", + "last_name": "Zhang", + "institution": "Yale University" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + }, + { + "first_name": "Ennan", + "last_name": "Zhai", + "institution": "Alibaba Group (United States)" + }, + { + "first_name": "Tianyin", + "last_name": "Xu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/ZhangPZX21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485501", + "title": "A multiparty session typing discipline for fault-tolerant event-driven distributed programming", + "abstract": "This paper presents a formulation of multiparty session types (MPSTs) for practical fault-tolerant distributed programming. We tackle the challenges faced by session types in the context of distributed systems involving asynchronous and concurrent partial failures – such as supporting dynamic replacement of failed parties and retrying failed protocol segments in an ongoing multiparty session – in the presence of unreliable failure detection. Key to our approach is that we develop a novel model of event-driven concurrency for multiparty sessions. Inspired by real-world practices, it enables us to unify the session-typed handling of regular I/O events with failure handling and the combination of features needed to express practical fault-tolerant protocols. Moreover, the characteristics of our model allow us to prove a global progress property for well-typed processes engaged in multiple concurrent sessions, which does not hold in traditional MPST systems. To demonstrate its practicality, we implement our framework as a toolchain and runtime for Scala, and use it to specify and implement a session-typed version of the cluster management system of the industrial-strength Apache Spark data analytics framework. Our session-typed cluster manager composes with other vanilla Spark components to give a functioning Spark runtime; e.g., it can execute existing third-party Spark applications without code modification. A performance evaluation using the TPC-H benchmark shows our prototype implementation incurs an average overhead below 10%.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485501", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Malte", + "last_name": "Viering", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Lukasz", + "last_name": "Ziarek", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "journals/pacmpl/VieringHEZ21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485543", + "title": "Programming and execution models for parallel bounded exhaustive testing", + "abstract": "Bounded-exhaustive testing (BET), which exercises a program under test for all inputs up to some bounds, is an effective method for detecting software bugs. Systematic property-based testing is a BET approach where developers write test generation programs that describe properties of test inputs. Hybrid test generation programs offer the most expressive way to write desired properties by freely combining declarative filters and imperative generators. However, exploring hybrid test generation programs, to obtain test inputs, is both computationally demanding and challenging to parallelize. We present the first programming and execution models, dubbed Tempo, for parallel exploration of hybrid test generation programs. We describe two different strategies for mapping the computation to parallel hardware and implement them both for GPUs and CPUs. We evaluated Tempo by generating instances of various data structures commonly used for benchmarking in the BET domain. Additionally, we generated CUDA programs to stress test CUDA compilers, finding four bugs confirmed by the developers.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485543", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nader Al", + "last_name": "Awar", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kush", + "last_name": "Jain", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Christopher J.", + "last_name": "Rossbach", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Milos", + "last_name": "Gligoric", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/AwarJRG21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485483", + "title": "SimTyper: sound type inference for Ruby using type equality prediction", + "abstract": "Many researchers have explored type inference for dynamic languages. However, traditional type inference computes most general types which, for complex type systems—which are often needed to type dynamic languages—can be verbose, complex, and difficult to understand. In this paper, we introduce SimTyper, a Ruby type inference system that aims to infer usable types—specifically, nominal and generic types—that match the types programmers write. SimTyper builds on InferDL, a recent Ruby type inference system that soundly combines standard type inference with heuristics. The key novelty of SimTyper is type equality prediction , a new, machine learning-based technique that predicts when method arguments or returns are likely to have the same type. SimTyper finds pairs of positions that are predicted to have the same type yet one has a verbose, overly general solution and the other has a usable solution. It then guesses the two types are equal, keeping the guess if it is consistent with the rest of the program, and discarding it if not. In this way, types inferred by SimTyper are guaranteed to be sound. To perform type equality prediction, we introduce the deep similarity (DeepSim) neural network. DeepSim is a novel machine learning classifier that follows the Siamese network architecture and uses CodeBERT, a pre-trained model, to embed source tokens into vectors that capture tokens and their contexts. DeepSim is trained on 100,000 pairs labeled with type similarity information extracted from 371 Ruby programs with manually documented, but not checked, types. We evaluated SimTyper on eight Ruby programs and found that, compared to standard type inference, SimTyper finds 69% more types that match programmer-written type information. Moreover, DeepSim can predict rare types that appear neither in the Ruby standard library nor in the training data. Our results show that type equality prediction can help type inference systems effectively produce more usable types.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485483", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Milod", + "last_name": "Kazerounian", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "Tufts University" + }, + { + "first_name": "Bonan", + "last_name": "Min", + "institution": "RTX (United States)" + } + ], + "dblp_key": "journals/pacmpl/KazerounianFM21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485516", + "title": "Reachability types: tracking aliasing and separation in higher-order functional programs", + "abstract": "Ownership type systems, based on the idea of enforcing unique access paths, have been primarily focused on objects and top-level classes. However, existing models do not as readily reflect the finer aspects of nested lexical scopes, capturing, or escaping closures in higher-order functional programming patterns, which are increasingly adopted even in mainstream object-oriented languages. We present a new type system, λ * , which enables expressive ownership-style reasoning across higher-order functions. It tracks sharing and separation through reachability sets, and layers additional mechanisms for selectively enforcing uniqueness on top of it. Based on reachability sets, we extend the type system with an expressive flow-sensitive effect system, which enables flavors of move semantics and ownership transfer. In addition, we present several case studies and extensions, including applications to capabilities for algebraic effects, one-shot continuations, and safe parallelization.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485516", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuyan", + "last_name": "Bao", + "institution": "University of Waterloo" + }, + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yuxuan", + "last_name": "Jiang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Qiyang", + "last_name": "He", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/BaoWBJHR21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485514", + "title": "Study of the subtyping machine of nominal subtyping with variance", + "abstract": "This is a study of the computing power of the subtyping machine behind Kennedy and Pierce's nominal subtyping with variance. We depict the lattice of fragments of Kennedy and Pierce's type system and characterize their computing power in terms of regular, context-free, deterministic, and non-deterministic tree languages. Based on the theory, we present Treetop---a generator of C# implementations of subtyping machines. The software artifact constitutes the first feasible (yet POC) fluent API generator to support context-free API protocols in a decidable type system fragment.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485514", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ori", + "last_name": "Roth", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/Roth21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485500", + "title": "Well-typed programs can go wrong: a study of typing-related bugs in JVM compilers", + "abstract": "Despite the substantial progress in compiler testing, research endeavors have mainly focused on detecting compiler crashes and subtle miscompilations caused by bugs in the implementation of compiler optimizations. Surprisingly, this growing body of work neglects other compiler components, most notably the front-end. In statically-typed programming languages with rich and expressive type systems and modern features, such as type inference or a mix of object-oriented with functional programming features, the process of static typing in compiler front-ends is complicated by a high-density of bugs. Such bugs can lead to the acceptance of incorrect programs (breaking code portability or the type system's soundness), the rejection of correct (e.g. well-typed) programs, and the reporting of misleading errors and warnings. We conduct, what is to the best of our knowledge, the first empirical study for understanding and characterizing typing-related compiler bugs. To do so, we manually study 320 typing-related bugs (along with their fixes and test cases) that are randomly sampled from four mainstream JVM languages, namely Java, Scala, Kotlin, and Groovy. We evaluate each bug in terms of several aspects, including their symptom, root cause, bug fix's size, and the characteristics of the bug-revealing test cases. Some representative observations indicate that: (1) more than half of the typing-related bugs manifest as unexpected compile-time errors: the buggy compiler wrongly rejects semantically correct programs, (2) the majority of typing-related bugs lie in the implementations of the underlying type systems and in other core components related to operations on types, (3) parametric polymorphism is the most pervasive feature in the corresponding test cases, (4) one third of typing-related bugs are triggered by non-compilable programs. We believe that our study opens up a new research direction by driving future researchers to build appropriate methods and techniques for a more holistic testing of compilers.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485500", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stefanos", + "last_name": "Chaliasos", + "institution": "Athens University of Economics and Business" + }, + { + "first_name": "Thodoris", + "last_name": "Sotiropoulos", + "institution": "Athens University of Economics and Business" + }, + { + "first_name": "Georgios-Petros", + "last_name": "Drosos", + "institution": "Athens University of Economics and Business" + }, + { + "first_name": "Charalambos", + "last_name": "Mitropoulos", + "institution": "Technical University of Crete" + }, + { + "first_name": "Dimitris", + "last_name": "Mitropoulos", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Diomidis", + "last_name": "Spinellis", + "institution": "Athens University of Economics and Business" + } + ], + "dblp_key": "journals/pacmpl/ChaliasosSDMMS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485535", + "title": "Multi-modal program inference: a marriage of pre-trained language models and component-based synthesis", + "abstract": "Multi-modal program synthesis refers to the task of synthesizing programs (code) from their specification given in different forms, such as a combination of natural language and examples. Examples provide a precise but incomplete specification, and natural language provides an ambiguous but more \"complete\" task description. Machine-learned pre-trained models (PTMs) are adept at handling ambiguous natural language, but struggle with generating syntactically and semantically precise code. Program synthesis techniques can generate correct code, often even from incomplete but precise specifications, such as examples, but they are unable to work with the ambiguity of natural languages. We present an approach that combines PTMs with component-based synthesis (CBS): PTMs are used to generate candidates programs from the natural language description of the task, which are then used to guide the CBS procedure to find the program that matches the precise examples-based specification. We use our combination approach to instantiate multi-modal synthesis systems for two programming domains: the domain of regular expressions and the domain of CSS selectors. Our evaluation demonstrates the effectiveness of our domain-agnostic approach in comparison to a state-of-the-art specialized system, and the generality of our approach in providing multi-modal program synthesis from natural language and examples in different programming domains.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485535", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kia", + "last_name": "Rahmani", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Mohammad", + "last_name": "Raza", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Daniel", + "last_name": "Morris", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gustavo", + "last_name": "Soares", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/RahmaniRGLMRST21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485481", + "title": "Synthesizing contracts correct modulo a test generator", + "abstract": "We present an approach to learn contracts for object-oriented programs where guarantees of correctness of the contracts are made with respect to a test generator. Our contract synthesis approach is based on a novel notion of tight contracts and an online learning algorithm that works in tandem with a test generator to synthesize tight contracts. We implement our approach in a tool called Precis and evaluate it on a suite of programs written in C#, studying the safety and strength of the synthesized contracts, and compare them to those synthesized by Daikon.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485481", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Angello", + "last_name": "Astorga", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Shambwaditya", + "last_name": "Saha", + "institution": "Tufts University" + }, + { + "first_name": "Ahmad", + "last_name": "Dinkins", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Felicia", + "last_name": "Wang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Tao", + "last_name": "Xie", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/AstorgaSDWMX21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485527", + "title": "Type stability in Julia: avoiding performance pathologies in JIT compilation", + "abstract": "As a scientific programming language, Julia strives for performance but also provides high-level productivity features. To avoid performance pathologies, Julia users are expected to adhere to a coding discipline that enables so-called type stability. Informally, a function is type stable if the type of the output depends only on the types of the inputs, not their values. This paper provides a formal definition of type stability as well as a stronger property of type groundedness, shows that groundedness enables compiler optimizations, and proves the compiler correct. We also perform a corpus analysis to uncover how these type-related properties manifest in practice.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485527", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Artem", + "last_name": "Pelenitsyn", + "institution": "Northeastern University" + }, + { + "first_name": "Julia", + "last_name": "Belyakova", + "institution": "Northeastern University" + }, + { + "first_name": "Benjamin", + "last_name": "Chung", + "institution": "Northeastern University" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/PelenitsynBCTV21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485529", + "title": "Generative type-aware mutation for testing SMT solvers", + "abstract": "We propose Generative Type-Aware Mutation, an effective approach for testing SMT solvers. The key idea is to realize generation through the mutation of expressions rooted with parametric operators from the SMT-LIB specification. Generative Type-Aware Mutation is a hybrid of mutation-based and grammar-based fuzzing and features an infinite mutation space—overcoming a major limitation of OpFuzz, the state-of-the-art fuzzer for SMT solvers. We have realized Generative Type-Aware Mutation in a practical SMT solver bug hunting tool, TypeFuzz. During our testing period with TypeFuzz, we reported over 237 bugs in the state-of-the-art SMT solvers Z3 and CVC4. Among these, 189 bugs were confirmed and 176 bugs were fixed. Most notably, we found 18 soundness bugs in CVC4’s default mode alone. Several of them were two years latent (7/18). CVC4 has been proved to be a very stable SMT solver and has resisted several fuzzing campaigns.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485529", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jiwon", + "last_name": "Park", + "institution": "École Polytechnique" + }, + { + "first_name": "Dominik", + "last_name": "Winterer", + "institution": "ETH Zurich" + }, + { + "first_name": "Chengyu", + "last_name": "Zhang", + "institution": "East China Normal University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/ParkWZS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485522", + "title": "Modular specification and verification of closures in Rust", + "abstract": "Closures are a language feature supported by many mainstream languages, combining the ability to package up references to code blocks with the possibility of capturing state from the environment of the closure's declaration. Closures are powerful, but complicate understanding and formal reasoning, especially when closure invocations may mutate objects reachable from the captured state or from closure arguments. This paper presents a novel technique for the modular specification and verification of closure-manipulating code in Rust. Our technique combines Rust's type system guarantees and novel specification features to enable formal verification of rich functional properties. It encodes higher-order concerns into a first-order logic, which enables automation via SMT solvers. Our technique is implemented as an extension of the deductive verifier Prusti, with which we have successfully verified many common idioms of closure usage.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485522", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Wolff", + "institution": "ETH Zurich" + }, + { + "first_name": "Aurel", + "last_name": "Bílý", + "institution": "ETH Zurich" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/WolffBMMS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485508", + "title": "Specifying and testing GPU workgroup progress models", + "abstract": "As GPU availability has increased and programming support has matured, a wider variety of applications are being ported to these platforms. Many parallel applications contain fine-grained synchronization idioms; as such, their correct execution depends on a degree of relative forward progress between threads (or thread groups). Unfortunately, many GPU programming specifications (e.g. Vulkan and Metal) say almost nothing about relative forward progress guarantees between workgroups. Although prior work has proposed a spectrum of plausible progress models for GPUs, cross-vendor specifications have yet to commit to any model. This work is a collection of tools and experimental data to aid specification designers when considering forward progress guarantees in programming frameworks. As a foundation, we formalize a small parallel programming language that captures the essence of fine-grained synchronization. We then provide a means of formally specifying a progress model, and develop a termination oracle that decides whether a given program is guaranteed to eventually terminate with respect to a given progress model. Next, we formalize a set of constraints that describe concurrent programs that require forward progress to terminate. This allows us to synthesize a large set of 483 progress litmus tests. Combined with the termination oracle, we can determine the expected status of each litmus test -- i.e. whether it is guaranteed to eventually terminate -- under various progress models. We present a large experimental campaign running the litmus tests across 8 GPUs from 5 different vendors. Our results highlight that GPUs have significantly different termination behaviors under our test suite. Most notably, we find that Apple and ARM GPUs do not support the linear occupancy-bound model, as was hypothesized by prior work.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485508", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Lucas F.", + "last_name": "Salvador", + "institution": "Princeton University" + }, + { + "first_name": "Harmit", + "last_name": "Raval", + "institution": "Princeton University" + }, + { + "first_name": "Hugues", + "last_name": "Evrard", + "institution": "Google (United States)" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Margaret", + "last_name": "Martonosi", + "institution": "Princeton University" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/SorensenSREWMD21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485496", + "title": "Rewrite rule inference using equality saturation", + "abstract": "Many compilers, synthesizers, and theorem provers rely on rewrite rules to simplify expressions or prove equivalences. Developing rewrite rules can be difficult: rules may be subtly incorrect, profitable rules are easy to miss, and rulesets must be rechecked or extended whenever semantics are tweaked. Large rulesets can also be challenging to apply: redundant rules slow down rule-based search and frustrate debugging. This paper explores how equality saturation, a promising technique that uses e-graphs to apply rewrite rules, can also be used to infer rewrite rules. E-graphs can compactly represent the exponentially large sets of enumerated terms and potential rewrite rules. We show that equality saturation efficiently shrinks both sets, leading to faster synthesis of smaller, more general rulesets. We prototyped these strategies in a tool dubbed Ruler. Compared to a similar tool built on CVC4, Ruler synthesizes 5.8× smaller rulesets 25× faster without compromising on proving power. In an end-to-end case study, we show Ruler-synthesized rules which perform as well as those crafted by domain experts, and addressed a longstanding issue in a popular open source tool.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485496", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chandrakana", + "last_name": "Nandi", + "institution": "University of Washington" + }, + { + "first_name": "Max", + "last_name": "Willsey", + "institution": "University of Washington" + }, + { + "first_name": "Amy", + "last_name": "Zhu", + "institution": "University of Washington" + }, + { + "first_name": "Yisu Remy", + "last_name": "Wang", + "institution": "University of Washington" + }, + { + "first_name": "Brett", + "last_name": "Saiki", + "institution": "University of Washington" + }, + { + "first_name": "Adam", + "last_name": "Anderson", + "institution": "University of Washington" + }, + { + "first_name": "Adriana", + "last_name": "Schulz", + "institution": "University of Washington" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/NandiWZWSASGT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485524", + "title": "Making pointer analysis more precise by unleashing the power of selective context sensitivity", + "abstract": "Traditional context-sensitive pointer analysis is hard to scale for large and complex Java programs. To address this issue, a series of selective context-sensitivity approaches have been proposed and exhibit promising results. In this work, we move one step further towards producing highly-precise pointer analyses for hard-to-analyze Java programs by presenting the Unity-Relay framework, which takes selective context sensitivity to the next level. Briefly, Unity-Relay is a one-two punch: given a set of different selective context-sensitivity approaches, say S = S1, . . . , Sn, Unity-Relay first provides a mechanism (called Unity)to combine and maximize the precision of all components of S. When Unity fails to scale, Unity-Relay offers a scheme (called Relay) to pass and accumulate the precision from one approach Si in S to the next, Si+1, leading to an analysis that is more precise than all approaches in S. As a proof-of-concept, we instantiate Unity-Relay into a tool called Baton and extensively evaluate it on a set of hard-to-analyze Java programs, using general precision metrics and popular clients. Compared with the state of the art, Baton achieves the best precision for all metrics and clients for all evaluated programs. The difference in precision is often dramatic — up to 71% of alias pairs reported by previously-best algorithms are found to be spurious and eliminated.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485524", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "Nanjing University" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Xiaoxing", + "last_name": "Ma", + "institution": "Nanjing University" + }, + { + "first_name": "Chang", + "last_name": "Xu", + "institution": "Nanjing University" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/TanLMXS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485476", + "title": "SecRSL: security separation logic for C11 release-acquire concurrency", + "abstract": "We present Security Relaxed Separation Logic (SecRSL), a separation logic for proving information-flow security of C11 programs in the Release-Acquire fragment with relaxed accesses. SecRSL is the first security logic that (1) supports weak-memory reasoning about programs in a high-level language; (2) inherits separation logic’s virtues of compositional, local reasoning about (3) expressive security policies like value-dependent classification. SecRSL is also, to our knowledge, the first security logic developed over an axiomatic memory model. Thus we also present the first definitions of information-flow security for an axiomatic weak memory model, against which we prove SecRSL sound. SecRSL ensures that programs satisfy a constant-time security guarantee, while being free of undefined behaviour. We apply SecRSL to implement and verify the functional correctness and constant-time security of a range of concurrency primitives, including a spinlock module, a mixed-sensitivity mutex, and multiple synchronous channel implementations. Empirical performance evaluations of the latter demonstrate SecRSL’s power to support the development of secure and performant concurrent C programs.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485476", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pengbo", + "last_name": "Yan", + "institution": "The University of Melbourne" + }, + { + "first_name": "Toby", + "last_name": "Murray", + "institution": "The University of Melbourne" + } + ], + "dblp_key": "journals/pacmpl/YanM21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485533", + "title": "Fully automated functional fuzzing of Android apps for detecting non-crashing logic bugs", + "abstract": "Android apps are GUI-based event-driven software and have become ubiquitous in recent years. Obviously, functional correctness is critical for an app’s success. However, in addition to crash bugs, non-crashing functional bugs (in short as “non-crashing bugs” in this work) like inadvertent function failures, silent user data lost and incorrect display information are prevalent, even in popular, well-tested apps. These non-crashing functional bugs are usually caused by program logic errors and manifest themselves on the graphic user interfaces (GUIs). In practice, such bugs pose significant challenges in effectively detecting them because (1) current practices heavily rely on expensive, small-scale manual validation ( the lack of automation ); and (2) modern fully automated testing has been limited to crash bugs ( the lack of test oracles ). This paper fills this gap by introducing independent view fuzzing , a novel, fully automated approach for detecting non-crashing functional bugs in Android apps. Inspired by metamorphic testing, our key insight is to leverage the commonly-held independent view property of Android apps to manufacture property-preserving mutant tests from a set of seed tests that validate certain app properties. The mutated tests help exercise the tested apps under additional, adverse conditions. Any property violations indicate likely functional bugs for further manual confirmation. We have realized our approach as an automated, end-to-end functional fuzzing tool, Genie. Given an app, (1) Genie automatically detects non-crashing bugs without requiring human-provided tests and oracles (thus fully automated ); and (2) the detected non-crashing bugs are diverse (thus general and not limited to specific functional properties ), which set Genie apart from prior work. We have evaluated Genie on 12 real-world Android apps and successfully uncovered 34 previously unknown non-crashing bugs in their latest releases — all have been confirmed, and 22 have already been fixed. Most of the detected bugs are nontrivial and have escaped developer (and user) testing for at least one year and affected many app releases, thus clearly demonstrating Genie’s effectiveness. According to our analysis, Genie achieves a reasonable true positive rate of 40.9%, while these 34 non-crashing bugs could not be detected by prior fully automated GUI testing tools (as our evaluation confirms). Thus, our work complements and enhances existing manual testing and fully automated testing for crash bugs.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485533", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ting", + "last_name": "Su", + "institution": "East China Normal University" + }, + { + "first_name": "Yichen", + "last_name": "Yan", + "institution": "East China Normal University" + }, + { + "first_name": "Jue", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Jingling", + "last_name": "Sun", + "institution": "East China Normal University" + }, + { + "first_name": "Yiheng", + "last_name": "Xiong", + "institution": "East China Normal University" + }, + { + "first_name": "Geguang", + "last_name": "Pu", + "institution": "East China Normal University" + }, + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "Visa (United States)" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/SuYWSXPWS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485547", + "title": "Compacting points-to sets through object clustering", + "abstract": "Inclusion-based set constraint solving is the most popular technique for whole-program points-to analysis whereby an analysis is typically formulated as repeatedly resolving constraints between points-to sets of program variables. The set union operation is central to this process. The number of points-to sets can grow as analyses become more precise and input programs become larger, resulting in more time spent performing unions and more space used storing these points-to sets. Most existing approaches focus on improving scalability of precise points-to analyses from an algorithmic perspective and there has been less research into improving the data structures behind the analyses. Bit-vectors as one of the more popular data structures have been used in several mainstream analysis frameworks to represent points-to sets. To store memory objects in bit-vectors, objects need to mapped to integral identifiers. We observe that this object-to-identifier mapping is critical for a compact points-to set representation and the set union operation. If objects in the same points-to sets (co-pointees) are not given numerically close identifiers, points-to resolution can cost significantly more space and time. Without data on the unpredictable points-to relations which would be discovered by the analysis, an ideal mapping is extremely challenging. In this paper, we present a new approach to inclusion-based analysis by compacting points-to sets through object clustering. Inspired by recent staged analysis where an auxiliary analysis produces results approximating a more precise main analysis, we formulate points-to set compaction as an optimisation problem solved by integer programming using constraints generated from the auxiliary analysis’s results in order to produce an effective mapping. We then develop a more approximate mapping, yet much more efficiently, using hierarchical clustering to compact bit-vectors. We also develop an improved representation of bit-vectors (called core bit-vectors) to fully take advantage of the newly produced mapping. Our approach requires no algorithmic change to the points-to analysis. We evaluate our object clustering on flow sensitive points-to analysis using 8 open-source programs (>3.1 million lines of LLVM instructions) and our results show that our approach can successfully improve the analysis with an up to 1.83× speed up and an up to 4.05× reduction in memory usage.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485547", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mohamad", + "last_name": "Barbar", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "University of Technology Sydney" + } + ], + "dblp_key": "journals/pacmpl/BarbarS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485528", + "title": "A derivative-based parser generator for visibly Pushdown grammars", + "abstract": "In this paper, we present a derivative-based, functional recognizer and parser generator for visibly pushdown grammars. The generated parser accepts ambiguous grammars and produces a parse forest containing all valid parse trees for an input string in linear time. Each parse tree in the forest can then be extracted also in linear time. Besides the parser generator, to allow more flexible forms of the visibly pushdown grammars, we also present a translator that converts a tagged CFG to a visibly pushdown grammar in a sound way, and the parse trees of the tagged CFG are further produced by running the semantic actions embedded in the parse trees of the translated visibly pushdown grammar. The performance of the parser is compared with a popular parsing tool ANTLR and other popular hand-crafted parsers. The correctness of the core parsing algorithm is formally verified in the proof assistant Coq.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485528", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xiaodong", + "last_name": "Jia", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Ashish", + "last_name": "Kumar", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/JiaKT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485537", + "title": "Automatic migration from synchronous to asynchronous JavaScript APIs", + "abstract": "The JavaScript ecosystem provides equivalent synchronous and asynchronous Application Programming Interfaces (APIs) for many commonly used I/O operations. Synchronous APIs involve straightforward sequential control flow that makes them easy to use and understand, but their \"blocking\" behavior may result in poor responsiveness or performance. Asynchronous APIs impose a higher syntactic burden that relies on callbacks, promises, and higher-order functions. On the other hand, their nonblocking behavior enables applications to scale better and remain responsive while I/O requests are being processed. While it is generally understood that asynchronous APIs have better performance characteristics, many applications still rely on synchronous APIs. In this paper, we present a refactoring technique for assisting programmers with the migration from synchronous to asynchronous APIs. The technique relies on static analysis to determine where calls to synchronous API functions can be replaced with their asynchronous counterparts, relying on JavaScript's async/await feature to minimize disruption to the source code. Since the static analysis is potentially unsound, the proposed refactorings are presented as suggestions that must be reviewed and confirmed by the programmer. The technique was implemented in a tool named Desynchronizer. In an empirical evaluation on 12 subject applications containing 316 synchronous API calls, Desynchronizer identified 256 of these as candidates for refactoring. Of these candidates, 244 were transformed successfully, and only 12 resulted in behavioral changes. Further inspection of these cases revealed that the majority of these issues can be attributed to unsoundness in the call graph.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485537", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Satyajit", + "last_name": "Gokhale", + "institution": "Northeastern University" + }, + { + "first_name": "Alexi", + "last_name": "Turcotte", + "institution": "Northeastern University" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/GokhaleTT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485510", + "title": "Durable functions: semantics for stateful serverless", + "abstract": "Serverless, or Functions-as-a-Service (FaaS), is an increasingly popular paradigm for application development, as it provides implicit elastic scaling and load based billing. However, the weak execution guarantees and intrinsic compute-storage separation of FaaS create serious challenges when developing applications that require persistent state, reliable progress, or synchronization. This has motivated a new generation of serverless frameworks that provide stateful abstractions. For instance, Azure's Durable Functions (DF) programming model enhances FaaS with actors, workflows, and critical sections. As a programming model, DF is interesting because it combines task and actor parallelism, which makes it suitable for a wide range of serverless applications. We describe DF both informally, using examples, and formally, using an idealized high-level model based on the untyped lambda calculus. Next, we demystify how the DF runtime can (1) execute in a distributed unreliable serverless environment with compute-storage separation, yet still conform to the fault-free high-level model, and (2) persist execution progress without requiring checkpointing support by the language runtime. To this end we define two progressively more complex execution models, which contain the compute-storage separation and the record-replay, and prove that they are equivalent to the high-level model.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485510", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Chris", + "last_name": "Gillum", + "institution": "Microsoft (United States)" + }, + { + "first_name": "David", + "last_name": "Justo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Κωνσταντίνος", + "last_name": "Καλλάς", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Connor", + "last_name": "McMahon", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Christopher", + "last_name": "Meiklejohn", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/BurckhardtGJKMM21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485477", + "title": "Semantic programming by example with pre-trained models", + "abstract": "The ability to learn programs from few examples is a powerful technology with disruptive applications in many domains, as it allows users to automate repetitive tasks in an intuitive way. Existing frameworks on inductive synthesis only perform syntactic manipulations, where they rely on the syntactic structure of the given examples and not their meaning. Any semantic manipulations, such as transforming dates, have to be manually encoded by the designer of the inductive programming framework. Recent advances in large language models have shown these models to be very adept at performing semantic transformations of its input by simply providing a few examples of the task at hand. When it comes to syntactic transformations, however, these models are limited in their expressive power. In this paper, we propose a novel framework for integrating inductive synthesis with few-shot learning language models to combine the strength of these two popular technologies. In particular, the inductive synthesis is tasked with breaking down the problem in smaller subproblems, among which those that cannot be solved syntactically are passed to the language model. We formalize three semantic operators that can be integrated with inductive synthesizers. To minimize invoking expensive semantic operators during learning, we introduce a novel deferred query execution algorithm that considers the operators to be oracles during learning. We evaluate our approach in the domain of string transformations: the combination methodology can automate tasks that cannot be handled using either technologies by themselves. Finally, we demonstrate the generality of our approach via a case study in the domain of string profiling.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485477", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gust", + "last_name": "Verbruggen", + "institution": "KU Leuven" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/VerbruggenLG21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485507", + "title": "Coarsening optimization for differentiable programming", + "abstract": "This paper presents a novel optimization for differentiable programming named coarsening optimization. It offers a systematic way to synergize symbolic differentiation and algorithmic differentiation (AD). Through it, the granularity of the computations differentiated by each step in AD can become much larger than a single operation, and hence lead to much reduced runtime computations and data allocations in AD. To circumvent the difficulties that control flow creates to symbolic differentiation in coarsening, this work introduces phi-calculus, a novel method to allow symbolic reasoning and differentiation of computations that involve branches and loops. It further avoids \"expression swell\" in symbolic differentiation and balance reuse and coarsening through the design of reuse-centric segment of interest identification. Experiments on a collection of real-world applications show that coarsening optimization is effective in speeding up AD, producing several times to two orders of magnitude speedups.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485507", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + }, + { + "first_name": "Guoqiang", + "last_name": "Zhang", + "institution": "North Carolina State University" + }, + { + "first_name": "Irene", + "last_name": "Dea", + "institution": "Meta (United States)" + }, + { + "first_name": "Samantha", + "last_name": "Andow", + "institution": "Meta (United States)" + }, + { + "first_name": "Emilio", + "last_name": "Arroyo-Fang", + "institution": "Meta (United States)" + }, + { + "first_name": "Neal", + "last_name": "Gafter", + "institution": "Meta (United States)" + }, + { + "first_name": "Johann", + "last_name": "George", + "institution": "Meta (United States)" + }, + { + "first_name": "Melissa", + "last_name": "Grueter", + "institution": "Meta (United States)" + }, + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "Meta (United States)" + }, + { + "first_name": "Olin", + "last_name": "Shivers", + "institution": "Meta (United States)" + }, + { + "first_name": "Steffi", + "last_name": "Stumpos", + "institution": "Meta (United States)" + }, + { + "first_name": "Alanna", + "last_name": "Tempest", + "institution": "Meta (United States)" + }, + { + "first_name": "Christy", + "last_name": "Warden", + "institution": "Meta (United States)" + }, + { + "first_name": "Shannon", + "last_name": "Yang", + "institution": "Meta (United States)" + } + ], + "dblp_key": "journals/pacmpl/ShenZDAAGGGMSST21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485489", + "title": "UDF to SQL translation through compositional lazy inductive synthesis", + "abstract": "Many data processing systems allow SQL queries that call user-defined functions (UDFs) written in conventional programming languages. While such SQL extensions provide convenience and flexibility to users, queries involving UDFs are not as efficient as their pure SQL counterparts that invoke SQL’s highly-optimized built-in functions. Motivated by this problem, we propose a new technique for translating SQL queries with UDFs to pure SQL expressions. Unlike prior work in this space, our method is not based on syntactic rewrite rules and can handle a much more general class of UDFs. At a high-level, our method is based on counterexample-guided inductive synthesis (CEGIS) but employs a novel compositional strategy that decomposes the synthesis task into simpler sub-problems. However, because there is no universal decomposition strategy that works for all UDFs, we propose a novel lazy inductive synthesis approach that generates a sequence of decompositions that correspond to increasingly harder inductive synthesis problems. Because most realistic UDF-to-SQL translation tasks are amenable to a fine-grained decomposition strategy, our lazy inductive synthesis method scales significantly better than traditional CEGIS. We have implemented our proposed technique in a tool called CLIS for optimizing Spark SQL programs containing Scala UDFs. To evaluate CLIS, we manually study 100 randomly selected UDFs and find that 63 of them can be expressed in pure SQL. Our evaluation on these 63 UDFs shows that CLIS can automatically synthesize equivalent SQL expressions in 92% of the cases and that it can solve 2.4× more benchmarks compared to a baseline that does not use our compositional approach. We also show that CLIS yields an average speed-up of 3.5× for individual UDFs and 1.3× to 3.1× in terms of end-to-end application performance.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485489", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guo‐Qiang", + "last_name": "Zhang", + "institution": "North Carolina State University" + }, + { + "first_name": "Yuanchao", + "last_name": "Xu", + "institution": "North Carolina State University" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/ZhangXSD21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485526", + "title": "Permchecker: a toolchain for debugging memory managers with typestate", + "abstract": "Dynamic memory managers are a crucial component of almost every modern software system. In addition to implementing efficient allocation and reclamation, memory managers provide the essential abstraction of memory as distinct objects, which underpins the properties of memory safety and type safety. Bugs in memory managers, while not common, are extremely hard to diagnose and fix. One reason is that their implementations often involve tricky pointer calculations, raw memory manipulation, and complex memory state invariants. While these properties are often documented, they are not specified in any precise, machine-checkable form. A second reason is that memory manager bugs can break the client application in bizarre ways that do not immediately implicate the memory manager at all. A third reason is that existing tools for debugging memory errors, such as Memcheck, cannot help because they rely on correct allocation and deallocation information to work. In this paper we present Permchecker, a tool designed specifically to detect and diagnose bugs in memory managers. The key idea in Permchecker is to make the expected structure of the heap explicit by associating typestates with each piece of memory. Typestate captures elements of both type (e.g., page, block, or cell) and state (e.g., allocated, free, or forwarded). Memory manager developers annotate their implementation with information about the expected typestates of memory and how heap operations change those typestates. At runtime, our system tracks the typestates and ensures that each memory access is consistent with the expected typestates. This technique detects errors quickly, before they corrupt the application or the memory manager itself, and it often provides accurate information about the reason for the error. The implementation of Permchecker uses a combination of compile-time annotation and instrumentation, and dynamic binary instrumentation (DBI). Because the overhead of DBI is fairly high, Permchecker is suitable for a testing and debugging setting and not for deployment. It works on a wide variety of existing systems, including explicit malloc/free memory managers and garbage collectors, such as those found in JikesRVM and OpenJDK. Since bugs in these systems are not numerous, we developed a testing methodology in which we automatically inject bugs into the code using bug patterns derived from real bugs. This technique allows us to test Permchecker on hundreds or thousands of buggy variants of the code. We find that Permchecker effectively detects and localizes errors in the vast majority of cases; without it, these bugs result in strange, incorrect behaviors usually long after the actual error occurs.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485526", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karl", + "last_name": "Cronburg", + "institution": "Tufts University" + }, + { + "first_name": "Samuel Z.", + "last_name": "Guyer", + "institution": "Tufts University" + } + ], + "dblp_key": "journals/pacmpl/CronburgG21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485475", + "title": "Making weak memory models fair", + "abstract": "Liveness properties, such as termination, of even the simplest shared-memory concurrent programs under sequential consistency typically require some fairness assumptions about the scheduler. Under weak memory models, we observe that the standard notions of thread fairness are insufficient, and an additional fairness property, which we call memory fairness, is needed. In this paper, we propose a uniform definition for memory fairness that can be integrated into any declarative memory model enforcing acyclicity of the union of the program order and the reads-from relation. For the well-known models, SC, x86-TSO, RA, and StrongCOH, that have equivalent operational and declarative presentations, we show that our declarative memory fairness condition is equivalent to an intuitive model-specific operational notion of memory fairness, which requires the memory system to fairly execute its internal propagation steps. Our fairness condition preserves the correctness of local transformations and the compilation scheme from RC11 to x86-TSO, and also enables the first formal proofs of termination of mutual exclusion lock implementations under declarative weak memory models.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485475", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Egor", + "last_name": "Namakonov", + "institution": "St Petersburg University" + }, + { + "first_name": "Jonas", + "last_name": "Oberhauser", + "institution": "Huawei German Research Center" + }, + { + "first_name": "Anton", + "last_name": "Podkopaev", + "institution": "National Research University Higher School of Economics" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/LahavNOPV21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485497", + "title": "The semantics of shared memory in Intel CPU/FPGA systems", + "abstract": "Heterogeneous CPU/FPGA devices, in which a CPU and an FPGA can execute together while sharing memory, are becoming popular in several computing sectors. In this paper, we study the shared-memory semantics of these devices, with a view to providing a firm foundation for reasoning about the programs that run on them. Our focus is on Intel platforms that combine an Intel FPGA with a multicore Xeon CPU. We describe the weak-memory behaviours that are allowed (and observable) on these devices when CPU threads and an FPGA thread access common memory locations in a fine-grained manner through multiple channels. Some of these behaviours are familiar from well-studied CPU and GPU concurrency; others are weaker still. We encode these behaviours in two formal memory models: one operational, one axiomatic. We develop executable implementations of both models, using the CBMC bounded model-checking tool for our operational model and the Alloy modelling language for our axiomatic model. Using these, we cross-check our models against each other via a translator that converts Alloy-generated executions into queries for the CBMC model. We also validate our models against actual hardware by translating 583 Alloy-generated executions into litmus tests that we run on CPU/FPGA devices; when doing this, we avoid the prohibitive cost of synthesising a hardware design per litmus test by creating our own 'litmus-test processor' in hardware. We expect that our models will be useful for low-level programmers, compiler writers, and designers of analysis tools. Indeed, as a demonstration of the utility of our work, we use our operational model to reason about a producer/consumer buffer implemented across the CPU and the FPGA. When the buffer uses insufficient synchronisation -- a situation that our model is able to detect -- we observe that its performance improves at the cost of occasional data corruption.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485497", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dan", + "last_name": "Iorga", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/IorgaDSW21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485499", + "title": "One down, 699 to go: or, synthesising compositional desugarings", + "abstract": "Programming or scripting languages used in real-world systems are seldom designed with a formal semantics in mind from the outset. Therefore, developing well-founded analysis tools for these systems requires reverse-engineering a formal semantics as a first step. This can take months or years of effort. Can we (at least partially) automate this process? Though desirable, automatically reverse-engineering semantics rules from an implementation is very challenging, as found by Krishnamurthi, Lerner and Elberty. In this paper, we highlight that scaling methods with the size of the language is very difficult due to state space explosion, so we propose to learn semantics incrementally. We give a formalisation of Krishnamurthi et al.'s desugaring learning framework in order to clarify the assumptions necessary for an incremental learning algorithm to be feasible. We show that this reformulation allows us to extend the search space and express rules that Krishnamurthi et al. described as challenging, while still retaining feasibility. We evaluate enumerative synthesis as a baseline algorithm, and demonstrate that, with our reformulation of the problem, it is possible to learn correct desugaring rules for the example source and core languages proposed by Krishnamurthi et al., in most cases identical to the intended rules. In addition, with user guidance, our system was able to synthesize rules for desugaring list comprehensions and try/catch/finally constructs.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485499", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sándor", + "last_name": "Bartha", + "institution": "University of Edinburgh" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "Turing Institute" + }, + { + "first_name": "Vaishak", + "last_name": "Belle", + "institution": "Turing Institute" + } + ], + "dblp_key": "journals/pacmpl/BarthaCB21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485544", + "title": "Generalizable synthesis through unification", + "abstract": "The generalizability of PBE solvers is the key to the empirical synthesis performance. Despite the importance of generalizability, related studies on PBE solvers are still limited. In theory, few existing solvers provide theoretical guarantees on generalizability, and in practice, there is a lack of PBE solvers with satisfactory generalizability on important domains such as conditional linear integer arithmetic (CLIA). In this paper, we adopt a concept from the computational learning theory, Occam learning, and perform a comprehensive study on the framework of synthesis through unification (STUN), a state-of-the-art framework for synthesizing programs with nested if-then-else operators. We prove that Eusolver, a state-of-the-art STUN solver, does not satisfy the condition of Occam learning, and then we design a novel STUN solver, PolyGen, of which the generalizability is theoretically guaranteed by Occam learning. We evaluate PolyGen on the domains of CLIA and demonstrate that PolyGen significantly outperforms two state-of-the-art PBE solvers on CLIA, Eusolver and Euphony, on both generalizability and efficiency.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485544", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ruyi", + "last_name": "Ji", + "institution": "Peking University" + }, + { + "first_name": "Jingtao", + "last_name": "Xia", + "institution": "Peking University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/JiXXH21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485542", + "title": "JavaDL: automatically incrementalizing Java bug pattern detection", + "abstract": "Static checker frameworks support software developers by automatically discovering bugs that fit general-purpose bug patterns. These frameworks ship with hundreds of detectors for such patterns and allow developers to add custom detectors for their own projects. However, existing frameworks generally encode detectors in imperative specifications, with extensive details of not only what to detect but also how . These details complicate detector maintenance and evolution, and also interfere with the framework’s ability to change how detection is done, for instance, to make the detectors incremental. In this paper, we present JavaDL, a Datalog-based declarative specification language for bug pattern detection in Java code. JavaDL seamlessly supports both exhaustive and incremental evaluation from the same detector specification. This specification allows developers to describe local detector components via syntactic pattern matching , and nonlocal (e.g., interprocedural) reasoning via Datalog-style logical rules . We compare our approach against the well-established SpotBugs and Error Prone tools by re-implementing several of their detectors in JavaDL. We find that our implementations are substantially smaller and similarly effective at detecting bugs on the Defects4J benchmark suite, and run with competitive runtime performance. In our experiments, neither incremental nor exhaustive analysis can consistently outperform the other, which highlights the value of our ability to transparently switch execution modes. We argue that our approach showcases the potential of clear-box static checker frameworks that constrain the bug detector specification language to enable the framework to adapt and enhance the detectors.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485542", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexandru", + "last_name": "Dura", + "institution": "Lund University" + }, + { + "first_name": "Christoph", + "last_name": "Reichenbach", + "institution": "Lund University" + }, + { + "first_name": "Emma", + "last_name": "Söderberg", + "institution": "Lund University" + } + ], + "dblp_key": "journals/pacmpl/DuraRS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485504", + "title": "Transitioning from structural to nominal code with efficient gradual typing", + "abstract": "Gradual typing is a principled means for mixing typed and untyped code. But typed and untyped code often exhibit different programming patterns. There is already substantial research investigating gradually giving types to code exhibiting typical untyped patterns, and some research investigating gradually removing types from code exhibiting typical typed patterns. This paper investigates how to extend these established gradual-typing concepts to give formal guarantees not only about how to change types as code evolves but also about how to change such programming patterns as well. In particular, we explore mixing untyped \"structural\" code with typed \"nominal\" code in an object-oriented language. But whereas previous work only allowed \"nominal\" objects to be treated as \"structural\" objects, we also allow \"structural\" objects to dynamically acquire certain nominal types, namely interfaces. We present a calculus that supports such \"cross-paradigm\" code migration and interoperation in a manner satisfying both the static and dynamic gradual guarantees, and demonstrate that the calculus can be implemented efficiently.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485504", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Muehlboeck", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/MuehlboeckT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485538", + "title": "APIfix: output-oriented program synthesis for combating breaking changes in libraries", + "abstract": "Use of third-party libraries is extremely common in application software. The libraries evolve to accommodate new features or mitigate security vulnerabilities, thereby breaking the Application Programming Interface(API) used by the software. Such breaking changes in the libraries may discourage client code from using the new library versions thereby keeping the application vulnerable and not up-to-date. We propose a novel output-oriented program synthesis algorithm to automate API usage adaptations via program transformation. Our aim is not only to rely on the few example human adaptations of the clients from the old library version to the new library version, since this can lead to over-fitting transformation rules. Instead, we also rely on example usages of the new updated library in clients, which provide valuable context for synthesizing and applying the transformation rules. Our tool APIFix provides an automated mechanism to transform application code using the old library versions to code using the new library versions - thereby achieving automated API usage adaptation to fix the effect of breaking changes. Our evaluation shows that the transformation rules inferred by APIFix achieve 98.7% precision and 91.5% recall. By comparing our approach to state-of-the-art program synthesis approaches, we show that our approach significantly reduces over-fitting while synthesizing transformation rules for API usage adaptations.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485538", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xiang", + "last_name": "Gao", + "institution": "National University of Singapore" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gustavo", + "last_name": "Soares", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ridwan", + "last_name": "Shariffdeen", + "institution": "National University of Singapore" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Abhik", + "last_name": "Roychoudhury", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/GaoRSSGR21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485523", + "title": "Rich specifications for Ethereum smart contract verification", + "abstract": "Smart contracts are programs that execute in blockchains such as Ethereum to manipulate digital assets. Since bugs in smart contracts may lead to substantial financial losses, there is considerable interest in formally proving their correctness. However, the specification and verification of smart contracts faces challenges that rarely arise in other application domains. Smart contracts frequently interact with unverified, potentially adversarial outside code, which substantially weakens the assumptions that formal analyses can (soundly) make. Moreover, the core functionality of smart contracts is to manipulate and transfer resources; describing this functionality concisely requires dedicated specification support. Current reasoning techniques do not fully address these challenges, being restricted in their scope or expressiveness (in particular, in the presence of re-entrant calls), and offering limited means of expressing the resource transfers a contract performs. In this paper, we present a novel specification methodology tailored to the domain of smart contracts. Our specifications and associated reasoning technique are the first to enable: (1) sound and precise reasoning in the presence of unverified code and arbitrary re-entrancy, (2) modular reasoning about collaborating smart contracts, and (3) domain-specific specifications for resources and resource transfers, expressing a contract's behaviour in intuitive and concise ways and excluding typical errors by default. We have implemented our approach in 2vyper, an SMT-based automated verification tool for Ethereum smart contracts written in Vyper, and demonstrated its effectiveness for verifying strong correctness guarantees for real-world contracts.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485523", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christian", + "last_name": "Bräm", + "institution": "ETH Zurich" + }, + { + "first_name": "Marco", + "last_name": "Eilers", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Robin", + "last_name": "Sierra", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/BramEMSS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485541", + "title": "The reads-from equivalence for the TSO and PSO memory models", + "abstract": "The verification of concurrent programs remains an open challenge due to the non-determinism in inter-process communication. One recurring algorithmic problem in this challenge is the consistency verification of concurrent executions. In particular, consistency verification under a reads-from map allows to compute the reads-from (RF) equivalence between concurrent traces, with direct applications to areas such as Stateless Model Checking (SMC). Importantly, the RF equivalence was recently shown to be coarser than the standard Mazurkiewicz equivalence, leading to impressive scalability improvements for SMC under SC (sequential consistency). However, for the relaxed memory models of TSO and PSO (total/partial store order), the algorithmic problem of deciding the RF equivalence, as well as its impact on SMC, has been elusive. In this work we solve the algorithmic problem of consistency verification for the TSO and PSO memory models given a reads-from map, denoted VTSO-rf and VPSO-rf, respectively. For an execution of n events over k threads and d variables, we establish novel bounds that scale as n k +1 for TSO and as n k +1 · min( n k 2 , 2 k · d ) for PSO. Moreover, based on our solution to these problems, we develop an SMC algorithm under TSO and PSO that uses the RF equivalence. The algorithm is exploration-optimal , in the sense that it is guaranteed to explore each class of the RF partitioning exactly once, and spends polynomial time per class when k is bounded. Finally, we implement all our algorithms in the SMC tool Nidhugg, and perform a large number of experiments over benchmarks from existing literature. Our experimental results show that our algorithms for VTSO-rf and VPSO-rf provide significant scalability improvements over standard alternatives. Moreover, when used for SMC, the RF partitioning is often much coarser than the standard Shasha-Snir partitioning for TSO/PSO, which yields a significant speedup in the model checking task.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485541", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Truc Lam", + "last_name": "Bui", + "institution": "Comenius University Bratislava" + }, + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Tushar", + "last_name": "Gautam", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + }, + { + "first_name": "Viktor", + "last_name": "Toman", + "institution": "Institute of Science and Technology Austria" + } + ], + "dblp_key": "journals/pacmpl/BuiCGPT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485532", + "title": "How statically-typed functional programmers write code", + "abstract": "How working statically-typed functional programmers write code is largely understudied. And yet, a better understanding of developer practices could pave the way for the design of more useful and usable tooling, more ergonomic languages, and more effective on-ramps into programming communities. The goal of this work is to address this knowledge gap: to better understand the high-level authoring patterns that statically-typed functional programmers employ. We conducted a grounded theory analysis of 30 programming sessions of practicing statically-typed functional programmers, 15 of which also included a semi-structured interview. The theory we developed gives insight into how the specific affordances of statically-typed functional programming affect domain modeling, type construction, focusing techniques, exploratory and reasoning strategies, and expressions of intent. We conducted a set of quantitative lab experiments to validate our findings, including that statically-typed functional programmers often iterate between editing types and expressions, that they often run their compiler on code even when they know it will not successfully compile, and that they make textual program edits that reliably signal future edits that they intend to make. Lastly, we outline the implications of our findings for language and tool design. The success of this approach in revealing program authorship patterns suggests that the same methodology could be used to study other understudied programmer populations.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485532", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Justin", + "last_name": "Lubin", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/LubinC21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485520", + "title": "Scalability and precision by combining expressive type systems and deductive verification", + "abstract": "Type systems and modern type checkers can be used very successfully to obtain formal correctness guarantees with little specification overhead. However, type systems in practical scenarios have to trade precision for decidability and scalability. Tools for deductive verification, on the other hand, can prove general properties in more cases than a typical type checker can, but they do not scale well. We present a method to complement the scalability of expressive type systems with the precision of deductive program verification approaches. This is achieved by translating the type uses whose correctness the type checker cannot prove into assertions in a specification language, which can be dealt with by a deductive verification tool. Type uses whose correctness the type checker can prove are instead turned into assumptions to aid the verification tool in finding a proof.Our novel approach is introduced both conceptually for a simple imperative language, and practically by a concrete implementation for the Java programming language. The usefulness and power of our approach has been evaluated by discharging known false positives from a real-world program and by a small case study.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485520", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Florian", + "last_name": "Lanzinger", + "institution": "" + }, + { + "first_name": "Alexander", + "last_name": "Weigl", + "institution": "" + }, + { + "first_name": "Mattias", + "last_name": "Ulbrich", + "institution": "" + }, + { + "first_name": "Werner", + "last_name": "Dietl", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/LanzingerWUD21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485495", + "title": "Program analysis via efficient symbolic abstraction", + "abstract": "This paper concerns the scalability challenges of symbolic abstraction: given a formula ϕ in a logic L and an abstract domain A , find a most precise element in the abstract domain that over-approximates the meaning of ϕ. Symbolic abstraction is an important point in the space of abstract interpretation, as it allows for automatically synthesizing the best abstract transformers. However, current techniques for symbolic abstraction can have difficulty delivering on its practical strengths, due to performance issues. In this work, we introduce two algorithms for the symbolic abstraction of quantifier-free bit-vector formulas, which apply to the bit-vector interval domain and a certain kind of polyhedral domain, respectively. We implement and evaluate the proposed techniques on two machine code analysis clients, namely static memory corruption analysis and constrained random fuzzing. Using a suite of 57,933 queries from the clients, we compare our approach against a diverse group of state-of-the-art algorithms. The experiments show that our algorithms achieve a substantial speedup over existing techniques and illustrate significant precision advantages for the clients. Our work presents strong evidence that symbolic abstraction of numeric domains can be efficient and practical for large and realistic programs.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485495", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peisen", + "last_name": "Yao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Qingkai", + "last_name": "Shi", + "institution": "" + }, + { + "first_name": "Heqing", + "last_name": "Huang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/YaoSHZ21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485515", + "title": "Dynaplex: analyzing program complexity using dynamically inferred recurrence relations", + "abstract": "Being able to detect program runtime complexity is useful in many tasks (e.g., checking expected performance and identifying potential security vulnerabilities). In this work, we introduce a new dynamic approach for inferring the asymptotic complexity bounds of recursive programs. From program execution traces, we learn recurrence relations and solve them using pattern matching to obtain closed-form solutions representing the complexity bounds of the program. This approach allows us to efficiently infer simple recurrence relations that represent nontrivial, potentially nonlinear polynomial and non-polynomial, complexity bounds. We present Dynaplex, a tool that implements these ideas to automatically generate recurrence relations from execution traces. Our preliminary results on popular and challenging recursive programs show that Dynaplex can learn precise relations capturing worst-case complexity bounds (e.g., O ( n log n ) for mergesort, O (2 n ) for Tower of Hanoi and O ( n 1.58 ) for Karatsuba’s multiplication algorithm).", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485515", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Didier", + "last_name": "Ishimwe", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "KimHao", + "last_name": "Nguyen", + "institution": "University of Nebraska–Lincoln" + }, + { + "first_name": "ThanhVu", + "last_name": "Nguyen", + "institution": "George Mason University" + } + ], + "dblp_key": "journals/pacmpl/IshimweNN21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485491", + "title": "Compiling with continuations, correctly", + "abstract": "In this paper we present a novel simulation relation for proving correctness of program transformations that combines syntactic simulations and logical relations. In particular, we establish a new kind of simulation diagram that uses a small-step or big-step semantics in the source language and an untyped, step-indexed logical relation in the target language. Our technique provides a practical solution for proving semantics preservation for transformations that do not preserve reductions in the source language. This is common when transformations generate new binder names, and hence α-conversion must be explicitly accounted for, or when transformations introduce administrative redexes. Our technique does not require reductions in the source language to correspond directly to reductions in the target language. Instead, we enforce a weaker notion of semantic preorder, which suffices to show that semantics are preserved for both whole-program and separate compilation. Because our logical relation is transitive, we can transition between intermediate program states in a small-step fashion and hence the shape of the proof resembles that of a simple small-step simulation. We use this technique to revisit the semantic correctness of a continuation-passing style (CPS) transformation and we demonstrate how it allows us to overcome well-known complications of this proof related to α-conversion and administrative reductions. In addition, by using a logical relation that is indexed by invariants that relate the resource consumption of two programs, we are able show that the transformation preserves diverging behaviors and that our CPS transformation asymptotically preserves the running time of the source program. Our results are formalized in the Coq proof assistant. Our continuation-passing style transformation is part of the CertiCoq compiler for Gallina, the specification language of Coq.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485491", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Northeastern University" + }, + { + "first_name": "Anvay", + "last_name": "Grover", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/Paraskevopoulou21a", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485486", + "title": "Efficient automatic scheduling of imaging and vision pipelines for the GPU", + "abstract": "We present a new algorithm to quickly generate high-performance GPU implementations of complex imaging and vision pipelines, directly from high-level Halide algorithm code. It is fully automatic, requiring no schedule templates or hand-optimized kernels. We address the scalability challenge of extending search-based automatic scheduling to map large real-world programs to the deep hierarchies of memory and parallelism on GPU architectures in reasonable compile time. We achieve this using (1) a two-phase search algorithm that first ‘freezes’ decisions for the lowest cost sections of a program, allowing relatively more time to be spent on the important stages, (2) a hierarchical sampling strategy that groups schedules based on their structural similarity, then samples representatives to be evaluated, allowing us to explore a large space with few samples, and (3) memoization of repeated partial schedules, amortizing their cost over all their occurrences. We guide the process with an efficient cost model combining machine learning, program analysis, and GPU architecture knowledge. We evaluate our method’s performance on a diverse suite of real-world imaging and vision pipelines. Our scalability optimizations lead to average compile time speedups of 49x (up to 530x). We find schedules that are on average 1.7x faster than existing automatic solutions (up to 5x), and competitive with what the best human experts were able to achieve in an active effort to beat our automatic results.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485486", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luke", + "last_name": "Anderson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Andrew", + "last_name": "Adams", + "institution": "Adobe Systems (United States)" + }, + { + "first_name": "Karima", + "last_name": "Ma", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Tzu‐Mao", + "last_name": "Li", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jin", + "last_name": "Tian", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AndersonAMLJR21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485478", + "title": "Promises are made to be broken: migrating R to strict semantics", + "abstract": "Function calls in the R language do not evaluate their arguments, these are passed to the callee as suspended computations and evaluated if needed. After 25 years of experience with the language, there are very few cases where programmers leverage delayed evaluation intentionally and laziness comes at a price in performance and complexity. This paper explores how to evolve the semantics of a lazy language towards strictness-by-default and laziness-on-demand. To provide a migration path, it is necessary to provide tooling for developers to migrate libraries without introducing errors. This paper reports on a dynamic analysis that infers strictness signatures for functions to capture both intentional and accidental laziness. Over 99% of the inferred signatures were correct when tested against clients of the libraries.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485478", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aviral", + "last_name": "Goel", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Ječmen", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Sebastián", + "last_name": "Krynski", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Olivier", + "last_name": "Flückiger", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/GoelJKFV21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485511", + "title": "Gauss: program synthesis by reasoning over graphs", + "abstract": "While input-output examples are a natural form of specification for program synthesis engines, they can be imprecise for domains such as table transformations. In this paper, we investigate how extracting readily-available information about the user intent behind these input-output examples helps speed up synthesis and reduce overfitting. We present Gauss, a synthesis algorithm for table transformations that accepts partial input-output examples, along with user intent graphs. Gauss includes a novel conflict-resolution reasoning algorithm over graphs that enables it to learn from mistakes made during the search and use that knowledge to explore the space of programs even faster. It also ensures the final program is consistent with the user intent specification, reducing overfitting. We implement Gauss for the domain of table transformations (supporting Pandas and R), and compare it to three state-of-the-art synthesizers accepting only input-output examples. We find that it is able to reduce the search space by 56×, 73× and 664× on average, resulting in 7×, 26× and 7× speedups in synthesis times on average, respectively.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485511", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rohan", + "last_name": "Bavishi", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Caroline", + "last_name": "Lemieux", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Ion", + "last_name": "Stoica", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/BavishiLSS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485534", + "title": "QuickSilver: modeling and parameterized verification for distributed agreement-based systems", + "abstract": "The last decade has sparked several valiant efforts in deductive verification of distributed agreement protocols such as consensus and leader election. Oddly, there have been far fewer verification efforts that go beyond the core protocols and target applications that are built on top of agreement protocols. This is unfortunate, as agreement-based distributed services such as data stores, locks, and ledgers are ubiquitous and potentially permit modular, scalable verification approaches that mimic their modular design. We address this need for verification of distributed agreement-based systems through our novel modeling and verification framework, QuickSilver, that is not only modular, but also fully automated. The key enabling feature of QuickSilver is our encoding of abstractions of verified agreement protocols that facilitates modular, decidable, and scalable automated verification. We demonstrate the potential of QuickSilver by modeling and efficiently verifying a series of tricky case studies, adapted from real-world applications, such as a data store, a lock service, a surveillance system, a pathfinding algorithm for mobile robots, and more.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485534", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nouraldin", + "last_name": "Jaber", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Christopher", + "last_name": "Wagner", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Swen", + "last_name": "Jacobs", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/JaberWJKS21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485506", + "title": "SpecSafe: detecting cache side channels in a speculative world", + "abstract": "The high-profile Spectre attack and its variants have revealed that speculative execution may leave secret-dependent footprints in the cache, allowing an attacker to learn confidential data. However, existing static side-channel detectors either ignore speculative execution, leading to false negatives, or lack a precise cache model, leading to false positives. In this paper, somewhat surprisingly, we show that it is challenging to develop a speculation-aware static analysis with precise cache models: a combination of existing works does not necessarily catch all cache side channels. Motivated by this observation, we present a new semantic definition of security against cache-based side-channel attacks, called Speculative-Aware noninterference (SANI), which is applicable to a variety of attacks and cache models. We also develop SpecSafe to detect the violations of SANI. Unlike other speculation-aware symbolic executors, SpecSafe employs a novel program transformation so that SANI can be soundly checked by speculation-unaware side-channel detectors. SpecSafe is shown to be both scalable and accurate on a set of moderately sized benchmarks, including commonly used cryptography libraries.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485506", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert", + "last_name": "Brotzman", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/BrotzmanZKT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485498", + "title": "Translating C to safer Rust", + "abstract": "Rust is a relatively new programming language that targets efficient and safe systems-level applications. It includes a sophisticated type system that allows for provable memory- and thread-safety, and is explicitly designed to take the place of unsafe languages such as C and C++ in the coding ecosystem. There is a large existing C and C++ codebase (many of which have been affected by bugs and security vulnerabilities due to unsafety) that would benefit from being rewritten in Rust to remove an entire class of potential bugs. However, porting these applications to Rust manually is a daunting task. In this paper we investigate the problem of automatically translating C programs into safer Rust programs--that is, Rust programs that improve on the safety guarantees of the original C programs. We conduct an in-depth study into the underlying causes of unsafety in translated programs and the relative impact of fixing each cause. We also describe a novel technique for automatically removing a particular cause of unsafety and evaluate its effectiveness and impact. This paper presents the first empirical study of unsafety in translated Rust programs (as opposed to programs originally written in Rust) and also the first technique for automatically removing causes of unsafety in translated Rust programs.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485498", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mehmet", + "last_name": "Emre", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Ryan", + "last_name": "Schroeder", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Kyle", + "last_name": "Dewey", + "institution": "California State University, Northridge" + }, + { + "first_name": "Ben", + "last_name": "Hardekopf", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "journals/pacmpl/EmreSDH21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485487", + "title": "Relational nullable types with Boolean unification", + "abstract": "We present a simple, practical, and expressive relational nullable type system. A relational nullable type system captures whether an expression may evaluate to null based on its type, but also based on the type of other related expressions. The type system extends the Hindley-Milner type system with Boolean constraints, supports parametric polymorphism, and preserves principal types modulo Boolean equivalence. We show how to support full Hindley-Milner style type inference with an extension of Algorithm W. We conduct a preliminary study of open source projects showing that there is a need for relational nullable type systems across a wide range of programming languages. The most important findings from the study are: (i) programmers use programming patterns where the nullability of one expression depends on the nullability of other related expressions, (ii) such invariants are commonly enforced with run-time exceptions, and (iii) reasoning about these programming patterns requires not only knowledge of when an expression may evaluate to null, but also when it may evaluate to a non-null value. We incorporate these observations in the design of the proposed relational nullable type system.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485487", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Jaco van de", + "last_name": "Pol", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/MadsenP21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485485", + "title": "Label dependent lambda calculus and gradual typing", + "abstract": "Dependently-typed programming languages are gaining importance, because they can guarantee a wide range of properties at compile time. Their use in practice is often hampered because programmers have to provide very precise types. Gradual typing is a means to vary the level of typing precision between program fragments and to transition smoothly towards more precisely typed programs. The combination of gradual typing and dependent types seems promising to promote the widespread use of dependent types. We investigate a gradual version of a minimalist value-dependent lambda calculus. Compile-time calculations and thus dependencies are restricted to labels, drawn from a generic enumeration type. The calculus supports the usual Pi and Sigma types as well as singleton types and subtyping. It is sufficiently powerful to provide flexible encodings of variant and record types with first-class labels. We provide type checking algorithms for the underlying label-dependent lambda calculus and its gradual extension. The gradual type checker drives the translation into a cast calculus, which extends the original language. The cast calculus comes with several innovations: refined typing for casts in the presence of singletons, type reduction in casts, and fully dependent Sigma types. Besides standard metatheoretical results, we establish the gradual guarantee for the gradual language.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485485", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Weili", + "last_name": "Fu", + "institution": "University of Freiburg" + }, + { + "first_name": "Fabian", + "last_name": "Krause", + "institution": "University of Freiburg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "journals/pacmpl/FuKT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485531", + "title": "Not so fast: understanding and mitigating negative impacts of compiler optimizations on code reuse gadget sets", + "abstract": "Despite extensive testing and correctness certification of their functional semantics, a number of compiler optimizations have been shown to violate security guarantees implemented in source code. While prior work has shed light on how such optimizations may introduce semantic security weaknesses into programs, there remains a significant knowledge gap concerning the impacts of compiler optimizations on non-semantic properties with security implications. In particular, little is currently known about how code generation and optimization decisions made by the compiler affect the availability and utility of reusable code segments called gadgets required for implementing code reuse attack methods such as return-oriented programming. In this paper, we bridge this gap through a study of the impacts of compiler optimization on code reuse gadget sets. We analyze and compare 1,187 variants of 20 different benchmark programs built with two production compilers (GCC and Clang) to determine how their optimization behaviors affect the code reuse gadget sets present in program variants with respect to both quantitative and qualitative metrics. Our study exposes an important and unexpected problem; compiler optimizations introduce new gadgets at a high rate and produce code containing gadget sets that are generally more useful to an attacker than those in unoptimized code. Using differential binary analysis, we identify several undesirable behaviors at the root of this phenomenon. In turn, we propose and evaluate several strategies to mitigate these behaviors. In particular, we show that post-production binary recompilation can effectively mitigate these behaviors with negligible performance impacts, resulting in optimized code with significantly smaller and less useful gadget sets.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485531", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael D.", + "last_name": "Brown", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Matthew", + "last_name": "Pruett", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Robert", + "last_name": "Bigelow", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Girish", + "last_name": "Mururu", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/BrownPBMP21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485539", + "title": "FPL: fast Presburger arithmetic through transprecision", + "abstract": "Presburger arithmetic provides the mathematical core for the polyhedral compilation techniques that drive analytical cache models, loop optimization for ML and HPC, formal verification, and even hardware design. Polyhedral compilation is widely regarded as being slow due to the potentially high computational cost of the underlying Presburger libraries. Researchers typically use these libraries as powerful black-box tools, but the perceived internal complexity of these libraries, caused by the use of C as the implementation language and a focus on end-user-facing documentation, holds back broader performance-optimization efforts. With FPL, we introduce a new library for Presburger arithmetic built from the ground up in modern C++. We carefully document its internal algorithmic foundations, use lightweight C++ data structures to minimize memory management costs, and deploy transprecision computing across the entire library to effectively exploit machine integers and vector instructions. On a newly-developed comprehensive benchmark suite for Presburger arithmetic, we show a 5.4x speedup in total runtime over the state-of-the-art library isl in its default configuration and 3.6x over a variant of isl optimized with element-wise transprecision computing. We expect that the availability of a well-documented and fast Presburger library will accelerate the adoption of polyhedral compilation techniques in production compilers.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485539", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arjun", + "last_name": "Pitchanathan", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Christian", + "last_name": "Ulmann", + "institution": "ETH Zurich" + }, + { + "first_name": "Michel", + "last_name": "Weber", + "institution": "ETH Zurich" + }, + { + "first_name": "Torsten", + "last_name": "Hoefler", + "institution": "ETH Zurich" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/PitchanathanUWH21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485490", + "title": "Verifying concurrent multicopy search structures", + "abstract": "Multicopy search structures such as log-structured merge (LSM) trees are optimized for high insert/update/delete (collectively known as upsert) performance. In such data structures, an upsert on key k , which adds ( k , v ) where v can be a value or a tombstone, is added to the root node even if k is already present in other nodes. Thus there may be multiple copies of k in the search structure. A search on k aims to return the value associated with the most recent upsert. We present a general framework for verifying linearizability of concurrent multicopy search structures that abstracts from the underlying representation of the data structure in memory, enabling proof-reuse across diverse implementations. Based on our framework, we propose template algorithms for (a) LSM structures forming arbitrary directed acyclic graphs and (b) differential file structures, and formally verify these templates in the concurrent separation logic Iris. We also instantiate the LSM template to obtain the first verified concurrent in-memory LSM tree implementation.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485490", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nisarg", + "last_name": "Patel", + "institution": "New York University" + }, + { + "first_name": "Siddharth", + "last_name": "Krishna", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Dennis", + "last_name": "Shasha", + "institution": "New York University" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/PatelKSW21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485480", + "title": "Safer at any speed: automatic context-aware safety enhancement for Rust", + "abstract": "Type-safe languages improve application safety by eliminating whole classes of vulnerabilities–such as buffer overflows–by construction. However, this safety sometimes comes with a performance cost. As a result, many modern type-safe languages provide escape hatches that allow developers to manually bypass them. The relative value of performance to safety and the degree of performance obtained depends upon the application context, including user goals and the hardware upon which the application is to be executed. Since libraries may be used in many different contexts, library developers cannot make safety-performance trade-off decisions appropriate for all cases. Application developers can tune libraries themselves to increase safety or performance, but this requires extra effort and makes libraries less reusable. To address this problem, we present NADER, a Rust development tool that makes applications safer by automatically transforming unsafe code into equivalent safe code according to developer preferences and application context. In end-to-end system evaluations in a given context, NADER automatically reintroduces numerous library bounds checks, in many cases making application code that uses popular Rust libraries safer with no corresponding loss in performance.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485480", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Natalie", + "last_name": "Popescu", + "institution": "Princeton University" + }, + { + "first_name": "Ziyang", + "last_name": "Xu", + "institution": "Princeton University" + }, + { + "first_name": "Sotiris", + "last_name": "Apostolakis", + "institution": "Google (United States)" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + }, + { + "first_name": "Amit", + "last_name": "Levy", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/PopescuXAAL21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485525", + "title": "LXM: better splittable pseudorandom number generators (and almost as fast)", + "abstract": "In 2014, Steele, Lea, and Flood presented SplitMix, an object-oriented pseudorandom number generator (prng) that is quite fast (9 64-bit arithmetic/logical operations per 64 bits generated) and also splittable . A conventional prng object provides a generate method that returns one pseudorandom value and updates the state of the prng; a splittable prng object also has a second operation, split , that replaces the original prng object with two (seemingly) independent prng objects, by creating and returning a new such object and updating the state of the original object. Splittable prng objects make it easy to organize the use of pseudorandom numbers in multithreaded programs structured using fork-join parallelism. This overall strategy still appears to be sound, but the specific arithmetic calculation used for generate in the SplitMix algorithm has some detectable weaknesses, and the period of any one generator is limited to 2 64 . Here we present the LXM family of prng algorithms. The idea is an old one: combine the outputs of two independent prng algorithms, then (optionally) feed the result to a mixing function. An LXM algorithm uses a linear congruential subgenerator and an F 2 -linear subgenerator; the examples studied in this paper use a linear congruential generator (LCG) of period 2 16 , 2 32 , 2 64 , or 2 128 with one of the multipliers recommended by L’Ecuyer or by Steele and Vigna, and an F 2 -linear xor-based generator (XBG) of the xoshiro family or xoroshiro family as described by Blackman and Vigna. For mixing functions we study the MurmurHash3 finalizer function; variants by David Stafford, Doug Lea, and degski; and the null (identity) mixing function. Like SplitMix, LXM provides both a generate operation and a split operation. Also like SplitMix, LXM requires no locking or other synchronization (other than the usual memory fence after instance initialization), and is suitable for use with simd instruction sets because it has no branches or loops. We analyze the period and equidistribution properties of LXM generators, and present the results of thorough testing of specific members of this family, using the TestU01 and PractRand test suites, not only on single instances of the algorithm but also for collections of instances, used in parallel, ranging in size from 2 to 2 24 . Single instances of LXM that include a strong mixing function appear to have no major weaknesses, and LXM is significantly more robust than SplitMix against accidental correlation in a multithreaded setting. We believe that LXM, like SplitMix, is suitable for “everyday” scientific and machine-learning applications (but not cryptographic applications), especially when concurrent threads or distributed processes are involved.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485525", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guy L.", + "last_name": "Steele", + "institution": "Oracle (United States)" + }, + { + "first_name": "Sebastiano", + "last_name": "Vigna", + "institution": "University of Milan" + } + ], + "dblp_key": "journals/pacmpl/SteeleV21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485494", + "title": "Formal verification of high-level synthesis", + "abstract": "High-level synthesis (HLS), which refers to the automatic compilation of software into hardware, is rapidly gaining popularity. In a world increasingly reliant on application-specific hardware accelerators, HLS promises hardware designs of comparable performance and energy efficiency to those coded by hand in a hardware description language such as Verilog, while maintaining the convenience and the rich ecosystem of software development. However, current HLS tools cannot always guarantee that the hardware designs they produce are equivalent to the software they were given, thus undermining any reasoning conducted at the software level. Furthermore, there is mounting evidence that existing HLS tools are quite unreliable, sometimes generating wrong hardware or crashing when given valid inputs. To address this problem, we present the first HLS tool that is mechanically verified to preserve the behaviour of its input software. Our tool, called Vericert, extends the CompCert verified C compiler with a new hardware-oriented intermediate language and a Verilog back end, and has been proven correct in Coq. Vericert supports most C constructs, including all integer operations, function calls, local arrays, structs, unions, and general control-flow statements. An evaluation on the PolyBench/C benchmark suite indicates that Vericert generates hardware that is around an order of magnitude slower (only around 2× slower in the absence of division) and about the same size as hardware generated by an existing, optimising (but unverified) HLS tool.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485494", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yann", + "last_name": "Herklotz", + "institution": "Imperial College London" + }, + { + "first_name": "James D.", + "last_name": "Pollard", + "institution": "Imperial College London" + }, + { + "first_name": "Nadesh", + "last_name": "Ramanathan", + "institution": "Imperial College London" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/HerklotzPRW21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485482", + "title": "Synbit: synthesizing bidirectional programs using unidirectional sketches", + "abstract": "We propose a technique for synthesizing bidirectional programs from the corresponding unidirectional code plus a few input/output examples. The core ideas are: (1) constructing a sketch using the given unidirectional program as a specification, and (2) filling the sketch in a modular fashion by exploiting the properties of bidirectional programs. These ideas are enabled by our choice of programming language, HOBiT, which is specifically designed to maintain the unidirectional program structure in bidirectional programming, and keep the parts that control bidirectional behavior modular. To evaluate our approach, we implemented it in a tool called Synbit and used it to generate bidirectional programs for intricate microbenchmarks, as well as for a few larger, more realistic problems. We also compared Synbit to a state-of-the-art unidirectional synthesis tool on the task of synthesizing backward computations.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485482", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Masaomi", + "last_name": "Yamaguchi", + "institution": "Tohoku University" + }, + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + }, + { + "first_name": "Cristina", + "last_name": "David", + "institution": "University of Bristol" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/YamaguchiMDW21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485492", + "title": "Statically bounded-memory delayed sampling for probabilistic streams", + "abstract": "Probabilistic programming languages aid developers performing Bayesian inference. These languages provide programming constructs and tools for probabilistic modeling and automated inference. Prior work introduced a probabilistic programming language, ProbZelus, to extend probabilistic programming functionality to unbounded streams of data. This work demonstrated that the delayed sampling inference algorithm could be extended to work in a streaming context. ProbZelus showed that while delayed sampling could be effectively deployed on some programs, depending on the probabilistic model under consideration, delayed sampling is not guaranteed to use a bounded amount of memory over the course of the execution of the program. In this paper, we the present conditions on a probabilistic program’s execution under which delayed sampling will execute in bounded memory. The two conditions are dataflow properties of the core operations of delayed sampling: the m -consumed property and the unseparated paths property . A program executes in bounded memory under delayed sampling if, and only if, it satisfies the m -consumed and unseparated paths properties. We propose a static analysis that abstracts over these properties to soundly ensure that any program that passes the analysis satisfies these properties, and thus executes in bounded memory under delayed sampling.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485492", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Atkinson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Guillaume", + "last_name": "Baudart", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Louis", + "last_name": "Mandel", + "institution": "" + }, + { + "first_name": "Charles", + "last_name": "Yuan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AtkinsonBMYC21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485488", + "title": "Solver-based gradual type migration", + "abstract": "Gradually typed languages allow programmers to mix statically and dynamically typed code, enabling them to incrementally reap the benefits of static typing as they add type annotations to their code. However, this type migration process is typically a manual effort with limited tool support. This paper examines the problem of automated type migration: given a dynamic program, infer additional or improved type annotations. Existing type migration algorithms prioritize different goals, such as maximizing type precision, maintaining compatibility with unmigrated code, and preserving the semantics of the original program. We argue that the type migration problem involves fundamental compromises: optimizing for a single goal often comes at the expense of others. Ideally, a type migration tool would flexibly accommodate a range of user priorities. We present TypeWhich, a new approach to automated type migration for the gradually-typed lambda calculus with some extensions. Unlike prior work, which relies on custom solvers, TypeWhich produces constraints for an off-the-shelf MaxSMT solver. This allows us to easily express objectives, such as minimizing the number of necessary syntactic coercions, and constraining the type of the migration to be compatible with unmigrated code. We present the first comprehensive evaluation of GTLC type migration algorithms, and compare TypeWhich to four other tools from the literature. Our evaluation uses prior benchmarks, and a new set of \"challenge problems.\" Moreover, we design a new evaluation methodology that highlights the subtleties of gradual type migration. In addition, we apply TypeWhich to a suite of benchmarks for Grift, a programming language based on the GTLC. TypeWhich is able to reconstruct all human-written annotations on all but one program.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485488", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luna", + "last_name": "Phipps-Costin", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Carolyn Jane", + "last_name": "Anderson", + "institution": "Wellesley College" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/Phipps-CostinAG21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485540", + "title": "Symbolic value-flow static analysis: deep, precise, complete modeling of Ethereum smart contracts", + "abstract": "We present a static analysis approach that combines concrete values and symbolic expressions. This symbolic value-flow (“symvalic”) analysis models program behavior with high precision, e.g., full path sensitivity. To achieve deep modeling of program semantics, the analysis relies on a symbiotic relationship between a traditional static analysis fixpoint computation and a symbolic solver: the solver does not merely receive a complex “path condition” to solve, but is instead invoked repeatedly (often tens or hundreds of thousands of times), in close cooperation with the flow computation of the analysis. The result of the symvalic analysis architecture is a static modeling of program behavior that is much more complete than symbolic execution, much more precise than conventional static analysis, and domain-agnostic: no special-purpose definition of anti-patterns is necessary in order to compute violations of safety conditions with high precision. We apply the analysis to the domain of Ethereum smart contracts. This domain represents a fundamental challenge for program analysis approaches: despite numerous publications, research work has not been effective at uncovering vulnerabilities of high real-world value. In systematic comparison of symvalic analysis with past tools, we find significantly increased completeness (shown as 83-96% statement coverage and more true error reports) combined with much higher precision, as measured by rate of true positive reports. In terms of real-world impact, since the beginning of 2021, the analysis has resulted in the discovery and disclosure of several critical vulnerabilities, over funds in the many millions of dollars. Six separate bug bounties totaling over $350K have been awarded for these disclosures.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485540", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "University of Malta" + }, + { + "first_name": "Sifis", + "last_name": "Lagouvardos", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Κonstantinos", + "last_name": "Τriantafyllou", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Ilias", + "last_name": "Tsatiris", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/SmaragdakisGLTT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485546", + "title": "MonkeyDB: effectively testing correctness under weak isolation levels", + "abstract": "Modern applications, such as social networking systems and e-commerce platforms are centered around using large-scale storage systems for storing and retrieving data. In the presence of concurrent accesses, these storage systems trade off isolation for performance. The weaker the isolation level, the more behaviors a storage system is allowed to exhibit and it is up to the developer to ensure that their application can tolerate those behaviors. However, these weak behaviors only occur rarely in practice and outside the control of the application, making it difficult for developers to test the robustness of their code against weak isolation levels. This paper presents MonkeyDB, a mock storage system for testing storage-backed applications. MonkeyDB supports a key-value interface as well as SQL queries under multiple isolation levels. It uses a logical specification of the isolation level to compute, on a read operation, the set of all possible return values. MonkeyDB then returns a value randomly from this set. We show that MonkeyDB provides good coverage of weak behaviors, which is complete in the limit. We test a variety of applications for assertions that fail only under weak isolation. MonkeyDB is able to break each of those assertions in a small number of attempts.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485546", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ranadeep", + "last_name": "Biswas", + "institution": "Université Paris Cité" + }, + { + "first_name": "Diptanshu", + "last_name": "Kakwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jyothi", + "last_name": "Vedurada", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Institut de Recherche en Informatique Fondamentale" + }, + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "journals/pacmpl/BiswasKVEL21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485503", + "title": "Gradually structured data", + "abstract": "Dynamically-typed languages offer easy interaction with ad hoc data such as JSON and S-expressions; statically-typed languages offer powerful tools for working with structured data, notably algebraic datatypes , which are a core feature of typed languages both functional and otherwise. Gradual typing aims to reconcile dynamic and static typing smoothly. The gradual typing literature has extensively focused on the computational aspect of types, such as type safety, effects, noninterference, or parametricity, but the application of graduality to data structuring mechanisms has been much less explored. While row polymorphism and set-theoretic types have been studied in the context of gradual typing, algebraic datatypes in particular have not, which is surprising considering their wide use in practice. We develop, formalize, and prototype a novel approach to gradually structured data with algebraic datatypes. Gradually structured data bridges the gap between traditional algebraic datatypes and flexible data management mechanisms such as tagged data in dynamic languages, or polymorphic variants in OCaml. We illustrate the key ideas of gradual algebraic datatypes through the evolution of a small server application from dynamic to progressively more static checking, formalize a core functional language with gradually structured data, and establish its metatheory, including the gradual guarantees.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485503", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Malewski", + "institution": "University of Chile" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/MalewskiGT21", + "venue": "oopsla", + "year": 2021 + }, + { + "paper_id": "10.1145/3485512", + "title": "A type system for extracting functional specifications from memory-safe imperative programs", + "abstract": "Verifying imperative programs is hard. A key difficulty is that the specification of what an imperative program does is often intertwined with details about pointers and imperative state. Although there are a number of powerful separation logics that allow the details of imperative state to be captured and managed, these details are complicated and reasoning about them requires significant time and expertise. In this paper, we take a different approach: a memory-safe type system that, as part of type-checking, extracts functional specifications from imperative programs. This disentangles imperative state, which is handled by the type system, from functional specifications, which can be verified without reference to pointers. A key difficulty is that sometimes memory safety depends crucially on the functional specification of a program; e.g., an array index is only memory-safe if the index is in bounds. To handle this case, our specification extraction inserts dynamic checks into the specification. Verification then requires the additional proof that none of these checks fail. However, these checks are in a purely functional language, and so this proof also requires no reasoning about pointers.", + "date": "2021-10-15", + "link": "https://doi.org/10.1145/3485512", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "He", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Eddy", + "last_name": "Westbrook", + "institution": "Galois (United States)" + }, + { + "first_name": "Brent", + "last_name": "Carmer", + "institution": "Galois (United States)" + }, + { + "first_name": "Chris", + "last_name": "Phifer", + "institution": "Galois (United States)" + }, + { + "first_name": "Valentin", + "last_name": "Robert", + "institution": "Galois (United States)" + }, + { + "first_name": "Karl", + "last_name": "Smeltzer", + "institution": "Galois (United States)" + }, + { + "first_name": "Andrei", + "last_name": "Ștefănescu", + "institution": "Galois (United States)" + }, + { + "first_name": "Aaron", + "last_name": "Tomb", + "institution": "Galois (United States)" + }, + { + "first_name": "Adam", + "last_name": "Wick", + "institution": "Galois (United States)" + }, + { + "first_name": "Matthew", + "last_name": "Yacavone", + "institution": "Galois (United States)" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/HeWCPRSSTWYZ21", + "venue": "oopsla", + "year": 2021 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2022.json b/data/pl_conferences/oopsla/2022.json new file mode 100644 index 0000000..9314a59 --- /dev/null +++ b/data/pl_conferences/oopsla/2022.json @@ -0,0 +1,3013 @@ +[ + { + "paper_id": "10.1145/3527326", + "title": "Purity of an ST monad: full abstraction by semantically typed back-translation", + "abstract": "In 1995, Launchbury and Peyton Jones extended Haskell with an ST monad that allows the programmer to use higher-order mutable state. They informally argued that these state computations were safely encapsulated, and as such, that the rich reasoning principles stemming from the purity of the language, were not threatened. In this paper, we give a formal account of the preservation of purity after adding an ST monad to a simply-typed call-by-value recursive lambda calculus. We state and prove full abstraction when embedding the pure language into its extension with ST; contextual equivalences from the pure language continue to hold in the presence of ST. Proving full abstraction of compilers is usually done by emulating or back-translating the target features (here: ST computations) into the source language, a well-known challenge in the secure compilation community. We employ a novel proof technique for proving our full abstraction result that allows us to use a semantically (but not syntactically) typed back-translation into an intermediate language. We believe that this technique provides additional insight into our proof and that it is of general interest to researchers studying programming languages and compilers using full abstraction. The results presented here are fully formalized in the Coq proof assistant using the Iris framework.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527326", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Koen", + "last_name": "Jacobs", + "institution": "KU Leuven" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/JacobsDT22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527317", + "title": "Coverage-guided tensor compiler fuzzing with joint IR-pass mutation", + "abstract": "In the past decade, Deep Learning (DL) systems have been widely deployed in various application domains to facilitate our daily life, e.g., natural language processing, healthcare, activity recognition, and autonomous driving. Meanwhile, it is extremely challenging to ensure the correctness of DL systems (e.g., due to their intrinsic nondeterminism), and bugs in DL systems can cause serious consequences and may even threaten human lives. In the literature, researchers have explored various techniques to test, analyze, and verify DL models, since their quality directly affects the corresponding system behaviors. Recently, researchers have also proposed novel techniques for testing the underlying operator-level DL libraries (such as TensorFlow and PyTorch), which provide general binary implementations for each high-level DL operator and are the foundation for running DL models on different hardware platforms. However, there is still limited work targeting the reliability of the emerging tensor compilers (also known as DL compilers), which aim to automatically compile high-level tensor computation graphs directly into high-performance binaries for better efficiency, portability, and scalability than traditional operator-level libraries. Therefore, in this paper, we target the important problem of tensor compiler testing, and have proposed Tzer, a practical fuzzing technique for the widely used TVM tensor compiler. Tzer focuses on mutating the low-level Intermediate Representation (IR) for TVM due to the limited mutation space for the high-level IR. More specifically, Tzer leverages both general-purpose and tensor-compiler-specific mutators guided by coverage feedback for diverse and evolutionary IR mutation; furthermore, since tensor compilers provide various passes (i.e., transformations) for IR optimization, Tzer also performs pass mutation in tandem with IR mutation for more effective fuzzing. Our experimental results show that Tzer substantially outperforms existing fuzzing techniques on tensor compiler testing, with 75% higher coverage and 50% more valuable tests than the 2nd-best technique. Also, different components of Tzer have been validated via ablation study. To date, Tzer has detected 49 previously unknown bugs for TVM, with 37 bugs confirmed and 25 bugs fixed (PR merged).", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527317", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jiawei", + "last_name": "Liu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Yuxiang", + "last_name": "Wei", + "institution": "Tongji University" + }, + { + "first_name": "Sen", + "last_name": "Yang", + "institution": "Fudan University" + }, + { + "first_name": "Yinlin", + "last_name": "Deng", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Lingming", + "last_name": "Zhang", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/LiuWYDZ22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527314", + "title": "Plausible sealing for gradual parametricity", + "abstract": "Graduality and parametricity have proven to be extremely challenging notions to bring together. Intuitively, enforcing parametricity gradually requires possibly sealing values in order to detect violations of uniform behavior. Toro et al. (2019) argue that the two notions are incompatible in the context of System F, where sealing is transparently driven by potentially imprecise type information, while New et al. (2020) reconcile both properties at the cost of abandoning the syntax of System F and requiring user-provided sealing annotations that are not subject to graduality guarantees. Furthermore, all current proposals rely on a global form of dynamic sealing in order to enforce parametric behavior at runtime, which weakens parametric reasoning and breaks equivalences in the static language. Based on the observation that the tension between graduality and parametricity comes from the early commitment to seal values based on type information, we propose plausible sealing as a new intermediate language mechanism that allows postponing such decisions to runtime. We propose an intermediate language for gradual parametricity, Funky, which supports plausible sealing in a simplified setting where polymorphism is restricted to instantiations with base and variable types. We prove that Funky satisfies both parametricity and graduality, mechanizing key lemmas in Agda. Additionally, we avoid global dynamic sealing and instead propose a novel lexically-scoped form of sealing realized using a representation of evidence inspired by the category of spans. As a consequence, Funky satisfies a standard formulation of parametricity that does not break System F equivalences. In order to show the practicality of plausible sealing, we describe a translation from Funk, a source language without explicit sealing, to Funky, that takes care of inserting plausible sealing forms. We establish graduality of Funk, subject to a restriction on type applications, and explain the source-level parametric reasoning it supports. Finally, we provide an interactive prototype along with illustrative examples both novel and from the literature.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527314", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Elizabeth", + "last_name": "Labrada", + "institution": "University of Chile" + }, + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + } + ], + "dblp_key": "journals/pacmpl/LabradaTTD22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527332", + "title": "SHARP: fast incremental context-sensitive pointer analysis for Java", + "abstract": "We present SHARP, an incremental context-sensitive pointer analysis algorithm that scales to real-world large complex Java programs and can also be efficiently parallelized. To our knowledge, SHARP is the first algorithm to tackle context-sensitivity in the state-of-the-art incremental pointer analysis (with regards to code modifications including both statement additions and deletions), which applies to both k-CFA and k-obj. To achieve it, SHARP tackles several technical challenges: soundness, redundant computations, and parallelism to improve scalability without losing precision. We conduct an extensive empirical evaluation of SHARP on large and popular Java projects and their code commits, showing impressive performance improvement: our incremental algorithm only requires on average 31 seconds to handle a real-world code commit for k-CFA and k-obj, which has comparable performance to the state-of-the-art incremental context-insensitive pointer analysis. Our parallelization further improves the performance and enables SHARP to finish within 18 seconds per code commit on average on an eight-core machine.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527332", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bozhen", + "last_name": "Liu", + "institution": "Texas A&M University" + }, + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + } + ], + "dblp_key": "journals/pacmpl/LiuH22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527324", + "title": "C4: verified transactional objects", + "abstract": "Transactional objects combine the performance of classical concurrent objects with the high-level programmability of transactional memory. However, verifying the correctness of transactional objects is tricky, requiring reasoning simultaneously about classical concurrent objects, which guarantee the atomicity of individual methods—the property known as linearizability—and about software-transactional-memory libraries, which guarantee the atomicity of user-defined sequences of method calls—or serializability. We present a formal-verification framework called C4, built up from the familiar notion of linearizability and its compositional properties, that allows proof of both kinds of libraries, along with composition of theorems from both styles to prove correctness of applications or further libraries. We apply the framework in a significant case study, verifying a transactional set object built out of both classical and transactional components following the technique of transactional predication ; the proof is modular, reasoning separately about the transactional and nontransactional parts of the implementation. Central to our approach is the use of syntactic transformers on interaction trees —i.e., transactional libraries that transform client code to enforce particular synchronization disciplines. Our framework and case studies are mechanized in Coq.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527324", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Riverside" + }, + { + "first_name": "Li-yao", + "last_name": "Xia", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Anders", + "last_name": "Kaseorg", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Christian J.", + "last_name": "Bell", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/LesaniXKBCPZ22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527328", + "title": "End-to-end translation validation for the halide language", + "abstract": "This paper considers the correctness of domain-specific compilers for tensor programming languages through the study of Halide, a popular representative. It describes a translation validation algorithm for affine Halide specifications, independently of the scheduling language. The algorithm relies on “prophetic” annotations added by the compiler to the generated array assignments. The annotations provide a refinement mapping from assignments in the generated code to the tensor definitions from the specification. Our implementation leverages an affine solver and a general SMT solver, and scales to complete Halide benchmarks.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527328", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Basile", + "last_name": "Clément", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/ClementC22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527315", + "title": "Automated transpilation of imperative to functional code using neural-guided program synthesis", + "abstract": "While many mainstream languages such as Java, Python, and C# increasingly incorporate functional APIs to simplify programming and improve parallelization/performance, there are no effective techniques that can be used to automatically translate existing imperative code to functional variants using these APIs. Motivated by this problem, this paper presents a transpilation approach based on inductive program synthesis for modernizing existing code. Our method is based on the observation that the overwhelming majority of source/target programs in this setting satisfy an assumption that we call trace-compatibility: not only do the programs share syntactically identical low-level expressions, but these expressions also take the same values in corresponding execution traces. Our method leverages this observation to design a new neural-guided synthesis algorithm that (1) uses a novel neural architecture called cognate grammar network (CGN) and (2) leverages a form of concolic execution to prune partial programs based on intermediate values that arise during a computation. We have implemented our approach in a tool called NGST2 and use it to translate imperative Java and Python code to functional variants that use the Stream and functools APIs respectively. Our experiments show that NGST2 significantly outperforms several baselines and that our proposed neural architecture and pruning techniques are vital for achieving good results.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527315", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Mariano", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yanju", + "last_name": "Chen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Greg", + "last_name": "Durrett", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/MarianoCFDD22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527313", + "title": "Linear types for large-scale systems verification", + "abstract": "Reasoning about memory aliasing and mutation in software verification is a hard problem. This is especially true for systems using SMT-based automated theorem provers. Memory reasoning in SMT verification typically requires a nontrivial amount of manual effort to specify heap invariants, as well as extensive alias reasoning from the SMT solver. In this paper, we present a hybrid approach that combines linear types with SMT-based verification for memory reasoning. We integrate linear types into Dafny, a verification language with an SMT backend, and show that the two approaches complement each other. By separating memory reasoning from verification conditions, linear types reduce the SMT solving time. At the same time, the expressiveness of SMT queries extends the flexibility of the linear type system. In particular, it allows our linear type system to easily and correctly mix linear and nonlinear data in novel ways, encapsulating linear data inside nonlinear data and vice-versa. We formalize the core of our extensions, prove soundness, and provide algorithms for linear type checking. We evaluate our approach by converting the implementation of a verified storage system (about 24K lines of code and proof) written in Dafny, to use our extended Dafny. The resulting system uses linear types for 91% of the code and SMT-based heap reasoning for the remaining 9%. We show that the converted system has 28% fewer lines of proofs and 30% shorter verification time overall. We discuss the development overhead in the original system due to SMT-based heap reasoning and highlight the improved developer experience when using linear types.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527313", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jialin", + "last_name": "Li", + "institution": "University of Washington" + }, + { + "first_name": "Andrea", + "last_name": "Lattuada", + "institution": "ETH Zurich" + }, + { + "first_name": "Yi", + "last_name": "Zhou", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Cameron", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jon", + "last_name": "Howell", + "institution": "" + }, + { + "first_name": "Bryan", + "last_name": "Parno", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/LiLZCHPH22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527316", + "title": "On incorrectness logic for Quantum programs", + "abstract": "Bug-catching is important for developing quantum programs. Motivated by the incorrectness logic for classical programs, we propose an incorrectness logic towards a logical foundation for static bug-catching in quantum programming. The validity of formulas in this logic is dual to that of quantum Hoare logics. We justify the formulation of validity by an intuitive explanation from a reachability point of view and a comparison against several alternative formulations. Compared with existing works focusing on dynamic analysis, our logic provides sound and complete arguments. We further demonstrate the usefulness of the logic by reasoning several examples, including Grover's search, quantum teleportation, and a repeat-until-success program. We also automate the reasoning procedure by a prototyped static analyzer built on top of the logic rules.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527316", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peng", + "last_name": "Yan", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Hanru", + "last_name": "Jiang", + "institution": "" + }, + { + "first_name": "Nengkun", + "last_name": "Yu", + "institution": "University of Technology Sydney" + } + ], + "dblp_key": "journals/pacmpl/YanJY22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527331", + "title": "Quantitative strongest post: a calculus for reasoning about the flow of quantitative information", + "abstract": "We present a novel strongest-postcondition-style calculus for quantitative reasoning about non-deterministic programs with loops. Whereas existing quantitative weakest pre allows reasoning about the value of a quantity after a program terminates on a given initial state, quantitative strongest post allows reasoning about the value that a quantity had before the program was executed and reached a given final state. We show how strongest post enables reasoning about the flow of quantitative information through programs. Similarly to weakest liberal preconditions, we also develop a quantitative strongest liberal post. As a byproduct, we obtain the entirely unexplored notion of strongest liberal postconditions and show how these foreshadow a potential new program logic - partial incorrectness logic - which would be a more liberal version of O'Hearn's recent incorrectness logic.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527331", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Linpeng", + "last_name": "Zhang", + "institution": "University College London" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/ZhangK22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527320", + "title": "Effects, capabilities, and boxes: from scope-based reasoning to type-based reasoning and back", + "abstract": "Reasoning about the use of external resources is an important aspect of many practical applications. Effect systems enable tracking such information in types, but at the cost of complicating signatures of common functions. Capabilities coupled with escape analysis offer safety and natural signatures, but are often overly coarse grained and restrictive. We present System C, which builds on and generalizes ideas from type-based escape analysis and demonstrates that capabilities and effects can be reconciled harmoniously. By assuming that all functions are second class, we can admit natural signatures for many common programs. By introducing a notion of boxed values, we can lift the restrictions of second-class values at the cost of needing to track degree-of-impurity information in types. The system we present is expressive enough to support effect handlers in full capacity. We practically evaluate System C in an implementation and prove its soundness.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527320", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Edward", + "last_name": "Lee", + "institution": "University of Waterloo" + }, + { + "first_name": "Aleksander", + "last_name": "Boruch-Gruszecki", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/BrachthauserSLB22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527330", + "title": "Bugs in Quantum computing platforms: an empirical study", + "abstract": "The interest in quantum computing is growing, and with it, the importance of software platforms to develop quantum programs. Ensuring the correctness of such platforms is important, and it requires a thorough understanding of the bugs they typically suffer from. To address this need, this paper presents the first in-depth study of bugs in quantum computing platforms. We gather and inspect a set of 223 real-world bugs from 18 open-source quantum computing platforms. Our study shows that a significant fraction of these bugs (39.9%) are quantum-specific, calling for dedicated approaches to prevent and find them. The bugs are spread across various components, but quantum-specific bugs occur particularly often in components that represent, compile, and optimize quantum programming abstractions. Many quantum-specific bugs manifest through unexpected outputs, rather than more obvious signs of misbehavior, such as crashes. Finally, we present a hierarchy of recurrent bug patterns, including ten novel, quantum-specific patterns. Our findings not only show the importance and prevalence bugs in quantum computing platforms, but they help developers to avoid common mistakes and tool builders to tackle the challenge of preventing, finding, and fixing these bugs.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527330", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matteo", + "last_name": "Paltenghi", + "institution": "University of Stuttgart" + }, + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "University of Stuttgart" + } + ], + "dblp_key": "journals/pacmpl/PaltenghiP22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527322", + "title": "C to checked C by 3c", + "abstract": "Owing to the continued use of C (and C++), spatial safety violations (e.g., buffer overflows) still constitute one of today's most dangerous and prevalent security vulnerabilities. To combat these violations, Checked C extends C with bounds-enforced checked pointer types. Checked C is essentially a gradually typed spatially safe C - checked pointers are backwards-binary compatible with legacy pointers, and the language allows them to be added piecemeal, rather than necessarily all at once, so that safety retrofitting can be incremental. This paper presents a semi-automated process for porting a legacy C program to Checked C. The process centers on 3C, a static analysis-based annotation tool. 3C employs two novel static analysis algorithms - typ3c and boun3c - to annotate legacy pointers as checked pointers, and to infer array bounds annotations for pointers that need them. 3C performs a root cause analysis to direct a human developer to code that should be refactored; once done, 3C can be re-run to infer further annotations (and updated root causes). Experiments on 11 programs totaling 319KLoC show 3C to be effective at inferring checked pointer types, and experience with previously and newly ported code finds 3C works well when combined with human-driven refactoring.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527322", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aravind", + "last_name": "Machiry", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "John", + "last_name": "Kastner", + "institution": "Amazon (United States)" + }, + { + "first_name": "Matt", + "last_name": "McCutchen", + "institution": "Amazon (United States)" + }, + { + "first_name": "Aaron", + "last_name": "Eline", + "institution": "Amazon (United States)" + }, + { + "first_name": "Kyle", + "last_name": "Headley", + "institution": "Amazon (United States)" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/MachiryKMEHH22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527318", + "title": "Le temps des cerises: efficient temporal stack safety on capability machines using directed capabilities", + "abstract": "Capability machines are a type of CPUs that support fine-grained privilege separation using capabilities , machine words that include forms of authority. Formal models of capability machines and associated calling conventions have so far focused on establishing two forms of stack safety properties, namely local state encapsulation and well-bracketed control flow. We introduce a novel kind of directed capabilities and show how to use them to make an earlier suggested calling convention more efficient. In contrast to earlier work on capability machine models we do not only consider integrity properties but also confidentiality properties; we provide a unary logical relation to reason about the former and a binary logical relation to reason about the latter, each expressive enough to reason about temporal stack safety. While the logical relations are useful for reasoning about concrete examples, they do not on their own demonstrate that stack safety holds for a large class of programs. Therefore, we also show full abstraction of a compiler from an overlay semantics that internalizes the calling convention as a single call step and explicitly keeps track of the call stack and frame lifetimes to a base capability machine. All results have been mechanized in Coq.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527318", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aïna Linn", + "last_name": "Georges", + "institution": "Aarhus University" + }, + { + "first_name": "Alix", + "last_name": "Trieu", + "institution": "Agence Nationale de Sécurité du Médicament et des Produits de Santé" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/GeorgesTB22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527329", + "title": "Language-parametric static semantic code completion", + "abstract": "Code completion is an editor service in IDEs that proposes code fragments for the user to insert at the caret position in their code. Code completion should be sound and complete. It should be sound, such that it only proposes fragments that do not violate the syntactic and static semantic rules of the language. It should be complete, such that it proposes all valid fragments so that code completion can be used to construct all programs. To realize soundness and completeness, code completion should be informed by the language definition. In practice, the implementation of code completion is an additional effort in the implementation of a language. In this paper, we develop a framework for language-parametric semantic code completion for statically typed programming languages based on their specification of syntax and static semantics, realizing the implementation of a code completion editor service with minimal additional effort. The framework builds on the SDF3 syntax definition formalism and the Statix static semantics specification language. The algorithm reinterprets the static semantics definition to find sound expansions of predicates and solutions to name resolution queries in scope graphs. This allows a search strategy to explore the solution space and synthesize completion proposals. The implementation of the strategy language and code completion algorithm extend the implementation of the Statix solver, and can be used for any language defined in Statix. We demonstrate soundness and completeness of the completion proposal synthesis, and evaluate its performance.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527329", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel A. A.", + "last_name": "Pelsmaeker", + "institution": "Delft University of Technology" + }, + { + "first_name": "Hendrik van", + "last_name": "Antwerpen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/PelsmaekerAPV22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527311", + "title": "Synthesizing fine-grained synchronization protocols for implicit monitors", + "abstract": "A monitor is a widely-used concurrent programming abstraction that encapsulates all shared state between threads. Monitors can be classified as being either implicit or explicit depending on the primitives they provide. Implicit monitors are much easier to program but typically not as efficient. To address this gap, there has been recent research on automatically synthesizing explicit-signal monitors from an implicit specification, but prior work does not exploit all paralellization opportunities due to the use of a single lock for the entire monitor. This paper presents a new technique for synthesizing fine-grained explicit-synchronization protocols from implicit monitors. Our method is based on two key innovations: First, we present a new static analysis for inferring safe interleavings that allow violating mutual exclusion of monitor operations without changing its semantics. Second, we use the results of this static analysis to generate a MaxSAT instance whose models correspond to correct-by-construction synchronization protocols. We have implemented our approach in a tool called Cortado and evaluate it on monitors that contain parallelization opportunities. Our evaluation shows that Cortado can synthesize synchronization policies that are competitive with, or even better than, expert-written ones on these benchmarks.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527311", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kostas", + "last_name": "Ferles", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Benjamin", + "last_name": "Sepanski", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "R.", + "last_name": "Krishnan", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "James", + "last_name": "Bornholt", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/FerlesSKBD22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527321", + "title": "Elipmoc: advanced decompilation of Ethereum smart contracts", + "abstract": "Smart contracts on the Ethereum blockchain greatly benefit from cutting-edge analysis techniques and pose significant challenges. A primary challenge is the extremely low-level representation of deployed contracts. We present Elipmoc, a decompiler for the next generation of smart contract analyses. Elipmoc is an evolution of Gigahorse, the top research decompiler, dramatically improving over it and over other state-of-the-art tools, by employing several high-precision techniques and making them scalable. Among these techniques are a new kind of context sensitivity (termed “transactional sensitivity”) that provides a more effective static abstraction of distinct dynamic executions; a path-sensitive (yet scalable, through path merging) algorithm for inference of function arguments and returns; and a fully context sensitive private function reconstruction process. As a result, smart contract security analyses and reverse-engineering tools built on top of Elipmoc achieve high scalability, precision and completeness. Elipmoc improves over all notable past decompilers, including its predecessor, Gigahorse, and the state-of-the-art industrial tool, Panoramix, integrated into the primary Ethereum blockchain explorer, Etherscan. Elipmoc produces decompiled contracts with fully resolved operands at a rate of 99.5% (compared to 62.8% for Gigahorse), and achieves much higher completeness in code decompilation than Panoramix—e.g., up to 67% more coverage of external call statements—while being over 5x faster. Elipmoc has been the enabler for recent (independent) discoveries of several exploitable vulnerabilities on popular protocols, over funds in the many millions of dollars.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527321", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "University of Malta" + }, + { + "first_name": "Sifis", + "last_name": "Lagouvardos", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Ilias", + "last_name": "Tsatiris", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/GrechLTS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527333", + "title": "Functional collection programming with semi-ring dictionaries", + "abstract": "This paper introduces semi-ring dictionaries, a powerful class of compositional and purely functional collections that subsume other collection types such as sets, multisets, arrays, vectors, and matrices. We developed SDQL, a statically typed language that can express relational algebra with aggregations, linear algebra, and functional collections over data such as relations and matrices using semi-ring dictionaries. Furthermore, thanks to the algebraic structure behind these dictionaries, SDQL unifies a wide range of optimizations commonly used in databases (DB) and linear algebra (LA). As a result, SDQL enables efficient processing of hybrid DB and LA workloads, by putting together optimizations that are otherwise confined to either DB systems or LA frameworks. We show experimentally that a handful of DB and LA workloads can take advantage of the SDQL language and optimizations. SDQL can be competitive with or outperforms a host of systems that are state of the art in their own domain: in-memory DB systems Typer and Tectorwise for (flat, not nested) relational data; SciPy for LA workloads; sparse tensor compiler taco; the Trance nested relational engine; and the in-database machine learning engines LMFAO and Morpheus for hybrid DB/LA workloads over relational data.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527333", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Edinburgh" + }, + { + "first_name": "Mathieu", + "last_name": "Huot", + "institution": "University of Oxford" + }, + { + "first_name": "Jaclyn", + "last_name": "Smith", + "institution": "University of Oxford" + }, + { + "first_name": "Dan", + "last_name": "Olteanu", + "institution": "University of Zurich" + } + ], + "dblp_key": "journals/pacmpl/ShaikhhaHSO22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563288", + "title": "AnICA: analyzing inconsistencies in microarchitectural code analyzers", + "abstract": "Microarchitectural code analyzers, i.e., tools that estimate the throughput of machine code basic blocks, are important utensils in the tool belt of performance engineers. Recent tools like llvm-mca, uiCA, and Ithemal use a variety of techniques and different models for their throughput predictions. When put to the test, it is common to see these state-of-the-art tools give very different results. These inconsistencies are either errors, or they point to different and rarely documented assumptions made by the tool designers. In this paper, we present AnICA, a tool taking inspiration from differential testing and abstract interpretation to systematically analyze inconsistencies among these code analyzers. Our evaluation shows that AnICA can summarize thousands of inconsistencies in a few dozen descriptions that directly lead to high-level insights into the different behavior of the tools. In several case studies, we further demonstrate how AnICA automatically finds and characterizes known and unknown bugs in llvm-mca, as well as a quirk in AMD's Zen microarchitectures.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563288", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Ritter", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "journals/pacmpl/RitterH22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527312", + "title": "Complexity-guided container replacement synthesis", + "abstract": "Containers, such as lists and maps, are fundamental data structures in modern programming languages. However, improper choice of container types may lead to significant performance issues. This paper presents Cres, an approach that automatically synthesizes container replacements to improve runtime performance. The synthesis algorithm works with static analysis techniques to identify how containers are utilized in the program, and attempts to select a method with lower time complexity for each container method call. Our approach can preserve program behavior and seize the opportunity of reducing execution time effectively for general inputs. We implement Cres and evaluate it on 12 real-world Java projects. It is shown that Cres synthesizes container replacements for the projects with 384.2 KLoC in 14 minutes and discovers six categories of container replacements, which can achieve an average performance improvement of 8.1%.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527312", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chengpeng", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Peisen", + "last_name": "Yao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Wensheng", + "last_name": "Tang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Qingkai", + "last_name": "Shi", + "institution": "" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/WangYTSZ22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563289", + "title": "First-class names for effect handlers", + "abstract": "Algebraic effects and handlers are a promising technique for incorporating composable computational effects into functional programming languages. Effect handlers enable concisely programming with different effects, but they do not offer a convenient way to program with different instances of the same effect. As a solution to this inconvenience, previous studies have introduced _named effect handlers_, which allow the programmer to distinguish among different effect instances. However, existing formalizations of named handlers are both involved and restrictive, as they employ non-standard mechanisms to prevent the escaping of handler names. In this paper, we propose a simple and flexible design of named handlers. Specifically, we treat handler names as first-class values, and prevent their escaping while staying within the ordinary λ-calculus. Such a design is enabled by combining named handlers with _scoped effects_, a novel variation of effects that maintain a scope via rank-2 polymorphism. We formalize two combinations of named handlers and scoped effects, and implement them in the Koka programming language. We also present practical applications of named handlers, including a neural network and a unification algorithm.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563289", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Cambridge" + }, + { + "first_name": "Youyou", + "last_name": "Cong", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Kazuki", + "last_name": "Ikemori", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/XieCIL22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527323", + "title": "Applying cognitive principles to model-finding output: the positive value of negative information", + "abstract": "Model-finders, such as SAT/SMT-solvers and Alloy, are used widely both directly and embedded in domain-specific tools. They support both conventional verification and, unlike other verification tools, property-free exploration. To do this effectively, they must produce output that helps users with these tasks. Unfortunately, the output of model-finders has seen relatively little rigorous human-factors study. Conventionally, these tools tend to show one satisfying instance at a time. Drawing inspiration from the cognitive science literature, we investigate two aspects of model-finder output: how many instances to show at once, and whether all instances must actually satisfy the input constraints. Using both controlled studies and open-ended talk-alouds, we show that there is benefit to showing negative instances in certain settings; the impact of multiple instances is less clear. Our work is a first step in a theoretically grounded approach to understanding how users engage cognitively with model-finder output, and how those tools might better support users in doing so.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527323", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tristan", + "last_name": "Dyer", + "institution": "John Brown University" + }, + { + "first_name": "Tim", + "last_name": "Nelson", + "institution": "John Brown University" + }, + { + "first_name": "Kathi", + "last_name": "Fisler", + "institution": "John Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "John Brown University" + } + ], + "dblp_key": "journals/pacmpl/DyerNFK22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563290", + "title": "Compositional virtual timelines: verifying dynamic-priority partitions with algorithmic temporal isolation", + "abstract": "Real-time systems power safety-critical applications that require strong isolation among each other. Such isolation needs to be enforced at two orthogonal levels. On the micro-architectural level, this mainly involves avoiding interference through micro-architectural states, such as cache lines. On the algorithmic level, this is usually achieved by adopting real-time partitions to reserve resources for each application. Implementations of such systems are often complex and require formal verification to guarantee proper isolation. In this paper, we focus on algorithmic isolation, which is mainly related to scheduling-induced interferences. We address earliest-deadline-first (EDF) partitions to achieve compositionality and utilization, while imposing constraints on tasks' periods and enforcing budgets on these periodic partitions to ensure isolation between each other. The formal verification of such a real-time OS kernel is challenging due to the inherent complexity of the dynamic priority assignment on the partition level. We tackle this problem by adopting a dynamically constructed abstraction to lift the reasoning of a concrete scheduler into an abstract domain. Using this framework, we verify a real-time operating system kernel with budget-enforcing EDF partitions and prove that it indeed ensures isolation between partitions. All the proofs are mechanized in Coq.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563290", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mengqi", + "last_name": "Liu", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + }, + { + "first_name": "Hao", + "last_name": "Chen", + "institution": "Yale University" + }, + { + "first_name": "Man-Ki", + "last_name": "Yoon", + "institution": "Yale University" + }, + { + "first_name": "Jung-Eun", + "last_name": "Kim", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/LiuSCYK22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563291", + "title": "Parsing randomness", + "abstract": "Random data generators can be thought of as parsers of streams of randomness. This perspective on generators for random data structures is established folklore in the programming languages community, but it has never been formalized, nor have its consequences been deeply explored. We build on the idea of freer monads to develop free generators, which unify parsing and generation using a common structure that makes the relationship between the two concepts precise. Free generators lead naturally to a proof that a monadic generator can be factored into a parser plus a distribution over choice sequences. Free generators also support a notion of derivative, analogous to the familiar Brzozowski derivatives of formal languages, allowing analysis tools to \"preview\" the effect of a particular generator choice. This gives rise to a novel algorithm for generating data structures satisfying user-specified preconditions.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563291", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Harrison", + "last_name": "Goldstein", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/GoldsteinP22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527325", + "title": "Finding real bugs in big programs with incorrectness logic", + "abstract": "Incorrectness Logic (IL) has recently been advanced as a logical theory for compositionally proving the presence of bugs—dual to Hoare Logic, which is used to compositionally prove their absence. Though IL was motivated in large part by the aim of providing a logical foundation for bug-catching program analyses, it has remained an open question: is IL useful only retrospectively (to explain existing analyses), or can it actually be useful in developing new analyses which can catch real bugs in big programs? In this work, we develop Pulse-X, a new, automatic program analysis for catching memory errors, based on ISL, a recent synthesis of IL and separation logic. Using Pulse-X, we have found 15 new real bugs in OpenSSL, which we have reported to OpenSSL maintainers and have since been fixed. In order not to be overwhelmed with potential but false error reports, we develop a compositional bug-reporting criterion based on a distinction between latent and manifest errors, which references the under-approximate ISL abstractions computed by Pulse-X, and we investigate the fix rate resulting from application of this criterion. Finally, to probe the potential practicality of our bug-finding method, we conduct a comparison to Infer, a widely used analyzer which has proven useful in industrial engineering practice.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527325", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Quang Loc", + "last_name": "Le", + "institution": "University College London" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Jules", + "last_name": "Villard", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Josh", + "last_name": "Berdine", + "institution": "Meta (United Kingdom)" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/LeRVBDO22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527327", + "title": "Translating canonical SQL to imperative code in Coq", + "abstract": "SQL is by far the most widely used and implemented query language. Yet, on some key features, such as correlated queries and NULL value semantics, many implementations diverge or contain bugs. We leverage recent advances in the formalization of SQL and query compilers to develop DBCert, the first mechanically verified compiler from SQL queries written in a canonical form to imperative code. Building DBCert required several new contributions which are described in this paper. First, we specify and mechanize a complete translation from SQL to the Nested Relational Algebra which can be used for query optimization. Second, we define Imp, a small imperative language sufficient to express SQL and which can target several execution languages including JavaScript. Finally, we develop a mechanized translation from the nested relational algebra to Imp, using the nested relational calculus as an intermediate step.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527327", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Véronique", + "last_name": "Benzaken", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Évelyne", + "last_name": "Contejean", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Mohammed Houssem Eddine", + "last_name": "Hachmaoui", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Chantal", + "last_name": "Keller", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Louis", + "last_name": "Mandel", + "institution": "IBM (United States)" + }, + { + "first_name": "Avraham", + "last_name": "Shinnar", + "institution": "IBM Research - Thomas J. Watson Research Center" + }, + { + "first_name": "Jérǒme", + "last_name": "Simèon", + "institution": "IBM Research - Thomas J. Watson Research Center" + } + ], + "dblp_key": "journals/pacmpl/BenzakenCHKMSS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527310", + "title": "Weighted programming: a programming paradigm for specifying mathematical models", + "abstract": "We study weighted programming, a programming paradigm for specifying mathematical models. More specifically, the weighted programs we investigate are like usual imperative programs with two additional features: (1) nondeterministic branching and (2) weighting execution traces. Weights can be numbers but also other objects like words from an alphabet, polynomials, formal power series, or cardinal numbers. We argue that weighted programming as a paradigm can be used to specify mathematical models beyond probability distributions (as is done in probabilistic programming). We develop weakest-precondition- and weakest-liberal-precondition-style calculi à la Dijkstra for reasoning about mathematical models specified by weighted programs. We present several case studies. For instance, we use weighted programming to model the ski rental problem — an optimization problem. We model not only the optimization problem itself, but also the best deterministic online algorithm for solving this problem as weighted programs. By means of weakest-precondition-style reasoning, we can determine the competitive ratio of the online algorithm on source code level.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527310", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Adrian", + "last_name": "Gallus", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Tobias", + "last_name": "Winkler", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/BatzGKKW22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3527319", + "title": "Proof transfer for fast certification of multiple approximate neural networks", + "abstract": "Developers of machine learning applications often apply post-training neural network optimizations, such as quantization and pruning, that approximate a neural network to speed up inference and reduce energy consumption, while maintaining high accuracy and robustness. Despite a recent surge in techniques for the robustness verification of neural networks, a major limitation of almost all state-of-the-art approaches is that the verification needs to be run from scratch every time the network is even slightly modified. Running precise end-to-end verification from scratch for every new network is expensive and impractical in many scenarios that use or compare multiple approximate network versions, and the robustness of all the networks needs to be verified efficiently. We present FANC, the first general technique for transferring proofs between a given network and its multiple approximate versions without compromising verifier precision. To reuse the proofs obtained when verifying the original network, FANC generates a set of templates – connected symbolic shapes at intermediate layers of the original network – that capture the proof of the property to be verified. We present novel algorithms for generating and transforming templates that generalize to a broad range of approximate networks and reduce the verification cost. We present a comprehensive evaluation demonstrating the effectiveness of our approach. We consider a diverse set of networks obtained by applying popular approximation techniques such as quantization and pruning on fully-connected and convolutional architectures and verify their robustness against different adversarial attacks such as adversarial patches, L 0 , rotation and brightening. Our results indicate that FANC can significantly speed up verification with state-of-the-art verifier, DeepZ by up to 4.1x.", + "date": "2022-04-29", + "link": "https://doi.org/10.1145/3527319", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shubham", + "last_name": "Ugare", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/UgareSM22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563293", + "title": "Reasoning about distributed reconfigurable systems", + "abstract": "This paper presents a Hoare-style calculus for formal reasoning about reconfiguration programs of distributed systems. Such programs create and delete components and/or interactions (connectors) while the system components change state according to their internal behaviour. Our proof calculus uses a resource logic, in the spirit of Separation Logic, to give local specifications of reconfiguration actions. Moreover, distributed systems with an unbounded number of components are described using inductively defined predicates. The correctness of reconfiguration programs relies on havoc invariants, that are assertions about the ongoing interactions in a part of the system that is not affected by the structural change caused by the reconfiguration. We present a proof system for such invariants in an assume/rely-guarantee style. We illustrate the feasibility of our approach by proving the correctness of real-life distributed systems with reconfigurable (self-adjustable) tree architectures.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563293", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emma", + "last_name": "Ahrens", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Marius", + "last_name": "Bozga", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Radu", + "last_name": "Iosif", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/AhrensBIK22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563294", + "title": "Compositional embeddings of domain-specific languages", + "abstract": "A common approach to defining domain-specific languages (DSLs) is via a direct embedding into a host language. There are several well-known techniques to do such embeddings, including shallow and deep embeddings. However, such embeddings come with various trade-offs in existing programming languages. Owing to such trade-offs, many embedded DSLs end up using a mix of approaches in practice, requiring a substantial amount of code, as well as some advanced coding techniques. In this paper, we show that the recently proposed Compositional Programming paradigm and the CP language provide improved support for embedded DSLs. In CP we obtain a new form of embedding, which we call a compositional embedding, that has most of the advantages of both shallow and deep embeddings. On the one hand, compositional embeddings enable various forms of linguistic reuse that are characteristic of shallow embeddings, including the ability to reuse host-language optimizations in the DSL and add new DSL constructs easily. On the other hand, similarly to deep embeddings, compositional embeddings support definitions by pattern matching or dynamic dispatching (including dependent interpretations, transformations, and optimizations) over the abstract syntax of the DSL and have the ability to add new interpretations. We illustrate an instance of compositional embeddings with a DSL for document authoring called ExT. The DSL is highly flexible and extensible, allowing users to create various non-trivial extensions easily. For instance, ExT supports various extensions that enable the production of wiki-like documents, LaTeX documents, vector graphics or charts. The viability of compositional embeddings for ExT is evaluated with three applications.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563294", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yaozhu", + "last_name": "Sun", + "institution": "University of Hong Kong" + }, + { + "first_name": "Utkarsh", + "last_name": "Dhandhania", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/SunDO22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563292", + "title": "CAAT: consistency as a theory", + "abstract": "We propose a family of logical theories for capturing an abstract notion of consistency and show how to build a generic and efficient theory solver that works for all members in the family. The theories can be used to model the influence of memory consistency models on the semantics of concurrent programs. They are general enough to precisely capture important examples like TSO, POWER, ARMv8, RISC-V, RC11, IMM, and the Linux kernel memory model. To evaluate the expressiveness of our theories and the performance of our solver, we integrate them into a lazy SMT scheme that we use as a backend for a bounded model checking tool. An evaluation against related verification tools shows, besides flexibility, promising performance on challenging programs under complex memory models.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563292", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Haas", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Hernán", + "last_name": "Ponce-de-León", + "institution": "Huawei German Research Center" + } + ], + "dblp_key": "journals/pacmpl/HaasML22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563295", + "title": "Scalable linear invariant generation with Farkas' lemma", + "abstract": "Invariant generation is a classical problem to automatically generate invariants to aid the formal analysis of programs. In this work, we consider the problem of generating tight linear-invariants over affine programs (i.e., programs with affine guards and updates) without a prescribed goal property. In the literature, the only known sound and complete characterization to solve this problem is via Farkas’ Lemma (FL), and has been implemented through either quantifier elimination or reasonable heuristics. Although FL-based approaches can generate highly accurate linear invariants from the completeness of FL, the main bottleneck to applying these approaches is the scalability issue caused by either non-linear constraints or combinatorial explosion. We base our approach on the only practical FL-based approach [Sankaranarayanan ‍ et al. , SAS 2004] that applies FL with reasonable heuristics, and develop two novel and independent improvements to leverage the scalability. The first improvement is the novel idea to generate invariants at one program location in a single invariant-generation process, so that the invariants for each location are generated separately rather than together in a single computation. This idea naturally leads to a parallel processing that divides the invariant-generation task for all program locations by assigning the locations separately to multiple processors. Moreover, the idea enables us to develop detailed technical improvements to further reduce the combinatorial explosion in the original work [Sankaranarayanan ‍ et al. , SAS 2004]. The second improvement is a segmented subsumption testing in the CNF-to-DNF expansion that allows discovering more local subsumptions in advance. We formally prove that our approach has the same accuracy as the original work and thus does not incur accuracy loss on the generated invariants. Moreover, experimental results on representative benchmarks involving non-trivial linear invariants demonstrate that our approach improves the runtime of the original work by several orders of magnitude, even in the non-parallel scenario that sums up the execution time for all program locations. Hence, our approach constitutes the first significant improvement in FL-based approaches for linear invariant generation after almost two decades.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563295", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hongming", + "last_name": "Liu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Zhiyong", + "last_name": "Yu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Jiaxin", + "last_name": "Song", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Guoqiang", + "last_name": "Li", + "institution": "Shanghai Jiao Tong University" + } + ], + "dblp_key": "journals/pacmpl/LiuFYSL22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563296", + "title": "Can guided decomposition help end-users write larger block-based programs? a mobile robot experiment", + "abstract": "Block-based programming environments, already popular in computer science education, have been successfully used to make programming accessible to end-users in domains like robotics, mobile apps, and even DevOps. Most studies of these applications have examined small programs that fit within a single screen, yet real-world programs often grow large, and editing these large block-based programs quickly becomes unwieldy. Traditional programming language features, like functions, allow programmers to decompose their programs. Unfortunately, both previous work, and our own findings, suggest that end-users rarely use these features, resulting in large monolithic code blocks that are hard to understand. In this work, we introduce a block-based system that provides users with a hierarchical, domain-specific program structure and requires them to decompose their programs accordingly. Through a user study with 92 users, we compared this approach, which we call guided program decomposition, to a traditional system that supports functions, but does not require decomposition. We found that while almost all users could successfully complete smaller tasks, those who decomposed their programs were significantly more successful as the tasks grew larger. As expected, most users without guided decomposition did not decompose their programs, resulting in poor performance on larger problems. In comparison, users of guided decomposition performed significantly better on the same tasks. Though this study investigated only a limited selection of tasks in one specific domain, it suggests that guided decomposition can benefit end-user programmers. While no single decomposition strategy fits all domains, we believe that similar domain-specific sub-hierarchies could be found for other application areas, increasing the scale of code end-users can create and understand.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563296", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nico", + "last_name": "Ritschel", + "institution": "University of British Columbia" + }, + { + "first_name": "Felipe", + "last_name": "Fronchetti", + "institution": "Virginia Commonwealth University" + }, + { + "first_name": "Reid", + "last_name": "Holmes", + "institution": "University of British Columbia" + }, + { + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" + }, + { + "first_name": "David", + "last_name": "Shepherd", + "institution": "Virginia Commonwealth University" + } + ], + "dblp_key": "journals/pacmpl/RitschelFHGS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563297", + "title": "Tower: data structures in Quantum superposition", + "abstract": "Emerging quantum algorithms for problems such as element distinctness, subset sum, and closest pair demonstrate computational advantages by relying on abstract data structures. Practically realizing such an algorithm as a program for a quantum computer requires an efficient implementation of the data structure whose operations correspond to unitary operators that manipulate quantum superpositions of data. To correctly operate in superposition, an implementation must satisfy three properties --- reversibility, history independence, and bounded-time execution. Standard implementations, such as the representation of an abstract set as a hash table, fail these properties, calling for tools to develop specialized implementations. In this work, we present Core Tower, the first language for quantum programming with random-access memory. Core Tower enables the developer to implement data structures as pointer-based, linked data. It features a reversible semantics enabling every valid program to be translated to a unitary quantum circuit. We present Boson, the first memory allocator that supports reversible, history-independent, and constant-time dynamic memory allocation in quantum superposition. We also present Tower, a language for quantum programming with recursively defined data structures. Tower features a type system that bounds all recursion using classical parameters as is necessary for a program to execute on a quantum computer. Using Tower, we implement Ground, the first quantum library of data structures, including lists, stacks, queues, strings, and sets. We provide the first executable implementation of sets that satisfies all three mandated properties of reversibility, history independence, and bounded-time execution.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563297", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Charles", + "last_name": "Yuan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/YuanC22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563300", + "title": "Concurrent size", + "abstract": "The size of a data structure (i.e., the number of elements in it) is a widely used property of a data set. However, for concurrent programs, obtaining a correct size efficiently is non-trivial. In fact, the literature does not offer a mechanism to obtain a correct (linearizable) size of a concurrent data set without resorting to inefficient solutions, such as taking a full snapshot of the data structure to count the elements, or acquiring one global lock in all update and size operations. This paper presents a methodology for adding a concurrent linearizable size operation to sets and dictionaries with a relatively low performance overhead. Theoretically, the proposed size operation is wait-free with asymptotic complexity linear in the number of threads (independently of data-structure size). Practically, we evaluated the performance overhead by adding size to various concurrent data structures in Java−a skip list, a hash table and a tree. The proposed linearizable size operation executes faster by orders of magnitude compared to the existing option of taking a snapshot, while incurring a throughput loss of 1%−20% on the original data structure’s operations.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563300", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gal", + "last_name": "Sela", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Erez", + "last_name": "Petrank", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/SelaP22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563299", + "title": "Bridging the semantic gap between qualitative and quantitative models of distributed systems", + "abstract": "Today’s distributed systems must satisfy both qualitative and quantitative properties. These properties are analyzed using very different formal frameworks: expressive untimed and non-probabilistic frameworks, such as TLA+ and Hoare/separation logics, for qualitative properties; and timed/probabilistic-automaton-based ones, such as Uppaal and Prism, for quantitative ones. This requires developing two quite different models of the same system, without guarantees of semantic consistency between them. Furthermore, it is very hard or impossible to represent intrinsic features of distributed object systems—such as unbounded data structures, dynamic object creation, and an unbounded number of messages—using finite automata. In this paper we bridge this semantic gap, overcome the problem of manually having to develop two different models of a system, and solve the representation problem by: (i) defining a transformation from a very general class of distributed systems (a generalization of Agha’s actor model) that maps an untimed non-probabilistic distributed system model suitable for qualitative analysis to a probabilistic timed model suitable for quantitative analysis; and (ii) proving the two models semantically consistent. We formalize our models in rewriting logic, and can therefore use the Maude tool to analyze qualitative properties, and statistical model checking with PVeStA to analyze quantitative properties. We have automated this transformation and integrated it, together with the PVeStA statistical model checker, into the Actors2PMaude tool. We illustrate the expressiveness of our framework and our tool’s ease of use by automatically transforming untimed, qualitative models of numerous distributed system designs—including an industrial data store and a state-of-the-art transaction system—into quantitative models to analyze and compare the performance of different designs.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563299", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Si", + "last_name": "Liu", + "institution": "ETH Zurich" + }, + { + "first_name": "José", + "last_name": "Meseguer", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Peter Csaba", + "last_name": "Ölveczky", + "institution": "University of Oslo" + }, + { + "first_name": "Min", + "last_name": "Zhang", + "institution": "East China Normal University" + }, + { + "first_name": "David", + "last_name": "Basin", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/LiuMOZB22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563298", + "title": "Proving hypersafety compositionally", + "abstract": "Hypersafety properties of arity n are program properties that relate n traces of a program (or, more generally, traces of n programs). Classic examples include determinism, idempotence, and associativity. A number of relational program logics have been introduced to target this class of properties. Their aim is to construct simpler proofs by capitalizing on structural similarities between the n related programs. We propose an unexplored, complementary proof principle that establishes hyper-triples (i.e. hypersafety judgments) as a unifying compositional building block for proofs, and we use it to develop a Logic for Hyper-triple Composition (LHC), which supports forms of proof compositionality that were not achievable in previous logics. We prove LHC sound and apply it to a number of challenging examples.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563298", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Emanuele", + "last_name": "D’Osualdo", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/DOsualdoFD22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563304", + "title": "MLstruct: principal type inference in a Boolean algebra of structural types", + "abstract": "Intersection and union types are becoming more popular by the day, entering the mainstream in programming languages like TypeScript and Scala 3. Yet, no language so far has managed to combine these powerful types with principal polymorphic type inference. We present a solution to this problem in MLstruct, a language with subtyped records, equirecursive types, first-class unions and intersections, class-based instance matching, and ML-style principal type inference. While MLstruct is mostly structurally typed, it contains a healthy sprinkle of nominality for classes, which gives it desirable semantics, enabling the expression of a powerful form of extensible variants that does not need row variables. Technically, we define the constructs of our language using conjunction, disjunction, and negation connectives, making sure they form a Boolean algebra, and we show that the addition of a few nonstandard but sound subtyping rules gives us enough structure to derive a sound and complete type inference algorithm. With this work, we hope to foster the development of better type inference for present and future programming languages with expressive subtyping systems.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563304", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Chun Yin", + "last_name": "Chau", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ParreauxC22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563305", + "title": "Highly illogical, Kirk: spotting type mismatches in the large despite broken contracts, unsound types, and too many linters", + "abstract": "The DefinitelyTyped repository hosts type declarations for thousands of JavaScript libraries. Given the lack of formal connection between the types and the corresponding code, a natural question is are the types right? An equally important question, as DefinitelyTyped and the libraries it supports change over time, is how can we keep the types from becoming wrong? In this paper we offer Scotty, a tool that detects mismatches between the types and code in the Definitely-Typed repository. More specifically, Scotty checks each package by converting its types into contracts and installing the contracts on the boundary between the library and its test suite. Running the test suite in this environment can reveal mismatches between the types and the JavaScript code. As automation and generality are both essential if such a tool is going to remain useful in the long term, we focus on techniques that sacrifice completeness, instead preferring to avoid false positives. Scotty currently handles about 26% of the 8006 packages on DefinitelyTyped (61% of the packages whose code is available and whose test suite passes). Perhaps unsurprisingly, running the tests with these contracts in place revealed many errors in Definitely-Typed. More surprisingly, despite the inherent limitations of the techniques we use, this exercise led to one hundred accepted pull requests that fix errors in DefinitelyTyped, demonstrating the value of this approach for the long-term maintenance of DefinitelyTyped. It also revealed a number of lessons about working in the JavaScript ecosystem and how details beyond the semantics of the language can be surprisingly important. Best of all, it also revealed a few places where programmers preferred incorrect types, suggesting some avenues of research to improve TypeScript.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563305", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joshua", + "last_name": "Hoeflich", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/HoeflichFS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563303", + "title": "Incremental type-checking for free: using scope graphs to derive incremental type-checkers", + "abstract": "Fast analysis response times in IDEs are essential for a good editor experience. Incremental type-checking can provide that in a scalable fashion. However, existing techniques are not reusable between languages. Moreover, mutual and dynamic dependencies preclude traditional approaches to incrementality. This makes finding automatic approaches to incremental type-checking a challenging but important open question. In this paper, we present a technique that automatically derives incremental type-checkers from type system specifications written in the Statix meta-DSL. We use name resolution queries in scope graphs (a generic model of name binding embedded in Statix) to derive dependencies between compilation units. A novel query confirmation algorithm finds queries for which the answer changed due to an edit in the program. Only units with such queries require reanalysis. The effectiveness of this algorithm is improved by (1) splitting the type-checking task into a context-free and a context-sensitive part, and (2) reusing a generic mechanism to resolve mutual dependencies. This automatically yields incremental type-checkers for any Statix specification. Compared to non-incremental parallel execution, we achieve speedups up to 147x on synthetic benchmarks, and up to 21x on real-world projects, with initial overheads below 10%. This suggests that our framework can provide efficient incremental type-checking to the wide range of languages supported by Statix.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563303", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aron", + "last_name": "Zwaan", + "institution": "Delft University of Technology" + }, + { + "first_name": "Hendrik van", + "last_name": "Antwerpen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/ZwaanAV22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563301", + "title": "Wildcards need witness protection", + "abstract": "In this paper, we show that the unsoundness discovered by Amin and Tate (2016) in Java’s wildcards is avoidable, even in the absence of a nullness-aware type system. The key insight of this paper is that soundness in type systems that implicitly introduce existential types through subtyping hinges on still making sure there are suitable witness types when introducing existentially quantified type variables. To show that this approach is viable, this paper formalizes a core calculus and proves it sound. We used a static analysis based on our approach to look for potential issues in a vast corpus of Java code and found none (with 1 false positive). This confirms both that Java's unsoundness has minimal practical consequence, and that our approach can avoid it entirely with minimal false positives.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563301", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Bierhoff", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/Bierhoff22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563306", + "title": "Data-driven lemma synthesis for interactive proofs", + "abstract": "Interactive proofs of theorems often require auxiliary helper lemmas to prove the desired theorem. Existing approaches for automatically synthesizing helper lemmas fall into two broad categories. Some approaches are goal-directed, producing lemmas specifically to help a user make progress from a given proof state, but they have limited expressiveness in terms of the lemmas that can be produced. Other approaches are highly expressive, able to generate arbitrary lemmas from a given grammar, but they are completely undirected and hence not amenable to interactive usage. In this paper, we develop an approach to lemma synthesis that is both goal-directed and expressive. The key novelty is a technique for reducing lemma synthesis to a data-driven program synthesis problem, whereby examples for synthesis are generated from the current proof state. We also describe a technique to systematically introduce new variables for lemma synthesis, as well as techniques for filtering and ranking candidate lemmas for presentation to the user. We implement these ideas in a tool called lfind, which can be run as a Coq tactic. In an evaluation on four benchmark suites, lfind produces useful lemmas in 68% of the cases where a human prover used a lemma to make progress. In these cases lfind synthesizes a lemma that either enables a fully automated proof of the original goal or that matches the human-provided lemma.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563306", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aishwarya", + "last_name": "Sivaraman", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Alex", + "last_name": "Sanchez-Stern", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Bretton", + "last_name": "Chen", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Sorin", + "last_name": "Lerner", + "institution": "University of California San Diego" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/SivaramanSCLM22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563302", + "title": "Overwatch: learning patterns in code edit sequences", + "abstract": "Integrated Development Environments (IDEs) provide tool support to automate many source code editing tasks. Traditionally, IDEs use only the spatial context, i.e., the location where the developer is editing, to generate candidate edit recommendations. However, spatial context alone is often not sufficient to confidently predict the developer’s next edit, and thus IDEs generate many suggestions at a location. Therefore, IDEs generally do not actively offer suggestions and instead, the developer is usually required to click on a specific icon or menu and then select from a large list of potential suggestions. As a consequence, developers often miss the opportunity to use the tool support because they are not aware it exists or forget to use it. To better understand common patterns in developer behavior and produce better edit recommendations, we can additionally use the temporal context, i.e., the edits that a developer was recently performing. To enable edit recommendations based on temporal context, we present Overwatch, a novel technique for learning edit sequence patterns from traces of developers’ edits performed in an IDE. Our experiments show that Overwatch has 78% precision and that Overwatch not only completed edits when developers missed the opportunity to use the IDE tool support but also predicted new edits that have no tool support in the IDE.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563302", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuhao", + "last_name": "Zhang", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Yasharth", + "last_name": "Bajpai", + "institution": "Microsoft (India)" + }, + { + "first_name": "Priyanshu", + "last_name": "Gupta", + "institution": "Microsoft (India)" + }, + { + "first_name": "Ameya", + "last_name": "Ketkar", + "institution": "Uber AI (United States)" + }, + { + "first_name": "Miltiadis", + "last_name": "Allamanis", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Titus", + "last_name": "Barik", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Mohammad", + "last_name": "Raza", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gustavo", + "last_name": "Soares", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/ZhangBGKABGRRST22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563307", + "title": "Type-directed synthesis of visualizations from natural language queries", + "abstract": "We propose a new technique based on program synthesis for automatically generating visualizations from natural language queries. Our method parses the natural language query into a refinement type specification using the intents-and-slots paradigm and leverages type-directed synthesis to generate a set of visualization programs that are most likely to meet the user's intent. Our refinement type system captures useful hints present in the natural language query and allows the synthesis algorithm to reject visualizations that violate well-established design guidelines for the input data set. We have implemented our ideas in a tool called Graphy and evaluated it on NLVCorpus, which consists of 3 popular datasets and over 700 real-world natural language queries. Our experiments show that Graphy significantly outperforms state-of-the-art natural language based visualization tools, including transformer and rule-based ones.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563307", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qiaochu", + "last_name": "Chen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Celeste", + "last_name": "Barnaby", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Abby", + "last_name": "Criswell", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Chenglong", + "last_name": "Wang", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Greg", + "last_name": "Durrett", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/ChenPBCWDD22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563308", + "title": "Synthesis-powered optimization of smart contracts via data type refactoring", + "abstract": "Since executing a smart contract on the Ethereum blockchain costs money (measured in gas ), smart contract developers spend significant effort in reducing gas usage. In this paper, we propose a new technique for reducing the gas usage of smart contracts by changing the underlying data layout. Given a smart contract P and a type-level transformation, our method automatically synthesizes a new contract P ′ that is functionally equivalent to P . Our approach provides a convenient DSL for expressing data type refactorings and employs program synthesis to generate the new version of the contract. We have implemented our approach in a tool called Solidare and demonstrate its capabilities on real-world smart contracts from Etherscan and GasStation. In particular, we show that our approach is effective at automating the desired data layout transformation and that it is useful for reducing gas usage of smart contracts that use rich data structures.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563308", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yanju", + "last_name": "Chen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "Simon Fraser University" + }, + { + "first_name": "Maruth", + "last_name": "Goyal", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "James", + "last_name": "Dong", + "institution": "Stanford University" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/ChenWGDFD22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563309", + "title": "Verified compilation of Quantum oracles", + "abstract": "Quantum algorithms often apply classical operations, such as arithmetic or predicate checks, over a quantum superposition of classical data; these so-called oracles are often the largest components of a quantum program. To ease the construction of efficient, correct oracle functions, this paper presents VQO, a high-assurance framework implemented with the Coq proof assistant. The core of VQO is OQASM, the oracle quantum assembly language. OQASM operations move qubits between two different bases via the quantum Fourier transform, thus admitting important optimizations, but without inducing entanglement and the exponential blowup that comes with it. OQASM’s design enabled us to prove correct VQO’s compilers—from a simple imperative language called OQIMP to OQASM, and from OQASM to SQIR, a general-purpose quantum assembly language—and allowed us to efficiently test properties of OQASM programs using the QuickChick property-based testing framework. We have used VQO to implement a variety of arithmetic and geometric operators that are building blocks for important oracles, including those used in Shor’s and Grover’s algorithms. We found that VQO’s QFT-based arithmetic oracles require fewer qubits, sometimes substantially fewer, than those constructed using “classical” gates; VQO’s versions of the latter were nevertheless on par with or better than (in terms of both qubit and gate counts) oracles produced by Quipper, a state-of-the-art but unverified quantum programming platform.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563309", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Liyi", + "last_name": "Li", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Finn", + "last_name": "Voichick", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Kesha", + "last_name": "Hietala", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Yuxiang", + "last_name": "Peng", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/LiVHPWH22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563310", + "title": "Specification-guided component-based synthesis from effectful libraries", + "abstract": "Component-based synthesis seeks to build programs using the APIs provided by a set of libraries. Oftentimes, these APIs have effects, which make it challenging to reason about the correctness of potential synthesis candidates. This is because changes to global state made by effectful library procedures affect how they may be composed together, yielding an intractably large search space that can confound typical enumerative synthesis techniques. If the nature of these effects are exposed as part of their specification, however, deductive synthesis approaches can be used to help guide the search for components. In this paper, we present a new specification-guided synthesis procedure that uses Hoare-style pre- and post-conditions to express fine-grained effects of potential library component candidates to drive a bi-directional synthesis search strategy. The procedure alternates between a forward search process that seeks to build larger terms given an existing context but which is otherwise unaware of the actual goal, alongside a backward search mechanism that seeks terms consistent with the desired goal but which is otherwise unaware of the context from which these terms must be synthesized. To further improve efficiency and scalability, we integrate a conflict-driven learning procedure into the synthesis algorithm that provides a semantic characterization of previously encountered unsuccessful search paths that is used to prune the space of possible candidates as synthesis proceeds. We have implemented our ideas in a tool called and demonstrate its effectiveness on a number of challenging synthesis problems defined over OCaml libraries equipped with effectful specifications.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563310", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ashish", + "last_name": "Mishra", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/MishraJ22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563311", + "title": "A fast in-place interpreter for WebAssembly", + "abstract": "WebAssembly (Wasm) is a compact, well-specified bytecode format that offers a portable compilation target with near-native execution speed. The bytecode format was specifically designed to be fast to parse, validate, and compile, positioning itself as a portable alternative to native code. It was pointedly not designed to be interpreted directly. Instead, design considerations at the time focused on competing with native code, utilizing optimizing compilers as the primary execution tier. Yet, in JIT scenarios, compilation time and memory consumption critically impact application startup, leading many Wasm engines to later deploy faster single-pass (baseline) compilers. Though faster, baseline compilers still take time and waste code space for infrequently executed code. A typical interpreter being infeasible, some engines resort to compiling Wasm not to machine code, but to a more compact, but easy to interpret format. This still takes time and wastes memory. Instead, we introduce in this article a fast in-place interpreter for WebAssembly, where no rewrite and no separate format is necessary. Our evaluation shows that in-place interpretation of Wasm code is space-efficient and fast, achieving performance on-par with interpreting a custom-designed internal format. This fills a hole in the execution tier space for Wasm, allowing for even faster startup and lower memory footprint than previous engine configurations.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563311", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben L.", + "last_name": "Titzer", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/Titzer22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563312", + "title": "SigVM: enabling event-driven execution for truly decentralized smart contracts", + "abstract": "This paper presents SigVM, the first blockchain virtual machine that extends EVM to support an event-driven execution model, enabling developers to build truly decentralized smart contracts. Contracts in SigVM can emit signal events, on which other contracts can listen. Once an event is triggered, corresponding handler functions are automatically executed as signal transactions. We build an end-to-end blockchain platform SigChain and a contract language compiler SigSolid to realize the potential of SigVM. Experimental results show that our benchmark applications can be reimplemented with SigVM in a truly decentralized way, eliminating the dependency on centralized and unreliable mechanisms like off-chain relay servers. The development effort of reimplementing these contracts with SigVM is small, i.e., we modified on average 3.17% of the contract code. The runtime and the gas overhead of SigVM on these contracts is negligible.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563312", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zihan", + "last_name": "Zhao", + "institution": "University of Toronto" + }, + { + "first_name": "Sidi Mohamed", + "last_name": "Beillahi", + "institution": "University of Toronto" + }, + { + "first_name": "Ryan", + "last_name": "Song", + "institution": "University of Toronto" + }, + { + "first_name": "Yuxi", + "last_name": "Cai", + "institution": "University of Toronto" + }, + { + "first_name": "Andreas", + "last_name": "Veneris", + "institution": "University of Toronto" + }, + { + "first_name": "Fan", + "last_name": "Long", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/ZhaoBSCVL22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563313", + "title": "Solo: a lightweight static analysis for differential privacy", + "abstract": "Existing approaches for statically enforcing differential privacy in higher order languages use either linear or relational refinement types. A barrier to adoption for these approaches is the lack of support for expressing these “fancy types” in mainstream programming languages. For example, no mainstream language supports relational refinement types, and although Rust and modern versions of Haskell both employ some linear typing techniques, they are inadequate for embedding enforcement of differential privacy, which requires “full” linear types. We propose a new type system that enforces differential privacy, avoids the use of linear and relational refinement types, and can be easily embedded in richly typed programming languages like Haskell. We demonstrate such an embedding in Haskell, demonstrate its expressiveness on case studies, and prove soundness of our type-based enforcement of differential privacy.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563313", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chiké", + "last_name": "Abuah", + "institution": "University of Vermont" + }, + { + "first_name": "David", + "last_name": "Darais", + "institution": "Galois (United States)" + }, + { + "first_name": "Joseph P.", + "last_name": "Near", + "institution": "University of Vermont" + } + ], + "dblp_key": "journals/pacmpl/AbuahDN22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563315", + "title": "Model checking for a multi-execution memory model", + "abstract": "Multi-execution memory models, such as Promising and Weakestmo, are an advanced class of weak memory consistency models that justify certain outcomes of a concurrent program by considering multiple candidate executions collectively. While this key characteristic allows them to support effective compilation to hardware models and a wide range of compiler optimizations, it makes reasoning about them substantially more difficult. In particular, we observe that Promising and Weakestmo inhibit effective model checking because they allow some suprisingly weak behaviors that cannot be generated by examining one execution at a time. We therefore introduce Weakestmo2, a strengthening of Weakestmo by constraining its multi-execution nature, while preserving the important properties of Weakestmo: DRF theorems, compilation to hardware models, and correctness of local program transformations. Our strengthening rules out a class of surprisingly weak program behaviors, which we attempt to characterize with the help of two novel properties: load buffering race freedom and certification locality. In addition, we develop WMC, a model checker for Weakestmo2 with performance close to that of the best tools for per-execution models.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563315", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Evgenii", + "last_name": "Moiseenko", + "institution": "" + }, + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/MoiseenkoKV22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563314", + "title": "A conceptual framework for safe object initialization: a principled and mechanized soundness proof of the Celsius model", + "abstract": "An object under initialization does not fulfill its class specification yet and can be unsafe to use as it may have uninitialized fields. It can sometimes be useful to call methods on such a partially initialized object in order to compute a complex initial value, or to let the object escape its constructor in order to create mutually recursive objects. However, inadvertent usage of uninitialized fields can lead to run-time crashes. Those subtle programming errors are not statically detected by most modern compilers. While many other features of object-oriented programming languages have been thoroughly studied over the years, object initialization lacks a simple, systematic, and principled treatment. Building on the insights of previous work, we identify a set of four core principles for safe initialization: monotonicity, authority, stackability, and scopability. We capture the essence of the principles with a minimal calculus, Celsius, and show that the principles give rise to a practical initialization system that strikes a balance between expressiveness and simplicity. The meta-theory of the system is entirely mechanized using the Coq proof assistant. We believe that our approach based on well-identified core principles sheds new light on the underlying mechanisms ensuring safety and could serve as a basis for language design when faced with similar challenges.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563314", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Clément", + "last_name": "Blaudeau", + "institution": "Université Paris Cité" + }, + { + "first_name": "Fengyun", + "last_name": "Liu", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/BlaudeauL22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563316", + "title": "The road not taken: exploring alias analysis based optimizations missed by the compiler", + "abstract": "Context-sensitive inter-procedural alias analyses are more precise than intra-procedural alias analyses. However, context-sensitive inter-procedural alias analyses are not scalable. As a consequence, most of the production compilers sacrifice precision for scalability and implement intra-procedural alias analysis. The alias analysis is used by many compiler optimizations, including loop transformations. Due to the imprecision of alias analysis, the program’s performance may suffer, especially in the presence of loops. Previous work proposed a general approach based on code-versioning with dynamic checks to disambiguate pointers at runtime. However, the overhead of dynamic checks in this approach is O(log n), which is substantially high to enable interesting optimizations. Other suggested approaches, e.g., polyhedral and symbolic range analysis, have O(1) overheads, but they only work for loops with certain constraints. The production compilers, such as LLVM and GCC, use scalar evolution analysis to compute an O(1) range check for loops to resolve memory dependencies at runtime. However, this approach also can only be applied to loops with certain constraints. In this work, we present our tool, Scout, that can disambiguate two pointers at runtime using single memory access. Scout is based on the key idea to constrain the allocation size and alignment during memory allocations. Scout can also disambiguate array accesses within a loop for which the existing O(1) range checks technique cannot be applied. In addition, Scout uses feedback from static optimizations to reduce the number of dynamic checks needed for optimizations. Our technique enabled new opportunities for loop-invariant code motion, dead store elimination, loop vectorization, and load elimination in an already optimized code. Our performance improvements are up to 51.11% for Polybench and up to 0.89% for CPU SPEC 2017 suites. The geometric means for our allocator’s CPU and memory overheads for CPU SPEC 2017 benchmarks are 1.05%, and 7.47%, respectively. For Polybench benchmarks, the geometric mean of CPU and memory overheads are 0.21% and 0.13%, respectively.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563316", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Khushboo", + "last_name": "Chitre", + "institution": "Indraprastha Institute of Information Technology Delhi" + }, + { + "first_name": "Piyus", + "last_name": "Kedia", + "institution": "Indraprastha Institute of Information Technology Delhi" + }, + { + "first_name": "Rahul", + "last_name": "Purandare", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "journals/pacmpl/ChitreKP22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563321", + "title": "Consistency-preserving propagation for SMT solving of concurrent program verification", + "abstract": "The happens-before orders have been widely adopted to model thread interleaving behaviors of concurrent programs. A dedicated ordering theory solver, usually composed of theory propagation, consistency checking, and conflict clause generation, plays a central role in concurrent program verification. We propose a novel preventive reasoning approach that automatically preserves the ordering consistency and makes consistency checking and conflict clause generation omissible. We implement our approach in a prototype tool and conduct experiments on credible benchmarks; results reveal a significant improvement over existing state-of-the-art concurrent program verifiers.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563321", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhihang", + "last_name": "Sun", + "institution": "Tsinghua University" + }, + { + "first_name": "Hongyu", + "last_name": "Fan", + "institution": "Tsinghua University" + }, + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + } + ], + "dblp_key": "journals/pacmpl/SunFH22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563320", + "title": "The essence of online data processing", + "abstract": "Data processing systems are a fundamental component of the modern computing stack. These systems are routinely deployed online: they continuously receive the requests of data processing operations, and continuously return the results to end users or client applications. Online data processing systems have unique features beyond conventional data processing, and the optimizations designed for them are complex, especially when data themselves are structured and dynamic. This paper describes DON Calculus, the first rigorous foundation for online data processing. It captures the essential behavior of both the backend data processing engine and the frontend application, with the focus on two design dimensions essential yet unique to online data processing systems: incremental operation processing (IOP) and temporal locality optimization (TLO). A novel design insight is that the operations continuously applied to the data can be defined as an operation stream flowing through the data structure, and this abstraction unifies diverse designs of IOP and TLO in one calculus. DON Calculus is endowed with a mechanized metatheory centering around a key observable equivalence property: despite the significant non-deterministic executions introduced by IOP and TLO, the observable result of DON Calculus data processing is identical to that of conventional data processing without IOP and TLO. Broadly, DON Calculus is a novel instance in the active pursuit of providing rigorous guarantees to the software system stack. The specification and mechanization of DON Calculus provide a sound base for the designers of future data processing systems to build upon, helping them embrace rigorous semantic engineering without the need of developing from scratch.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563320", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philip", + "last_name": "Dexter", + "institution": "Binghamton University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + }, + { + "first_name": "Kenneth", + "last_name": "Chiu", + "institution": "Binghamton University" + } + ], + "dblp_key": "journals/pacmpl/DexterLC22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563318", + "title": "A bunch of sessions: a propositions-as-sessions interpretation of bunched implications in channel-based concurrency", + "abstract": "The emergence of propositions-as-sessions, a Curry-Howard correspondence between propositions of Linear Logic and session types for concurrent processes, has settled the logical foundations of message-passing concurrency. Central to this approach is the resource consumption paradigm heralded by Linear Logic. In this paper, we investigate a new point in the design space of session type systems for message-passing concurrent programs. We identify O’Hearn and Pym’s Logic of Bunched Implications (BI) as a fruitful basis for an interpretation of the logic as a concurrent programming language. This leads to a treatment of non-linear resources that is radically different from existing approaches based on Linear Logic. We introduce a new π-calculus with sessions, called πBI; its most salient feature is a construct called spawn, which expresses new forms of sharing that are induced by structural principles in BI. We illustrate the expressiveness of πBI and lay out its fundamental theory: type preservation, deadlock-freedom, and weak normalization results for well-typed processes; an operationally sound and complete typed encoding of an affine λ-calculus; and a non-interference result for access of resources.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563318", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dan", + "last_name": "Frumin", + "institution": "University of Groningen" + }, + { + "first_name": "Emanuele", + "last_name": "D’Osualdo", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Bas van den", + "last_name": "Heuvel", + "institution": "University of Groningen" + }, + { + "first_name": "Jorge A.", + "last_name": "Pérez", + "institution": "University of Groningen" + } + ], + "dblp_key": "journals/pacmpl/FruminDHP22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563317", + "title": "Necessity specifications for robustness", + "abstract": "Robust modules guarantee to do only what they are supposed to do – even in the presence of untrusted malicious clients, and considering not just the direct behaviour of individual methods, but also the emergent behaviour from calls to more than one method. Necessity is a language for specifying robustness, based on novel necessity operators capturing temporal implication, and a proof logic that derives explicit robustness specifications from functional specifications. Soundness and an exemplar proof are mechanised in Coq.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563317", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Julian", + "last_name": "Mackay", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Susan", + "last_name": "Eisenbach", + "institution": "Imperial College London" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/MackayEND22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563322", + "title": "Oracle-free repair synthesis for floating-point programs", + "abstract": "The floating-point representation provides widely-used data types (such as “float” and “double”) for modern numerical software. Numerical errors are inherent due to floating-point’s approximate nature, and pose an important, well-known challenge. It is nontrivial to fix/repair numerical code to reduce numerical errors — it requires either numerical expertise (for manual fixing) or high-precision oracles (for automatic repair); both are difficult requirements. To tackle this challenge, this paper introduces a principled dynamic approach that is fully automated and oracle-free for effectively repairing floating-point errors. The key of our approach is the novel notion of micro-structure that characterizes structural patterns of floating-point errors. We leverage micro-structures’ statistical information on floating-point errors to effectively guide repair synthesis and validation. Compared with existing state-of-the-art repair approaches, our work is fully automatic and has the distinctive benefit of not relying on the difficult to obtain high-precision oracles. Evaluation results on 36 commonly-used numerical programs show that our approach is highly efficient and effective: (1) it is able to synthesize repairs instantaneously, and (2) versus the original programs, the repaired programs have orders of magnitude smaller floating-point errors, while having faster runtime performance.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563322", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daming", + "last_name": "Zou", + "institution": "ETH Zurich" + }, + { + "first_name": "GU", + "last_name": "Yu-chen", + "institution": "Peking University" + }, + { + "first_name": "Yuanfeng", + "last_name": "Shi", + "institution": "Peking University" + }, + { + "first_name": "MingZhe", + "last_name": "Wang", + "institution": "Princeton University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/ZouGSWXS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563319", + "title": "Coeffects for sharing and mutation", + "abstract": "In type-and-coeffect systems , contexts are enriched by coeffects modeling how they are actually used, typically through annotations on single variables. Coeffects are computed bottom-up, combining, for each term, the coeffects of its subterms, through a fixed set of algebraic operators. We show that this principled approach can be adopted to track sharing in the imperative paradigm, that is, links among variables possibly introduced by the execution. This provides a significant example of non-structural coeffects, which cannot be computed by-variable, since the way a given variable is used can affect the coeffects of other variables. To illustrate the effectiveness of the approach, we enhance the type system tracking sharing to model a sophisticated set of features related to uniqueness and immutability. Thanks to the coeffect-based approach, we can express such features in a simple way and prove related properties with standard techniques.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563319", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Riccardo", + "last_name": "Bianchini", + "institution": "University of Genoa" + }, + { + "first_name": "Francesco", + "last_name": "Dagnino", + "institution": "University of Genoa" + }, + { + "first_name": "Paola", + "last_name": "Giannini", + "institution": "Università degli Studi del Piemonte Orientale “Amedeo Avogadro”" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + }, + { + "first_name": "Marco", + "last_name": "Servetto", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "journals/pacmpl/BianchiniDGZS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563323", + "title": "Optimal heap limits for reducing browser memory use", + "abstract": "Garbage-collected language runtimes carefully tune heap limits to reduce garbage collection time and memory usage. However, there's a trade-off: a lower heap limit reduces memory use but increases garbage collection time. Classic methods for setting heap limits include manually tuned heap limits and multiple-of-live-size rules of thumb, but it is not clear when one rule is better than another or how to compare them. We address this problem with a new framework where heap limits are set for multiple heaps at once. Our key insight is that every heap limit rule induces a particular allocation of memory across multiple processes, and this allocation can be sub-optimal. We use our framework to derive an optimal \"square-root\" heap limit rule, which minimizes total memory usage for any amount of total garbage collection time. Paradoxically, the square-root heap limit rule achieves this coordination without communication: it allocates memory optimally across multiple heaps without requiring any communication between those heaps. To demonstrate that this heap limit rule is effective, we prototype it for V8, the JavaScript runtime used in Google Chrome, Microsoft Edge, and other browsers, as well as in server-side frameworks like node.js and Deno. On real-world web pages, our prototype achieves reductions of approximately 16.0% of memory usage while keeping garbage collection time constant. On memory-intensive benchmarks, reductions of up to 30.0% of garbage collection time are possible with no change in total memory usage.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563323", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marisa", + "last_name": "Kirisame", + "institution": "University of Utah" + }, + { + "first_name": "Pranav", + "last_name": "Shenoy", + "institution": "University of Utah" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/KirisameSP22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563324", + "title": "A general construction for abstract interpretation of higher-order automatic differentiation", + "abstract": "We present a novel, general construction to abstractly interpret higher-order automatic differentiation (AD). Our construction allows one to instantiate an abstract interpreter for computing derivatives up to a chosen order. Furthermore, since our construction reduces the problem of abstractly reasoning about derivatives to abstractly reasoning about real-valued straight-line programs, it can be instantiated with almost any numerical abstract domain, both relational and non-relational. We formally establish the soundness of this construction. We implement our technique by instantiating our construction with both the non-relational interval domain and the relational zonotope domain to compute both first and higher-order derivatives. In the latter case, we are the first to apply a relational domain to automatic differentiation for abstracting higher-order derivatives, and hence we are also the first abstract interpretation work to track correlations across not only different variables, but different orders of derivatives. We evaluate these instantiations on multiple case studies, namely robustly explaining a neural network and more precisely computing a neural network’s Lipschitz constant. For robust interpretation, first and second derivatives computed via zonotope AD are up to 4.76× and 6.98× more precise, respectively, compared to interval AD. For Lipschitz certification, we obtain bounds that are up to 11,850× more precise with zonotopes, compared to the state-of-the-art interval-based tool.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563324", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Laurel", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Rem", + "last_name": "Yang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Shubham", + "last_name": "Ugare", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Robert", + "last_name": "Nagel", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/LaurelYUNSM22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563326", + "title": "Fractional resources in unbounded separation logic", + "abstract": "Many separation logics support fractional permissions to distinguish between read and write access to a heap location, for instance, to allow concurrent reads while enforcing exclusive writes. Fractional permissions extend to composite assertions such as (co)inductive predicates and magic wands by allowing those to be multiplied by a fraction. Typical separation logic proofs require that this multiplication has three key properties: it needs to distribute over assertions, it should permit fractions to be factored out from assertions, and two fractions of the same assertion should be combinable into one larger fraction. Existing formal semantics incorporating fractional assertions into a separation logic define multiplication semantically (via models), resulting in a semantics in which distributivity and combinability do not hold for key resource assertions such as magic wands, and fractions cannot be factored out from a separating conjunction. By contrast, existing automatic separation logic verifiers define multiplication syntactically, resulting in a different semantics for which it is unknown whether distributivity and combinability hold for all assertions. In this paper, we present a novel semantics for separation logic assertions that allows states to hold more than a full permission to a heap location during the evaluation of an assertion. By reimposing upper bounds on the permissions held per location at statement boundaries, we retain key properties of separation logic, in particular, the frame rule. Our assertion semantics unifies semantic and syntactic multiplication and thereby reconciles the discrepancy between separation logic theory and tools and enjoys distributivity, factorisability, and combinability. We have formalised our semantics and proved its properties in Isabelle/HOL.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563326", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thibault", + "last_name": "Dardinier", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/DardinierMS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563327", + "title": "Neurosymbolic repair for low-code formula languages", + "abstract": "Most users of low-code platforms, such as Excel and PowerApps, write programs in domain-specific formula languages to carry out nontrivial tasks. Often users can write most of the program they want, but introduce small mistakes that yield broken formulas. These mistakes, which can be both syntactic and semantic, are hard for low-code users to identify and fix, even though they can be resolved with just a few edits. We formalize the problem of producing such edits as the last-mile repair problem. To address this problem, we developed LaMirage, a LAst-MIle RepAir-engine GEnerator that combines symbolic and neural techniques to perform last-mile repair in low-code formula languages. LaMirage takes a grammar and a set of domain-specific constraints/rules, which jointly approximate the target language, and uses these to generate a repair engine that can fix formulas in that language. To tackle the challenges of localizing errors and ranking candidate repairs, LaMirage leverages neural techniques, whereas it relies on symbolic methods to generate candidate edits. This combination allows LaMirage to find repairs that satisfy the provided grammar and constraints, and then pick the most natural repair. We compare LaMirage to state-of-the-art neural and symbolic approaches on 400 real Excel and Power Fx formulas, where LaMirage outperforms all baselines. We release these benchmarks to encourage subsequent work in low-code domains.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563327", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Rohan", + "last_name": "Bavishi", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Harshit", + "last_name": "Joshi", + "institution": "Microsoft (India)" + }, + { + "first_name": "José", + "last_name": "Cambronero", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Anna", + "last_name": "Fariha", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ivan", + "last_name": "Radiček", + "institution": "" + }, + { + "first_name": "Ashish", + "last_name": "Tiwari", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/BavishiJCFGLRT22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563325", + "title": "Scalable verification of GNN-based job schedulers", + "abstract": "Recently, Graph Neural Networks (GNNs) have been applied for scheduling jobs over clusters, achieving better performance than hand-crafted heuristics. Despite their impressive performance, concerns remain over whether these GNN-based job schedulers meet users’ expectations about other important properties, such as strategy-proofness, sharing incentive, and stability. In this work, we consider formal verification of GNN-based job schedulers. We address several domain-specific challenges such as networks that are deeper and specifications that are richer than those encountered when verifying image and NLP classifiers. We develop vegas, the first general framework for verifying both single-step and multi-step properties of these schedulers based on carefully designed algorithms that combine abstractions, refinements, solvers, and proof transfer. Our experimental results show that vegas achieves significant speed-up when verifying important properties of a state-of-the-art GNN-based scheduler compared to previous methods.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563325", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haoze", + "last_name": "Wu", + "institution": "Stanford University" + }, + { + "first_name": "Clark", + "last_name": "Barrett", + "institution": "Stanford University" + }, + { + "first_name": "Mahmood", + "last_name": "Sharif", + "institution": "Tel Aviv University" + }, + { + "first_name": "Nina", + "last_name": "Narodytska", + "institution": "" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/WuBSNS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563328", + "title": "A study of inline assembly in solidity smart contracts", + "abstract": "The Solidity programming language is the most widely used language for smart contract development. Improving smart contracts’ correctness, security, and performance has been the driving force for research in vulnerability detection, program analysis, and compiler techniques for Solidity. Similar to system-level languages such as C, Solidity enables the embedding of low-level code in programs, in the form of inline assembly code. Developers use inline assembly for low-level optimizations, extending the Solidity language through libraries, and using blockchain-specific opcodes only available through inline assembly. Nevertheless, inline assembly fragments are not well understood by an average developer and can introduce security threats as well as affect the optimizations that can be applied to programs by the compiler; it also significantly limits the effectiveness of source code static analyzers that operate on the Solidity level. A better understanding of how inline assembly is used in practice could in turn increase the performance, security, and support for inline assembly in Solidity. This paper presents a large-scale quantitative study of the use of inline assembly in 6.8M smart contracts deployed on the Ethereum blockchain. We find that 23% of the analyzed smart contracts contain inline assembly code, and that the use of inline assembly has become more widespread over time. We further performed a manual qualitative analysis for identifying usage patterns of inline assembly in Solidity smart contracts. Our findings are intended to help practitioners understand when they should use inline assembly and guide developers of Solidity tools in prioritizing which parts of inline assembly to implement first. Finally, the insights of this study could be used to enhance the Solidity language, improve the Solidity compiler, and to open up new research directions by driving future researchers to build appropriate methods and techniques for replacing inline assembly in Solidity programs when there is no real necessity to use it.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563328", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stefanos", + "last_name": "Chaliasos", + "institution": "Imperial College London" + }, + { + "first_name": "Arthur", + "last_name": "Gervais", + "institution": "Imperial College London" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/ChaliasosGL22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563329", + "title": "Neural architecture search using property guided synthesis", + "abstract": "Neural architecture search (NAS) has become an increasingly important tool within the deep learning community in recent years, yielding many practical advancements in the design of deep neural network architectures. However, most existing approaches operate within highly structured design spaces, and hence (1) explore only a small fraction of the full search space of neural architectures while also (2) requiring significant manual effort from domain experts. In this work, we develop techniques that enable efficient NAS in a significantly larger design space. In particular, we propose to perform NAS in an abstract search space of program properties. Our key insights are as follows: (1) an abstract search space can be significantly smaller than the original search space, and (2) architectures with similar program properties should also have similar performance; thus, we can search more efficiently in the abstract search space. To enable this approach, we also introduce a novel efficient synthesis procedure, which performs the role of concretizing a set of promising program properties into a satisfying neural architecture. We implement our approach, αNAS, within an evolutionary framework, where the mutations are guided by the program properties. Starting with a ResNet-34 model, αNAS produces a model with slightly improved accuracy on CIFAR-10 but 96% fewer parameters. On ImageNet, αNAS is able to improve over Vision Transformer (30% fewer FLOPS and parameters), ResNet-50 (23% fewer FLOPS, 14% fewer parameters), and EfficientNet (7% fewer FLOPS and parameters) without any degradation in accuracy.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563329", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Charles", + "last_name": "Jin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Phitchaya Mangpo", + "last_name": "Phothilimthana", + "institution": "Google (United States)" + }, + { + "first_name": "Sudip", + "last_name": "Roy", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/JinPR22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563331", + "title": "Generic go to go: dictionary-passing, monomorphisation, and hybrid", + "abstract": "Go is a popular statically-typed industrial programming language. To aid the type safe reuse of code, the recent Go release (Go 1.18) published early 2022 includes bounded parametric polymorphism via generic types. Go 1.18 implements generic types using a combination of monomorphisation and call-graph based dictionary-passing called hybrid. This hybrid approach can be viewed as an optimised form of monomorphisation that statically generates specialised methods and types based on possible instantiations. A monolithic dictionary supplements information lost during monomorphisation, and is structured according to the program’s call graph. Unfortunately, the hybrid approach still suffers from code bloat, poor compilation speed, and limited code coverage. In this paper we propose and formalise a new non-specialising call-site based dictionary-passing translation. Our call-site based translation creates individual dictionaries for each type parameter, with dictionary construction occurring in place of instantiation, overcoming the limitations of hybrid. We prove it correct using a novel and general bisimulation up to technique. To better understand how different generics translation approaches work in practice, we benchmark five translators, Go 1.18, two existing monomorphisation translators, our dictionary-passing translator, and an erasure translator. Our findings reveal several suggestions for improvements for Go 1.18— specifically how to overcome the expressiveness limitations of generic Go and improve compile time and compiled code size performance of Go 1.18.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563331", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen R.", + "last_name": "Ellis", + "institution": "University of Oxford" + }, + { + "first_name": "Shuofei", + "last_name": "Zhu", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "University of Oxford" + }, + { + "first_name": "Linhai", + "last_name": "Song", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/EllisZYS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563330", + "title": "Seq2Parse: neurosymbolic parse error repair", + "abstract": "We present Seq2Parse, a language-agnostic neurosymbolic approach to automatically repairing parse errors. Seq2Parse is based on the insight that Symbolic Error Correcting (EC) Parsers can, in principle, synthesize repairs, but, in practice, are overwhelmed by the many error-correction rules that are not relevant to the particular program that requires repair. In contrast, Neural approaches are fooled by the large space of possible sequence level edits, but can precisely pinpoint the set of EC-rules that are relevant to a particular program. We show how to combine their complementary strengths by using neural methods to train a sequence classifier that predicts the small set of relevant EC-rules for an ill-parsed program, after which, the symbolic EC-parsing algorithm can make short work of generating useful repairs. We train and evaluate our method on a dataset of 1,100,000 Python programs, and show that Seq2Parse is accurate and efficient : it can parse 94% of our tests within 2.1 seconds, while generating the exact user fix in 1 out 3 of the cases; and useful : humans perceive both Seq2Parse-generated error locations and repairs to be almost as good as human-generated ones in a statistically-significant manner.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563330", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Georgios K.", + "last_name": "Sakkas", + "institution": "University of California San Diego" + }, + { + "first_name": "Madeline", + "last_name": "Endres", + "institution": "University of Michigan" + }, + { + "first_name": "Philip J.", + "last_name": "Guo", + "institution": "University of California San Diego" + }, + { + "first_name": "Westley", + "last_name": "Weimer", + "institution": "University of Michigan" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/SakkasEGWJ22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563333", + "title": "UniRec: a unimodular-like framework for nested recursions and loops", + "abstract": "Scheduling transformations reorder operations in a program to improve locality and/or parallelism. There are mature loop transformation frameworks such as the polyhedral model for composing and applying instance-wise scheduling transformations for loop nests.In recent years, there have been efforts to build frameworks for composing and applying scheduling transformations for nested recursion and loops, but these frameworks cannot employ the full power of transformations for loop nests since they have overly-restrictive representations. This paper describes a new framework, UniRec, that not only generalizes prior frameworks for reasoning about transformations on recursion, but also generalizes the unimodular framework, and hence unifies reasoning about perfectly-nested loops and recursion.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563333", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kirshanthan", + "last_name": "Sundararajah", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Charitha", + "last_name": "Saumya", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/SundararajahSK22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563332", + "title": "Satisfiability modulo fuzzing: a synergistic combination of SMT solving and fuzzing", + "abstract": "Programming languages and software engineering tools routinely encounter components that are difficult to reason on via formal techniques or whose formal semantics are not even available—third-party libraries, inline assembly code, SIMD instructions, system calls, calls to machine learning models, etc. However, often access to these components is available as input-output oracles—interfaces are available to query these components on certain inputs to receive the respective outputs. We refer to such functions as closed-box functions . Regular SMT solvers are unable to handle such closed-box functions. We propose Sādhak, a solver for SMT theories modulo closed-box functions. Our core idea is to use a synergistic combination of a fuzzer to reason on closed-box functions and an SMT engine to solve the constraints pertaining to the SMT theories. The fuzz and the SMT engines attempt to converge to a model by exchanging a rich set of interface constraints that are relevant and interpretable by them. Our implementation, Sādhak, demonstrates a significant advantage over the only other solver that is capable of handling such closed-box constraints: Sādhak solves 36.45% more benchmarks than the best-performing mode of this state-of-the-art solver and has 5.72x better PAR-2 score; on the benchmarks that are solved by both tools, Sādhak is (on an average) 14.62x faster.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563332", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sujit Kumar", + "last_name": "Muduli", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Subhajit", + "last_name": "Roy", + "institution": "Indian Institute of Technology Kanpur" + } + ], + "dblp_key": "journals/pacmpl/MuduliR22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563340", + "title": "Checking equivalence in a non-strict language", + "abstract": "Program equivalence checking is the task of confirming that two programs have the same behavior on corresponding inputs. We develop a calculus based on symbolic execution and coinduction to check the equivalence of programs in a non-strict functional language. Additionally, we show that our calculus can be used to derive counterexamples for pairs of inequivalent programs, including counterexamples that arise from non-termination. We describe a fully automated approach for finding both equivalence proofs and counterexamples. Our implementation, Nebula, proves equivalences of programs written in Haskell. We demonstrate Nebula's practical effectiveness at both proving equivalence and producing counterexamples automatically by applying Nebula to existing benchmark properties.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563340", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John C.", + "last_name": "Kolesar", + "institution": "Yale University" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + }, + { + "first_name": "William T.", + "last_name": "Hallahan", + "institution": "Binghamton University" + } + ], + "dblp_key": "journals/pacmpl/KolesarPH22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563334", + "title": "Synthesizing abstract transformers", + "abstract": "This paper addresses the problem of creating abstract transformers automatically. The method we present automates the construction of static analyzers in a fashion similar to the way yacc automates the construction of parsers. Our method treats the problem as a program-synthesis problem. The user provides specifications of (i) the concrete semantics of a given operation op , (ii) the abstract domain A to be used by the analyzer, and (iii) the semantics of a domain-specific language L in which the abstract transformer is to be expressed. As output, our method creates an abstract transformer for op in abstract domain A , expressed in L (an “ L -transformer for op over A ”). Moreover, the abstract transformer obtained is a most-precise L -transformer for op over A ; that is, there is no other L -transformer for op over A that is strictly more precise. We implemented our method in a tool called AMURTH. We used AMURTH to create sets of replacement abstract transformers for those used in two existing analyzers, and obtained essentially identical performance. However, when we compared the existing transformers with the transformers obtained using AMURTH, we discovered that four of the existing transformers were unsound, which demonstrates the risk of using manually created transformers.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563334", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pankaj Kumar", + "last_name": "Kalita", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Sujit Kumar", + "last_name": "Muduli", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Subhajit", + "last_name": "Roy", + "institution": "Indian Institute of Technology Kanpur" + } + ], + "dblp_key": "journals/pacmpl/KalitaMDRR22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563335", + "title": "Monadic and comonadic aspects of dependency analysis", + "abstract": "Dependency analysis is vital to several applications in computer science. It lies at the essence of secure information flow analysis, binding-time analysis, etc. Various calculi have been proposed in the literature for analysing individual dependencies. Abadi et. al., by extending Moggi’s monadic metalanguage, unified several of these calculi into the Dependency Core Calculus (DCC). DCC has served as a foundational framework for dependency analysis for the last two decades. However, in spite of its success, DCC has its limitations. First, the monadic bind rule of the calculus is nonstandard and relies upon an auxiliary protection judgement. Second, being of a monadic nature, the calculus cannot capture dependency analyses that possess a comonadic nature, for example, the binding-time calculus, λ ∘ , of Davies. In this paper, we address these limitations by designing an alternative dependency calculus that is inspired by standard ideas from category theory. Our calculus is both monadic and comonadic in nature and subsumes both DCC and λ ∘ . Our construction explains the nonstandard bind rule and the protection judgement of DCC in terms of standard categorical concepts. It also leads to a novel technique for proving correctness of dependency analysis. We use this technique to present alternative proofs of correctness for DCC and λ ∘ .", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563335", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pritam", + "last_name": "Choudhury", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/Choudhury22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563338", + "title": "Compilation of dynamic sparse tensor algebra", + "abstract": "Many applications, from social network graph analytics to control flow analysis, compute on sparse data that evolves over the course of program execution. Such data can be represented as dynamic sparse tensors and efficiently stored in formats (data layouts) that utilize pointer-based data structures like block linked lists, binary search trees, B-trees, and C-trees among others. These specialized formats support fast in-place modification and are thus better suited than traditional, array-based data structures like CSR for storing dynamic sparse tensors. However, different dynamic sparse tensor formats have distinct benefits and drawbacks, and performing different computations on tensors that are stored in different formats can require vastly dissimilar code that are not straightforward to correctly implement and optimize. This paper shows how a compiler can generate efficient code to compute tensor algebra operations on dynamic sparse tensors that may be stored in a wide range of disparate formats. We propose a language for precisely specifying recursive, pointer-based data structures, and we show how this language can express many different dynamic data structures, including all the ones named above as well as many more. We then describe how, given high-level specifications of such dynamic data structures, a compiler can emit code to efficiently access and compute on dynamic sparse tensors that are stored in the aforementioned data structures. We evaluate our technique and find it generates efficient dynamic sparse tensor algebra kernels that have performance comparable to, if not better than, state-of-the-art libraries and frameworks such as PAM, Aspen, STINGER, and Terrace. At the same time, our technique supports a wider range of tensor algebra operations---such as those that simultaneously compute with static and dynamic sparse tensors---than Aspen, STINGER, and Terrace, while also achieving significantly better performance than PAM for those same operations.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563338", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen Y.", + "last_name": "Chou", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ChouA22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563336", + "title": "Katara: synthesizing CRDTs with verified lifting", + "abstract": "Conflict-free replicated data types (CRDTs) are a promising tool for designing scalable, coordination-free distributed systems. However, constructing correct CRDTs is difficult, posing a challenge for even seasoned developers. As a result, CRDT development is still largely the domain of academics, with new designs often awaiting peer review and a manual proof of correctness. In this paper, we present Katara, a program synthesis-based system that takes sequential data type implementations and automatically synthesizes verified CRDT designs from them. Key to this process is a new formal definition of CRDT correctness that combines a reference sequential type with a lightweight ordering constraint that resolves conflicts between non-commutative operations. Our process follows the tradition of work in verified lifting, including an encoding of correctness into SMT logic using synthesized inductive invariants and hand-crafted grammars for the CRDT state and runtime. Katara is able to automatically synthesize CRDTs for a wide variety of scenarios, from reproducing classic CRDTs to synthesizing novel designs based on specifications in existing literature. Crucially, our synthesized CRDTs are fully, automatically verified, eliminating entire classes of common errors and reducing the process of producing a new CRDT from a painstaking paper proof of correctness to a lightweight specification.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563336", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shadaj", + "last_name": "Laddad", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Conor", + "last_name": "Power", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Mae", + "last_name": "Milano", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Joseph M.", + "last_name": "Hellerstein", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/LaddadPMCH22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563337", + "title": "A concurrent program logic with a future and history", + "abstract": "Verifying fine-grained optimistic concurrent programs remains an open problem. Modern program logics provide abstraction mechanisms and compositional reasoning principles to deal with the inherent complexity. However, their use is mostly confined to pencil-and-paper or mechanized proofs. We devise a new separation logic geared towards the lacking automation. While local reasoning is known to be crucial for automation, we are the first to show how to retain this locality for (i) reasoning about inductive properties without the need for ghost code, and (ii) reasoning about computation histories in hindsight. We implemented our new logic in a tool and used it to automatically verify challenging concurrent search structures that require inductive properties and hindsight reasoning, such as the Harris set.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563337", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + }, + { + "first_name": "Sebastian", + "last_name": "Wolff", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/MeyerWW22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563339", + "title": "Indexing the extended Dyck-CFL reachability for context-sensitive program analysis", + "abstract": "Many context-sensitive dataflow analyses can be formulated as an extended Dyck-CFL reachability problem, where function calls and returns are modeled as partially matched parentheses. Unfortunately, despite many works on the standard Dyck-CFL reachability problem, solving the extended version is still of quadratic space complexity and nearly cubic time complexity, significantly limiting the scalability of program analyses. This paper, for the first time to the best of our knowledge, presents a cheap approach to transforming the extended Dyck-CFL reachability problem to conventional graph reachability, a much easier and well-studied problem. This transformation allows us to benefit from recent advances in reachability indexing schemes, making it possible to answer any reachability query in a context-sensitive dataflow analysis within almost constant time plus only a few extra spaces. We have implemented our approach in two common context-sensitive dataflow analyses, one determines pointer alias relations and the other tracks information flows. Experimental results demonstrate that, compared to their original analyses, we can achieve orders of magnitude (10 2 × to 10 5 ×) speedup at the cost of only a moderate space overhead. Our implementation is publicly available.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563339", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qingkai", + "last_name": "Shi", + "institution": "" + }, + { + "first_name": "Yongchao", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Peisen", + "last_name": "Yao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ShiWYZ22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563341", + "title": "This is the moment for probabilistic loops", + "abstract": "We present a novel static analysis technique to derive higher moments for program variables for a large class of probabilistic loops with potentially uncountable state spaces. Our approach is fully automatic, meaning it does not rely on externally provided invariants or templates. We employ algebraic techniques based on linear recurrences and introduce program transformations to simplify probabilistic programs while preserving their statistical properties. We develop power reduction techniques to further simplify the polynomial arithmetic of probabilistic programs and define the theory of moment-computable probabilistic loops for which higher moments can precisely be computed. Our work has applications towards recovering probability distributions of random variables and computing tail probabilities. The empirical evaluation of our results demonstrates the applicability of our work on many challenging examples.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563341", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marcel", + "last_name": "Moosbrugger", + "institution": "TU Wien" + }, + { + "first_name": "Miroslav", + "last_name": "Stankovič", + "institution": "TU Wien" + }, + { + "first_name": "Ezio", + "last_name": "Bartocci", + "institution": "TU Wien" + }, + { + "first_name": "Laura", + "last_name": "Kovács", + "institution": "TU Wien" + } + ], + "dblp_key": "journals/pacmpl/MoosbruggerSBK22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563342", + "title": "A case for DOT: theoretical foundations for objects with pattern matching and GADT-style reasoning", + "abstract": "Many programming languages in the OO tradition now support pattern matching in some form. Historical examples include Scala and Ceylon, with the more recent additions of Java, Kotlin, TypeScript, and Flow. But pattern matching on generic class hierarchies currently results in puzzling type errors in most of these languages. Yet this combination of features occurs naturally in many scenarios, such as when manipulating typed ASTs. To support it properly, compilers needs to implement a form of subtyping reconstruction: the ability to reconstruct subtyping information uncovered at runtime during pattern matching. We introduce cDOT, a new calculus in the family of Dependent Object Types (DOT) intended to serve as a formal foundation for subtyping reconstruction. Being descended from pDOT, itself a formal foundation for Scala, cDOT can be used to encode advanced object-oriented features such as generic inheritance, type constructor variance, F-bounded polymorphism, and first-class recursive modules. We demonstrate that subtyping reconstruction subsumes GADTs by encoding λ 2, G µ , a classical constraint-based GADT calculus, into cDOT.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563342", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aleksander", + "last_name": "Boruch-Gruszecki", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Radosław", + "last_name": "Waśko", + "institution": "University of Warsaw" + }, + { + "first_name": "Yichen", + "last_name": "Xu", + "institution": "Beijing University of Posts and Telecommunications" + }, + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/Boruch-Gruszecki22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563343", + "title": "Taming transitive redundancy for context-free language reachability", + "abstract": "Given an edge-labeled graph, context-free language reachability (CFL-reachability) computes reachable node pairs by deriving new edges and adding them to the graph. The redundancy that limits the scalability of CFL-reachability manifests as redundant derivations, i.e., identical edges can be derived multiple times due to the many paths between two reachable nodes. We observe that most redundancy arises from the derivations involving transitive relations of reachable node pairs. Unfortunately, existing techniques for reducing redundancy in transitive-closure-based problems are either ineffective or inapplicable to identifying and eliminating redundant derivations during on-the-fly CFL-reachability solving. This paper proposes a scalable yet precision-preserving approach to all-pairs CFL-reachability analysis by taming its transitive redundancy. Our key insight is that transitive relations are intrinsically ordered, and utilizing the order for edge derivation can avoid most redundancy. To address the challenges in determining the derivation order from the dynamically changed graph during CFL-reachability solving, we introduce a hybrid graph representation by combining spanning trees and adjacency lists, together with a dynamic construction algorithm. Based on this representation, we propose a fast and effective partially ordered algorithm POCR to boost the performance of CFL-reachability analysis by reducing its transitive redundancy during on-the-fly solving. Our experiments on context-sensitive value-flow analysis and field-sensitive alias analysis for C/C++ demonstrate the promising performance of POCR. On average, POCR eliminates 98.50% and 97.26% redundant derivations respectively for the value-flow and alias analysis, achieving speedups of 21.48× and 19.57× over the standard CFL-reachability algorithm. We also compare POCR with two recent open-source tools, Graspan (a CFL-reachability solver) and Soufflé (a Datalog engine). The results demonstrate that POCR is over 3.67× faster than Graspan and Soufflé on average for both value-flow analysis and alias analysis.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563343", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuxiang", + "last_name": "Lei", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Shuo", + "last_name": "Ding", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/LeiSDZ22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563344", + "title": "Symbolic execution for randomized programs", + "abstract": "We propose a symbolic execution method for programs that can draw random samples. In contrast to existing work, our method can verify randomized programs with unknown inputs and can prove probabilistic properties that universally quantify over all possible inputs. Our technique augments standard symbolic execution with a new class of probabilistic symbolic variables , which represent the results of random draws, and computes symbolic expressions representing the probability of taking individual paths. We implement our method on top of the KLEE symbolic execution engine alongside multiple optimizations and use it to prove properties about probabilities and expected values for a range of challenging case studies written in C++, including Freivalds’ algorithm, randomized quicksort, and a randomized property-testing algorithm for monotonicity. We evaluate our method against Psi, an exact probabilistic symbolic inference engine, and Storm, a probabilistic model checker, and show that our method significantly outperforms both tools.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563344", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zachary J.", + "last_name": "Susag", + "institution": "Cornell University" + }, + { + "first_name": "Sumit", + "last_name": "Lahiri", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Cornell University" + }, + { + "first_name": "Subhajit", + "last_name": "Roy", + "institution": "Indian Institute of Technology Kanpur" + } + ], + "dblp_key": "journals/pacmpl/SusagLHR22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563348", + "title": "Synthesizing axiomatizations using logic learning", + "abstract": "Axioms and inference rules form the foundation of deductive systems and are crucial in the study of reasoning with logics over structures. Historically, axiomatizations have been discovered manually with much expertise and effort. In this paper we show the feasibility of using synthesis techniques to discover axiomatizations for different classes of structures, and in some contexts, automatically prove their completeness. For evaluation, we apply our technique to find axioms for (1) classes of frames in modal logic characterized in first-order logic and (2) the class of language models with regular operations.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563348", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "Krogmeier", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Zhengyao", + "last_name": "Lin", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/KrogmeierLMM22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563345", + "title": "BFF: foundational and automated verification of bitfield-manipulating programs", + "abstract": "Low-level systems code often needs to interact with data, such as page table entries or network packet headers, in which multiple pieces of information are packaged together as bitfield components of a single machine integer and accessed via bitfield manipulations (e.g., shifts and masking). Most existing approaches to verifying such code employ SMT solvers, instantiated with theories for bit vector reasoning: these provide a powerful hammer, but also significantly increase the trusted computing base of the verification toolchain. In this work, we propose an alternative approach to the verification of bitfield-manipulating systems code, which we call BFF. Building on the RefinedC framework, BFF is not only highly automated (as SMT-based approaches are) but also foundational---i.e., it produces a machine-checked proof of program correctness against a formal semantics for C programs, fully mechanized in Coq. Unlike SMT-based approaches, we do not try to solve the general problem of arbitrary bit vector reasoning, but rather observe that real systems code typically accesses bitfields using simple, well-understood programming patterns: the layout of a bit vector is known up front, and its bitfields are accessed in predictable ways through a handful of bitwise operations involving bit masks. Correspondingly, we center our approach around the concept of a structured bit vector---i.e., a bit vector with a known bitfield layout---which we use to drive simple and predictable automation. We validate the BFF approach by verifying a range of bitfield-manipulating C functions drawn from real systems code, including page table manipulation code from the Linux kernel and the pKVM hypervisor.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563345", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fengmin", + "last_name": "Zhu", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Rodolphe", + "last_name": "Lepigre", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/ZhuSLDG22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563350", + "title": "Synthesizing code quality rules from examples", + "abstract": "Static Analysis tools have rules for several code quality issues and these rules are created by experts manually. In this paper, we address the problem of automatic synthesis of code quality rules from examples. We formulate the rule synthesis problem as synthesizing first order logic formulas over graph representations of code. We present a new synthesis algorithm RhoSynth that is based on Integer Linear Programming-based graph alignment for identifying code elements of interest to the rule. We bootstrap RhoSynth by leveraging code changes made by developers as the source of positive and negative examples. We also address rule refinement in which the rules are incrementally improved with additional user-provided examples. We validate RhoSynth by synthesizing more than 30 Java code quality rules. These rules have been deployed as part of Amazon CodeGuru Reviewer and their precision exceeds 75% based on developer feedback collected during live code-reviews within Amazon. Through comparisons with recent baselines, we show that current state-of-the-art program synthesis approaches are unable to synthesize most of these rules.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563350", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pranav", + "last_name": "Garg", + "institution": "" + }, + { + "first_name": "Srinivasan H.", + "last_name": "Sengamedu", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/GargS22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563349", + "title": "Veracity: declarative multicore programming with commutativity", + "abstract": "There is an ongoing effort to provide programming abstractions that ease the burden of exploiting multicore hardware. Many programming abstractions ( e.g. , concurrent objects, transactional memory, etc.) simplify matters, but still involve intricate engineering. We argue that some difficulty of multicore programming can be meliorated through a declarative programming style in which programmers directly express the independence of fragments of sequential programs. In our proposed paradigm, programmers write programs in a familiar, sequential manner, with the added ability to explicitly express the conditions under which code fragments sequentially commute. Putting such commutativity conditions into source code offers a new entry point for a compiler to exploit the known connection between commutativity and parallelism. We give a semantics for the programmer’s sequential perspective and, under a correctness condition, find that a compiler-transformed parallel execution is equivalent to the sequential semantics. Serializability/linearizability are not the right fit for this condition, so we introduce scoped serializability and show how it can be enforced with lock synthesis techniques. We next describe a technique for automatically verifying and synthesizing commute conditions via a new reduction from our commute blocks to logical specifications, upon which symbolic commutativity reasoning can be performed. We implemented our work in a new language called Veracity, implemented in Multicore OCaml. We show that commutativity conditions can be automatically generated across a variety of new benchmark programs, confirm the expectation that concurrency speedups can be seen as the computation increases, and apply our work to a small in-memory filesystem and an adaptation of a crowdfund blockchain smart contract.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563349", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adam", + "last_name": "Chen", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Parisa", + "last_name": "Fathololumi", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Jared", + "last_name": "Pincus", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ChenFKP22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563347", + "title": "Semi-symbolic inference for efficient streaming probabilistic programming", + "abstract": "A streaming probabilistic program receives a stream of observations and produces a stream of distributions that are conditioned on these observations. Efficient inference is often possible in a streaming context using Rao-Blackwellized particle filters (RBPFs), which exactly solve inference problems when possible and fall back on sampling approximations when necessary. While RBPFs can be implemented by hand to provide efficient inference, the goal of streaming probabilistic programming is to automatically generate such efficient inference implementations given input probabilistic programs. In this work, we propose semi-symbolic inference, a technique for executing probabilistic programs using a runtime inference system that automatically implements Rao-Blackwellized particle filtering. To perform exact and approximate inference together, the semi-symbolic inference system manipulates symbolic distributions to perform exact inference when possible and falls back on approximate sampling when necessary. This approach enables the system to implement the same RBPF a developer would write by hand. To ensure this, we identify closed families of distributions – such as linear-Gaussian and finite discrete models – on which the inference system guarantees exact inference. We have implemented the runtime inference system in the ProbZelus streaming probabilistic programming language. Despite an average 1.6× slowdown compared to the state of the art on existing benchmarks, our evaluation shows that speedups of 3×-87× are obtainable on a new set of challenging benchmarks we have designed to exploit closed families.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563347", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Atkinson", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Charles", + "last_name": "Yuan", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Guillaume", + "last_name": "Baudart", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Louis", + "last_name": "Mandel", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AtkinsonYBMC22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563354", + "title": "Model-guided synthesis of inductive lemmas for FOL with least fixpoints", + "abstract": "Recursively defined linked data structures embedded in a pointer-based heap and their properties are naturally expressed in pure first-order logic with least fixpoint definitions (FO+lfp) with background theories. Such logics, unlike pure first-order logic, do not admit even complete procedures. In this paper, we undertake a novel approach for synthesizing inductive hypotheses to prove validity in this logic. The idea is to utilize several kinds of finite first-order models as counterexamples that capture the non-provability and invalidity of formulas to guide the search for inductive hypotheses. We implement our procedures and evaluate them extensively over theorems involving heap data structures that require inductive proofs and demonstrate the effectiveness of our methodology.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563354", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Lucas", + "last_name": "Peña", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Eion", + "last_name": "Blanchard", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Christof", + "last_name": "Löding", + "institution": "RWTH Aachen University" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MuraliPBLM22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563352", + "title": "Implementing and verifying release-acquire transactional memory in C11", + "abstract": "Transactional memory (TM) is an intensively studied synchronisation paradigm with many proposed implementations in software and hardware, and combinations thereof. However, TM under relaxed memory, e.g., C11 (the 2011 C/C++ standard) is still poorly understood, lacking rigorous foundations that support verifiable implementations. This paper addresses this gap by developing TMS2-ra, a relaxed operational TM specification. We integrate TMS2-ra with RC11 (the repaired C11 memory model that disallows load-buffering) to provide a formal semantics for TM libraries and their clients. We develop a logic, TARO, for verifying client programs that use TMS2-ra for synchronisation. We also show how TMS2-ra can be implemented by a C11 library, TML-ra, that uses relaxed and release-acquire atomics, yet guarantees the synchronisation properties required by TMS2-ra. We benchmark TML-ra and show that it outperforms its sequentially consistent counterpart in the STAMP benchmarks. Finally, we use a simulation-based verification technique to prove correctness of TML-ra. Our entire development is supported by the Isabelle/HOL proof assistant.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563352", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sadegh", + "last_name": "Dalvandi", + "institution": "University of Surrey" + }, + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "University of Surrey" + } + ], + "dblp_key": "journals/pacmpl/DalvandiD22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563351", + "title": "Modular verification of op-based CRDTs in separation logic", + "abstract": "Operation-based Conflict-free Replicated Data Types (op-based CRDTs) are a family of distributed data structures where all operations are designed to commute, so that replica states eventually converge. Additionally, op-based CRDTs require that operations be propagated between replicas in causal order. This paper presents a framework for verifying safety properties of CRDT implementations using separation logic. The framework consists of two libraries. One implements a Reliable Causal Broadcast (RCB) protocol so that replicas can exchange messages in causal order. A second “OpLib” library then uses RCB to simplify the creation and correctness proofs of op-based CRDTs. OpLib allows clients to implement new CRDTs as purely-functional data structures, without having to reason about network operations, concurrency control and mutable state, and without having to each time re-implement causal broadcast. Using OpLib, we have implemented 12 example CRDTs from the literature, including multiple versions of replicated registers and sets, two CRDT combinators for products and maps, and two example use cases of the map combinator. Our proofs are conducted in the Aneris distributed separation logic and are formalized in Coq. Our technique is the first work on verification of op-based CRDTs that satisfies both of the following properties: it is modular and targets executable implementations , as opposed to high-level protocols.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563351", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Abel", + "last_name": "Nieto", + "institution": "Aarhus University" + }, + { + "first_name": "Léon", + "last_name": "Gondelman", + "institution": "Aarhus University" + }, + { + "first_name": "Alban", + "last_name": "Reynaud", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/NietoGRTB22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563353", + "title": "Fast shadow execution for debugging numerical errors using error free transformations", + "abstract": "This paper proposes, EFTSanitizer, a fast shadow execution framework for detecting and debugging numerical errors during late stages of testing especially for long-running applications. Any shadow execution framework needs an oracle to compare against the floating point (FP) execution. This paper makes a case for using error free transformations, which is a sequence of operations to compute the error of a primitive operation with existing hardware supported FP operations, as an oracle for shadow execution. Although the error of a single correctly rounded FP operation is bounded, the accumulation of errors across operations can result in exceptions, slow convergences, and even crashes. To ease the job of debugging such errors, EFTSanitizer provides a directed acyclic graph (DAG) that highlights the propagation of errors, which results in exceptions or crashes. Unlike prior work, DAGs produced by EFTSanitizer include operations that span various function calls while keeping the memory usage bounded. To enable the use of such shadow execution tools with long-running applications, EFTSanitizer also supports starting the shadow execution at an arbitrary point in the dynamic execution, which we call selective shadow execution. EFTSanitizer is an order of magnitude faster than prior state-of-art shadow execution tools such as FPSanitizer and Herbgrind. We have discovered new numerical errors and debugged them using EFTSanitizer.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563353", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sangeeta", + "last_name": "Chowdhary", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Santosh", + "last_name": "Nagarakatte", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "journals/pacmpl/ChowdharyN22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563355", + "title": "Intrinsically-typed definitional interpreters à la carte", + "abstract": "Specifying and mechanically verifying type safe programming languages requires significant effort. This effort can in theory be reduced by defining and reusing pre-verified, modular components. In practice, however, existing approaches to modular mechanical verification require many times as much specification code as plain, monolithic definitions. This makes it hard to develop new reusable components, and makes existing component specifications hard to grasp. We present an alternative approach based on intrinsically-typed interpreters, which reduces the size and complexity of modular specifications as compared to existing approaches. Furthermore, we introduce a new abstraction for safe-by-construction specification and composition of pre-verified type safe language components: language fragments . Language fragments are about as concise and easy to develop as plain, monolithic intrinsically-typed interpreters, but require about 10 times less code than previous approaches to modular mechanical verification of type safety.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563355", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cas van der", + "last_name": "Rest", + "institution": "Delft University of Technology" + }, + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Arjen", + "last_name": "Rouvoet", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + }, + { + "first_name": "Peter D.", + "last_name": "Mosses", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/RestPRVM22", + "venue": "oopsla", + "year": 2022 + }, + { + "paper_id": "10.1145/3563445", + "title": "High-level effect handlers in C++", + "abstract": "Effect handlers allow the programmer to implement computational effects, such as custom error handling, various forms of lightweight concurrency, and dynamic binding, inside the programming language. We introduce cpp-effects, a C++ library for effect handlers with a typed high-level, object-oriented interface. We demonstrate that effect handlers can be successfully applied in imperative systems programming languages with manual memory management. Through a collection of examples, we explore how to program effectively with effect handlers in C++, discuss the intricacies and challenges of the implementation, and show that despite its limitations, cpp-effects performance is competitive and in some cases even outperforms state-of-the-art approaches such as C++20 coroutines and the libmprompt library for multiprompt delimited control.", + "date": "2022-10-31", + "link": "https://doi.org/10.1145/3563445", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dan R.", + "last_name": "Ghica", + "institution": "Huawei Technologies (United Kingdom)" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "Marcos Maroñas", + "last_name": "Bravo", + "institution": "Huawei Technologies (United Kingdom)" + }, + { + "first_name": "Maciej", + "last_name": "Piróg", + "institution": "Huawei Technologies (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/GhicaLBP22", + "venue": "oopsla", + "year": 2022 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2023.json b/data/pl_conferences/oopsla/2023.json new file mode 100644 index 0000000..ea06f69 --- /dev/null +++ b/data/pl_conferences/oopsla/2023.json @@ -0,0 +1,3912 @@ +[ + { + "paper_id": "10.1145/3586030", + "title": "Grounded Copilot: How Programmers Interact with Code-Generating Models", + "abstract": "Powered by recent advances in code-generating models, AI assistants like Github Copilot promise to change the face of programming forever. But what is this new face of programming? We present the first grounded theory analysis of how programmers interact with Copilot, based on observing 20 participants—with a range of prior experience using the assistant—as they solve diverse programming tasks across four languages. Our main finding is that interactions with programming assistants are bimodal : in acceleration mode , the programmer knows what to do next and uses Copilot to get there faster; in exploration mode , the programmer is unsure how to proceed and uses Copilot to explore their options. Based on our theory, we provide recommendations for improving the usability of future AI programming assistants.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586030", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shraddha", + "last_name": "Barke", + "institution": "University of California San Diego" + }, + { + "first_name": "Michael B.", + "last_name": "James", + "institution": "University of California San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/BarkeJP23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586036", + "title": "A Gradual Probabilistic Lambda Calculus", + "abstract": "Probabilistic programming languages have recently gained a lot of attention, in particular due to their applications in domains such as machine learning and differential privacy. To establish invariants of interest, many such languages include some form of static checking in the form of type systems. However, adopting such a type discipline can be cumbersome or overly conservative. Gradual typing addresses this problem by supporting a smooth transition between static and dynamic checking, and has been successfully applied for languages with different constructs and type abstractions. Nevertheless, its benefits have never been explored in the context of probabilistic languages. In this work, we present and formalize GPLC, a gradual source probabilistic lambda calculus. GPLC includes a binary probabilistic choice operator and allows programmers to gradually introduce/remove static type–and probability–annotations. The static semantics of GPLC heavily relies on the notion of probabilistic couplings, as required for defining several relations, such as consistency, precision, and consistent transitivity. The dynamic semantics of GPLC is given via elaboration to the target language TPLC, which features a distribution-based semantics interpreting programs as probability distributions over final values. Regarding the language metatheory, we establish that TPLC–and therefore also GPLC–is type safe and satisfies two of the so-called refined criteria for gradual languages, namely, that it is a conservative extension of a fully static variant and that it satisfies the gradual guarantee, behaving smoothly with respect to type precision.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586036", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wenjia", + "last_name": "Ye", + "institution": "University of Hong Kong" + }, + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + }, + { + "first_name": "Federico", + "last_name": "Olmedo", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/YeTO23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586029", + "title": "Generating Proof Certificates for a Language-Agnostic Deductive Program Verifier", + "abstract": "Previous work on rewriting and reachability logic establishes a vision for a language-agnostic program verifier, which takes three inputs: a program, its formal specification, and the formal semantics of the programming language in which the program is written. The verifier then uses a language-agnostic verification algorithm to prove the program correct with respect to the specification and the formal language semantics. Such a complex verifier can easily have bugs. This paper proposes a method to certify the correctness of each successful verification run by generating a proof certificate. The proof certificate can be checked by a small proof checker. The preliminary experiments apply the method to generate proof certificates for program verification in an imperative language, a functional language, and an assembly language, showing that the proposed method is language-agnostic.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586029", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhengyao", + "last_name": "Lin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Xiaohong", + "last_name": "Chen", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Minh-Thai", + "last_name": "Trinh", + "institution": "Advanced Digital Sciences Center" + }, + { + "first_name": "John", + "last_name": "Wang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/LinCTWR23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586042", + "title": "Deep Learning Robustness Verification for Few-Pixel Attacks", + "abstract": "While successful, neural networks have been shown to be vulnerable to adversarial example attacks. In L 0 adversarial attacks, also known as few-pixel attacks, the attacker picks t pixels from the image and arbitrarily perturbs them. To understand the robustness level of a network to these attacks, it is required to check the robustness of the network to perturbations of every set of t pixels. Since the number of sets is exponentially large, existing robustness verifiers, which can reason about a single set of pixels at a time, are impractical for L 0 robustness verification. We introduce Calzone, an L 0 robustness verifier for neural networks. To the best of our knowledge, Calzone is the first to provide a sound and complete analysis for L 0 adversarial attacks. Calzone builds on the following observation: if a classifier is robust to any perturbation of a set of k pixels, for k > t , then it is robust to any perturbation of its subsets of size t . Thus, to reduce the verification time, Calzone predicts the largest k that can be proven robust, via dynamic programming and sampling. It then relies on covering designs to compute a covering of the image with sets of size k . For each set in the covering, Calzone submits its corresponding box neighborhood to an existing L ∞ robustness verifier. If a set’s neighborhood is not robust, Calzone repeats this process and covers this set with sets of size k ′< k . We evaluate Calzone on several datasets and networks, for t ≤ 5. Typically, Calzone verifies L 0 robustness within few minutes. On our most challenging instances (e.g., t =5), Calzone completes within few hours. We compare to a MILP baseline and show that it does not scale already for t =3.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586042", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuval P.", + "last_name": "Shapira", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Eran", + "last_name": "Avneri", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Dana", + "last_name": "Drachsler-Cohen", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/ShapiraAD23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586035", + "title": "Bidirectional Object-Oriented Programming: Towards Programmatic and Direct Manipulation of Objects", + "abstract": "Many bidirectional programming languages, which are mainly functional and relational, have been designed to support writing programs that run in both forward and backward directions. Nevertheless, there is little study on the bidirectionalization of object-oriented languages that are more popular in practice. This paper presents the first bidirectional object-oriented language that supports programmatic and direct manipulation of objects. Specifically, we carefully extend a core object-oriented language, which has a standard forward evaluation semantics, with backward updating semantics for class inheritance hierarchies and references. We formally prove that the bidirectional evaluation semantics satisfies the round-tripping properties if the output is altered consistently. To validate the utility of our approach, we have developed a tool called BiOOP for generating HTML documents through bidirectional GUI design. We evaluate the expressiveness and effectiveness of BiOOP for HTML webpage development by reproducing ten classic object-oriented applications from a Java Swing tutorial and one large project from GitHub. The experimental results show the response time of direct manipulation programming on object-oriented programs that produce HTML webpages is acceptable for developers.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586035", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xing", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Guanchen", + "last_name": "Guo", + "institution": "Peking University" + }, + { + "first_name": "Xiao", + "last_name": "He", + "institution": "University of Science and Technology Beijing" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/ZhangGHH23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586031", + "title": "Hybrid Multiparty Session Types: Compositionality for Protocol Specification through Endpoint Projection", + "abstract": "Multiparty session types (MPST) are a specification and verification framework for distributed message-passing systems. The communication protocol of the system is specified as a global type , from which a collection of local types (local process implementations) is obtained by endpoint projection . A global type is a single disciplining entity for the whole system, specified by one designer that has full knowledge of the communication protocol. On the other hand, distributed systems are often described in terms of their components : a different designer is in charge of providing a subprotocol for each component. The problem of modular specification of global protocols has been addressed in the literature, but the state of the art focuses only on dual input/output compatibility. Our work overcomes this limitation. We propose the first MPST theory of multiparty compositionality for distributed protocol specification that is semantics-preserving, allows the composition of two or more components, and retains full MPST expressiveness. We introduce hybrid types for describing subprotocols interacting with each other, define a novel compatibility relation , explicitly describe an algorithm for composing multiple subprotocols into a well-formed global type , and prove that compositionality preserves projection, thus retaining semantic guarantees, such as liveness and deadlock freedom. Finally, we test our work against real-world case studies and we smoothly extend our novel compatibility to MPST with delegation and explicit connections.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586031", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lorenzo", + "last_name": "Gheri", + "institution": "University of Oxford" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/GheriY23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586034", + "title": "User-Customizable Transpilation of Scripting Languages", + "abstract": "A transpiler converts code from one programming language to another. Many practical uses of transpilers require the user to be able to guide or customize the program produced from a given input program. This customizability is important for satisfying many application-specific goals for the produced code such as ensuring performance, readability, ease of exposition or maintainability, compatibility with external environment or analysis tools, and so on. Conventional transpilers are deterministic rule-driven systems often written without offering customizability per user and per program. Recent advances in transpilers based on neural networks offer some customizability to users, e.g. through interactive prompts, but they are still difficult to precisely control the production of a desired output. Both conventional and neural transpilation also suffer from the \"last mile\" problem: they produce correct code on average, i.e., on most parts of a given program, but not necessarily for all parts of it. We propose a new transpilation approach that offers fine-grained customizability and reusability of transpilation rules created by others, without burdening the user to understand the global semantics of the given source program. Our approach is mostly automatic and incremental, i.e., constructs translation rules needed to transpile the given program as per the user's guidance piece-by-piece. Users can rely on existing transpilation rules to translate most of the program correctly while focusing their effort locally, only on parts that are incorrect or need customization. This improves the correctness of the end result. We implement the transpiler as a tool called DuoGlot, which translates Python to Javascript programs, and evaluate it on the popular GeeksForGeeks benchmarks. DuoGlot achieves 90% translation accuracy and so it outperforms all existing translators (both handcrafted and neural-based), while it produces readable code. We evaluate DuoGlot on two additional benchmarks, containing more challenging and longer programs, and similarly observe improved accuracy compared to the other transpilers.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586034", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bo", + "last_name": "Wang", + "institution": "National University of Singapore" + }, + { + "first_name": "Aashish", + "last_name": "Kolluri", + "institution": "National University of Singapore" + }, + { + "first_name": "Ivica", + "last_name": "Nikolić", + "institution": "National University of Singapore" + }, + { + "first_name": "Teodora", + "last_name": "Baluta", + "institution": "National University of Singapore" + }, + { + "first_name": "Prateek", + "last_name": "Saxena", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/WangKNBS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586033", + "title": "Enabling Bounded Verification of Doubly-Unbounded Distributed Agreement-Based Systems via Bounded Regions", + "abstract": "The ubiquity of distributed agreement protocols, such as consensus, has galvanized interest in verification of such protocols as well as applications built on top of them. The complexity and unboundedness of such systems, however, makes their verification onerous in general, and, particularly prohibitive for full automation. An exciting, recent breakthrough reveals that, through careful modeling, it becomes possible to reduce verification of interesting distributed agreement-based (DAB) systems, that are unbounded in the number of processes, to model checking of small, finite-state systems. It is an open question if such reductions are also possible for DAB systems that are doubly-unbounded , in particular, DAB systems that additionally have unbounded data domains. We answer this question in the affirmative in this work thereby broadening the class of DAB systems which can be automatically and efficiently verified. We present a novel reduction which leverages value symmetry and a new notion of data saturation to reduce verification of doubly-unbounded DAB systems to model checking of small, finite-state systems. We develop a tool, Venus, that can efficiently verify sophisticated DAB system models such as the arbitration mechanism for a consortium blockchain, a distributed register, and a simple key-value store.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586033", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Christopher", + "last_name": "Wagner", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Nouraldin", + "last_name": "Jaber", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WagnerJS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586032", + "title": "Languages with Decidable Learning: A Meta-theorem", + "abstract": "We study expression learning problems with syntactic restrictions and introduce the class of finite-aspect checkable languages to characterize symbolic languages that admit decidable learning. The semantics of such languages can be defined using a bounded amount of auxiliary information that is independent of expression size but depends on a fixed structure over which evaluation occurs. We introduce a generic programming language for writing programs that evaluate expression syntax trees, and we give a meta-theorem that connects such programs for finite-aspect checkable languages to finite tree automata, which allows us to derive new decidable learning results and decision procedures for several expression learning problems by writing programs in the programming language.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586032", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "Krogmeier", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/KrogmeierM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586037", + "title": "Verus: Verifying Rust Programs using Linear Ghost Types", + "abstract": "The Rust programming language provides a powerful type system that checks linearity and borrowing, allowing code to safely manipulate memory without garbage collection and making Rust ideal for developing low-level, high-assurance systems. For such systems, formal verification can be useful to prove functional correctness properties beyond type safety. This paper presents Verus, an SMT-based tool for formally verifying Rust programs. With Verus, programmers express proofs and specifications using the Rust language, allowing proofs to take advantage of Rust's linear types and borrow checking. We show how this allows proofs to manipulate linearly typed permissions that let Rust code safely manipulate memory, pointers, and concurrent resources. Verus organizes proofs and specifications using a novel mode system that distinguishes specifications, which are not checked for linearity and borrowing, from executable code and proofs, which are checked for linearity and borrowing. We formalize Verus' linearity, borrowing, and modes in a small lambda calculus, for which we prove type safety and termination of specifications and proofs. We demonstrate Verus on a series of examples, including pointer-manipulating code (an xor-based doubly linked list), code with interior mutability, and concurrent code.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586037", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Lattuada", + "institution": "" + }, + { + "first_name": "Travis", + "last_name": "Hance", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Chanhee", + "last_name": "Cho", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Matthias", + "last_name": "Brun", + "institution": "ETH Zurich" + }, + { + "first_name": "Isitha", + "last_name": "Subasinghe", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yi", + "last_name": "Zhou", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jon", + "last_name": "Howell", + "institution": "" + }, + { + "first_name": "Bryan", + "last_name": "Parno", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/LattuadaHCBSZHPH23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586040", + "title": "A Verification Methodology for the Arm® Confidential Computing Architecture: From a Secure Specification to Safe Implementations", + "abstract": "We present Arm's efforts in verifying the specification and prototype reference implementation of the Realm Management Monitor (RMM), an essential firmware component of Arm Confidential Computing Architecture (Arm CCA), the recently-announced Confidential Computing technologies incorporated in the Armv9-A architecture. Arm CCA introduced the Realm Management Extension (RME), an architectural extension for Armv9-A, and a technology that will eventually be deployed in hundreds of millions of devices. Given the security-critical nature of the RMM, and its taxing threat model, we use a combination of interactive theorem proving, model checking, and concurrency-aware testing to validate and verify security and safety properties of both the specification and a prototype implementation of the RMM. Crucially, our verification efforts were, and are still being, developed and refined contemporaneously with active development of both specification and implementation, and have been adopted by Arm's product teams. We describe our major achievements, realized through the application of formal techniques, as well as challenges that remain for future work. We believe that the work reported in this paper is the most thorough application of formal techniques to the design and implementation of any current commercially-viable Confidential Computing implementation, setting a new high-water mark for work in this area.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586040", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anthony", + "last_name": "Fox", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Gareth", + "last_name": "Stockwell", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Shale", + "last_name": "Xiong", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Hanno", + "last_name": "Becker", + "institution": "Amazon (United Kingdom)" + }, + { + "first_name": "Dominic P.", + "last_name": "Mulligan", + "institution": "Amazon (United Kingdom)" + }, + { + "first_name": "Gustavo", + "last_name": "Petri", + "institution": "Amazon (United Kingdom)" + }, + { + "first_name": "Nathan", + "last_name": "Chong", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/FoxSXBMPC23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586028", + "title": "Solving Conditional Linear Recurrences for Program Verification: The Periodic Case", + "abstract": "In program verification, one method for reasoning about loops is to convert them into sets of recurrences, and then try to solve these recurrences by computing their closed-form solutions. While there are solvers for computing closed-form solutions to these recurrences, their capabilities are limited when the recurrences have conditional expressions, which arise when the body of a loop contains conditional statements. In this paper, we take a step towards solving these recurrences. Specifically, we consider what we call conditional linear recurrences and show that given such a recurrence and an initial value, if the index sequence generated by the recurrence on the initial value is what we call ultimately periodic, then it has a closed-form solution. However, checking whether such a sequence is ultimately periodic is undecidable so we propose a heuristic \"generate and verify\" algorithm for checking the ultimate periodicity of the sequence and computing closed-form solutions at the same time. We implemented a solver based on this algorithm, and our experiments show that a straightforward program verifier based on our solver and using the SMT solver Z3 is effective in verifying properties of many benchmark programs that contain conditional statements in their loops, and compares favorably to other recurrence-based verification tools. Finally, we also consider extending our results to computing closed-form solutions of recurrences with unknown initial values.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586028", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chenglin", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Fangzhen", + "last_name": "Lin", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/WangL23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586038", + "title": "Fat Pointers for Temporal Memory Safety of C", + "abstract": "Temporal memory safety bugs, especially use-after-free and double free bugs, pose a major security threat to C programs. Real-world exploits utilizing these bugs enable attackers to read and write arbitrary memory locations, causing disastrous violations of confidentiality, integrity, and availability. Many previous solutions retrofit temporal memory safety to C, but they all either incur high performance overhead and/or miss detecting certain types of temporal memory safety bugs. In this paper, we propose a temporal memory safety solution that is both efficient and comprehensive. Specifically, we extend Checked C, a spatially-safe extension to C, with temporally-safe pointers. These are implemented by combining two techniques: fat pointers and dynamic key-lock checks. We show that the fat-pointer solution significantly improves running time and memory overhead compared to the disjoint-metadata approach that provides the same level of protection. With empirical program data and hands-on experience porting real-world applications, we also show that our solution is practical in terms of backward compatibility---one of the major complaints about fat pointers.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586038", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jie", + "last_name": "Zhou", + "institution": "University of Rochester" + }, + { + "first_name": "John", + "last_name": "Criswell", + "institution": "University of Rochester" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/ZhouCH23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586039", + "title": "Modular Component-Based Quantum Circuit Synthesis", + "abstract": "In this article, we present a novel method for synthesizing quantum circuits from user-supplied components. Given input-output state vectors and component quantum gates, our synthesizer aims to construct a quantum circuit that implements the provided functionality in terms of the supplied component gates. To achieve this, we basically use an enumerative search with pruning. To accelerate the procedure, however, we perform the search and pruning at the module level; instead of simply enumerating candidate circuits by appending component gates in sequence, we stack modules, which are groups of gate operations. With this modular approach, we can effectively reduce the search space by directing the search in a way that bridges the gap between the current circuit and the input-output specification. Evaluation on 17 benchmark problems shows that our technique is highly effective at synthesizing quantum circuits. Our method successfully synthesized 16 out of 17 benchmark circuits in 96.6 seconds on average. On the other hand, the conventional, gate-level synthesis algorithm succeeded in 10 problems with an average time of 639.1 seconds. Our algorithm increased the speed of the baseline by 20.3x for the 10 problems commonly solved by both approaches.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586039", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chan Gu", + "last_name": "Kang", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/KangO23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586041", + "title": "Compositional Security Definitions for Higher-Order Where Declassification", + "abstract": "To ensure programs do not leak private data, we often want to be able to provide formal guarantees ensuring such data is handled correctly. Often, we cannot keep such data secret entirely; instead programmers specify how private data may be declassified . While security definitions for declassification exist, they mostly do not handle higher-order programs. In fact, in the higher-order setting no compositional security definition exists for intensional information-flow properties such as where declassification, which allows declassification in specific parts of a program. We use logical relations to build a model (and thus security definition) of where declassification. The key insight required for our model is that we must stop enforcing indistinguishability once a relevant declassification has occurred. We show that the resulting security definition provides more security than the most related previous definition, which is for the lower-order setting.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586041", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jan", + "last_name": "Menz", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Andrew K.", + "last_name": "Hirsch", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Peixuan", + "last_name": "Li", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/MenzHLG23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586027", + "title": "Accelerating Fuzzing through Prefix-Guided Execution", + "abstract": "Coverage-guided fuzzing is one of the most effective approaches for discovering software defects and vulnerabilities. It executes all mutated tests from seed inputs to expose coverage-increasing tests. However, executing all mutated tests incurs significant performance penalties---most of the mutated tests are discarded because they do not increase code coverage. Thus, determining if a test increases code coverage without actually executing it is beneficial, but a paradoxical challenge. In this paper, we introduce the notion of prefix-guided execution (PGE) to tackle this challenge. PGE leverages two key observations: (1) Only a tiny fraction of the mutated tests increase coverage, thus requiring full execution; and (2) whether a test increases coverage may be accurately inferred from its partial execution. PGE monitors the execution of a test and applies early termination when the execution prefix indicates that the test is unlikely to increase coverage. To demonstrate the potential of PGE, we implement a prototype on top of AFL++, which we call AFL++-PGE. We evaluate AFL++-PGE on MAGMA, a ground-truth benchmark set that consists of 21 programs from nine popular real-world projects. Our results show that, after 48 hours of fuzzing, AFL++-PGE finds more bugs, discovers bugs faster, and achieves higher coverage. Prefix-guided execution is general and can benefit the AFL-based family of fuzzers.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586027", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shaohua", + "last_name": "Li", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/LiS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586043", + "title": "Proof Automation for Linearizability in Separation Logic", + "abstract": "Recent advances in concurrent separation logic enabled the formal verification of increasingly sophisticated fine-grained ( i.e. , lock-free) concurrent programs. For such programs, the golden standard of correctness is linearizability , which expresses that concurrent executions always behave as some valid sequence of sequential executions. Compositional approaches to linearizability (such as contextual refinement and logical atomicity) make it possible to prove linearizability of whole programs or compound data structures ( e.g. , a ticket lock) using proofs of linearizability of their individual components ( e.g. , a counter). While powerful, these approaches are also laborious—state-of-the-art tools such as Iris, FCSL, and Voila all require a form of interactive proof. This paper develops proof automation for contextual refinement and logical atomicity in Iris. The key ingredient of our proof automation is a collection of proof rules whose application is directed by both the program and the logical state. This gives rise to effective proof search strategies that can prove linearizability of simple examples fully automatically. For more complex examples, we ensure the proof automation cooperates well with interactive proof tactics by minimizing the use of backtracking. We implement our proof automation in Coq by extending and generalizing Diaframe, a proof automation extension for Iris. While the old version (Diaframe 1.0) was limited to ordinary Hoare triples, the new version (Diaframe 2.0) is extensible in its support for program verification styles: our proof search strategies for contextual refinement and logical atomicity are implemented as modules for Diaframe 2.0. We evaluate our proof automation on a set of existing benchmarks and novel proofs, showing that it provides significant reduction of proof work for both approaches to linearizability.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586043", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ike", + "last_name": "Mulder", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/MulderK23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586044", + "title": "Regular Expression Matching using Bit Vector Automata", + "abstract": "Regular expressions (regexes) are ubiquitous in modern software. There is a variety of implementation techniques for regex matching, which can be roughly categorized as (1) relying on backtracking search, or (2) being based on finite-state automata. The implementations that use backtracking are often chosen due to their ability to support advanced pattern-matching constructs. Unfortunately, they are known to suffer from severe performance problems. For some regular expressions, the running time for matching can be exponential in the size of the input text. In order to provide stronger guarantees of matching efficiency, automata-based regex matching is the preferred choice. However, even these regex engines may exhibit severe performance degradation for some patterns. The main reason for this is that regexes used in practice are not exclusively built from the classical regular constructs, i.e., concatenation, nondeterministic choice and Kleene's star. They involve additional constructs that provide succinctness and convenience of expression. The most common such construct is bounded repetition (also called counting), which describes the repetition of the pattern a fixed number of times. In this paper, we propose a new algorithm for the efficient matching of regular expressions that involve bounded repetition. Our algorithms are based on a new model of automata, which we call nondeterministic bit vector automata (NBVA). This model is chosen to be expressively equivalent to nondeterministic counter automata with bounded counters, a very natural model for expressing patterns with bounded repetition. We show that there is a class of regular expressions with bounded repetition that can be matched in time that is independent from the repetition bounds. Our algorithms are general enough to cover the vast majority of challenging bounded repetitions that arise in practice. We provide an implementation of our approach in a regex engine, which we call BVA-Scan. We compare BVA-Scan against state-of-the-art regex engines on several real datasets.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586044", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexis Le", + "last_name": "Glaunec", + "institution": "Rice University" + }, + { + "first_name": "Lingkun", + "last_name": "Kong", + "institution": "Rice University" + }, + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + } + ], + "dblp_key": "journals/pacmpl/GlaunecKM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586057", + "title": "Fluent APIs in Functional Languages", + "abstract": "Fluent API is an object-oriented pattern for elegant APIs and embedded DSLs. A smart fluent API can enforce the API protocol or DSL syntax at compile time. Since fluent API implementations typically rely on overloading function names, they are hard to realize in functional programming languages. This work shows how functional fluent APIs can be implemented in the absence of name overloading, by relying on parametric polymorphism and Hindley-Milner type inference. The implementation supports fluent API protocols in the regular- and deterministic context-free language classes, and even beyond.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586057", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ori", + "last_name": "Roth", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Yossi", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/RothG23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586045", + "title": "Outcome Logic: A Unifying Foundation for Correctness and Incorrectness Reasoning", + "abstract": "Program logics for bug-finding (such as the recently introduced Incorrectness Logic) have framed correctness and incorrectness as dual concepts requiring different logical foundations. In this paper, we argue that a single unified theory can be used for both correctness and incorrectness reasoning. We present Outcome Logic (OL), a novel generalization of Hoare Logic that is both monadic (to capture computational effects) and monoidal (to reason about outcomes and reachability). OL expresses true positive bugs, while retaining correctness reasoning abilities as well. To formalize the applicability of OL to both correctness and incorrectness, we prove that any false OL specification can be disproven in OL itself. We also use our framework to reason about new types of incorrectness in nondeterministic and probabilistic programs. Given these advances, we advocate for OL as a new foundational theory of correctness and incorrectness.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586045", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Noam", + "last_name": "Zilberstein", + "institution": "Cornell University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/ZilbersteinDS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586055", + "title": "Improving Oracle-Guided Inductive Synthesis by Efficient Question Selection", + "abstract": "Oracle-guided inductive synthesis (OGIS) is a widely-used framework to apply program synthesis techniques in practice. The question selection problem aims at reducing the number of iterations in OGIS by selecting a proper input for each OGIS iteration. Theoretically, a question selector can generally improve the performance of OGIS solvers on both interactive and non-interactive tasks if it is not only effective for reducing iterations but also efficient. However, all existing effective question selectors fail in satisfying the requirement of efficiency. To ensure effectiveness, they convert the question selection problem into an optimization one, which is difficult to solve within a short time. In this paper, we propose a novel question selector, named LearnSy . LearnSy is both efficient and effective and thus achieves general improvement for OGIS solvers for the first time. Since we notice that the optimization tasks in previous studies are difficult because of the complex behavior of operators, we estimate these behaviors in LearnSy as simple random events. Subsequently, we provide theoretical results for the precision of this estimation and design an efficient algorithm for its calculation. According to our evaluation, when dealing with interactive tasks, LearnSy can offer competitive performance compared to existing selectors while being more efficient and more general. Moreover, when working on non-interactive tasks, LearnSy can generally reduce the time cost of existing CEGIS solvers by up to 43.0%.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586055", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ruyi", + "last_name": "Ji", + "institution": "Peking University" + }, + { + "first_name": "Chaozhe", + "last_name": "Kong", + "institution": "Peking University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/JiKXH23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586050", + "title": "Exact Recursive Probabilistic Programming", + "abstract": "Recursive calls over recursive data are useful for generating probability distributions, and probabilistic programming allows computations over these distributions to be expressed in a modular and intuitive way. Exact inference is also useful, but unfortunately, existing probabilistic programming languages do not perform exact inference on recursive calls over recursive data, forcing programmers to code many applications manually. We introduce a probabilistic language in which a wide variety of recursion can be expressed naturally, and inference carried out exactly. For instance, probabilistic pushdown automata and their generalizations are easy to express, and polynomial-time parsing algorithms for them are derived automatically. We eliminate recursive data types using program transformations related to defunctionalization and refunctionalization. These transformations are assured correct by a linear type system, and a successful choice of transformations, if there is one, is guaranteed to be found by a greedy algorithm.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586050", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David", + "last_name": "Chiang", + "institution": "University of Notre Dame" + }, + { + "first_name": "Colin", + "last_name": "McDonald", + "institution": "University of Notre Dame" + }, + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Indiana University" + } + ], + "dblp_key": "journals/pacmpl/ChiangMS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586051", + "title": "Lower Bounds for Possibly Divergent Probabilistic Programs", + "abstract": "We present a new proof rule for verifying lower bounds on quantities of probabilistic programs. Our proof rule is not confined to almost-surely terminating programs -- as is the case for existing rules -- and can be used to establish non-trivial lower bounds on, e.g., termination probabilities and expected values, for possibly divergent probabilistic loops, e.g., the well-known three-dimensional random walk on a lattice.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586051", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shenghua", + "last_name": "Feng", + "institution": "Institute of Software" + }, + { + "first_name": "Mingshuai", + "last_name": "Chen", + "institution": "Zhejiang University" + }, + { + "first_name": "Han", + "last_name": "Su", + "institution": "Institute of Software" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Naijun", + "last_name": "Zhan", + "institution": "Institute of Software" + } + ], + "dblp_key": "journals/pacmpl/FengCSKKZ23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586047", + "title": "Automated Translation of Functional Big Data Queries to SQL", + "abstract": "Big data analytics frameworks like Apache Spark and Flink enable users to implement queries over large, distributed databases using functional APIs. In recent years, these APIs have grown in popularity because their functional interfaces abstract away much of the minutiae of distributed programming required by traditional query languages like SQL. However, the convenience of these APIs comes at a cost because functional queries are often less efficient than their SQL counterparts. Motivated by this observation, we present a new technique for automatically transpiling functional queries to SQL. While our approach is based on the standard paradigm of counterexample-guided inductive synthesis, it uses a novel column-wise decomposition technique to split the synthesis task into smaller subquery synthesis problems. We have implemented this approach as a new tool called RDD2SQL for translating Spark RDD queries to SQL and empirically evaluate the effectiveness of RDD2SQL on a set of real-world RDD queries. Our results show that (1) most RDD queries can be translated to SQL, (2) our tool is very effective at automating this translation, and (3) performing this translation offers significant performance benefits.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586047", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guoqiang", + "last_name": "Zhang", + "institution": "North Carolina State University" + }, + { + "first_name": "Benjamin", + "last_name": "Mariano", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/ZhangMSD23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586046", + "title": "Aliasing Limits on Translating C to Safe Rust", + "abstract": "The Rust language was created to provide safe low-level systems programming. There is both industrial and academic interest in the problem of (semi-)automatically translating C code to Rust in order to exploit Rust's safety guarantees. We study the effectiveness and limitations of existing techniques for automatically translating unsafe raw pointers (in Rust programs translated from C) into safe Rust references via ownership and lifetime inference. Our novel evaluation methodology enables our study to extend beyond prior studies, and to discover new information contradicting the conclusions of prior studies. We find that existing translation methods are severely limited by a lack of precision in the Rust compiler's safety checker, causing many safe pointer manipulations to be labeled as potentially unsafe. Leveraging this information, we propose methods for improving translation, based on encoding the results of a more precise analysis in a manner that is understandable to an unmodified Rust compiler. We implement one of our proposed methods, increasing the number of pointers that can be translated to safe Rust references by 75% over the baseline (from 12% to 21% of all pointers).", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586046", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mehmet", + "last_name": "Emre", + "institution": "University of San Francisco" + }, + { + "first_name": "Peter", + "last_name": "Boyland", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Aesha", + "last_name": "Parekh", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Ryan", + "last_name": "Schroeder", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Kyle", + "last_name": "Dewey", + "institution": "California State University, Northridge" + }, + { + "first_name": "Ben", + "last_name": "Hardekopf", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "journals/pacmpl/EmreBPSDH23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586056", + "title": "Back to Direct Style: Typed and Tight", + "abstract": "Translating programs into continuation-passing style is a well-studied tool to explicitly deal with the control structure of programs. This is useful, for example, for compilation. In a typed setting, there also is a logical interpretation of such a translation as an embedding of classical logic into intuitionistic logic. A naturally arising question is whether there is an inverse translation back to direct style. The answer to this question depends on how the continuation-passing translation is defined and on the domain of the inverse translation. In general, translating programs from continuation-passing style back to direct style requires the use of control operators to account for the use of continuations in non-trivial ways. We present two languages, one in direct style and one in continuation-passing style. Both languages are typed and equipped with an abstract machine semantics. Moreover, both languages allow for non-trivial control flow. We further present a translation to continuation-passing style and a translation back to direct style. We show that both translations are type-preserving and also preserve semantics in a very precise way giving an operational correspondence between the two languages. Moreover, we show that the compositions of the translations are well-behaved. In particular, they are syntactic one-sided inverses on the full language and full syntactic inverses when restricted to trivial control flow.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586056", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marius", + "last_name": "Müller", + "institution": "University of Tübingen" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/MullerSBO23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586048", + "title": "Live Pattern Matching with Typed Holes", + "abstract": "Several modern programming systems, including GHC Haskell, Agda, Idris, and Hazel, support typed holes . Assigning static and, to varying degree, dynamic meaning to programs with holes allows program editors and other tools to offer meaningful feedback and assistance throughout editing, i.e. in a live manner. Prior work, however, has considered only holes appearing in expressions and types. This paper considers, from type theoretic and logical first principles, the problem of typed pattern holes. We confront two main difficulties, (1) statically reasoning about exhaustiveness and irredundancy when patterns are not fully known, and (2) live evaluation of expressions containing both pattern and expression holes. In both cases, this requires reasoning conservatively about all possible hole fillings. We develop a typed lambda calculus, Peanut, where reasoning about exhaustiveness and redundancy is mapped to the problem of deriving first order entailments. We equip Peanut with an operational semantics in the style of Hazelnut Live that allows us to evaluate around holes in both expressions and patterns. We mechanize the metatheory of Peanut in Agda and formalize a procedure capable of deciding the necessary entailments. Finally, we scale up and implement these mechanisms within Hazel, a programming environment for a dialect of Elm that automatically inserts holes during editing to provide static and dynamic feedback to the programmer in a maximally live manner, i.e. for every possible editor state. Hazel is the first maximally live environment for a general-purpose functional language.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586048", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yongwei", + "last_name": "Yuan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Scott", + "last_name": "Guest", + "institution": "University of Michigan" + }, + { + "first_name": "Eric", + "last_name": "Griffis", + "institution": "University of Michigan" + }, + { + "first_name": "Hannah", + "last_name": "Potter", + "institution": "University of Washington" + }, + { + "first_name": "David A.", + "last_name": "Moon", + "institution": "University of Michigan" + }, + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/YuanGGPMO23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622797", + "title": "Hardware-Aware Static Optimization of Hyperdimensional Computations", + "abstract": "Binary spatter code (BSC)-based hyperdimensional computing (HDC) is a highly error-resilient approximate computational paradigm suited for error-prone, emerging hardware platforms. In BSC HDC, the basic datatype is a hypervector , a typically large binary vector, where the size of the hypervector has a significant impact on the fidelity and resource usage of the computation. Typically, the hypervector size is dynamically tuned to deliver the desired accuracy; this process is time-consuming and often produces hypervector sizes that lack accuracy guarantees and produce poor results when reused for very similar workloads. We present Heim, a hardware-aware static analysis and optimization framework for BSC HD computations. Heim analytically derives the minimum hypervector size that minimizes resource usage and meets the target accuracy requirement. Heim guarantees the optimized computation converges to the user-provided accuracy target on expectation, even in the presence of hardware error. Heim deploys a novel static analysis procedure that unifies theoretical results from the neuroscience community to systematically optimize HD computations. We evaluate Heim against dynamic tuning-based optimization on 25 benchmark data structures. Given a 99% accuracy requirement, Heim-optimized computations achieve a 99.2%-100.0% median accuracy, up to 49.5% higher than dynamic tuning-based optimization, while achieving 1.15x-7.14x reductions in hypervector size compared to HD computations that achieve comparable query accuracy and finding parametrizations 30.0x-100167.4x faster than dynamic tuning-based approaches. We also use Heim to systematically evaluate the performance benefits of using analog CAMs and multiple-bit-per-cell ReRAM over conventional hardware, while maintaining iso-accuracy – for both emerging technologies, we find usages where the emerging hardware imparts significant benefits.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622797", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pu", + "last_name": "Yi", + "institution": "Stanford University" + }, + { + "first_name": "Sara", + "last_name": "Achour", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/YiA23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586053", + "title": "Randomized Testing of Byzantine Fault Tolerant Algorithms", + "abstract": "Byzantine fault-tolerant algorithms promise agreement on a correct value, even if a subset of processes can deviate from the algorithm arbitrarily. While these algorithms provide strong guarantees in theory, in practice, protocol bugs and implementation mistakes may still cause them to go wrong. This paper introduces ByzzFuzz, a simple yet effective method for automatically finding errors in implementations of Byzantine fault-tolerant algorithms through randomized testing. ByzzFuzz detects fault-tolerance bugs by injecting randomly generated network and process faults into their executions. To navigate the space of possible process faults, ByzzFuzz introduces small-scope message mutations which mutate the contents of the protocol messages by applying small changes to the original message either in value (e.g., by incrementing the round number) or in time (e.g., by repeating a proposal value from a previous message). We find that small-scope mutations, combined with insights from the testing and fuzzing literature, are effective at uncovering protocol logic and implementation bugs in real-world fault-tolerant systems. We implemented ByzzFuzz and applied it to test the production implementations of two popular blockchain systems, Tendermint and Ripple, and an implementation of the seminal PBFT protocol. ByzzFuzz detected several bugs in the implementation of PBFT, a potential liveness violation in Tendermint, and materialized two theoretically described vulnerabilities in Ripple’s XRP Ledger Consensus Algorithm. Moreover, we discovered a previously unknown fault-tolerance bug in the production implementation of Ripple, which is confirmed by the developers and fixed.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586053", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Levin N.", + "last_name": "Winter", + "institution": "Delft University of Technology" + }, + { + "first_name": "Florena", + "last_name": "Buse", + "institution": "Delft University of Technology" + }, + { + "first_name": "Daan de", + "last_name": "Graaf", + "institution": "Delft University of Technology" + }, + { + "first_name": "Klaus von", + "last_name": "Gleissenthall", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Burcu Kulahcioglu", + "last_name": "Ozkan", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/WinterBGGO23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586054", + "title": "Verification-Preserving Inlining in Automatic Separation Logic Verifiers", + "abstract": "Bounded verification has proved useful to detect bugs and to increase confidence in the correctness of a program. In contrast to unbounded verification, reasoning about calls via (bounded) inlining and about loops via (bounded) unrolling does not require method specifications and loop invariants and, therefore, reduces the annotation overhead to the bare minimum, namely specifications of the properties to be verified. For verifiers based on traditional program logics, verification is preserved by inlining (and unrolling): successful unbounded verification of a program w.r.t. some annotation implies successful verification of the inlined program. That is, any error detected in the inlined program reveals a true error in the original program. However, this essential property might not hold for automatic separation logic verifiers such as Caper, GRASShopper, RefinedC, Steel, VeriFast, and verifiers based on Viper. In this setting, inlining generally changes the resources owned by method executions, which may affect automatic proof search algorithms and introduce spurious errors. In this paper, we present the first technique for verification-preserving inlining in automatic separation logic verifiers. We identify a semantic condition on programs and prove in Isabelle/HOL that it ensures verification-preserving inlining for state-of-the-art automatic separation logic verifiers. We also prove a dual result: successful verification of the inlined program ensures that there are method and loop annotations that enable the verification of the original program for bounded executions. To check our semantic condition automatically, we present two approximations that can be checked syntactically and with a program verifier, respectively. We implement these checks in Viper and demonstrate that they are effective for non-trivial examples from different verifiers.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586054", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thibault", + "last_name": "Dardinier", + "institution": "ETH Zurich" + }, + { + "first_name": "G.", + "last_name": "Parthasarathy", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/DardinierPM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586049", + "title": "Pushing the Limit of 1-Minimality of Language-Agnostic Program Reduction", + "abstract": "Program reduction has demonstrated its usefulness in facilitating debugging language implementations in practice, by minimizing bug-triggering programs. There are two categories of program reducers: language-agnostic program reducers (AGRs) and language-specific program reducers (SPRs). AGRs, such as HDD and Perses, are generally applicable to various languages; SPRs are specifically designed for one language with meticulous thoughts and significant engineering efforts, e.g., C-Reduce for reducing C/C++ programs. Program reduction is an NP-complete problem: finding the globally minimal program is usually infeasible. Thus all existing program reducers resort to producing 1-minimal results, a special type of local minima. However, 1-minimality can still be large and contain excessive bug-irrelevant program elements. This is especially the case for AGR-produced results because of the generic reduction algorithms used in AGRs. An SPR often yields smaller results than AGRs for the language for which the SPR has customized reduction algorithms. But SPRs are not language-agnostic, and implementing a new SPR for a different language requires significant engineering efforts. This paper proposes Vulcan, a language-agnostic framework to further minimize AGRs-produced results by exploiting the formal syntax of the language to perform aggressive program transformations, in hope of creating reduction opportunities for other reduction algorithms to progress or even directly deleting bugirrelevant elements from the results. Our key insights are two-fold. First, the program transformations in all existing program reducers including SPRs are not diverse enough, which traps these program reducers early in 1-minimality. Second, compared with the original program, the results of AGRs are much smaller, and time-wise it is affordable to perform diverse program transformations that change programs but do not necessarily reduce the sizes of the programs directly. Within the Vulcan framework, we proposed three simple examples of fine-grained program transformations to demonstrate that Vulcan can indeed further push the 1-minimality of AGRs. By performing these program transformations, a 1-minimal program might become a non-1-minimal one that can be further reduced later. Our extensive evaluations on multilingual benchmarks including C, Rust and SMT-LIBv2 programs strongly demonstrate the effectiveness and generality of Vulcan. Vulcan outperforms the state-of-the-art language-agnostic program reducer Perses in size in all benchmarks: On average, the result of Vulcan contains 33.55%, 21.61%, and 31.34% fewer tokens than that of Perses on C, Rust, and SMT-LIBv2 subjects respectively. Vulcan can produce even smaller results if more reduction time is allocated. Moreover, for the C programs that are reduced by C-Reduce, Vulcan is even able to further minimize them by 10.07%.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586049", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhenyang", + "last_name": "Xu", + "institution": "University of Waterloo" + }, + { + "first_name": "Yongqiang", + "last_name": "Tian", + "institution": "University of Waterloo" + }, + { + "first_name": "Mengxiao", + "last_name": "Zhang", + "institution": "University of Waterloo" + }, + { + "first_name": "Gaosen", + "last_name": "Zhao", + "institution": "University of Waterloo" + }, + { + "first_name": "Yu", + "last_name": "Jiang", + "institution": "Tsinghua University" + }, + { + "first_name": "C. P.", + "last_name": "Sun", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/XuTZZJS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3586052", + "title": "Algebro-geometric Algorithms for Template-Based Synthesis of Polynomial Programs", + "abstract": "Template-based synthesis, also known as sketching, is a localized approach to program synthesis in which the programmer provides not only a specification, but also a high-level \"sketch\" of the program. The sketch is basically a partial program that models the general intuition of the programmer, while leaving the low-level details as unimplemented \"holes\". The role of the synthesis engine is then to fill in these holes such that the completed program satisfies the desired specification. In this work, we focus on template-based synthesis of polynomial imperative programs with real variables, i.e. imperative programs in which all expressions appearing in assignments, conditions and guards are polynomials over program variables. While this problem can be solved in a sound and complete manner by a reduction to the first-order theory of the reals, the resulting formulas will contain a quantifier alternation and are extremely hard for modern SMT solvers, even when considering toy programs with a handful of lines. Moreover, the classical algorithms for quantifier elimination are notoriously unscalable and not at all applicable to this use-case. In contrast, our main contribution is an algorithm, based on several well-known theorems in polyhedral and real algebraic geometry, namely Putinar's Positivstellensatz, the Real Nullstellensatz, Handelman's Theorem and Farkas' Lemma, which sidesteps the quantifier elimination difficulty and reduces the problem directly to Quadratic Programming (QP). Alternatively, one can view our algorithm as an efficient way of eliminating quantifiers in the particular formulas that appear in the synthesis problem. The resulting QP instances can then be handled quite easily by SMT solvers. Notably, our reduction to QP is sound and semi-complete, i.e. it is complete if polynomials of a sufficiently high degree are used in the templates. Thus, we provide the first method for sketching-based synthesis of polynomial programs that does not sacrifice completeness, while being scalable enough to handle meaningful programs. Finally, we provide experimental results over a variety of examples from the literature.", + "date": "2023-04-06", + "link": "https://doi.org/10.1145/3586052", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "S.", + "last_name": "Hitarth", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Fatemeh", + "last_name": "Mohammadi", + "institution": "KU Leuven" + }, + { + "first_name": "Harshit J.", + "last_name": "Motwani", + "institution": "Ghent University Hospital" + } + ], + "dblp_key": "journals/pacmpl/GoharshadyHMM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622798", + "title": "Leaf: Modularity for Temporary Sharing in Separation Logic", + "abstract": "In concurrent verification, separation logic provides a strong story for handling both resources that are owned exclusively and resources that are shared persistently (i.e., forever). However, the situation is more complicated for temporarily shared state, where state might be shared and then later reclaimed as exclusive. We believe that a framework for temporarily-shared state should meet two key goals not adequately met by existing techniques. One, it should allow and encourage users to verify new sharing strategies. Two, it should provide an abstraction where users manipulate shared state in a way agnostic to the means with which it is shared. We present Leaf, a library in the Iris separation logic which accomplishes both of these goals by introducing a novel operator, which we call guarding, that allows one proposition to represent a shared version of another. We demonstrate that Leaf meets these two goals through a modular case study: we verify a reader-writer lock that supports shared state, and a hash table built on top of it that uses shared state.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622798", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Travis", + "last_name": "Hance", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jon", + "last_name": "Howell", + "institution": "Bellevue Hospital Center" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "" + }, + { + "first_name": "Bryan", + "last_name": "Parno", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/HanceHPP23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622800", + "title": "Synthesizing Efficient Memoization Algorithms", + "abstract": "In this paper, we propose an automated approach to finding correct and efficient memoization algorithms from a given declarative specification. This problem has two major challenges: (i) a memoization algorithm is too large to be handled by conventional program synthesizers; (ii) we need to guarantee the efficiency of the memoization algorithm. To address this challenge, we structure the synthesis of memoization algorithms by introducing the local objective function and the memoization partition function and reduce the synthesis task to two smaller independent program synthesis tasks. Moreover, the number of distinct outputs of the function synthesized in the second synthesis task also decides the efficiency of the synthesized memoization algorithm, and we only need to minimize the number of different output values of the synthesized function. However, the generated synthesis task is still too complex for existing synthesizers. Thus, we propose a novel synthesis algorithm that combines the deductive and inductive methods to solve these tasks. To evaluate our algorithm, we collect 42 real-world benchmarks from Leetcode, the National Olympiad in Informatics in Provinces-Junior (a national-wide algorithmic programming contest in China), and previous approaches. Our approach successfully synhesizes 39/42 problems in a reasonable time, outperforming the baselines.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622800", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yican", + "last_name": "Sun", + "institution": "Peking University" + }, + { + "first_name": "Xiaosong", + "last_name": "Peng", + "institution": "Peking University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/SunPX23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622799", + "title": "Formally Verifying Optimizations with Block Simulations", + "abstract": "CompCert (ACM Software System Award 2021) is the first industrial-strength compiler with a mechanically checked proof of correctness. Yet, CompCert remains a moderately optimizing C compiler. Indeed, some optimizations of “gcc ‍-O1” such as Lazy Code Motion (LCM) or Strength Reduction (SR) were still missing: developing these efficient optimizations together with their formal proofs remained a challenge. Cyril Six et al. have developed efficient formally verified translation validators for certifying the results of superblock schedulers and peephole optimizations. We revisit and generalize their approach into a framework (integrated into CompCert) able to validate many more optimizations: an enhanced superblock scheduler, but also Dead Code Elimination (DCE), Constant Propagation (CP), and more noticeably, LCM and SR. In contrast to other approaches to translation validation, we co-design our untrusted optimizations and their validators. Our optimizations provide hints, in the forms of invariants or CFG morphisms , that help keep the formally verified validators both simple and efficient. Such designs seem applicable beyond CompCert.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622799", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Léo", + "last_name": "Gourdin", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Benjamin", + "last_name": "Bonneau", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Sylvain", + "last_name": "Boulmé", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "David", + "last_name": "Monniaux", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Alexandre", + "last_name": "Bérard", + "institution": "Institut polytechnique de Grenoble" + } + ], + "dblp_key": "journals/pacmpl/GourdinBBMB23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622801", + "title": "AtomiS: Data-Centric Synchronization Made Practical", + "abstract": "Data-Centric Synchronization (DCS) shifts the reasoning about concurrency restrictions from control structures to data declaration. It is a high-level declarative approach that abstracts away from the actual concurrency control mechanism(s) in use. Despite its advantages, the practical use of DCS is hindered by the fact that it may require many annotations and/or multiple implementations of the same method to cope with differently qualified parameters. To overcome these limitations, in this paper we present AtomiS, a new DCS approach that requires only qualifying types of parameters and return values in interface definitions, and of fields in class definitions. The latter may also be abstracted away in type parameters, rendering class implementations virtually annotation-free. From this high level specification, a static analysis infers the atomicity constraints that are local to each method, considering valid only the method variants that are consistent with the specification, and performs code generation for all valid variants of each method. The generated code is then the target for automatic injection of concurrency control primitives that are responsible for ensuring the absence of data-races, atomicity-violations and deadlocks. We provide a Java implementation and showcase the applicability of AtomiS in real-life code. For the benchmarks analysed, AtomiS requires fewer annotations than the original number of regions requiring locks, as well as fewer annotations than Atomic Sets (a reference DCS proposal).", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622801", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hervé", + "last_name": "Paulino", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Ana Almeida", + "last_name": "Matos", + "institution": "University of Lisbon" + }, + { + "first_name": "Jan", + "last_name": "Cederquist", + "institution": "University of Lisbon" + }, + { + "first_name": "Marco", + "last_name": "Giunti", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "João", + "last_name": "Matos", + "institution": "University of Lisbon" + }, + { + "first_name": "António", + "last_name": "Ravara", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "journals/pacmpl/PaulinoMCGMR23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622805", + "title": "The Essence of Verilog: A Tractable and Tested Operational Semantics for Verilog", + "abstract": "With the increasing need to apply modern software techniques to hardware design, Verilog, the most popular Hardware Description Language (HDL), plays an infrastructure role. However, Verilog has several semantic pitfalls that often confuse software and hardware developers. Although prior research on formal semantics for Verilog exists, it is not comprehensive and has not fully addressed these issues. In this work, we present a novel scheme inspired by previous work on defining core languages for software languages like JavaScript and Python. Specifically, we define the formal semantics of Verilog using a core language called λ V , which captures the essence of Verilog using as few language structures as possible. λ V not only covers the most complete set of language features to date, but also addresses the aforementioned pitfalls. We implemented λ V with about 27,000 lines of Java code, and comprehensively tested its totality and conformance with Verilog. As a reliable reference semantics, λ V can detect semantic bugs in real-world Verilog simulators and expose ambiguities in Verilog’s standard specification. Moreover, as a useful core language, λ V has the potential to facilitate the development of tools such as a state-space explorer and a concolic execution tool for Verilog.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622805", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Q.", + "last_name": "Chen", + "institution": "Nanjing University" + }, + { + "first_name": "N.", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Jinpeng", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "Nanjing University" + }, + { + "first_name": "Chang", + "last_name": "Xu", + "institution": "Nanjing University" + }, + { + "first_name": "Xiaoxing", + "last_name": "Ma", + "institution": "Nanjing University" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/ChenZWTXML23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622804", + "title": "Compiling Structured Tensor Algebra", + "abstract": "Tensor algebra is essential for data-intensive workloads in various computational domains. Computational scientists face a trade-off between the specialization degree provided by dense tensor algebra and the algorithmic efficiency that leverages the structure provided by sparse tensors. This paper presents StructTensor, a framework that symbolically computes structure at compilation time. This is enabled by Structured Tensor Unified Representation (STUR), an intermediate language that can capture tensor computations as well as their sparsity and redundancy structures. Through a mathematical view of lossless tensor computations, we show that our symbolic structure computation and the related optimizations are sound. Finally, for different tensor computation workloads and structures, we experimentally show how capturing the symbolic structure can result in outperforming state-of-the-art frameworks for both dense and sparse tensor algebra.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622804", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mahdi", + "last_name": "Ghorbani", + "institution": "University of Edinburgh" + }, + { + "first_name": "Mathieu", + "last_name": "Huot", + "institution": "University of Oxford" + }, + { + "first_name": "Shideh", + "last_name": "Hashemian", + "institution": "University of Edinburgh" + }, + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/GhorbaniHHS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622807", + "title": "The Bounded Pathwidth of Control-Flow Graphs", + "abstract": "Pathwidth and treewidth are standard and well-studied graph sparsity parameters which intuitively model the degree to which a given graph resembles a path or a tree, respectively. It is well-known that the control-flow graphs of structured goto-free programs have a tree-like shape and bounded treewidth. This fact has been exploited to design considerably more efficient algorithms for a wide variety of static analysis and compiler optimization problems, such as register allocation, µ-calculus model-checking and parity games, data-flow analysis, cache management, and liftetime-optimal redundancy elimination. However, there is no bound in the literature for the pathwidth of programs, except the general inequality that the pathwidth of a graph is at most O (lg n ) times its treewidth, where n is the number of vertices of the graph. In this work, we prove that control-flow graphs of structured programs have bounded pathwidth and provide a linear-time algorithm to obtain a path decomposition of small width. Specifically, we establish a bound of 2 · d on the pathwidth of programs with nesting depth d . Since real-world programs have small nesting depth, they also have bounded pathwidth. This is significant for a number of reasons: (i) ‍pathwidth is a strictly stronger parameter than treewidth, i.e. ‍any graph family with bounded pathwidth has bounded treewidth, but the converse does not hold; (ii) ‍any algorithm that is designed with treewidth in mind can be applied to bounded-pathwidth graphs with no change; (iii) ‍there are problems that are fixed-parameter tractable with respect to pathwidth but not treewidth; (iv) ‍verification algorithms that are designed based on treewidth would become significantly faster when using pathwidth as the parameter; and (v) ‍it is easier to design algorithms based on bounded pathwidth since one does not have to consider the often-challenging case of merge nodes in treewidth-based dynamic programming. Thus, we invite the static analysis and compiler optimization communities to adopt pathwidth as their parameter of choice instead of, or in addition to, treewidth. Intuitively, control-flow graphs are not only tree-like, but also path-like and one can obtain simpler and more scalable algorithms by relying on path-likeness instead of tree-likeness. As a motivating example, we provide a simpler and more efficient algorithm for spill-free register allocation using bounded pathwidth instead of treewidth. Our algorithm reduces the runtime from O ( n · r 2 · tw · r + 2 · r ) to O ( n · pw · r pw · r + r + 1 ), where n is the number of lines of code, r is the number of registers, pw is the pathwidth of the control-flow graph and tw is its treewidth. We provide extensive experimental results showing that our approach is applicable to a wide variety of real-world embedded benchmarks from SDCC and obtains runtime improvements of 2-3 orders of magnitude. This is because the pathwidth is equal to the treewidth, or one more, in the overwhelming majority of real-world CFGs and thus our algorithm provides an exponential runtime improvement. As such, the benefits of using pathwidth are not limited to the theoretical side and simplicity in algorithm design, but are also apparent in practice.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622807", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Giovanna Kobus", + "last_name": "Conrado", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Chun Kit", + "last_name": "Lam", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ConradoGL23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622808", + "title": "AST vs. Bytecode: Interpreters in the Age of Meta-Compilation", + "abstract": "Thanks to partial evaluation and meta-tracing, it became practical to build language implementations that reach state-of-the-art peak performance by implementing only an interpreter. Systems such as RPython and GraalVM provide components such as a garbage collector and just-in-time compiler in a language-agnostic manner, greatly reducing implementation effort. However, meta-compilation-based language implementations still need to improve further to reach the low memory use and fast warmup behavior that custom-built systems provide. A key element in this endeavor is interpreter performance. Folklore tells us that bytecode interpreters are superior to abstract-syntax-tree (AST) interpreters both in terms of memory use and run-time performance. This work assesses the trade-offs between AST and bytecode interpreters to verify common assumptions and whether they hold in the context of meta-compilation systems. We implemented four interpreters, each an AST and a bytecode one using RPython and GraalVM. We keep the difference between the interpreters as small as feasible to be able to evaluate interpreter performance, peak performance, warmup, memory use, and the impact of individual optimizations. Our results show that both systems indeed reach performance close to Node.js/V8. Looking at interpreter-only performance, our AST interpreters are on par with, or even slightly faster than their bytecode counterparts. After just-in-time compilation, the results are roughly on par. This means bytecode interpreters do not have their widely assumed performance advantage. However, we can confirm that bytecodes are more compact in memory than ASTs, which becomes relevant for larger applications. However, for smaller applications, we noticed that bytecode interpreters allocate more memory because boxing avoidance is not as applicable, and because the bytecode interpreter structure requires memory, e.g., for a reified stack. Our results show AST interpreters to be competitive on top of meta-compilation systems. Together with possible engineering benefits, they should thus not be discounted so easily in favor of bytecode interpreters.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622808", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Octave", + "last_name": "Larose", + "institution": "University of Kent" + }, + { + "first_name": "Sophie", + "last_name": "Kaleba", + "institution": "University of Kent" + }, + { + "first_name": "Humphrey", + "last_name": "Burchell", + "institution": "University of Kent" + }, + { + "first_name": "Stefan", + "last_name": "Marr", + "institution": "University of Kent" + } + ], + "dblp_key": "journals/pacmpl/LaroseKBM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622802", + "title": "Secure RDTs: Enforcing Access Control Policies for Offline Available JSON Data", + "abstract": "Replicated Data Types (RDTs) are a type of data structure that can be replicated over a network, where each replica can be kept (eventually) consistent with the other replicas. They are used in applications with intermittent network connectivity, since local (offline) edits can later be merged with the other replicas. Applications that want to use RDTs often have an inherent security component that restricts data access for certain clients. However, access control for RDTs is difficult to enforce for clients that are not running within a secure environment, e.g., web applications where the client-side software can be freely tampered with. In essence, an application cannot prevent a client from reading data which they are not supposed to read, and any malicious changes will also affect well-behaved clients. This paper proposes Secure RDTs (SRDTs), a data type that specifies role-based access control for offline-available JSON data. In brief, a trusted application server specifies a security policy based on roles with read and write privileges for certain fields of an SRDT. The server enforces read privileges by projecting the data and security policy to omit any non-readable fields for the user's given role, and it acts as an intermediary to enforce write privileges. The approach is presented as an operational semantics engineered in PLT Redex, which is validated by formal proofs and randomised testing in Redex to ensure that the formal specification is secure.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622802", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thierry", + "last_name": "Renaux", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Sam Van den", + "last_name": "Vonder", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Wolfgang De", + "last_name": "Meuter", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "journals/pacmpl/RenauxVM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622803", + "title": "Beacons: An End-to-End Compiler Framework for Predicting and Utilizing Dynamic Loop Characteristics", + "abstract": "Efficient management of shared resources is a critical problem in high-performance computing (HPC) environments. Existing workload management systems often promote non-sharing of resources among different co-executing applications to achieve performance isolation. Such schemes lead to poor resource utilization and suboptimal process throughput, adversely affecting user productivity. Tackling this problem in a scalable fashion is extremely challenging, since it requires the workload scheduler to possess an in-depth knowledge about various application resource requirements and runtime phases at fine granularities within individual applications. In this work, we show that applications’ resource requirements and execution phase behaviour can be captured in a scalable and lightweight manner at runtime by estimating important program artifacts termed as “ dynamic loop characteristics ”. Specifically, we propose a solution to the problem of efficient workload scheduling by designing a compiler and runtime cooperative framework that leverages novel loop-based compiler analysis for resource allocation . We present Beacons Framework , an end-to-end compiler and scheduling framework, that estimates dynamic loop characteristics, encapsulates them in compiler-instrumented beacons in an application, and broadcasts them during application runtime, for proactive workload scheduling. We focus on estimating four important loop characteristics : loop trip-count , loop timing , loop memory footprint , and loop data-reuse behaviour , through a combination of compiler analysis and machine learning. The novelty of the Beacons Framework also lies in its ability to tackle irregular loops that exhibit complex control flow with indeterminate loop bounds involving structure fields, aliased variables and function calls , which are highly prevalent in modern workloads. At the backend, Beacons Framework entails a proactive workload scheduler that leverages the runtime information to orchestrate aggressive process co-locations, for maximizing resource concurrency, without causing cache thrashing . Our results show that Beacons Framework can predict different loop characteristics with an accuracy of 85% to 95% on average, and the proactive scheduler obtains an average throughput improvement of 1.9x (up to 3.2x ) over the state-of-the-art schedulers on an Amazon Graviton2 machine on consolidated workloads involving 1000-10000 co-executing processes, across 51 benchmarks.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622803", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Girish", + "last_name": "Mururu", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Sharjeel", + "last_name": "Khan", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Bodhisatwa", + "last_name": "Chatterjee", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Chao", + "last_name": "Chen", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Chris", + "last_name": "Porter", + "institution": "IBM (United States)" + }, + { + "first_name": "Ada", + "last_name": "Gavrilovska", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Santosh", + "last_name": "Pande", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/MururuKCCPGP23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622806", + "title": "Run-Time Prevention of Software Integration Failures of Machine Learning APIs", + "abstract": "Due to the under-specified interfaces, developers face challenges in correctly integrating machine learning (ML) APIs in software. Even when the ML API and the software are well designed on their own, the resulting application misbehaves when the API output is incompatible with the software. It is desirable to have an adapter that converts ML API output at runtime to better fit the software need and prevent integration failures. In this paper, we conduct an empirical study to understand ML API integration problems in real-world applications. Guided by this study, we present SmartGear, a tool that automatically detects and converts mismatching or incorrect ML API output at run time, serving as a middle layer between ML API and software. Our evaluation on a variety of open-source applications shows that SmartGear detects 70% incompatible API outputs and prevents 67% potential integration failures, outperforming alternative solutions.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622806", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chengcheng", + "last_name": "Wan", + "institution": "East China Normal University" + }, + { + "first_name": "Yuhan", + "last_name": "Liu", + "institution": "University of Chicago" + }, + { + "first_name": "Kuntai", + "last_name": "Du", + "institution": "University of Chicago" + }, + { + "first_name": "Henry", + "last_name": "Hoffmann", + "institution": "University of Chicago" + }, + { + "first_name": "Junchen", + "last_name": "Jiang", + "institution": "University of Chicago" + }, + { + "first_name": "Michael", + "last_name": "Maire", + "institution": "University of Chicago" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/WanLDHJML23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622809", + "title": "Mutually Iso-Recursive Subtyping", + "abstract": "Iso-recursive types are often taken as a type-theoretic model for type recursion as present in many programming languages, e.g., classes in object-oriented languages or algebraic datatypes in functional languages. Their main advantage over an equi-recursive semantics is that they are simpler and algorithmically less expensive, which is an important consideration when the cost of type checking matters, such as for intermediate or low-level code representations, virtual machines, or runtime casts. However, a closer look reveals that iso-recursion cannot, in its standard form, efficiently express essential type system features like mutual recursion or non-uniform recursion. While it has been folklore that mutual recursion and non-uniform type parameterisation can nicely be handled by generalising to higher kinds, this encoding breaks down when combined with subtyping: the classic “Amber” rule for subtyping iso-recursive types is too weak to express mutual recursion without falling back to encodings of quadratic size. We present a foundational core calculus of iso-recursive types with declared subtyping that can express both inter- and intra-recursion subtyping without such blowup, including subtyping between constructors of higher or mixed kind. In a second step, we identify a syntactic fragment of this general calculus that allows for more efficient type checking without “deep” substitutions, by observing that higher-kinded iso-recursive types can be inserted to “guard” against unwanted β-reductions. This fragment closely resembles the structure of typical nominal subtype systems, but without requiring nominal semantics. It has been used as the basis for a proposed extension of WebAssembly with recursive types.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622809", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/Rossberg23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622812", + "title": "Getting into the Flow: Towards Better Type Error Messages for Constraint-Based Type Inference", + "abstract": "Creating good type error messages for constraint-based type inference systems is difficult. Typical type error messages reflect implementation details of the underlying constraint-solving algorithms rather than the specific factors leading to type mismatches. We propose using subtyping constraints that capture data flow to classify and explain type errors. Our algorithm explains type errors as faulty data flows, which programmers are already used to reasoning about, and illustrates these data flows as sequences of relevant program locations. We show that our ideas and algorithm are not limited to languages with subtyping, as they can be readily integrated with Hindley-Milner type inference. In addition to these core contributions, we present the results of a user study to evaluate the quality of our messages compared to other implementations. While the quantitative evaluation does not show that flow-based messages improve the localization or understanding of the causes of type errors, the qualitative evaluation suggests a real need and demand for flow-based messages.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622812", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ishan", + "last_name": "Bhanuka", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "David A.", + "last_name": "Binder", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/BhanukaPBB23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622810", + "title": "Mechanizing Session-Types using a Structural View: Enforcing Linearity without Linearity", + "abstract": "Session types employ a linear type system that ensures that communication channels cannot be implicitly copied or discarded. As a result, many mechanizations of these systems require modeling channel contexts and carefully ensuring that they treat channels linearly. We demonstrate a technique that localizes linearity conditions as additional predicates embedded within type judgments, which allows us to use structural typing contexts instead of linear ones. This technique is especially relevant when leveraging (weak) higher-order abstract syntax to handle channel mobility and the intricate binding structures that arise in session-typed systems. Following this approach, we mechanize a session-typed system based on classical linear logic and its type preservation proof in the proof assistant Beluga, which uses the logical framework LF as its encoding language. We also prove adequacy for our encoding. This shows the tractability and effectiveness of our approach in modelling substructural systems such as session-typed languages.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622810", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chuta", + "last_name": "Sano", + "institution": "McGill University" + }, + { + "first_name": "Ryan", + "last_name": "Kavanagh", + "institution": "McGill University" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "journals/pacmpl/SanoKP23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622813", + "title": "Graph IRs for Impure Higher-Order Languages: Making Aggressive Optimizations Affordable with Precise Effect Dependencies", + "abstract": "Graph-based intermediate representations (IRs) are widely used for powerful compiler optimizations, either interprocedurally in pure functional languages, or intraprocedurally in imperative languages. Yet so far, no suitable graph IR exists for aggressive global optimizations in languages with both effects and higher-order functions: aliasing and indirect control transfers make it difficult to maintain sufficiently granular dependency information for optimizations to be effective. To close this long-standing gap, we propose a novel typed graph IR combining a notion of reachability types with an expressive effect system to compute precise and granular effect dependencies at an affordable cost while supporting local reasoning and separate compilation. Our high-level graph IR imposes lexical structure to represent structured control flow and nesting, enabling aggressive and yet inexpensive code motion and other optimizations for impure higher-order programs. We formalize the new graph IR based on a λ-calculus with a reachability type-and-effect system along with a specification of various optimizations. We present performance case studies for tensor loop fusion, CUDA kernel fusion, symbolic execution of LLVM IR, and SQL query compilation in the Scala LMS compiler framework using the new graph IR. We observe significant speedups of up to 21 x .", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622813", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Songlin", + "last_name": "Jia", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Supun", + "last_name": "Abeysinghe", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yuxuan", + "last_name": "Jiang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yuyan", + "last_name": "Bao", + "institution": "Augusta University" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/BracevacWJAJBR23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622814", + "title": "Continuing WebAssembly with Effect Handlers", + "abstract": "WebAssembly (Wasm) is a low-level portable code format offering near native performance. It is intended as a compilation target for a wide variety of source languages. However, Wasm provides no direct support for non-local control flow features such as async/await, generators/iterators, lightweight threads, first-class continuations, etc. This means that compilers for source languages with such features must ceremoniously transform whole source programs in order to target Wasm. We present WasmFX an extension to Wasm which provides a universal target for non-local control features via effect handlers, enabling compilers to translate such features directly into Wasm. Our extension is minimal and only adds three main instructions for creating, suspending, and resuming continuations. Moreover, our primitive instructions are type-safe providing typed continuations which are well-aligned with the design principles of Wasm whose stacks are typed. We present a formal specification of WasmFX and show that the extension is sound. We have implemented WasmFX as an extension to the Wasm reference interpreter and also built a prototype WasmFX extension for Wasmtime, a production-grade Wasm engine, piggybacking on Wasmtime's existing fibers API. The preliminary performance results for our prototype are encouraging, and we outline future plans to realise a native implementation.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622814", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luna", + "last_name": "Phipps-Costin", + "institution": "Northeastern University" + }, + { + "first_name": "Andreas", + "last_name": "Rossberg", + "institution": "" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "Boston University" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Daniel", + "last_name": "Hillerström", + "institution": "" + }, + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Matija", + "last_name": "Pretnar", + "institution": "University of Ljubljana" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/PhippsCostinRGLHSPL23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622815", + "title": "Two Birds with One Stone: Boosting Code Generation and Code Search via a Generative Adversarial Network", + "abstract": "Automatically transforming developers' natural language descriptions into source code has been a longstanding goal in software engineering research. Two types of approaches have been proposed in the literature to achieve this: code generation, which involves generating a new code snippet, and code search, which involves reusing existing code. However, despite existing efforts, the effectiveness of the state-of-the-art techniques remains limited. To seek for further advancement, our insight is that code generation and code search can help overcome the limitation of each other: the code generator can benefit from feedback on the quality of its generated code, which can be provided by the code searcher, while the code searcher can benefit from the additional training data augmented by the code generator to better understand code semantics. Drawing on this insight, we propose a novel approach that combines code generation and code search techniques using a generative adversarial network (GAN), enabling mutual improvement through the adversarial training. Specifically, we treat code generation and code search as the generator and discriminator in the GAN framework, respectively, and incorporate several customized designs for our tasks. We evaluate our approach in eight different settings, and consistently observe significant performance improvements for both code generation and code search. For instance, when using NatGen, a state-of-the-art code generator, as the generator and GraphCodeBERT, a state-of-the-art code searcher, as the discriminator, we achieve a 32% increase in CodeBLEU score for code generation, and a 12% increase in mean reciprocal rank for code search on a large-scale Python dataset, compared to their original performances.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622815", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shangwen", + "last_name": "Wang", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Bo", + "last_name": "Lin", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Zhensu", + "last_name": "Sun", + "institution": "Singapore Management University" + }, + { + "first_name": "Ming", + "last_name": "Wen", + "institution": "Huazhong University of Science and Technology" + }, + { + "first_name": "Yepang", + "last_name": "Liu", + "institution": "Southern University of Science and Technology" + }, + { + "first_name": "Yan", + "last_name": "Lei", + "institution": "Chongqing University" + }, + { + "first_name": "Xiaoguang", + "last_name": "Mao", + "institution": "National University of Defense Technology" + } + ], + "dblp_key": "journals/pacmpl/WangLSWLLM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622816", + "title": "Fast and Efficient Boolean Unification for Hindley-Milner-Style Type and Effect Systems", + "abstract": "As type and effect systems become more expressive there is an increasing need for efficient type inference. We consider a polymorphic effect system based on Boolean formulas where inference requires Boolean unification. Since Boolean unification involves semantic equivalence, conventional syntax-driven unification is insufficient. At the same time, existing Boolean unification techniques are ill-suited for type inference. We propose a hybrid algorithm for solving Boolean unification queries based on Boole’s Successive Variable Elimination (SVE) algorithm. The proposed approach builds on several key observations regarding the Boolean unification queries encountered in practice, including: (i) most queries are simple, (ii) most queries involve a few flexible variables, (iii) queries are likely to repeat due similar programming patterns, and (iv) there is a long tail of complex queries. We exploit these observations to implement several strategies for formula minimization, including ones based on tabling and binary decision diagrams. We implement the new hybrid approach in the Flix programming language. Experimental results show that by reducing the overhead of Boolean unification, the compilation throughput increases from 8,580 lines/sec to 15,917 lines/sec corresponding to a 1.8x speed-up. Further, the overhead on type and effect inference time is only 16% which corresponds to an overhead of less than 7% on total compilation time. We study the hybrid approach and demonstrate that each design choice improves performance.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622816", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Jaco van de", + "last_name": "Pol", + "institution": "Aarhus University" + }, + { + "first_name": "Troels", + "last_name": "Henriksen", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/MadsenPH23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622817", + "title": "How Profilers Can Help Navigate Type Migration", + "abstract": "Sound migratory typing envisions a safe and smooth refactoring of untyped code bases to typed ones. However, the cost of enforcing safety with run-time checks is often prohibitively high, thus performance regressions are a likely occurrence. Additional types can often recover performance, but choosing the right components to type is difficult because of the exponential size of the migratory typing lattice. In principal though, migration could be guided by off-the-shelf profiling tools. To examine this hypothesis, this paper follows the rational programmer method and reports on the results of an experiment on tens of thousands of performance-debugging scenarios via seventeen strategies for turning profiler output into an actionable next step. The most effective strategy is the use of deep types to eliminate the most costly boundaries between typed and untyped components; this strategy succeeds in more than 50% of scenarios if two performance degradations are tolerable along the way.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622817", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "University of Utah" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Northeastern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/GreenmanFD23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622818", + "title": "Rhombus: A New Spin on Macros without All the Parentheses", + "abstract": "Rhombus is a new language that is built on Racket. It offers the same kind of language extensibility as Racket itself, but using traditional (infix) notation. Although Rhombus is far from the first language to support Lisp-style macros without Lisp-style parentheses, Rhombus offers a novel synthesis of macro technology that is practical and expressive. A key element is the use of multiple binding spaces for context-specific sublanguages. For example, expressions and pattern-matching forms can use the same operators with different meanings and without creating conflicts. Context-sensitive bindings, in turn, facilitate a language design that reduces the notational distance between the core language and macro facilities. For example, repetitions can be defined and used in binding and expression contexts generally, which enables a smoother transition from programming to metaprogramming. Finally, since handling static information (such as types) is also a necessary part of growing macros beyond Lisp, Rhombus includes support in its expansion protocol for communicating static information among bindings and expressions. The Rhombus implementation demonstrates that all of these pieces can work together in a coherent and user-friendly language.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622818", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Taylor", + "last_name": "Allred", + "institution": "University of Utah" + }, + { + "first_name": "Nia", + "last_name": "Angle", + "institution": "Anna Needs Neuroblastoma Answers" + }, + { + "first_name": "Stephen De", + "last_name": "Gabrielle", + "institution": "" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Jack", + "last_name": "Firth", + "institution": "Anna Needs Neuroblastoma Answers" + }, + { + "first_name": "Kiran", + "last_name": "Gopinathan", + "institution": "National University of Singapore" + }, + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Brown University" + }, + { + "first_name": "Siddhartha", + "last_name": "Kasivajhula", + "institution": "Anna Needs Neuroblastoma Answers" + }, + { + "first_name": "Alex", + "last_name": "Knauth", + "institution": "Williams (United States)" + }, + { + "first_name": "Jay", + "last_name": "McCarthy", + "institution": "Realistic Education in Action Coalition to Foster Health" + }, + { + "first_name": "S W", + "last_name": "Phillips", + "institution": "Anna Needs Neuroblastoma Answers" + }, + { + "first_name": "Sorawee", + "last_name": "Porncharoenwase", + "institution": "University of Washington" + }, + { + "first_name": "Jens Axel", + "last_name": "Søgaard", + "institution": "" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "journals/pacmpl/FlattAAGFFGGKKMPPST23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622819", + "title": "Towards Better Semantics Exploration for Browser Fuzzing", + "abstract": "Web browsers exhibit rich semantics that enable a plethora of web-based functionalities. However, these intricate semantics present significant challenges for the implementation and testing of browsers. For example, fuzzing, a widely adopted testing technique, typically relies on handwritten context-free grammars (CFGs) for automatically generating inputs. However, these CFGs fall short in adequately modeling the complex semantics of browsers, resulting in generated inputs that cover only a portion of the semantics and are prone to semantic errors. In this paper, we present SaGe, an automated method that enhances browser fuzzing through the use of production-context sensitive grammars (PCSGs) incorporating semantic information. Our approach begins by extracting a rudimentary CFG from W3C standards and iteratively enhancing it to create a PCSG. The resulting PCSG enables our fuzzer to generate inputs that explore a broader range of browser semantics with a higher proportion of semantically-correct inputs. To evaluate the efficacy of SaGe, we conducted 24-hour fuzzing campaigns on mainstream browsers, including Chrome, Safari, and Firefox. Our approach demonstrated better performance compared to existing browser fuzzers, with a 6.03%-277.80% improvement in edge coverage, a 3.56%-161.71% boost in semantic correctness rate, twice the number of bugs discovered. Moreover, we identified 62 bugs across the three browsers, with 40 confirmed and 10 assigned CVEs.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622819", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chijin", + "last_name": "Zhou", + "institution": "Tsinghua University" + }, + { + "first_name": "Quan", + "last_name": "Zhang", + "institution": "Tsinghua University" + }, + { + "first_name": "Lihua", + "last_name": "Guo", + "institution": "Tsinghua University" + }, + { + "first_name": "Mingzhe", + "last_name": "Wang", + "institution": "Tsinghua University" + }, + { + "first_name": "Yu", + "last_name": "Jiang", + "institution": "Tsinghua University" + }, + { + "first_name": "Qing", + "last_name": "Liao", + "institution": "Harbin Institute of Technology" + }, + { + "first_name": "Zhiyong", + "last_name": "Wu", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Shanshan", + "last_name": "Li", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Bin", + "last_name": "Gu", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/ZhouZGWJLWLG23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622826", + "title": "An Explanation Method for Models of Code", + "abstract": "This paper introduces a novel method, called WheaCha, for explaining the predictions of code models. Similar to attribution methods, WheaCha seeks to identify input features that are responsible for a particular prediction that models make. On the other hand, it differs from attribution methods in crucial ways. Specifically, WheaCha separates an input program into \"wheat\" (i.e., defining features that are the reason for which models predict the label that they predict) and the rest \"chaff\" for any given prediction. We realize WheaCha in a tool, HuoYan, and use it to explain four prominent code models: code2vec, seq-GNN, GGNN, and CodeBERT. Results show that (1) HuoYan is efficient — taking on average under twenty seconds to compute wheat for an input program in an end-to-end fashion (i.e., including model prediction time); (2) the wheat that all models use to make predictions is predominantly comprised of simple syntactic or even lexical properties (i.e., identifier names); (3) neither the latest explainability methods for code models (i.e., SIVAND and CounterFactual Explanations) nor the most noteworthy attribution methods (i.e., Integrated Gradients and SHAP) can precisely capture wheat. Finally, we set out to demonstrate the usefulness of WheaCha, in particular, we assess if WheaCha’s explanations can help end users to identify defective code models (e.g., trained on mislabeled data or learned spurious correlations from biased data). We find that, with WheaCha, users achieve far higher accuracy in identifying faulty models than SIVAND, CounterFactual Explanations, Integrated Gradients and SHAP.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622826", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yu", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "Visa (United States)" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/WangWW23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622820", + "title": "Spirea: A Mechanized Concurrent Separation Logic for Weak Persistent Memory", + "abstract": "Weak persistent memory (a.k.a. non-volatile memory) is an emerging technology that offers fast byte-addressable durable main memory. A wealth of algorithms and libraries has been developed to explore this exciting technology. As noted by others, this has led to a significant verification gap. Towards closing this gap, we present Spirea, the first concurrent separation logic for verification of programs under a weak persistent memory model. Spirea is based on the Iris and Perennial verification frameworks, and by combining features from these logics with novel techniques it supports high-level modular reasoning about crash-safe and thread-safe programs and libraries. Spirea is fully mechanized in the Coq proof assistant and allows for interactive development of proofs with the Iris Proof Mode. We use Spirea to verify several challenging examples with modular specifications. We show how our logic can verify thread-safety and crash-safety of non-blocking durable data structures with null-recovery, in particular the Treiber stack and the Michael-Scott queue adapted to persistent memory. This is the first time durable data structures have been verified with a program logic.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622820", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Simon Friis", + "last_name": "Vindum", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/VindumB23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622823", + "title": "Melocoton: A Program Logic for Verified Interoperability Between OCaml and C", + "abstract": "In recent years, there has been tremendous progress on developing program logics for verifying the correctness of programs in a rich and diverse array of languages. Thus far, however, such logics have assumed that programs are written entirely in a single programming language. In practice, this assumption rarely holds since programs are often composed of components written in different programming languages, which interact with one another via some kind of foreign function interface (FFI). In this paper, we take the first steps towards the goal of developing program logics for multi-language verification. Specifically, we present Melocoton, a multi-language program verification system for reasoning about OCaml, C, and their interactions through the OCaml FFI. Melocoton consists of the first formal semantics of (a large subset of) the OCaml FFI—previously only described in prose in the OCaml manual—as well as the first program logic to reason about the interactions of program components written in OCaml and C. Melocoton is fully mechanized in Coq on top of the Iris separation logic framework.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622823", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Armaël", + "last_name": "Guéneau", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Johannes", + "last_name": "Hostert", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Simon", + "last_name": "Spies", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/GueneauHSSBD23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622822", + "title": "Mat2Stencil: A Modular Matrix-Based DSL for Explicit and Implicit Matrix-Free PDE Solvers on Structured Grid", + "abstract": "Partial differential equation (PDE) solvers are extensively utilized across numerous scientific and engineering fields. However, achieving high performance and scalability often necessitates intricate and low-level programming, particularly when leveraging deterministic sparsity patterns in structured grids. In this paper, we propose an innovative domain-specific language (DSL), Mat2Stencil, with its compiler, for PDE solvers on structured grids. Mat2Stencil introduces a structured sparse matrix abstraction, facilitating modular, flexible, and easy-to-use expression of solvers across a broad spectrum, encompassing components such as Jacobi or Gauss-Seidel preconditioners, incomplete LU or Cholesky decompositions, and multigrid methods built upon them. Our DSL compiler subsequently generates matrix-free code consisting of generalized stencils through multi-stage programming. The code allows spatial loop-carried dependence in the form of quasi-affine loops, in addition to the Jacobi-style stencil’s embarrassingly parallel on spatial dimensions. We further propose a novel automatic parallelization technique for the spatially dependent loops, which offers a compile-time deterministic task partitioning for threading, calculates necessary inter-thread synchronization automatically, and generates an efficient multi-threaded implementation with fine-grained synchronization. Implementing 4 benchmarking programs, 3 of them being the pseudo-applications in NAS Parallel Benchmarks with 6.3% lines of code and 1 being matrix-free High Performance Conjugate Gradients with 16.4% lines of code, we achieve up to 1.67× and on average 1.03× performance compared to manual implementations.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622822", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Huanqi", + "last_name": "Cao", + "institution": "Tsinghua University" + }, + { + "first_name": "Shizhi", + "last_name": "Tang", + "institution": "Tsinghua University" + }, + { + "first_name": "Qianchao", + "last_name": "Zhu", + "institution": "Peking University" + }, + { + "first_name": "Bowen", + "last_name": "Yu", + "institution": "Tsinghua University" + }, + { + "first_name": "Wenguang", + "last_name": "Chen", + "institution": "Peng Cheng Laboratory" + } + ], + "dblp_key": "journals/pacmpl/CaoTZYC23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622825", + "title": "Concrete Type Inference for Code Optimization using Machine Learning with SMT Solving", + "abstract": "Despite the widespread popularity of dynamically typed languages such as Python, it is well known that they pose significant challenges to code optimization due to the lack of concrete type information. To overcome this limitation, many ahead-of-time optimizing compiler approaches for Python rely on programmers to provide optional type information as a prerequisite for extensive code optimization. Since few programmers provide this information, a large majority of Python applications are executed without the benefit of code optimization, thereby contributing collectively to a significant worldwide wastage of compute and energy resources. In this paper, we introduce a new approach to concrete type inference that is shown to be effective in enabling code optimization for dynamically typed languages, without requiring the programmer to provide any type information. We explore three kinds of type inference algorithms in our approach based on: 1) machine learning models including GPT-4, 2) constraint-based inference based on SMT solving, and 3) a combination of 1) and 2). Our approach then uses the output from type inference to generate multi-version code for a bounded number of concrete type options, while also including a catch-all untyped version for the case when no match is found. The typed versions are then amenable to code optimization. Experimental results show that the combined algorithm in 3) delivers far superior precision and performance than the separate algorithms for 1) and 2). The performance improvement due to type inference, in terms of geometric mean speedup across all benchmarks compared to standard Python, when using 3) is 26.4× with Numba as an AOT optimizing back-end and 62.2× with the Intrepydd optimizing compiler as a back-end. These vast performance improvements can have a significant impact on programmers’ productivity, while also reducing their applications’ use of compute and energy resources.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622825", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fangke", + "last_name": "Ye", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Jisheng", + "last_name": "Zhao", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Jun", + "last_name": "Shirako", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/YeZSS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622824", + "title": "Interactive Debugging of Datalog Programs", + "abstract": "Datalog is used for complex programming tasks nowadays, consisting of numerous inter-dependent predicates. But Datalog lacks interactive debugging techniques that support the stepwise execution and inspection of the execution state. In this paper, we propose interactive debugging of Datalog programs following a top-down evaluation strategy called recursive query/subquery. While the recursive query/subquery approach is well-known in the literature, we are the first to provide a complete programming-language semantics based on it. Specifically, we develop the first small-step operational semantics for top-down Datalog, where subqueries occur as nested intermediate terms. The small-step semantics forms the basis of step-into interactions in the debugger. Moreover, we show how step-over interactions can be realized efficiently based on a hybrid Datalog semantics that adds a bottom-up database to our top-down operational semantics. We implemented a debugger for core Datalog following these semantics and explain how to adopt it for debugging the frontend languages of Soufflé and IncA. Our evaluation shows that our hybrid Datalog semantics can be used to debug real-world Datalog programs with realistic workloads.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622824", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "André", + "last_name": "Pacak", + "institution": "" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/PacakE23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622827", + "title": "Modular Verification of Safe Memory Reclamation in Concurrent Separation Logic", + "abstract": "Formal verification is an effective method to address the challenge of designing correct and efficient concurrent data structures. But verification efforts often ignore memory reclamation , which involves nontrivial synchronization between concurrent accesses and reclamation. When incorrectly implemented, it may lead to critical safety errors such as use-after-free and the ABA problem. Semi-automatic safe memory reclamation schemes such as hazard pointers and RCU encapsulate the complexity of manual memory management in modular interfaces. However, this modularity has not been carried over to formal verification. We propose modular specifications of hazard pointers and RCU, and formally verify realistic implementations of them in concurrent separation logic. Specifically, we design abstract predicates for hazard pointers that capture the meaning of validating the protection of nodes, and those for RCU that support optimistic traversal to possibly retired nodes. We demonstrate that the specifications indeed facilitate modular verification in three criteria: compositional verification, general applicability, and easy integration. In doing so, we present the first formal verification of Harris’s list, the Harris-Michael list, the Chase-Lev deque, and RDCSS with reclamation. We report the Coq mechanization of all our results in the Iris separation logic framework.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622827", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jaehwang", + "last_name": "Jung", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Janggun", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jaemin", + "last_name": "Choi", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jaewoo", + "last_name": "Kim", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sunho", + "last_name": "Park", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/JungLCKPK23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622828", + "title": "Simple Reference Immutability for System F", + "abstract": "Reference immutability is a type based technique for taming mutation that has long been studied in the context of object-oriented languages, like Java. Recently, though, languages like Scala have blurred the lines between functional programming languages and object oriented programming languages. We explore how reference immutability interacts with features commonly found in these hybrid languages, in particular with higher-order functions – polymorphism – and subtyping. We construct a calculus System F<:M which encodes a reference immutability system as a simple extension of System F<: and prove that it satisfies the standard soundness and immutability safety properties.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622828", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Edward", + "last_name": "Lee", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/LeeL23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622821", + "title": "Adventure of a Lifetime: Extract Method Refactoring for Rust", + "abstract": "We present a design and implementation of the automated \"Extract Method\" refactoring for Rust programs. Even though Extract Method is one of the most well-studied and widely used in practice automated refactorings, featured in all major IDEs for all popular programming languages, implementing it soundly for Rust is surprisingly non-trivial due to the restrictions of the Rust's ownership and lifetime-based type system. In this work, we provide a systematic decomposition of the Extract Method refactoring for Rust programs into a series of program transformations, each concerned with satisfying a particular aspect of Rust type safety, eventually producing a well-typed Rust program. Our key discovery is the formulation of Extract Method as a composition of naive function hoisting and a series of automated program repair procedures that progressively make the resulting program \"more well-typed\" by relying on the corresponding repair oracles. Those oracles include a novel static intra-procedural ownership analysis that infers correct sharing annotations for the extracted function's parameters, and the lifetime checker of rustc, Rust's reference compiler. We implemented our approach in a tool called REM---an automated Extract Method refactoring built on top of IntelliJ IDEA plugin for Rust. Our extensive evaluation on a corpus of changes in five popular Rust projects shows that REM (a) can extract a larger class of feature-rich code fragments into semantically correct functions than other existing refactoring tools, (b) can reproduce method extractions performed manually by human developers in the past, and (c) is efficient enough to be used in interactive development.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622821", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sewen", + "last_name": "Thy", + "institution": "Yale-NUS College" + }, + { + "first_name": "Andreea", + "last_name": "Costea", + "institution": "National University of Singapore" + }, + { + "first_name": "Kiran", + "last_name": "Gopinathan", + "institution": "National University of Singapore" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/ThyCGS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622829", + "title": "Asparagus: Automated Synthesis of Parametric Gas Upper-Bounds for Smart Contracts", + "abstract": "Modern programmable blockchains have built-in support for smart contracts, i.e. ‍programs that are stored on the blockchain and whose state is subject to consensus. After a smart contract is deployed on the blockchain, anyone on the network can interact with it and call its functions by creating transactions. The blockchain protocol is then used to reach a consensus about the order of the transactions and, as a direct corollary, the state of every smart contract. Reaching such consensus necessarily requires every node on the network to execute all function calls. Thus, an attacker can perform DoS by creating expensive transactions and function calls that use considerable or even possibly infinite time and space. To avoid this, following Ethereum, virtually all programmable blockchains have introduced the concept of “gas”. A fixed hard-coded gas cost is assigned to every atomic operation and the user who calls a function has to pay for its total gas usage. This technique ensures that the protocol is not vulnerable to DoS attacks, but it has also had significant unintended consequences. Out-of-gas errors, i.e. ‍when a user misunderestimates the gas usage of their function call and does not allocate enough gas, are a major source of security vulnerabilities in Ethereum. We focus on the well-studied problem of automatically finding upper-bounds on the gas usage of a smart contract. This is a classical problem in the blockchain community and has also been extensively studied by researchers in programming languages and verification. In this work, we provide a novel approach using theorems from polyhedral geometry and real algebraic geometry, namely Farkas’ Lemma, Handelman’s Theorem, and Putinar’s Positivstellensatz, to automatically synthesize linear and polynomial parametric bounds for the gas usage of smart contracts. Our approach is the first to provide completeness guarantees for the synthesis of such parametric upper-bounds. Moreover, our theoretical results are independent of the underlying consensus protocol and can be applied to smart contracts written in any language and run on any blockchain. As a proof of concept, we also provide a tool, called “Asparagus” that implements our algorithms for Ethereum contracts written in Solidity. Finally, we provide extensive experimental results over 24,188 real-world smart contracts that are currently deployed on the Ethereum blockchain. We compare Asparagus against GASTAP, which is the only previous tool that could provide parametric bounds, and show that our method significantly outperforms it, both in terms of applicability and the tightness of the resulting bounds. More specifically, our approach can handle 80.56% of the functions (126,269 out of 156,735) in comparison with GASTAP’s 58.62%. Additionally, even on the benchmarks where both approaches successfully synthesize a bound, our bound is tighter in 97.85% of the cases.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622829", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhuo", + "last_name": "Cai", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Soroush", + "last_name": "Farokhnia", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "S.", + "last_name": "Hitarth", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/CaiFGH23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622830", + "title": "Inductive Program Synthesis Guided by Observational Program Similarity", + "abstract": "We present a new general-purpose synthesis technique for generating programs from input-output examples. Our method, called metric program synthesis, relaxes the observational equivalence idea (used widely in bottom-up enumerative synthesis) into a weaker notion of observational similarity, with the goal of reducing the search space that the synthesizer needs to explore. Our method clusters programs into equivalence classes based on an expert-provided distance metric and constructs a version space that compactly represents “approximately correct” programs. Then, given a “close enough” program sampled from this version space, our approach uses a distance-guided repair algorithm to find a program that exactly matches the given input-output examples. We have implemented our proposed metric program synthesis technique in a tool called SyMetric and evaluate it in three different domains considered in prior work. Our evaluation shows that SyMetric outperforms other domain-agnostic synthesizers that use observational equivalence and that it achieves results competitive with domain-specific synthesizers that are either designed for or trained on those domains.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622830", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John", + "last_name": "Feser", + "institution": "Hamilton College" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/FeserDS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622831", + "title": "From Capabilities to Regions: Enabling Efficient Compilation of Lexical Effect Handlers", + "abstract": "Effect handlers are a high-level abstraction that enables programmers to use effects in a structured way. They have gained a lot of popularity within academia and subsequently also in industry. However, the abstraction often comes with a significant runtime cost and there has been intensive research recently on how to reduce this price. A promising approach in this regard is to implement effect handlers using a CPS translation and to provide sufficient information about the nesting of handlers. With this information the CPS translation can decide how effects have to be lifted through handlers, i.e., which handlers need to be skipped, in order to handle the effect at the correct place. A structured way to make this information available is to use a calculus with a region system and explicit subregion evidence. Such calculi, however, are quite verbose, which makes them impractical to use as a source-level language. We present a method to infer the lifting information for a calculus underlying a source-level language. This calculus uses second-class capabilities for the safe use of effects. To do so, we define a typed translation to a calculus with regions and evidence and we show that this lift-inference translation is typability- and semantics-preserving. On the one hand, this exposes the precise relation between the second-class property and the structure given by regions. On the other hand, it closes a gap in a compiler pipeline enabling efficient compilation of the source-level language. We have implemented lift inference in this compiler pipeline and conducted benchmarks which indicate that the approach is indeed working.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622831", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marius", + "last_name": "Müller", + "institution": "University of Tübingen" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Lindegaard", + "last_name": "Starup", + "institution": "Aarhus University" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/MullerSSOB23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622832", + "title": "A Container-Usage-Pattern-Based Context Debloating Approach for Object-Sensitive Pointer Analysis", + "abstract": "In this paper, we introduce DebloaterX, a new approach for automatically identifying context-independent objects to debloat contexts in object-sensitive pointer analysis ( k obj). Object sensitivity achieves high precision, but its context construction mechanism combines objects with their contexts indiscriminately. This leads to a combinatorial explosion of contexts in large programs, resulting in inefficiency. Previous research has proposed a context-debloating approach that inhibits a pre-selected set of context-independent objects from forming new contexts, improving the efficiency of k obj. However, this earlier context-debloating approach under-approximates the set of context-independent objects identified, limiting performance speedups. We introduce a novel context-debloating pre-analysis approach that identifies objects as context-dependent only when they are potentially precision-critical to k obj based on three general container-usage patterns. Our research finds that objects containing no fields of ”abstract” (i.e., open) types can be analyzed context-insensitively with negligible precision loss in real-world applications. We provide clear rules and efficient algorithms to recognize these patterns, selecting more context-independent objects for better debloating. We have implemented DebloaterX in the Qilin framework and will release it as an open-source tool. Our experimental results on 12 standard Java benchmarks and real-world programs show that DebloaterX selects 92.4% of objects to be context-independent on average, enabling k obj to run significantly faster (an average of 19.3x when k = 2 and 150.2x when k = 3) and scale up to 8 more programs when k = 3, with only a negligible loss of precision (less than 0.2%). Compared to state-of-the-art alternative pre-analyses in accelerating k obj, DebloaterX outperforms Zipper significantly in both precision and efficiency and outperforms Conch (the earlier context-debloating approach) in efficiency substantially while achieving nearly the same precision.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622832", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dongjie", + "last_name": "He", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yujiang", + "last_name": "Gui", + "institution": "UNSW Sydney" + }, + { + "first_name": "Wei", + "last_name": "Li", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yonggang", + "last_name": "Tao", + "institution": "UNSW Sydney" + }, + { + "first_name": "Changwei", + "last_name": "Zou", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "UNSW Sydney" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "journals/pacmpl/HeGLTZSX23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622837", + "title": "A Pretty Expressive Printer", + "abstract": "Pretty printers make trade-offs between the expressiveness of their pretty printing language, the optimality objective that they minimize when choosing between different ways to lay out a document, and the performance of their algorithm. This paper presents a new pretty printer, Π e , that is strictly more expressive than all pretty printers in the literature and provably minimizes an optimality objective. Furthermore, the time complexity of Π e is better than many existing pretty printers. When choosing among different ways to lay out a document, Π e consults a user-supplied cost factory , which determines the optimality objective, giving Π e a unique degree of flexibility. We use the Lean theorem prover to verify the correctness (validity and optimality) of Π e , and implement Π e concretely as a pretty printer that we call PrettyExpressive. To evaluate our pretty printer against others, we develop a formal framework for reasoning about the expressiveness of pretty printing languages, and survey pretty printers in the literature, comparing their expressiveness, optimality, worst-case time complexity, and practical running time. Our evaluation shows that PrettyExpressive is efficient and effective at producing optimal layouts. PrettyExpressive has also seen real-world adoption: it serves as a foundation of a code formatter for Racket.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622837", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sorawee", + "last_name": "Porncharoenwase", + "institution": "University of Washington" + }, + { + "first_name": "Justin", + "last_name": "Pombrio", + "institution": "" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/PorncharoenwasePT23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622833", + "title": "A Cocktail Approach to Practical Call Graph Construction", + "abstract": "After decades of research, constructing call graphs for modern C-based software remains either imprecise or inefficient when scaling up to the ever-growing complexity. The main culprit is the difficulty of resolving function pointers, as precise pointer analyses are cubic in nature and become exponential when considering calling contexts. This paper takes a practical stance by first conducting a comprehensive empirical study of function pointer manipulations in the wild. By investigating 5355 indirect calls in five popular open-source systems, we conclude that, instead of the past uniform treatments for function pointers, a cocktail approach can be more effective in “squeezing” the number of difficult pointers to a minimum using a potpourri of cheap methods. In particular, we decompose the costs of constructing highly precise call graphs of big code by tailoring several increasingly precise algorithms and synergizing them into a concerted workflow. As a result, many indirect calls can be precisely resolved in an efficient and principled fashion, thereby reducing the final, expensive refinements. This is, in spirit, similar to the well-known cocktail medical therapy. The results are encouraging — our implemented prototype called Coral can achieve similar precision versus the previous field-, flow-, and context-sensitive Andersen-style call graph construction, yet scale up to millions of lines of code for the first time, to the best of our knowledge. Moreover, by evaluating the produced call graphs through the lens of downstream clients (i.e., use-after-free detection, thin slicing, and directed grey-box fuzzing), the results show that Coral can dramatically improve their effectiveness for better vulnerability hunting, understanding, and reproduction. More excitingly, we found twelve confirmed bugs (six impacted by indirect calls) in popular systems (e.g., MariaDB), spreading across multiple historical versions.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622833", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuandao", + "last_name": "Cai", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/CaiZ23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622835", + "title": "Complete First-Order Reasoning for Properties of Functional Programs", + "abstract": "Several practical tools for automatically verifying functional programs (e.g., Liquid Haskell and Leon for Scala programs) rely on a heuristic based on unrolling recursive function definitions followed by quantifier-free reasoning using SMT solvers. We uncover foundational theoretical properties of this heuristic, revealing that it can be generalized and formalized as a technique that is in fact complete for reasoning with combined First-Order theories of algebraic datatypes and background theories, where background theories support decidable quantifier-free reasoning. The theory developed in this paper explains the efficacy of these heuristics when they succeed, explain why they fail when they fail, and the precise role that user help plays in making proofs succeed.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622835", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Lucas", + "last_name": "Peña", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MuraliPJM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622836", + "title": "Structural Subtyping as Parametric Polymorphism", + "abstract": "Structural subtyping and parametric polymorphism provide similar flexibility and reusability to programmers. For example, both features enable the programmer to provide a wider record as an argument to a function that expects a narrower one. However, the means by which they do so differs substantially, and the precise details of the relationship between them exists, at best, as folklore in literature. In this paper, we systematically study the relative expressive power of structural subtyping and parametric polymorphism. We focus our investigation on establishing the extent to which parametric polymorphism, in the form of row and presence polymorphism, can encode structural subtyping for variant and record types. We base our study on various Church-style λ-calculi extended with records and variants, different forms of structural subtyping, and row and presence polymorphism. We characterise expressiveness by exhibiting compositional translations between calculi. For each translation we prove a type preservation and operational correspondence result. We also prove a number of non-existence results. By imposing restrictions on both source and target types, we reveal further subtleties in the expressiveness landscape, the restrictions enabling otherwise impossible translations to be defined. More specifically, we prove that full subtyping cannot be encoded via polymorphism, but we show that several restricted forms of subtyping can be encoded via particular forms of polymorphism.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622836", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wenhao", + "last_name": "Tang", + "institution": "University of Edinburgh" + }, + { + "first_name": "Daniel", + "last_name": "Hillerström", + "institution": "" + }, + { + "first_name": "James", + "last_name": "McKinna", + "institution": "Heriot-Watt University" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "University of Edinburgh" + }, + { + "first_name": "Ornela", + "last_name": "Dardha", + "institution": "University of Glasgow" + }, + { + "first_name": "Rongxiao", + "last_name": "Fu", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/TangHMSDFL23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622834", + "title": "Equality Saturation Theory Exploration à la Carte", + "abstract": "Rewrite rules are critical in equality saturation, an increasingly popular technique in optimizing compilers, synthesizers, and verifiers. Unfortunately, developing high-quality rulesets is difficult and error-prone. Recent work on automatically inferring rewrite rules does not scale to large terms or grammars, and existing rule inference tools are monolithic and opaque. Equality saturation users therefore struggle to guide inference and incrementally construct rulesets. As a result, most users still manually develop and maintain rulesets. This paper proposes Enumo, a new domain-specific language for programmable theory exploration. Enumo provides a small set of core operators that enable users to strategically guide rule inference and incrementally build rulesets. Short Enumo programs easily replicate results from state-of-the-art tools, but Enumo programs can also scale to infer deeper rules from larger grammars than prior approaches. Its composable operators even facilitate developing new strategies for ruleset inference. We introduce a new fast-forwarding strategy that does not require evaluating terms in the target language, and can thus support domains that were out of scope for prior work. We evaluate Enumo and fast-forwarding across a variety of domains. Compared to state-of-the-art techniques, enumo can synthesize better rulesets over a diverse set of domains, in some cases matching the effects of manually-developed rulesets in systems driven by equality saturation.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622834", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "A.", + "last_name": "Pal", + "institution": "University of Washington" + }, + { + "first_name": "Brett", + "last_name": "Saiki", + "institution": "University of Washington" + }, + { + "first_name": "Ryan", + "last_name": "Tjoa", + "institution": "University of Washington" + }, + { + "first_name": "Cynthia", + "last_name": "Richey", + "institution": "University of Washington" + }, + { + "first_name": "Amy", + "last_name": "Zhu", + "institution": "University of Washington" + }, + { + "first_name": "Oliver", + "last_name": "Flatt", + "institution": "University of Washington" + }, + { + "first_name": "Max", + "last_name": "Willsey", + "institution": "University of Washington" + }, + { + "first_name": "Zachary", + "last_name": "Tatlock", + "institution": "University of Washington" + }, + { + "first_name": "Chandrakana", + "last_name": "Nandi", + "institution": "Seattle University" + } + ], + "dblp_key": "journals/pacmpl/PalSTRZFWTN23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622840", + "title": "Bring Your Own Data Structures to Datalog", + "abstract": "The restricted logic programming language Datalog has become a popular implementation target for deductive-analytic workloads including social-media analytics and program analysis. Modern Datalog engines compile Datalog rules to joins over explicit representations of relations—often B-trees or hash maps. While these modern engines have enabled high scalability in many application domains, they have a crucial weakness: achieving the desired algorithmic complexity may be impossible due to representation-imposed overhead of the engine’s data structures. In this paper, we present the \"Bring Your Own Data Structures\" (Byods) approach, in the form of a DSL embedded in Rust. Using Byods, an engineer writes logical rules which are implicitly parametric on the concrete data structure representation; our implementation provides an interface to enable \"bringing their own\" data structures to represent relations, which harmoniously interact with code generated by our compiler (implemented as Rust procedural macros). We formalize the semantics of Byods as an extension of Datalog’s; our formalization captures the key properties demanded of data structures compatible with Byods, including properties required for incrementalized (semi-naïve) evaluation. We detail many applications of the Byods approach, implementing analyses requiring specialized data structures for transitive and equivalence relations to scale, including an optimized version of the Rust borrow checker Polonius; highly-parallel PageRank made possible by lattices; and a large-scale analysis of LLVM utilizing index-sharing to scale. Our results show that Byods offers both improved algorithmic scalability (reduced time and/or space complexity) and runtimes competitive with state-of-the-art parallelizing Datalog solvers.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622840", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arash", + "last_name": "Sahebolamri", + "institution": "Syracuse University" + }, + { + "first_name": "L. L.", + "last_name": "Barrett", + "institution": "Galois (United States)" + }, + { + "first_name": "Scott A.", + "last_name": "Moore", + "institution": "Galois (United States)" + }, + { + "first_name": "Kristopher", + "last_name": "Micinski", + "institution": "Syracuse University" + } + ], + "dblp_key": "journals/pacmpl/SahebolamriBMM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622841", + "title": "A Grounded Conceptual Model for Ownership Types in Rust", + "abstract": "Programmers learning Rust struggle to understand ownership types, Rust’s core mechanism for ensuring memory safety without garbage collection. This paper describes our attempt to systematically design a pedagogy for ownership types. First, we studied Rust developers’ misconceptions of ownership to create the Ownership Inventory, a new instrument for measuring a person’s knowledge of ownership. We found that Rust learners could not connect Rust’s static and dynamic semantics, such as determining why an ill-typed program would (or would not) exhibit undefined behavior. Second, we created a conceptual model of Rust’s semantics that explains borrow checking in terms of flow-sensitive permissions on paths into memory. Third, we implemented a Rust compiler plugin that visualizes programs under the model. Fourth, we integrated the permissions model and visualizations into a broader pedagogy of ownership by writing a new ownership chapter for The Rust Programming Language , a popular Rust textbook. Fifth, we evaluated an initial deployment of our pedagogy against the original version, using reader responses to the Ownership Inventory as a point of comparison. Thus far, the new pedagogy has improved learner scores on the Ownership Inventory by an average of 9", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622841", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Will", + "last_name": "Crichton", + "institution": "Brown University" + }, + { + "first_name": "G R", + "last_name": "Gray", + "institution": "ETH Zurich" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "journals/pacmpl/CrichtonGK23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622839", + "title": "Reusing Just-in-Time Compiled Code", + "abstract": "Most code is executed more than once. If not entire programs then libraries remain unchanged from one run to the next. Just-in-time compilers expend considerable effort gathering insights about code they compiled many times, and often end up generating the same binary over and over again. We explore how to reuse compiled code across runs of different programs to reduce warm-up costs of dynamic languages. We propose to use speculative contextual dispatch to select versions of functions from an off-line curated code repository . That repository is a persistent database of previously compiled functions indexed by the context under which they were compiled. The repository is curated to remove redundant code and to optimize dispatch. We assess practicality by extending Ř, a compiler for the R language, and evaluating its performance. Our results suggest that the approach improves warmup times while preserving peak performance.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622839", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "M.", + "last_name": "Mehta", + "institution": "Indian Institute of Technology Mandi" + }, + { + "first_name": "Sebastián", + "last_name": "Krynski", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Hugo Musso", + "last_name": "Gualandi", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Manas", + "last_name": "Thakur", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/MehtaKGTV23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622838", + "title": "Automated Ambiguity Detection in Layout-Sensitive Grammars", + "abstract": "Layout-sensitive grammars have been adopted in many modern programming languages. In a serious language design phase, the specified syntax—typically a grammar—must be unambiguous. Although checking ambiguity is undecidable for context-free grammars and (trivially also) layout-sensitive grammars, ambiguity detection , on the other hand, is possible and can benefit language designers from exposing potential design flaws . In this paper, we tackle the ambiguity detection problem in layout-sensitive grammars. Inspired by a previous work on checking the bounded ambiguity of context-free grammars via SAT solving , we intensively extend their approach to support layout-sensitive grammars but via SMT solving to express the ordering and quantitative relations over line/column numbers. Our key novelty lies in a reachability condition, which takes the impact of layout constraints on ambiguity into careful account. With this condition in hand, we propose an equivalent ambiguity notion called local ambiguity for the convenience of SMT encoding. We translate local ambiguity into an SMT formula and developed a bounded ambiguity checker that automatically finds a shortest nonempty ambiguous sentence (if exists) for a user-input grammar. The soundness and completeness of our SMT encoding are mechanized in the Coq proof assistant. We conducted an evaluation on both grammar fragments and full grammars extracted from the language manuals of domain-specific languages like YAML as well as general-purpose languages like Python, which reveals the effectiveness of our approach.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622838", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jiangyi", + "last_name": "Liu", + "institution": "Tsinghua University" + }, + { + "first_name": "Fengmin", + "last_name": "Zhu", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + } + ], + "dblp_key": "journals/pacmpl/LiuZH23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622843", + "title": "Resource-Aware Soundness for Big-Step Semantics", + "abstract": "We extend the semantics and type system of a lambda calculus equipped with common constructs to be resource-aware . That is, reduction is instrumented to keep track of the usage of resources, and the type system guarantees, besides standard soundness, that for well-typed programs there is a computation where no needed resource gets exhausted. The resource-aware extension is parametric on an arbitrary grade algebra , and does not require ad-hoc changes to the underlying language. To this end, the semantics needs to be formalized in big-step style; as a consequence, expressing and proving (resource-aware) soundness is challenging, and is achieved by applying recent techniques based on coinductive reasoning.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622843", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Riccardo", + "last_name": "Bianchini", + "institution": "University of Genoa" + }, + { + "first_name": "Francesco", + "last_name": "Dagnino", + "institution": "University of Genoa" + }, + { + "first_name": "Paola", + "last_name": "Giannini", + "institution": "Università degli Studi del Piemonte Orientale “Amedeo Avogadro”" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "journals/pacmpl/BianchiniDGZ23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622842", + "title": "Building Dynamic System Call Sandbox with Partial Order Analysis", + "abstract": "Attack surface reduction is a security technique that secures the operating system by removing the unnecessary code or features of a program. By restricting the system calls that programs can use, the system call sandbox is able to reduce the exposed attack surface of the operating system and prevent attackers from damaging it through vulnerable programs. Ideally, programs should only retain access to system calls they require for normal execution. Many researchers focus on adopting static analysis to automatically restrict the system calls for each program. However, these methods do not adjust the restriction policy along with program execution. Thus, they need to permit all system calls required for program functionalities. We observe that some system calls, especially security-sensitive ones, are used a few times in certain stages of a program’s execution and then never used again. This motivates us to minimize the set of required system calls dynamically. In this paper, we propose , which gradually disables access to unnecessary system calls throughout the program’s execution. To accomplish this, we utilize partial order analysis to transform the program into a partially ordered graph, which enables efficient identification of the necessary system calls at any given point during program execution. Once a system call is no longer required by the program, can restrict it immediately. To evaluate , we applied it to seven widely-used programs with an average of 615 KLOC, including web servers and databases. With partial order analysis, restricts an average of 23.50, 16.86, and 15.89 more system calls than the state-of-the-art Chestnut, Temporal Specialization, and the configuration-aware sandbox, C2C, respectively. For mitigating malicious exploitations, on average, defeats 83.42% of 1726 exploitation payloads with only a 5.07% overhead.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622842", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Quan", + "last_name": "Zhang", + "institution": "Tsinghua University" + }, + { + "first_name": "Chijin", + "last_name": "Zhou", + "institution": "Tsinghua University" + }, + { + "first_name": "Yiwen", + "last_name": "Xu", + "institution": "Tsinghua University" + }, + { + "first_name": "Zijing", + "last_name": "Yin", + "institution": "Tsinghua University" + }, + { + "first_name": "Mingzhe", + "last_name": "Wang", + "institution": "Tsinghua University" + }, + { + "first_name": "Zhuo", + "last_name": "Su", + "institution": "Tsinghua University" + }, + { + "first_name": "C. P.", + "last_name": "Sun", + "institution": "University of Waterloo" + }, + { + "first_name": "Yu", + "last_name": "Jiang", + "institution": "Tsinghua University" + }, + { + "first_name": "Jiaguang", + "last_name": "Sun", + "institution": "Tsinghua University" + } + ], + "dblp_key": "journals/pacmpl/ZhangZXYWSSJS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622844", + "title": "Initializing Global Objects: Time and Order", + "abstract": "Object-oriented programming has been bothered by an awkward feature for a long time: static members . Static members not only compromise the conceptual integrity of object-oriented programming, but also give rise to subtle initialization errors, such as reading non-initialized fields and deadlocks. The Scala programming language eliminated static members from the language, replacing them with global objects that present a unified object-oriented programming model. However, the problem of global object initialization remains open, and programmers still suffer from initialization errors. We propose partial ordering and initialization-time irrelevance as two fundamental principles for initializing global objects. Based on these principles, we put forward an effective static analysis to ensure safe initialization of global objects, which eliminates initialization errors at compile time. The analysis also enables static scheduling of global object initialization to avoid runtime overhead. The analysis is modular at the granularity of objects and it avoids whole-program analysis. To make the analysis explainable and tunable, we introduce the concept of regions to make context-sensitivity understandable and customizable by programmers.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622844", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fengyun", + "last_name": "Liu", + "institution": "" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "David", + "last_name": "Hua", + "institution": "University of Waterloo" + }, + { + "first_name": "Enze", + "last_name": "Xing", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/LiuLHX23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622845", + "title": "Formal Abstractions for Packet Scheduling", + "abstract": "Early programming models for software-defined networking (SDN) focused on basic features for controlling network-wide forwarding paths, but more recent work has considered richer features, such as packet scheduling and queueing, that affect performance. In particular, PIFO trees , proposed by Sivaraman et al., offer a flexible and efficient primitive for programmable packet scheduling. Prior work has shown that PIFO trees can express a wide range of practical algorithms including strict priority, weighted fair queueing, and hierarchical schemes. However, the semantic properties of PIFO trees are not well understood. This paper studies PIFO trees from a programming language perspective. We formalize the syntax and semantics of PIFO trees in an operational model that decouples the scheduling policy running on a tree from the topology of the tree. Building on this formalization, we develop compilation algorithms that allow the behavior of a PIFO tree written against one topology to be realized using a tree with a different topology. Such a compiler could be used to optimize an implementation of PIFO trees, or realize a logical PIFO tree on a target with a fixed topology baked into the hardware. To support experimentation, we develop a software simulator for PIFO trees, and we present case studies illustrating its behavior on standard and custom algorithms.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622845", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anshuman", + "last_name": "Mohan", + "institution": "Cornell University" + }, + { + "first_name": "Yunhe", + "last_name": "Liu", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/MohanLFKK23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622846", + "title": "Reference Capabilities for Flexible Memory Management", + "abstract": "Verona is a concurrent object-oriented programming language that organises all the objects in a program into a forest of isolated regions. Memory is managed locally for each region, so programmers can control a program's memory use by adjusting objects' partition into regions, and by setting each region's memory management strategy. A thread can only mutate (allocate, deallocate) objects within one active region---its \"window of mutability\". Memory management costs are localised to the active region, ensuring overheads can be predicted and controlled. Moving the mutability window between regions is explicit, so code can be executed wherever it is required, yet programs remain in control of memory use. An ownership type system based on reference capabilities enforces region isolation, controlling aliasing within and between regions, yet supporting objects moving between regions and threads. Data accesses never need expensive atomic operations, and are always thread-safe.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622846", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ellen", + "last_name": "Arvidsson", + "institution": "Uppsala University" + }, + { + "first_name": "Elias", + "last_name": "Castegren", + "institution": "Uppsala University" + }, + { + "first_name": "Sylvan", + "last_name": "Clebsch", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "journals/pacmpl/ArvidssonCCDNPW23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622847", + "title": "Mobius: Synthesizing Relational Queries with Recursive and Invented Predicates", + "abstract": "Synthesizing relational queries from data is challenging in the presence of recursion and invented predicates. We propose a fully automated approach to synthesize such queries. Our approach comprises of two steps: it first synthesizes a non-recursive query consistent with the given data, and then identifies recursion schemes in it and thereby generalizes to arbitrary data. This generalization is achieved by an iterative predicate unification procedure which exploits the notion of data provenance to accelerate convergence. In each iteration of the procedure, a constraint solver proposes a candidate query, and a query evaluator checks if the proposed program is consistent with the given data. The data provenance for a failed query allows us to construct additional constraints for the constraint solver and refine the search. We have implemented our approach in a tool named Mobius. On a suite of 21 challenging recursive query synthesis tasks, Mobius outperforms three state-of-the-art baselines Gensynth, ILASP, and Popper, both in terms of runtime and accuracy. We also demonstrate that the synthesized queries generalize well to unseen data.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622847", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aalok", + "last_name": "Thakkar", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Nathaniel", + "last_name": "Sands", + "institution": "University of Southern California" + }, + { + "first_name": "George", + "last_name": "Petrou", + "institution": "University of Southern California" + }, + { + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "University of Southern California" + } + ], + "dblp_key": "journals/pacmpl/ThakkarSPANR23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622848", + "title": "MemPerf: Profiling Allocator-Induced Performance Slowdowns", + "abstract": "The memory allocator plays a key role in the performance of applications, but none of the existing profilers can pinpoint performance slowdowns caused by a memory allocator. Consequently, programmers may spend time improving application code incorrectly or unnecessarily, achieving low or no performance improvement. This paper designs the first profiler—MemPerf—to identify allocator-induced performance slowdowns without comparing against another allocator. Based on the key observation that an allocator may impact the whole life-cycle of heap objects, including the accesses (or uses) of these objects, MemPerf proposes a life-cycle based detection to identify slowdowns caused by slow memory management operations and slow accesses separately. For the prior one, MemPerf proposes a thread-aware and type-aware performance modeling to identify slow management operations. For slow memory accesses, MemPerf utilizes a top-down approach to identify all possible reasons for slow memory accesses introduced by the allocator, mainly due to cache and TLB misses, and further proposes a unified method to identify them correctly and efficiently. Based on our extensive evaluation, MemPerf reports 98% medium and large allocator-reduced slowdowns (larger than 5%) correctly without reporting any false positives. MemPerf also pinpoints multiple known and unknown design issues in widely-used allocators.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622848", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhou", + "last_name": "Jin", + "institution": "Amherst College" + }, + { + "first_name": "Sam", + "last_name": "Silvestro", + "institution": "The University of Texas at San Antonio" + }, + { + "first_name": "Steven", + "last_name": "Tang", + "institution": "Amherst College" + }, + { + "first_name": "Hanmei", + "last_name": "Yang", + "institution": "Amherst College" + }, + { + "first_name": "Hongyu", + "last_name": "Liu", + "institution": "The University of Texas at San Antonio" + }, + { + "first_name": "Guangming", + "last_name": "Zeng", + "institution": "Synopsys (United States)" + }, + { + "first_name": "Bo", + "last_name": "Wu", + "institution": "Colorado School of Mines" + }, + { + "first_name": "Cong", + "last_name": "Liu", + "institution": "" + }, + { + "first_name": "Tongping", + "last_name": "Liu", + "institution": "Amherst College" + } + ], + "dblp_key": "journals/pacmpl/ZhouSTYLZWLL23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622850", + "title": "Quantifying and Mitigating Cache Side Channel Leakage with Differential Set", + "abstract": "Cache side-channel attacks leverage secret-dependent footprints in CPU cache to steal confidential information, such as encryption keys. Due to the lack of a proper abstraction for reasoning about cache side channels, existing static program analysis tools that can quantify or mitigate cache side channels are built on very different kinds of abstractions. As a consequence, it is hard to bridge advances in quantification and mitigation research. Moreover, existing abstractions lead to imprecise results. In this paper, we present a novel abstraction, called differential set, for analyzing cache side channels at compile time. A distinguishing feature of differential sets is that it allows compositional and precise reasoning about cache side channels. Moreover, it is the first abstraction that carries sufficient information for both side channel quantification and mitigation. Based on this new abstraction, we develop a static analysis tool DSA that automatically quantifies and mitigates cache side channel leakage at the same time. Experimental evaluation on a set of commonly used benchmarks shows that DSA can produce more precise leakage bound as well as mitigated code with fewer memory footprints, when compared with state-of-the-art tools that only quantify or mitigate cache side channel leakage.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622850", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cong", + "last_name": "Ma", + "institution": "University of Waterloo" + }, + { + "first_name": "Dinghao", + "last_name": "Wu", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Mahmut", + "last_name": "Kandemir", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "journals/pacmpl/MaWTKZ23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622857", + "title": "Stuttering for Free", + "abstract": "One of the most common tools for proving behavioral refinements between transition systems is the method of simulation proofs, which has been explored extensively over the past several decades. Stuttering simulations are an extension of traditional simulations—used, for example, in CompCert—in which either the source or target of the simulation is permitted to “stutter” (stay in place) while the other side steps forward. In the interest of ensuring soundness, however, existing stuttering simulations restrict proofs to only perform a finite number of stuttering steps before making synchronous progress —a step of reasoning in which both sides of the simulation progress forward together. This restriction guarantees that a terminating program cannot be proven to simulate a non-terminating one. In this paper, we observe that the requirement to eventually achieve synchronous progress is burdensome and, what’s more, unnecessary: it is possible to ensure soundness of stuttering simulations while only requiring asynchronous progress (progress on both sides of the simulation that may be achieved with only stuttering steps). Building on this observation, we develop a new simulation technique we call FreeSim (short for “freely-stuttering simulations”), mechanized in Coq, and we demonstrate its effectiveness on a range of interesting case studies. These include a simplification of the meta-theory of CompCert, as well as the DTrees library, which enriches the ITrees (Interaction Trees) library with dual non-determinism.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622857", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Dongjae", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Lennard", + "last_name": "Gäher", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/ChoSLGD23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622851", + "title": "How Domain Experts Use an Embedded DSL", + "abstract": "Programming tools are increasingly integral to research and analysis in myriad domains, including specialized areas with no formal relation to computer science. Embedded domain-specific languages (eDSLs) have the potential to serve these programmers while placing relatively light implementation burdens on language designers. However, barriers to eDSL use reduce their practical value and adoption. In this paper, we aim to deepen our understanding of how programmers use eDSLs and identify user needs to inform future eDSL designs. We performed a contextual inquiry (9 participants) with domain experts using Mimi, an eDSL for climate change economics modeling. A thematic analysis identified five key themes, including: the interaction between the eDSL and the host language has significant and sometimes unexpected impacts on eDSL user experience, and users preferentially engage with domain-specific communities and code templates rather than host language resources. The needs uncovered in our study offer design considerations for future eDSLs and suggest directions for future DSL usability research.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622851", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lisa", + "last_name": "Rennels", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sarah", + "last_name": "Chasins", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/RennelsC23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622849", + "title": "Verifying Indistinguishability of Privacy-Preserving Protocols", + "abstract": "Internet users rely on the protocols they use to protect their private information including their identity and the websites they visit. Formal verification of these protocols can detect subtle bugs that compromise these protections at design time, but is a challenging task as it involves probabilistic reasoning about random sampling, cryptographic primitives, and concurrent execution. Existing approaches either reason about symbolic models of the protocols that sacrifice precision for automation, or reason about more precise computational models that are harder to automate and require cryptographic expertise. In this paper we propose a novel approach to verifying privacy-preserving protocols that is more precise than symbolic models yet more accessible than computational models. Our approach permits direct-style proofs of privacy, as opposed to indirect game-based proofs in computational models, by formalizing privacy as indistinguishability of possible network traces induced by a protocol. We ease automation by leveraging insights from the distributed systems verification community to create sound synchronous models of concurrent protocols. Our verification framework is implemented in F* as a library we call Waldo. We describe two large case studies of using Waldo to verify indistinguishability; one on the Encrypted Client Hello (ECH) extension of the TLS protocol and another on a Private Information Retrieval (PIR) protocol. We uncover subtle flaws in the TLS ECH specification that were missed by other models.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622849", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kirby", + "last_name": "Linvill", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Eric", + "last_name": "Wustrow", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "journals/pacmpl/LinvillKW23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622854", + "title": "Validating IoT Devices with Rate-Based Session Types", + "abstract": "We develop a session types based framework for implementing and validating rate-based message passing systems in Internet of Things (IoT) domains. To model the indefinite repetition present in many embedded and IoT systems, we introduce a timed process calculus with a periodic recursion primitive. This allows us to model rate-based computations and communications inherent to these application domains. We introduce a definition of rate based session types in a binary session types setting and a new compatibility relationship, which we call rate compatibility. Programs which type check enjoy the standard session types guarantees as well as rate error freedom --- meaning processes which exchanges messages do so at the same rate. Rate compatibility is defined through a new notion of type expansion, a relation that allows communication between processes of differing periods by synthesizing and checking a common superperiod type. We prove type preservation and rate error freedom for our system, and show a decidable method for type checking based on computing superperiods for a collection of processes. We implement a prototype of our type system including rate compatibility via an embedding into the native type system of Rust. We apply this framework to a range of examples from our target domain such as Android software sensors, wearable devices, and sound processing.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622854", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Grant", + "last_name": "Iraci", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Cheng-En", + "last_name": "Chuang", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Lukasz", + "last_name": "Ziarek", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "journals/pacmpl/IraciCHZ23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622853", + "title": "TASTyTruffle: Just-in-Time Specialization of Parametric Polymorphism", + "abstract": "Parametric polymorphism enables programmers to express algorithms independently of the types of values that they operate on. The approach used to implement parametric polymorphism can have important performance implications. One popular approach, erasure, uses a uniform representation for generic data, which entails primitive boxing and other indirections that harm performance. Erasure destroys type information that could be used by language implementations to optimize generic code. We present TASTyTruffle, an implementation for a subset of the Scala programming language. Instead of JVM bytecode, TASTyTruffle interprets Scala's TASTy intermediate representation, a typed representation wherein generic types are not erased. TASTy's precise type information empowers TASTyTruffle to implement generic code more effectively. In particular, it allows TASTyTruffle to reify types as run-time objects that can be passed around. Using reified types, TASTyTruffle supports heterogeneous box-free representations for generic values. TASTyTruffle also uses reified types to specialize generic code, producing monomorphic copies of generic code that can be easily and reliably optimized by its just-in-time (JIT) compiler. Empirically, TASTyTruffle is competitive with standard JVM implementations on a small set of benchmark programs; when generic code is used with multiple types, TASTyTruffle consistently outperforms the JVM. The precise type information in TASTy enables TASTyTruffle to find additional optimization opportunities that could not be uncovered with erased JVM bytecode.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622853", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matt", + "last_name": "D'Souza", + "institution": "University of Waterloo" + }, + { + "first_name": "James", + "last_name": "You", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "Aleksandar", + "last_name": "Prokopec", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/DSouzaYLP23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622855", + "title": "Static Analysis of Memory Models for SMT Encodings", + "abstract": "The goal of this work is to improve the efficiency of bounded model checkers that are modular in the memory model. Our first contribution is a static analysis for the given memory model that is performed as a preprocessing step and helps us significantly reduce the encoding size. Memory model make use of relations to judge whether an execution is consistent. The analysis computes bounds on these relations: which pairs of events may or must be related. What is new is that the bounds are relativized to the execution of events. This makes it possible to derive, for the first time, not only upper but also meaningful lower bounds. Another important feature is that the analysis can import information about the verification instance from external sources to improve its precision. Our second contribution are new optimizations for the SMT encoding. Notably, the lower bounds allow us to simplify the encoding of acyclicity constraints. We implemented our analysis and optimizations within a bounded model checker and evaluated it on challenging benchmarks. The evaluation shows up-to 40% reduction in verification time (including the analysis) over previous encodings. Our optimizations allow us to efficiently check safety, liveness, and data race freedom in Linux kernel code.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622855", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Haas", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "René", + "last_name": "Maseli", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" + }, + { + "first_name": "Hernán", + "last_name": "Ponce-de-León", + "institution": "Huawei German Research Center" + } + ], + "dblp_key": "journals/pacmpl/HaasMML23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622856", + "title": "Turaco: Complexity-Guided Data Sampling for Training Neural Surrogates of Programs", + "abstract": "Programmers and researchers are increasingly developing surrogates of programs, models of a subset of the observable behavior of a given program, to solve a variety of software development challenges. Programmers train surrogates from measurements of the behavior of a program on a dataset of input examples. A key challenge of surrogate construction is determining what training data to use to train a surrogate of a given program. We present a methodology for sampling datasets to train neural-network-based surrogates of programs. We first characterize the proportion of data to sample from each region of a program's input space (corresponding to different execution paths of the program) based on the complexity of learning a surrogate of the corresponding execution path. We next provide a program analysis to determine the complexity of different paths in a program. We evaluate these results on a range of real-world programs, demonstrating that complexity-guided sampling results in empirical improvements in accuracy.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622856", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alex", + "last_name": "Renda", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Yi", + "last_name": "Ding", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/RendaDC23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622858", + "title": "Inference of Resource Management Specifications", + "abstract": "A resource leak occurs when a program fails to free some finite resource after it is no longer needed. Such leaks are a significant cause of real-world crashes and performance problems. Recent work proposed an approach to prevent resource leaks based on checking resource management specifications. A resource management specification expresses how the program allocates resources, passes them around, and releases them; it also tracks the ownership relationship between objects and resources, and aliasing relationships between objects. While this specify-and-verify approach has several advantages compared to prior techniques, the need to manually write annotations presents a significant barrier to its practical adoption. This paper presents a novel technique to automatically infer a resource management specification for a program, broadening the applicability of specify-and-check verification for resource leaks. Inference in this domain is challenging because resource management specifications differ significantly in nature from the types that most inference techniques target. Further, for practical effectiveness, we desire a technique that can infer the resource management specification intended by the developer, even in cases when the code does not fully adhere to that specification. We address these challenges through a set of inference rules carefully designed to capture real-world coding patterns, yielding an effective fixed-point-based inference algorithm. We have implemented our inference algorithm in two different systems, targeting programs written in Java and C#. In an experimental evaluation, our technique inferred 85.5% of the annotations that programmers had written manually for the benchmarks. Further, the verifier issued nearly the same rate of false alarms with the manually-written and automatically-inferred annotations.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622858", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Narges", + "last_name": "Shadab", + "institution": "University of California, Riverside" + }, + { + "first_name": "Pritam", + "last_name": "Gharat", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Shrey", + "last_name": "Tiwari", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Michael D.", + "last_name": "Ernst", + "institution": "University of Washington" + }, + { + "first_name": "Martin", + "last_name": "Kellogg", + "institution": "New Jersey Institute of Technology" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "journals/pacmpl/ShadabGTEKLLS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622859", + "title": "Rapid: Region-Based Pointer Disambiguation", + "abstract": "Interprocedural alias analyses often sacrifice precision for scalability. Thus, modern compilers such as GCC and LLVM implement more scalable but less precise intraprocedural alias analyses. This compromise makes the compilers miss out on potential optimization opportunities, affecting the performance of the application. Modern compilers implement loop-versioning with dynamic checks for pointer disambiguation to enable the missed optimizations. Polyhedral access range analysis and symbolic range analysis enable 𝑂 (1) range checks for non-overlapping of memory accesses inside loops. However, these approaches work only for the loops in which the loop bounds are loop invariants. To address this limitation, researchers proposed a technique that requires 𝑂 (𝑙𝑜𝑔 𝑛) memory accesses for pointer disambiguation. Others improved the performance of dynamic checks to single memory access by constraining the object size and alignment. However, the former approach incurs noticeable overhead due to its dynamic checks, whereas the latter has a noticeable allocator overhead. Thus, scalability remains a challenge. In this work, we present a tool, Rapid, that further reduces the overheads of the allocator and dynamic checks proposed in the existing approaches. The key idea is to identify objects that need disambiguation checks using a profiler and allocate them in different regions, which are disjoint memory areas. The disambiguation checks simply compare the regions corresponding to the objects. The regions are aligned such that the top 32 bits in the addresses of any two objects allocated in different regions are always different. As a consequence, the dynamic checks do not require any memory access to ensure that the objects belong to different regions, making them efficient. Rapid achieved a maximum performance benefit of around 52.94% for Polybench and 1.88% for CPU SPEC 2017 benchmarks. The maximum CPU overhead of our allocator is 0.57% with a geometric mean of -0.2% for CPU SPEC 2017 benchmarks. Due to the low overhead of the allocator and dynamic checks, Rapid could improve the performance of 12 out of 16 CPU SPEC 2017 benchmarks. In contrast, a state-of-the-art approach used in the comparison could improve only five CPU SPEC 2017 benchmarks.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622859", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Khushboo", + "last_name": "Chitre", + "institution": "Indraprastha Institute of Information Technology Delhi" + }, + { + "first_name": "Piyus", + "last_name": "Kedia", + "institution": "Indraprastha Institute of Information Technology Delhi" + }, + { + "first_name": "Rahul", + "last_name": "Purandare", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "journals/pacmpl/ChitreKP23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622860", + "title": "Gradual Typing for Effect Handlers", + "abstract": "We present a gradually typed language, GrEff, with effects and handlers that supports migration from unchecked to checked effect typing. This serves as a simple model of the integration of an effect typing discipline with an existing effectful typed language that does not track fine-grained effect information. Our language supports a simple module system to model the programming model of gradual migration from unchecked to checked effect typing in the style of Typed Racket. The surface language GrEff is given semantics by elaboration to a core language Core GrEff. We equip Core GrEff with an inequational theory for reasoning about the semantic error ordering and desired program equivalences for programming with effects and handlers. We derive an operational semantics for the language from the equations provable in the theory. We then show that the theory is sound by constructing an operational logical relations model to prove the graduality theorem. This extends prior work on embedding-projection pair models of gradual typing to handle effect typing and subtyping.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622860", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Max S.", + "last_name": "New", + "institution": "University of Michigan" + }, + { + "first_name": "Eric", + "last_name": "Giovannini", + "institution": "University of Michigan" + }, + { + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Wesleyan University" + } + ], + "dblp_key": "journals/pacmpl/NewGL23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622861", + "title": "Synthesizing Specifications", + "abstract": "Every program should be accompanied by a specification that describes important aspects of the code's behavior, but writing good specifications is often harder than writing the code itself. This paper addresses the problem of synthesizing specifications automatically, guided by user-supplied inputs of two kinds: i) a query posed about a set of function definitions, and ii) a domain-specific language L in which the extracted property is to be expressed (we call properties in the language L-properties). Each of the property is a best L-property for the query: there is no other L-property that is strictly more precise. Furthermore, the set of synthesized L-properties is exhaustive: no more L-properties can be added to it to make the conjunction more precise. We implemented our method in a tool, Spyro. The ability to modify both the query and L provides a Spyro user with ways to customize the kind of specification to be synthesized. We use this ability to show that Spyro can be used in a variety of applications, such as mining program specifications, performing abstract-domain operations, and synthesizing algebraic properties of program modules.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622861", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kanghee", + "last_name": "Park", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/ParkDR23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622862", + "title": "Compositional Verification of Efficient Masking Countermeasures against Side-Channel Attacks", + "abstract": "Masking is one of the most effective countermeasures for securely implementing cryptographic algorithms against power side-channel attacks, the design of which however turns out to be intricate and error-prone. While techniques have been proposed to rigorously verify implementations of cryptographic algorithms, currently they are limited in scalability. To address this issue, compositional approaches have been investigated, but insofar they fail to prove the security of recent efficient implementations. To fill this gap, we propose a novel compositional verification approach. In particular, we introduce two new language-level security notions based on which we propose composition strategies and verification algorithms. Our approach is able to prove efficient implementations, which cannot be done by prior compositional approaches. We implement our approach as a tool CONVINCE and conduct extensive experiments to confirm its efficacy. We also use CONVINCE to further explore the design space of the AES Sbox with least refreshing by replacing its implementation for finite-field multiplication with more efficient counterparts. We automatically prove leakage-freeness of these new versions. As a result, we can effectively reduce 1,600 randomness and 3,200 XOR-operations of the state-of-the-art AES implementation.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622862", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pengfei", + "last_name": "Gao", + "institution": "ShanghaiTech University" + }, + { + "first_name": "Yedi", + "last_name": "Zhang", + "institution": "ShanghaiTech University" + }, + { + "first_name": "Fu", + "last_name": "Song", + "institution": "Institute of Software" + }, + { + "first_name": "Taolue", + "last_name": "Chen", + "institution": "Birkbeck, University of London" + }, + { + "first_name": "François‐Xavier", + "last_name": "Standaert", + "institution": "UCLouvain" + } + ], + "dblp_key": "journals/pacmpl/GaoZSCS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622863", + "title": "Data Extraction via Semantic Regular Expression Synthesis", + "abstract": "Many data extraction tasks of practical relevance require not only syntactic pattern matching but also semantic reasoning about the content of the underlying text. While regular expressions are very well suited for tasks that require only syntactic pattern matching, they fall short for data extraction tasks that involve both a syntactic and semantic component. To address this issue, we introduce semantic regexes, a generalization of regular expressions that facilitates combined syntactic and semantic reasoning about textual data. We also propose a novel learning algorithm that can synthesize semantic regexes from a small number of positive and negative examples. Our proposed learning algorithm uses a combination of neural sketch generation and compositional type-directed synthesis for fast and effective generalization from a small number of examples. We have implemented these ideas in a new tool called Smore and evaluated it on representative data extraction tasks involving several textual datasets. Our evaluation shows that semantic regexes can better support complex data extraction tasks than standard regular expressions and that our learning algorithm significantly outperforms existing tools, including state-of-the-art neural networks and program synthesis tools.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622863", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qiaochu", + "last_name": "Chen", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Arko", + "last_name": "Banerjee", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Çağatay", + "last_name": "Demiralp", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Greg", + "last_name": "Durrett", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/ChenBDDD23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622864", + "title": "Counterexample Driven Quantifier Instantiations with Applications to Distributed Protocols", + "abstract": "Formally verifying infinite-state systems can be a daunting task, especially when it comes to reasoning about quantifiers. In particular, quantifier alternations in conjunction with function symbols can create function cycles that result in infinitely many ground terms, making it difficult for solvers to instantiate quantifiers and causing them to diverge. This can leave users with no useful information on how to proceed. To address this issue, we propose an interactive verification methodology that uses a relational abstraction technique to mitigate solver divergence in the presence of quantifiers. This technique abstracts functions in the verification conditions (VCs) as one-to-one relations, which avoids the creation of function cycles and the resulting proliferation of ground terms. Relational abstraction is sound and guarantees correctness if the solver cannot find counter-models. However, it may also lead to false counterexamples, which can be addressed by refining the abstraction and requiring the existence of corresponding elements. In the domain of distributed protocols, we can refine the abstraction by diagnosing counterexamples and manually instantiating elements in the range of the original function. If the verification conditions are correct, there always exist finitely many refinement steps that eliminate all spurious counter-models, making the approach complete. We applied this approach in Ivy to verify the safety properties of consensus protocols and found that: (1) most verification goals can be automatically verified using relational abstraction, while SMT solvers often diverge when given the original VC, (2) only a few manual instantiations were needed, and the counterexamples provided valuable guidance for the user compared to timeouts produced by the traditional approach, and (3) the technique can be used to derive efficient low-level implementations of tricky algorithms.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622864", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Orr", + "last_name": "Tamir", + "institution": "Tel Aviv University" + }, + { + "first_name": "Marcelo", + "last_name": "Taube", + "institution": "Tel Aviv University" + }, + { + "first_name": "Kenneth L.", + "last_name": "McMillan", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + }, + { + "first_name": "Jon", + "last_name": "Howell", + "institution": "Bellevue Hospital Center" + }, + { + "first_name": "Guy Golan", + "last_name": "Gueta", + "institution": "Herzliya Medical Center" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/TamirTMSHGS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622865", + "title": "Historia: Refuting Callback Reachability with Message-History Logics", + "abstract": "This paper considers the callback reachability problem --- determining if a callback can be called by an event-driven framework in an unexpected state. Event-driven programming frameworks are pervasive for creating user-interactive applications (apps) on just about every modern platform. Control flow between callbacks is determined by the framework and largely opaque to the programmer. This opacity of the callback control flow not only causes difficulty for the programmer but is also difficult for those developing static analysis. Previous static analysis techniques address this opacity either by assuming an arbitrary framework implementation or attempting to eagerly specify all possible callback control flow, but this is either too coarse to prove properties requiring callback-ordering constraints or too burdensome and tricky to get right. Instead, we present a middle way where the callback control flow can be gradually refined in a targeted manner to prove assertions of interest. The key insight to get this middle way is by reasoning about the history of method invocations at the boundary between app and framework code --- enabling a decoupling of the specification of callback control flow from the analysis of app code. We call the sequence of such boundary-method invocations message histories and develop message-history logics to do this reasoning. In particular, we define the notion of an application-only transition system with boundary transitions, a message-history program logic for programs with such transitions, and a temporal specification logic for capturing callback control flow in a targeted and compositional manner. Then to utilize the logics in a goal-directed verifier, we define a way to combine after-the-fact an assertion about message histories with a specification of callback control flow. We implemented a prototype message history-based verifier called Historia and provide evidence that our approach is uniquely capable of distinguishing between buggy and fixed versions on challenging examples drawn from real-world issues and that our targeted specification approach enables proving the absence of multi-callback bug patterns in real-world open-source Android apps.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622865", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shawn", + "last_name": "Meier", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Sergio", + "last_name": "Mover", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/MeierMKC23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622852", + "title": "When Concurrency Matters: Behaviour-Oriented Concurrency", + "abstract": "Expressing parallelism and coordination is central for modern concurrent programming. Many mechanisms exist for expressing both parallelism and coordination. However, the design decisions for these two mechanisms are tightly intertwined. We believe that the interdependence of these two mechanisms should be recognised and achieved through a single, powerful primitive. We are not the first to realise this: the prime example is actor model programming, where parallelism arises through fine-grained decomposition of a program’s state into actors that are able to execute independently in parallel. However, actor model programming has a serious pain point: updating multiple actors as a single atomic operation is a challenging task. We address this pain point by introducing a new concurrency paradigm: Behaviour-Oriented Concurrency (BoC). In BoC, we are revisiting the fundamental concept of a behaviour to provide a more transactional concurrency model. BoC enables asynchronously creating atomic and ordered units of work with exclusive access to a collection of independent resources. In this paper, we describe BoC informally in terms of examples, which demonstrate the advantages of exclusive access to several independent resources, as well as the need for ordering. We define it through a formal model. We demonstrate its practicality by implementing a C++ runtime. We argue its applicability through the Savina benchmark suite: benchmarks in this suite can be more compactly represented using BoC in place of Actors, and we observe comparable, if not better, performance.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622852", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luke", + "last_name": "Cheeseman", + "institution": "Imperial College London" + }, + { + "first_name": "Matthew", + "last_name": "Parkinson", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Sylvan", + "last_name": "Clebsch", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Marios", + "last_name": "Kogias", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + }, + { + "first_name": "David", + "last_name": "Chisnall", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + }, + { + "first_name": "Paul", + "last_name": "Liétar", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "journals/pacmpl/CheesemanPCKDCWL23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622866", + "title": "P4R-Type: A Verified API for P4 Control Plane Programs", + "abstract": "Software-Defined Networking (SDN) significantly simplifies programming, reconfiguring, and optimizing network devices, such as switches and routers. The de facto standard for programming SDN devices is the P4 language. However, the flexibility and power of P4, and SDN more generally, gives rise to important risks. As a number of incidents at major cloud providers have shown, errors in SDN programs can compromise the availability of networks, leaving them in a non-functional state. The focus of this paper are errors in control-plane programs that interact with P4-enabled network devices via the standardized P4Runtime API. For clients of the P4Runtime API it is easy to make mistakes that may lead to catastrophic failures, despite the use of Google’s Protocol Buffers as an interface definition language. This paper proposes P4R-Type, a novel verified P4Runtime API for Scala that performs static checks for P4 control plane operations, ruling out mismatches between P4 tables, allowed actions, and action parameters. As a formal foundation of P4R-Type, we present the F P4R calculus and its typing system, which ensure that well-typed programs never get stuck by issuing invalid P4Runtime operations. We evaluate the safety and flexibility of P4R-Type with 3 case studies. To the best of our knowledge, this is the first work that formalises P4Runtime control plane applications, and a typing discipline ensuring the correctness of P4Runtime operations.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622866", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jens", + "last_name": "Larsen", + "institution": "Danish Geotechnical Society" + }, + { + "first_name": "Roberto", + "last_name": "Guanciale", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Philipp", + "last_name": "Haller", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "Danish Geotechnical Society" + } + ], + "dblp_key": "journals/pacmpl/LarsenGHS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622867", + "title": "Synthesizing Precise Static Analyzers for Automatic Differentiation", + "abstract": "We present Pasado, a technique for synthesizing precise static analyzers for Automatic Differentiation. Our technique allows one to automatically construct a static analyzer specialized for the Chain Rule, Product Rule, and Quotient Rule computations for Automatic Differentiation in a way that abstracts all of the nonlinear operations of each respective rule simultaneously. By directly synthesizing an abstract transformer for the composite expressions of these 3 most common rules of AD, we are able to obtain significant precision improvement compared to prior works which compose standard abstract transformers together suboptimally. We prove our synthesized static analyzers sound and additionally demonstrate the generality of our approach by instantiating these AD static analyzers with different nonlinear functions, different abstract domains (both intervals and zonotopes) and both forward-mode and reverse-mode AD. We evaluate Pasado on multiple case studies, namely soundly computing bounds on a neural network’s local Lipschitz constant, soundly bounding the sensitivities of financial models, certifying monotonicity, and lastly, bounding sensitivities of the solutions of differential equations from climate science and chemistry for verified ranges of initial conditions and parameters. The local Lipschitz constants computed by Pasado on our largest CNN are up to 2750× more precise compared to the existing state-of-the-art zonotope analysis. The bounds obtained on the sensitivities of the climate, chemical, and financial differential equation solutions are between 1.31 − 2.81× more precise (on average) compared to a state-of-the-art zonotope analysis.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622867", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Laurel", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "S.", + "last_name": "Qian", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/LaurelQSM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622868", + "title": "Exploiting the Sparseness of Control-Flow and Call Graphs for Efficient and On-Demand Algebraic Program Analysis", + "abstract": "Algebraic Program Analysis (APA) is a ubiquitous framework that has been employed as a unifying model for various problems in data-flow analysis, termination analysis, invariant generation, predicate abstraction and a wide variety of other standard static analysis tasks. APA models program summaries as elements of a regular algebra . Suppose that a summary in A is assigned to every transition of the program and that we aim to compute the effect of running the program starting at line s and ending at line t . APA first computes a regular expression capturing all program paths of interest. In case of intraprocedural analysis, models all paths from s to t , whereas in the interprocedural case it models all interprocedurally-valid paths, i.e. ‍paths that go back to the right caller function when a callee returns. This regular expression is then interpreted over the algebra to obtain the desired result. Suppose the program has n lines of code and each evaluation of an operation in the regular algebra takes O ( k ) time. It is well-known that a single APA query, or a set of queries with the same starting point s , can be answered in O ( n · α( n ) · k ), where α is the inverse Ackermann function. In this work, we consider an on-demand setting for APA: the program is given in the input and can be preprocessed. The analysis has to then answer a large number of on-line queries, each providing a pair ( s , t ) of program lines which are the start and end point of the query, respectively. The goal is to avoid the significant cost of running a fresh APA instance for each query. Our main contribution is a series of algorithms that, after a lightweight preprocessing of O ( n · lg n · k ), answer each query in O ( k ) time. In other words, our preprocessing has almost the same asymptotic complexity as a single APA query, except for a sub-logarithmic factor, and then every future query is answered instantly, i.e. ‍by a constant number of operations in the algebra. We achieve this remarkable speedup by relying on certain structural sparsity properties of control-flow and call graphs (CFGs and CGs). Specifically, we exploit the fact that control-flow graphs of real-world programs have a tree-like structure and bounded treewidth and nesting depth and that their call graphs have small treedepth in comparison to the size of the program. Finally, we provide experimental results demonstrating the effectiveness and efficiency of our approach and showing that it beats the runtime of classical APA by several orders of magnitude.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622868", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Giovanna Kobus", + "last_name": "Conrado", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Kerim", + "last_name": "Kochekov", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Yun Chen", + "last_name": "Tsai", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Ahmed Khaled", + "last_name": "Zaher", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ConradoGKTZ23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622869", + "title": "Saggitarius: A DSL for Specifying Grammatical Domains", + "abstract": "Common data types like dates, addresses, phone numbers and tables can have multiple textual representations, and many heavily-used languages, such as SQL, come in several dialects. These variations can cause data to be misinterpreted, leading to silent data corruption, failure of data processing systems, or even security vulnerabilities. Saggitarius is a new language and system designed to help programmers reason about the format of data, by describing grammatical domains---that is, sets of context-free grammars that describe the many possible representations of a datatype. We describe the design of Saggitarius via example and provide a relational semantics. We show how Saggitarius may be used to analyze a data set: given example data, it uses an algorithm based on semi-ring parsing and MaxSAT to infer which grammar in a given domain best matches that data. We evaluate the effectiveness of the algorithm on a benchmark suite of 110 example problems, and we demonstrate that our system typically returns a satisfying grammar within a few seconds with only a small number of examples. We also delve deeper into a more extensive case study on using Saggitarius for CSV dialect detection. Despite being general-purpose, we find that Saggitarius offers comparable results to hand-tuned, specialized tools; in the case of CSV, it infers grammars for 84% of benchmarks within 60 seconds, and has comparable accuracy to custom-built dialect detection tools.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622869", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anders", + "last_name": "Miltner", + "institution": "Simon Fraser University" + }, + { + "first_name": "Devon", + "last_name": "Loehr", + "institution": "Princeton University" + }, + { + "first_name": "A.C.", + "last_name": "Mong", + "institution": "Princeton University" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + }, + { + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/MiltnerLMFW23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622871", + "title": "Greedy Implicit Bounded Quantification", + "abstract": "Mainstream object-oriented programming languages such as Java, Scala, C#, or TypeScript have polymorphic type systems with subtyping and bounded quantification. Bounded quantification, despite being a pervasive and widely used feature, has attracted little research work on type-inference algorithms to support it. A notable exception is local type inference, which is the basis of most current implementations of type inference for mainstream languages. However, support for bounded quantification in local type inference has important restrictions, and its non-algorithmic specification is complex. In this paper, we present a variant of kernel F ≤ , which is the canonical calculus with bounded quantification, with implicit polymorphism. Our variant, called F ≤ b , comes with a declarative and an algorithmic formulation of the type system. The declarative type system is based on previous work on bidirectional typing for predicative higher-rank polymorphism and a greedy approach to implicit instantiation. This allows for a clear declarative specification where programs require few type annotations and enables implicit polymorphism where applications omit type parameters. Just as local type inference, explicit type applications are also available in F ≤ b if desired. This is useful to deal with impredicative instantiations, which would not be allowed otherwise in F ≤ b . Due to the support for impredicative instantiations, we can obtain a completeness result with respect to kernel F ≤ , showing that all the well-typed kernel F ≤ programs can type-check in F ≤ b . The corresponding algorithmic version of the type system is shown to be sound, complete, and decidable. All the results have been mechanically formalized in the Abella theorem prover.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622871", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chen", + "last_name": "Cui", + "institution": "University of Hong Kong" + }, + { + "first_name": "Shengyi", + "last_name": "Jiang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/CuiJO23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622876", + "title": "Message Chains for Distributed System Verification", + "abstract": "Verification of asynchronous distributed programs is challenging due to the need to reason about numerous control paths resulting from the myriad interleaving of messages and failures. In this paper, we propose an automated bookkeeping method based on message chains. Message chains reveal structure in asynchronous distributed system executions and can help programmers verify their systems at the message passing level of abstraction. To evaluate our contributions empirically we build a verification prototype for the P programming language that integrates message chains. We use it to verify 16 benchmarks from related work, one new benchmark that exemplifies the kinds of systems our method focuses on, and two industrial benchmarks. We find that message chains are able to simplify existing proofs and our prototype performs comparably to existing work in terms of runtime. We extend our work with support for specification mining and find that message chains provide enough structure to allow existing learning and program synthesis tools to automatically infer meaningful specifications using only execution examples.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622876", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Federico", + "last_name": "Mora", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Ankush", + "last_name": "Desai", + "institution": "Amazon (United States)" + }, + { + "first_name": "Elizabeth", + "last_name": "Polgreen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sanjit A.", + "last_name": "Seshia", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "journals/pacmpl/MoraDPS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622872", + "title": "Solving String Constraints with Lengths by Stabilization", + "abstract": "We present a new algorithm for solving string constraints. The algorithm builds upon a recent method for solving word equations and regular constraints that interprets string variables as languages rather than strings and, consequently, mitigates the combinatorial explosion that plagues other approaches. We extend the approach to handle linear integer arithmetic length constraints by combination with a known principle of equation alignment and splitting, and by extension to other common types of string constraints, yielding a fully-fledged string solver. The ability of the framework to handle unrestricted disequalities even extends one of the largest decidable classes of string constraints, the chain-free fragment. We integrate our algorithm into a DPLL-based SMT solver. The performance of our implementation is competitive and even significantly better than state-of-the-art string solvers on several established benchmarks obtained from applications in verification of string programs.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622872", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yu‐Fang", + "last_name": "Chen", + "institution": "Academia Sinica" + }, + { + "first_name": "David", + "last_name": "Chocholatý", + "institution": "Brno University of Technology" + }, + { + "first_name": "Vojtěch", + "last_name": "Havlena", + "institution": "Brno University of Technology" + }, + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" + }, + { + "first_name": "Ondřej", + "last_name": "Lengál", + "institution": "Brno University of Technology" + }, + { + "first_name": "Juraj", + "last_name": "Síč", + "institution": "Brno University of Technology" + } + ], + "dblp_key": "journals/pacmpl/ChenCHHLS23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622873", + "title": "Type-Safe Dynamic Placement with First-Class Placed Values", + "abstract": "Several distributed programming language solutions have been proposed to reason about the placement of data, computations, and peers interaction. Such solutions include, among the others, multitier programming, choreographic programming and various approaches based on behavioral types. These methods statically ensure safety properties thanks to a complete knowledge about placement of data and computation at compile time. In distributed systems, however, dynamic placement of computation and data is crucial to enable performance optimizations, e.g., driven by data locality or in presence of a number of other constraints such as security and compliance regarding data storage location. Unfortunately, in existing programming languages, dynamic placement conflicts with static reasoning about distributed programs: the flexibility required by dynamic placement hinders statically tracking the location of data and computation. In this paper we present Dyno, a programming language that enables static reasoning about dynamic placement. Dyno features a type system where values are explicitly placed, but in contrast to existing approaches, placed values are also first class, ensuring that they can be passed around and referred to from other locations. Building on top of this mechanism, we provide a novel interpretation of dynamic placement as unions of placement types. We formalize type soundness, placement correctness (as part of type soundness) and architecture conformance. In case studies and benchmarks, our evaluation shows that Dyno enables static reasoning about programs even in presence of dynamic placement, ensuring type safety and placement correctness of programs at negligible performance cost. We reimplement an Android app with ∼ 7 K LOC in Dyno, find a bug in the existing implementation, and show that the app's approach is representative of a common way to implement dynamic placement found in over 100 apps in a large open-source app store.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622873", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "George", + "last_name": "Zakhour", + "institution": "University of St.Gallen" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "University of St.Gallen" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "University of St.Gallen" + } + ], + "dblp_key": "journals/pacmpl/ZakhourWS23a", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622874", + "title": "Explainable Program Synthesis by Localizing Specifications", + "abstract": "The traditional formulation of the program synthesis problem is to find a program that meets a logical correctness specification. When synthesis is successful, there is a guarantee that the implementation satisfies the specification. Unfortunately, synthesis engines are typically monolithic algorithms, and obscure the correspondence between the specification, implementation and user intent. In contrast, humans often include comments in their code to guide future developers towards the purpose and design of different parts of the codebase. In this paper, we introduce subspecifications as a mechanism to augment the synthesized implementation with explanatory notes of this form. In this model, the user may ask for explanations of different parts of the implementation; the subspecification generated in response is a logical formula that describes the constraints induced on that subexpression by the global specification and surrounding implementation. We develop algorithms to construct and verify subspecifications and investigate their theoretical properties. We perform an experimental evaluation of the subspecification generation procedure, and measure its effectiveness and running time. Finally, we conduct a user study to determine whether subspecifications are useful: we find that subspecifications greatly aid in understanding the global specification, in identifying alternative implementations, and in debugging faulty implementations.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622874", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Amirmohammad", + "last_name": "Nazari", + "institution": "University of Southern California" + }, + { + "first_name": "Y.", + "last_name": "Huang", + "institution": "University of Southern California" + }, + { + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Arjun", + "last_name": "Radhakrishna", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "University of Southern California" + } + ], + "dblp_key": "journals/pacmpl/NazariHSRR23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622875", + "title": "Perception Contracts for Safety of ML-Enabled Systems", + "abstract": "We introduce a novel notion of perception contracts to reason about the safety of controllers that interact with an environment using neural perception. Perception contracts capture errors in ground-truth estimations that preserve invariants when systems act upon them. We develop a theory of perception contracts and design symbolic learning algorithms for synthesizing them from a finite set of images. We implement our algorithms and evaluate synthesized perception contracts for two realistic vision-based control systems, a lane tracking system for an electric vehicle and an agricultural robot that follows crop rows. Our evaluation shows that our approach is effective in synthesizing perception contracts and generalizes well when evaluated over test images obtained during runtime monitoring of the systems.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622875", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Angello", + "last_name": "Astorga", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Chiao", + "last_name": "Hsieh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Sayan", + "last_name": "Mitra", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/AstorgaHMM23", + "venue": "oopsla", + "year": 2023 + }, + { + "paper_id": "10.1145/3622870", + "title": "A Deductive Verification Infrastructure for Probabilistic Programs", + "abstract": "This paper presents a quantitative program verification infrastructure for discrete probabilistic programs. Our infrastructure can be viewed as the probabilistic analogue of Boogie: its central components are an intermediate verification language (IVL) together with a real-valued logic. Our IVL provides a programming-language-style for expressing verification conditions whose validity implies the correctness of a program under investigation. As our focus is on verifying quantitative properties such as bounds on expected outcomes, expected run-times, or termination probabilities, off-the-shelf IVLs based on Boolean first-order logic do not suffice. Instead, a paradigm shift from the standard Boolean to a real-valued domain is required. Our IVL features quantitative generalizations of standard verification constructs such as assume- and assert-statements. Verification conditions are generated by a weakest-precondition-style semantics, based on our real-valued logic. We show that our verification infrastructure supports natural encodings of numerous verification techniques from the literature. With our SMT-based implementation, we automatically verify a variety of benchmarks. To the best of our knowledge, this establishes the first deductive verification infrastructure for expectation-based reasoning about probabilistic programs.", + "date": "2023-10-16", + "link": "https://doi.org/10.1145/3622870", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philipp", + "last_name": "Schröer", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "Danish Geotechnical Society" + } + ], + "dblp_key": "journals/pacmpl/SchroerBKKM23", + "venue": "oopsla", + "year": 2023 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2024.json b/data/pl_conferences/oopsla/2024.json new file mode 100644 index 0000000..e8db6b8 --- /dev/null +++ b/data/pl_conferences/oopsla/2024.json @@ -0,0 +1,5026 @@ +[ + { + "paper_id": "10.1145/3649820", + "title": "Compiling Recurrences over Dense and Sparse Arrays", + "abstract": "We present a framework for compiling recurrence equations into native code. In our framework, users specify a system of recurrences, the types of data structures that store inputs and outputs, and scheduling commands for optimization. Our compiler then lowers these specifications into native code that respects the dependencies in the recurrence equations. Our compiler can generate code over both sparse and dense data structures, and determines if the recurrence system is solvable with the provided scheduling primitives. We evaluate the performance and correctness of the generated code on several recurrences, from domains as diverse as dense and sparse matrix solvers, dynamic programming, graph problems, and sparse tensor algebra. We demonstrate that the generated code has competitive performance to hand-optimized implementations in libraries. However, these handwritten libraries target specific recurrences, specific data structures, and specific optimizations. Our system, on the other hand, automatically generates implementations from recurrences, data formats, and schedules, giving our system more generality than library approaches.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649820", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shiv", + "last_name": "Sundram", + "institution": "Stanford University" + }, + { + "first_name": "Muhammad Usman", + "last_name": "Tariq", + "institution": "Stanford University" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/SundramTK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649825", + "title": "CYCLE: Learning to Self-Refine the Code Generation", + "abstract": "Pre-trained code language models have achieved promising performance in code generation and improved the programming efficiency of human developers. However, their self-refinement capability is typically overlooked by the existing evaluations of code LMs, which focus only on the accuracy of the one-time prediction. For the cases when code LMs fail to implement the correct program, developers actually find it hard to debug and fix the faulty prediction since it is not written by the developers themselves. Unfortunately, our study reveals that code LMs cannot efficiently self-refine their faulty generations as well. In this paper, we propose CYCLE framework, learning to self-refine the faulty generation according to the available feedback, such as the execution results reported by the test suites. We evaluate CYCLE on three popular code generation benchmarks, HumanEval, MBPP, and APPS. The results reveal that CYCLE successfully maintains, sometimes improves, the quality of one-time code generation, while significantly improving the self-refinement capability of code LMs. We implement four variants of CYCLE with varied numbers of parameters across 350M, 1B, 2B, and 3B, and the experiments show that CYCLE consistently boosts the code generation performance, by up to 63.5", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649825", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yangruibo", + "last_name": "Ding", + "institution": "Columbia University" + }, + { + "first_name": "Marcus J.", + "last_name": "Min", + "institution": "Columbia University" + }, + { + "first_name": "Gail E.", + "last_name": "Kaiser", + "institution": "Columbia University" + }, + { + "first_name": "Baishakhi", + "last_name": "Ray", + "institution": "Columbia University" + } + ], + "dblp_key": "journals/pacmpl/DingMKR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649812", + "title": "Profiling Programming Language Learning", + "abstract": "This paper documents a year-long experiment to “profile” the process of learning a programming language: gathering data to understand what makes a language hard to learn, and using that data to improve the learning process. We added interactive quizzes to The Rust Programming Language, the official textbook for learning Rust. Over 13 months, 62,526 readers answered questions 1,140,202 times. First, we analyze the trajectories of readers. We find that many readers drop-out of the book early when faced with difficult language concepts like Rust’s ownership types. Second, we use classical test theory and item response theory to analyze the characteristics of quiz questions. We find that better questions are more conceptual in nature, such as asking why a program does not compile vs. whether a program compiles. Third, we performed 12 interventions into the book to help readers with difficult questions. We find that on average, interventions improved quiz scores on the targeted questions by +20", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649812", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Will", + "last_name": "Crichton", + "institution": "Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "journals/pacmpl/CrichtonK24a", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649823", + "title": "Identifying and Correcting Programming Language Behavior Misconceptions", + "abstract": "Misconceptions about core linguistic concepts like mutable variables, mutable compound data, and their interaction with scope and higher-order functions seem to be widespread. But how do we detect them, given that experts have blind spots and may not realize the myriad ways in which students can misunderstand programs? Furthermore, once identified, what can we do to correct them? In this paper, we present a curated list of misconceptions, and an instrument to detect them. These are distilled from student work over several years and match and extend prior research. We also present an automated, self-guided tutoring system. The tutor builds on strategies in the education literature and is explicitly designed around identifying and correcting misconceptions. We have tested the tutor in multiple settings. Our data consistently show that (a) the misconceptions we tackle are widespread, and (b) the tutor appears to improve understanding.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649823", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kuang-Chen", + "last_name": "Lu", + "institution": "Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "journals/pacmpl/LuK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649813", + "title": "Synthetiq: Fast and Versatile Quantum Circuit Synthesis", + "abstract": "To implement quantum algorithms on quantum computers it is crucial to decompose their operators into the limited gate set supported by those computers. Unfortunately, existing works automating this essential task are generally slow and only applicable to narrow use cases.We present Synthetiq, a method to synthesize quantum circuits implementing a given specification over arbitrary finite gate sets, which is faster and more versatile than existing works. Synthetiq utilizes Simulated Annealing instantiated with a novel, domain-specific energy function that allows developers to leverage partial specifications for better efficiency. Synthetiq further couples this synthesis method with a custom simplification pass, to ensure efficiency of the found circuits. We experimentally demonstrate that Synthetiq can generate better implementations than were previously known for multiple relevant quantum operators including RCCCX, CCT, CCiSWAP, C√SWAP, and C√iSWAP. Our extensive evaluation also demonstrates Synthetiq frequently outperforms a wide variety of more specialized tools in their own domains, including (i) ‍the well-studied task of synthesizing fully specified operators in the Clifford+T gate set, (ii) ‍є-approximate synthesis of multi-qubit operators in the same gate set, and (iii) ‍synthesis tasks with custom gate sets. On all those tasks, Synthetiq is typically one to two orders of magnitude faster than previous state-of-the-art and can tackle problems that were previously out of the reach of any synthesis tool.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649813", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anouk", + "last_name": "Paradis", + "institution": "ETH Zurich" + }, + { + "first_name": "Jasper", + "last_name": "Dekoninck", + "institution": "ETH Zurich" + }, + { + "first_name": "Benjamin", + "last_name": "Bichsel", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/ParadisDBV24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649815", + "title": "Finding Cross-Rule Optimization Bugs in Datalog Engines", + "abstract": "Datalog is a popular and widely-used declarative logic programming language. Datalog engines apply many cross-rule optimizations; bugs in them can cause incorrect results. To detect such optimization bugs, we propose an automated testing approach called Incremental Rule Evaluation (IRE), which synergistically tackles the test oracle and test case generation problem. The core idea behind the test oracle is to compare the results of an optimized program and a program without cross-rule optimization; any difference indicates a bug in the Datalog engine. Our core insight is that, for an optimized, incrementally-generated Datalog program, we can evaluate all rules individually by constructing a reference program to disable the optimizations that are performed among multiple rules. Incrementally generating test cases not only allows us to apply the test oracle for every new rule generated—we also can ensure that every newly added rule generates a non-empty result with a given probability and eschew recomputing already-known facts. We implemented IRE as a tool named Deopt, and evaluated Deopt on four mature Datalog engines, namely Soufflé, CozoDB, μZ, and DDlog, and discovered a total of 30 bugs. Of these, 13 were logic bugs, while the remaining were crash and error bugs. Deopt can detect all bugs found by queryFuzz, a state-of-the-art approach. Out of the bugs identified by Deopt, queryFuzz might be unable to detect 5. Our incremental test case generation approach is efficient; for example, for test cases containing 60 rules, our incremental approach can produce 1.17× (for DDlog) to 31.02× (for Soufflé) as many valid test cases with non-empty results as the naive random method. We believe that the simplicity and the generality of the approach will lead to its wide adoption in practice.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649815", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "C.", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Manuel", + "last_name": "Rigger", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/ZhangWR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649811", + "title": "Quantum Control Machine: The Limits of Control Flow in Quantum Programming", + "abstract": "Quantum algorithms for tasks such as factorization, search, and simulation rely on control flow such as branching and iteration that depends on the value of data in superposition. High-level programming abstractions for control flow, such as switches, loops, higher-order functions, and continuations, are ubiquitous in classical languages. By contrast, many quantum languages do not provide high-level abstractions for control flow in superposition, and instead require the use of hardware-level logic gates to implement such control flow. The reason for this gap is that whereas a classical computer supports control flow abstractions using a program counter that can depend on data, the typical architecture of a quantum computer does not analogously provide a program counter that can depend on data in superposition. As a result, the complete set of control flow abstractions that can be correctly realized on a quantum computer has not yet been established. In this work, we provide a complete characterization of the properties of control flow abstractions that are correctly realizable on a quantum computer. First, we prove that even on a quantum computer whose program counter exists in superposition, one cannot correctly realize control flow in quantum algorithms by lifting the classical conditional jump instruction to work in superposition. This theorem denies the ability to directly lift general abstractions for control flow such as the λ-calculus from classical to quantum programming. In response, we present the necessary and sufficient conditions for control flow to be correctly realizable on a quantum computer. We introduce the quantum control machine, an instruction set architecture featuring a conditional jump that is restricted to satisfy these conditions. We show how this design enables a developer to correctly express control flow in quantum algorithms using a program counter in place of logic gates.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649811", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Charles", + "last_name": "Yuan", + "institution": "Vassar College" + }, + { + "first_name": "Agnes", + "last_name": "Villanyi", + "institution": "Vassar College" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Vassar College" + } + ], + "dblp_key": "journals/pacmpl/YuanVC24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649817", + "title": "Cocoon: Static Information Flow Control in Rust", + "abstract": "Information flow control (IFC) provides confidentiality by enforcing noninterference, which ensures that high-secrecy values cannot affect low-secrecy values. Prior work introduces fine-grained IFC approaches that modify the programming language and use non-standard compilation tools, impose run-time overhead, or report false secrecy leaks—all of which hinder adoption. This paper presents Cocoon, a Rust library for static type-based IFC that uses the unmodified Rust language and compiler. The key insight of Cocoon lies in leveraging Rust’s type system and procedural macros to establish an effect system that enforces noninterference. A performance evaluation shows that using Cocoon increases compile time but has no impact on application performance. To demonstrate Cocoon’s utility, we retrofitted two popular Rust programs, the Spotify TUI client and Mozilla’s Servo browser engine, to use Cocoon to enforce limited confidentiality policies", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649817", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ada", + "last_name": "Lamba", + "institution": "The Ohio State University" + }, + { + "first_name": "Max", + "last_name": "Taylor", + "institution": "The Ohio State University" + }, + { + "first_name": "Vincent", + "last_name": "Beardsley", + "institution": "The Ohio State University" + }, + { + "first_name": "Jacob", + "last_name": "Bambeck", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Zhiqiang", + "last_name": "Lin", + "institution": "The Ohio State University" + } + ], + "dblp_key": "journals/pacmpl/LambaTBBBL24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649814", + "title": "A Learning-Based Approach to Static Program Slicing", + "abstract": "Traditional program slicing techniques are crucial for early bug detection and manual/automated debugging of online code snippets. Nevertheless, their inability to handle incomplete code hinders their real-world applicability in such scenarios. To overcome these challenges, we present NS-Slicer, a novel learning-based approach that predicts static program slices for both complete and partial code Our tool leverages a pre-trained language model to exploit its understanding of fine-grained variable-statement dependencies within source code. With this knowledge, given a variable at a specific location and a statement in a code snippet, NS-Slicer determines whether the statement belongs to the backward slice or forward slice, respectively. We conducted a series of experiments to evaluate NS-Slicer's performance. On complete code, it predicts the backward and forward slices with an F1-score of 97.41% and 95.82%, respectively, while achieving an overall F1-score of 96.77%. Notably, in 85.20% of the cases, the static program slices predicted by NS-Slicer exactly match entire slices from the oracle. For partial programs, it achieved an F1-score of 96.77%–97.49% for backward slicing, 92.14%–95.40% for forward slicing, and an overall F1-score of 94.66%–96.62%. Furthermore, we demonstrate NS-Slicer's utility in vulnerability detection (VD), integrating its predicted slices into an automated VD tool. In this setup, the tool detected vulnerabilities in Java code with a high F1-score of 73.38%. We also include the analyses studying NS-Slicer’s promising performance and limitations, providing insights into its understanding of intrinsic code properties such as variable aliasing, leading to better slicing.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649814", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aashish", + "last_name": "Yadavally", + "institution": "" + }, + { + "first_name": "Yi", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Shaohua", + "last_name": "Wang", + "institution": "Central University of Finance and Economics" + }, + { + "first_name": "Tien N.", + "last_name": "Nguyen", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/YadavallyLWN24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649822", + "title": "Newtonian Program Analysis of Probabilistic Programs", + "abstract": "Due to their quantitative nature, probabilistic programs pose non-trivial challenges for designing compositional and efficient program analyses. Many analyses for probabilistic programs rely on iterative approximation. This article presents an interprocedural dataflow-analysis framework, called NPA-PMA, for designing and implementing (partially) non-iterative program analyses of probabilistic programs with unstructured control-flow, nondeterminism, and general recursion. NPA-PMA is based on Newtonian Program Analysis (NPA), a generalization of Newton's method to solve equation systems over semirings. The key challenge for developing NPA-PMA is to handle multiple kinds of confluences in both the algebraic structures that specify analyses and the equation systems that encode control flow: semirings support a single confluence operation, whereas NPA-PMA involves three confluence operations (conditional, probabilistic, and nondeterministic). Our work introduces ω-continuous pre-Markov algebras (ωPMAs) to factor out common parts of different analyses; adopts regular infinite-tree expressions to encode probabilistic programs with unstructured control-flow; and presents a linearization method that makes Newton's method applicable to the setting of regular-infinite-tree equations over ωPMAs. NPA-PMA allows analyses to supply a non-iterative strategy to solve linearized equations. Our experimental evaluation demonstrates that (i) NPA-PMA holds considerable promise for outperforming Kleene iteration, and (ii) provides great generality for designing program analyses.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649822", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Peking University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/WangR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649821", + "title": "Outcome Separation Logic: Local Reasoning for Correctness and Incorrectness with Computational Effects", + "abstract": "Separation logic’s compositionality and local reasoning properties have led to significant advances in scalable static analysis. But program analysis has new challenges—many programs display computational effects and, orthogonally, static analyzers must handle incorrectness too. We present Outcome Separation Logic (OSL), a program logic that is sound for both correctness and incorrectness reasoning in programs with varying effects. OSL has a frame rule—just like separation logic—but uses different underlying assumptions that open up local reasoning to a larger class of properties than can be handled by any single existing logic. Building on this foundational theory, we also define symbolic execution algorithms that use bi-abduction to derive specifications for programs with effects. This involves a new tri-abduction procedure to analyze programs whose execution branches due to effects such as nondeterministic or probabilistic choice. This work furthers the compositionality promised by separation logic by opening up the possibility for greater reuse of analysis tools across two dimensions: bug-finding vs verification in programs with varying effects.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649821", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Noam", + "last_name": "Zilberstein", + "institution": "Cornell University" + }, + { + "first_name": "Angelina", + "last_name": "Saliling", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/ZilbersteinSS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649819", + "title": "HOL4P4: Mechanized Small-Step Semantics for P4", + "abstract": "We present the first semantics of the network data plane programming language P4 able to adequately capture all key features of P4 16 , the most recent version of P4, including external functions (externs) and concurrency. These features are intimately related since, in P4, extern invocations are the only points at which one execution thread can affect another. Reflecting P4’s lack of a general-purpose memory and the presence of multithreading the semantics is given in small-step style and eschews the use of a heap. In addition to the P4 language itself, we provide an architectural level semantics, which allows the composition of P4-programmed blocks, models end-to-end packet processing, and can take into account features such as arbitration and packet recirculation. A corresponding type system is provided with attendant progress, preservation, and type-soundness theorems. Semantics, type system, and meta-theory are formalized in the HOL4 theorem prover. From this formalization, we derive a HOL4 executable semantics that supports verified execution of programs with partially symbolic packets able to validate simple end-to-end program properties.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649819", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anoud", + "last_name": "Alshnakat", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Didrik", + "last_name": "Lundberg", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Roberto", + "last_name": "Guanciale", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Mads", + "last_name": "Dam", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AlshnakatLGD24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649824", + "title": "Quantitative Bounds on Resource Usage of Probabilistic Programs", + "abstract": "Cost analysis, also known as resource usage analysis, is the task of finding bounds on the total cost of a program and is a well-studied problem in static analysis. In this work, we consider two classical quantitative problems in cost analysis for probabilistic programs. The first problem is to find a bound on the expected total cost of the program. This is a natural measure for the resource usage of the program and can also be directly applied to average-case runtime analysis. The second problem asks for a tail bound, i.e. ‍given a threshold t the goal is to find a probability bound p such that ℙ[total cost ≥ t ] ≤ p . Intuitively, given a threshold t on the resource, the problem is to find the likelihood that the total cost exceeds this threshold. First, for expectation bounds, a major obstacle in previous works on cost analysis is that they can handle only non-negative costs or bounded variable updates. In contrast, we provide a new variant of the standard notion of cost martingales, that allows us to find expectation bounds for a class of programs with general positive or negative costs and no restriction on the variable updates. More specifically, our approach is applicable as long as there is a lower bound on the total cost incurred along every path. Second, for tail bounds, all previous methods are limited to programs in which the expected total cost is finite. In contrast, we present a novel approach, based on a combination of our martingale-based method for expectation bounds with a quantitative safety analysis, to obtain a solution to the tail bound problem that is applicable even to programs with infinite expected cost. Specifically, this allows us to obtain runtime tail bounds for programs that do not terminate almost-surely. In summary, we provide a novel combination of martingale-based cost analysis and quantitative safety analysis that is able to find expectation and tail cost bounds for probabilistic programs, without the restrictions of non-negative costs, bounded updates, or finiteness of the expected total cost. Finally, we provide experimental results showcasing that our approach can solve instances that were beyond the reach of previous methods.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649824", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Tobias", + "last_name": "Meggendorfer", + "institution": "" + }, + { + "first_name": "Đorđe", + "last_name": "Žikelić", + "institution": "Singapore Management University" + } + ], + "dblp_key": "journals/pacmpl/ChatterjeeGMZ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649826", + "title": "AdoB: Bridging Benign and Byzantine Consensus with Atomic Distributed Objects", + "abstract": "Achieving consensus is a challenging and ubiquitous problem in distributed systems that is only made harder by the introduction of malicious byzantine servers. While significant effort has been devoted to the benign and byzantine failure models individually, no prior work has considered the mechanized verification of both in a generic way. We claim this is due to the lack of an appropriate abstraction that is capable of representing both benign and byzantine consensus without either losing too much detail or becoming impractically complex. We build on recent work on the atomic distributed object model to fill this void with a novel abstraction called AdoB. In addition to revealing important insights into the essence of consensus, this abstraction has practical benefits for easing distributed system verification. As a case study, we proved safety and liveness properties for AdoB in Coq, which are the first such mechanized proofs to handle benign and byzantine consensus in a unified manner. We also demonstrate that AdoB faithfully models real consensus protocols by proving it is refined by standard network-level specifications of Fast Paxos and a variant of Jolteon.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649826", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wolf", + "last_name": "Honoré", + "institution": "Yale University" + }, + { + "first_name": "Longfei", + "last_name": "Qiu", + "institution": "Yale University" + }, + { + "first_name": "Y. K.", + "last_name": "Kim", + "institution": "Yale University" + }, + { + "first_name": "Ji-Yong", + "last_name": "Shin", + "institution": "Northeastern University" + }, + { + "first_name": "Jieung", + "last_name": "Kim", + "institution": "Inha University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/HonoreQKSKS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649816", + "title": "UniSparse: An Intermediate Language for General Sparse Format Customization", + "abstract": "The ongoing trend of hardware specialization has led to a growing use of custom data formats when processing sparse workloads, which are typically memory-bound. These formats facilitate optimized software/hardware implementations by utilizing sparsity pattern- or target-aware data structures and layouts to enhance memory access latency and bandwidth utilization. However, existing sparse tensor programming models and compilers offer little or no support for productively customizing the sparse formats. Additionally, because these frameworks represent formats using a limited set of per-dimension attributes, they lack the flexibility to accommodate numerous new variations of custom sparse data structures and layouts. To overcome this deficiency, we propose UniSparse, an intermediate language that provides a unified abstraction for representing and customizing sparse formats. Unlike the existing attribute-based frameworks, UniSparse decouples the logical representation of the sparse tensor (i.e., the data structure) from its low-level memory layout, enabling the customization of both. As a result, a rich set of format customizations can be succinctly expressed in a small set of well-defined query, mutation, and layout primitives. We also develop a compiler leveraging the MLIR infrastructure, which supports adaptive customization of formats, and automatic code generation of format conversion and compute operations for heterogeneous architectures. We demonstrate the efficacy of our approach through experiments running commonly-used sparse linear algebra operations with specialized formats on multiple different hardware targets, including an Intel CPU, an NVIDIA GPU, an AMD Xilinx FPGA, and a simulated processing-in-memory (PIM) device.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649816", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jie", + "last_name": "Liu", + "institution": "Cornell University" + }, + { + "first_name": "Zhongyuan", + "last_name": "Zhao", + "institution": "Cornell University" + }, + { + "first_name": "Zijian", + "last_name": "Ding", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Benjamin", + "last_name": "Brock", + "institution": "Intel (United States)" + }, + { + "first_name": "Hongbo", + "last_name": "Rong", + "institution": "Intel (United States)" + }, + { + "first_name": "Zhiru", + "last_name": "Zhang", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/LiuZDBRZ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649818", + "title": "Fulfilling OCaml Modules with Transparency", + "abstract": "ML modules come as an additional layer on top of a core language to offer large-scale notions of composition and abstraction. They largely contributed to the success of OCaml and SML. While modules are easy to write for common cases, their advanced use may become tricky. Additionally, despite a long line of works, their meta-theory remains difficult to comprehend, with involved soundness proofs. In fact, the module layer of OCaml does not currently have a formal specification and its implementation has some surprising behaviors. Building on previous translations from ML modules to Fω, we propose a type system, called Mω, that covers a large subset of OCaml modules, including both applicative and generative functors, and extended with transparent ascription. This system produces signatures in an OCaml-like syntax extended with Fω quantifiers. We provide a reverse translation from Mω signatures to path-based source signatures along with a characterization of signature avoidance cases, making Mω signatures well suited to serve as a new internal representation for a typechecker. The soundness of the type system is shown by elaboration in Fω. We improve over previous encodings of sealing within applicative functors, by the introduction of transparent existential types, a weaker form of existential types that can be lifted out of universal and arrow types. This shines a new light on the form of abstraction provided by applicative functors and brings their treatment much closer to those of generative functors.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649818", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Clément", + "last_name": "Blaudeau", + "institution": "Université Paris Cité" + }, + { + "first_name": "Didier", + "last_name": "Rémy", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gabriel", + "last_name": "Radanne", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/BlaudeauRR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649828", + "title": "Enhancing Static Analysis for Practical Bug Detection: An LLM-Integrated Approach", + "abstract": "While static analysis is instrumental in uncovering software bugs, its precision in analyzing large and intricate codebases remains challenging. The emerging prowess of Large Language Models (LLMs) offers a promising avenue to address these complexities. In this paper, we present LLift, a pioneering framework that synergizes static analysis and LLMs, with a spotlight on identifying use-before-initialization (UBI) bugs within the Linux kernel. Drawing from our insights into variable usage conventions in Linux, we enhance path analysis using post-constraint guidance. This approach, combined with our methodically crafted procedures, empowers LLift to adeptly handle the challenges of bug-specific modeling, extensive codebases, and the unpredictable nature of LLMs. Our real-world evaluations identified four previously undiscovered UBI bugs in the mainstream Linux kernel, which the Linux community has acknowledged. This study reaffirms the potential of marrying static analysis with LLMs, setting a compelling direction for future research in this area.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649828", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haonan", + "last_name": "Li", + "institution": "University of California, Riverside" + }, + { + "first_name": "Hao", + "last_name": "Yu", + "institution": "University of California, Riverside" + }, + { + "first_name": "Yizhuo", + "last_name": "Zhai", + "institution": "University of California, Riverside" + }, + { + "first_name": "Zhiyun", + "last_name": "Qian", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "journals/pacmpl/LiHZQ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649827", + "title": "PROMPT: A Fast and Extensible Memory Profiling Framework", + "abstract": "Memory profiling captures programs’ dynamic memory behavior, assisting programmers in debugging, tuning, and enabling advanced compiler optimizations like speculation-based automatic parallelization. As each use case demands its unique program trace summary, various memory profiler types have been developed. Yet, designing practical memory profilers often requires extensive compiler expertise, adeptness in program optimization, and significant implementation effort. This often results in a void where aspirations for fast and robust profilers remain unfulfilled. To bridge this gap, this paper presents PROMPT, a framework for streamlined development of fast memory profilers. With PROMPT, developers need only specify profiling events and define the core profiling logic, bypassing the complexities of custom instrumentation and intricate memory profiling components and optimizations. Two state-of-the-art memory profilers were ported with PROMPT where all features preserved. By focusing on the core profiling logic, the code was reduced by more than 65% and the profiling overhead was improved by 5.3× and 7.1× respectively. To further underscore PROMPT’s impact, a tailored memory profiling workflow was constructed for a sophisticated compiler optimization client. In 570 lines of code, this redesigned workflow satisfies the client’s memory profiling needs while achieving more than 90% reduction in profiling overhead and improved robustness compared to the original profilers.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649827", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ziyang", + "last_name": "Xu", + "institution": "Princeton University" + }, + { + "first_name": "Yebin", + "last_name": "Chon", + "institution": "Princeton University" + }, + { + "first_name": "Yian", + "last_name": "Su", + "institution": "Northwestern University" + }, + { + "first_name": "Zujun", + "last_name": "Tan", + "institution": "Princeton University" + }, + { + "first_name": "Sotiris", + "last_name": "Apostolakis", + "institution": "Google (United States)" + }, + { + "first_name": "Simone", + "last_name": "Campanoni", + "institution": "Northwestern University" + }, + { + "first_name": "David I.", + "last_name": "August", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/XuCSTACA24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649834", + "title": "Design and Implementation of an Aspect-Oriented C Programming Language", + "abstract": "Aspect-Oriented Programming (AOP) is a programming paradigm that implements crosscutting concerns in a modular way. People have witnessed the prosperity of AOP languages for Java and C++, such as AspectJ and AspectC++, which has propelled AOP to become an important programming paradigm with many interesting application scenarios, e.g., runtime verification. In contrast, the AOP languages for C are still poor and lack compiler support. In this paper, we design a new general-purpose and expressive aspect-oriented C programming language, namely Aclang, and implement a compiler for it, which brings fully-fledged AOP support into the C domain. We have evaluated the effectiveness and performance of our compiler against two state-of-the-art tools, ACC and AspectC++. In terms of effectiveness, Aclang outperforms ACC and AspectC++. In terms of performance, Aclang outperforms ACC in execution time and outperforms AspectC++ in both execution time and memory consumption.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649834", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhe", + "last_name": "Chen", + "institution": "Nanjing University of Aeronautics and Astronautics" + }, + { + "first_name": "Yanxiang", + "last_name": "Zhu", + "institution": "Nanjing University of Aeronautics and Astronautics" + }, + { + "first_name": "Z.R.", + "last_name": "Wang", + "institution": "Nanjing University of Aeronautics and Astronautics" + } + ], + "dblp_key": "journals/pacmpl/ChenZW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649837", + "title": "Hydra: Generalizing Peephole Optimizations with Program Synthesis", + "abstract": "Optimizing compilers rely on peephole optimizations to simplify combinations of instructions and remove redundant instructions. Typically, a new peephole optimization is added when a compiler developer notices an optimization opportunity---a collection of dependent instructions that can be improved---and manually derives a more general rewrite rule that optimizes not only the original code, but also other, similar collections of instructions. In this paper, we present Hydra, a tool that automates the process of generalizing peephole optimizations using a collection of techniques centered on program synthesis. One of the most important problems we have solved is finding a version of each optimization that is independent of the bitwidths of the optimization's inputs (when this version exists). We show that Hydra can generalize 75% of the ungeneralized missed peephole optimizations that LLVM developers have posted to the LLVM project's issue tracker. All of Hydra's generalized peephole optimizations have been formally verified, and furthermore we can automatically turn them into C++ code that is suitable for inclusion in an LLVM pass.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649837", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Manasij", + "last_name": "Mukherjee", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/MukherjeeR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649838", + "title": "Multiverse Notebook: Shifting Data Scientists to Time Travelers", + "abstract": "Computational notebook environments are popular and de facto standard tools for programming in data science, whereas computational notebooks are notorious in software engineering. The criticism there stems from the characteristic of facilitating unrestricted dynamic patching of running programs, which makes exploratory coding quick but the resultant code messy and inconsistent. In this work, we first reveal that dynamic patching is a natural demand rather than a mere bad practice in data science programming on Kaggle. We then develop Multiverse Notebook, a computational notebook engine for time-traveling exploration. It enables users to time-travel to any past state and restart with new code from there under state isolation. We present an approach to efficiently implementing time-traveling exploration. We empirically evaluate Multiverse Notebook on ten real-world tasks from Kaggle. Our experiments show that time-traveling exploration on Multiverse Notebook is reasonably efficient.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649838", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shigeyuki", + "last_name": "Sato", + "institution": "University of Electro-Communications" + }, + { + "first_name": "Tomoki", + "last_name": "Nakamaru", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "journals/pacmpl/SatoN24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649829", + "title": "Evaluating the Effectiveness of Deep Learning Models for Foundational Program Analysis Tasks", + "abstract": "While deep neural networks provide state-of-the-art solutions to a wide range of programming language tasks, their effectiveness in dealing with foundational program analysis tasks remains under explored. In this paper, we present an empirical study that evaluates four prominent models of code (i.e., CuBERT, CodeBERT, GGNN, and Graph Sandwiches) in two such foundational tasks: (1) alias prediction, in which models predict whether two pointers must alias, may alias or must not alias; and (2) equivalence prediction, in which models predict whether or not two programs are semantically equivalent. At the core of this study is CodeSem, a dataset built upon the source code of real-world flagship software (e.g., Linux Kernel, GCC, MySQL) and manually validated for the two prediction tasks. Results show that all models are accurate in both prediction tasks, especially CuBERT with an accuracy of 89% and 84% in alias prediction and equivalence prediction, respectively. We also conduct a comprehensive, in-depth analysis of the results of all models in both tasks, concluding that deep learning models are generally capable of performing foundational tasks in program analysis even though in specific cases their weaknesses are also evident. Our code and evaluation data are publicly available at https://github.com/CodeSemDataset/CodeSem.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649829", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qian", + "last_name": "Chen", + "institution": "Nanjing University" + }, + { + "first_name": "Chenyang", + "last_name": "Yu", + "institution": "Nanjing University" + }, + { + "first_name": "Ruyan", + "last_name": "Liu", + "institution": "Nanjing University" + }, + { + "first_name": "C.", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Yu", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "Visa (United States)" + }, + { + "first_name": "Ting", + "last_name": "Su", + "institution": "East China Normal University" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/ChenYLZWWSW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649830", + "title": "Inductive Diagrams for Causal Reasoning", + "abstract": "The Lamport diagram is a pervasive and intuitive tool for informal reasoning about “happens-before” relationships in a concurrent system. However, traditional axiomatic formalizations of Lamport diagrams can be painful to work with in a mechanized setting like Agda. We propose an alternative, inductive formalization — the causal separation diagram (CSD) — that takes inspiration from string diagrams and concurrent separation logic, but enjoys a graphical syntax similar to Lamport diagrams. Critically, CSDs are based on the idea that causal relationships between events are witnessed by the paths that information follows between them. To that end, we model “happens-before” as a dependent type of paths between events. The inductive formulation of CSDs enables their interpretation into a variety of semantic domains. We demonstrate the interpretability of CSDs with a case study on properties of logical clocks , widely-used mechanisms for reifying causal relationships as data. We carry out this study by implementing a series of interpreters for CSDs, culminating in a generic proof of Lamport’s clock condition that is parametric in a choice of clock. We instantiate this proof on Lamport’s scalar clock, on Mattern’s vector clock, and on the matrix clocks of Raynal et al. and of Wuu and Bernstein, yielding verified implementations of each. The CSD formalism and our case study are mechanized in the Agda proof assistant.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649830", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Castello", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Patrick", + "last_name": "Redmond", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "journals/pacmpl/CastelloRK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649831", + "title": "Quarl: A Learning-Based Quantum Circuit Optimizer", + "abstract": "Optimizing quantum circuits is challenging due to the very large search space of functionally equivalent circuits and the necessity of applying transformations that temporarily decrease performance to achieve a final performance improvement. This paper presents Quarl, a learning-based quantum circuit optimizer. Applying reinforcement learning (RL) to quantum circuit optimization raises two main challenges: the large and varying action space and the non-uniform state representation. Quarl addresses these issues with a novel neural architecture and RL-training procedure. Our neural architecture decomposes the action space into two parts and leverages graph neural networks in its state representation, both of which are guided by the intuition that optimization decisions can be mostly guided by local reasoning while allowing global circuit-wide reasoning. Our evaluation shows that Quarl significantly outperforms existing circuit optimizers on almost all benchmark circuits. Surprisingly, Quarl can learn to perform rotation merging—a complex, non-local circuit optimization implemented as a separate pass in existing optimizers.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649831", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zikun", + "last_name": "Li", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jinjun", + "last_name": "Peng", + "institution": "City University of Seattle" + }, + { + "first_name": "Yixuan", + "last_name": "Mei", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sina", + "last_name": "Lin", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Yi", + "last_name": "Wu", + "institution": "Tsinghua University" + }, + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "" + }, + { + "first_name": "Zhihao", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/LiPMLWPJ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649833", + "title": "Forge: A Tool and Language for Teaching Formal Methods", + "abstract": "This paper presents the design of Forge , a tool for teaching formal methods gradually. Forge is based on the widely-used Alloy language and analysis tool, but contains numerous improvements based on more than a decade of experience teaching Alloy to students. Although our focus has been on the classroom, many of the ideas in Forge likely also apply to training in industry. Forge offers a progression of languages that improve the learning experience by only gradually increasing in expressive power. Forge supports custom visualization of its outputs, enabling the use of widely-understood domain-specific representations. Finally, Forge provides a variety of testing features to ease the transition from programming to formal modeling. We present the motivation for and design of these aspects of Forge, and then provide a substantial evaluation based on multiple years of classroom use.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649833", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tim", + "last_name": "Nelson", + "institution": "Brown University" + }, + { + "first_name": "Ben", + "last_name": "Greenman", + "institution": "University of Utah" + }, + { + "first_name": "Siddhartha", + "last_name": "Prasad", + "institution": "Brown University" + }, + { + "first_name": "Tristan", + "last_name": "Dyer", + "institution": "" + }, + { + "first_name": "Ethan", + "last_name": "Bove", + "institution": "Brown University" + }, + { + "first_name": "Q.", + "last_name": "Chen", + "institution": "Brown University" + }, + { + "first_name": "Charles", + "last_name": "Cutting", + "institution": "Brown University" + }, + { + "first_name": "Thomas J.", + "last_name": "Vecchio", + "institution": "Brown University" + }, + { + "first_name": "S. Joseph", + "last_name": "Levine", + "institution": "Brown University" + }, + { + "first_name": "Julianne", + "last_name": "Rudner", + "institution": "Brown University" + }, + { + "first_name": "Ben", + "last_name": "Ryjikov", + "institution": "Brown University" + }, + { + "first_name": "A. Kibédi", + "last_name": "Varga", + "institution": "Brown University" + }, + { + "first_name": "Andrew", + "last_name": "Wagner", + "institution": "Northeastern University" + }, + { + "first_name": "Luke", + "last_name": "West", + "institution": "Brown University" + }, + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + } + ], + "dblp_key": "journals/pacmpl/NelsonGPDBCCVLRRVWWK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649832", + "title": "Qualifying System F<: Some Terms and Conditions May Apply", + "abstract": "Type qualifiers offer a lightweight mechanism for enriching existing type systems to enforce additional, desirable, program invariants. They do so by offering a restricted but effective form of subtyping. While the theory of type qualifiers is well understood and present in many programming languages today, polymorphism over type qualifiers remains an area less well examined. We explore how such a polymorphic system could arise by constructing a calculus, System F-sub-Q, which combines the higher-rank bounded polymorphism of System F-sub with the theory of type qualifiers. We explore how the ideas used to construct System F-sub-Q can be reused in situations where type qualifiers naturally arise---in reference immutability, function colouring, and capture checking. Finally, we re-examine other qualifier systems in the literature in light of the observations presented while developing System F-sub-Q.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649832", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Edward", + "last_name": "Lee", + "institution": "University of Waterloo" + }, + { + "first_name": "Yaoyu", + "last_name": "Zhao", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "James", + "last_name": "You", + "institution": "University of Waterloo" + }, + { + "first_name": "Kavin", + "last_name": "Satheeskumar", + "institution": "University of Waterloo" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/LeeZLYSB24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649841", + "title": "TorchQL: A Programming Framework for Integrity Constraints in Machine Learning", + "abstract": "Finding errors in machine learning applications requires a thorough exploration of their behavior over data. Existing approaches used by practitioners are often ad-hoc and lack the abstractions needed to scale this process. We present TorchQL, a programming framework to evaluate and improve the correctness of machine learning applications. TorchQL allows users to write queries to specify and check integrity constraints over machine learning models and datasets. It seamlessly integrates relational algebra with functional programming to allow for highly expressive queries using only eight intuitive operators. We evaluate TorchQL on diverse use-cases including finding critical temporal inconsistencies in objects detected across video frames in autonomous driving, finding data imputation errors in time-series medical records, finding data labeling errors in real-world images, and evaluating biases and constraining outputs of language models. Our experiments show that TorchQL enables up to 13x faster query executions than baselines like Pandas and MongoDB, and up to 40% shorter queries than native Python. We also conduct a user study and find that TorchQL is natural enough for developers familiar with Python to specify complex integrity constraints.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649841", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aaditya", + "last_name": "Naik", + "institution": "University of Pennsylvania" + }, + { + "first_name": "A.", + "last_name": "Stein", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yinjun", + "last_name": "Wu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Mayur", + "last_name": "Naik", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Eric", + "last_name": "Wong", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/NaikSWNW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649836", + "title": "Persimmon: Nested Family Polymorphism with Extensible Variant Types", + "abstract": "Many obstacles stand in the way of modular, extensible code. Some language constructs, such as pattern matching, are not easily extensible. Inherited code may not be type safe in the presence of extended types. The burden of setting up design patterns can discourage users, and parameter clutter can make the code less readable. Given these challenges, it is no wonder that extensibility often gives way to code duplication. We present our solution: Persimmon, a functional system with nested family polymorphism, extensible variant types, and extensible pattern matching. Most constructs in our language are built-in \"extensibility hooks,\" cutting down on the parameter clutter and user burden associated with extensible code. Persimmon preserves the relationships between nested families upon inheritance, enabling extensibility at a large scale. Since nested family polymorphism can express composable extensions, Persimmon supports mixins via an encoding. We show how Persimmon can be compiled into a functional language without extensible variants with our translation to Scala. Finally, we show that our system is sound by proving the properties of progress and preservation.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649836", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anastasiya", + "last_name": "Kravchuk-Kirilyuk", + "institution": "Harvard University Press" + }, + { + "first_name": "Guozheng", + "last_name": "Feng", + "institution": "University of Waterloo" + }, + { + "first_name": "Jonas", + "last_name": "Iskander", + "institution": "Harvard University Press" + }, + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + }, + { + "first_name": "Nada", + "last_name": "Amin", + "institution": "Harvard University Press" + } + ], + "dblp_key": "journals/pacmpl/KravchukKirilyukFIZA24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649835", + "title": "Cedar: A New Language for Expressive, Fast, Safe, and Analyzable Authorization", + "abstract": "Cedar is a new authorization policy language designed to be ergonomic, fast, safe, and analyzable. Rather than embed authorization logic in an application’s code, developers can write that logic as Cedar policies and delegate access decisions to Cedar’s evaluation engine. Cedar’s simple and intuitive syntax supports common authorization use-cases with readable policies, naturally leveraging concepts from role-based, attribute-based, and relation-based access control models. Cedar’s policy structure enables access requests to be decided quickly. Cedar’s policy validator leverages optional typing to help policy writers avoid mistakes, but not get in their way. Cedar’s design has been finely balanced to allow for a sound and complete logical encoding, which enables precise policy analysis, e.g., to ensure that when refactoring a set of policies, the authorized permissions do not change. We have modeled Cedar in the Lean programming language, and used Lean’s proof assistant to prove important properties of Cedar’s design. We have implemented Cedar in Rust, and released it open-source. Comparing Cedar to two open-source languages, OpenFGA and Rego, we find (subjectively) that Cedar has equally or more readable policies, but (objectively) performs far better.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649835", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joseph W.", + "last_name": "Cutler", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Craig", + "last_name": "Disselkoen", + "institution": "" + }, + { + "first_name": "Aaron", + "last_name": "Eline", + "institution": "" + }, + { + "first_name": "Shaobo", + "last_name": "He", + "institution": "Amazon (United States)" + }, + { + "first_name": "Kyle", + "last_name": "Headley", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "" + }, + { + "first_name": "Kesha", + "last_name": "Hietala", + "institution": "" + }, + { + "first_name": "Eleftherios", + "last_name": "Ioannidis", + "institution": "University of Pennsylvania" + }, + { + "first_name": "John", + "last_name": "Kastner", + "institution": "" + }, + { + "first_name": "Anwar", + "last_name": "Mamat", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Darin", + "last_name": "McAdams", + "institution": "Amazon (United States)" + }, + { + "first_name": "Matt", + "last_name": "McCutchen", + "institution": "" + }, + { + "first_name": "Neha", + "last_name": "Rungta", + "institution": "Amazon (United States)" + }, + { + "first_name": "Emina", + "last_name": "Torlak", + "institution": "Amazon (United States)" + }, + { + "first_name": "Andrew M.", + "last_name": "Wells", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/CutlerDEHHHHIKMMMRTW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649840", + "title": "Accurate Data Race Prediction in the Linux Kernel through Sparse Fourier Learning", + "abstract": "Testing for data races in the Linux OS kernel is challenging because there is an exponentially large space of system calls and thread interleavings that can potentially lead to concurrent executions with races. In this work, we introduce a new approach for modeling execution trace feasibility and apply it to Linux OS Kernel race prediction. To address the fundamental scalability challenge posed by the exponentially large domain of possible execution traces, we decompose the task of predicting trace feasibility into independent prediction subtasks encoded as learning Boolean indicator functions for specific memory accesses, and apply a sparse fourier learning approach to learning each feasibility subtask. Boolean functions that are sparse in their fourier domain can be efficiently learned by estimating the coefficients of their fourier expansion. Since the feasibility of each memory access depends on only a few other relevant memory accesses or system calls (e.g., relevant inter-thread communications), we observe that trace feasibility functions often have this sparsity property and can be learned efficiently. We use learned trace feasibility functions in conjunction with conservative alias analysis to implement a kernel race-testing system, HBFourier, that uses sparse fourier learning to efficiently model feasibility when making predictions. We evaluate our approach on a recent Linux development kernel and show it finds 44 more races with 15.7% more accurate race predictions than the next best performing system in our evaluation, in addition to identifying 5 new race bugs confirmed by kernel developers.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649840", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gabriel", + "last_name": "Ryan", + "institution": "Columbia University" + }, + { + "first_name": "B.E.", + "last_name": "Çetin", + "institution": "Columbia University" + }, + { + "first_name": "Yongwhan", + "last_name": "Lim", + "institution": "Columbia University" + }, + { + "first_name": "S.", + "last_name": "Jana", + "institution": "Columbia University" + } + ], + "dblp_key": "journals/pacmpl/RyanCLJ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649842", + "title": "Gradually Typed Languages Should Be Vigilant!", + "abstract": "In gradual typing, different languages perform different dynamic type checks for the same program even though the languages have the same static type system. This raises the question of whether, given a gradually typed language, the combination of the translation that injects checks in well-typed terms and the dynamic semantics that determines their behavior sufficiently enforce the static type system of the language. Neither type soundness, nor complete monitoring, nor any other meta-theoretic property of gradually typed languages to date provides a satisfying answer. In response, we present vigilance, a semantic analytical instrument that defines when the check-injecting translation and dynamic semantics of a gradually typed language are adequate for its static type system. Technically, vigilance asks if a given translation-and-semantics combination enforces the complete run-time typing history of a value, which consists of all of the types associated with the value. We show that the standard combination for so-called Natural gradual typing is vigilant for the standard simple type system, but the standard combination for Transient gradual typing is not. At the same time, the standard combination for Transient is vigilant for a tag type system but the standard combination for Natural is not. Hence, we clarify the comparative type-level reasoning power between the two most studied approaches to sound gradual typing. Furthermore, as an exercise that demonstrates how vigilance can guide design, we introduce and examine a new theoretical static gradual type system, dubbed truer, that is stronger than tag typing and more faithfully reflects the type-level reasoning power that the dynamic semantics of Transient gradual typing can guarantee.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649842", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Olek", + "last_name": "Gierczak", + "institution": "Northeastern University" + }, + { + "first_name": "L.", + "last_name": "Menon", + "institution": "Northeastern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/GierczakMDA24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649839", + "title": "Hopping Proofs of Expectation-Based Properties: Applications to Skiplists and Security Proofs", + "abstract": "We propose, implement, and evaluate a hopping proof approach for proving expectation-based properties of probabilistic programs. Our approach combines EHL, a syntax-directed proof system for reducing proof goals of a program to proof goals of simpler programs, with a \"hopping\" proof rule for reducing proof goals of an original program to proof goal of a different program which is suitably related (by means of pRHL, a relational program logic for probabilistic program) to the original program. We prove that EHL is sound for a core language with procedure calls and adversarial computations, and complete for the adversary-free fragment of the language. We also provide an implementation of EHL into EasyCrypt, a proof assistant tailored for reasoning about relational properties of probabilistic programs. We provide a tight integration of EHL with other program logics supported by EasyCrypt, and in particular probabilistic Relational Hoare Logic (pRHL). Using this tight integration, we give mechanized proofs of expected complexity of in-place implementations of randomized quickselect and skip lists. We also sketch applications of our approach to cryptographic proofs and discuss the broader impact of EHL in the EasyCrypt proof assistant.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649839", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Martin", + "last_name": "Avanzini", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Georg", + "last_name": "Moser", + "institution": "Universität Innsbruck" + }, + { + "first_name": "Gabriele", + "last_name": "Vanoni", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "journals/pacmpl/AvanziniBGMV24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649843", + "title": "Distributions for Compositionally Differentiating Parametric Discontinuities", + "abstract": "Computations in physical simulation, computer graphics, and probabilistic inference often require the differentiation of discontinuous processes due to contact, occlusion, and changes at a point in time. Popular differentiable programming languages, such as PyTorch and JAX, ignore discontinuities during differentiation. This is incorrect for parametric discontinuities —conditionals containing at least one real-valued parameter and at least one variable of integration. We introduce Potto, the first differentiable first-order programming language to soundly differentiate parametric discontinuities. We present a denotational semantics for programs and program derivatives and show the two accord. We describe the implementation of Potto, which enables separate compilation of programs. Our prototype implementation overcomes previous compile-time bottlenecks achieving an 88.1x and 441.2x speed up in compile time and a 2.5x and 7.9x speed up in runtime, respectively, on two increasingly large image stylization benchmarks. We showcase Potto by implementing a prototype differentiable renderer with separately compiled shaders.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649843", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jesse", + "last_name": "Michel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Kevin", + "last_name": "Mu", + "institution": "University of Washington" + }, + { + "first_name": "Xuanda", + "last_name": "Yang", + "institution": "University of California San Diego" + }, + { + "first_name": "Sai Praveen", + "last_name": "Bangaru", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Elias Rojas", + "last_name": "Collins", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Gilbert", + "last_name": "Bernstein", + "institution": "University of Washington" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Tzu‐Mao", + "last_name": "Li", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/MichelMYBCBRCL24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649844", + "title": "Exact Bayesian Inference for Loopy Probabilistic Programs using Generating Functions", + "abstract": "We present an exact Bayesian inference method for inferring posterior distributions encoded by probabilistic programs featuring possibly unbounded loops . Our method is built on a denotational semantics represented by probability generating functions , which resolves semantic intricacies induced by intertwining discrete probabilistic loops with conditioning (for encoding posterior observations). We implement our method in a tool called Prodigy; it augments existing computer algebra systems with the theory of generating functions for the (semi-)automatic inference and quantitative verification of conditioned probabilistic programs. Experimental results show that Prodigy can handle various infinite-state loopy programs and exhibits comparable performance to state-of-the-art exact inference tools over loop-free benchmarks.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649844", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lutz", + "last_name": "Klinkenberg", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Christian", + "last_name": "Blumenthal", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Mingshuai", + "last_name": "Chen", + "institution": "Zhejiang University" + }, + { + "first_name": "Darion", + "last_name": "Haase", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/KlinkenbergBCHK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649847", + "title": "Verification of Neural Networks' Global Robustness", + "abstract": "Neural networks are successful in various applications but are also susceptible to adversarial attacks. To show the safety of network classifiers, many verifiers have been introduced to reason about the local robustness of a given input to a given perturbation. While successful, local robustness cannot generalize to unseen inputs. Several works analyze global robustness properties, however, neither can provide a precise guarantee about the cases where a network classifier does not change its classification. In this work, we propose a new global robustness property for classifiers aiming at finding the minimal globally robust bound, which naturally extends the popular local robustness property for classifiers. We introduce VHAGaR, an anytime verifier for computing this bound. VHAGaR relies on three main ideas: encoding the problem as a mixed-integer programming and pruning the search space by identifying dependencies stemming from the perturbation or the network's computation and generalizing adversarial attacks to unknown inputs. We evaluate VHAGaR on several datasets and classifiers and show that, given a three hour timeout, the average gap between the lower and upper bound on the minimal globally robust bound computed by VHAGaR is 1.9, while the gap of an existing global robustness verifier is 154.7. Moreover, VHAGaR is 130.6x faster than this verifier. Our results further indicate that leveraging dependencies and adversarial attacks makes VHAGaR 78.6x faster.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649847", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anan", + "last_name": "Kabaha", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Dana", + "last_name": "Drachsler-Cohen", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KabahaD24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649853", + "title": "Degrees of Separation: A Flexible Type System for Safe Concurrency", + "abstract": "Data races have long been a notorious problem in concurrent programming. They are hard to detect, and lead to non-deterministic behaviours. There has been a lot of interest in type systems that statically guarantee data race freedom. Significant progress has been made in this area, and these type systems are increasingly usable and practical. However, their adoption in mainstream programming languages is still limited, which is largely attributed to their strict alias prevention principles that obstruct the usage of existing programming patterns. This is a deterrent to the migration of existing code bases. To tackle this problem, we propose Capture Separation Calculus (System CSC), a calculus that models fork-join parallelism and statically prevents data races while being compatible with established programming patterns. It follows a control-as-you-need philosophy: by default, aliases are allowed, but they are tracked in the type system. When data races are a concern, the tracked aliases are controlled to prevent data-race-prone patterns. We study the formal properties of System CSC. Type soundness is proven via the standard progress and preservation theorems. Additionally, we formally verify the data race freedom property of System CSC by proving that the reduction of a well-typed program is confluent.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649853", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yichen", + "last_name": "Xu", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Aleksander", + "last_name": "Boruch-Gruszecki", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/XuBO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649845", + "title": "Learning Abstraction Selection for Bayesian Program Analysis", + "abstract": "We propose a learning-based approach to select abstractions for Bayesian program analysis. Bayesian program analysis converts a program analysis into a Bayesian model by attaching probabilities to analysis rules. It computes probabilities of analysis results and can update them by learning from user feedback, test runs, and other information. Its abstraction heavily affects how well it learns from such information. There exists a long line of works in selecting abstractions for conventional program analysis but they are not effective for Bayesian program analysis. This is because they do not optimize for generalization ability. We propose a data-driven framework to solve this problem by learning from labeled programs. Starting from an abstraction, it decides how to change the abstraction based on analysis derivations. To be general, it considers graph properties of analysis derivations; to be effective, it considers the derivations before and after changing the abstraction. We demonstrate the effectiveness of our approach using a datarace analysis and a thread-escape analysis.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649845", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Y. M.", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Yuanfeng", + "last_name": "Shi", + "institution": "Peking University" + }, + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/ZhangSZ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649849", + "title": "VeriEQL: Bounded Equivalence Verification for Complex SQL Queries with Integrity Constraints", + "abstract": "The task of SQL query equivalence checking is important in various real-world applications (including query rewriting and automated grading) that involve complex queries with integrity constraints; yet, state-of-the-art techniques are very limited in their capability of reasoning about complex features (e.g., those that involve sorting, case statement, rich integrity constraints, etc.) in real-life queries. To the best of our knowledge, we propose the first SMT-based approach and its implementation, VeriEQL, capable of proving and disproving bounded equivalence of complex SQL queries. VeriEQL is based on a new logical encoding that models query semantics over symbolic tuples using the theory of integers with uninterpreted functions. It is simple yet highly practical -- our comprehensive evaluation on over 20,000 benchmarks shows that VeriEQL outperforms all state-of-the-art techniques by more than one order of magnitude in terms of the number of benchmarks that can be proved or disproved. VeriEQL can also generate counterexamples that facilitate many downstream tasks (such as finding serious bugs in systems like MySQL and Apache Calcite).", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649849", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yang", + "last_name": "He", + "institution": "Simon Fraser University" + }, + { + "first_name": "P.", + "last_name": "Zhao", + "institution": "University of Michigan" + }, + { + "first_name": "Xinyu", + "last_name": "Wang", + "institution": "University of Michigan" + }, + { + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "Simon Fraser University" + } + ], + "dblp_key": "journals/pacmpl/HeZWW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649857", + "title": "Scenario-Based Proofs for Concurrent Objects", + "abstract": "Concurrent objects form the foundation of many applications that exploit multicore architectures and their importance has lead to informal correctness arguments, as well as formal proof systems. Correctness arguments (as found in the distributed computing literature) give intuitive descriptions of a few canonical executions or \"scenarios\" often each with only a few threads, yet it remains unknown as to whether these intuitive arguments have a formal grounding and extend to arbitrary interleavings over unboundedly many threads. We present a novel proof technique for concurrent objects, based around identifying a small set of scenarios (representative, canonical interleavings), formalized as the commutativity quotient of a concurrent object. We next give an expression language for defining abstractions of the quotient in the form of regular or context-free languages that enable simple proofs of linearizability. These quotient expressions organize unbounded interleavings into a form more amenable to reasoning and make explicit the relationship between implementation-level contention/interference and ADT-level transitions. We evaluate our work on numerous non-trivial concurrent objects from the literature (including the Michael-Scott queue, Elimination stack, SLS reservation queue, RDCSS and Herlihy-Wing queue). We show that quotients capture the diverse features/complexities of these algorithms, can be used even when linearization points are not straight-forward, correspond to original authors' correctness arguments, and provide some new scenario-based arguments. Finally, we show that discovery of some object's quotients reduces to two-thread reasoning and give an implementation that can derive candidate quotients expressions from source code.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649857", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Stevens Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/EneaK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649856", + "title": "PP-CSA: Practical Privacy-Preserving Software Call Stack Analysis", + "abstract": "Software call stack is a sequence of function calls that are executed during the runtime of a software program. Software call stack analysis (CSA) is widely used in software engineering to analyze the runtime behavior of software, which can be used to optimize the software performance, identify bugs, and profile the software. Despite the benefits of CSA, it has recently come under scrutiny due to concerns about privacy. To date, software is often deployed at user-side devices like mobile phones and smart watches. The collected call stacks may thus contain privacy-sensitive information, such as healthy information or locations, depending on the software functionality. Leaking such information to third parties may cause serious privacy concerns such as discrimination and targeted advertisement. This paper presents PP-CSA, a practical and privacy-preserving CSA framework that can be deployed in real-world scenarios. Our framework leverages local differential privacy (LDP) as a principled privacy guarantee, to mutate the collected call stacks and protect the privacy of individual users. Furthermore, we propose several key design principles and optimizations in the technical pipeline of PP-CSA, including an encoder-decoder scheme to properly enforce LDP over software call stacks, and several client/server-side optimizations to largely improve the efficiency of PP-CSA. Our evaluation over real-world Java and Android programs shows that our privacy-preserving CSA pipeline can achieve high utility and privacy guarantees while maintaining high efficiency. We have released our implementation of PP-CSA as an open-source project at https://github.com/wangzhaoyu07/PP-CSA for results reproducibility. We will provide more detailed documents to support and the usage and extension of the community.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649856", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhaoyu", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Pingchuan", + "last_name": "Ma", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Huaijin", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Shuai", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/WangMWW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649850", + "title": "PyDex: Repairing Bugs in Introductory Python Assignments using LLMs", + "abstract": "Students often make mistakes in their introductory programming assignments as part of their learning process. Unfortunately, providing custom repairs for these mistakes can require a substantial amount of time and effort from class instructors. Automated program repair (APR) techniques can be used to synthesize such fixes. Prior work has explored the use of symbolic and neural techniques for APR in the education domain. Both types of approaches require either substantial engineering efforts or large amounts of data and training. We propose to use a large language model trained on code, such as Codex (a version of GPT), to build an APR system -- PyDex -- for introductory Python programming assignments. Our system can fix both syntactic and semantic mistakes by combining multi-modal prompts, iterative querying, test-case-based selection of few-shots, and program chunking. We evaluate PyDex on 286 real student programs and compare to three baselines, including one that combines a state-of-the-art Python syntax repair engine, BIFI, and a state-of-the-art Python semantic repair engine for student assignments, Refactory. We find that PyDex can fix more programs and produce smaller patches on average.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649850", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jialu", + "last_name": "Zhang", + "institution": "University of Waterloo" + }, + { + "first_name": "José", + "last_name": "Cambronero", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Vu", + "last_name": "Le", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + }, + { + "first_name": "Gustavo", + "last_name": "Soares", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gust", + "last_name": "Verbruggen", + "institution": "Microsoft (Belgium)" + } + ], + "dblp_key": "journals/pacmpl/ZhangCGLPSV24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649846", + "title": "Deriving Dependently-Typed OOP from First Principles", + "abstract": "The expression problem describes how most types can easily be extended with new ways to produce the type or new ways to consume the type, but not both. When abstract syntax trees are defined as an algebraic data type, for example, they can easily be extended with new consumers, such as print or eval , but adding a new constructor requires the modification of all existing pattern matches. The expression problem is one way to elucidate the difference between functional or data-oriented programs (easily extendable by new consumers) and object-oriented programs (easily extendable by new producers). This difference between programs which are extensible by new producers or new consumers also exists for dependently typed programming, but with one core difference: Dependently-typed programming almost exclusively follows the functional programming model and not the object-oriented model, which leaves an interesting space in the programming language landscape unexplored. In this paper, we explore the field of dependently-typed object-oriented programming by deriving it from first principles using the principle of duality. That is, we do not extend an existing object-oriented formalism with dependent types in an ad-hoc fashion, but instead start from a familiar data-oriented language and derive its dual fragment by the systematic use of defunctionalization and refunctionalization. Our central contribution is a dependently typed calculus which contains two dual language fragments. We provide type- and semantics-preserving transformations between these two language fragments: defunctionalization and refunctionalization. We have implemented this language and these transformations and use this implementation to explain the various ways in which constructions in dependently typed programming can be explained as special instances of the general phenomenon of duality.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649846", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David A.", + "last_name": "Binder", + "institution": "University of Tübingen" + }, + { + "first_name": "Ingo", + "last_name": "Skupin", + "institution": "University of Tübingen" + }, + { + "first_name": "Tim", + "last_name": "Süberkrüb", + "institution": "" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/BinderSSO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649851", + "title": "Seneca: Taint-Based Call Graph Construction for Java Object Deserialization", + "abstract": "Object serialization and deserialization are widely used for storing and preserving objects in files, memory, or database as well as for transporting them across machines, enabling remote interaction among processes and many more. This mechanism relies on reflection, a dynamic language that introduces serious challenges for static analyses. Current state-of-the-art call graph construction algorithms do not fully support object serialization/deserialization, i.e., they are unable to uncover the callback methods that are invoked when objects are serialized and deserialized. Since call graphs are a core data structure for multiple types of analysis (e.g., vulnerability detection), an appropriate analysis cannot be performed since the call graph does not capture hidden (vulnerable) paths that occur via callback methods. In this paper, we present Seneca, an approach for handling serialization with improved soundness in the context of call graph construction. Our approach relies on taint analysis and API modeling to construct sound call graphs. We evaluated our approach with respect to soundness, precision, performance, and usefulness in detecting untrusted object deserialization vulnerabilities. Our results show that Seneca can create sound call graphs with respect to serialization features. The resulting call graphs do not incur significant runtime overhead and were shown to be useful for performing identification of vulnerable paths caused by untrusted object deserialization.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649851", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joanna C. S.", + "last_name": "Santos", + "institution": "University of Notre Dame" + }, + { + "first_name": "Mehdi", + "last_name": "Mirakhorli", + "institution": "University of Hawaiʻi at Mānoa" + }, + { + "first_name": "Ali", + "last_name": "Shokri", + "institution": "Virginia Tech" + } + ], + "dblp_key": "journals/pacmpl/SantosMS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649848", + "title": "Functional Ownership through Fractional Uniqueness", + "abstract": "Ownership and borrowing systems, designed to enforce safe memory management without the need for garbage collection, have been brought to the fore by the Rust programming language. Rust also aims to bring some guarantees offered by functional programming into the realm of performant systems code, but the type system is largely separate from the ownership model, with type and borrow checking happening in separate compilation phases. Recent models such as RustBelt and Oxide aim to formalise Rust in depth, but there is less focus on integrating the basic ideas into more traditional type systems. An approach designed to expose an essential core for ownership and borrowing would open the door for functional languages to borrow concepts found in Rust and other ownership frameworks, so that more programmers can enjoy their benefits. One strategy for managing memory in a functional setting is through uniqueness types, but these offer a coarse-grained view: either a value has exactly one reference, and can be mutated safely, or it cannot, since other references may exist. Recent work demonstrates that linear and uniqueness types can be combined in a single system to offer restrictions on program behaviour and guarantees about memory usage. We develop this connection further, showing that just as graded type systems like those of Granule and Idris generalise linearity, a Rust-like ownership model arises as a graded generalisation of uniqueness. We combine fractional permissions with grading to give the first account of ownership and borrowing that smoothly integrates into a standard type system alongside linearity and graded types, and extend Granule accordingly with these ideas.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649848", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Marshall", + "institution": "University of Kent" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + } + ], + "dblp_key": "journals/pacmpl/MarshallO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649854", + "title": "ParDiff: Practical Static Differential Analysis of Network Protocol Parsers", + "abstract": "Countless devices all over the world are connected by networks and communicated via network protocols. Just like common software, protocol implementations suffer from bugs, many of which only cause silent data corruption instead of crashes. Hence, existing automated bug-finding techniques focused on memory safety, such as fuzzing, can hardly detect them. In this work, we propose a static differential analysis called ParDiff to find protocol implementation bugs, especially silent ones hidden in message parsers. Our key observation is that a network protocol often has multiple implementations and any semantic discrepancy between them may indicate bugs. However, different implementations are often written in disparate styles, e.g., using different data structures or written with different control structures, making it challenging to directly compare two implementations of even the same protocol. To exploit this observation and effectively compare multiple protocol implementations, ParDiff (1) automatically extracts finite state machines from programs to represent protocol format specifications, and (2) then leverages bisimulation and SMT solvers to find fine-grained and semantic inconsistencies between them. We have extensively evaluated ParDiff using 14 network protocols. The results show that ParDiff outperforms both differential symbolic execution and differential fuzzing tools. To date, we have detected 41 bugs with 25 confirmed by developers.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649854", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mingwei", + "last_name": "Zheng", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Qingkai", + "last_name": "Shi", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xuwei", + "last_name": "Liu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangzhe", + "last_name": "Xu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Le", + "last_name": "Yu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Congyu", + "last_name": "Liu", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Xiangyu", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/ZhengSLXYLWZ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649852", + "title": "A Pure Demand Operational Semantics with Applications to Program Analysis", + "abstract": "This paper develops a novel minimal-state operational semantics for higher-order functional languages that uses only the call stack and a source program point or a lexical level as the complete state information: there is no environment, no substitution, no continuation, etc. We prove this form of operational semantics equivalent to standard presentations. We then show how this approach can open the door to potential new applications: we define a program analysis as a direct finitization of this operational semantics. The program analysis that naturally emerges has a number of novel and interesting properties compared to standard program analyses for higher-order programs: for example, it can infer recurrences and does not need value widening. We both give a formal definition of the analysis and describe our current implementation.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649852", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + }, + { + "first_name": "R.", + "last_name": "Zhang", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "journals/pacmpl/SmithZ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649858", + "title": "Mechanizing the CMP Abstraction for Parameterized Verification", + "abstract": "Parameterized verification is a challenging problem that is known to be undecidable in the general case. ‍is a widely-used method for parameterized verification, originally proposed by Chou, Mannava and Park in 2004. It involves abstracting the protocol to a small fixed number of nodes, and strengthening by auxiliary invariants to refine the abstraction. In most of the existing applications of CMP, the abstraction and strengthening procedures are carried out manually, which can be tedious and error-prone. Existing theoretical justification of the ‍method is also done at a high level, without detailed descriptions of abstraction and strengthening rules. In this paper, we present a formally verified theory of ‍in Isabelle/HOL, with detailed, syntax-directed procedure for abstraction and strengthening that is proven correct. The formalization also includes correctness of symmetry reduction and assume-guarantee reasoning. We also describe a tool AutoCMP for automatically carrying out abstraction and strengthening in , as well as generating Isabelle proof scripts showing their correctness. We applied the tool to a number of parameterized protocols, and discovered some inaccuracies in previous manual applications of ‍to the FLASH cache coherence protocol.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649858", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yongjian", + "last_name": "Li", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Bohua", + "last_name": "Zhan", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Jun", + "last_name": "Pang", + "institution": "University of Luxembourg" + } + ], + "dblp_key": "journals/pacmpl/LiZP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649855", + "title": "A Constraint Solving Approach to Parikh Images of Regular Languages", + "abstract": "A common problem in string constraint solvers is computing the Parikh image, a linear arithmetic formula that describes all possible combinations of character counts in strings of a given language. Automata-based string solvers frequently need to compute the Parikh image of products (or intersections) of finite-state automata, in particular when solving string constraints that also include the integer data-type due to operations like string length and indexing. In this context, the computation of Parikh images often turns out to be both prohibitively slow and memory-intensive. This paper contributes a new understanding of how the reasoning about Parikh images can be cast as a constraint solving problem, and questions about Parikh images be answered without explicitly computing the product automaton or the exact Parikh image. The paper shows how this formulation can be efficiently implemented as a calculus, PC*, embedded in an automated theorem prover supporting Presburger logic. The resulting standalone tool Catra is evaluate on constraints produced by the Ostrich+ string solver when solving standard string constraint benchmarks involving integer operations. The experiments show that PC* strictly outperforms the standard approach by Verma et al. to extract Parikh images from finite-state automata, as well as the over-approximating method recently described by Janků and Turoňová by a wide margin, and for realistic timeouts (under 60 s) also the nuXmv model checker. When added as the Parikh image backend of Ostrich+ to the Ostrich string constraint solver’s portfolio, it boosts its results on the quantifier-free strings with linear integer algebra track of SMT-COMP 2023 (QF_SLIA) enough to solve the most Unsat instances in that track of all competitors.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649855", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Amanda", + "last_name": "Stjerna", + "institution": "Uppsala University" + }, + { + "first_name": "Philipp", + "last_name": "Rümmer", + "institution": "Uppsala University" + } + ], + "dblp_key": "journals/pacmpl/StjernaR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649860", + "title": "Understanding and Finding Java Decompiler Bugs", + "abstract": "Java decompilers are programs that perform the reverse process of Java compilers, i.e., they translate Java bytecode to Java source code. They are essential for reverse engineering purposes and have become more sophisticated and reliable over the years. However, it remains challenging for modern Java decompilers to reliably perform correct decompilation on real-world programs. To shed light on the key challenges of Java decompilation, this paper provides the first systematic study on the characteristics and causes of bugs in mature, widely-used Java decompilers. We conduct the study by investigating 333 unique bugs from three popular Java decompilers. Our key findings and observations include: (1) Although most of the reported bugs were found when decompiling large, real-world code, 40.2% of them have small test cases for bug reproduction; (2) Over 80% of the bugs manifest as exceptions, syntactic errors, or semantic errors, and bugs with source code artifacts are very likely semantic errors; (3) 57.7%, 39.0%, and 41.1% of the bugs respectively are attributed to three stages of decompilers—loading structure entities from bytecode, optimizing these entities, and generating source code from these entities; (4) Bugs in decompilers’ type inference are the most complex to fix; and (5) Region restoration for structures like loop, sugaring for special structures like switch, and type inference of variables of generic types or indistinguishable types are the three most significant challenges in Java decompilation, which to some extent explains our findings in (3) and (4). Based on these findings, we present JD-Tester, a differential testing framework for Java decompilers, and our experience of using it in testing the three popular Java decompilers. JD-Testerutilizes different Java program generators to construct executable Java tests and finds exceptions, syntactic, and semantic inconsistencies (i.e. bugs) between a generated test and its compiled-decompiled version (through compilation and execution). In total, we have found 62 bugs in the three decompilers, demonstrating both the effectiveness of JD-Tester, and the importance of testing and validating Java decompilers.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649860", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yifei", + "last_name": "Lu", + "institution": "Nanjing University" + }, + { + "first_name": "Weidong", + "last_name": "Hou", + "institution": "Nanjing University" + }, + { + "first_name": "Minxue", + "last_name": "Pan", + "institution": "Nanjing University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/LuHPLS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649859", + "title": "Message-Observing Sessions", + "abstract": "We present Most, a process language with message-observing session types. Message-observing session types extend binary session types with type-level computation to specify communication protocols that vary based on messages observed on other channels. Hence, Most allows us to express global invariants about processes, rather than just local invariants, in a bottom-up, compositional way. We give Most a semantic foundation using traces with binding, a semantic approach for compositionally reasoning about traces in the presence of name generation. We use this semantics to prove type soundness and compositionality for Most processes. We see this as a significant step towards capturing message-dependencies and providing more precise guarantees about processes.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649859", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Kavanagh", + "institution": "Université du Québec à Montréal" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "journals/pacmpl/KavanaghP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689714", + "title": "Intensional Functions", + "abstract": "Functions in functional languages have a single elimination form — application — and cannot be compared, hashed, or subjected to other non-application operations. These operations can be approximated via defunctionalization: functions are replaced with first-order data and calls are replaced with invocations of a dispatch function. Operations such as comparison may then be implemented for these first-order data to approximate e.g. deduplication of continuations in algorithms such as unbounded searches. Unfortunately, this encoding is tedious, imposes a maintenance burden, and obfuscates the affected code. We introduce an alternative in intensional functions , a language feature which supports the definition of non-application operations in terms of a function’s definition site and closure-captured values. First-order data operations may be defined on intensional functions without burdensome code transformation. We give an operational semantics and type system and prove their formal properties. We further define intensional monads , whose Kleisli arrows are intensional functions, enabling monadic values to be similarly subjected to additional operations.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689714", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Palmer", + "institution": "Swarthmore College" + }, + { + "first_name": "Nathaniel Wesley", + "last_name": "Filardo", + "institution": "Microsoft (Canada)" + }, + { + "first_name": "Ke", + "last_name": "Wu", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "journals/pacmpl/PalmerFW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689716", + "title": "Statistical Testing of Quantum Programs via Fixed-Point Amplitude Amplification", + "abstract": "We present a new technique for accelerating quantum program testing. Given a quantum circuit with an input/output specification, our goal is to check whether executing the program on the input state produces the expected output. In quantum computing, however, it is impossible to directly check the equivalence of the two quantum states. Instead, we rely on statistical testing, which involves repeated program executions, state measurements, and subsequent comparisons with the specified output. To guarantee a high level of assurance, however, this method requires an extensive number of measurements. In this paper, we propose a solution to alleviate this challenge by adapting Fixed-Point Amplitude Amplification (FPAA) for quantum program testing. We formally present our technique, demonstrate its ability to reduce the required number of measurements as well as runtime cost without sacrificing the original statistical guarantee, and showcase its runtime effectiveness through case studies.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689716", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chan Gu", + "last_name": "Kang", + "institution": "Korea University" + }, + { + "first_name": "J. W.", + "last_name": "Lee", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/KangLO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689718", + "title": "Full Iso-Recursive Types", + "abstract": "There are two well-known formulations of recursive types: iso-recursive and equi-recursive types. Abadi and Fiore [LICS 1996] have shown that iso- and equi-recursive types have the same expressive power. However, their encoding of equi-recursive types in terms of iso-recursive types requires explicit coercions. These coercions come with significant additional computational overhead , and complicate reasoning about the equivalence of the two formulations of recursive types. This paper proposes a generalization of iso-recursive types called full iso-recursive types. Full iso-recursive types allow encoding all programs with equi-recursive types without computational overhead. Instead of explicit term coercions, all type transformations are captured by computationally irrelevant casts, which can be erased at runtime without affecting the semantics of the program. Consequently, reasoning about the equivalence between the two approaches can be greatly simplified. We present a calculus called λ F i μ , which extends the simply typed lambda calculus (STLC) with full iso-recursive types. The λ F i μ calculus is proved to be type sound, and shown to have the same expressive power as a calculus with equi-recursive types. We also extend our results to subtyping, and show that equi-recursive subtyping can be expressed in terms of iso-recursive subtyping with cast operators.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689718", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Litao", + "last_name": "Zhou", + "institution": "University of Hong Kong" + }, + { + "first_name": "Qianyong", + "last_name": "Wan", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/ZhouWO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689711", + "title": "VarLifter: Recovering Variables and Types from Bytecode of Solidity Smart Contracts", + "abstract": "Since funds or tokens in smart contracts are maintained through specific state variables, contract audit, an effective means for security assurance, particularly focuses on these variables and their related operations. However, the absence of publicly accessible source code for numerous contracts, with only bytecode exposed, hinders audit efforts. Recovering variables and their types from Solidity bytecode is thus a critical task in smart contract analysis and audit, yet this is a challenging task because the bytecode loses variable and type information, only with low-level data operated by stack manipulations and untyped memory/storage accesses. The state-of-the-art smart contract decompilers miss identifying many variables and incorrectly infer the types for many identified variables. To this end, we propose VarLifter , a lifter dedicated to the precise and efficient recovery of typed variables. VarLifter interprets every read or written field of a data region as at least one potential variable, and after discarding falsely identified variables, it progressively refines the variable types based on the variable behaviors in the form of operation sequences. We evaluate VarLifter on 34,832 real-world Solidity smart contracts. VarLifter attains a precision of 97.48% and a recall of 91.84% for typed variable recovery. Moreover, VarLifter finishes analyzing 77% of smart contracts in around 10 seconds per contract. If VarLifter is used to replace the variable recovery modules of the two state-of-the-art Solidity bytecode decompilers, 52.4%, and 74.6% more typed variables will be correctly recovered, respectively. The applications of VarLifter to contract decompilation, contract audit, and contract bytecode fuzzing illustrate that the recovered variable information improves many contract analysis tasks.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689711", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yichuan", + "last_name": "Li", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Wei", + "last_name": "Song", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + } + ], + "dblp_key": "journals/pacmpl/00050024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689717", + "title": "A Low-Level Look at A-Normal Form", + "abstract": "A-normal form (ANF) is a widely studied intermediate form in which local control and data flow is made explicit in syntax, and a normal form in which many programs with equivalent control-flow graphs have a single normal syntactic representation. However, ANF is difficult to implement effectively and, as we formalize, difficult to extend with new lexically scoped constructs such as scoped region-based allocation. The problem, as has often been observed, is that normalization of commuting conversions is hard. This traditional view of ANF that normalizing commuting conversions is hard, found in formal models and informed by high-level calculi, is wrong. By studying the low-level intensional aspects of ANF, we can derive a normal form in which normalizing commuting conversion is easy, does not require join points, or code duplication, or renormalization after inlining, and is easily extended with new lexically scoped effects. We formalize the connection between ANF and monadic form and their intensional properties, derive an imperative ANF, and design a compiler pipeline from an untyped λ-calculus with scoped regions, to monadic form, to a low-level imperative monadic form in which A-normalization is trivial and safe for regions. We prove that any such compiler preserves, or optimizes, stack and memory behaviour compared to ANF. Our formalization reconstructs and systematizes pragmatic choices found in practice, including current production-ready compilers. The main take-away from this work is that, in general, monadic form should be preferred over ANF, and A-normalization should only be done in a low-level imperative intermediate form. This maximizes the advantages of each form, and avoids all the standard problems with ANF.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689717", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/Bowman24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649861", + "title": "Taypsi: Static Enforcement of Privacy Policies for Policy-Agnostic Oblivious Computation", + "abstract": "Secure multiparty computation (MPC) techniques enable multiple parties to compute joint functions over their private data without sharing that data with other parties, typically by employing powerful cryptographic protocols to protect individual's data. One challenge when writing such functions is that most MPC languages force users to intermix programmatic and privacy concerns in a single application, making it difficult to change or audit a program's underlying privacy policy. Prior policy-agnostic MPC languages relied on dynamic enforcement to decouple privacy requirements from program logic. Unfortunately, the resulting overhead makes it difficult to scale MPC applications that manipulate structured data. This work proposes to eliminate this overhead by instead transforming programs into semantically equivalent versions that statically enforce user-provided privacy policies. We have implemented this approach in a new MPC language, called Taypsi; our experimental evaluation demonstrates that the resulting system features considerable performance improvements on a variety of MPC applications involving structured data and complex privacy policies.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649861", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qianchuan", + "last_name": "Ye", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/YeD24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649863", + "title": "Modeling Dynamic (De)Allocations of Local Memory for Translation Validation", + "abstract": "End-to-End Translation Validation is the problem of verifying the executable code generated by a compiler against the corresponding input source code for a single compilation. This becomes particularly hard in the presence of dynamically-allocated local memory where addresses of local memory may be observed by the program. In the context of validating the translation of a C procedure to executable code, a validator needs to tackle constant-length local arrays, address-taken local variables, address-taken formal parameters, variable-length local arrays, procedure-call arguments (including variadic arguments), and the alloca () operator. We provide an execution model, a definition of refinement, and an algorithm to soundly convert a refinement check into first-order logic queries that an off-the-shelf SMT solver can handle efficiently. In our experiments, we perform blackbox translation validation of C procedures (with up to 100+ SLOC), involving these local memory allocation constructs, against their corresponding assembly implementations (with up to 200+ instructions) generated by an optimizing compiler with complex loop and vectorizing transformations.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649863", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Abhishek", + "last_name": "Rose", + "institution": "Indian Institute of Technology Delhi" + }, + { + "first_name": "Sorav", + "last_name": "Bansal", + "institution": "Indian Institute of Technology Delhi" + } + ], + "dblp_key": "journals/pacmpl/RoseB24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3649862", + "title": "Iterative-Epoch Online Cycle Elimination for Context-Free Language Reachability", + "abstract": "Context-free language reachability (CFL-reachability) is a fundamental framework for implementing various static analyses. CFL-reachability utilizes context-free grammar (CFG) to extend the expressiveness of ordinary graph reachability from an unlabeled graph to an edge-labeled graph. Solving CFL-reachability requires a (sub)cubic time complexity with respect to the graph size, which limits its scalability in practice. Thus, an approach that can effectively reduce the graph size while maintaining the reachability result is highly desirable. Most of the existing graph simplification techniques for CFL-reachability work during the preprocessing stage, i.e., before the dynamic CFL-reachability solving process. However, in real-world CFL-reachability analyses, there is a large number of reducible nodes and edges that can only be discovered during dynamic solving, leaving significant room for on-the-fly improvements. This paper aims to reduce the graph size of CFL-reachability dynamically via online cycle elimination. We propose a simple yet effective approach to detect collapsible cycles in the graph based on the input context-free grammar. Our key insight is that symbols with particular forms of production rules in the grammar are the essence of transitivity of reachability relations in the graph. Specifically, in the graph, a reachability relation to a node v_i can be \"transited\" to another node v_j if there is a transitive relation from v_i to v_j, and cycles formed by transitive relations are collapsible. In this paper, we present an approach to identify the transitive symbols in a context-free grammar and propose an iterative-epoch framework for online cycle elimination. From the perspective of non-parallelized CFL-reachability solving, our iterative-epoch framework is well compatible with both the standard (unordered) solver and the recent ordered solver, and can significantly improve their performance. Our experiment on context-sensitive value-flow analysis for C/C++ and field-sensitive alias analysis for Java demonstrates promising performance improvement by our iterative-epoch cycle elimination technique. By collapsing cycles online, our technique accelerates the standard solver by 17.17× and 13.94× for value-flow analysis and alias analysis, respectively, with memory reductions of 48.8% and 45.0%. Besides, our technique can also accelerate the ordered solver by 14.32× and 8.36× for value-flow analysis and alias analysis, respectively, with memory reductions of 55.2% and 57.8%.", + "date": "2024-04-29", + "link": "https://doi.org/10.1145/3649862", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pei", + "last_name": "Xu", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Yuxiang", + "last_name": "Lei", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "UNSW Sydney" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "journals/pacmpl/XuLSX24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689719", + "title": "SMT2Test: From SMT Formulas to Effective Test Cases", + "abstract": "One of the primary challenges in software testing is generating high-quality test inputs and obtaining corresponding test oracles. This paper introduces a novel methodology to mitigate this challenge in testing program verifiers by employing SMT (Satisfiability Modulo Theories) formulas as a universal test case generator. The key idea is to transform SMT formulas into programs and link the satisfiability of the formulas with the safety property of the programs, allowing the satisfiability of the formulas to act as a test oracle for program verifiers. This method was implemented as a framework named SMT2Test , which enables the transformation of SMT formulas into Dafny and C programs. An intermediate representation was designed to augment the flexibility of this framework, streamlining the transformation for other programming languages and fostering modular transformation strategies. We evaluated the effectiveness of SMT2Test by finding defects in two program verifiers: the Dafny verifier and CPAchecker. Utilizing the SMT2Test framework with the SMT formulas from the SMT competition and SMT solver fuzzers, we discovered and reported a total of 14 previously unknown defects in these program verifiers that were not found by previous methods. After reporting, all of them have been confirmed, and 6 defects have been fixed. These findings show the effectiveness of our method and imply its potential application in testing other programming language infrastructures.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689719", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chengyu", + "last_name": "Zhang", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/0001024a", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689712", + "title": "A Dependent Nominal Physical Type System for Static Analysis of Memory in Low Level Code", + "abstract": "We tackle the problem of checking non-proof-carrying code , i.e. automatically proving type-safety (implying in our type system spatial memory safety) of low-level C code or of machine code resulting from its compilation without modification. This requires a precise static analysis that we obtain by having a type system which (i) is expressive enough to encode common low-level idioms, like pointer arithmetic, discriminating variants by bit-stealing on aligned pointers, storing the size and the base address of a buffer in distinct parts of the memory, or records with flexible array members, among others; and (ii) can be embedded in an abstract interpreter. We propose a new type system that meets these criteria. The distinguishing feature of this type system is a nominal organization of contiguous memory regions, which (i) allows nesting, concatenation, union, and sharing parameters between regions; (ii) induces a lattice over sets of addresses from the type definitions; and (iii) permits updates to memory cells that change their type without requiring one to control aliasing. We provide a semantic model for our type system, which enables us to derive sound type checking rules by abstract interpretation, then to integrate these rules as an abstract domain in a standard flow-sensitive static analysis. Our experiments on various challenging benchmarks show that semantic type-checking using this expressive type system generally succeeds in proving type safety and spatial memory safety of C and machine code programs without modification, using only user-provided function prototypes.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689712", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Julien", + "last_name": "Simonnet", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Matthieu", + "last_name": "Lemerre", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Mihaela", + "last_name": "Sighireanu", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/SimonnetLS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689715", + "title": "Automating Unrealizability Logic: Hoare-Style Proof Synthesis for Infinite Sets of Programs", + "abstract": "Automated verification of all members of a (potentially infinite) set of programs has the potential to be useful in program synthesis, as well as in verification of dynamically loaded code, concurrent code, and language properties. Existing techniques for verification of sets of programs are limited in scope and unable to create or use interpretable or reusable information about sets of programs. The consequence is that one cannot learn anything from one verification problem that can be used in another. Unrealizability Logic (UL), proposed by Kim et al. as the first Hoare-style proof system to prove properties over sets of programs (defined by a regular tree grammar), presents a theoretical framework that can express and use reusable insight. In particular, UL features nonterminal summaries —inductive facts that characterize recursive nonterminals (analogous to procedure summaries in Hoare logic). In this work, we design the first UL proof synthesis algorithm, implemented as Wuldo . Specifically, we decouple the problem of deciding how to apply UL rules from the problem of synthesizing/checking nonterminal summaries by computing proof structure in a fully syntax-directed fashion. We show that Wuldo , when provided nonterminal summaries, can express and prove verification problems beyond the reach of existing tools, including establishing how infinitely many programs behave on infinitely many inputs. In some cases, Wuldo can even synthesize the necessary nonterminal summaries. Moreover, Wuldo can reuse previously proven nonterminal summaries across verification queries, making verification 1.96 times as fast as when summaries are instead proven from scratch.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689715", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shaan", + "last_name": "Nagy", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Jinwoo", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/NagyKRD24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689720", + "title": "Non-termination Proving at Scale", + "abstract": "Program termination is a classic non-safety property whose falsification cannot in general be witnessed by a finite trace. This makes testing for non-termination challenging, and also a natural target for symbolic proof. Several works in the literature apply non-termination proving to small, self-contained benchmarks, but it has not been developed for large, real-world projects; as such, despite its allure, non-termination proving has had limited practical impact. We develop a compositional theory for non-termination proving, paving the way for its scalable application to large codebases. Discovering non-termination is an under-approximate problem, and we present UNT er , a sound and complete under-approximate logic for proving non-termination. We then extend UNT er with separation logic and develop UNTer SL for heap-manipulating programs, yielding a compositional proof method amenable to automation via under-approximation and bi-abduction. We extend the Pulse analyser from Meta and develop Pulse ∞ , an automated, compositional prover for non-termination based onx UNTer SL . We have run Pulse ∞ on large codebases and libraries, each comprising hundreds of thousands of lines of code, including OpenSSL, libxml2, libxpm and CryptoPP; we discovered several previously-unknown non-termination bugs and have reported them to developers of these libraries.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689720", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Bloomberg (United States)" + }, + { + "first_name": "Julien", + "last_name": "Vanegue", + "institution": "Bloomberg (United States)" + }, + { + "first_name": "Peter W.", + "last_name": "O’Hearn", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/RaadVO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689713", + "title": "Object-Oriented Fixpoint Programming with Datalog", + "abstract": "Modern usages of Datalog exceed its original design purpose in scale and complexity. In particular, Datalog lacks abstractions for code organization and reuse, making programs hard to maintain. Is it possible to exploit abstractions and design patterns from object-oriented programming (OOP) while retaining a Datalog-like fixpoint semantics? To answer this question, we design a new OOP language called OODL with common OOP features: dynamic object allocation, object identity, dynamic dispatch, and mutation. However, OODL has a Datalog-like fixpoint semantics, such that recursive computations iterate until their result becomes stable. We develop two semantics for OODL: a fixpoint interpreter and a compiler that translates OODL to Datalog. Although the side effects found in OOP (object allocation and mutation) conflict with Datalog's fixpoint semantics, we can mostly resolve these incompatibilities through extensions of OODL. Within fixpoint computations, we employ immutable algebraic data structures (e.g. case classes in Scala), rather than relying on object allocation, and we introduce monotonically mutable data types ( mono types ) to enable a relaxed form of mutation. Our performance evaluation shows that the interpreter fails to solve fixpoint problems efficiently, whereas the compiled code exploits Datalog's semi-naïve evaluation.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689713", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "D. A.", + "last_name": "Klopp", + "institution": "" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "" + }, + { + "first_name": "André", + "last_name": "Pacak", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/KloppEP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689721", + "title": "Compiler Support for Sparse Tensor Convolutions", + "abstract": "This paper extends prior work on sparse tensor algebra compilers to generate asymptotically efficient code for tensor expressions with affine subscript expressions. Our technique enables compiler support for a wide range of sparse computations, including sparse convolutions and pooling that are widely used in ML and graphics applications. We propose an approach that gradually rewrites compound subscript expressions to simple subscript expressions with loops that exploit the sparsity pattern of the input sparse tensors. As a result, the time complexity of the generated kernels is bounded by the number of stored elements and not by the shape of the tensors. Our approach seamlessly integrates into existing frameworks and is compatible with recent advances in compilers for sparse computations, including the flexibility to efficiently handle arbitrary combinations of different sparse tensor formats. The implementation of our algorithm is open source and upstreamed to the MLIR sparse compiler. Experimental results show that our method achieves 19.5x speedup when compared with the state-of-the-art compiler-based method at 99.9% sparsity. The generated sparse kernels start to outperform dense convolution implementations at about 80% sparsity", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689721", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peiming", + "last_name": "Liu", + "institution": "Google (United States)" + }, + { + "first_name": "Alexander J", + "last_name": "Root", + "institution": "Stanford University" + }, + { + "first_name": "Anlun", + "last_name": "Xu", + "institution": "Google (United States)" + }, + { + "first_name": "Yinying", + "last_name": "Li", + "institution": "Google (United States)" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + }, + { + "first_name": "Aart J. C.", + "last_name": "Bik", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/LiuRXLKB24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689722", + "title": "Iris-MSWasm: Elucidating and Mechanising the Security Invariants of Memory-Safe WebAssembly", + "abstract": "WebAssembly offers coarse-grained encapsulation guarantees via its module system, but does not support fine-grained sharing of its linear memory. MSWasm is a recent proposal which extends WebAssembly with fine-grained memory sharing via handles, a type of capability that guarantees spatial and temporal safety, and thus enables an expressive yet safe style of programming with flexible sharing. In this paper, we formally validate the pen-and-paper design of MSWasm. To do so, we first define MSWasmCert, a mechanisation of MSWasm that makes it a fully-defined, conservative extension of WebAssembly 1.0, including the module system. We then develop Iris-MSWasm, a foundational reasoning framework for MSWasm composed of a separation logic to reason about known code, and a logical relation to reason about unknown, potentially adversarial code. Iris-MSWasm thereby makes explicit a key aspect of the implicit universal contract of MSWasm: robust capability safety. We apply Iris-MSWasm to reason about key use cases of handles, in which the effect of calling an unknown function is bounded by robust capability safety. Iris-MSWasm thus works as a framework to prove complex security properties of MSWasm programs, and provides a foundation to evaluate the language-level guarantees of MSWasm.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689722", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Maxime", + "last_name": "Legoupil", + "institution": "Aarhus University" + }, + { + "first_name": "June", + "last_name": "Rousseau", + "institution": "Aarhus University" + }, + { + "first_name": "Aïna Linn", + "last_name": "Georges", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/LegoupilRGPB24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689723", + "title": "libLISA: Instruction Discovery and Analysis on x86-64", + "abstract": "Even though heavily researched, a full formal model of the x86-64 instruction set is still not available. We present libLISA , a tool for automated discovery and analysis of the ISA of a CPU. This produces the most extensive formal x86-64 model to date, with over 118 000 different instruction groups. The process requires as little human specification as possible: specifically, we do not rely on a human-written (dis)assembler to dictate which instructions are executable on a given CPU, or what their in- and outputs are. The generated model is CPU-specific: behavior that is “undefined” is synthesized for the current machine. Producing models for five different x86-64 machines, we mutually compare them, discover undocumented instructions, and generate instruction sequences that are CPU-specific. Experimental evaluation shows that we enumerate virtually all instructions within scope, that the instructions’ semantics are correct w.r.t. existing work, and that we improve existing work by exposing bugs in their handwritten models.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689723", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jos", + "last_name": "Craaijo", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Freek", + "last_name": "Verbeek", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Binoy", + "last_name": "Ravindran", + "institution": "Virginia Tech" + } + ], + "dblp_key": "journals/pacmpl/CraaijoVR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689724", + "title": "Synthesizing Formal Semantics from Executable Interpreters", + "abstract": "Program verification and synthesis frameworks that allow one to customize the language in which one is interested typically require the user to provide a formally defined semantics for the language. Because writing a formal semantics can be a daunting and error-prone task, this requirement stands in the way of such frameworks being adopted by non-expert users. We present an algorithm that can automatically synthesize inductively defined syntax-directed semantics when given ( i ) a grammar describing the syntax of a language and ( ii ) an executable (closed-box) interpreter for computing the semantics of programs in the language of the grammar. Our algorithm synthesizes the semantics in the form of Constrained-Horn Clauses (CHCs), a natural, extensible, and formal logical framework for specifying inductively defined relations that has recently received widespread adoption in program verification and synthesis. The key innovation of our synthesis algorithm is a Counterexample-Guided Synthesis (CEGIS) approach that breaks the hard problem of synthesizing a set of constrained Horn clauses into small, tractable expression-synthesis problems that can be dispatched to existing SyGuS synthesizers. Our tool SynAntic synthesized inductively-defined formal semantics from 14 interpreters for languages used in program-synthesis applications. When synthesizing formal semantics for one of our benchmarks, Synantic unveiled an inconsistency in the semantics computed by the interpreter for a language of regular expressions; fixing the inconsistency resulted in a more efficient semantics and, for some cases, in a 1.2 x speedup for a synthesizer solving synthesis problems over such a language.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689724", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jiangyi", + "last_name": "Liu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Charlie", + "last_name": "Murphy", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Anvay", + "last_name": "Grover", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Keith J. C.", + "last_name": "Johnson", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/LiuMGJRD24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689729", + "title": "FlowCert: Translation Validation for Asynchronous Dataflow via Dynamic Fractional Permissions", + "abstract": "Coarse-grained reconfigurable arrays (CGRAs) have gained attention in recent years due to their promising power efficiency compared to traditional von Neumann architectures. To program these architectures using ordinary languages such as C, a dataflow compiler must transform the original sequential, imperative program into an equivalent dataflow graph, composed of dataflow operators running in parallel. This transformation is challenging since the asynchronous nature of dataflow graphs allows out-of-order execution of operators, leading to behaviors not present in the original imperative programs. Weaddress this challenge by developing a translation validation technique for dataflow compilers to ensure that the dataflow program has the same behavior as the original imperative program on all possible inputs and schedules of execution. We apply this method to a state-of-the-art dataflow compiler targeting the RipTide CGRAarchitecture. Our tool uncovers 8 compiler bugs where the compiler outputs incorrect dataflow graphs, including a data race that is otherwise hard to discover via testing. After repairing these bugs, our tool verifies the correct compilation of all programs in the RipTide benchmark suite.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689729", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhengyao", + "last_name": "Lin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Joshua", + "last_name": "Gancher", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Bryan", + "last_name": "Parno", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/LinGP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689727", + "title": "Mix Testing: Specifying and Testing ABI Compatibility of C/C++ Atomics Implementations", + "abstract": "The correctness of complex software depends on the correctness of both the source code and the compilers that generate corresponding binary code. Compilers must do more than preserve the semantics of a single source file: they must ensure that generated binaries can be composed with other binaries to form a final executable. The compatibility of composition is ensured using an Application Binary Interface (ABI), which specifies details of calling conventions, exception handling, and so on. Unfortunately, there are no official ABIs for concurrent programs, so different atomics mappings, although correct in isolation, may induce bugs when composed. Indeed, today, mixing binaries generated by different compilers can lead to an erroneous resulting binary. We present mix testing : a new technique designed to find compiler bugs when the instructions of a C/C++ test are separately compiled for multiple compatible architectures and then mixed together. We define a class of compiler bugs, coined mixing bugs , that arise when parts of a program are compiled separately using different mappings from C/C++ atomic operations to assembly sequences. To demonstrate the generality of mix testing, we have designed and implemented a tool, atomic-mixer , which we have used: (a) to reproduce one existing non-mixing bug that state-of-the-art concurrency testing tools are limited to being able to find (showing that atomic-mixer at least meets the capabilities of these tools), and (b) to find four previously-unknown mixing bugs in LLVM and GCC, and one prospective mixing bug in mappings proposed for the Java Virtual Machine. Lastly, we have worked with engineers at Arm to specify, for the first time, an atomics ABI for Armv8, and have used atomic-mixer to validate the LLVM and GCC compilers against it.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689727", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Luke", + "last_name": "Geeson", + "institution": "University College London" + }, + { + "first_name": "J G.", + "last_name": "Brotherston", + "institution": "University College London" + }, + { + "first_name": "W.", + "last_name": "Dijkstra", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + }, + { + "first_name": "Lee", + "last_name": "Smith", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/GeesonBDDS0W24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689725", + "title": "A Modal Type Theory of Expected Cost in Higher-Order Probabilistic Programs", + "abstract": "The design of online learning algorithms typically aims to optimise the incurred loss or cost , e.g., the number of classification mistakes made by the algorithm. The goal of this paper is to build a type-theoretic framework to prove that a certain algorithm achieves its stated bound on the cost. Online learning algorithms often rely on randomness, their loss functions are often defined as expectations, precise bounds are often non-polynomial (e.g., logarithmic) and proofs of optimality often rely on potentialbased arguments. Accordingly, we present pλ-amor, a type-theoretic graded modal framework for analysing (expected) costs of higher-order probabilistic programs with recursion. pλ-amor is an effect-based framework which uses graded modal types to represent potentials, cost and probability at the type level. It extends prior work ( λ-amor) on cost analysis for deterministic programs. We prove pλ-amor sound relative to a Kripke step-indexed model which relates potentials with probabilistic coupling. We use pλ-amor to prove cost bounds of several examples from the online machine learning literature. Finally, we describe an extension of pλ-amor with a graded comonad and describe the relationship between the different modalities.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689725", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vineet", + "last_name": "Rajani", + "institution": "University of Kent" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RajaniB024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689726", + "title": "Sensitivity by Parametricity", + "abstract": "The work of Fuzz has pioneered the use of functional programming languages where types allow reasoning about the sensitivity of programs. Fuzz and subsequent work (e.g., DFuzz and Duet) use advanced technical devices like linear types, modal types, and partial evaluation. These features usually require the design of a new programming language from scratch—a significant task on its own! While these features are part of the classical toolbox of programming languages, they are often unfamiliar to non-experts in this field. Fortunately, recent studies (e.g., Solo ) have shown that linear and complex types in general, are not strictly needed for the task of determining programs’ sensitivity since this can be achieved by annotating base types with static sensitivity information. In this work, we take a different approach. We propose to enrich base types with information about the metric relation between values, and we present the novel idea of applying parametricity to derive direct proofs for the sensitivity of functions. A direct consequence of our result is that calculating and proving the sensitivity of functions is reduced to simply type-checking in a programming language with support for polymorphism and type-level naturals. We formalize our main result in a calculus, prove its soundness, and implement a software library in the programming language Haskell-where we reason about the sensitivity of canonical examples. We show that the simplicity of our approach allows us to exploit the type inference of the host language to support a limited form of sensitivity inference. Furthermore, we extend the language with a privacy monad to showcase how our library can be used in practical scenarios such as the implementation of differentially private programs, where the privacy guarantees depend on the sensitivity of user-defined functions. Our library, called Spar , is implemented in less than 500 lines of code.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689726", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Elisabet", + "last_name": "Lobo-Vesga", + "institution": "" + }, + { + "first_name": "Alejandro", + "last_name": "Russo", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "" + }, + { + "first_name": "Carlos Tomé", + "last_name": "Cortiñas", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "journals/pacmpl/VesgaRGC24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689728", + "title": "Statically Contextualizing Large Language Models with Typed Holes", + "abstract": "Large language models (LLMs) have reshaped the landscape of program synthesis. However, contemporary LLM-based code completion systems often hallucinate broken code because they lack appropriate code context, particularly when working with definitions that are neither in the training data nor near the cursor. This paper demonstrates that tighter integration with the type and binding structure of the programming language in use, as exposed by its language server, can help address this contextualization problem in a token-efficient manner. In short, we contend that AIs need IDEs, too! In particular, we integrate LLM code generation into the Hazel live program sketching environment. The Hazel Language Server is able to identify the type and typing context of the hole that the programmer is filling, with Hazel’s total syntax and type error correction ensuring that a meaningful program sketch is available whenever the developer requests a completion. This allows the system to prompt the LLM with codebase-wide contextual information that is not lexically local to the cursor, nor necessarily in the same file, but that is likely to be semantically local to the developer’s goal. Completions synthesized by the LLM are then iteratively refined via further dialog with the language server, which provides error localization and error messages. To evaluate these techniques, we introduce MVUBench, a dataset of model-view-update (MVU) web applications with accompanying unit tests that have been written from scratch to avoid data contamination, and that can easily be ported to new languages because they do not have large external library dependencies. These applications serve as challenge problems due to their extensive reliance on application-specific data structures. Through an ablation study, we examine the impact of contextualization with type definitions, function headers, and errors messages, individually and in combination. We find that contextualization with type definitions is particularly impactful. After introducing our ideas in the context of Hazel, a low-resource language, we duplicate our techniques and port MVUBench to TypeScript in order to validate the applicability of these methods to higher-resource mainstream languages. Finally, we outline ChatLSP, a conservative extension to the Language Server Protocol (LSP) that language servers can implement to expose capabilities that AI code completion systems of various designs can use to incorporate static context when generating prompts for an LLM.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689728", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Blinn", + "institution": "University of Michigan" + }, + { + "first_name": "Xiang", + "last_name": "Li", + "institution": "University of Michigan" + }, + { + "first_name": "J.", + "last_name": "Kim", + "institution": "University of Michigan" + }, + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/BlinnLKO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689731", + "title": "Quantum Probabilistic Model Checking for Time-Bounded Properties", + "abstract": "Probabilistic model checking (PMC) is a verification technique for analyzing the properties of probabilistic systems. However, existing techniques face challenges in verifying large systems with high accuracy. PMC struggles with state explosion , where the number of states grows exponentially with the size of the system, making large system verification infeasible. While statistical model checking (SMC) avoids PMC’s state explosion problem by using a simulation approach, it suffers from runtime explosion, requiring numerous samples for high accuracy. To address these limitations in verifying large systems with high accuracy, we present quantum probabilistic model checking (QPMC), the first method leveraging quantum computing for PMC with respect to timebounded properties. QPMC addresses state explosion by encoding PMC problems into quantum circuits that superpose states within qubits. Additionally, QPMC resolves runtime explosion through Quantum Amplitude Estimation, efficiently estimating the probabilities of specified properties. We prove that QPMC correctly solves PMC problems and achieves a quadratic speedup in time complexity compared to SMC.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689731", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Seungmin", + "last_name": "Jeon", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Kyeongmin", + "last_name": "Cho", + "institution": "" + }, + { + "first_name": "Chan Gu", + "last_name": "Kang", + "institution": "Korea University" + }, + { + "first_name": "Janggun", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/JeonCKLOK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689733", + "title": "Crabtree: Rust API Test Synthesis Guided by Coverage and Type", + "abstract": "Rust type system constrains pointer operations, preventing bugs such as use-after-free. However, these constraints may be too strict for programming tasks such as implementing cyclic data structures. For such tasks, programmers can temporarily suspend checks using the unsafe keyword. Rust libraries wrap unsafe code blocks and expose higher-level APIs. They need to be extensively tested to uncover memory-safety bugs that can only be triggered by unexpected API call sequences or inputs. While prior works have attempted to automatically test Rust library APIs, they fail to test APIs with common Rust features, such as polymorphism, traits, and higher-order functions, or they have scalability issues and can only generate tests for a small number of combined APIs. We propose Crabtree, a testing tool for Rust library APIs that can automatically synthesize test cases with native support for Rust traits and higher-order functions. Our tool improves upon the test synthesis algorithms of prior works by combining synthesis and fuzzing through a coverage- and type-guided search algorithm that intelligently grows test programs and input corpus towards testing more code. To the best of our knowledge, our tool is the first to generate well-typed tests for libraries that make use of higher-order trait functions. Evaluation of Crabtree on 30 libraries found four previously unreported memory-safety bugs, all of which were accepted by the respective authors.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689733", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yoshiki", + "last_name": "Takashima", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Chanhee", + "last_name": "Cho", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ruben", + "last_name": "Martins", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Corina S.", + "last_name": "Păsăreanu", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/TakashimaCM0P24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689732", + "title": "Verified Lock-Free Session Channels with Linking", + "abstract": "Type systems and program logics based on session types provide powerful high-level reasoning principles for message-passing concurrency. Modern versions employ bidirectional session channels that (1) are asynchronous so that send operations do not block, (2) have buffers in both directions so that both parties can send messages in parallel, and (3) feature a link operation (also called forward ) to concisely write programs in process style . These features complicate a low-level lock-free implementation of channels and therefore increase the gap between the meta theory of prior work—which is verified w.r.t. a high-level semantics of channels ( e.g ., π -calculus)—and the code that runs on an actual computer. We address this problem by verifying a low-level lock-free implementation of session channels w.r.t. a high-level specification based on session types. We carry out our verification in a layered manner by employing the Iris framework for concurrent separation logic. We start with an abstract specification of (unidirectional) queues—of which we provide a linked-list and array-segment based implementation—and gradually build up to session channels with all of the aforementioned features. To make a layered verification possible we develop two logical abstractions— queues with ghost linking and pairing invariants —to reason about the atomicity and changing endpoints due to linking, respectively. All our results are mechanized in the Coq proof assistant.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689732", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Somers", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/SomersK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689737", + "title": "HiPy: Extracting High-Level Semantics from Python Code for Data Processing", + "abstract": "Data science workloads frequently include Python code, but Python’s dynamic nature makes efficient execution hard. Traditional approaches either treat Python as a black box, missing out on optimization potential, or are limited to a narrow domain. However, a deep and efficient integration of user-defined Python code into data processing systems requires extracting the semantics of the entire Python code. In this paper, we propose a novel approach for extracting the high-level semantics by transforming general Python functions into program generators that generate a statically-typed IR when executed. The extracted IR then allows for high-level, domain-specific optimizations and the generation of efficient C++ code. With our prototype implementation, HiPy, we achieve single-threaded speedups of 2–20x for many workloads. Furthermore, HiPy is also capable of accelerating Python code in other domains like numerical data, where it can sometimes even outperform specialized compilers.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689737", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Jungmair", + "institution": "" + }, + { + "first_name": "Alexis", + "last_name": "Engelke", + "institution": "" + }, + { + "first_name": "Jana", + "last_name": "Giceva", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/JungmairEG24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689736", + "title": "WhiteFox: White-Box Compiler Fuzzing Empowered by Large Language Models", + "abstract": "Compiler correctness is crucial, as miscompilation can falsify program behaviors, leading to serious consequences over the software supply chain. In the literature, fuzzing has been extensively studied to uncover compiler defects. However, compiler fuzzing remains challenging: Existing arts focus on black- and grey-box fuzzing, which generates test programs without sufficient understanding of internal compiler behaviors. As such, they often fail to construct test programs to exercise intricate optimizations. Meanwhile, traditional white-box techniques, such as symbolic execution, are computationally inapplicable to the giant codebase of compiler systems. Recent advances demonstrate that Large Language Models (LLMs) excel in code generation/understanding tasks and even have achieved state-of-the-art performance in black-box fuzzing. Nonetheless, guiding LLMs with compiler source-code information remains a missing piece of research in compiler testing. To this end, we propose W hite F ox , the first white-box compiler fuzzer using LLMs with source-code information to test compiler optimization, with a spotlight on detecting deep logic bugs in the emerging deep learning (DL) compilers. W hite F ox adopts a multi-agent framework: (i) an LLM-based analysis agent examines the low-level optimization source code and produces requirements on the high-level test programs that can trigger the optimization; (ii) an LLM-based generation agent produces test programs based on the summarized requirements. Additionally, optimization-triggering tests are also used as feedback to further enhance the test generation prompt on the fly. Our evaluation on the three most popular DL compilers ( i.e ., PyTorch Inductor, TensorFlow-XLA, and TensorFlow Lite) shows that W hite F ox can generate high-quality test programs to exercise deep optimizations requiring intricate conditions, practicing up to 8 times more optimizations than state-of-the-art fuzzers. To date, W hite F ox has found in total 101 bugs for the compilers under test, with 92 confirmed as previously unknown and 70 already fixed. Notably, W hite F ox has been recently acknowledged by the PyTorch team, and is in the process of being incorporated into its development workflow. Finally, beyond DL compilers, W hite F ox can also be adapted for compilers in different domains, such as LLVM, where WHiteFox has already found multiple bugs.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689736", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chenyuan", + "last_name": "Yang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Yinlin", + "last_name": "Deng", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Runyu", + "last_name": "Lu", + "institution": "Huazhong University of Science and Technology" + }, + { + "first_name": "Jiayi", + "last_name": "Yao", + "institution": "Chinese University of Hong Kong, Shenzhen" + }, + { + "first_name": "Jiawei", + "last_name": "Liu", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Reyhaneh", + "last_name": "Jabbarvand", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Lingming", + "last_name": "Zhang", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/YangDLY0J024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689738", + "title": "Automatically Reducing Privilege for Access Control Policies", + "abstract": "Access control policies are programs used to secure cloud resources. These polices should only grant the necessary permissions that a given application needs. However, it is challenging to write and maintain policies as applications and their required permissions change over time. In this paper, we focus on the Amazon Web Services (AWS) IAM policy language and present an approach that, given a policy, synthesizes a modified policy that is more restrictive and better abides to the principle of least privilege. Our approach looks at the actual access history (e.g., access logs) used by an application and computes the least permissive local modification of the user-given policy that still provides the same permissions that were observed in the access history. We treat the problem of computing the least permissive policy as a generalization problem in a lattice of possible policies (i.e., the set of local modifications). We show that our synthesis algorithm comes with correctness guarantees and is amendable to an efficient implementation that is easy to parallelize. We implement our algorithm in a tool IAM-PolicyRefiner and evaluate it on policies attached to AWS roles with access logs. For each role, IAM-PolicyRefiner can compute easy-to-inspect refined policies in less than 1 minute, and the refined policies do not overfit to the requests in the log—i.e., the policies also allow requests in a left-out test set of requests.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689738", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "Amazon (United States)" + }, + { + "first_name": "Shuo", + "last_name": "Ding", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Amit", + "last_name": "Goel", + "institution": "Amazon (United States)" + }, + { + "first_name": "Mathangi", + "last_name": "Ramesh", + "institution": "Amazon (United States)" + }, + { + "first_name": "Neha", + "last_name": "Rungta", + "institution": "Amazon (United States)" + }, + { + "first_name": "Chungha", + "last_name": "Sung", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/DAntoniDGRRS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689735", + "title": "Knowledge Transfer from High-Resource to Low-Resource Programming Languages for Code LLMs", + "abstract": "Over the past few years, Large Language Models of Code (Code LLMs) have started to have a significant impact on programming practice. Code LLMs are also emerging as building blocks for research in programming languages and software engineering. However, the quality of code produced by a Code LLM varies significantly by programming language. Code LLMs produce impressive results on high-resource programming languages that are well represented in their training data (e.g., Java, Python, or JavaScript), but struggle with low-resource languages that have limited training data available (e.g., OCaml, Racket, and several others). This paper presents an effective approach for boosting the performance of Code LLMs on low-resource languages using semi-synthetic data. Our approach, called M ulti PL-T, generates high-quality datasets for low-resource languages, which can then be used to fine-tune any pretrained Code LLM. M ulti PL-T translates training data from high-resource languages into training data for low-resource languages in the following way. 1) We use a Code LLM to synthesize unit tests for commented code from a high-resource source language, filtering out faulty tests and code with low test coverage. 2) We use a Code LLM to translate the code from the high-resource source language to a target low-resource language. This gives us a corpus of candidate training data in the target language, but many of these translations are wrong. 3) We use a lightweight compiler to compile the test cases generated in (1) from the source language to the target language, which allows us to filter our obviously wrong translations. The result is a training corpus in the target low-resource language where all items have been validated with test cases. We apply this approach to generate tens of thousands of new, validated training items for five low-resource languages: Julia, Lua, OCaml, R, and Racket, using Python as the source high-resource language. Furthermore, we use an open Code LLM (StarCoderBase) with open training data (The Stack), which allows us to decontaminate benchmarks, train models without violating licenses, and run experiments that could not otherwise be done. Using datasets generated with M ulti PL-T, we present fine-tuned versions of StarCoderBase and Code Llama for Julia, Lua, OCaml, R, and Racket that outperform other fine-tunes of these base models on the natural language to code task. We also present Racket fine-tunes for two very recent models, DeepSeek Coder and StarCoder2, to show that M ulti PL-T continues to outperform other fine-tuning approaches for low-resource languages. The M ulti PL-T approach is easy to apply to new languages, and is significantly more efficient and effective than alternatives such as training longer.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689735", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Federico", + "last_name": "Cassano", + "institution": "Northeastern University" + }, + { + "first_name": "John", + "last_name": "Gouwar", + "institution": "Northeastern University" + }, + { + "first_name": "Francesca", + "last_name": "Lucchetti", + "institution": "Northeastern University" + }, + { + "first_name": "Claire", + "last_name": "Schlesinger", + "institution": "Northeastern University" + }, + { + "first_name": "Anders", + "last_name": "Freeman", + "institution": "Wellesley College" + }, + { + "first_name": "Carolyn Jane", + "last_name": "Anderson", + "institution": "Wellesley College" + }, + { + "first_name": "Molly Q", + "last_name": "Feldman", + "institution": "Oberlin College" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Abhinav", + "last_name": "Jangda", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/CassanoGLSFAF0J24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689734", + "title": "Merging Gradual Typing", + "abstract": "Programming language mechanisms with a type-directed semantics are nowadays common and widely used. Such mechanisms include gradual typing, type classes, implicits and intersection types with a merge operator . While sharing common challenges in their design and having complementary strengths, type-directed mechanisms have been mostly independently studied. This paper studies a new calculus, called λ M ★ , which combines two type-directed mechanisms: gradual typing and a merge operator based on intersection types. Gradual typing enables a smooth transition between dynamically and statically typed code, and is available in languages such as TypeScript or Flow. The merge operator generalizes record concatenation to allow merges of values of any two types. Recent work has shown that the merge operator enables modelling expressive OOP features like first-class traits/classes and dynamic inheritance with static type-checking. These features are not found in mainstream statically typed OOP languages, but they can be found in dynamically or gradually typed languages such as JavaScript or TypeScript. In λ M ★ , by exploiting the complementary strengths of gradual typing and the merge operator, we obtain a foundation for modelling gradually typed languages with both first-class classes and dynamic inheritance. We study a static variant of λ M ★ (called λ M ); prove the type-soundness of λ M ★ ; show that λ M ★ can encode gradual rows and all well-typed terms in the GTFL ≲ typing criteria. The dynamic gradual guarantee (DGG) is challenging due to the possibility of ambiguity errors. We establish a variant of the DGG using a semantic notion of precision based on a step-indexed logical relation.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689734", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wenjia", + "last_name": "Ye", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/YeOT24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689739", + "title": "Fully Verified Instruction Scheduling", + "abstract": "CompCert project, the state-of-the-art compiler that achieves the first end-to-end formally verified C compiler, does not support fully verified instruction scheduling. Instead, existing research that works on such topics only implements translation validation. This means they do not have direct formal proof that the scheduling algorithm is correct, but only a posterior validation to check each compiling case. Using such a method, CompCert accepts a valid C program and compiles correctly only when the untrusted scheduler generates a correct result. However, it does not guarantee the complete correctness of the scheduler. It also causes compile-time validation overhead in the view of runtime performance. In this work, we present the first achievement in developing a mechanized library for fully verified instruction scheduling while keeping the proof workload acceptably lightweight. The idea to reduce the proof length is to exploit a simple property that the topological reordering of a topological sorted list is equal to a sequence of swapping adjacent unordered elements. Together with the transitivity of semantic simulation relation, the only burden will become proving the semantic preservation of a transition that only swaps two adjacent independent instructions inside one block. After successfully proving this result, proving the correctness of any new instruction scheduling algorithm only requires proof that it preserved the syntax-level dependence among instructions, instead of reasoning about semantics details every time. We implemented a mechanized library of such methods in the Coq proof assistant based on CompCert’s library as a framework and used the list scheduling algorithm as a case study to show the correctness can be formally proved using our theory. We show that with our method that abstracts away the semantics details, it is flexible to implement any scheduler that reorders instructions with little extra proof burden. Our scheduler in the case study also abstracts away the outside scheduling heuristic as a universal parameter so it is flexible to modify without touching any correctness proof.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689739", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ziteng", + "last_name": "Yang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Jun", + "last_name": "Shirako", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/YangSS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689740", + "title": "Quantitative Weakest Hyper Pre: Unifying Correctness and Incorrectness Hyperproperties via Predicate Transformers", + "abstract": "We present a novel weakest pre calculus for reasoning about quantitative hyperproperties over nondeterministic and probabilistic programs . Whereas existing calculi allow reasoning about the expected value that a quantity assumes after program termination from a single initial state , we do so for initial sets of states or initial probability distributions . We thus (i) obtain a weakest pre calculus for hyper Hoare logic and (ii) enable reasoning about so-called hyperquantities which include expected values but also quantities (e.g. variance) out of scope of previous work. As a byproduct, we obtain a novel strongest post for weighted programs that extends both existing strongest and strongest liberal post calculi. Our framework reveals novel dualities between forward and backward transformers, correctness and incorrectness, as well as nontermination and unreachability.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689740", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Linpeng", + "last_name": "Zhang", + "institution": "University College London" + }, + { + "first_name": "Noam", + "last_name": "Zilberstein", + "institution": "Cornell University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/ZhangZK024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689741", + "title": "CoolerSpace: A Language for Physically Correct and Computationally Efficient Color Programming", + "abstract": "Color programmers manipulate lights, materials, and the resulting colors from light-material interactions. Existing libraries for color programming provide only a thin layer of abstraction around matrix operations. Color programs are, thus, vulnerable to bugs arising from mathematically permissible but physically meaningless matrix computations. Correct implementations are difficult to write and optimize. We introduce C ooler S pace to facilitate physically correct and computationally efficient color programming. C ooler S pace raises the level of abstraction of color programming by allowing programmers to focus on describing the logic of color physics. Correctness and efficiency are handled by C ooler S pace . The type system in C ooler S pace assigns physical meaning and dimensions to user-defined objects. The typing rules permit only legal computations informed by color physics and perception. Along with type checking, C ooler S pace also generates performance-optimized programs using equality saturation. C ooler S pace is implemented as a Python library and compiles to ONNX, a common intermediate representation for tensor computations. C ooler S pace not only prevents common errors in color programming, but also does so without run-time overhead: even unoptimized C ooler S pace programs out-perform existing Python-based color programming systems by up to 5.7 times; our optimizations provide up to an additional 1.4 times speed-up.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689741", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ethan", + "last_name": "Chen", + "institution": "University of Rochester" + }, + { + "first_name": "Jiwon", + "last_name": "Chang", + "institution": "University of Rochester" + }, + { + "first_name": "Yuhao", + "last_name": "Zhu", + "institution": "University of Rochester" + } + ], + "dblp_key": "journals/pacmpl/ChenC024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689742", + "title": "Plume: Efficient and Complete Black-Box Checking of Weak Isolation Levels", + "abstract": "Modern databases embrace weak isolation levels to cater for highly available transactions. However, weak isolation bugs have recently manifested in many production databases. This raises the concern of whether database implementations actually deliver their promised isolation guarantees in practice. In this paper we present Plume, the first efficient, complete, black-box checker for weak isolation levels. Plume builds on modular, fine-grained, transactional anomalous patterns, with which we establish sound and complete characterizations of representative weak isolation levels, including read committed, read atomicity, and transactional causal consistency. Plume leverages a novel combination of two techniques, vectors and tree clocks, to accelerate isolation checking. Our extensive assessment shows that Plume can reproduce all known violations in a large collection of anomalous database execution histories, detect new isolation bugs in three production databases along with informative counterexamples, find more weak isolation anomalies than the state-of-the-art checkers, and efficiently validate isolation guarantees under a wide variety of workloads.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689742", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Si", + "last_name": "Liu", + "institution": "ETH Zurich" + }, + { + "first_name": "Long", + "last_name": "Gu", + "institution": "Nanjing University" + }, + { + "first_name": "Hengfeng", + "last_name": "Wei", + "institution": "Nanjing University" + }, + { + "first_name": "David", + "last_name": "Basin", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/0003GWB24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689746", + "title": "The Ultimate Conditional Syntax", + "abstract": "Functional programming languages typically support expressive pattern-matching syntax allowing programmers to write concise and type-safe code, especially appropriate for manipulating algebraic data types. Many features have been proposed to enhance the expressiveness of stock pattern-matching syntax, such as pattern bindings, pattern alternatives (a.k.a. disjunction), pattern conjunction, view patterns, pattern guards, pattern synonyms, active patterns, ‘if-let’ patterns, multi-way if-expressions, etc. In this paper, we propose a new pattern-matching syntax that is both more expressive and (we argue) simpler and more readable than previous alternatives. Our syntax supports parallel and nested matches interleaved with computations and intermediate bindings. This is achieved through a form of nested multi-way if-expressions with a condition-splitting mechanism to factor common conditional prefixes as well as a binding technique we call conditional pattern flowing . We motivate this new syntax with many examples in the setting of MLscript, a new ML-family programming language. We describe a straightforward desugaring pass from our rich source syntax into a minimal core syntax that only supports flat patterns and has an intuitive small-step semantics. We then provide a translation from the core syntax into a normalized syntax without backtracking, which is more amenable to coverage checking and compilation, and formally prove that our translation is semantics-preserving. We view this work as a step towards rethinking pattern matching to make it more powerful and natural to use. Our syntax can easily be integrated, in part or in whole, into existing as well as future programming language designs.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689746", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "L.", + "last_name": "Cheng", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ChengP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689744", + "title": "Automating Pruning in Top-Down Enumeration for Program Synthesis Problems with Monotonic Semantics", + "abstract": "In top-down enumeration for program synthesis, abstraction-based pruning uses an abstract domain to approximate the set of possible values that a partial program, when completed, can output on a given input. If the set does not contain the desired output, the partial program and all its possible completions can be pruned. In its general form, abstraction-based pruning requires manually designed, domain-specific abstract domains and semantics, and thus has only been used in domain-specific synthesizers. This paper provides sufficient conditions under which a form of abstraction-based pruning can be automated for arbitrary synthesis problems in the general-purpose Semantics-Guided Synthesis (SemGuS) framework without requiring manually-defined abstract domains. We show that if the semantics of the language for which we are synthesizing programs exhibits some monotonicity properties, one can obtain an abstract interval-based semantics for free from the concrete semantics of the programming language, and use such semantics to effectively prune the search space. We also identify a condition that ensures such abstract semantics can be used to compute a precise abstraction of the set of values that a program derivable from a given hole in a partial program can produce. These precise abstractions make abstraction-based pruning more effective. We implement our approach in a tool, M oito , which can tackle synthesis problems defined in the SemGuS framework. M oito can automate interval-based pruning without any a-priori knowledge of the problem domain, and solve synthesis problems that previously required domain-specific, abstraction-based synthesizers—e.g., synthesis of regular expressions, CSV file schema, and imperative programs from examples.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689744", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Keith J. C.", + "last_name": "Johnson", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "R.", + "last_name": "Krishnan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/JohnsonKRD24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689743", + "title": "Computing Precise Control Interface Specifications", + "abstract": "Verifying network programs is challenging because of how they divide labor: the control plane computes high level routes through the network and compiles them to device configurations, while the data plane uses these configurations to realize the desired forwarding behavior. In practice, the correctness of the data plane often assumes that the configurations generated by the control plane will satisfy complex specifications. Consequently, validation tools such as program verifiers, runtime monitors, fuzzers, and test-case generators must be aware of these control interface specifications (ci-specs) to avoid raising false alarms. In this paper, we propose the first algorithm for computing precise ci-specs for network data planes. Our specifications are designed to be efficiently monitorable —concretely, checking that a fixed configuration satisfies a ci-spec can be done in polynomial time. Our algorithm, based on modular program instrumentation, quantifier elimination, and a path-based analysis, is more expressive than prior work, and is applicable to practical network programs. We describe an implementation and show that ci-specs computed by our tool are useful for finding real bugs in real-world data plane programs.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689743", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric Hayden", + "last_name": "Campbell", + "institution": "Cornell University" + }, + { + "first_name": "Hossein", + "last_name": "Hojjat", + "institution": "Pasargad Institute for Advanced Innovative Solutions" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/CampbellHF24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689745", + "title": "Refinement Type Refutations", + "abstract": "Refinement types combine SMT decidable constraints with a compositional, syntax-directed type system to provide a convenient way to statically and automatically check properties of programs. However, when type checking fails, programmers must use cryptic error messages that, at best, point out the code location where a subtyping constraint failed to determine the root cause of the failure. In this paper, we introduce refinement type refutations , a new approach to explaining why refinement type checking fails, which mirrors the compositional way in which refinement type checking is carried out. First, we show how to systematically transform standard bidirectional type checking rules to obtain refutations. Second, we extend the approach to account for global constraint-based refinement inference via the notion of a must-instantiation : a set of concrete inhabitants of the types of subterms that suffice to demonstrate why typing fails. Third, we implement our method in H ay S tack –an extension to L iquid H askell which automatically finds type-refutations when refinement type checking fails, and helps users understand refutations via an interactive user-interface. Finally, we present an empirical evaluation of H ay S tack using the regression benchmark-set of L iquid H askell , and the benchmark set of G2, a previous method that searches for (non-compositional) counterexample traces by symbolically executing Haskell source. We show that H ay S tack can find refutations for 99.7 % of benchmarks, including those with complex typing constructs ( e.g ., abstract and bounded refinements, and reflection), and does so, an order of magnitude faster than G2.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689745", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robin", + "last_name": "Webbers", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Klaus von", + "last_name": "Gleissenthall", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/WebbersGJ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689749", + "title": "Extending the C/C++ Memory Model with Inline Assembly", + "abstract": "Programs written in C/C++ often include inline assembly : a snippet of architecture-specific assembly code used to access low-level functionalities that are impossible or expensive to simulate in the source language. Although inline assembly is widely used, its semantics has not yet been formally studied. In this paper, we overcome this deficiency by investigating the effect of inline assembly on the consistency semantics of C/C++ programs. We propose the first memory model of the C++ Programming Language with support for inline assembly for Intel’s x86 including non-temporal stores and store fences . We argue that previous provably correct compiler optimizations and correct compiler mappings should remain correct under such an extended model and we prove that this requirement is met by our proposed model.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689749", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paulo Emílio de", + "last_name": "Vilhena", + "institution": "Imperial College London" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/Vilhena0VR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689747", + "title": "On the Expressive Power of Languages for Static Variability", + "abstract": "Variability permeates software development to satisfy ever-changing requirements and mass-customization needs. A prime example is the Linux kernel, which employs the C preprocessor to specify a set of related but distinct kernel variants. To study, analyze, and verify variational software, several formal languages have been proposed. For example, the choice calculus has been successfully applied for type checking and symbolic execution of configurable software, while other formalisms have been used for variational model checking, change impact analysis, among other use cases. Yet, these languages have not been formally compared, hence, little is known about their relationships. Crucially, it is unclear to what extent one language subsumes another, how research results from one language can be applied to other languages, and which language is suitable for which purpose or domain. In this paper, we propose a formal framework to compare the expressive power of languages for static (i.e. compile-time) variability. By establishing a common semantic domain to capture a widely used intuition of explicit variability, we can formulate the basic, yet to date neglected, properties of soundness, completeness, and expressiveness for variability languages. We then prove the (un)soundness and (in)completeness of a range of existing languages, and relate their ability to express the same variational systems. We implement our framework as an extensible open source Agda library in which proofs act as correct compilers between languages or differencing algorithms. We find different levels of expressiveness as well as complete and incomplete languages w.r.t. our unified semantic domain, with the choice calculus being among the most expressive languages.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689747", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul Maximilian", + "last_name": "Bittner", + "institution": "Universität Ulm" + }, + { + "first_name": "Alexander", + "last_name": "Schultheiß", + "institution": "University of Bern" + }, + { + "first_name": "Benjamin", + "last_name": "Moosherr", + "institution": "Universität Ulm" + }, + { + "first_name": "Jeffrey M.", + "last_name": "Young", + "institution": "" + }, + { + "first_name": "Leopoldo", + "last_name": "Teixeira", + "institution": "Universidade Federal de Pernambuco" + }, + { + "first_name": "Eric", + "last_name": "Walkingshaw", + "institution": "Corvallis Environmental Center" + }, + { + "first_name": "Parisa", + "last_name": "Ataei", + "institution": "" + }, + { + "first_name": "Thomas", + "last_name": "Thüm", + "institution": "Paderborn University" + } + ], + "dblp_key": "journals/pacmpl/BittnerSMYTWAT24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689748", + "title": "Programmable MCMC with Soundly Composed Guide Programs", + "abstract": "Probabilistic programming languages (PPLs) provide language support for expressing flexible probabilistic models and solving Bayesian inference problems. PPLs with programmable inference make it possible for users to obtain improved results by customizing inference engines using guide programs that are tailored to a corresponding model program. However, errors in guide programs can compromise the statistical soundness of the inference. This article introduces a novel coroutine-based framework for verifying the correctness of user-written guide programs for a broad class of Markov chain Monte Carlo (MCMC) inference algorithms. Our approach rests on a novel type system for describing communication protocols between a model program and a sequence of guides that each update only a subset of random variables. We prove that, by translating guide types to context-free processes with finite norms, it is possible to check structural type equality between models and guides in polynomial time. This connection gives rise to an efficient type-inference algorithm for probabilistic programs with flexible constructs such as general recursion and branching. We also contribute a coverage-checking algorithm that verifies the support of sequentially composed guide programs agrees with that of the model program, which is a key soundness condition for MCMC inference with multiple guides. Evaluations on diverse benchmarks show that our type-inference and coverage-checking algorithms efficiently infer types and detect sound and unsound guides for programs that existing static analyses cannot handle.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689748", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Long", + "last_name": "Pham", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Peking University" + }, + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/Pham0S024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689751", + "title": "Gradient: Gradual Compartmentalization via Object Capabilities Tracked in Types", + "abstract": "Modern software needs fine-grained compartmentalization, i.e., intra-process isolation. A particularly important reason for it are supply-chain attacks, the need for which is aggravated by modern applications depending on hundreds or even thousands of libraries. Object capabilities are a particularly salient approach to compartmentalization, but they require the entire program to assume a lack of ambient authority. Most of existing code was written under no such assumption; effectively, existing applications need to undergo a rewrite-the-world migration to reap the advantages of ocap. We propose gradual compartmentalization , an approach which allows gradually migrating an application to object capabilities, component by component in arbitrary order, all the while continuously enjoying security guarantees. The approach relies on runtime authority enforcement and tracking the authority of objects the type system. We present Gradient, a proof-of- concept gradual compartmentalization extension to Scala which uses Enclosures and Capture Tracking as its key components. We evaluate our proposal by migrating the standard XML library of Scala to Gradient.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689751", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aleksander", + "last_name": "Boruch-Gruszecki", + "institution": "Charles University" + }, + { + "first_name": "Adrien", + "last_name": "Ghosn", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Mathias", + "last_name": "Payer", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/Boruch-Gruszecki24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689752", + "title": "Compilation of Shape Operators on Sparse Arrays", + "abstract": "We show how to build a compiler for a sparse array language that supports shape operators such as reshaping or concatenating arrays, in addition to compute operators. Existing sparse array programming systems implement generic shape operators for only some sparse data structures, reduce shape operators on other data structures to those, and do not support fusion. Our system compiles sparse array expressions to code that efficiently iterates over reshaped views of irregular sparse data structures, without needing to materialize temporary storage for intermediates. Our evaluation shows that our approach generates sparse array code competitive with popular sparse array libraries: our generated shape operators achieve geometric mean speed-ups of 1.66×–15.3× when compared to hand-written kernels in scipy.sparse and 1.67×–651× when compared to generic implementations in pydata/sparse . For operators that require data structure conversions in these libraries, our generated code achieves geometric mean speed-ups of 7.29×–13.0× when compared to scipy.sparse and 21.3×–511× when compared to pydata/sparse . Finally, our evaluation demonstrates that fusing shape and compute operators improves the performance of several expressions by geometric mean speed-ups of 1.22×–2.23×.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689752", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexander J", + "last_name": "Root", + "institution": "Stanford University" + }, + { + "first_name": "Bobby", + "last_name": "Yan", + "institution": "Stanford University" + }, + { + "first_name": "Peiming", + "last_name": "Liu", + "institution": "Google (United States)" + }, + { + "first_name": "Christophe", + "last_name": "Gyurgyik", + "institution": "Stanford University" + }, + { + "first_name": "Aart J. C.", + "last_name": "Bik", + "institution": "Google (United States)" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/RootYLGBK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689750", + "title": "Effects and Coeffects in Call-by-Push-Value", + "abstract": "Effect and coeffect tracking integrate many types of compile-time analysis, such as cost, liveness, or dataflow, directly into a language’s type system. In this paper, we investigate the addition of effect and coeffect tracking to the type system of call-by-push-value (CBPV), a computational model useful in compilation for its isolation of effects and for its ability to cleanly express both call-by-name and call-by-value computations. Our main result is effect-and-coeffect soundness , which asserts that the type system accurately bounds the effects that the program may trigger during execution and accurately tracks the demands that the program may make on its environment. This result holds for two different dynamic semantics: a generic one that can be adapted for different coeffects and one that is adapted for reasoning about resource usage. In particular, the second semantics discards the evaluation of unused values and pure computations while ensuring that effectful computations are always evaluated, even if their results are not required. Our results have been mechanized using the Coq proof assistant.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689750", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cassia", + "last_name": "Torczon", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Emmanuel Suárez", + "last_name": "Acevedo", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Shubh", + "last_name": "Agrawal", + "institution": "University of Michigan" + }, + { + "first_name": "Joey", + "last_name": "Velez‐Ginorio", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/TorczonAAVW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689753", + "title": "Tachis: Higher-Order Separation Logic with Credits for Expected Costs", + "abstract": "We present Tachis, a higher-order separation logic to reason about the expected cost of probabilistic programs. Inspired by the uses of time credits for reasoning about the running time of deterministic programs, we introduce a novel notion of probabilistic cost credit. Probabilistic cost credits are a separation logic resource that can be used to pay for the cost of operations in programs, and that can be distributed across all possible branches of sampling instructions according to their weight, thus enabling us to reason about expected cost. The representation of cost credits as separation logic resources gives Tachis a great deal of flexibility and expressivity. In particular, it permits reasoning about amortized expected cost by storing excess credits as potential into data structures to pay for future operations. Tachis further supports a range of cost models, including running time and entropy usage. We showcase the versatility of this approach by applying our techniques to prove upper bounds on the expected cost of a variety of probabilistic algorithms and data structures, including randomized quicksort, hash tables, and meldable heaps. All of our results have been mechanized using Coq, Iris, and the Coquelicot real analysis library.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689753", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philipp G.", + "last_name": "Haselwarter", + "institution": "Aarhus University" + }, + { + "first_name": "Kwing Hei", + "last_name": "Li", + "institution": "Aarhus University" + }, + { + "first_name": "Markus de", + "last_name": "Medeiros", + "institution": "New York University" + }, + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "New York University" + }, + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "Aarhus University" + }, + { + "first_name": "Joseph", + "last_name": "Tassarotti", + "institution": "New York University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/HaselwarterLMG024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689754", + "title": "Making Formulog Fast: An Argument for Unconventional Datalog Evaluation", + "abstract": "With its combination of Datalog, SMT solving, and functional programming, the language Formulog provides an appealing mix of features for implementing SMT-based static analyses (e.g., refinement type checking, symbolic execution) in a natural, declarative way. At the same time, the performance of its custom Datalog solver can be an impediment to using Formulog beyond prototyping—a common problem for Datalog variants that aspire to solve large problem instances. In this work we speed up Formulog evaluation, with some surprising results: while 2.2× speedups can be obtained by using the conventional techniques for high-performance Datalog (e.g., compilation, specialized data structures), the big wins come by abandoning the central assumption in modern performant Datalog engines, semi-naive Datalog evaluation. In the place of semi-naive evaluation, we develop eager evaluation, a concurrent Datalog evaluation algorithm that explores the logical inference space via a depth-first traversal order. In practice, eager evaluation leads to an advantageous distribution of Formulog’s SMT workload to external SMT solvers and improved SMT solving times: our eager evaluation extensions to the Formulog interpreter and Soufflé’s code generator achieve mean 5.2× and 7.6× speedups, respectively, over the optimized code generated by off-the-shelf Soufflé on SMT-heavy Formulog benchmarks. All in all, using compilation and eager evaluation (as appropriate), Formulog implementations of refinement type checking, bottom-up pointer analysis, and symbolic execution achieve speedups on 20 out of 23 benchmarks over previously published, hand-tuned analyses written in F♯, Java, and C++, providing strong evidence that Formulog can be the basis of a realistic platform for SMT-based static analysis. Moreover, our experience adds nuance to the conventional wisdom that traditional semi-naive evaluation is the one-size-fits-all best Datalog evaluation algorithm for static analysis workloads.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689754", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aaron", + "last_name": "Bembenek", + "institution": "The University of Melbourne" + }, + { + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + } + ], + "dblp_key": "journals/pacmpl/Bembenek0C24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689755", + "title": "Realistic Realizability: Specifying ABIs You Can Count On", + "abstract": "The Application Binary Interface (ABI) for a language defines the interoperability rules for its target platforms, including data layout and calling conventions, such that compliance with the rules ensures “safe” execution and perhaps certain resource usage guarantees. These rules are relied upon by compilers, libraries, and foreign- function interfaces. Unfortunately, ABIs are typically specified in prose, and while type systems for source languages have evolved, ABIs have comparatively stalled, lacking advancements in expressivity and safety. We propose a vision for richer, semantic ABIs to improve interoperability and library integration, supported by a methodology for formally specifying ABIs using realizability models. These semantic ABIs connect abstract, high-level types to unwieldy, but well-behaved, low-level code. We illustrate our approach with a case study formalizing the ABI of a functional source language in terms of a reference-counting implementation in a C-like target language. A key contribution supporting this case study is a graph-based model of separation logic that captures the ownership and accessibility of reference-counted resources using modalities inspired by hybrid logic. To highlight the flexibility of our methodology, we show how various design decisions can be interpreted into the semantic ABI. Finally, we provide the first formalization of library evolution, a distinguishing feature of Swift’s ABI.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689755", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Wagner", + "institution": "Northeastern University" + }, + { + "first_name": "Zachary", + "last_name": "Eisbach", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/WagnerE024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689756", + "title": "Hypra: A Deductive Program Verifier for Hyper Hoare Logic", + "abstract": "Hyperproperties relate multiple executions of a program and are useful to express common correctness properties (such as determinism) and security properties (such as non-interference). While there are a number of powerful program logics for the deductive verification of hyperproperties, their automation falls behind. Most existing deductive verification tools are limited to safety properties, but cannot reason about the existence of executions, for instance, to prove the violation of a safety property. Others support more flexible hyperproperties such as generalized non-interference, but have limitations in terms of the programs and proof structures they support. In this paper, we present the first deductive verification technique for arbitrary hyperproperties over multiple executions of the same program. Our technique automates the generation of verification conditions for Hyper Hoare Logic. Our key insight is that arbitrary hyperproperties and the corresponding proof rules can be encoded into a standard intermediate verification language by representing sets of states of the input program explicitly in the states of the intermediate program. Verification is then automated using an existing SMT-based verifier for the intermediate language. We implement our technique in a tool called Hypra and demonstrate that it can reliably verify complex hyperproperties.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689756", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thibault", + "last_name": "Dardinier", + "institution": "ETH Zurich" + }, + { + "first_name": "Anqi", + "last_name": "Li", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/DardinierL024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689763", + "title": "Law and Order for Typestate with Borrowing", + "abstract": "Typestate systems are notoriously complex as they require sophisticated machinery for tracking aliasing. We propose a new, transition-oriented foundation for typestate in the setting of impure functional programming. Our approach relies on ordered types for simple alias tracking and its formalization draws on work on bunched implications. Yet, we support a flexible notion of borrowing in the presence of typestate. Our core calculus comes with a notion of resource types indexed by an ordered partial monoid that models abstract state transitions. We prove syntactic type soundness with respect to a resource-instrumented semantics. We give an algorithmic version of our type system and prove its soundness. Algorithmic typing facilitates a simple surface language that does not expose tedious details of ordered types. We implemented a typechecker for the surface language along with an interpreter for the core language.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689763", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hannes", + "last_name": "Saffrich", + "institution": "University of Freiburg" + }, + { + "first_name": "Yuki", + "last_name": "Nishida", + "institution": "Kyoto University" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "journals/pacmpl/Saffrich0024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689759", + "title": "MEA2: A Lightweight Field-Sensitive Escape Analysis with Points-to Calculation for Golang", + "abstract": "Escape analysis plays a crucial role in garbage-collected languages as it enables the allocation of non-escaping variables on the stack by identifying the dynamic lifetimes of objects and pointers. This helps in reducing heap allocations and alleviating garbage collection pressure. However, Go, as a garbage-collected language, employs a fast yet conservative escape analysis, which is field-insensitive and omits point-to-set calculation to expedite compilation. This results in more variables being allocated on the heap. Empirical statistics reveal that field access and indirect memory access are prevalent in real-world Go programs, suggesting potential opportunities for escape analysis to enhance program performance. In this paper, we propose MEA 2 , an escape analysis framework atop GoLLVM (an LLVM-based Go compiler), which combines field sensitivity and points-to analysis. Moreover, a novel generic function summary representation is designed to facilitate fast inter-procedural analysis. We evaluated it by using MEA 2 to perform stack allocation in 12 wildly-use open-source projects. The results show that, compared to Go’s escape analysis, MEA 2 can reduce heap allocation sites by 7.9 % on average (up to 25.7 % ) while reducing the dynamic memory allocation size by 11.6 % on average (up to 35.5 % ). All this is achieved while keeping the time overhead of escape analysis within 1 % of the compilation process.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689759", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Boyao", + "last_name": "Ding", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Qingwei", + "last_name": "Li", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Yu", + "last_name": "Zhang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Fugen", + "last_name": "Tang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Jing", + "last_name": "Chen", + "institution": "University of Science and Technology of China" + } + ], + "dblp_key": "journals/pacmpl/DingL0TC24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689766", + "title": "Minotaur: A SIMD-Oriented Synthesizing Superoptimizer", + "abstract": "A superoptimizing compiler—one that performs a meaningful search of the program space as part of the optimization process—can find optimization opportunities that are missed by even the best existing optimizing compilers. We created Minotaur: a superoptimizer for LLVM that uses program synthesis to improve its code generation, focusing on integer and floating-point SIMD code. On an Intel Cascade Lake processor, Minotaur achieves an average speedup of 7.3% on the GNU Multiple Precision library (GMP)’s benchmark suite, with a maximum speedup of 13%. On SPEC CPU 2017, our superoptimizer produces an average speedup of 1.5%, with a maximum speedup of 4.5% for 638.imagick. Every optimization produced by Minotaur has been formally verified, and several optimizations that it has discovered have been implemented in LLVM as a result of our work.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689766", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Z.", + "last_name": "Liu", + "institution": "University of Utah" + }, + { + "first_name": "Stefan", + "last_name": "Mada", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/0003MR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689760", + "title": "Weighted Context-Free-Language Ordered Binary Decision Diagrams", + "abstract": "This paper presents a new data structure, called Weighted Context-Free-Language Ordered BDDs (WCFLOBDDs), which are a hierarchically structured decision diagram, akin to Weighted BDDs (WBDDs) enhanced with a procedure-call mechanism. For some functions, WCFLOBDDs are exponentially more succinct than WBDDs. They are potentially beneficial for representing functions of type B n → D , when a function’s image V ⊆ D has many different values. We apply WCFLOBDDs in quantum-circuit simulation, and find that they perform better than WBDDs on certain benchmarks. With a 15-minute timeout, the number of qubits that can be handled by WCFLOBDDs is 1 − 64 × that of WBDDs (and 1 − 128 × that of CFLOBDDs, which are an unweighted version of WCFLOBDDs). These results support the conclusion that for this application—from the standpoint of problem size, measured as the number of qubits—WCFLOBDDs provide the best of both worlds: performance roughly matches whichever of WBDDs and CFLOBDDs is better. (From the standpoint of running time, the results are more nuanced.)", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689760", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Meghana Aparna", + "last_name": "Sistla", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Swarat", + "last_name": "Chaudhuri", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/SistlaCR24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689757", + "title": "PolyJuice: Detecting Mis-compilation Bugs in Tensor Compilers with Equality Saturation Based Rewriting", + "abstract": "Tensor compilers are essential for deploying deep learning applications across various hardware platforms. While powerful, they are inherently complex and present significant challenges in ensuring correctness. This paper introduces PolyJuice, an automatic detection tool for identifying mis-compilation bugs in tensor compilers. Its basic idea is to construct semantically-equivalent computation graphs to validate the correctness of tensor compilers. The main challenge is to construct equivalent graphs capable of efficiently exploring the diverse optimization logic during compilation. We approach it from two dimensions. First, we propose arithmetic and structural equivalent rewrite rules to modify the dataflow of a tensor program. Second, we design an efficient equality saturation based rewriting framework to identify the most simplified and the most complex equivalent computation graphs for an input graph. After that, the outcome computation graphs have different dataflow and will likely experience different optimization processes during compilation. We applied it to five well-tested industrial tensor compilers, namely PyTorch Inductor, OnnxRuntime, TVM, TensorRT, and XLA, as well as two well-maintained academic tensor compilers, EinNet and Hidet. In total, PolyJuice detected 84 non-crash mis-compilation bugs, out of which 49 were confirmed with 20 fixed.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689757", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chijin", + "last_name": "Zhou", + "institution": "Tsinghua University" + }, + { + "first_name": "Bingzhou", + "last_name": "Qian", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Gwihwan", + "last_name": "Go", + "institution": "Tsinghua University" + }, + { + "first_name": "Quan", + "last_name": "Zhang", + "institution": "Tsinghua University" + }, + { + "first_name": "Shanshan", + "last_name": "Li", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Yu", + "last_name": "Jiang", + "institution": "Tsinghua University" + } + ], + "dblp_key": "journals/pacmpl/ZhouQGZ0024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689767", + "title": "A Typed Multi-level Datalog IR and Its Compiler Framework", + "abstract": "The resurgence of Datalog in the last two decades has led to a multitude of new Datalog systems. These systems explore novel ideas for improving Datalog’s programmability and performance, making important contributions to the field. Unfortunately, the individual systems progress at a much slower pace than the overall field, because improvements in one system are rarely ported to other systems. The reason for this rift is that each system provides its own Datalog dialect with specific notation, language features, and invariants, enabling specific optimization and execution strategies. This paper presents the first compiler framework for Datalog that can be used to support any Datalog frontend language and to target any Datalog backend. The centerpiece of our framework is a novel typed multi-level Datalog IR that supports IR extensions and guarantees executability. Existing Datalog systems can provide a compiler frontend that translates their Datalog dialect to the extended IR. The IR is then progressively lowered toward core Datalog, allowing optimizations at each level. At last, compiler backends can target different Datalog solvers. We have implemented the compiler framework and integrated 4 Datalog frontends and 3 Datalog backends, using 16 IR extensions. We also formalize the IR’s flexible type system, which is bidirectional, flow-sensitive, bipolar, and uses three-valued typing contexts. The type system simultaneously validates type compatibility and precisely tracks bindings of logic variables while permitting IR extensions.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689767", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "D. A.", + "last_name": "Klopp", + "institution": "" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "" + }, + { + "first_name": "André", + "last_name": "Pacak", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/KloppEP24a", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689764", + "title": "FPCC: Detecting Floating-Point Errors via Chain Conditions", + "abstract": "Floating-point arithmetic is notorious for its rounding errors, which can propagate and accumulate, leading to unacceptable results. Detecting inputs that can trigger significant floating-point errors is crucial for enhancing the reliability of numerical programs. Existing methods for generating error-triggering inputs often rely on costly shadow executions that involve high-precision computations or suffer from false positives. This paper introduces chain conditions to capture the propagation and accumulation of floating-point errors, using them to guide the search for error-triggering inputs. We have implemented a tool named FPCC and evaluated it on 88 functions from the GNU Scientific Library, as well as 21 functions with multiple inputs from previous research. The experimental results demonstrate the effectiveness and efficiency of our approach: (1) FPCC achieves 100% accuracy in detecting significant errors for the reported rank-1 inputs, while 72.69% rank-1 inputs from the state-of-the-art tool ATOMU can trigger significant errors. Overall, 99.64% (1049/1053) of the inputs reported by FPCC can trigger significant errors, whereas only 19.45% (141/723) of the inputs reported by ATOMU can trigger significant errors; (2) FPCC exhibits a 2.17x speedup over ATOMU in detecting significant errors; (3) FPCC also excels in supporting functions with multiple inputs, outperforming the state-of-the-art technique. To facilitate further research in the community, we have made FPCC available on GitHub at https://github.com/DataReportRe/FPCC .", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689764", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xin", + "last_name": "Yi", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Hengbiao", + "last_name": "Yu", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Liqian", + "last_name": "Chen", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Xiaoguang", + "last_name": "Mao", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Ji", + "last_name": "Wang", + "institution": "National University of Defense Technology" + } + ], + "dblp_key": "journals/pacmpl/YiYCM024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689765", + "title": "Scaling Abstraction Refinement for Program Analyses in Datalog using Graph Neural Networks", + "abstract": "Counterexample-guided abstraction refinement (CEGAR) is a popular approach for automatically selecting abstractions with high precision and low time costs. Existing works cast abstraction refinements as constraintsolving problems. Due to the complexity of these problems, they cannot be scaled to large programs or complex analyses. We propose a novel approach that applies graph neural networks to improve the scalability of CEGAR for Datalog-based program analyses. By constructing graphs directly from the Datalog solver’s calculations, our method then uses a neural network to score abstraction parameters based on the information in these graphs. Then we reform the constraint problems such that the constraint solver ignores parameters with low scores. This in turn reduces the solution space and the size of the constraint problems. Since our graphs are directly constructed from Datalog computation without human effort, our approach can be applied to a broad range of parametric static analyses implemented in Datalog. We evaluate our approach on a pointer analysis and a typestate analysis and our approach can answer 2.83× and 1.5× as many queries as the baseline approach on large programs for the pointer analysis and the typestate analysis, respectively.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689765", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhenyu", + "last_name": "Yan", + "institution": "Peking University" + }, + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Peng", + "last_name": "Di", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/YanZD24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689761", + "title": "Finding ∀∃ Hyperbugs using Symbolic Execution", + "abstract": "Many important hyperproperties, such as refinement and generalized non-interference, fall into the class of ∀∃ hyperproperties and require, for each execution trace of a system, the existence of another trace relating to the first one in a certain way. The alternation of quantifiers renders ∀∃ hyperproperties extremely difficult to verify, or even just to test. Indeed, contrary to trace properties, where it suffices to find a single counterexample trace, refuting a ∀∃ hyperproperty requires not only to find a trace, but also a proof that no second trace satisfies the specified relation with the first trace. As a consequence, automated testing of ∀∃ hyperproperties falls out of the scope of existing automated testing tools. In this paper, we present a fully automated approach to detect violations of ∀∃ hyperproperties in software systems. Our approach extends bug-finding techniques based on symbolic execution with support for trace quantification. We provide a prototype implementation of our approach, and demonstrate its effectiveness on a set of challenging examples.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689761", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arthur", + "last_name": "Correnson", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Tobias", + "last_name": "Nießen", + "institution": "TU Wien" + }, + { + "first_name": "Bernd", + "last_name": "Finkbeiner", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Georg", + "last_name": "Weißenbacher", + "institution": "TU Wien" + } + ], + "dblp_key": "journals/pacmpl/CorrensonNFW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689762", + "title": "Multris: Functional Verification of Multiparty Message Passing in Separation Logic", + "abstract": "We introduce Multris, a separation logic for verifying functional correctness of programs that combine multiparty message-passing communication with shared-memory concurrency. The foundation of our work is a novel concept of multiparty protocol consistency , which guarantees safe communication among a set of parties, provided each party adheres to its prescribed protocol. Our concept of protocol consistency is inspired by the bottom-up approach for multiparty session types. However, by considering it in the context of separation logic instead of a type system, we go further in terms of generality by supporting new notions of implicit transfer of knowledge and implicit transfer of resources . We develop tactics for automatically verifying protocol consistency and for reasoning about message-passing operations in Multris. We evaluate Multris on a range of examples, including the well-known two- and three-buyer protocols, as well as a new verification benchmark based on Chang and Roberts's ring leader election protocol. To ensure the reliability of our work, we prove soundness of Multris w.r.t. a low-level channel semantics using the Iris framework in Coq.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689762", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", + "institution": "Aarhus University" + }, + { + "first_name": "Jules", + "last_name": "Jacobs", + "institution": "Cornell University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "journals/pacmpl/HinrichsenJK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689769", + "title": "Jmvx: Fast Multi-threaded Multi-version Execution and Record-Replay for Managed Languages", + "abstract": "Multi-version execution (MVX) is a technique that deploys many equivalent versions of the same program — variants — as a single program, with direct application in important fields such as: security, reliability, analysis, and availability. MVX can be seen as “online Record/Replay (RR)”, as RR captures a program’s execution as a log stored on disk that can later be replayed to observe the same execution. Unfortunately, current MVX techniques target programs written in C/C++ and do not support programs written in managed languages, which are the vast majority of code written nowadays. This paper presents the design, implementation, and evaluation of Jmvx— a novel system for performing MVX and RR on programs written in managed languages. Jmvx supports programs written in Java by intercepting automatically identified non-deterministic methods, via a novel dynamic analysis technique, and ensuring that all variants execute the same methods and obtain the same data. Jmvx supports multi-threaded programs, by capturing synchronization operations in one variant, and ensuring all other variants follow the same ordering. We validated that Jmvx supports MVX and RR by applying it to a suite of benchmarks representative of programs written in Java. Internally, Jmvx uses a circular buffer located in shared memory between JVMs to enable fast communication between all variants, averaging 5% |47% performance overhead when performing MVX with multithreading support disabled|enabled, 8% |25% when recording, and 13% |73% when replaying.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689769", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David N.", + "last_name": "Schwartz", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Ankith", + "last_name": "Kowshik", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Luís", + "last_name": "Pina", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "journals/pacmpl/SchwartzKP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689768", + "title": "HardTaint: Production-Run Dynamic Taint Analysis via Selective Hardware Tracing", + "abstract": "Dynamic taint analysis (DTA), as a fundamental analysis technique, is widely used in security, privacy, and diagnosis, etc. As DTA demands to collect and analyze massive taint data online, it suffers extremely high runtime overhead. Over the past decades, numerous attempts have been made to lower the overhead of DTA. Unfortunately, the reductions they achieved are marginal, causing DTA only applicable to the debugging/testing scenarios. In this paper, we propose and implement HardTaint, a system that can realize production-run dynamic taint tracking. HardTaint adopts a hybrid and systematic design which combines static analysis, selective hardware tracing and parallel graph processing techniques. The comprehensive evaluations demonstrate that HardTaint introduces only around 8% runtime overhead which is an order of magnitude lower than the state-of-the-arts, while without sacrificing any taint detection capability.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689768", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yiyu", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Tianyi", + "last_name": "Liu", + "institution": "Nanjing University" + }, + { + "first_name": "Yueyang", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Yun Lian", + "last_name": "Qi", + "institution": "Nanjing University" + }, + { + "first_name": "Kai", + "last_name": "Ji", + "institution": "Nanjing University" + }, + { + "first_name": "Jian", + "last_name": "Tang", + "institution": "Nanjing University" + }, + { + "first_name": "Xiaoliang", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Zhiqiang", + "last_name": "Zuo", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/ZhangLWQJTWL024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689772", + "title": "A Runtime System for Interruptible Query Processing: When Incremental Computing Meets Fine-Grained Parallelism", + "abstract": "Online data services have stringent performance requirement and must tolerate workload fluctuation. This paper introduces P it S top , a new query language runtime design built on the idea of interruptible query processing : the time-consuming task of data inspection for processing each query or update may be interrupted and resumed later at the boundary of fine-grained data partitions. This counter-intuitive idea enables a novel form of fine-grained concurrency while preserving sequential consistency . We build P it S top through modifying the language runtime of Cypher, the query language of a state-of-the-art graph database, Neo4j. Our evaluation on the Google Cloud shows that P it S top can outperform unmodified Neo4j during workload fluctuation, with reduced latency and increased throughput.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689772", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Eymer", + "institution": "Binghamton University" + }, + { + "first_name": "Philip", + "last_name": "Dexter", + "institution": "Binghamton University" + }, + { + "first_name": "Joseph", + "last_name": "Raskind", + "institution": "Binghamton University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + } + ], + "dblp_key": "journals/pacmpl/EymerDRL24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689771", + "title": "HybridSA: GPU Acceleration of Multi-pattern Regex Matching using Bit Parallelism", + "abstract": "Multi-pattern matching is widely used in modern software for applications requiring high throughput such as protein search, network traffic inspection, virus or spam detection. Graphics Processor Units (GPUs) excel at executing massively parallel workloads. Regular expression (regex) matching is typically performed by simulating the execution of deterministic finite automata (DFAs) or nondeterministic finite automata (NFAs). The natural implementations of these automata simulation algorithms on GPUs are highly inefficient because they give rise to irregular memory access patterns. This paper presents HybridSA, a heterogeneous CPU-GPU parallel engine for multi-pattern matching. HybridSA uses bit parallelism to efficiently simulate NFAs on GPUs, thus reducing the number of memory accesses and increasing the throughput. Our bit-parallel algorithms extend the classical shift-and algorithm for string matching to a large class of regular expressions and reduce automata simulation to a small number of bitwise operations. We have developed a compiler to translate regular expressions into bit masks, perform optimizations, and choose the best algorithms to run on the GPU. The majority of the regular expressions are accelerated on the GPU, while the patterns that exhibit random memory accesses are executed on the CPU in parallel. We evaluate HybridSA against state-of-the-art CPU and GPU engines, as well as a hybrid combination of the two. HybridSA achieves between 4 and 60 times higher throughput than the state-of-the-art CPU engine and between 4 and 233 times better than the state-of-the-art GPU engine across a collection of real-world benchmarks.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689771", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Alexis Le", + "last_name": "Glaunec", + "institution": "Rice University" + }, + { + "first_name": "Lingkun", + "last_name": "Kong", + "institution": "Rice University" + }, + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + } + ], + "dblp_key": "journals/pacmpl/GlaunecKM24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689770", + "title": "Lexical Effect Handlers, Directly", + "abstract": "Lexically scoping effect handlers is a language-design idea that equips algebraic effects with a modular semantics: it enables local-reasoning principles without giving up on the control-flow expressiveness that makes effect handlers powerful. However, we observe that existing implementations risk incurring costs akin to the run-time search for dynamically scoped handlers. This paper presents a compilation strategy for lexical effect handlers, adhering to the lexical scoping principle and targeting a language with low-level control over stack layout. Key aspects of this approach are formalized and proven correct. We embody the ideas in a language called L exa : the L exa compiler translates high-level effect handling to low-level stack switching. We evaluate the L exa compiler on a set of benchmarks; the results suggest that it generates efficient code, reducing running-time complexity from quadratic to linear in some cases.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689770", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cong", + "last_name": "Ma", + "institution": "University of Waterloo" + }, + { + "first_name": "Zhaoyi", + "last_name": "Ge", + "institution": "University of Waterloo" + }, + { + "first_name": "Edward", + "last_name": "Lee", + "institution": "University of Waterloo" + }, + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/MaGLZ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689777", + "title": "Monotone Procedure Summarization via Vector Addition Systems and Inductive Potentials", + "abstract": "This paper presents a technique for summarizing recursive procedures operating on integer variables. The motivation of our work is to create more predictable program analyzers, and in particular to formally guarantee compositionality and monotonicity of procedure summarization. To summarize a procedure, we compute its best abstraction as a vector addition system with resets (VASR) and exactly summarize the executions of this VASR over the context-free language of syntactic paths through the procedure. We improve upon this technique by refining the language of syntactic paths using (automatically synthesized) linear potential functions that bound the number of recursive calls within valid executions of the input program. We implemented our summarization technique in an automated program verification tool; our experimental evaluation demonstrates that our technique computes more precise summaries than existing abstract interpreters and that our tool’s verification capabilities are comparable with state-of-the-art software model checkers.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689777", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nikhil", + "last_name": "Pimpalkhare", + "institution": "Princeton University" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + } + ], + "dblp_key": "journals/pacmpl/PimpalkhareK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689778", + "title": "Model Checking Distributed Protocols in Must", + "abstract": "We describe the design and implementation of Must, a framework for modeling and automatically verifying distributed systems. Must provides a concurrency API that supports multiple communication models, on top of a mainstream programming language, such as Rust. Given a program using this API, Must verifies it by means of a novel, optimal dynamic partial order reduction algorithm that maintains completeness and optimality for all communication models supported by the API. We use Must to design and verify models of distributed systems in an industrial context. We demonstrate the usability of Must’s API by modeling high-level system idioms (e.g., timeouts, leader election, versioning) as abstractions over the core API, and demonstrate Must’s scalability by verifying systems employed in production (e.g., replicated logs, distributed transaction management protocols), the verification of which lies beyond the capacity of previous model checkers.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689778", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "École Polytechnique" + }, + { + "first_name": "Dimitra", + "last_name": "Giannakopoulou", + "institution": "" + }, + { + "first_name": "Michalis", + "last_name": "Kokologiannakis", + "institution": "ETH Zurich" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/EneaGKM24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689773", + "title": "StarMalloc: Verifying a Modern, Hardened Memory Allocator", + "abstract": "We present StarMalloc, a verified, efficient, security-oriented, and concurrent memory allocator. Using the Steel separation logic framework, we show how to specify and verify a multitude of low-level patterns and delicate security mechanisms, by relying on a combination of dependent types, SMT, and modular abstractions to enable efficient verification. We produce a verified artifact, in C, that implements the entire API surface of an allocator, and as such works as a drop-in replacement for real-world projects, notably the Firefox browser. As part of StarMalloc, we develop several generic datastructures and proof libraries directly reusable in future systems verification projects. We also extend the Steel toolchain to express several low-level idioms that were previously missing. Finally, we show that StarMalloc exhibits competitive performance by evaluating it against 10 state-of-the-art memory allocators, and against a variety of real-world projects, such as Redis, the Lean compiler, and the Z3 SMT solver.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689773", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Antonin", + "last_name": "Reitz", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Aymeric", + "last_name": "Fromherz", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/ReitzFP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689776", + "title": "Drowzee: Metamorphic Testing for Fact-Conflicting Hallucination Detection in Large Language Models", + "abstract": "Large language models (LLMs) have revolutionized language processing, but face critical challenges with security, privacy, and generating hallucinations — coherent but factually inaccurate outputs. A major issue is fact-conflicting hallucination (FCH), where LLMs produce content contradicting ground truth facts. Addressing FCH is difficult due to two key challenges: 1) Automatically constructing and updating benchmark datasets is hard, as existing methods rely on manually curated static benchmarks that cannot cover the broad, evolving spectrum of FCH cases. 2) Validating the reasoning behind LLM outputs is inherently difficult, especially for complex logical relations. To tackle these challenges, we introduce a novel logic-programming-aided metamorphic testing technique for FCH detection. We develop an extensive and extensible framework that constructs a comprehensive factual knowledge base by crawling sources like Wikipedia, seamlessly integrated into D rowzee . Using logical reasoning rules, we transform and augment this knowledge into a large set of test cases with ground truth answers. We test LLMs on these cases through template-based prompts, requiring them to provide reasoned answers. To validate their reasoning, we propose two semantic-aware oracles that assess the similarity between the semantic structures of the LLM answers and ground truth. Our approach automatically generates useful test cases and identifies hallucinations across six LLMs within nine domains, with hallucination rates ranging from 24.7% to 59.8%. Key findings include LLMs struggling with temporal concepts, out-of-distribution knowledge, and lack of logical reasoning capabilities. The results show that logic-based test cases generated by D rowzee effectively trigger and detect hallucinations. To further mitigate the identified FCHs, we explored model editing techniques, which proved effective on a small scale (with edits to fewer than 1000 knowledge pieces). Our findings emphasize the need for continued community efforts to detect and mitigate model hallucinations.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689776", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ningke", + "last_name": "Li", + "institution": "Huazhong University of Science and Technology" + }, + { + "first_name": "Yuekang", + "last_name": "Li", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yi", + "last_name": "Liu", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Ling", + "last_name": "Shi", + "institution": "Nanyang Technological University" + }, + { + "first_name": "Kailong", + "last_name": "Wang", + "institution": "Huazhong University of Science and Technology" + }, + { + "first_name": "Haoyu", + "last_name": "Wang", + "institution": "Huazhong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/LiL0SW024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689775", + "title": "Concurrent Data Structures Made Easy", + "abstract": "Design of an efficient thread-safe concurrent data structure is a balancing act between its implementation complexity and performance. Lock-based concurrent data structures, which are relatively easy to derive from their sequential counterparts and to prove thread-safe, suffer from poor throughput under even light multi-threaded workload. At the same time, lock-free concurrent structures allow for high throughput, but are notoriously difficult to get right and require careful reasoning to formally establish their correctness. In this work, we explore a solution to this conundrum based on a relatively old idea of batch parallelism —an approach for designing high-throughput concurrent data structures via a simple insight: efficiently processing a batch of a priori known operations in parallel is easier than optimising performance for a stream of arbitrary asynchronous requests. Alas, batch-parallel structures have not seen wide practical adoption due to (i ) the inconvenience of having to structure multi-threaded programs to explicitly group operations and (ii) the lack of a systematic methodology to implement batch-parallel structures as simply as lock-based ones. We present OB atcher —a Multicore OCaml library that streamlines the design, implementation, and usage of batch-parallel structures. It solves the first challenge (how to use) by suggesting a new lightweight implicit batching design that is built on top of generic asynchronous programming mechanisms. The second challenge (how to implement) is addressed by identifying a family of strategies for converting common sequential structures into efficient batch-parallel ones, and by providing functors that embody those strategies. We showcase OBatcher with a diverse set of benchmarks. Our evaluation of all the implementations on large asynchronous workloads shows that (a) they consistently outperform the corresponding coarse-grained lock-based implementations and that (b) their throughput scales reasonably with the number of processors.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689775", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Callista", + "last_name": "Le", + "institution": "Yale-NUS College" + }, + { + "first_name": "Kiran", + "last_name": "Gopinathan", + "institution": "National University of Singapore" + }, + { + "first_name": "K.", + "last_name": "Lee", + "institution": "" + }, + { + "first_name": "Seth", + "last_name": "Gilbert", + "institution": "National University of Singapore" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/LeGLGS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689774", + "title": "AUTOMAP: Inferring Rank-Polymorphic Function Applications with Integer Linear Programming", + "abstract": "Dynamically typed array languages such as Python, APL, and Matlab lift scalar operations to arrays and replicate scalars to fit applications. We present a mechanism for automatically inferring map and replicate operations in a statically-typed language in a way that resembles the programming experience of a dynamically-typed language while preserving the static typing guarantees. Our type system—which supports parametric polymorphism, higher-order functions, and top-level let-generalization—makes use of integer linear programming in order to find the minimum number of operations needed to elaborate to a well-typed program. We argue that the inference system provides useful and unsurprising guarantees to the programmer. We demonstrate important theoretical properties of the mechanism and report on the implementation of the mechanism in the statically-typed array programming language Futhark.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689774", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert", + "last_name": "Schenck", + "institution": "University of Copenhagen" + }, + { + "first_name": "Nikolaj Hey", + "last_name": "Hinnerskov", + "institution": "University of Copenhagen" + }, + { + "first_name": "Troels", + "last_name": "Henriksen", + "institution": "University of Copenhagen" + }, + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Martin", + "last_name": "Elsman", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "journals/pacmpl/0001HHME24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689779", + "title": "Reward Augmentation in Reinforcement Learning for Testing Distributed Systems", + "abstract": "Bugs in popular distributed protocol implementations have been the source of many downtimes in popular internet services. We describe a randomized testing approach for distributed protocol implementations based on reinforcement learning. Since the natural reward structure is very sparse, the key to successful exploration in reinforcement learning is reward augmentation. We show two different techniques that build on one another. First, we provide a decaying exploration bonus based on the discovery of new states—the reward decays as the same state is visited multiple times. The exploration bonus captures the intuition from coverage-guided fuzzing of prioritizing new coverage points; in contrast to other schemes, we show that taking the maximum of the bonus and the Q-value leads to more effective exploration. Second, we provide waypoints to the algorithm as a sequence of predicates that capture interesting semantic scenarios. Waypoints exploit designer insight about the protocol and guide the exploration to “interesting” parts of the state space. Our reward structure ensures that new episodes can reliably get to deep interesting states even without execution caching. We have implemented our algorithm in Go. Our evaluation on three large benchmarks (RedisRaft, Etcd, and RSL) shows that our algorithm can significantly outperform baseline approaches in terms of coverage and bug finding.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689779", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Borgarelli", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Srinidhi", + "last_name": "Nagendra", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/BorgarelliEMN24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689781", + "title": "Semantics of Remote Direct Memory Access: Operational and Declarative Models of RDMA on TSO Architectures", + "abstract": "Remote direct memory access (RDMA) is a modern technology enabling networked machines to exchange information without involving the operating system of either side, and thus significantly speeding up data transfer in computer clusters. While RDMA is extensively used in practice and studied in various research papers, a formal underlying model specifying the allowed behaviours of concurrent RDMA programs running in modern multicore architectures is still missing. This paper aims to close this gap and provide semantic foundations of RDMA on x86-TSO machines. We propose three equivalent formal models, two operational models in different levels of abstraction and one declarative model, and prove that the three characterisations are equivalent. To gain confidence in the proposed semantics, the more concrete operational model has been reviewed by NVIDIA experts, a major vendor of RDMA systems, and we have empirically validated the declarative formalisation on various subtle litmus tests by extensive testing. We believe that this work is a necessary initial step for formally addressing RDMA-based systems by proposing language-level models, verifying their mapping to hardware, and developing reasoning techniques for concurrent RDMA programs.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689781", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Ambal", + "institution": "Imperial College London" + }, + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "University of Surrey" + }, + { + "first_name": "Haggai", + "last_name": "Eran", + "institution": "Israel Electric (Israel)" + }, + { + "first_name": "Vasileios", + "last_name": "Klimis", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/AmbalDEK0R24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689782", + "title": "Imperative Compositional Programming: Type Sound Distributive Intersection Subtyping with References via Bidirectional Typing", + "abstract": "Compositional programming is a programming paradigm that emphasizes modularity and is implemented in the CP programming language. The foundations for compositional programming are based on a purely functional variant of System F with intersection types, called F i + , which includes distributivity rules for subtyping. This paper shows how to extend compositional programming and CP with mutable references, enabling a modular, imperative compositional programming style. A technical obstacle solved in our work is the interaction between distributive intersection subtyping and mutable references. Davies and Pfenning [2000] studied this problem in standard formulations of intersection type systems and argued that, when combined with references, distributive subtyping rules lead to type unsoundness. To recover type soundness, they proposed dropping distributivity rules in subtyping. CP cannot adopt this solution, since it fundamentally relies on distributivity for modularity. Therefore, we revisit the problem and show that, by adopting bidirectional typing , a more lightweight and type sound restriction is possible: we can simply restrict the typing rule for references. This solution retains distributivity and an unrestricted intersection introduction rule. We present a first calculus, based on Davies and Pfenning ’s work, which illustrates the generality of our solution. Then we present an extension of F i + with references, which adopts our restriction and enables imperative compositional programming. We implement an extension of CP with references and show how to model a modular live-variable analysis in CP. Both calculi and their proofs are formalized in the Coq proof assistant.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689782", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wenjia", + "last_name": "Ye", + "institution": "University of Hong Kong" + }, + { + "first_name": "Yaozhu", + "last_name": "Sun", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/YeSO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689783", + "title": "QuAC: Quick Attribute-Centric Type Inference for Python", + "abstract": "Python’s dynamic typing facilitates rapid prototyping and underlies its popularity in many domains. However, dynamic typing reduces the power of many static checking and bug-finding tools. Python type annotations can make these tools more useful. Type inference tools aim to reduce developers’ burden of adding them. However, existing type inference tools struggle to support dynamic features, infer correct types (especially container type parameters and non-builtin types), and run in reasonable time. Inspired by Python’s duck typing, where the attributes accessed on Python expressions characterize their implicit interfaces, we propose QuAC (Quick Attribute-Centric Type Inference for Python). At its core, QuAC collects attribute sets for Python expressions and leverages information retrieval techniques to predict classes from these attribute sets. It also recursively predicts container type parameters. We evaluate QuAC’s performance on popular Python projects. Compared to state-of-the-art non-LLM baselines, QuAC predicts types with high accuracy complementary to those predicted by the baselines while not sacrificing coverage. It also demonstrates clear advantages in predicting container type parameters and non-builtin types and reduces run times. Furthermore, QuAC is nearly two orders of magnitude faster than an LLM-based method while covering nearly half of its errorless non-trivial type predictions. It is also significantly more consistent at predicting container type parameters and non-builtin types than the LLM-based method, regardless of whether the project has ground-truth type annotations.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689783", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jifeng", + "last_name": "Wu", + "institution": "University of British Columbia" + }, + { + "first_name": "Caroline", + "last_name": "Lemieux", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/WuL24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689784", + "title": "Automated Verification of Parametric Channel-Based Process Communication", + "abstract": "A challenge of writing concurrent message passing programs is ensuring the absence of partial deadlocks, which can cause severe memory leaks in long running systems. Several static analysis techniques have been proposed for automatically detecting partial deadlocks in Go programs. For a large enterprise code base, we found these tools too imprecise to reason about process communication that is parametric, i.e., where the number of channel communication operations or the channel capacities are determined at runtime. We present a novel approach to automatically verify the absence of partial deadlocks in Go program fragments with such parametric process communication. The key idea is to translate Go fragments to a core language that is sufficiently expressive to represent real-world parametric communication patterns and can be encoded into Dafny programs annotated with postconditions enforcing partial deadlock freedom. In situations where a fragment is partial deadlock free only when the concurrency parameters satisfy certain conditions, a suitable precondition can often be inferred. Experimental results on a real-world code base containing 583 program fragments that are beyond the reach of existing techniques have shown that the approach can verify the absence of partial deadlocks in 145 cases. For an additional 228 cases, a nontrivial precondition is inferred that the surrounding code must satisfy to ensure partial deadlock freedom.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689784", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Georgian-Vlad", + "last_name": "Saioc", + "institution": "Aarhus University" + }, + { + "first_name": "Julien", + "last_name": "Lange", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/SaiocLM24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689785", + "title": "Modular Synthesis of Efficient Quantum Uncomputation", + "abstract": "A key challenge of quantum programming is uncomputation: the reversible deallocation of qubits. And while there has been much recent progress on automating uncomputation, state-of-the-art methods are insufficient for handling today's expressive quantum programming languages. A core reason is that they operate on primitive quantum circuits, while quantum programs express computations beyond circuits, for instance, they can capture families of circuits defined recursively in terms of uncomputation and adjoints. In this paper, we introduce the first modular automatic approach to synthesize correct and efficient uncomputation for expressive quantum programs. Our method is based on two core technical contributions: (i) an intermediate representation (IR) that can capture expressive quantum programs and comes with support for uncomputation, and (ii) modular algorithms over that IR for synthesizing uncomputation and adjoints. We have built a complete end-to-end implementation of our method, including an implementation of the IR and the synthesis algorithms, as well as a translation from an expressive fragment of the Silq programming language to our IR and circuit generation from the IR. Our experimental evaluation demonstrates that we can handle programs beyond the capabilities of existing uncomputation approaches, while being competitive on the benchmarks they can handle. More broadly, we show that it is possible to benefit from the greater expressivity and safety offered by high-level quantum languages without sacrificing efficiency.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689785", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hristo", + "last_name": "Venev", + "institution": "Sofia University \"St. Kliment Ohridski\"" + }, + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Dimitar", + "last_name": "Dimitrov", + "institution": "Sofia University \"St. Kliment Ohridski\"" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/VenevGDV24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689786", + "title": "Type Inference Logics", + "abstract": "Type inference is essential for statically-typed languages such as OCaml and Haskell. It can be decomposed into two (possibly interleaved) phases: a generator converts programs to constraints; a solver decides whether a constraint is satisfiable. Elaboration, the task of decorating a program with explicit type annotations, can also be structured in this way. Unfortunately, most machine-checked implementations of type inference do not follow this phase-separated, constraint-based approach. Those that do are rarely executable, lack effectful abstractions, and do not include elaboration. To close the gap between common practice in real-world implementations and mechanizations inside proof assistants, we propose an approach that enables modular reasoning about monadic constraint generation in the presence of elaboration. Our approach includes a domain-specific base logic for reasoning about metavariables and a program logic that allows us to reason abstractly about the meaning of constraints. To evaluate it, we report on a machine-checked implementation of our techniques inside the Coq proof assistant. As a case study, we verify both soundness and completeness for three elaborating type inferencers for the simply typed λ -calculus with Booleans. Our results are the first demonstration that type inference algorithms can be verified in the same form as they are implemented in practice: in an imperative style, modularly decomposed into constraint generation and solving, and delivering elaborated terms to the remainder of the compiler chain.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689786", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Denis", + "last_name": "Carnier", + "institution": "KU Leuven" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Steven", + "last_name": "Keuchel", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "journals/pacmpl/CarnierPK24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689787", + "title": "Wasm-R3: Record-Reduce-Replay for Realistic and Standalone WebAssembly Benchmarks", + "abstract": "WebAssembly (Wasm for short) brings a new, powerful capability to the web as well as Edge, IoT, and embedded systems. Wasm is a portable, compact binary code format with high performance and robust sandboxing properties. As Wasm applications grow in size and importance, the complex performance characteristics of diverse Wasm engines demand robust, representative benchmarks for proper tuning. Stopgap benchmark suites, such as PolyBenchC and libsodium, continue to be used in the literature, though they are known to be unrepresentative. Porting of more complex suites remains difficult because Wasm lacks many system APIs and extracting real-world Wasm benchmarks from the web is difficult due to complex host interactions. To address this challenge, we introduce Wasm-R3 , the first record and replay technique for Wasm. Wasm-R3 transparently injects instrumentation into Wasm modules to record an execution trace from inside the module, then reduces the execution trace via several optimizations, and finally produces a replay module that is executable standalone without any host environment—on any engine. The benchmarks created by our approach are (i) realistic, because the approach records real-world web applications, (ii) faithful to the original execution, because the replay benchmark includes the unmodified original code, only adding emulation of host interactions, and (iii) standalone, because the replay benchmarks run on any engine. Applying Wasm-R3 to web-based Wasm applications in the wild demonstrates the correctness of our approach as well as the effectiveness of our optimizations, which reduce the recorded traces by 99.53% and the size of the replay benchmark by 9.98%. We release the resulting benchmark suite of 27 applications, called Wasm-R3-Bench , to the community, to inspire a new generation of realistic and standalone Wasm benchmarks.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689787", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Doehyun", + "last_name": "Baek", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jakob", + "last_name": "Getz", + "institution": "University of Stuttgart" + }, + { + "first_name": "Yusung", + "last_name": "Sim", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Daniel", + "last_name": "Lehmann", + "institution": "" + }, + { + "first_name": "Ben L.", + "last_name": "Titzer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "University of Stuttgart" + } + ], + "dblp_key": "journals/pacmpl/BaekGS0TRP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689789", + "title": "Control-Flow Deobfuscation using Trace-Informed Compositional Program Synthesis", + "abstract": "Code deobfuscation, which attempts to simplify code that has been intentionally obfuscated to prevent understanding, is a critical technique for downstream security analysis tasks like malware detection. While there has been significant prior work on code deobfuscation, most techniques either do not handle control flow obfuscations that modify control flow or they target specific classes of control flow obfuscations, making them unsuitable for handling new types of obfuscations or combinations of existing ones. In this paper, we study a new deobfuscation technique that is based on program synthesis and that can handle a broad class of control flow obfuscations. Given an obfuscated program P , our approach aims to synthesize a smallest program that is a control-flow reduction of P and that is semantically equivalent. Since our method does not assume knowledge about the types of obfuscations that have been applied to the original program, the underlying synthesis problem ends up being very challenging. To address this challenge, we propose a novel trace-informed compositional synthesis algorithm that leverages hints present in dynamic traces of the obfuscated program to decompose the synthesis problem into a set of simpler subproblems. In particular, we show how dynamic traces can be useful for inferring a suitable control-flow skeleton of the deobfuscated program and performing independent synthesis of each basic block. We have implemented this approach in a tool called Chisel and evaluate it on 546 benchmarks that have been obfuscated using combinations of six different obfuscation techniques. Our evaluation shows that our approach is effective and that it produces code that is almost identical (modulo variable renaming) to the original (non-obfuscated) program in 86% of cases. Our evaluation also shows that Chisel significantly outperforms existing techniques.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689789", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Mariano", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ziteng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Shankara", + "last_name": "Pailoor", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Christian", + "last_name": "Collberg", + "institution": "University of Arizona" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/MarianoWPCD24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689788", + "title": "Semantic-Type-Guided Bug Finding", + "abstract": "In recent years, there has been an increased interest in tools that establish incorrectness rather than correctness of program properties. In this work we build on this approach by developing a novel methodology to prove incorrectness of semantic typing properties of functional programs, extending the incorrectness approach to the model theory of functional program typing. We define a semantic type refuter which refutes semantic typings for a simple functional language. We prove our refuter is co-recursively enumerable, and that it is sound and complete with respect to a semantic typing notion. An initial implementation is described which uses symbolic evaluation to efficiently find type errors over a functional language with a rich type system.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689788", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kelvin", + "last_name": "Qian", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Brandon", + "last_name": "Stride", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Shiwei", + "last_name": "Weng", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Ke", + "last_name": "Wu", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "journals/pacmpl/Qian0SWW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689791", + "title": "Mark-Scavenge: Waiting for Trash to Take Itself Out", + "abstract": "Moving garbage collectors (GCs) typically free memory by evacuating live objects in order to reclaim contiguous memory regions. Evacuation is typically done either during tracing (scavenging), or after tracing when identification of live objects is complete (mark–evacuate). Scavenging typically requires more memory (memory for all objects to be moved), but performs less work in sparse memory areas (single pass). This makes it attractive for collecting young objects. Mark–evacuate typically requires less memory and performs less work in memory areas with dense object clusters, by focusing relocation around sparse regions, making it attractive for collecting old objects. Mark–evacuate also completes identification of live objects faster, making it attractive for concurrent GCs that can reclaim memory immediately after identification of live objects finishes (as opposed to when evacuation finishes), at the expense of more work compared to scavenging, for young objects. We propose an alternative approach for concurrent GCs to combine the benefits of scavenging with the benefits of mark–evacuate, for young objects. The approach is based on the observation that by the time young objects are relocated by a concurrent GC, they are likely to already be unreachable. By performing relocation lazily, most of the relocations in the defragmentation phase of mark–evacuate can typically be eliminated. Similar to scavenging, objects are relocated during tracing with the proposed approach. However, instead of relocating all objects that are live in the current GC cycle, it lazily relocates profitable sparse object clusters that survived from the previous GC cycle. This turns the memory headroom that concurrent GCs typically “waste” in order to safely avoid running out of memory before GC finishes, into an asset used to eliminate much of the relocation work, which constitutes a significant portion of the GC work. We call this technique mark–scavenge and implement it on-top of ZGC in OpenJDK in a collector we call MS-ZGC. We perform a performance evaluation that compares MS-ZGC against ZGC. The most striking result is (up to) 91% reduction in relocation of dead objects (depending on machine-dependent factors).", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689791", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jonas", + "last_name": "Norlinder", + "institution": "Uppsala University" + }, + { + "first_name": "Erik", + "last_name": "Österlund", + "institution": "" + }, + { + "first_name": "David", + "last_name": "Black-Schaffer", + "institution": "Uppsala University" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "journals/pacmpl/NorlinderOBW24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689790", + "title": "Unifying Static and Dynamic Intermediate Languages for Accelerator Generators", + "abstract": "Compilers for accelerator design languages (ADLs) translate high-level languages into application-specific hardware. ADL compilers rely on a hardware control interface to compose hardware units. There are two choices: static control, which relies on cycle-level timing; or dynamic control, which uses explicit signalling to avoid depending on timing details. Static control is efficient but brittle; dynamic control incurs hardware costs to support compositional reasoning. Piezo is an ADL compiler that unifies static and dynamic control in a single intermediate language (IL). Its key insight is that the IL’s static fragment is a refinement of its dynamic fragment: static code admits a subset of the run-time behaviors of the dynamic equivalent. Piezo can optimize code by combining facts from static and dynamic submodules, and it opportunistically converts code from dynamic to static control styles. We implement Piezo as an extension to an existing dynamic ADL compiler, Calyx. We use Piezo to implement a frontend for an existing ADL, a systolic array generator, and a packet-scheduling hardware generator to demonstrate its optimizations and the static–dynamic interactions it enables.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689790", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Caleb", + "last_name": "Kim", + "institution": "Cornell University" + }, + { + "first_name": "Pai", + "last_name": "Li", + "institution": "Cornell University" + }, + { + "first_name": "Anshuman", + "last_name": "Mohan", + "institution": "Cornell University" + }, + { + "first_name": "Andrew", + "last_name": "Butt", + "institution": "Cornell University" + }, + { + "first_name": "Adrian", + "last_name": "Sampson", + "institution": "Cornell University" + }, + { + "first_name": "Rachit", + "last_name": "Nigam", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/KimLMBSN24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689792", + "title": "Compositionality and Observational Refinement for Linearizability with Crashes", + "abstract": "Crash-safety is an important property of real systems, as the main functionality of some systems is resilience to crashes. Toward a compositional verification approach for crash-safety under full-system crashes, one observes that crashes propagate instantaneously to all components across all levels of abstraction, even to unspecified components, hindering compositionality. Furthermore, in the presence of concurrency, a correctness criterion that addresses both crashes and concurrency proves necessary. For this, several adaptations of linearizability have been suggested, each featuring different trade-offs between complexity and expressiveness. The recently proposed compositional linearizability framework shows that to achieve compositionality with linearizability, both a locality and observational refinement property are necessary. Despite that, no linearizability criterion with crashes has been proven to support an observational refinement property. In this paper, we define a compositional model of concurrent computation with full-system crashes. We use this model to develop a compositional theory of linearizability with crashes, which reveals a criterion, crash-aware linearizability , as its inherent notion of linearizability and supports both locality and observational refinement. We then show that strict linearizability and durable linearizability factor through crash-aware linearizability as two different ways of translating between concurrent computation with and without crashes, enabling simple proofs of locality and observational refinement for a generalization of these two criteria. Then, we show how the theory can be connected with a program logic for durable and crash-aware linearizability, which gives the first program logic that verifies a form of linearizability with crashes. We showcase the advantages of compositionality by verifying a library facilitating programming persistent data structures and a fragment of a transactional interface for a file system.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689792", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arthur Oliveira", + "last_name": "Vale", + "institution": "Yale University" + }, + { + "first_name": "Zhongye", + "last_name": "Wang", + "institution": "Yale University" + }, + { + "first_name": "Yixuan", + "last_name": "Chen", + "institution": "Yale University" + }, + { + "first_name": "Peixin", + "last_name": "You", + "institution": "Yale University" + }, + { + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/ValeW0YS24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689793", + "title": "Making Sense of Multi-threaded Application Performance at Scale with NonSequitur", + "abstract": "Modern multi-threaded systems are highly complex. This makes their behavior difficult to understand. Developers frequently capture behavior in the form of program traces and then manually inspect these traces. Existing tools, however, fail to scale to traces larger than a million events. In this paper we present an approach to compress multi-threaded traces in order to allow developers to visually explore these traces at scale. Our approach is able to compress traces that contain millions of events down to a few hundred events. We use this approach to design and implement a tool called NonSequitur. We present three case studies which demonstrate how we used NonSequitur to analyze real-world performance issues with Meta’s storage engine RocksDB and MongoDB’s storage engine WiredTiger, two complex database backends. We also evaluate NonSequitur with 42 participants on traces from RocksDB and WiredTiger. We demonstrate that, in some cases, participants on average scored 11 times higher when performing performance analysis tasks on large execution traces. Additionally, for some performance analysis tasks, the participants spent on average three times longer with other tools than with NonSequitur.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689793", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Augustine", + "last_name": "Wong", + "institution": "University of British Columbia" + }, + { + "first_name": "Paul", + "last_name": "Bucci", + "institution": "University of British Columbia" + }, + { + "first_name": "Ivan", + "last_name": "Beschastnikh", + "institution": "University of British Columbia" + }, + { + "first_name": "Alexandra", + "last_name": "Fedorova", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/WongBBF24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689794", + "title": "Dependency-Aware Code Naturalness", + "abstract": "Code naturalness, which captures repetitiveness and predictability in programming languages, has proven valuable for various code-related tasks in software engineering. However, precisely measuring code naturalness remains a fundamental challenge. Existing methods measure code naturalness over individual lines of code while ignoring the deep semantic relations among different lines, e.g., program dependency, which may negatively affect the precision of the measure. Despite the intuitive appeal of extending the code naturalness measure to the code dependency domain (as there are some work that have initiated the utilization of code dependency for diverse code-related tasks), this assumption remains unexplored and warrants direct investigation. In this study, we aim to perform the first empirical study to investigate whether incorporating code dependency, instead of analyzing individual lines, can enhance the precision of measuring code naturalness. To achieve that, we first propose a new method named DAN for measuring code naturalness by incorporating the rich dependency information in the code. Specifically, DAN extracts multiple sequences of code lines by traversing the program dependency graph, where different code lines are connected by dependencies in each sequence, and then the code naturalness will be measured by taking each sequence as a whole. In this way, the dependency information can be well captured. Finally, we have conducted an extensive study to evaluate the influence of code dependency for measuring code naturalness with DAN, and compared it with the state-of-the-art methods under three emerging application scenarios of code naturalness. The results demonstrate that DAN can not only better distinguish natural and unnatural code, but also substantially boost two important downstream applications of code naturalness, i.e., distinguishing buggy and non-buggy code lines and data cleansing for training better code models, reflecting the significance of code dependency in measuring code naturalness.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689794", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chen", + "last_name": "Yang", + "institution": "Tianjin University" + }, + { + "first_name": "Junjie", + "last_name": "Chen", + "institution": "Tianjin University" + }, + { + "first_name": "Jiajun", + "last_name": "Jiang", + "institution": "Tianjin University" + }, + { + "first_name": "Yuliang", + "last_name": "Huang", + "institution": "Tianjin University" + } + ], + "dblp_key": "journals/pacmpl/Yang0JH24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689795", + "title": "Validating SMT Solvers for Correctness and Performance via Grammar-Based Enumeration", + "abstract": "We introduce ET, a grammar-based enumerator for validating SMT solver correctness and performance. By compiling grammars of the SMT theories to algebraic datatypes, ET leverages the functional enumerator FEAT. ET is highly effective at bug finding and has many complimentary benefits. Despite the extensive and continuous testing of the state-of-the-art SMT solvers Z3 and cvc5, ET found 102 bugs, out of which 84 were confirmed and 40 were fixed. Moreover, ET can be used to understand the evolution of solvers. We derive eight grammars realizing all major SMT theories including the booleans, integers, reals, realints, bit-vectors, arrays, floating points, and strings. Using ET, we test all consecutive releases of the SMT solvers Z3 and CVC4/cvc5 from the last six years (61 versions) on 8 million formulas, and 488 million solver calls. Our results suggest improved correctness in recent versions of both solvers but decreased performance in newer releases of Z3 on small timeouts (since z3-4.8.11) and regressions in early cvc5 releases on larger timeouts. Due to its systematic testing and efficiency, we further advocate ET’s use for continuous integration.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689795", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dominik", + "last_name": "Winterer", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/Winterer024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689797", + "title": "Sound and Partially-Complete Static Analysis of Data-Races in GPU Programs", + "abstract": "GPUs are progressively being integrated into modern society, playing a pivotal role in Artificial Intelligence and High-Performance Computing. Programmers need a deep understanding of the GPU programming model to avoid subtle data-races in their codes. Static verification that is sound and incomplete can guarantee data-race freedom, but the alarms it raises may be spurious and need to be validated. In this paper, we establish a True Positive Theorem for a static data-race detector for GPU programs, i.e., a result that identifies a class of programs for which our technique only raises true alarms. Our work builds on the formalism of memory access protocols , that models the concurrency operations of CUDA programs. The crux of our approach is an approximation analysis that can correctly identify true alarms, and pinpoint the conditions that make an alarm imprecise. Our approximation analysis detects when the reported locations are reachable (control independence, or CI), and when the reported locations are precise (data independence, or DI), as well identify inexact values in an alarm. In addition to a True Positive result for programs that are CI and DI, we establish the root causes of spurious alarms depending on whether CI or DI are present. We apply our theory to introduce FaialAA, the first sound and partially complete data-race detector. We evaluate FaialAA in three experiments. First, in a comparative study with the state-of-the-art tools, we show that FaialAA confirms more DRF programs than others while emitting 1.9 × fewer potential alarms. Importantly, the approximation analysis of FaialAA detects 10 undocumented data-races. Second, in an experiment studying 6 commits of data-race fixes in open source projects OpenMM and Nvidia’s MegaTron, FaialAA confirmed the buggy and fixed versions of 5 commits, while others were only able to confirm 2. Third, we show that 59.5 % of 2,770 programs are CI and DI, quantifying when the approximation analysis of FaialAA is complete. This paper is accompanied by the mechanized proofs of the theoretical results presented therein and a tool (FaialAA) implementing of our theory.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689797", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dennis", + "last_name": "Liew", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Tiago", + "last_name": "Cogumbreiro", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Julien", + "last_name": "Lange", + "institution": "Royal Holloway University of London" + } + ], + "dblp_key": "journals/pacmpl/LiewCL24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689796", + "title": "Practical Verification of Smart Contracts using Memory Splitting", + "abstract": "SMT-based verification of low-level code requires modeling and reasoning about memory operations. Prior work has shown that optimizing memory representations is beneficial for scaling verification—pointer analysis, for example can be used to split memory into disjoint regions leading to faster SMT solving. However, these techniques are mostly designed for C and C++ programs with explicit operations for memory allocation which are not present in all languages. For instance, on the Ethereum virtual machine, memory is simply a monolithic array of bytes which can be freely accessed by Ethereum bytecode, and there is no allocation primitive. In this paper, we present a memory splitting transformation guided by a conservative memory analysis for Ethereum bytecode generated by the Solidity compiler. The analysis consists of two phases: recovering memory allocation and memory regions, followed by a pointer analysis. The goal of the analysis is to enable memory splitting which in turn speeds up verification. We have implemented both the analysis and the memory splitting transformation as part of a verification tool, CertoraProver, and show that the transformation speeds up SMT solving by up to 120× and additionally mitigates 16 timeouts when used on 229 real-world smart contract verification tasks.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689796", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shelly", + "last_name": "Grossman", + "institution": "Tel Aviv University" + }, + { + "first_name": "John", + "last_name": "Toman", + "institution": "Seattle University" + }, + { + "first_name": "Alexander", + "last_name": "Bakst", + "institution": "" + }, + { + "first_name": "Sameer", + "last_name": "Arora", + "institution": "Seattle University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "" + }, + { + "first_name": "Chandrakana", + "last_name": "Nandi", + "institution": "Seattle University" + } + ], + "dblp_key": "journals/pacmpl/GrossmanTBASN24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689798", + "title": "Effect Handlers for C via Coroutines", + "abstract": "Effect handlers provide a structured means for implementing user-defined, composable, and customisable computational effects, ranging from exceptions to generators to lightweight threads. We introduce libseff , a novel effect handlers library for C, based on coroutines. Whereas prior effect handler libraries for C are intended primarily as compilation targets, libseff is intended to be used directly from C programs. As such, the design of libseff parts ways from traditional effect handler implementations, both by using mutable coroutines as the main representation of pending computations, and by avoiding closures as handlers by way of reified effects. We show that the performance of libseff is competitive across a range of platforms and benchmarks.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689798", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mario", + "last_name": "Alvarez-Picallo", + "institution": "Huawei Technologies (United Kingdom)" + }, + { + "first_name": "Teodoro", + "last_name": "Freund", + "institution": "Huawei Technologies (United Kingdom)" + }, + { + "first_name": "Dan R.", + "last_name": "Ghica", + "institution": "Huawei Technologies (United Kingdom)" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/Alvarez-Picallo24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689800", + "title": "A Case for First-Class Environments", + "abstract": "Formalizations of programming languages typically adopt the substitution model from the lambda calculus. However, substitution creates notorious complications for reasoning and implementation. Furthermore, it is disconnected from practical implementations, which normally adopt environments and closures. In this paper we advocate for formalizing programming languages using a novel style of small-step environment-based semantics , which avoids substitution and is closer to implementations. We present a call-by-value statically typed calculus, called λ E , using our small-step environment semantics. With our alternative environment semantics programming language constructs for first-class environments arise naturally, without creating significant additional complexity. Therefore, λ E also adopts first-class environments, adding expressive power that is not available in conventional lambda calculi. λ E is a conservative extension of the call-by-value Simply Typed Lambda Calculus (STLC), and employs de Bruijn indices for its formalization, which fit naturally with the environment-based semantics. Reasoning about λ E is simple, and in many cases simpler than reasoning about the traditional STLC. We show an abstract machine that implements the semantics of λ E , and has an easy correctness proof. We also extend λ E with references. We show that λ E can model a simple form of first-class modules, and suggest using first-class environments as an alternative to objects for modelling capabilities. All technical results are formalized in the Coq proof assistant. In summary, our work shows that the small-step environment semantics that we adopt has three main and orthogonal benefits: 1) it simplifies the notorious binding problem in formalizations and proof assistants; 2) it is closer to implementations; and 3) additional expressive power is obtained from first-class environments almost for free.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689800", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jinhao", + "last_name": "Tan", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/TanO24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689801", + "title": "Fast and Optimal Extraction for Sparse Equality Graphs", + "abstract": "Equality graphs (e-graphs) are used to compactly represent equivalence classes of terms in symbolic reasoning systems. Beyond their original roots in automated theorem proving, e-graphs have been used in a variety of applications. They have become particularly important as the key ingredient in the popular technique of equality saturation , which has notable applications in compiler optimization, program synthesis, program verification, and symbolic execution, among others. In a typical equality saturation workflow, an e-graph is used to store a large number of equalities that are generated by local rewrites during a saturation phase, after which an optimal term is extracted from the e-graph as the output of the technique. However, despite its crucial role in equality saturation, e-graph extraction has received relatively little attention in the literature, which we seek to start addressing in this paper. Extraction is a challenging problem and is notably known to be NP-hard in general, so current equality saturation tools rely either on slow optimal extraction algorithms based on integer linear programming (ILP) or on heuristics that may not always produce the optimal result. In fact, in this paper, we show that e-graph extraction is hard to approximate within any constant ratio. Thus, any such heuristic will produce wildly suboptimal results in the worst case. Fortunately, we show that the problem becomes tractable when the e-graph is sparse, which is the case in many practical applications. We present a novel parameterized algorithm for extracting optimal terms from e-graphs with low treewidth, a measure of how “tree-like” a graph is, and prove its correctness. We also present an efficient Rust implementation of our algorithm and evaluate it against ILP on a number of benchmarks extracted from the Cranelift benchmark suite, a real-world compiler optimization library based on equality saturation. Our algorithm optimally extracts e-graphs with treewidths of up to 10 in a fraction of the time taken by ILP. These results suggest that our algorithm can be a valuable tool for equality saturation users who need to extract optimal terms from sparse e-graphs.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689801", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Chun Kit", + "last_name": "Lam", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/GoharshadyLP24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689799", + "title": "When Your Infrastructure Is a Buggy Program: Understanding Faults in Infrastructure as Code Ecosystems", + "abstract": "Modern applications have become increasingly complex and their manual installation and configuration is no longer practical. Instead, IT organizations heavily rely on Infrastructure as Code (IaC) technologies, to automate the provisioning, configuration, and maintenance of computing infrastructures and systems. IaC systems typically offer declarative, domain-specific languages (DSLs) that allow system administrators and developers to write high-level programs that specify the desired state of their infrastructure in a reliable, predictable, and documented fashion. Just like traditional programs, IaC software is not immune to faults, with issues ranging from deployment failures to critical misconfigurations that often impact production systems used by millions of end users. Surprisingly, despite its crucial role in global infrastructure management, the tooling and techniques for ensuring IaC reliability still have room for improvement. In this work, we conduct a comprehensive analysis of 360 bugs identified in IaC software within prominent IaC ecosystems including Ansible, Puppet, and Chef. Our work is the first in-depth exploration of bug characteristics in these widely-used IaC environments. Through our analysis we aim to understand: (1) how these bugs manifest, (2) their underlying root causes, (3) their reproduction requirements in terms of system state (e.g., operating system versions) or input characteristics, and (4) how these bugs are fixed. Based on our findings, we evaluate the state-of-the-art techniques for IaC reliability, identify their limitations, and provide a set of recommendations for future research. We believe that our study helps researchers to (1) better understand the complexity and peculiarities of IaC software, and (2) develop advanced tooling for more reliable and robust system configurations.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689799", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Georgios-Petros", + "last_name": "Drosos", + "institution": "ETH Zurich" + }, + { + "first_name": "Thodoris", + "last_name": "Sotiropoulos", + "institution": "ETH Zurich" + }, + { + "first_name": "Georgios", + "last_name": "Alexopoulos", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Dimitris", + "last_name": "Mitropoulos", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/DrososSAM024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689802", + "title": "Automated Robustness Verification of Concurrent Data Structure Libraries against Relaxed Memory Models", + "abstract": "Clients reason about the behavior of concurrent data structure libraries such as sets, queues, or stacks using specifications that capture well-understood correctness conditions, such as linearizability. The implementation of these libraries, however, focused as they are on performance, may additionally exploit relaxed memory behavior allowed by the language or underlying hardware that weaken the strong ordering and visibility constraints on shared-memory accesses that would otherwise be imposed by a sequentially consistent (SC) memory model. As an alternative to developing new specification and verification mechanisms for reasoning about libraries under relaxed memory model, we instead consider the orthogonal problem of library robustness , a property that holds when all possible behaviors of a library implementation under relaxed memory model are also possible under SC. In this paper, we develop a new automated technique for verifying robustness of library implementations in the context of a C11-style memory model. This task is challenging because a most-general client may invoke an unbounded number of concurrently executing library operations that can manipulate an unbounded number of shared locations. We establish a novel inductive technique for verifying library robustness that leverages prior work on the robustness problem for the C11 memory model based on the search for a non-robustness witness under SC executions. We crucially rely on the fact that this search is carried out over SC executions, and use high-level SC specifications (including linearizability) of the library to verify the absence of a non-robustness witness. Our technique is compositional - we show how we can safely preserve robustness of multiple interacting library implementations and clients using additional SC fences to guarantee robustness of entire executions. Experimental results on a number of complex realistic library implementations demonstrate the feasibility of our approach.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689802", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kartik", + "last_name": "Nagar", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Anmol", + "last_name": "Sahoo", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Romit Roy", + "last_name": "Chowdhury", + "institution": "Chennai Mathematical Institute" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/NagarSCJ24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689805", + "title": "Higher-Order Model Checking of Effect-Handling Programs with Answer-Type Modification", + "abstract": "Since the seminal work by Ong, the model checking of higher-order programs—called higher-order model checking , or HOMC for short—has gained attention. It is also crucial for making HOMC applicable to real-world software to address programs involving computational effects. Recently, Dal Lago and Ghyselen considered an extension of HOMC to algebraic effect handlers , which enable programming the semantics of effects. They showed a negative result for HOMC with algebraic effect handlers—it is undecidable. In this work, we explore a restriction on programs with algebraic effect handlers which ensures the decidability of HOMC while allowing implementations of various effects. We identify the crux of the undecidability as the use of an unbounded number of algebraic effect handlers being active at the same time. To prevent it, we introduce answer-type modification (ATM), which can bound the number of algebraic effect handlers that can be active at the same time. We prove that ATM can ensure the decidability of HOMC and show that it accommodates a wide range of effects. To evaluate our approach, we implemented an automated verifier EffCaml based on the presented techniques and confirmed that the program examples discussed in this paper can be automatically verified.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689805", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/Sekiyama024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689804", + "title": "Boosting the Performance of Alias-Aware IFDS Analysis with CFL-Based Environment Transformers", + "abstract": "The IFDS algorithm is pivotal in solving field-sensitive data-flow problems. However, its conventional use of access paths for field sensitivity leads to the generation of a large number of data-flow facts. This causes scalability challenges in larger programs, limiting its practical application in extensive codebases. In response, we propose a new field-sensitive technique that reinterprets the generation of access paths as a Context-Free Language (CFL) for field-sensitivity and formulates it as an IDE problem. This approach significantly reduces the number of data-flow facts generated and handled during the analysis, which is a major factor in performance degradation. To demonstrate the effectiveness of this approach, we developed a taint analysis tool, IDEDroid, in the IFDS/IDE framework. IDEDroid outperforms FlowDroid, an established IFDS-based taint analysis tool, in the analysis of 24 major Android apps while improving its precision (guaranteed theoretically). The speed improvement ranges from 2.1 × to 2,368.4 × , averaging at 222.0 × , with precision gains reaching up to 20.0 % (in terms of false positives reduced). This performance indicates that IDEDroid is substantially more effective in detecting information-flow leaks, making it a potentially superior tool for mobile app vetting in the market.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689804", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haofeng", + "last_name": "Li", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Chenghang", + "last_name": "Shi", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Jie", + "last_name": "Lu", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Lian", + "last_name": "Li", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "journals/pacmpl/LiS00X24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689803", + "title": "The ART of Sharing Points-to Analysis: Reusing Points-to Analysis Results Safely and Efficiently", + "abstract": "Data-flow analyses like points-to analysis can vastly improve the precision of other analyses, and enable powerful code optimizations. However, whole-program points-to analysis of large Java programs tends to be expensive – both in terms of time and memory. Consequently, many compilers (both static and JIT) and program-analysis tools tend to employ faster – but more conservative – points-to analyses to improve usability. As an alternative to such trading of precision for performance, various techniques have been proposed to perform precise yet expensive fixed-point points-to analyses ahead of time in a static analyzer, store the results, and then transmit them to independent compilation/program-analysis stages that may need them. However, an underlying concern of safety affects all such techniques – can a compiler (or program analysis tool) trust the points-to analysis results generated by another compiler/tool? In this work, we address this issue of trust in the context of Java, while accounting for the issue of performance. We propose ART : Analysis-Results Representation Template – a novel scheme to efficiently and concisely encode results of flow-sensitive, context-insensitive points-to analysis computed by a static analyzer for use in any independent system that may benefit from such a precise points-to analysis. ART also allows for fast regeneration of the encoded sound analysis results in such systems. Our scheme has two components: (i) a producer that can statically perform expensive points-to analysis and encode the same concisely, (ii) a consumer that, on receiving such encoded results (called art work), can regenerate the points-to analysis results encoded by the art work if it is deemed “safe”. The regeneration scheme completely avoids fixed-point computations and thus can help consumers like static analyzers and JIT compilers to obtain precise points-to information without paying a prohibitively high cost. We demonstrate the usage of ART by implementing a producer (in Soot) and two consumers (in Soot and the Eclipse OpenJ9 JIT compiler). We have evaluated our implementation over various benchmarks from the DaCapo and SPECjvm2008 suites. Our results demonstrate that using ART, a consumer can obtain precise flow-sensitive, context-insensitive points-to analysis results in less than (average) 1% of the time taken by a static analyzer to perform the same analysis, with the storage overhead of ART representing a small fraction of the program size (average around 4%).", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689803", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shashin", + "last_name": "Halalingaiah", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Vijay", + "last_name": "Sundaresan", + "institution": "IBM (Canada)" + }, + { + "first_name": "Daryl", + "last_name": "Maier", + "institution": "IBM (Canada)" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "journals/pacmpl/HalalingaiahSMN24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689730", + "title": "SparseAuto: An Auto-scheduler for Sparse Tensor Computations using Recursive Loop Nest Restructuring", + "abstract": "Automated code generation and performance enhancements for sparse tensor algebra have become essential in many real-world applications, such as quantum computing, physical simulations, computational chemistry, and machine learning. General sparse tensor algebra compilers are not always versatile enough to generate asymptotically optimal code for sparse tensor contractions. This paper shows how to generate asymptotically better schedules for complex sparse tensor expressions using kernel fission and fusion. We present generalized loop restructuring transformations to reduce asymptotic time complexity and memory footprint. Furthermore, we present an auto-scheduler that uses a partially ordered set (poset)-based cost model that uses both time and auxiliary memory complexities to prune the search space of schedules. In addition, we highlight the use of Satisfiability Module Theory (SMT) solvers in sparse auto-schedulers to approximate the Pareto frontier of better schedules to the smallest number of possible schedules, with user-defined constraints available at compile-time. Finally, we show that our auto-scheduler can select better-performing schedules and generate code for them. Our results show that the auto-scheduler provided schedules achieve orders of-magnitude speedup compared to the code generated by the Tensor Algebra Compiler (TACO) for several computations on different real-world tensors.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689730", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adhitha", + "last_name": "Dias", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Logan", + "last_name": "Anderson", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kirshanthan", + "last_name": "Sundararajah", + "institution": "Virginia Tech" + }, + { + "first_name": "Artem", + "last_name": "Pelenitsyn", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/DiasASP024", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689758", + "title": "Semantics Lifting for Syntactic Sugar", + "abstract": "Syntactic sugar plays a crucial role in engineering programming languages. It offers convenient syntax and higher-level of abstractions, as witnessed by its pervasive use in both general-purpose and domain-specific contexts. Unfortunately, the traditional approach of translating programs containing syntactic sugars into the host language can lead to abstraction leakage, breaking the promise of convenience and hindering program comprehension. To address this challenge, we introduce the idea of semantics lifting that aims to statically derive self-contained evaluation rules for syntactic sugars. More specifically, we propose a semantics-lifting framework that consists of (i) a general algorithm for deriving host-independent semantics of syntactic sugars from the semantics of the host language and the desugaring rules, (ii) a formulation of the correctness and abstraction properties for a lifted semantics, and (iii) a systematic investigation of sufficient conditions that ensure a lifted semantics is provably correct and abstract. To evaluate our semantics-lifting framework, we have implemented a system named Osazone and conducted several case studies, demonstrating that our approach is flexible, effective, and practical for implementing domain-specific languages.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689758", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhichao", + "last_name": "Guan", + "institution": "Peking University" + }, + { + "first_name": "Yiyuan", + "last_name": "Cao", + "institution": "Peking University" + }, + { + "first_name": "Tailai", + "last_name": "Yu", + "institution": "Tsinghua University" + }, + { + "first_name": "Ziheng", + "last_name": "Wang", + "institution": "Peking University" + }, + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Peking University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/GuanCYW0H24", + "venue": "oopsla", + "year": 2024 + }, + { + "paper_id": "10.1145/3689780", + "title": "Rustlantis: Randomized Differential Testing of the Rust Compiler", + "abstract": "Compilers are at the core of all computer architecture. Their middle-end and back-end are full of subtle code that is easy to get wrong. At the same time, the consequences of compiler bugs can be severe. Therefore, it is important that we develop techniques to increase our confidence in compiler correctness, and to help find the bugs that inevitably happen. One promising such technique that has successfully found many compiler bugs in the past is randomized differential testing , a fuzzing approach whereby the same program is executed with different compilers or different compiler settings to detect any unexpected differences in behavior. We present Rustlantis , the first fuzzer for the Rust programming language that is able to find new correctness bugs in the official Rust compiler. To avoid having to deal with Rust’s strict type and borrow checker, Rustlantis directly generates MIR, the central IR of the Rust compiler for optimizations. The program generation strategy of Rustlantis is a combination of statically tracking the state of the program, obscuring the program state for the compiler, and decoy blocks to lead optimizations astray. This has allowed us to identify 22 previously unknown bugs in the Rust compiler, most of which have been fixed.", + "date": "2024-10-08", + "link": "https://doi.org/10.1145/3689780", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qian", + "last_name": "Wang", + "institution": "ETH Zurich" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/Wang024", + "venue": "oopsla", + "year": 2024 + } +] \ No newline at end of file diff --git a/data/pl_conferences/oopsla/2025.json b/data/pl_conferences/oopsla/2025.json new file mode 100644 index 0000000..7cda821 --- /dev/null +++ b/data/pl_conferences/oopsla/2025.json @@ -0,0 +1,7345 @@ +[ + { + "paper_id": "10.1145/3720474", + "title": "KestRel: Relational Verification using E-Graphs for Program Alignment", + "abstract": "Many interesting program properties involve the execution of multiple programs, including observational equivalence, noninterference, co-termination, monotonicity, and idempotency. One strategy for verifying such relational properties is to construct and reason about an intermediate program whose correctness implies that the individual programs exhibit those properties. A key challenge in building an intermediate program is finding a good alignment of the original programs. An alignment puts subparts of the original programs into correspondence so that their similarities can be exploited in order to simplify verification. We propose an approach to intermediate program construction that uses e-graphs, equality saturation, and algebraic realignment rules to efficiently represent and build programs amenable to automated verification. A key ingredient of our solution is a novel data-driven extraction technique that uses execution traces of candidate intermediate programs to identify solutions that are semantically well-aligned. We have implemented a relational verification engine based on our proposed approach, called KestRel, and use it to evaluate our approach over a suite of benchmarks taken from the relational verification literature.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720474", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Robert", + "last_name": "Dickerson", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Prasita", + "last_name": "Mukherjee", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/DickersonMD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720515", + "title": "Semantics of Sets of Programs", + "abstract": "Applications like program synthesis sometimes require proving that a property holds for all of the infinitely many programs described by a grammar---i.e., an inductively defined set of programs. Current verification frameworks overapproximate programs' behavior when sets of programs contain loops, including two Hoare-style logics that fail to be relatively complete when loops are allowed. In this work, we prove that compositionally verifying simple properties for infinite sets of programs requires tracking distinct program behaviors over unboundedly many executions. Tracking this information is both necessary and sufficient for verification. We prove this fact in a general, reusable theory of denotational semantics that can model the expressivity and compositionality of verification techniques over infinite sets of programs. We construct the minimal compositional semantics that captures simple properties of sets of programs and use it to derive the first sound and relatively complete Hoare-style logic for infinite sets of programs. Thus, our methods can be used to design minimally complex, compositional verification techniques for sets of programs.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720515", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jinwoo", + "last_name": "Kim", + "institution": "University of California San Diego" + }, + { + "first_name": "Shaan", + "last_name": "Nagy", + "institution": "University of California San Diego" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/KimNRD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720435", + "title": "Soundness of Predictive Concurrency Analyses", + "abstract": "A predictive analysis takes an execution trace as input and discovers concurrency bugs without accessing the program source code. A sound predictive analysis reports no false positives, which sounds like a property that can be defined easily, but which has been defined in many different ways in previous work. In this paper, we unify, simplify, and generalize those soundness definitions for analyses that discover concurrency bugs that can be represented as a consecutive sequence of events. Our soundness definition is graph based, separates thread-local properties and whole-execution properties, and works well with weak memory executions. We also present a three-step proof recipe, and we use it to prove six existing analyses sound. This includes the first proof of soundness for a predictive analysis that works with weak memory.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720435", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Siqi", + "last_name": "Liu", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Doug", + "last_name": "Lea", + "institution": "State University of New York at Oswego" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/LiuLP25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720431", + "title": "Scalable and Accurate Application-Level Crash-Consistency Testing via Representative Testing", + "abstract": "Crash consistency is essential for applications that must persist data. Crash-consistency testing has been commonly applied to find crash-consistency bugs in applications. The crash-state space grows exponentially as the number of operations in the program increases, necessitating techniques for pruning the search space. However, state-of-the-art crash-state space pruning is far from ideal. Some techniques look for known buggy patterns or bound the exploration for efficiency, but they sacrifice coverage and may miss bugs lodged deep within applications. Other techniques eliminate redundancy in the search space by skipping identical crash states, but they still fail to scale to larger applications. In this work, we propose representative testing: a new crash-state space reduction strategy that achieves high scalability and high coverage. Our key observation is that the consistency of crash states is often correlated, even if those crash states are not identical. We build Pathfinder, a crash-consistency testing tool that implements an update behaviors-based heuristic to approximate a small set of representative crash states. We evaluate Pathfinder on POSIX-based and MMIO-based applications, where it finds 18 (7 new) bugs across 8 production-ready systems. Pathfinder scales more effectively to large applications than prior works and finds 4x more bugs in POSIX-based applications and 8x more bugs in MMIO-based applications compared to state-of-the-art systems.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720431", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yile", + "last_name": "Gu", + "institution": "University of Washington" + }, + { + "first_name": "Ian", + "last_name": "Neal", + "institution": "University of Michigan" + }, + { + "first_name": "Jiexiao", + "last_name": "Xu", + "institution": "University of Washington" + }, + { + "first_name": "S.", + "last_name": "Lee", + "institution": "University of Washington" + }, + { + "first_name": "Ayman", + "last_name": "Said", + "institution": "University of Michigan" + }, + { + "first_name": "Musa", + "last_name": "Haydar", + "institution": "University of Michigan" + }, + { + "first_name": "Jacob Van", + "last_name": "Geffen", + "institution": "" + }, + { + "first_name": "Rohan", + "last_name": "Kadekodi", + "institution": "University of Washington" + }, + { + "first_name": "Andrew", + "last_name": "Quinn", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Baris", + "last_name": "Kasikci", + "institution": "University of Washington" + } + ], + "dblp_key": "journals/pacmpl/GuNXLSHGKQK25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720446", + "title": "Checking δ-Satisfiability of Reals with Integrals", + "abstract": "Many synthesis and verification problems can be reduced to determining the truth of formulas over the real numbers. These formulas often involve constraints with integrals in them. To this end, we extend the framework of δ-decision procedures with techniques for handling integrals of user-specified real functions. We implement this decision procedure in the tool ∫dReal, which is built on top of dReal. We evaluate ∫dReal on a suite of problems that include formulas verifying the fairness of algorithms and the privacy and the utility of privacy mechanisms and formulas that synthesize parameters for the desired utility of privacy mechanisms. The performance of the tool in these experiments demonstrates the effectiveness of ∫dReal.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720446", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cody", + "last_name": "Rivera", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Bishnu", + "last_name": "Bhusal", + "institution": "University of Missouri" + }, + { + "first_name": "Rohit", + "last_name": "Chadha", + "institution": "University of Missouri" + }, + { + "first_name": "A. Prasad", + "last_name": "Sistla", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/RiveraBCSV25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720499", + "title": "Laurel: Unblocking Automated Verification with Large Language Models", + "abstract": "Program verifiers such as Dafny automate proofs by outsourcing them to an SMT solver. This automation is not perfect, however, and the solver often requires hints in the form of assertions , creating a burden for the proof engineer. In this paper, we propose , a tool that alleviates this burden by automatically generating assertions using large language models (LLMs). To improve the success rate of LLMs in this task, we design two domain-specific prompting techniques. First, we help the LLM determine the location of the missing assertion by analyzing the verifier’s error message and inserting an assertion placeholder at that location. Second, we provide the LLM with example assertions from the same codebase, which we select based on a new proof similarity metric. We evaluate our techniques on our new benchmark , a dataset of complex lemmas we extracted from three real-world Dafny codebases. Our evaluation shows that is able to generate over 56.6% of the required assertions given only a few attempts, making LLMs an affordable tool for unblocking program verifiers without human intervention.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720499", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Mugnier", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Emmanuel Anaya", + "last_name": "Gonzalez", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "UC San Diego Health System" + }, + { + "first_name": "Zhou", + "last_name": "Yuanyuan", + "institution": "UC San Diego Health System" + } + ], + "dblp_key": "journals/pacmpl/MugnierGPJY25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720509", + "title": "Automated Verification of Soundness of DNN Certifiers", + "abstract": "The uninterpretability of Deep Neural Networks (DNNs) hinders their use in safety-critical applications. Abstract Interpretation-based DNN certifiers provide promising avenues for building trust in DNNs. Unsoundness in the mathematical logic of these certifiers can lead to incorrect results. However, current approaches to ensure their soundness rely on manual, expert-driven proofs that are tedious to develop, limiting the speed of developing new certifiers. Automating the verification process is challenging due to the complexity of verifying certifiers for arbitrary DNN architectures and handling diverse abstract analyses. We introduce ProveSound, a novel verification procedure that automates the soundness verification of DNN certifiers for arbitrary DNN architectures. Our core contribution is the novel concept of a symbolic DNN, using which, ProveSound reduces the soundness property, a universal quantification over arbitrary DNNs, to a tractable symbolic representation, enabling verification with standard SMT solvers. By formalizing the syntax and operational semantics of ConstraintFlow, a DSL for specifying certifiers, ProveSound efficiently verifies both existing and new certifiers, handling arbitrary DNN architectures. Our code is available at https://github.com/uiuc-focal-lab/constraintflow.git", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720509", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Avaljot", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Yasmin", + "last_name": "Sarita", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/SinghSMS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720438", + "title": "Orax: A Feedback-Driven Framework for Efficiently Solving Satisfiability Modulo Theories and Oracles", + "abstract": "Recent advancements in Satisfiability Modulo Theory (SMT) solving have significantly improved formula-driven techniques for verification, testing, repair, and synthesis. However, addressing open programs that lack formal specifications, such as those relying on third-party libraries, remains a challenge. The problem of Satisfiability Modulo Theories and Oracles (SMTO) has emerged as a critical issue where oracles, representing components with observable behavior but unknown implementation, hinder SMT solver from reasoning. Existing approaches like Delphi and Saadhak struggle to effectively combine sufficient oracle mapping information that is crucial for feasible solution construction with the reasoning capabilities of the SMT solver, leading to inefficient solving of SMTO problems. In this work, we propose a novel solving framework for SMTO problems, Orax, which establishes an oracle mapping information feedback loop between the SMT solver and the oracle handler. In Orax, the SMT solver analyzes the deficiency in oracle mapping information it has and feeds this back to the oracle handler. The oracle handler then provides the most suitable additional oracle mapping information back to the SMT solver. Orax employs a dual-clustering strategy to select the initial oracle mapping information provided to the SMT solver and a relaxation-based method to analyze the deficiency in the oracle mapping information the SMT solver knows. Experimental results on the benchmark suite demonstrate that Orax outperforms existing methods, solving 118.37% and 13.83% more benchmarks than Delphi and Saadhak, respectively. In terms of efficiency, Orax achieves a PAR-2 score of 1.39, significantly exceeding Delphi’s score of 669.13 and Saadhak’s score of 173.31.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720438", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhineng", + "last_name": "Zhong", + "institution": "Peking University" + }, + { + "first_name": "Ziqi", + "last_name": "Zhang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Hanqin", + "last_name": "Guan", + "institution": "Peking University" + }, + { + "first_name": "Ding", + "last_name": "Li", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/ZhongZGL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720420", + "title": "Inductive Synthesis of Inductive Heap Predicates", + "abstract": "We present an approach to automatically synthesise recursive predicates in Separation Logic (SL) from concrete data structure instances using Inductive Logic Programming (ILP) techniques. The main challenges to make such synthesis effective are (1) making it work without negative examples that are required in ILP but are difficult to construct for heap-based structures in an automated fashion, and (2) to be capable of summarising not just the shape of a heap (e.g., it is a linked list), but also the properties of the data it stores (e.g., it is a sorted linked list). We tackle these challenges with a new predicate learning algorithm. The key contributions of our work are (a) the formulation of ILP-based learning only using positive examples and (b) an algorithm that synthesises property-rich SL predicates from concrete memory graphs based on the positive-only learning. We show that our framework can efficiently and correctly synthesise SL predicates for structures that were beyond the reach of the state-of-the-art tools, including those featuring non-trivial payload constraints (e.g., binary search trees) and nested recursion (e.g., n -ary trees). We further extend the usability of our approach by a memory graph generator that produces positive heap examples from programs. Finally, we show how our approach facilitates deductive verification and synthesis of correct-by-construction code.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720420", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ziyi", + "last_name": "Yang", + "institution": "National University of Singapore" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/YangS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720452", + "title": "Automatically Verifying Replication-Aware Linearizability", + "abstract": "Data replication is crucial for enabling fault tolerance and uniform low latency in modern decentralized applications. Replicated Data Types (RDTs) have emerged as a principled approach for developing replicated implementations of basic data structures such as counter, flag, set, map, etc. While the correctness of RDTs is generally specified using the notion of strong eventual consistency--which guarantees that replicas that have received the same set of updates would converge to the same state--a more expressive specification which relates the converged state to updates received at a replica would be more beneficial to RDT users. Replication-aware linearizability is one such specification, which requires all replicas to always be in a state which can be obtained by linearizing the updates received at the replica. In this work, we develop a novel fully automated technique for verifying replication-aware linearizability for Mergeable Replicated Data Types (MRDTs). We identify novel algebraic properties for MRDT operations and the merge function which are sufficient for proving an implementation to be linearizable and which go beyond the standard notions of commutativity, associativity, and idempotence. We also develop a novel inductive technique called bottom-up linearization to automatically verify the required algebraic properties. Our technique can be used to verify both MRDTs and state-based CRDTs. We have successfully applied our approach to a number of complex MRDT and CRDT implementations including a novel JSON MRDT.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720452", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vimala", + "last_name": "Soundarapandian", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Kartik", + "last_name": "Nagar", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "KC", + "last_name": "Sivaramakrishnan", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "journals/pacmpl/SoundarapandianNRS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720419", + "title": "UTFix: Change Aware Unit Test Repairing using LLM", + "abstract": "Software updates, including bug repair and feature additions, are frequent in modern applications but they often leave test suites outdated, resulting in undetected bugs and increased chances of system failures. A recent study by Meta revealed that 14%-22% of software failures stem from outdated tests that fail to reflect changes in the codebase. This highlights the need to keep tests in sync with code changes to ensure software reliability. In this paper, we present UTFix, a novel approach for repairing unit tests when their corresponding focal methods undergo changes. UTFix addresses two critical issues: assertion failure and reduced code coverage caused by changes in the focal method. Our approach leverages language models to repair unit tests by providing contextual information such as static code slices, dynamic code slices, and failure messages. We evaluate UTFix on our generated synthetic benchmarks (Tool-Bench), and real-world benchmarks. Tool- Bench includes diverse changes from popular open-source Python GitHub projects, where UTFix successfully repaired 89.2% of assertion failures and achieved 100% code coverage for 96 tests out of 369 tests. On the real-world benchmarks, UTFix repairs 60% of assertion failures while achieving 100% code coverage for 19 out of 30 unit tests. To the best of our knowledge, this is the first comprehensive study focused on unit test in evolving Python projects. Our contributions include the development of UTFix, the creation of Tool-Bench and real-world benchmarks, and the demonstration of the effectiveness of LLM-based methods in addressing unit test failures due to software evolution.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720419", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shanto", + "last_name": "Rahman", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Sachit", + "last_name": "Kuhar", + "institution": "Amazon (United States)" + }, + { + "first_name": "Berk", + "last_name": "Çirişci", + "institution": "Amazon (Germany)" + }, + { + "first_name": "Pranav", + "last_name": "Garg", + "institution": "" + }, + { + "first_name": "Shiqi", + "last_name": "Wang", + "institution": "" + }, + { + "first_name": "Xiaofei", + "last_name": "Ma", + "institution": "" + }, + { + "first_name": "Anoop", + "last_name": "Deoras", + "institution": "Amazon (United States)" + }, + { + "first_name": "Baishakhi", + "last_name": "Ray", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/RahmanKCGWMDR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720500", + "title": "Scaling Optimization over Uncertainty via Compilation", + "abstract": "Probabilistic inference is fundamentally hard, yet many tasks require optimization on top of inference, which is even harder. We present a new optimization-via-compilation strategy to scalably solve a certain class of such problems. In particular, we introduce a new intermediate representation (IR), binary decision diagrams weighted by a novel notion of branch-and-bound semiring , that enables a scalable branch-and-bound based optimization procedure. This IR automatically factorizes problems through program structure and prunes suboptimal values via a straightforward branch-and-bound style algorithm to find optima. Additionally, the IR is naturally amenable to staged compilation , allowing the programmer to query for optima mid-compilation to inform further executions of the program. We showcase the effectiveness and flexibility of the IR by implementing two performant languages that both compile to it: dappl and pineappl. dappl is a functional language that solves maximum expected utility problems with first-class support for rewards, decision making, and conditioning. pineappl is an imperative language that performs exact probabilistic inference with support for nested marginal maximum a posteriori (MMAP) optimization via staging.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720500", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Minsung", + "last_name": "Cho", + "institution": "Northeastern University" + }, + { + "first_name": "John", + "last_name": "Gouwar", + "institution": "Northeastern University" + }, + { + "first_name": "Steven", + "last_name": "Holtzen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/ChoGH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3721089", + "title": "Symbolic MRD: Dynamic Memory, Undefined Behaviour, and Extrinsic Choice", + "abstract": "We present the first thin-air free memory model that admits compiler optimisations that aggressively leverage knowledge from alias analysis, an assumption of freedom from undefined behaviour, and from the extrinsic choices of real implementations such as over-alignment. Our model has tooling support with state-of-the-art performance, executing a battery of tests orders of magnitude quicker than other executable thin-air free semantics. The model integrates with the C/C++ memory model through an exportable semantic dependency relation, it allows standard compilation mappings for atomics, and it matches all tests in the recently published desiderata for C/C++ from the ISO.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3721089", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "J. C. N.", + "last_name": "Richards", + "institution": "University of Kent" + }, + { + "first_name": "Daniel", + "last_name": "Wright", + "institution": "University of Surrey" + }, + { + "first_name": "Simon", + "last_name": "Cooksey", + "institution": "Nvidia (United Kingdom)" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + } + ], + "dblp_key": "journals/pacmpl/RichardsWCB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720482", + "title": "Multi-Language Probabilistic Programming", + "abstract": "There are many different probabilistic programming languages that are specialized to specific kinds of probabilistic programs. From a usability and scalability perspective, this is undesirable: today, probabilistic programmers are forced up-front to decide which language they want to use and cannot mix-and-match different languages for handling heterogeneous programs. To rectify this, we seek a foundation for sound interoperability for probabilistic programming languages: just as today’s Python programmers can resort to low-level C programming for performance, we argue that probabilistic programmers should be able to freely mix different languages for meeting the demands of heterogeneous probabilistic programming environments. As a first step towards this goal, we introduce MultiPPL, a probabilistic multi-language that enables programmers to interoperate between two different probabilistic programming languages: one that leverages a high-performance exact discrete inference strategy, and one that uses approximate importance sampling. We give a syntax and semantics for MultiPPL, prove soundness of its inference algorithm, and provide empirical evidence that it enables programmers to perform inference on complex heterogeneous probabilistic programs and flexibly exploits the strengths and weaknesses of two languages simultaneously.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720482", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sam", + "last_name": "Stites", + "institution": "Northeastern University" + }, + { + "first_name": "John M.", + "last_name": "Li", + "institution": "Northeastern University" + }, + { + "first_name": "Steven", + "last_name": "Holtzen", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/StitesLH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720526", + "title": "PAFL: Enhancing Fault Localizers by Leveraging Project-Specific Fault Patterns", + "abstract": "We present PAFL, a new technique for enhancing existing fault localization methods by leveraging project-specific fault patterns. We observed that each software project has its own challenges and suffers from recurring fault patterns associated with those challenges. However, existing fault localization techniques use a universal localization strategy without considering those repetitive faults. To address this limitation, our technique, called project-aware fault localization (PAFL), enables existing fault localizers to leverage project-specific fault patterns. Given a buggy version of a project and a baseline fault localizer, PAFL first mines the fault patterns from past buggy versions of the project. Then, it uses the mined fault patterns to update the suspiciousness scores of statements computed by the baseline fault localizer. To this end, we use two novel ideas. First, we design a domain-specific fault pattern-description language to represent various fault patterns. An instance, called crossword, in our language describes a project-specific fault pattern and how it affects the suspiciousness scores of statements. Second, we develop an algorithm that synthesizes crosswords (i.e., fault patterns) from past buggy versions of the project. Evaluation using seven baseline fault localizers and 12 real-world C/C++ and Python projects demonstrates that PAFL effectively, robustly, and efficiently improves the performance of the baseline fault localization techniques.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720526", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Donguk", + "last_name": "Kim", + "institution": "Korea University" + }, + { + "first_name": "Minseok", + "last_name": "Jeon", + "institution": "Korea University" + }, + { + "first_name": "Doha", + "last_name": "Hwang", + "institution": "Samsung (South Korea)" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/KimJHO25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720508", + "title": "Combining Formal and Informal Information in Bayesian Program Analysis via Soft Evidences", + "abstract": "We propose a neural-symbolic style of program analysis that systematically incorporates informal information in a Datalog program analysis. The analysis is converted into a probabilistic analysis by attaching probabilities to its rules. And its output becomes a ranking of possible alarms based on their probabilities. We apply a neural network to judge how likely an analysis fact holds based on informal information such as variable names and String constants. This information is encoded as a soft evidence in the probabilistic analysis, which is a “noisy sensor” of the fact. With this information, the probabilistic analysis produces a better ranking of the alarms. We have demonstrated the effectiveness of our approach by improving a pointer analysis based on variable names on eight Java benchmarks, and a taint analysis that considers inter-component communication on eight Android applications. On average, our approach has improved the inversion count between true alarms and false alarms, mean rank of true alarms, and median rank of true alarms by 55.4%, 44.9%, and 58% on the pointer analysis, and 67.2%, 44.7%, and 37.6% on the taint analysis respectively. We also demonstrated the generality of our soft evidence mechanism by improving a taint analysis and an interval analysis for C programs using dynamic information from program executions.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720508", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tianchi", + "last_name": "Li", + "institution": "Peking University" + }, + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/LiZ25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720424", + "title": "Denotational Foundations for Expected Cost Analysis", + "abstract": "Reasoning about the cost of executing programs is one of the fundamental questions in computer science. In the context of programming with probabilities, however, the notion of cost stops being deterministic, since it depends on the probabilistic samples made throughout the execution of the program. This interaction is further complicated by the non-trivial interaction between cost, recursion and evaluation strategy. In this work we introduce cert : a Call-By-Push-Value (CBPV) metalanguage for reasoning about probabilistic cost. We equip cert with an operational cost semantics and define two denotational semantics — a cost semantics and an expected-cost semantics. We prove operational soundness and adequacy for the denotational cost semantics and a cost adequacy theorem for the expected-cost semantics. We formally relate both denotational semantics by stating and proving a novel effect simulation property for CBPV. We also prove a canonicity property of the expected-cost semantics as the minimal semantics for expected cost and probability by building on recent advances on monadic probabilistic semantics. Finally, we illustrate the expressivity of cert and the expected-cost semantics by presenting case-studies ranging from randomized algorithms to stochastic processes and show how our semantics capture their intended expected cost.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720424", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Pedro H. Azevedo de", + "last_name": "Amorim", + "institution": "University of Oxford" + } + ], + "dblp_key": "journals/pacmpl/Amorim25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720449", + "title": "API-Guided Dataset Synthesis to Finetune Large Code Models", + "abstract": "Large code models (LCMs), pre-trained on vast code corpora, have demonstrated remarkable performance across a wide array of code-related tasks. Supervised fine-tuning (SFT) plays a vital role in aligning these models with specific requirements and enhancing their performance in particular domains. However, synthesizing high-quality SFT datasets poses a significant challenge due to the uneven quality of datasets and the scarcity of domain-specific datasets. Inspired by APIs as high-level abstractions of code that encapsulate rich semantic information in a concise structure, we propose DataScope, an API-guided dataset synthesis framework designed to enhance the SFT process for LCMs in both general and domain-specific scenarios. DataScope comprises two main components: Dslt and Dgen. On the one hand, Dslt employs API coverage as a core metric, enabling efficient dataset synthesis in general scenarios by selecting subsets of existing (uneven-quality) datasets with higher API coverage. On the other hand, Dgen recasts domain dataset synthesis as a process of using API-specified high-level functionality and deliberately constituted code skeletons to synthesize concrete code. Extensive experiments demonstrate DataScope’s effectiveness, with models fine-tuned on its synthesized datasets outperforming those tuned on unoptimized datasets five times larger. Furthermore, a series of analyses on model internals, relevant hyperparameters, and case studies provide additional evidence for the efficacy of our proposed methods. These findings underscore the significance of dataset quality in SFT and advance the field of LCMs by providing an efficient, cost-effective framework for constructing high-quality datasets, which in turn lead to more powerful and tailored LCMs for both general and domain-specific scenarios.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720449", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zongjie", + "last_name": "Li", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Daoyuan", + "last_name": "Wu", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Shuai", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/LiWWS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720484", + "title": "The Simulation Semantics of Synthesisable Verilog", + "abstract": "Despite numerous previous formalisation projects targeting Verilog, the semantics of Verilog defined by the Verilog standard -- Verilog's simulation semantics -- has thus far eluded definitive mathematical formalisation. Previous projects on formalising the semantics have made good progress but no previous project provides a formalisation that can be used to execute or formally reason about real-world hardware designs. In this paper, we show that the reason for this is that the Verilog standard is inconsistent both with Verilog practice and itself. We pinpoint a series of problems in the Verilog standard that we have identified in how the standard defines the semantics of the subset of Verilog used to describe hardware designs, that is, the synthesisable subset of Verilog. We show how the most complete Verilog formalisation to date inherits these problems and how, after we repair these problems in an executable implementation of the formalisation, the repaired implementation can be used to execute real-world hardware designs. The existing formalisation together with the repairs hence constitute the first formalisation of Verilog's simulation semantics compatible with real-world hardware designs. Additionally, to make the results of this paper accessible to a wider (nonmathematical) audience, we provide a visual formalisation of Verilog's simulation semantics.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720484", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Lööw", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/Loow25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720480", + "title": "Guarding the Privacy of Label-Only Access to Neural Network Classifiers via iDP Verification", + "abstract": "Neural networks are susceptible to privacy attacks that can extract private information of the training set. To cope, several training algorithms guarantee differential privacy (DP) by adding noise to their computation. However, DP requires to add noise considering every possible training set. This leads to a significant decrease in the network’s accuracy. Individual DP (iDP) restricts DP to a given training set. We observe that some inputs deterministically satisfy iDP without any noise . By identifying them, we can provide iDP label-only access to the network with a minor decrease to its accuracy. However, identifying the inputs that satisfy iDP without any noise is highly challenging. Our key idea is to compute the iDP deterministic bound (iDP-DB), which overapproximates the set of inputs that do not satisfy iDP, and add noise only to their predicted labels. To compute the tightest iDP-DB, which enables to guard the label-only access with minimal accuracy decrease, we propose LUCID, which leverages several formal verification techniques. First, it encodes the problem as a mixed-integer linear program, defined over a network and over every network trained identically but without a unique data point. Second, it abstracts a set of networks using a hyper-network . Third, it eliminates the overapproximation error via a novel branch-and-bound technique. Fourth, it bounds the differences of matching neurons in the network and the hyper-network, encodes them as linear constraints to prune the search space, and employs linear relaxation if they are small. We evaluate LUCID on fully-connected and convolutional networks for four datasets and compare the results to existing DP training algorithms, which in particular provide iDP guarantees. We show that LUCID can provide classifiers with a perfect individuals’ privacy guarantee (0-iDP) – which is infeasible for DP training algorithms – with an accuracy decrease of 1.4%. For more relaxed ε-iDP guarantees, LUCID has an accuracy decrease of 1.2%. In contrast, existing DP training algorithms that obtain ε-DP guarantees, and in particular ε-iDP guarantees, reduce the accuracy by 12.7%.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720480", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anan", + "last_name": "Kabaha", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Dana", + "last_name": "Drachsler-Cohen", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KabahaD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720501", + "title": "A Unifying Approach to Product Constructions for Quantitative Temporal Inference", + "abstract": "Probabilistic programs are a powerful and convenient approach to formalising distributions over system executions. A classical verification problem for probabilistic programs is temporal inference : to compute the likelihood that the execution traces satisfy a given temporal property. This paper presents a general framework for temporal inference, which applies to a rich variety of quantitative models including those that arise in the operational semantics of probabilistic and weighted programs. The key idea underlying our framework is that in a variety of existing approaches, the main construction that enables temporal inference is that of a product between the system of interest and the temporal property. We provide a unifying mathematical definition of product constructions, enabled by the realisation that 1) both systems and temporal properties can be modelled as coalgebras and 2) product constructions are distributive laws in this context. Our categorical framework leads us to our main contribution: a sufficient condition for correctness , which is precisely what enables to use the product construction for temporal inference. We show that our framework can be instantiated to naturally recover a number of disparate approaches from the literature including, e.g., partial expected rewards in Markov reward models, resource-sensitive reachability analysis, and weighted optimization problems. Furthermore, we demonstrate a product of weighted programs and weighted temporal properties as a new instance to show the scalability of our approach.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720501", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kazuki", + "last_name": "Watanabe", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Sebastian", + "last_name": "Junges", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Jurriaan", + "last_name": "Rot", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Ichiro", + "last_name": "Hasuo", + "institution": "National Institute of Informatics" + } + ], + "dblp_key": "journals/pacmpl/WatanabeJRH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720503", + "title": "SPLAT: A Framework for Optimised GPU Code-Generation for SParse reguLar ATtention", + "abstract": "Multi-head-self-attention (MHSA) mechanisms achieve state-of-the-art (SOTA) performance across natural language processing and vision tasks. However, their quadratic dependence on sequence lengths has bottlenecked inference speeds. To circumvent this bottleneck, researchers have proposed various sparse-MHSA models, where a subset of full attention is computed. Despite their promise, current sparse libraries and compilers do not support high-performance implementations for diverse sparse-MHSA patterns due to the underlying sparse formats they operate on. On one end, sparse libraries operate on general sparse formats which target extreme amounts of random sparsity (<10% non-zero values) and have high metadata in O ( nnzs ). On the other end, hand-written kernels operate on custom sparse formats which target specific sparse-MHSA patterns. However, the sparsity patterns in sparse-MHSA are moderately sparse (10-50% non-zero values) and varied, resulting in general sparse formats incurring high metadata overhead and custom sparse formats covering few sparse-MSHA patterns, trading off generality for performance. We bridge this gap, achieving both generality and performance, by proposing a novel sparse format: affine-compressed-sparse-row (ACSR) and supporting code-generation scheme, SPLAT, that generates high-performance implementations for diverse sparse-MHSA patterns on GPUs. Core to our proposed format and code generation algorithm is the observation that common sparse-MHSA patterns have uniquely regular geometric properties. These properties, which can be analyzed just-in-time, expose novel optimizations and tiling strategies that SPLAT exploits to generate high-performance implementations for diverse patterns. To demonstrate SPLAT’s efficacy, we use it to generate code for various sparse-MHSA models, achieving speedups of up-to 2.05x and 4.05x over hand-written kernels written in triton and TVM respectively on A100 GPUs in single-precision.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720503", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ahan", + "last_name": "Gupta", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Yueming", + "last_name": "Yuan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Devansh", + "last_name": "Jain", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Yunxiu", + "last_name": "Ge", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "David", + "last_name": "Aponte", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Yanqi", + "last_name": "Zhou", + "institution": "Google (United States)" + }, + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/GuptaYJGAZM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720417", + "title": "Efficient Incremental Verification of Neural Networks Guided by Counterexample Potentiality", + "abstract": "Incremental verification is an emerging neural network verification approach that aims to accelerate the verification of a neural network N * by reusing the existing verification result (called a template ) of a similar neural network N . To date, the state-of-the-art incremental verification approach leverages the problem splitting history produced by branch and bound ( BaB in verification of N , to select only a part of the sub-problems for verification of N * , thus more efficient than verifying N * from scratch. While this approach identifies whether each sub-problem should be re-assessed, it neglects the information of how necessary each sub-problem should be re-assessed, in the sense that the sub-problems that are more likely to contain counterexamples should be prioritized, in order to terminate the verification process as soon as a counterexample is detected. To bridge this gap, we first define a counterexample potentiality order over different sub-problems based on the template, and then we propose Olive , an incremental verification approach that explores the sub-problems of verifying N * orderly guided by counterexample potentiality. Specifically, Olive has two variants, including Olive g , a greedy strategy that always prefers to exploit the sub-problems that are more likely to contain counterexamples, and Olive b , a balanced strategy that also explores the sub-problems that are less likely, in case the template is not sufficiently precise. We experimentally evaluate the efficiency of Olive on 1445 verification problem instances derived from 15 neural networks spanning over two datasets MNIST and CIFAR-10. Our evaluation demonstrates significant performance advantages of Olive over state-of-the-art classic verification and incremental approaches. In particular, Olive shows evident superiority on the problem instances that contain counterexamples, and performs as well as Ivan on the certified problem instances.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720417", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guanqin", + "last_name": "Zhang", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Zhenya", + "last_name": "Zhang", + "institution": "Kyushu University" + }, + { + "first_name": "H. M. N. Dilum", + "last_name": "Bandara", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Shiping", + "last_name": "Chen", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Jianjun", + "last_name": "Zhao", + "institution": "Kyushu University" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "journals/pacmpl/ZhangZBCZS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720493", + "title": "Characterizing Implementability of Global Protocols with Infinite States and Data", + "abstract": "We study the implementability problem for an expressive class of symbolic communication protocols involving multiple participants. Our symbolic protocols describe infinite states and data values using dependent refinement predicates. Implementability asks whether a global protocol specification admits a distributed, asynchronous implementation, namely one for each participant, that is deadlock-free and exhibits the same behavior as the specification. We provide a unified explanation of seemingly disparate sources of non-implementability through a precise semantic characterization of implementability for infinite protocols. Our characterization reduces the problem of implementability to (co)reachability in the global protocol restricted to each participant. This compositional reduction yields the first sound and relatively complete algorithm for checking implementability of symbolic protocols. We use our characterization to show that for finite protocols, implementability is co-NP-complete for explicit representations and PSPACE-complete for symbolic representations. The finite, explicit fragment subsumes a previously studied fragment of multiparty session types for which our characterization yields a co-NP decision procedure, tightening a prior PSPACE upper bound.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720493", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Elaine", + "last_name": "Li", + "institution": "New York University" + }, + { + "first_name": "Felix", + "last_name": "Stutz", + "institution": "University of Luxembourg" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + }, + { + "first_name": "Damien", + "last_name": "Zufferey", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/LiSWZ25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720434", + "title": "Notions of Stack-Manipulating Computation and Relative Monads", + "abstract": "Monads provide a simple and concise interface to user-defined computational effects in functional programming languages. This enables equational reasoning about effects, abstraction over monadic interfaces and the development of monad transformer stacks to combine different effects. Compiler implementors and assembly code programmers similarly virtualize effects, and would benefit from similar abstractions if possible. However, the implementation details of effects seem disconnected from the high-level monad interface: at this lower level much of the design is in the layout of the runtime stack, which is not accessible in a high-level programming language. We demonstrate that the monadic interface can be faithfully adapted from high-level functional programming to a lower level setting with explicit stack manipulation. We use a polymorphic call-by-push-value (CBPV) calculus as a setting that captures the essence of stack-manipulation, with a type system that allows programs to define domain-specific stack structures. Within this setting, we show that the existing category-theoretic notion of a relative monad can be used to model the stack-based implementation of computational effects. To demonstrate generality, we adapt a variety of standard monads to relative monads. Additionally, we show that stack-manipulating programs can benefit from a generalization of do-notation we call \"monadic blocks\" that allow all CBPV code to be reinterpreted to work with an arbitrary relative monad. As an application, we show that all relative monads extend automatically to relative monad transformers, a process which is not automatic for monads in pure languages.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720434", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yajun", + "last_name": "Jiang", + "institution": "University of Michigan" + }, + { + "first_name": "Ruiyang", + "last_name": "Xue", + "institution": "University of Cambridge" + }, + { + "first_name": "Max S.", + "last_name": "New", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/JiangXN25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720425", + "title": "Hambazi: Spatial Coordination Synthesis for Augmented Reality", + "abstract": "Augmented reality (AR) seamlessly overlays virtual objects onto the real world, enabling an exciting new range of applications. Multiple users view and interact with virtual objects, which are replicated and shown on each user's display. A key requirement of AR is that the replicas should be quickly updated and converge to the same state; otherwise, users may have laggy or inconsistent views of the virtual object, which negatively affects their experience. A second key requirement is that the movements of virtual objects in space should preserve certain integrity properties either due to physical boundaries in the real world, or privacy and safety preferences of the user. For example, a virtual cup should not sink into a table, or a private virtual whiteboard should stay within an office. The challenge tackled in this paper is the coordination of virtual objects with low latency, spatial integrity properties and convergence. We introduce “well-organized” replicated data types that guarantee these two properties. Importantly, they capture a local notion of conflict that supports more concurrency and lower latency. To implement well-organized virtual objects, we introduce a credit scheme and replication protocol that further facilitate local execution, and prove the protocol's correctness. Given an AR environment, we automatically derive conflicting actions through constraint solving, and statically instantiate the protocol to synthesize custom coordination. We evaluate our implementation, HAMBAZI, on off-the-shelf Android AR devices and show a latency reduction of 30.5-88.4% and a location staleness reduction of 35.6-75.6%, compared to three baselines, for varying numbers of devices, AR environments, request loads, and network conditions.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720425", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yi-Zhen", + "last_name": "Tsai", + "institution": "University of California, Riverside" + }, + { + "first_name": "Jiasi", + "last_name": "Chen", + "institution": "University of Michigan" + }, + { + "first_name": "Mohsen", + "last_name": "Lesani", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "journals/pacmpl/TsaiCL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720492", + "title": "Automatic Linear Resource Bound Analysis for Rust via Prophecy Potentials", + "abstract": "Rust has become a popular system programming language that strikes a balance between memory safety and performance. Rust’s type system ensures the safety of low-level memory controls; however, a well-typed Rust program is not guaranteed to enjoy high performance. This article studies static analysis for resource consumption of Rust programs, aiming at understanding the performance of Rust programs. Although there have been tons of studies on static resource analysis, exploiting Rust’s memory safety—especially the borrow mechanisms and their properties—to aid resource-bound analysis, remains unexplored. This article presents RaRust, a type-based linear resource-bound analysis for well-typed Rust programs. RaRust follows the methodology of automatic amortized resource analysis (AARA) to build a resource-aware type system. To support Rust’s borrow mechanisms, including shared and mutable borrows, RaRust introduces shared and novel prophecy potentials to reason about borrows compositionally. To prove the soundness of RaRust, this article proposes Resource-Aware Borrow Calculus (RABC) as a variant of recently proposed Low-Level Borrow Calculus (LLBC). The experimental evaluation of a prototype implementation of RaRust demonstrates that RaRust is capable of inferring symbolic linear resource bounds for Rust programs featuring shared and mutable borrows, reborrows, heap-allocated data structures, loops, and recursion.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720492", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qihao", + "last_name": "Lian", + "institution": "Peking University" + }, + { + "first_name": "Di", + "last_name": "Wang", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/LianW25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720481", + "title": "Language-Parametric Reference Synthesis", + "abstract": "Modern Integrated Development Environments (IDEs) offer automated refactorings to aid programmers in developing and maintaining software. However, implementing sound automated refactorings is challenging, as refactorings may inadvertently introduce name-binding errors or cause references to resolve to incorrect declarations. To address these issues, previous work by Schäfer et al. proposed replacing concrete references with _locked references_ to separate binding preservation from transformation. Locked references vacuously resolve to a specific declaration, and after transformation must be replaced with concrete references that also resolve to that declaration. Synthesizing these references requires a faithful inverse of the name lookup functions of the underlying language. Manually implementing such inverse lookup functions is challenging due to the complex name-binding features in modern programming languages. Instead, we propose to automatically derive this function from type system specifications written in the Statix meta-DSL. To guide the synthesis of qualified references we use _scope graphs_, which represent the binding structure of a program, to infer their names and discover their syntactic structure. We evaluate our approach by synthesizing concrete references for locked references in 2528 Java, 196 ChocoPy, and 49 Featherweight Generic Java test programs. Our approach yields a principled language-parametric method for synthesizing references.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720481", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniel A. A.", + "last_name": "Pelsmaeker", + "institution": "Delft University of Technology" + }, + { + "first_name": "Aron", + "last_name": "Zwaan", + "institution": "Delft University of Technology" + }, + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Arjan J.", + "last_name": "Mooij", + "institution": "ZHAW Zurich University of Applied Sciences" + } + ], + "dblp_key": "journals/pacmpl/PelsmaekerZPM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720448", + "title": "Metamorph: Synthesizing Large Objects from Dafny Specifications", + "abstract": "Program synthesis aims to produce code that adheres to user-provided specifications. In this work, we focus on synthesizing sequences of calls to formally specified APIs to generate objects that satisfy certain properties. This problem is particularly relevant in automated test generation, where a test engine may need an object with specific properties to trigger a given execution path. Constructing instances of complex data structures may require dozens of method calls, but reasoning about consecutive calls is computationally expensive, and existing work typically limits the number of calls in the solution. In this paper, we focus on synthesizing such long sequences of method calls in the Dafny programming language. To that end, we introduce Metamorph, a synthesis tool that uses counterexamples returned by the Dafny verifier to reason about the effects of method calls one at a time, limiting the complexity of solver queries. We also aim to limit the overall number of SMT queries by comparing the counterexamples using two distance metrics we develop for guiding the synthesis process. In particular, we introduce a novel piecewise distance metric, which puts a provably correct lower bound on the number of method calls in the solution and allows us to frame the synthesis problem as weighted A* search. When computing piecewise distance, we view object states as conjunctions of atomic constraints, identify constraints that each method call can satisfy, and combine this information using integer programming. We evaluate Metamorph’s ability to generate large objects on six benchmarks defining key data structures: linked lists, queues, arrays, binary trees, and graphs. Metamorph can successfully construct programs that require up to 57 method calls per instance and compares favorably to an alternative baseline approach. Additionally, we integrate Metamorph with DTest, Dafny’s automated test generation toolkit, and show that Metamorph can synthesize test inputs for parts of the AWS Cryptographic Material Providers Library that DTest alone is not able to cover. Finally, we use Metamorph to generate executable bytecode for a simple virtual machine, demonstrating that the techniques described here are more broadly applicable in the context of specification-guided synthesis.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720448", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aleksandr", + "last_name": "Fedchin", + "institution": "Tufts University" + }, + { + "first_name": "Alexander Y.", + "last_name": "Bai", + "institution": "Tufts University" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "Tufts University" + } + ], + "dblp_key": "journals/pacmpl/FedchinBF25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720423", + "title": "Destination Calculus: A Linear 𝜆-Calculus for Purely Functional Memory Writes", + "abstract": "Destination passing —aka. out parameters— is taking a parameter to fill rather than returning a result from a function. Due to its apparently imperative nature, destination passing has struggled to find its way to pure functional programming. In this paper, we present a pure functional calculus with destinations at its core. Our calculus subsumes all the similar systems, and can be used to reason about their correctness or extension. In addition, our calculus can express programs that were previously not known to be expressible in a pure language. This is guaranteed by a modal type system where modes are used to manage both linearity and scopes. Type safety of our core calculus was proved formally with the Coq proof assistant.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720423", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Bagrel", + "institution": "Laboratoire Lorrain de Recherche en Informatique et ses Applications" + }, + { + "first_name": "Arnaud", + "last_name": "Spiwack", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/BagrelS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720450", + "title": "Adaptive Shielding via Parametric Safety Proofs", + "abstract": "A major challenge to deploying cyber-physical systems with learning-enabled controllers is to ensure their safety, especially in the face of changing environments that necessitate runtime knowledge acquisition. Model-checking and automated reasoning have been successfully used for shielding, i.e., to monitor untrusted controllers and override potentially unsafe decisions, but only at the cost of hard tradeoffs in terms of expressivity, safety, adaptivity, precision and runtime efficiency. We propose a programming-language framework that allows experts to statically specify adaptive shields for learning-enabled agents, which enforce a safe control envelope that gets more permissive as knowledge is gathered at runtime. A shield specification provides a safety model that is parametric in the current agent's knowledge. In addition, a nondeterministic inference strategy can be specified using a dedicated domain-specific language, enforcing that such knowledge parameters are inferred at runtime in a statistically-sound way. By leveraging language design and theorem proving, our proposed framework empowers experts to design adaptive shields with an unprecedented level of modeling flexibility, while providing rigorous, end-to-end probabilistic safety guarantees.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720450", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yao", + "last_name": "Feng", + "institution": "Tsinghua University" + }, + { + "first_name": "Jun", + "last_name": "Zhu", + "institution": "Tsinghua University" + }, + { + "first_name": "André", + "last_name": "Platzer", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Jonathan", + "last_name": "Laurent", + "institution": "Karlsruhe Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/FengZPL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720476", + "title": "Modal Effect Types", + "abstract": "Effect handlers are a powerful abstraction for defining, customising, and composing computational effects. Statically ensuring that all effect operations are handled requires some form of effect system, but using a traditional effect system would require adding extensive effect annotations to the millions of lines of existing code in these languages. Recent proposals seek to address this problem by removing the need for explicit effect polymorphism. However, they typically rely on fragile syntactic mechanisms or on introducing a separate notion of second-class function. We introduce a novel approach based on modal effect types.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720476", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wenhao", + "last_name": "Tang", + "institution": "University of Edinburgh" + }, + { + "first_name": "Leo", + "last_name": "White", + "institution": "" + }, + { + "first_name": "Stephen", + "last_name": "Dolan", + "institution": "" + }, + { + "first_name": "Daniel", + "last_name": "Hillerström", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "Anton", + "last_name": "Lorenzen", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/TangWDHLL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720415", + "title": "Binary Cryptographic Function Identification via Similarity Analysis with Path-Insensitive Emulation", + "abstract": "It becomes an essential requirement to identify cryptographic functions in binaries due to their widespread application in modern software. The technology fundamentally supports numerous software security analyses, such as malware analysis, blockchain forensics, etc. Unfortunately, the existing methods still struggle to strike a balance between analysis accuracy, efficiency, and code coverage, which hampers their practical application. In this paper, we propose BinCrypto, a method of emulation-based code similarity analysis on the interval domain, to identify cryptographic functions in binary files. It produces accurate results because it relies on the behavior-related code features collected during emulation. On the other hand, the emulation is performed in a path-insensitive manner, where the emulated values are all represented as intervals. As such, it is able to analyze every basic block only once, accomplishing the identification efficiently, and achieve complete block coverage simultaneously. We conduct the experiments with nine real-world cryptographic libraries. The results show that BinCrypto achieves the average accuracy of 83.2%, nearly twice that of WheresCrypto, the state-of-the-art method. BinCrypto is also able to successfully complete the tasks, including statically-linked library analysis, cross-library analysis, obfuscated code analysis, and malware analysis, demonstrating its potential for practical applications.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720415", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yikun", + "last_name": "Hu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Yituo", + "last_name": "He", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Wenyu", + "last_name": "He", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Haoran", + "last_name": "Li", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Yubo", + "last_name": "Zhao", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Shuai", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Dawu", + "last_name": "Gu", + "institution": "Shanghai Jiao Tong University" + } + ], + "dblp_key": "journals/pacmpl/HuHHLZWG25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720433", + "title": "QbC: Quantum Correctness by Construction", + "abstract": "Thanks to the rapid progress and growing complexity of quantum algorithms, correctness of quantum programs has become a major concern. Pioneering research over the past years has proposed various approaches to formally verify quantum programs using proof systems such as quantum Hoare logic. All these prior approaches are post-hoc: one first implements a program and only then verifies its correctness. Here we propose Quantum Correctness by Construction (QbC): an approach to constructing quantum programs from their specification in a way that ensures correctness. We use pre- and postconditions to specify program properties, and propose sound and complete refinement rules for constructing programs in a quantum while language from their specification. We validate QbC by constructing quantum programs for idiomatic problems and patterns. We find that the approach naturally suggests how to derive program details, highlighting key design choices along the way. As such, we believe that QbC can play a role in supporting the design and taxonomization of quantum algorithms and software.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720433", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anurudh", + "last_name": "Peduri", + "institution": "Ruhr University Bochum" + }, + { + "first_name": "Ina", + "last_name": "Schaefer", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Walter", + "institution": "Ruhr University Bochum" + } + ], + "dblp_key": "journals/pacmpl/PeduriSW25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720457", + "title": "Adequacy for Algebraic Effects Revisited", + "abstract": "This paper proves an adequacy theorem for a general class of algebraic effects, including infinitary ones. The theorem targets a version of Call-by-Push-Value (CBPV), so that it applies to many possible evaluation mechanisms, including call-by-value. The calculus is given an operational semantics based on interaction trees, as well as a denotational semantics based on monad algebras. The main result, viz. that denotational equivalence implies observational equivalence, using a traditional logical relations argument.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720457", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "G. A.", + "last_name": "Kavvos", + "institution": "University of Bristol" + } + ], + "dblp_key": "journals/pacmpl/Kavvos25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720429", + "title": "Foundations for Deductive Verification of Continuous Probabilistic Programs: From Lebesgue to Riemann and Back", + "abstract": "We lay out novel foundations for the computer-aided verification of guaranteed bounds on expected outcomes of imperative probabilistic programs featuring (i) general loops, (ii) continuous distributions, and (iii) conditioning. To handle loops we rely on user-provided quantitative invariants, as is well established. However, in the realm of continuous distributions, invariant verification becomes extremely challenging due to the presence of integrals in expectation-based program semantics. Our key idea is to soundly under- or over-approximate these integrals via Riemann sums. We show that this approach enables the SMT-based invariant verification for programs with a fairly general control flow structure. On the theoretical side, we prove convergence of our Riemann approximations, and establish coRE-completeness of the central verification problems. On the practical side, we show that our approach enables to use existing automated verifiers targeting discrete probabilistic programs for the verification of programs involving continuous sampling. Towards this end, we implement our approach in the recent quantitative verification infrastructure Caesar by encoding Riemann sums in its intermediate verification language. We present several promising case studies.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720429", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "University College London" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Francesca", + "last_name": "Randone", + "institution": "University of Trieste" + }, + { + "first_name": "Tobias", + "last_name": "Winkler", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "journals/pacmpl/BatzKRW25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720427", + "title": "Carapace: Static-Dynamic Information Flow Control in Rust", + "abstract": "Fine-grained information flow control (IFC) ensures confidentiality and integrity at the programming language level by ensuring that high-secrecy values do not affect low-secrecy values and that low-integrity values do not affect high-integrity values. However, prior support for fine-grained IFC is impractical: It either analyzes programs using whole-program static analysis, detecting false IFC violations; or it extends the language and compiler, thwarting adoption. Recent work called Cocoon demonstrates how to provide fine-grained IFC for Rust programs without modifying the language or compiler, but it is limited to static secrecy labels, and its case studies are limited. This paper introduces an approach called Carapace that employs Cocoon’s core approach and supports both static and dynamic IFC and supports both secrecy and integrity. We demonstrate Carapace using three case studies involving real applications and comprehensive security policies. An evaluation shows that applications can be retrofitted to use Carapace with relatively few changes, while incurring negligible run-time overhead in most cases. Carapace advances the state of the art by being the first hybrid static–dynamic IFC that works with an off-the-shelf language—Rust—and its unmodified compiler", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720427", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vincent", + "last_name": "Beardsley", + "institution": "The Ohio State University" + }, + { + "first_name": "Chris", + "last_name": "Xiong", + "institution": "The Ohio State University" + }, + { + "first_name": "Ada", + "last_name": "Lamba", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + } + ], + "dblp_key": "journals/pacmpl/BeardsleyXLB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720437", + "title": "Type-Preserving Flat Closure Optimization", + "abstract": "Type-preserving compilation seeks to make intent as much as a part of compilation as computation. Specifications of intent in the form of types are preserved and exploited during compilation and linking, alongside the mere computation of a program. This provides lightweight guarantees for compilation, optimization, and linking. Unfortunately, type-preserving compilation typically interferes with important optimizations. In this paper, we study typed closure representation and optimization. We analyze limitations in prior typed closure conversion representations, and the requirements of many important closure optimizations. We design a new typed closure representation in our Flat-Closure Calculus (FCC) that admits all these optimizations, prove type safety and subject reduction of FCC, prove type preservation from an existing closure converted IR to FCC, and implement common closure optimizations for FCC.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720437", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adam T.", + "last_name": "Geller", + "institution": "University of British Columbia" + }, + { + "first_name": "Sean", + "last_name": "Bocirnea", + "institution": "University of British Columbia" + }, + { + "first_name": "Chester J. F.", + "last_name": "Gould", + "institution": "University of British Columbia" + }, + { + "first_name": "Paulette", + "last_name": "Koronkevich", + "institution": "University of British Columbia" + }, + { + "first_name": "William J.", + "last_name": "Bowman", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/GellerBGKB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720505", + "title": "Counterexample-Guided Inference of Modular Specifications", + "abstract": "Modular verification tools allow programmers to compositionally specify and prove function specifications. When using a modular verifier, proving a specification about a function f requires additional specifications for the functions called by f . With existing state of the art tools, programmers must manually write the specifications for callee functions. We present a counterexample guided algorithm to automatically infer these specifications. The algorithm is parameterized over a verifier, counterexample generator, and constraint guided synthesizer. We show that if each of these three components is sound and complete over a finite set of possible specifications, our algorithm is sound and complete as well. Additionally, we introduce size-bounded synthesis functions, which extends our completeness result to an infinite set of possible specifications. In particular, we describe a size-bounded synthesis function for linear integer arithmetic constraints. We conclude with an evaluation demonstrating our technique on a variety of benchmarks. When using a modular verifier, proving a specification about a function f requires additional specifications for the functions called by f . With existing state of the art tools, programmers must manually write the specifications for callee functions. We present a counterexample guided algorithm to automatically infer these specifications. The algorithm is parameterized over a verifier, counterexample generator, and constraint guided synthesizer. We show that if each of these three components is sound and complete over a finite set of possible specifications, our algorithm is sound and complete as well. Additionally, we introduce size-bounded synthesis functions, which extends our completeness result to an infinite set of possible specifications. In particular, we describe a size-bounded synthesis function for linear integer arithmetic constraints. We conclude with an evaluation demonstrating our technique on a variety of benchmarks.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720505", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "William T.", + "last_name": "Hallahan", + "institution": "Binghamton University" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/HallahanJP25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720488", + "title": "Artemis: Toward Accurate Detection of Server-Side Request Forgeries through LLM-Assisted Inter-procedural Path-Sensitive Taint Analysis", + "abstract": "Server-side request forgery (SSRF) vulnerabilities are inevitable in PHP web applications. Existing static tools in detecting vulnerabilities in PHP web applications neither contain SSRF-related features to enhance detection accuracy nor consider PHP’s dynamic type features. In this paper, we present Artemis, a static taint analysis tool for detecting SSRF vulnerabilities in PHP web applications. First, Artemis extracts both PHP built-in and third-party functions as candidate source and sink functions. Second, Artemis constructs both explicit and implicit call graphs to infer functions’ relationships. Third, Artemis performs taint analysis based on a set of rules that prevent over-tainting and pauses when SSRF exploitation is impossible. Fourth, Artemis analyzes the compatibility of path conditions to prune false positives. We have implemented a prototype of Artemis and evaluated it on 250 PHP web applications. Artemis reports 207 true vulnerable paths (106 true SSRFs) with 15 false positives. Of the 106 detected SSRFs, 35 are newly found and reported to developers, with 24 confirmed and assigned CVE IDs.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720488", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuchen", + "last_name": "Ji", + "institution": "ShanghaiTech University" + }, + { + "first_name": "Ting", + "last_name": "Dai", + "institution": "IBM (United States)" + }, + { + "first_name": "Zhichao", + "last_name": "Zhou", + "institution": "ShanghaiTech University" + }, + { + "first_name": "Yutian", + "last_name": "Tang", + "institution": "University of Glasgow" + }, + { + "first_name": "Jingzhu", + "last_name": "He", + "institution": "ShanghaiTech University" + } + ], + "dblp_key": "journals/pacmpl/JiDZTH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720498", + "title": "Efficient Algorithms for the Uniform Tokenization Problem", + "abstract": "Tokenization (also known as scanning or lexing) is a computational task that has applications in the lexical analysis of programs during compilation and in data extraction and analysis for unstructured or semi-structured data (e.g., data represented using the JSON and CSV data formats). We propose two algorithms for the tokenization problem that have linear time complexity (in the length of the input text) without using large amounts of memory. We also show that an optimized version of one of these algorithms performs well compared to prior approaches on practical tokenization workloads.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720498", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wu Angela", + "last_name": "Li", + "institution": "Rice University" + }, + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + } + ], + "dblp_key": "journals/pacmpl/LiM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720418", + "title": "JavART: A Lightweight Rule-Based JIT Compiler using Translation Rules Extracted from a Learning Approach", + "abstract": "The balance between the compilation/optimization time and the produced code quality is very important for Just-In-Time (JIT) compilation. Time-consuming optimizations can cause delayed deployment of the optimized code, and thus more execution time needs to be spent either in the interpretation or less optimized code, leading to a performance drag. Such a performance drag can be detrimental to mobile and client-side devices such as those running Android, where applications are often shorting-running, frequently restarted and updated. To tackle this issue, this paper presents a lightweight learning-based, rule-guided dynamic compilation approach to generate good-quality native code directly without the need to go through the interpretive phase and the first-level optimization at runtime. Different from existing JIT compilers, the compilation process is driven by translation rules, which are automatically learned offline by taking advantage of existing JIT compilers. We have implemented a prototype of our approach based on Android 14 to demonstrate the feasibility and effectiveness of such a lightweight rule-based approach using several real-world applications. Results show that, compared to the default mode running with the interpreter and two tiers of JIT compilers, our prototype can achieve a 1.23× speedup on average. Our proposed compilation approach can also generate native code 5.5× faster than the existing first-tier JIT compiler in Android, with the generated code running 6% faster. We also implement and evaluate our approach on a client-side system running Hotspot JVM, and the results show an average of 1.20× speedup.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720418", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hanzhang", + "last_name": "Wang", + "institution": "Fudan University" + }, + { + "first_name": "Wei", + "last_name": "Peng", + "institution": "Fudan University" + }, + { + "first_name": "Wenwen", + "last_name": "Wang", + "institution": "University of Georgia" + }, + { + "first_name": "Yunping", + "last_name": "Lu", + "institution": "Fudan University" + }, + { + "first_name": "Pen-Chung", + "last_name": "Yew", + "institution": "University of Minnesota" + }, + { + "first_name": "Weihua", + "last_name": "Zhang", + "institution": "Fudan University" + } + ], + "dblp_key": "journals/pacmpl/WangPWLYZ25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720507", + "title": "Compiling Classical Sequent Calculus to Stock Hardware: The Duality of Compilation", + "abstract": "Compiler intermediate representations have to strike a balance between being high-level enough to allow for easy translation of surface languages into them and being low-level enough to make code generation easy. An intermediate representation based on a logical system typically has the former property and additionally satisfies several meta-theoretical properties which are valuable when optimizing code. Recently, classical sequent calculus, which is widely recognized and impactful within the fields of logic and proof theory, has been proposed as a natural candidate in this regard, due to its symmetric treatment of data and control flow. For such a language to be useful, however, it must eventually be compiled to machine code. In this paper, we introduce an intermediate representation that is based on classical sequent calculus and demonstrate that this language can be directly translated to conventional hardware. We provide both a formal description and an implementation. Preliminary performance evaluations indicate that our approach is viable.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720507", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Marius", + "last_name": "Müller", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/SchusterMOB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720422", + "title": "Fast Constraint Synthesis for C++ Function Templates", + "abstract": "C++ templates are a powerful feature for generic programming and compile-time computations, but C++ compilers often emit overly verbose template error messages. Even short error messages often involve unnecessary and confusing implementation details, which are difficult for developers to read and understand. To address this problem, C++20 introduced constraints and concepts, which impose requirements on template parameters. The new features can define clearer interfaces for templates and can improve compiler diagnostics. However, manually specifying template constraints can still be non-trivial, which becomes even more challenging when working with legacy C++ projects or with frequent code changes. This paper bridges the gap and proposes an automatic approach to synthesizing constraints for C++ function templates. We utilize a lightweight static analysis to analyze the usage patterns within the template body and summarize them into constraints for each type parameter of the template. The analysis is inter-procedural and uses disjunctions of constraints to model function overloading. We have implemented our approach based on the Clang frontend and evaluated it on two C++ libraries chosen separately from two popular library sets: algorithm from the Standard Template Library (STL) and special functions from the Boost library, both of which extensively use templates. Our tool can process over 110k lines of C++ code in less than 1.5 seconds and synthesize non-trivial constraints for 30%-40% of the function templates. The constraints synthesized for algorithm align well with the standard documentation, and on average, the synthesized constraints can reduce error message lengths by 56.6% for algorithm and 63.8% for special functions.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720422", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shuo", + "last_name": "Ding", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Qirun", + "last_name": "Zhang", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/DingZ25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720497", + "title": "Polymorphic Records for Dynamic Languages", + "abstract": "We study row polymorphism for records types in systems with set-theoretic types, specifically, union, intersection, and negation types. We consider record types that embed row variables and define a subtyping relation by interpreting record types into sets of record values, and row variables into sets of rows , that is, “chunks” of record values where some record keys are left out: subtyping is then containment of the interpretations. We define a λ-calculus equipped with operations for field extension, selection, and deletion, its operational semantics, and a type system that we prove to be sound. We provide algorithms for deciding the typing and subtyping relations, and to decide whether two types can be instantiated to make one subtype of the other. This research is motivated by the current trend of defining static type systems for dynamic languages and, in our case, by an ongoing effort of endowing the Elixir programming language with a gradual type system.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720497", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Loïc", + "last_name": "Peyrot", + "institution": "IMDEA Software Institute" + } + ], + "dblp_key": "journals/pacmpl/CastagnaP25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720525", + "title": "Lilo: A Higher-Order, Relational Concurrent Separation Logic for Liveness", + "abstract": "Concurrent separation logic (CSL) has excelled in verifying safety properties across various applications, yet its application to liveness properties remains limited. While existing approaches like TaDA Live and Fair Operational Semantics (FOS) have made significant strides, they still face limitations. TaDA Live struggles to verify certain classes of programs, particularly concurrent objects with non-local linearization points, and lacks support for general liveness properties such as \"good things happen infinitely often\". On the other hand, FOS’s scalability is hindered by the absence of thread modular reasoning principles and modular specifications. This paper introduces Lilo, a higher-order, relational CSL designed to overcome these limitations. Our core observation is that FOS helps us to maintain simple primitives for our logic, which enable us to explore design space with fewer restrictions. As a result, Lilo adapts various successful techniques from literature. It supports reasoning about non-terminating programs by supporting refinement proofs, and also provides Iris-style invariants and modular specifications to facilitate modular verification. To support higher-order reasoning without relying on step-indexing, we develop a technique called stratified propositions inspired by Nola. In particular, we develop novel abstractions for liveness reasoning that bring these techniques together in a uniform way. We show Lilo’s scalability through case studies, including the first termination-guaranteeing modular verification of the elimination stack. Lilo and examples in this paper are mechanized in Coq.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720525", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dongjae", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Janggun", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Tae‐Hoon", + "last_name": "Yoon", + "institution": "Seoul National University" + }, + { + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/LeeLYCKH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720428", + "title": "Unveiling Heisenbugs with Diversified Execution", + "abstract": "Heisenbugs, notorious for their ability to change behavior and elude reproducibility under observation, are among the toughest challenges in debugging programs. They often evade static detection tools, making them especially prevalent in cyber-physical edge systems characterized by complex dynamics and unpredictable interactions with physical environments. Although dynamic detection tools work much better, most still struggle to meet low enough jitter and overhead performance requirements, impeding their adoption. More importantly however, dynamic tools currently lack metrics to determine an observed bug's \"difficulty\" or \"heisen-ness\" undermining their ability to make any claims regarding their effectiveness against heisenbugs. This paper proposes a methodology for detecting and identifying heisenbugs with low overheads at scale, actualized through the lens of dynamic data-race detection. In particular, we establish the critical impact of execution diversity across both instrumentation density and hardware platforms for detecting heisenbugs; the benefits of which outweigh any reduction in efficiency from limited instrumentation or weaker devices. We develop an experimental WebAssembly-backed dynamic data-race detection framework, Beanstalk, which exploits this diversity to show superior bug detection capability compared to any homogeneous instrumentation strategy on a fixed compute budget. Beanstalk's approach also gains power with scale, making it suitable for low-overhead deployments across numerous compute nodes. Finally, based on a rigorous statistical treatment of bugs observed by Beanstalk, we propose a novel metric, the heisen factor, that similar detectors can utilize to categorize heisenbugs and measure effectiveness. We reflect on our analysis of Beanstalk to provide insight on effective debugging strategies for both in-house and in deployment settings.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720428", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arjun", + "last_name": "Ramesh", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Tianshu", + "last_name": "Huang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jaspreet", + "last_name": "Riar", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ben L.", + "last_name": "Titzer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Anthony", + "last_name": "Rowe", + "institution": "Robert Bosch (United States)" + } + ], + "dblp_key": "journals/pacmpl/RameshHRTR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720513", + "title": "Peepco: Batch-Based Consistency Optimization", + "abstract": "We present batch-based consistency, a new approach for consistency optimization that allows programmers to specialize consistency with application-level integrity properties. We implement the approach with a two-step process: we statically infer optimal consistency requirements for executions of bounded sets of operations, and then, use the inferred requirements to parameterize a new distributed protocol to relax operation reordering at run time when it is safe to do so. Our approach supports standard notions of consistency. We implement batch-based consistency in Peepco, demonstrate its expressiveness for partial data replication, and examine Peepco’s run-time performance impact in different settings.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720513", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivan", + "last_name": "Kuraj", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "John", + "last_name": "Feser", + "institution": "BASIS International (United States)" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + }, + { + "first_name": "Armando", + "last_name": "Solar-Lezama", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KurajFPS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720416", + "title": "Dependency-Aware Compilation for Surface Code Quantum Architectures", + "abstract": "Practical applications of quantum computing depend on fault-tolerant devices with error correction. We study the problem of compiling quantum circuits for quantum computers implementing surface codes. Optimal or near-optimal compilation is critical for both efficiency and correctness. The compilation problem requires (1) mapping circuit qubits to the device qubits and (2) routing execution paths between interacting qubits. We solve this problem efficiently and near-optimally with a novel algorithm that exploits the dependency structure of circuit operations to formulate discrete optimization problems that can be approximated via simulated annealing , a classic and simple algorithm. Our extensive evaluation shows that our approach is powerful and flexible for compiling realistic workloads.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720416", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Abtin", + "last_name": "Molavi", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Amanda", + "last_name": "Xu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Swamit", + "last_name": "Tannu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/MolaviXTA25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720472", + "title": "The Simple Essence of Monomorphization", + "abstract": "Monomorphization is a common implementation technique for parametric type-polymorphism, which avoids the potential runtime overhead of uniform representations at the cost of code duplication. While important as a folklore implementation technique, there is a lack of general formal treatments in the published literature. Moreover, it is commonly believed to be incompatible with higher-rank polymorphism. In this paper, we formally present a simple monomorphization technique based on a type-based flow analysis that generalizes to programs with higher-rank types, existential types, and arbitrary combinations. Inspired by algebraic subtyping, we track the flow of type instantiations through the program. Our approach only supports monomorphization up to polymorphic recursion, which we uniformly detect as cyclic flow. Treating universal and existential quantification uniformly, we identify a novel form of polymorphic recursion in the presence of existential types, which we coin polymorphic packing. We study the meta-theory of our approach, showing that our translation is type-preserving and preserves semantics step-wise.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720472", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Lutze", + "institution": "Aarhus University" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/LutzeSB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720436", + "title": "IncIDFA: An Efficient and Generic Algorithm for Incremental Iterative Dataflow Analysis", + "abstract": "Iterative dataflow analyses (IDFAs) are important static analyses employed by tools like compilers for enabling program optimizations, comprehension, verification, and more. During compilation of a program, optimizations/transformations can render existing dataflow solutions stale, jeopardizing the optimality and correctness of subsequent compiler passes. Exhaustively recomputing these solutions can be costly. Since most program changes impact only small portions of the flowgraph, several incrementalization approaches have been proposed for various subclasses of IDFAs. However, these approaches face one or more of these limitations: (i) loss of precision compared to exhaustive analysis, (ii) inability to handle arbitrary lattices and dataflow functions, and (iii) lacking fully automated incrementalization of the IDFA. As a result, mainstream compilers lack frameworks for generating precise incremental versions of arbitrary IDFAs, leaving analysis writers to create ad hoc algorithms for incrementalization – an often cumbersome and error-prone task. To tackle these challenges, we introduce IncIDFA, a novel algorithm that delivers precise and efficient incremental variants of any monotone IDFA. IncIDFA utilizes a two-pass approach to maintain precision. Unlike prior works, IncIDFA avoids resetting the dataflow solutions to least informative values when dealing with strongly-connected regions and arbitrary program changes. We formally prove the precision guarantees of IncIDFA for arbitrary dataflow problems and program changes. IncIDFA has been implemented in the IMOP compiler framework for parallel OpenMP C programs. To showcase its generality, we have instantiated IncIDFA to ten specific dataflow analyses, without requiring any additional code for incrementalization. We present an evaluation of IncIDFA on a real-world set of optimization passes, across two different architectures. As compared to exhaustive recomputation, IncIDFA resulted in a speedup of up to 11×(geomean 2.6×) in incremental-update time, and improvement of up to 46% (geomean 15.1%) in the total compilation time.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720436", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aman", + "last_name": "Nougrahiya", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "journals/pacmpl/NougrahiyaN25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720506", + "title": "Compressed and Parallelized Structured Tensor Algebra", + "abstract": "Tensor algebra is a crucial component for data-intensive workloads such as machine learning and scientific computing. As the complexity of data grows, scientists often encounter a dilemma between the highly specialized dense tensor algebra and efficient structure-aware algorithms provided by sparse tensor algebra. In this paper, we introduce DASTAC, a framework to propagate the tensors's captured high-level structure down to low-level code generation by incorporating techniques such as automatic data layout compression, polyhedral analysis, and affine code generation. Our methodology reduces memory footprint by automatically detecting the best data layout, heavily benefits from polyhedral optimizations, leverages further optimizations, and enables parallelization through MLIR. Through extensive experimentation, we show that DASTAC can compete if not significantly outperform specialized hand-tuned implementation by experts. We observe 0.16x - 44.83x and 1.37x - 243.78x speed-up for single- and multi-threaded cases, respectively.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720506", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mahdi", + "last_name": "Ghorbani", + "institution": "University of Edinburgh" + }, + { + "first_name": "Emilien", + "last_name": "Bauer", + "institution": "University of Edinburgh" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Cambridge" + }, + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "journals/pacmpl/GhorbaniBGS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720478", + "title": "HpC: A Calculus for Hybrid and Mobile Systems", + "abstract": "Networked cybernetic and physical systems of the Internet of Things (IoT) immerse civilian and industrial infrastructures into an interconnected and dynamic web of hybrid and mobile devices. The key feature of such systems is the hybrid and tight coupling of mobile and pervasive discrete communications in a continuously evolving environment (discrete computations with predominant continuous dynamics). In the aim of ensuring the correctness and reliability of such heterogeneous infrastructures, we introduce the hybrid π-calculus (HpC), to formally capture both mobility, pervasiveness and hybridisation in infrastructures where the network topology and its communicating entities evolve continuously in the physical world. The π-calculus proposed by Robin Milner et al. is a process calculus that can model mobile communications and computations in a very elegant manner. The HpC we propose is a conservative extension of the classical π-calculus, i.e., the extension is “minimal”, and yet describes mobility, time and physics of systems, while allowing to lift all theoretical results (e.g. bisimulation) to the context of that extension. We showcase the HpC by considering a realistic handover protocol among mobile devices.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720478", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Xiong", + "last_name": "Xu", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Jean-Pierre", + "last_name": "Talpin", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Shuling", + "last_name": "Wang", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Hao", + "last_name": "Wu", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Bohua", + "last_name": "Zhan", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Xinxin", + "last_name": "Liu", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Naijun", + "last_name": "Zhan", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/XuTWWZLZ25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720486", + "title": "Revealing Sources of (Memory) Errors via Backward Analysis", + "abstract": "Sound over-approximation methods are effective for proving the absence of errors, but inevitably produce false alarms that can hamper programmers. In contrast, under-approximation methods focus on bug detection and are free from false alarms. In this work, we present two novel proof systems designed to locate the source of errors via backward under-approximation, namely Sufficient Incorrectness Logic (SIL) and its specialization for handling memory errors, called Separation SIL. The SIL proof system is minimal, sound and complete for Lisbon triples, enabling a detailed comparison of triple-based program logics across various dimensions, including negation, approximation, execution order, and analysis objectives. More importantly, SIL lays the foundation for our main technical contribution, by distilling the inference rules of Separation SIL, a sound and (relatively) complete proof system for automated backward reasoning in programs involving pointers and dynamic memory allocation. The completeness result for Separation SIL relies on a careful crafting of both the assertion language and the rules for atomic commands.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720486", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Flavio", + "last_name": "Ascari", + "institution": "University of Pisa" + }, + { + "first_name": "Roberto", + "last_name": "Bruni", + "institution": "University of Pisa" + }, + { + "first_name": "Roberta", + "last_name": "Gori", + "institution": "University of Pisa" + }, + { + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Meta (United States)" + } + ], + "dblp_key": "journals/pacmpl/AscariBGL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720524", + "title": "Bridging the Gap between Real-World and Formal Binary Lifting through Filtered-Simulation", + "abstract": "Binary lifting is a key component in binary analysis tools. In order to guarantee the correctness of binary lifting, researchers have proposed various formally verified lifters. However, such formally verified lifters have too strict requirements on binary, which do not sufficiently reflect real-world lifters. In addition, real-world lifters use heuristic-based assumptions to lift binary code, which makes it difficult to guarantee the correctness of the lifted code using formal methods. In this paper, we propose a new interpretation of the correctness of real-world binary lifting. We formalize the process of binary lifting with heuristic-based assumptions used in real-world lifters by dividing it into a series of transformations, where each transformation represents a lift with new abstraction features. We define the correctness of each transformation as filtered-simulation , which is a variant of bi-simulation, between programs before and after transformation. We present three essential transformations in binary lifting and formalize them: (1) control flow graph reconstruction, (2) abstract stack reconstruction, and (3) function input/output identification. We implement our approach for x86-64 Linux binaries, named FIBLE, and demonstrate that it can correctly lift Coreutils and CGC datasets compiled with GCC.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720524", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ji-Hee", + "last_name": "Park", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Insu", + "last_name": "Yun", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ParkYR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720502", + "title": "Bolt-On Strong Consistency: Specification, Implementation, and Verification", + "abstract": "Strongly-consistent replicated data stores are a popular foundation for many kinds of online services, but their implementations are very complex. Strong replication is not available under network partitions, and so achieving a functional degree of fault-tolerance requires correctly implementing consensus algorithms like Raft and Paxos. These algorithms are notoriously difficult to reason about, and many data stores implement custom variations to support unique performance tradeoffs, presenting an opportunity for automated verification tools. Unfortunately, existing tools that have been applied to distributed consensus demand too much developer effort, a problem stemming from the low-level programming model in which consensus and strong replication are implemented—asynchronous message passing—which thwarts decidable automation by exposing the details of asynchronous communication. In this paper, we consider the implementation and automated verification of strong replication systems as applications of weak replicated data stores. Weak stores, being available under partition, are a suitable foundation for performant distributed applications. Crucially, they abstract asynchronous communication and allow us to derive local-scope conditions for the verification of consensus safety. To evaluate this approach, we have developed a verified-programming framework for the weak replicated state model, called Super-V. This framework enables SMT-based verification based on local-scope artifacts called stable update preconditions , replacing standard-practice global inductive invariants. We have used our approach to implement and verify a strong replication system based on an adaptation of the Raft consensus algorithm.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720502", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nicholas V.", + "last_name": "Lewchenko", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "journals/pacmpl/LewchenkoKC25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720447", + "title": "FO-Complete Program Verification for Heap Logics", + "abstract": "Program verification techniques for expressive heap logics are inevitably incomplete. In this work we argue that algorithmic techniques for reasoning with expressive heap logics can be held up to a different robust theoretical standard for completeness: FO-Completeness. FO-completeness is a theoretical guarantee that all theorems that are valid when recursive definitions are interpreted as fixpoint definitions (instead of least fixpoint) are guaranteed to be eventually proven by the system. We illustrate a set of principles to design such logics and develop the first two heap logics that have implicit heaplets and that admit FO-Complete program verification. The logics we develop are a frame logic (FL) and a separation logic (SL-FL) that has an alternate semantics inspired by frame logic. We show a verification condition generation technique that is amenable to FO-complete reasoning using quantifier instantiation and SMT solvers. We implement tools that realize our technique and show the expressiveness of our logics and the efficacy of the verification technique on a suite of benchmarks that manipulate data structures.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720447", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Hrishikesh", + "last_name": "Balakrishnan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Aaron", + "last_name": "Councilman", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MuraliBCM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720504", + "title": "Checking Observational Correctness of Database Systems", + "abstract": "Clients rely on database systems to be correct, which requires the system not only to implement transactions’ semantics correctly but also to provide isolation guarantees for the transactions. This paper presents a client-centric technique for checking both semantic correctness and isolation-level guarantees for black-box database systems based on observations collected from running transactions on these systems. Our technique verifies observational correctness with respect to a given set of transactions and observations for them, which holds iff there exists a possible correct execution of the transactions under a given isolation level that could result in these observations. Our technique relies on novel symbolic encodings of (1) the semantic correctness of database transactions in the presence of weak isolation and (2) isolation-level guarantees. These are used by the checker to query a Satisfiability Modulo Theories solver. We applied our tool Troubadour to verify observational correctness of several database systems, including PostgreSQL and an industrial system under development, in which the tool helped detect two new bugs. We also demonstrate that Troubadour is able to find known semantic correctness bugs and detect isolation-related anomalies.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720504", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lauren", + "last_name": "Pick", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Amanda", + "last_name": "Xu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Ankush", + "last_name": "Desai", + "institution": "Amazon (United States)" + }, + { + "first_name": "Sanjit A.", + "last_name": "Seshia", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/PickXDSA25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720421", + "title": "Code Style Sheets: CSS for Code", + "abstract": "Program text is rendered using impoverished typographic styles. Beyond choice of fonts and syntax-highlighting colors, code editors and related tools utilize very few text decorations. These limited styles are, furthermore, applied in monolithic fashion, regardless of the programs and tasks at hand. We present the notion of _code style sheets_ for styling program text. Motivated by analogy to cascading style sheets (CSS) for styling HTML documents, code style sheets provide mechanisms for defining rules to select elements from an abstract syntax tree (AST) in order to style their corresponding visual representation. Technically, our selector language generalizes essential constructs from CSS to a programming-language setting with algebraic data types (such as ASTs). Practically, code style sheets allow ASTs to be styled granularly, based on semantic information—such as the structure of abstract syntax, static type information, and corresponding run-time values—as well as design choices on the part of authors and readers of a program. Because programs are heavily nested in structure, a key aspect of our design is a layout algorithm that renders nested, multiline text blocks more compactly than in existing box-based layout systems such as HTML. In this paper, we design and implement a code style sheets system for a subset of Haskell, using it to illustrate several code presentation and visualization tasks. These examples demonstrate that code style sheets provide a uniform framework for rendering programs in multivarious ways, which could be employed in future designs for text-based as well as structure editors.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720421", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sam", + "last_name": "Cohen", + "institution": "University of Chicago" + }, + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of Chicago" + } + ], + "dblp_key": "journals/pacmpl/CohenC25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720432", + "title": "A Mechanized Semantics for Dataflow Circuits", + "abstract": "This paper proposes a mechanized formal semantics for dataflow circuits: rather than following a predetermined, static schedule, the execution of the circuit components is constrained solely by the availability of their input data. We model circuit components as abstract computing units, asynchronously connected with each other through unidirectional, unbounded FIFO. In contrast to Kahn’s classic, denotational semantic framework, our semantics is operational. It intends to reflect Dennis’ dataflow paradigm with firing, while still formalizing the observable behaviors of circuits as channels histories. The components we handle are either stateless or stateful, and may be non-deterministic. We formalize sufficient conditions to achieve the determinacy of circuits executions: all possible schedules of such circuits lead to a unique observable behavior. We provide two equivalent views for circuits. The first one is a direct and natural representation as graphs of components. The second is a core, structured term calculus, which enables constructing and reasoning about circuits in a inductive way. We prove that both representations are semantically equivalent. We conduct our formalization within the Coq proof assistant. We experimentally validate its relevance by applying our general semantic framework to dataflow circuits generated with Dynamatic, a recent HLS tool exploiting dataflow circuits to generate dynamically scheduled, elastic circuits.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720432", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tony", + "last_name": "Law", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Delphine", + "last_name": "Demange", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/LawDB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720426", + "title": "QED in Context: An Observation Study of Proof Assistant Users", + "abstract": "Interactive theorem provers, or proof assistants, are important tools across many areas of computer science and mathematics, but even experts find them challenging to use effectively. To improve their design, we need a deeper, user-centric understanding of proof assistant usage. We present the results of an observation study of proof assistant users. We use contextual inquiry methodology, observing 30 participants doing their everyday work in Rocq and Lean. We qualitatively analyze their experiences to surface four observations: that proof writers iterate on their proofs by reacting to and incorporating feedback from the proof assistant; that proof progress often involves challenging conversations with the proof assistant; that proofs are constructed in consultation with a wide array of external resources; and that proof writers are guided by design considerations that go beyond \"getting to QED.\" Our documentation of these themes clarifies what proof assistant usage looks like currently and identifies potential opportunities that researchers should consider when working to improve the usability of proof assistants.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720426", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jessica", + "last_name": "Shi", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Cassia", + "last_name": "Torczon", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Harrison", + "last_name": "Goldstein", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Andrew", + "last_name": "Head", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/ShiTGPH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720414", + "title": "A Complete Formal Semantics of eBPF Instruction Set Architecture for Solana", + "abstract": "We present the first formal semantics for the Solana eBPF bytecode language used in smart contracts on the Solana blockchain platform. Our formalization accurately captures all binary-level instructions of the Solana eBPF instruction set architecture. This semantics is structured in a small-step style, facilitating the formalization of the Solana eBPF interpreter within Isabelle/HOL. We provide a semantics validation framework that extracts an executable semantics from our formalization to test against the original implementation of the Solana eBPF interpreter. This approach introduces a novel lightweight and non-invasive method to relax the limitations of the existing Isabelle/HOL extraction mechanism. Furthermore, we illustrate potential applications of our semantics in the formalization of the main components of the Solana eBPF virtual machine.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720414", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shenghao", + "last_name": "Yuan", + "institution": "Zhejiang University" + }, + { + "first_name": "Zhuoruo", + "last_name": "Zhang", + "institution": "Zhejiang University" + }, + { + "first_name": "Jiandong", + "last_name": "lu", + "institution": "Zhejiang University" + }, + { + "first_name": "David", + "last_name": "Sanán", + "institution": "Singapore Institute of Technology" + }, + { + "first_name": "Rui", + "last_name": "Chang", + "institution": "Zhejiang University" + }, + { + "first_name": "Yongwang", + "last_name": "Zhao", + "institution": "Zhejiang University" + } + ], + "dblp_key": "journals/pacmpl/YuanZLSCZ25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720473", + "title": "Finch: Sparse and Structured Tensor Programming with Control Flow", + "abstract": "From FORTRAN to NumPy, tensors have revolutionized how we express computation. However, tensors in these, and almost all prominent systems, can only handle dense rectilinear integer grids. Real world tensors often contain underlying structure, such as sparsity, runs of repeated values, or symmetry. Support for structured data is fragmented and incomplete. Existing frameworks limit the tensor structures and program control flow they support to better simplify the problem. In this work, we propose a new programming language, Finch, which supports both flexible control flow and diverse data structures. Finch facilitates a programming model which resolves the challenges of computing over structured tensors by combining control flow and data structures into a common representation where they can be co-optimized. Finch automatically specializes control flow to data so that performance engineers can focus on experimenting with many algorithms. Finch supports a familiar programming language of loops, statements, ifs, breaks, etc., over a wide variety of tensor structures, such as sparsity, run-length-encoding, symmetry, triangles, padding, or blocks. Finch reliably utilizes the key properties of structure, such as structural zeros, repeated values, or clustered non-zeros. We show that this leads to dramatic speedups in operations such as SpMV and SpGEMM, image processing, and graph analytics.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720473", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Willow", + "last_name": "Ahrens", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Teodoro Fields", + "last_name": "Collin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Radha", + "last_name": "Patel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Kyle", + "last_name": "Deeds", + "institution": "University of Washington" + }, + { + "first_name": "Changwan", + "last_name": "Hong", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/AhrensCPDHA25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720430", + "title": "Pathological Cases for a Class of Reachability-Based Garbage Collectors", + "abstract": "Although existing garbage collectors (GCs) perform extremely well on typical programs, there still exist pathological programs for which modern GCs significantly degrade performance. This observation begs the question: might there exist a ‘holy grail’ GC algorithm, as yet undiscovered, guaranteeing both constant-length pause times and that memory is collected promptly upon becoming unreachable? For decades, researchers have understood that such a GC is not always possible, i.e., some pathological behavior is unavoidable when the program can make heap cycles and operates near the memory limit, regardless of the GC algorithm used. However, this understanding has until now been only informal, lacking a rigorous formal proof. This paper complements that informal understanding with a rigorous proof, showing with mathematical certainty that every GC algorithm that can implement a realistic mutator-observer interface has some pathological program that forces it to either introduce a long GC pause into program execution or reject an allocation even though there is available space. Hence, language designers must either accept these pathological scenarios and design heuristic approaches that minimize their impact (e.g., generational collection), or restrict programs and environments to a strict subset of the behaviors allowed by our mutator-observer–style interface (e.g., by enforcing a type system that disallows cycles or overprovisioning memory). We do not expect this paper to have any effect on garbage collection practice. Instead, it provides the first mathematically rigorous answers to these interesting questions about the limits of garbage collection. We do so via rigorous reductions between GC and the dynamic graph connectivity problem in complexity theory, so future algorithms and lower bounds from either community transfer to the other via our reductions. We end by describing how to adapt techniques from the graph data structures community to build a garbage collector making worst-case guarantees that improve performance on our motivating, pathologically memory-constrained scenarios, but in practice find too much overhead to recommend for typical use.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720430", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Sotoudeh", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/Sotoudeh25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720471", + "title": "Verification of Bit-Flip Attacks against Quantized Neural Networks", + "abstract": "In the rapidly evolving landscape of neural network security, the resilience of neural networks against bit-flip attacks (i.e., an attacker maliciously flips an extremely small amount of bits within its parameter storage memory system to induce harmful behavior), has emerged as a relevant area of research. Existing studies suggest that quantization may serve as a viable defense against such attacks. Recognizing the documented susceptibility of real-valued neural networks to such attacks and the comparative robustness of quantized neural networks (QNNs), in this work, we introduce BFAVerifier, the first verification framework designed to formally verify the absence of bit-flip attacks against QNNs or to identify all vulnerable parameters in a sound and rigorous manner. BFAVerifier comprises two integral components: an abstraction-based method and an MILP-based method. Specifically, we first conduct a reachability analysis with respect to symbolic parameters that represent the potential bit-flip attacks, based on a novel abstract domain with a sound guarantee. If the reachability analysis fails to prove the resilience of such attacks, then we encode this verification problem into an equivalent MILP problem which can be solved by off-the-shelf solvers. Therefore, BFAVerifier is sound, complete, and reasonably efficient. We conduct extensive experiments, which demonstrate its effectiveness and efficiency across various activation functions, quantization bit-widths, and adversary capabilities.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720471", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yedi", + "last_name": "Zhang", + "institution": "National University of Singapore" + }, + { + "first_name": "Lei", + "last_name": "Huang", + "institution": "ShanghaiTech University" + }, + { + "first_name": "Pengfei", + "last_name": "Gao", + "institution": "" + }, + { + "first_name": "Fu", + "last_name": "Song", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Jun", + "last_name": "Sun", + "institution": "Singapore Management University" + }, + { + "first_name": "Jin Song", + "last_name": "Dong", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/ZhangHGSSD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720470", + "title": "LOUD: Synthesizing Strongest and Weakest Specifications", + "abstract": "This paper tackles the problem of synthesizing specifications for nondeterministic programs. For such programs, useful specifications can capture demonic properties, which hold for every nondeterministic execution, but also angelic properties, which hold for some nondeterministic execution. We build on top of a recently proposed Spyro framework in which given (i) a quantifier-free query Ψ posed about a set of function definitions (i.e., the behavior for which we want to generate a specification), and (ii) a language L in which each extracted property is to be expressed (we call properties in the language L -properties), the goal is to synthesize a conjunction ∧ i ϕ i of L -properties such that each of the ϕ i is a strongest L -consequence for Ψ: ϕ i is an over-approximation of Ψ and there is no other L -property that over-approximates Ψ and is strictly more precise than ϕ i . This framework does not apply to nondeterministic programs for two reasons: it does not support existential quantifiers in queries (which are necessary to expressing nondeterminism) and it can only compute L -consequences, i.e., it is unsuitable for capturing both angelic and demonic properties. This paper addresses these two limitations and presents a framework, LOUD, for synthesizing both strongest L -consequences and weakest L -implicants (i.e., under-approximations of the query Ψ) for queries that can involve existential quantifiers . We implement a solver, ASPIRE, for problems expressed in LOUD which can be used to describe and identify sources of bugs in both deterministic and nondeterministic programs, extract properties from concurrent programs, and synthesize winning strategies in two-player games.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720470", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kanghee", + "last_name": "Park", + "institution": "" + }, + { + "first_name": "Xiaosong", + "last_name": "Peng", + "institution": "" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/ParkPD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763050", + "title": "Exploring the Theory and Practice of Concurrency in the Entity-Component-System Pattern", + "abstract": "The Entity-Component-System (ECS) software design pattern, long used in game development, encourages a clean separation of identity (entities), data properties (components), and computational behaviors (systems). Programs written using the ECS pattern are naturally concurrent, and the pattern offers modularity, flexibility, and performance benefits that have led to a proliferation of ECS frameworks. Nevertheless, the ECS pattern is little-known and not well understood outside of a few domains. Existing explanations of the ECS pattern tend to be mired in the concrete details of particular ECS frameworks, or they explain the pattern in terms of imperfect metaphors or in terms of what it is not. We seek a rigorous understanding of the ECS pattern via the design of a formal model, Core ECS, that abstracts away the details of specific implementations to reveal the essence of software using the ECS pattern. We identify a class of Core ECS programs that behave deterministically regardless of scheduling, enabling use of the ECS pattern as a deterministic-by-construction concurrent programming model. With Core ECS as a point of comparison, we then survey several real-world ECS frameworks and find that they all leave opportunities for deterministic concurrency unexploited. Our findings point out a space for new ECS implementation techniques that better leverage such opportunities.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763050", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Redmond", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Jonathan", + "last_name": "Castello", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "José Manuel Calderón", + "last_name": "Trilla", + "institution": "" + }, + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "journals/pacmpl/RedmondCTK25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763051", + "title": "Quantified Underapproximation via Labeled Bunches", + "abstract": "Given the high cost of formal verification, a large system may include differently analyzed components: a few are fully verified, and the rest are tested. Currently, there is no reasoning system that can soundly compose these heterogeneous analyses and derive the overall formal guarantees of the entire system. The traditional compositional reasoning technique—rely-guarantee reasoning—is effective for verified components, which undergo over-approximated reasoning, but not for those components that undergo under-approximated reasoning, e.g., using testing or other program analysis techniques. The goal of this paper is to develop a formal, logical foundation for composing heterogeneous analysis, deploying both over-approximated (verification) and under-approximated (testing) reasoning. We focus on systems that can be modeled as a collection of communicating processes. Each process owns its internal resources and a set of channels through which it communicates with other processes. The key idea is to quantify the guarantees obtained about the behavior of a process as a test level, which captures the constraints under which this guarantee is analyzed to be true. We design a novel proof system LabelBI based on the logic of bunched implications that enables rely-guarantee reasoning principles for a system of differently analyzed components. We develop trace semantics for this logic, against which we prove our logic is sound. We also prove cut elimination of our sequent calculus. We demonstrate the expressiveness of our logic via a case study.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763051", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Lang", + "last_name": "Liu", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Farzaneh", + "last_name": "Derakhshan", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Gabriel A.", + "last_name": "Moreno", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Mark", + "last_name": "Klein", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/LiuD0M025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763052", + "title": "Pyrosome: Verified Compilation for Modular Metatheory", + "abstract": "We present Pyrosome, a generic framework for modular language metatheory that embodies a novel approach to extensible semantics and compilation, implemented in Coq. Common techniques for semantic reasoning are often tied to the specific structures of the languages and compilers that they support. Contextual equivalence is difficult to work with directly, and both logical relations and transition system-based approaches typically fix a specific notion of effect globally. While modular transition systems have been effective in imperative settings, they are suboptimal for functional code. These limitations restrict the extension and composition of semantics in these systems. In Pyrosome, verified compilers are fully extensible, meaning that to extend a language simply requires defining and verifying the compilation of the new feature, reusing the old correctness theorem for all other cases. The novel enabling idea is an inductive formulation of equivalence preservation that supports the addition of new rules to the source language, target language, and compiler. Pyrosome defines a formal, deeply embedded notion of programming languages with semantics given by dependently sorted equational theories, so all compiler-correctness proofs boil down to type-checking and equational reasoning. We support vertical composition of any compilers expressed in our framework in addition to feature extension. Since our design requires compilers to support open programs, our correctness guarantees support linking with any target code of the appropriate type. As a case study, we present a multipass compiler from System F with simple references, through CPS translation and closure conversion. Specifically, we demonstrate how we can build such a compiler incrementally by starting with a compiler for simply typed lambda-calculus and adding natural numbers, the unit type, recursive functions, and a global heap, then extending judgments with a type environment and adding type abstraction, all while reusing the original theorems. We also present a linear version of the simply typed CPS pass and compile a small imperative language to the simply typed target to show how Pyrosome handles substructural typing and imperative features.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763052", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dustin", + "last_name": "Jamner", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Gabriel", + "last_name": "Kammer", + "institution": "Intel (United States)" + }, + { + "first_name": "Ritam", + "last_name": "Nag", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/JamnerKNC25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763054", + "title": "Static Inference of Regular Grammars for Ad Hoc Parsers", + "abstract": "Parsing—the process of structuring a linear representation according to a given grammar—is a fundamental activity in software engineering. While formal language theory has provided theoretical foundations for parsing, the most common kind of parsers used in practice are written ad hoc. They use common string operations without explicitly defining an input grammar. These ad hoc parsers are often intertwined with application logic and can result in subtle semantic bugs. Grammars, which are complete formal descriptions of input languages, can enhance program comprehension, facilitate testing and debugging, and provide formal guarantees for parsing code. But writing grammars—e.g., in the form of regular expressions—can be tedious and error-prone. Inspired by the success of type inference in programming languages, we propose a general approach for static inference of regular input string grammars from unannotated ad hoc parser source code. We use refinement type inference to synthesize logical and string constraints that represent regular parsing operations, which we then interpret with an abstract semantics into regular expressions. Our contributions include a core calculus λ Σ for representing ad hoc parsers, a formulation of (regular) grammar inference as refinement inference, an abstract interpretation framework for solving string refinement variables, and a set of abstract domains for efficiently representing the constraints encountered during regular ad hoc parsing. We implement our approach in the PANINI system and evaluate its efficacy on a benchmark of 204 Python ad hoc parsers. Compared with state-of-the-art approaches, PANINI produces better grammars (100% precision, 93% average recall) in less time (0.82 ± 2.85 s) without prior knowledge of the input space.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763054", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "Schröder", + "institution": "TU Wien" + }, + { + "first_name": "Jürgen", + "last_name": "Cito", + "institution": "TU Wien" + } + ], + "dblp_key": "journals/pacmpl/0005C25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763057", + "title": "Liberating Merges via Apartness and Guarded Subtyping", + "abstract": "The merge operator is a powerful construct in programming languages, enabling flexible composition of various components such as functions, records, or classes. Unfortunately, its application often leads to ambiguity and non-determinism, especially when dealing with overlapping types. To prevent ambiguity, approaches such as disjoint intersection types have been proposed. However, disjointness imposes strict constraints to ensure determinism, at the cost of limiting expressiveness, particularly for function overloading. This paper introduces a novel concept called type apartness , which relaxes the strict disjointness constraints, while maintaining type safety and determinism. Type apartness allows some overlap for overloaded functions as long as the calling contexts of those functions can be used to disambiguate upcasts in function calls. By incorporating the notion of guarded subtyping to prevent ambiguity when upcasting, our approach is the first to support function overloading , return type overloading , extensible records , and nested composition in a single calculus while preserving determinism. We formalize our calculi and proofs using Coq and prove their type soundness and determinism. Additionally, we demonstrate how type normalization and type difference provide more convenience and help resolve conflicts, enhancing the flexibility and expressiveness of the merge operator.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763057", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Han", + "last_name": "Xu", + "institution": "Princeton University" + }, + { + "first_name": "Xuejing", + "last_name": "Huang", + "institution": "Université Paris Cité" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/0004HO25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763056", + "title": "Compositional Quantum Control Flow with Efficient Compilation in Qunity", + "abstract": "Most existing quantum programming languages are based on the quantum circuit model of computation, as higher-level abstractions are particularly challenging to implement—especially ones relating to quantum control flow. The Qunity language, proposed by Voichick et al., offered such an abstraction in the form of a quantum control construct, with great care taken to ensure that the resulting language is still realizable. However, Qunity lacked a working implementation, and the originally proposed compilation procedure was very inefficient, with even simple quantum algorithms compiling to unreasonably large circuits. In this work, we focus on the efficient compilation of high-level quantum control flow constructs, using Qunity as our starting point. We introduce a wider range of abstractions on top of Qunity's core language that offer compelling trade-offs compared to its existing control construct. We create a complete implementation of a Qunity compiler, which converts high-level Qunity code into the quantum assembly language OpenQASM 3. We develop optimization techniques for multiple stages of the Qunity compilation procedure, including both low-level circuit optimizations as well as methods that consider the high-level structure of a Qunity program, greatly reducing the number of qubits and gates used by the compiler.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763056", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mikhail", + "last_name": "Mints", + "institution": "California Institute of Technology" + }, + { + "first_name": "Finn", + "last_name": "Voichick", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Robert W.", + "last_name": "Rand", + "institution": "University of Chicago" + } + ], + "dblp_key": "journals/pacmpl/MintsVL025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3720510", + "title": "Show Me Why It's Correct: Saving 1/3 of Debugging Time in Program Repair with Interactive Runtime Comparison", + "abstract": "Automated Program Repair (APR) holds the promise of alleviating the burden of debugging and fixing software bugs. Despite this, developers still need to manually inspect each patch to confirm its correctness, which is tedious and time-consuming. This challenge is exacerbated in the presence of plausible patches, which accidentally pass test cases but may not correctly fix the bug. To address this challenge, we propose an interactive approach called iFix to facilitate patch understanding and comparison based on their runtime difference. iFix performs static analysis to identify runtime variables related to the buggy statement and captures their runtime values during execution for each patch. These values are then aligned across different patch candidates, allowing users to compare and contrast their runtime behavior. To evaluate iFix, we conducted a within-subjects user study with 28 participants. Compared with manual inspection and a state-of-the-art interactive patch filtering technique, iFix reduced participants’ task completion time by 36% and 33% while also improving their confidence by 50% and 20%, respectively. Besides, quantitative experiments demonstrate that iFix improves the ranking of correct patches by at least 39% compared with other patch ranking methods and is generalizable to different APR tools.", + "date": "2025-04-09", + "link": "https://doi.org/10.1145/3720510", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ruixin", + "last_name": "Wang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Zhongkai", + "last_name": "Zhao", + "institution": "National University of Singapore" + }, + { + "first_name": "Le", + "last_name": "Fang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Nan", + "last_name": "Jiang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yiling", + "last_name": "Lou", + "institution": "Fudan University" + }, + { + "first_name": "Lin", + "last_name": "Tan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tianyi", + "last_name": "Zhang", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/WangZFJLTZ25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763058", + "title": "Probabilistic Inference for Datalog with Correlated Inputs", + "abstract": "Probabilistic extensions of logic programming languages, such as ProbLog, integrate logical reasoning with probabilistic inference to evaluate probabilities of output relations; however, prior work does not account for potential statistical correlations among input facts. This paper introduces Praline, a new extension to Datalog designed for precise probabilistic inference in the presence of (partially known) input correlations. We formulate the inference task as a constrained optimization problem, where the solution yields sound and precise probability bounds for output facts. However, due to the complexity of the resulting optimization problem, this approach alone often does not scale to large programs. To address scalability, we propose a more efficient δ-exact inference algorithm that leverages constraint solving, static analysis, and iterative refinement. Our empirical evaluation on challenging real-world benchmarks, including side-channel analysis, demonstrates that our method not only scales effectively but also delivers tight probability bounds.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763058", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jingbo", + "last_name": "Wang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Shashin", + "last_name": "Halalingaiah", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Weiyi", + "last_name": "Chen", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Chao", + "last_name": "Wang", + "institution": "University of Southern California" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/0006HC0D25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763059", + "title": "im2im: Automatically Converting In-Memory Image Representations using a Knowledge Graph Approach", + "abstract": "Image processing workflows typically consist of a series of different functions, each working with “image” inputs and outputs in an abstract sense. However, the specific in-memory representation of images differs between and sometimes within libraries. Conversion is therefore necessary when integrating functions from several sources into a single program. The conversion process forces users to consider low-level implementation details, including data types, color channels, channel order, minibatch layout, memory locations, and pixel intensity ranges. Specifically in the case of visual programming languages (VPLs), this distracts from high-level operations. We introduce im2im, a Python library that automates the conversion of in-memory image representations. The central concept of this library is a knowledge graph that describes image representations and how to convert between them. The system queries this knowledge graph to generate the conversion code and execute it, converting an image to the desired representation. The effectiveness of the approach is evaluated through two case studies in VPLs. In each case, we compared a workflow created in a basic block-based VPL with the same workflow enhanced using im2im. These evaluations show that im2im automates type conversions and eliminates the need for manual intervention. Additionally, we compared the overhead of using explicit intermediate representations versus im2im, both of which avoid manual type conversions in VPLs. The results indicate that im2im generates only the necessary conversions, avoiding the runtime overhead associated with converting to and from intermediate formats. A performance comparison between the step-by-step approach used by im2im and a single-function approach demonstrates that the overhead introduced by im2im does not impact practical usability. While focused on block-based VPLs, im2im can be generalized to other VPLs and textual programming environments. Its principles are also applicable to domains other than images. The source code and analyses are available via GitHub.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763059", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Fei", + "last_name": "Chen", + "institution": "German Research Centre for Artificial Intelligence" + }, + { + "first_name": "Sunita", + "last_name": "Saha", + "institution": "German Research Centre for Artificial Intelligence" + }, + { + "first_name": "Manuela", + "last_name": "Schuler", + "institution": "German Research Centre for Artificial Intelligence" + }, + { + "first_name": "Philipp", + "last_name": "Slusallek", + "institution": "German Research Centre for Artificial Intelligence" + }, + { + "first_name": "Tim", + "last_name": "Dahmen", + "institution": "German Research Centre for Artificial Intelligence" + } + ], + "dblp_key": "journals/pacmpl/ChenSSSD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763055", + "title": "RestPi: Path-Sensitive Type Inference for REST APIs", + "abstract": "REST APIs form the backbone of modern interconnected systems by providing a language-agnostic communication interface. REST API specifications should clearly describe all response types, but automatically generating specifications is difficult with existing tools. We present REST𝜋, a type inference engine capable of automatically generating REST API specifications. The novel contribution of REST𝜋 is our use of path-sensitive type inference, which encodes symbolic path-constraints directly into a type system. This allows REST𝜋 to enumerate all response types by considering each distinct execution path through an endpoint implementation. We implement path-sensitive type inference for Ruby, a popular language used for REST API servers. We evaluate REST𝜋 by using it to infer types for 132 endpoints across 5 open-source REST API implementations without utilizing existing specifications or test suites. We find REST𝜋 performs type inference efficiently and produces types that are more precise and complete than those obtained via an HTTP proxy. Our results suggest that path-sensitivity is a key technique to enumerate distinct response types for REST endpoints.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763055", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mark W.", + "last_name": "Aldrich", + "institution": "Tufts University" + }, + { + "first_name": "Kyla H.", + "last_name": "Levin", + "institution": "Amherst College" + }, + { + "first_name": "Michael", + "last_name": "Coblenz", + "institution": "University of California San Diego" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "Tufts University" + } + ], + "dblp_key": "journals/pacmpl/AldrichLCF25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763060", + "title": "Model-Guided Fuzzing of Distributed Systems", + "abstract": "We present a coverage-guided testing algorithm for distributed systems implementations. Our main innovation is the use of an abstract formal model of the system that is used to define coverage. Such abstract models are frequently developed in the early phases of protocol design and verification but are infrequently used at testing time. We show that guiding random test generation using model coverage can be effective in covering interesting points in the implementation state space. We have implemented a fuzzer for distributed system implementations and abstract models written in TLA+. Our algorithm achieves better coverage over purely random exploration as well as random exploration guided by different notions of scheduler coverage and mutation. In particular, we show consistently higher coverage on implementations of distributed consensus protocols such as Two-Phase Commit and the Raft implementations in Etcd-raft and RedisRaft and detect bugs faster. Moreover, we discovered 12 previously unknown bugs in their implementations, four of which could only be detected by model-guided fuzzing.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763060", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Berkay", + "last_name": "Gulcan", + "institution": "Delft University of Technology" + }, + { + "first_name": "Burcu Kulahcioglu", + "last_name": "Ozkan", + "institution": "Delft University of Technology" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Srinidhi", + "last_name": "Nagendra", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "journals/pacmpl/GulcanOMN25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763053", + "title": "Boosting Program Reduction with the Missing Piece of Syntax-Guided Transformations", + "abstract": "Program reduction is a widely used technique in testing and debugging language processors. Given a program that triggers a bug in a language processor, program reduction searches for a canonicalized and minimized program that triggers the same bug, thereby facilitating bug deduplication and simplifying the debugging process. To improve reduction performance without sacrificing generality, prior research has leveraged the formal syntax of the programming language as guidance. Two key syntax-guided transformations—Compatible Substructure Hoisting and Quantified Node Reduction—were introduced to enhance this process. While these transformations have proven effective to some extent, their application excessively prunes the search space, preventing the discovery of many smaller results. Consequently, there remains significant potential for further improvement in overall reduction performance. To this end, we propose a novel syntax-guided transformation named Structure Form Conversion (SFC) to complement the aforementioned two transformations. Building on SFC, we introduce three reduction methods: Smaller Structure Replacement, Identifier Elimination, and Structure Canonicalization, designed to effectively and efficiently leverage SFC for program reduction. By integrating these reduction methods to previous language-agnostic program reducers, Perses and Vulcan, we implement two prototypes named SFCPerses and SFCVulcan. Extensive evaluations show that SFCPerses and SFCVulcan significantly outperforms Perses and Vulcan in both minimization and canonicalization. Specifically, compared to Perses, SFCPerses produces programs that are 36.82%, 18.71%, and 41.05% smaller on average on the C, Rust, and SMT-LIBv2 benchmarks at the cost of 3.65×, 16.99×, and 1.42× the time of Perses, respectively. Similarly, SFCVulcan generates programs that are 14.51%, 7.65%, and 7.66% smaller than those produced by Vulcan at the cost of 1.56×, 2.35×, and 1.42× the execution time of Vulcan. Furthermore, in an experiment with a benchmark suite containing 3,796 C programs that trigger 46 unique bugs, SFCPerses and SFCVulcan reduce 442 and 435 more duplicates (programs that trigger the same bug) to identical programs than Perses and Vulcan, respectively.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763053", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhenyang", + "last_name": "Xu", + "institution": "University of Waterloo" + }, + { + "first_name": "Yongqiang", + "last_name": "Tian", + "institution": "Monash University" + }, + { + "first_name": "Mengxiao", + "last_name": "Zhang", + "institution": "University of Waterloo" + }, + { + "first_name": "C. P.", + "last_name": "Sun", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/Xu0ZS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763062", + "title": "Mind the Abstraction Gap: Bringing Equality Saturation to Real-World ML Compilers", + "abstract": "Machine learning (ML) compilers rely on graph-level transformations to enhance the runtime performance of ML models. However, performing local transformations on individual operations can create effects far beyond the location of the rewrite. In particular, a local rewrite can change the profitability or legality of hard-to-predict downstream transformations, particularly regarding data layout, parallelization, fine-grained scheduling, and memory management. As a result, program transformations are often driven by manually-tuned compiler heuristics, which are quickly rendered obsolete by new hardware and model architectures. Instead of hand-written local heuristics, we propose the use of equality saturation. We replace such heuristics with a more robust global performance model, which accounts for downstream transformations. Equality saturation addresses the challenge of local optimizations inadvertently constraining or negating the benefits of subsequent transformations, thereby providing a solution that is inherently adaptable to newer workloads. While this approach still requires a global performance model to evaluate the profitability of transformations, it holds significant promise for increased automation and adaptability. This paper addresses challenges in applying equality saturation on real-world ML compute graphs and state-of-the-art hardware. By doing so, we present an improved method for discovering effective compositions of graph optimizations. We study different cost modeling approaches to deal with fusion and layout optimization, and tackle scalability issues that arise from considering a very wide range of algebraic optimizations. We design an equality saturation pass for the XLA compiler, with an implementation in C++ and Rust. We demonstrate an average speedup of 3.45% over XLA’s optimization flow across our benchmark suite on various CPU and GPU platforms, with a maximum speedup of 56.26% for NasRNN on CPU.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763062", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arya", + "last_name": "Vohra", + "institution": "University of Chicago" + }, + { + "first_name": "L.", + "last_name": "Lee", + "institution": "University of Oxford" + }, + { + "first_name": "Jakub", + "last_name": "Bachurski", + "institution": "University of Cambridge" + }, + { + "first_name": "Oleksandr", + "last_name": "Zinenko", + "institution": "Constellium (France)" + }, + { + "first_name": "Phitchaya Mangpo", + "last_name": "Phothilimthana", + "institution": "OpenAI (United States)" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "" + }, + { + "first_name": "William S.", + "last_name": "Moses", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/VohraLBZP0M25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763063", + "title": "Coinductive Proofs of Regular Expression Equivalence in Zero Knowledge", + "abstract": "Zero-knowledge (ZK) protocols enable software developers to provide proofs of their programs' correctness to other parties without revealing the programs themselves. Regular expressions are pervasive in real-world software, and zero-knowledge protocols have been developed in the past for the problem of checking whether an individual string appears in the language of a regular expression, but no existing protocol addresses the more complex PSPACE-complete problem of proving that two regular expressions are equivalent. We introduce Crepe, the first ZK protocol for encoding regular expression equivalence proofs and also the first ZK protocol to target a PSPACE-complete problem. Crepe uses a custom calculus of proof rules based on regular expression derivatives and coinduction, and we introduce a sound and complete algorithm for generating proofs in our format. We test Crepe on a suite of hundreds of regular expression equivalence proofs. Crepe can validate large proofs in only a few seconds each.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763063", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "John C.", + "last_name": "Kolesar", + "institution": "Yale University" + }, + { + "first_name": "Shan", + "last_name": "Ali", + "institution": "Yale University" + }, + { + "first_name": "Timos", + "last_name": "Antonopoulos", + "institution": "Yale University" + }, + { + "first_name": "Ružica", + "last_name": "Piskač", + "institution": "Yale University" + } + ], + "dblp_key": "journals/pacmpl/KolesarAAP25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763061", + "title": "Flexible and Expressive Typed Path Patterns for GQL", + "abstract": "Graph databases have become an important data management technology across various domains, including biology, sociology, industry (e.g. fraud detection, supply chain management, financial services), and investigative journalism, due to their ability to efficiently store and query large-scale knowledge graphs and networks. Recently, the Graph Query Language (GQL) was introduced as a new ISO standard providing a unified framework for querying graphs. However, this initial specification lacks a formal type system for query validation. As a result, queries can fail at runtime due to type inconsistencies or produce empty results without prior warning. Solving this issue could have great benefits for users in writing correct queries, especially when handling large datasets. To address this gap, we introduce a formal type model for a core fragment of GQL extended with property-based filtering and imprecise types both in the schema and the queries. This model, named FPPC, enables static detection of semantically incorrect and stuck queries, improving user feedback. We establish key theoretical properties, including emptiness (detecting empty queries due to type mismatches) and type safety (guaranteeing that well-typed queries do not fail at runtime). Additionally, we prove a gradual guarantee, ensuring that removing type annotations either does not introduce static type errors or only increases the result set. By integrating imprecision into GQL, FPPC offers a flexible solution for handling schema evolution and incomplete type information. This work contributes to making GQL more robust, improving both its usability and its formal foundation.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763061", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wenjia", + "last_name": "Ye", + "institution": "National University of Singapore" + }, + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + }, + { + "first_name": "Tomás", + "last_name": "Díaz", + "institution": "University of Chile" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Manuel", + "last_name": "Rigger", + "institution": "National University of Singapore" + }, + { + "first_name": "Claudio", + "last_name": "Gutiérrez", + "institution": "University of Chile" + }, + { + "first_name": "Domagoj", + "last_name": "Vrgoč", + "institution": "Pontificia Universidad Católica de Chile" + } + ], + "dblp_key": "journals/pacmpl/YeTDORGV25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763066", + "title": "qblaze: An Efficient and Scalable Sparse Quantum Simulator", + "abstract": "Classical simulation of quantum circuits is critical for the development of implementations of quantum algorithms: it does not require access to specialized hardware, facilitates debugging by allowing direct access to the quantum state, and is the only way to test on inputs that are too big for current NISQ computers. Many quantum algorithms rely on invariants that result in sparsity in the state vector. A sparse state vector simulator only computes with non-zero amplitudes. For important classes of algorithms, this results in an asymptotic improvement in simulation time. While promising prior work has investigated ways to exploit sparsity, it is still unclear what is the best way to scale sparse simulation to modern multi-core architectures. In this work, we address this challenge and present qblaze, a highly optimized sparse state vector simulator based on (i) a compact sorted array representation, and (ii) new, easily parallelizable and highly-scalable algorithms for all quantum operations. Our extensive experimental evaluation shows that qblaze is often orders-of-magnitude more efficient than prior sparse state vector simulators even on a single thread, and also that qblaze scales well to a large number of CPU cores. Overall, our work enables testing quantum algorithms on input sizes that were previously out of reach.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763066", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hristo", + "last_name": "Venev", + "institution": "Sofia University \"St. Kliment Ohridski\"" + }, + { + "first_name": "Thien", + "last_name": "Udomsrirungruang", + "institution": "University of Oxford" + }, + { + "first_name": "Dimitar", + "last_name": "Dimitrov", + "institution": "Sofia University \"St. Kliment Ohridski\"" + }, + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/VenevU0GV25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763065", + "title": "Fast Client-Driven CFL-Reachability via Regularization-Based Graph Simplification", + "abstract": "Context-free language (CFL) reachability is a critical framework for various program analyses, widely adopted despite its computational challenges due to cubic or near-cubic time complexity. This often leads to significant performance degradation in client applications. Notably, in real-world scenarios, clients typically require reachability information only for specific source-to-sink pairs, offering opportunities for targeted optimization. We introduce MoYe, an effective regularization-based graph simplification technique designed to enhance the performance of client-driven CFL-reachability analyses by pruning non-contributing edges—those that do not participate in any specified CFL-reachable paths. MoYe employs a regular approximation to ensure exact reachability results for all designated node pairs and operates linearly with respect to the number of edges in the graph. This lightweight efficiency makes MoYe a valuable pre-processing step that substantially reduces both computational time and memory requirements for CFL-reachability analysis, outperforming a recent leading graph simplification approach. Our evaluations with two prominent CFL-reachability client applications demonstrate that MoYe can substantially improve performance and reduce resource consumption.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763065", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chenghang", + "last_name": "Shi", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Dongjie", + "last_name": "He", + "institution": "Chongqing University" + }, + { + "first_name": "Haofeng", + "last_name": "Li", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Jie", + "last_name": "Lu", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Lian", + "last_name": "Li", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "journals/pacmpl/ShiHL00X25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763064", + "title": "Reasoning about External Calls", + "abstract": "In today’s complex software, internal trusted code is tightly intertwined with external untrusted code. To reason about internal code, programmers must reason about the potential effects of calls to external code, even though that code is not trusted and may not even be available. The effects of external calls can be limited if internal code is programmed defensively, limiting potential effects by limiting access to the capabilities necessary to cause those effects. This paper addresses the specification and verification of internal code that relies on encapsulation and object capabilities to limit the effects of external calls. We propose new assertions for access to capabilities, new specifications for limiting effects, and a Hoare logic to verify that a module satisfies its specification, even while making external calls. We illustrate the approach though a running example with mechanised proofs, and prove soundness of the Hoare logic.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763064", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + }, + { + "first_name": "Julian", + "last_name": "Mackay", + "institution": "Statistics New Zealand" + }, + { + "first_name": "Susan", + "last_name": "Eisenbach", + "institution": "Imperial College London" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "" + } + ], + "dblp_key": "journals/pacmpl/DrossopoulouME025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763067", + "title": "React-tRace: A Semantics for Understanding React Hooks: An Operational Semantics and a Visualizer for Clarifying React Hooks", + "abstract": "React has become the most widely used web front-end framework, enabling the creation of user interfaces in a declarative and compositional manner. Hooks are a set of APIs that manage side effects in function components in React. However, their semantics are often seen as opaque to developers, leading to UI bugs. We introduce React-tRace, a formalization of the semantics of the essence of React Hooks, providing a semantics that clarifies their behavior. We demonstrate that our model captures the behavior of React, by theoretically showing that it embodies essential properties of Hooks and empirically comparing our React-tRace-definitional interpreter against a test suite. Furthermore, we showcase a practical visualization tool based on the formalization to demonstrate how developers can better understand the semantics of Hooks.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763067", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jaeho", + "last_name": "Lee", + "institution": "Seoul National University" + }, + { + "first_name": "Joongwon", + "last_name": "Ahn", + "institution": "Seoul National University" + }, + { + "first_name": "Kwangkeun", + "last_name": "Yi", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/LeeAY25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763069", + "title": "Correct Black-Box Monitors for Distributed Deadlock Detection: Formalisation and Implementation", + "abstract": "Many software applications rely on concurrent and distributed (micro)services that interact via message-passing and various forms of remote procedure calls (RPC). As these systems organically evolve and grow in scale and complexity, the risk of introducing deadlocks increases and their impact may worsen: even if only a few services deadlock, many other services may block while awaiting responses from the deadlocked ones. As a result, the \"core\" of the deadlock can be obfuscated by its consequences on the rest of the system, and diagnosing and fixing the problem can be challenging. In this work we tackle the challenge by proposing distributed black-box monitors that are deployed alongside each service and detect deadlocks by only observing the incoming and outgoing messages, and exchanging probes with other monitors. We present a formal model that captures popular RPC-based application styles (e.g., gen_servers in Erlang/OTP), and a distributed black-box monitoring algorithm that we prove sound and complete (i.e., identifies deadlocked services with neither false positives nor false negatives). We implement our results in a tool called DDMon for the monitoring of Erlang/OTP applications, and we evaluate its performance. This is the first work that formalises, proves the correctness, and implements distributed black-box monitors for deadlock detection. Our results are mechanised in Coq. DDMon is the companion artifact of this paper.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763069", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Radosław", + "last_name": "Rowicki", + "institution": "Technical University of Denmark" + }, + { + "first_name": "Adrian", + "last_name": "Francalanza", + "institution": "University of Malta" + }, + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "Technical University of Denmark" + } + ], + "dblp_key": "journals/pacmpl/RowickiFS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763068", + "title": "Incremental Certified Programming", + "abstract": "Certified programming, as carried out in proof assistants and dependently-typed programming languages, ensures that a software meets its requirements by supporting the definition of both specifications and proofs. However, proofs easily break with partial definitions and incremental changes because specifications are not designed to account for the intermediate incomplete states of programs. We advocate for proper support for incremental certified programming by analyzing its objectives and inherent challenges, and propose a formal framework for achieving incremental certified programming in a principled manner. The key idea is to define appropriate notions of completion refinement and completeness to capture incrementality, and to systematically produce specifications that are valid at every stage of development while preserving the intent of the original statements. We provide a prototype implementation in the Rocq Prover, called IncRease, which exploits typeclasses for automation and extensibility, and is independent of any specific mechanism used to handle incompleteness. We illustrate its use with both an incremental textbook formalization of the simply-typed λ-calculus, and a more complex case study of incremental certified programming for an existing dead-code elimination optimization pass of the CompCert project. We show that the approach is compatible with randomized property-based testing as provided by QuickChick. Finally we study how to combine incremental certified programming with deductive synthesis, using a novel incrementality-friendly adaptation of the Fiat library. This work provides theoretical and practical foundations towards systematic support for incremental certified programming, highlighting challenges and perspectives for future developments.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763068", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tomás", + "last_name": "Díaz", + "institution": "University of Chile" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "journals/pacmpl/DiazMTT25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763071", + "title": "A Sound Static Analysis Approach to I/O API Migration", + "abstract": "The advances in modern storage technologies necessitate the development of new input/output (I/O) APIs to maximize their performance benefits. However, migrating existing software to use different APIs poses significant challenges due to mismatches in computational models and complex code structures surrounding stateful, non-contiguous multi-API call sites. We present Sprout, a new system for automatically migrating programs across I/O APIs that guarantees behavioral equivalence. Sprout uses flow-sensitive pointer analysis to identify semantic variables, which enables the typestate analysis for matching API semantics and the synthesis of migrated programs. Experimental results with real-world C programs highlight the efficiency and effectiveness of our approach. We also show that Sprout can be adapted to other domains, such as databases.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763071", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shangyu", + "last_name": "Li", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Z J", + "last_name": "Zhang", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Sizhe", + "last_name": "Zhong", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Diyu", + "last_name": "Zhou", + "institution": "Peking University" + }, + { + "first_name": "Jiasi", + "last_name": "Shen", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/LiZZZ025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763070", + "title": "Abstraction Refinement-Guided Program Synthesis for Robot Learning from Demonstrations", + "abstract": "Over the past decade, deep reinforcement learning (RL) techniques have significantly advanced robotic systems. However, due to the complex architectures of neural network models, ensuring their trustworthiness is a considerable challenge. Programmatic reinforcement learning has surfaced as a promising approach. Nonetheless, synthesizing robot-control programs remains challenging. Existing methods rely on domain-specific languages (DSLs) populated with user-defined state abstraction predicates and a library of low-level controllers as abstract actions to boot synthesis, which is impractical in unknown environments that lack such predefined components. To address this limitation, we introduce RoboScribe, a novel abstraction refinement-guided program synthesis framework that automatically derives robot state and action abstractions from raw, unsegmented task demonstrations in high-dimensional, continuous spaces. It iteratively enriches and refines an initially coarse abstraction until it generates a task-solving program over the abstracted robot environment. RoboScribe is effective in synthesizing iterative programs by inferring recurring subroutines directly from the robot’s raw, continuous state and action spaces, without needing predefined abstractions. Experimental results show that RoboScribe programs inductively generalize to long-horizon robot tasks involving arbitrary numbers of objects, outperforming baseline methods in terms of both interpretability and efficiency.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763070", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guofeng", + "last_name": "Cui", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Yuning", + "last_name": "Wang", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Wensen", + "last_name": "Mao", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "Yuanlin", + "last_name": "Duan", + "institution": "Rutgers, The State University of New Jersey" + }, + { + "first_name": "He", + "last_name": "Zhu", + "institution": "Rutgers, The State University of New Jersey" + } + ], + "dblp_key": "journals/pacmpl/CuiWMD025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763073", + "title": "Synthesizing DSLs for Few-Shot Learning", + "abstract": "We study the problem of synthesizing domain-specific languages (DSLs) for few-shot learning in symbolic domains. Given a base language and instances of few-shot learning problems, where each instance is split into training and testing samples, the DSL synthesis problem asks for a grammar over the base language that guarantees that small expressions solving training samples also solve corresponding testing samples. We prove that the problem is decidable for a class of languages whose semantics over fixed structures can be evaluated by tree automata and when expression size corresponds to parse tree depth in the grammar, and, furthermore, the grammars solving the problem correspond to a regular set of trees. We also prove decidability results for variants of the problem where DSLs are only required to express solutions for input learning problems and where DSLs are defined using macro grammars.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763073", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paul", + "last_name": "Krogmeier", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/KrogmeierM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763072", + "title": "Homomorphism Calculus for User-Defined Aggregations", + "abstract": "Data processing frameworks like Apache Spark and Flink provide built-in support for user-defined aggregation functions (UDAFs), enabling the integration of domain-specific logic. However, for these frameworks to support efficient UDAF execution, the function needs to satisfy a homomorphism property , which ensures that partial results from independent computations can be merged correctly. Motivated by this problem, this paper introduces a novel homomorphism calculus that can both verify and refute whether a UDAF is a dataframe homomorphism. If so, our calculus also enables the construction of a corresponding merge operator which can be used for incremental computation and parallel execution. We have implemented an algorithm based on our proposed calculus and evaluate it on real-world UDAFs, demonstrating that our approach significantly outperforms two leading synthesizers.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763072", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ziteng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ruijie", + "last_name": "Fang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Linus", + "last_name": "Zheng", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Dixin", + "last_name": "Tang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/0001FZTD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763074", + "title": "REPTILE: Performant Tiling of Recurrences", + "abstract": "We introduce REPTILE, a compiler that performs tiling optimizations for programs expressed as mathematical recurrence equations. REPTILE recursively decomposes a recurrence program into a set of unique tiles and then simplifies each into a different set of recurrences. Given declarative user specifications of recurrence equations, optimizations, and optional mappings of recurrence subexpressions to external libraries calls, REPTILE generates C code that composes compiler-generated loops with calls to external hand-optimized libraries. We show that for direct linear solvers expressible as recurrence equations, the generated C code matches and often exceed the performance of standard hand-optimized libraries. We evaluate REPTILE's generated C code against hand-optimized implementations of linear solvers in Intel MKL, as well as two non-solver recurrences from bioinformatics: Needleman-Wunsch and Smith-Waterman. When the user provides good tiling specifications, REPTILE achieves parity with MKL, achieving between 0.79--1.27x speedup for the LU decomposition, 0.97--1.21x speedup for the Cholesky decomposition, 1.61x--2.72x for lower triangular matrix inversion, 1.01--1.14x speedup for triangular solve with multiple right-hand sides, and 1.14--1.73x speedup over handwritten implementations of the bioinformatics recurrences.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763074", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Muhammad Usman", + "last_name": "Tariq", + "institution": "Stanford University" + }, + { + "first_name": "Shiv", + "last_name": "Sundram", + "institution": "Stanford University" + }, + { + "first_name": "Fredrik", + "last_name": "Kjølstad", + "institution": "Stanford University" + } + ], + "dblp_key": "journals/pacmpl/TariqSK25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763076", + "title": "HEMVM: A Heterogeneous Blockchain Framework for Interoperable Virtual Machines", + "abstract": "This paper introduces HEMVM, an innovative heterogeneous blockchain framework that seamlessly integrates diverse virtual machines (VMs), including the Ethereum Virtual Machine (EVM) and the Move Virtual Machine (MoveVM), into a unified system. This integration facilitates interoperability while retaining compatibility with existing Ethereum and Move toolchains by preserving high-level language constructs. HEMVM’s unique cross-VM operations allow users to interact with contracts across various VMs using any wallet software, effectively resolving the fragmentation in user experience caused by differing VM designs. Our experimental results demonstrate that HEMVM is both fast and efficient, incurring minimal overhead (less than 4.4%) for intra-VM transactions and achieving up to 9,300 TPS for cross-VM transactions. Our results also show that the cross-VM operations in HEMVM are sufficiently expressive to support complex decentralized finance interactions across multiple VMs. Finally, the parallelized prototype of HEMVM shows performance improvements up to 44.8% compared to the sequential version of HEMVM under workloads with mixed transaction types.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763076", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vladyslav", + "last_name": "Nekriach", + "institution": "University of Toronto" + }, + { + "first_name": "Sidi Mohamed", + "last_name": "Beillahi", + "institution": "University of Toronto" + }, + { + "first_name": "C.", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Peilun", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Ming", + "last_name": "Wu", + "institution": "" + }, + { + "first_name": "Andreas", + "last_name": "Veneris", + "institution": "University of Toronto" + }, + { + "first_name": "Fan", + "last_name": "Long", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/NekriachBLL0VL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763075", + "title": "SafeRace: Assessing and Addressing WebGPU Memory Safety in the Presence of Data Races", + "abstract": "In untrusted execution environments such as web browsers, code from remote sources is regularly executed. To harden these environments against attacks, constituent programming languages and their implementations must uphold certain safety properties, such as memory safety. These properties must be maintained across the entire compilation stack, which may include intermediate languages that do not provide the same safety guarantees. Any case where properties are not preserved could lead to a serious security vulnerability. In this work, we identify a specification vulnerability in the WebGPU Shading Language (WGSL) where code with data races can be compiled to intermediate representations in which an optimizing compiler could legitimately remove memory safety guardrails. To address this, we present SafeRace, a collection of threat assessments and specification proposals across the WGSL execution stack. While our threat assessment showed that this vulnerability does not appear to be exploitable on current systems, it creates a ”ticking time bomb”, especially as compilers in this area are rapidly evolving. Given this, we introduce the SafeRace Memory Safety Guarantee (SMSG), two components that preserve memory safety in the WGSL execution stack even in the presence of data races. The first component specifies that program slices contributing to memory indexing must be race free and is implemented via a compiler pass for WGSL programs. The second component is a requirement on intermediate representations that limits the effects of data races so that they cannot impact race-free program slices. While the first component is not guaranteed to apply to all possible WGSL programs due to limitations on how some data types can be accessed, we show that existing language constructs are sufficient to implement this component with minimal performance overhead on many existing important WebGPU applications. We test the second component by performing a fuzzing campaign of 81 hours across 21 compilation stacks; our results show violations on only one (likely buggy) machine, thus providing evidence that lower-level GPU frameworks could relatively straightforwardly support this constraint. Finally, our assessments discovered GPU memory isolation vulnerabilities in Apple and AMD GPUs, as well as a security-critical miscompilation of WGSL in a pre-release version of Firefox.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763075", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Reese", + "last_name": "Levine", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Ashley", + "last_name": "Lee", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Neha", + "last_name": "Abbas", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Kyle", + "last_name": "Little", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/LevineLAL025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763078", + "title": "A Domain-Specific Probabilistic Programming Language for Reasoning about Reasoning (Or: A Memo on memo)", + "abstract": "The human ability to think about thinking (\"theory of mind\") is a fundamental object of study in many disciplines. In recent decades, researchers across these disciplines have converged on a rich computational paradigm for modeling theory of mind, grounded in recursive probabilistic reasoning. However, practitioners often find programming in this paradigm challenging: first, because thinking-about-thinking is confusing for programmers, and second, because models are slow to run. This paper presents memo, a new domain-specific probabilistic programming language that overcomes these challenges: first, by providing specialized syntax and semantics for theory of mind, and second, by taking a unique approach to inference that scales well on modern hardware via array programming. memo enables practitioners to write dramatically faster models with much less code, and has already been adopted by several research groups.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763078", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kartik", + "last_name": "Chandra", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Tony", + "last_name": "Chen", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Joshua B.", + "last_name": "Tenenbaum", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jonathan", + "last_name": "Ragan‐Kelley", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/Chandra0TR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763079", + "title": "Interleaving Large Language Models for Compiler Testing", + "abstract": "Testing compilers with AI models, especially large language models (LLMs), has shown great promise. However, current approaches struggle with two key problems: The generated programs for testing compilers are often too simple, and extensive testing with the LLMs is computationally expensive. In this paper, we propose a novel compiler testing framework that decouples the testing process into two distinct phases: an offline phase and an online phase. In the offline phase, we use LLMs to generate a collection of small but feature-rich code pieces. In the online phase, we reuse these code pieces by strategically combining them to build high-quality and valid test programs, which are then used to test compilers. We implement this idea in a tool, LegoFuzz, for testing C compilers. The results are striking: we found 66 bugs in GCC and LLVM, the most widely used C compilers. Almost half of the bugs are miscompilation bugs, which are serious and hard-to-find bugs that none of the existing LLM-based tools could find. We believe this efficient design opens up new possibilities for using AI models in software testing beyond just C compilers.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763079", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yujing", + "last_name": "Ni", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Shaohua", + "last_name": "Li", + "institution": "Chinese University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/Ni025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763077", + "title": "Towards Verifying Crash Consistency", + "abstract": "Compute Express Link (CXL) memory sharing, persistent memory, and other related technologies allow data to survive crash events. A key challenge is ensuring that data is consistent after crashes such that it can be safely accessed. While there has been much work on bug-finding tools for persistent memory programs, these tools cannot guarantee that a program is crash-consistent. In this paper, we present a language, CrashLang, and its type system, that together guarantee that well-typed data structure implementations written in CrashLang are crash-consistent. CrashLang leverages the well-known commit-store pattern in which a single store logically commits an entire data structure operation. In this paper, we prove that well-typed CrashLang programs are crash-consistent, and provide a prototype implementation of the CrashLang compiler. We have evaluated CrashLang on five benchmarks: the Harris linked list, the Treiber stack, the Michael–Scott queue, a Read-Copy-Update binary search tree, and a Cache-Line Hash Table. We experimentally verified that each implementation correctly survives crashes.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763077", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Keonho", + "last_name": "Lee", + "institution": "University of California, Irvine" + }, + { + "first_name": "Conan", + "last_name": "Truong", + "institution": "University of California, Irvine" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "journals/pacmpl/LeeTD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763089", + "title": "HybridPersist: A Compiler Support for User-Friendly and Efficient PM Programming", + "abstract": "Persistent memory (PM), with its data persistence, has found widespread applications. However, programmers have to manually annotate PM operations in programming to achieve crash consistency, which is labor-intensive and error-prone. In this paper, to alleviate the burden of programming PM applications, we develop HybridPersist, a compiler support for user-friendly and efficient PM programming. On the one hand, HybridPersist automatically achieves crash consistency, minimally intruding on programmers with negligible annotations. On the other hand, it enhances both performance and correctness of PM programs through a series of dedicated analysis passes. The evaluations on well-known benchmarks validate that HybridPersist offers superior programming productivity and runtime performance compared to the state-of-the-art.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763089", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yiyu", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Yongzhi", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Yanfeng", + "last_name": "Gao", + "institution": "Nanjing University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Zhiqiang", + "last_name": "Zuo", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/ZhangWGL025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763082", + "title": "Tuning Random Generators: Property-Based Testing as Probabilistic Programming", + "abstract": "Property-based testing validates software against an executable specification by evaluating it on randomly generated inputs. The standard way that PBT users generate test inputs is via generators that describe how to sample test inputs through random choices. To achieve a good distribution over test inputs, users must tune their generators, i.e., decide on the weights of these individual random choices. Unfortunately, it is very difficult to understand how to choose individual generator weights in order to achieve a desired distribution, so today this process is tedious and limits the distributions that can be practically achieved. In this paper, we develop techniques for the automatic and offline tuning of generators. Given a generator with undetermined symbolic weights and an objective function, our approach automatically learns values for these weights that optimize for the objective. We describe useful objective functions that allow users to (1) target desired distributions and (2) improve the diversity and validity of their test cases. We have implemented our approach in a novel discrete probabilistic programming system, Loaded Dice, that supports differentiation and parameter learning, and use it as a language for generators. We empirically demonstrate that our approach is effective at optimizing generator distributions according to the specified objective functions. We also perform a thorough evaluation on PBT benchmarks, demonstrating that, when automatically tuned for diversity and validity, the generators exhibit a 3.1-7.4x speedup in bug finding.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763082", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Tjoa", + "institution": "University of Washington" + }, + { + "first_name": "Poorva", + "last_name": "Garg", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Harrison", + "last_name": "Goldstein", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Guy Van den", + "last_name": "Broeck", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/TjoaGGMPB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763081", + "title": "Two Approaches to Fast Bytecode Frontend for Static Analysis", + "abstract": "In static analysis frameworks for Java, the bytecode frontend serves as a critical component, transforming complex, stack-based Java bytecode into a more analyzable register-based, typed 3-address code representation. This transformation often significantly influences the overall performance of analysis frameworks, particularly when processing large-scale Java applications, rendering the efficiency of the bytecode frontend paramount for static analysis. However, the bytecode frontends of currently dominant Java static analysis frameworks, Soot and WALA, despite being time-tested and widely adopted, exhibit limitations in efficiency, hindering their ability to offer a better user experience. To tackle efficiency issues, we introduce a new bytecode frontend. Typically, bytecode frontends consist of two key stages: (1) translating Java bytecode to untyped 3-address code, and (2) performing type inference on this code. For 3-address code translation, we identified common patterns in bytecode that enable more efficient processing than traditional methods. For type inference, we found that traditional algorithms often include redundant computations that hinder performance. Leveraging these insights, we propose two novel approaches: pattern-aware 3-address code translation and pruning-based type inference , which together form our new frontend and lead to significant efficiency improvements. Besides, our approach can also generate SSA IR, enhancing its usability for various static analysis techniques. We implemented our new bytecode frontend in Tai-e, a recent state-of-the-art static analysis framework for Java, and evaluated its performance across a diverse set of Java applications. Experimental results demonstrate that our frontend significantly outperforms Soot, WALA, and SootUp (an overhaul of Soot)—in terms of efficiency, being on average 14.2×, 14.5×, and 75.2× faster than Soot, WALA, and SootUp, respectively. Moreover, additional experiments reveal that our frontend exhibits superior reliability in processing Java bytecode compared to these tools, thus providing a more robust foundation for Java static analysis.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763081", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chenjie", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Haoran", + "last_name": "Lin", + "institution": "Nanjing University" + }, + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "Nanjing University" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/LiL0025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763085", + "title": "Tracing Just-in-Time Compilation for Effects and Handlers", + "abstract": "Effect handlers are a programming language feature that has recently gained popularity. They allow for non-local yet structured control flow and subsume features like generators, exceptions, asynchronicity, etc. However, implementations of effect handlers currently often sacrifice features to enable efficient implementations. Meta-tracing just-in-time (JIT) compilers promise to yield the performance of a compiler by implementing an interpreter. They record execution in a trace, dynamically detect hot loops, and aggressively optimize those using information available at runtime. They excel at optimizing dynamic control flow, which is exactly what effect handlers introduce. We present the first evaluation of tracing JIT compilation specifically for effect handlers. To this end, we developed RPython-based tracing JIT implementations for Eff, Effekt, and Koka by compiling them to a common bytecode format. We evaluate the performance, discuss which classes of effectful programs are optimized well and how our additional optimizations influence performance. We also benchmark against a baseline of state-of-the-art mainstream language implementations.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763085", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marcial", + "last_name": "Gaißert", + "institution": "University of Tübingen" + }, + { + "first_name": "CF", + "last_name": "Bolz-Tereick", + "institution": "Heinrich Heine University Düsseldorf" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/GaissertBB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763092", + "title": "MTP: A Meaning-Typed Language Abstraction for AI-Integrated Programming", + "abstract": "Software development is shifting from traditional programming to AI-integrated applications that leverage generative AI and large language models (LLMs) during runtime. However, integrating LLMs remains complex, requiring developers to manually craft prompts and process outputs. Existing tools attempt to assist with prompt engineering, but often introduce additional complexity. This paper presents Meaning-Typed Programming (MTP) , a novel paradigm that abstracts LLM integration through intuitive language-level constructs. By leveraging the inherent semantic richness of code, MTP automates prompt generation and response handling without additional developer effort. We introduce the (1) by operator for seamless LLM invocation, (2) MT-IR , a meaning-based intermediate representation for semantic extraction, and (3) MT-Runtime , an automated system for managing LLM interactions. We implement MTP in Jac , a programming language that supersets Python, and find that MTP significantly reduces coding complexity while maintaining accuracy and efficiency. MTP significantly reduces development complexity, lines of code modifications needed, and costs while improving run-time performance and maintaining or exceeding the accuracy of existing approaches. Our user study shows that developers using MTP completed tasks 3.2× faster with 45% fewer lines of code compared to existing frameworks. Moreover, demonstrates resilience even when up to 50% of naming conventions are degraded, demonstrating robustness to suboptimal code. is developed as part of the Jaseci open-source project, and is available under the module byLLM .", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763092", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jayanaka L.", + "last_name": "Dantanarayana", + "institution": "University of Michigan" + }, + { + "first_name": "Yiping", + "last_name": "Kang", + "institution": "University of Michigan" + }, + { + "first_name": "Kugesan", + "last_name": "Sivasothynathan", + "institution": "JPMorgan Chase & Co (United States)" + }, + { + "first_name": "Christopher", + "last_name": "Clarke", + "institution": "University of Michigan" + }, + { + "first_name": "Baichuan", + "last_name": "Li", + "institution": "University of Michigan" + }, + { + "first_name": "Savini", + "last_name": "Kashmira", + "institution": "University of Michigan" + }, + { + "first_name": "Krisztián", + "last_name": "Flautner", + "institution": "University of Michigan" + }, + { + "first_name": "Lingjia", + "last_name": "Tang", + "institution": "University of Michigan" + }, + { + "first_name": "Jason", + "last_name": "Mars", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/DantanarayanaKS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763091", + "title": "Structural Temporal Logic for Mechanized Program Verification", + "abstract": "Mechanized verification of liveness properties for infinite programs with effects and nondeterminism is challenging. Existing temporal reasoning frameworks operate at the level of models such as traces and automata. Reasoning happens at a very low-level, requiring complex nested (co-)inductive proof techniques and familiarity with proof assistant mechanics (e.g., the guardedness checker). Further, reasoning at the level of models instead of program constructs creates a verification gap that loses the benefits of modularity and composition enjoyed by structural program logics such as Hoare Logic. To address this verification gap, and the lack of compositional proof techniques for temporal specifications, we propose Ticl, a new structural temporal logic. Using Ticl, we encode complex (co-)inductive proof techniques as structural lemmas and focus our reasoning on variants and invariants. We show that it is possible to perform compositional proofs of general temporal properties in a proof assistant, while working at a high level of abstraction. We demonstrate the benefits of Ticl by giving mechanized proofs of safety and liveness properties for programs with scheduling, concurrent shared memory, and distributed consensus, demonstrating a low proof-to-code ratio.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763091", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eleftherios", + "last_name": "Ioannidis", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Sebastian", + "last_name": "Angel", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/IoannidisZZA25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763084", + "title": "Revamping Verilog Semantics for Foundational Verification", + "abstract": "In formal hardware verification, particularly for Register-Transfer Level (RTL) designs in Verilog, model checking has been the predominant technique. However, it suffers from state explosion, limited expressive power, and a large trusted computing base (TCB). Deductive verification offers greater expressive power and enables foundational verification with a minimal TCB. Nevertheless, Verilog's standard semantics, characterized by its nondeterministic and global scheduling, pose significant challenges to its application. To address these challenges, we propose a new Verilog semantics designed to facilitate deductive verification. Our semantics is based on least fixpoints to enable cycle-level functional evaluation and modular reasoning. For foundational verification, we prove our semantics equivalent to the standard scheduling semantics for synthesizable designs. We demonstrate the benefits of our semantics with a modular verification of a pipelined RISC-V processor's functional correctness and progress guarantees. All our results are mechanized in Rocq.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763084", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Joonwon", + "last_name": "Choi", + "institution": "Amazon (United States)" + }, + { + "first_name": "Jaewoo", + "last_name": "Kim", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/ChoiKK25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763087", + "title": "Statically Analyzing the Dataflow of R Programs", + "abstract": "The R programming language is primarily designed for statistical computing and mostly used by researchers without a background in computer science. R provides a wide range of dynamic features and peculiarities that are difficult to analyze statically like dynamic scoping and lazy evaluation with dynamic side effects. At the same time, the R ecosystem lacks sophisticated analysis tools that support researchers in understanding and improving their code. In this paper, we present a novel static dataflow analysis framework for the R programming language that is capable of handling the dynamic nature of R programs and produces the dataflow graph of given R programs. This graph can be essential in a range of analyses, including program slicing, which we implement as a proof of concept. The core analysis works as a stateful fold over a normalized version of the abstract syntax tree of the R program, which tracks (re-)definitions, values, function calls, side effects, external files, and a dynamic control flow to produce one dataflow graph per program. We evaluate the correctness of our analysis using output equivalence testing on a manually curated dataset of 779 sensible slicing points from executable real-world R scripts. Additionally, we use a set of systematic test cases based on the capabilities of the R language and the implementation of the R interpreter and measure the runtimes well as the memory consumption on a set of 4,230 real-world R scripts and 20,815 packages available on R’s package manager CRAN. Furthermore, we evaluate the recall of our program slicer, its accuracy using shrinking, and its improvement over the state of the art. We correctly analyze almost all programs in our equivalence test suite, preserving the identical output for 99.7% of the manually curated slicing points. On average, we require 576ms to analyze the dataflow and around 213kB to store the graph of a research script. This shows that our analysis is capable of analyzing real-world sources quickly and correctly. Our slicer achieves an average reduction of 84.8% of tokens indicating its potential to improve program comprehension.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763087", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Florian", + "last_name": "Sihler", + "institution": "Universität Ulm" + }, + { + "first_name": "Matthias", + "last_name": "Tichy", + "institution": "Universität Ulm" + } + ], + "dblp_key": "journals/pacmpl/SihlerT25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763086", + "title": "Convex Hull Approximation for Activation Functions", + "abstract": "The wide adoption of deep learning in safety-critical domains has driven the need for formally verifying the robustness of neural networks. A critical challenge in this endeavor lies in addressing the inherent non-linearity of activation functions. The convex hull of the activation function has emerged as a promising solution, as it effectively tightens variable ranges and provides multi-neuron constraints, which together enhance verification precision. Given that constructing exact convex hulls is computationally expensive and even infeasible in most cases, existing research has focused on over-approximating them. Several ad-hoc methods have been devised for specific functions such as ReLU and Sigmoid. Nonetheless, there remains a substantial gap in developing broadly applicable approaches for general activation functions. In this work, we propose WraAct, an approach to efficiently constructing tight over-approximations for activation function hulls. Its core idea is to introduce linear constraints to smooth out the fluctuations in the target function, by leveraging double-linear-piece (DLP) functions to simplify the local geometry. In this way, the problem is reduced to over-approximating DLP functions, which can be efficiently handled. We evaluate WraAct against SBLM+PDDM, the state-of-the-art (SOTA) multi-neuron over-approximation method based on decompositing functions into segments. WraAct outperforms it on commonly-used functions like Sigmoid, Tanh, and MaxPool, offering superior efficiency (average 400X faster) and precision (average 150X) while constructing fewer constraints (average 50% reduction). It can complete the computation of up to 8 input dimensions in 10 seconds. We also integrate WraAct into a neural network verifier to evaluate its capability in verification tasks. On 100 benchmark samples, it significantly enhances the single-neuron verification from under 10 to over 40, and outperforms the multi-neuron verifier PRIMA with up to additional 20 verified samples. On large networks like ResNets with 22k neurons, it can complete the verification of one sample within one minute.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763086", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zhongkui", + "last_name": "Ma", + "institution": "The University of Queensland" + }, + { + "first_name": "Zihan", + "last_name": "Wang", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Guangdong", + "last_name": "Bai", + "institution": "The University of Queensland" + } + ], + "dblp_key": "journals/pacmpl/MaWB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763088", + "title": "Synthesizing Sound and Precise Abstract Transformers for Nonlinear Hyperbolic PDE Solvers", + "abstract": "Partial Differential Equations (PDEs) play a ubiquitous role in scientific computing and engineering. While numerical methods make solving PDEs tractable, these numerical solvers encounter several issues, particularly for hyperbolic PDEs. These issues arise from multiple sources including the PDE’s physical model, which can lead to effects like shock wave formation, and the PDE solver’s inherent approximations, which can introduce spurious numerical artifacts. These issues can cause the solver’s program execution to crash (due to overflow) or return results with unacceptable levels of inaccuracy (due to spurious oscillations or dissipation). Moreover, these challenges are compounded by the nonlinear nature of many of these PDEs. In addition, PDE solvers must obey numerical invariants like the CFL condition. Hence there exists a critical need to apply program analysis to PDE solvers to certify such problems do not arise and that invariants are always satisfied. As a solution, we develop Phocus, which is the first abstract interpretation of hyperbolic PDE solvers. Phocus can certify precise bounds on nonlinear PDE solutions and certify key invariants such as the CFL condition and a solution’s total variation bound. Hence Phocus can verify the absence of shock formation, the stability of the solver, and bounds on the amount of spurious numerical effects. To enable effective abstract interpretation of hyperbolic PDE solvers, Phocus uses a novel optimization-based procedure to synthesize precise abstract transformers for multiple finite difference schemes. To evaluate Phocus, we develop a new set of PDE benchmark programs and use them to perform an extensive experimental evaluation which demonstrates Phocus’s significant precision benefits and scalability to several thousand mesh points.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763088", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Laurel", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Ignacio", + "last_name": "Laguna", + "institution": "Lawrence Livermore National Laboratory" + }, + { + "first_name": "Jan", + "last_name": "Hückelheim", + "institution": "Argonne National Laboratory" + } + ], + "dblp_key": "journals/pacmpl/LaurelLH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763080", + "title": "A Hoare Logic for Symmetry Properties", + "abstract": "Many natural program correctness properties can be stated in terms of symmetries, but existing formal methods have little support for reasoning about such properties. We consider how to formally verify a broad class of symmetry properties expressed in terms of group actions. To specify these properties, we design a syntax for group actions, supporting standard constructions and a natural notion of entailment. Then, we develop a Hoare-style logic for verifying symmetry properties of imperative programs, where group actions take the place of the typical pre- and post-condition assertions. Finally, we develop a prototype tool SymVerif , and use it to verify symmetry properties on a series of handcrafted benchmarks. Our tool uncovered an error in a model of a dynamical system described by McLachlan and Quispel [Acta Numerica 2002].", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763080", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vaibhav", + "last_name": "Mehta", + "institution": "Cornell University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/MehtaH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763090", + "title": "Memory-Safety Verification of Open Programs with Angelic Assumptions", + "abstract": "An open program is one for which the complete source code is not available, which is a reality for real-world program verification. Software verification tools tend to assume the worst about any unconstrained behavior and this can yield an enormous number of spurious warnings for open programs. For any serious verification effort, the engineer must invest time up-front in building a suitable model (or mock) of any missing code, which is time-consuming and error-prone. Inaccuracies in the mocks can lead to incorrect verification results. In this paper, we demonstrate a technique that is capable of distinguishing between false positives and actual bugs from potential memory-safety violations in an open program with high accuracy. Central to the technique is the ability of making angelic assumptions about missing code. To accomplish this, we first mine a set of idiomatic patterns in buffer-manipulating programs using a large language model (LLM). This is complemented by a formal synthesis strategy that performs property-directed reasoning to select, adapt and instantiate these idiomatic patterns into angelic assumptions on the target program. Overall, our system, Seeker, guarantees that a program is deemed correct only if it can be verified under a well-defined set of \"trusted\" idiomatic patterns. In our experiments over a set of benchmarks curated from popular open-source software, our tool Seeker is able to identify 79% of the false positives with zero false negatives.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763090", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Gourav", + "last_name": "Takhar", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Baldip", + "last_name": "Bijlani", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Prantik", + "last_name": "Chatterjee", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Subhajit", + "last_name": "Roy", + "institution": "Indian Institute of Technology Kanpur" + } + ], + "dblp_key": "journals/pacmpl/TakharBCL025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763099", + "title": "Agora: Trust Less and Open More in Verification for Confidential Computing", + "abstract": "Confidential computing (CC), designed for security-critical scenarios, uses remote attestation to guarantee code integrity on cloud servers. However, CC alone cannot provide assurance of high-level security properties (e.g., no data leak) on the code. In this paper, we introduce a novel framework, Agora, scrupulously designed to provide a trustworthy and open verification platform for CC. To prompt trustworthiness, we observe that certain verification tasks can be delegated to untrusted entities, while the corresponding (smaller) validators are securely housed within the trusted computing base (TCB). Moreover, through a novel blockchain-based bounty task manager, it also utilizes crowdsourcing to remove trust in complex theorem provers. These synergistic techniques successfully ameliorate the TCB size burden associated with two procedures: binary analysis and theorem proving. To prompt openness, Agora supports a versatile assertion language that allows verification of various security policies. Moreover, the design of Agora enables untrusted parties to participate in any complex processes out of Agora’s TCB. By implementing verification workflows for software-based fault isolation, information flow control, and side-channel mitigation policies, our evaluation demonstrates the efficacy of Agora.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763099", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hongbo", + "last_name": "Chen", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Quan", + "last_name": "Zhou", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Sen", + "last_name": "Yang", + "institution": "Yale University" + }, + { + "first_name": "Sixuan", + "last_name": "Dang", + "institution": "Duke University" + }, + { + "first_name": "Xing", + "last_name": "Han", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Danfeng", + "last_name": "Zhang", + "institution": "Duke University" + }, + { + "first_name": "Fan", + "last_name": "Zhang", + "institution": "Yale University" + }, + { + "first_name": "XiaoFeng", + "last_name": "Wang", + "institution": "Nanyang Technological University" + } + ], + "dblp_key": "journals/pacmpl/ChenZYDHZ0025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763101", + "title": "Non-interference Preserving Optimising Compilation", + "abstract": "To protect security-critical applications, secure compilers have to preserve security policies, such as non-interference, during compilation. The preservation of security policies goes beyond the classical notion of compiler correctness which only enforces the preservation of the semantics of the source program. Therefore, several standard compiler optimisations are prone to break standard security policies like non-interference. Existing approaches to secure compilation are very restrictive with respect to the compiler optimisations that they permit or to the security policies they support because of conceptual limitations in their formal setup. In this paper, we present hyperproperty simulations , a novel framework to secure compilation that models the preservation of arbitrary k -hyperproperties during compilation and overcomes several limitations of existing approaches, in particular it is more expressive and more flexible. We demonstrate this by designing and proving a generic non-interference preserving code transformation that can be applied on different optimisations and leakage models. This approach reduces the proof burden per optimisation to a minimum. We instantiate this code transformation on different leakage models with various standard compiler optimisations that could be handled in a very limited and less modular way (if at all) by existing approaches. Our results are formally verified in the Rocq theorem prover.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763101", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Julian", + "last_name": "Rosemann", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RosemannH025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763105", + "title": "Synchronized Behavior Checking: A Method for Finding Missed Compiler Optimizations", + "abstract": "Compilers are among the most foundational software ever developed. A critical component of a compiler is its optimization phase, which enhances the efficiency of the generated code. Given the sheer size and complexity of modern compilers, automated techniques for improving their optimization component have been a major area of research. This paper focuses on a specific category of issues, namely missed optimizations, where compilers fail to apply an optimization that could have made the generated code more efficient. To detect missed optimizations, we propose Synchronized Behavior Checking ( SBC ), a novel approach that cross-validates multiple optimizations by leveraging their coordinated behaviors. The key insight behind SBC is that the outcome of one optimization can validate whether the conditions required for another optimization were met. For a practical implementation of SBC , we cross-validate two optimizations at once based on two kinds of relationships — co-occurring and complementary. In the co-occurring relationship, if an optimization is applied based on a specific semantic constraint (, optimization condition) from an input program, another optimization, which depends on the same semantic constraint, should be applied as well. Second, when two optimizations are enabled by complementary semantic constraints, exactly one of the two optimizations should be applied. When an optimization should have been applied (according to either relationship) but was not applied, we regard it as a missed optimization. We conduct an extensive evaluation of SBC on two state-of-the-art industry compilers LLVM and GCC. SBC successfully detects a large number of missed optimizations in both compilers, in particular, they are caused by a wide range of compiler analyses. Based on our evaluation results, we reported 101 issues to LLVM and GCC, out of which 84 have been confirmed, and 39 have been fixed or assigned (for planned fixes). SBC opens up a new, exciting direction for finding missed compiler optimizations.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763105", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yi", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Yu", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Linzhang", + "last_name": "Wang", + "institution": "Nanjing University" + }, + { + "first_name": "Ke", + "last_name": "Wang", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/ZhangWWW25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763096", + "title": "Qualified Types with Boolean Algebras", + "abstract": "We propose type qualifiers based on Boolean algebras. Traditional type systems with type qualifiers have been based on lattices, but lattices lack the ability to express exclusion. We argue that Boolean algebras, which permit exclusion, are a practical and useful choice of domain for qualifiers. In this paper, we present a calculus System F<:B that extends System F<: with type qualifiers over Boolean algebras and has support for negation, qualifier polymorphism, and subqualification. We illustrate how System F<:B can be used as a design recipe for a type and effect system, System F<:BE, with effect polymorphism, subeffecting, and polymorphic effect exclusion. We use System F<:BE to establish formal foundations of the type and effect system of the Flix programming language. We also pinpoint and implement a practical form of subeffecting: abstraction-site subeffecting. Experimental results show that abstraction-site subeffecting allows us to eliminate all effect upcasts present in the current Flix Standard Library.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763096", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Edward", + "last_name": "Lee", + "institution": "University of Waterloo" + }, + { + "first_name": "Jonathan Lindegaard", + "last_name": "Starup", + "institution": "Aarhus University" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/LeeSLM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763094", + "title": "Fuzzing C++ Compilers via Type-Driven Mutation", + "abstract": "C++ is a system-level programming language for modern software development, which supports multiple programming paradigms, including object-oriented, generic, and functional programming. The intrinsic complexity of these paradigms and their interactions grants C++ powerful expressiveness while posing significant challenges for compilers in correctly implementing its type system. A type system encompasses various aspects such as type inference, type checking, subtyping, type conversions, generics, scoping, and binding. However, systematic testing of the type systems of C++ compilers remains largely underexplored in existing studies. In this work, we present TyMut, the first approach specifically designed to test the C++ type system. TyMut is a mutation-based compiler fuzzer equipped with advanced type-driven mutation operators, carefully crafted to target intricate type-related features such as template generics, type conversions, and inheritance. Beyond differential testing, TyMut introduces enhanced test oracles through a must analysis that partially confirms the validity of generated programs. Specifically, mutation operators are classified into well-formed and not-well-formed: Programs generated by well-formed mutation operators are valid and must be accepted by compilers. Programs generated by not-well-formed operators are validated against a set of well-formedness rules. Any violation indicates the program is invalid and must be rejected. For programs that pass the rules but lack a definitive oracle, TyMut applies differential testing to identify behavioral inconsistencies across compilers. The testing campaign took about 32 hours to generate and test 250584 programs. The must analysis provides definite test oracles for nearly 80% of all generated programs. TyMut uncovered 102 bugs in the recent versions of GCC and Clang, with 56 confirmed as new bugs by compiler developers. Among the confirmed bugs, 26 of them cause compiler crashes, and more than 50% cause miscompilation. Additionally, 7 of them had remained hidden for over 20 years, 22 for over 10 years, and 39 for over 5 years. One long-standing bug discovered by TyMut was later confirmed as the root cause of a real-world issue in TensorFlow. Before submitting this paper, 13 bugs were fixed, most of which were fixed within 60 days. Notably, some unconfirmed bugs have led to in-depth discussions among developers. For instance, one bug led a compiler developer to submit a new issue to the C++ language standard, showing that we uncovered ambiguities in the language specification.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763094", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Bo", + "last_name": "Wang", + "institution": "Beijing Jiaotong University" + }, + { + "first_name": "Chong", + "last_name": "Chen", + "institution": "Beijing Jiaotong University" + }, + { + "first_name": "Ming", + "last_name": "Deng", + "institution": "Beijing Jiaotong University" + }, + { + "first_name": "Junjie", + "last_name": "Chen", + "institution": "Tianjin University" + }, + { + "first_name": "Xing", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Youfang", + "last_name": "Lin", + "institution": "Beijing Jiaotong University" + }, + { + "first_name": "Dan", + "last_name": "Hao", + "institution": "Peking University" + }, + { + "first_name": "Jun", + "last_name": "Sun", + "institution": "Singapore Management University" + } + ], + "dblp_key": "journals/pacmpl/00500D0ZL0025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763083", + "title": "Efficient Abstract Interpretation via Selective Widening", + "abstract": "Abstract interpretation provides a systematic framework for static analysis, where widening operators are crucial for ensuring termination when analyzing programs over infinite-height lattices. Current abstract interpreters apply widening operations and fixpoint detection uniformly across all variables at the identified widening point (e.g., control-flow loop headers), leading to costly computations. Through our empirical study, we observe that infinite ascending chains typically originate from only a subset of variables involved in value-flow cycles, providing opportunities for selective widening and targeted fixpoint detection. This paper introduces an efficient approach to optimize abstract interpretation over non-relational domains through selective widening guided by value-flow analysis. We develop a modular and condensed value-flow graph (MVFG) that enables precise identification of variables requiring widening by detecting value-flow cycles across procedure boundaries. Our MVFG design incorporates efficient shortcut edges that summarize interprocedural value flows, achieving the precision of context-sensitive analysis but with linear complexity. By aligning value-flow cycles with the weak topological ordering (WTO) of the control-flow graph, we identify the minimal set of variables requiring widening operations, applying widening exclusively to variables that participate in value-flow back edges. Our evaluation on large-scale open-source projects shows that our selective widening approach reduces analysis time by up to 41.2% while maintaining identical precision. The method significantly reduces the number of widened variables by up to 99.5%, with greater benefits observed in larger codebases.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763083", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jiawei", + "last_name": "Wang", + "institution": "UNSW Sydney" + }, + { + "first_name": "Xiao", + "last_name": "Cheng", + "institution": "Macquarie University" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "journals/pacmpl/Wang0S25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763100", + "title": "Shaking Up Quantum Simulators with Fuzzing and Rigour", + "abstract": "Quantum computing platforms rely on simulators for modelling circuit behaviour prior to hardware execution, where inconsistencies can lead to costly errors. While existing formal validation methods typically target specific compiler components to manage state explosion, they often miss critical bugs. Meanwhile, conventional testing lacks systematic exploration of corner cases and realistic execution scenarios, resulting in both false positives and negatives. We present FuzzQ, a novel framework that bridges this gap by combining formal methods with structured test generation and fuzzing for quantum simulators. Our approach employs differential benchmarking complemented by mutation testing and invariant checking. At its core, FuzzQ utilises our Alloy-based formal model of QASM 3.0, which encodes the semantics of quantum circuits to enable automated analysis and to generate structurally diverse, constraint-guided quantum circuits with guaranteed properties. We introduce several test oracles to assess both Alloy’s modelling of QASM 3.0 and simulator correctness, including invariant-based checks, statistical distribution tests, and a novel cross-simulator unitary consistency check that verifies functional equivalence modulo global phase, revealing discrepancies that standard statevector comparisons fail to detect in cross-platform differential testing. We evaluate FuzzQ on both Qiskit and Cirq, demonstrating its platform-agnostic effectiveness. By executing over 800,000 quantum circuits to completion, we assess throughput, code and circuit coverage, and simulator performance metrics, including sensitivity, correctness, and memory overhead. Our analysis revealed eight simulator bugs, six previously undocumented. We also outline a path for extending the framework to support mixed-state simulations under realistic noise models.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763100", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Vasileios", + "last_name": "Klimis", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Avner", + "last_name": "Bensoussan", + "institution": "King's College London" + }, + { + "first_name": "Elena", + "last_name": "Chachkarova", + "institution": "King's College London" + }, + { + "first_name": "Karine", + "last_name": "Even-Mendoza", + "institution": "King's College London" + }, + { + "first_name": "Sophie", + "last_name": "Fortz", + "institution": "King's College London" + }, + { + "first_name": "Connor", + "last_name": "Lenihan", + "institution": "King's College London" + } + ], + "dblp_key": "journals/pacmpl/KlimisBCEFL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763095", + "title": "MetaKernel: Enabling Efficient Encrypted Neural Network Inference through Unified MVM and Convolution", + "abstract": "Practical encrypted neural network inference under the CKKS fully homomorphic encryption (FHE) scheme relies heavily on accelerating two key kernel operations: Matrix-Vector Multiplication (MVM) and Convolution (Conv). However, existing solutions—such as expert-tuned libraries and domain-specific languages—are designed in an ad hoc manner, leading to significant inefficiencies caused by excessive rotations. We introduce MKR, a novel composition-based compiler approach that optimizes MVM and Conv kernel operations for DNN models under CKKS within a unified framework. MKR decomposes each kernel into composable units, called MetaKernels, to enhance SIMD parallelism within ciphertexts (via horizontal batching) and computational parallelism across them (via vertical batching). Our approach tackles previously unaddressed challenges, including reducing rotation overhead through a rotation-aware cost model for data packing, while also ensuring high slot utilization, uniform handling of inputs with arbitrary sizes, and compatibility with the output tensor layout. Implemented in a production-quality FHE compiler, MKR achieves inference time speedups of 10.08×–185.60× for individual MVM and Conv kernels and 1.75×–11.84× for end-to-end inference compared to a state-of-the-art FHE compiler. Moreover, MKR enables homomorphic execution of large DNN models, where prior methods fail, significantly advancing the practicality of FHE compilers.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763095", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Peng", + "last_name": "Yuan", + "institution": "" + }, + { + "first_name": "Yan", + "last_name": "Liu", + "institution": "" + }, + { + "first_name": "JianXin", + "last_name": "Lai", + "institution": "" + }, + { + "first_name": "Long", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Tianxiang", + "last_name": "Sui", + "institution": "" + }, + { + "first_name": "Linjie", + "last_name": "Xiao", + "institution": "" + }, + { + "first_name": "X. D.", + "last_name": "Zhang", + "institution": "" + }, + { + "first_name": "Qing", + "last_name": "Zhu", + "institution": "" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "journals/pacmpl/YuanLL0SXZ0X25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763093", + "title": "Validating SMT Rewriters via Rewrite Space Exploration Supported by Generative Equality Saturation", + "abstract": "Satisfiability Modulo Theories (SMT) solvers are widely used for program analysis and other applications that require automated reasoning. Rewrite systems, as crucial integral components of SMT solvers, are responsible for simplifying and transforming formulas to optimize the solving process. The effectiveness of an SMT solver heavily depends on the robustness of its rewrite system, making its validation crucial. Despite ongoing advancements in SMT solver testing, rewrite system validation remains largely unexplored. Our empirical analysis reveals that developers invest significant effort in ensuring the correctness and reliability of rewrite systems. However, existing testing techniques do not adequately address this aspect. In this paper, we introduce Aries, a novel technique designed to validate SMT solver rewrite systems. First, Aries employs mimetic mutation, a targeted strategy that actively reshapes input formulas to provoke and diversify rewrite opportunities. By aligning mutated terms with known rewrite patterns, Aries can conduct a thorough exploration of the rewrite space in the following phase. Second, Aries utilizes deductive rewriting, leveraging generative equality saturation to effectively explore rewrite space and produce semantically equivalent mutants for the purpose of validation. We implemented Aries as a practical validation tool and evaluated it on leading SMT solvers, including Z3 and cvc5. Our experiments demonstrate that Aries effectively identifies bugs, with 27 new issues detected, of which 22 have been confirmed or fixed by developers. Most of these issues involve the rewrite systems, highlighting Aries's strength in exploring the rewrite space.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763093", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Maolin", + "last_name": "Sun", + "institution": "Nanjing University" + }, + { + "first_name": "Yibiao", + "last_name": "Yang", + "institution": "Nanjing University" + }, + { + "first_name": "Jiangchang", + "last_name": "Wu", + "institution": "Nanjing University" + }, + { + "first_name": "Yuming", + "last_name": "Zhou", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/SunYWZ25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763107", + "title": "Correct-by-Construction: Certified Individual Fairness through Neural Network Training", + "abstract": "Fairness in machine learning is more important than ever as ethical concerns continue to grow. Individual fairness demands that individuals differing only in sensitive attributes receive the same outcomes. However, commonly used machine learning algorithms often fail to achieve such fairness. To improve individual fairness, various training methods have been developed, such as incorporating fairness constraints as optimisation objectives. While these methods have demonstrated empirical effectiveness, they lack formal guarantees of fairness. Existing approaches that aim to provide fairness guarantees primarily rely on verification techniques, which can sometimes fail to produce definitive results. Moreover, verification alone does not actively enhance individual fairness during training. To address this limitation, we propose a novel framework that formally guarantees individual fairness throughout training. Our approach consists of two parts, i.e., (1) provably fair initialisation that ensures the model starts in a fair state, and (2) a fairness-preserving training algorithm that maintains fairness as the model learns. A key element of our method is the use of randomised response mechanisms, which protect sensitive attributes while maintaining fairness guarantees. We formally prove that this mechanism sustains individual fairness throughout the training process. Experimental evaluations confirm that our approach is effective, i.e., producing models that are empirically fair and accurate. Furthermore, our approach is much more efficient than the alternative approach based on certified training (which requires neural network verification during training).", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763107", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ruihan", + "last_name": "Zhang", + "institution": "Singapore Management University" + }, + { + "first_name": "Jun", + "last_name": "Sun", + "institution": "Singapore Management University" + } + ], + "dblp_key": "journals/pacmpl/Zhang025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763097", + "title": "PReMM: LLM-Based Program Repair for Multi-method Bugs via Divide and Conquer", + "abstract": "Large-language models (LLMs) have been leveraged to enhance the capability of automated program repair techniques in recent research. While existing LLM-based program repair techniques compared favorably to other techniques based on heuristics, constraint-solving, and learning in producing high-quality patches, they mainly target bugs that can be corrected by changing a single faulty method, which greatly limits the effectiveness of such techniques in repairing bugs that demand patches spanning across multiple methods. In this work, we propose the PReMM technique to effectively propose patches changing multiple methods. PReMM builds on three core component techniques: the faulty method clustering technique to partition the faulty methods into clusters based on the dependence relationship among them, enabling a divide-and-conquer strategy for the repairing task; the fault context extraction technique to gather extra information about the fault context which can be utilized to better guide the diagnosis of the fault and the generation of correct patches; the dual-agent-based patch generation technique that employs two LLM-based agents with different roles to analyze the fault more precisely and generate patches of higher-quality. We have implemented the PReMM technique into a tool with the same name and applied the tool to repair real-world bugs from datasets Defects4J V1.2 and V2.0. PReMM produced correct patches for 307 bugs in total. Compared with ThinkRepair, the state-of-the-art LLM-based program repair technique, PReMM correctly repaired 102 more bugs, achieving an improvement of 49.8%.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763097", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Linna", + "last_name": "Xie", + "institution": "Nanjing University" + }, + { + "first_name": "Zhong", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Yu", + "last_name": "Pei", + "institution": "Hong Kong Polytechnic University" + }, + { + "first_name": "Zhongzhen", + "last_name": "Wen", + "institution": "Nanjing University" + }, + { + "first_name": "Kui", + "last_name": "Liu", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Tian", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/XieL0WL0L25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763098", + "title": "Understanding and Improving Flaky Test Classification", + "abstract": "Regression testing is an essential part of software development, but it suffers from the presence of flaky tests – tests that pass and fail non-deterministically when run on the same code. These unpredictable failures waste developers’ time and often hide real bugs. Prior work showed that fine-tuned large language models (LLMs) can classify flaky tests into different categories with very high accuracy. However, we find that prior approaches over-estimated the accuracy of the models due to incorrect experimental design and unrealistic datasets – making the flaky test classification problem seem simpler than it is. In this paper, we first show how prior flaky test classifiers over-estimate the prediction accuracy due to 1) flawed experiment design and 2) mis-representation of the real distribution of flaky (and non-flaky) tests in their datasets. After we fix the experimental design and construct a more realistic dataset (which we name FlakeBench), the prior state-of-the-art model shows a steep drop in F1-score, from 81.82% down to 56.62%. Motivated by these observations, we develop a new training strategy to fine-tune a flaky test classifier, FlakyLens, that improves the classification F1-score to 65.79% (9.17pp higher than the state-of-the-art). We also compare FlakyLens against recent pre-trained LLMs, such as CodeLlama and DeepSeekCoder, on the same classification task. Our results show that FlakyLens consistently outperforms these models, highlighting that general-purpose LLMs still fall short on this specialized task. Using our improved flaky test classifier, we identify the important tokens in the test code that influence the models in making correct or incorrect predictions. By leveraging attribution scores computed per code token in each test, we investigate the tokens that have higher impact on the flaky test classifier’s decision-making per flaky test category. To assess the influence of these important tokens, we introduce adversarial perturbation using these important tokens into the tests and observe whether the model’s predictions change. Our findings show that, when introducing perturbations using the most important tokens, the classification accuracy can change by as much as -18.37pp. These results highlight that these models still struggle to generalize beyond their training data and rely on identifying category-specific tokens (instead of understanding their semantic context), calling for further research into more robust training methodologies.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763098", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shanto", + "last_name": "Rahman", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Saikat", + "last_name": "Dutta", + "institution": "Cornell University" + }, + { + "first_name": "August", + "last_name": "Shi", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/Rahman0S25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763102", + "title": "Active Learning for Neurosymbolic Program Synthesis", + "abstract": "The goal of active learning for program synthesis is to synthesize the desired program by asking targeted questions that minimize user interaction. While prior work has explored active learning in the purely symbolic setting, such techniques are inadequate for the increasingly popular paradigm of neurosymbolic program synthesis, where the synthesized program incorporates neural components. When applied to the neurosymbolic setting, such techniques can -- and, in practice, do -- return an unintended program due to mispredictions of neural components. This paper proposes a new active learning technique that can handle the unique challenges posed by neural network mispredictions. Our approach is based upon a new evaluation strategy called constrained conformal evaluation (CCE), which accounts for neural mispredictions while taking into account user-provided feedback. Our proposed method iteratively makes CCE more precise until all remaining programs are guaranteed to be observationally equivalent. We have implemented this method in a tool called SmartLabel and experimentally evaluated it on three neurosymbolic domains. Our results demonstrate that SmartLabel identifies the ground truth program for 98% of the benchmarks, requiring under 5 rounds of user interaction on average. In contrast, prior techniques for active learning are only able to converge to the ground truth program for at most 65% of the benchmarks.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763102", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Celeste", + "last_name": "Barnaby", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Qiaochu", + "last_name": "Chen", + "institution": "New York University" + }, + { + "first_name": "Ramya", + "last_name": "Ramalingam", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/BarnabyCRBD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763104", + "title": "ABC: Towards a Universal Code Styler through Model Merging", + "abstract": "Code style transformation models built on code Language Models (code LMs) have achieved remarkable success. However, they typically focus on basis style transformations, where the target style follows a single criterion, and often struggle with combination styles, where the target style involves multiple criteria. In practice, style guides encompass multiple criteria, making the lack of effective combination style transformation a major limitation to their real-world applicability. In this paper, we propose Absent-Basis-Combination (abbreviated as ABC), a novel framework for code style transformation that significantly improves combination style transformation and overcomes the limitations of existing approaches. We implement four variants of ABC with parameter sizes of 0.5B, 1.3B, 1.5B, and 3B, demonstrating consistent superiority over existing approaches across all model sizes in both basis and combination style transformations. Specifically, ABC achieves performance gains of up to 86.70%, and remains superior even when baseline approaches use three times the parameters. Furthermore, to address the lack of high-quality datasets and evaluation metrics, we construct and release a new style transformation dataset, Basis & Combination Code Style (abbreviated as BCCStyle), and introduce Code Sequence, Syntactic, Semantic and Stylistic BLEU (abbreviated as CS4BLEU), a novel code similarity metric that surpasses existing metrics in accuracy and consistency.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763104", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yitong", + "last_name": "Chen", + "institution": "Southeast University" + }, + { + "first_name": "Zhiqiang", + "last_name": "Gao", + "institution": "Southeast University" + }, + { + "first_name": "Chuanqi", + "last_name": "Shi", + "institution": "Southeast University" + }, + { + "first_name": "Baixuan", + "last_name": "Li", + "institution": "Southeast University" + }, + { + "first_name": "Miao", + "last_name": "Gao", + "institution": "Southeast University" + } + ], + "dblp_key": "journals/pacmpl/ChenGSLG25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763103", + "title": "Heap-Snapshot Matching and Ordering using CAHPs: A Context-Augmented Heap-Path Representation for Exact and Partial Path Matching using Prefix Trees", + "abstract": "GraalVM Native Image is increasingly used to optimize the startup performance of applications that run on the Java Virtual Machine (JVM), and particularly of Function-as-a-Service and Serverless workloads. Native Image resorts to Ahead-of-Time (AOT) compilation to produce a binary from a JVM application that contains a snapshot of the pre-initialized heap memory, reducing the initialization time and hence improving startup performance. However, this performance improvement is hindered by page faults that occur when accessing objects in the heap snapshot. Related work has proposed profile-guided approaches to reduce page faults by reordering objects in the heap snapshot of an optimized binary based on the order in which objects are first accessed, obtaining this information by profiling an instrumented binary of the same application. This reordering is effective only if objects in the instrumented binary can be matched to the semantically equivalent ones in the optimized binary. Unfortunately, this is very challenging because objects do not have unique identities and the heap-snapshot contents are not persistent across Native-Image builds of the same program. This work tackles the problem of matching heap snapshots, and proposes a novel approach to improve the mapping between semantically equivalent objects in different binaries of a Native-Image application. We introduce the concept of context-augmented heap path (CAHP)—a list of elements that describes a path to an object stored in the heap snapshot. Our approach associates a CAHP to each object in a way that is as unique as possible. Objects with the same CAHP across different binaries are considered semantically equivalent. Moreover, since some semantically equivalent objects may have different CAHPs in the instrumented and optimized binaries (due to nondeterminism in the image-build process and other factors), we present an approach that finds, for each unmatched CAHP in the optimized binary, the most similar CAHP in the instrumented binary, associating the two objects. We integrate our approach into Native Image, reordering the objects stored in the heap snapshot more efficiently using the improved mapping. Our experiments show that our approach leads to much less page faults (2.98× on average) and considerably improves startup time (1.98× on average) w.r.t. the original Native-Image implementation.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763103", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matteo", + "last_name": "Basso", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Aleksandar", + "last_name": "Prokopec", + "institution": "" + }, + { + "first_name": "Andrea", + "last_name": "Rosà", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "journals/pacmpl/BassoPRB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763106", + "title": "Formalizing Linear Motion G-Code for Invariant Checking and Differential Testing of Fabrication Tools", + "abstract": "The computational fabrication pipeline for 3D printing is much like a compiler --- users design models in Computer Aided Design (CAD) tools that are lowered to polygon meshes to be ultimately compiled to machine code by 3D slicers. For traditional compilers and programming languages, techniques for checking program invariants are well-established. Similarly, methods like differential testing are frequently used to uncover bugs in compilers themselves, which makes them more reliable. The fabrication pipeline would benefit from similar techniques but traditional approaches do not directly apply to the representations used in this domain. Unlike traditional programs, 3D models exist both as geometric objects (a CAD model or a polygon mesh) as well as machine code that ultimately runs on the hardware. The machine code, like in traditional compiling, is affected by many factors like the model, the slicer being used, and numerous user-configurable parameters that control the slicing process. In this work, we propose a new algorithm for lifting G-code (a common language used in many fabrication pipelines) by denoting a G-code program to a set of cuboids, and then defining an approximate point cloud representation for efficiently operating on these cuboids. Our algorithm opens up new opportunities: we show three use cases that demonstrate how it enables (1)~error localization in CAD models through invariant checking, (2)~quantitative comparisons between slicers, and (3)~evaluating the efficacy of mesh repair tools. We present a prototype implementation of our algorithm in a tool, GlitchFinder, and evaluate it on 58 real-world CAD models. Our results show that GlitchFinder is particularly effective in identifying slicing issues due to small features, can highlight differences in how popular slicers (Cura and PrusaSlicer) slice the same model, and can identify cases where mesh repair tools (MeshLab and Meshmixer) introduce new errors during repair.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763106", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yubao", + "last_name": "He", + "institution": "University of Utah" + }, + { + "first_name": "Chandrakana", + "last_name": "Nandi", + "institution": "University of Washington" + }, + { + "first_name": "Sreepathi", + "last_name": "Pai", + "institution": "University of Rochester" + } + ], + "dblp_key": "journals/pacmpl/HeNP25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763109", + "title": "TailTracer: Continuous Tail Tracing for Production Use", + "abstract": "Despite extensive in-house testing, bugs often escape to deployed software. Whenever a failure occurs in production software, it is desirable to collect as much execution information as possible so as to help developers reproduce, diagnose and fix the bug. To reconcile the tension between trace capability, runtime overhead, and trace scale, we propose continuous tail tracing for production use. Instead of capturing only crash stacks, we produce the complete sequence of function calls and returns. Importantly, to avoid the overwhelming stress to I/O, storage, and network transfer caused by the tremendous amount of trace data, we only retain the final segment of trace. To accomplish it, we design a novel trace decoder to support precise tail trace decoding, and an effective path-based instrumentation-site selection algorithm to reduce overhead. We implemented our approach as a tool called TailTracer on top of LLVM, and conducted the evaluations over the SPEC CPU 2017 benchmark suite, the open-source database system, and real-world bugs. The experimental results validate that TailTracer achieves low-overhead tail tracing, while providing more informative trace data than the baseline.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763109", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tianyi", + "last_name": "Liu", + "institution": "Nanjing University" + }, + { + "first_name": "Yi", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Yiyu", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Zhuangda", + "last_name": "Wang", + "institution": "Xiamen University" + }, + { + "first_name": "Rongxin", + "last_name": "Wu", + "institution": "Xiamen University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + }, + { + "first_name": "Zhiqiang", + "last_name": "Zuo", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/LiuLZWWL025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763108", + "title": "Float Self-Tagging", + "abstract": "Dynamic and polymorphic languages attach information, such as types, to run time objects, and therefore adapt the memory layout of values to include space for this information. This makes it difficult to efficiently implement IEEE754 floating-point numbers as this format does not leave an easily accessible space to store type information. The three main floating-point number encodings in use today, tagged pointers, NaN-boxing, and NuN-boxing, have drawbacks. Tagged pointers entail a heap allocation of all float objects, and NaN/NuN-boxing puts additional run time costs on type checks and the handling of other objects. This paper introduces self-tagging, a new approach to object tagging that uses an invertible bitwise transformation to map floating-point numbers to tagged values that contain the correct type information at the correct position in their bit pattern, superimposing both their value and type information in a single machine word. Such a transformation can only map a subset of all floats to correctly typed tagged values, hence self-tagging takes advantage of the non-uniform distribution of floating point numbers used in practice to avoid heap allocation of the most frequently encountered floats. Variants of self-tagging were implemented in two distinct Scheme compilers and evaluated on four microarchitectures to assess their performance and compare them to tagged pointers, NaN-boxing, and NuN-boxing. Experiments demonstrate that, in practice, the approach eliminates heap allocation of nearly all floating-point numbers and provides good execution speed of float-intensive benchmarks in Scheme with a negligible performance impact on other benchmarks, making it an attractive alternative to tagged pointers, alongside NaN-boxing and NuN-boxing.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763108", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Melançon", + "institution": "Université de Montréal" + }, + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Marc", + "last_name": "Feeley", + "institution": "Université de Montréal" + } + ], + "dblp_key": "journals/pacmpl/MelanconSF25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763110", + "title": "Tabby: A Synthesis-Aided Compiler for High-Performance Zero-Knowledge Proof Circuits", + "abstract": "Zero-knowledge proof (ZKP) applications require translating high-level programs into arithmetic circuits—a process that demands both correctness and efficiency. While recent DSLs improve usability, they often yield suboptimal circuits, and hand-optimized implementations remain difficult to construct and verify. We present Tabby, a synthesis-aided compiler that automates the generation of high-performance ZK circuits from high-level code. Tabby introduces a domain-specific intermediate representation designed for symbolic reasoning and applies sketch-based program synthesis to derive optimized low-level implementations. By decomposing programs into reusable components and verifying semantic equivalence via SMT-based reasoning, Tabby ensures correctness while achieving substantial performance improvements. We evaluate Tabby on a suite of real-world ZKP applications and demonstrate significant reductions in proof generation time and circuit size against mainstream ZK compilers.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763110", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Junrui", + "last_name": "Liu", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Jiaxin", + "last_name": "Song", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Yanning", + "last_name": "Chen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Hanzhi", + "last_name": "Liu", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Hongbo", + "last_name": "Wen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Luke", + "last_name": "Pearson", + "institution": "University of French Polynesia" + }, + { + "first_name": "Yanju", + "last_name": "Chen", + "institution": "University of California, Santa Barbara" + }, + { + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" + } + ], + "dblp_key": "journals/pacmpl/LiuSCLWPC025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763112", + "title": "What's in the Box: Ergonomic and Expressive Capture Tracking over Generic Data Structures", + "abstract": "Capturing types in Scala unify static effect and resource tracking with object capabilities, enabling lightweight effect polymorphism with minimal notational overhead. However, their expressiveness has been insufficient for tracking capabilities embedded in generic data structures, preventing them from scaling to the standard collections library – an essential prerequisite for broader adoption. This limitation stems from the inability to name capabilities within the system’s notion of box types. This paper develops System Capless, a new foundation for capturing types that provides the theoretical basis for reach capabilities (rcaps), a novel mechanism for naming “what’s in the box”. The calculus refines the universal capability notion into a new scheme with existential and universal capture set quantification. Intuitively, rcaps witness existentially quantified capture sets inside the boxes of generic types in a way that does not require exposing existential capture types in the surface language. We have fully mechanized the formal metatheory of System Capless in Lean, including proofs of type soundness and scope safety. System Capless supports the same lightweight notation of capturing types plus rcaps, as certified by a type-preserving translation, and also enables fully optional explicit capture-set quantification to increase expressiveness. Finally, we present a full reimplementation of capture checking in Scala 3 based on System Capless and migrate the entire Scala collections library and an asynchronous programming library to evaluate its practicality and ergonomics. Our results demonstrate that reach capabilities enable the adoption of capture checking in production code with minimal changes and minimal-to-zero notational overhead in a vast majority of cases.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763112", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yichen", + "last_name": "Xu", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Cao Nguyen", + "last_name": "Pham", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/XuBPO25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763111", + "title": "Towards a Theoretically-Backed and Practical Framework for Selective Object-Sensitive Pointer Analysis", + "abstract": "Context sensitivity is a foundational technique in pointer analysis, critical and essential for improving precision but often incurring significant efficiency costs. Recent advances focus on selective context-sensitive analysis, where only a subset of program elements, such as methods or heap objects, are analyzed under context sensitivity while the rest are analyzed under context insensitivity, aiming to balance precision with efficiency. However, despite the proliferation of such approaches, existing methods are typically driven by specific code patterns, therefore lacking a comprehensive theoretical foundation for systematically identifying code scenarios that benefit from context sensitivity. This paper presents a novel and foundational theory that establishes a sound over-approximation of the ground truth, i.e., objects that really improve precision under context sensitivity. The proposed theory reformulates the identification of this upper bound into graph reachability problems over a typical Pointer Flow Graph (PFG), each of which can be efficiently solved under context insensitivity, respectively. Building on this theoretical foundation, we introduce our selective context-sensitive analysis approach, Moon. Moon performs both backward and forward traversal on a Variable Flow Graph (VFG), an optimized variant of PFG designed to facilitate efficient traversal. This traversal systematically identifies all objects that improve precision under context sensitivity. Our theoretical foundation, along with carefully designed trade-offs within our approach, allows Moon to limit the scope of objects to be selected, leading to an effective balance between its analysis precision and efficiency. Extensive experiments with Moon across 30 Java programs demonstrate that Moon achieves 37.2X and 382.0X speedups for 2-object-sensitive and 3-object-sensitive analyses, respectively with negligible precision losses of only 0.1% and 0.2%. These results highlight that the balance between efficiency and precision achieved by Moon significantly outperforms all previous approaches.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763111", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "C.", + "last_name": "Zhang", + "institution": "Nanjing University" + }, + { + "first_name": "Longlong", + "last_name": "Lu", + "institution": "Nanjing University" + }, + { + "first_name": "Yifei", + "last_name": "Lu", + "institution": "Nanjing University" + }, + { + "first_name": "Minxue", + "last_name": "Pan", + "institution": "Nanjing University" + }, + { + "first_name": "Xuandong", + "last_name": "Li", + "institution": "Nanjing University" + } + ], + "dblp_key": "journals/pacmpl/ZhangLLPL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763113", + "title": "GALA: A High Performance Graph Neural Network Acceleration LAnguage and Compiler", + "abstract": "Multiple frameworks and optimizations have been proposed for accelerating Graph Neural Network (GNN) workloads over the years, achieving sizable runtime performance improvements. However, we notice that existing systems usually explore optimizing either at the intra-operator level or at the inter-operator level, missing synergies that exist due to their compositions. Further, most existing works focus primarily on optimizing the forward computation of GNNs, often overlooking opportunities for training-specific optimizations. To exploit these missed optimization opportunities, we introduce GALA, a domain-specific language (DSL) and a compiler that allows composing optimizations at different levels. The GALA DSL exposes intra-operator transformations as scheduling commands, while we introduce novel inter-operator transformations as part of the compiler. The composition of these transformations is made possible through the introduction of two novel intermediate representations (IR) in the GALA compiler that tracks and composes transformations at both the intra- and inter-operator levels. Further, the IRs maintain a global view of the GNN program, including its training process. This allows us to introduce training-specific transformations to aggressively optimize GNN training. Our evaluations show that GALA achieves a geo-mean speedup of 2.55× for inference and 2.52× for training across multiple systems, graphs, and GNN models. We also show that GALA performs well across different graph sizes and GNN model configurations, as well as allows users to explore different methods of performing similar optimizations leading to different tradeoff spaces.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763113", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Damitha", + "last_name": "Lenadora", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Nikhil", + "last_name": "Jayakumar", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Chamika", + "last_name": "Sudusinghe", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/LenadoraJSM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763114", + "title": "Choreographic Quick Changes: First-Class Location (Set) Polymorphism", + "abstract": "Choreographic programming is a promising new paradigm for programming concurrent systems where a developer writes a single centralized program that compiles to individual programs for each node. Existing choreographic languages, however, lack critical features integral to modern systems, like the ability of one node to dynamically compute who should perform a computation and send that decision to others. This work addresses this gap with λ QC , the first typed choreographic language with first class process names and polymorphism over both types and (sets of) locations. λ QC also improves expressive power over previous work by supporting algebraic and recursive data types as well as multiply-located values. We formalize and mechanically verify our results in Rocq, including the standard choreographic guarantee of deadlock freedom.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763114", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "A.G.", + "last_name": "Samuelson", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Andrew K.", + "last_name": "Hirsch", + "institution": "Buffalo State University" + }, + { + "first_name": "Ethan", + "last_name": "Cecchetti", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/SamuelsonHC25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763115", + "title": "Structural Abstraction and Refinement for Probabilistic Programs", + "abstract": "In this paper, we present structural abstraction refinement, a novel framework for verifying the threshold problem of probabilistic programs. Our approach represents the structure of a Probabilistic Control-Flow Automaton (PCFA) as a Markov Decision Process (MDP) by abstracting away statement semantics. The maximum reachability of the MDP naturally provides a proper upper bound of the violation probability, termed the structural upper bound . This introduces a fresh “structural” characterization of the relationship between PCFA and MDP, contrasting with the traditional “semantical” view, where the MDP reflects semantics. The method uniquely features a clean separation of concerns between probability and computational semantics that the abstraction focuses solely on probabilistic computation and the refinement handles only the semantics aspect, where the latter allows non-random program verification techniques to be employed without modification. Building upon this feature, we propose a general counterexample-guided abstraction refinement (CEGAR) framework, capable of leveraging established non-probabilistic techniques for probabilistic verification. We explore its instantiations using trace abstraction. Our method was evaluated on a diverse set of examples against state-of-the-art tools, and the experimental results highlight its versatility and ability to handle more flexible structures swiftly.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763115", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guanyan", + "last_name": "Li", + "institution": "University of Oxford" + }, + { + "first_name": "Jiayu", + "last_name": "Li", + "institution": "Beijing Normal University" + }, + { + "first_name": "Zhilei", + "last_name": "Han", + "institution": "Tsinghua University" + }, + { + "first_name": "Peixin", + "last_name": "Wang", + "institution": "East China Normal University" + }, + { + "first_name": "Hongfei", + "last_name": "Fu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Fei", + "last_name": "He", + "institution": "Tsinghua University" + } + ], + "dblp_key": "journals/pacmpl/LiLHW0025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763116", + "title": "Modeling Reachability Types with Logical Relations: Semantic Type Soundness, Termination, Effect Safety, and Equational Theory", + "abstract": "Reachability types are a recent proposal to bring Rust-style reasoning about memory properties to higher-level languages, with a focus on higher-order functions, parametric types, and shared mutable state -- features that are only partially supported by current techniques as employed in Rust. While prior work has established key type soundness results for reachability types using the usual syntactic techniques of progress and preservation, stronger metatheoretic properties have so far been unexplored. This paper presents an alternative semantic model of reachability types using logical relations, providing a framework in which we study key properties of interest: (1) semantic type soundness, including of not syntactically well-typed code fragments, (2) termination, especially in the presence of higher-order mutable references, (3) effect safety, especially the absence of observable mutation, and, finally, (4) program equivalence, especially reordering of non-interfering expressions for parallelization or compiler optimization.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763116", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuyan", + "last_name": "Bao", + "institution": "Augusta University" + }, + { + "first_name": "Songlin", + "last_name": "Jia", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Guannan", + "last_name": "Wei", + "institution": "Tufts University" + }, + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/BaoJ0BR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763118", + "title": "Quantization with Guaranteed Floating-Point Neural Network Classifications", + "abstract": "Despite the wide success of neural networks, their computational cost is very high. Quantization techniques reduce this cost, but it can result in changing the classifications of the original floating-point network, even if the training is quantization-aware. In this work, we rely on verification to design correction systems that detect classification inconsistencies at inference time and eliminate them. The key idea is to overapproximate the space of inconsistent inputs with their maximal classification confidence. The main challenge in computing this confidence is that it involves analyzing a quantized network, which introduces a very high degree of nonlinearity, over all possible inputs. We propose CoMPAQt, an algorithm for computing this confidence. CoMPAQt relies on a novel encoding of quantization in mixed-integer linear programming (MILP), along with customized linear relaxations to reduce the high complexity. To prune the search space, it ties the computations of the quantized network and its floating-point counterpart. Given this confidence, we propose two correction mechanisms. The first mechanism guarantees to return the classification of the floating-point network and relies on networks with increasing bit precisions. The second mechanism mitigates classification inconsistencies by an ensemble of quantized networks. We evaluate our approach on MNIST, ACAS-Xu, and tabular datasets over fully connected and convolutional networks. Results show that our first correction mechanism guarantees 100% consistency with the floating-point network’s classifications while reducing its computational cost by 3.8x, on average. Our second mechanism reaches an almost perfect consistency guarantee in our experiments while reducing the computational cost by 4.1x. Our work is the first to provide a formal guarantee on the classification consistency of a quantized network.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763118", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anan", + "last_name": "Kabaha", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Dana", + "last_name": "Drachsler-Cohen", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/KabahaD25a", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763119", + "title": "A Refinement Methodology for Distributed Programs in Rust", + "abstract": "Refinement relates an abstract system model to a concrete, executable program, such that properties established for the abstract model carry over to the concrete implementation. Refinement has been used successfully in the development of substantial verified systems. Nevertheless, existing refinement techniques have limitations that impede their practical usefulness. Top-down refinement techniques that automatically generate executable code generally produce implementations with sub-optimal performance. Bottom-up refinement allows one to reason about existing, efficient implementations, but imposes strict requirements on the structure of the code, the structure of the refinement proofs, as well as the employed verification logic and tools. In this paper, we present a novel bottom-up refinement methodology that removes these limitations. Our methodology uses the familiar notion of guarded transition systems to express abstract models, but combines guards with a novel notion of locally inductive invariants to relate the abstract model locally to concrete state. This approach is much more flexible than standard coupling invariants; in particular, it supports a wide range of program structures, data representations, and proof structures. We integrate our methodology as a library into Rust, leveraging the Rust type system to reason about ownership of guards. This integration allows one to use our methodology with an off-the-shelf Rust verification tool. It also facilitates practical applications, as we demonstrate on a number of substantial case studies including a concurrent implementation of Memcached.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763119", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aurel", + "last_name": "Bílý", + "institution": "ETH Zurich" + }, + { + "first_name": "João C.", + "last_name": "Pereira", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/BilyP025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763123", + "title": "Efficient Decrease-and-Conquer Linearizability Monitoring", + "abstract": "Linearizability has become the de facto standard for specifying correctness of implementations of concurrent data structures. While formally verifying such implementations remains challenging, linearizability monitoring has emerged as a promising first step to rule out early problems in the development of custom implementations, and serves as a key component in approaches that stress test such implementations. In this work, we undertake an algorithmic investigation of the linearizability monitoring problem, which asks to check if an execution history obtained from a concurrent data structure implementation is linearizable. While this problem is largely understood to be intractable in general, a systematic understanding of when it becomes tractable has remained elusive. We revisit this problem and first present a unified ‘decrease-and-conquer’ algorithmic framework for designing linearizability monitoring. At its heart, this framework asks to identify special linearizability-preserving values in a given history — values whose presence yields an equi-linearizable sub-history (obtained by removing operations of such values), and whose absence indicates non-linearizability. More importantly, we prove that a polynomial time algorithm for the problem of identifying linearizability-preserving values, immediately yields a polynomial time algorithm for the linearizability monitoring problem, while conversely, intractability of this problem implies intractability of monitoring. We demonstrate the effectiveness of our decrease-and-conquer framework by instantiating it for several popular concurrent data types — registers, sets, stacks, queues and priority queues — deriving polynomial time algorithms for them, under the ( unambiguity ) restriction that each insertion to the underlying data structure adds a distinct value. We further optimize these algorithms to achieve log-linear running time through the use of efficient data structures for amortizing the cost of solving induced sub-problems. Our implementation and evaluation on publicly available implementations of concurrent data structures show that our approach scales to very large histories and significantly outperforms existing state-of-the-art tools.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763123", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zheng Han", + "last_name": "Lee", + "institution": "National University of Singapore" + }, + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/Han025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763120", + "title": "Divide and Conquer: A Compositional Approach to Game-Theoretic Security", + "abstract": "We propose a compositional approach to combine and scale automated reasoning in the static analysis of decentralized system security, such as blockchains. Our focus lies in the game-theoretic security analysis of such systems, allowing us to examine economic incentives behind user actions. In this context, it is particularly important to certify that deviating from the intended, honest behavior of the decentralized protocol is not beneficial: as long as users follow the protocol, they cannot be financially harmed, regardless of how others behave. Such an economic analysis of blockchain protocols can be encoded as an automated reasoning problem in the first-order theory of real arithmetic, reducing game-theoretic reasoning to satisfiability modulo theories (SMT). However, analyzing an entire game-theoretic model (called a game) as a single SMT instance does not scale to protocols with millions of interactions. We address this challenge and propose a divide-and-conquer security analysis based on compositional reasoning over games. Our compositional analysis is incremental: we divide games into subgames such that changes to one subgame do not necessitate re-analyzing the entire game, but only the ancestor nodes. Our approach is sound, complete, and effective: combining the security properties of subgames yields security of the entire game. Experimental results show that compositional reasoning discovers intra-game properties and errors while scaling to games with millions of nodes, enabling security analysis of large protocols.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763120", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ivana", + "last_name": "Bocevska", + "institution": "TU Wien" + }, + { + "first_name": "Anja Petković", + "last_name": "Komel", + "institution": "Argomedical (Switzerland)" + }, + { + "first_name": "Laura", + "last_name": "Kovács", + "institution": "TU Wien" + }, + { + "first_name": "Sophie", + "last_name": "Rain", + "institution": "Argomedical (Switzerland)" + }, + { + "first_name": "Michael", + "last_name": "Rawson", + "institution": "University of Southampton" + } + ], + "dblp_key": "journals/pacmpl/BocevskaKKR025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763117", + "title": "Incremental Bidirectional Typing via Order Maintenance", + "abstract": "Live programming environments provide various semantic services, including type checking and evaluation, continuously as the user is editing the program. The live paradigm promises to improve the developer experience, but liveness is an implementation challenge, particularly when working with large programs. This paper specifies and efficiently implements a system that is able to incrementally update type information for a live program in response to fine-grained program edits. This information includes type error marks and information about the expected and actual type of every expression. The system is specified type-theoretically as a small-step dynamics that propagates updates through the marked and annotated program. Most updates flow according to a base bidirectional type system. Additional pointers are maintained to connect bound variables to their binding locations, with type updates traversing these pointers directly. Order maintenance data structures are employed to efficiently maintain these pointers and to prioritize the order of update propagation. We prove this system is equivalent to naive reanalysis in the Agda theorem prover, along with other important metatheoretic properties. We then provide an efficient OCaml implementation, detailing a number of impactful optimizations. We evaluate this implementation's performance with a large stress-test and find that it is able to achieve multiple orders of magnitude speed-up compared to from-scratch reanalysis.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763117", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tod S.", + "last_name": "Porter", + "institution": "University of Michigan" + }, + { + "first_name": "Marisa", + "last_name": "Kirisame", + "institution": "University of Utah" + }, + { + "first_name": "Ivan", + "last_name": "Wei", + "institution": "University of Michigan" + }, + { + "first_name": "Pavel", + "last_name": "Panchekha", + "institution": "University of Utah" + }, + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/PorterKWPO25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763121", + "title": "Automated Discovery of Tactic Libraries for Interactive Theorem Proving", + "abstract": "Enabling more concise and modular proofs is essential for advancing formal reasoning using interactive theorem provers (ITPs). Since many ITPs, such as Rocq and Lean, use tactic-style proofs, learning higher-level custom tactics is crucial for proof modularity and automation. This paper presents a novel approach to tactic discovery, which leverages Tactic Dependence Graphs (TDGs) to identify reusable proof strategies across multiple proofs. TDGs capture logical dependencies between tactic applications while abstracting away irrelevant syntactic details, allowing for both the discovery of new tactics and the refactoring of existing proofs into more modular forms. We have implemented this technique in a tool called TacMineR and compare it against an anti-unification-based approach (Peano) to tactic discovery. Our evaluation demonstrates that TacMineR can learn 3× as many tactics as Peano and reduces the size of proofs by 26% across all benchmarks. Furthermore, our evaluation demonstrates the benefits of learning custom tactics for proof automation, allowing a state-of-the-art proof automation tool to achieve a relative increase of 172% in terms of success rate.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763121", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yutong", + "last_name": "Xin", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Jimmy", + "last_name": "Xin", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Gabriel", + "last_name": "Poesia", + "institution": "Stanford University" + }, + { + "first_name": "Noah D.", + "last_name": "Goodman", + "institution": "Stanford University" + }, + { + "first_name": "Qiaochu", + "last_name": "Chen", + "institution": "New York University" + }, + { + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "journals/pacmpl/XinXPGCD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763122", + "title": "Place Capability Graphs: A General-Purpose Model of Rust's Ownership and Borrowing Guarantees", + "abstract": "Rust’s novel type system has proved an attractive target for verification and program analysis tools, due to the rich guarantees it provides for controlling aliasing and mutability. However, fully understanding, extracting and exploiting these guarantees is subtle and challenging: existing models for Rust’s type checking either support a smaller idealised language disconnected from real-world Rust code, or come with severe limitations in terms of precise modelling of Rust borrows, composite types storing them, function signatures and loops. In this paper, we present Place Capability Graphs : a novel model of Rust’s type-checking results, which lifts these limitations, and which can be directly calculated from the Rust compiler’s own programmatic representations and analyses. We demonstrate that our model supports over 97% of Rust functions in the most popular public crates, and show its suitability as a general-purpose basis for verification and program analysis tools by developing promising new prototype versions of the existing Flowistry and Prusti tools.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763122", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Grannan", + "institution": "University of British Columbia" + }, + { + "first_name": "Aurel", + "last_name": "Bílý", + "institution": "ETH Zurich" + }, + { + "first_name": "Jonáš", + "last_name": "Fiala", + "institution": "ETH Zurich" + }, + { + "first_name": "Jasper", + "last_name": "Geer", + "institution": "University of British Columbia" + }, + { + "first_name": "Markus de", + "last_name": "Medeiros", + "institution": "New York University" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/GrannanBFGM0S25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763124", + "title": "Debugging WebAssembly? Put Some Whamm on It!", + "abstract": "Debugging and monitoring programs are integral to engineering and deploying software. Dynamic analyses monitor applications through source code or IR injection, machine code or bytecode rewriting, virtual machine APIs, or direct hardware support. While these techniques are viable within their respective domains, common tooling across techniques is rare, leading to fragmentation of skills, duplicated efforts, and inconsistent feature support. We address this problem in the WebAssembly ecosystem with Whamm, an instrumentation framework for Wasm that uses engine-level probing and has a bytecode rewriting fallback to promote portability. Whamm solves three problems: 1) tooling fragmentation, 2) prohibitive instrumentation overhead of general-purpose frameworks, and 3) tedium of tailoring low-level high-performance mechanisms. Whamm provides fully-programmable instrumentation with declarative match rules, static and dynamic predication, automatic state reporting, and user library support, achieving high performance through compiler and engine optimizations. The Whamm engine API allows instrumentation to be provided to a Wasm engine as Wasm code, reusing existing engine optimizations and unlocking new ones, most notably intrinsification , to minimize overhead. A key insight of our work is that explicitly requesting program state in match rules, rather than reflection, enables the engine to efficiently bundle arguments and even inline compiled probe logic. Whamm streamlines the tooling effort, as its bytecode-rewriting target can run instrumented programs everywhere, lowering fragmentation and advancing the state of the art for engine support. We evaluate Whamm with case studies of non-trivial monitors and show it is expressive, powerful, and efficient.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763124", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Elizabeth", + "last_name": "Gilbert", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Matthew", + "last_name": "Schneider", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Zixi", + "last_name": "An", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Suhas", + "last_name": "Thalanki", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Wavid", + "last_name": "Bowman", + "institution": "University of Florida" + }, + { + "first_name": "Anbin", + "last_name": "Bai", + "institution": "New York University" + }, + { + "first_name": "Ben L.", + "last_name": "Titzer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Heather", + "last_name": "Miller", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/GilbertSATBBTM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763126", + "title": "Flix: A Design for Language-Integrated Datalog", + "abstract": "We present a comprehensive overview of the Datalog facilities in the Flix programming language. We show how programmers can write functions implemented as Datalog programs and we demonstrate how to build modular and reusable families of Datalog programs using first-class Datalog program values, rho abstraction, parametric polymorphism, and type classes. We describe several features that improve the ergonomics, flexibility, and expressive power of Datalog programming in Flix, including the inject and query program constructs, head and guard expressions, functional predicates, lattice semantics, and more. We illustrate Datalog programming in Flix with several applications, including implementations of Ullman's algorithm to stratify Datalog programs, the Ford-Fulkerson algorithm for maximum flow, and the IFDS and IDE algorithms for context-sensitive program analysis. The implementations of IFDS and IDE fulfill a long-term goal: to have fully modular, polymorphic, typed, and declarative formulations of these algorithms that can be instantiated with any abstract domain.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763126", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/MadsenL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763125", + "title": "Sound and Modular Activity Analysis for Automatic Differentiation in MLIR", + "abstract": "Computing derivatives is paramount for multiple domains ranging from training neural networks to precise climate simulations. While derivatives can be generated by Automatic Differentiation (AD) tools, they often require aggressive optimization to avoid compromising program performance. One of the central optimizations consists of identifying inactive operations that do not contribute to the partial derivatives of interest. Multiple tools provide activity analyses for a variety of input languages, though often with only informal correctness guarantees. This paper formally defines activity analysis for AD as an abstract interpretation, proves its soundness, and implements it within the MLIR compiler infrastructure. To account for MLIR’s genericity, a subset of MLIR’s internal representation amenable to AD is formalized for the first time. Furthermore, the paper proposes a sound intraprocedural approximation of the whole-program activity analysis via function summaries along with a mechanism to automatically derive these summaries from function definitions. The implementation is evaluated on a differentiation-specific benchmark suite. It achieves a 1.24 geometric mean speedup on CPU and a 1.7 geometric mean speedup on GPU in the runtime of generated programs, when compared to a baseline that does not use activity analysis. The evaluation also demonstrates that the intraprocedural analysis with function summaries proves inactive 100% of instructions proven inactive by the whole-program analysis.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763125", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mai Jacob", + "last_name": "Peng", + "institution": "McGill University" + }, + { + "first_name": "William S.", + "last_name": "Moses", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Oleksandr", + "last_name": "Zinenko", + "institution": "Constellium (France)" + }, + { + "first_name": "Christophe", + "last_name": "Dubach", + "institution": "Mila - Quebec Artificial Intelligence Institute" + } + ], + "dblp_key": "journals/pacmpl/PengMZD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763127", + "title": "SafeTree: Expressive Tree Policies for Microservices", + "abstract": "A microservice-based application is composed of multiple self-contained components called microservices, and controlling inter-service communication is important for enforcing safety properties. Presently, inter-service communication is configured using microservice deployment tools. However, such tools only support a limited class of single-hop policies, which can be overly permissive because they ignore the rich service tree structure of microservice calls. Policies that can express the service tree structure can offer development and security teams more fine-grained control over communication patterns. To this end, we design an expressive policy language to specify service tree structures, and we develop a visibly pushdown automata-based dynamic enforcement mechanism to enforce service tree policies. Our technique is non-invasive: it does not require any changes to service implementations, and does not require access to microservice code. To realize our method, we build a runtime monitor on top of a service mesh, an emerging network infrastructure layer that can control inter-service communication during deployment. In particular, we employ the programmable network traffic filtering capabilities of Istio, a popular service mesh implementation, to implement an online and distributed monitor. Our experiments show that our monitor can enforce rich safety properties while adding minimal latency overhead on the order of milliseconds.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763127", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Karuna", + "last_name": "Grewal", + "institution": "Cornell University" + }, + { + "first_name": "P. Brighten", + "last_name": "Godfrey", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/GrewalGH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763128", + "title": "TraceLinking Implementations with Their Verified Designs", + "abstract": "An important correctness gap exists between formally verifiable distributed system designs and their implementations. Recently proposed work bridges this gap by automatically extracting, or compiling, an implementation from the formally-verified design. The runtime behavior of this compiled implementation, however, may deviate from its design. For example, the compiler may contain bugs, the design may make incorrect assumptions about the deployment environment, or the implementation might be misconfigured. In this paper we develop TraceLink, a methodology to detect such deviations through trace validation. TraceLink maps traces, that capture an execution's behavior, to the corresponding formal design. Unlike previous work on trace validation, our approach is completely automated. We implement TraceLink for PGo, a compiler from Modular PlusCal to both TLA+ and Go. We present a formal semantics for interpreting execution traces as TLA+, along with a templatization strategy to minimize the size of the TLA+ tracing specification. We also present a novel trace path validation strategy, called sidestep, which detects bugs faster and with little additional overhead. We evaluated TraceLink on several distributed systems, including an MPCal implementation of a Raft key-value store. Our evaluation demonstrates that TraceLink is able to find 9 previously undetected and diverse bugs in PGo's TCB, including a bug in the PGo compiler itself. We also show the effectiveness of the templatization approach and the sidestep path validation strategy.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763128", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Finn", + "last_name": "Hackett", + "institution": "University of British Columbia" + }, + { + "first_name": "Ivan", + "last_name": "Beschastnikh", + "institution": "University of British Columbia" + } + ], + "dblp_key": "journals/pacmpl/HackettB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763129", + "title": "Universal Scalability in Declarative Program Analysis (with Choice-Based Combination Pruning)", + "abstract": "Datalog engines for fixpoint evaluation have brought great benefits to static program analysis over the past decades. A Datalog specification of an analysis allows a declarative, easy-to-maintain specification, without sacrificing performance, and indeed often achieving significant speedups compared to hand-coded algorithms. However, these benefits come with a certain loss of control. Datalog evaluation is bottom-up, meaning that all inferences (from a set of initial facts) are performed and all their conclusions are outputs of the computation. In practice, virtually every program analysis expressed in Datalog becomes unscalable for some inputs, due to the worst-case blowup of computing all results, even when a partial answer would have been perfectly satisfactory. In this work, we present a simple, uniform, and elegant solution to the problem, with great practical effectiveness and application to virtually any Datalog-based analysis. The approach consists of leveraging the choice construct, supported natively in modern Datalog engines like Souffle. The choice construct allows the definition of functional dependencies in a relation and has been used in the past for expressing worklist algorithms. We show a near-universal construction that allows the choice construct to flexibly limit evaluation of predicates. The technique is applicable to practically any analysis architecture imaginable, since it adaptively prunes evaluation results when a (programmer-controlled) projection of a relation exceeds a desired cardinality. We apply the technique to probably the largest, pre-existing Datalog analysis frameworks in existence: Doop (for Java bytecode) and the main client analyses from the Gigahorse framework (for Ethereum smart contracts). Without needing to understand the existing analysis logic and with minimal, local-only changes, the performance of each framework increases dramatically, by over 20x for the hardest inputs, with near-negligible sacrifice in completeness.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763129", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anastasios", + "last_name": "Antoniadis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Ilias", + "last_name": "Tsatiris", + "institution": "" + }, + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "University of Malta" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "journals/pacmpl/AntoniadisTGS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763130", + "title": "Verifying Asynchronous Hyperproperties in Reactive Systems", + "abstract": "Hyperproperties are system properties that relate multiple execution traces and commonly occur when specifying information-flow and security policies. Logics like HyperLTL utilize explicit quantification over execution traces to express temporal hyperproperties in reactive systems, i.e., hyperproperties that reason about the temporal behavior along infinite executions. An often unwanted side-effect of such logics is that they compare the quantified traces synchronously. This prohibits the logics from expressing properties that compare multiple traces asynchronously, such as Zdancewic and Myers’s observational determinism, McLean’s non-inference, or stuttering refinement. We study the model-checking problem for a variant of asynchronous HyperLTL (A-HLTL), a temporal logic that can express hyperproperties where multiple traces are compared across timesteps. In addition to quantifying over system traces, A-HLTL features secondary quantification over stutterings of these traces. Consequently, A-HLTL allows for a succinct specification of many widely used asynchronous hyperproperties. Model-checking A-HLTL requires finding suitable stutterings, which, thus far, has been only possible for very restricted fragments or terminating systems. In this paper, we propose a novel game-based approach for the verification of arbitrary ∀ * ∃ * A-HLTL formulas in reactive systems. In our method, we consider the verification as a game played between a verifier and a refuter, who challenge each other by controlling parts of the underlying traces and stutterings. A winning strategy for the verifier then corresponds to concrete witnesses for existentially quantified traces and asynchronous alignments for existentially quantified stutterings. We identify fragments for which our game-based interpretation is complete and thus constitutes a finite-state decision procedure. We contribute a prototype implementation for finite-state systems and report on encouraging experimental results.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763130", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Raven", + "last_name": "Beutner", + "institution": "Helmholtz Center for Information Security" + }, + { + "first_name": "Bernd", + "last_name": "Finkbeiner", + "institution": "Helmholtz Center for Information Security" + } + ], + "dblp_key": "journals/pacmpl/BeutnerF25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763131", + "title": "Synthesizing Implication Lemmas for Interactive Theorem Proving", + "abstract": "Interactive theorem provers (ITP) enable programmers to formally verify properties of their software systems. One burden for users of ITPs is identifying the necessary helper lemmas to complete a proof, for example those that define key inductive invariants. Existing approaches to lemma synthesis for ITPs have limited, if any, support for synthesizing implications : lemmas of the form P 1 ∧ ⋯ ∧ P n ⇒ Q . In this paper, we propose a technique and associated tool for synthesizing useful implication lemmas. Our approach employs a form of data-driven invariant inference to explore strengthenings of the current proof state, based on sample valuations of the current goal and assumptions. We have implemented our approach in a Rocq tactic called dilemma. We demonstrate its effectiveness in synthesizing necessary helper lemmas for proofs from the Verified Functional Algorithms textbook as well as from prior benchmark suites for lemma synthesis.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763131", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ana", + "last_name": "Brendel", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Aishwarya", + "last_name": "Sivaraman", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "journals/pacmpl/BrendelSM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763132", + "title": "AccelerQ: Accelerating Quantum Eigensolvers with Machine Learning on Quantum Simulators", + "abstract": "We present AccelerQ, a framework for automatically tuning quantum eigensolver (QE) implementations–these are quantum programs implementing a specific QE algorithm–using machine learning and search-based optimisation. Rather than redesigning quantum algorithms or manually tweaking the code of an already existing implementation, AccelerQ treats QE implementations as black-box programs and learns to optimise their hyperparameters to improve accuracy and efficiency by incorporating search-based techniques and genetic algorithms (GA) alongside ML models to efficiently explore the hyperparameter space of QE implementations and avoid local minima. Our approach leverages two ideas: 1) train on data from smaller, classically simulable systems, and 2) use program-specific ML models, exploiting the fact that local physical interactions in molecular systems persist across scales, supporting generalisation to larger systems. We present an empirical evaluation of AccelerQ on two fundamentally different QE implementations: ADAPT-QSCI and QCELS. For each, we trained a QE predictor model, a lightweight XGBoost Python regressor, using data extracted classically from systems of up to 16 qubits. We deployed the model to optimise hyperparameters for executions on larger systems of 20-, 24-, and 28-qubit Hamiltonians, where direct classical simulation becomes impractical. We observed a reduction in error from 5.48% to 5.3% with only the ML model and further to 5.05% with GA for ADAPT-QSCI, and from 7.5% to 6.5%, with no additional gain with GA for QCELS. Given inconclusive results for some 20- and 24-qubit systems, we recommend further analysis of training data concerning Hamiltonian characteristics. Nonetheless, our results highlight the potential of ML and optimisation techniques for quantum programs and suggest promising directions for integrating software engineering methods into quantum software stacks.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763132", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Avner", + "last_name": "Bensoussan", + "institution": "King's College London" + }, + { + "first_name": "Elena", + "last_name": "Chachkarova", + "institution": "King's College London" + }, + { + "first_name": "Karine", + "last_name": "Even-Mendoza", + "institution": "King's College London" + }, + { + "first_name": "Sophie", + "last_name": "Fortz", + "institution": "King's College London" + }, + { + "first_name": "Connor", + "last_name": "Lenihan", + "institution": "King's College London" + } + ], + "dblp_key": "journals/pacmpl/BensoussanCEFL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763133", + "title": "Modular Reasoning about Global Variables and Their Initialization", + "abstract": "Many imperative programming languages offer global variables to implement common functionality such as global caches and counters. Global variables are typically initialized by module initializers (e.g., static initializers in Java), code blocks that are executed automatically by the runtime system. When or in what order these initializers run is typically not known statically and modularly. For instance in Java, initialization is triggered dynamically upon the first use of a class, while in Go, the order depends on all packages of a program. As a result, reasoning modularly about global variables and their initialization is difficult, especially because module initializers may perform arbitrary side effects and may have cyclic dependencies. Consequently, existing modular verification techniques either do not support global state or impose drastic restrictions that are not satisfied by mainstream languages and programs. In this paper, we present the first practical verification technique to reason formally and modularly about global state and its initialization. Our technique is based on separation logic and uses module invariants to specify ownership and values of global variables. A partial order on modules and methods allows us to reason modularly about when a module invariant may be soundly assumed to hold, irrespective of when exactly the module initializer establishing it runs. Our technique supports both thread-local and shared global state. We formalize it as a program logic in Iris and prove its soundness in Rocq. We make only minimal assumptions about the initialization semantics, making our technique applicable to a wide range of programming languages. We implemented our technique in existing verifiers for Java and Go and demonstrate its effectiveness on typical uses cases of global state as well as a substantial codebase implementing an Internet router.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763133", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "João C.", + "last_name": "Pereira", + "institution": "ETH Zurich" + }, + { + "first_name": "Isaac van", + "last_name": "Bakel", + "institution": "ETH Zurich" + }, + { + "first_name": "Patricia", + "last_name": "Firlejczyk", + "institution": "ETH Zurich" + }, + { + "first_name": "Marco", + "last_name": "Eilers", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/PereiraBFE025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763135", + "title": "A Language for Quantifying Quantum Network Behavior", + "abstract": "Quantum networks have capabilities that are impossible to achieve using only classical information. They connect quantum capable nodes, with their fundamental unit of communication being the Bell pair , a pair of entangled quantum bits. Due to the nature of quantum phenomena, Bell pairs are fragile and difficult to transmit over long distances, thus requiring a network of repeaters along with dedicated hardware and software to ensure the desired results. The intrinsic challenges associated with quantum networks, such as competition over shared resources and high probabilities of failure, require quantitative reasoning about quantum network protocols. This paper develops PBKAT, an expressive language for specification, verification and optimization of quantum network protocols for Bell pair distribution. Our language is equipped with primitives for expressing probabilistic and possibilistic behaviors, and with semantics modeling protocol executions. We establish the properties of PBKAT’s semantics, which we use for quantitative analysis of protocol behavior. We further implement a tool to automate PBKAT’s usage, which we evaluated on real-world protocols drawn from the literature. Our results indicate that PBKAT is well suited for both expressing real-world quantum network protocols and reasoning about their quantitative properties.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763135", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anita", + "last_name": "Buckley", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Pavel", + "last_name": "Chuprikov", + "institution": "Télécom Paris" + }, + { + "first_name": "Rodrigo", + "last_name": "Otoni", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Robert", + "last_name": "Soulé", + "institution": "Yale University" + }, + { + "first_name": "Robert W.", + "last_name": "Rand", + "institution": "University of Chicago" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "journals/pacmpl/BuckleyCOS0E25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763139", + "title": "Work Packets: A New Abstraction for GC Software Engineering, Optimization, and Innovation", + "abstract": "Garbage collection (GC) implementations must meet efficiency and maintainability requirements, which are often perceived to be at odds. Moreover, the desire for efficiency typically sacrifices agility, undermining rapid development and innovation, with unintended consequences on longer-term performance aspirations. Prior GC implementations struggle to: i) maximize efficiency, parallelism, and hardware utilization, while ii) correctly and elegantly implementing optimizations and scheduling constraints. This struggle is reflected in today’s implementations, which tend to be monolithic and depend on coarse phase-based synchronization. This paper presents a new design for GC implementations that emphasizes both agility and efficiency. The design simplifies and unifies all GC tasks into work packets which define: i) work items, ii) kernels that process them, and iii) scheduling constraints. Our simple insights are that execution is dominated by a few very small, heavily executed kernels, and that GC implementations are high-level algorithms that orchestrate vast numbers of performance-critical work items. Work packets comprise groups of like work items, such as the scanning of a thread’s stack or the tracing of a single object in a multi-million object heap. The kernel attached to a packet specifies how to process items within the packet, such as how to scan a stack, or how to trace an object. The scheduling constraints express dependencies, e.g. all mutators must stop before copying any objects. Fully parallel activities, such as scanning roots and performing a transitive closure, proceed with little synchronization. The implementation of a GC algorithm reduces to declaring required work packets, their kernels, and dependencies. The execution model operates transparently of GC algorithms and work packet type. We broaden the scope of work-stealing, applying it to any type of GC work and introduce a novel two-tier work-stealing algorithm to further optimize parallelism at fine granularity. We show the software engineering benefits of this design via eight collectors that use 23 common work packet types in the MMTk GC framework. We use the LXR collector to show that the work packet abstraction supports innovation and high performance: i) comparing versions of LXR, work packets deliver performance benefits over a phase-based approach, and ii) LXR with work packets outperforms the highly-tuned latest (OpenJDK 24), state-of-the-art G1 garbage collector. We thus demonstrate that work packets achieve high performance, while simplifying GC implementation, making them inherently easier to optimize and verify.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763139", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wenyu", + "last_name": "Zhao", + "institution": "Australian National University" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/ZhaoBM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763134", + "title": "Modal Abstractions for Virtualizing Memory Addresses", + "abstract": "Virtual memory management (VMM) code is a critical piece of general-purpose OS kernels, but verification of this functionality is challenging due to the complexity of the hardware interface (the page tables are updated via writes to those memory locations, using addresses which are themselves virtualized). Prior work on verification of VMM code has either only handled a single address space, or trusted significant pieces of assembly code. In this paper, we introduce a modal abstraction to describe the truth of assertions relative to a specific virtual address space: [r]P indicating that P holds in the virtual address space rooted at r. Such modal assertions allow different address spaces to refer to each other, enabling complete verification of instruction sequences manipulating multiple address spaces. Using them effectively requires working with other assertions, such as points-to assertions about memory contents — which implicitly depend on the address space they are used in. We therefore define virtual points-to assertions to definitionally mimic hardware address translation, relative to a page table root. We demonstrate our approach with challenging fragments of VMM code showing that our approach handles examples beyond what prior work can address, including reasoning about a sequence of instructions as it changes address spaces. Our results are formalized for a RISC-like fragment of x86-64 assembly in Rocq.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763134", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ismail", + "last_name": "Kuru", + "institution": "Drexel University" + }, + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "Drexel University" + } + ], + "dblp_key": "journals/pacmpl/0001G25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763138", + "title": "Encode the ∀∃ Relational Hoare Logic into Standard Hoare Logic", + "abstract": "Verifying a real-world program’s functional correctness can be decomposed into (1) a refinement proof showing that the program implements a more abstract high-level program and (2) an algorithm correctness proof at the high level. Relational Hoare logic serves as a powerful tool to establish refinement but often necessitates formalization beyond standard Hoare logic. Particularly in the nondeterministic setting, the ∀∃ relational Hoare logic is required. Existing approaches encode this logic into a Hoare logic with ghost states and invariants, yet these extensions significantly increase formalization complexity and soundness proof overhead. This paper proposes a generic encoding theory that reduces the ∀∃ relational Hoare logic to standard (unary) Hoare logic. Precisely, we propose to redefine the validity of relational Hoare triples while preserving the original proof rules and then encapsulate the ∀∃ pattern within assertions. We have proved that the validity of encoded standard Hoare triples is equivalent to the validity of the desired relational Hoare triples. Moreover, the encoding theory demonstrates how common relational Hoare logic proof rules are indeed special cases of standard Hoare logic proof rules, and relational proof steps correspond to standard proof steps. Our theory enables standard Hoare logic to prove ∀∃ relational properties by defining a predicate Exec , without requiring modifications to the logic framework or re-verification of soundness.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763138", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sheng-jia", + "last_name": "Wu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Xiwei", + "last_name": "Wu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Qinxiang", + "last_name": "Cao", + "institution": "Shanghai Jiao Tong University" + } + ], + "dblp_key": "journals/pacmpl/WuWC25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763136", + "title": "MIO: Multiverse Debugging in the Face of Input/Output", + "abstract": "Debugging non-deterministic programs on microcontrollers is notoriously challenging, especially when bugs manifest in unpredictable, input-dependent execution paths. A recent approach, called multiverse debugging, makes it easier to debug non-deterministic programs by allowing programmers to explore all potential execution paths. Current multiverse debuggers enable both forward and backward traversal of program paths, and some facilitate jumping to any previously visited states, potentially branching into alternative execution paths within the state space. Unfortunately, debugging programs that involve input/output operations using existing multiverse debuggers can reveal inaccessible program states, i.e. states which are not encountered during regular execution. This can significantly hinder the debugging process, as the programmer may spend substantial time exploring and examining inaccessible program states, or worse, may mistakenly assume a bug is present in the code, when in fact, the issue is caused by the debugger. This paper presents a novel approach to multiverse debugging, which can accommodate a broad spectrum of input/output operations. We provide the semantics of our approach and prove the correctness of our debugger, ensuring that despite having support for a wide range of input/output operations the debugger will only explore those program states which can be reached during regular execution. We have developed a prototype, called MIO, leveraging the WARDuino WebAssembly virtual machine to demonstrate the feasibility and efficiency of our techniques. As a demonstration of the approach we highlight a color dial built with a Lego Mindstorms motor, and color sensor, providing a tangible example of how our approach enables multiverse debugging for programs running on an STM32 microcontroller.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763136", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Tom", + "last_name": "Lauwaerts", + "institution": "Ghent University" + }, + { + "first_name": "Maarten", + "last_name": "Steevens", + "institution": "Ghent University" + }, + { + "first_name": "Christophe", + "last_name": "Scholliers", + "institution": "Ghent University" + } + ], + "dblp_key": "journals/pacmpl/LauwaertsSS25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763137", + "title": "Cost of Soundness in Mixed-Precision Tuning", + "abstract": "Numerical code is often executed repetitively and on hardware with limited resources, which makes it a perfect target for optimizations. One of the most effective ways to boost performance—especially in terms of runtime—is by reducing the precision of computations. However, low precision can introduce significant rounding errors, potentially compromising the correctness of results. Mixed-precision tuning addresses this trade-off by assigning the lowest possible precision to a subset of variables and arithmetic operations in the program while ensuring that the overall error remains within acceptable bounds. State-of-the-art tools validate the accuracy of optimized programs using either sound static analysis or dynamic sampling. While sound methods are often considered safer but overly conservative, and dynamic methods are more aggressive and potentially more effective, the question remains: how do these approaches compare in practice? In this paper, we present the first comprehensive evaluation of existing mixed-precision tuning tools for floating-point programs, offering a quantitative comparison between sound static and (unsound) dynamic approaches. We measure the trade-offs between performance gains, utilizing optimization potential, and the soundness guarantees on the accuracy---what we refer to as the cost of soundness . Our experiments on the standard FPBench benchmark suite challenge the common belief that dynamic optimizers consistently generate faster programs. In fact, for small straight-line numerical programs, we find that sound tools enhanced with regime inference match or outperform dynamic ones, while providing formal correctness guarantees, albeit at the cost of increased optimization time. Standalone sound tools, however, are overly conservative, especially when accuracy constraints are tight; whereas dynamic tools are consistently effective for different targets, but exceed the maximum allowed error by up to 9 orders of magnitude.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763137", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Anastasia", + "last_name": "Isychev", + "institution": "TU Wien" + }, + { + "first_name": "Debasmita", + "last_name": "Lohar", + "institution": "Karlsruhe Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/IsychevL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763141", + "title": "ApkDiffer: Accurate and Scalable Cross-Version Diffing Analysis for Android Applications", + "abstract": "Software diffing (a.k.a., code alignment) is a fundamental technique to differentiate similar and dissimilar code pieces between two given software products. It can enable various kinds of critical security analysis, e.g., n-day bug localization, software plagiarism detection, etc. To date, many diffing tools have been proposed dedicated to aligning binaries. However, few research efforts have elaborated on cross-version Android app diffing, largely hindering the security assessment of wild apps. To sum up, existing diffing works usually establish scalability-oriented alignment algorithms, and suffer from significant alignment errors when handling the large codebases of modern apps. To fill this gap, we propose ApkDiffer, a method-level (i.e., function-level) diffing tool dedicated to aligning versions of the same closed-source Android app. ApkDiffer achieves a good balance between scalability and effectiveness, by featuring a two-stage decomposition-based alignment solution. It first decomposes the codebase of each app version, respectively, into multiple functionality units; then tries to precisely align methods that serve equivalent app functionalities across versions. In evaluation, the results show that ApkDiffer noticeably outperforms existing alignment algorithms in precision and recall, while still having a satisfactory time cost. In addition, we used ApkDiffer to track the one-year evolution of 100 popular Google Play apps. By pinpointing the detailed code locations where app versions deviate in privacy collection, we convincingly revealed that app updates may pose ever-evolving privacy threats to end-users.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763141", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jiarun", + "last_name": "Dai", + "institution": "Fudan University" + }, + { + "first_name": "Mingyuan", + "last_name": "Luo", + "institution": "Fudan University" + }, + { + "first_name": "Yuan", + "last_name": "Zhang", + "institution": "Fudan University" + }, + { + "first_name": "Min", + "last_name": "Yang", + "institution": "Fudan University" + }, + { + "first_name": "Minghui", + "last_name": "Yang", + "institution": "Fudan University" + } + ], + "dblp_key": "journals/pacmpl/DaiLZ0Y25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763140", + "title": "Abstract Interpretation of Temporal Safety Effects of Higher Order Programs", + "abstract": "This paper describes a new abstract interpretation-based approach to verify temporal safety properties of recursive, higher-order programs. While prior works have provided theoretical impact and some automation, they have had limited scalability. We begin with a new automata-based \"abstract effect domain\" for summarizing context-sensitive dependent effects, capable of abstracting relations between the program environment and the automaton control state. Our analysis includes a new transformer for abstracting event prefixes to automatically computed context-sensitive effect summaries, and is instantiated in a type-and-effect system grounded in abstract interpretation. Since the analysis is parametric on the automaton, we next instantiate it to a broader class of history/register (or \"accumulator\") automata, beyond finite state automata to express some context-free properties, input-dependency, event summation, resource usage, cost, equal event magnitude, etc. We implemented a prototype evDrift that computes dependent effect summaries (and validates assertions) for OCaml-like recursive higher-order programs. As a basis of comparison, we describe reductions to assertion checking for higher-order but effect-free programs, and demonstrate that our approach outperforms prior tools Drift, RCaml/Spacer, MoCHi, and ReTHFL. Overall, across a set of 23 benchmarks, Drift verified 12 benchmarks, RCaml/Spacer verified 6, MoCHi verified 11, ReTHFL verified 18, and evDrift verified 21; evDrift also achieved a 6.3x, 5.3x, 16.8x, and 6.4x speedup over Drift, RCaml/Spacer, MoCHi, and ReTHFL, respectively, on those benchmarks that both tools could solve.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763140", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mihai", + "last_name": "Nicola", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Chaitanya", + "last_name": "Agarwal", + "institution": "New York University" + }, + { + "first_name": "Eric", + "last_name": "Koskinen", + "institution": "Stevens Institute of Technology" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "journals/pacmpl/NicolaAKW25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763142", + "title": "Software Model Checking via Summary-Guided Search", + "abstract": "In this work, we describe a new software model-checking algorithm called GPS. GPS treats the task of model checking a program as a directed search of the program states, guided by a compositional, summary-based static analysis. The summaries produced by static analysis are used both to prune away infeasible paths and to drive test generation to reach new, unexplored program states. GPS can find both proofs of safety and counter-examples to safety (i.e., inputs that trigger bugs), and features a novel two-layered search strategy that renders it particularly efficient at finding bugs in programs featuring long, input-dependent error paths. To make GPS refutationally complete (in the sense that it will find an error if one exists, if it is allotted enough time), we introduce an instrumentation technique and show that it helps GPS achieve refutation-completeness without sacrificing overall performance. We benchmarked GPS on a diverse suite of benchmarks including programs from the Software Verification Competition (SV-COMP), from prior literature, as well as synthetic programs based on examples in this paper. We found that our implementation of GPS outperforms state-of-the-art software model checkers (including the top performers in SV-COMP ReachSafety-Loops category), both in terms of the number of benchmarks solved and in terms of running time.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763142", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ruijie", + "last_name": "Fang", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/FangKR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763143", + "title": "Opportunistically Parallel Lambda Calculus", + "abstract": "Scripting languages are widely used to compose external calls such as native libraries and network services. In such scripts, execution time is often dominated by waiting for these external calls, rendering traditional single-language optimizations ineffective. To address this, we propose a novel opportunistic evaluation strategy for scripting languages based on a core lambda calculus that automatically dispatches independent external calls in parallel and streams their results. We prove that our approach is confluent, ensuring that it preserves the programmer’s original intent, and that it eventually executes every external call. We implement this approach in a scripting language called Opal. We demonstrate the versatility and performance of Opal, focusing on programs that invoke heavy external computation through the use of large language models (LLMs) and other APIs. Across five scripts, we compare to several state-of-the-art baselines and show that opportunistic evaluation improves total running time (up to 6.2×) and latency (up to 12.7×) compared to standard sequential Python, while performing very close (between 1.3% and 18.5% running time overhead) to hand-tuned manually optimized asynchronous Rust. For Tree-of-Thoughts, a prominent LLM reasoning approach, we achieve a 6.2× performance improvement over the authors’ own implementation.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763143", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Stephen", + "last_name": "Mell", + "institution": "Philips (Finland)" + }, + { + "first_name": "Κωνσταντίνος", + "last_name": "Καλλάς", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/MellKZB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763144", + "title": "A Lightweight Type-and-Effect System for Invalidation Safety: Tracking Permanent and Temporary Invalidation with Constraint-Based Subtype Inference", + "abstract": "In many programming paradigms, some program entities are only valid within delimited regions of the program, such as resources that might be automatically deallocated at the end of specific scopes. Outside their live scopes, the corresponding entities are no longer valid – they are permanently invalidated. Sometimes, even within the live scope of a resource, the use of that resource must become temporarily invalid, such as when iterating over a mutable collection, as mutating the collection during iteration might lead to undefined behavior. However, high-level general-purpose programming languages rarely allow this information to be reflected on the type level. Most previously proposed solutions to this problem have relied on restricting either the aliasing or the capture of variables, which can reduce the expressiveness of the language. In this paper, we propose a higher-rank polymorphic type-and-effect system to statically track the permanent and temporary invalidation of sensitive values and resources, without any aliasing or capture restrictions. We use Boolean-algebraic types (unions, intersections, and negations) to precisely model the side effects of program terms and guarantee they are invalidation-safe. Moreover, we present a complete and practical type inference algorithm, whereby programmers only need to annotate the types of higher-rank and polymorphically-recursive functions. Our system, nicknamed InvalML, has a wide range of applications where tracking invalidation is needed, including stack-based and region-based memory management, iterator invalidation, data-race-free concurrency, mutable state encapsulation, type-safe exception and effect handlers, and even scope-safe metaprogramming.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763144", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cunyuan", + "last_name": "Gao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/GaoP25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763145", + "title": "P³: Reasoning about Patches via Product Programs", + "abstract": "Software systems change on a continuous basis, with each patch prone to introducing new errors and security vulnerabilities. While providing a full functional specification for the program is a notoriously difficult task, writing a patch specification that describes the behaviour of the patched version in terms of the unpatched one (e.g., “the post-patch version is a refactoring of the pre-patch one”) is often easy. To reason about such specifications, program analysers have to concomitantly analyse the pre- and post-patch software versions. In this paper, we propose P 3 , a framework for automated reasoning about patches via product programs. While product programs have been used before, particularly in a security context, P 3 is the first framework that automatically constructs product programs for a real-world language (namely C), supports diverse and complex patches found in real software, and provides runtime support enabling techniques as varied as greybox fuzzing and symbolic execution to run unmodified. Our experimental evaluation on a set of complex software patches from the challenging CoREBench suite shows that P 3 can successfully handle intricate code, inter-operate with the widely-used analysers AFL++ and KLEE, and enable reasoning over patch specifications.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763145", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Arindam", + "last_name": "Sharma", + "institution": "Imperial College London" + }, + { + "first_name": "Daniel", + "last_name": "Schemmel", + "institution": "Imperial College London" + }, + { + "first_name": "Cristian", + "last_name": "Cadar", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/SharmaSC25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763155", + "title": "Dynamic Wind for Effect Handlers", + "abstract": "Effect handlers offer an attractive way of abstracting over effectful computation. Moreover, languages with effect handlers usually statically track effects, which ensures the user is aware of all side effects different parts of a program might have. Similarly to exception handlers, effect handlers discharge effects by locally defining their behavior. In contrast to exception handlers, they allow for resuming computation, possibly later and possibly multiple times. In this paper we present a design, formalization, and implementation for a variant of dynamic wind that integrates well with lexical effect handlers. It has well-defined semantics in the presence of arbitrary control effects in arbitrary places. Specifically, the behavior of capturing and resuming continuations in the pre- or postlude is well-defined and respects resource bracketing. We demonstrate how these features can be used to express backtracking of external state and finalization of external resources.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763155", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David Q.", + "last_name": "Voigt", + "institution": "University of Tübingen" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/VoigtSB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763146", + "title": "The Continuous Tensor Abstraction: Where Indices Are Real", + "abstract": "This paper introduces the continuous tensor abstraction, allowing indices to take real-number values (e.g., A[3.14]). It also presents continuous tensor algebra expressions, such as C x , y = A x , y ∗ B x , y , where indices are defined over a continuous domain. This work expands the traditional tensor model to include continuous tensors. Our implementation supports piecewise-constant tensors, on which infinite domains can be processed in finite time. We also introduce a new tensor format for efficient storage and a code generation technique for automatic kernel generation. For the first time, our abstraction expresses domains like computational geometry and computer graphics in the language of tensor programming. Our approach demonstrates competitive or better performance to hand-optimized kernels in leading libraries across diverse applications. Compared to hand-implemented libraries on a CPU, our compiler-based implementation achieves an average speedup of 9.20× on 2D radius search with ∼60× fewer lines of code (LoC), 1.22× on genomic interval overlapping queries (with ∼18× LoC saving), and 1.69× on trilinear interpolation in Neural Radiance Field (with ∼6× LoC saving).", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763146", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jaeyeon", + "last_name": "Won", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Willow", + "last_name": "Ahrens", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Teodoro Fields", + "last_name": "Collin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Joel", + "last_name": "Emer", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/WonACEA25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763147", + "title": "Translation Validation for LLVM's AArch64 Backend", + "abstract": "LLVM's backends translate its intermediate representation (IR) to assembly or object code. Alongside register allocation and instruction selection, these backends contain many analogues of components traditionally associated with compiler middle ends: dataflow analyses, common subexpression elimination, loop invariant code motion, and a first-class IR -- MIR, the \"machine IR.\" In effect, this kind of compiler backend is a highly optimizing compiler in its own right, with all of the correctness hazards entailed by a million lines of intricate C++. As a step towards gaining confidence in the correctness of work done by LLVM backends, we have created arm-tv, which formally verifies translations between LLVM IR and AArch64 (64-bit ARM) code. Ours is not the first translation validation work for LLVM, but we have advanced the state of the art along multiple fronts: arm-tv is a checking validator that enforces numerous ABI rules; we have extended Alive2 (which we reuse as a verification backend) to deal with unstructured mixes of pointers and integers that are typical of assembly code; we investigate the tradeoffs between hand-written AArch64 semantics and those derived mechanically from ARM's published formal semantics; and, we have used arm-tv to discover 45 previously unknown miscompilation bugs in this LLVM backend, most of which are now fixed in upstream LLVM.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763147", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ryan", + "last_name": "Berger", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Mitch", + "last_name": "Briles", + "institution": "University of Utah" + }, + { + "first_name": "Nader Boushehrinejad", + "last_name": "Moradi", + "institution": "University of Utah" + }, + { + "first_name": "Nicholas", + "last_name": "Coughlin", + "institution": "Defence Science and Technology Group" + }, + { + "first_name": "K.P.", + "last_name": "Lam", + "institution": "Defence Science and Technology Group" + }, + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Stefan", + "last_name": "Mada", + "institution": "University of Utah" + }, + { + "first_name": "Tanmay", + "last_name": "Tirpankar", + "institution": "University of Utah" + }, + { + "first_name": "John", + "last_name": "Regehr", + "institution": "University of Utah" + } + ], + "dblp_key": "journals/pacmpl/BergerBMCLLMTR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763148", + "title": "Certified Decision Procedures for Width-Independent Bitvector Predicates", + "abstract": "Bitvectors are foundational for automated reasoning. A few interactive theorem provers (ITP), such as Lean, have strong support for deciding fixed-width bitvector predicates by means of bitblasting. However, even these ITPs provide little automation for width-independent bitvector predicates. To fill this gap, we contribute novel, mechanized decision procedures for width-independent bitvector predicates in Lean. Classical algorithms to decide fragments of width-independent bitvector theory can be viewed from the lens of model checking, where the formula corresponds to an automaton and the correctness of the formula is a safety property. However, we cannot currently use this lens in mechanized proofs, as there are no executable, fast, and formally verified model checking algorithms that can be used interactively from within ITPs. To fill this gap, we mechanize key algorithms in the model checking literature: k -induction, automata reachability, automata emptiness checking, and automata minimization. Using these mechanized algorithms, we contribute scalable, mechanized, decision procedures for width-independent bitvector predicates. Furthermore, for controlled fragments of mixtures of arithmetic and bitwise operations which occur in the deobfuscation literature, we mechanize a recent fast algorithm (MBA-Blast), which outperforms the more general procedures on this fragment. Finally, we evaluate our decision procedures on benchmarks from classical compiler problems such as Hacker’s Delight and the LLVM peephole optimizer, as well as on equivalence checking problems for program obfuscation. Our tools solve 100% of Hacker’s Delight, two of our tools solve 100% of the deobfuscation dataset, and up to 27% of peephole rewrites extracted from LLVM’s peephole rewriting test suite. Our new decision procedures provide a push-button experience for width-independent bitvector reasoning in interactive theorem provers, and, more broadly, pave the way for foundational algorithms for fast, formally verified model checking.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763148", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Siddharth", + "last_name": "Bhat", + "institution": "University of Cambridge" + }, + { + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "University of Cambridge" + }, + { + "first_name": "Chris", + "last_name": "Hughes", + "institution": "" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/BhatSHG25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763152", + "title": "Finding Compiler Bugs through Cross-Language Code Generator and Differential Testing", + "abstract": "Compilers play a central role in translating high-level code into executable programs, making their correctness essential for ensuring code safety and reliability. While extensive research has focused on verifying the correctness of compilers for single-language compilation, the correctness of cross-language compilation — which involves the interaction between two languages and their respective compilers — remains largely unexplored. To fill this research gap, we propose CrossLangFuzzer, a novel framework that introduces a universal intermediate representation (IR) for JVM-based languages and automatically generates cross-language test programs with diverse type parameters and complex inheritance structures. After generating the initial IR, CrossLangFuzzer applies three mutation techniques — LangShuffler, FunctionRemoval, and TypeChanger — to enhance program diversity. By evaluating both the original and mutated programs across multiple compiler versions, CrossLangFuzzer successfully uncovered 10 confirmed bugs in the Kotlin compiler, 4 confirmed bugs in the Groovy compiler, 7 confirmed bugs in the Scala 3 compiler, 2 confirmed bugs in the Scala 2 compiler, and 1 confirmed bug in the Java compiler. Among all mutators, TypeChanger is the most effective, detecting 11 of the 24 compiler bugs. Furthermore, we analyze the symptoms and root causes of cross-compilation bugs, examining the respective responsibilities of language compilers when incorrect behavior occurs during cross-language compilation. To the best of our knowledge, this is the first work specifically focused on identifying and diagnosing compiler bugs in cross-language compilation scenarios. Our research helps to understand these challenges and contributes to improving compiler correctness in multi-language environments.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763152", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Qiong", + "last_name": "Feng", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Xiaotian", + "last_name": "Ma", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Ziyuan", + "last_name": "Feng", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Marat", + "last_name": "Akhin", + "institution": "" + }, + { + "first_name": "Wei", + "last_name": "Song", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Peng", + "last_name": "Liang", + "institution": "Wuhan University" + } + ], + "dblp_key": "journals/pacmpl/FengMFA0025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763149", + "title": "CoSSJIT: Combining Static Analysis and Speculation in JIT Compilers", + "abstract": "Just-in-time (JIT) compilers typically sacrifice the precision of program analysis for efficiency, but are capable of performing sophisticated speculative optimizations based on run-time profiles to generate code that is specialized to a given execution. On the contrary, ahead-of-time static compilers can often afford precise flow-sensitive interprocedural analysis, but produce conservative results in scenarios where higher precision could be derived from run-time specialization. In this paper, we propose the first-of-its-kind approach to enrich static analysis with the possibility of speculative optimization during JIT compilation, as well as its usage to perform aggressive stack allocation on a production Java Virtual Machine. Our approach of combining static analysis with JIT speculation -- named CoSSJIT -- involves three key contributions. First, we identify the scenarios where a static analysis would make conservative assumptions but a JIT could deliver precision based on run-time speculation. Second, we present the notion of \"speculative conditions\" and plug them into a static interprocedural dataflow analyzer (whose aim is to identify heap objects that can be allocated on stack), to generate partial results that can be specialized at run-time. Finally, we extend a production JIT compiler to read and enrich static-analysis results with the resolved values of speculative conditions, leading to a practical approach that efficiently combines the best of both worlds. Cherries on the cake: Using CoSSJIT, we obtain 5.7x improvement in stack allocation (translating to performance), while building on a system that ensures functional correctness during JIT compilation.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763149", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Aditya", + "last_name": "Anand", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Vijay", + "last_name": "Sundaresan", + "institution": "IBM (Canada)" + }, + { + "first_name": "Daryl", + "last_name": "Maier", + "institution": "IBM (Canada)" + }, + { + "first_name": "Manas", + "last_name": "Thakur", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "journals/pacmpl/0002SMT25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763154", + "title": "Extraction and Mutation at a High Level: Template-Based Fuzzing for JavaScript Engines", + "abstract": "JavaScript (JS) engines implement complex language semantics and optimization strategies to support the dynamic nature of JS, making them difficult to test thoroughly and prone to subtle, security-critical bugs. Existing fuzzers often struggle to generate diverse and valid test cases. They either rely on syntax-level mutations that lack semantic awareness or perform limited, local mutations on concrete code, thus failing to explore deeper, more complex program behaviors. This paper presents TemuJs, a novel fuzzing framework that performs extraction and mutation at a high level, operating on abstract templates derived from real-world JS programs. These templates capture coarse-grained program structures with semantic placeholders, enabling semantics-aware mutations that preserve the high-level intent of the original code while diversifying its behavior. By decoupling mutation from concrete syntax and leveraging a structured intermediate representation for the templates, TemuJs explores a broader and more meaningful space of program behaviors. Evaluated on three major JS engines, namely, V8, SpiderMonkey, and JavaScriptCore, TemuJs discovers 44 bugs and achieves a 10.3% increase in edge coverage compared to state-of-the-art fuzzers on average. Our results demonstrate the efficacy of high-level, template-mutation fuzzing in testing JS engines.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763154", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wai Kin", + "last_name": "Wong", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Dongwei", + "last_name": "Xiao", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Cheuk Tung", + "last_name": "Lai", + "institution": "Axa (United Kingdom)" + }, + { + "first_name": "Yiteng", + "last_name": "Peng", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Daoyuan", + "last_name": "Wu", + "institution": "" + }, + { + "first_name": "Shuai", + "last_name": "Wang", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/WongXLPW025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763153", + "title": "Scalable Equivalence Checking and Verification of Shallow Quantum Circuits", + "abstract": "This paper concerns the problem of checking whether two shallow (i.e., constant-depth) quantum circuits perform equivalent computations. Equivalence checking is a fundamental correctness question—needed, for example, to ensure that transformations applied to a quantum circuit do not alter its behavior. For quantum circuits, the problem is challenging because a straightforward representation on a classical computer of each circuit’s quantum state can require time and space that are exponential in the number of qubits n . The paper presents Projection-Based Equivalence Checking (PBEC), which provides decision procedures for two variants of the equivalence-checking problem. Both can be carried out on a classical computer in time and space that, for any fixed depth, are linear in n . Our key insight is that local projections can serve as constraints that fully characterize the output state of a shallow quantum circuit. The output state is the unique quantum state that satisfies all the constraints. Beyond equivalence checking, we show how to use the constraint representation to check a class of assertions, both statically and at run time. Our assertion-checking methods are sound and complete for assertions expressed as conjunctions of local projections. Our experiments showed that computing the constraint representation of a random 100-qubit 1D circuit of depth 6 takes 129.64 seconds. Equivalence checking between two random 100-qubit 1D circuits of depth 3 requires 4.46 seconds for fixed input 0 ⊗ 100 , and no more than 31.96 seconds for arbitrary inputs. Computing the constraint representation for a random 100-qubit circuit of depth 3 takes 6.99 seconds for a 2D structure, compared to 10.67 seconds for a circuit with arbitrary connectivity. At depth 2, equivalence checking takes 0.20 seconds for fixed input and 0.44 seconds for arbitrary input, with similar performance for both 2D and arbitrary-connectivity circuits.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763153", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Nengkun", + "last_name": "Yu", + "institution": "Stony Brook University" + }, + { + "first_name": "Xuan Du", + "last_name": "Trinh", + "institution": "Stony Brook University" + }, + { + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "journals/pacmpl/YuTR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763156", + "title": "Detecting and Explaining (In-)equivalence of Context-Free Grammars", + "abstract": "We propose a scalable framework for deciding, proving, and explaining (in-)equivalence of context-free grammars. We present an implementation of the framework and evaluate it on large data sets collected within educational support systems. Even though the equivalence problem for context-free languages is undecidable in general, the framework is able to handle a large portion of these datasets. It introduces and combines techniques from several areas, such as an abstract grammar transformation language to identify equivalent grammars as well as sufficiently similar inequivalent grammars, theory-based comparison algorithms for a large class of context-free languages, and a graph-theory-inspired grammar canonization that allows to efficiently identify isomorphic grammars.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763156", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Marko", + "last_name": "Schmellenkamp", + "institution": "Ruhr University Bochum" + }, + { + "first_name": "Thomas", + "last_name": "Zeume", + "institution": "Ruhr University Bochum" + }, + { + "first_name": "Sven", + "last_name": "Argo", + "institution": "Ruhr University Bochum" + }, + { + "first_name": "Sandra", + "last_name": "Kiefer", + "institution": "University of Oxford" + }, + { + "first_name": "Cedric", + "last_name": "Siems", + "institution": "Ruhr University Bochum" + }, + { + "first_name": "Fynn", + "last_name": "Stebel", + "institution": "Ruhr University Bochum" + } + ], + "dblp_key": "journals/pacmpl/SchmellenkampZA25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763150", + "title": "Mini-Batch Robustness Verification of Deep Neural Networks", + "abstract": "Neural network image classifiers are ubiquitous in many safety-critical applications. However, they are susceptible to adversarial attacks. To understand their robustness to attacks, many local robustness verifiers have been proposed to analyze є-balls of inputs. Yet, existing verifiers introduce a long analysis time or lose too much precision, making them less effective for a large set of inputs. In this work, we propose a new approach to local robustness: group local robustness verification. The key idea is to leverage the similarity of the network computations of certain є-balls to reduce the overall analysis time. We propose BaVerLy, a sound and complete verifier that boosts the local robustness verification of a set of є-balls by dynamically constructing and verifying mini-batches. BaVerLy adaptively identifies successful mini-batch sizes, accordingly constructs mini-batches of є-balls that have similar network computations, and verifies them jointly. If a mini-batch is verified, all its є-balls are proven robust. Otherwise, one є-ball is suspected as not being robust, guiding the refinement. BaVerLy leverages the analysis results to expedite the analysis of that є-ball as well as the analysis of the mini-batch with the other є-balls. We evaluate BaVerLy on fully connected and convolutional networks for MNIST and CIFAR-10. Results show that BaVerLy scales the common one by one verification by 2.3x on average and up to 4.1x, in which case it reduces the total analysis time from 24 hours to 6 hours.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763150", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Saar", + "last_name": "Tzour-Shaday", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Dana", + "last_name": "Drachsler-Cohen", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/Tzour-ShadayD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763158", + "title": "We've Got You Covered: Type-Guided Repair of Incomplete Input Generators", + "abstract": "Property-based testing (PBT) is a popular technique for automatically testing semantic properties of a program, specified as a pair of pre- and post-conditions. The efficacy of this approach depends on being able to quickly generate inputs that meet the precondition, in order to maximize the set of program behaviors that are probed. For semantically rich preconditions, purely random generation is unlikely to produce many valid inputs; when this occurs, users are forced to manually write their own specialized input generators. One common problem with handwritten generators is that they may be incomplete, i.e., they are unable to generate some values meeting the target precondition. This paper presents a novel program repair technique that patches an incomplete generator so that its range includes every valid input. Our approach uses a novel enumerative synthesis algorithm that leverages the recently developed notion of coverage types to characterize the set of missing test values as well as the coverage provided by candidate repairs. We have implemented a repair tool for OCaml generators, called Cobb, and used it to repair a suite of benchmarks drawn from the PBT literature.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763158", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Patrick", + "last_name": "LaFontaine", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Z.", + "last_name": "Zhou", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Ashish", + "last_name": "Mishra", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/LaFontaineZ0JD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763151", + "title": "Compositional Symbolic Execution for the Next 700 Memory Models", + "abstract": "Multiple successful compositional symbolic execution (CSE) tools and platforms exploit separation logic (SL) for compositional verification and/or incorrectness separation logic (ISL) for compositional bug-finding, including VeriFast, Viper, Gillian, CN, and Infer-Pulse. Previous work on the Gillian platform, the only CSE platform that is parametric on the memory model, meaning that it can be instantiated to different memory models, suggests that the ability to use custom memory models allows for more flexibility in supporting analysis of a wide range of programming languages, for implementing custom automation, and for improving performance. However, the literature lacks a satisfactory formal foundation for memory-model-parametric CSE platforms. In this paper, inspired by Gillian, we provide a new formal foundation for memory-model-parametric CSE platforms. Our foundation advances the state of the art in four ways. First, we mechanise our foundation (in the interactive theorem prover Rocq). Second, we validate our foundation by instantiating it to a broad range of memory models, including models for C and CHERI. Third, whereas previous memory-model-parametric work has only covered SL analyses, we cover both SL and ISL analyses. Fourth, our foundation is based on standard definitions of SL and ISL (including definitions of function specification validity, to ensure sound interoperation with other tools and platforms also based on standard definitions).", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763151", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Lööw", + "institution": "Imperial College London" + }, + { + "first_name": "Seung Hoon", + "last_name": "Park", + "institution": "Imperial College London" + }, + { + "first_name": "Daniele", + "last_name": "Nantes-Sobrinho", + "institution": "Imperial College London" + }, + { + "first_name": "Sacha-Élie", + "last_name": "Ayoun", + "institution": "Imperial College London" + }, + { + "first_name": "Opale", + "last_name": "Sjöstedt", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/LoowPNASG25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763157", + "title": "Embedding Quantum Program Verification into Dafny", + "abstract": "Despite recent development of quantum program verification, it is still in its early stage, where many quantum programs are hard to verify due to their inherent probabilistic nature and parallelism in quantum superposition. We propose Qafny C , a system that compiles quantum program verification into a well-established classical program verifier Dafny, enabling the formal verification of quantum programs. The key insight behind Qafny C is the separation of quantum program verification from its execution, leveraging the strength of classical verifiers to ensure correctness before compiling certified quantum programs into executable circuits. Using Qafny C , we have successfully verified 37 diverse quantum programs by compiling their verification into Dafny. To the best of our knowledge, this is the most extensive formally verified set of quantum programs.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763157", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Feifei", + "last_name": "Cheng", + "institution": "Iowa State University" + }, + { + "first_name": "Sushen Vallabh", + "last_name": "Vangeepuram", + "institution": "Iowa State University" + }, + { + "first_name": "Henry", + "last_name": "Allard", + "institution": "Iowa State University" + }, + { + "first_name": "Seyed Mohammad Reza", + "last_name": "Jafari", + "institution": "Iowa State University" + }, + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Australian National University" + }, + { + "first_name": "Liyi", + "last_name": "Li", + "institution": "Iowa State University" + } + ], + "dblp_key": "journals/pacmpl/ChengVAJP025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763159", + "title": "Stencil-Lifting: Hierarchical Recursive Lifting System for Extracting Summary of Stencil Kernel in Legacy Codes", + "abstract": "We introduce Stencil-Lifting, a novel system for automatically converting stencil kernels written in low-level languages in legacy code into semantically equivalent Domain-Specific Language (DSL) implementations. Targeting the efficiency bottlenecks of existing verified lifting systems, Stencil-Lifting achieves scalable stencil kernel abstraction through two key innovations. First, we propose a hierarchical recursive lifting theory that represents stencil kernels, structured as nested loops, using invariant subgraphs, which are customized data dependency graphs that capture loop-carried computation and structural invariants. Each vertex in the invariant subgraph is associated with a predicate-based summary, encoding its computational semantics. By enforcing self-consistency across these summaries, Stencil-Lifting ensures the derivation of correct loop invariants and postconditions for nested loops, eliminating the need for external verification. Second, we develop a hierarchical recursive lifting algorithm that guarantees termination through a convergent recursive process, avoiding the inefficiencies of search-based synthesis. The algorithm efficiently derives the valid summaries of stencil kernels, and its completeness is formally proven. We evaluate Stencil-Lifting on diverse stencil benchmarks from two different suites and on four real-world applications. Experimental results demonstrate that Stencil-Lifting achieves 31.62× and 5.8× speedups compared to the state-of-the-art verified lifting systems STNG and Dexter, respectively, while maintaining full semantic equivalence. Our work significantly enhances the translation efficiency of low-level stencil kernels to DSL implementations, effectively bridging the gap between legacy optimization techniques and modern DSL-based paradigms.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763159", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Mingyi", + "last_name": "Li", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Junmin", + "last_name": "Xiao", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Siyan", + "last_name": "Chen", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Hui", + "last_name": "Ma", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Xi", + "last_name": "Chen", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Peihua", + "last_name": "Bao", + "institution": "University of Chinese Academy of Sciences" + }, + { + "first_name": "Liang", + "last_name": "Yuan", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Guangming", + "last_name": "Tan", + "institution": "Chinese Academy of Sciences" + } + ], + "dblp_key": "journals/pacmpl/LiXCMCBYT25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763160", + "title": "Products of Recursive Programs for Hypersafety Verification", + "abstract": "We study the problem of automated hypersafety verification of infinite-state recursive programs . We propose an infinite class of product programs , specifically designed with recursion in mind, that reduce the hypersafety verification of a recursive program to standard safety verification. For this, we combine insights from language theory and concurrency theory to propose an algorithmic solution for constructing an infinite class of recursive product programs. One key insight is that, using the simple theory of visibly pushdown languages , one can maintain the recursive structure of syntactic program alignments which is vital to constructing a new product program that can be viewed as a classic recursive program — that is, one that can be executed on a single stack. Another key insight is that techniques from concurrency theory can be generalized to help define product programs based on the view that the parallel composition of individual recursive programs includes all possible alignments from which a sound set of alignments that faithfully preserve the satisfaction of the hypersafety property can be selected. On the practical side, we formulate a family of parametric canonical product constructions that are intuitive to programmers and can be used as building blocks to specify recursive product programs for the purpose of relational and hypersafety verification, with the idea that the right product program can be verified automatically using existing techniques. We demonstrate the effectiveness of these techniques through an implementation and highly promising experimental results.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763160", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ruotong", + "last_name": "Cheng", + "institution": "University of Toronto" + }, + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/ChengF25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763161", + "title": "DESIL: Detecting Silent Bugs in MLIR Compiler Infrastructure", + "abstract": "MLIR (Multi-Level Intermediate Representation) compiler infrastructure provides an efficient framework for introducing a new abstraction level for programming languages and domain-specific languages. It has attracted widespread attention in recent years and has been applied in various domains, such as deep learning compiler construction. Recently, several MLIR compiler fuzzing techniques, such as MLIRSmith and MLIRod, have been proposed. However, none of them can detect silent bugs, i.e., bugs that incorrectly optimize code silently. The difficulty in detecting silent bugs arises from two main aspects: (1) UB-Free Program Generation: Generates programs that are free from undefined behaviors to suit the non-UB assumptions required by compiler optimizations. (2) Lowering Support: Converts the given MLIR program into an executable form with a suitable lowering path that reduces redundant lowering passes and improves the efficiency of fuzzing. To address the above issues, we propose DESIL. DESIL enables silent bug detection by defining a set of UB-elimination rules based on the MLIR documentation and applying them to input programs. To convert dialects in the MLIR program into executable form, DESIL designs a lowering path optimization strategy to convert the dialects in the given MLIR program into executable form. Furthermore, DESIL incorporates the differential testing for silent bug detection. It introduces an operation-aware optimization recommendation strategy into the compilation process to generate diverse executable files. We applied DESIL to the latest revisions of the MLIR compiler infrastructure. It detected 23 silent bugs and 19 crash bugs, of which 17/16 have been confirmed or fixed.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763161", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chenyao", + "last_name": "Suo", + "institution": "Tianjin University" + }, + { + "first_name": "Jianrong", + "last_name": "Wang", + "institution": "Tianjin University" + }, + { + "first_name": "Y. F.", + "last_name": "Wang", + "institution": "Tianjin University" + }, + { + "first_name": "Jiajun", + "last_name": "Jiang", + "institution": "Tianjin University" + }, + { + "first_name": "Qingchao", + "last_name": "Shen", + "institution": "Tianjin University" + }, + { + "first_name": "Junjie", + "last_name": "Chen", + "institution": "Tianjin University" + } + ], + "dblp_key": "journals/pacmpl/SuoWWJS025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763162", + "title": "HieraSynth: A Parallel Framework for Complete Super-Optimization with Hierarchical Space Decomposition", + "abstract": "Modern optimizing compilers generate efficient code but rarely achieve theoretical optimality, often necessitating manual fine-tuning. This is especially the case for processors with vector instructions, which can grow the instruction set by an order of magnitude. Super-optimizers can synthesize optimal code, but they face a fundamental scalability constraint: as the size of the instruction set increases, the length of the longest synthesizable program decreases rapidly. To help super-optimizers deal with large instruction sets, we introduce HieraSynth, a parallel framework for super-optimization that decomposes the problem by hierarchically partitioning the space of candidate programs, effectively decreasing the instruction set size. It also prunes search branches when the solver proves unrealizability, and explores independent subspaces in parallel, achieving near-linear speedup. HieraSynth is sufficiently efficient to run to completeness even on many hard problems, which means that it exhaustively explores the program space. This ensures that the synthesized program is optimal according to a cost model. We implement HieraSynth as a library and demonstrate its effectiveness with a RISC-V Vector super-optimizer capable of handling instruction sets with up to 700 instructions while synthesizing 7–8-instruction programs. This is a significant advancement over previous approaches that were limited to 1–3 instructions with similar instruction set sizes. Specifically, HieraSynth can handle instruction sets up to 10.66× larger for a given program size, or synthesize up to 4.75× larger programs for a fixed instruction set. Evaluations show that HieraSynth can synthesize code surpassing human-expert optimizations and significantly reduce synthesis time, making super-optimization more practical for modern vector architectures.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763162", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Sirui", + "last_name": "Lu", + "institution": "University of Washington" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/LuB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763163", + "title": "Large Language Model Powered Symbolic Execution", + "abstract": "Large Language Models (LLMs) have emerged as a promising alternative to traditional static program analysis methods, such as symbolic execution, offering the ability to reason over code directly without relying on theorem provers or SMT solvers. However, LLMs are also inherently approximate by nature, and therefore face significant challenges in relation to the accuracy and scale of analysis in real-world applications. Such issues often necessitate the use of larger LLMs with higher token limits, but this requires enterprise-grade hardware (GPUs) and thus limits accessibility for many users. In this paper, we propose LLM-based symbolic execution —a novel approach that enhances LLM inference via a path-based decomposition of the program analysis tasks into smaller (more tractable) subtasks. The core idea is to generalize path constraints using a generic code-based representation that the LLM can directly reason over, and without translation into another (less-expressive) formal language. We implement our approach in the form of AutoBug, an LLM-based symbolic execution engine that is lightweight and language-agnostic, making it a practical tool for analyzing code that is challenging for traditional approaches. We show that AutoBug can improve both the accuracy and scale of LLM-based program analysis, especially for smaller LLMs that can run on consumer-grade hardware.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763163", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yihe", + "last_name": "Li", + "institution": "National University of Singapore" + }, + { + "first_name": "Ruijie", + "last_name": "Meng", + "institution": "National University of Singapore" + }, + { + "first_name": "Gregory J.", + "last_name": "Duck", + "institution": "National University of Singapore" + } + ], + "dblp_key": "journals/pacmpl/LiMD25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763164", + "title": "Proof Repair across Quotient Type Equivalences", + "abstract": "Proofs in proof assistants like Rocq can be brittle, breaking easily in response to changes. To address this, recent work introduced an algorithm and tool in Rocq to automatically repair broken proofs in response to changes that correspond to type equivalences. However, many changes remained out of the scope of this algorithm and tool—especially changes in underlying behavior . We extend this proof repair algorithm so that it can express certain changes in behavior that were previously out of scope. We focus in particular on equivalences between quotient types —types equipped with a relation that describes what it means for any two elements of that type to be equal. Quotient type equivalences can be used to express interesting changes in representations of mathematical structures, as well as changes in the implementations of data structures. We extend this algorithm and tool to support quotient type equivalences in Rocq. Notably, since Rocq lacks quotient types entirely, our extensions use Rocq’s setoid machinery in place of quotients. Specifically, (1) our extension to the algorithm supports new changes corresponding to setoids, and (2) our extension to the tool supports this new class of changes and further automates away some of the new proof obligations. We demonstrate our extensions on proof repair case studies for previously unsupported changes. We also perform manual proof repair in Cubical Agda, a language with a univalent metatheory, which allows us to construct the first ever internal proofs of correctness for proof repair.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763164", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cosmo", + "last_name": "Viola", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Max", + "last_name": "Fan", + "institution": "Cornell University" + }, + { + "first_name": "Talia", + "last_name": "Ringer", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/ViolaFR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763165", + "title": "The Power of Regular Constraint Propagation", + "abstract": "The past decade has witnessed substantial developments in string solving. Motivated by the complexity of string solving strategies adopted in existing string solvers, we investigate a simple and generic method for solving string constraints: regular constraint propagation. The method repeatedly computes pre- or post-images of regular languages under the string functions present in a string formula, inferring more and more knowledge about the possible values of string variables, until either a conflict is found or satisfiability of the string formula can be concluded. Such a propagation strategy is applicable to string constraints with multiple operations like concatenation, replace, and almost all flavors of string transductions. We demonstrate the generality and effectiveness of this method theoretically and experimentally. On the theoretical side, we show that RCP is sound and complete for a large fragment of string constraints, subsuming both straight-line and chain-free constraints, two of the most expressive decidable fragments for which some modern string solvers provide formal completeness guarantees. On the practical side, we implement regular constraint propagation within the open-source string solver OSTRICH. Our experimental evaluation shows that this addition significantly improves OSTRICH’s performance and makes it competitive with existing solvers. In fact, it substantially outperforms other solvers on random PCP and bioinformatics benchmarks. The results also suggest that incorporating regular constraint propagation alongside other techniques could lead to substantial performance gains for existing solvers.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763165", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Matthew", + "last_name": "Hague", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Artur", + "last_name": "Jeż", + "institution": "University of Wrocław" + }, + { + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Oliver", + "last_name": "Markgraf", + "institution": "Rheinland-Pfälzische Technische Universität Kaiserslautern-Landau" + }, + { + "first_name": "Philipp", + "last_name": "Rümmer", + "institution": "Uppsala University" + } + ], + "dblp_key": "journals/pacmpl/HagueJLMR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763166", + "title": "On Abstraction Refinement for Bayesian Program Analysis", + "abstract": "Bayesian program analysis is a systematic approach to learn from external information for better accuracy by converting logical deduction in conventional program analysis into Bayesian inference. A key challenge in Bayesian program analysis is how to select program abstractions to effectively generalize from external information. A recent approach addresses this challenge by learning a selection policy on training programs but may result in sub-optimal performance on new programs due to its learning nature and when the training set selection is not ideal. To address this problem, we propose an approach that is inspired by the framework of counterexample-guided refinement to search for an abstraction on the fly. Our key innovation is to apply the theory of conditional independence to refine the abstraction so that incorrect generalizations can be removed. To demonstrate the effectiveness of our approach, we have instantiated it on a Bayesian thread-escape analysis and a Bayesian datarace analysis and shown that it significantly improves the performance of the analyses.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763166", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Yuanfeng", + "last_name": "Shi", + "institution": "Peking University" + }, + { + "first_name": "Y. M.", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Xin", + "last_name": "Zhang", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/ShiZ025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763173", + "title": "Borrowing from Session Types", + "abstract": "Session types provide a formal framework to enforce rich communication protocols, ensuring correctness properties such as type safety and deadlock freedom. However, the traditional API of functional session type systems with first-class channels often leads to problems with modularity and composability. This paper proposes a new, alternative session type API based on borrowing, embodied in the core calculus BGV. The borrowing-based API enables building modular and composable code for session type clients without imposing clutter or undue limitations. Its basis is a novel type system, founded on ordered linear typing, for functional session types with an explicit operation for splitting ownership of channels. We establish the semantics of BGV via a type-preserving translation to PGV, a deadlock-free functional session type calculus. We establish type safety and deadlock freedom for BGV by this translation. We also present an external version of BGV that supports use of borrow notation. We developed an algorithmic version of the type system that includes a mechanized verified translation from the external language to BGV. This part establishes decidable type checking.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763173", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hannes", + "last_name": "Saffrich", + "institution": "University of Freiburg" + }, + { + "first_name": "Janek", + "last_name": "Spaderna", + "institution": "University of Freiburg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + } + ], + "dblp_key": "journals/pacmpl/SaffrichS0V25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763170", + "title": "Enhancing APR with PRISM: A Semantic-Based Approach to Overfitting Patch Detection", + "abstract": "We present PRISM, a novel technique for detecting overfitting patches in automatic program repair (APR). Despite significant advances in APR, overfitting patches—those passing test suites but not fixing bugs—persist, degrading performance and increasing developer review burden. To mitigate overfitting, various automatic patch correctness classification (APCC) techniques have been proposed. However, while accurate, existing APCC methods often mislabel scarce correct patches as incorrect, significantly lowering the APR fix rate. To address this, we propose (1) novel semantic features capturing patch-induced behavioral changes and (2) a tailored learning algorithm that preserves correct patches while filtering incorrect ones. Experiments on ranked patch data from 10 APR tools show that PRISM uniquely reduces review burden and finds more correct patches. Other methods lower the fix rate by misclassifying correct patches. Evaluations on 1,829 labeled patches confirm Prism removes more incorrect patches at equal correct patch preservation rates.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763170", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Dowon", + "last_name": "Song", + "institution": "Korea University" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/SongO25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763168", + "title": "The Simple Essence of Overloading: Making Ad-Hoc Polymorphism More Algebraic with Flow-Based Variational Type-Checking", + "abstract": "Type-directed overload resolution allows programmers to reuse the same name, offloading disambiguation to the type checker. Since many programming languages implement overload resolution by performing backtracking in the type checker, it is commonly believed to be incompatible with Hindley-Milner-style type systems. In this paper, we present an approach to overload resolution that combines insights from variational type checking and algebraic subtyping. We formalize and discuss our flow-based variational framework that captures the essence of overloads by representing them as choices. This cleanly separates constraint collection, constraint solving, and overload resolution. We believe our framework not only gives rise to more modular and efficient implementations of type checkers, but also serves as a simpler mental model and paves the way for improved error messages.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763168", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jiří", + "last_name": "Beneš", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + } + ], + "dblp_key": "journals/pacmpl/BenesB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763167", + "title": "Interactive Bitvector Reasoning using Verified Bit-Blasting", + "abstract": "Bit-blasting SMT solvers enable efficient automatic reasoning about bitvectors, which are fundamental for the verification of compiler backends, cryptographic algorithms, hardware designs and other soft- or hardware tasks. Despite the clear demand for efficient bitvector reasoning infrastructure and the impressive advancements in state-of-the-art bit-blasting SMT solvers such as Bitwuzla, effective bitvector reasoning within interactive theorem provers (ITPs) remains a challenge, hindering their use for mechanized proofs. Incomplete bitvector libraries, unavailable or only partially integrated decision procedures, complex and hard-to-bitblast operations, and limited integration with the host language prevent the wide adoption of bitvector reasoning in proving contexts. We introduce bv_decide: the first end-to-end verified bitblaster designed for interactive bitvector reasoning in a dependently-typed ITP . Our verified bitblaster is scalable, comes with a complete end-to-end proof (trusting only the Lean compiler and kernel), and is available as a proof tactic that allows interactive reasoning right from within a programming language, in our case Lean. We use Lean’s Functional But In-Place (FBIP) paradigm to efficiently encode our core data structures (e.g., AIGs), demonstrating that fast execution of an SMT solver need not come at the expense of rigorous formalization. We enable dependable interactive verification of user-written-code by basing Lean’s C-Style standard dataypes UInt/SInt on our bitvector type, adding a lowering from enums and structs to bitvectors to enable transparent bit-blasting support for composed types, and by offering an interactive tactic that either solves a goal or provides a counter-example. Moreover, we present the design of Lean’s canonical bitvector library, which supports all operations (with reasoning principles) for the SMT-LIB 2.7 standard (including overflow modeling), is fast-to-execute, and offers a comprehensive API and automation for bit-width-independent reasoning. We thoroughly evaluate our bit-blaster on a comprehensive set of benchmarks, including the full SMT-LIB dataset, where bv_decide solves more theorems than the state-of-the-art in verified bit-blasting, CoqQFBV. We also verify over 7000 SMT statements extracted from LLVM, providing the largest mechanized verification of LLVM rewrites to date, to our knowledge. By making bit-blasting bitvector reasoning a polished, well-supported, and interactive feature of modern ITPs, we enable effective, dependable white-box reasoning for bitvector-level verification.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763167", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Henrik", + "last_name": "Böving", + "institution": "" + }, + { + "first_name": "Siddharth", + "last_name": "Bhat", + "institution": "University of Cambridge" + }, + { + "first_name": "Luisa", + "last_name": "Cicolini", + "institution": "University of Cambridge" + }, + { + "first_name": "Alex", + "last_name": "Keizer", + "institution": "University of Cambridge" + }, + { + "first_name": "Léon", + "last_name": "Frenot", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Abdalrhman", + "last_name": "Mohamed", + "institution": "Stanford University" + }, + { + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "University of Cambridge" + }, + { + "first_name": "Harun", + "last_name": "Khan", + "institution": "Stanford University" + }, + { + "first_name": "Joshua", + "last_name": "Clune", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Clark", + "last_name": "Barrett", + "institution": "Stanford University" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Cambridge" + } + ], + "dblp_key": "journals/pacmpl/BovingBCKFMS0CB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763169", + "title": "ROSpec: A Domain-Specific Language for ROS-Based Robot Software", + "abstract": "Component-based robot software frameworks, such as the Robot Operating System (ROS), allow developers to quickly compose and execute systems by focusing on configuring and integrating reusable, off-the-shelf components. However, these components often lack documentation on how to configure and integrate them correctly. Even when documentation exists, its natural language specifications are not enforced, resulting in misconfigurations that lead to unpredictable and potentially dangerous robot behaviors. In this work, we introduce ROSpec, a ROS-tailored domain-specific language designed to specify and verify component configurations and their integration. ROSpec's design is grounded in ROS domain concepts and informed by a prior empirical study on misconfigurations, allowing the language to provide a usable and expressive way of specifying and detecting misconfigurations. At a high level, ROSpec verifies the correctness of argument and component configurations, ensures the correct integration of components by checking their communication properties, and checks if configurations respect the assumptions and constraints of their deployment context. We demonstrate ROSpec's ability to specify and verify components by modeling a medium-sized warehouse robot with 19 components, and by manually analyzing, categorizing, and implementing partial specifications for components from a dataset of 182 misconfiguration questions extracted from a robotics Q&A platform.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763169", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Paulo", + "last_name": "Santos", + "institution": "University of Lisbon" + }, + { + "first_name": "Bradley", + "last_name": "Schmerl", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Alcides", + "last_name": "Fonseca", + "institution": "University of Lisbon" + }, + { + "first_name": "Christopher S.", + "last_name": "Timperley", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/CanelasSFT25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763174", + "title": "AutoVerus: Automated Proof Generation for Rust Code", + "abstract": "Generative AI has shown its value for many software engineering tasks. Still in its infancy, large language model (LLM)-based proof generation lags behind LLM-based code generation. In this paper, we present AutoVerus. AutoVerus uses LLMs to automatically generate correctness proof for Rust code. AutoVerus is designed to match the unique features of Verus, a verification tool that can prove the correctness of Rust code using proofs and specifications also written in Rust. AutoVerus consists of a network of agents that are crafted and orchestrated to mimic human experts' three phases of proof construction: preliminary proof generation, proof refinement guided by generic tips, and proof debugging guided by verification errors. To thoroughly evaluate AutoVerus and help foster future research in this direction, we have built a benchmark suite of 150 non-trivial proof tasks, based on existing code-generation benchmarks and verification benchmarks. Our evaluation shows that AutoVerus can automatically generate correct proof for more than 90% of them, with more than half of them tackled in less than 30 seconds or 3 LLM calls.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763174", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chenyuan", + "last_name": "Yang", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "X.", + "last_name": "Li", + "institution": "Columbia University" + }, + { + "first_name": "Md Rakib Hossain", + "last_name": "Misu", + "institution": "University of California, Irvine" + }, + { + "first_name": "Jianan", + "last_name": "Yao", + "institution": "University of Toronto" + }, + { + "first_name": "Weidong", + "last_name": "Cui", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Yeyun", + "last_name": "Gong", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jacob R.", + "last_name": "Lorch", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shuai", + "last_name": "Lu", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Fan", + "last_name": "Yang", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Ziqiao", + "last_name": "Zhou", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Shan", + "last_name": "Lu", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/pacmpl/YangLMYCGHLLL0Z25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763172", + "title": "Complete the Cycle: Reachability Types with Expressive Cyclic References", + "abstract": "Local reasoning about programs that combine aliasing and mutable state is a longstanding challenge. Existing approaches – ownership systems, linear and affine types, uniqueness types, and lexical effect tracking – impose global restrictions such as uniqueness or linearity, or rely on shallow syntactic analyses. These designs fall short with higher-order functions and shared mutable state. Reachability Types (RT) track aliasing and separation in higher-order programs, ensuring runtime safety and non-interference. However, RT systems face three key limitations: (1) they prohibit cyclic references, ruling out non-terminating computations and fixed-point combinators; (2) they require deep tracking, where a qualifier must include all transitively reachable locations, reducing precision and hindering optimizations like fine-grained parallelism; and (3) referent qualifier invariance prevents referents from escaping their allocation contexts, making reference factories inexpressible. In this work, we address these limitations by extending RT with three mechanisms that enhance expressiveness. First, we introduce cyclic references, enabling recursive patterns to be encoded directly through the store. Second, we adopt shallow qualifier tracking, decoupling references from their transitively reachable values. Finally, we introduce an escaping rule with reference subtyping, allowing referent qualifiers to outlive their allocation context. These extensions are formalized in the F <: ∘ -calculus with a mechanized proof of type soundness, and case studies illustrate expressiveness through fixpoint combinators, non-interfering parallelism, and escaping read-only references.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763172", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Haotian", + "last_name": "Deng", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Siyuan", + "last_name": "He", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Songlin", + "last_name": "Jia", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Yuyan", + "last_name": "Bao", + "institution": "Augusta University" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "journals/pacmpl/0001HJBR25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763175", + "title": "HeapBuffers: Why Not Just Using a Binary Serialization Format for Your Managed Memory?", + "abstract": "In modern cloud applications, data serialization and deserialization (DSD) are common yet expensive operations. Languages such as Java incur significant overhead from DSD operations because of their managed memory, which uses an IO-incompatible, sparse, platform-dependent data layout for storing objects. Can language VMs bypass costly DSD operations by directly operating on an IO-ready binary format? In this paper, we address this question by presenting a new DSD library for Java called HeapBuffers. HeapBuffers maintains a Java-friendly programming model through managed memory, yet it operates on data stored using a dense, platform-independent, memory format. In this way, HeapBuffers data can be used to perform IO operations without the need to convert objects from/to a VM-internal memory representation, thus eliminating the need for expensive DSD operations. Compiler optimizations combined with specialized garbage collection ensure that accessing HeapBuffers data is nearly as efficient as handling regular Java objects. The answer to our question is largely positive: our experiments show that HeapBuffers data can be accessed at high performance and can be used as is to perform IO, making the cost of DSD effectively negligible. IO performance of applications using HeapBuffers is often orders of magnitude faster than that obtained using the prevailing DSD libraries.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763175", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Daniele", + "last_name": "Bonetta", + "institution": "Vrije Universiteit Amsterdam" + }, + { + "first_name": "Júnior", + "last_name": "Löff", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Matteo", + "last_name": "Basso", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "journals/pacmpl/BonettaLBB25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763176", + "title": "Tunneling through the Hill: Multi-way Intersection for Version-Space Algebras in Program Synthesis", + "abstract": "Version space algebra (VSA) is an effective data structure for representing sets of programs and has been extensively used in program synthesis. Despite this success, a crucial shortcoming of VSA-based synthesis is its inefficiency when processing many examples. Given a set of IO examples, a typical VSA-based synthesizer runs by first constructing an individual VSA for each example and then iteratively intersecting these VSAs one by one. However, the intersection of two VSAs can be much larger than the original ones -- this effect accumulates during the iteration, making the scale of intermediate VSAs quickly explode. In this paper, we aim to reduce the cost of intersecting VSAs in synthesis. We investigate the process of the iterative intersection and observe that, although this process may construct some huge intermediate VSAs, its final VSA is usually small in practice because only a few programs can pass all examples. Utilizing this observation, we propose the approach of multi-way intersection, which directly intersects multiple small VSAs into the final result, thus avoiding the previous bottleneck of constructing huge intermediate VSAs. Furthermore, since the previous intersection algorithm is inefficient for multiple VSAs, we design a novel algorithm to avoid most unnecessary VSA nodes. We integrated our approach into two SOTA VSA-based synthesizers: a general synthesizer based on VSA and a specialized one for the string domain, Blaze. We evaluate them over 4 different datasets, 994 synthesis tasks; the results show that our approach can significantly improve the performance of VSA-based synthesis, with up to 105 more tasks solved and a speedup of 7.36 times.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763176", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Guanlin", + "last_name": "Chen", + "institution": "Peking University" + }, + { + "first_name": "Ruyi", + "last_name": "Ji", + "institution": "Peking University" + }, + { + "first_name": "Shuhao", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + } + ], + "dblp_key": "journals/pacmpl/ChenJZ025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763171", + "title": "Validating Soundness and Completeness in Pattern-Match Coverage Analyzers", + "abstract": "Pattern matching is a powerful mechanism for writing safe and expressive conditional logic. Once primarily associated with functional programming, it has become a common paradigm even in non-functional languages, such as Java. Languages that support pattern matching include specific analyzers, known as pattern-match coverage analyzers, to ensure its correct and efficient use by statically verifying properties such as exhaustiveness and redundancy. However, these analyzers can suffer from soundness and completeness issues, leading to false negatives (unsafe patterns mistakenly accepted) or false positives (valid patterns incorrectly rejected). In this work, we present a systematic approach for validating soundness and completeness in pattern-match coverage analyzers. The approach consists of a novel generator for algebraic data types and pattern-matching statements, supporting features that increase the complexity of coverage analysis, such as generalized algebraic data types. To establish the test oracle without building a reference implementation from scratch, the approach generates both exhaustive and inexhaustive pattern-matching cases, either by construction or by encoding them as SMT formulas. The latter leads to a universal test oracle that cross-checks coverage analysis results against a constraint solver, exposing soundness and completeness bugs in case of inconsistencies. We implement this approach in Ikaros, which we evaluate on three major compilers: Scala, Java, and Haskell. Despite pattern-match coverage analyzers being only a small part of these compilers, Ikaros has uncovered 16 bugs, of which 12 have been fixed. Notably, 7 instances were important soundness bugs that could lead to unexpected runtime errors. Additionally, Ikaros provides a scalable framework for extending it to any language with ML-like pattern matching.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763171", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cyril Flurin", + "last_name": "Moser", + "institution": "ETH Zurich" + }, + { + "first_name": "Thodoris", + "last_name": "Sotiropoulos", + "institution": "ETH Zurich" + }, + { + "first_name": "Chengyu", + "last_name": "Zhang", + "institution": "ETH Zurich" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/MoserS0025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763178", + "title": "Multi-modal Sketch-Based Behavior Tree Synthesis", + "abstract": "Behavior trees (BTs) are widely adopted in the field of agent control, particularly in robotics, due to their modularity and reactivity. However, constructing a BT that meets the desired expectations is time-consuming and challenging, especially for non-experts. This paper presents BtBot, a multi-modal sketch-based behavior tree synthesis technique. Given a natural language task description and a set of positive and negative examples, BtBot automatically generates a BT program that aligns with the natural language description and meets the requirements of the examples. Inside BtBot, an LLM is employed to understand the task’s natural language description and generate a sketch of the task execution. Then, BtBot searches the sketch to synthesize a candidate BT program consistent with the user-provided positive and negative examples. When the sketch is proven to be incapable of generating the target BT, BtBot provides a multi-step repairing method that modifies the control nodes and structure of the sketch to search for the desired BT. We have implemented BtBot in a prototype and evaluated it on a benchmark of 70 tasks across multiple scenarios. The experimental results indicate that BtBot outperforms the existing BT synthesis techniques in effectiveness and efficiency. In addition, two user studies have been conducted to demonstrate the usefulness of BtBot.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763178", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "W.H.", + "last_name": "Zhang", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Zhenbang", + "last_name": "Chen", + "institution": "National University of Defense Technology" + }, + { + "first_name": "Weijiang", + "last_name": "Hong", + "institution": "National University of Defense Technology" + } + ], + "dblp_key": "journals/pacmpl/ZhangCH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763177", + "title": "Zero-Overhead Lexical Effect Handlers", + "abstract": "Exception handlers—and effect handlers more generally—are language mechanisms for structured non­local control flow. A recent trend in language-design research has introduced lexically scoped handlers, which address a modularity problem with dynamic scoping. While dynamically scoped handlers allow zero-overhead implementations when no effects are raised, existing implementations of lexically scoped handlers require programs to pay a cost just for having handlers in the lexical context. In this paper, we present a novel approach to implementing lexically scoped handlers of exceptional effects. It satisfies the zero-overhead principle—a property otherwise met by most modern compilers supporting dynamically scoped exception handlers. The key idea is a type-directed translation that emits information indicating how handlers come into the lexical context. This information guides the runtime in walking the stack to locate the right handler. Crucially, no reified lexical identifiers of handlers are needed, and mainline code is not slowed down by the presence of handlers in the program text. We formalize the essential aspects of this compilation scheme and prove it correct. We integrate our approach into the Lexa language, allowing the compilation strategy to be customized for each declared effect based on its expected invocation rate. Empirical results suggest that the new Lexa compiler reduces run-time overhead in low-effect or no-effect scenarios while preserving competitive performance for effect-heavy workloads.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763177", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Cong", + "last_name": "Ma", + "institution": "University of Waterloo" + }, + { + "first_name": "Zhaoyi", + "last_name": "Ge", + "institution": "University of Waterloo" + }, + { + "first_name": "Max", + "last_name": "Jung", + "institution": "University of Waterloo" + }, + { + "first_name": "Yizhou", + "last_name": "Zhang", + "institution": "University of Waterloo" + } + ], + "dblp_key": "journals/pacmpl/0009GJ025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763179", + "title": "Garbage Collection for Rust: The Finalizer Frontier", + "abstract": "Rust is a non-Garbage Collected (GCed) language, but the lack of GC makes expressing data-structures that require shared ownership awkward, inefficient, or both. In this paper we explore a new design for, and implementation of, GC in Rust, called Alloy. Unlike previous approaches to GC in Rust, Alloy allows existing Rust destructors to be automatically used as GC finalizers: this makes Alloy integrate better with existing Rust code than previous solutions but introduces surprising soundness and performance problems. Alloy provides novel solutions for the core problems: finalizer safety analysis rejects unsound destructors from automatically being reused as finalizers; finalizer elision optimises away unnecessary finalizers; and premature finalizer prevention ensures that finalizers are only run when it is provably safe to do so.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763179", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Hughes", + "institution": "King's College London" + }, + { + "first_name": "Laurence", + "last_name": "Tratt", + "institution": "King's College London" + } + ], + "dblp_key": "journals/pacmpl/HughesT25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763180", + "title": "Divining Profiler Accuracy: An Approach to Approximate Profiler Accuracy through Machine Code-Level Slowdown", + "abstract": "Optimizing performance on top of modern runtime systems with just-in-time (JIT) compilation is a challenge for a wide range of applications from browser-based applications on mobile devices to large-scale server applications. Developers often rely on sampling-based profilers to understand where their code spends its time. Unfortunately, sampling of JIT-compiled programs can give inaccurate and sometimes unreliable results. To assess accuracy of such profilers, we would ideally want to compare their results to a known ground truth. With the complexity of today’s software and hardware stacks, such ground truth is unfortunately not available. Instead, we propose a novel technique to approximate a ground truth by accurately slowing down a Java program at the machine-code level, preserving its optimization and compilation decisions as well as its execution behavior on modern CPUs. Our experiments demonstrate that we can slow down benchmarks by a specific amount, which is a challenge because of the optimizations in modern CPUs, and we verified with hardware profiling that on a basic-block level, the slowdown is accurate for blocks that dominate the execution. With the benchmarks slowed down to specific speeds, we confirmed that Async-profiler, JFR, JProfiler, and YourKit maintain original performance behavior and assign the same percentage of run time to methods. Additionally, we identify cases of inaccuracy caused by missing debug information, which prevents the correct identification of the relevant source code. Finally, we tested the accuracy of sampling profilers by approximating the ground truth by the slowing down of specific basic blocks and found large differences in accuracy between the profilers. We believe, our slowdown-based approach is the first practical methodology to assess the accuracy of sampling profilers for JIT-compiling systems and will enable further work to improve the accuracy of profilers.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763180", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Humphrey", + "last_name": "Burchell", + "institution": "University of Kent" + }, + { + "first_name": "Stefan", + "last_name": "Marr", + "institution": "University of Kent" + } + ], + "dblp_key": "journals/pacmpl/BurchellM25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763181", + "title": "On the Impact of Formal Verification on Software Development", + "abstract": "Auto-active verifiers like Dafny aim to make formal methods accessible to non-expert users through SMT automation. However, despite the automation and other programmer-friendly features, they remain sparsely used in real-world software development, due to the significant effort required to apply them in practice. We interviewed 14 experienced Dafny users about their experiences using it in large-scale projects. We apply grounded theory to analyze the interviews to systematically identify how auto-active verification impacts software development, and to identify opportunities to simplify the use, and hence, expand the adoption of verification in software development.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763181", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Eric", + "last_name": "Mugnier", + "institution": "University of California San Diego" + }, + { + "first_name": "Yuanyuan", + "last_name": "Zhou", + "institution": "University of California San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California San Diego" + }, + { + "first_name": "Michael", + "last_name": "Coblenz", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/Mugnier0JC25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763183", + "title": "Faster Explicit-Trace Monitoring-Oriented Programming for Runtime Verification of Software Tests", + "abstract": "Runtime verification (RV) monitors program executions for conformance with formal specifications (specs). This paper concerns Monitoring-Oriented Programming (MOP), the only RV approach shown to scale to thousands of open-source GitHub projects when simultaneously monitoring passing unit tests against dozens of specs. Explicitly storing traces—sequences of spec-related program events—can make it easier to debug spec violations or to monitor tests against hyperproperties, which requires reasoning about sets of traces. But, most online MOP algorithms are implicit trace, i.e. they work event by event to avoid the time and space costs of storing traces. Yet, TraceMOP, the only explicit-trace online MOP algorithm, is often too slow and often fails. We propose LazyMOP, a faster explicit-trace online MOP algorithm for RV of tests that is enabled by three simple optimizations. First, whereas all existing online MOP algorithms eagerly monitor all events as they occur, LazyMOP lazily stores only unique traces at runtime and monitors them just before the test run ends. Lazy monitoring is inspired by a recent finding: 99.87% of traces during RV of tests are duplicates. Second, to speed up trace storage, LazyMOP encodes events and their locations as integers, and amortizes the cost of looking up locations across events. Lastly, LazyMOP only synchronizes accesses to its trace store after detecting multi-threading, unlike TraceMOP’s eager and wasteful synchronization of all accesses. On 179 Java open-source projects, LazyMOP is up to 4.9x faster and uses 4.8x less memory than TraceMOP, finding the same traces (modulo test non-determinism) and violations. We show LazyMOP’s usefulness in the context of software evolution, where tests are re-run after each code change. LazyMOP e optimizes LazyMOP in this context by generating fewer duplicate traces. Using unique traces from one code version, LazyMOP e finds all pairs of method 𝑚 and spec 𝑠, where all traces for 𝑠 in 𝑚 are identical. Then, in a future version, LazyMOP e generates and monitors only one trace of 𝑠 in 𝑚. LazyMOP e is up to 3.9x faster than LazyMOP and it speeds up two recent techniques that speed up RV during evolution by up to 4.6x with no loss in violations.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763183", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Guan", + "institution": "Cornell University" + }, + { + "first_name": "Marcelo", + "last_name": "d’Amorim", + "institution": "North Carolina State University" + }, + { + "first_name": "Owolabi", + "last_name": "Legunsen", + "institution": "Cornell University" + } + ], + "dblp_key": "journals/pacmpl/GuandL25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763797", + "title": "Type-Outference with Label-Listeners: Foundations for Decidable Type-Consistency for Nominal Object-Oriented Generics", + "abstract": "We present the first sound and complete decision procedure capable of validating nominal object-oriented programs without type annotations in expressions even in the presence of generic interfaces with irregularly-recursive signatures. Such interface signatures are exemplary of the challenges an algorithm must overcome in order to scale to the needs of modern major typed object-oriented languages. We do so by incorporating event-driven label-listeners into our constraint system, enabling more complex aspects of program validation to be generated on demand while still ensuring termination. Furthermore, we define type-consistency as a novel declarative notion of program validity that ensures safety without requiring a complex grammar of types to perform inference within. While type-inferability ensures type-consistency, the converse does not necessarily hold. Thus our algorithm decides program validity with out inferring the types missing from the program, and so we instead call it a type-outference algorithm. By bypassing type-inference, the proofs involving type-consistency more directly connect the design of and reasoning about constraints to the operational semantics of the language, simplifying much of the design and verification process. We mechanically formalize and verify these concepts and techniques—type-consistency, type-outference, and label-listeners—in Rocq to provide a solid foundation for scaling decidability beyond the limitations of structural types.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763797", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "Oldham Council" + } + ], + "dblp_key": "journals/pacmpl/Tate25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763184", + "title": "On Higher-Order Model Checking of Effectful Answer-Type-Polymorphic Programs", + "abstract": "Applying higher-order model checking techniques to programs that use effect handlers is a major challenge, given the recent undecidability result obtained by Dal Lago and Ghyselen. This challenge has been addressed by using answer-type modifications, the use of a monomorphic version of which allows to recover decidability. However, the absence of polymorphism leads to a loss of modularity, reusability, and even expressivity. In this work, we study the problem of defining a calculus that on the one hand supports answer-type polymorphism and subtyping but on the other hand ensures the underlying model checking problem to remain decidable. The solution proposed in this paper is based on the introduction of the polymorphic answer-type □ whose role is to provide a good compromise between expressiveness and decidability, the latter demonstrated through the construction of a selective type-directed CPS transformation targeting a calculus without effect handlers and any form of polymorphism. Noticeably, the introduced calculus HEPCF □ ATM allows the answer types of effects implemented by tail-resumptive effect handlers to be polymorphic. We also implemented a proof-of-concept model checker for HEPCF □ ATM programs.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763184", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "Tohoku University" + } + ], + "dblp_key": "journals/pacmpl/SekiyamaL025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763182", + "title": "Syntactic Completions with Material Obligations", + "abstract": "Code editors provide essential services that help developers understand, navigate, and modify programs. However, these services often fail in the presence of syntax errors. Existing syntax error recovery techniques, like panic mode and multi-option repairs, are either too coarse, e.g. in deleting large swathes of code, or lead to a proliferation of possible completions. This paper introduces tall tylr, an error-handling parser and editor generator that completes malformed code with syntactic obligations that abstract over many possible completions. These obligations generalize the familiar notion of holes in structure editors to cover missing operands, operators, delimiters, and sort transitions. tall tylr is backed by a novel theory of tile-based parsing, conceptually organized around a molder that turns tokens into tiles and a melder that completes and parses tiles into terms using an error-handling generalization of operator-precedence parsing. We formalize melding as a parsing calculus, meldr, that completes input tiles with additional obligations such that it can be parsed into a well-formed term, with success guaranteed over all inputs. We further describe how tall tylr implements molding and completion-ranking using the principle of minimizing obligations . Obligations offer a useful way to scaffold internal program representations, but in tall tylr we go further to investigate the potential of materializing these obligations visually to the programmer. We conduct a user study to evaluate the extent to which an editor like tall tylr that materializes syntactic obligations might be usable and useful, finding both points of positivity and interesting new avenues for future work.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763182", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "David A.", + "last_name": "Moon", + "institution": "University of Michigan" + }, + { + "first_name": "Andrew", + "last_name": "Blinn", + "institution": "University of Michigan" + }, + { + "first_name": "Tod S.", + "last_name": "Porter", + "institution": "University of Michigan" + }, + { + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "University of Michigan" + } + ], + "dblp_key": "journals/pacmpl/MoonBPO25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3764068", + "title": "An Empirical Evaluation of Property-Based Testing in Python", + "abstract": "Property-based testing (PBT) is a testing methodology with origins in the functional programming community. In recent years, PBT libraries have been developed for non-functional languages, including Python. However, to date, there is little evidence regarding how effective property-based tests are at finding bugs, and whether some kinds of property-based tests might be more effective than others. To gather this evidence, we conducted a corpus study of 426 Python programs that use Hypothesis, Python’s most popular library for PBT. We developed formal definitions for 12 categories of property-based test and implemented an intraprocedural static analysis that categorizes tests. Then, we evaluated the efficacy of test suites of 40 projects using mutation testing, and found that on average, each property-based test finds about 50 times as many mutations as the average unit test. We also identified the categories with the tests most effective at finding mutations, finding that tests that look for exceptions, that test inclusion in collections, and that check types are over 19 times more effective at finding mutations than other kinds of property-based tests. Finally, we conducted a parameter sweep study to assess the strength of property-based tests as a function of the number of random inputs generated, finding that 76% of mutations found were found within the first 20 inputs.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3764068", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Savitha", + "last_name": "Ravi", + "institution": "University of California San Diego" + }, + { + "first_name": "Michael", + "last_name": "Coblenz", + "institution": "University of California San Diego" + } + ], + "dblp_key": "journals/pacmpl/RaviC25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763800", + "title": "An Empirical Study of Bugs in the rustc Compiler", + "abstract": "Rust is gaining popularity for its well-known memory safety guarantees and high performance, distinguishing it from C/C++ and JVM-based languages. Its compiler, rustc, enforces these guarantees through specialized mechanisms such as trait solving, borrow checking, and specific optimizations. However, Rust's unique language mechanisms introduce complexity to its compiler, resulting in bugs that are uncommon in traditional compilers. With Rust's increasing adoption in safety-critical domains, understanding these language mechanisms and their impact on compiler bugs is essential for improving the reliability of both rustc and Rust programs. Such understanding could provide the foundation for developing more effective testing strategies tailored to rustc. Improving the quality of rustc testing is essential for enhancing compiler reliability, which in turn strengthens the safety and correctness of all Rust programs, as compiler bugs can silently propagate into every compiled program. Yet, we still lack a large-scale, detailed, and in-depth study of rustc bugs. To bridge this gap, this work presents a comprehensive and systematic study of rustc bugs, specifically those originating in semantic analysis and intermediate representation (IR) processing, which are stages that implement essential Rust language features such as ownership and lifetimes. Our analysis examines issues and fixes reported between 2022 and 2024, with a manual review of 301 valid issues. We categorize these bugs based on their causes, symptoms, affected compilation stages, and test case characteristics. Additionally, we evaluate existing rustc testing tools to assess their effectiveness and limitations. Our key findings include: (1) rustc bugs primarily arise from Rust's type system and lifetime model, with frequent errors in the High-Level Intermediate Representation (HIR) and Mid-Level Intermediate Representation (MIR) modules due to complex checkers and optimizations; (2) bug-revealing test cases often involve unstable features, advanced trait usages, lifetime annotations, standard APIs, and specific optimization levels; (3) while both valid and invalid programs can trigger bugs, existing testing tools struggle to detect non-crash errors, underscoring the need for further advancements in rustc testing.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763800", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zixi", + "last_name": "Liu", + "institution": "Nanjing University" + }, + { + "first_name": "Yang", + "last_name": "Feng", + "institution": "Nanjing University" + }, + { + "first_name": "Yunbo", + "last_name": "Ni", + "institution": "Nanjing University" + }, + { + "first_name": "Shaohua", + "last_name": "Li", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Xizhe", + "last_name": "Yin", + "institution": "Nanjing University" + }, + { + "first_name": "Qingkai", + "last_name": "Shi", + "institution": "Nanjing University" + }, + { + "first_name": "Baowen", + "last_name": "Xu", + "institution": "Nanjing University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" + } + ], + "dblp_key": "journals/pacmpl/Liu0N0YSX025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763798", + "title": "Integrating Resource Analyses via Resource Decomposition", + "abstract": "Resource analysis aims to derive symbolic resource bounds of programs. Although numerous resource-analysis techniques have been developed—ranging from static to dynamic and manual to automated techniques—they each come with their own distinct strengths and weaknesses. To overcome the limitations of individual resource-analysis techniques, a promising approach is to combine them in such a way that retains their complementary strengths while mitigating their respective weaknesses. This article proposes a novel program translation method called resource decomposition that facilitates the combination of different resource-analysis techniques. The key idea of resource decomposition is to first identify and annotate the program with resource components , which are user-specified variables that serve as an interface between different analysis techniques. Using these resource components, our method generates a resource-guarded program , where one analysis technique is used to infer an overall cost bound parametric in the resource components, and other analysis techniques are used to infer symbolic bounds to be substituted for the resource components. We establish the soundness of resource decomposition using a denotational cost semantics and a binary logical relation. It states that composing sound bounds results in a sound bound for the original program. Furthermore, we present three instantiations of the resource-decomposition framework, each representing distinct combinations of static, data-driven, and manual resource analyses. The data-driven part of these instantiations is a novel Bayesian approach to inferring linear and logarithmic bounds of recursion depths. An implementation and empirical evaluation of resource decomposition demonstrates that it can effectively infer sound and asymptotically tight cost bounds for a number of challenging benchmarks that are beyond the reach of previous analysis methods.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763798", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Long", + "last_name": "Pham", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yue", + "last_name": "Niu", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Nathan", + "last_name": "Glover", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Feras A.", + "last_name": "Saad", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/PhamNGS025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763799", + "title": "A Flow-Sensitive Refinement Type System for Verifying eBPF Programs", + "abstract": "The Extended Berkeley Packet Filter (eBPF) subsystem within an operating system’s kernel enables userspace programs to extend kernel functionality dynamically. Due to the security risks associated with runtime modification of the operating system, eBPF requires all programs to be verified before deploying them within the kernel. Existing approaches to eBPF verification are monolithic, requiring their entire analysis to be done in a secure environment, resulting in the need for extensive trusted codebases. We present a type- based verification approach that automatically infers proof certificates in userspace, thus reducing the size and complexity of the trusted codebase. At the same time, only the proof-checking component needs to be deployed in a secure environment. Moreover, compared to previous techniques, our type system enhances the debuggability of the programs for users through ergonomic type annotations when verification fails. We implemented our type inference algorithm in a tool called VeRefine and evaluated it against an existing eBPF verifier, Prevail. VeRefine outperformed Prevail on most of the industrial benchmarks.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763799", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ameer", + "last_name": "Hamza", + "institution": "Florida State University" + }, + { + "first_name": "Lucas", + "last_name": "Zavalía", + "institution": "Florida State University" + }, + { + "first_name": "Arie", + "last_name": "Gurfinkel", + "institution": "University of Waterloo" + }, + { + "first_name": "Jorge A.", + "last_name": "Navas", + "institution": "Seattle University" + }, + { + "first_name": "Grigory", + "last_name": "Fedyukovich", + "institution": "Florida State University" + } + ], + "dblp_key": "journals/pacmpl/HamzaZGNF25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3763185", + "title": "DepFuzz: Efficient Smart Contract Fuzzing with Function Dependence Guidance", + "abstract": "Fuzzing is an effective technique to detect vulnerabilities in smart contracts. The challenge of smart contract fuzzing lies in the statefulness of contracts, which indicates that certain vulnerabilities can only be manifested in specific contract states. State-of-the-art fuzzers may generate and execute a plethora of meaningless or redundant transaction sequences during fuzzing, incurring a penalty in efficiency. To this end, we present DepFuzz, a hybrid fuzzer for efficient smart contract fuzzing, which introduces a symbolic execution module into the feedback-based fuzzer. Guided by the distance-based function dependencies between functions, DepFuzz can efficiently yield meaningful transaction sequences that contribute to vulnerability exposure or code coverage. The experiments on 286 benchmark smart contracts and 500 large real-world smart contracts corroborate that, compared to state-of-the-art approaches, DepFuzz achieves higher instruction coverage rate and uncovers many more vulnerabilities with less time.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3763185", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Chenyang", + "last_name": "Ma", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Wei", + "last_name": "Song", + "institution": "Nanjing University of Science and Technology" + }, + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + } + ], + "dblp_key": "journals/pacmpl/Ma0025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3764116", + "title": "Structural Information Flow: A Fresh Look at Types for Non-interference", + "abstract": "Information flow control is a long-studied approach for establishing non-interference properties of programs. For instance, it can be used to prove that a secret does not interfere with some computation, thereby establishing that the former does not leak through the latter. Despite their potential as a holy grail for security reasoning and their maturity within the literature, information flow type systems have seen limited adoption. In practice, information flow specifications tend to be excessively complex and can easily spiral out of control even for simple programs. Additionally, while non-interference is well-behaved in an idealized setting where information leakage never occurs, most practical programs must violate non-interference in order to fulfill their purpose. Useful information flow type systems in prior work must therefore contend with a definition of non-interference extended with declassification , which often offers weaker modular reasoning properties. We introduce structural information flow , which both illuminates and addresses these issues from a logical viewpoint. In particular, we draw on established insights from the modal logic literature to argue that information flow reasoning arises from hybrid logic , rather than conventional modal logic as previously imagined. We show with a range of examples that structural information flow specifications are straightforward to write and easy to visually parse. Uniquely in the structural setting, we demonstrate that declassification emerges not as an aberration to non-interference, but as a natural and unavoidable consequence of sufficiently general machinery for information flow. This flavor of declassification features excellent local reasoning and enables our approach to account for real-world information flow needs without compromising its theoretical elegance. Finally, we establish non-interference via a logical relations approach, showing off its simplicity in the face of the expressive power captured.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3764116", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Hemant", + "last_name": "Gouni", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/GouniPA25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3764115", + "title": "Bennet: Randomized Specification Testing for Heap-Manipulating Programs", + "abstract": "Property-based testing (PBT), widely used in functional languages and interactive theorem provers, works by randomly generating many inputs to a system under test. While PBT has also seen some use in low-level languages like C, users in this setting must craft all their own generators by hand, rather than letting the tool synthesize most generators automatically from types or logical specifications. For low-level code with complex memory ownership patterns, writing such generators can waste significant amounts of time. CN, a specification and verification framework for C, features a streamlined presentation of separation logic that is specially tuned to present only \"easy\" logical problems to an underlying constraint solver. Prior work on the Fulminate testing framework has shown that CN's streamlined specifications can also be checked effectively at run time, providing an oracle for testing whether a memory state satisfies a pre- or postcondition. We show that the restricted syntax of CN is also a good basis for deriving generators for random inputs satisfying separation-logic preconditions. We formalize the semantics for a DSL describing these generators, as well as optimizations that reorder when values are generated and propagate arithmetic constraints. Using this DSL, we implement a property-based testing tool, Bennet, that generates and runs random tests for C functions annotated with CN specifications. We evaluate Bennet on a corpus of programs with CN specifications and show that it can efficiently generate bug-revealing inputs for heap-manipulating programs with complex preconditions.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3764115", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Zain K", + "last_name": "Aamer", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "journals/pacmpl/AamerP25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3764117", + "title": "From Linearity to Borrowing", + "abstract": "Linear type systems are powerful because they can statically ensure the correct management of resources like memory, but they can also be cumbersome to work with, since even benign uses of a resource require that it be explicitly threaded through during computation. Borrowing, as popularized by Rust, reduces this burden by allowing one to temporarily disable certain resource permissions (e.g., deallocation or mutation) in exchange for enabling certain structural permissions (e.g., weakening or contraction). In particular, this mechanism spares the borrower of a resource from having to explicitly return it to the lender but nevertheless ensures that the lender eventually reclaims ownership of the resource. In this paper, we elucidate the semantics of borrowing by starting with a standard linear type system for ensuring safe manual memory management in an untyped lambda calculus and gradually augmenting it with immutable borrows, lexical lifetimes, reborrowing, and finally mutable borrows. We prove semantic type soundness for our Borrow Calculus (BoCa) using Borrow Logic (BoLo), a novel domain-specific separation logic for borrowing. We establish the soundness of this logic using a semantic model that additionally guarantees that our calculus is terminating and free of memory leaks. We also show that our Borrow Logic is robust enough to establish the semantic safety of some syntactically ill-typed programs that temporarily break but reestablish invariants.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3764117", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Andrew", + "last_name": "Wagner", + "institution": "Northeastern University" + }, + { + "first_name": "Olek", + "last_name": "Gierczak", + "institution": "Northeastern University" + }, + { + "first_name": "Brianna", + "last_name": "Marshall", + "institution": "Northeastern University" + }, + { + "first_name": "John M.", + "last_name": "Li", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + } + ], + "dblp_key": "journals/pacmpl/WagnerGML025", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3764118", + "title": "Advancing Performance via a Systematic Application of Research and Industrial Best Practice", + "abstract": "An elusive facet of high-impact research is translation to production. Production deployments are intrinsically complex and specialized, whereas research exploration requires stripping away incidental complexity and extraneous requirements to create clarity and generality. Conventional wisdom suggests that promising research rarely holds up once simplifying assumptions and missing features are addressed. This paper describes a productization methodology that led to a striking result: outperforming the mature and highly optimized state of the art by more than 10%. Concretely, this experience paper captures lessons from translating a high-performance research garbage collector published at PLDI’22, called LXR, to a hyperscale revenue-critical application. Key to our success was a new process that dovetails best practice research methodology with industrial processes, at each step assuring that neither research metrics nor production measures regressed. This paper makes three contributions. i) We advance the state of the art, nearly halving the cost of garbage collection. ii) We advance research translation by sharing our approach and five actionable lessons. iii) We pose questions about how the community should evaluate innovative ideas in mature and heavily productized fields. We deliver an optimized version of LXR. This collector, as far as we are aware, is the fastest general-purpose garbage collector for Java to date. On standard workloads, it substantially outperforms OpenJDK’s default G1 collector and the prior version of LXR, while also meeting Google internal correctness and uptime requirements. We address all of the limitations identified in the PLDI’22 paper. We use this experience to illustrate the following key lessons that are concrete, actionable, and transferable. L1) A systematic combination of research and production methodologies can meet production objectives while simultaneously advancing the research state-of-the-art. L2) A benchmark suite cannot and need not contain facsimiles of production workloads. It is sufficient to replicate individual pathologies that manifest in production (e.g., allocation rates, trace rates, heap constraints, etc.) or configure the JVM to force a workload to manifest the pathology. L3) Productization experiences can strengthen research workloads; we upstreamed one such workload. L4) Production environment requirements are myriad and sometimes prosaic, extending well beyond those that can reasonably be addressed in a research paper. L5) This collector is not yet in production, reminding us that replacing core technology in industry is a challenging sociotechnical problem. The artifact we deliver gives practitioners and researchers a new benchmark for high performance garbage collection. The lessons we enumerate should help academic and industrial researchers with actionable steps to close the gap between research paper results and industrial impact. The 10% ‘productization dividend’ the process delivered should spark discussion about how our field evaluates innovative ideas in mature areas.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3764118", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Wenyu", + "last_name": "Zhao", + "institution": "Australian National University" + }, + { + "first_name": "Stephen M.", + "last_name": "Blackburn", + "institution": "Australian National University" + }, + { + "first_name": "Kathryn S.", + "last_name": "McKinley", + "institution": "Google (United States)" + }, + { + "first_name": "Man", + "last_name": "Cao", + "institution": "Google (United States)" + }, + { + "first_name": "Sara S.", + "last_name": "Hamouda", + "institution": "Calvary Hospital" + } + ], + "dblp_key": "journals/pacmpl/ZhaoBMCH25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3766912", + "title": "Corrigendum: PAFL: Enhancing Fault Localizers by Leveraging Project-Specific Fault Patterns", + "abstract": "This is a corrigendum for the article “PAFL: Enhancing Fault Localizers by Leveraging Project-Specific Fault Patterns” by Donguk Kim, Minseok Jeon, Doha Hwang, and Hakjoo Oh, published in Proc. ACM Program. Lang. 9, OOPSLA1, Article 129 (April 2025), https://doi.org/10.1145/3720526 . The designation of Minseok Jeon, Korea University, and Hakjoo Oh, Korea University, as co-corresponding authors was erroneously left off the article. The correct corresponding authors for this article are Minseok Jeon, Korea University, and Hakjoo Oh, Korea University.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3766912", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Donguk", + "last_name": "Kim", + "institution": "Korea University" + }, + { + "first_name": "Minseok", + "last_name": "Jeon", + "institution": "Korea University" + }, + { + "first_name": "Doha", + "last_name": "Hwang", + "institution": "Samsung (South Korea)" + }, + { + "first_name": "Hakjoo", + "last_name": "Oh", + "institution": "Korea University" + } + ], + "dblp_key": "journals/pacmpl/KimJHO25a", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3764119", + "title": "Fray: An Efficient General-Purpose Concurrency Testing Platform for the JVM", + "abstract": "Concurrency bugs are hard to discover and reproduce, even in well-synchronized programs that are free of data races. Thankfully, prior work on controlled concurrency testing (CCT) has developed sophisticated algorithms---such as partial-order based and selectively uniform sampling---to effectively search over the space of thread interleavings. Unfortunately, in practice, these techniques cannot easily be applied to real-world Java programs due to the difficulties of controlling concurrency in the presence of the managed runtime and complex synchronization primitives. So, mature Java projects that make heavy use of concurrency still rely on naive repeated stress testing in a loop. In this paper, we take a first-principles approach for elucidating the requirements and design space to enable CCT on arbitrary real-world JVM applications. We identify practical challenges with classical design choices described in prior work---such as concurrency mocking, VM hacking, and OS-level scheduling---that affect bug-finding effectiveness and/or the scope of target applications that can be easily supported. Based on these insights, we present Fray, a new platform for performing push-button concurrency testing (beyond data races) of JVM programs. The key design principle behind Fray is to orchestrate thread interleavings without replacing existing concurrency primitives, using a concurrency control mechanism called shadow locking for faithfully expressing the set of all possible program behaviors. With full concurrency control, Fray can test applications using a number of search algorithms from a simple random walk to sophisticated techniques like PCT, POS, and SURW. In an empirical evaluation on 53 benchmark programs with known bugs (SCTBench and JaConTeBe), Fray with random walk finds 70% more bugs than JPF and 77% more bugs than RR's chaos mode. We also demonstrate Fray's push-button applicability on 2,664 tests from Apache Kafka, Lucene, and Google Guava. In these mature projects, Fray successfully discovered 18 real-world concurrency bugs that can cause 371 of the existing tests to fail under specific interleavings. We believe that Fray serves as a bridge between classical academic research and industrial practice--- empowering developers with advanced concurrency testing algorithms that demonstrably uncover more bugs, while simultaneously providing researchers a platform for large-scale evaluation of search techniques.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3764119", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Ao", + "last_name": "Li", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Byeongjee", + "last_name": "Kang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Vasudev", + "last_name": "Vikram", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Isabella", + "last_name": "Laybourn", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Samvid", + "last_name": "Dharanikota", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Shrey", + "last_name": "Tiwari", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Rohan", + "last_name": "Padhye", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "journals/pacmpl/0009KVLDTP25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3764383", + "title": "Scaling Instruction-Selection Verification against Authoritative ISA Semantics", + "abstract": "Secure, performant execution of untrusted code—as promised by WebAssembly (Wasm)—requires correct compilation to native code that enforces a sandbox. Errors in instruction selection can undermine the sandbox's guarantees, but prior verification work struggles to scale to the complexity of realistic industrial compilers. We present Arrival, an instruction-selection verifier for the Cranelift production Wasm-to-native compiler. Arrival enables end-to-end, high-assurance verification while reducing developer effort. Arrival (1) automatically reasons about chains of instruction-selection rules, thereby reducing the need for developer-supplied intermediate specifications, (2) introduces a lightweight, efficient method for reasoning about stateful instruction-selection rules, and (3) automatically derives high-assurance machine code specifications. Our work verifies nearly all AArch64 instruction-selection rules reachable from Wasm core. Furthermore, Arrival reduces the developer effort required: 60% of all specifications benefit from our automation, thereby requiring 2.6X fewer hand-written specifications than prior approaches. Arrival finds new bugs in Cranelift's instruction selection, and it is viable for integration into production workflows.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3764383", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Michael", + "last_name": "McLoughlin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "A.", + "last_name": "Sheng", + "institution": "Wellesley College" + }, + { + "first_name": "Chris", + "last_name": "Fallin", + "institution": "" + }, + { + "first_name": "Bryan", + "last_name": "Parno", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Fraser", + "last_name": "Brown", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Alexa", + "last_name": "VanHattum", + "institution": "Wellesley College" + } + ], + "dblp_key": "journals/pacmpl/McLoughlinSFPBV25", + "venue": "oopsla", + "year": 2025 + }, + { + "paper_id": "10.1145/3764861", + "title": "Contract System Metatheories à la Carte: A Transition-System View of Contracts", + "abstract": "Over the last 15 years, researchers have studied a wide variety of important aspects of contract systems, ranging from internal consistency (complete monitoring and correct blame) to subtle details about the semantics of contracts combinators (dependency) to the difficulty of efficient checking (avoiding asymptotically bad redundant checking). Although each paper offers essential insights about contract systems, they also differ in inessential ways, making it hard to know how their metatheories combine. Even worse, the metatheories share tremendous tedium in their definitions and proofs, occupying researchers' time with no benefit. In this paper, we present the idea that higher-order contract systems can be viewed as transition systems and show that this perspective offers an important opportunity for reuse in their metatheories. We demonstrate the value of this perspective by proving representative properties from the literature, and by contributing a new proof establishing that elimination of redundant contract checks can eliminate asymptotic slowdowns. To confirm our claims and encourage the adoption of our ideas, we provide a mechanized development in Agda.", + "date": "2025-10-09", + "link": "https://doi.org/10.1145/3764861", + "conference_name": "OOPSLA", + "authors": [ + { + "first_name": "Shu-Hung", + "last_name": "You", + "institution": "Northwestern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "journals/pacmpl/YouDF25", + "venue": "oopsla", + "year": 2025 + } +] \ No newline at end of file From e5a8d2728be6d57025b29e9c080236866299ea54 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:46:24 +0200 Subject: [PATCH 15/34] fix: cap Semantic Scholar retries at 2 attempts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The unauthenticated SS API throttles to a few RPS and 429s repeatedly on bulk lookups, particularly for old Springer LNCS DOIs that have no abstract anywhere anyway. The default 6-attempt exponential backoff burns ~90s per paper before giving up — at 20-30 papers per ESOP/ECOOP year that wedges bulk ingest into many-hours-per-venue territory. OpenAlex (which has the abstract for most modern DOIs) is the primary source; SS is a fallback for the cases OpenAlex misses. If SS also throttles, we cleanly drop the paper rather than burn the budget. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index fc08e92..32e7973 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -814,10 +814,18 @@ def _fetch_semantic_scholar(self, doi: str) -> dict[str, Any] | None: url = f"https://api.semanticscholar.org/graph/v1/paper/DOI:{doi}" params = {"fields": "abstract,authors,year"} + # Cap SS retries tightly: their unauthenticated API throttles to a + # few RPS and pre-2010 Springer LNCS abstracts are mostly missing + # anyway. Burning ~90s of backoff per paper to discover that a + # given DOI is unavailable wedges the bulk run to a crawl. try: with _SEMSCHOLAR_CONCURRENCY: resp = _request_with_retries( - self._thread_session(), url, params=params, timeout=30 + self._thread_session(), + url, + params=params, + timeout=30, + max_attempts=2, ) except requests.RequestException as exc: logger.warning("Semantic Scholar request failed for %s: %s", doi, exc) From a8f74f5962b3f1135c746b737f49b33f6d33553a Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:51:49 +0200 Subject: [PATCH 16/34] feat: ingest ESOP back-catalogue (1986-2025) 19 of 35 indexed years yielded papers with abstracts. Pre-2018 ESOP proceedings were published by Springer LNCS, which exposes neither abstracts to OpenAlex nor reliably to Semantic Scholar; most of the intervening years (1986-2017 except a handful) were ingested as 0-2 papers each. Post-2018 LIPIcs proceedings have full abstracts and yield 20-36 papers per year. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/esop/1992.json | 36 +- data/pl_conferences/esop/1994.json | 20 + data/pl_conferences/esop/1998.json | 30 + data/pl_conferences/esop/1999.json | 25 + data/pl_conferences/esop/2000.json | 20 + data/pl_conferences/esop/2001.json | 35 + data/pl_conferences/esop/2004.json | 20 + data/pl_conferences/esop/2007.json | 58 ++ data/pl_conferences/esop/2013.json | 30 + data/pl_conferences/esop/2016.json | 30 + data/pl_conferences/esop/2017.json | 73 ++ data/pl_conferences/esop/2018.json | 1060 ++++++++++++++++++++++++++++ data/pl_conferences/esop/2019.json | 681 ++++++++++++++++++ data/pl_conferences/esop/2020.json | 833 ++++++++++++++++++++++ data/pl_conferences/esop/2021.json | 664 +++++++++++++++++ data/pl_conferences/esop/2022.json | 705 ++++++++++++++++++ data/pl_conferences/esop/2023.json | 572 +++++++++++++++ data/pl_conferences/esop/2024.json | 832 ++++++++++++++++++++++ data/pl_conferences/esop/2025.json | 953 +++++++++++++++++++++++++ 19 files changed, 6659 insertions(+), 18 deletions(-) create mode 100644 data/pl_conferences/esop/1994.json create mode 100644 data/pl_conferences/esop/1998.json create mode 100644 data/pl_conferences/esop/1999.json create mode 100644 data/pl_conferences/esop/2000.json create mode 100644 data/pl_conferences/esop/2001.json create mode 100644 data/pl_conferences/esop/2004.json create mode 100644 data/pl_conferences/esop/2007.json create mode 100644 data/pl_conferences/esop/2013.json create mode 100644 data/pl_conferences/esop/2016.json create mode 100644 data/pl_conferences/esop/2017.json create mode 100644 data/pl_conferences/esop/2018.json create mode 100644 data/pl_conferences/esop/2019.json create mode 100644 data/pl_conferences/esop/2020.json create mode 100644 data/pl_conferences/esop/2021.json create mode 100644 data/pl_conferences/esop/2022.json create mode 100644 data/pl_conferences/esop/2023.json create mode 100644 data/pl_conferences/esop/2024.json create mode 100644 data/pl_conferences/esop/2025.json diff --git a/data/pl_conferences/esop/1992.json b/data/pl_conferences/esop/1992.json index 42e4fb8..535ef12 100644 --- a/data/pl_conferences/esop/1992.json +++ b/data/pl_conferences/esop/1992.json @@ -1,4 +1,22 @@ [ + { + "paper_id": "10.1007/3-540-55253-7_25", + "title": "A Provably Correct Compiler Generator", + "abstract": "We have designed, implemented, and proved the correctness of a compiler generator that accepts action semantic descriptions of imperative programming languages. The generated compilers emit absolute code for an abstract RISC machine language that currently is assembled into code for the SPARC and the HP Precision Architecture. Our machine language needs no run-time type-checking and is thus more realistic than those considered in previous compiler proofs. We use solely algebraic specifications; proofs are given in the initial model.", + "date": "1992-01-01", + "link": "https://doi.org/10.1007/3-540-55253-7_25", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/esop/Palsberg92", + "venue": "esop", + "year": 1992 + }, { "paper_id": "10.1007/3-540-55253-7_2", "title": "SIGNAL as a Model for Real-Time and Hybrid Systems", @@ -26,23 +44,5 @@ "dblp_key": "conf/esop/BenvenisteBG92", "venue": "esop", "year": 1992 - }, - { - "paper_id": "10.1007/3-540-55253-7_25", - "title": "A Provably Correct Compiler Generator", - "abstract": "We have designed, implemented, and proved the correctness of a compiler generator that accepts action semantic descriptions of imperative programming languages. The generated compilers emit absolute code for an abstract RISC machine language that currently is assembled into code for the SPARC and the HP Precision Architecture. Our machine language needs no run-time type-checking and is thus more realistic than those considered in previous compiler proofs. We use solely algebraic specifications; proofs are given in the initial model.", - "date": "1992-01-01", - "link": "https://doi.org/10.1007/3-540-55253-7_25", - "conference_name": "ESOP", - "authors": [ - { - "first_name": "Jens", - "last_name": "Palsberg", - "institution": "Aarhus University" - } - ], - "dblp_key": "conf/esop/Palsberg92", - "venue": "esop", - "year": 1992 } ] \ No newline at end of file diff --git a/data/pl_conferences/esop/1994.json b/data/pl_conferences/esop/1994.json new file mode 100644 index 0000000..f331b2f --- /dev/null +++ b/data/pl_conferences/esop/1994.json @@ -0,0 +1,20 @@ +[ + { + "paper_id": "10.1007/3-540-57880-3_28", + "title": "The PCKS-Machine: An Abstract Machine for Sound Evaluation of Parallel Functional Programs with First-Class Continuations", + "abstract": "The PCKS-machine is an abstract machine that evaluates parallel functional programs with first-class continuations. Parallelism is introduced by the construct pcall, which provides a fork-and-join type of parallelism. To the best of our knowledge, the PCKS-machine is the first implementation of such a language that is proved to have a transparent construct for parallelism: every program using such a construct returns the same result as in the absence of this construct. This machine is also characterised by the non-speculative invocation of continuations whose interest is illustrated in an application.", + "date": "1994-01-01", + "link": "https://doi.org/10.1007/3-540-57880-3_28", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Luc", + "last_name": "Moreau", + "institution": "University of Liège" + } + ], + "dblp_key": "conf/esop/Moreau94", + "venue": "esop", + "year": 1994 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/1998.json b/data/pl_conferences/esop/1998.json new file mode 100644 index 0000000..b1e73d3 --- /dev/null +++ b/data/pl_conferences/esop/1998.json @@ -0,0 +1,30 @@ +[ + { + "paper_id": "10.1007/BFb0053561", + "title": "A Polyvariant Binding-Time Analysis for Off-line Partial Deduction", + "abstract": "We study the notion of binding-time analysis for logic programs. We formalise the unfolding aspect of an on-line partial deduction system as a Prolog program. Using abstract interpretation, we collect information about the run-time behaviour of the program. We use this information to make the control decisions about the unfolding at analysis time and to turn the on-line system into an off-line system. We report on some initial experiments.", + "date": "1998-01-01", + "link": "https://doi.org/10.1007/BFb0053561", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Maurice", + "last_name": "Bruynooghe", + "institution": "KU Leuven" + }, + { + "first_name": "Michaël", + "last_name": "Leuschel", + "institution": "KU Leuven" + }, + { + "first_name": "Konstantinos", + "last_name": "Sagonas", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/esop/BruynoogheLS98", + "venue": "esop", + "year": 1998 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/1999.json b/data/pl_conferences/esop/1999.json new file mode 100644 index 0000000..19b9692 --- /dev/null +++ b/data/pl_conferences/esop/1999.json @@ -0,0 +1,25 @@ +[ + { + "paper_id": "10.1007/3-540-49099-X_15", + "title": "An Operational Investigation of the CPS Hierarchy", + "abstract": "We explore the hierarchy of control induced by successive transformations into continuation-passing style (CPS) in the presence of \"control delimiters\" and \"composable continuations\". Specifically, we investigate the structural operational semantics associated with the CPS hierarchy. \n \nTo this end, we characterize an operational notion of continuation semantics. We relate it to the traditional CPS transformation and we use it to account for the control operator shift and the control delimiter reset operationally. We then transcribe the resulting continuation semantics in ML, thus obtaining a native and modular implementation of the entire hierarchy. We illustrate it with several examples, the most significant of which is layered monads.", + "date": "1999-01-01", + "link": "https://doi.org/10.1007/3-540-49099-X_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Danish National Research Foundation" + }, + { + "first_name": "Zhe", + "last_name": "Yang", + "institution": "Mercer University" + } + ], + "dblp_key": "conf/esop/DanvyY99", + "venue": "esop", + "year": 1999 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2000.json b/data/pl_conferences/esop/2000.json new file mode 100644 index 0000000..80ffbf2 --- /dev/null +++ b/data/pl_conferences/esop/2000.json @@ -0,0 +1,20 @@ +[ + { + "paper_id": "10.1007/3-540-46425-5_6", + "title": "Formalizing Implementation Strategies for First-Class Continuations", + "abstract": "We present the first formalization of implementation strategies for first-class continuations. The formalization hinges on abstract machines for continuation-passing style (CPS) programs with a special treatment for the current continuation, accounting for the essence of first-class continuations. These abstract machines are proven equivalent to a standard, substitution-based abstract machine. The proof techniques work uniformly for various representations of continuations. As a byproduct, we also present a formal proof of the two folklore theorems that one continuation identifier is enough for second-class continuations and that second-class continuations are stackable. \n \nA large body of work exists on implementing continuations, but it is predominantly empirical and implementation-oriented. In contrast, our formalization abstracts the essence of first-class continuations and provides a uniform setting for specifying and formalizing their representation.", + "date": "2000-01-01", + "link": "https://doi.org/10.1007/3-540-46425-5_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Danvy", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/esop/Danvy00", + "venue": "esop", + "year": 2000 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2001.json b/data/pl_conferences/esop/2001.json new file mode 100644 index 0000000..05e2cb6 --- /dev/null +++ b/data/pl_conferences/esop/2001.json @@ -0,0 +1,35 @@ +[ + { + "paper_id": "10.1007/3-540-45309-1_27", + "title": "Semantics and Termination of Simply-Moded Logic Programs with Dynamic Scheduling", + "abstract": "In logic programming, dynamic scheduling refers to a situation where the selection of the atom in each resolution (computation) step is determined at runtime, as opposed to a fixed selection rule such as the left-to-right one of Prolog. This has applications e.g. in parallel programming. A mechanism to control dynamic scheduling is provided in existing languages in the form of delay declarations. \n \nInput-consuming derivations were introduced to describe dynamic scheduling while abstracting from the technical details. In this paper, we first formalise the relationship between delay declarations and input-consuming derivations, showing in many cases a one-to-one correspondence. Then, we define a model-theoretic semantics for input-consuming derivations of simply-moded programs. Finally, for this class of programs, we provide a necessary and sufficient criterion for termination.", + "date": "2001-01-01", + "link": "https://doi.org/10.1007/3-540-45309-1_27", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Annalisa", + "last_name": "Bossi", + "institution": "Università Iuav di Venezia" + }, + { + "first_name": "Sandro", + "last_name": "Etalle", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Sabina", + "last_name": "Rossi", + "institution": "Università Iuav di Venezia" + }, + { + "first_name": "Jan‐Georg", + "last_name": "Smaus", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/esop/BossiERS01", + "venue": "esop", + "year": 2001 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2004.json b/data/pl_conferences/esop/2004.json new file mode 100644 index 0000000..795841e --- /dev/null +++ b/data/pl_conferences/esop/2004.json @@ -0,0 +1,20 @@ +[ + { + "paper_id": "10.1007/978-3-540-24725-8_2", + "title": "Relational Abstract Domains for the Detection of Floating-Point Run-Time Errors", + "abstract": "We present a new idea to adapt relational abstract domains to the analysis of IEEE 754-compliant floating-point numbers in order to statically detect, through Abstract Interpretation-based static analyses, potential floating-point run-time exceptions such as overflows or invalid operations. In order to take the non-linearity of rounding into account, expressions are modeled as linear forms with interval coefficients. We show how to extend already existing numerical abstract domains, such as the octagon abstract domain, to efficiently abstract transfer functions based on interval linear forms. We discuss specific fixpoint stabilization techniques and give some experimental results.", + "date": "2004-01-01", + "link": "https://doi.org/10.1007/978-3-540-24725-8_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Antoine", + "last_name": "Miné", + "institution": "École Normale Supérieure" + } + ], + "dblp_key": "conf/esop/Mine04", + "venue": "esop", + "year": 2004 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2007.json b/data/pl_conferences/esop/2007.json new file mode 100644 index 0000000..b2f6ad6 --- /dev/null +++ b/data/pl_conferences/esop/2007.json @@ -0,0 +1,58 @@ +[ + { + "paper_id": "10.1007/978-3-540-71316-6_5", + "title": "A Concurrent Calculus with Atomic Transactions", + "abstract": "The Software Transactional Memory (STM) model is an original approach for controlling concurrent accesses to resources without the need for explicit lock-based synchronization mechanisms. A key feature of STMis to provide a way to group sequences of read and write actions inside atomic blocks, similar to database transactions, whose whole effect should occur atomically. \n \nIn this paper, we investigate STM from a process algebra perspective and define an extension of asynchronous CCS with atomic blocks of actions. We show that the addition of atomic transactions results in a very expressive calculus, enough to easily encode other concurrent primitives such as guarded choice and multiset-synchronization (a la join-calculus). The correctness of our encodings is proved using a suitable notion of bisimulation equivalence. The equivalence is then applied to prove interesting \"laws of transactions\" and to obtain a simple normal form for transactions.", + "date": "2007-01-01", + "link": "https://doi.org/10.1007/978-3-540-71316-6_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Lucia", + "last_name": "Acciai", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Michele", + "last_name": "Boreale", + "institution": "University of Florence" + }, + { + "first_name": "Silvano Dal", + "last_name": "Zilio", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/AcciaiBD07", + "venue": "esop", + "year": 2007 + }, + { + "paper_id": "10.1007/978-3-540-71316-6_8", + "title": "On the Implementation of Construction Functions for Non-free Concrete Data Types", + "abstract": "Many algorithms use concrete data types with some additional invariants. The set of values satisfying the invariants is often a set of representatives for the equivalence classes of some equational theory. For instance, a sorted list is a particular representative wrt commutativity. Theories like associativity, neutral element, idempotence, etc. are also very common. Now, when one wants to combine various invariants, it may be difficult to find the suitable representatives and to efficiently implement the invariants. The preservation of invariants throughout the whole program is even more difficult and error prone. Classically, the programmer solves this problem using a combination of two techniques: the definition of appropriate construction functions for the representatives and the consistent usage of these functions ensured via compiler verifications. The common way of ensuring consistency is to use an abstract data type for the representatives; unfortunately, pattern matching on representatives is lost. A more appealing alternative is to define a concrete data type with private constructors so that both compiler verification and pattern matching on representatives are granted. In this paper, we detail the notion of private data type and study the existence of construction functions. We also describe a prototype, called Moca, that addresses the entire problem of defining concrete data types with invariants: it generates efficient construction functions for the combination of common invariants and builds representatives that belong to a concrete data type with private constructors.", + "date": "2007-01-01", + "link": "https://doi.org/10.1007/978-3-540-71316-6_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Frédéric", + "last_name": "Blanqui", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Thérèse", + "last_name": "Hardin", + "institution": "Sorbonne Université" + }, + { + "first_name": "Pierre", + "last_name": "Weis", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/BlanquiHW07", + "venue": "esop", + "year": 2007 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2013.json b/data/pl_conferences/esop/2013.json new file mode 100644 index 0000000..f090d76 --- /dev/null +++ b/data/pl_conferences/esop/2013.json @@ -0,0 +1,30 @@ +[ + { + "paper_id": "10.1007/978-3-642-37036-6_1", + "title": "Distributed Electronic Rights in JavaScript", + "abstract": "Contracts enable mutually suspicious parties to cooperate safely through the exchange of rights. Smart contracts are programs whose behavior enforces the terms of the contract. This paper shows how such contracts can be specified elegantly and executed safely, given an appropriate distributed, secure, persistent, and ubiquitous computational fabric. JavaScript provides the ubiquity but must be significantly extended to deal with the other aspects. The first part of this paper is a progress report on our efforts to turn JavaScript into this fabric. To demonstrate the suitability of this design, we describe an escrow exchange contract implemented in 42 lines of JavaScript code.", + "date": "2013-01-01", + "link": "https://doi.org/10.1007/978-3-642-37036-6_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Mark S.", + "last_name": "Miller", + "institution": "Google (United States)" + }, + { + "first_name": "Tom Van", + "last_name": "Cutsem", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Bill", + "last_name": "Tulloh", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/esop/MillerCT13", + "venue": "esop", + "year": 2013 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2016.json b/data/pl_conferences/esop/2016.json new file mode 100644 index 0000000..bfa6a4c --- /dev/null +++ b/data/pl_conferences/esop/2016.json @@ -0,0 +1,30 @@ +[ + { + "paper_id": "10.1007/978-3-662-49498-1_5", + "title": "A Timed Process Algebra for Wireless Networks with an Application in Routing - (Extended Abstract)", + "abstract": "This paper proposes a timed process algebra for wireless networks, an extension of the Algebra for Wireless Networks. It combines treatments of local broadcast, conditional unicast and data structures, which are essential features for the modelling of network protocols. In this framework we model and analyse the Ad hoc On-Demand Distance Vector routing protocol, and show that, contrary to claims in the literature, it fails to be loop free. We also present boundary conditions for a fix ensuring that the resulting protocol is indeed loop free.", + "date": "2016-06-12", + "link": "https://doi.org/10.1007/978-3-662-49498-1_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Emile", + "last_name": "Bres", + "institution": "Data61" + }, + { + "first_name": "Rob van", + "last_name": "Glabbeek", + "institution": "Data61" + }, + { + "first_name": "H\\\"ofner,", + "last_name": "Peter", + "institution": "Data61" + } + ], + "dblp_key": "conf/esop/BresGH16", + "venue": "esop", + "year": 2016 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2017.json b/data/pl_conferences/esop/2017.json new file mode 100644 index 0000000..e4cf7a1 --- /dev/null +++ b/data/pl_conferences/esop/2017.json @@ -0,0 +1,73 @@ +[ + { + "paper_id": "10.1007/978-3-662-54434-1_8", + "title": "Incremental Update for Graph Rewriting", + "abstract": "International audience", + "date": "2017-04-22", + "link": "https://doi.org/10.1007/978-3-662-54434-1_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ehrhard", + "institution": "Harvard University" + }, + { + "first_name": "Pierre", + "last_name": "Boutillier", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jean", + "last_name": "Krivine", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/BoutillierEK17", + "venue": "esop", + "year": 2017 + }, + { + "paper_id": "10.1007/978-3-662-54434-1_26", + "title": "The Essence of Higher-Order Concurrent Separation Logic", + "abstract": "Concurrent separation logics (CSLs) have come of age, and with age they have accumulated a great deal of complexity. Previous work on the Iris logic attempted to reduce the complex logical mechanisms of modern CSLs to two orthogonal concepts: partial commutative monoids (PCMs) and invariants. However, the realization of these concepts in Iris still bakes in several complex mechanisms—such as weakest preconditions and mask-changing view shifts—as primitive notions. In this paper, we take the Iris story to its (so to speak) logical conclusion, applying the reductionist methodology of Iris to Iris itself. Specifically, we define a small, resourceful base logic, which distills the essence of Iris: it comprises only the assertion layer of vanilla separation logic, plus a handful of simple modalities. We then show how the much fancier logical mechanisms of Iris—in particular, its entire program specification layer—can be understood as merely derived forms in our base logic. This approach helps to explain the meaning of Iris’s program specifications at a much higher level of abstraction than was previously possible. We also show that the step-indexed “later” modality of Iris is an essential source of complexity, in that removing it leads to a logical inconsistency. All our results are fully formalized in the Coq proof assistant.", + "date": "2017-01-01", + "link": "https://doi.org/10.1007/978-3-662-54434-1_26", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + }, + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Aleš", + "last_name": "Bizjak", + "institution": "Aarhus University" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Max Planck Institute for Informatics" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/esop/Krebbers0BJDB17", + "venue": "esop", + "year": 2017 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2018.json b/data/pl_conferences/esop/2018.json new file mode 100644 index 0000000..9ceffdf --- /dev/null +++ b/data/pl_conferences/esop/2018.json @@ -0,0 +1,1060 @@ +[ + { + "paper_id": "10.1007/978-3-319-89884-1_1", + "title": "Consistent Subtyping for All", + "abstract": "Consistent subtyping is employed in some gradual type systems to validate type conversions. The original definition by Siek and Taha serves as a guideline for designing gradual type systems with subtyping. Polymorphic types à la System F also induce a subtyping relation that relates polymorphic types to their instantiations. However Siek and Taha’s definition is not adequate for polymorphic subtyping. The first goal of this paper is to propose a generalization of consistent subtyping that is adequate for polymorphic subtyping, and subsumes the original definition by Siek and Taha. The new definition of consistent subtyping provides novel insights with respect to previous polymorphic gradual type systems, which did not employ consistent subtyping. The second goal of this paper is to present a gradually typed calculus for implicit (higher-rank) polymorphism that uses our new notion of consistent subtyping. We develop both declarative and (bidirectional) algorithmic versions for the type system. We prove that the new calculus satisfies all static aspects of the refined criteria for gradual typing, which are mechanically formalized using the Coq proof assistant.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" + }, + { + "first_name": "Xuan", + "last_name": "Bi", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/esop/XieBO18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_4", + "title": "Deterministic Concurrency: A Clock-Synchronised Shared Memory Approach", + "abstract": "Concurrency and determinacy do not go well with each other when resources must be shared. Haskell provides parallel programming abstractions such as IVar and LVar in the Par monad and concurrent abstractions such as MVar and TVar in the in IO and STM monads, respectively. The former are determinate but have no destructive updates and the latter have destructive updates but do not guarantee determinacy. Programming patterns that are both concurrent and determinate, such as those provided by Kahn or Berry require memory abstractions at a higher level than is currently available. In this paper we describe a new type context PSM for policy synchronised memory in Haskell. Like STM and IO, the computations in PSM can access persistent state and, as a side-effect, update the memory in imperative style. Like the Par and IO monads, PSM supports concurrent threads and shared state. However, in contrast to IO, our PSM contexts are race-free since concurrent accesses are policy coordinated which guarantees determinacy.Well-typed transactions in the PSM context can accommodate abstract data structures that are imperative, concurrently shareable and still behave deterministically, by construction.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Joaquín", + "last_name": "Aguado", + "institution": "University of Bamberg" + }, + { + "first_name": "Michael", + "last_name": "Mendler", + "institution": "University of Bamberg" + }, + { + "first_name": "Marc", + "last_name": "Pouzet", + "institution": "Laboratoire de Géologie de l’École Normale Supérieure" + }, + { + "first_name": "Partha S.", + "last_name": "Roop", + "institution": "University of Auckland" + }, + { + "first_name": "Reinhard von", + "last_name": "Hanxleden", + "institution": "Kiel University" + } + ], + "dblp_key": "conf/esop/AguadoMPRH18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_14", + "title": "Logical Reasoning for Disjoint Permissions", + "abstract": "Resource sharing is a fundamental phenomenon in concurrent programming where several threads have permissions to access a common resource. Logics for verification need to capture the notion of permission ownership and transfer. One typical practice is the use of rational numbers in (0, 1] as permissions in which 1 is the full permission and the rest are fractional permissions. Rational permissions are not a good fit for separation logic because they remove the essential “disjointness” feature of the logic itself. We propose a general logic framework that supports permission reasoning in separation logic while preserving disjointness. Our framework is applicable to sophisticated verification tasks such as doing induction over the finiteness of the heap within the object logic or carrying out biabductive inference. We can also prove precision of recursive predicates within the object logic. We developed the ShareInfer tool to benchmark our techniques. We introduce “scaling separation algebras,” a compositional extension of separation algebras, to model our logic, and use them to construct a concrete model.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Xuan-Bach", + "last_name": "Le", + "institution": "National University of Singapore" + }, + { + "first_name": "Aquinas", + "last_name": "Hobor", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/esop/LeH18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_16", + "title": "Fragment Abstraction for Concurrent Shape Analysis", + "abstract": "A major challenge in automated verification is to develop techniques that are able to reason about fine-grained concurrent algorithms that consist of an unbounded number of concurrent threads, which operate on an unbounded domain of data values, and use unbounded dynamically allocated memory. Existing automated techniques consider the case where shared data is organized into singly-linked lists. We present a novel shape analysis for automated verification of fine-grained concurrent algorithms that can handle heap structures which are more complex than just singly-linked lists, in particular skip lists and arrays of singly linked lists, while at the same time handling an unbounded number of concurrent threads, an unbounded domain of data values (including timestamps), and an unbounded shared heap. Our technique is based on a novel shape abstraction, which represents a set of heaps by a set of fragments. A fragment is an abstraction of a pair of heap cells that are connected by a pointer field. We have implemented our approach and applied it to automatically verify correctness, in the sense of linearizability, of most linearizable concurrent implementations of sets, stacks, and queues, which employ singly-linked lists, skip lists, or arrays of singly-linked lists with timestamps, which are known to us in the literature.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Bengt", + "last_name": "Jönsson", + "institution": "Uppsala University" + }, + { + "first_name": "Cong Quy", + "last_name": "Trinh", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/esop/AbdullaJT18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_2", + "title": "HOBiT: Programming Lenses Without Using Lens Combinators", + "abstract": "We propose HOBiT, a higher-order bidirectional programming language, in which users can write bidirectional programs in the familiar style of conventional functional programming, while enjoying the full expressiveness of lenses. A bidirectional transformation, or a lens, is a pair of mappings between source and view data objects, one in each direction. When the view is modified, the source is updated accordingly with respect to some laws—a pattern that is found in databases, model-driven development, compiler construction, and so on. The most common way of programming lenses is with lens combinators, which are lens-to-lens functions that compose simpler lenses to form more complex ones. Lens combinators preserve the bidirectionality of lenses and are expressive; but they compel programmers to a specialised point-free style—i.e., no naming of intermediate computation results—limiting the scalability of bidirectional programming. To address this issue, we propose a new bidirectional programming language HOBiT, in which lenses are represented as standard functions, and combinators are mapped to language constructs with binders. This design transforms bidirectional programming, enabling programmers to write bidirectional programs in a flexible functional style and at the same time access the full expressiveness of lenses. We formally define the syntax, type system, and the semantics of the language, and then show that programs in HOBiT satisfy bidirectionality. Additionally, we demonstrate HOBiT ’s programmability with examples.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + } + ], + "dblp_key": "conf/esop/Matsuda018", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_5", + "title": "An Assertion-Based Program Logic for Probabilistic Programs", + "abstract": "We present Ellora, a sound and relatively complete assertion-based program logic, and demonstrate its expressivity by verifying several classical examples of randomized algorithms using an implementation in the EasyCrypt proof assistant. Ellora features new proof rules for loops and adversarial code, and supports richer assertions than existing program logics. We also show that Ellora allows convenient reasoning about complex probabilistic concepts by developing a new program logic for probabilistic independence and distribution law, and then smoothly embedding it into Ellora.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Thomas", + "last_name": "Espitau", + "institution": "Sorbonne Université" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Centre Inria d'Université Côte d'Azur" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University College London" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "École Polytechnique" + } + ], + "dblp_key": "conf/esop/BartheEGGHS18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_7", + "title": "How long, O Bayesian network, will I sample thee? - A program analysis perspective on expected sampling times", + "abstract": "Bayesian networks (BNs) are probabilistic graphical models for describing complex joint probability distributions. The main problem for BNs is inference: Determine the probability of an event given observed evidence. Since exact inference is often infeasible for large BNs, popular approximate inference methods rely on sampling. We study the problem of determining the expected time to obtain a single valid sample from a BN. To this end, we translate the BN together with observations into a probabilistic program. We provide proof rules that yield the exact expected runtime of this program in a fully automated fashion. We implemented our approach and successfully analyzed various real–world BNs taken from the Bayesian network repository.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "conf/esop/BatzKKM18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_15", + "title": "Deadlock-Free Monitors", + "abstract": "Monitors constitute one of the common techniques to synchronize threads in multithreaded programs, where calling a $$\\mathsf {wait}$$ command on a condition variable suspends the caller thread and notifying a condition variable causes the threads waiting for that condition variable to resume their execution. One potential problem with these programs is that a waiting thread might be suspended forever leading to deadlock, a state where each thread of the program is waiting for a condition variable or a lock. In this paper, a modular verification approach for deadlock-freedom of such programs is presented, ensuring that in any state of the execution of the program if there are some threads suspended then there exists at least one thread running. The main idea behind this approach is to make sure that for any condition variable v for which a thread is waiting there exists a thread obliged to fulfil an obligation for v that only waits for a waitable object whose wait level, an arbitrary number associated with each waitable object, is less than the wait level of v. The relaxed precedence relation introduced in this paper, aiming to avoid cycles, can also benefit some other verification approaches, verifying deadlock-freedom of other synchronization constructs such as channels and semaphores, enabling them to accept a wider range of deadlock-free programs. We encoded the proposed proof rules in the VeriFast program verifier and by defining some appropriate invariants for the locks associated with some condition variables succeeded in verifying some popular use cases of monitors including unbounded/bounded buffer, sleeping barber, barrier, and readers-writers locks. A soundness proof for the presented approach is provided; some of the trickiest lemmas in this proof have been machine-checked with Coq.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jafar", + "last_name": "Hamin", + "institution": "KU Leuven" + }, + { + "first_name": "Bart", + "last_name": "Jacobs", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/esop/Hamin018", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_8", + "title": "Relational Reasoning for Markov Chains in a Probabilistic Guarded Lambda Calculus", + "abstract": "We extend the simply-typed guarded $$\\lambda $$ -calculus with discrete probabilities and endow it with a program logic for reasoning about relational properties of guarded probabilistic computations. This provides a framework for programming and reasoning about infinite stochastic processes like Markov chains. We demonstrate the logic sound by interpreting its judgements in the topos of trees and by using probabilistic couplings for the semantics of relational assertions over distributions on discrete types. The program logic is designed to support syntax-directed proofs in the style of relational refinement types, but retains the expressiveness of higher-order logic extended with discrete distributions, and the ability to reason relationally about expressions that have different types or syntactic structure. In addition, our proof system leverages a well-known theorem from the coupling literature to justify better proof rules for relational reasoning about probabilistic expressions. We illustrate these benefits with a broad range of examples that were beyond the scope of previous systems, including shift couplings and lump couplings between random walks.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Alejandro", + "last_name": "Aguirre", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + }, + { + "first_name": "Aleš", + "last_name": "Bizjak", + "institution": "Aarhus University" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/esop/0001BBBG018", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_13", + "title": "A Separation Logic for a Promising Semantics", + "abstract": "We present SLR, the first expressive program logic for reasoning about concurrent programs under a weak memory model addressing the out-of-thin-air problem. Our logic includes the standard features from existing logics, such as RSL and GPS, that were previously known to be sound only under stronger memory models: (1) separation, (2) per-location invariants, and (3) ownership transfer via release-acquire synchronisation—as well as novel features for reasoning about (4) the absence of out-of-thin-air behaviours and (5) coherence. The logic is proved sound over the recent “promising” memory model of Kang et al., using a substantially different argument to soundness proofs of logics for simpler memory models.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Kasper", + "last_name": "Svendsen", + "institution": "University of Cambridge" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "University of Cambridge" + }, + { + "first_name": "Marko", + "last_name": "Doko", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/esop/SvendsenPDLV18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_9", + "title": "Failure is Not an Option - An Exceptional Type Theory", + "abstract": "We define the exceptional translation, a syntactic translation of the Calculus of Inductive Constructions (CIC) into itself, that covers full dependent elimination. The new resulting type theory features call-by-name exceptions with decidable type-checking and canonicity, but at the price of inconsistency. Then, noticing parametricity amounts to Kreisel’s realizability in this setting, we provide an additional layer on top of the exceptional translation in order to tame exceptions and ensure that all exceptions used locally are caught, leading to the parametric exceptional translation which fully preserves consistency. This way, we can consistently extend the logical expressivity of CIC with independence of premises, Markov’s rule, and the negation of function extensionality while retaining $$\\eta $$ -expansion. As a byproduct, we also show that Markov’s principle is not provable in CIC. Both translations have been implemented in a Coq plugin, which we use to formalize the examples.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Pierre-Marie", + "last_name": "Pédrot", + "institution": "Max Planck Society" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/PedrotT18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_11", + "title": "Behavioural Equivalence via Modalities for Algebraic Effects", + "abstract": "The paper investigates behavioural equivalence between programs in a call-by-value functional language extended with a signature of (algebraic) effect-triggering operations. Two programs are considered as being behaviourally equivalent if they enjoy the same behavioural properties. To formulate this, we define a logic whose formulas specify behavioural properties. A crucial ingredient is a collection of modalities expressing effect-specific aspects of behaviour. We give a general theory of such modalities. If two conditions, openness and decomposability, are satisfied by the modalities then the logically specified behavioural equivalence coincides with a modality-defined notion of applicative bisimilarity, which can be proven to be a congruence by a generalisation of Howe’s method. We show that the openness and decomposability conditions hold for several examples of algebraic effects: nondeterminism, probabilistic choice, global store and input/output.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Alex", + "last_name": "Simpson", + "institution": "University of Ljubljana" + }, + { + "first_name": "Niels", + "last_name": "Voorneveld", + "institution": "University of Ljubljana" + } + ], + "dblp_key": "conf/esop/SimpsonV18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_10", + "title": "Let Arguments Go First", + "abstract": "Bi-directional type checking has proved to be an extremely useful and versatile tool for type checking and type inference. The conventional presentation of bi-directional type checking consists of two modes: inference mode and checked mode. In traditional bi-directional type-checking, type annotations are used to guide (via the checked mode) the type inference/checking procedure to determine the type of an expression, and type information flows from functions to arguments. This paper presents a variant of bi-directional type checking where the type information flows from arguments to functions. This variant retains the inference mode, but adds a so-called application mode. Such design can remove annotations that basic bi-directional type checking cannot, and is useful when type information from arguments is required to type-check the functions being applied. We present two applications and develop the meta-theory (mostly verified in Coq) of the application mode.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/esop/XieO18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_6", + "title": "Fine-Grained Semantics for Probabilistic Programs", + "abstract": "Probabilistic programming is an emerging technique for modeling processes involving uncertainty. Thus, it is important to ensure these programs are assigned precise formal semantics that also cleanly handle typical exceptions such as non-termination or division by zero. However, existing semantics of probabilistic programs do not fully accommodate different exceptions and their interaction, often ignoring some or conflating multiple ones into a single exception state, making it impossible to distinguish exceptions or to study their interaction. In this paper, we provide an expressive probabilistic programming language together with a fine-grained measure-theoretic denotational semantics that handles and distinguishes non-termination, observation failures and error states. We then investigate the properties of this semantics, focusing on the interaction of different kinds of exceptions. Our work helps to better understand the intricacies of probabilistic programs and ensures their behavior matches the intended semantics.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Bichsel", + "institution": "ETH Zurich" + }, + { + "first_name": "Timon", + "last_name": "Gehr", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/esop/BichselGV18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_3", + "title": "Dualizing Generalized Algebraic Data Types by Matrix Transposition", + "abstract": "We characterize the relation between generalized algebraic datatypes (GADTs) with pattern matching on their constructors one hand, and generalized algebraic co-datatypes (GAcoDTs) with copattern matching on their destructors on the other hand: GADTs can be converted mechanically to GAcoDTs by refunctionalization, GAcoDTs can be converted mechanically to GADTs by defunctionalization, and both defunctionalization and refunctionalization correspond to a transposition of the matrix in which the equations for each constructor/destructor pair of the (co-)datatype are organized. We have defined a calculus, $$GADT^T$$ , which unifies GADTs and GAcoDTs in such a way that GADTs and GAcoDTs are merely different ways to partition the program. We have formalized the type system and operational semantics of $$GADT^T$$ in the Coq proof assistant and have mechanically verified the following results: (1) The type system of $$GADT^T$$ is sound, (2) defunctionalization and refunctionalization can translate GADTs to GAcoDTs and back, (3) both transformations are type- and semantics-preserving and are inverses of each other, (4) (co-)datatypes can be represented by matrices in such a way the aforementioned transformations correspond to matrix transposition, (5) GADTs are extensible in an exactly dual way to GAcoDTs; we thereby clarify folklore knowledge about the “expression problem”. We believe that the identification of this relationship can guide future language design of “dual features” for data and codata.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + }, + { + "first_name": "Julian", + "last_name": "Jabs", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/esop/OstermannJ18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_12", + "title": "Explicit Effect Subtyping", + "abstract": "As popularity of algebraic effects and handlers increases, so does a demand for their efficient execution. Eff, an ML-like language with native support for handlers, has a subtyping-based effect system on which an effect-aware optimizing compiler could be built. Unfortunately, in our experience, implementing optimizations for Eff is overly error-prone because its core language is implicitly-typed, making code transformations very fragile.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Amr Hany", + "last_name": "Saleh", + "institution": "KU Leuven" + }, + { + "first_name": "Georgios", + "last_name": "Karachalias", + "institution": "KU Leuven" + }, + { + "first_name": "Matija", + "last_name": "Pretnar", + "institution": "University of Ljubljana" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/esop/SalehKPS18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_17", + "title": "Reasoning About a Machine with Local Capabilities - Provably Safe Stack and Return Pointer Management", + "abstract": "Capability machines provide security guarantees at machine level which makes them an interesting target for secure compilation schemes that provably enforce properties such as control-flow correctness and encapsulation of local state. We provide a formalization of a representative capability machine with local capabilities and study a novel calling convention. We provide a logical relation that semantically captures the guarantees provided by the hardware (a form of capability safety) and use it to prove control-flow correctness and encapsulation of local state. The logical relation is not specific to our calling convention and can be used to reason about arbitrary programs.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_17", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Lau", + "last_name": "Skorstengaard", + "institution": "Aarhus University" + }, + { + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/esop/SkorstengaardDB18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_21", + "title": "Program Verification by Coinduction", + "abstract": "We present a novel program verification approach based on coinduction, which takes as input an operational semantics. No intermediates like program logics or verification condition generators are needed. Specifications can be written using any state predicates. We implement our approach in Coq, giving a certifying language-independent verification framework. Our proof system is implemented as a single module imported unchanged into language-specific proofs. Automation is reached by instantiating a generic heuristic with language-specific tactics. Manual assistance is also smoothly allowed at points the automation cannot handle. We demonstrate the power and versatility of our approach by verifying algorithms as complicated as Schorr-Waite graph marking and instantiating our framework for object languages in several styles of semantics. Finally, we show that our coinductive approach subsumes reachability logic, a recent language-independent sound and (relatively) complete logic for program verification that has been instantiated with operational semantics of languages as complex as C, Java and JavaScript.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_21", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Brandon", + "last_name": "Moore", + "institution": "Runtime Verification (United States)" + }, + { + "first_name": "Lucas", + "last_name": "Peña", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Grigore", + "last_name": "Roşu", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/esop/MoorePR18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_18", + "title": "Modular Product Programs", + "abstract": "Many interesting program properties like determinism or information flow security are hyperproperties, that is, they relate multiple executions of the same program. Hyperproperties can be verified using relational logics, but these logics require dedicated tool support and are difficult to automate. Alternatively, constructions such as self-composition represent multiple executions of a program by one product program, thereby reducing hyperproperties of the original program to trace properties of the product. However, existing constructions do not fully support procedure specifications, for instance, to derive the determinism of a caller from the determinism of a callee, making verification non-modular. We present modular product programs, a novel kind of product program that permits hyperproperties in procedure specifications and, thus, can reason about calls modularly. We demonstrate its expressiveness by applying it to information flow security with advanced features such as declassification and termination-sensitivity. Modular product programs can be verified using off-the-shelf verifiers; we have implemented our approach to secure information flow using the Viper verification infrastructure.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_18", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Marco", + "last_name": "Eilers", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + }, + { + "first_name": "Samuel", + "last_name": "Hitz", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/esop/EilersMH18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_20", + "title": "Verified Learning Without Regret - From Algorithmic Game Theory to Distributed Systems with Mechanized Complexity Guarantees", + "abstract": "Multiplicative Weights (MW) is a simple yet powerful algorithm for learning linear classifiers, for ensemble learning à la boosting, for approximately solving linear and semidefinite systems, for computing approximate solutions to multicommodity flow problems, and for online convex optimization, among other applications. Recent work in algorithmic game theory, which applies a computational perspective to the design and analysis of systems with mutually competitive actors, has shown that no-regret algorithms like MW naturally drive games toward approximate Coarse Correlated Equilibria (CCEs), and that for certain games, approximate CCEs have bounded cost with respect to the optimal states of such systems. In this paper, we put such results to practice by building distributed systems such as routers and load balancers with performance and convergence guarantees mechanically verified in Coq. The main contributions on which our results rest are (1) the first mechanically verified implementation of Multiplicative Weights (specifically, we show that our MW is no regret) and (2) a language-based formulation, in the form of a DSL, of the class of games satisfying Roughgarden smoothness, a broad characterization of those games whose approximate CCEs have cost bounded with respect to optimal. Composing (1) with (2) within Coq yields a new strategy for building distributed systems with mechanically verified complexity guarantees on the time to convergence to near-optimal system configurations.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_20", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Samuel", + "last_name": "Merten", + "institution": "Ohio University" + }, + { + "first_name": "Alexander", + "last_name": "Bagnall", + "institution": "Ohio University" + }, + { + "first_name": "Gordon", + "last_name": "Stewart", + "institution": "Ohio University" + } + ], + "dblp_key": "conf/esop/MertenBS18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_19", + "title": "A Fistful of Dollars: Formalizing Asymptotic Complexity Claims via Deductive Program Verification", + "abstract": "We present a framework for simultaneously verifying the functional correctness and the worst-case asymptotic time complexity of higher-order imperative programs. We build on top of Separation Logic with Time Credits, embedded in an interactive proof assistant. We formalize the O notation, which is key to enabling modular specifications and proofs. We cover the subtleties of the multivariate case, where the complexity of a program fragment depends on multiple parameters. We propose a way of integrating complexity bounds into specifications, present lemmas and tactics that support a natural reasoning style, and illustrate their use with a collection of examples.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_19", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Armaël", + "last_name": "Guéneau", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Arthur", + "last_name": "Charguéraud", + "institution": "Université de Strasbourg" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/esop/GueneauCP18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_30", + "title": "Concurrent Kleene Algebra: Free Model and Completeness", + "abstract": "Concurrent Kleene Algebra (CKA) was introduced by Hoare, Moeller, Struth and Wehrman in 2009 as a framework to reason about concurrent programs. We prove that the axioms for CKA with bounded parallelism are complete for the semantics proposed in the original paper; consequently, these semantics are the free model for this fragment. This result settles a conjecture of Hoare and collaborators. Moreover, the technique developed to this end allows us to establish a Kleene Theorem for CKA, extending an earlier Kleene Theorem for a fragment of CKA.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_30", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "University College London" + }, + { + "first_name": "Paul", + "last_name": "Brunet", + "institution": "University College London" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "University College London" + }, + { + "first_name": "Fabio", + "last_name": "Zanasi", + "institution": "University College London" + } + ], + "dblp_key": "conf/esop/KappeB0Z18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_24", + "title": "An Abstract Interpretation Framework for Input Data Usage", + "abstract": "Data science software plays an increasingly important role in critical decision making in fields ranging from economy and finance to biology and medicine. As a result, errors in data science applications can have severe consequences, especially when they lead to results that look plausible, but are incorrect. A common cause of such errors is when applications erroneously ignore some of their input data, for instance due to bugs in the code that reads, filters, or clusters it. In this paper, we propose an abstract interpretation framework to automatically detect unused input data. We derive a program semantics that precisely captures data usage by abstraction of the program's operational trace semantics and express it in a constructive fixpoint form. Based on this semantics, we systematically derive static analyses that automatically detect unused input data by fixpoint approximation. This clear design principle provides a framework that subsumes existing analyses; we show that secure information flow analyses and a form of live variables analysis can be used for data usage, with varying degrees of precision. Additionally, we derive a static analysis to detect single unused data inputs, which is similar to dependency analyses used in the context of backward program slicing. Finally, we demonstrate the value of expressing such analyses as abstract interpretation by combining them with an existing abstraction of compound data structures such as arrays and lists to detect unused chunks of the data.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_24", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Caterina", + "last_name": "Urban", + "institution": "ETH Zurich" + }, + { + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/esop/UrbanM18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_29", + "title": "On Polymorphic Sessions and Functions - A Tale of Two (Fully Abstract) Encodings", + "abstract": "This work exploits the logical foundation of session types to determine what kind of type discipline for the $$\\pi $$ -calculus can exactly capture, and is captured by, $$\\lambda $$ -calculus behaviours. Leveraging the proof theoretic content of the soundness and completeness of sequent calculus and natural deduction presentations of linear logic, we develop the first mutually inverse and fully abstract processes-as-functions and functions-as-processes encodings between a polymorphic session $$\\pi $$ -calculus and a linear formulation of System F. We are then able to derive results of the session calculus from the theory of the $$\\lambda $$ -calculus: (1) we obtain a characterisation of inductive and coinductive session types via their algebraic representations in System F; and (2) we extend our results to account for value and process passing, entailing strong normalisation.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_29", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/esop/ToninhoY18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_28", + "title": "A Typing Discipline for Statically Verified Crash Failure Handling in Distributed Systems", + "abstract": "A key requirement for many distributed systems is to be resilient toward partial failures, allowing a system to progress despite the failure of some components. This makes programming of such systems daunting, particularly in regards to avoiding inconsistencies due to failures and asynchrony. This work introduces a formal model for crash failure handling in asynchronous distributed systems featuring a lightweight coordinator, modeled in the image of widely used systems such as ZooKeeper and Chubby. We develop a typing discipline based on multiparty session types for this model that supports the specification and static verification of multiparty protocols with explicit failure handling. We show that our type system ensures subject reduction and progress in the presence of failures. In other words, in a well-typed system even if some participants crash during execution, the system is guaranteed to progress in a consistent manner with the remaining participants.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_28", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Malte", + "last_name": "Viering", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Tzu‐Chun", + "last_name": "Chen", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Patrick", + "last_name": "Eugster", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "Imperial College London" + }, + { + "first_name": "Lukasz", + "last_name": "Ziarek", + "institution": "University at Buffalo, State University of New York" + } + ], + "dblp_key": "conf/esop/VieringCEHZ18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_22", + "title": "Velisarios: Byzantine Fault-Tolerant Protocols Powered by Coq", + "abstract": "Our increasing dependence on complex and critical information infrastructures and the emerging threat of sophisticated attacks, ask for extended efforts to ensure the correctness and security of these systems. Byzantine fault-tolerant state-machine replication (BFT-SMR) provides a way to harden such systems. It ensures that they maintain correctness and availability in an application-agnostic way, provided that the replication protocol is correct and at least $$n-f$$ out of n replicas survive arbitrary faults. This paper presents Velisarios, a logic-of-events based framework implemented in Coq, which we developed to implement and reason about BFT-SMR protocols. As a case study, we present the first machine-checked proof of a crucial safety property of an implementation of the area’s reference protocol: PBFT.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_22", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Vincent", + "last_name": "Rahli", + "institution": "University of Luxembourg" + }, + { + "first_name": "Ivana", + "last_name": "Vukotic", + "institution": "University of Luxembourg" + }, + { + "first_name": "Marcus", + "last_name": "Völp", + "institution": "University of Luxembourg" + }, + { + "first_name": "Paulo", + "last_name": "Verı́ssimo", + "institution": "University of Luxembourg" + } + ], + "dblp_key": "conf/esop/RahliVVV18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_23", + "title": "Evaluating Design Tradeoffs in Numeric Static Analysis for Java", + "abstract": "Numeric static analysis for Java has a broad range of potentially useful applications, including array bounds checking and resource usage estimation. However, designing a scalable numeric static analysis for real-world Java programs presents a multitude of design choices, each of which may interact with others. For example, an analysis could handle method calls via either a top-down or bottom-up interprocedural analysis. Moreover, this choice could interact with how we choose to represent aliasing in the heap and/or whether we use a relational numeric domain, e.g., convex polyhedra. In this paper, we present a family of abstract interpretation-based numeric static analyses for Java and systematically evaluate the impact of 162 analysis configurations on the DaCapo benchmark suite. Our experiment considered the precision and performance of the analyses for discharging array bounds checks. We found that top-down analysis is generally a better choice than bottom-up analysis, and that using access paths to describe heap objects is better than using summary objects corresponding to points-to analysis locations. Moreover, these two choices are the most significant, while choices about the numeric domain, representation of abstract objects, and context-sensitivity make much less difference to the precision/performance tradeoff.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_23", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Shiyi", + "last_name": "Wei", + "institution": "The University of Texas at Dallas" + }, + { + "first_name": "Piotr", + "last_name": "Mardziel", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Andrew", + "last_name": "Ruef", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Jeffrey S.", + "last_name": "Foster", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/esop/WeiMRF018", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_27", + "title": "Session-Typed Concurrent Contracts", + "abstract": "Multi-process systems control the behavior of everything from datacenters storing our information to banking systems managing money. Each one of these processes has a prescribed role, their contract, that governs their behavior during the joint computation. When a single process violates their communication contract, the impact of this misbehavior can rapidly propagate through the system. This thesisdevelops techniques for dynamically monitoring expressive classes of concurrent contracts. We provide multiple mechanisms to monitor contracts of increasing complexity.In order to model message-passing concurrent computation, we use a session type system. First, we present a method for dynamic monitoring and blame assignment where communication contracts are expressed using session types. Second, we describe contract-checking processes that handle stateful contracts that cannot be expressed with a session type. These contract-checking processes are also able to encode type refinements. Third, we encode dependent types in our system which allow us to monitor complex invariants. Finally, we survey a number of other monitoring extensions including a mechanism to monitor deadlock.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_27", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Hannah", + "last_name": "Gommerstadt", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/esop/GommerstadtJP18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_26", + "title": "Quantitative Analysis of Smart Contracts", + "abstract": "Smart contracts are computer programs that are executed by a network of mutually distrusting agents, without the need of an external trusted authority. Smart contracts handle and transfer assets of considerable value (in the form of crypto-currency like Bitcoin). Hence, it is crucial that their implementation is bug-free. We identify the utility (or expected payoff) of interacting with such smart contracts as the basic and canonical quantitative property for such contracts. We present a framework for such quantitative analysis of smart contracts. Such a formal framework poses new and novel research challenges in programming languages, as it requires modeling of game-theoretic aspects to analyze incentives for deviation from honest behavior and modeling utilities which are not specified as standard temporal properties such as safety and termination. While game-theoretic incentives have been analyzed in the security community, their analysis has been restricted to the very special case of stateless games. However, to analyze smart contracts, stateful analysis is required as it must account for the different program states of the protocol. Our main contributions are as follows: we present (i) a simplified programming language for smart contracts; (ii) an automatic translation of the programs to state-based games; (iii) an abstraction-refinement approach to solve such games; and (iv) experimental results on real-world-inspired smart contracts.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_26", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Yaron", + "last_name": "Velner", + "institution": "Hebrew University of Jerusalem" + } + ], + "dblp_key": "conf/esop/ChatterjeeGV18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_25", + "title": "Higher-Order Program Verification via HFL Model Checking", + "abstract": "There are two kinds of higher-order extensions of model checking: HORS model checking and HFL model checking. Whilst the former has been applied to automated verification of higher-order functional programs, applications of the latter have not been well studied. In the present paper, we show that various verification problems for functional programs, including may/must-reachability, trace properties, and linear-time temporal properties (and their negations), can be naturally reduced to (extended) HFL model checking. The reductions yield a sound and complete logical characterization of those program properties. Compared with the previous approaches based on HORS model checking, our approach provides a more uniform, streamlined method for higher-order program verification.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_25", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "The University of Tokyo" + }, + { + "first_name": "Keiichi", + "last_name": "Watanabe", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/esop/0001TW18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_31", + "title": "Correctness of a Concurrent Object Collector for Actor Languages", + "abstract": "ORCA is a garbage collection protocol for actor-based programs. Multiple actors may mutate the heap while the collector is running without any dedicated synchronisation. ORCA is applicable to any actor language whose type system prevents data races and which supports causal message delivery. We present a model of ORCA which is parametric to the host language and its type system. We describe the interplay between the host language and the collector. We give invariants preserved by ORCA, and prove its soundness and completeness.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_31", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Juliana", + "last_name": "Franco", + "institution": "Imperial College London" + }, + { + "first_name": "Sylvan", + "last_name": "Clebsch", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Imperial College London" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/esop/FrancoCDVW18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_32", + "title": "Paxos Consensus, Deconstructed and Abstracted", + "abstract": "Lamport’s Paxos algorithm is a classic consensus protocol for state machine replication in environments that admit crash failures. Many versions of Paxos exploit the protocol’s intrinsic properties for the sake of gaining better run-time performance, thus widening the gap between the original description of the algorithm, which was proven correct, and its real-world implementations. In this work, we address the challenge of specifying and verifying complex Paxos-based systems by (a) devising composable specifications for implementations of Paxos’s single-decree version, and (b) engineering disciplines to reason about protocol-aware, semantics-preserving optimisations to single-decree Paxos. In a nutshell, our approach elaborates on the deconstruction of single-decree Paxos by Boichat et al. We provide novel non-deterministic specifications for each module in the deconstruction and prove that the implementations refine the corresponding specifications, such that the proofs of the modules that remain unchanged can be reused across different implementations. We further reuse this result and show how to obtain a verified implementation of Multi-Paxos from a verified implementation of single-decree Paxos, by a series of novel protocol-aware transformations of the network semantics, which we prove to be behaviour-preserving.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_32", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Álvaro", + "last_name": "García-Pérez", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Yuri", + "last_name": "Meshman", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "University College London" + } + ], + "dblp_key": "conf/esop/Garcia-PerezGMS18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_33", + "title": "On Parallel Snapshot Isolation and Release/Acquire Consistency", + "abstract": "Parallel snapshot isolation (PSI) is a standard transactional consistency model used in databases and distributed systems. We argue that PSI is also a useful formal model for software transactional memory (STM) as it has certain advantages over other consistency models. However, the formal PSI definition is given declaratively by acyclicity axioms, which most programmers find hard to understand and reason about. To address this, we develop a simple lock-based reference implementation for PSI built on top of the release-acquire memory model, a well-behaved subset of the C/C++11 memory model. We prove that our implementation is sound and complete against its higher-level declarative specification. We further consider an extension of PSI allowing transactional and non-transactional code to interact, and provide a sound and complete reference implementation for the more general setting. Supporting this interaction is necessary for adopting a transactional model in programming languages.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_33", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/esop/RaadLV18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_34", + "title": "Eventual Consistency for CRDTs", + "abstract": "We address the problem of validity in eventually consistent (EC) systems: In what sense does an EC data structure satisfy the sequential specification of that data structure? Because EC is a very weak criterion, our definition does not describe every EC system; however it is expressive enough to describe any Convergent or Commutative Replicated Data Type (CRDT).", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_34", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Radha", + "last_name": "Jagadeesan", + "institution": "DePaul University" + }, + { + "first_name": "James", + "last_name": "Riely", + "institution": "DePaul University" + } + ], + "dblp_key": "conf/esop/JagadeesanR18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_36", + "title": "Compositional Verification of Compiler Optimisations on Relaxed Memory", + "abstract": "A valid compiler optimisation transforms a block in a program without introducing new observable behaviours to the program as a whole. Deciding which optimisations are valid can be difficult, and depends closely on the semantic model of the programming language. Axiomatic relaxed models, such as C++11, present particular challenges for determining validity, because such models allow subtle effects of a block transformation to be observed by the rest of the program. In this paper we present a denotational theory that captures optimisation validity on an axiomatic model corresponding to a fragment of C++11. Our theory allows verifying an optimisation compositionally, by considering only the block it transforms instead of the whole program. Using this property, we realise the theory in the first push-button tool that can verify real-world optimisations under an axiomatic memory model.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_36", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Mike", + "last_name": "Dodds", + "institution": "Galois (United States)" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + }, + { + "first_name": "Alexey", + "last_name": "Gotsman", + "institution": "IMDEA Software Institute" + } + ], + "dblp_key": "conf/esop/DoddsBG18", + "venue": "esop", + "year": 2018 + }, + { + "paper_id": "10.1007/978-3-319-89884-1_35", + "title": "A Verified Compiler from Isabelle/HOL to CakeML", + "abstract": "Many theorem provers can generate functional programs from definitions or proofs. However, this code generation needs to be trusted. Except for the HOL4 system, which has a proof producing code generator for a subset of ML. We go one step further and provide a verified compiler from Isabelle/HOL to CakeML. More precisely we combine a simple proof producing translation of recursion equations in Isabelle/HOL into a deeply embedded term language with a fully verified compilation chain to the target language CakeML.", + "date": "2018-01-01", + "link": "https://doi.org/10.1007/978-3-319-89884-1_35", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Lars", + "last_name": "Hupel", + "institution": "Technical University of Munich" + }, + { + "first_name": "Tobias", + "last_name": "Nipkow", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/esop/HupelN18", + "venue": "esop", + "year": 2018 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2019.json b/data/pl_conferences/esop/2019.json new file mode 100644 index 0000000..934435f --- /dev/null +++ b/data/pl_conferences/esop/2019.json @@ -0,0 +1,681 @@ +[ + { + "paper_id": "10.1007/978-3-030-17184-1_5", + "title": "Codata in Action", + "abstract": "Computer scientists are well-versed in dealing with data structures. The same cannot be said about their dual: codata. Even though codata is pervasive in category theory, universal algebra, and logic, the use of codata for programming has been mainly relegated to representing infinite objects and processes. Our goal is to demonstrate the benefits of codata as a general-purpose programming abstraction independent of any specific language: eager or lazy, statically or dynamically typed, and functional or object-oriented. While codata is not featured in many programming languages today, we show how codata can be easily adopted and implemented by offering simple inter-compilation techniques between data and codata. We believe codata is a common ground between the functional and object-oriented paradigms; ultimately, we hope to utilize the Curry-Howard isomorphism to further bridge the gap.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Downen", + "institution": "University of Oregon" + }, + { + "first_name": "Zachary", + "last_name": "Sullivan", + "institution": "University of Oregon" + }, + { + "first_name": "Zena M.", + "last_name": "Ariola", + "institution": "University of Oregon" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/esop/DownenSAJ19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_13", + "title": "Handling Polymorphic Algebraic Effects", + "abstract": "Algebraic effects and handlers are a powerful abstraction mechanism to represent and implement control effects. In this work, we study their extension with parametric polymorphism that allows abstracting not only expressions but also effects and handlers. Although polymorphism makes it possible to reuse and reason about effect implementations more effectively, it has long been known that a naive combination of polymorphic effects and let-polymorphism breaks type safety. Although type safety can often be gained by restricting let-bound expressions—e.g., by adopting value restriction or weak polymorphism—we propose a complementary approach that restricts handlers instead of let-bound expressions. Our key observation is that, informally speaking, a handler is safe if resumptions from the handler do not interfere with each other. To formalize our idea, we define a call-by-value lambda calculus $$\\lambda _\\text {eff}^\\text {let}$$ that supports let-polymorphism and polymorphic algebraic effects and handlers, design a type system that rejects interfering handlers, and prove type safety of our calculus.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/esop/SekiyamaI19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_15", + "title": "Types by Need", + "abstract": "A cornerstone of the theory of $$\\lambda $$ -calculus is that intersection types characterise termination properties. They are a flexible tool that can be adapted to various notions of termination, and that also induces adequate denotational models. Since the seminal work of de Carvalho in 2007, it is known that multi types (i.e. non-idempotent intersection types) refine intersection types with quantitative information and a strong connection to linear logic. Typically, type derivations provide bounds for evaluation lengths, and minimal type derivations provide exact bounds. De Carvalho studied call-by-name evaluation, and Kesner used his system to show the termination equivalence of call-by-need and call-by-name. De Carvalho’s system, however, cannot provide exact bounds on call-by-need evaluation lengths. In this paper we develop a new multi type system for call-by-need. Our system produces exact bounds and induces a denotational model of call-by-need, providing the first tight quantitative semantics of call-by-need.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "École Polytechnique" + }, + { + "first_name": "Giulio", + "last_name": "Guerrieri", + "institution": "University of Bath" + }, + { + "first_name": "Maico", + "last_name": "Leberle", + "institution": "École Polytechnique" + } + ], + "dblp_key": "conf/esop/AccattoliGL19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_12", + "title": "Probabilistic Programming Inference via Intensional Semantics", + "abstract": "We define a new denotational semantics for a first-order probabilistic programming language in terms of probabilistic event structures. This semantics is intensional, meaning that the interpretation of a program contains information about its behaviour throughout execution, rather than a simple distribution on return values. In particular, occurrences of sampling and conditioning are recorded as explicit events, partially ordered according to the data dependencies between the corresponding statements in the program. This interpretation is adequate: we show that the usual measure-theoretic semantics of a program can be recovered from its event structure representation. Moreover it can be leveraged for MCMC inference: we prove correct a version of single-site Metropolis-Hastings with incremental recomputation, in which the proposal kernel takes into account the semantic information in order to avoid performing some of the redundant sampling.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Castellan", + "institution": "Imperial College London" + }, + { + "first_name": "Hugo", + "last_name": "Paquet", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/esop/CastellanP19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_9", + "title": "Extended Call-by-Push-Value: Reasoning About Effectful Programs and Evaluation Order", + "abstract": "Traditionally, reasoning about programs under varying evaluation regimes (call-by-value, call-by-name etc.) was done at the meta-level, treating them as term rewriting systems. Levy’s call-by-push-value (CBPV) calculus provides a more powerful approach for reasoning, by treating CBPV terms as a common intermediate language which captures both call-by-value and call-by-name, and by allowing equational reasoning about changes to evaluation order between or within programs. We extend CBPV to additionally deal with call-by-need, which is non-trivial because of shared reductions. This allows the equational reasoning to also support call-by-need. As an example, we then prove that call-by-need and call-by-name are equivalent if nontermination is the only side-effect in the source language. We then show how to incorporate an effect system. This enables us to exploit static knowledge of the potential effects of a given expression to augment equational reasoning; thus a program fragment might be invariant under change of evaluation regime only because of knowledge of its effects.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Dylan", + "last_name": "McDermott", + "institution": "University of Cambridge" + }, + { + "first_name": "Alan", + "last_name": "Mycroft", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/esop/McDermottM19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_14", + "title": "Distributive Disjoint Polymorphism for Compositional Programming", + "abstract": "Popular programming techniques such as shallow embeddings of Domain Specific Languages (DSLs), finally tagless or object algebras are built on the principle of compositionality. However, existing programming languages only support simple compositional designs well, and have limited support for more sophisticated ones. This paper presents the $$\\mathsf {F}_{i}^{+}$$ calculus, which supports highly modular and compositional designs that improve on existing techniques. These improvements are due to the combination of three features: disjoint intersection types with a merge operator; parametric (disjoint) polymorphism; and BCD-style distributive subtyping. The main technical challenge is $$\\mathsf {F}_{i}^{+}$$ ’s proof of coherence. A naive adaptation of ideas used in System F’s parametricity to canonicity (the logical relation used by $$\\mathsf {F}_{i}^{+}$$ to prove coherence) results in an ill-founded logical relation. To solve the problem our canonicity relation employs a different technique based on immediate substitutions and a restriction to predicative instantiations. Besides coherence, we show several other important meta-theoretical results, such as type-safety, sound and complete algorithmic subtyping, and decidability of the type system. Remarkably, unlike $$\\mathsf {F}_{<:}$$ ’s bounded polymorphism, disjoint polymorphism in $$\\mathsf {F}_{i}^{+}$$ supports decidable type-checking.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Xuan", + "last_name": "Bi", + "institution": "University of Hong Kong" + }, + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/esop/BiXOS19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_3", + "title": "Semi-automated Reasoning About Non-determinism in C Expressions", + "abstract": "Research into C verification often ignores that the C standard leaves the evaluation order of expressions unspecified, and assigns undefined behavior to write-write or read-write conflicts in subexpressions—so called “sequence point violations”. These aspects should be accounted for in verification because C compilers exploit them. We present a verification condition generator (vcgen) that enables one to semi-automatically prove the absence of undefined behavior in a given C program for any evaluation order. The key novelty of our approach is a symbolic execution algorithm that computes a frame at the same time as a postcondition. The frame is used to automatically determine how resources should be distributed among subexpressions. We prove correctness of our vcgen with respect to a new monadic definitional semantics of a subset of C. This semantics is modular and gives a concise account of non-determinism in C. We have implemented our vcgen as a tactic in the Coq interactive theorem prover, and have proved correctness of it using a separation logic for the new monadic definitional semantics of a subset of C.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Dan", + "last_name": "Frumin", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Léon", + "last_name": "Gondelman", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/esop/FruminGK19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_2", + "title": "Meta-F ^\\star : Proof Automation with SMT, Tactics, and Metaprograms", + "abstract": "We introduce Meta-F $$^{\\star }$$ , a tactics and metaprogramming framework for the F $$^\\star $$ program verifier. The main novelty of Meta-F $$^\\star $$ is allowing the use of tactics and metaprogramming to discharge assertions not solvable by SMT, or to just simplify them into well-behaved SMT fragments. Plus, Meta-F $$^\\star $$ can be used to generate verified code automatically. Meta-F $$^\\star $$ is implemented as an F $$^\\star $$ effect, which, given the powerful effect system of F $$^{\\star }$$ , heavily increases code reuse and even enables the lightweight verification of metaprograms. Metaprograms can be either interpreted, or compiled to efficient native code that can be dynamically loaded into the F $$^\\star $$ type-checker and can interoperate with interpreted code. Evaluation on realistic case studies shows that Meta-F $$^\\star $$ provides substantial gains in proof development, efficiency, and robustness.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Guido", + "last_name": "Martínez", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "University of Ljubljana" + }, + { + "first_name": "Victor", + "last_name": "Dumitrescu", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nick", + "last_name": "Giannarakis", + "institution": "Princeton University" + }, + { + "first_name": "Chris", + "last_name": "Hawblitzel", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Monal", + "last_name": "Narasimhamurthy", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Princeton University" + }, + { + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/esop/MartinezADGHHNP19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_4", + "title": "Safe Deferred Memory Reclamation with Types", + "abstract": "Memory management in lock-free data structures remains a major challenge in concurrent programming. Design techniques including read-copy-update (RCU) and hazard pointers provide workable solutions, and are widely used to great effect. These techniques rely on the concept of a grace period: nodes that should be freed are not deallocated immediately, and all threads obey a protocol to ensure that the deallocating thread can detect when all possible readers have completed their use of the object. This provides an approach to safe deallocation, but only when these subtle protocols are implemented correctly. We present a static type system to ensure correct use of RCU memory management: that nodes removed from a data structure are always scheduled for subsequent deallocation, and that nodes are scheduled for deallocation at most once. As part of our soundness proof, we give an abstract semantics for RCU memory management primitives which captures the fundamental properties of RCU. Our type system allows us to give the first proofs of memory safety for RCU linked list and binary search tree implementations without requiring full verification.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ismail", + "last_name": "Kuru", + "institution": "Drexel University" + }, + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "Drexel University" + } + ], + "dblp_key": "conf/esop/KuruG19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_8", + "title": "One Step at a Time - A Functional Derivation of Small-Step Evaluators from Big-Step Counterparts", + "abstract": "Big-step and small-step are two popular flavors of operational semantics. Big-step is often seen as a more natural transcription of informal descriptions, as well as being more convenient for some applications such as interpreter generation or optimization verification. Small-step allows reasoning about non-terminating computations, concurrency and interactions. It is also generally preferred for reasoning about type systems. Instead of having to manually specify equivalent semantics in both styles for different applications, it would be useful to choose one and derive the other in a systematic or, preferably, automatic way. Transformations of small-step semantics into big-step have been investigated in various forms by Danvy and others. However, it appears that a corresponding transformation from big-step to small-step semantics has not had the same attention. We present a fully automated transformation that maps big-step evaluators written in direct style to their small-step counterparts. Many of the steps in the transformation, which include CPS-conversion, defunctionalisation, and various continuation manipulations, mirror those used by Danvy and his co-authors. For many standard languages, including those with either call-by-value or call-by-need and those with state, the transformation produces small-step semantics that are close in style to handwritten ones. We evaluate the applicability and correctness of the approach on 20 languages with a range of features.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ferdinand", + "last_name": "Vesely", + "institution": "Tufts University" + }, + { + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" + } + ], + "dblp_key": "conf/esop/VeselyF19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_16", + "title": "Verifiable Certificates for Predicate Subtyping", + "abstract": "Adding predicate subtyping to higher-order logic yields a very expressive language in which type-checking is undecidable, making the definition of a system of verifiable certificates challenging. This work presents a solution to this issue with a minimal formalization of predicate subtyping, named PVS-Core, together with a system of verifiable certificates for PVS-Core, named PVS-Cert. PVS-Cert is based on the introduction of proof terms and explicit coercions. Its design is similar to that of PTSs with dependent pairs, with the exception of the definition of conversion, which is based on a specific notion of reduction $$\\rightarrow _{\\beta *}$$ , corresponding to $$\\beta $$ -reduction combined with the erasure of coercions. The use of this reduction instead of the more standard reduction $$\\rightarrow _{\\beta \\sigma }$$ allows to establish a simple correspondence between PVS-Core and PVS-Cert. On the other hand, a type-checking algorithm is designed for PVS-Cert, built on proofs of type preservation of $$\\rightarrow _{\\beta \\sigma }$$ and strong normalization of both $$\\rightarrow _{\\beta \\sigma }$$ and $$\\rightarrow _{\\beta *}$$ . Combining these results, PVS-Cert judgements are used as verifiable certificates for predicate subtyping. In addition, the reduction $$\\rightarrow _{\\beta \\sigma }$$ is used to define a cut elimination procedure for predicate subtyping. This definition provides a new tool to study the properties of predicate subtyping, as illustrated with a proof of consistency.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Frédéric", + "last_name": "Gilbert", + "institution": "" + } + ], + "dblp_key": "conf/esop/Gilbert19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_6", + "title": "Composing Bidirectional Programs Monadically", + "abstract": "Software frequently converts data from one representation to another and vice versa. Naïvely specifying both conversion directions separately is error prone and introduces conceptual duplication. Instead, bidirectional programming techniques allow programs to be written which can be interpreted in both directions. However, these techniques often employ unfamiliar programming idioms via restricted, specialised combinator libraries. Instead, we introduce a framework for composing bidirectional programs monadically, enabling bidirectional programming with familiar abstractions in functional languages such as Haskell. We demonstrate the generality of our approach applied to parsers/printers, lenses, and generators/predicates. We show how to leverage compositionality and equational reasoning for the verification of round-tripping properties for such monadic bidirectional programs.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Li-yao", + "last_name": "Xia", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + } + ], + "dblp_key": "conf/esop/XiaOW19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_1", + "title": "Time Credits and Time Receipts in Iris", + "abstract": "We present a machine-checked extension of the program logic Iris with time credits and time receipts, two dual means of reasoning about time. Whereas time credits are used to establish an upper bound on a program’s execution time, time receipts can be used to establish a lower bound. More strikingly, time receipts can be used to prove that certain undesirable events—such as integer overflows—cannot occur until a very long time has elapsed. We present several machine-checked applications of time credits and time receipts, including an application where both concepts are exploited.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Glen", + "last_name": "Mével", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Université Paris-Sud" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/esop/MevelJP19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_18", + "title": "Compiling Sandboxes: Formally Verified Software Fault Isolation", + "abstract": "Software Fault Isolation (SFI) is a security-enhancing program transformation for instrumenting an untrusted binary module so that it runs inside a dedicated isolated address space, called a sandbox. To ensure that the untrusted module cannot escape its sandbox, existing approaches such as Google’s Native Client rely on a binary verifier to check that all memory accesses are within the sandbox. Instead of relying on a posteriori verification, we design, implement and prove correct a program instrumentation phase as part of the formally verified compiler CompCert that enforces a sandboxing security property a priori. This eliminates the need for a binary verifier and, instead, leverages the soundness proof of the compiler to prove the security of the sandboxing transformation. The technical contributions are a novel sandboxing transformation that has a well-defined C semantics and which supports arbitrary function pointers, and a formally verified C compiler that implements SFI. Experiments show that our formally verified technique is a competitive way of implementing SFI.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_18", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Frédéric", + "last_name": "Besson", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Alexandre", + "last_name": "Dang", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Thomas", + "last_name": "Jensen", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Pierre", + "last_name": "Wilke", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/BessonBDJW19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_21", + "title": "Asynchronous Timed Session Types - From Duality to Time-Sensitive Processes", + "abstract": "We present a behavioural typing system for a higher-order timed calculus using session types to model timed protocols. Behavioural typing ensures that processes in the calculus perform actions in the time-windows prescribed by their protocols. We introduce duality and subtyping for timed asynchronous session types. Our notion of duality allows typing a larger class of processes with respect to previous proposals. Subtyping is critical for the precision of our typing system, especially in the presence of session delegation. The composition of dual (timed asynchronous) types enjoys progress when using an urgent receive semantics, in which receive actions are executed as soon as the expected message is available. Our calculus increases the modelling power of extant calculi on timed sessions, adding a blocking receive primitive with timeout and a primitive that consumes an arbitrary amount of time in a given range.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_21", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Laura", + "last_name": "Bocchi", + "institution": "University of Kent" + }, + { + "first_name": "Maurizio", + "last_name": "Murgia", + "institution": "University of Kent" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/esop/BocchiMVY19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_20", + "title": "Incremental \\lambda -Calculus in Cache-Transfer Style - Static Memoization by Program Transformation", + "abstract": "Incremental computation requires propagating changes and reusing intermediate results of base computations. Derivatives, as produced by static differentiation [7], propagate changes but do not reuse intermediate results, leading to wasteful recomputation. As a solution, we introduce conversion to Cache-Transfer-Style, an additional program transformations producing purely incremental functional programs that create and maintain nested tuples of intermediate results. To prove CTS conversion correct, we extend the correctness proof of static differentiation from STLC to untyped $$\\lambda $$ -calculus via step-indexed logical relations, and prove sound the additional transformation via simulation theorems. To show ILC-based languages can improve performance relative to from-scratch recomputation, and that CTS conversion can extend its applicability, we perform an initial performance case study. We provide derivatives of primitives for operations on collections and incrementalize selected example programs using those primitives, confirming expected asymptotic speedups.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_20", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Paolo G.", + "last_name": "Giarrusso", + "institution": "Centre Alpien de Phytogéographie" + }, + { + "first_name": "Yann", + "last_name": "Régis-Gianas", + "institution": "Délégation Paris 7" + }, + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/esop/GiarrussoRS19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_19", + "title": "Fixing Incremental Computation - Derivatives of Fixpoints, and the Recursive Semantics of Datalog", + "abstract": "Incremental computation has recently been studied using the concepts of change structures and derivatives of programs, where the derivative of a function allows updating the output of the function based on a change to its input. We generalise change structures to change actions, and study their algebraic properties. We develop change actions for common structures in computer science, including directed-complete partial orders and Boolean algebras. We then show how to compute derivatives of fixpoints. This allows us to perform incremental evaluation and maintenance of recursively defined functions with particular application generalised Datalog programs. Moreover, unlike previous results, our techniques are modular in that they are easy to apply both to variants of Datalog and to other programming languages.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_19", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Mario", + "last_name": "Alvarez-Picallo", + "institution": "University of Oxford" + }, + { + "first_name": "Alex", + "last_name": "Eyers-Taylor", + "institution": "" + }, + { + "first_name": "Michael Peyton", + "last_name": "Jones", + "institution": "" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/esop/Alvarez-Picallo19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_25", + "title": "Data Races and Static Analysis for Interrupt-Driven Kernels", + "abstract": "We consider a class of interrupt-driven programs that model the kernel API libraries of some popular real-time embedded operating systems and the synchronization mechanisms they use. We define a natural notion of data races and a happens-before ordering for such programs. The key insight is the notion of disjoint blocks to define the synchronizes-with relation. This notion also suggests an efficient and effective lockset based analysis for race detection. It also enables us to define efficient “sync-CFG” based static analyses for such programs, which exploit data race freedom. We use this theory to carry out static analysis on the FreeRTOS kernel library to detect races and to infer simple relational invariants on key kernel variables and data-structures.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_25", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Nikita", + "last_name": "Chopra", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Rekha", + "last_name": "Pai", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Deepak", + "last_name": "D’Souza", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/esop/ChopraPD19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_24", + "title": "A Process Algebra for Link Layer Protocols", + "abstract": "We propose a process algebra for link layer protocols, featuring a unique mechanism for modelling frame collisions. We also formalise suitable liveness properties for link layer protocols specified in this framework. To show applicability we model and analyse two versions of the Carrier-Sense Multiple Access with Collision Avoidance (CSMA/CA) protocol. Our analysis confirms the hidden station problem for the version without virtual carrier sensing. However, we show that the version with virtual carrier sensing not only overcomes this problem, but also the exposed station problem with probability 1. Yet the protocol cannot guarantee packet delivery, not even with probability 1.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_24", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Rob van", + "last_name": "Glabbeek", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Peter", + "last_name": "Höfner", + "institution": "UNSW Sydney" + }, + { + "first_name": "Michael", + "last_name": "Markl", + "institution": "Data61" + } + ], + "dblp_key": "conf/esop/GlabbeekHM19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_28", + "title": "Coinduction in Uniform: Foundations for Corecursive Proof Search with Horn Clauses", + "abstract": "We establish proof-theoretic, constructive and coalgebraic foundations for proof search in coinductive Horn clause theories. Operational semantics of coinductive Horn clause resolution is cast in terms of coinductive uniform proofs; its constructive content is exposed via soundness relative to an intuitionistic first-order logic with recursion controlled by the later modality; and soundness of both proof systems is proven relative to a novel coalgebraic description of complete Herbrand models.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_28", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Henning", + "last_name": "Basold", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Ekaterina", + "last_name": "Komendantskaya", + "institution": "Heriot-Watt University" + }, + { + "first_name": "Yue", + "last_name": "Li", + "institution": "Heriot-Watt University" + } + ], + "dblp_key": "conf/esop/BasoldKL19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_26", + "title": "An Abstract Domain for Trees with Numeric Relations", + "abstract": "We present an abstract domain able to infer invariants on programs manipulating trees. Trees considered in the article are defined over a finite alphabet and can contain unbounded numeric values at their leaves. Our domain can infer the possible shapes of the tree values of each variable and find numeric relations between: the values at the leaves as well as the size and depth of the tree values of different variables. The abstract domain is described as a product of (1) a symbolic domain based on a tree automata representation and (2) a numerical domain lifted, for the occasion, to describe numerical maps with potentially infinite and heterogeneous definition set. In addition to abstract set operations and widening we define concrete and abstract transformers on these environments. We present possible applications, such as the ability to describe memory zones, or track symbolic equalities between program variables. We implemented our domain in a static analysis platform and present preliminary results analyzing a tree-manipulating toy-language.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_26", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Matthieu", + "last_name": "Journault", + "institution": "Laboratoire de Recherche en Informatique de Paris 6" + }, + { + "first_name": "Antoine", + "last_name": "Miné", + "institution": "Sorbonne Université" + }, + { + "first_name": "Abdelraouf", + "last_name": "Ouadjaout", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/JournaultMO19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_23", + "title": "A Categorical Model of an \\mathbf i/o -typed \\pi -calculus", + "abstract": "This paper introduces a new categorical structure that is a model of a variant of the $$ \\mathbf {i/o} $$ -typed $$ \\pi $$ -calculus, in the same way that a cartesian closed category is a model of the $$ \\lambda $$ -calculus. To the best of our knowledge, no categorical model has been given for the $$ \\mathbf {i/o} $$ -typed $$ \\pi $$ -calculus, in contrast to session-typed calculi, to which corresponding logic and categorical structure were given. The categorical structure introduced in this paper has a simple definition, combining two well-known structures, namely, closed Freyd category and compact closed category. The former is a model of effectful computation in a general setting, and the latter describes connections via channels, which cause the effect we focus on in this paper. To demonstrate the relevance of the categorical model, we show by a semantic consideration that the $$ \\pi $$ -calculus is equivalent to a core calculus of Concurrent ML.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_23", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ken", + "last_name": "Sakayori", + "institution": "The University of Tokyo" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/esop/SakayoriT19", + "venue": "esop", + "year": 2019 + }, + { + "paper_id": "10.1007/978-3-030-17184-1_27", + "title": "A Static Higher-Order Dependency Pair Framework", + "abstract": "We revisit the static dependency pair method for proving termination of higher-order term rewriting and extend it in a number of ways: (1) We introduce a new rewrite formalism designed for general applicability in termination proving of higher-order rewriting, Algebraic Functional Systems with Meta-variables. (2) We provide a syntactically checkable soundness criterion to make the method applicable to a large class of rewrite systems. (3) We propose a modular dependency pair framework for this higher-order setting. (4) We introduce a fine-grained notion of formative and computable chains to render the framework more powerful. (5) We formulate several existing and new termination proving techniques in the form of processors within our framework. The framework has been implemented in the (fully automatic) higher-order termination tool WANDA.", + "date": "2019-01-01", + "link": "https://doi.org/10.1007/978-3-030-17184-1_27", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Carsten", + "last_name": "Fuhs", + "institution": "Birkbeck, University of London" + }, + { + "first_name": "Cynthia", + "last_name": "Kop", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "conf/esop/FuhsK19", + "venue": "esop", + "year": 2019 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2020.json b/data/pl_conferences/esop/2020.json new file mode 100644 index 0000000..b4740ce --- /dev/null +++ b/data/pl_conferences/esop/2020.json @@ -0,0 +1,833 @@ +[ + { + "paper_id": "10.1007/978-3-030-44914-8_6", + "title": "Concise Read-Only Specifications for Better Synthesis of Programs with Pointers", + "abstract": "Abstract In program synthesis there is a well-known trade-off between concise and strong specifications: if a specification is too verbose, it might be harder to write than the program; if it is too weak, the synthesised program might not match the user’s intent. In this work we explore the use of annotations for restricting memory access permissions in program synthesis, and show that they can make specifications much stronger while remaining surprisingly concise. Specifically, we enhance Synthetic Separation Logic (SSL), a framework for synthesis of heap-manipulating programs, with the logical mechanism of read-only borrows . We observe that this minimalistic and conservative SSL extension benefits the synthesis in several ways, making it more (a) expressive (stronger correctness guarantees are achieved with a modest annotation overhead), (b) effective (it produces more concise and easier-to-read programs), (c) efficient (faster synthesis), and (d) robust (synthesis efficiency is less affected by the choice of the search heuristic). We explain the intuition and provide formal treatment for read-only borrows. We substantiate the claims (a)–(d) by describing our quantitative evaluation of the borrowing-aware synthesis implementation on a series of standard benchmark specifications for various heap-manipulating programs.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Andreea", + "last_name": "Costea", + "institution": "National University of Singapore" + }, + { + "first_name": "Amy", + "last_name": "Zhu", + "institution": "University of British Columbia" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/esop/CosteaZPS20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_9", + "title": "SMT-Friendly Formalization of the Solidity Memory Model", + "abstract": "Abstract Solidity is the dominant programming language for Ethereum smart contracts. This paper presents a high-level formalization of the Solidity language with a focus on the memory model. The presented formalization covers all features of the language related to managing state and memory. In addition, the formalization we provide is effective: all but few features can be encoded in the quantifier-free fragment of standard SMT theories. This enables precise and efficient reasoning about the state of smart contracts written in Solidity. The formalization is implemented in the SOLC-VERIFY verifier and we provide an extensive set of tests that covers the breadth of the required semantics. We also provide an evaluation on the test set that validates the semantics and shows the novelty of the approach compared to other Solidity-level contract analysis tools.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ákos", + "last_name": "Hajdu", + "institution": "Budapest University of Technology and Economics" + }, + { + "first_name": "Dejan", + "last_name": "Jovanović", + "institution": "SRI International" + } + ], + "dblp_key": "conf/esop/HajduJ20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_12", + "title": "Local Reasoning for Global Graph Properties", + "abstract": "Abstract Separation logics are widely used for verifying programs that manipulate complex heap-based data structures. These logics build on so-called separation algebras , which allow expressing properties of heap regions such that modifications to a region do not invalidate properties stated about the remainder of the heap. This concept is key to enabling modular reasoning and also extends to concurrency. While heaps are naturally related to mathematical graphs, many ubiquitous graph properties are non-local in character, such as reachability between nodes, path lengths, acyclicity and other structural invariants, as well as data invariants which combine with these notions. Reasoning modularly about such graph properties remains notoriously difficult, since a local modification can have side-effects on a global property that cannot be easily confined to a small region. In this paper, we address the question: What separation algebra can be used to avoid proof arguments reverting back to tedious global reasoning in such cases? To this end, we consider a general class of global graph properties expressed as fixpoints of algebraic equations over graphs. We present mathematical foundations for reasoning about this class of properties, imposing minimal requirements on the underlying theory that allow us to define a suitable separation algebra. Building on this theory, we develop a general proof technique for modular reasoning about global graph properties expressed over program heaps, in a way which can be directly integrated with existing separation logics. To demonstrate our approach, we present local proofs for two challenging examples: a priority inheritance protocol and the non-blocking concurrent Harris list.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Siddharth", + "last_name": "Krishna", + "institution": "New York University" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "conf/esop/KrishnaSW20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_11", + "title": "Verifying Visibility-Based Weak Consistency", + "abstract": "Abstract Multithreaded programs generally leverage efficient and thread-safe concurrent objects like sets, key-value maps, and queues. While some concurrent-object operations are designed to behave atomically, each witnessing the atomic effects of predecessors in a linearization order, others forego such strong consistency to avoid complex control and synchronization bottlenecks. For example, contains (value) methods of key-value maps may iterate through key-value entries without blocking concurrent updates, to avoid unwanted performance bottlenecks, and consequently overlook the effects of some linearization-order predecessors. While such weakly-consistent operations may not be atomic, they still offer guarantees, e.g., only observing values that have been present. In this work we develop a methodology for proving that concurrent object implementations adhere to weak-consistency specifications. In particular, we consider (forward) simulation-based proofs of implementations against relaxed-visibility specifications , which allow designated operations to overlook some of their linearization-order predecessors, i.e., behaving as if they never occurred. Besides annotating implementation code to identify linearization points , i.e., points at which operations’ logical effects occur, we also annotate code to identify visible operations , i.e., operations whose effects are observed; in practice this annotation can be done automatically by tracking the writers to each accessed memory location. We formalize our methodology over a general notion of transition systems, agnostic to any particular programming language or memory model, and demonstrate its application, using automated theorem provers, by verifying models of Java concurrent object implementations.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Siddharth", + "last_name": "Krishna", + "institution": "New York University" + }, + { + "first_name": "Michael", + "last_name": "Emmi", + "institution": "SRI International" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Dejan", + "last_name": "Jovanović", + "institution": "SRI International" + } + ], + "dblp_key": "conf/esop/KrishnaEEJ20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_3", + "title": "On the Versatility of Open Logical Relations - Continuity, Automatic Differentiation, and a Containment Theorem", + "abstract": "Abstract Logical relations are one among the most powerful techniques in the theory of programming languages, and have been used extensively for proving properties of a variety of higher-order calculi. However, there are properties that cannot be immediately proved by means of logical relations, for instance program continuity and differentiability in higher-order languages extended with real-valued functions. Informally, the problem stems from the fact that these properties are naturally expressed on terms of non-ground type (or, equivalently, on open terms of base type), and there is no apparent good definition for a base case (i.e. for closed terms of ground types). To overcome this issue, we study a generalization of the concept of a logical relation, called open logical relation , and prove that it can be fruitfully applied in several contexts in which the property of interest is about expressions of first-order type. Our setting is a simply-typed $$\\lambda $$ λ -calculus enriched with real numbers and real-valued first-order functions from a given set, such as the one of continuous or differentiable functions. We first prove a containment theorem stating that for any collection of real-valued first-order functions including projection functions and closed under function composition, any well-typed term of first-order type denotes a function belonging to that collection. Then, we show by way of open logical relations the correctness of the core of a recently published algorithm for forward automatic differentiation. Finally, we define a refinement-based type system for local continuity in an extension of our calculus with conditionals, and prove the soundness of the type system using open logical relations.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "Max Planck Institute for Security and Privacy" + }, + { + "first_name": "Raphaëlle", + "last_name": "Crubillé", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Francesco", + "last_name": "Gavazzo", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/BartheCLG20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_4", + "title": "Constructive Game Logic", + "abstract": "Abstract Game Logic is an excellent setting to study proofs-about-programs via the interpretation of those proofs as programs, because constructive proofs for games correspond to effective winning strategies to follow in response to the opponent’s actions. We thus develop Constructive Game Logic , which extends Parikh’s Game Logic (GL) with constructivity and with first-order programs à la Pratt’s first-order dynamic logic (DL). Our major contributions include: 1. a novel realizability semantics capturing the adversarial dynamics of games, 2. a natural deduction calculus and operational semantics describing the computational meaning of strategies via proof-terms, and 3. theoretical results including soundness of the proof calculus w.r.t. realizability semantics, progress and preservation of the operational semantics of proofs, and Existential Properties on support of the extraction of computational artifacts from game proofs. Together, these results provide the most general account of a Curry-Howard interpretation for any program logic to date, and the first at all for Game Logic.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Rose", + "last_name": "Bohrer", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "André", + "last_name": "Platzer", + "institution": "Technical University of Munich" + } + ], + "dblp_key": "conf/esop/BohrerP20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_2", + "title": "Runners in Action", + "abstract": "Abstract Runners of algebraic effects, also known as comodels, provide a mathematical model of resource management. We show that they also give rise to a programming concept that models top-level external resources, as well as allows programmers to modularly define their own intermediate “virtual machines”. We capture the core ideas of programming with runners in an equational calculus $$\\lambda _{\\mathsf {coop}}$$ λ coop , which we equip with a sound and coherent denotational semantics that guarantees the linear use of resources and execution of finalisation code. We accompany $$\\lambda _{\\mathsf {coop}}$$ λ coop with examples of runners in action, provide a prototype language implementation in OCaml , as well as a Haskell library based on $$\\lambda _{\\mathsf {coop}}$$ λ coop .", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Danel", + "last_name": "Ahman", + "institution": "University of Ljubljana" + }, + { + "first_name": "Andrej", + "last_name": "Bauer", + "institution": "University of Ljubljana" + } + ], + "dblp_key": "conf/esop/AhmanB20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_16", + "title": "Connecting Higher-Order Separation Logic to a First-Order Outside World", + "abstract": "Abstract Separation logic is a useful tool for proving the correctness of programs that manipulate memory, especially when the model of memory includes higher-order state: Step-indexing, predicates in the heap, and higher-order ghost state have been used to reason about function pointers, data structure invariants, and complex concurrency patterns. On the other hand, the behavior of system features (e.g., operating systems) and the external world (e.g., communication between components) is usually specified using first-order formalisms. In principle, the soundness theorem of a separation logic is its interface with first-order theorems, but the soundness theorem may implicitly make assumptions about how other components are specified, limiting its use. In this paper, we show how to extend the higher-order separation logic of the Verified Software Toolchain to interface with a first-order verified operating system, in this case CertiKOS, that mediates its interaction with the outside world. The resulting system allows us to prove the correctness of C programs in separation logic based on the semantics of system calls implemented in CertiKOS. It also demonstrates that the combination of interaction trees + CompCert memories serves well as a lingua franca to interface and compose two quite different styles of program verification.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "William", + "last_name": "Mansky", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Wolf", + "last_name": "Honoré", + "institution": "Yale University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/esop/ManskyHA20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_5", + "title": "Optimal and Perfectly Parallel Algorithms for On-demand Data-Flow Analysis", + "abstract": "Abstract Interprocedural data-flow analyses form an expressive and useful paradigm of numerous static analysis applications, such as live variables analysis, alias analysis and null pointers analysis. The most widely-used framework for interprocedural data-flow analysis is IFDS , which encompasses distributive data-flow functions over a finite domain. On-demand data-flow analyses restrict the focus of the analysis on specific program locations and data facts. This setting provides a natural split between (i) an offline (or preprocessing) phase , where the program is partially analyzed and analysis summaries are created, and (ii) an online (or query) phase , where analysis queries arrive on demand and the summaries are used to speed up answering queries. In this work, we consider on-demand IFDS analyses where the queries concern program locations of the same procedure (aka same-context queries). We exploit the fact that flow graphs of programs have low treewidth to develop faster algorithms that are space and time optimal for many common data-flow analyses, in both the preprocessing and the query phase. We also use treewidth to develop query solutions that are embarrassingly parallelizable , i.e. the total work for answering each query is split to a number of threads such that each thread performs only a constant amount of work. Finally, we implement a static analyzer based on our algorithms, and perform a series of on-demand analysis experiments on standard benchmarks. Our experimental results show a drastic speed-up of the queries after only a lightweight preprocessing phase, which significantly outperforms existing techniques.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Amir Kafshdar", + "last_name": "Goharshady", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Rasmus", + "last_name": "Ibsen-Jensen", + "institution": "University of Liverpool" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/esop/ChatterjeeGIP20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_1", + "title": "Trace-Relating Compiler Correctness and Secure Compilation", + "abstract": "Abstract Compiler correctness is, in its simplest form, defined as the inclusion of the set of traces of the compiled program into the set of traces of the original program, which is equivalent to the preservation of all trace properties. Here traces collect, for instance, the externally observable events of each execution. This definition requires, however, the set of traces of the source and target languages to be exactly the same, which is not the case when the languages are far apart or when observations are fine-grained. To overcome this issue, we study a generalized compiler correctness definition, which uses source and target traces drawn from potentially different sets and connected by an arbitrary relation. We set out to understand what guarantees this generalized compiler correctness definition gives us when instantiated with a non-trivial relation on traces. When this trace relation is not equality, it is no longer possible to preserve the trace properties of the source program unchanged. Instead, we provide a generic characterization of the target trace property ensured by correctly compiling a program that satisfies a given source property, and dually, of the source trace property one is required to show in order to obtain a certain target property for the compiled code. We show that this view on compiler correctness can naturally account for undefined behavior, resource exhaustion, different source and target values, side-channels, and various abstraction mismatches. Finally, we show that the same generalization also applies to many secure compilation definitions, which characterize the protection of a compiled program against linked adversarial code.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Carmine", + "last_name": "Abate", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Roberto", + "last_name": "Blanco", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Ştefan", + "last_name": "Ciobâcă", + "institution": "" + }, + { + "first_name": "Adrien", + "last_name": "Durier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "Stanford University" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + }, + { + "first_name": "Jérémy", + "last_name": "Thibault", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/esop/AbateBCD0HPTT20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_13", + "title": "Aneris: A Mechanised Logic for Modular Reasoning about Distributed Systems", + "abstract": "Abstract Building network-connected programs and distributed systems is a powerful way to provide scalability and availability in a digital, always-connected era. However, with great power comes great complexity. Reasoning about distributed systems is well-known to be difficult. In this paper we present , a novel framework based on separation logic supporting modular, node-local reasoning about concurrent and distributed systems. The logic is higher-order, concurrent, with higher-order store and network sockets, and is fully mechanized in the Coq proof assistant. We use our framework to verify an implementation of a load balancer that uses multi-threading to distribute load amongst multiple servers and an implementation of the two-phase-commit protocol with a replicated logging service as a client. The two examples certify that is well-suited for both horizontal and vertical modular reasoning.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Morten", + "last_name": "Krogh-Jespersen", + "institution": "Aarhus University" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Marit Edna", + "last_name": "Ohlenbusch", + "institution": "Aarhus University" + }, + { + "first_name": "Simon Oddershede", + "last_name": "Gregersen", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/esop/Krogh-Jespersen20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_7", + "title": "Soundness Conditions for Big-Step Semantics", + "abstract": "Abstract We propose a general proof technique to show that a predicate is sound , that is, prevents stuck computation, with respect to a big-step semantics . This result may look surprising, since in big-step semantics there is no difference between non-terminating and stuck computations, hence soundness cannot even be expressed . The key idea is to define constructions yielding an extended version of a given arbitrary big-step semantics, where the difference is made explicit. The extended semantics are exploited in the meta-theory, notably they are necessary to show that the proof technique works. However, they remain transparent when using the proof technique, since it consists in checking three conditions on the original rules only, as we illustrate by several examples.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Francesco", + "last_name": "Dagnino", + "institution": "University of Genoa" + }, + { + "first_name": "Viviana", + "last_name": "Bono", + "institution": "University of Turin" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + }, + { + "first_name": "Mariangiola", + "last_name": "Dezani-Ciancaglini", + "institution": "University of Turin" + } + ], + "dblp_key": "conf/esop/DagninoBZD20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_8", + "title": "Liberate Abstract Garbage Collection from the Stack by Decomposing the Heap", + "abstract": "Abstract Abstract garbage collection and the use of pushdown systems each enhance the precision of control-flow analysis (CFA). However, their respective needs conflict: abstract garbage collection requires the stack but pushdown systems obscure it. Though several existing techniques address this conflict, none take full advantage of the underlying interplay. In this paper, we dissolve this conflict with a technique which exploits the precision of pushdown systems to decompose the heap across the continuation.This technique liberates abstract garbage collection from the stack, increasing its effectiveness and the compositionality of its host analysis. We generalize our approach to apply compositional treatment to abstract timestamps which induces the context abstraction of m -CFA, an abstraction more precise than k -CFA’s for many common programming patterns.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Kimball", + "last_name": "Germane", + "institution": "Brigham Young University" + }, + { + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/esop/Germane020", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_10", + "title": "Exploring Type-Level Bisimilarity towards More Expressive Multiparty Session Types", + "abstract": "Abstract A key open problem with multiparty session types (MPST) concerns their expressiveness: current MPST have inflexible choice, no existential quantification over participants, and limited parallel composition. This precludes many real protocols to be represented by MPST. To overcome these bottlenecks of MPST, we explore a new technique using weak bisimilarity between global types and endpoint types, which guarantees deadlock-freedom and absence of protocol violations. Based on a process algebraic framework, we present well-formed conditions for global types that guarantee weak bisimilarity between a global type and its endpoint types and prove their check is decidable. Our main practical result, obtained through benchmarks, is that our well-formedness conditions can be checked orders of magnitude faster than directly checking weak bisimilarity using a state-of-the-art model checker.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sung-Shik", + "last_name": "Jongmans", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/esop/JongmansY20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_15", + "title": "Semantic Foundations for Deterministic Dataflow and Stream Processing", + "abstract": "Abstract We propose a denotational semantic framework for deterministic dataflow and stream processing that encompasses a variety of existing streaming models. Our proposal is based on the idea that data streams, stream transformations, and stream-processing programs should be classified using types. The type of a data stream is captured formally by a monoid, an algebraic structure with a distinguished binary operation and a unit. The elements of a monoid model the finite fragments of a stream, the binary operation represents the concatenation of stream fragments, and the unit is the empty fragment. Stream transformations are modeled using monotone functions on streams, which we call stream transductions. These functions can be implemented using abstract machines with a potentially infinite state space, which we call stream transducers. This abstract typed framework of stream transductions and transducers can be used to (1) verify the correctness of streaming computations, that is, that an implementation adheres to the desired behavior, (2) prove the soundness of optimizing transformations, e.g. for parallelization and distribution, and (3) inform the design of programming models and query languages for stream processing. In particular, we show that several useful combinators can be supported by the full class of stream transductions and transducers: serial composition, parallel composition, and feedback composition.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Konstantinos", + "last_name": "Mamouras", + "institution": "Rice University" + } + ], + "dblp_key": "conf/esop/Mamouras20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_14", + "title": "Continualization of Probabilistic Programs With Correction", + "abstract": "Abstract Probabilistic Programming offers a concise way to represent stochastic models and perform automated statistical inference. However, many real-world models have discrete or hybrid discrete-continuous distributions, for which existing tools may suffer non-trivial limitations. Inference and parameter estimation can be exceedingly slow for these models because many inference algorithms compute results faster (or exclusively) when the distributions being inferred are continuous. To address this discrepancy, this paper presents Leios. Leios is the first approach for systematically approximating arbitrary probabilistic programs that have discrete, or hybrid discrete-continuous random variables. The approximate programs have all their variables fully continualized. We show that once we have the fully continuous approximate program, we can perform inference and parameter estimation faster by exploiting the existing support that many languages offer for continuous distributions. Furthermore, we show that the estimates obtained when performing inference and parameter estimation on the continuous approximation are still comparably close to both the true parameter values and the estimates obtained when performing inference on the original model.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Laurel", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Saša", + "last_name": "Misailovíc", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/esop/LaurelM20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_17", + "title": "Modular Inference of Linear Types for Multiplicity-Annotated Arrows", + "abstract": "Abstract Bernardy et al. [2018] proposed a linear type system $$\\lambda ^q_\\rightarrow $$ λ → q as a core type system of Linear Haskell. In the system, linearity is represented by annotated arrow types $$A \\rightarrow _m B$$ A → m B , where m denotes the multiplicity of the argument. Thanks to this representation, existing non-linear code typechecks as it is, and newly written linear code can be used with existing non-linear code in many cases. However, little is known about the type inference of $$\\lambda ^q_\\rightarrow $$ λ → q . Although the Linear Haskell implementation is equipped with type inference, its algorithm has not been formalized, and the implementation often fails to infer principal types, especially for higher-order functions. In this paper, based on OutsideIn(X) [Vytiniotis et al., 2011], we propose an inference system for a rank 1 qualified-typed variant of $$\\lambda ^q_\\rightarrow $$ λ → q , which infers principal types. A technical challenge in this new setting is to deal with ambiguous types inferred by naive qualified typing. We address this ambiguity issue through quantifier elimination and demonstrate the effectiveness of the approach with examples.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_17", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + } + ], + "dblp_key": "conf/esop/Matsuda20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_19", + "title": "A First-Order Logic with Frames", + "abstract": "Abstract We propose a novel logic, called Frame Logic (FL), that extends first-order logic (with recursive definitions) using a construct $$\\textit{Sp}(\\cdot )$$ Sp ( · ) that captures the implicit supports of formulas— the precise subset of the universe upon which their meaning depends. Using such supports, we formulate proof rules that facilitate frame reasoning elegantly when the underlying model undergoes change. We show that the logic is expressive by capturing several data-structures and also exhibit a translation from a precise fragment of separation logic to frame logic. Finally, we design a program logic based on frame logic for reasoning with programs that dynamically update heaps that facilitates local specifications and frame reasoning. This program logic consists of both localized proof rules as well as rules that derive the weakest tightest preconditions in FL.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_19", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Lucas", + "last_name": "Peña", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Christof", + "last_name": "Löding", + "institution": "RWTH Aachen University" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/esop/MuraliPLM20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_20", + "title": "Proving the Safety of Highly-Available Distributed Objects", + "abstract": "Abstract To provide high availability in distributed systems, object replicas allow concurrent updates. Although replicas eventually converge, they may diverge temporarily, for instance when the network fails. This makes it difficult for the developer to reason about the object’s properties, and in particular, to prove invariants over its state. For the subclass of state-based distributed systems, we propose a proof methodology for establishing that a given object maintains a given invariant, taking into account any concurrency control. Our approach allows reasoning about individual operations separately. We demonstrate that our rules are sound, and we illustrate their use with some representative examples. We automate the rule using Boogie, an SMT-based tool.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_20", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sreeja", + "last_name": "Nair", + "institution": "Sorbonne Université" + }, + { + "first_name": "Gustavo", + "last_name": "Petri", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Marc", + "last_name": "Shapiro", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "conf/esop/NairP020", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_25", + "title": "ConSORT: Context- and Flow-Sensitive Ownership Refinement Types for Imperative Programs", + "abstract": "Abstract We present ConSORT, a type system for safety verification in the presence of mutability and aliasing. Mutability requires strong updates to model changing invariants during program execution, but aliasing between pointers makes it difficult to determine which invariants must be updated in response to mutation. Our type system addresses this difficulty with a novel combination of refinement types and fractional ownership types. Fractional ownership types provide flow-sensitive and precise aliasing information for reference variables. ConSORT interprets this ownership information to soundly handle strong updates of potentially aliased references. We have proved ConSORT sound and implemented a prototype, fully automated inference tool. We evaluated our tool and found it verifies non-trivial programs including data structure implementations.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_25", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "John", + "last_name": "Toman", + "institution": "Kyoto University" + }, + { + "first_name": "Ren", + "last_name": "Siqi", + "institution": "Kyoto University" + }, + { + "first_name": "Kohei", + "last_name": "Suenaga", + "institution": "Kyoto University" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/esop/TomanSSI020", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_18", + "title": "RustHorn: CHC-Based Verification for Rust Programs", + "abstract": "Abstract Reduction to the satisfiablility problem for constrained Horn clauses (CHCs) is a widely studied approach to automated program verification. The current CHC-based methods for pointer-manipulating programs, however, are not very scalable. This paper proposes a novel translation of pointer-manipulating Rust programs into CHCs, which clears away pointers and heaps by leveraging ownership. We formalize the translation for a simplified core of Rust and prove its correctness. We have implemented a prototype verifier for a subset of Rust and confirmed the effectiveness of our method.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_18", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Yusuke", + "last_name": "Matsushita", + "institution": "The University of Tokyo" + }, + { + "first_name": "Takeshi", + "last_name": "Tsukada", + "institution": "The University of Tokyo" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/esop/0002T020", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_22", + "title": "Modular Relaxed Dependencies in Weak Memory Concurrency", + "abstract": "Abstract We present a denotational semantics for weak memory concurrency that avoids thin-air reads , provides data-race free programs with sequentially consistent semantics (DRF-SC), and supports a compositional refinement relation for validating optimisations. Our semantics identifies false program dependencies that might be removed by compiler optimisation, and leaves in place just the dependencies necessary to rule out thin-air reads. We show that our dependency calculation can be used to rule out thin-air reads in any axiomatic concurrency model, in particular C++. We present a tool that automatically evaluates litmus tests, show that we can augment C++ to fix the thin-air problem, and we prove that our augmentation is compatible with the previously used compilation mappings over key processor architectures. We argue that our dependency calculation offers a practical route to fixing the longstanding problem of thin-air reads in the C++ specification.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_22", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Marco", + "last_name": "Paviotti", + "institution": "Imperial College London" + }, + { + "first_name": "Simon", + "last_name": "Cooksey", + "institution": "University of Kent" + }, + { + "first_name": "Anouk", + "last_name": "Paradis", + "institution": "ETH Zurich" + }, + { + "first_name": "Daniel", + "last_name": "Wright", + "institution": "University of Kent" + }, + { + "first_name": "Scott", + "last_name": "Owens", + "institution": "University of Kent" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/esop/PaviottiCPWOB20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_24", + "title": "Higher-Ranked Annotation Polymorphic Dependency Analysis", + "abstract": "Abstract The precision of a static analysis can be improved by increasing the context-sensitivity of the analysis. In a type-based formulation of static analysis for functional languages this can be achieved by, e.g., introducing let-polyvariance or subtyping. In this paper we go one step further by defining a higher-ranked polyvariant type system so that even properties of lambda-bound identifiers can be generalized over. We do this for dependency analysis, a generic analysis that can be instantiated to a range of different analyses that in this way all can profit. We prove that our analysis is sound with respect to a call-by-name semantics and that it satisfies a so-called noninterference property. We provide a type reconstruction algorithm that we have proven to be terminating, and sound and complete with respect to its declarative specification. Our principled description can serve as a blueprint for making other analyses higher-ranked.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_24", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Fabian", + "last_name": "Thorand", + "institution": "Utrecht University" + }, + { + "first_name": "Jurriaan", + "last_name": "Hage", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/esop/ThorandH20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_23", + "title": "ARMv8-A System Semantics: Instruction Fetch in Relaxed Architectures", + "abstract": "Abstract Computing relies on architecture specifications to decouple hardware and software development. Historically these have been prose documents, with all the problems that entails, but research over the last ten years has developed rigorous and executable-as-test-oracle specifications of mainstream architecture instruction sets and “user-mode” concurrency, clarifying architectures and bringing them into the scope of programming-language semantics and verification. However, the system semantics , of instruction-fetch and cache maintenance, exceptions and interrupts, and address translation, remains obscure, leaving us without a solid foundation for verification of security-critical systems software. In this paper we establish a robust model for one aspect of system semantics: instruction fetch and cache maintenance for ARMv8-A. Systems code relies on executing instructions that were written by data writes, e.g. in program loading, dynamic linking, JIT compilation, debugging, and OS configuration, but hardware implementations are often highly optimised, e.g. with instruction caches, linefill buffers, out-of-order fetching, branch prediction, and instruction prefetching, which can affect programmer-observable behaviour. It is essential, both for programming and verification, to abstract from such microarchitectural details as much as possible, but no more. We explore the key architecture design questions with a series of examples, discussed in detail with senior Arm staff; capture the architectural intent in operational and axiomatic semantic models, extending previous work on “user-mode” concurrency; make these models executable as test oracles for small examples; and experimentally validate them against hardware behaviour (finding a bug in one hardware device). We thereby bring these subtle issues into the mathematical domain, clarifying the architecture and enabling future work on system software verification.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_23", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ben", + "last_name": "Simner", + "institution": "University of Cambridge" + }, + { + "first_name": "Shaked", + "last_name": "Flur", + "institution": "University of Cambridge" + }, + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Alasdair", + "last_name": "Armstrong", + "institution": "University of Cambridge" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "University of Cambridge" + }, + { + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/esop/SimnerFPAPMS20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_21", + "title": "Solving Program Sketches with Large Integer Values", + "abstract": "Abstract Program sketching is a program synthesis paradigm in which the programmer provides a partial program with holes and assertions. The goal of the synthesizer is to automatically find integer values for the holes so that the resulting program satisfies the assertions. The most popular sketching tool, Sketch , can efficiently solve complex program sketches, but uses an integer encoding that often performs poorly if the sketched program manipulates large integer values. In this paper, we propose a new solving technique that allows Sketch to handle large integer values while retaining its integer encoding. Our technique uses a result from number theory, the Chinese Remainder Theorem, to rewrite program sketches to only track the remainders of certain variable values with respect to several prime numbers. We prove that our transformation is sound and the encoding of the resulting programs are exponentially more succinct than existing Sketch encodings. We evaluate our technique on a variety of benchmarks manipulating large integer values. Our technique provides speedups against both existing Sketch solvers and can solve benchmarks that existing Sketch solvers cannot handle.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_21", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Rong", + "last_name": "Pan", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Qinheping", + "last_name": "Hu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Google (United States)" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" + } + ], + "dblp_key": "conf/esop/PanHSD20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_27", + "title": "Higher-Order Spreadsheets with Spilled Arrays", + "abstract": "Abstract We develop a theory for two recently-proposed spreadsheet mechanisms: gridlets allow for abstraction and reuse in spreadsheets, and build on spilled arrays , where an array value spills out of one cell into nearby cells. We present the first formal calculus of spreadsheets with spilled arrays. Since spilled arrays may collide, the semantics of spilling is an iterative process to determine which arrays spill successfully and which do not. Our first theorem is that this process converges deterministically. To model gridlets, we propose the grid calculus , a higher-order extension of our calculus of spilled arrays with primitives to treat spreadsheets as values. We define a semantics of gridlets as formulas in the grid calculus. Our second theorem shows the correctness of a remarkably direct encoding of the Abadi and Cardelli object calculus into the grid calculus. This result is the first rigorous analogy between spreadsheets and objects; it substantiates the intuition that gridlets are an object-oriented counterpart to functional programming extensions to spreadsheets, such as sheet-defined functions.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_27", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jack M.", + "last_name": "Williams", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Nima", + "last_name": "Joharizadeh", + "institution": "University of California, Davis" + }, + { + "first_name": "Andrew D.", + "last_name": "Gordon", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Advait", + "last_name": "Sarkar", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/esop/WilliamsJGS20", + "venue": "esop", + "year": 2020 + }, + { + "paper_id": "10.1007/978-3-030-44914-8_26", + "title": "Mixed Sessions", + "abstract": "Abstract Session types describe patterns of interaction on communicating channels. Traditional session types include a form of choice whereby servers offer a collection of options, of which each client picks exactly one. This sort of choice constitutes a particular case of separated choice: offering on one side, selecting on the other. We introduce mixed choices in the context of session types and argue that they increase the flexibility of program development at the same time that they reduce the number of synchronisation primitives to exactly one. We present a type system incorporating subtyping and prove preservation and absence of runtime errors for well-typed processes. We further show that classical (conventional) sessions can be faithfully and tightly embedded in mixed choices. Finally, we discuss algorithmic type checking and a runtime system built on top of a conventional (choice-less) message-passing architecture.", + "date": "2020-01-01", + "link": "https://doi.org/10.1007/978-3-030-44914-8_26", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + }, + { + "first_name": "Filipe", + "last_name": "Casal", + "institution": "University of Lisbon" + }, + { + "first_name": "Bernardo Pinto de", + "last_name": "Almeida", + "institution": "University of Lisbon" + }, + { + "first_name": "Andreia", + "last_name": "Mordido", + "institution": "University of Lisbon" + } + ], + "dblp_key": "conf/esop/VasconcelosCAM20", + "venue": "esop", + "year": 2020 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2021.json b/data/pl_conferences/esop/2021.json new file mode 100644 index 0000000..1ad96c1 --- /dev/null +++ b/data/pl_conferences/esop/2021.json @@ -0,0 +1,664 @@ +[ + { + "paper_id": "10.1007/978-3-030-72019-3_2", + "title": "Data Flow Analysis of Asynchronous Systems using Infinite Abstract Domains", + "abstract": "Abstract Asynchronous message-passing systems are employed frequently to implement distributed mechanisms, protocols, and processes. This paper addresses the problem of precise data flow analysis for such systems. To obtain good precision, data flow analysis needs to somehow skip execution paths that read more messages than the number of messages sent so far in the path, as such paths are infeasible at run time. Existing data flow analysis techniques do elide a subset of such infeasible paths, but have the restriction that they admit only finite abstract analysis domains. In this paper we propose a generalization of these approaches to admit infinite abstract analysis domains, as such domains are commonly used in practice to obtain high precision. We have implemented our approach, and have analyzed its performance on a set of 14 benchmarks. On these benchmarks our tool obtains significantly higher precision compared to a baseline approach that does not elide any infeasible paths and to another baseline that elides infeasible paths but admits only finite abstract domains.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Snigdha", + "last_name": "Athaiya", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Raghavan", + "last_name": "Komondoor", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "K. Narayan", + "last_name": "Kumar", + "institution": "Chennai Mathematical Institute" + } + ], + "dblp_key": "conf/esop/AthaiyaKK21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_8", + "title": "Coupled Relational Symbolic Execution for Differential Privacy", + "abstract": "Abstract Differential privacy is a de facto standard in data privacy with applications in the private and public sectors. Most of the techniques that achieve differential privacy are based on a judicious use of randomness. However, reasoning about randomized programs is difficult and error prone. For this reason, several techniques have been recently proposed to support designer in proving programs differentially private or in finding violations to it. In this work we propose a technique based on symbolic execution for reasoning about differential privacy. Symbolic execution is a classic technique used for testing, counterexample generation and to prove absence of bugs. Here we use symbolic execution to support these tasks specifically for differential privacy. To achieve this goal, we design a relational symbolic execution technique which supports reasoning about probabilistic coupling, a formal notion that has been shown useful to structure proofs of differential privacy. We show how our technique can be used to both verify and find violations to differential privacy.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Gian Pietro", + "last_name": "Farina", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Stephen", + "last_name": "Chong", + "institution": "Harvard University Press" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "" + } + ], + "dblp_key": "conf/esop/FarinaCG21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_12", + "title": "Run-time Complexity Bounds Using Squeezers", + "abstract": "Abstract Determining upper bounds on the time complexity of a program is a fundamental problem with a variety of applications, such as performance debugging, resource certification, and compile-time optimizations. Automated techniques for cost analysis excel at bounding the resource complexity of programs that use integer values and linear arithmetic. Unfortunately, they fall short when execution traces become more involved, esp. when data dependencies may affect the termination conditions of loops. In such cases, state-of-the-art analyzers have shown to produce loose bounds, or even no bound at all. We propose a novel technique that generalizes the common notion of recurrence relations based on ranking functions. Existing methods usually unfold one loop iteration, and examine the resulting relations between variables. These relations assist in establishing a recurrence that bounds the number of loop iterations. We propose a different approach, where we derive recurrences by comparing whole traces with whole traces of a lower rank, avoiding the need to analyze the complexity of intermediate states. We offer a set of global properties, defined with respect to whole traces, that facilitate such a comparison, and show that these properties can be checked efficiently using a handful of local conditions. To this end, we adapt state squeezers , an induction mechanism previously used for verifying safety properties. We demonstrate that this technique encompasses the reasoning power of bounded unfolding, and more. We present some seemingly innocuous, yet intricate, examples where previous tools based on cost relations and control flow analysis fail to solve, and that our squeezer-powered approach succeeds.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Oren", + "last_name": "Ish-Shalom", + "institution": "Tel Aviv University" + }, + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/esop/Ish-ShalomIRS21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_7", + "title": "Nested Session Types", + "abstract": "Abstract Session types statically describe communication protocols between concurrent message-passing processes. Unfortunately, parametric polymorphism even in its restricted prenex form is not fully understood in the context of session types. In this paper, we present the metatheory of session types extended with prenex polymorphism and, as a result, nested recursive datatypes. Remarkably, we prove that type equality is decidable by exhibiting a reduction to trace equivalence of deterministic first-order grammars. Recognizing the high theoretical complexity of the latter, we also propose a novel type equality algorithm and prove its soundness. We observe that the algorithm is surprisingly efficient and, despite its incompleteness, sufficient for all our examples. We have implemented our ideas by extending the Rast programming language with nested session types. We conclude with several examples illustrating the expressivity of our enhanced type system.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ankush", + "last_name": "Das", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Henry", + "last_name": "DeYoung", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Andreia", + "last_name": "Mordido", + "institution": "University of Lisbon" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/esop/DasDMP21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_5", + "title": "Verified Software Units", + "abstract": "Abstract Modularity - the partitioning of software into units of functionality that interact with each other via interfaces - has been the mainstay of software development for half a century. In case of the C language, the main mechanism for modularity is the compilation unit / header file abstraction. This paper complements programmatic modularity for C with modularity idioms for specification and verification in the context of Verifiable C, an expressive separation logic for CompCert . Technical innovations include (i) abstract predicate declarations – existential packages that combine Parkinson & Bierman’s abstract predicates with their client-visible reasoning principles; (ii) residual predicates, which help enforcing data abstraction in callback-rich code; and (iii) an application to pure (Smalltalk-style) objects that connects code verification to model-level reasoning about features such as subtyping, self , inheritance, and late binding. We introduce our techniques using concrete example modules that have all been verified using the Coq proof assistant and combine to fully linked verified programs using a novel, abstraction-respecting component composition rule for Verifiable C.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Lennart", + "last_name": "Beringer", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/esop/Beringer21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_3", + "title": "Types for Complexity of Parallel Computation in Pi-Calculus", + "abstract": "Abstract Type systems as a technique to analyse or control programs have been extensively studied for functional programming languages. In particular some systems allow to extract from a typing derivation a complexity bound on the program. We explore how to extend such results to parallel complexity in the setting of the pi-calculus, considered as a communication-based model for parallel computation. Two notions of time complexity are given: the total computation time without parallelism (the work) and the computation time under maximal parallelism (the span). We define operational semantics to capture those two notions, and present two type systems from which one can extract a complexity bound on a process. The type systems are inspired both by size types and by input/output types, with additional temporal information about communications.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Baillot", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Alexis", + "last_name": "Ghyselen", + "institution": "École Normale Supérieure de Lyon" + } + ], + "dblp_key": "conf/esop/BaillotG21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_11", + "title": "For a Few Dollars More - Verified Fine-Grained Algorithm Analysis Down to LLVM", + "abstract": "Abstract We present a framework to verify both, functional correctness and worst-case complexity of practically efficient algorithms. We implemented a stepwise refinement approach, using the novel concept of resource currencies to naturally structure the resource analysis along the refinement chain, and allow a fine-grained analysis of operation counts. Our framework targets the LLVM intermediate representation. We extend its semantics from earlier work with a cost model. As case study, we verify the correctness and $$O(n\\log n)$$ O ( n log n ) worst-case complexity of an implementation of the introsort algorithm, whose performance is on par with the state-of-the-art implementation found in the GNU C++ Library.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Maximilian P. L.", + "last_name": "Haslbeck", + "institution": "Technical University of Munich" + }, + { + "first_name": "Peter", + "last_name": "Lammich", + "institution": "University of Manchester" + } + ], + "dblp_key": "conf/esop/HaslbeckL21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_4", + "title": "Checking Robustness Between Weak Transactional Consistency Models", + "abstract": "Abstract Concurrent accesses to databases are typically encapsulated in transactions in order to enable isolation from other concurrent computations and resilience to failures. Modern databases provide transactions with various semantics corresponding to different trade-offs between consistency and availability. Since a weaker consistency model provides better performance, an important issue is investigating the weakest level of consistency needed by a given program (to satisfy its specification). As a way of dealing with this issue, we investigate the problem of checking whether a given program has the same set of behaviors when replacing a consistency model with a weaker one. This property known as robustness generally implies that any specification of the program is preserved when weakening the consistency. We focus on the robustness problem for consistency models which are weaker than standard serializability, namely, causal consistency, prefix consistency, and snapshot isolation. We show that checking robustness between these models is polynomial time reducible to a state reachability problem under serializability. We use this reduction to also derive a pragmatic proof technique based on Lipton’s reduction theory that allows to prove programs robust. We have applied our techniques to several challenging applications drawn from the literature of distributed systems and databases.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sidi Mohamed", + "last_name": "Beillahi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/esop/BeillahiBE21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_13", + "title": "Complete trace models of state and control", + "abstract": "Abstract We consider a hierarchy of four typed call-by-value languages with either higher-order or ground-type references and with either $$\\mathrm {call/cc}$$ call / cc or no control operator. Our first result is a fully abstract trace model for the most expressive setting, featuring both higher-order references and $$\\mathrm {call/cc}$$ call / cc , constructed in the spirit of operational game semantics. Next we examine the impact of suppressing higher-order references and callcc in contexts and provide an operational explanation for the game-semantic conditions known as visibility and bracketing respectively. This allows us to refine the original model to provide fully abstract trace models of interaction with contexts that need not use higher-order references or $$\\mathrm {call/cc}$$ call / cc . Along the way, we discuss the relationship between error- and termination-based contextual testing in each case, and relate the two to trace and complete trace equivalence respectively. Overall, the paper provides a systematic development of operational game semantics for all four cases, which represent the state-based face of the so-called semantic cube.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Guilhem", + "last_name": "Jaber", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Andrzej S.", + "last_name": "Murawski", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/esop/JaberM21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_6", + "title": "An Automated Deductive Verification Framework for Circuit-building Quantum Programs", + "abstract": "Abstract While recent progress in quantum hardware open the door for significant speedup in certain key areas, quantum algorithms are still hard to implement right, and the validation of such quantum programs is a challenge. In this paper we propose Qbricks , a formal verification environment for circuit-building quantum programs, featuring both parametric specifications and a high degree of proof automation. We propose a logical framework based on first-order logic, and develop the main tool we rely upon for achieving the automation of proofs of quantum specification: PPS, a parametric extension of the recently developed path sum semantics. To back-up our claims, we implement and verify parametric versions of several famous and non-trivial quantum algorithms, including the quantum parts of Shor’s integer factoring , quantum phase estimation (QPE) and Grover’s search.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Christophe", + "last_name": "Chareton", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Sébastien", + "last_name": "Bardin", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "François", + "last_name": "Bobot", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Valentin", + "last_name": "Perrelle", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Benoît", + "last_name": "Valiron", + "institution": "Université Paris-Saclay" + } + ], + "dblp_key": "conf/esop/CharetonBBPV21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_9", + "title": "Graded Hoare Logic and its Categorical Semantics", + "abstract": "Abstract Deductive verification techniques based on program logics (i.e., the family of Floyd-Hoare logics) are a powerful approach for program reasoning. Recently, there has been a trend of increasing the expressive power of such logics by augmenting their rules with additional information to reason about program side-effects. For example, general program logics have been augmented with cost analyses, logics for probabilistic computations have been augmented with estimate measures, and logics for differential privacy with indistinguishability bounds. In this work, we unify these various approaches via the paradigm of grading , adapted from the world of functional calculi and semantics. We propose Graded Hoare Logic (GHL), a parameterisable framework for augmenting program logics with a preordered monoidal analysis. We develop a semantic framework for modelling GHL such that grading, logical assertions (pre- and post-conditions) and the underlying effectful semantics of an imperative language can be integrated together. Central to our framework is the notion of a graded category which we extend here, introducing graded Freyd categories which provide a semantics that can interpret many examples of augmented program logics from the literature. We leverage coherent fibrations to model the base assertion language, and thus the overall setting is also fibrational.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "" + }, + { + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + }, + { + "first_name": "Tetsuya", + "last_name": "Sato", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "conf/esop/GaboardiKOS21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_14", + "title": "Session Coalgebras: A Coalgebraic View on Session Types and Communication Protocols", + "abstract": "Abstract Compositional methods are central to the development and verification of software systems. They allow breaking down large systems into smaller components, while enabling reasoning about the behaviour of the composed system. For concurrent and communicating systems, compositional techniques based on behavioural type systems have received much attention. By abstracting communication protocols as types, these type systems can statically check that programs interact with channels according to a certain protocol, whether the intended messages are exchanged in a certain order. In this paper, we put on our coalgebraic spectacles to investigate session types , a widely studied class of behavioural type systems. We provide a syntax-free description of session-based concurrency as states of coalgebras. As a result, we rediscover type equivalence, duality, and subtyping relations in terms of canonical coinductive presentations. In turn, this coinductive presentation makes it possible to elegantly derive a decidable type system with subtyping for $$\\pi $$ π -calculus processes, in which the states of a coalgebra will serve as channel protocols. Going full circle, we exhibit a coalgebra structure on an existing session type system, and show that the relations and type system resulting from our coalgebraic perspective agree with the existing ones.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Alex C.", + "last_name": "Keizer", + "institution": "University of Amsterdam" + }, + { + "first_name": "Henning", + "last_name": "Basold", + "institution": "Leiden University" + }, + { + "first_name": "Jorge A.", + "last_name": "Pérez", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/esop/KeizerB021", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_16", + "title": "Densities of Almost Surely Terminating Probabilistic Programs are Differentiable Almost Everywhere", + "abstract": "Abstract We study the differential properties of higher-order statistical probabilistic programs with recursion and conditioning. Our starting point is an open problem posed by Hongseok Yang: what class of statistical probabilistic programs have densities that are differentiable almost everywhere? To formalise the problem, we consider Statistical PCF (SPCF), an extension of call-by-value PCF with real numbers, and constructs for sampling and conditioning. We give SPCF a sampling-style operational semantics à la Borgström et al., and study the associated weight (commonly referred to as the density) function and value function on the set of possible execution traces. Our main result is that almost surely terminating SPCF programs, generated from a set of primitive functions (e.g. the set of analytic functions) satisfying mild closure properties, have weight and value functions that are almost everywhere differentiable. We use a stochastic form of symbolic execution to reason about almost everywhere differentiability. A by-product of this work is that almost surely terminating deterministic (S)PCF programs with real parameters denote functions that are almost everywhere differentiable. Our result is of practical interest, as almost everywhere differentiability of the density function is required to hold for the correctness of major gradient-based inference algorithms.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Carol", + "last_name": "Mak", + "institution": "University of Oxford" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + }, + { + "first_name": "Hugo", + "last_name": "Paquet", + "institution": "University of Oxford" + }, + { + "first_name": "Dominik", + "last_name": "Wagner", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/esop/MakOPW21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_15", + "title": "Correctness of Sequential Monte Carlo Inference for Probabilistic Programming Languages", + "abstract": "Abstract Probabilistic programming is an approach to reasoning under uncertainty by encoding inference problems as programs. In order to solve these inference problems, probabilistic programming languages (PPLs) employ different inference algorithms, such as sequential Monte Carlo (SMC), Markov chain Monte Carlo (MCMC), or variational methods. Existing research on such algorithms mainly concerns their implementation and efficiency, rather than the correctness of the algorithms themselves when applied in the context of expressive PPLs. To remedy this, we give a correctness proof for SMC methods in the context of an expressive PPL calculus, representative of popular PPLs such as WebPPL, Anglican, and Birch. Previous work have studied correctness of MCMC using an operational semantics, and correctness of SMC and MCMC in a denotational setting without term recursion. However, for SMC inference—one of the most commonly used algorithms in PPLs as of today—no formal correctness proof exists in an operational setting. In particular, an open question is if the resample locations in a probabilistic program affects the correctness of SMC. We solve this fundamental problem, and make four novel contributions: (i) we extend an untyped PPL lambda calculus and operational semantics to include explicit resample terms, expressing synchronization points in SMC inference; (ii) we prove, for the first time, that subject to mild restrictions, any placement of the explicit resample terms is valid for a generic form of SMC inference; (iii) as a result of (ii), our calculus benefits from classic results from the SMC literature: a law of large numbers and an unbiased estimate of the model evidence; and (iv) we formalize the bootstrap particle filter for the calculus and discuss how our results can be further extended to other SMC algorithms.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Lundén", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Johannes", + "last_name": "Borgström", + "institution": "Uppsala University" + }, + { + "first_name": "David", + "last_name": "Broman", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/esop/LundenBB21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_1", + "title": "The Decidability of Verification under PS 2.0", + "abstract": "Abstract We consider the reachability problem for finite-state multi-threaded programs under the promising semantics () of Lee et al., which captures most common program transformations. Since reachability is already known to be undecidable in the fragment of with only release-acquire accesses (-), we consider the fragment with only relaxed accesses and promises (). We show that reachability under is undecidable in general and that it becomes decidable, albeit non-primitive recursive, if we bound the number of promises. Given these results, we consider a bounded version of the reachability problem. To this end, we bound both the number of promises and of “ view-switches ”, i.e., the number of times the processes may switch their local views of the global memory. We provide a code-to-code translation from an input program under (with relaxed and release-acquire memory accesses along with promises) to a program under SC, thereby reducing the bounded reachability problem under to the bounded context-switching problem under SC. We have implemented a tool and tested it on a set of benchmarks, demonstrating that typical bugs in programs can be found with a small bound.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Adwait", + "last_name": "Godbole", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Shankara Narayanan", + "last_name": "Krishna", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/esop/AbdullaAGKV21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_10", + "title": "Do Judge a Test by its Cover - Combining Combinatorial and Property-Based Testing", + "abstract": "Abstract Property-based testing uses randomly generated inputs to validate high-level program specifications. It can be shockingly effective at finding bugs, but it often requires generating a very large number of inputs to do so. In this paper, we apply ideas from combinatorial testing , a powerful and widely studied testing methodology, to modify the distributions of our random generators so as to find bugs with fewer tests. The key concept is combinatorial coverage , which measures the degree to which a given set of tests exercises every possible choice of values for every small combination of input features. In its “classical” form, combinatorial coverage only applies to programs whose inputs have a very particular shape—essentially, a Cartesian product of finite sets. We generalize combinatorial coverage to the richer world of algebraic data types by formalizing a class of sparse test descriptions based on regular tree expressions. This new definition of coverage inspires a novel combinatorial thinning algorithm for improving the coverage of random test generators, requiring many fewer tests to catch bugs. We evaluate this algorithm on two case studies, a typed evaluator for System F terms and a Haskell compiler, showing significant improvements in both.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Harrison", + "last_name": "Goldstein", + "institution": "University of Pennsylvania" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Quviq (Sweden)" + }, + { + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/esop/GoldsteinHLP21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_17", + "title": "Graded Modal Dependent Type Theory", + "abstract": "Abstract Graded type theories are an emerging paradigm for augmenting the reasoning power of types with parameterizable, fine-grained analyses of program properties. There have been many such theories in recent years which equip a type theory with quantitative dataflow tracking, usually via a semiring-like structure which provides analysis on variables (often called ‘quantitative’ or ‘coeffect’ theories). We present Graded Modal Dependent Type Theory ( Grtt for short), which equips a dependent type theory with a general, parameterizable analysis of the flow of data, both in and between computational terms and types. In this theory, it is possible to study, restrict, and reason about data use in programs and types, enabling, for example, parametric quantifiers and linearity to be captured in a dependent setting. We propose Grtt , study its metatheory, and explore various case studies of its use in reasoning about programs and studying other type theories. We have implemented the theory and highlight the interesting details, including showing an application of grading to optimising the type checking procedure itself.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_17", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Moon", + "institution": "University of Kent" + }, + { + "first_name": "Harley", + "last_name": "Eades", + "institution": "Augusta University" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/esop/MoonEO21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_19", + "title": "Bayesian strategies: probabilistic programs as generalised graphical models", + "abstract": "Abstract We introduce Bayesian strategies , a new interpretation of probabilistic programs in game semantics. This interpretation can be seen as a refinement of Bayesian networks. Bayesian strategies are based on a new form of event structure , with two causal dependency relations respectively modelling control flow and data flow. This gives a graphical representation for probabilistic programs which resembles the concrete representations used in modern implementations of probabilistic programming. From a theoretical viewpoint, Bayesian strategies provide a rich setting for denotational semantics. To demonstrate this we give a model for a general higher-order programming language with recursion, conditional statements, and primitives for sampling from continuous distributions and trace re-weighting. This is significant because Bayesian networks do not easily support higher-order functions or conditionals.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_19", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Hugo", + "last_name": "Paquet", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/esop/Paquet21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_21", + "title": "Query Lifting - Language-integrated query for heterogeneous nested collections", + "abstract": "Abstract Language-integrated query based on comprehension syntax is a powerful technique for safe database programming, and provides a basis for advanced techniques such as query shredding or query flattening that allow efficient programming with complex nested collections. However, the foundations of these techniques are lacking: although SQL, the most widely-used database query language, supports heterogeneous queries that mix set and multiset semantics, these important capabilities are not supported by known correctness results or implementations that assume homogeneous collections. In this paper we study language-integrated query for a heterogeneous query language $$\\mathcal {NRC}_{\\lambda }( Set,Bag )$$ NRC λ ( S e t , B a g ) that combines set and multiset constructs. We show how to normalize and translate queries to SQL, and develop a novel approach to querying heterogeneous nested collections, based on the insight that “local” query subexpressions that calculate nested subcollections can be “lifted” to the top level analogously to lambda-lifting for local function definitions.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_21", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Wilmer", + "last_name": "Ricciotti", + "institution": "University of Edinburgh" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "The Alan Turing Institute" + } + ], + "dblp_key": "conf/esop/RicciottiC21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_23", + "title": "Sound and Complete Concolic Testing for Higher-order Functions", + "abstract": "Abstract Higher-order functions have become a staple of modern programming languages. However, such values stymie concolic testers, as the SMT solvers at their hearts are inherently first-order. This paper lays a formal foundations for concolic testing higher-order functional programs. Three ideas enable our results: (i) our tester considers only program inputs in a canonical form; (ii) it collects novel constraints from the evaluation of the canonical inputs to search the space of inputs with partial help from an SMT solver and (iii) it collects constraints from canonical inputs even when they are arguments to concretized calls. We prove that (i) concolic evaluation is sound with respect to concrete evaluation; (ii) modulo concretization and SMT solver incompleteness, the search for a counter-example succeeds if a user program has a bug and (iii) this search amounts to directed evolution of inputs targeting hard-to-reach corners of the program.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_23", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Shu-Hung", + "last_name": "You", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/esop/YouFD21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_18", + "title": "Automated Termination Analysis of Polynomial Probabilistic Programs", + "abstract": "Abstract The termination behavior of probabilistic programs depends on the outcomes of random assignments. Almost sure termination (AST) is concerned with the question whether a program terminates with probability one on all possible inputs. Positive almost sure termination (PAST) focuses on termination in a finite expected number of steps. This paper presents a fully automated approach to the termination analysis of probabilistic while-programs whose guards and expressions are polynomial expressions. As proving (positive) AST is undecidable in general, existing proof rules typically provide sufficient conditions. These conditions mostly involve constraints on supermartingales. We consider four proof rules from the literature and extend these with generalizations of existing proof rules for (P)AST. We automate the resulting set of proof rules by effectively computing asymptotic bounds on polynomials over the program variables. These bounds are used to decide the sufficient conditions – including the constraints on supermartingales – of a proof rule. Our software tool Amber can thus check AST, PAST, as well as their negations for a large class of polynomial probabilistic programs, while carrying out the termination reasoning fully with polynomial witnesses. Experimental results show the merits of our generalized proof rules and demonstrate that Amber can handle probabilistic programs that are out of reach for other state-of-the-art tools.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_18", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Marcel", + "last_name": "Moosbrugger", + "institution": "TU Wien" + }, + { + "first_name": "Ezio", + "last_name": "Bartocci", + "institution": "TU Wien" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Laura", + "last_name": "Kovács", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/esop/MoosbruggerBKK21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_24", + "title": "Strong-Separation Logic", + "abstract": "Abstract Most automated verifiers for separation logic are based on the symbolic-heap fragment, which disallows both the magic-wand operator and the application of classical Boolean operators to spatial formulas. This is not surprising, as support for the magic wand quickly leads to undecidability, especially when combined with inductive predicates for reasoning about data structures. To circumvent these undecidability results, we propose assigning a more restrictive semantics to the separating conjunction. We argue that the resulting logic, strong-separation logic, can be used for symbolic execution and abductive reasoning just like “standard” separation logic, while remaining decidable even in the presence of both the magic wand and the list-segment predicate—a combination of features that leads to undecidability for the standard semantics.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_24", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jens", + "last_name": "Katelaan", + "institution": "TU Wien" + }, + { + "first_name": "Florian", + "last_name": "Zuleger", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/esop/PagelZ21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_22", + "title": "Reverse AD at Higher Types: Pure, Principled and Denotationally Correct", + "abstract": "Abstract We show how to define forward- and reverse-mode automatic differentiation source-code transformations or on a standard higher-order functional language. The transformations generate purely functional code, and they are principled in the sense that their definition arises from a categorical universal property. We give a semantic proof of correctness of the transformations. In their most elegant formulation, the transformations generate code with linear types. However, we demonstrate how the transformations can be implemented in a standard functional language without sacrificing correctness. To do so, we make use of abstract data types to represent the required linear types, e.g. through the use of a basic module system.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_22", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Matthijs", + "last_name": "Vákár", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/esop/Vakar21", + "venue": "esop", + "year": 2021 + }, + { + "paper_id": "10.1007/978-3-030-72019-3_20", + "title": "Temporal Refinements for Guarded Recursive Types", + "abstract": "Abstract We propose a logic for temporal properties of higher-order programs that handle infinite objects like streams or infinite trees, represented via coinductive types. Specifications of programs use safety and liveness properties. Programs can then be proven to satisfy their specification in a compositional way, our logic being based on a type system. The logic is presented as a refinement type system over the guarded $$\\lambda $$ λ -calculus, a $$\\lambda $$ λ -calculus with guarded recursive types. The refinements are formulae of a modal $$\\mu $$ μ -calculus which embeds usual temporal modal logics such as and . The semantics of our system is given within a rich structure, the topos of trees, in which we build a realizability model of the temporal refinement type system.", + "date": "2021-01-01", + "link": "https://doi.org/10.1007/978-3-030-72019-3_20", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Guilhem", + "last_name": "Jaber", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Colin", + "last_name": "Riba", + "institution": "Université Claude Bernard Lyon 1" + } + ], + "dblp_key": "conf/esop/JaberR21", + "venue": "esop", + "year": 2021 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2022.json b/data/pl_conferences/esop/2022.json new file mode 100644 index 0000000..c46166f --- /dev/null +++ b/data/pl_conferences/esop/2022.json @@ -0,0 +1,705 @@ +[ + { + "paper_id": "10.1007/978-3-030-99336-8_1", + "title": "Categorical Foundations of Gradient-Based Learning", + "abstract": "Abstract We propose a categorical semantics of gradient-based machine learning algorithms in terms of lenses, parametric maps, and reverse derivative categories. This foundation provides a powerful explanatory and unifying framework: it encompasses a variety of gradient descent algorithms such as ADAM, AdaGrad, and Nesterov momentum, as well as a variety of loss functions such as MSE and Softmax cross-entropy, shedding new light on their similarities and differences. Our approach to gradient-based learning has examples generalising beyond the familiar continuous domains (modelled in categories of smooth maps) and can be realized in the discrete setting of boolean circuits. Finally, we demonstrate the practical significance of our framework with an implementation in Python.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "G. S. H.", + "last_name": "Cruttwell", + "institution": "Mount Allison University" + }, + { + "first_name": "Bruno", + "last_name": "Gavranović", + "institution": "University of Strathclyde" + }, + { + "first_name": "Neil", + "last_name": "Ghani", + "institution": "University of Strathclyde" + }, + { + "first_name": "P.", + "last_name": "Wilson", + "institution": "University College London" + }, + { + "first_name": "Fabio", + "last_name": "Zanasi", + "institution": "University College London" + } + ], + "dblp_key": "conf/esop/CruttwellGGWZ22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_16", + "title": "Polarized Subtyping", + "abstract": "Abstract Polarization of types in call-by-push-value naturally leads to the separation of inductively defined observable values (classified by positive types), and coinductively defined computations (classified by negative types), with adjoint modalities mediating between them. Taking this separation as a starting point, we develop a semantic characterization of typing with step indexing to capture observation depth of recursive computations. This semantics justifies a rich set of subtyping rules for an equirecursive variant of call-by-push-value, including variant and lazy records. We further present a bidirectional syntactic typing system for both values and computations that elegantly and pragmatically circumvents difficulties of type inference in the presence of width and depth subtyping for variant and lazy records. We demonstrate the flexibility of our system by systematically deriving related systems of subtyping for (a) isorecursive types, (b) call-by-name, and (c) call-by-value, all using a structural rather than a nominal interpretation of types.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Zeeshan", + "last_name": "Lakhani", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Ankush", + "last_name": "Das", + "institution": "Amazon (United States)" + }, + { + "first_name": "Henry", + "last_name": "DeYoung", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Andreia", + "last_name": "Mordido", + "institution": "University of Lisbon" + }, + { + "first_name": "Frank", + "last_name": "Pfenning", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/esop/LakhaniDDMP22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_10", + "title": "Abstraction for Crash-Resilient Objects", + "abstract": "Abstract We study abstraction for crash-resilient concurrent objects using non-volatile memory (NVM). We develop a library-correctness criterion that is sound for ensuring contextual refinement in this setting, thus allowing clients to reason about library behaviors in terms of their abstract specifications, and library developers to verify their implementations against the specifications abstracting away from particular client programs. As a semantic foundation we employ a recent NVM model, called Persistent Sequential Consistency, and extend its language and operational semantics with useful specification constructs. The proposed correctness criterion accounts for NVM-related interactions between client and library code due to explicit persist instructions, and for calling policies enforced by libraries. We illustrate our approach on two implementations and specifications of simple persistent objects with different prototypical durability guarantees. Our results provide the first approach to formal compositional reasoning under NVM.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Artem", + "last_name": "Khyzha", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/esop/KhyzhaL22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_13", + "title": "Linearity and Uniqueness: An Entente Cordiale", + "abstract": "Abstract Substructural type systems are growing in popularity because they allow for a resourceful interpretation of data which can be used to rule out various software bugs. Indeed, substructurality is finally taking hold in modern programming; Haskell now has linear types roughly based on Girard’s linear logic but integrated via graded function arrows, Clean has uniqueness types designed to ensure that values have at most a single reference to them, and Rust has an intricate ownership system for guaranteeing memory safety. But despite this broad range of resourceful type systems, there is comparatively little understanding of their relative strengths and weaknesses or whether their underlying frameworks can be unified. There is often confusion about whether linearity and uniqueness are essentially the same, or are instead ‘dual’ to one another, or somewhere in between. This paper formalises the relationship between these two well-studied but rarely contrasted ideas, building on two distinct bodies of literature, showing that it is possible and advantageous to have both linear and unique types in the same type system. We study the guarantees of the resulting system and provide a practical implementation in the graded modal setting of the Granule language, adding a third kind of modality alongside coeffect and effect modalities. We then demonstrate via a benchmark that our implementation benefits from expected efficiency gains enabled by adding uniqueness to a language that already has a linear basis.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Marshall", + "institution": "University of Kent" + }, + { + "first_name": "Michael", + "last_name": "Vollmer", + "institution": "University of Kent" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/esop/MarshallVO22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_5", + "title": "Why3-do: The Way of Harmonious Distributed System Proofs", + "abstract": "Abstract We study principles and models for reasoning inductively about properties of distributed systems, based on programmed atomic handlers equipped with contracts. We present the Why3-do library, leveraging a state of the art software verifier for reasoning about distributed systems based on our models. A number of examples involving invariants containing existential and nested quantifiers (including Dijsktra’s self-stabilizing systems) illustrate how the library promotes contract-based modular development, abstraction barriers, and automated proofs.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Cláudio Belo", + "last_name": "Lourenço", + "institution": "Huawei Technologies (United Kingdom)" + }, + { + "first_name": "Jorge Sousa", + "last_name": "Pinto", + "institution": "INESC TEC" + } + ], + "dblp_key": "conf/esop/LourencoP22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_7", + "title": "Verified Security for the Morello Capability-enhanced Prototype Arm Architecture", + "abstract": "Abstract Memory safety bugs continue to be a major source of security vulnerabilities in our critical infrastructure. The CHERI project has proposed extending conventional architectures with hardware-supported capabilities to enable fine-grained memory protection and scalable compartmentalisation, allowing historically memory-unsafe C and C++ to be adapted to deterministically mitigate large classes of vulnerabilities, while requiring only minor changes to existing system software sources. Arm is currently designing and building Morello, a CHERI-enabled prototype architecture, processor, SoC, and board, extending the high-performance Neoverse N1, to enable industrial evaluation of CHERI and pave the way for potential mass-market adoption. However, for such a major new security-oriented architecture feature, it is important to establish high confidence that it does provide the intended protections, and that cannot be done with conventional engineering techniques. In this paper we put the Morello architecture on a solid mathematical footing from the outset. We define the fundamental security property that Morello aims to provide, reachable capability monotonicity, and prove that the architecture definition satisfies it. This proof is mechanised in Isabelle/HOL, and applies to a translation of the official Arm specification of the Morello instruction-set architecture (ISA) into Isabelle. The main challenge is handling the complexity and scale of a production architecture: 62,000 lines of specification, translated to 210,000 lines of Isabelle. We do so by factoring the proof via a narrow abstraction capturing essential properties of arbitrary CHERI ISAs, expressed above a monadic intra-instruction semantics. We also develop a model-based test generator, which generates instruction-sequence tests that give good specification coverage, used in early testing of the Morello implementation and in Morello QEMU development, and we use Arm’s internal test suite to validate our model. This gives us machine-checked mathematical proofs of whole-ISA security properties of a full-scale industry architecture, at design-time. To the best of our knowledge, this is the first demonstration that that is feasible, and it significantly increases confidence in Morello.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Bauereiß", + "institution": "University of Cambridge" + }, + { + "first_name": "B. K.", + "last_name": "Campbell", + "institution": "University of Edinburgh" + }, + { + "first_name": "Thomas", + "last_name": "Sewell", + "institution": "University of Cambridge" + }, + { + "first_name": "Alasdair", + "last_name": "Armstrong", + "institution": "University of Cambridge" + }, + { + "first_name": "Lawrence", + "last_name": "Esswood", + "institution": "University of Cambridge" + }, + { + "first_name": "Ian", + "last_name": "Stark", + "institution": "University of Edinburgh" + }, + { + "first_name": "Graeme", + "last_name": "Barnes", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Robert N. M.", + "last_name": "Watson", + "institution": "University of Cambridge" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/esop/BauereissCSAESB22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_3", + "title": "Foundations for Entailment Checking in Quantitative Separation Logic", + "abstract": "Abstract Quantitative separation logic () is an extension of separation logic () for the verification of probabilistic pointer programs. In , formulae evaluate to real numbers instead of truth values, e.g., the probability of memory-safe termination in a given symbolic heap. As with , one of the key problems when reasoning with is entailment : does a formula f entail another formula g ? We give a generic reduction from entailment checking in to entailment checking in . This allows to leverage the large body of research for the automated verification of probabilistic pointer programs. We analyze the complexity of our approach and demonstrate its applicability. In particular, we obtain the first decidability results for the verification of such programs by applying our reduction to a quantitative extension of the well-known symbolic-heap fragment of separation logic.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Kevin", + "last_name": "Batz", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Ira", + "last_name": "Fesefeldt", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Marvin", + "last_name": "Jansen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Florian", + "last_name": "Keßler", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Christoph", + "last_name": "Matheja", + "institution": "ETH Zurich" + }, + { + "first_name": "Thomas", + "last_name": "Noll", + "institution": "RWTH Aachen University" + } + ], + "dblp_key": "conf/esop/BatzFJKKMN22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_8", + "title": "The Trusted Computing Base of the CompCert Verified Compiler", + "abstract": "Abstract is the first realistic formally verified compiler: it provides a machine-checked mathematical proof that the code it generates matches the source code. Yet, there could be loopholes in this approach. We comprehensively analyze aspects of where errors could lead to incorrect code being generated. Possible issues range from the modeling of the source and the target languages to some techniques used to call external algorithms from within the compiler.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "David", + "last_name": "Monniaux", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Sylvain", + "last_name": "Boulmé", + "institution": "Institut polytechnique de Grenoble" + } + ], + "dblp_key": "conf/esop/MonniauxB22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_4", + "title": "Extracting total Amb programs from proofs", + "abstract": "Abstract We present a logical system CFP (Concurrent Fixed Point Logic) that supports the extraction of nondeterministic and concurrent programs that are provably total and correct. CFP is an intuitionistic first-order logic with inductive and coinductive definitions extended by two propositional operators, $$B|_{A}$$ B | A (restriction, a strengthening of implication) and $${\\mathbf {\\downdownarrows }}(B)$$ ⇊ ( B ) (total concurrency). The source of the extraction are formal CFP proofs, the target is a lambda calculus with constructors and recursion extended by a constructor Amb (for McCarthy’s amb) which is interpreted operationally as globally angelic choice and is used to implement nondeterminism and concurrency. The correctness of extracted programs is proven via an intermediate domain-theoretic denotational semantics. We demonstrate the usefulness of our system by extracting a nondeterministic program that translates infinite Gray code into the signed digit representation. A noteworthy feature of our system is that the proof rules for restriction and concurrency involve variants of the classical law of excluded middle that would not be interpretable computationally without Amb.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ulrich", + "last_name": "Berger", + "institution": "Swansea University" + }, + { + "first_name": "Hideki", + "last_name": "Tsuiki", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/esop/BergerT22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_15", + "title": "A Dependent Dependency Calculus", + "abstract": "Abstract Over twenty years ago, Abadi et al. established the Dependency Core Calculus (DCC) as a general purpose framework for analyzing dependency in typed programming languages. Since then, dependency analysis has shown many practical benefits to language design: its results can help users and compilers enforce security constraints, eliminate dead code, among other applications. In this work, we present a Dependent Dependency Calculus (DDC), which extends this general idea to the setting of a dependently-typed language. We use this calculus to track both run-time and compile-time irrelevance, enabling faster type-checking and program execution.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Pritam", + "last_name": "Choudhury", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Harley", + "last_name": "Eades", + "institution": "Augusta University" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/esop/ChoudhuryEW22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_12", + "title": "Probabilistic Total Store Ordering", + "abstract": "Abstract We present Probabilistic Total Store Ordering (PTSO) – a probabilistic extension of the classical TSO semantics. For a given (finite-state) program, the operational semantics of PTSO induces an infinite-state Markov chain. We resolve the inherent non-determinism due to process schedulings and memory updates according to given probability distributions. We provide a comprehensive set of results showing the decidability of several properties for PTSO, namely (i) Almost-Sure (Repeated) Reachability : whether a run, starting from a given initial configuration, almost surely visits (resp. almost surely repeatedly visits) a given set of target configurations. (ii) Almost-Never (Repeated) Reachability : whether a run from the initial configuration, almost never visits (resp. almost never repeatedly visits) the target. (iii) Approximate Quantitative (Repeated) Reachability : to approximate, up to an arbitrary degree of precision, the measure of runs that start from the initial configuration and (repeatedly) visit the target. (iv) Expected Average Cost: to approximate, up to an arbitrary degree of precision, the expected average cost of a run from the initial configuration to the target. We derive our results through a nontrivial combination of results from the classical theory of (infinite-state) Markov chains, the theories of decisive and eager Markov chains, specific techniques from combinatorics, as well as, decidability and complexity results for the classical (non-probabilistic) TSO semantics. As far as we know, this is the first work that considers probabilistic verification of programs running on weak memory models.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Raj Aryan", + "last_name": "Agarwal", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Adwait", + "last_name": "Godbole", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Shankara Narayanan", + "last_name": "Krishna", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "conf/esop/AbdullaAAGK22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_9", + "title": "View-Based Owicki-Gries Reasoning for Persistent x86-TSO", + "abstract": "Abstract The rise of persistent memory is disrupting computing to its core. Our work aims to help programmers navigate this brave new world by providing a program logic for reasoning about x86 code that uses low-level operations such as memory accesses and fences, as well as persistency primitives such as flushes. Our logic, Pierogi , benefits from a simple underlying operational semantics based on views , is able to handle optimised flush operations, and is mechanised in the Isabelle/HOL proof assistant. We detail the proof rules of Pierogi and prove them sound. We also show how Pierogi can be used to reason about a range of challenging single- and multi-threaded persistent programs.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Eleni", + "last_name": "Bila", + "institution": "University of Surrey" + }, + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "University of Surrey" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/esop/BilaDLRW22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_14", + "title": "A Framework for Substructural Type Systems", + "abstract": "Abstract Mechanisation of programming language research is of growing interest, and the act of mechanising type systems and their metatheory is generally becoming easier as new techniques are invented. However, state-of-the-art techniques mostly rely on structurality of the type system — that weakening, contraction, and exchange are admissible and variables can be used unrestrictedly once assumed. Linear logic, and many related subsequent systems, provide motivations for breaking some of these assumptions. We present a framework for mechanising the metatheory of certain substructural type systems, in a style resembling mechanised metatheory of structural type systems. The framework covers a wide range of simply typed syntaxes with semiring usage annotations, via a metasyntax of typing rules. The metasyntax for the premises of a typing rule is related to bunched logic, featuring both sharing and separating conjunction, roughly corresponding to the additive and multiplicative features of linear logic. We use the uniformity of syntaxes to derive type system-generic renaming, substitution, and a form of linearity checking.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "James", + "last_name": "Wood", + "institution": "University of Strathclyde" + }, + { + "first_name": "Robert", + "last_name": "Atkey", + "institution": "University of Strathclyde" + } + ], + "dblp_key": "conf/esop/WoodA22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_6", + "title": "Relaxed virtual memory in Armv8-A", + "abstract": "Abstract Virtual memory is an essential mechanism for enforcing security boundaries, but its relaxed-memory concurrency semantics has not previously been investigated in detail. The concurrent systems code managing virtual memory has been left on an entirely informal basis, and OS and hypervisor verification has had to make major simplifying assumptions. We explore the design space for relaxed virtual memory semantics in the Armv8-A architecture, to support future system-software verification. We identify many design questions, in discussion with Arm; develop a test suite, including use cases from the pKVM production hypervisor under development by Google; delimit the design space with axiomatic-style concurrency models; prove that under simple stable configurations our architectural model collapses to previous “user” models; develop tooling to compute allowed behaviours in the model integrated with the full Armv8-A ISA semantics; and develop a hardware test harness. This lays out some of the main issues in relaxed virtual memory bringing these security-critical systems phenomena into the domain of programming-language semantics and verification with foundational architecture semantics.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Ben", + "last_name": "Simner", + "institution": "University of Cambridge" + }, + { + "first_name": "Alasdair", + "last_name": "Armstrong", + "institution": "University of Cambridge" + }, + { + "first_name": "Jean", + "last_name": "Pichon-Pharabod", + "institution": "Aarhus University" + }, + { + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" + }, + { + "first_name": "Richard", + "last_name": "Grisenthwaite", + "institution": "ARM (United Kingdom)" + }, + { + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/esop/SimnerAPPGS22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_11", + "title": "Static Race Detection for Periodic Programs", + "abstract": "Abstract We consider the problem of statically detecting data races in periodic real-time programs that use locks, and run on a single processor platform. We propose a technique based on a small set of rules that exploits the priority, periodicity, locking, and timing information of tasks in the program. One of the key requirements is a response time analysis for such programs, and we propose an algorithm to compute this for the case of non-nested locks. We have implemented our analysis for real-time programs written in C in a tool called PePRacer and evaluated its performance on a small set of benchmarks from the literature.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Varsha P", + "last_name": "Suresh", + "institution": "International Institute of Information Technology Bangalore" + }, + { + "first_name": "Rekha", + "last_name": "Pai", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Deepak", + "last_name": "D’Souza", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Meenakshi", + "last_name": "D’Souza", + "institution": "International Institute of Information Technology Bangalore" + }, + { + "first_name": "Sujit Kumar", + "last_name": "Chakrabarti", + "institution": "International Institute of Information Technology Bangalore" + } + ], + "dblp_key": "conf/esop/SureshPDDC22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_2", + "title": "Compiling Universal Probabilistic Programming Languages with Efficient Parallel Sequential Monte Carlo Inference", + "abstract": "Abstract Probabilistic programming languages (PPLs) allow users to encode arbitrary inference problems, and PPL implementations provide general-purpose automatic inference for these problems. However, constructing inference implementations that are efficient enough is challenging for many real-world problems. Often, this is due to PPLs not fully exploiting available parallelization and optimization opportunities. For example, handling probabilistic checkpoints in PPLs through continuation-passing style transformations or non-preemptive multitasking—as is done in many popular PPLs—often disallows compilation to low-level languages required for high-performance platforms such as GPUs. To solve the checkpoint problem, we introduce the concept of PPL control-flow graphs (PCFGs)—a simple and efficient approach to checkpoints in low-level languages. We use this approach to implement RootPPL : a low-level PPL built on CUDA and C++ with OpenMP, providing highly efficient and massively parallel SMC inference. We also introduce a general method of compiling universal high-level PPLs to PCFGs and illustrate its application when compiling Miking CorePPL —a high-level universal PPL—to RootPPL. The approach is the first to compile a universal PPL to GPUs with SMC inference. We evaluate RootPPL and the CorePPL compiler through a set of real-world experiments in the domains of phylogenetics and epidemiology, demonstrating up to 6 $$\\times $$ × speedups over state-of-the-art PPLs implementing SMC inference.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Lundén", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Joey", + "last_name": "Öhman", + "institution": "AI Sweden" + }, + { + "first_name": "Jan", + "last_name": "Kudlicka", + "institution": "BI Norwegian Business School" + }, + { + "first_name": "Viktor", + "last_name": "Senderov", + "institution": "Swedish Museum of Natural History" + }, + { + "first_name": "Fredrik", + "last_name": "Ronquist", + "institution": "Stockholm University" + }, + { + "first_name": "David", + "last_name": "Broman", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/esop/LundenOKSRB22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_18", + "title": "Region-based Resource Management and Lexical Exception Handlers in Continuation-Passing Style", + "abstract": "Abstract Regions are a useful tool for the safe and automatic management of resources. Due to their scarcity, resources are often limited in their lifetime which is associated with a certain scope. When control flow leaves the scope, the resources are released. Exceptions can non-locally exit such scopes and it is important that resources are also released in this case. Continuation-passing style is a useful compiler intermediate language that makes control flow explicit. All calls are tail calls and the runtime stack is not used. It can also serve as an implementation technique for control effects like exceptions. In this case throwing an exception means jumping to a continuation which is not the current one. How is it possible to offer region-based resource management and exceptions in the same language and translate both to continuation-passing style? In this paper, we answer this question. We present a typed language with resources and exceptions, and its translation to continuation-passing style. The translation can be defined modularly for resources and exceptions – the correct interaction between the two automatically arises from simple composition. We prove that the translation preserves well-typedness and semantics.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_18", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Philipp", + "last_name": "Schuster", + "institution": "University of Tübingen" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" + } + ], + "dblp_key": "conf/esop/SchusterBO22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_17", + "title": "Structured Handling of Scoped Effects", + "abstract": "Abstract Algebraic effects offer a versatile framework that covers a wide variety of effects. However, the family of operations that delimit scopes are not algebraic and are usually modelled as handlers, thus preventing them from being used freely in conjunction with algebraic operations. Although proposals for scoped operations exist, they are either ad-hoc and unprincipled, or too inconvenient for practical programming. This paper provides the best of both worlds: a theoretically-founded model of scoped effects that is convenient for implementation and reasoning. Our new model is based on an adjunction between a locally finitely presentable category and a category of functorial algebras . Using comparison functors between adjunctions, we show that our new model, an existing indexed model, and a third approach that simulates scoped operations in terms of algebraic ones have equal expressivity for handling scoped operations. We consider our new model to be the sweet spot between ease of implementation and structuredness. Additionally, our approach automatically induces fusion laws of handlers of scoped effects, which are useful for reasoning and optimisation.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_17", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Zhixuan", + "last_name": "Yang", + "institution": "Imperial College London" + }, + { + "first_name": "Marco", + "last_name": "Paviotti", + "institution": "Imperial College London" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + }, + { + "first_name": "Birthe van den", + "last_name": "Berg", + "institution": "KU Leuven" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/esop/YangPWBS22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_21", + "title": "Concurrent NetKAT - Modeling and analyzing stateful, concurrent networks", + "abstract": "Abstract We introduce Concurrent (), an extension of with operators for specifying and reasoning about concurrency in scenarios where multiple packets interact through state. We provide a model of the language based on partially-ordered multisets (pomsets), which are a well-established mathematical structure for defining the denotational semantics of concurrent languages. We provide a sound and complete axiomatization of this model, and we illustrate the use of through examples. More generally, can be understood as an algebraic framework for reasoning about programs with both local state (in packets) and global state (in a global store).", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_21", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jana", + "last_name": "Wagemaker", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "University of Amsterdam" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Jurriaan", + "last_name": "Rot", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/esop/WagemakerFKKRS22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_19", + "title": "A Predicate Transformer for Choreographies - Computing Preconditions in Choreographic Programming", + "abstract": "Abstract Construction and analysis of distributed systems is difficult; choreographic programming is a deadlock-freedom-by-construction approach to simplify it. In this paper, we present a new theory of choreographic programming. It supports for the first time: construction of distributed systems that require decentralised decision making (i.e., if/while-statements with multiparty conditions); analysis of distributed systems to provide not only deadlock freedom but also functional correctness (i.e., pre/postcondition reasoning). Both contributions are enabled by a single new technique, namely a predicate transformer for choreographies.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_19", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sung-Shik", + "last_name": "Jongmans", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Petra van den", + "last_name": "Bos", + "institution": "University of Twente" + } + ], + "dblp_key": "conf/esop/JongmansB22", + "venue": "esop", + "year": 2022 + }, + { + "paper_id": "10.1007/978-3-030-99336-8_20", + "title": "Comparing the expressiveness of the π-calculus and CCS", + "abstract": "Abstract This paper shows that the $$\\pi $$ π -calculus with implicit matching is no more expressive than $$\\mathrm {CCS}_{\\gamma }$$ CCS γ , a variant of CCS in which the result of a synchronisation of two actions is itself an action subject to relabelling or restriction, rather than the silent action $$\\tau $$ τ . This is done by exhibiting a compositional translation from the $$\\pi $$ π -calculus with implicit matching to $$\\mathrm {CCS}_{\\gamma }$$ CCS γ that is valid up to strong barbed bisimilarity. The full $$\\pi $$ π -calculus can be similarly expressed in $$\\mathrm {CCS}_{\\gamma }$$ CCS γ enriched with the triggering operation of Meije . I also show that these results cannot be recreated with CCS in the rôle of $$\\mathrm {CCS}_{\\gamma }$$ CCS γ , not even up to reduction equivalence, and not even for the asynchronous $$\\pi $$ π -calculus without restriction or replication. Finally I observe that CCS cannot be encoded in the $$\\pi $$ π -calculus.", + "date": "2022-01-01", + "link": "https://doi.org/10.1007/978-3-030-99336-8_20", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Rob van", + "last_name": "Glabbeek", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + } + ], + "dblp_key": "conf/esop/Glabbeek22", + "venue": "esop", + "year": 2022 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2023.json b/data/pl_conferences/esop/2023.json new file mode 100644 index 0000000..df10eda --- /dev/null +++ b/data/pl_conferences/esop/2023.json @@ -0,0 +1,572 @@ +[ + { + "paper_id": "10.1007/978-3-031-30044-8_5", + "title": "Builtin Types Viewed as Inductive Families", + "abstract": "Abstract State of the art optimisation passes for dependently typed languages can help erase the redundant information typical of invariant-rich data structures and programs. These automated processes do not dramatically change the structure of the data, even though more efficient representations could be available. Using Quantitative Type Theory as implemented in Idris 2, we demonstrate how to define an invariant-rich, typechecking-time data structure packing an efficient runtime representation together with runtime irrelevant invariants. The compiler can then aggressively erase all such invariants during compilation. Unlike other approaches, the complexity of the resulting representation is entirely predictable, we do not require both representations to have the same structure, and yet we are able to seamlessly program as if we were using the high-level structure.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Allais", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/esop/Allais23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_3", + "title": "Adversarial Reachability for Program-level Security Analysis", + "abstract": "Abstract Many program analysis tools and techniques have been developed to assess program vulnerability. Yet, they are based on the standard concept of reachability and represent an attacker able to craft smart legitimate input, while in practice attackers can be much more powerful, using for instance micro-architectural exploits or fault injection methods. We introduce adversarial reachability , a framework allowing to reason about such advanced attackers and check whether a system is vulnerable or immune to a particular attacker. As equipping the attacker with new capacities significantly increases the state space of the program under analysis, we present a new symbolic exploration algorithm, namely adversarial symbolic execution , injecting faults in a forkless manner to prevent path explosion, together with optimizations dedicated to reduce the number of injections to consider while keeping the same attacker power. Experiments on representative benchmarks from fault injection show that our method significantly reduces the number of adversarial paths to explore, allowing to scale up to 10 faults where prior work timeout for 3 faults. In addition, we analyze the well-tested WooKey bootloader, and demonstrate the ability of our analysis to find attacks and evaluate countermeasures in real-life security scenarios. We were especially able to find an attack not mentioned in a previous patch.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Soline", + "last_name": "Ducousso", + "institution": "Laboratoire d'Intégration des Systèmes et des Technologies" + }, + { + "first_name": "Sébastien", + "last_name": "Bardin", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Marie-Laure", + "last_name": "Potet", + "institution": "Verimag" + } + ], + "dblp_key": "conf/esop/DucoussoBP23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_2", + "title": "Clustered Relational Thread-Modular Abstract Interpretation with Local Traces", + "abstract": "Abstract We construct novel thread-modular analyses that track relational information for potentially overlapping clusters of global variables – given that they are protected by common mutexes. We provide a framework to systematically increase the precision of clustered relational analyses by splitting control locations based on abstractions of local traces . As one instance, we obtain an analysis of dynamic thread creation and joining. Interestingly, tracking less relational information for globals may result in higher precision. We consider the class of 2-decomposable domains that encompasses many weakly relational domains (e.g., Octagons ). For these domains, we prove that maximal precision is attained already for clusters of globals of sizes at most 2.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Michael", + "last_name": "Schwarz", + "institution": "Technical University of Munich" + }, + { + "first_name": "Simmo", + "last_name": "Saan", + "institution": "University of Tartu" + }, + { + "first_name": "Helmut", + "last_name": "Seidl", + "institution": "Technical University of Munich" + }, + { + "first_name": "Julian", + "last_name": "Erhard", + "institution": "Technical University of Munich" + }, + { + "first_name": "Vesal", + "last_name": "Vojdani", + "institution": "University of Tartu" + } + ], + "dblp_key": "conf/esop/SchwarzSSEV23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_9", + "title": "A Type System for Effect Handlers and Dynamic Labels", + "abstract": "Abstract We consider a simple yet expressive $$\\lambda $$ λ -calculus equipped with references, effect handlers, and dynamic allocation of effect labels, and whose operational semantics does not involve coercions or rely on type information. We equip this language with a type system that supports type and effect polymorphism, allows reordering row entries and extending a row with new entries, and supports (but is not restricted to) lexically scoped handlers. This requires addressing the issue of potential aliasing between effect names. Our original solution is to interpret a row not only as a permission to perform certain effects but also as a disjointness requirement bearing on effect names. The type system guarantees strong type soundness: a well-typed program cannot crash or perform an unhandled effect. We prove this fact by encoding the type system into a novel Separation Logic for effect handlers, which we build on top of Iris. Our results are formalized in Coq.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Paulo Emílio de", + "last_name": "Vilhena", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/esop/VilhenaP23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_6", + "title": "Pragmatic Gradual Polymorphism with References", + "abstract": "Abstract Gradualizing System F has been widely discussed. A big challenge is to preserve relational parametricity and/or the gradual guarantee. Most past work has focused on the preservation of parametricity, but often without the gradual guarantee. A few recent works satisfy both properties by giving up System F syntax, or with some restrictions and the introduction of sophisticated mechanisms in the dynamic semantics. While parametricity is important for polymorphic languages, most mainstream languages typically do not satisfy it, for a variety of different reasons. In this paper, we explore the design space of polymorphic languages that satisfy the gradual guarantee, but do not preserve parametricity. When parametricity is not a goal, the design of polymorphic gradual languages can be considerably simplified. Moreover, it becomes easy to add features that are of practical importance, such as mutable references. We present a new gradually typed polymorphic calculus, called $$\\lambda ^{G}_{gpr}$$ λ gpr G , with mutable references and with an easy proof of the gradual guarantee. In addition, compared to other gradual polymorphism work, $$\\lambda ^{G}_{gpr}$$ λ gpr G is defined using a Type-Directed Operational Semantics (TDOS), which allows the dynamic semantics to be defined directly instead of elaborating to a target cast language. $$\\lambda ^{G}_{gpr}$$ λ gpr G and all the proofs in this paper are formalized in Coq.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Wenjia", + "last_name": "Ye", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/esop/YeO23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_10", + "title": "Interpreting Knowledge-based Programs", + "abstract": "Abstract Knowledge-based programs specify multi-agent protocols with epistemic guards that abstract from how agents learn and record facts or information about other agents and the environment. Their interpretation involves a non-monotone mutual dependency between the evaluation of epistemic guards over the reachable states and the derivation of the reachable states depending on the evaluation of epistemic guards. We apply the technique of a must/cannot analysis invented for synchronous programming languages to the interpretation problem of knowledge-based programs and demonstrate that the resulting constructive interpretation is monotone and has a least fixed point. We relate our approach with existing interpretation schemes for both synchronous and asynchronous programs. Finally, we describe an implementation of the constructive interpretation and illustrate the procedure by several examples and an application to the Java memory model.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Knapp", + "institution": "University of Augsburg" + }, + { + "first_name": "Heribert", + "last_name": "Mühlberger", + "institution": "University of Augsburg" + }, + { + "first_name": "Bernhard", + "last_name": "Reus", + "institution": "University of Sussex" + } + ], + "dblp_key": "conf/esop/KnappMR23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_11", + "title": "Contextual Modal Type Theory with Polymorphic Contexts", + "abstract": "Abstract Modal types—types that are derived from proof systems of modal logic—have been studied as theoretical foundations of metaprogramming, where program code is manipulated as first-class values. In modal type systems, modality corresponds to a type constructor for code types and controls free variables and their types in code values. Nanevski et al. have proposed contextual modal type theory , which has modal types with fine-grained information on free variables: modal types are explicitly indexed by contexts —the types of all free variables in code values. This paper presents $$\\lambda _{\\forall []}$$ λ ∀ [ ] , a novel extension of contextual modal type theory with parametric polymorphism over contexts . Such an extension has been studied in the literature but, unlike earlier proposals, $$\\lambda _{\\forall []}$$ λ ∀ [ ] is more general in that it allows multiple occurrence of context variables in a single context. We formalize $$\\lambda _{\\forall []}$$ λ ∀ [ ] with its type system and operational semantics given by $$\\beta $$ β -reduction and prove its basic properties including subject reduction, strong normalization, and confluence. Moreover, to demonstrate the expressive power of polymorphic contexts, we show a type-preserving embedding from a two-level fragment of Davies’ $$\\lambda _{\\bigcirc }$$ λ ◯ , which is based on linear-time temporal logic, to $$\\lambda _{\\forall []}$$ λ ∀ [ ] .", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Yuito", + "last_name": "Murase", + "institution": "Kyoto University" + }, + { + "first_name": "Yuichi", + "last_name": "Nishiwaki", + "institution": "" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/esop/MuraseNI23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_13", + "title": "Quorum Tree Abstractions of Consensus Protocols", + "abstract": "Abstract Distributed algorithms solving agreement problems like consensus or state machine replication are essential components of modern fault-tolerant distributed services. They are also notoriously hard to understand and reason about. Their complexity stems from the different assumptions on the environment they operate with, i.e., process or network link failures, Byzantine failures etc. In this paper, we propose a novel abstract representation of the dynamics of such protocols which focuses on quorums of responses (votes) to a request (proposal) that form during a run of the protocol. We show that focusing on such quorums, a run of a protocol can be viewed as working over a tree structure where different branches represent different possible outcomes of the protocol, the goal being to stabilize on the choice of a fixed branch. This abstraction resembles the description of recent protocols used in Blockchain infrastructures, e.g., the protocol supporting Bitcoin or Hotstuff. We show that this abstraction supports reasoning about the safety of various algorithms, e.g., Paxos, PBFT, Raft, and HotStuff, in a uniform way. In general, it provides a novel induction based argument for proving that such protocols are safe.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Berk", + "last_name": "Çirişci", + "institution": "Université Paris Cité" + }, + { + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Süha Orhun", + "last_name": "Mutluergil", + "institution": "Sabancı Üniversitesi" + } + ], + "dblp_key": "conf/esop/CirisciEM23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_7", + "title": "Modal Crash Types for Intermittent Computing", + "abstract": "Abstract Intermittent computing is gaining traction in application domains such as Energy Harvesting Devices (EHDs) that experience arbitrary power failures during program execution. To make progress, programs require system support to checkpoint state and re-execute after power failure by restoring the last saved state. This re-execution should be correct , i.e., simulated by a continuously-powered execution. We study the logical underpinning of intermittent computing and model checkpoint, crash, restore, and re-execution operations as computation on Crash types. We draw inspiration from adjoint logic and define Crash types by introducing two adjoint modality operators to model persistent and transient memory values of partial (re-)executions and the transitions between them caused by checkpoints and restoration. We define a Crash type system for a core calculus. We prove the correctness of intermittent systems by defining a novel logical relation for Crash types.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Farzaneh", + "last_name": "Derakhshan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Myra", + "last_name": "Dotzel", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Milijana", + "last_name": "Surbatovich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Limin", + "last_name": "Jia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/esop/DerakhshanDSJ23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_1", + "title": "Logics for Extensional, Locally Complete Analysis via Domain Refinements", + "abstract": "Abstract Abstract interpretation is a framework to design sound static analyses by over-approximating the set of program behaviours. While over-approximations can prove correctness, they cannot witness incorrectness because false alarms may arise. An ideal, but uncommon, situation is completeness of the abstraction that can ensure no false alarm is introduced by the abstract interpreter. Local Completeness Logic is a proof system that can decide both correctness and incorrectness of a program: any provable triple $$\\vdash _{A}[P]~\\textsf{c}~[Q]$$ ⊢ A [ P ] c [ Q ] in the logic implies completeness of an intensional abstraction of program $$\\textsf{c}$$ c on input P and is such that Q can be used to decide (in)correctness. However, completeness itself is an extensional property of the function computed by the program, while the above intensional analysis depends on the way the program is written and therefore not all valid triples can be derived in the proof system. Our main contribution is the study of new inference rules which allow one to perform part of the intensional analysis in a more precise abstract domain, and then to transfer the result back to the coarser domain. With these new rules, all (extensionally) valid triples can be derived in the proof system, thus untying the set of provable properties from the way the program is written.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Flavio", + "last_name": "Ascari", + "institution": "University of Pisa" + }, + { + "first_name": "Roberto", + "last_name": "Bruni", + "institution": "University of Pisa" + }, + { + "first_name": "Roberta", + "last_name": "Gori", + "institution": "University of Pisa" + } + ], + "dblp_key": "conf/esop/AscariBG23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_8", + "title": "Gradual Tensor Shape Checking", + "abstract": "Abstract Tensor shape mismatch is a common source of bugs in deep learning programs. We propose a new type-based approach to detect tensor shape mismatches. One of the main features of our approach is the best-effort shape inference. As the tensor shape inference problem is undecidable in general, we allow static type/shape inference to be performed only in a best-effort manner. If the static inference cannot guarantee the absence of the shape inconsistencies, dynamic checks are inserted into the program. Another main feature is gradual typing, where users can improve the precision of the inference by adding appropriate type annotations to the program. We formalize our approach and prove that it satisfies the criteria of gradual typing proposed by Siek et al. in 2015. We have implemented a prototype shape checking tool based on our approach and evaluated its effectiveness by applying it to some deep neural network programs.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Momoko", + "last_name": "Hattori", + "institution": "The University of Tokyo" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryosuke", + "last_name": "Sato", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/esop/HattoriKS23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_16", + "title": "Safe Session-Based Concurrency with Shared Linear State", + "abstract": "Abstract We introduce $$\\textsf{CLASS}$$ CLASS , a session-typed, higher-order, core language that supports concurrent computation with shared linear state.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Pedro", + "last_name": "Rocha", + "institution": "University of Lisbon" + }, + { + "first_name": "Luı́s", + "last_name": "Caires", + "institution": "University of Lisbon" + } + ], + "dblp_key": "conf/esop/RochaC23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_14", + "title": "MAGπ: Types for Failure-Prone Communication", + "abstract": "Abstract Multiparty Session Types (MPST) are a typing discipline for communication-centric systems, guaranteeing communication safety, deadlock freedom and protocol compliance. Several works have emerged which model failures and introduce fault-tolerance techniques. However, such works often make assumptions on the underlying network, e.g. , assuming TCP-based communication where messages are guaranteed to be delivered; or adopting centralised reliable nodes and ad-hoc notions of reliability; or only addressing a single kind of failure, such as node crashes. In this work, we develop MAG $$\\pi $$ π —a Multiparty, Asynchronous and Generalised $$\\pi $$ π -calculus, which is the first language and type system to accommodate in unison: ( i ) the widest range of non-Byzantine faults, including message loss, delays and reordering ; crash and link failures ; and network partitioning ; ( ii ) a novel and most general notion of reliability , taking into account the viewpoint of each participant in the protocol; ( iii ) a spectrum of network assumptions from the lowest UDP-based network programming to the TCP-based application level. We prove subject reduction and session fidelity; process properties (deadlock freedom, termination, etc. ); failure-handling safety and reliability adherence.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Matthew Alan Le", + "last_name": "Brun", + "institution": "University of Glasgow" + }, + { + "first_name": "Ornela", + "last_name": "Dardha", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/esop/BrunD23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_4", + "title": "Automated Grading of Regular Expressions", + "abstract": "Abstract With the rapid transition to distance learning, automatic grading software becomes more important to both teachers and students. We study the problem of automatically grading the regular expressions submitted by students in courses related to automata and formal language theory. In order to utilize the semantic information of the regular expression, we define a declarative logic that can be described by regular language and at the same time has natural language characteristics, and use it for the following tasks: 1) to assign partial grades for incorrect regular expressions and 2) to provide helpful feedback to students to make them understand the reason for the grades and a way to revise the incorrect regular expressions into correct ones. We categorize the cases when students’ incorrect submissions deserve partial grades and suggest how to assign appropriate grades for each of the cases. In order to optimize the runtime complexity of the algorithm, two heuristics based on automata theory are proposed and evaluated on the dataset collected from undergraduate students. In addition, we suggest Regex2NL which translates regular expressions to natural language descriptions to give insight to students so that they can understand how the regular expressions work.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Su-Hyeon", + "last_name": "Kim", + "institution": "Kangwon National University" + }, + { + "first_name": "Youngwook", + "last_name": "Kim", + "institution": "Yonsei University" + }, + { + "first_name": "Yo-Sub", + "last_name": "Han", + "institution": "Yonsei University" + }, + { + "first_name": "Hyeonseung", + "last_name": "Im", + "institution": "Kangwon National University" + }, + { + "first_name": "Sang‐Ki", + "last_name": "Ko", + "institution": "Kangwon National University" + } + ], + "dblp_key": "conf/esop/KimKHIK23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_12", + "title": "A Complete Inference System for Skip-free Guarded Kleene Algebra with Tests", + "abstract": "Abstract Guarded Kleene Algebra with Tests (GKAT) is a fragment of Kleene Algebra with Tests (KAT) that was recently introduced to reason efficiently about imperative programs. In contrast to KAT, GKAT does not have an algebraic axiomatization, but relies on an analogue of Salomaa’s axiomatization of Kleene Algebra. In this paper, we present an algebraic axiomatization and prove two completeness results for a large fragment of GKAT consisting of skip-free programs .", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Todd", + "last_name": "Schmid", + "institution": "University College London" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/esop/SchmidKS23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_15", + "title": "System Fμ ømega with Context-free Session Types", + "abstract": "Abstract We study increasingly expressive type systems, from $$F^\\mu $$ Fμ —an extension of the polymorphic lambda calculus with equirecursive types—to $$F^{\\mu ;}_\\omega $$ Fωμ; —the higher-order polymorphic lambda calculus with equirecursive types and context-free session types. Type equivalence is given by a standard bisimulation defined over a novel labelled transition system for types. Our system subsumes the contractive fragment of $$F^\\mu _\\omega $$ Fωμ as studied in the literature. Decidability results for type equivalence of the various type languages are obtained from the translation of types into objects of an appropriate computational model: finite-state automata, simple grammars and deterministic pushdown automata. We show that type equivalence is decidable for a significant fragment of the type language. We further propose a message-passing, concurrent functional language equipped with the expressive type language and show that it enjoys preservation and absence of runtime errors for typable processes.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Diogo", + "last_name": "Poças", + "institution": "University of Lisbon" + }, + { + "first_name": "Diana", + "last_name": "Costa", + "institution": "University of Lisbon" + }, + { + "first_name": "Andreia", + "last_name": "Mordido", + "institution": "University of Lisbon" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + } + ], + "dblp_key": "conf/esop/PocasCMV23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_17", + "title": "Bunched Fuzz: Sensitivity for Vector Metrics", + "abstract": "Abstract Program sensitivity measures the distance between the outputs of a program when run on two related inputs. This notion, which plays a key role in areas such as data privacy and optimization, has been the focus of several program analysis techniques introduced in recent years. Among the most successful ones, we can highlight type systems inspired by linear logic, as pioneered by Reed and Pierce in the Fuzz programming language. In Fuzz, each type is equipped with its own distance, and sensitivity analysis boils down to type checking. In particular, Fuzz features two product types, corresponding to two different notions of distance: the tensor product combines the distances of each component by adding them, while the with product takes their maximum . In this work, we show that these products can be generalized to arbitrary $$L^p$$ L p distances , metrics that are often used in privacy and optimization. The original Fuzz products, tensor and with, correspond to the special cases $$L^1$$ L 1 and $$L^\\infty $$ L ∞ . To ease the handling of such products, we extend the Fuzz type system with bunches —as in the logic of bunched implications—where the distances of different groups of variables can be combined using different $$L^p$$ L p distances. We show that our extension can be used to reason about quantitative properties of probabilistic programs.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_17", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "june", + "last_name": "wunder", + "institution": "" + }, + { + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "Rochester Institute of Technology" + }, + { + "first_name": "Patrick", + "last_name": "Baillot", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "" + } + ], + "dblp_key": "conf/esop/wunderABG23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_18", + "title": "Fast and Correct Gradient-Based Optimisation for Probabilistic Programming via Smoothing", + "abstract": "Abstract We study the foundations of variational inference, which frames posterior inference as an optimisation problem, for probabilistic programming. The dominant approach for optimisation in practice is stochastic gradient descent. In particular, a variant using the so-called reparameterisation gradient estimator exhibits fast convergence in a traditional statistics setting. Unfortunately, discontinuities, which are readily expressible in programming languages, can compromise the correctness of this approach. We consider a simple (higher-order, probabilistic) programming language with conditionals, and we endow our language with both a measurable and a smoothed (approximate) value semantics. We present type systems which establish technical pre-conditions. Thus we can prove stochastic gradient descent with the reparameterisation gradient estimator to be correct when applied to the smoothed problem. Besides, we can solve the original problem up to any error tolerance by choosing an accuracy coefficient suitably. Empirically we demonstrate that our approach has a similar convergence as a key competitor, but is simpler, faster, and attains orders of magnitude reduction in work-normalised variance.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_18", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Basim", + "last_name": "Khajwal", + "institution": "University of Oxford" + }, + { + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" + }, + { + "first_name": "Dominik", + "last_name": "Wagner", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/esop/KhajwalOW23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_19", + "title": "Type-safe Quantum Programming in Idris", + "abstract": "Abstract Variational Quantum Algorithms are hybrid classical-quantum algorithms where classical and quantum computation work in tandem to solve computational problems. These algorithms create interesting challenges for the design of suitable programming languages. In this paper we introduce Qimaera, which is a set of libraries for the Idris 2 programming language that enable the programmer to implement hybrid classical-quantum algorithms where the full power of the elegant Idris language works in synchrony with quantum programming primitives. The two key ingredients of Idris that make this possible are (1) dependent types which allow us to implement unitary quantum operations; and (2) linearity which allows us to enforce fine-grained control over the execution of quantum operations so that we may detect and reject many physically inadmissible programs. We also show that Qimaera is suitable for variational quantum programming by providing implementations of two prominent variational quantum algorithms – QAOA and VQE.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_19", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Liliane-Joy", + "last_name": "Dandy", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Emmanuel", + "last_name": "Jeandel", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Vladimir", + "last_name": "Zamdzhiev", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/DandyJZ23", + "venue": "esop", + "year": 2023 + }, + { + "paper_id": "10.1007/978-3-031-30044-8_20", + "title": "Automatic Alignment in Higher-Order Probabilistic Programming Languages", + "abstract": "Abstract Probabilistic Programming Languages (PPLs) allow users to encode statistical inference problems and automatically apply an inference algorithm to solve them. Popular inference algorithms for PPLs, such as sequential Monte Carlo (SMC) and Markov chain Monte Carlo (MCMC), are built around checkpoints —relevant events for the inference algorithm during the execution of a probabilistic program. Deciding the location of checkpoints is, in current PPLs, not done optimally. To solve this problem, we present a static analysis technique that automatically determines checkpoints in programs, relieving PPL users of this task. The analysis identifies a set of checkpoints that execute in the same order in every program run—they are aligned . We formalize alignment, prove the correctness of the analysis, and implement the analysis as part of the higher-order functional PPL Miking CorePPL. By utilizing the alignment analysis, we design two novel inference algorithm variants: aligned SMC and aligned lightweight MCMC . We show, through real-world experiments, that they significantly improve inference execution time and accuracy compared to standard PPL versions of SMC and MCMC.", + "date": "2023-01-01", + "link": "https://doi.org/10.1007/978-3-031-30044-8_20", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Lundén", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Gizem", + "last_name": "Çaylak", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Fredrik", + "last_name": "Ronquist", + "institution": "Stockholm University" + }, + { + "first_name": "David", + "last_name": "Broman", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/esop/LundenCRB23", + "venue": "esop", + "year": 2023 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2024.json b/data/pl_conferences/esop/2024.json new file mode 100644 index 0000000..d1a4cf8 --- /dev/null +++ b/data/pl_conferences/esop/2024.json @@ -0,0 +1,832 @@ +[ + { + "paper_id": "10.1007/978-3-031-57262-3_5", + "title": "A Formal Treatment of Bidirectional Typing", + "abstract": "Abstract There has been much progress in designing bidirectional type systems and associated type synthesis algorithms, but mainly on a case-by-case basis. To remedy the situation, this paper develops a general and formal theory of bidirectional typing for simply typed languages: for every signature that specifies a mode-correct bidirectionally typed language, there exists a proof-relevant type synthesiser which, given an input abstract syntax tree, constructs a typing derivation if any, gives its refutation if not, or reports that the input does not have enough type annotations. Sufficient conditions for deriving a type synthesiser such as soundness, completeness, and mode-correctness are studied universally for all signatures. We propose a preprocessing step called mode decoration , which helps the user to deal with missing type annotations. The entire theory is formally implemented in Agda , so we provide a verified generator of proof-relevant type synthesisers as a by-product of our formalism.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Liang-Ting", + "last_name": "Chen", + "institution": "Institute of Information Science, Academia Sinica" + }, + { + "first_name": "Hsiang−Shang", + "last_name": "Ko", + "institution": "Institute of Information Science, Academia Sinica" + } + ], + "dblp_key": "conf/esop/ChenK24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_7", + "title": "Artifact report: Generic bidirectional typing for dependent type theories", + "abstract": "Abstract We report on the implementation of a generic bidirectional algorithm for dependent type theories, following the proposal of the paper \"Generic bidirectional typing for dependent type theories\".", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Thiago", + "last_name": "Felicissimo", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/esop/Felicissimo24a", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_14", + "title": "Artifact Description - Definitional Functoriality for Dependent (Sub)Types", + "abstract": "Abstract This document describes the Coq formalisation accompanying the paper Definitional Functoriality for Dependent (Sub)Types , more specifically the content of section 4.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Théo", + "last_name": "Laurent", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Meven", + "last_name": "Lennon-Bertrand", + "institution": "University of Cambridge" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/LaurentLM24a", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_2", + "title": "On the Hardness of Analyzing Quantum Programs Quantitatively", + "abstract": "Abstract In this paper, we study quantitative properties of quantum programs. Properties of interest include (positive) almost-sure termination, expected runtime or expected cost, that is, for example, the expected number of applications of a given quantum gate, etc. After studying the completeness of these problems in the arithmetical hierarchy over the Clifford+T fragment of quantum mechanics, we express these problems using a variation of a quantum pre-expectation transformer, a weakest pre-condition based technique that allows to symbolically compute these quantitative properties. Under a smooth restriction—a restriction to polynomials of bounded degree over a real closed field—we show that the quantitative problem, which consists in finding an upper-bound to the pre-expectation, can be decided in time double-exponential in the size of a program, thus providing, despite its great complexity, one of the first decidable results on the analysis and verification of quantum programs. Finally, we sketch how the latter can be transformed into an efficient synthesis method.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Avanzini", + "institution": "Université Côte d'Azur" + }, + { + "first_name": "Georg", + "last_name": "Moser", + "institution": "Universität Innsbruck" + }, + { + "first_name": "Romain", + "last_name": "Péchoux", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Simon", + "last_name": "Perdrix", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/AvanziniMPP24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_8", + "title": "Deciding Subtyping for Asynchronous Multiparty Sessions", + "abstract": "Abstract Multiparty session types (MSTs) are a type-based approach to verifying communication protocols, represented as global types in the framework. We present a precise subtyping relation for asynchronous MSTs with communicating state machines (CSMs) as implementation model. We address two problems: when can a local implementation safely substitute another, and when does an arbitrary CSM implement a global type? We define safety with respect to a given global type, in terms of subprotocol fidelity and deadlock freedom. Our implementation model subsumes existing work which considers local types with restricted choice. We exploit the connection between MST subtyping and refinement to formulate concise conditions that are directly checkable on the candidate implementations, and use them to show that both problems are decidable in polynomial time.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Elaine", + "last_name": "Li", + "institution": "New York University" + }, + { + "first_name": "Felix", + "last_name": "Stutz", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "conf/esop/LiSW24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_11", + "title": "Artifact Report: Trocq: Proof Transfer for Free, With or Without Univalence", + "abstract": "Abstract Trocq [5] is both the name of a calculus, describing a parametricity framework, and of a plugin [6] that provides tactics for performing representation changes in goals, as well as vernacular commands for specifying the expected translations.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Cyril", + "last_name": "Cohen", + "institution": "Université Côte d'Azur" + }, + { + "first_name": "Enzo", + "last_name": "Crance", + "institution": "Laboratoire des Sciences du Numérique de Nantes" + }, + { + "first_name": "Assia", + "last_name": "Mahboubi", + "institution": "École Centrale de Nantes" + } + ], + "dblp_key": "conf/esop/CohenCM24a", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_2", + "title": "Monadic Intersection Types, Relationally", + "abstract": "Abstract We extend intersection types to a computational $$\\lambda $$ λ -calculus with algebraic operations à la Plotkin and Power. We achieve this by considering monadic intersections—whereby computational effects appear not only in the operational semantics, but also in the type system . Since in the effectful setting termination is not anymore the only property of interest, we want to analyze the interactive behavior of typed programs with the environment. Indeed, our type system is able to characterize the natural notion of observation, both in the finite and in the infinitary setting, and for a wide class of effects, such as output, cost, pure and probabilistic nondeterminism, and combinations thereof. The main technical tool is a novel combination of syntactic techniques with abstract relational reasoning, which allows us to lift all the required notions, e.g. of typability and logical relation, to the monadic setting.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Francesco", + "last_name": "Gavazzo", + "institution": "University of Padua" + }, + { + "first_name": "Riccardo", + "last_name": "Treglia", + "institution": "King's College London" + }, + { + "first_name": "Gabriele", + "last_name": "Vanoni", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "conf/esop/GavazzoTV24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_9", + "title": "The Session Abstract Machine", + "abstract": "Abstract We build on a fine-grained analysis of session-based interaction as provided by the linear logic typing disciplines to introduce the SAM, an abstract machine for mechanically executing session-typed processes. A remarkable feature of the SAM’s design is its ability to naturally segregate and coordinate sequential with concurrent session behaviours. In particular, implicitly sequential parts of session programs may be efficiently executed by deterministic sequential application of SAM transitions, amenable to compilation, and without concurrent synchronisation mechanisms. We provide an intuitive discussion of the SAM structure and its underlying design, and state and prove its correctness for executing programs in a session calculus corresponding to full classical linear logic $$\\textsf{CLL}$$ CLL . We also discuss extensions and applications of the SAM to the execution of linear and session-based programming languages.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Luı́s", + "last_name": "Caires", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "conf/esop/CairesT24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_6", + "title": "Generic bidirectional typing for dependent type theories", + "abstract": "Abstract Bidirectional typing is a discipline in which the typing judgment is decomposed explicitly into inference and checking modes, allowing to control the flow of type information in typing rules and to specify algorithmically how they should be used. Bidirectional typing has been fruitfully studied and bidirectional systems have been developed for many type theories. However, the formal development of bidirectional typing has until now been kept confined to specific theories, with general guidelines remaining informal. In this work, we give a generic account of bidirectional typing for a general class of dependent type theories. This is done by first giving a general definition of type theories (or equivalently, a logical framework), for which we define declarative and bidirectional type systems. We then show, in a theory-independent fashion, that the two systems are equivalent. This equivalence is then explored to establish the decidability of typing for weak normalizing theories, yielding a generic type-checking algorithm that has been implemented in a prototype and used in practice with many theories.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Thiago", + "last_name": "Felicissimo", + "institution": "Université Paris-Saclay" + } + ], + "dblp_key": "conf/esop/Felicissimo24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_10", + "title": "Trocq: Proof Transfer for Free, With or Without Univalence", + "abstract": "Abstract This article presents Trocq , a new proof transfer framework for dependent type theory. Trocq is based on a novel formulation of type equivalence, used to generalize the univalent parametricity translation. This framework takes care of avoiding dependency on the axiom of univalence when possible, and may be used with more relations than just equivalences. We have implemented a corresponding plugin for the interactive theorem prover, in the meta-language.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Cyril", + "last_name": "Cohen", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Enzo", + "last_name": "Crance", + "institution": "École Centrale de Nantes" + }, + { + "first_name": "Assia", + "last_name": "Mahboubi", + "institution": "École Centrale de Nantes" + } + ], + "dblp_key": "conf/esop/CohenCM24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_3", + "title": "Layered Modal Type Theory - Where Meta-programming Meets Intensional Analysis", + "abstract": "Abstract We introduce layering to modal type theory to combine type theory with intensional analysis. In particular, we demonstrate this idea by developing a 2-layered modal type theory. At the core of this type theory (layer 0) is a simply typed $$\\lambda $$ λ -calculus with no modality. Layer 1 is obtained by extending the core language with one layer of contextual $$\\square $$ □ types to support pattern matching on potentially open code from layer 0 while retaining normalization. Although both layers fundamentally share the same language and the same typing judgment, we only allow computation at layer 1. As a consequence, layer 0 accurately captures the syntactic representation of code in contrast to the computational behaviors at layer 1. The system is justified by normalization by evaluation (NbE) using a presheaf model. The normalization algorithm extracted from the model is sound and complete and is implemented in Agda. Layered modal type theory provides a uniform foundation for meta-programming with intensional analysis. We see this work as an important step towards a foundational way to support meta-programming in proof assistants.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jason Z. S.", + "last_name": "Hu", + "institution": "McGill University" + }, + { + "first_name": "Brigitte", + "last_name": "Pientka", + "institution": "McGill University" + } + ], + "dblp_key": "conf/esop/HuP24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_1", + "title": "Scoped Effects as Parameterized Algebraic Theories", + "abstract": "Abstract Notions of computation can be modelled by monads. Algebraic effects offer a characterization of monads in terms of algebraic operations and equational axioms, where operations are basic programming features, such as reading or updating the state, and axioms specify observably equivalent expressions. However, many useful programming features depend on additional mechanisms such as delimited scopes or dynamically allocated resources. Such mechanisms can be supported via extensions to algebraic effects including scoped effects and parameterized algebraic theories . We present a fresh perspective on scoped effects by translation into a variation of parameterized algebraic theories. The translation enables a new approach to equational reasoning for scoped effects and gives rise to an alternative characterization of monads in terms of generators and equations involving both scoped and algebraic operations. We demonstrate the power of our fresh perspective by way of equational characterizations of several known models of scoped effects.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" + }, + { + "first_name": "Cristina", + "last_name": "Matache", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sean", + "last_name": "Moss", + "institution": "University of Birmingham" + }, + { + "first_name": "Sam", + "last_name": "Staton", + "institution": "University of Oxford" + }, + { + "first_name": "Nicolas", + "last_name": "Wu", + "institution": "Imperial College London" + }, + { + "first_name": "Zhixuan", + "last_name": "Yang", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/esop/LindleyMMSWY24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_13", + "title": "Definitional Functoriality for Dependent (Sub)Types", + "abstract": "Abstract Dependently typed proof assistant rely crucially on definitional equality, which relates types and terms that are automatically identified in the underlying type theory. This paper extends type theory with definitional functor laws , equations satisfied propositionally by a large class of container-like type constructors $$F : {\\text {Type}}\\rightarrow {\\text {Type}}$$ F : Type → Type , equipped with a $$\\textrm{map}_{F} {{\\,\\mathrm{:}\\,}}(A \\rightarrow B) \\rightarrow F\\,A \\rightarrow F\\,B$$ map F : ( A → B ) → F A → F B , such as lists or trees. Promoting these equations to definitional ones strengthens the theory, enabling slicker proofs and more automation for functorial type constructors. This extension is used to modularly justify a structural form of coercive subtyping, propagating subtyping through type formers in a map-like fashion. We show that the resulting notion of coercive subtyping, thanks to the extra definitional equations, is equivalent to a natural and implicit form of subsumptive subtyping. The key result of decidability of type-checking in a dependent type system with functor laws for lists has been entirely mechanized in Coq .", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Théo", + "last_name": "Laurent", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Meven", + "last_name": "Lennon-Bertrand", + "institution": "University of Cambridge" + }, + { + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/LaurentLM24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_12", + "title": "Observational Equality Meets CIC", + "abstract": "Abstract Equality is at the heart of dependent type theory, as it plays a fundamental role in specifications and mathematical reasoning. The standard way to handle it in mainstream proof assistants such as Agda , Lean or Coq is based on Martin-Löf’s identity type, which comes straight out of the ’70s—its elegance and simplicity have earned it a long-standing use, despite a major discrepancy with traditional mathematical formulations: it does not satisfy any extensionality principles. Recently, the work on observational equality has regained interest as a new way to encode equality in proof assistants that support a universe of definitionally proof-irrelevant propositions; however it has yet to be integrated in any major proof assistant, because it is not fully compatible with another important feature of type theory: indexed inductive types. In this paper, we propose a systematic integration of indexed inductive types with an observational equality, and show that this integration can only be completely satisfactory if the observational equality satisfies the computational rule of Martin-Löf’s identity type. The second contribution of this paper is a formal proof that this additional computation rule, although not present in previous works on observational equality, can be integrated to the system without compromising the decidability of conversion.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Loïc", + "last_name": "Pujet", + "institution": "Stockholm University" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Laboratoire des Sciences du Numérique de Nantes" + } + ], + "dblp_key": "conf/esop/PujetT24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_1", + "title": "Circuit Width Estimation via Effect Typing and Linear Dependency", + "abstract": "Abstract Circuit description languages are a class of quantum programming languages in which programs are classical and produce a description of a quantum computation, in the form of a quantum circuit . Since these programs can leverage all the expressive power of high-level classical languages, circuit description languages have been successfully used to describe complex and practical quantum algorithms, whose circuits, however, may involve many more qubits and gate applications than current quantum architectures can actually muster. In this paper, we present , a circuit description language endowed with a linear dependent type-and-effect system capable of deriving parametric upper bounds on the width of the circuits produced by a program. We prove both the standard type safety results and that the resulting resource analysis is correct with respect to a big-step operational semantics. We also show that our approach is expressive enough to verify realistic quantum algorithms.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Andrea", + "last_name": "Colledan", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/ColledanL24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57262-3_4", + "title": "Program Synthesis from Graded Types", + "abstract": "Abstract Graded type systems are a class of type system for fine-grained quantitative reasoning about data-flow in programs. Through the use of resource annotations (or grades ), a programmer can express various program properties at the type level, reducing the number of typeable programs. These additional constraints on types lend themselves naturally to type-directed program synthesis , where this information can be exploited to constrain the search space of programs. We present a synthesis algorithm for a graded type system, where grades form an arbitrary pre-ordered semiring. Harnessing this grade information in synthesis is non-trivial, and we explore some of the issues involved in designing and implementing a resource-aware program synthesis tool. In our evaluation we show that by harnessing grades in synthesis, the majority of our benchmark programs (many of which involve recursive functions over recursive ADTs) require less exploration of the synthesis search space than a purely type-driven approach and with fewer needed input-output examples. This type-and-graded-directed approach is demonstrated for the research language Granule but we also adapt it for synthesising Haskell programs that use GHC’s linear types extension.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57262-3_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jack", + "last_name": "Hughes", + "institution": "University of Kent" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/esop/HughesO24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_3", + "title": "Reconciling Partial and Local Invertibility", + "abstract": "Abstract Invertible programming languages specify transformations to be run in two directions, such as compression/decompression or encryption/decryption. Two key concepts in invertible programming languages are partial invertibility and local invertibility . Partial invertibility lets invertible code be parameterized by the results of non-invertible code, whereas local invertibility requires all code to be invertible. The former allows for more flexible programming, while the latter has connections to domains such as low-energy computing and quantum computing. We find that existing approaches lack a satisfying treatment of partial invertibility, leaving the connection to local invertibility unclear. In this paper, we identify four core constructs for partially invertible programming, and show how to give them a locally invertible interpretation. We show the expressiveness of the constructs by designing the functional invertible language Kalpis , and show how to give them a locally invertible semantics using the novel arrow combinator language $$\\textsc {rrArr}$$ R R A R R —the key idea is viewing partial invertibility as an invertible effect. By formalizing the two systems and giving Kalpis semantics by translation to $$\\textsc {rrArr}$$ R R A R R , we reconcile partial and local invertibility, solving an open problem in the field. All formal developments are mechanized in Agda.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Anders Ågren", + "last_name": "Thuné", + "institution": "Tohoku University" + }, + { + "first_name": "Kazutaka", + "last_name": "Matsuda", + "institution": "Tohoku University" + }, + { + "first_name": "Meng", + "last_name": "Wang", + "institution": "University of Bristol" + } + ], + "dblp_key": "conf/esop/ThuneMW24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_4", + "title": "Efficient Matching with Memoization for Regexes with Look-around and Atomic Grouping", + "abstract": "Abstract Regular expression (regex) matching is fundamental in many applications, especially in web services. However, matching by backtracking —preferred by most real-world implementations for its practical performance and backward compatibility—can suffer from so-called catastrophic backtracking , which makes the number of backtracking super-linear and leads to the well-known ReDoS vulnerability. Inspired by a recent algorithm by Davis et al. that runs in linear time for (non-extended) regexes, we study efficient backtracking matching for regexes with two common extensions, namely look-around and atomic grouping . We present linear-time backtracking matching algorithms for these extended regexes. Their efficiency relies on memoization , much like the one by Davis et al.; we also strive for smaller memoization tables by carefully trimming their range. Our experiments—we used some real-world regexes with the aforementioned extensions—confirm the performance advantage of our algorithms.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Hiroya", + "last_name": "Fujinami", + "institution": "National Institute of Informatics" + }, + { + "first_name": "Ichiro", + "last_name": "Hasuo", + "institution": "National Institute of Informatics" + } + ], + "dblp_key": "conf/esop/FujinamiH24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_9", + "title": "Hyperproperty Verification as CHC Satisfiability", + "abstract": "Abstract Hyperproperties specify the behavior of a system across multiple executions, and are an important extension of regular temporal properties. So far, such properties have resisted comprehensive treatment by software model-checking approaches such as IC3/PDR, due to the need to find not only an inductive invariant but also a total alignment of different executions that facilitates simpler inductive invariants. We show how this treatment is achieved via a reduction from the verification problem of $$\\forall ^*\\exists ^*$$ ∀ ∗ ∃ ∗ hyperproperties to Constrained Horn Clauses (CHCs). Our starting point is a set of universally quantified formulas in first-order logic (modulo theories) that encode the verification of $$\\forall ^*\\exists ^*$$ ∀ ∗ ∃ ∗ hyperproperties over infinite-state transition systems. The first-order encoding uses uninterpreted predicates to capture the (1) witness function for existential quantification over traces, (2) alignment of executions, and (3) corresponding inductive invariant. Such an encoding was previously proposed for k -safety properties. Unfortunately, finding a satisfying model for the resulting first-order formulas is beyond reach for modern first-order satisfiability solvers. Previous works tackled this obstacle by developing specialized solvers for the aforementioned first-order formulas. In contrast, we show that the same problems can be encoded as CHCs and solved by existing CHC solvers. CHC solvers take advantage of the unique structure of CHC formulas and handle the combination of quantifiers with theories and uninterpreted predicates more efficiently. Our key technical contribution is a logical transformation of the aforementioned sets of first-order formulas to equi-satisfiable sets of CHCs. The transformation to CHCs is sound and complete, and applying it to the first-order formulas that encode verification of hyperproperties leads to a CHC encoding of these problems. We implemented the CHC encoding in a prototype tool and show that, using existing CHC solvers for solving the CHCs, the approach already outperforms state-of-the-art tools for hyperproperty verification by orders of magnitude.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Shachar", + "last_name": "Itzhaky", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + }, + { + "first_name": "Yakir", + "last_name": "Vizel", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/esop/ItzhakySV24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_5", + "title": "A Denotational Approach to Release/Acquire Concurrency", + "abstract": "Abstract We present a compositional denotational semantics for a functional language with first-class parallel composition and shared-memory operations whose operational semantics follows the Release/Acquire weak memory model (RA). The semantics is formulated in Moggi’s monadic approach, and is based on Brookes-style traces. To do so we adapt Brookes’s traces to Kang et al.’s view-based machine for RA, and supplement Brookes’s mumble and stutter closure operations with additional operations, specific to RA. The latter provides a more nuanced understanding of traces that uncouples them from operational interrupted executions. We show that our denotational semantics is adequate and use it to validate various program transformations of interest. This is the first work to put weak memory models on the same footing as many other programming effects in Moggi’s standard monadic approach.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Yotam", + "last_name": "Dvir", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Edinburgh" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "conf/esop/DvirKL24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_6", + "title": "Intel PMDK Transactions: Specification, Validation and Concurrency", + "abstract": "Abstract Software Transactional Memory (STM) is an extensively studied paradigm that provides an easy-to-use mechanism for thread safety and concurrency control. With the recent advent of byte-addressable persistent memory, a natural question to ask is whether STM systems can be adapted to support failure atomicity . In this paper, we answer this question by showing how STM can be easily integrated with Intel’s Persistent Memory Development Kit (PMDK) transactional library (which we refer to as txPMDK ) to obtain STM systems that are both concurrent and persistent. We demonstrate this approach using known STM systems, TML and NOrec , which when combined with txPMDK result in persistent STM systems, referred to as PMDK-TML and PMDK-NORec , respectively. However, it turns out that existing correctness criteria are insufficient for specifying the behaviour of txPMDK and our concurrent extensions. We therefore develop a new correctness criterion, dynamic durable opacity , that extends the previously defined notion of durable opacity with dynamic memory allocation. We provide a model of txPMDK , then show that this model satisfies dynamic durable opacity. Moreover, dynamic durable opacity supports concurrent transactions, thus we also use it to show correctness of both PMDK-TML and PMDK-NORec .", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Piotr", + "last_name": "Balcer", + "institution": "Intel (Poland)" + }, + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "University of Surrey" + } + ], + "dblp_key": "conf/esop/RaadLWBD24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_14", + "title": "A Modular Soundness Theory for the Blackboard Analysis Architecture", + "abstract": "Abstract Sound static analyses are an important ingredient for compiler optimizations and program verification tools. However, mathematically proving that a static analysis is sound is a difficult task due to two problems. First, soundness proofs relate two complicated program semantics (the static and the dynamic semantics) which are hard to reason about. Second, the more the static and dynamic semantics differ, the more work a soundness proof needs to do to bridge the impedance mismatch. These problems increase the effort and complexity of soundness proofs. Existing soundness theories address these problems by deriving both the dynamic and static semantics from the same artifact, often called generic interpreter . A generic interpreter provides a common structure along which a soundness proof can be composed, which avoids having to reason about the analysis as a whole. However, a generic interpreter restricts which analyses can be derived, as all derived analyses must roughly follow the program execution order. To lift this restriction, we develop a soundness theory for the blackboard analysis architecture, which is capable of describing backward, demand-driven, and summary-based analyses. The architecture describes static analyses with small independent modules, which communicate via a central store. Soundness of a compound analysis follows from soundness of all of its modules. Furthermore, modules can be proven sound independently, even though modules depend on each other. We evaluate our theory by proving soundness of four analyses: a pointer and call-graph analysis, a reflection analysis, an immutability analysis, and a demand-driven reaching definitions analysis.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sven", + "last_name": "Keidel", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Dominik", + "last_name": "Helm", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Tobias", + "last_name": "Roth", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technische Universität Darmstadt" + } + ], + "dblp_key": "conf/esop/KeidelHRM24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_15", + "title": "Detection of Uncaught Exceptions in Functional Programs by Abstract Interpretation", + "abstract": "Abstract Exception handling is a key feature in modern programming languages. Exceptions can be used to deal with errors, or as a means to control the flow of execution of a program. Since they might unexpectedly terminate a program, unhandled exceptions are a serious safety concern. We propose a static analysis to detect uncaught exceptions in functional programs, that is defined as an abstract interpreter. It computes a description of the values potentially returned by a program using a novel abstract domain, that can express inductively defined sets of values. Simultaneously, the analysis infers the possibly raised exceptions, by computing in the abstract exception monad . This abstract interpreter has been implemented as an effective static analyser for a large subset of programs, that supports mutable data types, the module system, and dynamically extensible data types such as the exception type. The analyser has been evaluated on several hundreds of programs.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Lermusiaux", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Benoît", + "last_name": "Montagu", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/LermusiauxM24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_10", + "title": "Maximal Quantified Precondition Synthesis for Linear Array Loops", + "abstract": "Abstract Precondition inference is an important problem with many applications in verification and testing. Finding preconditions can be tricky as programs often have loops and arrays, which necessitates finding quantified inductive invariants. However, existing techniques have limitations in finding such invariants, especially when preconditions are missing. Further, maximal (or weakest) preconditions are often required to maximize the usefulness of preconditions. So the inferred inductive invariants have to be adequately weak. To address these challenges, we present an approach for maximal quantified precondition inference using an infer-check-weaken framework. Preconditions and inductive invariants are inferred by a novel technique called range abduction , and then checked for maximality and weakened if required. Range abduction attempts to propagate the given quantified postcondition backwards and then strengthen or weaken it as needed to establish inductiveness. Weakening is done in a syntax-guided fashion. Our evaluation performed on a set of public benchmarks demonstrates that the technique significantly outperforms existing techniques in finding maximal preconditions and inductive invariants.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sumanth", + "last_name": "Prabhu", + "institution": "Tata Consultancy Services (India)" + }, + { + "first_name": "Grigory", + "last_name": "Fedyukovich", + "institution": "Florida State University" + }, + { + "first_name": "Deepak", + "last_name": "D’Souza", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/esop/PrabhuFD24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_11", + "title": "Verified Inlining and Specialisation for PureCake", + "abstract": "Abstract Inlining is a crucial optimisation when compiling functional programming languages. This paper describes how we have implemented and verified function inlining and loop specialisation for PureCake, a verified compiler for a Haskell-like (purely functional, lazy) programming language. A novel aspect of our formalisation is that we justify inlining by pushing and pulling \"Image missing\"-bindings. All of our work has been mechanised in the HOL4 interactive theorem prover.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Hrutvik", + "last_name": "Kanabar", + "institution": "University of Kent" + }, + { + "first_name": "Kacper", + "last_name": "Korban", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Magnus O.", + "last_name": "Myreen", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/esop/KanabarKM24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_13", + "title": "Higher-Order LCTRSs and Their Termination", + "abstract": "Abstract Logically constrained term rewriting systems (LCTRSs) are a formalism for program analysis with support for data types that are not (co)inductively defined. Only imperative programs have been considered through the lens of LCTRSs so far since LCTRSs were introduced as a first-order formalism. In this paper, we propose logically constrained simply-typed term rewriting systems (LCSTRSs), a higher-order generalization of LCTRSs, which suits the needs of representing and analyzing functional programs. We also study the termination problem of LCSTRSs and define a variant of the higher-order recursive path ordering (HORPO) for the newly proposed formalism.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Liye", + "last_name": "Guo", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Cynthia", + "last_name": "Kop", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "conf/esop/GuoK24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_12", + "title": "Suspension Analysis and Selective Continuation-Passing Style for Universal Probabilistic Programming Languages", + "abstract": "Abstract Universal probabilistic programming languages (PPLs) make it relatively easy to encode and automatically solve statistical inference problems. To solve inference problems, PPL implementations often apply Monte Carlo inference algorithms that rely on execution suspension. State-of-the-art solutions enable execution suspension either through (i) continuation-passing style (CPS) transformations or (ii) efficient, but comparatively complex, low-level solutions that are often not available in high-level languages. CPS transformations introduce overhead due to unnecessary closure allocations—a problem the PPL community has generally overlooked. To reduce overhead, we develop a new efficient selective CPS approach for PPLs. Specifically, we design a novel static suspension analysis technique that determines parts of programs that require suspension, given a particular inference algorithm. The analysis allows selectively CPS transforming the program only where necessary. We formally prove the correctness of the analysis and implement the analysis and transformation in the Miking CorePPL compiler. We evaluate the implementation for a large number of Monte Carlo inference algorithms on real-world models from phylogenetics, epidemiology, and topic modeling. The evaluation results demonstrate significant improvements across all models and inference algorithms.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Daniel", + "last_name": "Lundén", + "institution": "" + }, + { + "first_name": "Lars", + "last_name": "Hummelgren", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Jan", + "last_name": "Kudlicka", + "institution": "BI Norwegian Business School" + }, + { + "first_name": "Oscar", + "last_name": "Eriksson", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "David", + "last_name": "Broman", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/esop/LundenHKEB24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_7", + "title": "Artifact Report: Intel PMDK Transactions: Specification, Validation and Concurrency", + "abstract": "Abstract This report extends §6 of the main paper by providing further details of the mechanisation effort.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Piotr", + "last_name": "Balcer", + "institution": "Intel (Poland)" + }, + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "University of Surrey" + } + ], + "dblp_key": "conf/esop/RaadLWBD24a", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_8", + "title": "Specifying and Verifying Persistent Libraries", + "abstract": "Abstract We present a general framework for specifying and verifying persistent libraries , that is, libraries of data structures that provide some persistency guarantees upon a failure of the machine they are executing on. Our framework enables modular reasoning about the correctness of individual libraries (horizontal and vertical compositionality) and is general enough to encompass all existing persistent library specifications ranging from hardware architectural specifications to correctness conditions such as durable linearizability. As case studies, we specify the and libraries, verify their implementations over \"Image missing\", and use them to build higher-level durably linearizable libraries, all within our framework. We also specify and verify a persistent transaction library that highlights some of the technical challenges which are specific to persistent memory compared to weak memory and how they are handled by our framework.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/esop/StefanescoRV24", + "venue": "esop", + "year": 2024 + }, + { + "paper_id": "10.1007/978-3-031-57267-8_16", + "title": "Formalizing Date Arithmetic and Statically Detecting Ambiguities for the Law", + "abstract": "Abstract Legal expert systems routinely rely on date computations to determine the eligibility of a citizen to social benefits or whether an application has been filed on time. Unfortunately, date arithmetic exhibits many corner cases, which are handled differently from one library to the other, making faithfully transcribing the law into code error-prone, and possibly leading to heavy financial and legal consequences for users. In this work, we aim to provide a solid foundation for date arithmetic working on days, months and years. We first present a novel, formal semantics for date computations, and formally establish several semantic properties through a mechanization in the F $$^\\star $$ ⋆ proof assistant. Building upon this semantics, we then propose a static analysis by abstract interpretation to automatically detect ambiguities in date computations. We finally integrate our approach in the Catala language, a recent domain-specific language for formalizing computational law, and use it to analyze the Catala implementation of the French housing benefits, leading to the discovery of several date-related ambiguities.", + "date": "2024-01-01", + "link": "https://doi.org/10.1007/978-3-031-57267-8_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Raphaël", + "last_name": "Monat", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Aymeric", + "last_name": "Fromherz", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Denis", + "last_name": "Merigoux", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/MonatFM24", + "venue": "esop", + "year": 2024 + } +] \ No newline at end of file diff --git a/data/pl_conferences/esop/2025.json b/data/pl_conferences/esop/2025.json new file mode 100644 index 0000000..7a100be --- /dev/null +++ b/data/pl_conferences/esop/2025.json @@ -0,0 +1,953 @@ +[ + { + "paper_id": "10.1007/978-3-031-91118-7_13", + "title": "A Program Logic for Concurrent Randomized Programs in the Oblivious Adversary Model", + "abstract": "Abstract Concurrent randomized programs in the oblivious adversary model are extremely difficult for modular verification because the interaction between threads is very sensitive to the program structure and the execution steps. We propose a new program logic supporting thread-local verification. With a novel “split” mechanism, one can split the state distribution into smaller partitions, and the reasoning can be done based on each partition independently, which allows us to avoid considering different execution paths of branch statements simultaneously. The logic rules are compositional and are natural extensions of their sequential counterparts. Using our program logic, we verify four typical algorithms in the oblivious adversary model.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Weijie", + "last_name": "Fan", + "institution": "Nanjing University" + }, + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "Nanjing University" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Nanjing University" + }, + { + "first_name": "Hanru", + "last_name": "Jiang", + "institution": "Institute of Mathematical Sciences" + } + ], + "dblp_key": "conf/esop/FanLFJ25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_3", + "title": "Sufficient Conditions for Robustness of RDMA Programs", + "abstract": "Abstract Remote Direct Memory Access (RDMA) is a modern technology enabling high-performance inter-node communication. Despite its widespread adoption, theoretical understanding of permissible behaviours remains limited, as RDMA follows a very weak memory model. This paper addresses the challenge of establishing sufficient conditions for RDMA robustness. We introduce a set of straightforward criteria that, when met, guarantee sequential consistency and mitigate potential issues arising from weak memory behaviours in RDMA applications. Notably, when restricted to a tree topology, these conditions become even more relaxed, significantly reducing the need for synchronisation primitives. This work provides developers with practical guidelines to ensure the reliability and correctness of their RDMA-based systems.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Guillaume", + "last_name": "Ambal", + "institution": "Imperial College London" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/esop/AmbalLR25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_14", + "title": "Iso-Recursive Multiparty Sessions and their Automated Verification", + "abstract": "Abstract \"Image missing\"\"Image missing\" Most works on session types take an equi-recursive approach and do not distinguish among a recursive type and its unfolding. This becomes more important in recent type systems which do not require global types, also known as generalised multiparty session types (GMST). In GMST, in order to establish properties as deadlock-freedom, the environments which type processes are assumed to satisfy extensional properties holding in all infinite sequences. This is a problem because: (1) the mechanisation of GMST and equi-recursion in proof assistants is utterly complex and eventually requires co-induction; and (2) the implementation of GMST in type checkers relies on model checkers for environment verification, and thus the program analysis is not self-contained. In this paper, we overcome these limitations by providing an iso-recursive typing system that computes the behavioural properties of environments . The type system relies on a terminating function named compliance that computes all final redexes of an environment, and determines when these redexes do not contain mismatches or deadlocks: compliant environments cannot go wrong . The function is defined theoretically by introducing the novel notions of deterministic LTS of environments and of environment closure, and can be implemented in mainstream programming languages and compilers. We showcase an implementation in OCaml by using exception handling to tackle the inherent non-determinism of synchronisation of branching and selection types. We assess that the implementation provides the desired properties, namely absence of mismatches and of deadlocks in environments, by resorting to automated deductive verification performed in tools of the OCaml ecosystem relying on Why3.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Marco", + "last_name": "Giunti", + "institution": "University of Oxford" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/esop/GiuntiY25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_9", + "title": "Neural Network Verification is a Programming Language Challenge", + "abstract": "Abstract Neural network verification is a new and rapidly developing field of research. So far, the main priority has been establishing efficient verification algorithms and tools, while proper support from the programming language perspective has been considered secondary or unimportant. Yet, there is mounting evidence that insights from the programming language community may make a difference in the future development of this domain. In this paper, we formulate neural network verification challenges as programming language challenges and suggest possible future solutions.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Lucas C.", + "last_name": "Cordeiro", + "institution": "University of Manchester" + }, + { + "first_name": "Matthew L.", + "last_name": "Daggitt", + "institution": "University of Western Australia" + }, + { + "first_name": "Julien", + "last_name": "Girard-Satabin", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Omri", + "last_name": "Isac", + "institution": "Hebrew University of Jerusalem" + }, + { + "first_name": "Taylor T.", + "last_name": "Johnson", + "institution": "Vanderbilt University" + }, + { + "first_name": "Guy", + "last_name": "Katz", + "institution": "Hebrew University of Jerusalem" + }, + { + "first_name": "Ekaterina", + "last_name": "Komendantskaya", + "institution": "Heriot-Watt University" + }, + { + "first_name": "Augustin", + "last_name": "Lemesle", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Edoardo", + "last_name": "Manino", + "institution": "University of Manchester" + }, + { + "first_name": "Artjoms", + "last_name": "Šinkarovs", + "institution": "University of Southampton" + }, + { + "first_name": "Haoze", + "last_name": "Wu", + "institution": "Amherst College" + } + ], + "dblp_key": "conf/esop/CordeiroDGIJKKLMSW25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_1", + "title": "The Vanilla Sequent Calculus is Call-by-Value", + "abstract": "Abstract Existing Curry-Howard interpretations of call-by-value evaluation for the $$\\lambda $$ λ -calculus are either based on ad-hoc modifications of intuitionistic proof systems or involve additional logical concepts such as classical logic or linear logic, despite the fact that call-by-value was introduced in an intuitionistic setting without linear features. This paper shows that the most basic sequent calculus for minimal intuitionistic logic—dubbed here vanilla —can naturally be seen as a logical interpretation of call-by-value evaluation. This is obtained by establishing mutual simulations with a well-known formalism for call-by-value evaluation.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Beniamino", + "last_name": "Accattoli", + "institution": "École Polytechnique" + } + ], + "dblp_key": "conf/esop/Accattoli25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_5", + "title": "Abstraction of memory block manipulations by symbolic loop folding", + "abstract": "Abstract We introduce a new abstract domain for analyzing memory block manipulations, focusing on programs with dynamically allocated arrays. This domain computes properties universally quantified over the value of the loop counters, both for assignments and tests. These properties consist of equalities and comparison predicates involving abstract expressions, represented as affine forms in the loop counters and symbolic dereferences. All these methods have been incorporated within the © static analyzer that checks for the absence of run-time errors in embedded critical software. We also give insights on how to implement this abstract domain within any other C static analyzer.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jérôme", + "last_name": "Boillot", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jérôme", + "last_name": "Ferêt", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/BoillotF25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_10", + "title": "Stratified Type Theory", + "abstract": "Abstract A hierarchy of type universes is a rudimentary ingredient in the type theories of many proof assistants to prevent the logical inconsistency resulting from combining dependent functions and the type-in-type axiom. In this work, we argue that a universe hierarchy is not the only option for universes in type theory. Taking inspiration from Leivant’s Stratified System F, we introduce Stratified Type Theory (), where rather than stratifying universes by levels, we stratify typing judgements and restrict the domain of dependent functions to strictly lower levels. Even with type-in-type, this restriction suffices to enforce consistency. In , we consider a number of extensions beyond just stratified dependent functions. First, the subsystem employs McBride’s crude-but-effective stratification (also known as displacement) as a simple form of level polymorphism where global definitions with concrete levels can be displaced uniformly to any higher level. Second, to recover some expressivity lost due to the restriction on dependent function domains, the full includes a separate nondependent function type with a floating domain whose level matches that of the overall function type. Finally, we have implemented a prototype type checker for extended with datatypes and inference for level and displacement annotations, along with a small core library. We have proven to be consistent and to be type safe, but consistency of the full remains an open problem, largely due to the interaction between floating functions and cumulativity of judgements. Nevertheless, we believe to be consistent, and as evidence have verified the ill-typedness of some well-known type-theoretic paradoxes using our implementation.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Chan", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/esop/ChanW25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_6", + "title": "Cognacy Queries over Dependence Graphs for Transparent Visualisations", + "abstract": "Abstract Charts, figures, and text derived from data play an important role in decision making. But making sense of or fact-checking outputs means understanding how they relate to the underlying data. Even for experts with access to the source code and data sets, this poses a significant challenge. We introduce a new program analysis framework (A supporting artifact is available at https://zenodo.org/records/14637654 [5].) which supports interactive exploration of fine-grained IO relationships directly through computed outputs, using dynamic dependence graphs. This framework enables a novel notion in data provenance which we call linked inputs , a relation of mutual relevance or cognacy which arises between inputs that contribute to common features of the output. We give a procedure for computing linked inputs over a dependence graph, and show how the presented in this paper is faster on most examples than an implementation based on execution traces.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Joe", + "last_name": "Bond", + "institution": "University of Bristol" + }, + { + "first_name": "Cristina", + "last_name": "David", + "institution": "University of Bristol" + }, + { + "first_name": "Minh Son", + "last_name": "Nguyen", + "institution": "University of Bristol" + }, + { + "first_name": "Dominic", + "last_name": "Orchard", + "institution": "University of Kent" + }, + { + "first_name": "Roly", + "last_name": "Perera", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/esop/BondDNOP25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_7", + "title": "An abstract, certified account of operational game semantics", + "abstract": "Abstract Operational game semantics ( OGS ) is a method for interpreting programs as strategies in suitable games, or more precisely as labelled transition systems over suitable games, in the sense of Levy and Staton. Such an interpretation is called sound when, for any two given programs, weak bisimilarity of associated strategies entails contextual equivalence. OGS has been applied to a variety of languages, with rather tedious soundness proofs. In this paper, we contribute to the unification and mechanisation of OGS . Indeed, we propose an abstract notion of language with evaluator, for which we construct a generic OGS interpretation, which we prove sound. Our framework covers a variety of simply-typed and untyped lambda-calculi with various evaluation strategies. These calculi notably feature recursive definitions, first-class continuations, and a wide variety of datatypes. All constructions and proofs are entirely mechanised in the Coq proof assistant.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Peio", + "last_name": "Borthelle", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Tom", + "last_name": "Hirschowitz", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Guilhem", + "last_name": "Jaber", + "institution": "Laboratoire des Sciences du Numérique de Nantes" + }, + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "Université Claude Bernard Lyon 1" + } + ], + "dblp_key": "conf/esop/BorthelleHJZ25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_16", + "title": "Elucidating Type Conversions in SQL Engines", + "abstract": "Abstract Practical SQL engines differ in subtle ways in their handling of typing constraints and implicit type casts. These issues, usually not considered in formal accounts of SQL, directly affect the portability of queries between engines. To understand this problem, we present a formal typing semantics for SQL, named $$\\textsf{TRAF} $$ TRAF , that explicitly captures both static and dynamic type behavior. The system $$\\textsf{TRAF} $$ TRAF is expressed in terms of abstract operators that provide the necessary leeway to precisely model different SQL engines (PostgreSQL, MS SQL Server, MySQL, SQLite, and Oracle). We show that this formalism provides formal guarantees regarding the handling of types. We provide practical conditions on engines to prove type safety and soundness of queries. In this regard, $$\\textsf{TRAF} $$ TRAF can serve as precise documentation of typing in existing engines and potentially guide their evolution, as well as provide a formal basis to study type-aware query optimizations, and design provably-correct query translators. Additionally, we test the adequacy of the formalism, implementing $$\\textsf{TRAF} $$ TRAF in Python for these five engines, and tested them with thousands of randomly-generated queries.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Wenjia", + "last_name": "Ye", + "institution": "University of Hong Kong" + }, + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + }, + { + "first_name": "Claudio", + "last_name": "Gutiérrez", + "institution": "University of Chile" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/esop/YeTGOT25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_8", + "title": "Artifact Report: an Abstract, Certified Account of Operational Game Semantics", + "abstract": "Abstract This artifact report is a companion to the ESOP’25 paper An abstract, certified account of operational game semantics [3]. The paper describes the construction of a sound model for an abstract notion of language. The model is built using a semantic technique named Operational Game Semantics (OGS) . All our results are mechanised in the Coq proof assistant: this mechanisation (The proof artifact is archived at https://doi.org/10.5281/zenodo.14697618 .) constitutes the artifact we discuss in the present document. More specifically, our mechanisation covers our main result, the soundness of the abstract OGS model w.r.t. substitution equivalence (Theorem 8), as well as four example calculi: two variants of call-by-value $$\\lambda $$ λ -calculus and two variants of $$\\mu \\tilde{\\mu }$$ μ μ ~ -calculus [4, 5]. The only axiom used is the Axiom K [17] for equality proof irrelevance (To ease dependent pattern matching due to the intrinsically scoped representation.). The explains the installation process and the structure of the code. An online rendering ( https://lapin0t.github.io/ogs/esop25/Readme.html .) is available thanks to Alectryon [12]. Furthermore, the main paper provides systematic hyperlinks from statements to their Coq counterparts. We encourage the interested reader to use these tools to navigate the code. In this document, we focus first on users: how to read and instantiate our main result. We then detail salient technical aspects of our mechanisation.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Peio", + "last_name": "Borthelle", + "institution": "Université Savoie Mont Blanc" + }, + { + "first_name": "Tom", + "last_name": "Hirschowitz", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Guilhem", + "last_name": "Jaber", + "institution": "Nantes Université" + }, + { + "first_name": "Yannick", + "last_name": "Zakowski", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/esop/BorthelleHJZ25a", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_4", + "title": "Constructive characterisations of the MUST-preorder for asynchrony", + "abstract": "Abstract De Nicola and Hennessy’s $$\\textsc {must}$$ M U S T -preorder is a liveness preserving refinement which states that a server $$q$$ q refines a server $$p$$ p if all clients satisfied by $$p$$ p are also satisfied by $$q$$ q . Owing to the universal quantification over clients, this definition does not yield a practical proof method, and alternative characterisations are necessary to reason over it. Finding these characterisations for asynchronous semantics, i.e. where outputs are non-blocking, has thus far proven to be a challenge, usually tackled via ad-hoc definitions. We show that the standard characterisations of the $$\\textsc {must}$$ M U S T -preorder carry over as they stand to asynchronous communication, if servers are enhanced to act as forwarders, i.e. they can input any message as long as they store it back into the shared buffer. Our development is constructive, is completely mechanised in Coq, and is independent of any calculus: our results pertain to Selinger output-buffered agents with feedback. This is a class of Labelled Transition Systems that captures programs that communicate via a shared unordered buffer, as in asynchronous CCS or the asynchronous $$\\pi $$ π -calculus. We show that the standard coinductive characterisation lets us prove in Coq that concrete programs are related by the $$\\textsc {must}$$ M U S T -preorder. Finally, our proofs show that Brouwer’s bar induction principle is a useful technique to reason on liveness preserving program transformations.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Giovanni", + "last_name": "Bernardi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Ilaria", + "last_name": "Castellani", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Paul", + "last_name": "Laforgue", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Léo", + "last_name": "Stefanesco", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/esop/BernardiCLS25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_15", + "title": "Verifying Algorithmic Versions of the Lovász Local Lemma", + "abstract": "Abstract Algorithmic versions of the Lovász Local Lemma (ALLLs), or rather, the Moser-Tardos algorithm and its variants, are impactful in both theory and practice. In this paper, we take the first step towards the goal of formally verifying ALLLs by applying programming language techniques. We propose two proof recipes, called loop truncation and resampling-table-based coupling, for bridging the gap between Hoare-style program logics and ALLLs’ original informal proofs. We formally verify six existing important results related to ALLLs, and propose a new result which generalizes several existing results. Our proof recipes can also be used to verify general properties of other probabilistic programs in addition to ALLLs.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Rongen", + "last_name": "Lin", + "institution": "Nanjing University" + }, + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "Nanjing University" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Nanjing University" + } + ], + "dblp_key": "conf/esop/LinLF25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_2", + "title": "Formulas as Processes, Deadlock-Freedom as Choreographies", + "abstract": "Abstract We introduce a novel approach to studying properties of processes in the $$\\pi $$ π -calculus based on a processes-as-formulas interpretation, by establishing a correspondence between specific sequent calculus derivations and computation trees in the reduction semantics of the recursion-free $$\\pi $$ π -calculus. Our method provides a simple logical characterisation of deadlock-freedom for the recursion- and race-free fragment of the $$\\pi $$ π -calculus, supporting key features such as cyclic dependencies and an independence of the name restriction and parallel operators. Based on this technique, we establish a strong completeness result for a nontrivial choreographic language: all deadlock-free and race-free finite $$\\pi $$ π -calculus processes composed in parallel at the top level can be faithfully represented by a choreography. With these results, we show how the computation-as-derivation paradigm extends the reach of logical methods for the study of concurrency, by bridging gaps between logic, the expressiveness of the $$\\pi $$ π -calculus, and the expressiveness of choreographic languages.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Matteo", + "last_name": "Acclavio", + "institution": "University of Sussex" + }, + { + "first_name": "Giulia", + "last_name": "Manara", + "institution": "Roma Tre University" + }, + { + "first_name": "Fabrizio", + "last_name": "Montesi", + "institution": "University of Southern Denmark" + } + ], + "dblp_key": "conf/esop/AcclavioMM25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_12", + "title": "Variable Elimination as Rewriting in a Linear Lambda Calculus", + "abstract": "Abstract Variable Elimination ( $$\\textsf{VE}$$ VE ) is a classical exact inference algorithm for probabilistic graphical models such as Bayesian Networks, computing the marginal distribution of a subset of the random variables in the model. Our goal is to understand Variable Elimination as an algorithm acting on programs in an idealized probabilistic functional language—a linear simply-typed $$\\lambda $$ λ -calculus suffices for our purpose. Precisely, we express $$\\textsf{VE}$$ VE as a term rewriting process , which transforms a global definition of a variable into a local definition, by swapping and nesting let-in expressions. We exploit in an essential way linear types.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Ehrhard", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Claudia", + "last_name": "Faggian", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "M.", + "last_name": "Pagani", + "institution": "École Normale Supérieure de Lyon" + } + ], + "dblp_key": "conf/esop/EhrhardFP25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91118-7_11", + "title": "Coverage Semantics for Dependent Pattern Matching", + "abstract": "Abstract Dependent pattern matching is a key feature in dependently typed programming. However, there is a theory-practice disconnect: while many proof assistants implement pattern matching as primitive, theoretical presentations give semantics to pattern matching by elaborating to eliminators. Though theoretically convenient, eliminators can be awkward and verbose, particularly for complex combinations of patterns. This work aims to bridge the theory-practice gap by presenting a direct categorical semantics for pattern matching, which does not elaborate to eliminators. This is achieved using sheaf theory to describe when sets of arrows (terms) can be amalgamated into a single arrow. We present a language with top-level dependent pattern matching, without specifying which sets of patterns are considered covering for a match. Then, we give a sufficient criterion for which pattern-sets admit a sound model: patterns should be in the canonical coverage for the category of contexts. Finally, we use sheaf-theoretic saturation conditions to devise some allowable sets of patterns. We are able to express and exceed the status quo, giving semantics for datatype constructors, nested patterns, absurd patterns, propositional equality, and dot patterns.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91118-7_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Eremondi", + "institution": "University of Regina" + }, + { + "first_name": "Ohad", + "last_name": "Kammar", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/esop/EremondiK25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_11", + "title": "SMT-Boosted Security Types for Low-Level MPC", + "abstract": "Abstract Secure Multi-Party Computation (MPC) is an important enabling technology for data privacy in modern distributed applications. We develop a new type theory to automatically enforce correctness, confidentiality, and integrity properties of protocols written in the Prelude/Overture language framework. Judgements in the type theory are predicated on SMT verifications in a theory of finite fields, which supports precise and efficient analysis. Our approach is automated, compositional, scalable, and generalizes to arbitrary prime fields for data and key sizes.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Christian", + "last_name": "Skalka", + "institution": "" + }, + { + "first_name": "Joseph P.", + "last_name": "Near", + "institution": "" + } + ], + "dblp_key": "conf/esop/SkalkaN25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_12", + "title": "Context-Dependent Effects in Guarded Interaction Trees", + "abstract": "Abstract Guarded Interaction Trees are a structure and a fully formalized framework for representing higher-order computations with higher-order effects in Coq. We present an extension of Guarded Interaction Trees to support formal reasoning about context-dependent effects. That is, effects whose behaviors depend on the evaluation context, e.g., , and . Using and reasoning about such effects is challenging since certain compositionality principles no longer hold in the presence of such effects. For example, the so-called “bind rule” in modern program logics (which allows one to reason modularly about a term inside a context) is no longer valid. The goal of our extension is to support representation and reasoning about context-dependent effects in the most painless way possible. To that end, our extension is conservative: the reasoning principles (and the Coq implementation) for context-independent effects remain the same. We show that our implementation of context-dependent effects is viable and powerful. We use it to give direct-style denotational semantics for higher-order programming languages with and with delimited continuations. We extend the program logic for Guarded Interaction Trees to account for context-dependent effects, and we use the program logic to prove that the denotational semantics is adequate with respect to the operational semantics. This is achieved by constructing logical relations between syntax and semantics inside the program logic. Additionally, we retain the ability to combine multiple effects in a modular way, which we demonstrate by showing type soundness for safe interoperability of a programming language with delimited continuations and a programming language with higher-order store.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_12", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sergei", + "last_name": "Stepanenko", + "institution": "Aarhus University" + }, + { + "first_name": "Emma", + "last_name": "Nardino", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Dan", + "last_name": "Frumin", + "institution": "University of Groningen" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "Aarhus University" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/esop/StepanenkoNFTB25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_1", + "title": "Efficient Synthesis of Tight Polynomial Upper-Bounds for Systems of Conditional Polynomial Recurrences", + "abstract": "Abstract Recurrence relations are used in a wide variety of static program analysis tasks such as loop summarization, invariant generation, and, most classically, modeling the (asymptotic) worst-case runtime behavior of recursive divide-and-conquer algorithms. In this work, we focus on the latter use-case. Classical methods for this problem, such as the well-known Master Theorem (MT) or the Akra-Bazzi method (AB) can only handle single recurrences of a certain limited form. Specifically, MT requires that each instance be divided into a fixed number of smaller sub-instances of the same size . AB generalizes MT by allowing sub-instances of different sizes, but still requires that the number of such sub-instances be fixed and independent of the size of the original instance. Moreover, these methods can handle neither multi-variate recurrences nor systems of recurrences that model non-simple recursive behavior among two or more procedures. In this work, we lift these restrictions and consider a wide family of recurrences called Generalized Polynomial Recurrence Systems (GPRS). Our setting is highly expressive and allows systems of multi-variate recurrences in which an instance can be divided into polynomially-many sub-instances. Moreover, the division is not limited to a single rule and can have several cases based on conditions on the values of the variables. We show how to obtain polynomial upper-bounds for a GPRS using template-based methods and classical theorems from polyhedral and algebraic geometry. Our approach reduces the synthesis of polynomial upper-bounds to linear or semi-definite programming instances, enabling efficient solutions. Crucially, our method is sound and semi-complete, i.e. complete for polynomials of any fixed degree and obtains concrete, as opposed to asymptotic, upper-bounds.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_1", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Amir K.", + "last_name": "Goharshady", + "institution": "University of Oxford" + }, + { + "first_name": "S.", + "last_name": "Hitarth", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Sergei", + "last_name": "Novozhilov", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/esop/GoharshadyHN25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_15", + "title": "Context-Sensitive Demand-Driven Control-Flow Analysis", + "abstract": "Abstract By decoupling and decomposing control flows, demand control-flow analysis (CFA) resolves only the flow segments determined necessary to produce a specified control-flow fact. It therefore presents a more flexible interface and pricing model than typical CFA, making many useful applications practical. At present, the only realization of demand CFA is the context-insensitive Demand 0CFA. Typical mechanisms for adding context sensitivity are not compatible with the demand setting because the analyzer is dispatched at arbitrary program points in indeterminate contexts. We overcome this challenge by identifying a context suitable for a demand analysis and designing a representation thereof that allows it to model incomplete knowledge of the context. On top of this design, we construct Demand m -CFA, a context-sensitive demand CFA hierarchy. With the attractive pricing model of demand analysis and the precision offered by context sensitivity, we show that Demand m -CFA can replace its exhaustive counterpart in compiler backends and integrate into interactive tools such as language servers.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_15", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Tim", + "last_name": "Whiting", + "institution": "Brigham Young University" + }, + { + "first_name": "Kimball", + "last_name": "Germane", + "institution": "Brigham Young University" + } + ], + "dblp_key": "conf/esop/WhitingG25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_3", + "title": "First-Person Choreographic Programming with Continuation-Passing Communications", + "abstract": "Abstract Choreographic programming (CP) is a method to implement distributed systems that ensures communication deadlock freedom by design. To use CP, though, the number of processes and the network among them must be known statically. Often, that information is known only dynamically. Thus, existing CP languages cannot be used to implement process-parametric distributed systems. This paper introduces first-person choreographic programming (1CP) to support the implementation of process-parametric distributed systems while also ensuring communication deadlock freedom. We present both a design of 1CP (new calculus, formalised in Isabelle/HOL) and an implementation (new language and tooling, integrated in VS Code).", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_3", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sung-Shik", + "last_name": "Jongmans", + "institution": "University of Groningen" + } + ], + "dblp_key": "conf/esop/Jongmans25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_14", + "title": "Named Arguments as Intersections, Optional Arguments as Unions", + "abstract": "Abstract Named and optional arguments are prevalent features in many mainstream programming languages, enhancing code readability and flexibility. Despite widespread use, their formalization has not been extensively studied. This paper bridges this gap by presenting a type-safe foundation for named and optional arguments using intersection and union types. We begin by identifying a critical type-safety issue in popular static type checkers for Python and Ruby, particularly in handling first-class named arguments in the presence of subtyping. Our solution involves rewriting call sites to ensure type safety, which we formalize through a translation into a core calculus called $$\\lambda _\\textsf{iu}$$ λ iu . The type safety of the translation is proven using the Coq proof assistant. The practical implementation of our approach in the CP language validates our theoretical contributions. Furthermore, we informally discuss how our approach could be adapted to encode named and optional arguments in other existing languages.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_14", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Yaozhu", + "last_name": "Sun", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/esop/SunO25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_2", + "title": "CUTECat: Concolic Execution for Computational Law", + "abstract": "Abstract Many legal computations, including the amount of tax owed by a citizen, whether they are eligible to social benefits, or the wages due to civil state servants, are specified by computational laws . Their application, however, is performed by expert computer programs intended to faithfully transcribe the law into computer code. Bugs in these programs can lead to dramatic societal impact, e.g., paying employees incorrect amounts, or not awarding benefits to families in need. To address this issue, we consider concolic unit testing, a combination of concrete execution with SMT-based symbolic execution, and propose CUTECat, a concolic execution tool targeting implementations of computational laws. Such laws typically follow a pattern where a base case is later refined by many exceptions in following law articles, a pattern that can be formally modeled using default logic . We show how to handle default logic inside a concolic execution tool, and implement our approach in the context of Catala, a recent domain-specific language tailored to implement computational laws. We evaluate CUTECat on several programs, including the Catala implementation of the French housing benefits and Section 132 of the US tax code. We show that CUTECat can successfully generate hundreds of thousands of testcases covering all branches of these bodies of law. Through several heuristics, we improve CUTECat’s scalability and usability, making the testcases understandable by lawyers and programmers alike. We believe CUTECat paves the way for the use of formal methods during legislative processes.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_2", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Pierre", + "last_name": "Goutagny", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Aymeric", + "last_name": "Fromherz", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Raphaël", + "last_name": "Monat", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/GoutagnyFM25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_5", + "title": "Formal Verification of WTO-based Dataflow Solvers - Artifact Experience Report", + "abstract": "Abstract In this report, we provide our full set of results for the experimental evaluation of our formally verified, WTO-based dataflow solvers [2]. We also detail useful information regarding our artifact [3] and evaluation setup. In particular, we validate experimentally that our implementation of Bourdoncle’s iteration strategies have acceptable performances in practice, when applied to the dataflow analyses used in the CompCert C verified compiler. Our experiments also help better understanding the differences between the solvers, their strengths and their weaknesses.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_5", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Roméo La", + "last_name": "Spina", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Delphine", + "last_name": "Demange", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/SpinaDB25a", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_9", + "title": "A Complete Axiomatisation of Equivalence for Discrete Probabilistic Programming", + "abstract": "Abstract We introduce a sound and complete equational theory capturing equivalence of discrete probabilistic programs, that is, programs extended with primitives for Bernoulli distributions and conditioning, to model distributions over finite sets of events. To do so, we translate these programs into a graphical syntax of probabilistic circuits, formalised as string diagrams, the two-dimensional syntax of symmetric monoidal categories. We then prove a first completeness result for the equational theory of the conditioning-free fragment of our syntax. Finally, we extend this result to a complete equational theory for the entire language. Our first result gives a presentation of the category of Markov kernels, restricted to objects that are powers of the two-elements set.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_9", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Robin", + "last_name": "Piedeleu", + "institution": "University College London" + }, + { + "first_name": "Mateo", + "last_name": "Torres-Ruiz", + "institution": "University College London" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Cornell University" + }, + { + "first_name": "Fabio", + "last_name": "Zanasi", + "institution": "University College London" + } + ], + "dblp_key": "conf/esop/PiedeleuTSZ25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_8", + "title": "coma, an Intermediate Verification Language with Explicit Abstraction Barriers", + "abstract": "Abstract We introduce coma , a formally defined intermediate verification language. Specification annotations in coma take the form of assertions mixed with the executable program code. A special programming construct representing the abstraction barrier is used to separate, inside a subroutine, the “interface” part of the code, which is verified at every call site, from the “implementation” part, which is verified only once, at the definition site. In comparison with traditional contract-based specification, this offers us an additional degree of freedom, as we can provide separate specification (or none at all) for different execution paths. We define a verification condition generator for coma and prove its correctness. For programs where specification is given in a traditional way, with abstraction barriers at the function entries and exits, our verification conditions are similar to the ones produced by a classical weakest-precondition calculus. For programs where abstraction barriers are placed in the middle of a function definition, the user-written specification is seamlessly completed with the verification conditions generated for the exposed part of the code. In addition, our procedure can factorize selected subgoals on the fly, which leads to more compact verification conditions. We illustrate the use of coma on two non-trivial examples, which have been formalized and verified using our implementation: a second-order regular expression engine and a sorting algorithm written in unstructured assembly code.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Andrei", + "last_name": "Paskevich", + "institution": "Université Paris-Saclay" + }, + { + "first_name": "Paul", + "last_name": "Patault", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jean-Christophe", + "last_name": "Filliâtre", + "institution": "CentraleSupélec" + } + ], + "dblp_key": "conf/esop/PaskevichPF25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_4", + "title": "Formal Verification of WTO-based Dataflow Solvers", + "abstract": "Abstract In this paper, we consider specific dataflow solvers, inspired by the work of Bourdoncle [5], in which an iteration order is pre-computed, based on the structure of the control-flow graph of programs. Our work aims at a clearer formulation and a better understanding of the folklore algorithms proposed three decades ago. We present a formalization of the dataflow solvers. Central to the proof of correctness is the general notion of a Weak Topological Ordering (WTO). Our correctness proofs are valid for any such ordering. The first solver implements an iterative strategy over the ordering, the second solver implements a recursive strategy. Our formalization is done within the Coq proof assistant and our solvers are extractable to OCaml code. Our formalization is fully compatible with the interface of dataflow solvers of the verified, optimizing C CompCert compiler. We conduct practical experiments on the wide range of forward and backward analyses of CompCert, demonstrating the practicality of our solvers in terms of efficiency and precision.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Roméo La", + "last_name": "Spina", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Delphine", + "last_name": "Demange", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/esop/SpinaDB25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_7", + "title": "Formal Autograding in a Classroom", + "abstract": "Abstract We report our experience in enhancing automated grading in an undergraduate programming course using formal verification. In our experiment, we deploy a program verifier to check the equivalence between student submissions and our reference solutions, alongside the existing testing-based grading infrastructure. We were able to use program equivalence to differentiate student submissions according to their high-level program structure, in particular their recursion pattern, even when their input-output behaviour is identical. Consequently, we achieve (1) higher confidence in correctness of idiomatic solutions but also (2) more thorough assessment of solution landscape that reveals solutions beyond those envisioned by instructors.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Dragana", + "last_name": "Milovančević", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Mario", + "last_name": "Bucev", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Marcin", + "last_name": "Wojnarowski", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Samuel", + "last_name": "Chassot", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/esop/MilovancevicBWCK25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_13", + "title": "An Automata-theoretic Basis for Specification and Type Checking of Multiparty Protocols", + "abstract": "Abstract We propose the Automata-based Multiparty Protocols framework (AMP) for top-down protocol development. The framework features a new very general formalism for global protocol specifications called Protocol State Machines (PSMs), Communicating State Machines (CSMs) as specifications for local participants, and a type system to check a $$\\pi $$ π -calculus with session interleaving and delegation against the CSM specification. Moreover, we define a large class of PSMs, called “tame”, for which we provide a sound and complete PSPACE projection operation that computes a CSM describing the same protocol as a given PSM if one exists. We propose these components as a backwards-compatible new backend for frameworks in the style of Multiparty Session Types. In comparison to the latter, AMP offers a considerable improvement in expressivity, decoupling of the various components (e.g. projection and typing), and robustness (thanks to the complete projection).", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_13", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Felix", + "last_name": "Stutz", + "institution": "University of Luxembourg" + }, + { + "first_name": "Emanuele", + "last_name": "D’Osualdo", + "institution": "University of Konstanz" + } + ], + "dblp_key": "conf/esop/StutzD25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_6", + "title": "Multiparty Session Types with a Bang!", + "abstract": "Abstract Replication is an alternative construct to recursion for describing infinite behaviours in the $$\\pi $$ π -calculus. In this paper we explore the implications of including type-level replication in Multiparty Session Types (MPST) , a behavioural type theory for message-passing programs. We introduce $$\\textsf {MPST!} $$ MPST ! , a session-typed multiparty process calculus with replication and first-class roles. We show that replication is not an equivalent alternative to recursion in MPST, and that using both replication and recursion in one type system in fact allows us to express both context-free protocols and protocols that support mutual exclusion and races. We demonstrate the expressiveness of $$\\textsf {MPST!} $$ MPST ! on examples including binary tree serialisation, dining philosophers, and a model of an auction, and explore the implications of replication on the decidability of typechecking.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_6", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Matthew Alan Le", + "last_name": "Brun", + "institution": "University of Glasgow" + }, + { + "first_name": "Simon", + "last_name": "Fowler", + "institution": "University of Glasgow" + }, + { + "first_name": "Ornela", + "last_name": "Dardha", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/esop/BrunFD25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_10", + "title": "Compositional Shape Analysis with Shared Abduction and Biabductive Loop Acceleration", + "abstract": "Abstract Biabduction-based shape analysis is a compositional verification and analysis technique that can prove memory safety in the presence of complex, linked data structures. Despite its usefulness, several open problems persist for this kind of analysis; two of which we address in this paper. On the one hand, the original analysis is path-sensitive but cannot combine safety requirements for related branches. This causes the analysis to require additional soundness checks and decreases the analysis’ precision. We extend the underlying symbolic execution and propose a framework for shared abduction where a common pre-condition is maintained for related computation branches. On the other hand, prior implementations lift loop acceleration methods from forward analysis to biabduction analysis by applying them separately on the pre- and post-condition, which can lead to imprecise or even unsound acceleration results that do not form a loop invariant. In contrast, we propose biabductive loop acceleration , which explicitly constructs and checks candidate loop invariants. For this, we also introduce a novel heuristic called shape extrapolation . This heuristic takes advantage of locality in the handling of list-like data structures (which are the most common data structures found in low-level code) and jointly accelerates pre- and post-conditions by extrapolating the related shapes. In addition to making the analysis more precise, our techniques also make biabductive analysis more efficient since they are sound in just one analysis phase. In contrast, prior techniques always require two phases (as the first phase can produce contracts that are unsound and must hence be verified). We experimentally confirm that our techniques improve on prior techniques; both in terms of precision and runtime of the analysis.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_10", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Florian", + "last_name": "Sextl", + "institution": "TU Wien" + }, + { + "first_name": "Adam", + "last_name": "Rogalewicz", + "institution": "Brno University of Technology" + }, + { + "first_name": "Tomáš", + "last_name": "Vojnar", + "institution": "Masaryk University" + }, + { + "first_name": "Florian", + "last_name": "Zuleger", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/esop/SextlRVZ25", + "venue": "esop", + "year": 2025 + }, + { + "paper_id": "10.1007/978-3-031-91121-7_16", + "title": "On the Relationship between Dijkstra Monads and Higher-Order Fixpoint Logic", + "abstract": "Abstract We study the relationship between two approaches to higher-order program verification: a semi-automated method using Dijkstra monads and a fully automated method using a higher-order fixpoint logic called HFL(Z). Although the origins of both approaches are quite different, there are some striking similarities: both convert programs to corresponding predicate transformers, and the conversion is essentially obtained by a CPS transformation. After reviewing the two approaches, we formalize an exact correspondence between the two for a restricted fragment of a functional language. We also point out that, outside the restricted fragment, there are some important differences between the two approaches, suggesting the need for cross-fertilization to obtain the best of the two approaches. As an example of the cross-fertilization, we also propose a semi-automated verification method, which requires less annotations than the Dijkstra monad approach and can scale to larger programs than the HFL(Z) approach.", + "date": "2025-01-01", + "link": "https://doi.org/10.1007/978-3-031-91121-7_16", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Risa", + "last_name": "Yamada", + "institution": "The University of Tokyo" + }, + { + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ken", + "last_name": "Sakayori", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryosuke", + "last_name": "Sato", + "institution": "Tokyo University of Agriculture and Technology" + } + ], + "dblp_key": "conf/esop/YamadaKSS25", + "venue": "esop", + "year": 2025 + } +] \ No newline at end of file From 9030145b08a43ce339e20369499b2fedd959dac1 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 17:52:16 +0200 Subject: [PATCH 17/34] feat: ingest ESOP 2026 ESOP 2026 was published while the harvester was running on earlier years. 5 papers had abstracts in OpenAlex/SS at run time. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/esop/2026.json | 147 +++++++++++++++++++++++++++++ 1 file changed, 147 insertions(+) create mode 100644 data/pl_conferences/esop/2026.json diff --git a/data/pl_conferences/esop/2026.json b/data/pl_conferences/esop/2026.json new file mode 100644 index 0000000..2d9f197 --- /dev/null +++ b/data/pl_conferences/esop/2026.json @@ -0,0 +1,147 @@ +[ + { + "paper_id": "10.1007/978-3-032-22720-1_7", + "title": "Code Generation via Meta-programming in Dependently Typed Proof Assistants", + "abstract": "Abstract Dependently typed proof assistants offer powerful meta-programming features, which allow users to implement proof automation or compile-time code generation. This paper surveys meta-programming frameworks in Rocq, Agda, and Lean, with seven implementations of a running example: deriving instances for the typeclass. This example is fairly simple, but realistic enough to highlight recurring difficulties with meta-programming: conceptual limitations of frameworks such as term representation – and in particular binder representation –, meta-language expressiveness, and verifiability, as well as current limitations such as API completeness, learning curve, and prover state management, which could in principle be remedied. We conclude with insights regarding features an ideal meta-programming framework should provide.", + "date": "2026-01-01", + "link": "https://doi.org/10.1007/978-3-032-22720-1_7", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Mathis", + "last_name": "Bouverot-Dupuis", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Yannick", + "last_name": "Forster", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/BouverotDupuisF26", + "venue": "esop", + "year": 2026 + }, + { + "paper_id": "10.1007/978-3-032-22720-1_4", + "title": "In Cantor Space No One Can Hear You Stream", + "abstract": "Abstract We revisit the famous notion of sheaves through the lens of type theory and side-effects. Using the language of $$\\textsf{MLTT}$$ MLTT , we show that they inductively approximate idealized functional objects as decision trees, realizing a generalized form of continuity. We materialize this intuition in $$\\textsf{MLTT}^{\\textsf{F}}$$ MLTT F , a case-study sheaf extension of $$\\textsf{MLTT}$$ MLTT with a Cohen real and leverage it to show uniform continuity of all $$\\textsf{MLTT}$$ MLTT functionals of type $$({\\mathbb {N}}\\rightarrow {\\mathbb {B}}) \\rightarrow {\\mathbb {N}}$$ ( N → B ) → N . The latter results were mechanized in Rocq.", + "date": "2026-01-01", + "link": "https://doi.org/10.1007/978-3-032-22720-1_4", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Baillon", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Assia", + "last_name": "Mahboubi", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Pierre-Marie", + "last_name": "Pédrot", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/BaillonMP26", + "venue": "esop", + "year": 2026 + }, + { + "paper_id": "10.1007/978-3-032-22720-1_8", + "title": "Linear Effects, Exceptions, and Resource Safety - A Curry-Howard Correspondence for Destructors", + "abstract": "Abstract We analyse the problem of combining linearity, effects, and exceptions, in abstract models of programming languages, as the issue of providing some kind of strength for a monad $$T(- \\oplus E)$$ T ( - ⊕ E ) in a linear setting. We consider in particular for T the allocation monad , which we introduce to model and study resource-safety properties. We apply these results to a series of two linear effectful calculi for which we establish their resource-safety properties. The first calculus is a linear (optionally ordered) call-by-push-value language with two allocation effects $${{\\,\\mathrm{\\textbf{new}}\\,}}$$ new and $${{\\,\\mathrm{\\textbf{delete}}\\,}}$$ delete . The resource-safety properties follow from the linear and ordered character of the typing rules. We then integrate exceptions with linearity and effects by adjoining default destruction actions to types, as inspired by C++/Rust destructors. We see destructors as objects $$\\delta : A\\rightarrow TI$$ δ : A → T I in the slice category over TI . This construction gives rise to a second calculus, the resource call-by-push-value , featuring exceptions and destructors, and whose weakening and exchange rules perform side-effects. It is therefore affine at the level of types but ordered at the level of derivations. As in C++ and Rust, a “move” operation—the side-effecting exchange rule—is necessary for releasing resources in random order, as opposed to LIFO order.", + "date": "2026-01-01", + "link": "https://doi.org/10.1007/978-3-032-22720-1_8", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Sidney", + "last_name": "Congard", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Guillaume", + "last_name": "Munch-Maccagnoni", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Rémi", + "last_name": "Douence", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/esop/CongardMD26", + "venue": "esop", + "year": 2026 + }, + { + "paper_id": "10.1007/978-3-032-22720-1_11", + "title": "Specification-Driven Generation of Summaries for Symbolic Execution", + "abstract": "Abstract Symbolic execution is a popular program analysis technique that has been successfully used for bug-finding and bounded verification in various modern programming languages. Despite its popularity, however, symbolic execution suffers from two main limitations when applied to real-world code: interactions with the runtime environment and path explosion. Symbolic summaries are the standard solution to tackle these challenges. Yet, the development of summaries remains to this day a manual task that is known to be highly error-prone. To address this, we propose SumGen , a new tool for automatically generating correct-by-construction summaries from function specifications. With SumGen , we were able to generate a total of 131 summaries for 47 libc functions, demonstrating the effectiveness of our methodology in producing correct summaries for real-world, highly complex code.", + "date": "2026-01-01", + "link": "https://doi.org/10.1007/978-3-032-22720-1_11", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Rafael", + "last_name": "Gonçalves", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Frederico", + "last_name": "Ramos", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Pedro", + "last_name": "Adão", + "institution": "University of Lisbon" + }, + { + "first_name": "José Fragoso", + "last_name": "Santos", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + } + ], + "dblp_key": "conf/esop/GoncalvesRAS26", + "venue": "esop", + "year": 2026 + }, + { + "paper_id": "10.1007/978-3-032-22720-1_17", + "title": "The Memorist Tale: Every Thunk Every Cost All At Once", + "abstract": "Abstract Lazy evaluation offers great flexibility by computing only what is necessary. However, analysing the cost of lazy programs is notoriously challenging, as computation occurs out of order and depends on future demands. Recent work has proposed alternative semantics for modelling lazy evaluation cost that avoid reasoning about program states. However, existing approaches either rely on nondeterminism or require complex bidirectional semantics. We present the Memorist Semantics , a novel semantics for analysing the cost of lazy programs by explicitly tracking the cost and dependencies of every subterm. Our semantics annotates components of a term with fine-grained cost and usage information, yielding a deterministic semantics that can be expressed through a simple monadic interface. We formalize the semantics in Rocq and verify its soundness with respect to the existing Clairvoyance Semantics. Similar to prior formalized semantics, our semantics is defined for a total, typed language with built-in structural recursion and without support for first-class functions. We outline ideas for possible extensions.", + "date": "2026-01-01", + "link": "https://doi.org/10.1007/978-3-032-22720-1_17", + "conference_name": "ESOP", + "authors": [ + { + "first_name": "Xing", + "last_name": "Li", + "institution": "The University of Melbourne" + }, + { + "first_name": "Yao", + "last_name": "Li", + "institution": "Portland State University" + }, + { + "first_name": "Peter", + "last_name": "Schachte", + "institution": "The University of Melbourne" + }, + { + "first_name": "Christine", + "last_name": "Rizkallah", + "institution": "The University of Melbourne" + } + ], + "dblp_key": "conf/esop/LiLSR26", + "venue": "esop", + "year": 2026 + } +] \ No newline at end of file From b665588dc9fcf97c4a5028fbf69dd08ff68b7880 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:03:48 +0200 Subject: [PATCH 18/34] feat: ingest ECOOP back-catalogue (1987-2025) 12 of 38 indexed years yielded papers with abstracts. ECOOP was a Springer LNCS conference until 2015 when it migrated to LIPIcs; nearly all 1987-2014 abstracts are missing from OpenAlex and Semantic Scholar (the publishers don't expose them), so those years mostly produce 0 or 1 paper. Post-2015 LIPIcs proceedings have abstracts and yield 22-43 papers per year. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/ecoop/2008.json | 30 + data/pl_conferences/ecoop/2015.json | 942 +++++++++++++++++ data/pl_conferences/ecoop/2016.json | 763 ++++++++++++++ data/pl_conferences/ecoop/2017.json | 895 ++++++++++++++++ data/pl_conferences/ecoop/2018.json | 793 ++++++++++++++ data/pl_conferences/ecoop/2019.json | 803 +++++++++++++++ data/pl_conferences/ecoop/2020.json | 1484 +++++++++++++++++++++++++++ data/pl_conferences/ecoop/2021.json | 688 +++++++++++++ data/pl_conferences/ecoop/2022.json | 1046 +++++++++++++++++++ data/pl_conferences/ecoop/2023.json | 1286 +++++++++++++++++++++++ data/pl_conferences/ecoop/2024.json | 1426 +++++++++++++++++++++++++ data/pl_conferences/ecoop/2025.json | 1296 +++++++++++++++++++++++ 12 files changed, 11452 insertions(+) create mode 100644 data/pl_conferences/ecoop/2008.json create mode 100644 data/pl_conferences/ecoop/2015.json create mode 100644 data/pl_conferences/ecoop/2016.json create mode 100644 data/pl_conferences/ecoop/2017.json create mode 100644 data/pl_conferences/ecoop/2018.json create mode 100644 data/pl_conferences/ecoop/2019.json create mode 100644 data/pl_conferences/ecoop/2020.json create mode 100644 data/pl_conferences/ecoop/2021.json create mode 100644 data/pl_conferences/ecoop/2022.json create mode 100644 data/pl_conferences/ecoop/2023.json create mode 100644 data/pl_conferences/ecoop/2024.json create mode 100644 data/pl_conferences/ecoop/2025.json diff --git a/data/pl_conferences/ecoop/2008.json b/data/pl_conferences/ecoop/2008.json new file mode 100644 index 0000000..9365c95 --- /dev/null +++ b/data/pl_conferences/ecoop/2008.json @@ -0,0 +1,30 @@ +[ + { + "paper_id": "10.1007/978-3-540-70592-5_9", + "title": "Prototyping and Composing Aspect Languages", + "abstract": "Abstract. Domain specific aspect languages (DSALs) are becoming more pop-ular because they can be designed to represent recurring concerns in a way that is optimized for a specific domain. However, the design and implementation of even a limited domain-specific aspect language can be a tedious job. To address this, we propose a framework that offers a fast way to prototype implementations of domain specific aspect languages. A particular goal of the framework is to be general enough to support a wide range of aspect language concepts, such that existing language concepts can be easily used, and new language concepts can be quickly created. We briefly introduce the framework and its underlying model, as well as the work-flow used when implementing DSALs. Subsequently, we show mappings of sev-eral domain specific aspect languages to demonstrate the framework. Since in our approach the DSALs are mapped to a common model, the framework provides an integrating platform allowing us to compose programs that use aspects written in multiple DSALs. The framework also provides explicit mechanisms to specify composition of advices written in multiple DSALs. 1", + "date": "2007-10-13", + "link": "https://doi.org/10.1007/978-3-540-70592-5_9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Wilke", + "last_name": "Havinga", + "institution": "University of Twente" + }, + { + "first_name": "Lodewijk", + "last_name": "Bergmans", + "institution": "University of Twente" + }, + { + "first_name": "Mehmet", + "last_name": "Akşit", + "institution": "University of Twente" + } + ], + "dblp_key": "conf/ecoop/HavingaBA08", + "venue": "ecoop", + "year": 2008 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2015.json b/data/pl_conferences/ecoop/2015.json new file mode 100644 index 0000000..d71d22e --- /dev/null +++ b/data/pl_conferences/ecoop/2015.json @@ -0,0 +1,942 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.i", + "title": "Front Matter, Table of Contents, Preface, Artifacts, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Artifacts, Conference Organization", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.i", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "John", + "last_name": "Boyland", + "institution": "University of Wisconsin–Milwaukee" + } + ], + "dblp_key": "conf/ecoop/X15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.124", + "title": "Loop Tiling in the Presence of Exceptions", + "abstract": "Exceptions in OO languages provide a convenient mechanism to deal with anomalous situations. However, many of the loop optimization techniques cannot be applied in the presence of conditional throw statements in the body of the loop, owing to possible cross iteration control dependences. Compilers either ignore such throw statements and apply traditional loop optimizations (semantic non-preserving), or conservatively avoid invoking any of these optimizations altogether (inefficient). We define a loop optimization to be xception-safe, if the optimization can be applied even on (possibly) exception throwing loops, in a semantics preserving manner. In this paper, we present a generalized scheme to do exception-safe loop optimizations and present a scheme of optimized exception-safe loop tiling (oESLT), as a specialization thereof. oESLT tiles the input loops, assuming that exceptions will never be thrown. To ensure the semantics preservation (in case an exception is thrown), oESLT generates code to rollback the updates done in the advanced iterations (iterations that the unoptimized code would not have executed, but executed speculatively by the oESLT generated code) and safely-execute the delayed iterations (ones that the unoptimized code would have executed, but not executed by the code generated by oESLT). For the rollback phase to work efficiently, oESLT identifies a minimal number of elements to backup and generates the necessary code. We implement oESLT, along with a naive scheme (nESLT, where we backup every element and do a full rollback and safe-execution in case an exception is thrown), in the Graphite framework of GCC 4.8. To help in this process, we define a new program region called ESCoPs (Extended Static Control Parts) that helps identify loops with multiple exit points and interface with the underlying polyhedral representation. We use the popular PolyBench suite to present a comparative evaluation of nESLT and oESLT against the unoptimized versions.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.124", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Abhilash", + "last_name": "Bhandari", + "institution": "" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "conf/ecoop/BhandariN15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.1", + "title": "Object-Oriented Programming without Inheritance (Invited Talk)", + "abstract": "Object-oriented programming is often characterized as encapsulation plus polymorphism plus inheritance. The original Simula67 demonstrated that we could do without encapsulation and Kristen Nygaard insisted that some OOP could be done without inheritance. I present generic programming as providing encapsulation plus polymorphism. In C++, this view is directly supported by language facilities, such as classes, templates and (only recently) concepts. I show a range of type-and-resource-safe techniques covering a wide range of applications including containers, algebraic concepts, and numerical and non-numerical algorithms.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bjarne", + "last_name": "Stroustrup", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/ecoop/Stroustrup15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.247", + "title": "Variability Abstractions: Trading Precision for Speed in Family-Based Analyses", + "abstract": "Family-based (lifted) data-flow analysis for Software Product Lines (SPLs) is capable of analyzing all valid products (variants) without generating any of them explicitly. It takes as input only the common code base, which encodes all variants of a SPL, and produces analysis results corresponding to all variants. However, the computational cost of the lifted analysis still depends inherently on the number of variants (which is exponential in the number of features, in the worst case). For a large number of features, the lifted analysis may be too costly or even infeasible. In this paper, we introduce variability abstractions defined as Galois connections and use abstract interpretation as a formal method for the calculational-based derivation of approximate (abstracted) lifted analyses of SPL programs, which are sound by construction. Moreover, given an abstraction we define a syntactic transformation that translates any SPL program into an abstracted version of it, such that the analysis of the abstracted SPL coincides with the corresponding abstracted analysis of the original SPL. We implement the transformation in a tool, that works on Object-Oriented Java program families, and evaluate the practicality of this approach on three Java SPL benchmarks.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.247", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aleksandar S.", + "last_name": "Dimovski", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Claus", + "last_name": "Brabrand", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Andrzej", + "last_name": "Wąsowski", + "institution": "IT University of Copenhagen" + } + ], + "dblp_key": "conf/ecoop/DimovskiBW15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.4", + "title": "Towards Practical Gradual Typing", + "abstract": "Over the past 20 years, programmers have embraced dynamically-typed programming languages. By now, they have also come to realize that programs in these languages lack reliable type information for software engineering purposes. Gradual typing addresses this problem; it empowers programmers to annotate an existing system with sound type information on a piecemeal basis. This paper presents an implementation of a gradual type system for a full-featured class-based language as well as a novel performance evaluation framework for gradual typing.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Asumu", + "last_name": "Takikawa", + "institution": "Universidad del Noreste" + }, + { + "first_name": "Daniel", + "last_name": "Feltey", + "institution": "Universidad del Noreste" + }, + { + "first_name": "Earl", + "last_name": "Dean", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Matthew", + "last_name": "Flatt", + "institution": "University of Utah" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Matthias", + "last_name": "Felleisen", + "institution": "Universidad del Noreste" + } + ], + "dblp_key": "conf/ecoop/TakikawaFDFFTF15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.198", + "title": "Brand Objects for Nominal Typing", + "abstract": "Combinations of structural and nominal object typing in systems such as Scala, Whiteoak, and Unity have focused on extending existing nominal, class-based systems with structural subtyping. The typical rules of nominal typing do not lend themselves to such an extension, resulting in major modifications. Adding object branding to an existing structural system integrates nominal and structural typing without excessively complicating the type system. We have implemented brand objects to explicitly type objects, using existing features of the structurally typed language Grace, along with a static type checker which treats the brands as nominal types. We demonstrate that the brands are useful in an existing implementation of Grace, and provide a formal model of the extension to the language.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.198", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Timothy M.", + "last_name": "Jones", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Michael", + "last_name": "Homer", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/ecoop/JonesHN15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.76", + "title": "Concrete Types for TypeScript", + "abstract": "Typescript extends JavaScript with optional type annotations that are, by design, unsound and, that the Typescript compiler discards as it emits code. This design point preserves programming idioms developers are familiar with, and allows them to leave their legacy code unchanged, while offering a measure of static error checking in parts of the program that have type annotations. We present an alternative design for TypeScript, one where it is possible to support the same degree of dynamism, but where types can be strengthened to provide hard guarantees. We report on an implementation, called StrongScript, that improves runtime performance of typed programs when run on a modified version of the V8 JavaScript engine.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.76", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Gregor", + "last_name": "Richards", + "institution": "University of Waterloo" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "École Normale Supérieure - PSL" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/RichardsNV15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.3", + "title": "Software Verification "Across the Stack" (Invited Talk)", + "abstract": "Producing reliable programs has always been tough, and the complexity and variety of programming tasks just keeps on growing. Fortunately, the growth of computing power has also enabled substantial advances in automated reasoning, particularly the development of SMT solvers and automatic theorem provers. In turn, this has resulted in new research directions for program correctness, with the aim of producing tools which can verify complex properties of software automatically. Developing useful verification techniques requires balancing a number of competing factors. We want to be as expressive as possible in the program properties we can support - if we can write it down, we'd like to be able to prove it. But to progress beyond pen-and-paper efforts, we also need to tailor our approaches such that they can be implemented or encoded by tools, ideally with both precise and efficient results. To make things harder still, if we hope to produce tools which everyday programmers can benefit from, we also need techniques that require manageable interaction from a user, and give understandable feedback. In this talk, I'll describe some of the fun experiences I've had working on these kinds of problems, from the design of front-end program logics and reasoning techniques to the development of underlying implementation technology, and the tricky encoding challenges that show up in between.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/ecoop/Summers15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.149", + "title": "Transparent Object Proxies in JavaScript", + "abstract": "Proxies are the swiss army knives of object adaptation. They introduce a level of indirection to intercept select operations on a target object and divert them as method calls to a handler. Proxies have many uses like implementing access control, enforcing contracts, virtualizing resources. One important question in the design of a proxy API is whether a proxy object should inherit the identity of its target. Apparently proxies should have their own identity for security-related applications whereas other applications, in particular contract systems, require transparent proxies that compare equal to their target objects. We examine the issue with transparency in various use cases for proxies, discuss different approaches to obtain transparency, and propose two designs that require modest modifications in the JavaScript engine and cannot be bypassed by the programmer. We implement our designs in the SpiderMonkey JavaScript interpreter and bytecode compiler. Our evaluation shows that these modifications of have no statistically significant impact on the benchmark performance of the JavaScript engine. Furthermore, we demonstrate that contract systems based on wrappers require transparent proxies to avoid interference with program execution in realistic settings.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.149", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Matthias S.", + "last_name": "Keil", + "institution": "" + }, + { + "first_name": "Sankha Narayan", + "last_name": "Guria", + "institution": "" + }, + { + "first_name": "Andreas", + "last_name": "Schlegel", + "institution": "" + }, + { + "first_name": "Manuel", + "last_name": "Geffken", + "institution": "" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/KeilGSGT15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.52", + "title": "Trust, but Verify: Two-Phase Typing for Dynamic Languages", + "abstract": "A key challenge when statically typing so-called dynamic languages is the ubiquity of value-based overloading, where a given function can dynamically reflect upon and behave according to the types of its arguments. Thus, to establish basic types, the analysis must reason precisely about values, but in the presence of higher-order functions and polymorphism, this reasoning itself can require basic types. In this paper we address this chicken-and-egg problem by introducing the framework of two-phased typing. The first \"trust\" phase performs classical, i.e. flow-, path- and value-insensitive type checking to assign basic types to various program expressions. When the check inevitably runs into \"errors\" due to value-insensitivity, it wraps problematic expressions with DEAD-casts, which explicate the trust obligations that must be discharged by the second phase. The second phase uses refinement typing, a flow- and path-sensitive analysis, that decorates the first phase's types with logical predicates to track value relationships and thereby verify the casts and establish other correctness properties for dynamically typed languages.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.52", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Panagiotis", + "last_name": "Vekris", + "institution": "University of California, San Diego" + }, + { + "first_name": "Benjamin", + "last_name": "Cosman", + "institution": "University of California, San Diego" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" + } + ], + "dblp_key": "conf/ecoop/VekrisCJ15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.2", + "title": "Programming in the Large for the Internet of Things (Invited Talk)", + "abstract": "The term Internet of Things (IoT) has generated a lot of buzz in the information technology and consumer electronics industries. In the IoT setting, a large number of physically dispersed devices - such as sensors, actuators and processing units - coordinate to bring useful capabilities to the user. A significant portion of these devices may have rather small computation and storage footprints, but at the same time, they can leverage support from potential enormous computation and storage resources via the cloud. Also, a large set of small footprint devices can serve not just a single logical app or service, but also many independent logical apps or services. This requires a careful separation of computational activities and their associated data within a device, for privacy and security purposes. Application development for the Internet of Things gives a whole new meaning to the term \"programming in the large\", and some of this is likely to be new to the practitioner. This talk will discuss what the IoT environment means to the practical programmer, and what apps and app ecosystems for IoT might look like. The talk will also discuss the issues and open challenges in software engineering brought on by this new environment, pointing towards new opportunities for researchers in our community.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jong-Deok", + "last_name": "Choi", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/ecoop/Choi15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.222", + "title": "Access-rights Analysis in the Presence of Subjects", + "abstract": "Modern software development and run-time environments, such as Java and the Microsoft .NET Common Language Runtime (CLR), have adopted a declarative form of access control. Permissions are granted to code providers, and during execution, the platform verifies compatibility between the permissions required by a security-sensitive operation and those granted to the executing code. While convenient, configuring the access-control policy of a program is not easy. If a code component is not granted sufficient permissions, authorization failures may occur. Thus, security administrators tend to define overly permissive policies, which violate the Principle of Least Privilege (PLP). A considerable body of research has been devoted to building program-analysis tools for computing the optimal policy for a program. However, Java and the CLR also allow executing code under the authority of a subject (user or service), and no program-analysis solution has addressed the challenges of determining the policy of a program in the presence of subjects. This paper introduces Subject Access Rights Analysis (SARA), a novel analysis algorithm for statically computing the permissions required by subjects at run time. We have applied SARA to 348 libraries in IBM WebSphere Application Server - a commercial enterprise application server written in Java that consists of >2 million lines of code and is required to support the Java permission- and subject-based security model. SARA detected 263 PLP violations, 219 cases of policies with missing permissions, and 29 bugs that led code to be unnecessarily executed under the authority of a subject. SARA corrected all these vulnerabilities automatically, and additionally synthesized fresh policies for all the libraries, with a false-positive rate of 5% and an average running time of 103 seconds per library. SARA also implements mechanisms for mitigating the risk of false negatives due to reflection and native code; according to a thorough result evaluation based on testing, no false negative was detected. SARA enabled IBM WebSphere Application Server to receive the Common Criteria for Information Technology Security Evaluation Assurance Level 4 certification.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.222", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Paolina", + "last_name": "Centonze", + "institution": "Iona College" + }, + { + "first_name": "Marco", + "last_name": "Pistoia", + "institution": "IBM (United States)" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/ecoop/CentonzePT15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.28", + "title": "TreatJS: Higher-Order Contracts for JavaScripts", + "abstract": "TreatJS is a language embedded, higher-order contract system for JavaScript which enforces contracts by run-time monitoring. Beyond providing the standard abstractions for building higher-order contracts (base, function, and object contracts), TreatJS's novel contributions are its guarantee of non-interfering contract execution, its systematic approach to blame assignment, its support for contracts in the style of union and intersection types, and its notion of a parameterized contract scope, which is the building block for composable run-time generated contracts that generalize dependent function contracts. TreatJS is implemented as a library so that all aspects of a contract can be specified using the full JavaScript language. The library relies on JavaScript proxies to guarantee full interposition for contracts. It further exploits JavaScript's reflective features to run contracts in a sandbox environment, which guarantees that the execution of contract code does not modify the application state. No source code transformation or change in the JavaScript run-time system is required. The impact of contracts on execution speed is evaluated using the Google Octane benchmark.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.28", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Matthias S.", + "last_name": "Keil", + "institution": "University of Freiburg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/ecoop/KeilT15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.271", + "title": "Optimization Coaching for JavaScript", + "abstract": "The performance of dynamic object-oriented programming languages such as JavaScript depends heavily on highly optimizing just-in-time compilers. Such compilers, like all compilers, can silently fall back to generating conservative, low-performance code during optimization. As a result, programmers may inadvertently cause performance issues on users' systems by making seemingly inoffensive changes to programs. This paper shows how to solve the problem of silent optimization failures. It specifically explains how to create a so-called optimization coach for an object-oriented just-in-time-compiled programming language. The development and evaluation build on the SpiderMonkey JavaScript engine, but the results should generalize to a variety of similar platforms.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.271", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Vincent", + "last_name": "St-Amour", + "institution": "Universidad del Noreste" + }, + { + "first_name": "Shu", + "last_name": "Guo", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/St-AmourG15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.174", + "title": "A Theory of Tagged Objects", + "abstract": "Foundational models of object-oriented constructs typically model objects as records with a structural type. However, many object-oriented languages are class-based; statically-typed formal models of these languages tend to sacrifice the foundational nature of the record-based models, and in addition cannot express dynamic class loading or creation. In this paper, we explore how to model statically-typed object-oriented languages that support dynamic class creation using foundational constructs of type theory. We start with an extensible tag construct motivated by type theory, and adapt it to support static reasoning about class hierarchy and the tags supported by each object. The result is a model that better explains the relationship between object-oriented and functional programming paradigms, suggests a useful enhancement to functional programming languages, and paves the way for more expressive statically typed object-oriented languages. In that vein, we describe the design and implementation of the Wyvern language, which leverages our theory.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.174", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Joseph", + "last_name": "Lee", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Troy", + "last_name": "Shaw", + "institution": "" + }, + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/ecoop/LeeASP15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.101", + "title": "Simple and Effective Type Check Removal through Lazy Basic Block Versioning", + "abstract": "Dynamically typed programming languages such as JavaScript and Python defer type checking to run time. In order to maximize performance, dynamic language VM implementations must attempt to eliminate redundant dynamic type checks. However, type inference analyses are often costly and involve tradeoffs between compilation time and resulting precision. This has lead to the creation of increasingly complex multi-tiered VM architectures. This paper introduces lazy basic block versioning, a simple JIT compilation technique which effectively removes redundant type checks from critical code paths. This novel approach lazily generates type-specialized versions of basic blocks on-the-fly while propagating context-dependent type information. This does not require the use of costly program analyses, is not restricted by the precision limitations of traditional type analyses and avoids the implementation complexity of speculative optimization techniques. We have implemented intraprocedural lazy basic block versioning in a JavaScript JIT compiler. This approach is compared with a classical flow-based type analysis. Lazy basic block versioning performs as well or better on all benchmarks. On average, 71% of type tests are eliminated, yielding speedups of up to 50%. We also show that our implementation generates more efficient machine code than TraceMonkey, a tracing JIT compiler for JavaScript, on several benchmarks. The combination of implementation simplicity, low algorithmic complexity and good run time performance makes basic block versioning attractive for baseline JIT compilers.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.101", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Maxime", + "last_name": "Chevalier-Boisvert", + "institution": "Université de Montréal" + }, + { + "first_name": "Marc", + "last_name": "Feeley", + "institution": "Université de Montréal" + } + ], + "dblp_key": "conf/ecoop/Chevalier-Boisvert15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.296", + "title": "PerfBlower: Quickly Detecting Memory-Related Performance Problems via Amplification", + "abstract": "Performance problems in managed languages are extremely difficult to find. Despite many efforts to find those problems, most existing work focuses on how to debug a user-provided test execution in which performance problems already manifest. It remains largely unknown how to effectively find performance bugs before software release. As a result, performance bugs often escape to production runs, hurting software reliability and user experience. This paper describes PerfBlower, a general performance testing framework that allows developers to quickly test Java programs to find memory-related performance problems. PerfBlower provides (1) a novel specification language ISL to describe a general class of performance problems that have observable symptoms; (2) an automated test oracle via \\emph{virtual amplification}; and (3) precise reference-path-based diagnostic information via object mirroring. Using this framework, we have amplified three different types of problems. Our experimental results demonstrate that (1) ISL is expressive enough to describe various memory-related performance problems; (2) PerfBlower successfully distinguishes executions with and without problems; 8 unknown problems are quickly discovered under small workloads; and (3) PerfBlower outperforms existing detectors and does not miss any bugs studied before in the literature.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.296", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Lu", + "last_name": "Fang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Liang", + "last_name": "Dou", + "institution": "East China Normal University" + }, + { + "first_name": "Guoqing", + "last_name": "Xu", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/ecoop/FangDX15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.321", + "title": "Hybrid DOM-Sensitive Change Impact Analysis for JavaScript", + "abstract": "JavaScript has grown to be among the most popular programming languages. However, performing change impact analysis on JavaScript applications is challenging due to features such as the seamless interplay with the DOM, event-driven and dynamic function calls, and asynchronous client/server communication. We first perform an empirical study of change propagation, the results of which show that the DOM-related and dynamic features of JavaScript need to be taken into consideration in the analysis since they affect change impact propagation. We propose a DOM-sensitive hybrid change impact analysis technique for Javascript through a combination of static and dynamic analysis. The proposed approach incorporates a novel ranking algorithm for indicating the importance of each entity in the impact set. Our approach is implemented in a tool called Tochal. The results of our evaluation reveal that Tochal provides a more complete analysis compared to static or dynamic methods. Moreover, through an industrial controlled experiment, we find that Tochal helps developers by improving their task completion duration by 78% and accuracy by 223%.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.321", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Saba", + "last_name": "Alimadadi", + "institution": "University of British Columbia" + }, + { + "first_name": "Ali", + "last_name": "Mesbah", + "institution": "University of British Columbia" + }, + { + "first_name": "Karthik", + "last_name": "Pattabiraman", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/ecoop/Alimadadi0P15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.346", + "title": "Intensional Effect Polymorphism", + "abstract": "Type-and-effect systems are a powerful tool for program construction and verification. We describe intensional effect polymorphism, a new foundation for effect systems that integrates static and dynamic effect checking. Our system allows the effect of polymorphic code to be intensionally inspected through a lightweight notion of dynamic typing. When coupled with parametric polymorphism, the powerful system utilizes runtime information to enable precise effect reasoning, while at the same time retains strong type safety guarantees. We build our ideas on top of an imperative core calculus with regions. The technical innovations of our design include a relational notion of effect checking, the use of bounded existential types to capture the subtle interactions between static typing and dynamic typing, and a differential alignment strategy to achieve efficiency in dynamic typing. We demonstrate the applications of intensional effect polymorphism in concurrent programming, security, graphical user interface access, and memoization.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.346", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yuheng", + "last_name": "Long", + "institution": "Iowa State University" + }, + { + "first_name": "Yu David", + "last_name": "Liu", + "institution": "Binghamton University" + }, + { + "first_name": "Hridesh", + "last_name": "Rajan", + "institution": "Iowa State University" + } + ], + "dblp_key": "conf/ecoop/LongLR15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.371", + "title": "Type Inference for Place-Oblivious Objects", + "abstract": "In a distributed system, access to local data is much faster than access to remote data. As a help to programmers, some languages require every access to be local. A program in those languages can access remote data via first a shift of the place of computation and then a local access. To enforce this discipline, researchers have presented type systems that determine whether every access is local and every place shift is appropriate. However, those type systems fall short of handling a common programming pattern that we call place-oblivious objects. Such objects safely access other objects without knowledge of their place. In response, we present the first type system for place-oblivious objects along with an efficient inference algorithm and a proof that inference is P-complete. Our example language extends the Abadi-Cardelli object calculus with place shift and existential types, and our implementation has inferred types for some microbenchmarks.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.371", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Riyaz", + "last_name": "Haque", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/ecoop/HaqueP15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.519", + "title": "The Good, the Bad, and the Ugly: An Empirical Study of Implicit Type Conversions in JavaScript", + "abstract": "Most popular programming languages support situations where a value of one type is converted into a value of another type without any explicit cast. Such implicit type conversions, or type coercions, are a highly controversial language feature. Proponents argue that type coercions enable writing concise code. Opponents argue that type coercions are error-prone and that they reduce the understandability of programs. This paper studies the use of type coercions in JavaScript, a language notorious for its widespread use of coercions. We dynamically analyze hundreds of programs, including real-world web applications and popular benchmark programs. We find that coercions are widely used (in 80.42% of all function executions) and that most coercions are likely to be harmless (98.85%). Furthermore, we identify a set of rarely occurring and potentially harmful coercions that safer subsets of JavaScript or future language designs may want to disallow. Our results suggest that type coercions are significantly less evil than commonly assumed and that analyses targeted at real-world JavaScript programs must consider coercions.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.519", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Michael", + "last_name": "Pradel", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/ecoop/PradelS15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.542", + "title": "A Pattern Calculus for Rule Languages: Expressiveness, Compilation, and Mechanization", + "abstract": "This paper introduces a core calculus for pattern-matching in production rule languages: the Calculus for Aggregating Matching Patterns (CAMP). CAMP is expressive enough to capture modern rule languages such as JRules, including extensions for aggregation. We show how CAMP can be compiled into a nested-relational algebra (NRA), with only minimal extension. This paves the way for applying relational techniques to running rules over large stores. Furthermore, we show that NRA can also be compiled back to CAMP, using named nested-relational calculus (NNRC) as an intermediate step. We mechanize proofs of correctness, program size preservation, and type preservation of the translations using modern theorem-proving techniques. A corollary of the type preservation is that polymorphic type inference for both CAMP and NRA is NP-complete. CAMP and its correspondence to NRA provide the foundations for efficient implementations of rules languages using databases technologies.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.542", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Avraham", + "last_name": "Shinnar", + "institution": "" + }, + { + "first_name": "Jérǒme", + "last_name": "Simèon", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Hirzel", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/ShinnarSH15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.396", + "title": "Asynchronous Liquid Separation Types", + "abstract": "We present a refinement type system for reasoning about asynchronous programs manipulating shared mutable state. Our type system guarantees the absence of races and the preservation of user-specified invariants using a combination of two ideas: refinement types and concurrent separation logic. Our type system allows precise reasoning about programs using two ingredients. First, our types are indexed by sets of resource names and the type system tracks the effect of program execution on individual heap locations and task handles. In particular, it allows making strong updates to the types of heap locations. Second, our types track ownership of shared state across concurrently posted tasks and allow reasoning about ownership transfer between tasks using permissions. We demonstrate through several examples that these two ingredients, on top of the framework of liquid types, are powerful enough to reason about correct behavior of practical, complex, asynchronous systems manipulating shared heap resources. We have implemented type inference for our type system and have used it to prove complex invariants of asynchronous OCaml programs. We also show how the type system detects subtle concurrency bugs in a file system implementation.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.396", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Kloos", + "institution": "Max Planck Society" + }, + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/ecoop/KloosMV15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.470", + "title": "Defining Correctness Conditions for Concurrent Objects in Multicore Architectures", + "abstract": "Correctness of concurrent objects is defined in terms of conditions that determine allowable relationships between histories of a concurrent object and those of the corresponding sequential object. Numerous correctness conditions have been proposed over the years, and more have been proposed recently as the algorithms implementing concurrent objects have been adapted to cope with multicore processors with relaxed memory architectures. We present a formal framework for defining correctness conditions for multicore architectures, covering both standard conditions for totally ordered memory and newer conditions for relaxed memory, which allows them to be expressed in uniform manner, simplifying comparison. Our framework distinguishes between order and commitment properties, which in turn enables a hierarchy of correctness conditions to be established. We consider the Total Store Order (TSO) memory model in detail, formalise known conditions for TSO using our framework, and develop sequentially consistent variations of these. We present a work-stealing deque for TSO memory that is not linearizable, but is correct with respect to these new conditions. Using our framework, we identify a new non-blocking compositional condition, fence consistency, which lies between known conditions for TSO, and aims to capture the intention of a programmer-specified fence.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.470", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "Brunel University of London" + }, + { + "first_name": "John", + "last_name": "Derrick", + "institution": "University of Sheffield" + }, + { + "first_name": "Lindsay", + "last_name": "Groves", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Graeme", + "last_name": "Smith", + "institution": "The University of Queensland" + } + ], + "dblp_key": "conf/ecoop/DongolDGS15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.568", + "title": "Global Sequence Protocol: A Robust Abstraction for Replicated Shared State", + "abstract": "In the age of cloud-connected mobile devices, users want responsive apps that read and write shared data everywhere, at all times, even if network connections are slow or unavailable. The solution is to replicate data and propagate updates asynchronously. Unfortunately, such mechanisms are notoriously difficult to understand, explain, and implement. To address these challenges, we present GSP (global sequence protocol), an operational model for replicated shared data. GSP is simple and abstract enough to serve as a mental reference model, and offers fine control over the asynchronous update propagation (update transactions, strong synchronization). It abstracts the data model and thus applies both to simple key-value stores, and complex structured data. We then show how to implement GSP robustly on a client-server architecture (masking silent client crashes, server crash-recovery failures, and arbitrary network failures) and efficiently (transmitting and storing minimal information by reducing update sequences).", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.568", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Burckhardt", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Manuel", + "last_name": "Fähndrich", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/ecoop/BurckhardtLPF15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.445", + "title": "Cooking the Books: Formalizing JMM Implementation Recipes", + "abstract": "The Java Memory Model (JMM) is intended to characterize the meaning of concurrent Java programs. Because of the model's complexity, however, its definition cannot be easily transplanted within an optimizing Java compiler, even though an important rationale for its design was to ensure Java compiler optimizations are not unduly hampered because of the language's concurrency features. In response, Lea's JSR-133 Cookbook for Compiler Writers, an informal guide to realizing the principles underlying the JMM on different (relaxed-memory) platforms was developed. The goal of the cookbook is to give compiler writers a relatively simple, yet reasonably efficient, set of reordering-based recipes that satisfy JMM constraints. In this paper, we present the first formalization of the cookbook, providing a semantic basis upon which the relationship between the recipes defined by the cookbook and the guarantees enforced by the JMM can be rigorously established. Notably, one artifact of our investigation is that the rules defined by the cookbook for compiling Java onto Power are inconsistent with the requirements of the JMM, a surprising result, and one which justifies our belief in the need for formally provable definitions to reason about sophisticated (and racy) concurrency patterns in Java, and their implementation on modern-day relaxed-memory hardware. Our formalization enables simulation arguments between an architecture-independent intermediate representation of the kind suggested by Lea with machine abstractions for Power and x86. Moreover, we provide fixes for cookbook recipes that are inconsistent with the behaviors admitted by the target platform, and prove the correctness of these repairs.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.445", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Gustavo", + "last_name": "Petri", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/ecoop/PetriVJ15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.421", + "title": "The Eureka Programming Model for Speculative Task Parallelism", + "abstract": "In this paper, we describe the Eureka Programming Model (EuPM) that simplifies the expression of speculative parallel tasks, and is especially well suited for parallel search and optimization applications. The focus of this work is to provide a clean semantics for, and efficiently support, such \"eureka-style\" computations (EuSCs) in general structured task parallel programming models. In EuSCs, a eureka event is a point in a program that announces that a result has been found. A eureka triggered by a speculative task can cause a group of related speculative tasks to become redundant, and enable them to be terminated at well-defined program points. Our approach provides a bound on the additional work done in redundant speculative tasks after such a eureka event occurs. We identify various patterns that are supported by our eureka construct, which include search, optimization, convergence, and soft real-time deadlines. These different patterns of computations can also be safely combined or nested in the EuPM, along with regular task-parallel constructs, thereby enabling high degrees of composability and reusability. As demonstrated by our implementation, the EuPM can also be implemented efficiently. We use a cooperative runtime that uses delimited continuations to manage the termination of redundant tasks and their synchronization at join points. In contrast to current approaches, EuPM obviates the need for cumbersome manual refactoring by the programmer that may (for example) require the insertion of if checks and early return statements in every method in the call chain. Experimental results show that solutions using the EuPM simplify programmability, achieve performance comparable to hand-coded speculative task-based solutions and out-perform non-speculative task-based solutions.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.421", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Shams", + "last_name": "Imam", + "institution": "Rice University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + } + ], + "dblp_key": "conf/ecoop/ImamS15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.614", + "title": "Lightweight Support for Magic Wands in an Automatic Verifier", + "abstract": "Permission-based verification logics such as separation logic have led to the development of many practical verification tools over the last decade. Verifiers employ the separating conjunction A*B to elegantly handle aliasing problems, framing, race conditions, etc. Introduced along with the separating conjunction, the magic wand connective, written A -* B, can describe hypothetical modifications of the current state, and provide guarantees about the results. Its formal semantics involves quantifying over states: as such, the connective is typically not supported in automatic verification tools. Nonetheless, the magic wand has been shown to be useful in by-hand and mechanised proofs, for example, for specifying loop invariants and partial data structures. In this paper, we show how to integrate support for the magic wand into an automatic verifier, requiring low specification overhead from the tool user, due to a novel approach for choosing footprints for magic wand formulas automatically. We show how to extend this technique to interact elegantly with common specification features such as recursive predicates. Our solution is designed to be compatible with a variety of logics and underlying implementation techniques. We have implemented our approach, and a prototype verifier is available to download, along with a collection of examples.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.614", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Malte", + "last_name": "Schwerhoff", + "institution": "ETH Zurich" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/ecoop/SchwerhoffS15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.591", + "title": "Streams a la carte: Extensible Pipelines with Object Algebras", + "abstract": "Streaming libraries have become ubiquitous in object-oriented languages, with recent offerings in Java, C#, and Scala. All such libraries, however, suffer in terms of extensibility: there is no way to change the semantics of a streaming pipeline (e.g., to fuse filter operators, to perform computations lazily, to log operations) without changes to the library code. Furthermore, in some languages it is not even possible to add new operators (e.g., a zip operator, in addition to the standard map, filter, etc.) without changing the library. We address such extensibility shortcomings with a new design for streaming libraries. The architecture underlying this design borrows heavily from Oliveira and Cook's object algebra solution to the expression problem, extended with a design that exposes the push/pull character of the iteration, and an encoding of higher-kinded polymorphism. We apply our design to Java and show that the addition of full extensibility is accompanied by high performance, matching or exceeding that of the original, highly-optimized Java streams library.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.591", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aggelos", + "last_name": "Biboudis", + "institution": "" + }, + { + "first_name": "Nick", + "last_name": "Palladinos", + "institution": "" + }, + { + "first_name": "George", + "last_name": "Fourtounis", + "institution": "" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BiboudisPFS15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.495", + "title": "The Love/Hate Relationship with the C Preprocessor: An Interview Study", + "abstract": "The C preprocessor has received strong criticism in academia, among others regarding separation of concerns, error proneness, and code obfuscation, but is widely used in practice. Many (mostly academic) alternatives to the preprocessor exist, but have not been adopted in practice. Since developers continue to use the preprocessor despite all criticism and research, we ask how practitioners perceive the C preprocessor. We performed interviews with 40 developers, used grounded theory to analyze the data, and cross-validated the results with data from a survey among 202 developers, repository mining, and results from previous studies. In particular, we investigated four research questions related to why the preprocessor is still widely used in practice, common problems, alternatives, and the impact of undisciplined annotations. Our study shows that developers are aware of the criticism the C preprocessor receives, but use it nonetheless, mainly for portability and variability. Many developers indicate that they regularly face preprocessor-related problems and preprocessor-related bugs. The majority of our interviewees do not see any current C-native technologies that can entirely replace the C preprocessor. However, developers tend to mitigate problems with guidelines, even though those guidelines are not enforced consistently. We report the key insights gained from our study and discuss implications for practitioners and researchers on how to better use the C preprocessor to minimize its negative impact.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.495", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Flávio", + "last_name": "Medeiros", + "institution": "Universidade Federal de Campina Grande" + }, + { + "first_name": "Christian", + "last_name": "Kästner", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Márcio", + "last_name": "Ribeiro", + "institution": "Universidade Federal de Alagoas" + }, + { + "first_name": "Sarah", + "last_name": "Nadi", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Rohit", + "last_name": "Gheyi", + "institution": "Universidade Federal de Campina Grande" + } + ], + "dblp_key": "conf/ecoop/MedeirosKRNG15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.639", + "title": "Modular Verification of Finite Blocking in Non-terminating Programs", + "abstract": "Most multi-threaded programs synchronize threads via blocking operations such as acquiring locks or joining other threads. An important correctness property of such programs is for each thread to make progress, that is, not to be blocked forever. For programs in which all threads terminate, progress essentially follows from deadlock freedom. However, for the common case that a program contains non-terminating threads such as servers or actors, deadlock freedom is not sufficient. For instance, a thread may be blocked forever by a non-terminating thread if it attempts to join that thread or to acquire a lock held by that thread. In this paper, we present a verification technique for finite blocking in non-terminating programs. The key idea is to track explicitly whether a thread has an obligation to perform an operation that unblocks another thread, for instance, an obligation to release a lock or to terminate. Each obligation is associated with a measure to ensure that it is fulfilled within finitely many steps. Obligations may be used in specifications, which makes verification modular. We formalize our technique via an encoding into Boogie, which treats different kinds of obligations uniformly. It subsumes termination checking as a special case.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.639", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Boström,", + "last_name": "Pontus", + "institution": "" + }, + { + "first_name": "Müller,", + "last_name": "Peter", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BostromM15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.664", + "title": "Modular Termination Verification", + "abstract": "We propose an approach for the modular specification and verification of total correctness properties of object-oriented programs. We start from an existing program logic for partial correctness based on separation logic and abstract predicate families. We extend it with call permissions qualified by an arbitrary ordinal number, and we define a specification style that properly hides implementation details, based on the ideas of using methods and bags of methods as ordinals, and exposing the bag of methods reachable from an object as an abstract predicate argument. These enable each method to abstractly request permission to call all methods reachable by it any finite number of times, and to delegate similar permissions to its callees. We illustrate the approach with several examples.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.664", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bart", + "last_name": "Jacobs", + "institution": "KU Leuven" + }, + { + "first_name": "Dragan", + "last_name": "Bošnački", + "institution": "" + }, + { + "first_name": "Ruurd", + "last_name": "Kuiper", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/JacobsBK15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.689", + "title": "Framework for Static Analysis of PHP Applications", + "abstract": "Dynamic languages, such as PHP and JavaScript, are widespread and heavily used. They provide dynamic features such as dynamic type system, virtual and dynamic method calls, dynamic includes, and built-in dynamic data structures. This makes it hard to create static analyses, e.g., for automatic error discovery. Yet exploiting errors in such programs, especially in web applications, can have significant impacts. In this paper, we present static analysis framework for PHP, automatically resolving features common to dynamic languages and thus reducing the complexity of defining new static analyses. In particular, the framework enables defining value and heap analyses for dynamic languages independently and composing them automatically and soundly. We used the framework to implement static taint analysis for finding security vulnerabilities. The analysis has revealed previously unknown security problems in real application. Comparing to existing state-of-the-art analysis tools for PHP, it has found more real problems with a lower false-positive rate.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.689", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "David", + "last_name": "Hauzar", + "institution": "Charles University" + }, + { + "first_name": "Jan", + "last_name": "Kofroň", + "institution": "Charles University" + } + ], + "dblp_key": "conf/ecoop/HauzarK15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.712", + "title": "Adaptive Context-sensitive Analysis for JavaScript", + "abstract": "Context sensitivity is a technique to improve program analysis precision by distinguishing between function calls. A specific context-sensitive analysis is usually designed to accommodate the programming paradigm of a particular programming language. JavaScript features both the object-oriented and functional programming paradigms. Our empirical study suggests that there is no single context-sensitive analysis that always produces precise results for JavaScript applications. This observation motivated us to design an adaptive analysis, selecting a context-sensitive analysis from multiple choices for each function. Our two-staged adaptive context-sensitive analysis first extracts function characteristics from an inexpensive points-to analysis and then chooses a specialized context-sensitive analysis per function based on the heuristics. The experimental results show that our adaptive analysis achieved more precise results than any single context-sensitive analysis for several JavaScript programs in the benchmarks.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.712", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Shiyi", + "last_name": "Wei", + "institution": "Virginia Tech" + }, + { + "first_name": "Barbara G.", + "last_name": "Ryder", + "institution": "Virginia Tech" + } + ], + "dblp_key": "conf/ecoop/WeiR15", + "venue": "ecoop", + "year": 2015 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2015.735", + "title": "Scalable and Precise Static Analysis of JavaScript Applications via Loop-Sensitivity", + "abstract": "The numbers and sizes of JavaScript applications are ever growing but static analysis techniques for analyzing large-scale JavaScript applications are not yet ready in a scalable and precise manner. Even when building complex software like compilers and operating systems in JavaScript, developers do not get much benefits from existing static analyzers, which suffer from mutually intermingled problems of scalability and imprecision. In this paper, we present Loop-Sensitive Analysis (LSA) that improves the analysis scalability by enhancing the analysis precision in loops. LSA distinguishes loop iterations as many as needed by automatically choosing loop unrolling numbers during analysis. We formalize LSA in the abstract interpretation framework and prove its soundness and precision theorems using Coq. We evaluate our implementation of LSA using the analysis results of main web pages in the 5 most popular websites and those of the programs that use top 5 JavaScript libraries, and show that it outperforms the state-of-the-art JavaScript static analyzers in terms of analysis scalability. Our mechanization and implementation of LSA are both publicly available.", + "date": "2015-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2015.735", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Changhee", + "last_name": "Park", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Sukyoung", + "last_name": "Ryu", + "institution": "Korea Advanced Institute of Science and Technology" + } + ], + "dblp_key": "conf/ecoop/ParkR15", + "venue": "ecoop", + "year": 2015 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2016.json b/data/pl_conferences/ecoop/2016.json new file mode 100644 index 0000000..ef73d3a --- /dev/null +++ b/data/pl_conferences/ecoop/2016.json @@ -0,0 +1,763 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.0", + "title": "Front Matter, Table of Contents, Preface, List of Authors", + "abstract": "Front Matter, Table of Contents, Preface, List of Authors", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Shriram", + "last_name": "Krishnamurthi", + "institution": "Brown University" + }, + { + "first_name": "Benjamin S.", + "last_name": "Lerner", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/X16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.1", + "title": "Trace Typing: An Approach for Evaluating Retrofitted Type Systems", + "abstract": "Recent years have seen growing interest in the retrofitting of type systems onto dynamically-typed programming languages, in order to improve type safety, programmer productivity, or performance. In such cases, type system developers must strike a delicate balance between disallowing certain coding patterns to keep the type system simple, or including them at the expense of additional complexity and effort. Thus far, the process for designing retrofitted type systems has been largely ad hoc, because evaluating multiple variations of a type system on large bodies of existing code is a significant undertaking. We present trace typing: a framework for automatically and quantitatively evaluating variations of a retrofitted type system on large code bases. The trace typing approach involves gathering traces of program executions, inferring types for instances of variables and expressions occurring in a trace, and merging types according to merge strategies that reflect specific (combinations of) choices in the source-level type system design space. We evaluated trace typing through several experiments. We compared several variations of type systems retrofitted onto JavaScript, measuring the number of program locations with type errors in each case on a suite of over fifty thousand lines of JavaScript code. We also used trace typing to validate and guide the design of a new retrofitted type system that enforces fixed object layout for JavaScript objects. Finally, we leveraged the types computed by trace typing to automatically identify tag tests --- dynamic checks that refine a type --- and examined the variety of tests identified.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Esben", + "last_name": "Andreasen", + "institution": "" + }, + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "" + }, + { + "first_name": "Satish", + "last_name": "Chandra", + "institution": "" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/AndreasenGCSTS16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.10", + "title": "Formal Language Recognition with the Java Type Checker", + "abstract": "This paper is a theoretical study of a practical problem: the automatic generation of Java Fluent APIs from their specification. We explain why the problem's core lies with the expressive power of Java generics. Our main result is that automatic generation is possible whenever the specification is an instance of the set of deterministic context-free languages, a set which contains most \"practical\" languages. Other contributions include a collection of techniques and idioms of the limited meta-programming possible with Java generics, and an empirical measurement demonstrating that the runtime of the \"javac\" compiler of Java may be exponential in the program's length, even for programs composed of a handful of lines and which do not rely on overly complex use of generics.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yossi", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Tomer", + "last_name": "Levy", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/GilL16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.12", + "title": "Magic with Dynamo -- Flexible Cross-Component Linking for Java with Invokedynamic", + "abstract": "Modern software systems are not built from scratch. They use functionality provided by libraries. These libraries evolve and often upgrades are deployed without the systems being recompiled. In Java, this process is particularly error-prone due to the mismatch between source and binary compatibility, and the lack of API stability in many popular libraries. We propose a novel approach to mitigate this problem based on the use of invokedynamic instructions for cross-component method invocations. The dispatch mechanism of invokedynamic is used to provide on-the-fly signature adaptation. We show how this idea can be used to construct a Java compiler that produces more resilient bytecode. We present the dynamo compiler, a proof-of-concept implemented as a javac post compiler. We evaluate our approach using several benchmark examples and two case studies showing how the dynamo compiler can prevent certain types of linkage and stack overflow errors that have been observed in real-world systems.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Kamil", + "last_name": "Ježek", + "institution": "University of West Bohemia" + }, + { + "first_name": "Jens", + "last_name": "Dietrich", + "institution": "Massey University" + } + ], + "dblp_key": "conf/ecoop/JezekD16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.9", + "title": "LJGS: Gradual Security Types for Object-Oriented Languages", + "abstract": "LJGS is a lightweight Java core calculus with a gradual security type system. The calculus guarantees secure information flow for sequential, class-based, typed object-oriented programming with mutable objects and virtual method calls. An LJGS program is composed of fragments that are checked either statically or dynamically. Statically checked fragments adhere to a security type system so that they incur no run-time penalty whereas dynamically checked fragments rely on run-time security labels. The programmer marks the boundaries between static and dynamic checking with casts so that it is always clear whether a program fragment requires run-time checks. LJGS requires security annotations on fields and methods. A field annotation either specifies a fixed static security level or it prescribes dynamic checking. A method annotation specifies a constrained polymorphic security signature. The types of local variables in method bodies are analyzed flow-sensitively and require no annotation. The dynamic checking of fields relies on a static points-to analysis to approximate implicit flows. We prove type soundness and non-interference for LJGS.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Luminous", + "last_name": "Fennell", + "institution": "University of Freiburg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/ecoop/FennellT16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.6", + "title": "A Calculus for Variational Programming", + "abstract": "Variation is ubiquitous in software. Many applications can benefit from making this variation explicit, then manipulating and computing with it directly---a technique we call \"variational programming\". This idea has been independently discovered in several application domains, such as efficiently analyzing and verifying software product lines, combining bounded and symbolic model-checking, and computing with alternative privacy profiles. Although these domains share similar core problems, and there are also many similarities in the solutions, there is no dedicated programming language support for variational programming. This makes the various implementations tedious, prone to errors, hard to maintain and reuse, and difficult to compare. In this paper we present a calculus that forms the basis of a programming language with explicit support for representing, manipulating, and computing with variation in programs and data. We illustrate how such a language can simplify the implementation of variational programming tasks. We present the syntax and semantics of the core calculus, a sound type system, and a type inference algorithm that produces principal types.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Martin", + "last_name": "Erwig", + "institution": "Oregon State University" + }, + { + "first_name": "Eric", + "last_name": "Walkingshaw", + "institution": "Oregon State University" + } + ], + "dblp_key": "conf/ecoop/0008EW16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.3", + "title": "Fine-grained Language Composition: A Case Study", + "abstract": "Although run-time language composition is common, it normally takes the form of a crude Foreign Function Interface (FFI). While useful, such compositions tend to be coarse-grained and slow. In this paper we introduce a novel fine-grained syntactic composition of PHP and Python which allows users to embed each language inside the other, including referencing variables across languages. This composition raises novel design and implementation challenges. We show that good solutions can be found to the design challenges; and that the resulting implementation imposes an acceptable performance overhead of, at most, 2.6x.", + "date": "2015-03-30", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Edd", + "last_name": "Barrett", + "institution": "" + }, + { + "first_name": "Carl Friedrich", + "last_name": "Bolz", + "institution": "" + }, + { + "first_name": "Lukas", + "last_name": "Diekmann", + "institution": "" + }, + { + "first_name": "Laurence", + "last_name": "Tratt", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BarrettBDT16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.4", + "title": "Making an Embedded DBMS JIT-friendly", + "abstract": "While database management systems (DBMSs) are highly optimized, \\ninteractions across the boundary between the programming language (PL) and the DBMS are costly, even for in-process embedded DBMSs. In this paper, we show that programs that interact with the popular embedded DBMS SQLite can be significantly optimized -- by a factor of 3.4 in our benchmarks -- by inlining across the PL / DBMS boundary. We achieved this speed-up by replacing parts of SQLite's \\nC interpreter with RPython code and composing the resulting meta-tracing virtual machine (VM) -- called SQPyte -- with the PyPy VM. SQPyte does not compromise stand-alone SQL performance and is 2.2% faster than SQLite on the widely used TPC-H benchmark suite.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Carl Friedrich", + "last_name": "Bolz", + "institution": "" + }, + { + "first_name": "Darya", + "last_name": "Kurilova", + "institution": "" + }, + { + "first_name": "Laurence", + "last_name": "Tratt", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BolzKT16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.11", + "title": "IceDust: Incremental and Eventual Computation of Derived Values in Persistent Object Graphs", + "abstract": "Derived values are values calculated from base values. They can be expressed in object-oriented languages by means of getters calculating the derived value, and in relational or logic databases by means of (materialized) views. However, switching to a different calculation strategy (for example caching) in object-oriented programming requires invasive code changes, and the databases limit expressiveness by disallowing recursive aggregation. In this paper, we present IceDust, a data modeling language for expressing derived attribute values without committing to a calculation strategy. IceDust provides three strategies for calculating derived values in persistent object graphs: Calculate-on-Read, Calculate-on-Write, and Calculate-Eventually. We have developed a path-based abstract interpretation that provides static dependency analysis to generate code for these strategies. Benchmarks show that different strategies perform better in different scenarios. In addition we have conducted a case study that suggests that derived value calculations of systems used in practice can be expressed in IceDust.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Daco C.", + "last_name": "Harkes", + "institution": "Delft University of Technology" + }, + { + "first_name": "Danny M.", + "last_name": "Groenewegen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/ecoop/HarkesGV16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.5", + "title": "Reference Capabilities for Concurrency Control", + "abstract": "The proliferation of shared mutable state in object-oriented programming complicates software development as two seemingly unrelated operations may interact via an alias and produce unexpected results. In concurrent programming this manifests itself as data-races. Concurrent object-oriented programming further suffers from the fact that code that warrants synchronisation cannot easily be distinguished from code that does not. The burden is placed solely on the programmer to reason about alias freedom, sharing across threads and side-effects to deduce where and when to apply concurrency control, without inadvertently blocking parallelism. This paper presents a reference capability approach to concurrent and parallel object-oriented programming where all uses of aliases are guaranteed to be data-race free. The static type of an alias describes its possible sharing without using explicit ownership or effect annotations. Type information can express non-interfering deterministic parallelism without dynamic concurrency control, thread-locality, lock-based schemes, and guarded-by relations giving multi-object atomicity to nested data structures. Unification of capabilities and traits allows trait-based reuse across multiple concurrency scenarios with minimal code duplication. The resulting system brings together features from a wide range of prior work in a unified way.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Elias", + "last_name": "Castegren", + "institution": "Uppsala University" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/ecoop/CastegrenW16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.13", + "title": "Object Inheritance Without Classes", + "abstract": "Which comes first: the object or the class? Language designers enjoy the conceptual simplicity of object-based languages (such as Emerald or Self) while many programmers prefer the pragmatic utility of classical inheritance (as in Simula and Java). Programmers in object-based languages have a tendency to build libraries to support traditional inheritance, and language implementations are often contorted to the same end. In this paper, we revisit the relationship between classes and objects. We model various kinds of inheritance in the context of an object-oriented language whose objects are not defined by classes, and explain why class inheritance and initialisation cannot be easily modelled purely by delegation.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Timothy M.", + "last_name": "Jones", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Michael", + "last_name": "Homer", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "James", + "last_name": "Noble", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Kim B.", + "last_name": "Bruce", + "institution": "Pomona College" + } + ], + "dblp_key": "conf/ecoop/0002HNB16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.2", + "title": "QL: Object-oriented Queries on Relational Data", + "abstract": "This paper describes QL, a language for querying complex, potentially recursive data structures. QL compiles to Datalog and runs on a standard relational database, yet it provides familiar-looking object-oriented features such as classes and methods, reinterpreted in logical terms: classes are logical properties describing sets of values, subclassing is implication, and virtual calls are dispatched dynamically by considering the most specific classes containing the receiver. Furthermore, types in QL are prescriptive and actively influence program evaluation rather than just describing it. In combination, these features enable the development of concise queries based on reusable libraries, which are written in a purely declarative style, yet can be efficiently executed even on very large data sets. In particular, we have used QL to implement static analyses for various programming languages, which scale to millions of lines of code.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Pavel", + "last_name": "Avgustinov", + "institution": "University of Oxford" + }, + { + "first_name": "Oege de", + "last_name": "Moor", + "institution": "University of Oxford" + }, + { + "first_name": "Michael Peyton", + "last_name": "Jones", + "institution": "" + }, + { + "first_name": "Max", + "last_name": "Schäfer", + "institution": "Nanyang Technological University" + } + ], + "dblp_key": "conf/ecoop/AvgustinovMJS16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.7", + "title": "Interprocedural Type Specialization of JavaScript Programs Without Type Analysis", + "abstract": "Previous work proposed lazy basic block versioning, a technique for just-in-time compilation of dynamic languages which we believe represents an interesting point in the design space. Basic block versioning is simple to implement, simple enough that a single developer can build a complete just-in-time compiler for JavaScript in a year, yet it performs surprisingly well as it propagates \\ncontext-sensitive type information to generate type-specialized code on the fly. \\n \\nIn this paper, we demonstrate that lazy basic block versioning \\ncan be extended is simple ways to propagate type information across function call boundaries. This gives some of the benefits of whole-program analysis, or a tracing compiler, without having to implement the machinery for either. We have implemented this proposal in the Higgs JavaScript virtual machine and report on the empirical evaluation of this system on a set of industry standard benchmarks. The approach eliminates 94.3 of dynamic type tests on average, \\nwhich we show is more than what is achievable with any static whole-program type analysis.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Maxime", + "last_name": "Chevalier-Boisvert", + "institution": "Université de Montréal" + }, + { + "first_name": "Marc", + "last_name": "Feeley", + "institution": "Université de Montréal" + } + ], + "dblp_key": "conf/ecoop/Chevalier-Boisvert16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.14", + "title": "One Way to Select Many", + "abstract": "Selecting items from a collection is one of the most common tasks users perform with graphical user interfaces. Practically every application supports this task with a selection feature different from that of any other application. Defects are common, especially in manipulating selections of non-adjacent elements, and flexible selection features are often missing when they would clearly be useful. As a consequence, user effort is wasted. The loss of productivity is experienced in small doses, but all computer users are impacted. The undesirable state of support for multi-element selection prevails because the same selection features are redesigned and reimplemented repeatedly. This article seeks to establish common abstractions for multi-selection. It gives generic but precise meanings to selection operations and makes multi-selection reusable; a JavaScript implementation is described. Application vendors benefit because of reduced development effort. Users benefit because correct and consistent multi-selection becomes available in more contexts.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jaakko", + "last_name": "Järvi", + "institution": "Texas A&M University" + }, + { + "first_name": "Sean", + "last_name": "Parent", + "institution": "Adobe Systems (United States)" + } + ], + "dblp_key": "conf/ecoop/JarviP16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.8", + "title": "C++ const and Immutability: An Empirical Study of Writes-Through-const", + "abstract": "The ability to specify immutability in a programming language is a powerful tool for developers, enabling them to better understand and more safely transform their code without fearing unintended changes to program state. The C++ programming language allows developers to specify a form of immutability using the const keyword. In this work, we characterize the meaning of the C++ const qualifier and present the ConstSanitizer tool, which dynamically verifies a stricter form of immutability than that defined in C++: it identifies const uses that are either not consistent with transitive immutability, that write to mutable fields, or that write to formerly-const objects whose const-ness has been cast away. We evaluate a set of 7 C++ benchmark programs to find writes-through-const, establish root causes for how they fail to respect our stricter definition of immutability, and assign attributes to each write (namely: synchronized, not visible, buffer/cache, delayed initialization, and incorrect). ConstSanitizer finds 17 archetypes for writes in these programs which do not respect our version of immutability. Over half of these seem unnecessary to us. Our classification and observations of behaviour in practice contribute to the understanding of a widely-used C++ language feature.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jon", + "last_name": "Eyolfson", + "institution": "University of Waterloo" + }, + { + "first_name": "Patrick", + "last_name": "Lam", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/ecoop/EyolfsonL16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.15", + "title": "Program Tailoring: Slicing by Sequential Criteria", + "abstract": "Protocol and typestate analyses often report some sequences of statements ending at a program point P that needs to be scrutinized, since P may be erroneous or imprecisely analyzed. Program slicing focuses only on the behavior at P by computing a slice of the program affecting the values at P. In this paper, we propose to restrict our attention to the subset of that behavior at P affected by one or several statement sequences, called a sequential criterion (SC). By leveraging the ordering information in a SC, e.g., the temporal order in a few valid/invalid API method invocation sequences, we introduce a new technique, program tailoring, to compute a tailored program that comprises the statements in all possible execution paths passing through at least one sequence in SC in the given order. With a prototyping implementation, Tailor, we show why tailoring is practically useful by conducting two case studies on seven large real-world Java applications. For program debugging and understanding, Tailor can complement program slicing by removing SC-irrelevant statements. For program analysis, Tailor can enable a pointer analysis, which is unscalable to a program, to perform a more focused and therefore potentially scalable analysis to its specific parts containing hard language features such as reflection.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yue", + "last_name": "Li", + "institution": "UNSW Sydney" + }, + { + "first_name": "Tian", + "last_name": "Tan", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yifei", + "last_name": "Zhang", + "institution": "UNSW Sydney" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/ecoop/LiTZX16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.16", + "title": "Composing Interfering Abstract Protocols", + "abstract": "The undisciplined use of shared mutable state can be a source of program errors when aliases unsafely interfere with each other. While protocol-based techniques to reason about interference abound, they do not address two practical concerns: the decidability of protocol composition and its integration with protocol abstraction. We show that our composition procedure is decidable and that it ensures safe interference even when composing abstract protocols. To evaluate the expressiveness of our protocol framework for safe shared memory interference, we show how this same protocol framework can be used to model safe, typeful message-passing concurrency idioms.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Filipe", + "last_name": "Militão", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Luı́s", + "last_name": "Caires", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/MilitaoAC16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.17", + "title": "The Elements of Decision Alignment", + "abstract": "When one object makes a request of another, why do we expect that the second object's behavior correctly satisfies the first object's wishes? The need to cope with such principal-agent problems shapes programming practice as much as it shapes human organizations and economies. However, the literature about such plan coordination issues among humans is almost disjoint from the literature about these issues among objects. Even the terms used are unrelated. These fields have much to learn from each other---both from their similarities and from the causes of their differences. We propose a framework for thinking about decision alignment as a bridge between these disciplines.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Mark S.", + "last_name": "Miller", + "institution": "Google (United States)" + }, + { + "first_name": "Bill", + "last_name": "Tulloh", + "institution": "Google (United States)" + } + ], + "dblp_key": "conf/ecoop/MillerT16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.18", + "title": "A Calculus with Partially Dynamic Records for Typeful Manipulation of JSON Objects", + "abstract": "This paper investigates language constructs for high-level and type-safe manipulation of JSON objects in a typed functional language. A major obstacle in representing JSON in a static type system is their heterogeneous nature: in most practical JSON APIs, a JSON array is a heterogeneous list consisting of, for example, objects having common fields and possibly some optional fields. This paper presents a typed calculus that reconciles static typing constraints and heterogeneous JSON arrays based on the idea of partially dynamic records originally proposed and sketched by Buneman and Ohori for complex database object manipulation. Partially dynamic records are dynamically typed records, but some parts of their structures are statically known. This feature enables us to represent JSON objects as typed data structures. The proposed calculus smoothly extends with ML-style pattern matching and record polymorphism. These results yield a typed functional language where the programmer can directly import JSON data as terms having static types, and can manipulate them with the full benefits of static polymorphic type-checking. The proposed calculus has been embodied in SML#, an extension of Standard ML with record polymorphism and other practically useful features. This paper also reports on the details of the implementation and demonstrates its feasibility through examples using actual Web APIs. The SML# version 3.1.0 compiler includes JSON support presented in this paper, and is available from Tohoku University as open-source software under a BSD-style license.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Atsushi", + "last_name": "Ohori", + "institution": "" + }, + { + "first_name": "Katsuhiro", + "last_name": "Ueno", + "institution": "" + }, + { + "first_name": "Tomohiro", + "last_name": "Sasaki", + "institution": "" + }, + { + "first_name": "Daisuke", + "last_name": "Kikuchi", + "institution": "Hitachi (Japan)" + } + ], + "dblp_key": "conf/ecoop/OhoriUSK16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.20", + "title": "Scopes Describe Frames: A Uniform Model for Memory Layout in Dynamic Semantics", + "abstract": "Designing, developing and maintaining concurrent applications is an error-prone and time-consuming task; most difficulties arise because compilers are usually unable to check whether the inputs/outputs performed by a program at runtime will adhere to a given protocol specification. To address this problem, we propose lightweight session programming in Scala: we leverage the native features of the Scala type system and standard library, to introduce (1) a representation of session types as Scala types, and (2) a library, called lchannels, with a convenient API for session-based programming, supporting local and distributed communication. We generalise the idea of Continuation-Passing Style Protocols (CPSPs), studying their formal relationship with session types. We illustrate how session programming can be carried over in Scala: how to formalise a communication protocol, and represent it using Scala classes and lchannels, letting the compiler help spotting protocol violations. We attest the practicality of our approach with a complex use case, and evaluate the performance of lchannels with a series of benchmarks.", + "date": "2015-10-18", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Scalas,", + "last_name": "Alceste", + "institution": "" + }, + { + "first_name": "Yoshida,", + "last_name": "Nobuko", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/PoulsenNTV16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.23", + "title": "Transactional Tasks: Parallelism in Software Transactions", + "abstract": "Many programming languages, such as Clojure, Scala, and Haskell, support different concurrency models. In practice these models are often combined, however the semantics of the combinations are not always well-defined. In this paper, we study the combination of futures and Software Transactional Memory. Currently, futures created within a transaction cannot access the transactional state safely, violating the serializability of the transactions and leading to undesired behavior. We define transactional tasks: a construct that allows futures to be created in transactions. Transactional tasks allow the parallelism in a transaction to be exploited, while providing safe access to the state of their encapsulating transaction. We show that transactional tasks have several useful properties: they are coordinated, they maintain serializability, and they do not introduce non-determinism. As such, transactional tasks combine futures and Software Transactional Memory, allowing the potential parallelism of a program to be fully exploited, while preserving the properties of the separate models where possible.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Janwillem", + "last_name": "Swalens", + "institution": "" + }, + { + "first_name": "Joeri De", + "last_name": "Koster", + "institution": "" + }, + { + "first_name": "Wolfgang De", + "last_name": "Meuter", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/SwalensKM16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.26", + "title": "Towards Ontology-Based Program Analysis", + "abstract": "Program analysis is fundamental for program optimizations, debugging, and many other tasks. But developing program analyses has been a challenging and error-prone process for general users. Declarative program analysis has shown the promise to dramatically improve the productivity in the development of program analyses. Current declarative program analysis is however subject to some major limitations in supporting cooperations among analysis tools, guiding program optimizations, and often requires much effort for repeated program preprocessing. In this work, we advocate the integration of ontology into declarative program analysis. As a way to standardize the definitions of concepts in a domain and the representation of the knowledge in the domain, ontology offers a promising way to address the limitations of current declarative program analysis. We develop a prototype framework named PATO for conducting program analysis upon ontology-based program representation. Experiments on six program analyses confirm the potential of ontology for complementing existing declarative program analysis. It supports multiple analyses without separate program preprocessing, promotes cooperative Liveness analysis between two compilers, and effectively guides a data placement optimization for Graphic Processing Units (GPU).", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.26", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yue", + "last_name": "Zhao", + "institution": "North Carolina State University" + }, + { + "first_name": "Guoyang", + "last_name": "Chen", + "institution": "North Carolina State University" + }, + { + "first_name": "Chunhua", + "last_name": "Liao", + "institution": "Lawrence Livermore National Laboratory" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + } + ], + "dblp_key": "conf/ecoop/ZhaoCLS16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.19", + "title": "Higher-Order Demand-Driven Program Analysis", + "abstract": "We explore a novel approach to higher-order program analysis that brings ideas of on-demand lookup from first-order CFL-reachability program analyses to higher-order programs. The analysis needs to produce only a control-flow graph; it can derive all other information including values of variables directly from the graph. Several challenges had to be overcome, including how to build the control-flow graph on-the-fly and how to deal with non-local variables in functions. The resulting analysis is flow- and context-sensitive with a provable polynomial-time bound. The analysis is formalized and proved correct and terminating, and an initial implementation is described.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Palmer", + "institution": "Johns Hopkins University" + }, + { + "first_name": "Scott F.", + "last_name": "Smith", + "institution": "Johns Hopkins University" + } + ], + "dblp_key": "conf/ecoop/PalmerS16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.22", + "title": "Boomerang: Demand-Driven Flow- and Context-Sensitive Pointer Analysis for Java", + "abstract": "Many current program analyses require highly precise pointer information about small, tar- geted parts of a given program. This motivates the need for demand-driven pointer analyses that compute information only where required. Pointer analyses generally compute points-to sets of program variables or answer boolean alias queries. However, many client analyses require richer pointer information. For example, taint and typestate analyses often need to know the set of all aliases of a given variable under a certain calling context. With most current pointer analyses, clients must compute such information through repeated points-to or alias queries, increasing complexity and computation time for them. This paper presents Boomerang, a demand-driven, flow-, field-, and context-sensitive pointer analysis for Java programs. Boomerang computes rich results that include both the possible allocation sites of a given pointer (points-to information) and all pointers that can point to those allocation sites (alias information). For increased precision and scalability, clients can query Boomerang with respect to particular calling contexts of interest. Our experiments show that Boomerang is more precise than existing demand-driven pointer analyses. Additionally, using Boomerang, the taint analysis FlowDroid issues up to 29.4x fewer pointer queries compared to using other pointer analyses that return simpler pointer infor- mation. Furthermore, the search space of Boomerang can be significantly reduced by requesting calling contexts from the client analysis.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Späth", + "institution": "Paderborn University" + }, + { + "first_name": "Lisa Nguyen", + "last_name": "Quang", + "institution": "Paderborn University" + }, + { + "first_name": "Karim", + "last_name": "Ali", + "institution": "University of Alberta" + }, + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Paderborn University" + } + ], + "dblp_key": "conf/ecoop/SpathDAB16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.25", + "title": "Transforming Programs between APIs with Many-to-Many Mappings", + "abstract": "Transforming programs between two APIs or different versions of the same API is a common software engineering task. However, existing languages supporting for such transformation cannot satisfactorily handle the cases when the relations between elements in the old API and the new API are many-to-many mappings: multiple invocations to the old API are supposed to be replaced by multiple invocations to the new API. Since the multiple invocations of the original APIs may not appear consecutively and the variables in these calls may have different names, writing a tool correctly to cover all such invocation cases is not an easy task. In this paper we propose a novel guided-normalization approach to address this problem. Our core insight is that programs in different forms can be semantics-equivalently normalized into a basic form guided by transformation goals, and developers only need to write rules for the basic form to address the transformation. Based on this approach, we design a declarative program transformation language, PATL, for adapting Java programs between different APIs. PATL has simple syntax and basic semantics to handle transformations only considering consecutive statements inside basic blocks, while with guided-normalization, it can be extended to handle complex forms of invocations. Furthermore, PATL ensures that the user-written rules would not accidentally break def-use relations in the program. We formalize the semantics of PATL on Middleweight Java and prove the semantics-preserving property of guided-normalization. We also evaluated our language with three non-trivial case studies: i.e. updating Google Calendar API, switching from JDom to Dom4j, and switching from Swing to SWT. The result is encouraging; it shows that our language allows successful transformations of real world programs with a small number of rules and little manual resolution.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.25", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Chenglong", + "last_name": "Wang", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Jiajun", + "last_name": "Jiang", + "institution": "Peking University" + }, + { + "first_name": "Jun", + "last_name": "Li", + "institution": "China University of Mining and Technology" + }, + { + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Xiangyu", + "last_name": "Luo", + "institution": "" + }, + { + "first_name": "Lu", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Zhenjiang", + "last_name": "Hu", + "institution": "The Graduate University for Advanced Studies, SOKENDAI" + } + ], + "dblp_key": "conf/ecoop/WangJLXLZH16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.21", + "title": "Lightweight Session Programming in Scala", + "abstract": "Designing, developing and maintaining concurrent applications is an \\nerror-prone and time-consuming task; most difficulties arise because \\ncompilers are usually unable to check whether the inputs/outputs \\nperformed by a program at runtime will adhere to a given protocol \\nspecification. To address this problem, we propose lightweight session programming in Scala: we leverage the native features of the Scala \\ntype system and standard library, to introduce (1) a representation of session types as Scala types, and (2) a library, called lchannels, with a convenient API for session-based programming, supporting local and distributed communication. We generalise the idea of Continuation-Passing Style Protocols (CPSPs), studying their formal relationship with session types. We illustrate how session programming can be carried over in Scala: how to formalise a communication protocol, and represent it using Scala classes and lchannels, letting the compiler help spotting protocol violations. We attest the practicality of our approach with a complex use case, and evaluate the performance of lchannels with a series of benchmarks.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "University of Cagliari" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/ScalasY16", + "venue": "ecoop", + "year": 2016 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2016.24", + "title": "Staccato: A Bug Finder for Dynamic Configuration Updates", + "abstract": "Modern software applications are highly configurable, allowing configuration options to be changed even during program execution. When dynamic configuration updating is implemented incorrectly, program errors can result. These program errors occur primarily when stale data—computed from old configurations—or inconsistent data—computed from different configurations—are used. We introduce Staccato, the first tool designed to detect these errors. Staccato uses a dynamic analysis in the style of taint analysis to find the use of stale configuration data in Java programs. It supports concurrent programs running on commodity JVMs. In some cases, Staccato can provide automatic bug avoidance and semi-automatic repair when errors occur. We evaluated Staccato on 3 open-source applications that support complex reconfigurability. Staccato found multiple errors in all of them. Staccato requires only modest annotation overhead and has moderate performance overhead.", + "date": "2016-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2016.24", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "John", + "last_name": "Toman", + "institution": "Seattle University" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "Seattle University" + } + ], + "dblp_key": "conf/ecoop/TomanG16", + "venue": "ecoop", + "year": 2016 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2017.json b/data/pl_conferences/ecoop/2017.json new file mode 100644 index 0000000..72f4820 --- /dev/null +++ b/data/pl_conferences/ecoop/2017.json @@ -0,0 +1,895 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.0", + "title": "Front Matter, Table of Contents, Foreword, Conference Organization, External Reviewers, Authors", + "abstract": "Front Matter, Table of Contents, Foreword, Conference Organization, External Reviewers, Authors", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Müller,", + "last_name": "Peter", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/X17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.3", + "title": "Retargeting Gradual Typing (Invited Talk)", + "abstract": "Gradual typing is often motivated by efforts to add types to massive untyped code bases. A major challenge here is the fact that these code bases were not written with types in mind, yet the goal is to add types to them without requiring any significant changes in their implementation. Thus, critical to this application is the notion that gradual typing is being added onto a preexisting system. But gradual typing also has applications in education, prototyping, and scripting. It allows programmers to ignore types while they are learning programmatic reasoning, while they are experimenting with new designs, or while they are interacting with external systems. At the same time, gradual typing allows these programmers to utilize APIs with types that provide navigable documentation, that concisely describe interfaces, and that enable IDEs to provide assistance. In these applications, programmers are working with types even when they are not writing types. By targeting just these applications, we can lift a major burden from gradual typing. Rather than being added to something that already exists, here gradual typing can be integrated into the software-development process, into the core language design, and into the run-time environment, with each component designed to support gradual typing from conception. This retargeting provides significant flexibility, enabling designers to tradeoff various capabilities of gradual typing. For example, a designer might choose to require some minor annotation burden in untyped programs for, say, a hundred-fold improvement in run-time performance. For the past half decade I have been exploring gradual typing behind the scenes in both academia and industry, and I will be presenting my experiences with these design tradeoffs so far.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ross", + "last_name": "Tate", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/Tate17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.15", + "title": "What's the Optimal Performance of Precise Dynamic Race Detection? - A Redundancy Perspective", + "abstract": "In a precise data race detector, a race is detected only if the execution exhibits a real race. In such tools, every memory access from each thread is typically checked by a happens-before algorithm. What’s the optimal runtime performance of such tools? In this paper, we identify that a significant percentage of memory access checks in real-world program executions are often redundant: removing these checks affects neither the precision nor the capability of race detection. We show that if all such redundant checks were eliminated with no cost, the optimal performance of a state-of-the-art dynamic race detector, FastTrack, could be improved by 90%, reducing its runtime overhead from 68X to 7X on a collection of CPU intensive benchmarks. We further develop a purely dynamic technique, ReX, that efficiently filters out redundant checks and apply it to FastTrack. With ReX, the runtime performance of FastTrack is improved by 31% on average.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + }, + { + "first_name": "Rajagopalan, Arun", + "last_name": "K.", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/ecoop/0001R17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.11", + "title": "Mixing Metaphors: Actors as Channels and Channels as Actors", + "abstract": "Channel- and actor-based programming languages are both used in practice, but the two are often confused. Languages such as Go provide anonymous processes which communicate using buffers or rendezvous points---known as channels---while languages such as Erlang provide addressable processes---known as actors---each with a single incoming message queue. The lack of a common representation makes it difficult to reason about translations that exist in the folklore. We define a calculus lambda-ch for typed asynchronous channels, and a calculus lambda-act for typed actors. We define translations from lambda-act into lambda-ch and lambda-ch into lambda-act and prove that both are type- and semantics-preserving. We show that our approach accounts for synchronisation and selective receive in actor systems and discuss future extensions to support guarded choice and behavioural types.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Fowler", + "institution": "University of Edinburgh" + }, + { + "first_name": "Sam", + "last_name": "Lindley", + "institution": "" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/FowlerLW17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.5", + "title": "Modelling Homogeneous Generative Meta-Programming", + "abstract": "Homogeneous generative meta-programming (HGMP) enables the generation of program fragments at compile-time or run-time. We present a foundational calculus which can model both compile-time and run-time evaluated HGMP, allowing us to model, for the first time, languages such as Template Haskell. The calculus is designed such that it can be gradually enhanced with the features needed to model many of the advanced features of real languages. We demonstrate this by showing how a simple, staged type system as found in Template Haskell can be added to the calculus.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Martin", + "last_name": "Berger", + "institution": "University of Sussex" + }, + { + "first_name": "Laurence", + "last_name": "Tratt", + "institution": "" + }, + { + "first_name": "Christian", + "last_name": "Urban", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BergerTU17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.1", + "title": "Challenges to Achieving High Availability at Scale (Invited Talk)", + "abstract": "Facebook is a social network that connects more than 1.8 billion people. To serve these many users requires infrastructure which is composed of thousands of interdependent systems that span geographically distributed data centers. But what is the guiding principle for building and operating these systems? For Facebook’s infrastructure teams the answer is: Systems must always be available and never lose data. This talk will explore this quest. We will focus on three aspects. Availability and consistency. What form of consistency do Facebook’s systems guarantee? Strong consistency makes understanding easy but has latency penalties, weak consistency is fast but difficult to reason for developers and users. We describe our usage of eventual consistency and delve into how Facebook constructs its caching and replicated storage systems to minimize the duration for achieving consistency. We share empirical data that measures the effectiveness of our design. Availability and correctness. With network partitions, relaxed forms of consistency, and software bugs, how do we guarantee a consistent state? We present two systems to find and repair structural errors in Facebook’s social graph, one batch and one real-time. Availability and scale. Sharding is one of the standard answers to operate at scale. But how can we develop one system that can shard storage as well as compute? We will introduce a new Sharding-as-a-Service component. We will show and evaluate how its design and service policies control for latency, failure tolerance and operationally efficiency.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Wolfram", + "last_name": "Schulte", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/ecoop/Schulte17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.7", + "title": "Type Abstraction for Relaxed Noninterference", + "abstract": "Information-flow security typing statically prevents confidential information to leak to public channels. The fundamental information flow property, known as noninterference, states that a public observer cannot learn anything from private data. As attractive as it is from a theoretical viewpoint, noninterference is impractical: real systems need to intentionally declassify some information, selectively. Among the different information flow approaches to declassification, a particularly expressive approach was proposed by Li and Zdancewic, enforcing a notion of relaxed noninterference by allowing programmers to specify declassification policies that capture the intended manner in which public information can be computed from private data. This paper shows how we can exploit the familiar notion of type abstraction to support expressive declassification policies in a simpler, yet more expressive manner. In particular, the type-based approach to declassification---which we develop in an object-oriented setting---addresses several issues and challenges with respect to prior work, including a simple notion of label ordering based on subtyping, support for recursive declassification policies, and a local, modular reasoning principle for relaxed noninterference. This work paves the way for integrating declassification policies in practical security-typed languages.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Raimil", + "last_name": "Cruz", + "institution": "Laboratoire d'Informatique de Paris-Nord" + }, + { + "first_name": "Tamara", + "last_name": "Rezk", + "institution": "" + }, + { + "first_name": "Bernard", + "last_name": "Serpette", + "institution": "" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "Laboratoire d'Informatique de Paris-Nord" + } + ], + "dblp_key": "conf/ecoop/CruzRST17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.10", + "title": "Evil Pickles: DoS Attacks Based on Object-Graph Engineering", + "abstract": "In recent years, multiple vulnerabilities exploiting the serialisation APIs of various programming languages, including Java, have been discovered. These vulnerabilities can be used to devise in- jection attacks, exploiting the presence of dynamic programming language features like reflection or dynamic proxies. In this paper, we investigate a new type of serialisation-related vulnerabilit- ies for Java that exploit the topology of object graphs constructed from classes of the standard library in a way that deserialisation leads to resource exhaustion, facilitating denial of service attacks. We analyse three such vulnerabilities that can be exploited to exhaust stack memory, heap memory and CPU time. We discuss the language and library design features that enable these vulnerabilities, and investigate whether these vulnerabilities can be ported to C#, Java- Script and Ruby. We present two case studies that demonstrate how the vulnerabilities can be used in attacks on two widely used servers, Jenkins deployed on Tomcat and JBoss. Finally, we propose a mitigation strategy based on contract injection.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jens", + "last_name": "Dietrich", + "institution": "Massey University" + }, + { + "first_name": "Kamil", + "last_name": "Ježek", + "institution": "University of West Bohemia" + }, + { + "first_name": "Shawn", + "last_name": "Rasheed", + "institution": "Massey University" + }, + { + "first_name": "Amjed", + "last_name": "Tahir", + "institution": "Massey University" + }, + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/ecoop/DietrichJRTP17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.12", + "title": "muPuppet: A Declarative Subset of the Puppet Configuration Language", + "abstract": "Puppet is a popular declarative framework for specifying and managing complex system configurations. The Puppet framework includes a domain-specific language with several advanced features inspired by object-oriented programming, including user-defined resource types, 'classes' with a form of inheritance, and dependency management. Like most real-world languages, the language has evolved in an ad hoc fashion, resulting in a design with numerous features, some of which are complex, hard to understand, and difficult to use correctly. We present an operational semantics for $μ$Puppet, a representative subset of the Puppet language that covers the distinctive features of Puppet, while excluding features that are either deprecated or work-in-progress. Formalising the semantics sheds light on difficult parts of the language, identifies opportunities for future improvements, and provides a foundation for future analysis or debugging techniques, such as static typechecking or provenance tracking. Our semantics leads straightforwardly to a reference implementation in Haskell. We also discuss some of Puppet's idiosyncrasies, particularly its handling of classes and scope, and present an initial corpus of test cases supported by our formal semantics.", + "date": "2016-08-17", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Weili", + "last_name": "Fu", + "institution": "" + }, + { + "first_name": "Roly", + "last_name": "Perera", + "institution": "" + }, + { + "first_name": "Paul", + "last_name": "Anderson", + "institution": "" + }, + { + "first_name": "James", + "last_name": "Cheney", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/FuPAC17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.6", + "title": "Relaxed Linear References for Lock-free Data Structures", + "abstract": "Linear references are guaranteed to be free from aliases. This is a strong property that simplifies reasoning about programs and enables powerful optimisations, but it is also a property that is too strong for many applications. Notably, lock-free algorithms, which implement protocols that ensure safe, non-blocking concurrent access to data structures, are generally not typable with linear references because they rely on aliasing to achieve lock-freedom. This paper presents LOLCAT, a type system with a relaxed notion of linearity that allows an unbounded number of aliases to an object as long as at most one alias at a time owns the right to access the contents of the object. This ownership can be transferred between aliases, but can never be duplicated. types are powerful enough to type several lock-free data structures and give a compile-time guarantee of absence of data-races when accessing owned data. In particular, LOLCAT is able to assign types to the CAS (compare and swap) primitive that precisely describe how ownership is transferred across aliases, possibly across different threads. The paper introduces LOLCAT through a sound core procedural calculus, and shows how LOLCAT can be applied to three fundamental lock-free data structures. It also discusses a prototype implementation which integrates LOLCAT with an object-oriented programming language.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Castegren,", + "last_name": "Elias", + "institution": "" + }, + { + "first_name": "Wrigstad,", + "last_name": "Tobias", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/CastegrenW17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.8", + "title": "Concurrent Data Structures Linked in Time", + "abstract": "Arguments about correctness of a concurrent data structure are typically carried out by using the notion of linearizability and specifying the linearization points of the data structure's procedures. Such arguments are often cumbersome as the linearization points' position in time can be dynamic (depend on the interference, run-time values and events from the past, or even future), non-local (appear in procedures other than the one considered), and whose position in the execution trace may only be determined after the considered procedure has already terminated. In this paper we propose a new method, based on a separation-style logic, for reasoning about concurrent objects with such linearization points. We embrace the dynamic nature of linearization points, and encode it as part of the data structure's auxiliary state, so that it can be dynamically modified in place by auxiliary code, as needed when some appropriate run-time event occurs. We name the idea linking-in-time, because it reduces temporal reasoning to spatial reasoning. For example, modifying a temporal position of a linearization point can be modeled similarly to a pointer update in separation logic. Furthermore, the auxiliary state provides a convenient way to concisely express the properties essential for reasoning about clients of such concurrent objects. We illustrate the method by verifying (mechanically in Coq) an intricate optimal snapshot algorithm due to Jayanti, as well as some clients.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Germán Andrés", + "last_name": "Delbianco", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "University College London" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "Madrid Institute for Advanced Studies" + }, + { + "first_name": "Anindya", + "last_name": "Banerjee", + "institution": "Madrid Institute for Advanced Studies" + } + ], + "dblp_key": "conf/ecoop/DelbiancoSNB17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.13", + "title": "A Generic Approach to Flow-Sensitive Polymorphic Effects", + "abstract": "Effect systems are lightweight extensions to type systems that can verify a wide range of important properties with modest developer burden. But our general understanding of effect systems is limited primarily to systems where the order of effects is irrelevant. Understanding such systems in terms of a lattice of effects grounds understanding of the essential issues, and provides guidance when designing new effect systems. By contrast, sequential effect systems --- where the order of effects is important --- lack a clear algebraic characterization. We derive an algebraic characterization from the shape of prior concrete sequential effect systems. We present an abstract polymorphic effect system with singleton effects parameterized by an effect quantale --- an algebraic structure with well-defined properties that can model a range of existing order-sensitive effect systems. We define effect quantales, derive useful properties, and show how they cleanly model a variety of known sequential effect systems. We show that effect quantales provide a free, general notion of iterating a sequential effect, and that for systems we consider the derived iteration agrees with the manually designed iteration operators in prior work. Identifying and applying the right algebraic structure led us to subtle insights into the design of order-sensitive effect systems, which provides guidance on non-obvious points of designing order-sensitive effect systems. Effect quantales have clear relationships to the recent category theoretic work on order-sensitive effect systems, but are explained without recourse to category theory. In addition, our derived iteration construct should generalize to these semantic structures, addressing limitations of that work.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "Drexel University" + } + ], + "dblp_key": "conf/ecoop/Gordon17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.9", + "title": "Contracts in the Wild: A Study of Java Programs", + "abstract": "The use of formal contracts has long been advocated as an approach to develop programs that are provably correct. However, the reality is that adoption of contracts has been slow in practice. Despite this, the adoption of lightweight contracts — typically utilising runtime checking — has progressed. In the case of Java, built-in features of the language (e.g. assertions and exceptions) can be used for this. Furthermore, a number of libraries which facilitate contract checking have arisen. In this paper, we catalogue 25 techniques and tools for lightweight contract checking in Java, and present the results of an empirical study looking at a dataset extracted from the 200 most popular projects found on Maven Central, constituting roughly 351,034 KLOC. We examine (1) the extent to which contracts are used and (2) what kind of contracts are used. We then investigate how contracts are used to safeguard code, and study problems in the context of two types of substitutability that can be guarded by contracts: (3) unsafe evolution of APIs that may break client programs and (4) violations of Liskovs Substitution Principle (LSP) when methods are overridden. We find that: (1) a wide range of techniques and constructs are used to represent contracts, and often the same program uses different techniques at the same time; (2) overall, contracts are used less than expected, with significant differences between programs; (3) projects that use contracts continue to do so, and expand the use of contracts as they grow and evolve; and, (4) there are cases where the use of contracts points to unsafe subtyping (violations of Liskov's Substitution Principle) and unsafe evolution.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jens", + "last_name": "Dietrich", + "institution": "Massey University" + }, + { + "first_name": "David J.", + "last_name": "Pearce", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Kamil", + "last_name": "Ježek", + "institution": "University of West Bohemia" + }, + { + "first_name": "Přemek", + "last_name": "Brada", + "institution": "University of West Bohemia" + } + ], + "dblp_key": "conf/ecoop/DietrichPJBD17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.4", + "title": "Parallelizing Julia with a Non-Invasive DSL", + "abstract": "Computational scientists often prototype software using productivity \\nlanguages that offer high-level programming abstractions. When higher \\nperformance is needed, they are obliged to rewrite their code in a \\nlower-level efficiency language. Different solutions have been \\nproposed to address this trade-off between productivity and \\nefficiency. One promising approach is to create embedded \\ndomain-specific languages that sacrifice generality for productivity \\nand performance, but practical experience with DSLs points to some \\nroad blocks preventing widespread adoption. This paper proposes a \\nnon-invasive domain-specific language that makes as few visible \\nchanges to the host programming model as possible. We present ParallelAccelerator, \\na library and compiler for high-level, high-performance scientific \\ncomputing in Julia. ParallelAccelerator's programming model is aligned with existing \\nJulia programming idioms. Our compiler exposes the implicit \\nparallelism in high-level array-style programs and compiles them to \\nfast, parallel native code. Programs can also run in \"library-only\" \\nmode, letting users benefit from the full Julia environment and \\nlibraries. Our results show encouraging performance improvements with very few changes to source code required. In particular, few to no additional type annotations are necessary.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Todd A.", + "last_name": "Anderson", + "institution": "Intel (United States)" + }, + { + "first_name": "Hai", + "last_name": "Liu", + "institution": "Intel (United States)" + }, + { + "first_name": "Lindsey", + "last_name": "Kuper", + "institution": "Intel (United States)" + }, + { + "first_name": "Ehsan", + "last_name": "Totoni", + "institution": "Intel (United States)" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + }, + { + "first_name": "Tatiana", + "last_name": "Shpeisman", + "institution": "Intel (United States)" + } + ], + "dblp_key": "conf/ecoop/AndersonLKTVS17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.14", + "title": "IceDust 2: Derived Bidirectional Relations and Calculation Strategy Composition", + "abstract": "Derived values are values calculated from base values. They can be expressed with views in relational databases, or with expressions in incremental or reactive programming. However, relational views do not provide multiplicity bounds, and incremental and reactive programming require significant boilerplate code in order to encode bidirectional derived values. Moreover, the composition of various strategies for calculating derived values is either disallowed, or not checked for producing derived values which will be consistent with the derived values they depend upon. In this paper we present IceDust2, an extension of the declarative data modeling language IceDust with derived bidirectional relations with multiplicity bounds and support for statically checked composition of calculation strategies. Derived bidirectional relations, multiplicity bounds, and calculation strategies all influence runtime behavior of changes to data, leading to hundreds of possible behavior definitions. IceDust2 uses a product-line based code generator to avoid explicitly defining all possible combinations, making it easier to reason about correctness. The type system allows only sound composition of strategies and guarantees multiplicity bounds. Finally, our case studies validate the usability of IceDust2 in applications.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Daco C.", + "last_name": "Harkes", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/ecoop/HarkesV17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.2", + "title": "Composing Software in an Age of Dissonance (Invited Talk)", + "abstract": "The power of languages is rooted in composition. An infinite number of sentences can be composed from a finite set of generative rules. The more uniformly the rules apply, the more valid compositions there are. Hence simpler rules give rise to richer discourse - a case of ‘less is more’. We must however be careful as to which distinctions we preserve and which we eliminate. If we abstract too much we risk creating an undifferentiated soup with no landmarks to orient us. A uniform space of objects with simple rules governing their interaction is an obvious example of these ideas, but objects also serve as a cautionary tale. Achieving simplicity is not easy; it requires taste, judgement, experience and dedication. Ingenuity is essential as well, but left unchecked, it often leads to uncontrollable complexity. The path of least resistance follows the tautological principle that ‘more is more’, and who can argue with a tautology? Dissonance dominates. I will endeavour to illustrate these rather abstract principles by means of examples from my own work and that of others, in programming languages, software and other domains. We may speak of many things - mixins, modules and memory, graphics and generics, patterns and parsers, architecture and automobiles, objects or other things entirely.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Gilad", + "last_name": "Bracha", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/ecoop/Bracha17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.16", + "title": "Speeding Up Maximal Causality Reduction with Static Dependency Analysis", + "abstract": "Stateless Model Checking (SMC) offers a powerful approach to verifying multithreaded programs but suffers from the state-space explosion problem caused by the huge thread interleaving space. The pioneering reduction technique Partial Order Reduction (POR) mitigates this problem by pruning equivalent interleavings from the state space. However, limited by the happens-before relation, POR still explores redundant executions. The recent advance, Maximal Causality Reduction (MCR), shows a promising performance improvement over the existing reduction techniques, but it has to construct complicated constraints to ensure the feasibility of the derived execution due to the lack of dependency information. In this work, we present a new technique, which extends MCR with static analysis to reduce the size of the constraints, thus speeding up the exploration of the state space. We also address the redundancy problem caused by the use of static analysis. We capture the dependency between a read and a later event e in the trace from the system dependency graph and identify those reads that e is not control dependent on. Our approach then ignores the constraints over such reads to reduce the complexity of the constraints. The experimental results show that compared to MCR, the number of the constraints and the solving time by our approach are averagely reduced by 31.6% and 27.8%, respectively.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Shiyou", + "last_name": "Huang", + "institution": "Texas A&M University" + }, + { + "first_name": "Jeff", + "last_name": "Huang", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/ecoop/Huang017", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.17", + "title": "Strong Logic for Weak Memory: Reasoning About Release-Acquire Consistency in Iris", + "abstract": "The field of concurrent separation logics (CSLs) has recently undergone two exciting developments: (1) the Iris framework for encoding and unifying advanced higher-order CSLs and formalizing them in Coq, and (2) the adaptation of CSLs to account for weak memory models, notably C11's release-acquire (RA) consistency. Unfortunately, these developments are seemingly incompatible, since Iris only applies to languages with an operational interleaving semantics, while C11 is defined by a declarative (axiomatic) semantics. In this paper, we show that, on the contrary, it is not only feasible but useful to marry these developments together. Our first step is to provide a novel operational characterization of RA+NA, the fragment of C11 containing RA accesses and \"non-atomic\" (normal data) accesses. Instantiating Iris with this semantics, we then derive higher-order variants of two prominent RA+NA logics, GPS and RSL. Finally, we deploy these derived logics in order to perform the first mechanical verifications (in Coq) of several interesting case studies of RA+NA programming. In a nutshell, we provide the first foundationally verified framework for proving programs correct under C11's weak-memory semantics.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jan-Oliver", + "last_name": "Kaiser", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Hoang-Hai", + "last_name": "Dang", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/ecoop/KaiserDDLV17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.18", + "title": "A Co-contextual Type Checker for Featherweight Java ", + "abstract": "This paper addresses compositional and incremental type checking for object-oriented programming languages. Recent work achieved incremental type checking for structurally typed functional languages through co-contextual typing rules, a constraint-based formulation that removes any context dependency for expression typings. However, that work does not cover key features of object-oriented languages: Subtype polymorphism, nominal typing, and implementation inheritance. Type checkers encode these features in the form of class tables, an additional form of typing context inhibiting incrementalization. In the present work, we demonstrate that an appropriate co-contextual notion to class tables exists, paving the way to efficient incremental type checkers for object-oriented languages. This yields a novel formulation of Igarashi et al.'s Featherweight Java (FJ) type system, where we replace class tables by the dual concept of class table requirements and class table operations by dual operations on class table requirements. We prove the equivalence of FJ's type system and our co-contextual formulation. Based on our formulation, we implemented an incremental FJ type checker and compared its performance against javac on a number of realistic example programs.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Edlira", + "last_name": "Kuci", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Sebastian", + "last_name": "Erdweg", + "institution": "Delft University of Technology" + }, + { + "first_name": "Oliver", + "last_name": "Bračevac", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Andi", + "last_name": "Bejleri", + "institution": "Imperial College London" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/ecoop/KuciEBBM17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.27", + "title": "Towards Strong Normalization for Dependent Object Types (DOT)", + "abstract": "The Dependent Object Types (DOT) family of calculi has been proposed as a new theoretic foundation for Scala and similar languages, unifying functional programming, object oriented programming and ML-style module systems. Following the recent type soundness proof for DOT, the present paper aims to establish stronger meta-theoretic properties. The main result is a fully mechanized proof of strong normalization for D_<:, a variant of DOT that excludes recursive functions and recursive types. We further discuss techniques and challenges for adding recursive types while maintaining strong normalization, and demonstrate that certain variants of recursive self types can be integrated successfully.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.27", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Fei", + "last_name": "Wang", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/ecoop/WangR17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.19", + "title": "Proactive Synthesis of Recursive Tree-to-String Functions from Examples", + "abstract": "Synthesis from examples enables non-expert users to generate programs by specifying examples of their behavior. A domain-specific form of such synthesis has been recently deployed in a widely used spreadsheet software product. In this paper we contribute to foundations of such techniques and present a complete algorithm for synthesis of a class of recursive functions defined by structural recursion over a given algebraic data type definition. The functions we consider map an algebraic data type to a string; they are useful for, e.g., pretty printing and serialization of programs and data. We formalize our problem as learning deterministic sequential \\ntop-down tree-to-string transducers with a single state (1STS). \\n \\nThe first problem we consider is learning a tree-to-string \\ntransducer from any set of input/output examples provided by the user. We show that, given a set of input/output examples, checking whether there exists a 1STS consistent with these examples is NP-complete in general. In contrast, the problem can be solved in polynomial time under a (practically useful) closure condition that each \\nsubtree of a tree in the input/output example set is also \\npart of the input/output examples. \\n \\nBecause coming up with relevant input/output examples may be \\ndifficult for the user while creating hard constraint problems \\nfor the synthesizer, we also study a more automated \\nactive learning scenario in which the algorithm chooses the \\ninputs for which the user provides the outputs. Our \\nalgorithm asks a worst-case linear number of queries as a \\nfunction of the size of the algebraic data type definition \\nto determine a unique transducer. \\n \\nTo construct our algorithms we present two new results on \\nformal languages. \\n \\nFirst, we define a class of word equations, called \\nsequential word equations, for which we prove that \\nsatisfiability can be solved in deterministic polynomial \\ntime. This is in contrast to the general word equations for \\nwhich the best known complexity upper bound is in linear space. \\n \\nSecond, we close a long-standing open problem about the \\nasymptotic size of test sets for context-free languages. A \\ntest set of a language of words L is a subset T of L \\nsuch that any two word homomorphisms equivalent on T are \\nalso equivalent on L. We prove that it is possible to \\nbuild test sets of cubic size for context-free languages, \\nmatching for the first time the lower bound found 20 years \\nago.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Mikaël", + "last_name": "Mayer", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Jad", + "last_name": "Hamza", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/ecoop/MayerHK17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.23", + "title": "Interprocedural Specialization of Higher-Order Dynamic Languages Without Static Analysis", + "abstract": "Function duplication is widely used by JIT compilers to efficiently implement dynamic languages. When the source language supports higher order functions, the called function's identity is not generally known when compiling a call site, thus limiting the use of function duplication. This paper presents a JIT compilation technique enabling function duplication in the presence of higher order functions. Unlike existing techniques, our approach uses dynamic dispatch at call sites instead of relying on a conservative analysis to discover function identity. We have implemented the technique in a JIT compiler for Scheme. Experiments show that it is efficient at removing type checks, allowing the removal of almost all the run time type checks for several benchmarks. This allows the compiler to generate code up to 50% faster. We show that the technique can be used to duplicate functions using other run time information opening up new applications such as register allocation based duplication and aggressive inlining.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Baptiste", + "last_name": "Saleil", + "institution": "Université de Montréal" + }, + { + "first_name": "Marc", + "last_name": "Feeley", + "institution": "Université de Montréal" + } + ], + "dblp_key": "conf/ecoop/SaleilF17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.20", + "title": "A Capability-Based Module System for Authority Control", + "abstract": "The principle of least authority states that each component of the system should be given authority to access only the information and resources that it needs for its operation. This principle is fundamental to the secure design of software systems, as it helps to limit an application's attack surface and to isolate vulnerabilities and faults. Unfortunately, current programming languages do not provide adequate help in controlling the authority of application modules, an issue that is particularly acute in the case of untrusted third-party extensions. In this paper, we present a language design that facilitates controlling the authority granted to each application module. The key technical novelty of our approach is that modules are first-class, statically typed capabilities. First-class modules are essentially objects, and so we formalize our module system by translation into an object calculus and prove that the core calculus is type-safe and authority-safe. Unlike prior formalizations, our work defines authority non-transitively, allowing engineers to reason about software designs that use wrappers to provide an attenuated version of a more powerful capability. Our approach allows developers to determine a module's authority by examining the capabilities passed as module arguments when the module is created, or delegated to the module later during execution. The type system facilitates this by identifying which objects provide capabilities to sensitive resources, and by enabling security architects to examine the capabilities passed into and out of a module based only on the module's interface, without needing to examine the module's implementation code. An implementation of the module system and illustrative examples in the Wyvern programming language suggest that our approach can be a practical way to control module authority.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Melicher,", + "last_name": "Darya", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Yangqingwei", + "last_name": "Shi", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/ecoop/MelicherSPA17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.22", + "title": "Promising Compilation to ARMv8 POP", + "abstract": "The C and C++ high-level languages provide programmers with atomic operations for writing high-performance concurrent code. At the assembly language level, C and C++ atomics get mapped down to individual instructions or combinations of instructions by compilers, depending on the ordering guarantees and synchronization instructions provided by the underlying architecture. These compiler mappings must uphold the ordering guarantees provided by C/C++ atomics or the compiled program will not behave according to the C/C++ memory model. In this paper we discuss two counterexamples to the well-known trailing-sync compiler mappings for the Power and ARMv7 architectures that were previously thought to be proven correct. In addition to the counterexamples, we discuss the loophole in the proof of the mappings that allowed the incorrect mappings to be proven correct. We also discuss the current state of compilers and architectures in relation to the bug.", + "date": "2016-11-04", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yatin A.", + "last_name": "Manerkar", + "institution": "" + }, + { + "first_name": "Caroline", + "last_name": "Trippel", + "institution": "" + }, + { + "first_name": "Daniel", + "last_name": "Lustig", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Pellauer", + "institution": "" + }, + { + "first_name": "Margaret", + "last_name": "Martonosi", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/PodkopaevLV17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.28", + "title": "Mixed Messages: Measuring Conformance and Non-Interference in TypeScript", + "abstract": "TypeScript participates in the recent trend among programming languages to support gradual typing. The DefinitelyTyped Repository for TypeScript supplies type definitions for over 2000 popular JavaScript libraries. However, there is no guarantee that implementations conform to their corresponding declarations. We present a practical evaluation of gradual typing for TypeScript. We have developed a tool for use with TypeScript, based on the polymorphic blame calculus, for monitoring JavaScript libraries and TypeScript clients against the TypeScript definition. We apply our tool, TypeScript TPD, to those libraries in the DefinitelyTyped Repository which had adequate test code to use. Of the 122 libraries we checked, 62 had cases where either the library or its tests failed to conform to the declaration. Gradual typing should satisfy non-interference. Monitoring a program should never change its behaviour, except to raise a type error should a value not conform to its declared type. However, our experience also suggests serious technical concerns with the use of the JavaScript proxy mechanism for enforcing contracts. Of the 122 libraries we checked, 22 had cases where the library or its tests violated non-interference.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.28", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jack M.", + "last_name": "Williams", + "institution": "University of Edinburgh" + }, + { + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "" + }, + { + "first_name": "Philip", + "last_name": "Wadler", + "institution": "" + }, + { + "first_name": "Jakub", + "last_name": "Zalewski", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/ecoop/WilliamsMWZ17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.26", + "title": "Compiling Tree Transforms to Operate on Packed Representations", + "abstract": "When written idiomatically in most programming languages, programs that traverse and construct trees operate over pointer-based data structures, using one heap object per-leaf and per-node. This representation is efficient for random access and shape-changing modifications, but for traversals, such as compiler passes, that process most or all of a tree in bulk, it can be inefficient. In this work we instead compile tree traversals to operate on pointer-free pre-order serializations of trees. On modern architectures such programs often run significantly faster than their pointer-based counterparts, and additionally are directly suited to storage and transmission without requiring marshaling. We present a prototype compiler, Gibbon, that compiles a small first-order, purely functional language sufficient for tree traversals. The compiler transforms this language into intermediate representation with explicit pointers into input and output buffers for packed data. The key compiler technologies include an effect system for capturing traversal behavior, combined with an algorithm to insert destination cursors. We evaluate our compiler on tree transformations over a real-world dataset of source-code syntax trees. For traversals touching the whole tree, such as maps and folds, packed data allows speedups of over 2x compared to a highly-optimized pointer-based baseline.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.26", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Michael", + "last_name": "Vollmer", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Sarah", + "last_name": "Spall", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Buddhika", + "last_name": "Chamith", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Laith", + "last_name": "Sakka", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Chaitanya", + "last_name": "Koparkar", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University Bloomington" + }, + { + "first_name": "Ryan", + "last_name": "Newton", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/ecoop/VollmerSCSK0TN17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.25", + "title": "Mailbox Abstractions for Static Analysis of Actor Programs", + "abstract": "Properties such as the absence of errors or bounds on mailbox sizes are hard to deduce statically for actor-based programs. This is because actor-based programs exhibit several sources of unboundedness, in addition to the non-determinism that is inherent to the concurrent execution of actors. We developed a static technique based on abstract interpretation to soundly reason in a finite amount of time about the possible executions of an actor-based program. We use our technique to statically verify the absence of errors in actor-based programs, and to compute upper bounds on the actors' mailboxes. Sound abstraction of these mailboxes is crucial to the precision of any such technique. We provide several mailbox abstractions and categorize them according to the extent to which they preserve message ordering and multiplicity of messages in a mailbox. We formally prove the soundness of each mailbox abstraction, and empirically evaluate their precision and performance trade-offs on a corpus of benchmark programs. The results show that our technique can statically verify the absence of errors for more benchmark programs than the state-of-the-art analysis.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.25", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Quentin", + "last_name": "Stiévenart", + "institution": "Bioengineering Center" + }, + { + "first_name": "Jens", + "last_name": "Nicolay", + "institution": "" + }, + { + "first_name": "Wolfgang De", + "last_name": "Meuter", + "institution": "" + }, + { + "first_name": "Coen De", + "last_name": "Roover", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/StievenartNMR17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.30", + "title": "An Empirical Study on Deoptimization in the Graal Compiler", + "abstract": "Managed language platforms such as the Java Virtual Machine or the Common Language Runtime rely on a dynamic compiler to achieve high performance. Besides making optimization decisions based on the actual program execution and the underlying hardware platform, a dynamic compiler is also in an ideal position to perform speculative optimizations. However, these tend to increase the compilation costs, because unsuccessful speculations trigger deoptimization and recompilation of the affected parts of the program, wasting previous work. Even though speculative optimizations are widely used, the costs of these optimizations in terms of extra compilation work has not been previously studied. In this paper, we analyze the behavior of the Graal dynamic compiler integrated in Oracle's HotSpot Virtual Machine. We focus on situations which cause program execution to switch from machine code to the interpreter, and compare application performance using three different deoptimization strategies which influence the amount of extra compilation work done by Graal. Using an adaptive deoptimization strategy, we managed to improve the average start-up performance of benchmarks from the DaCapo, ScalaBench, and Octane benchmark suites, mostly by avoiding wasted compilation work. On a single-core system, we observed an average speed-up of 6.4% for the DaCapo and ScalaBench workloads, and a speed-up of 5.1% for the Octane workloads; the improvement decreases with an increasing number of available CPU cores. We also find that the choice of a deoptimization strategy has negligible impact on steady-state performance. This indicates that the cost of speculation matters mainly during start-up, where it can disturb the delicate balance between executing the program and the compiler, but is quickly amortized in steady state.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.30", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yudi", + "last_name": "Zheng", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Lubomír", + "last_name": "Bulej", + "institution": "Charles University" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/ecoop/ZhengBB17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.21", + "title": "Data Exploration through Dot-driven Development", + "abstract": "Data literacy is becoming increasingly important in the modern world. While spreadsheets make simple data analytics accessible to a large number of people, creating transparent scripts that can be checked, modified, reproduced and formally analyzed requires expert programming skills. In this paper, we describe the design of a data exploration language that makes the task more accessible by embedding advanced programming concepts into a simple core language. The core language uses type providers, but we employ them in a novel way -- rather than providing types with members for accessing data, we provide types with members that allow the user to also compose rich and correct queries using just member access ('dot'). This way, we recreate functionality that usually requires complex type systems (row polymorphism, type state and dependent typing) in an extremely simple object-based language. We formalize our approach using an object-based calculus and prove that programs constructed using the provided types represent valid data transformations. We discuss a case study developed using the language, together with additional editor tooling that bridges some of the gaps between programming and spreadsheets. We believe that this work provides a pathway towards democratizing data science - our use of type providers significantly reduce the complexity of languages that one needs to understand in order to write scripts for exploring data.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Petricek,", + "last_name": "Tomas", + "institution": "Turing Institute" + } + ], + "dblp_key": "conf/ecoop/Petricek17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.29", + "title": "EVF: An Extensible and Expressive Visitor Framework for Programming Language Reuse", + "abstract": "Object Algebras are a design pattern that enables extensibility, modularity, and reuse in mainstream object-oriented languages such as Java. The theoretical foundations of Object Algebras are rooted on Church encodings of datatypes, which are in turn closely related to folds in functional programming. Unfortunately, it is well-known that certain programs are difficult to write, and may incur performance penalties when using Church-encodings/folds. This paper presents EVF: an extensible and expressive Java Visitor framework. The visitors supported by EVF generalize Object Algebras and enable writing programs using a generally recursive style rather than folds. The use of such generally recursive style enables users to more naturally write programs, which would otherwise require contrived workarounds using a fold-like structure. EVF visitors retain the type-safe extensibility of Object Algebras. The key advance in EVF is a novel technique to support extensible external visitors. Extensible external visitors are able to control traversals with direct access to the data structure being traversed, allowing dependent operations to be defined modularly without the need of advanced type system features. To make EVF practical, the framework employs annotations to automatically generate large amounts of boilerplate code related to visitors and traversals. To illustrate the applicability of EVF we conduct a case study, which refactors a large number of non-modular interpreters from the “Types and Programming Languages” (TAPL) book. Using EVF we are able to create a modular software product line (SPL) of the TAPL interpreters, enabling sharing of large portions of code and features. The TAPL software product line contains several modular operations, which would be non-trivial to define with standard Object Algebras.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.29", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Weixin", + "last_name": "Zhang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/ecoop/ZhangO17", + "venue": "ecoop", + "year": 2017 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2017.24", + "title": "A Linear Decomposition of Multiparty Sessions for Safe Distributed Programming", + "abstract": "Multiparty Session Types (MPST) is a typing discipline for message-passing distributed processes that can ensure properties such as absence of communication errors and deadlocks, and protocol conformance. Can MPST provide a theoretical foundation for concurrent and distributed programming in \"mainstream\" languages? We address this problem by (1) developing the first encoding of a full-fledged multiparty session pi-calculus into linear pi-calculus, and (2) using the encoding as the foundation of a practical toolchain for safe multiparty programming in Scala. Our encoding is type-preserving and operationally sound and complete. Crucially, it keeps the distributed choreographic nature of MPST, illuminating that the safety properties of multiparty sessions can be precisely represented with a decomposition into binary linear channels. Previous works have only studied the relation between (limited) multiparty and binary sessions via centralised orchestration means. We exploit these results to implement an automated generation of Scala APIs for multiparty sessions, abstracting existing libraries for binary communication channels. This allows multiparty systems to be safely implemented over binary message transports, as commonly found in practice. Our implementation is the first to support distributed multiparty delegation: our encoding yields it for free, via existing mechanisms for binary delegation.", + "date": "2017-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2017.24", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "" + }, + { + "first_name": "Ornela", + "last_name": "Dardha", + "institution": "University of Glasgow" + }, + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "Royal Brompton Hospital" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Royal Brompton Hospital" + } + ], + "dblp_key": "conf/ecoop/ScalasDHY17", + "venue": "ecoop", + "year": 2017 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2018.json b/data/pl_conferences/ecoop/2018.json new file mode 100644 index 0000000..3ead7d3 --- /dev/null +++ b/data/pl_conferences/ecoop/2018.json @@ -0,0 +1,793 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.0", + "title": "Front Matter, Table of Contents, Preface, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Conference Organization", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Todd", + "last_name": "Millstein", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/ecoop/X18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.2", + "title": "ContextWorkflow: A Monadic DSL for Compensable and Interruptible Executions", + "abstract": "Context-aware applications, whose behavior reactively depends on the time-varying status of the surrounding environment - such as network connection, battery level, and sensors - are getting more and more pervasive and important. The term \"context-awareness\" usually suggests prompt reactions to context changes: as the context change signals that the current execution cannot be continued, the application should immediately abort its execution, possibly does some clean-up tasks, and suspend until the context allows it to restart. Interruptions, or asynchronous exceptions, are useful to achieve context-awareness. It is, however, difficult to program with interruptions in a compositional way in most programming languages because their support is too primitive, relying on synchronous exception handling mechanism such as try-catch. We propose a new domain-specific language ContextWorkflow for interruptible programs as a solution to the problem. A basic unit of an interruptible program is a workflow, i.e., a sequence of atomic computations accompanied with compensation actions. The uniqueness of ContextWorkflow is that, during its execution, a workflow keeps watching the context between atomic actions and decides if the computation should be continued, aborted, or suspended. Our contribution of this paper is as follows; (1) the design of a workflow-like language with asynchronous interruption, checkpointing, sub-workflows and suspension; (2) a formal semantics of the core language; (3) a monadic interpreter corresponding to the semantics; and (4) its concrete implementation as an embedded domain-specific language in Scala.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Hiroaki", + "last_name": "Inoue", + "institution": "Kyoto College of Graduate Studies for Informatics" + }, + { + "first_name": "Tomoyuki", + "last_name": "Aotani", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto College of Graduate Studies for Informatics" + } + ], + "dblp_key": "conf/ecoop/InoueAI18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.13", + "title": "Dependent Types for Class-based Mutable Objects", + "abstract": "We present an imperative object-oriented language featuring a dependent type system designed to support class-based programming and inheritance. Programmers implement classes in the usual imperative style, and may take advantage of a richer dependent type system to express class invariants and restrictions on how objects are allowed to change and be used as arguments to methods. By way of example, we implement insertion and deletion for binary search trees in an imperative style, and come up with types that ensure the binary search tree invariant. This is the first dependently-typed language with mutable objects that we know of to bring classes and index refinements into play, enabling types (classes) to be refined by indices drawn from some constraint domain. We give a declarative type system that supports objects whose types may change, despite being sound. We also give an algorithmic type system that provides a precise account of quantifier instantiation in a bidirectional style, and from which it is straightforward to read off an implementation. Moreover, all the examples in the paper have been run, compiled and executed in a fully functional prototype that includes a plugin for the Eclipse IDE.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Joana", + "last_name": "Campos", + "institution": "University of Lisbon" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + } + ], + "dblp_key": "conf/ecoop/0002V18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.14", + "title": "Static Typing of Complex Presence Constraints in Interfaces", + "abstract": "Many functions in libraries and APIs have the notion of optional parameters, which can be mapped onto optional properties of an object representing those parameters. The fact that properties are optional opens up the possibility for APIs and libraries to design a complex \"dependency logic\" between properties: for example, some properties may be mutually exclusive, some properties may depend on others, etc. Existing type systems are not strong enough to express such dependency logic, which can lead to the creation of invalid objects and accidental usage of absent properties. In this paper we propose TypeScriptIPC: a variant of TypeScript with a novel type system that enables programmers to express complex presence constraints on properties. We prove that it is sound with respect to enforcing complex dependency logic defined by the programmer when an object is created, modified or accessed.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Nathalie", + "last_name": "Oostvogels", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Joeri De", + "last_name": "Koster", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Wolfgang De", + "last_name": "Meuter", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/ecoop/OostvogelsKM18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.8", + "title": "Targeted Test Generation for Actor Systems", + "abstract": "This paper addresses the problem of targeted test generation for actor systems. Specifically, we propose a method to support generation of system-level tests to cover a given code location in an actor system. The test generation method consists of two phases. First, static analysis is used to construct an abstraction of an entire actor system in terms of a message flow graph (MFG). An MFG captures potential actor interactions that are defined in a program. Second, a backwards symbolic execution (BSE) from a target location to an \"entry point\" of the actor system is performed. BSE uses the MFG constructed in the first phase of our targeted test generation method to guide execution across actors. Because concurrency leads to a huge search space which can potentially be explored through BSE, we prune the search space by using two heuristics combined with a feedback-directed technique. We implement our method in Tap, a tool for Java Akka programs, and evaluate Tap on the Savina benchmarks as well as four open source projects. Our evaluation shows that the Tap achieves a relatively high target coverage (78% on 1,000 targets) and detects six previously unreported bugs in the subjects.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sihan", + "last_name": "Li", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Farah", + "last_name": "Hariri", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Gul", + "last_name": "Agha", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/ecoop/LiHA18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.5", + "title": "A Characteristic Study of Parameterized Unit Tests in .NET Open Source Projects", + "abstract": "In the past decade, parameterized unit testing has emerged as a promising method to specify program behaviors under test in the form of unit tests. Developers can write parameterized unit tests (PUTs), unit-test methods with parameters, in contrast to conventional unit tests, without parameters. The use of PUTs can enable powerful test generation tools such as Pex to have strong test oracles to check against, beyond just uncaught runtime exceptions. In addition, PUTs have been popularly supported by various unit testing frameworks for .NET and the JUnit framework for Java. However, there exists no study to offer insights on how PUTs are written by developers in either proprietary or open source development practices, posing barriers for various stakeholders to bring PUTs to widely adopted practices in software industry. To fill this gap, we first present categorization results of the Microsoft MSDN Pex Forum posts (contributed primarily by industrial practitioners) related to PUTs. We then use the categorization results to guide the design of the first characteristic study of PUTs in .NET open source projects. We study hundreds of PUTs that open source developers wrote for these open source projects. Our study findings provide valuable insights for various stakeholders such as current or prospective PUT writers (e.g., developers), PUT framework designers, test-generation tool vendors, testing researchers, and testing educators.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Wing", + "last_name": "Lam", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Siwakorn", + "last_name": "Srisakaokul", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Blake", + "last_name": "Bassett", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Peyman", + "last_name": "Mahdian", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Tao", + "last_name": "Xie", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Pratap", + "last_name": "Lakshman", + "institution": "Microsoft Research Asia (China)" + }, + { + "first_name": "Jonathan de", + "last_name": "Halleux", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/ecoop/LamSBM0LH18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.6", + "title": "Learning to Accelerate Symbolic Execution via Code Transformation", + "abstract": "Symbolic execution is an effective but expensive technique for automated test generation. Over the years, a large number of refined symbolic execution techniques have been proposed to improve its efficiency. However, the symbolic execution efficiency problem remains, and largely limits the application of symbolic execution in practice. Orthogonal to refined symbolic execution, in this paper we propose to accelerate symbolic execution through semantic-preserving code transformation on the target programs. During the initial stage of this direction, we adopt a particular code transformation, compiler optimization, which is initially proposed to accelerate program concrete execution by transforming the source program into another semantic-preserving target program with increased efficiency (e.g., faster or smaller). However, compiler optimizations are mostly designed to accelerate program concrete execution rather than symbolic execution. Recent work also reported that unified settings on compiler optimizations that can accelerate symbolic execution for any program do not exist at all. Therefore, in this work we propose a machine-learning based approach to tuning compiler optimizations to accelerate symbolic execution, whose results may also aid further design of specific code transformations for symbolic execution. In particular, the proposed approach LEO separates source-code functions and libraries through our program-splitter, and predicts individual compiler optimization (i.e., whether a type of code transformation is chosen) separately through analyzing the performance of existing symbolic execution. Finally, LEO applies symbolic execution on the code transformed by compiler optimization (through our local-optimizer). We conduct an empirical study on GNU Coreutils programs using the KLEE symbolic execution engine. The results show that LEO significantly accelerates symbolic execution, outperforming the default KLEE configurations (i.e., turning on/off all compiler optimizations) in various settings, e.g., with the default training/testing time, LEO achieves the highest line coverage in 50/68 programs, and its average improvement rate on all programs is 46.48%/88.92% in terms of line coverage compared with turning on/off all compiler optimizations.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Junjie", + "last_name": "Chen", + "institution": "Institute of Software" + }, + { + "first_name": "Wenxiang", + "last_name": "Hu", + "institution": "Institute of Software" + }, + { + "first_name": "Lingming", + "last_name": "Zhang", + "institution": "The University of Texas at Dallas" + }, + { + "first_name": "Dan", + "last_name": "Hao", + "institution": "Peking University" + }, + { + "first_name": "Sarfraz", + "last_name": "Khurshid", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Lu", + "last_name": "Zhang", + "institution": "Peking University" + } + ], + "dblp_key": "conf/ecoop/ChenHZHK018", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.7", + "title": "Type Regression Testing to Detect Breaking Changes in Node.js Libraries", + "abstract": "The npm repository contains JavaScript libraries that are used by millions of software developers. Its semantic versioning system relies on the ability to distinguish between breaking and non-breaking changes when libraries are updated. However, the dynamic nature of JavaScript often causes unintended breaking changes to be detected too late, which undermines the robustness of the applications.\\nWe present a novel technique, type regression testing, to automatically determine whether an update of a library implementation affects the types of its public interface, according to how the library is being used by other npm packages. By leveraging available test suites of clients, type regression testing uses a dynamic analysis to learn models of the library interface. Comparing the models before and after an update effectively amplifies the existing tests by revealing changes that may affect the clients.\\nExperimental results on 12 widely used libraries show that the technique can identify type-related breaking changes with high accuracy. It fully automatically classifies at least 90% of the updates correctly as either major or as minor or patch, and it detects 26 breaking changes among the minor and patch updates.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Gianluca", + "last_name": "Mezzetti", + "institution": "University of Pisa" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Martin Toldam", + "last_name": "Torp", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/ecoop/MezzettiMT18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.10", + "title": "CrySL: An Extensible Approach to Validating the Correct Usage of Cryptographic APIs", + "abstract": "Various studies have empirically shown that the majority of Java and Android apps misuse cryptographic libraries, causing devastating breaches of data security. It is crucial to detect such misuses early in the development process. To detect cryptography misuses, one must first define secure uses, a process mastered primarily by cryptography experts, and not by developers. In this paper, we present CrySL, a definition language for bridging the cognitive gap between cryptography experts and developers. CrySL enables cryptography experts to specify the secure usage of the cryptographic libraries that they provide. We have implemented a compiler that translates such CrySL specification into a context-sensitive and flow-sensitive demand-driven static analysis. The analysis then helps developers by automatically checking a given Java or Android app for compliance with the CrySL-encoded rules. We have designed an extensive CrySL rule set for the Java Cryptography Architecture (JCA), and empirically evaluated it by analyzing 10,000 current Android apps. Our results show that misuse of cryptographic APIs is still widespread, with 95% of apps containing at least one misuse. Our easily extensible CrySL rule set covers more violations than previous special-purpose tools with hard-coded rules, with our tooling offering a more precise analysis.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Stefan", + "last_name": "Krüger", + "institution": "Paderborn University" + }, + { + "first_name": "Johannes", + "last_name": "Späth", + "institution": "Fraunhofer Institute for Mechatronic Systems Design" + }, + { + "first_name": "Karim", + "last_name": "Ali", + "institution": "University of Alberta" + }, + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Paderborn University" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/ecoop/KrugerS0BM18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.11", + "title": "Safe Transferable Regions", + "abstract": "There is an increasing interest in alternative memory management schemes that seek to combine the convenience of garbage collection and the performance of manual memory management in a single language framework. Unfortunately, ensuring safety in presence of manual memory management remains as great a challenge as ever. In this paper, we present a C#-like object-oriented language called Broom that uses a combination of region type system and lightweight runtime checks to enforce safety in presence of user-managed memory regions called transferable regions. Unsafe transferable regions have been previously used to contain the latency due to unbounded GC pauses. Our approach shows that it is possible to restore safety without compromising on the benefits of transferable regions. We prove the type safety of Broom in a formal framework that includes its C#-inspired features, such as higher-order functions and generics. We complement our type system with a type inference algorithm, which eliminates the need for programmers to write region annotations on types. The inference algorithm has been proven sound and relatively complete. We describe a prototype implementation of the inference algorithm, and our experience of using it to enforce memory safety in dataflow programs.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "G.", + "last_name": "Ramalingam", + "institution": "Microsoft Research (India)" + } + ], + "dblp_key": "conf/ecoop/KakiR18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.4", + "title": "A Concurrent Specification of POSIX File Systems", + "abstract": "POSIX is a standard for operating systems, with a substantial part devoted to specifying file-system operations. File-system operations exhibit complex concurrent behaviour, comprising multiple actions affecting different parts of the state: typically, multiple atomic reads followed by an atomic update. However, the standard's description of concurrent behaviour is unsatisfactory: it is fragmented; contains ambiguities; and is generally under-specified. We provide a formal concurrent specification of POSIX file systems and demonstrate scalable reasoning for clients. Our specification is based on a concurrent specification language, which uses a modern concurrent separation logic for reasoning about abstract atomic operations, and an associated refinement calculus. Our reasoning about clients highlights an important difference between reasoning about modules built over a heap, where the interference on the shared state is restricted to the operations of the module, and modules built over a file system, where the interference cannot be restricted as the file system is a public namespace. We introduce specifications conditional on context invariants used to restrict the interference, and apply our reasoning to the example of lock files.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Gian", + "last_name": "Ntzik", + "institution": "Imperial College London" + }, + { + "first_name": "Pedro da Rocha", + "last_name": "Pinto", + "institution": "Imperial College London" + }, + { + "first_name": "Julian", + "last_name": "Sutherland", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/NtzikPSG18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.9", + "title": "Typed First-Class Traits", + "abstract": "Many dynamically-typed languages (including JavaScript, Ruby, Python or Racket) support first-class classes, or related concepts such as first-class traits and/or mixins. In those languages classes are first-class values and, like any other values, they can be passed as an argument, or returned from a function. Furthermore first-class classes support dynamic inheritance: i.e. they can inherit from other classes at runtime, enabling programmers to abstract over the inheritance hierarchy. In contrast, type system limitations prevent most statically-typed languages from having first-class classes and dynamic inheritance. This paper shows the design of SEDEL: a polymorphic statically-typed language with first-class traits, supporting dynamic inheritance as well as conventional OO features such as dynamic dispatching and abstract methods. To address the challenges of type-checking first-class traits, SEDEL employs a type system based on the recent work on disjoint intersection types and disjoint polymorphism. The novelty of SEDEL over core disjoint intersection calculi are source level features for practical OO programming, including first-class traits with dynamic inheritance, dynamic dispatching and abstract methods. Inspired by Cook and Palsberg's work on the denotational semantics for inheritance, we show how to design a source language that can be elaborated into Alpuim et al.'s F_{i} (a core polymorphic calculus with records supporting disjoint polymorphism). We illustrate the applicability of SEDEL with several example uses for first-class traits, and a case study that modularizes programming language interpreters using a highly modular form of visitors.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Xuan", + "last_name": "Bi", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/ecoop/BiO18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.1", + "title": "Fault-tolerant Distributed Reactive Programming", + "abstract": "In this paper, we present a holistic approach to provide fault tolerance for distributed reactive programming. Our solution automatically stores and recovers program state to handle crashes, automatically updates and shares distributed parts of the state to provide eventual consistency, and handles errors in a fine-grained manner to allow precise manual control when necessary. By making use of the reactive programming paradigm, we provide these mechanisms without changing the behavior of existing programs and with reasonable performance, as indicated by our experimental evaluation.", + "date": "2016-09-08", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Matej", + "last_name": "Pavlovič", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Dragos-Adrian", + "last_name": "Seredinschi", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/ecoop/MogkBSFM18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.15", + "title": "Mailbox Types for Unordered Interactions", + "abstract": "We propose a type system for reasoning on protocol conformance and deadlock freedom in networks of processes that communicate through unordered mailboxes. We model these networks in the mailbox calculus, a mild extension of the asynchronous pi-calculus with first-class mailboxes and selective input. The calculus subsumes the actor model and allows us to analyze networks with dynamic topologies and varying number of processes possibly mixing different concurrency abstractions. Well-typed processes are deadlock free and never fail because of unexpected messages. For a non-trivial class of them, junk freedom is also guaranteed. We illustrate the expressiveness of the calculus and of the type system by encoding instances of non-uniform, concurrent objects, binary sessions extended with joins and forks, and some known actor benchmarks.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "De&apos; Liguoro,", + "last_name": "Ugo", + "institution": "University of Turin" + }, + { + "first_name": "Luca", + "last_name": "Padovani", + "institution": "University of Turin" + } + ], + "dblp_key": "conf/ecoop/deLiguoroP18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.3", + "title": "Theory and Practice of Coroutines with Snapshots", + "abstract": "Coroutines are a general control flow construct that can eliminate control flow fragmentation inherent in event-driven programs, and are still missing in many popular languages. Coroutines with snapshots are a first-class, type-safe, stackful coroutine model, which unifies many variants of suspendable computing, and is sufficiently general to express iterators, single-assignment variables, async-await, actors, event streams, backtracking, symmetric coroutines and continuations. In this paper, we develop a formal model called $λ_{\\rightsquigarrow}$ (lambda-squiggly) that captures the essence of type-safe, stackful, delimited coroutines with snapshots. We prove the standard progress and preservation safety properties. Finally, we show a formal transformation from the $λ_{\\rightsquigarrow}$ calculus to the simply-typed lambda calculus with references.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aleksandar", + "last_name": "Prokopec", + "institution": "" + }, + { + "first_name": "Fengyun", + "last_name": "Liu", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/ecoop/ProkopecL18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.12", + "title": "KafKa: Gradual Typing for Objects", + "abstract": "A wide range of gradual type systems have been proposed, providing many languages with the ability to mix typed and untyped code. However, hiding under language details, these gradual type systems embody fundamentally different ideas of what it means to be well-typed. In this paper, we show that four of the most common gradual type systems provide distinct guarantees, and we give a formal framework for comparing gradual type systems for object-oriented languages. First, we show that the different gradual type systems are practically distinguishable via a three-part litmus test. We present a formal framework for defining and comparing gradual type systems. Within this framework, different gradual type systems become translations between a common source and target language, allowing for direct comparison of semantics and guarantees.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Chung", + "institution": "Northeastern University" + }, + { + "first_name": "Paley", + "last_name": "Li", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/ChungLNV18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.16", + "title": "Accelerating Dynamically-Typed Languages on Heterogeneous Platforms Using Guards Optimization", + "abstract": "Scientific applications are ideal candidates for the \"heterogeneous computing\" paradigm, in which parts of a computation are \"offloaded\" to available accelerator hardware such as GPUs. However, when such applications are written in dynamic languages such as Python or R, as they increasingly are, things become less straightforward. The same flexibility that makes these languages so appealing to programmers also significantly complicates the problem of automatically and transparently partitioning a program's execution between a CPU and available accelerator hardware without having to rely on programmer annotations. A common way of handling the features of dynamic languages is by introducing speculation in conjunction with guards to ascertain the validity of assumptions made in the speculative computation. Unfortunately, a single guard violation during the execution of \"offloaded\" code may result in a huge performance penalty and necessitate the complete re-execution of the offloaded computation. In the case of dynamic languages, this problem is compounded by the fact that a full compiler analysis is not always possible ahead of time. This paper presents MegaGuards, a new approach for speculatively executing dynamic languages on heterogeneous platforms in a fully automatic and transparent manner. Our method translates each target loop into a single static region devoid of any dynamic type features. The dynamic parts are instead handled by a construct that we call a mega guard which checks all the speculative assumptions ahead of its corresponding static region. Notably, the advantage of MegaGuards is not limited to heterogeneous computing; because it removes guards from compute-intensive loops, the approach also improves sequential performance. We have implemented MegaGuards along with an automatic loop parallelization backend in ZipPy, a Python Virtual Machine. The results of a careful and detailed evaluation reveal very significant speedups of an order of magnitude on average with a maximum speedup of up to two orders of magnitudes when compared to the original ZipPy performance as a baseline. These results demonstrate the potential for applying heterogeneous computing to dynamic languages.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Mohaned", + "last_name": "Qunaibit", + "institution": "University of California, Irvine" + }, + { + "first_name": "Stefan", + "last_name": "Brunthaler", + "institution": "Paderborn University" + }, + { + "first_name": "Yeoul", + "last_name": "Na", + "institution": "University of California, Irvine" + }, + { + "first_name": "Stijn", + "last_name": "Volckaert", + "institution": "University of California, Irvine" + }, + { + "first_name": "Michael", + "last_name": "Franz", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/ecoop/QunaibitBNVF18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.17", + "title": "CROCHET: Checkpoint and Rollback via Lightweight Heap Traversal on Stock JVMs", + "abstract": "Checkpoint/rollback (CR) mechanisms create snapshots of the state of a running application, allowing it to later be restored to that checkpointed snapshot. Support for checkpoint/rollback enables many program analyses and software engineering techniques, including test generation, fault tolerance, and speculative execution. Fully automatic CR support is built into some modern operating systems. However, such systems perform checkpoints at the coarse granularity of whole pages of virtual memory, which imposes relatively high overhead to incrementally capture the changing state of a process, and makes it difficult for applications to checkpoint only some logical portions of their state. CR systems implemented at the application level and with a finer granularity typically require complex developer support to identify: (1) where checkpoints can take place, and (2) which program state needs to be copied. A popular compromise is to implement CR support in managed runtime environments, e.g. the Java Virtual Machine (JVM), but this typically requires specialized, non-standard runtime environments, limiting portability and adoption of this approach. In this paper, we present a novel approach for Checkpoint ROllbaCk via lightweight HEap Traversal (Crochet), which enables fully automatic fine-grained lightweight checkpoints within unmodified commodity JVMs (specifically Oracle's HotSpot and OpenJDK). Leveraging key insights about the internal design common to modern JVMs, Crochet works entirely through bytecode rewriting and standard debug APIs, utilizing special proxy objects to perform a lazy heap traversal that starts at the root references and traverses the heap as objects are accessed, copying or restoring state as needed and removing each proxy immediately after it is used. We evaluated Crochet on the DaCapo benchmark suite, finding it to have very low runtime overhead in steady state (ranging from no overhead to 1.29x slowdown), and that it often outperforms a state-of-the-art system-level checkpoint tool when creating large checkpoints.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jonathan", + "last_name": "Bell", + "institution": "George Mason University" + }, + { + "first_name": "Luís", + "last_name": "Pina", + "institution": "George Mason University" + } + ], + "dblp_key": "conf/ecoop/BellP18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.18", + "title": "ThingsMigrate: Platform-Independent Migration of Stateful JavaScript IoT Applications", + "abstract": "The Internet of Things (IoT) has gained wide popularity both in academic and industrial contexts. As IoT devices become increasingly powerful, they can run more and more complex applications written in higher-level languages, such as JavaScript. However, by their nature, IoT devices are subject to resource constraints, which require applications to be dynamically migrated between devices (and the cloud). Further, IoT applications are also becoming more stateful, and hence we need to save their state during migration transparently to the programmer. In this paper, we present ThingsMigrate, a middleware providing VM-independent migration of stateful JavaScript applications across IoT devices. ThingsMigrate captures and reconstructs the internal JavaScript program state by instrumenting application code before run time, without modifying the underlying Virtual Machine (VM), thus providing platform and VM-independence. We evaluated ThingsMigrate against standard benchmarks, and over two IoT platforms and a cloud-like environment. We show that it can successfully migrate even highly CPU-intensive applications, with acceptable overheads (about 30%), and supports multiple migrations.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Julien", + "last_name": "Gascon‐Samson", + "institution": "University of British Columbia" + }, + { + "first_name": "Kumseok", + "last_name": "Jung", + "institution": "University of British Columbia" + }, + { + "first_name": "Shivanshu", + "last_name": "Goyal", + "institution": "University of British Columbia" + }, + { + "first_name": "Armin", + "last_name": "Rezaiean‐Asel", + "institution": "University of British Columbia" + }, + { + "first_name": "Karthik", + "last_name": "Pattabiraman", + "institution": "University of British Columbia" + } + ], + "dblp_key": "conf/ecoop/Gascon-SamsonJG18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.21", + "title": "Modeling Infinite Behaviour by Corules", + "abstract": "Generalized inference systems have been recently introduced, and used, among other applications, to define semantic judgments which uniformly model terminating computations and divergence. We show that the approach can be successfully extended to more sophisticated notions of infinite behaviour, that is, to express that a diverging computation produces some possibly infinite result. This also provides a motivation to smoothly extend the theory of generalized inference systems to include, besides coaxioms, also corules, a more general notion for which significant examples were missing until now. We first illustrate the approach on a lambda-calculus with output effects, for which we also provide an alternative semantics based on standard notions, and a complete proof of the equivalence of the two semantics. Then, we consider a more involved example, that is, an imperative Java-like language with I/O primitives.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Davide", + "last_name": "Ancona", + "institution": "University of Genoa" + }, + { + "first_name": "Francesco", + "last_name": "Dagnino", + "institution": "University of Genoa" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/ecoop/AnconaDZ18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.20", + "title": "FHJ: A Formal Model for Hierarchical Dispatching and Overriding", + "abstract": "Multiple inheritance is a valuable feature for Object-Oriented Programming. However, it is also tricky to get right, as illustrated by the extensive literature on the topic. A key issue is the ambiguity arising from inheriting multiple parents, which can have conflicting methods. Numerous existing work provides solutions for conflicts which arise from diamond inheritance: i.e. conflicts that arise from implementations sharing a common ancestor. However, most mechanisms are inadequate to deal with unintentional method conflicts: conflicts which arise from two unrelated methods that happen to share the same name and signature. This paper presents a new model called Featherweight Hierarchical Java (FHJ) that deals with unintentional method conflicts. In our new model, which is partly inspired by C++, conflicting methods arising from unrelated methods can coexist in the same class, and hierarchical dispatching supports unambiguous lookups in the presence of such conflicting methods. To avoid ambiguity, hierarchical information is employed in method dispatching, which uses a combination of static and dynamic type information to choose the implementation of a method at run-time. Furthermore, unlike all existing inheritance models, our model supports hierarchical method overriding: that is, methods can be independently overridden along the multiple inheritance hierarchy. We give illustrative examples of our language and features and formalize FHJ as a minimal Featherweight-Java style calculus.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yanlin", + "last_name": "Wang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Haoyuan", + "last_name": "Zhang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Marco", + "last_name": "Servetto", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/ecoop/WangZOS18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.19", + "title": "Automating Object Transformations for Dynamic Software Updating via Online Execution Synthesis", + "abstract": "Dynamic software updating (DSU) is a technique to upgrade a running software system on the fly without stopping the system. During updating, the runtime state of the modified components of the system needs to be properly transformed into a new state, so that the modified components can still correctly interact with the rest of the system. However, the transformation is non-trivial to realize due to the gap between the low-level implementations of two versions of a program. This paper presents AOTES, a novel approach to automating object transformations for dynamic updating of Java programs. AOTES bridges the gap by abstracting the old state of an object to a history of method invocations, and re-invoking the new version of all methods in the history to get the desired new state. AOTES requires no instrumentation to record any data and thus has no overhead during normal execution. We propose and implement a novel technique that can synthesize an equivalent history of method invocations based on the current object state only. We evaluated AOTES on software updates taken from Apache Commons Collections, Tomcat, FTP Server and SSHD Server. Experimental results show that AOTES successfully handled 51 of 61 object transformations of 21 updated classes, while two state-of-the-art approaches only handled 11 and 6 of 61, respectively.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Tianxiao", + "last_name": "Gu", + "institution": "Nanjing University" + }, + { + "first_name": "Xiaoxing", + "last_name": "Ma", + "institution": "Nanjing University" + }, + { + "first_name": "Chang", + "last_name": "Xu", + "institution": "Nanjing University" + }, + { + "first_name": "Yanyan", + "last_name": "Jiang", + "institution": "Nanjing University" + }, + { + "first_name": "Chun", + "last_name": "Cao", + "institution": "Nanjing University" + }, + { + "first_name": "Jian", + "last_name": "Lü", + "institution": "Nanjing University" + } + ], + "dblp_key": "conf/ecoop/GuM00CL18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.25", + "title": "Definite Reference Mutability", + "abstract": "Reference immutability type systems such as Javari and ReIm ensure that a given reference cannot be used to mutate the referenced object. These systems are conservative in the sense that a mutable reference may be mutable due to approximation. In this paper, we present ReM (for definite Re[ference] M[utability]). It separates mutable references into (1) definitely mutable, and (2) maybe mutable, i.e., references whose mutability is due to inherent approximation. In addition, we propose a CFL-reachability system for reference immutability, and prove that it is equivalent to ReIm/ReM, thus building a novel framework for reasoning about correctness of reference immutability type systems. We have implemented ReM and applied it on a large benchmark suite. Our results show that approximately 86.5% of all mutable references are definitely mutable.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.25", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ana", + "last_name": "Milanova", + "institution": "Rensselaer Polytechnic Institute" + } + ], + "dblp_key": "conf/ecoop/Milanova18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.22", + "title": "The Essence of Nested Composition", + "abstract": "Calculi with disjoint intersection types support an introduction form for intersections called the merge operator, while retaining a coherent semantics. Disjoint intersections types have great potential to serve as a foundation for powerful, flexible and yet type-safe and easy to reason OO languages. This paper shows how to significantly increase the expressive power of disjoint intersection types by adding support for nested subtyping and composition, which enables simple forms of family polymorphism to be expressed in the calculus. The extension with nested subtyping and composition is challenging, for two different reasons. Firstly, the subtyping relation that supports these features is non-trivial, especially when it comes to obtaining an algorithmic version. Secondly, the syntactic method used to prove coherence for previous calculi with disjoint intersection types is too inflexible, making it hard to extend those calculi with new features (such as nested subtyping). We show how to address the first problem by adapting and extending the Barendregt, Coppo and Dezani (BCD) subtyping rules for intersections with records and coercions. A sound and complete algorithmic system is obtained by using an approach inspired by Pierce's work. To address the second problem we replace the syntactic method to prove coherence, by a semantic proof method based on logical relations. Our work has been fully formalized in Coq, and we have an implementation of our calculus.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Xuan", + "last_name": "Bi", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/ecoop/BiOS18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.26", + "title": "Efficient Reflection String Analysis via Graph Coloring", + "abstract": "Static analyses for reflection and other dynamic language features have recently increased in number and advanced in sophistication. Most such analyses rely on a whole-program model of the flow of strings, through the stack and heap. We show that this global modeling of strings remains a major bottleneck of static analyses and propose a compact encoding, in order to battle unnecessary complexity. In our encoding, strings are maximally merged if they can never serve to differentiate class members in reflection operations. We formulate the problem as an instance of graph coloring and propose a fast polynomial-time algorithm that exploits the unique features of the setting (esp. large cliques, leading to hundreds of colors for realistic programs). The encoding is applied to two different frameworks for string-guided Java reflection analysis from past literature and leads to significant optimization (e.g., a ~2x reduction in the number of string-flow inferences), for a whole-program points-to analysis that uses strings.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.26", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Neville", + "last_name": "Grech", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "George", + "last_name": "Kastrinis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/ecoop/GrechKS18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.23", + "title": "Defensive Points-To Analysis: Effective Soundness via Laziness", + "abstract": "We present a defensive may-point-to analysis approach, which offers soundness even in the presence of arbitrary opaque code: all non-empty points-to sets computed are guaranteed to be over-approximations of the sets of values arising at run time. A key design tenet of the analysis is laziness: the analysis computes points-to relationships only for variables or objects that are guaranteed to never escape into opaque code. This means that the analysis misses some valid inferences, yet it also never wastes work to compute sets of values that are not \"complete\", i.e., that may be missing elements due to opaque code. Laziness enables great efficiency, allowing a highly precise points-to analysis (such as a 5-call-site-sensitive, flow-sensitive analysis). Despite its conservative nature, our analysis yields sound, actionable results for a large subset of the program code, achieving (under worst-case assumptions) 34-74% of the program coverage of an unsound state-of-the-art analysis for real-world programs.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "George", + "last_name": "Kastrinis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/ecoop/SmaragdakisK18", + "venue": "ecoop", + "year": 2018 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2018.24", + "title": "Legato: An At-Most-Once Analysis with Applications to Dynamic Configuration Updates", + "abstract": "Modern software increasingly relies on external resources whose location or content can change during program execution. Examples of such resources include remote network hosts, database entries, dynamically updated configuration options, etc. Long running, adaptable programs must handle these changes gracefully and correctly. Dealing with all possible resource update scenarios is difficult to get right, especially if, as is common, external resources can be modified without prior warning by code and/or users outside of the application's direct control. If a resource unexpectedly changes during a computation, an application may observe multiple, inconsistent states of the resource, leading to incorrect program behavior. This paper presents a sound and precise static analysis, Legato, that verifies programs correctly handle changes in external resources. Our analysis ensures that every value computed by an application reflects a single, consistent version of every external resource's state. Although consistent computation in the presence of concurrent resource updates is fundamentally a concurrency issue, our analysis relies on the novel at-most-once condition to avoid explicitly reasoning about concurrency. The at-most-once condition requires that all values depend on at most one access of each resource. Our analysis is flow-, field-, and context-sensitive. It scales to real-world Java programs while producing a moderate number of false positives. We applied Legato to 10 applications with dynamically updated configurations, and found several non-trivial consistency bugs.", + "date": "2018-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2018.24", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "John", + "last_name": "Toman", + "institution": "Seattle University" + }, + { + "first_name": "Dan", + "last_name": "Grossman", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/ecoop/TomanG18", + "venue": "ecoop", + "year": 2018 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2019.json b/data/pl_conferences/ecoop/2019.json new file mode 100644 index 0000000..37ce57d --- /dev/null +++ b/data/pl_conferences/ecoop/2019.json @@ -0,0 +1,803 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.0", + "title": "Front Matter, Table of Contents, Preface, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Conference Organization", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Donaldson, Alastair", + "last_name": "F.", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/X19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.7", + "title": "On Satisfiability of Nominal Subtyping with Variance", + "abstract": "Nominal type systems with variance, the core of the subtyping relation in object-oriented programming languages like Java, C# and Scala, have been extensively studied by Kennedy and Pierce: they have shown the undecidability of the subtyping between ground types and proposed the decidable fragments of such type systems. However, modular verification of object-oriented code may require reasoning about the relations of open types. In this paper, we formalize and investigate the satisfiability problem for nominal subtyping with variance. We define the problem in the context of first-order logic. We show that although the non-expansive ground nominal subtyping with variance is decidable, its satisfiability problem is undecidable. Our proof uses a remarkably small fragment of the type system. In fact, we demonstrate that even for the non-expansive class tables with only nullary and unary covariant and invariant type constructors, the satisfiability of quantifier-free conjunctions of positive subtyping atoms is undecidable. We discuss this result in detail, as well as show one decidable fragment and a scheme for obtaining other decidable fragments.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aleksandr", + "last_name": "Misonizhnik", + "institution": "St Petersburg University" + }, + { + "first_name": "Dmitry", + "last_name": "Mordvinov", + "institution": "St Petersburg University" + } + ], + "dblp_key": "conf/ecoop/MisonizhnikM19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.2", + "title": "Godot: All the Benefits of Implicit and Explicit Futures", + "abstract": "Concurrent programs often make use of futures, handles to the results of asynchronous operations. Futures provide means to communicate not yet computed results, and simplify the implementation of operations that synchronise on the result of such asynchronous operations. Futures can be characterised as implicit or explicit, depending on the typing discipline used to type them. Current future implementations suffer from \"future proliferation\", either at the type-level or at run-time. The former adds future type wrappers, which hinders subtype polymorphism and exposes the client to the internal asynchronous communication architecture. The latter increases latency, by traversing nested future structures at run-time. Many languages suffer both kinds. Previous work offer partial solutions to the future proliferation problems; in this paper we show how these solutions can be integrated in an elegant and coherent way, which is more expressive than either system in isolation. We describe our proposal formally, and state and prove its key properties, in two related calculi, based on the two possible families of future constructs (data-flow futures and control-flow futures). The former relies on static type information to avoid unwanted future creation, and the latter uses an algebraic data type with dynamic checks. We also discuss how to implement our new system efficiently.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Kiko", + "last_name": "Fernandez-Reyes", + "institution": "Uppsala University" + }, + { + "first_name": "Dave", + "last_name": "Clarke", + "institution": "Stockholm School of Economics" + }, + { + "first_name": "Ludovic", + "last_name": "Henrio", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Einar Broch", + "last_name": "Johnsen", + "institution": "University of Oslo" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/ecoop/Fernandez-Reyes19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.13", + "title": "Fling - A Fluent API Generator", + "abstract": "We present the first general and practical solution of the fluent API problem - an algorithm, that given a deterministic language (equivalently, LR(k), k >= 0 language) encodes it in an unbounded parametric polymorphism type system employing only a polynomial number of types. The theoretical result is accompanied by an actual tool Fling - a fluent API compiler-compiler in the venue of YACC, tailored for embedding DSLs in Java.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yossi", + "last_name": "Gil", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Ori", + "last_name": "Roth", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/ecoop/GilR19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.4", + "title": "Scopes and Frames Improve Meta-Interpreter Specialization", + "abstract": "DynSem is a domain-specific language for concise specification of the dynamic semantics of programming languages, aimed at rapid experimentation and evolution of language designs. To maintain a short definition-to-execution cycle, DynSem specifications are meta-interpreted. Meta-interpretation introduces runtime overhead that is difficult to remove by using interpreter optimization frameworks such as the Truffle/Graal Java tools; previous work has shown order-of-magnitude improvements from applying Truffle/Graal to a meta-interpreter, but this is still far slower than what can be achieved with a language-specific interpreter. In this paper, we show how specifying the meta-interpreter using scope graphs, which encapsulate static name binding and resolution information, produces much better optimization results from Truffle/Graal. Furthermore, we identify that JIT compilation is hindered by large numbers of calls between small polymorphic rules and we introduce rule cloning to derive larger monomorphic rules at run time as a countermeasure. Our contributions improve the performance of DynSem-derived interpreters to within an order of magnitude of a handwritten language-specific interpreter.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Vlad", + "last_name": "Vergu", + "institution": "Delft University of Technology" + }, + { + "first_name": "Andrew", + "last_name": "Tolmach", + "institution": "Portland State University" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/ecoop/VerguTV19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.12", + "title": "How to Avoid Making a Billion-Dollar Mistake: Type-Safe Data Plane Programming with SafeP4", + "abstract": "The P4 programming language offers high-level, declarative abstractions that bring the flexibility of software to the domain of networking. Unfortunately, the main abstraction used to represent packet data in P4, namely header types, lacks basic safety guarantees. Over the last few years, experience with an increasing number of programs has shown the risks of the unsafe approach, which often leads to subtle software bugs. This paper proposes SafeP4, a domain-specific language for programmable data planes in which all packet data is guaranteed to have a well-defined meaning and satisfy essential safety guarantees. We equip SafeP4 with a formal semantics and a static type system that statically guarantees header validity---a common source of safety bugs according to our analysis of real-world P4 programs. Statically ensuring header validity is challenging because the set of valid headers can be modified at runtime, making it a dynamic program property. Our type system achieves static safety by using a form of path-sensitive reasoning that tracks dynamic information from conditional statements, routing tables, and the control plane. Our evaluation shows that SafeP4's type system can effectively eliminate common failures in many real-world programs.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Eichholz", + "institution": "" + }, + { + "first_name": "Eric Hayden", + "last_name": "Campbell", + "institution": "" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/EichholzCFSM19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.14", + "title": "NumLin: Linear Types for Linear Algebra", + "abstract": "We present NumLin, a functional programming language whose type system is designed to enforce the safe usage of the APIs of low-level linear algebra libraries (such as BLAS/LAPACK). We do so through a brief description of its key features and several illustrative examples. We show that NumLin’s type system is sound and that its implementation improves upon naïve implementations of linear algebra programs, almost towards C-levels of performance. By doing so, we demonstrate (a) that linear types are well-suited to expressing the APIs of low-level linear algebra libraries accurately and concisely and (b) that, despite the complexity of prior work on it, fractional permissions can actually be implemented using simple, well-known techniques and be used practically in real programs.", + "date": "2019-07-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dhruv C.", + "last_name": "Makwana", + "institution": "" + }, + { + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/ecoop/MakwanaK19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.15", + "title": "Deep Static Modeling of invokedynamic", + "abstract": "Java 7 introduced programmable dynamic linking in the form of the invokedynamic framework. Static analysis of code containing programmable dynamic linking has often been cited as a significant source of unsoundness in the analysis of Java programs. For example, Java lambdas, introduced in Java 8, are a very popular feature, which is, however, resistant to static analysis, since it mixes invokedynamic with dynamic code generation. These techniques invalidate static analysis assumptions: programmable linking breaks reasoning about method resolution while dynamically generated code is, by definition, not available statically. In this paper, we show that a static analysis can predictively model uses of invokedynamic while also cooperating with extra rules to handle the runtime code generation of lambdas. Our approach plugs into an existing static analysis and helps eliminate all unsoundness in the handling of lambdas (including associated features such as method references) and generic invokedynamic uses. We evaluate our technique on a benchmark suite of our own and on third-party benchmarks, uncovering all code previously unreachable due to unsoundness, highly efficiently.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Fourtounis,", + "last_name": "George", + "institution": "Hellenic Telecommunications and Post Commission (Greece)" + }, + { + "first_name": "Smaragdakis,", + "last_name": "Yannis", + "institution": "Hellenic Telecommunications and Post Commission (Greece)" + } + ], + "dblp_key": "conf/ecoop/FourtounisS19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.1", + "title": "Lifestate: Event-Driven Protocols and Callback Control Flow", + "abstract": "Developing interactive applications (apps) against event-driven software frameworks such as Android is notoriously difficult. To create apps that behave as expected, developers must follow complex and often implicit asynchronous programming protocols. Such protocols intertwine the proper registering of callbacks to receive control from the framework with appropriate application-programming interface (API) calls that in turn affect the set of possible future callbacks. An app violates the protocol when, for example, it calls a particular API method in a state of the framework where such a call is invalid. What makes automated reasoning hard in this domain is largely what makes programming apps against such frameworks hard: the specification of the protocol is unclear, and the control flow is complex, asynchronous, and higher-order. In this paper, we tackle the problem of specifying and modeling event-driven application-programming protocols. In particular, we formalize a core meta-model that captures the dialogue between event-driven frameworks and application callbacks. Based on this meta-model, we define a language called lifestate that permits precise and formal descriptions of application-programming protocols and the callback control flow imposed by the event-driven framework. Lifestate unifies modeling what app callbacks can expect of the framework with specifying rules the app must respect when calling into the framework. In this way, we effectively combine lifecycle constraints and typestate rules. To evaluate the effectiveness of lifestate modeling, we provide a dynamic verification algorithm that takes as input a trace of execution of an app and a lifestate protocol specification to either produce a trace witnessing a protocol violation or a proof that no such trace is realizable.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Shawn", + "last_name": "Meier", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Sergio", + "last_name": "Mover", + "institution": "École Polytechnique" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/ecoop/MeierMC19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.3", + "title": "Multitier Modules", + "abstract": "Multitier programming languages address the complexity of developing distributed systems abstracting over low level implementation details such as data representation, serialization and network protocols. Since the functionalities of different peers can be defined in the same compilation unit, multitier languages do not force developers to modularize software along network boundaries. Unfortunately, combining the code for all tiers into the same compilation unit poses a scalability challenge or forces developers to resort to traditional modularization abstractions that are agnostic to the multitier nature of the language. In this paper, we address this issue with a module system for multitier languages. Our module system supports encapsulating each (cross-peer) functionality and defining it over abstract peer types. As a result, we disentangle modularization and distribution and we enable the definition of a distributed system as a composition of multitier modules, each representing a subsystem. Our case studies on distributed algorithms, distributed data structures, as well as on the Apache Flink task distribution system, show that multitier modules allow the definition of reusable (abstract) patterns of interaction in distributed software and enable separating the modularization and distribution concerns, properly separating functionalities in distributed systems.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Weisenburger,", + "last_name": "Pascal", + "institution": "Technical University of Darmstadt" + }, + { + "first_name": "Salvaneschi,", + "last_name": "Guido", + "institution": "Technical University of Darmstadt" + } + ], + "dblp_key": "conf/ecoop/WeisenburgerS19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.10", + "title": "Garbage-Free Abstract Interpretation Through Abstract Reference Counting", + "abstract": "Abstract garbage collection is the application of garbage collection to an abstract interpreter. Existing work has shown that abstract garbage collection can improve both the interpreter’s precision and performance. Current approaches rely on heuristics to decide when to apply abstract garbage collection. Garbage will build up and impact precision and performance when the collection is applied infrequently, while too frequent applications will bring about their own performance overhead. A balance between these tradeoffs is often difficult to strike. We propose a new approach to cope with the buildup of garbage in the results of an abstract interpreter. Our approach is able to eliminate all garbage, therefore obtaining the maximum precision and performance benefits of abstract garbage collection. At the same time, our approach does not require frequent heap traversals, and therefore adds little to the interpreters’s running time. The core of our approach uses reference counting to detect and eliminate garbage as soon as it arises. However, reference counting cannot deal with cycles, and we show that cycles are much more common in an abstract interpreter than in its concrete counterpart. To alleviate this problem, our approach detects cycles and employs reference counting at the level of strongly connected components. While this technique in general works for any system that uses reference counting, we argue that it works particularly well for an abstract interpreter. In fact, we show formally that for the continuation store, where most of the cycles occur, the cycle detection technique only requires O(1) amortized operations per continuation push. We present our approach formally, and provide a proof-of-concept implementation in the Scala-AM framework. We empirically show our approach achieves both the optimal precision and significantly better performance compared to existing approaches to abstract garbage collection.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Noah Van", + "last_name": "Es", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Quentin", + "last_name": "Stiévenart", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Coen De", + "last_name": "Roover", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/ecoop/EsSR19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.11", + "title": "Eventually Sound Points-To Analysis with Specifications", + "abstract": "Static analyses make the increasingly tenuous assumption that all source code is available for analysis; for example, large libraries often call into native code that cannot be analyzed. We propose a points-to analysis that initially makes optimistic assumptions about missing code, and then inserts runtime checks that report counterexamples to these assumptions that occur during execution. Our approach guarantees eventual soundness, which combines two guarantees: (i) the runtime checks are guaranteed to catch the first counterexample that occurs during any execution, in which case execution can be terminated to prevent harm, and (ii) only finitely many counterexamples ever occur, implying that the static analysis eventually becomes statically sound with respect to all remaining executions. We implement Optix, an eventually sound points-to analysis for Android apps, where the Android framework is missing. We show that the runtime checks added by Optix incur low overhead on real programs, and demonstrate how Optix improves a client information flow analysis for detecting Android malware.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "University of Ottawa" + }, + { + "first_name": "Lazaro", + "last_name": "Clapp", + "institution": "Uber AI (United States)" + }, + { + "first_name": "Saswat", + "last_name": "Anand", + "institution": "Stanford University" + }, + { + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" + } + ], + "dblp_key": "conf/ecoop/Bastani0CAA19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.8", + "title": "Static Analysis for Asynchronous JavaScript Programs", + "abstract": "Asynchrony has become an inherent element of JavaScript, as an effort to improve the scalability and performance of modern web applications. To this end, JavaScript provides programmers with a wide range of constructs and features for developing code that performs asynchronous computations, including but not limited to timers, promises, and non-blocking I/O. However, the data flow imposed by asynchrony is implicit, and not always well-understood by the developers who introduce many asynchrony-related bugs to their programs. Worse, there are few tools and techniques available for analyzing and reasoning about such asynchronous applications. In this work, we address this issue by designing and implementing one of the first static analysis schemes capable of dealing with almost all the asynchronous primitives of JavaScript up to the 7th edition of the ECMAScript specification. Specifically, we introduce the callback graph, a representation for capturing data flow between asynchronous code. We exploit the callback graph for designing a more precise analysis that respects the execution order between different asynchronous functions. We parameterize our analysis with one novel context-sensitivity flavor, and we end up with multiple analysis variations for building callback graph. We performed a number of experiments on a set of hand-written and real-world JavaScript programs. Our results show that our analysis can be applied to medium-sized programs achieving 79% precision on average. The findings further suggest that analysis sensitivity is beneficial for the vast majority of the benchmarks. Specifically, it is able to improve precision by up to 28.5%, while it achieves an 88% precision on average without highly sacrificing performance.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Thodoris", + "last_name": "Sotiropoulos", + "institution": "Athens University of Economics and Business" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/SotiropoulosL19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.6", + "title": "A Typing Discipline for Hardware Interfaces", + "abstract": "Modern Systems-on-a-Chip (SoC) are constructed by composition of IP (Intellectual Property) Cores with the communication between these IP Cores being governed by well described interaction protocols. However, there is a disconnect between the machine readable specification of these protocols and the verification of their implementation in known hardware description languages. Although tools can be written to address such separation of concerns, the tooling is often hand written and used to check hardware designs a posteriori. We have developed a dependent type-system and proof-of-concept modelling language to reason about the physical structure of hardware interfaces using user provided descriptions. Our type-system provides correct-by-construction guarantees that the interfaces on an IP Core will be well-typed if they adhere to a specified standard.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jan de", + "last_name": "Muijnck-Hughes", + "institution": "University of Glasgow" + }, + { + "first_name": "Wim", + "last_name": "Vanderbauwhede", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/ecoop/Muijnck-HughesV19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.16", + "title": "Reasoning About Foreign Function Interfaces Without Modelling the Foreign Language", + "abstract": "Object-oriented programming has long been regarded as too inefficient for SIMD high-performance computing, despite the fact that many important HPC applications have an inherent object structure. On SIMD accelerators, including GPUs, this is mainly due to performance problems with memory allocation and memory access: There are a few libraries that support parallel memory allocation directly on accelerator devices, but all of them suffer from uncoalesed memory accesses. We discovered a broad class of object-oriented programs with many important real-world applications that can be implemented efficiently on massively parallel SIMD accelerators. We call this class Single-Method Multiple-Objects (SMMO), because parallelism is expressed by running a method on all objects of a type. To make fast GPU programming available to average programmers, we developed DynaSOAr, a CUDA framework for SMMO applications. DynaSOAr consists of (1) a fully-parallel, lock-free, dynamic memory allocator, (2) a data layout DSL and (3) an efficient, parallel do-all operation. DynaSOAr achieves performance superior to state-of-the-art GPU memory allocators by controlling both memory allocation and memory access. DynaSOAr improves the usage of allocated memory with a Structure of Arrays data layout and achieves low memory fragmentation through efficient management of free and allocated memory blocks with lock-free, hierarchical bitmaps. Contrary to other allocators, our design is heavily based on atomic operations, trading raw (de)allocation performance for better overall application performance. In our benchmarks, DynaSOAr achieves a speedup of application code of up to 3x over state-of-the-art allocators. Moreover, DynaSOAr manages heap memory more efficiently than other allocators, allowing programmers to run up to 2x larger problem sizes with the same amount of memory.", + "date": "2018-10-28", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Springer", + "institution": "" + }, + { + "first_name": "Hidehiko", + "last_name": "Masuhara", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/TurcotteAR19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.17", + "title": "DynaSOAr: A Parallel Memory Allocator for Object-Oriented Programming on GPUs with Efficient Memory Access", + "abstract": "Object-oriented programming has long been regarded as too inefficient for SIMD high-performance computing, despite the fact that many important HPC applications have an inherent object structure. On SIMD accelerators, including GPUs, this is mainly due to performance problems with memory allocation and memory access: There are a few libraries that support parallel memory allocation directly on accelerator devices, but all of them suffer from uncoalesed memory accesses. We discovered a broad class of object-oriented programs with many important real-world applications that can be implemented efficiently on massively parallel SIMD accelerators. We call this class Single-Method Multiple-Objects (SMMO), because parallelism is expressed by running a method on all objects of a type. To make fast GPU programming available to average programmers, we developed DynaSOAr, a CUDA framework for SMMO applications. DynaSOAr consists of (1) a fully-parallel, lock-free, dynamic memory allocator, (2) a data layout DSL and (3) an efficient, parallel do-all operation. DynaSOAr achieves performance superior to state-of-the-art GPU memory allocators by controlling both memory allocation and memory access. DynaSOAr improves the usage of allocated memory with a Structure of Arrays data layout and achieves low memory fragmentation through efficient management of free and allocated memory blocks with lock-free, hierarchical bitmaps. Contrary to other allocators, our design is heavily based on atomic operations, trading raw (de)allocation performance for better overall application performance. In our benchmarks, DynaSOAr achieves a speedup of application code of up to 3x over state-of-the-art allocators. Moreover, DynaSOAr manages heap memory more efficiently than other allocators, allowing programmers to run up to 2x larger problem sizes with the same amount of memory.", + "date": "2018-10-28", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Springer", + "institution": "Association for Computing Machinery" + }, + { + "first_name": "Hidehiko", + "last_name": "Masuhara", + "institution": "Association for Computing Machinery" + } + ], + "dblp_key": "conf/ecoop/SpringerM19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.25", + "title": "Finally, a Polymorphic Linear Algebra Language (Pearl)", + "abstract": "Many different data analytics tasks boil down to linear algebra primitives. In practice, for each different type of workload, data scientists use a particular specialised library. In this paper, we present Pilatus, a polymorphic iterative linear algebra language, applicable to various types of data analytics workloads. The design of this domain-specific language (DSL) is inspired by both mathematics and programming languages: its basic constructs are borrowed from abstract algebra, whereas the key technology behind its polymorphic design uses the tagless final approach (a.k.a. polymorphic embedding/object algebras). This design enables us to change the behaviour of arithmetic operations to express matrix algebra, graph algorithms, logical probabilistic programs, and differentiable programs. Crucially, the polymorphic design of Pilatus allows us to use multi-stage programming and rewrite-based optimisation to recover the performance of specialised code, supporting fixed sized matrices, algebraic optimisations, and fusion.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.25", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Oxford" + }, + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "conf/ecoop/ShaikhhaP19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.19", + "title": "Transferring Obligations Through Synchronizations", + "abstract": "One common approach for verifying safety properties of multithreaded programs is assigning appropriate permissions, such as ownership of a heap location, and obligations, such as an obligation to send a message on a channel, to each thread and making sure that each thread only performs the actions for which it has permissions and it also fulfills all of its obligations before it terminates. Although permissions can be transferred through synchronizations from a sender thread, where for example a message is sent or a condition variable is notified, to a receiver thread, where that message or that notification is received, in existing approaches obligations can only be transferred when a thread is forked. In this paper we introduce two mechanisms, one for channels and the other for condition variables, that allow obligations, along with permissions, to be transferred from the sender to the receiver, while ensuring that there is no state where the transferred obligations are lost, i.e. where they are discharged from the sender thread but not loaded onto the receiver thread yet. We show how these mechanisms can be used to modularly verify deadlock-freedom of a number of interesting programs, such as some variations of client-server programs, fair readers-writers locks, and dining philosophers, which cannot be modularly verified without such transfer. We also encoded the proposed separation logic-based proof rules in the VeriFast program verifier and succeeded in verifying the mentioned programs.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jafar", + "last_name": "Hamin", + "institution": "University of Copenhagen" + }, + { + "first_name": "Bart", + "last_name": "Jacobs", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "conf/ecoop/Hamin019", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.18", + "title": "Reliable State Machines: A Framework for Programming Reliable Cloud Services", + "abstract": "Building reliable applications for the cloud is challenging because of unpredictable failures during a program’s execution. This paper presents a programming framework, called Reliable State Machines (RSMs), that offers fault-tolerance by construction. In our framework, an application comprises several (possibly distributed) RSMs that communicate with each other via messages, much in the style of actor-based programming. Each RSM is fault-tolerant by design, thereby offering the illusion of being \"always-alive\". An RSM is guaranteed to process each input request exactly once, as one would expect in a failure-free environment. The RSM runtime automatically takes care of persisting state and rehydrating it on a failover. We present the core syntax and semantics of RSMs, along with a formal proof of failure-transparency. We provide a .NET implementation of the RSM framework for deploying services to Microsoft Azure. We carry out an extensive performance evaluation on micro-benchmarks to show that one can build high-throughput applications with RSMs. We also present a case study where we rewrite a significant part of a production cloud service using RSMs. The resulting service has simpler code and exhibits production-grade performance.", + "date": "2019-02-25", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Suvam", + "last_name": "Mukherjee", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Nitin John", + "last_name": "Raj", + "institution": "" + }, + { + "first_name": "Krishnan", + "last_name": "Govindraj", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Pantazis", + "last_name": "Deligiannis", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Chandramouleswaran", + "last_name": "Ravichandran", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Akash", + "last_name": "Lal", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Raja", + "last_name": "Krishnaswamy", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/ecoop/MukherjeeRGDRLR19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.20", + "title": "Automated Large-Scale Multi-Language Dynamic Program Analysis in the Wild (Tool Insights Paper)", + "abstract": "Today’s availability of open-source software is overwhelming, and the number of free, ready-to-use software components in package repositories such as NPM, Maven, or SBT is growing exponentially. In this paper we address two straightforward yet important research questions: would it be possible to develop a tool to automate dynamic program analysis on public open-source software at a large scale? Moreover, and perhaps more importantly, would such a tool be useful? We answer the first question by introducing NAB, a tool to execute large-scale dynamic program analysis of open-source software in the wild. NAB is fully-automatic, language-agnostic, and can scale dynamic program analyses on open-source software up to thousands of projects hosted in code repositories. Using NAB, we analyzed more than 56K Node.js, Java, and Scala projects. Using the data collected by NAB we were able to (1) study the adoption of new language constructs such as JavaScript Promises, (2) collect statistics about bad coding practices in JavaScript, and (3) identify Java and Scala task-parallel workloads suitable for inclusion in a domain-specific benchmark suite. We consider such findings and the collected data an affirmative answer to the second question.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Alex", + "last_name": "Villazón", + "institution": "Universidad Privada Boliviana" + }, + { + "first_name": "Haiyang", + "last_name": "Sun", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Andrea", + "last_name": "Rosà", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Eduardo", + "last_name": "Rosales", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Daniele", + "last_name": "Bonetta", + "institution": "Oracle (United States)" + }, + { + "first_name": "Isabella", + "last_name": "Defilippis", + "institution": "Universidad Privada Boliviana" + }, + { + "first_name": "Sergio", + "last_name": "Oporto", + "institution": "Universidad Privada Boliviana" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/ecoop/VillazonSRRBDOB19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.21", + "title": "MagpieBridge: A General Approach to Integrating Static Analyses into IDEs and Editors (Tool Insights Paper)", + "abstract": "In the past, many static analyses have been created in academia, but only a few of them have found widespread use in industry. Those analyses which are adopted by developers usually have IDE support in the form of plugins, without which developers have no convenient mechanism to use the analysis. Hence, the key to making static analyses more accessible to developers is to integrate the analyses into IDEs and editors. However, integrating static analyses into IDEs is non-trivial: different IDEs have different UI workflows and APIs, expertise in those matters is required to write such plugins, and analysis experts are not typically familiar with doing this. As a result, especially in academia, most analysis tools are headless and only have command-line interfaces. To make static analyses more usable, we propose MagpieBridge - a general approach to integrating static analyses into IDEs and editors. MagpieBridge reduces the mxn complexity problem of integrating m analyses into n IDEs to m+n complexity because each analysis and type of plugin need be done just once for MagpieBridge itself. We demonstrate our approach by integrating two existing analyses, Ariadne and CogniCrypt, into IDEs; these two analyses illustrate the generality of MagpieBridge, as they are based on different program analysis frameworks - WALA and Soot respectively - for different application areas - machine learning and security - and different programming languages - Python and Java. We show further generality of MagpieBridge by using multiple popular IDEs and editors, such as Eclipse, IntelliJ, PyCharm, Jupyter, Sublime Text and even Emacs and Vim.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Linghui", + "last_name": "Luo", + "institution": "Paderborn University" + }, + { + "first_name": "Julian", + "last_name": "Dolby", + "institution": "IBM (United States)" + }, + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Fraunhofer Institute for Mechatronic Systems Design" + } + ], + "dblp_key": "conf/ecoop/LuoDB19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.26", + "title": "Towards Language-Parametric Semantic Editor Services Based on Declarative Type System Specifications (Brave New Idea Paper)", + "abstract": "Editor services assist programmers to more effectively write and comprehend code. Implementing editor services correctly is not trivial. This paper focuses on the specification of semantic editor services, those that use the semantic model of a program. The specification of refactorings is a common subject of study, but many other semantic editor services have received little attention. We propose a language-parametric approach to the definition of semantic editor services, using a declarative specification of the static semantics of the programming language, and constraint solving. Editor services are specified as constraint problems, and language specifications are used to ensure correctness. We describe our approach for the following semantic editor services: reference resolution, find usages, goto subclasses, code completion, and the extract definition refactoring. We do this in the context of Statix, a constraint language for the specification of type systems. We investigate the specification of editor services in terms of Statix constraints, and the requirements these impose on a suitable solver.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.26", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Daniel A. A.", + "last_name": "Pelsmaeker", + "institution": "Delft University of Technology" + }, + { + "first_name": "Hendrik van", + "last_name": "Antwerpen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/ecoop/PelsmaekerAV19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.28", + "title": "Motion Session Types for Robotic Interactions (Brave New Idea Paper)", + "abstract": "Robotics applications involve programming concurrent components synchronising through messages while simultaneously executing motion primitives that control the state of the physical world. Today, these applications are typically programmed in low-level imperative programming languages which provide little support for abstraction or reasoning. We present a unifying programming model for concurrent message-passing systems that additionally control the evolution of physical state variables, together with a compositional reasoning framework based on multiparty session types. Our programming model combines message-passing concurrent processes with motion primitives. Processes represent autonomous components in a robotic assembly, such as a cart or a robotic arm, and they synchronise via discrete messages as well as via motion primitives. Continuous evolution of trajectories under the action of controllers is also modelled by motion primitives, which operate in global, physical time. We use multiparty session types as specifications to orchestrate discrete message-passing concurrency and continuous flow of trajectories. A global session type specifies the communication protocol among the components with joint motion primitives. A projection from a global type ensures that jointly executed actions at end-points are communication safe and deadlock-free, i.e., session-typed components do not get stuck. Together, these checks provide a compositional verification methodology for assemblies of robotic components with respect to concurrency invariants such as a progress property of communications as well as dynamic invariants such as absence of collision. We have implemented our core language and, through initial experiments, have shown how multiparty session types can be used to specify and compositionally verify robotic systems implemented on top of off-the-shelf and custom hardware using standard robotics application libraries.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.28", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Society" + }, + { + "first_name": "Marcus", + "last_name": "Pirron", + "institution": "Max Planck Society" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Max Planck Society" + }, + { + "first_name": "Damien", + "last_name": "Zufferey", + "institution": "Max Planck Society" + } + ], + "dblp_key": "conf/ecoop/MajumdarPYZ19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.23", + "title": "Minimal Session Types (Pearl)", + "abstract": "Session types are a type-based approach to the verification of message-passing programs. They have been much studied as type systems for the pi-calculus and for languages such as Java. A session type specifies what and when should be exchanged through a channel. Central to session-typed languages are constructs in types and processes that specify sequencing in protocols. Here we study minimal session types, session types without sequencing. This is arguably the simplest form of session types. By relying on a core process calculus with sessions and higher-order concurrency (abstraction-passing), we prove that every process typable with standard (non minimal) session types can be compiled down into a process typed with minimal session types. This means that having sequencing constructs in both processes and session types is redundant; only sequentiality in processes is indispensable, as it can precisely codify sequentiality in types. Our developments draw inspiration from work by Parrow on behavior-preserving decompositions of untyped processes. By casting Parrow’s results in the realm of typed processes, our results reveal a conceptually simple formulation of session types and a principled avenue to the integration of session types into languages without sequencing in types.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Alen", + "last_name": "Arslanagić", + "institution": "University of Groningen" + }, + { + "first_name": "Jorge A.", + "last_name": "Pérez", + "institution": "University of Groningen" + }, + { + "first_name": "Erik", + "last_name": "Voogd", + "institution": "University of Groningen" + } + ], + "dblp_key": "conf/ecoop/ArslanagicPV19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.22", + "title": "Semantic Patches for Java Program Transformation (Experience Report)", + "abstract": "Developing software often requires code changes that are widespread and applied to multiple locations. There are tools for Java that allow developers to specify patterns for program matching and source-to-source transformation. However, to our knowledge, none allows for transforming code based on its control-flow context. We prototype Coccinelle4J, an extension to Coccinelle, which is a program transformation tool designed for widespread changes in C code, in order to work on Java source code. We adapt Coccinelle to be able to apply scripts written in the Semantic Patch Language (SmPL), a language provided by Coccinelle, to Java source files. As a case study, we demonstrate the utility of Coccinelle4J with the task of API migration. We show 6 semantic patches to migrate from deprecated Android API methods on several open source Android projects. We describe how SmPL can be used to express several API migrations and justify several of our design decisions.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Hong Jin", + "last_name": "Kang", + "institution": "Singapore Management University" + }, + { + "first_name": "Ferdian", + "last_name": "Thung", + "institution": "Singapore Management University" + }, + { + "first_name": "Julia", + "last_name": "Lawall", + "institution": "Sorbonne Université" + }, + { + "first_name": "Gilles", + "last_name": "Muller", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Lingxiao", + "last_name": "Jiang", + "institution": "Singapore Management University" + }, + { + "first_name": "David", + "last_name": "Lo", + "institution": "Singapore Management University" + } + ], + "dblp_key": "conf/ecoop/KangTLMJ019", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.24", + "title": "Julia's Efficient Algorithm for Subtyping Unions and Covariant Tuples (Pearl)", + "abstract": "The Julia programming language supports multiple dispatch and provides a rich type annotation language to specify method applicability. When multiple methods are applicable for a given call, Julia relies on subtyping between method signatures to pick the correct method to invoke. Julia’s subtyping algorithm is surprisingly complex, and determining whether it is correct remains an open question. In this paper, we focus on one piece of this problem: the interaction between union types and covariant tuples. Previous work normalized unions inside tuples to disjunctive normal form. However, this strategy has two drawbacks: complex type signatures induce space explosion, and interference between normalization and other features of Julia’s type system. In this paper, we describe the algorithm that Julia uses to compute subtyping between tuples and unions - an algorithm that is immune to space explosion and plays well with other features of the language. We prove this algorithm correct and complete against a semantic-subtyping denotational model in Coq.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.24", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Benjamin", + "last_name": "Chung", + "institution": "Northeastern University" + }, + { + "first_name": "Francesco Zappa", + "last_name": "Nardelli", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/ChungNV19", + "venue": "ecoop", + "year": 2019 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2019.27", + "title": "Multiverse Debugging: Non-Deterministic Debugging for Non-Deterministic Programs (Brave New Idea Paper)", + "abstract": "Many of today’s software systems are parallel or concurrent. With the rise of Node.js and more generally event-loop architectures, many systems need to handle concurrency. However, its non-deterministic behavior makes it hard to reproduce bugs. Today’s interactive debuggers unfortunately do not support developers in debugging non-deterministic issues. They only allow us to explore a single execution path. Therefore, some bugs may never be reproduced in the debugging session, because the right conditions are not triggered. As a solution, we propose multiverse debugging, a new approach for debugging non-deterministic programs that allows developers to observe all possible execution paths of a parallel program and debug it interactively. We introduce the concepts of multiverse breakpoints and stepping, which can halt a program in different execution paths, i.e. universes. We apply multiverse debugging to AmbientTalk, an actor-based language, resulting in Voyager, a multiverse debugger implemented on top of the AmbientTalk operational semantics. We provide a proof of non-interference, i.e., we prove that observing the behavior of a program by the debugger does not affect the behavior of that program and vice versa. Multiverse debugging establishes the foundation for debugging non-deterministic programs interactively, which we believe can aid the development of parallel and concurrent systems.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2019.27", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Carmen Torres", + "last_name": "Lopez", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Robbert Gurdeep", + "last_name": "Singh", + "institution": "Ghent University" + }, + { + "first_name": "Stefan", + "last_name": "Marr", + "institution": "University of Kent" + }, + { + "first_name": "Elisa Gonzalez", + "last_name": "Boix", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Christophe", + "last_name": "Scholliers", + "institution": "Ghent University" + } + ], + "dblp_key": "conf/ecoop/LopezSMBS19", + "venue": "ecoop", + "year": 2019 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2020.json b/data/pl_conferences/ecoop/2020.json new file mode 100644 index 0000000..b6e1153 --- /dev/null +++ b/data/pl_conferences/ecoop/2020.json @@ -0,0 +1,1484 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.0", + "title": "Front Matter, Table of Contents, Preface, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Conference Organization", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Robert", + "last_name": "Hirschfeld", + "institution": "Hasso Plattner Institute" + }, + { + "first_name": "Tobias", + "last_name": "Pape", + "institution": "Hasso Plattner Institute" + } + ], + "dblp_key": "conf/ecoop/X19a", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.2", + "title": "Perfect Is the Enemy of Good: Best-Effort Program Synthesis", + "abstract": "Program synthesis promises to help software developers with everyday tasks by generating code snippets automatically from input-output examples and other high-level specifications. The conventional wisdom is that a synthesizer must always satisfy the specification exactly. We conjecture that this all-or-nothing paradigm stands in the way of adopting program synthesis as a developer tool: in practice, the user-written specification often contains errors or is simply too hard for the synthesizer to solve within a reasonable time; in these cases, the user is left with a single over-fitted result or, more often than not, no result at all. In this paper we propose a new program synthesis paradigm we call best-effort program synthesis, where the synthesizer returns a ranked list of partially-valid results, i.e. programs that satisfy some part of the specification. \\nTo support this paradigm, we develop best-effort enumeration, a new synthesis algorithm that extends a popular program enumeration technique with the ability to accumulate and return multiple partially-valid results with minimal overhead. We implement this algorithm in a tool called BESTER, and evaluate it on 79 synthesis benchmarks from the literature. Contrary to the conventional wisdom, our evaluation shows that BESTER returns useful results even when the specification is flawed or too hard: i) for all benchmarks with an error in the specification, the top three BESTER results contain the correct solution, and ii) for most hard benchmarks, the top three results contain non-trivial fragments of the correct solution. We also performed an exploratory user study, which confirms our intuition that partially-valid results are useful: the study shows that programmers use the output of the synthesizer for comprehension and often incorporate it into their solutions.", + "date": "2020-11-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Hila", + "last_name": "Peleg", + "institution": "University of California San Diego" + }, + { + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California San Diego" + } + ], + "dblp_key": "conf/ecoop/PelegP19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.3", + "title": "Blame for Null", + "abstract": "Multiple modern programming languages, including Kotlin, Scala, Swift, and C#, have type systems where nullability is explicitly specified in the types. All of the above also need to interoperate with languages where types remain implicitly nullable, like Java. This leads to runtime errors that can manifest in subtle ways. In this paper, we show how to reason about the presence and provenance of such nullability errors using the concept of blame from gradual typing. Specifically, we introduce a calculus, λ_null, where some terms are typed as implicitly nullable and others as explicitly nullable. Just like in the original blame calculus of Wadler and Findler, interactions between both kinds of terms are mediated by casts with attached blame labels, which indicate the origin of errors. On top of λ_null, we then create a second calculus, λ_null^s, which closely models the interoperability between languages with implicit nullability and languages with explicit nullability, such as Java and Scala. Our main result is a theorem that states that nullability errors in λ_null^s can always be blamed on terms with less-precise typing; that is, terms typed as implicitly nullable. By analogy, this would mean that NullPointerExceptions in combined Java/Scala programs are always the result of unsoundness in the Java type system. We summarize our result with the slogan explicitly nullable programs can't be blamed. All our results are formalized in the Coq proof assistant.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Nieto,", + "last_name": "Abel", + "institution": "University of Waterloo" + }, + { + "first_name": "Rapoport,", + "last_name": "Marianna", + "institution": "University of Waterloo" + }, + { + "first_name": "Richards,", + "last_name": "Gregor", + "institution": "University of Waterloo" + }, + { + "first_name": "Lhoták,", + "last_name": "Ondřej", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/ecoop/NietoRRL19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.10", + "title": "Designing with Static Capabilities and Effects: Use, Mention, and Invariants (Pearl)", + "abstract": "Capabilities (whether object or reference capabilities) are fundamentally tools to restrict effects. Thus static capabilities (object or reference) and effect systems take different technical machinery to the same core problem of statically restricting or reasoning about effects in programs. Any time two approaches can in principle address the same sets of problems, it becomes important to understand the trade-offs between the approaches, how these trade-offs might interact with the problem at hand. Experts who have worked in these areas tend to find the trade-offs somewhat obvious, having considered them in context before. However, this kind of design discussion is often written down only implicitly as comparison between two approaches for a specific program reasoning problem, rather than as a discussion of general trade-offs between general classes of techniques. As a result, it is not uncommon to set out to solve a problem with one technique, only to find the other better-suited. We discuss the trade-offs between static capabilities (specifically reference capabilities) and effect systems, articulating the challenges each approach tends to have in isolation, and how these are sometimes mitigated. We also put our discussion in context, by appealing to examples of how these trade-offs were considered in the course of developing prior systems in the area. Along the way, we highlight how seemingly-minor aspects of type systems - weakening/framing and the mere existence of type contexts - play a subtle role in the efficacy of these systems.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "Drexel University" + } + ], + "dblp_key": "conf/ecoop/Gordon19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.14", + "title": "Model-View-Update-Communicate: Session Types Meet the Elm Architecture", + "abstract": "Session types are a type discipline for communication channel endpoints which allow conformance to protocols to be checked statically. Safely implementing session types requires linearity, usually in the form of a linear type system. Unfortunately, linear typing is difficult to integrate with graphical user interfaces (GUIs), and to date most programs using session types are command line applications. In this paper, we propose the first principled integration of session typing and GUI development by building upon the Model-View-Update (MVU) architecture, pioneered by the Elm programming language. We introduce $λ_{\\textsf{MVU}}$, the first formal model of the MVU architecture, and prove it sound. By extending $λ_{\\textsf{MVU}}$ with \\emph{commands} as found in Elm, along with \\emph{linearity} and \\emph{model transitions}, we show the first formal integration of session typing and GUI programming. We implement our approach in the Links web programming language, and show examples including a two-factor authentication workflow and multi-room chat server.", + "date": "2019-10-24", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Simon", + "last_name": "Fowler", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/ecoop/000119", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.12", + "title": "A Semantics for the Essence of React", + "abstract": "Traditionally, web applications have been written as HTML pages with embedded JavaScript code that implements dynamic and interactive features by manipulating the Document Object Model (DOM) through a low-level browser API. However, this unprincipled approach leads to code that is brittle, difficult to understand, non-modular, and does not facilitate incremental update of user-interfaces in response to state changes. React is a popular framework for constructing web applications that aims to overcome these problems. React applications are written in a declarative and object-oriented style, and consist of components that are organized in a tree structure. Each component has a set of properties representing input parameters, a state consisting of values that may vary over time, and a render method that declaratively specifies the subcomponents of the component. React’s concept of reconciliation determines the impact of state changes and updates the user-interface incrementally by selective mounting and unmounting of subcomponents. At designated points, the React framework invokes lifecycle hooks that enable programmers to perform actions outside the framework such as acquiring and releasing resources needed by a component. These mechanisms exhibit considerable complexity, but, to our knowledge, no formal specification of React’s semantics exists. This paper presents a small-step operational semantics that captures the essence of React, as a first step towards a long-term goal of developing automatic tools for program understanding, automatic testing, and bug finding for React web applications. To demonstrate that key operations such as mounting, unmounting, and reconciliation terminate, we define the notion of a well-behaved component and prove that well-behavedness is preserved by these operations.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/MadsenLT19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.13", + "title": "Test-Case Reduction via Test-Case Generation: Insights from the Hypothesis Reducer (Tool Insights Paper)", + "abstract": "We describe internal test-case reduction, the method of test-case reduction employed by Hypothesis, a widely-used property-based testing library for Python. The key idea of internal test-case reduction is that instead of applying test-case reduction externally to generated test cases, we apply it internally, to the sequence of random choices made during generation, so that a test case is reduced by continually re-generating smaller and simpler test cases that continue to trigger some property of interest (e.g. a bug in the system under test). This allows for fully generic test-case reduction without any user intervention and without the need to write a specific test-case reducer for a particular application domain. It also significantly mitigates the impact of the test-case validity problem, by ensuring that any reduced test case is one that could in principle have been generated. We describe the rationale behind this approach, explain its implementation in Hypothesis, and present an extensive evaluation comparing its effectiveness with that of several other test-case reducers, including C-Reduce and delta debugging, on applications including Python auto-formatting, C compilers, and the SymPy symbolic math library. Our hope is that these insights into the reduction mechanism employed by Hypothesis will be useful to researchers interested in randomized testing and test-case reduction, as the crux of the approach is fully generic and should be applicable to any random generator of test cases.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "David R.", + "last_name": "MacIver", + "institution": "Imperial College London" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/MaciverD19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.8", + "title": "Space-Efficient Gradual Typing in Coercion-Passing Style", + "abstract": "Herman et al. pointed out that the insertion of run-time checks into a gradually typed program could hamper tail-call optimization and, as a result, worsen the space complexity of the program. To address the problem, they proposed a space-efficient coercion calculus, which was subsequently improved by Siek et al. The semantics of these calculi involves eager composition of run-time checks expressed by coercions to prevent the size of a term from growing. However, it relies also on a nonstandard reduction rule, which does not seem easy to implement. In fact, no compiler implementation of gradually typed languages fully supports the space-efficient semantics faithfully. In this paper, we study coercion-passing style, which Herman et al. have already mentioned, as a technique for straightforward space-efficient implementation of gradually typed languages. A program in coercion-passing style passes \"the rest of the run-time checks\" around---just like continuation-passing style (CPS), in which \"the rest of the computation\" is passed around---and (unlike CPS) composes coercions eagerly. We give a formal coercion-passing translation from $λ$S by Siek et al. to $λ$S$_1$, which is a new calculus of first-class coercions tailored for coercion-passing style, and prove correctness of the translation. We also implement our coercion-passing style transformation for the Grift compiler developed by Kuhlenschmidt et al. An experimental result shows stack overflow can be prevented properly at the cost of up to 3 times slower execution for most partially typed practical programs.", + "date": "2019-08-07", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yuya", + "last_name": "Tsuda", + "institution": "Kyoto University" + }, + { + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" + }, + { + "first_name": "Tomoya", + "last_name": "Tabuchi", + "institution": "Kyoto University" + } + ], + "dblp_key": "conf/ecoop/TsudaIT19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.6", + "title": "Don't Panic! Better, Fewer, Syntax Errors for LR Parsers", + "abstract": "Syntax errors are generally easy to fix for humans, but not for parsers in general nor LR parsers in particular. Traditional \"panic mode\" error recovery, though easy to implement and applicable to any grammar, often leads to a cascading chain of errors that drown out the original. More advanced error recovery techniques suffer less from this problem but have seen little practical use because their typical performance was seen as poor, their worst case unbounded, and the repairs they reported arbitrary. In this paper we introduce the CPCT+ algorithm, and an implementation of that algorithm, that address these issues. First, CPCT+ reports the complete set of minimum cost repair sequences for a given location, allowing programmers to select the one that best fits their intention. Second, on a corpus of 200,000 real-world syntactically invalid Java programs, CPCT+ is able to repair 98.37%±0.017% of files within a timeout of 0.5s. Finally, CPCT+ uses the complete set of minimum cost repair sequences to reduce the cascading error problem, where incorrect error recovery causes further spurious syntax errors to be identified. Across the test corpus, CPCT+ reports 435,812±473 error locations to the user, reducing the cascading error problem substantially relative to the 981,628±0 error locations reported by panic mode.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Lukas", + "last_name": "Diekmann", + "institution": "" + }, + { + "first_name": "Laurence", + "last_name": "Tratt", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/DiekmannT19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.5", + "title": "Reconciling Event Structures with Modern Multiprocessors", + "abstract": "In this work, we present a family of operational semantics that gradually approximates the realistic program behaviors in the C/C++11 memory model. Each semantics in our framework is built by elaborating and combining two simple ingredients: viewfronts and operation buffers. Viewfronts allow us to express the spatial aspect of thread interaction, i.e., which values a thread can read, while operation buffers enable manipulation with the temporal execution aspect, i.e., determining the order in which the results of certain operations can be observed by concurrently running threads. Starting from a simple abstract state machine, through a series of gradual refinements of the abstract state, we capture such language aspects and synchronization primitives as release/acquire atomics, sequentially-consistent and non-atomic memory accesses, also providing a semantics for relaxed atomics, while avoiding the Out-of-Thin-Air problem. To the best of our knowledge, this is the first formal and executable operational semantics of C11 capable of expressing all essential concurrent aspects of the standard. We illustrate our approach via a number of characteristic examples, relating the observed behaviors to those of standard litmus test programs from the literature. We provide an executable implementation of the semantics in PLT Redex, along with a number of implemented litmus tests and examples, and showcase our prototype on a large case study: randomized testing and debugging of a realistic Read-Copy-Update data structure.", + "date": "2016-06-04", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Anton", + "last_name": "Podkopaev", + "institution": "" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "" + }, + { + "first_name": "Aleksandar", + "last_name": "Nanevski", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/MoiseenkoPLMV19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.11", + "title": "Owicki-Gries Reasoning for C11 RAR", + "abstract": "Owicki-Gries reasoning for concurrent programs uses Hoare logic together with an interference freedom rule for concurrency. In this paper, we develop a new proof calculus for the C11 RAR memory model (a fragment of C11 with both relaxed and release-acquire accesses) that allows all Owicki-Gries proof rules for compound statements, including non-interference, to remain unchanged. Our proof method features novel assertions specifying thread-specific views on the state of programs. This is combined with a set of Hoare logic rules that describe how these assertions are affected by atomic program steps. We demonstrate the utility of our proof calculus by verifying a number of standard C11 litmus tests and Peterson’s algorithm adapted for C11. Our proof calculus and its application to program verification have been fully mechanised in the theorem prover Isabelle.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sadegh", + "last_name": "Dalvandi", + "institution": "University of Surrey" + }, + { + "first_name": "Simon", + "last_name": "Doherty", + "institution": "University of Sheffield" + }, + { + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "University of Surrey" + }, + { + "first_name": "Heike", + "last_name": "Wehrheim", + "institution": "Paderborn University" + } + ], + "dblp_key": "conf/ecoop/DalvandiDDW19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.1", + "title": "Sound Regular Corecursion in coFJ", + "abstract": "The aim of the paper is to provide solid foundations for a programming paradigm natively supporting the creation and manipulation of cyclic data structures. To this end, we describe coFJ, a Java-like calculus where objects can be infinite and methods are equipped with a codefinition (an alternative body). We provide an abstract semantics of the calculus based on the framework of inference systems with corules. In coFJ with this semantics, FJ recursive methods on finite objects can be extended to infinite objects as well, and behave as desired by the programmer, by specifying a codefinition. We also describe an operational semantics which can be directly implemented in a programming language, and prove the soundness of such semantics with respect to the abstract one.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Davide", + "last_name": "Ancona", + "institution": "University of Genoa" + }, + { + "first_name": "Pietro Gino", + "last_name": "Barbieri", + "institution": "University of Genoa" + }, + { + "first_name": "Francesco", + "last_name": "Dagnino", + "institution": "University of Genoa" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/ecoop/AnconaBDZ19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.7", + "title": "K-LLVM: A Relatively Complete Semantics of LLVM IR", + "abstract": "LLVM [Lattner and Adve, 2004] is designed for the compile-time, link-time and run-time optimization of programs written in various programming languages. The language supported by LLVM targeted by modern compilers is LLVM IR [llvm.org, 2018]. In this paper we define K-LLVM, a reference semantics for LLVM IR. To the best of our knowledge, K-LLVM is the most complete formal LLVM IR semantics to date, including all LLVM IR instructions, intrinsic functions in the LLVM documentation and Standard-C library functions that are necessary to execute many LLVM IR programs. Additionally, K-LLVM formulates an abstract machine that executes all LLVM IR instructions. The machine allows to describe our formal semantics in terms of simulating a conceptual virtual machine that runs LLVM IR programs, including non-deterministic programs. Even though the K-LLVM memory model in this paper is assumed to be a sequentially consistent memory model and does not include all LLVM concurrency memory behaviors, the design of K-LLVM’s data layout allows the K-LLVM abstract machine to execute some LLVM IR programs that previous semantics did not cover, such as the full range of LLVM IR behaviors for the interaction among LLVM IR casting, pointer arithmetic, memory operations and some memory flags (e.g. readonly) of function headers. Additionally, the memory model is modularized in a manner that supports investigating other memory models. To validate K-LLVM, we have implemented it in 𝕂 [Roşu, 2016], which generated an interpreter for LLVM IR. Using this, we ran tests including 1,385 unit test programs and around 3,000 concrete LLVM IR programs, and K-LLVM passed all of them.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Liyi", + "last_name": "Li", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Elsa L.", + "last_name": "Gunter", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "conf/ecoop/LiG19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.4", + "title": "Static Race Detection and Mutex Safety and Liveness for Go Programs", + "abstract": "Go is a popular concurrent programming language thanks to its ability to efficiently combine concurrency and systems programming. In Go programs, a number of concurrency bugs can be caused by a mixture of data races and communication problems. In this paper, we develop a theory based on behavioural types to statically detect data races and deadlocks in Go programs. We first specify lock safety/liveness and data race properties over a Go program model, using the happens-before relation defined in the Go memory model. We represent these properties of programs in a μ-calculus model of types, and validate them using type-level model-checking. We then extend the framework to account for Go’s channels, and implement a static verification tool which can detect concurrency errors. This is, to the best of our knowledge, the first static verification framework of this kind for the Go language, uniformly analysing concurrency errors caused by a mix of shared memory accesses and asynchronous message-passing communications.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Julia", + "last_name": "Gabet", + "institution": "" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/GabetY19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.9", + "title": "Multiparty Session Programming With Global Protocol Combinators", + "abstract": "Multiparty Session Types (MPST) is a typing discipline for communication protocols. It ensures the absence of communication errors and deadlocks for well-typed communicating processes. The state-of-the-art implementations of the MPST theory rely on (1) runtime linearity checks to ensure correct usage of communication channels and (2) external domain-specific languages for specifying and verifying multiparty protocols. \\nTo overcome these limitations, we propose a library for programming with global combinators - a set of functions for writing and verifying multiparty protocols in OCaml. Local behaviours for all processes in a protocol are inferred at once from a global combinator. We formalise global combinators and prove a sound realisability of global combinators - a well-typed global combinator derives a set of local types, by which typed endpoint programs can ensure type and communication safety. Our approach enables fully-static verification and implementation of the whole protocol, from the protocol specification to the process implementations, to happen in the same language. \\nWe compare our implementation to untyped and continuation-passing style implementations, and demonstrate its expressiveness by implementing a plethora of protocols. We show our library can interoperate with existing libraries and services, implementing DNS (Domain Name Service) protocol and the OAuth (Open Authentication) protocol.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Keigo", + "last_name": "Imai", + "institution": "Gifu University" + }, + { + "first_name": "Rumyana", + "last_name": "Neykova", + "institution": "Brunel University of London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + }, + { + "first_name": "Shoji", + "last_name": "Yuen", + "institution": "Nagoya University" + } + ], + "dblp_key": "conf/ecoop/ImaiNYY19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.15", + "title": "Static Analysis of Shape in TensorFlow Programs", + "abstract": "Machine learning has been widely adopted in diverse science and engineering domains, aided by reusable libraries and quick development patterns. The TensorFlow library is probably the best-known representative of this trend and most users employ the Python API to its powerful back-end. TensorFlow programs are susceptible to several systematic errors, especially in the dynamic typing setting of Python. We present Pythia, a static analysis that tracks the shapes of tensors across Python library calls and warns of several possible mismatches. The key technical aspects are a close modeling of library semantics with respect to tensor shape, and an identification of violations and error-prone patterns. Pythia is powerful enough to statically detect (with 84.62% precision) 11 of the 14 shape-related TensorFlow bugs in the recent Zhang et al. empirical study - an independent slice of real-world bugs.", + "date": "2016-05-09", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "The Theano Development", + "last_name": "Team", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Al-Rfou,", + "last_name": "Rami", + "institution": "IBM (United States)" + }, + { + "first_name": "Alain,", + "last_name": "Guillaume", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Almahairi,", + "last_name": "Amjad", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Angermueller,", + "last_name": "Christof", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Bahdanau,", + "last_name": "Dzmitry", + "institution": "" + }, + { + "first_name": "Ballas,", + "last_name": "Nicolas", + "institution": "" + }, + { + "first_name": "Bastien,", + "last_name": "Frédéric", + "institution": "" + }, + { + "first_name": "Bayer,", + "last_name": "Justin", + "institution": "" + }, + { + "first_name": "Belikov,", + "last_name": "Anatoly", + "institution": "" + }, + { + "first_name": "Belopolsky,", + "last_name": "Alexander", + "institution": "" + }, + { + "first_name": "Bengio,", + "last_name": "Yoshua", + "institution": "" + }, + { + "first_name": "Bergeron,", + "last_name": "Arnaud", + "institution": "" + }, + { + "first_name": "Bergstra,", + "last_name": "James", + "institution": "" + }, + { + "first_name": "Bisson,", + "last_name": "Valentin", + "institution": "" + }, + { + "first_name": "Snyder, Josh", + "last_name": "Bleecher", + "institution": "" + }, + { + "first_name": "Bouchard,", + "last_name": "Nicolas", + "institution": "" + }, + { + "first_name": "Boulanger-Lewandowski,", + "last_name": "Nicolas", + "institution": "" + }, + { + "first_name": "Bouthillier,", + "last_name": "Xavier", + "institution": "" + }, + { + "first_name": "de Brébisson,", + "last_name": "Alexandre", + "institution": "" + }, + { + "first_name": "Breuleux,", + "last_name": "Olivier", + "institution": "" + }, + { + "first_name": "Carrier,", + "last_name": "Pierre-Luc", + "institution": "" + }, + { + "first_name": "Cho,", + "last_name": "Kyunghyun", + "institution": "" + }, + { + "first_name": "Chorowski,", + "last_name": "Jan", + "institution": "" + }, + { + "first_name": "Christiano,", + "last_name": "Paul", + "institution": "" + }, + { + "first_name": "Cooijmans,", + "last_name": "Tim", + "institution": "" + }, + { + "first_name": "Côté,", + "last_name": "Marc-Alexandre", + "institution": "" + }, + { + "first_name": "Côté,", + "last_name": "Myriam", + "institution": "" + }, + { + "first_name": "Courville,", + "last_name": "Aaron", + "institution": "" + }, + { + "first_name": "Dauphin, Yann", + "last_name": "N.", + "institution": "" + }, + { + "first_name": "Delalleau,", + "last_name": "Olivier", + "institution": "" + }, + { + "first_name": "Demouth,", + "last_name": "Julien", + "institution": "" + }, + { + "first_name": "Desjardins,", + "last_name": "Guillaume", + "institution": "" + }, + { + "first_name": "Dieleman,", + "last_name": "Sander", + "institution": "" + }, + { + "first_name": "Dinh,", + "last_name": "Laurent", + "institution": "" + }, + { + "first_name": "Ducoffe,", + "last_name": "Mélanie", + "institution": "" + }, + { + "first_name": "Dumoulin,", + "last_name": "Vincent", + "institution": "" + }, + { + "first_name": "Kahou, Samira", + "last_name": "Ebrahimi", + "institution": "" + }, + { + "first_name": "Erhan,", + "last_name": "Dumitru", + "institution": "" + }, + { + "first_name": "Fan,", + "last_name": "Ziye", + "institution": "" + }, + { + "first_name": "Firat,", + "last_name": "Orhan", + "institution": "" + }, + { + "first_name": "Germain,", + "last_name": "Mathieu", + "institution": "" + }, + { + "first_name": "Glorot,", + "last_name": "Xavier", + "institution": "" + }, + { + "first_name": "Goodfellow,", + "last_name": "Ian", + "institution": "" + }, + { + "first_name": "Graham,", + "last_name": "Matt", + "institution": "" + }, + { + "first_name": "Gulcehre,", + "last_name": "Caglar", + "institution": "" + }, + { + "first_name": "Hamel,", + "last_name": "Philippe", + "institution": "" + }, + { + "first_name": "Harlouchet,", + "last_name": "Iban", + "institution": "" + }, + { + "first_name": "Heng,", + "last_name": "Jean-Philippe", + "institution": "" + }, + { + "first_name": "Hidasi,", + "last_name": "Balázs", + "institution": "" + }, + { + "first_name": "Honari,", + "last_name": "Sina", + "institution": "" + }, + { + "first_name": "Jain,", + "last_name": "Arjun", + "institution": "" + }, + { + "first_name": "Jean,", + "last_name": "Sébastien", + "institution": "" + }, + { + "first_name": "Jia,", + "last_name": "Kai", + "institution": "" + }, + { + "first_name": "Korobov,", + "last_name": "Mikhail", + "institution": "" + }, + { + "first_name": "Kulkarni,", + "last_name": "Vivek", + "institution": "" + }, + { + "first_name": "Lamb,", + "last_name": "Alex", + "institution": "" + }, + { + "first_name": "Lamblin,", + "last_name": "Pascal", + "institution": "" + }, + { + "first_name": "Larsen,", + "last_name": "Eric", + "institution": "" + }, + { + "first_name": "Laurent,", + "last_name": "César", + "institution": "" + }, + { + "first_name": "Lee,", + "last_name": "Sean", + "institution": "" + }, + { + "first_name": "Lefrancois,", + "last_name": "Simon", + "institution": "" + }, + { + "first_name": "Lemieux,", + "last_name": "Simon", + "institution": "" + }, + { + "first_name": "Léonard,", + "last_name": "Nicholas", + "institution": "" + }, + { + "first_name": "Lin,", + "last_name": "Zhouhan", + "institution": "" + }, + { + "first_name": "Livezey, Jesse", + "last_name": "A.", + "institution": "" + }, + { + "first_name": "Lorenz,", + "last_name": "Cory", + "institution": "" + }, + { + "first_name": "Lowin,", + "last_name": "Jeremiah", + "institution": "" + }, + { + "first_name": "Ma,", + "last_name": "Qianli", + "institution": "" + }, + { + "first_name": "Manzagol,", + "last_name": "Pierre-Antoine", + "institution": "" + }, + { + "first_name": "Mastropietro,", + "last_name": "Olivier", + "institution": "" + }, + { + "first_name": "McGibbon, Robert", + "last_name": "T.", + "institution": "" + }, + { + "first_name": "Memisevic,", + "last_name": "Roland", + "institution": "" + }, + { + "first_name": "van Merriënboer,", + "last_name": "Bart", + "institution": "" + }, + { + "first_name": "Michalski,", + "last_name": "Vincent", + "institution": "" + }, + { + "first_name": "Mirza,", + "last_name": "Mehdi", + "institution": "" + }, + { + "first_name": "Orlandi,", + "last_name": "Alberto", + "institution": "" + }, + { + "first_name": "Pal,", + "last_name": "Christopher", + "institution": "" + }, + { + "first_name": "Pascanu,", + "last_name": "Razvan", + "institution": "" + }, + { + "first_name": "Pezeshki,", + "last_name": "Mohammad", + "institution": "" + }, + { + "first_name": "Raffel,", + "last_name": "Colin", + "institution": "" + }, + { + "first_name": "Renshaw,", + "last_name": "Daniel", + "institution": "" + }, + { + "first_name": "Rocklin,", + "last_name": "Matthew", + "institution": "" + }, + { + "first_name": "Romero,", + "last_name": "Adriana", + "institution": "" + }, + { + "first_name": "Roth,", + "last_name": "Markus", + "institution": "" + }, + { + "first_name": "Sadowski,", + "last_name": "Peter", + "institution": "" + }, + { + "first_name": "Salvatier,", + "last_name": "John", + "institution": "" + }, + { + "first_name": "Savard,", + "last_name": "François", + "institution": "" + }, + { + "first_name": "Schlüter,", + "last_name": "Jan", + "institution": "" + }, + { + "first_name": "Schulman,", + "last_name": "John", + "institution": "" + }, + { + "first_name": "Schwartz,", + "last_name": "Gabriel", + "institution": "" + }, + { + "first_name": "Serban, Iulian", + "last_name": "Vlad", + "institution": "" + }, + { + "first_name": "Serdyuk,", + "last_name": "Dmitriy", + "institution": "" + }, + { + "first_name": "Shabanian,", + "last_name": "Samira", + "institution": "" + }, + { + "first_name": "Simon,", + "last_name": "Étienne", + "institution": "" + }, + { + "first_name": "Spieckermann,", + "last_name": "Sigurd", + "institution": "" + }, + { + "first_name": "Subramanyam, S.", + "last_name": "Ramana", + "institution": "" + }, + { + "first_name": "Sygnowski,", + "last_name": "Jakub", + "institution": "" + }, + { + "first_name": "Tanguay,", + "last_name": "Jérémie", + "institution": "" + }, + { + "first_name": "van Tulder,", + "last_name": "Gijs", + "institution": "" + }, + { + "first_name": "Turian,", + "last_name": "Joseph", + "institution": "" + }, + { + "first_name": "Urban,", + "last_name": "Sebastian", + "institution": "" + }, + { + "first_name": "Vincent,", + "last_name": "Pascal", + "institution": "" + }, + { + "first_name": "Visin,", + "last_name": "Francesco", + "institution": "" + }, + { + "first_name": "de Vries,", + "last_name": "Harm", + "institution": "" + }, + { + "first_name": "Warde-Farley,", + "last_name": "David", + "institution": "" + }, + { + "first_name": "Webb, Dustin", + "last_name": "J.", + "institution": "" + }, + { + "first_name": "Willson,", + "last_name": "Matthew", + "institution": "" + }, + { + "first_name": "Xu,", + "last_name": "Kelvin", + "institution": "" + }, + { + "first_name": "Xue,", + "last_name": "Lijun", + "institution": "" + }, + { + "first_name": "Yao,", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Zhang,", + "last_name": "Saizheng", + "institution": "" + }, + { + "first_name": "Zhang,", + "last_name": "Ying", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/LagouvardosDGAS19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.16", + "title": "Value Partitioning: A Lightweight Approach to Relational Static Analysis for JavaScript", + "abstract": "In static analysis of modern JavaScript libraries, relational analysis at key locations is critical to provide sound and useful results. Prior work addresses this challenge by the use of various forms of trace partitioning and syntactic patterns, which is fragile and does not scale well, or by incorporating complex backwards analysis. In this paper, we propose a new lightweight variant of trace partitioning named value partitioning that refines individual abstract values instead of entire abstract states. We describe how this approach can effectively capture important relational properties involving dynamic property accesses, functions with free variables, and predicate functions. Furthermore, we extend an existing JavaScript analyzer with value partitioning and demonstrate experimentally that it is a simple, precise, and efficient alternative to the existing approaches for analyzing widely used JavaScript libraries.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Benjamin Barslev", + "last_name": "Nielsen", + "institution": "Aarhus University" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/ecoop/NielsenM19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.17", + "title": "Static Type Analysis by Abstract Interpretation of Python Programs", + "abstract": "Python is an increasingly popular dynamic programming language, particularly used in the scientific community and well-known for its powerful and permissive high-level syntax. Our work aims at detecting statically and automatically type errors. As these type errors are exceptions that can be caught later on, we precisely track all exceptions (raised or caught). We designed a static analysis by abstract interpretation able to infer the possible types of variables, taking into account the full control-flow. It handles both typing paradigms used in Python, nominal and structural, supports Python’s object model, introspection operators allowing dynamic type testing, dynamic attribute addition, as well as exception handling. We present a flow- and context-sensitive analysis with special domains to support containers (such as lists) and infer type equalities (allowing it to express parametric polymorphism). The analysis is soundly derived by abstract interpretation from a concrete semantics of Python developed by Fromherz et al. Our analysis is designed in a modular way as a set of domains abstracting a concrete collecting semantics. It has been implemented into the MOPSA analysis framework, and leverages external type annotations from the Typeshed project to support the vast standard library. We show that it scales to benchmarks a few thousand lines long, and preliminary results show it is able to analyze a small real-life command-line utility called PathPicker. Compared to previous work, it is sound, while it keeps similar efficiency and precision.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Raphaël", + "last_name": "Monat", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Abdelraouf", + "last_name": "Ouadjaout", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Antoine", + "last_name": "Miné", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/ecoop/MonatOM19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.18", + "title": "Reference Mutability for DOT", + "abstract": "Reference mutability is a type-based technique for controlling mutation that has been thoroughly studied in Java. We explore how reference mutability interacts with the features of Scala by adding it to the Dependent Object Types (DOT) calculus. Our extension shows how reference mutability can be encoded using existing Scala features such as path-dependent, intersection, and union types. We prove type soundness and the immutability guarantee provided by our calculus.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Vlastimil", + "last_name": "Dort", + "institution": "Charles University" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/ecoop/DortL19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.22", + "title": "Putting Randomized Compiler Testing into Production (Experience Report)", + "abstract": "We describe our experience over the last 18 months on a compiler testing technology transfer project: taking the GraphicsFuzz research project on randomized metamorphic testing of graphics shader compilers, and building the necessary tooling around it to provide a highly automated process for improving the Khronos Vulkan Conformance Test Suite (CTS) with test cases that expose fuzzer-found compiler bugs, or that plug gaps in test coverage. We present this tooling for test automation - gfauto - in detail, as well as our use of differential coverage and test case reduction as a method for automatically synthesizing tests that fill coverage gaps. We explain the value that GraphicsFuzz has provided in automatically testing the ecosystem of tools for transforming, optimizing and validating Vulkan shaders, and the challenges faced when testing a tool ecosystem rather than a single tool. We discuss practical issues associated with putting automated metamorphic testing into production, related to test case validity, bug de-duplication and floating-point precision, and provide illustrative examples of bugs found during our work.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Google (United Kingdom)" + }, + { + "first_name": "Hugues", + "last_name": "Evrard", + "institution": "Google (United Kingdom)" + }, + { + "first_name": "Paul", + "last_name": "Thomson", + "institution": "Google (United Kingdom)" + } + ], + "dblp_key": "conf/ecoop/DonaldsonET19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.19", + "title": "Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model", + "abstract": "Reactive programming is a programming paradigm whereby programs are internally represented by a dependency graph, which is used to automatically (re)compute parts of a program whenever its input changes. In practice reactive programming can only be used for some parts of an application: a reactive program is usually embedded in an application that is still written in ordinary imperative languages such as JavaScript or Scala. In this paper we investigate this embedding and we distill \"the awkward squad for reactive programming\" as 3 concerns that are essential for real-world software development, but that do not fit within reactive programming. They are related to long lasting computations, side-effects, and the coordination between imperative and reactive code. To solve these issues we design a new programming model called the Actor-Reactor Model in which programs are split up in a number of actors and reactors. Actors and reactors enforce a strict separation of imperative and reactive code, and they can be composed via a number of composition operators that make use of data streams. We demonstrate the model via our own implementation in a language called Stella.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sam Van den", + "last_name": "Vonder", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Thierry", + "last_name": "Renaux", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Bjarno", + "last_name": "Oeyen", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Joeri De", + "last_name": "Koster", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Wolfgang De", + "last_name": "Meuter", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/ecoop/VonderROKM19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.20", + "title": "A Framework for Resource Dependent EDSLs in a Dependently Typed Language (Pearl)", + "abstract": "Idris' Effects library demonstrates how to embed resource dependent algebraic effect handlers into a dependently typed host language, providing run-time and compile-time based reasoning on type-level resources. Building upon this work, Resources is a framework for realising Embedded Domain Specific Languages (EDSLs) with type systems that contain domain specific substructural properties. Differing from Effects, Resources allows a language’s substructural properties to be encoded within type-level resources that are associated with language variables. Such an association allows for multiple effect instances to be reasoned about autonomically and without explicit type-level declaration. Type-level predicates are used as proof that the language’s substructural properties hold. Several exemplar EDSLs are presented that illustrates our framework’s operation and how dependent types provide correctness-by-construction guarantees that substructural properties of written programs hold.", + "date": "2020-11-06", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jan de", + "last_name": "Muijnck-Hughes", + "institution": "University of Glasgow" + }, + { + "first_name": "Edwin", + "last_name": "Brady", + "institution": "University of St Andrews" + }, + { + "first_name": "Wim", + "last_name": "Vanderbauwhede", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/ecoop/Muijnck-HughesB19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.21", + "title": "Data Consistency in Transactional Storage Systems: A Centralised Semantics", + "abstract": "We introduce an interleaving operational semantics for describing the client-observable behaviour of atomic transactions on distributed key-value stores. Our semantics builds on abstract states comprising centralised, global key-value stores and partial client views. Using our abstract states, we present operational definitions of well-known consistency models in the literature, and prove them to be equivalent to their existing declarative definitions using abstract executions. We explore two applications of our operational framework: 1) verifying that the COPS replicated database and the Clock-SI partitioned database satisfy their consistency models using trace refinement, and 2) proving invariant properties of client programs.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Shale", + "last_name": "Xiong", + "institution": "Imperial College London" + }, + { + "first_name": "Andrea", + "last_name": "Cerone", + "institution": "Imperial College London" + }, + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/XiongCRG19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.30", + "title": "Safe, Flexible Aliasing with Deferred Borrows", + "abstract": "In recent years, programming-language support for static memory safety has developed significantly. In particular, borrowing and ownership systems, such as the one pioneered by the Rust language, require the programmer to abide by certain aliasing restrictions but in return guarantee that no unsafe aliasing can ever occur. This allows parallel code to be written, or existing code to be parallelized, safely and easily, and the aliasing restrictions also statically prevent a whole class of bugs such as iterator invalidation. Borrowing is easy to reason about because it matches the intuitive ownership-passing conventions often used in systems languages. Unfortunately, a borrowing-based system can sometimes be too restrictive. Because borrows enforce aliasing rules for their entire lifetimes, they cannot be used to implement some common patterns that pointers would allow. Programs often use pseudo-pointers, such as indices into an array of nodes or objects, instead, which can be error-prone: the program is still memory-safe by construction, but it is not logically memory-safe, because an object access may reach the wrong object. In this work, we propose deferred borrows, which provide the type-safety benefits of borrows without the constraints on usage patterns that they otherwise impose. Deferred borrows work by encapsulating enough state at creation time to perform the actual borrow later, while statically guaranteeing that the eventual borrow will reach the same object it would have otherwise. The static guarantee is made with a path-dependent type tying the deferred borrow to the container (struct, vector, etc.) of the borrowed object. This combines the type-safety of borrowing with the flexibility of traditional pointers, while retaining logical memory-safety.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.30", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Chris", + "last_name": "Fallin", + "institution": "Mozilla Foundation" + } + ], + "dblp_key": "conf/ecoop/Fallin19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.25", + "title": "Scala with Explicit Nulls", + "abstract": "The Scala programming language makes all reference types implicitly nullable. This is a problem, because null references do not support most operations that do make sense on regular objects, leading to runtime errors. In this paper, we present a modification to the Scala type system that makes nullability explicit in the types. Specifically, we make reference types non-nullable by default, while still allowing for nullable types via union types. We have implemented this design for explicit nulls as a fork of the Dotty (Scala 3) compiler. We evaluate our scheme by migrating a number of Scala libraries to use explicit nulls. Finally, we give a denotational semantics of type nullification, the interoperability layer between Java and Scala with explicit nulls. We show a soundness theorem stating that, for variants of System F_ω that model Java and Scala, nullification preserves values of types.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.25", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Nieto,", + "last_name": "Abel", + "institution": "University of Waterloo" + }, + { + "first_name": "Zhao,", + "last_name": "Yaoyu", + "institution": "University of Waterloo" + }, + { + "first_name": "Lhoták,", + "last_name": "Ondřej", + "institution": "University of Waterloo" + }, + { + "first_name": "Chang,", + "last_name": "Angela", + "institution": "University of Waterloo" + }, + { + "first_name": "Pu,", + "last_name": "Justin", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/ecoop/NietoZLCP19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.28", + "title": "A Trusted Infrastructure for Symbolic Analysis of Event-Driven Web Applications", + "abstract": "We introduce a trusted infrastructure for the symbolic analysis of modern event-driven Web applications. This infrastructure consists of reference implementations of the DOM Core Level 1, DOM UI Events, JavaScript Promises and the JavaScript async/await APIs, all underpinned by a simple Core Event Semantics which is sufficiently expressive to describe the event models underlying these APIs. Our reference implementations are trustworthy in that three follow the appropriate standards line-by-line and all are thoroughly tested against the official test-suites, passing all the applicable tests. Using the Core Event Semantics and the reference implementations, we develop JaVerT.Click, a symbolic execution tool for JavaScript that, for the first time, supports reasoning about JavaScript programs that use multiple event-related APIs. We demonstrate the viability of JaVerT.Click by proving both the presence and absence of bugs in real-world JavaScript code.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.28", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Gabriela", + "last_name": "Sampaio", + "institution": "Imperial College London" + }, + { + "first_name": "José Fragoso", + "last_name": "Santos", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Petar", + "last_name": "Maksimović", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/SampaioSMG19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.26", + "title": "A Type-Directed Operational Semantics For a Calculus with a Merge Operator", + "abstract": "Calculi with disjoint intersection types and a merge operator provide general mechanisms that can subsume various other features. Such calculi can also encode highly dynamic forms of object composition, which capture common programming patterns in dynamically typed languages (such as JavaScript) in a fully statically typed manner. Unfortunately, unlike many other foundational calculi (such as System F, System F_{< :} or Featherweight Java), recent calculi with the merge operator lack a (direct) operational semantics with standard and expected properties such as determinism and subject-reduction. Furthermore the metatheory for such calculi can only account for terminating programs, which is a significant restriction in practice. This paper proposes a type-directed operational semantics (TDOS) for λ_i^{:}: a calculus with intersection types and a merge operator. The calculus is inspired by two closely related calculi by Dunfield (2014) and Oliveira et al. (2016). Although Dunfield proposes a direct small-step semantics for her calculus, her semantics lacks both determinism and subject-reduction. Using our TDOS we obtain a direct semantics for λ_i^{:} that has both properties. To fully obtain determinism, the λ_i^{:} calculus employs a disjointness restriction proposed in Oliveira et al.’s λ_i calculus. As an added benefit the TDOS approach deals with recursion in a straightforward way, unlike λ_i and subsequent calculi where recursion is problematic. To further relate λ_i^{:} to the calculi by Dunfield and Oliveira et al. we show two results. Firstly, the semantics of λ_i^{:} is sound with respect to Dunfield’s small-step semantics. Secondly, we show that the type system of λ_i^{:} is complete with respect to the λ_i type system. All results have been fully formalized in the Coq theorem prover.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.26", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Xuejing", + "last_name": "Huang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/ecoop/HuangO19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.29", + "title": "The Duality of Subtyping", + "abstract": "Subtyping is a concept frequently encountered in many programming languages and calculi. Various forms of subtyping exist for different type system features, including intersection types, union types or bounded quantification. Normally these features are designed independently of each other, without exploiting obvious similarities (or dualities) between features. \\nThis paper proposes a novel methodology for designing subtyping relations that exploits duality between features. At the core of our methodology is a generalization of subtyping relations, which we call Duotyping. Duotyping is parameterized by the mode of the relation. One of these modes is the usual subtyping, while another mode is supertyping (the dual of subtyping). Using the mode it is possible to generalize the usual rules of subtyping to account not only for the intended behaviour of one particular language construct, but also of its dual. Duotyping brings multiple benefits, including: shorter specifications and implementations, dual features that come essentially for free, as well as new proof techniques for various properties of subtyping. To evaluate a design based on Duotyping against traditional designs, we formalized various calculi with common OOP features (including union types, intersection types and bounded quantification) in Coq in both styles. Our results show that the metatheory when using Duotyping does not come at a significant cost: the metatheory with Duotyping has similar complexity and size compared to the metatheory for traditional designs. However, we discover new features as duals to well-known features. Furthermore, we also show that Duotyping can significantly simplify transitivity proofs for many of the calculi studied by us.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.29", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Shaobo", + "last_name": "Cui", + "institution": "" + }, + { + "first_name": "Baber", + "last_name": "Rehman", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/OliveiraCR19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.24", + "title": "Flow-Sensitive Type-Based Heap Cloning", + "abstract": "By respecting program control-flow, flow-sensitive pointer analysis promises more precise results than its flow-insensitive counterpart. However, existing heap abstractions for C and C++ flow-sensitive pointer analyses model the heap by creating a single abstract heap object for each memory allocation. Two runtime heap objects which originate from the same allocation site are imprecisely modelled using one abstract object, which makes them share the same imprecise points-to sets and thus reduces the benefit of analysing heap objects flow-sensitively. On the other hand, equipping flow-sensitive analysis with context-sensitivity, whereby an abstract heap object would be created (cloned) per calling context, can yield a more precise heap model, but at the cost of uncontrollable analysis overhead when analysing larger programs. This paper presents TypeClone, a new type-based heap model for flow-sensitive analysis. Our key insight is to differentiate concrete heap objects lazily using type information at use sites within the program control-flow (e.g., when accessed via pointer dereferencing) for programs which conform to the strict aliasing rules set out by the C and C++ standards. The novelty of TypeClone lies in its lazy heap cloning: an untyped abstract heap object created at an allocation site is killed and replaced with a new object (i.e. a clone), uniquely identified by the type information at its use site, for flow-sensitive points-to propagation. Thus, heap cloning can be performed within a flow-sensitive analysis without the need for context-sensitivity. Moreover, TypeClone supports new kinds of strong updates for flow-sensitive analysis where heap objects are filtered out from imprecise points-to relations at object use sites according to the strict aliasing rules. Our method is neither strictly superior nor inferior to context-sensitive heap cloning, but rather, represents a new dimension that achieves a sweet spot between precision and efficiency. We evaluate our analysis by comparing TypeClone with state-of-the-art sparse flow-sensitive points-to analysis using the 12 largest programs in GNU Coreutils. Our experimental results also confirm that TypeClone is more precise than flow-sensitive pointer analysis and is able to, on average, answer over 15% more alias queries with a no-alias result.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.24", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Mohamad", + "last_name": "Barbar", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "University of Technology Sydney" + }, + { + "first_name": "Shiping", + "last_name": "Chen", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + } + ], + "dblp_key": "conf/ecoop/BarbarS019", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.27", + "title": "Row and Bounded Polymorphism via Disjoint Polymorphism", + "abstract": "Polymorphism and subtyping are important features in mainstream OO languages. The most common way to integrate the two is via 𝖥_{< :} style bounded quantification. A closely related mechanism is row polymorphism, which provides an alternative to subtyping, while still enabling many of the same applications. Yet another approach is to have type systems with intersection types and polymorphism. A recent addition to this design space are calculi with disjoint intersection types and disjoint polymorphism. With all these alternatives it is natural to wonder how they are related. This paper provides an answer to this question. We show that disjoint polymorphism can recover forms of both row polymorphism and bounded polymorphism, while retaining key desirable properties, such as type-safety and decidability. Furthermore, we identify the extra power of disjoint polymorphism which enables additional features that cannot be easily encoded in calculi with row polymorphism or bounded quantification alone. Ultimately we expect that our work is useful to inform language designers about the expressive power of those common features, and to simplify implementations and metatheory of feature-rich languages with polymorphism and subtyping.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.27", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + }, + { + "first_name": "Xuan", + "last_name": "Bi", + "institution": "University of Hong Kong" + }, + { + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" + } + ], + "dblp_key": "conf/ecoop/XieOBS19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.23", + "title": "Lifting Sequential Effects to Control Operators", + "abstract": "Sequential effect systems are a class of effect system that exploits information about program order, rather than discarding it as traditional commutative effect systems do. This extra expressive power allows effect systems to reason about behavior over time, capturing properties such as atomicity, unstructured lock ownership, or even general safety properties. While we now understand the essential denotational (categorical) models fairly well, application of these ideas to real software is hampered by the variety of source level control flow constructs and control operators in real languages. We address this new problem by appeal to a classic idea: macro-expression of commonly-used programming constructs in terms of control operators. We give an effect system for a subset of Racket’s tagged delimited control operators, as a lifting of an effect system for a language without direct control operators. This gives the first account of sequential effects in the presence of general control operators. Using this system, we also re-derive the sequential effect system rules for control flow constructs previously shown sound directly, and derive sequential effect rules for new constructs not previously studied in the context of source-level sequential effect systems. This offers a way to directly extend source-level support for sequential effect systems to real programming languages.", + "date": "2018-11-29", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Colin S.", + "last_name": "Gordon", + "institution": "Drexel University" + } + ], + "dblp_key": "conf/ecoop/Gordon19a", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.31", + "title": "Reshape Your Layouts, Not Your Programs: A Safe Language Extension for Better Cache Locality (SCICO Journal-first)", + "abstract": "The vast gap between CPU and RAM speed means that on modern architectures, developers need to carefully consider data placement in memory to exploit spatial and temporal cache locality and use CPU caches effectively. To that extent, developers have devised various strategies regarding data placement; for objects that should be close in memory, a contiguous pool of objects is allocated and then new instances are constructed inside it; an array of objects is clustered into multiple arrays, each holding the values of a specific field of the objects. Such data placements, however, have to be performed manually, hence readability, maintainability, memory safety, and key OO concepts such as encapsulation and object identity need to be sacrificed and the business logic needs to be modified accordingly. We propose a language extension, SHAPES, which aims to offer developers high-level fine-grained control over data placement, whilst retaining memory safety and the look-and-feel of OO. SHAPES extends an OO language with the concepts of pools and layouts: Developers declare pools that contain objects of a specific type and specify the pool’s layout. A layout specifies how objects in a pool are laid out in memory. That is, it dictates how the values of the fields of the pool’s objects are grouped together into clusters. Objects stored in pools behave identically to ordinary, standalone objects; the type system allows the code to be oblivious to the layout being used. This means that the business logic is completely decoupled from any placement concerns and the developer need not deviate from the spirit of OO to better utilise the cache. In this paper, we present the features of SHAPES, as well as the design rationale behind each feature. We then showcase the merit of SHAPES through a sequence of case studies; we claim that, compared to the manual pooling and clustering of objects, we can observe improvement in readability and maintainability, and comparable (i.e., on par or better) performance. We also present SHAPES^h, an OO calculus which models the SHAPES ideas, we formalise the type system, and prove soundness. The SHAPES^h type system uses ideas from Ownership Types [Clarke et al., 2013] and Java Generics [Gosling et al., 2014]: In SHAPES^h, pools are part of the types; SHAPES^h class and type definitions are enriched with pool parameters. Moreover, class pool parameters are enriched with bounds, which is what allows the business logic of SHAPES to be oblivious to the layout being used. SHAPES^h types also enforce pool uniformity and homogeneity. A pool is uniform if it contains objects of the same class only; a pool is homogeneous if the corresponding fields of all its objects point to objects in the same pool. These properties allow for more efficient implementation. For performance considerations, we also designed SHAPES^l, an untyped, unsafe low-level language with no explicit support for objects or pools. We argue that it is possible to translate SHAPES^l into existing low-level intermediate representations, such as LLVM [Lattner and Adve, 2004], present the translation of SHAPES^h into SHAPES^l, and show its soundness. Thus, we expect SHAPES to offer developers more fine-grained control over data placement, without sacrificing memory safety or the OO look-and-feel.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.31", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Αλέξανδρος", + "last_name": "Τάσος", + "institution": "Imperial College London" + }, + { + "first_name": "Juliana", + "last_name": "Franco", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Sophia", + "last_name": "Drossopoulou", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Tobias", + "last_name": "Wrigstad", + "institution": "Uppsala University" + }, + { + "first_name": "Susan", + "last_name": "Eisenbach", + "institution": "Victoria University of Wellington" + } + ], + "dblp_key": "conf/ecoop/TasosFDWE19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.32", + "title": "A Big Step from Finite to Infinite Computations (SCICO Journal-first)", + "abstract": "The known is finite, the unknown infinite - Thomas Henry Huxley The behaviour of programs can be described by the final results of computations, and/or their interactions with the context, also seen as observations. For instance, a function call can terminate and return a value, as well as have output effects during its execution. Here, we deal with semantic definitions covering both results and observations. Often, such definitions are provided for finite computations only. Notably, in big-step style, infinite computations are simply not modelled, hence diverging and stuck terms are not distinguished. This becomes even more unsatisfactory if we have observations, since a non-terminating program may have significant infinite behaviour. Recently, examples of big-step semantics modeling divergence have been provided [Davide Ancona et al., 2017; Davide Ancona et al., 2018] by means of generalized inference systems [Davide Ancona et al., 2017; Francesco Dagnino, 2019], which allow corules to control coinduction. Indeed, modeling infinite behaviour by a purely coinductive interpretation of big-step rules would lead to spurious results [Xavier Leroy and Hervé Grall, 2009] and undetermined observation, whereas, by adding appropriate corules, we can correctly get divergence (∞) as the only result, and a uniquely determined observation. This approach has been adopted in [Davide Ancona et al., 2017; Davide Ancona et al., 2018] to design big-step definitions including infinite behaviour for lambda-calculus and a simple imperative Java-like language. However, in such works the designer of the semantics is in charge of finding the appropriate corules, and this is a non-trivial task. In this paper, we show a general construction that extends a given big-step semantics, modeling finite computations, to include infinite behaviour as well, notably by generating appropriate corules. The construction consists of two steps: 1) Starting from a monoid O modeling finite observations (e.g., finite traces), we construct an ω-monoid ⟨O, O_∞⟩ also modeling infinite observations (e.g., infinite traces). The latter structure is a variation of the notion of ω-semigroup [Dominique Perrin and Jean-Eric Pin, 2004], including a mixed product composing a finite with a possibly infinite observation, and an infinite product mapping an infinite sequence of finite observations into a single one (possibly infinite). 2) Starting from an inference system defining a big-step judgment c⇒⟨r, o⟩, with c denoting a configuration, r ∈ R a result, and o ∈ O a finite observation, we construct an inference system with corules defining an extended big-step judgment c⇒c ⇒ ⟨r_∞, o_∞⟩ with r_∞ ∈ R_∞ = R+{∞}, and o_∞ ∈ O_∞ a \"possibly infinite\" observation. The construction generates additional rules for propagating divergence, and corules for introducing divergence in a controlled way. The exact corules added in the construction depend on the type of observations that one starts with. To show the effectiveness of our approach, we provide several instances of the framework, with different kinds of (finite) observations. Finally, we prove a correctness result for the construction. To this end, we assume the original big-step semantics to be equivalent to (finite sequences of steps in) a reference small-step semantics, and we show that, by applying the construction, we obtain an extended big-step semantics which is still equivalent to the small-step semantics, where we consider possibly infinite sequences of steps.} As hypotheses, rather than {just} equivalence in the finite case {(which would be not enough)}, we assume a set of equivalence conditions between individual big-step rules and the small-step relation. This proof of equivalence holds for deterministic semantics; issues arising in the non-deterministic case and a possible solution are sketched in the conclusion of the full paper.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.32", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Davide", + "last_name": "Ancona", + "institution": "University of Genoa" + }, + { + "first_name": "Francesco", + "last_name": "Dagnino", + "institution": "University of Genoa" + }, + { + "first_name": "Jurriaan", + "last_name": "Rot", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/ecoop/AnconaDRZ19", + "venue": "ecoop", + "year": 2020 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2020.33", + "title": "Abstracting Gradual References (SCICO Journal-first)", + "abstract": "Gradual typing is an effective approach to integrate static and dynamic typing, which supports the smooth transition between both extremes via the (programmer-controlled) precision of type annotations [Jeremy Siek and Walid Taha, 2006; Siek et al., 2015]. Imprecision is normally introduced via the unknown type ?, e.g. function type Int → Bool is more precise than ? → ?, and both more precise than ?. Gradual typing relates types of different precision using consistent type relations, such as type consistency (resp. consistent subtyping), the gradual counterpart of type equality (resp. subtyping). For instance, ? → Int is consistent with Bool → ?. This approach has been applied in a number of settings, such as objects [Jeremy Siek and Walid Taha, 2007], subtyping [Jeremy Siek and Walid Taha, 2007; Ronald Garcia et al., 2016], effects [Bañados Schwerter et al., 2014; Bañados Schwerter et al., 2016], ownership [Ilya Sergey and Dave Clarke, 2012], typestates [Roger Wolff et al., 2011; Ronald Garcia et al., 2014], information-flow typing [Tim Disney and Cormac Flanagan, 2011; Luminous Fennell and Peter Thiemann, 2013; Matías Toro et al., 2018], session types [Igarashi et al., 2017], refinements [Nico Lehmann and {É}ric Tanter, 2017], set-theoretic types [Castagna and Lanvin, 2017], Hoare logic [Johannes Bader et al., 2018], parametric polymorphism [Amal Ahmed et al., 2011; Ahmed et al., 2017; Ina and Igarashi, 2011; Igarashi et al., 2017; Ningning Xie et al., 2018; Matías Toro et al., 2019], and references [Jeremy Siek and Walid Taha, 2006; Herman et al., 2010; Siek et al., 2015]. In particular, gradual typing for mutable references has seen the elaboration of various possible semantics: invariant references [Jeremy Siek and Walid Taha, 2006], guarded references [Herman et al., 2010], monotonic references [Siek et al., 2015], and permissive references [Siek et al., 2015]. Invariant references are a form of references where reference types are invariant with respect to type consistency. Guarded references admit variance thanks to systematic runtime checks on reference reads and writes; the runtime type of an allocated cell never changes during execution. Guarded references have been formulated in a space-efficient coercion calculus, which ensures that gradual programs do not accumulate unbounded pending checks during execution. Hereafter, we refer to this language as HCC. Monotonic references favor efficiency over flexibility by only allowing reference cells to vary towards more precise types. This allows reference operations in statically-typed regions to safely proceed without any runtime checks. Permissive references are the most flexible approach, in which reference cells can be initialized and updated to any value of any type at any time. These four developments reflect different design decisions with respect to gradual references: is the reference type constructor variant under consistency? Can the programmer specify a precise bound on the static type of a reference, and hence on the corresponding heap cell type? Can the heap cell type evolve its precision at runtime, and if yes, how? There is obviously no absolute answer to these questions, as they reflect different tradeoffs such as in efficiency and precision. This work explores the semantics that results from the application of a systematic methodology to gradualize static type systems. Currently we can find in the literature two methodologies to gradualize statically-typed languages: Abstracting Gradual Typing (AGT) [Ronald Garcia et al., 2016], and the Gradualizer [Matteo Cimini and Jeremy Siek, 2016]. In this work, we consider the AGT methodology as it naturally scales to auxiliary structures such as a mutable heap. The AGT methodology helps to systematically construct gradually-typed languages by using abstract interpretation [Cousot and Cousot, 1977] at the type level. In brief, AGT interprets gradual types as an abstraction of sets of possible static types, formally captured through a Galois connection. The static semantics of a gradual language are then derived by lifting the semantics of a statically-typed language through this connection, and the dynamic semantics follow by Curry-Howard from proof normalization of the type safety argument. The AGT methodology has been shown to be effective in many contexts: records and subtyping [Ronald Garcia et al., 2016], type-and-effects [Bañados Schwerter et al., 2014; Bañados Schwerter et al., 2016], refinement types [Nico Lehmann and Éric Tanter, 2017; Niki Vazou et al., 2018], set-theoretic and union types [Castagna and Lanvin, 2017; Matías Toro and Éric Tanter, 2017], information-flow typing [Matías Toro et al., 2018], and parametric polymorphism [Matías Toro et al., 2019]. However, this methodology has never been applied to mutable references in isolation. Although Toro et al. [Matías Toro et al., 2018] apply AGT to a language with references, they only gradualize security levels of types (e.g. Ref Int_?), not whole types (e.g. Ref ? is not supported). In this article we answer the following open questions: Which semantics for gradually-type references follows by systematically applying AGT? Does AGT justify one of the existing approaches, or does it suggest yet another design? Can we recover other semantics for gradual references, if yes, how? This article first reviews the different existing gradual approaches to mutable references through examples. It then presents the semantics for gradual references that is obtained by applying AGT, and how to accommodate the other semantics. More specifically, this work makes the following contributions: - We present λ_REF~, a gradual language with support for mutable references. We derive λ_REF~ by applying the AGT methodology to a fully-static simple language with mutable references called λ_REF. This is the first application of AGT that focuses on gradually-typed mutable references. - We prove that λ_REF~ satisfies the gradual guarantee of Siek et al. [Siek et al., 2015]. We also present the first formal statement and proof of the conservative extension of the dynamic semantics of the static language [Siek et al., 2015], for a gradual language derived using AGT. - We prove that the derived language, λ_REF~, corresponds to the semantics of guarded references from HCC. Formally, given a λ_REF~ term and its compilation to HCC^+ (an adapted version of HCC extended with conditionals and binary operations) we prove that both terms are bisimilar, and that consequently they either both terminate, both fail, or both diverge. - We observe that λ_REF~ and HCC^+ differ in the order of combination of runtime checks. As a result, HCC is space efficient whereas λ_REF~ is not: we can write programs in λ_REF~ that may accumulate an unbounded number of checks. We formalize the changes needed in the dynamic semantics of λ_REF~ to achieve space efficiency. This technique to recover space efficiency is in fact independent from mutable references, and is therefore applicable to other gradual languages derived with AGT. - We formally describe how to support other gradual reference semantics in λ_REF~ by presenting λ_REF~^𝗉𝗆, an extension that additionally supports both permissive and monotonic references. Finally, we prove for the first time that monotonic references satisfy the dynamic gradual guarantee, a non-trivial result that requires careful consideration of updates to the store. Additionally, we implemented λ_REF~ as an interactive prototype that displays both typing derivations and reduction traces. All the examples mentioned in this paper are readily available in the online prototype available at https://pleiad.cl/grefs. As a result, this paper sheds further light on the design space of gradual languages with mutable references and contributes to deepening the understanding of the AGT methodology.", + "date": "2020-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2020.33", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Matías", + "last_name": "Toro", + "institution": "University of Chile" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/ecoop/ToroT19", + "venue": "ecoop", + "year": 2020 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2021.json b/data/pl_conferences/ecoop/2021.json new file mode 100644 index 0000000..b463956 --- /dev/null +++ b/data/pl_conferences/ecoop/2021.json @@ -0,0 +1,688 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.0", + "title": "Front Matter, Table of Contents, Preface, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Conference Organization", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/ecoop/X21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.1", + "title": "Scope States: Guarding Safety of Name Resolution in Parallel Type Checkers", + "abstract": "Compilers that can type check compilation units in parallel can make more efficient use of multi-core architectures, which are nowadays widespread. Developing parallel type checker implementations is complicated by the need to handle concurrency and synchronization of parallel compilation units. Dependencies between compilation units are induced by name resolution, and a parallel type checker needs to ensure that units have defined all relevant names before other units do a lookup. Mutually recursive references and implicitly discovered dependencies between compilation units preclude determining a static compilation order for many programming languages. In this paper, we present a new framework for implementing hierarchical type checkers that provides implicit parallel execution in the presence of dynamic and mutual dependencies between compilation units. The resulting type checkers can be written without explicit handling of communication or synchronization between different compilation units. We achieve this by providing type checkers with an API for name resolution based on scope graphs, a language-independent formalism that supports a wide range of binding patterns. We introduce the notion of scope state to ensure safe name resolution. Scope state tracks the completeness of a scope, and is used to decide whether a scope graph query between compilation units must be delayed. Our framework is implemented in Java using the actor paradigm. We evaluated our approach by parallelizing the solver for Statix, a meta-language for type checkers based on scope graphs, using our framework. This parallelizes every Statix-based type checker, provided its specification follows a split declaration-type style. Benchmarks show that the approach results in speedups for the parallel Statix solver of up to 5.0x on 8 cores for real-world code bases.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Hendrik van", + "last_name": "Antwerpen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/ecoop/AntwerpenV21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.9", + "title": "Idris 2: Quantitative Type Theory in Practice", + "abstract": "Dependent types allow us to express precisely what a function is intended to do. Recent work on Quantitative Type Theory (QTT) extends dependent type systems with linearity, also allowing precision in expressing when a function can run. This is promising, because it suggests the ability to design and reason about resource usage protocols, such as we might find in distributed and concurrent programming, where the state of a communication channel changes throughout program execution. As yet, however, there has not been a full-scale programming language with which to experiment with these ideas. Idris 2 is a new version of the dependently typed language Idris, with a new core language based on QTT, supporting linear and dependent types. In this paper, we introduce Idris 2, and describe how QTT has influenced its design. We give examples of the benefits of QTT in practice including: expressing which data is erased at run time, at the type level; and, resource tracking in the type system leading to type-safe concurrent programming with session types.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Edwin", + "last_name": "Brady", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/ecoop/Brady21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.15", + "title": "Best-Effort Lazy Evaluation for Python Software Built on APIs", + "abstract": "There is a perceived trade-off between machine learning code that is easy to write, and machine learning code that is scalable or fast to execute. In machine learning, imperative style libraries like Autograd and PyTorch are easy to write, but suffer from high interpretive overhead and are not easily deployable in production or mobile settings. Graph-based libraries like TensorFlow and Theano benefit from whole-program optimization and can be deployed broadly, but make expressing complex models more cumbersome. We describe how the use of staged programming in Python, via source code transformation, offers a midpoint between these two library design patterns, capturing the benefits of both. A key insight is to delay all type-dependent decisions until runtime, via dynamic dispatch. We instantiate these principles in AutoGraph, a software system that improves the programming experience of the TensorFlow library, and demonstrate usability improvements with no loss in performance compared to native TensorFlow graphs. We also show that our system is backend agnostic, and demonstrate targeting an alternate IR with characteristics not found in TensorFlow graphs.", + "date": "2018-10-16", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Moldovan,", + "last_name": "Dan", + "institution": "North Carolina State University" + }, + { + "first_name": "Decker, James", + "last_name": "M", + "institution": "North Carolina State University" + }, + { + "first_name": "Wang,", + "last_name": "Fei", + "institution": "" + }, + { + "first_name": "Johnson, Andrew", + "last_name": "A", + "institution": "" + }, + { + "first_name": "Lee, Brian", + "last_name": "K", + "institution": "" + }, + { + "first_name": "Nado,", + "last_name": "Zachary", + "institution": "" + }, + { + "first_name": "Sculley,", + "last_name": "D", + "institution": "" + }, + { + "first_name": "Rompf,", + "last_name": "Tiark", + "institution": "" + }, + { + "first_name": "Wiltschko, Alexander", + "last_name": "B", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/ZhangS21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.4", + "title": "Covariant Conversions (CoCo): A Design Pattern for Type-Safe Modular Software Evolution in Object-Oriented Systems", + "abstract": "Software evolution is an essential challenge for all software engineers, typically addressed solely using code versioning systems and language-specific code analysis tools. Most versioning systems view the evolution of a system as a directed acyclic graph of steps, with independent branches that could be merged. What these systems fail to provide is the ability to ensure stable APIs or that each subsequent evolution represents a cohesive extension yielding a valid system. Modular software evolution ensures that APIs remain stable, which is achieved by ensuring that only additional methods, fields, and data types are added, while treating existing modules through blackbox interfaces. Even with these restrictions, it must be possible to add new variations, fields, and methods without extensive duplication of prior module code. In contrast to most literature, our focus is on ensuring modular software evolution using mainstream object-oriented programming languages, instead of resorting to novel language extensions. We present a novel CoCo design pattern that supports type-safe covariantly overridden convert methods to transform earlier data type instances into their newest evolutionary representation to access operations that had been added later. CoCo supports both binary methods and producer methods. We validate and contrast our approach using a well-known compiler construction case study that other researchers have also investigated for modular evolution. Our resulting implementation relies on less boilerplate code, is completely type-safe, and allows clients to use normal object-oriented calling conventions. We also compare CoCo with existing approaches to the Expression Problem. We conclude by discussing how CoCo could change the direction of currently proposed Java language extensions to support closed-world assumptions about data types, as borrowed from functional programming.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jan", + "last_name": "Bessai", + "institution": "TU Dortmund University" + }, + { + "first_name": "George T.", + "last_name": "Heineman", + "institution": "Worcester Polytechnic Institute" + }, + { + "first_name": "Boris", + "last_name": "Düdder", + "institution": "University of Copenhagen" + } + ], + "dblp_key": "conf/ecoop/BessaiHD21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.13", + "title": "Linear Promises: Towards Safer Concurrent Programming", + "abstract": "In this paper, we introduce a new type system based on linear typing, and show how it can be incorporated in a concurrent programming language to track ownership of promises. By tracking write operations on each promise, the language is able to guarantee exactly one write operation is ever performed on any given promise. This language thus precludes a number of common bugs found in promise-based programs, such as failing to write to a promise and writing to the same promise multiple times. We also present an implementation of the language, complete with an efficient type checking algorithm and high-level programming constructs. This language serves as a safer platform for writing high-level concurrent code.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ohad", + "last_name": "Rau", + "institution": "" + }, + { + "first_name": "Caleb", + "last_name": "Voss", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/ecoop/Rau0S21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.7", + "title": "Enabling Additional Parallelism in Asynchronous JavaScript Applications", + "abstract": "JavaScript is a single-threaded programming language, so asynchronous programming is practiced out of necessity to ensure that applications remain responsive in the presence of user input or interactions with file systems and networks. However, many JavaScript applications execute in environments that do exhibit concurrency by, e.g., interacting with multiple or concurrent servers, or by using file systems managed by operating systems that support concurrent I/O. In this paper, we demonstrate that JavaScript programmers often schedule asynchronous I/O operations suboptimally, and that reordering such operations may yield significant performance benefits. Concretely, we define a static side-effect analysis that can be used to determine how asynchronous I/O operations can be refactored so that asynchronous I/O-related requests are made as early as possible, and so that the results of these requests are awaited as late as possible. While our static analysis is potentially unsound, we have not encountered any situations where it suggested reorderings that change program behavior. We evaluate the refactoring on 20 applications that perform file- or network-related I/O. For these applications, we observe average speedups ranging between 0.99% and 53.6% for the tests that execute refactored code (8.1% on average).", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ellen", + "last_name": "Arteca", + "institution": "Northeastern University" + }, + { + "first_name": "Frank", + "last_name": "Tip", + "institution": "Northeastern University" + }, + { + "first_name": "Max", + "last_name": "Schäfer", + "institution": "Nanyang Technological University" + } + ], + "dblp_key": "conf/ecoop/ArtecaTS21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.3", + "title": "Gradual Program Analysis for Null Pointers", + "abstract": "Static analysis tools typically address the problem of excessive false positives by requiring programmers to explicitly annotate their code. However, when faced with incomplete annotations, many analysis tools are either too conservative, yielding false positives, or too optimistic, resulting in unsound analysis results. In order to flexibly and soundly deal with partially-annotated programs, we propose to build upon and adapt the gradual typing approach to abstract-interpretation-based program analyses. Specifically, we focus on null-pointer analysis and demonstrate that a gradual null-pointer analysis hits a sweet spot, by gracefully applying static analysis where possible and relying on dynamic checks where necessary for soundness. In addition to formalizing a gradual null-pointer analysis for a core imperative language, we build a prototype using the Infer static analysis framework, and present preliminary evidence that the gradual null-pointer analysis reduces false positives compared to two existing null-pointer checkers for Infer. Further, we discuss ways in which the gradualization approach used to derive the gradual analysis from its static counterpart can be extended to support more domains. This work thus provides a basis for future analysis tools that can smoothly navigate the tradeoff between human effort and run-time overhead to reduce the number of reported false positives.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sam", + "last_name": "Estep", + "institution": "Jane Street (United States)" + }, + { + "first_name": "Jenna", + "last_name": "Wise", + "institution": "Jane Street (United States)" + }, + { + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Jane Street (United States)" + }, + { + "first_name": "Éric", + "last_name": "Tanter", + "institution": "Jane Street (United States)" + }, + { + "first_name": "Johannes", + "last_name": "Bader", + "institution": "Jane Street (United States)" + }, + { + "first_name": "Joshua", + "last_name": "Sunshine", + "institution": "Jane Street (United States)" + } + ], + "dblp_key": "conf/ecoop/EstepWATBS21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.8", + "title": "Differential Privacy for Coverage Analysis of Software Traces", + "abstract": "This work considers software execution traces, where a trace is a sequence of run-time events. Each user of a software system collects the set of traces covered by her execution of the software, and reports this set to an analysis server. Our goal is to report the local data of each user in a privacy-preserving manner by employing local differential privacy, a powerful theoretical framework for designing privacy-preserving data analysis. A significant advantage of such analysis is that it offers principled \"built-in\" privacy with clearly-defined and quantifiable privacy protections. In local differential privacy, the data of an individual user is modified using a local randomizer before being sent to the untrusted analysis server. Based on the randomized information from all users, the analysis server computes, for each trace, an estimate of how many users have covered it. Such analysis requires that the domain of possible traces be defined ahead of time. Unlike in prior related work, here the domain is either infinite or, at best, restricted to many billions of elements. Further, the traces in this domain typically have structure defined by the static properties of the software. To capture these novel aspects, we define the trace domain with the help of context-free grammars. We illustrate this approach with two exemplars: a call chain analysis in which traces are described through a regular language, and an enter/exit trace analysis in which traces are described by a balanced-parentheses context-free language. Randomization over such domains is challenging due to their large size, which makes it impossible to use prior randomization techniques. To solve this problem, we propose to use count sketch, a fixed-size hashing data structure for summarizing frequent items. We develop a version of count sketch for trace analysis and demonstrate its suitability for software execution data. In addition, instead of randomizing separately each contribution to the sketch, we develop a much-faster one-shot randomization of the accumulated sketch data. One important client of the collected information is the identification of high-frequency (\"hot\") traces. We develop a novel approach to identify hot traces from the collected randomized sketches. A key insight is that the very large domain of possible traces can be efficiently explored for hot traces by using the frequency estimates of a visited trace and its prefixes and suffixes. Our experimental study of both call chain analysis and enter/exit trace analysis indicates that the frequency estimates, as well as the identification of hot traces, achieve high accuracy and high privacy.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yu", + "last_name": "Hao", + "institution": "The Ohio State University" + }, + { + "first_name": "Sufian", + "last_name": "Latif", + "institution": "The Ohio State University" + }, + { + "first_name": "Hailong", + "last_name": "Zhang", + "institution": "Fordham University" + }, + { + "first_name": "Raef", + "last_name": "Bassily", + "institution": "The Ohio State University" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/ecoop/HaoL0BR21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.11", + "title": "Do Bugs Propagate? An Empirical Analysis of Temporal Correlations Among Software Bugs", + "abstract": "The occurrences of bugs are not isolated events, rather they may interact, affect each other, and trigger other latent bugs. Identifying and understanding bug correlations could help developers localize bug origins, predict potential bugs, and design better architectures of software artifacts to prevent bug affection. Many studies in the defect prediction and fault localization literature implied the dependence and interactions between multiple bugs, but few of them explicitly investigate the correlations of bugs across time steps and how bugs affect each other. In this paper, we perform social network analysis on the temporal correlations between bugs across time steps on software artifact ties, i.e., software graphs. Adopted from the correlation analysis methodology in social networks, we construct software graphs of three artifact ties such as function calls and type hierarchy and then perform longitudinal logistic regressions of time-lag bug correlations on these graphs. Our experiments on four open-source projects suggest that bugs can propagate as observed on certain artifact tie graphs. Based on our findings, we propose a hybrid artifact tie graph, a synthesis of a few well-known software graphs, that exhibits a higher degree of bug propagation. Our findings shed light on research for better bug prediction and localization models and help developers to perform maintenance actions to prevent consequential bugs.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Xiaodong", + "last_name": "Gu", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Yo-Sub", + "last_name": "Han", + "institution": "Yonsei University" + }, + { + "first_name": "Sung Hun", + "last_name": "Kim", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Hongyu", + "last_name": "Zhang", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/GuH0021", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.2", + "title": "Lossless, Persisted Summarization of Static Callgraph, Points-To and Data-Flow Analysis", + "abstract": "Static analysis is used to automatically detect bugs and security breaches, and aids compiler optimization. Whole-program analysis (WPA) can yield high precision, however causes long analysis times and thus does not match common software-development workflows, making it often impractical to use for large, real-world applications. This paper thus presents the design and implementation of ModAlyzer, a novel static-analysis approach that aims at accelerating whole-program analysis by making the analysis modular and compositional. It shows how to compute lossless, persisted summaries for callgraph, points-to and data-flow information, and it reports under which circumstances this function-level compositional analysis outperforms WPA. We implemented ModAlyzer as an extension to LLVM and PhASAR, and applied it to 12 real-world C and C++ applications. At analysis time, ModAlyzer modularly and losslessly summarizes the analysis effect of the library code those applications share, hence avoiding its repeated re-analysis. The experimental results show that the reuse of these summaries can save, on average, 72% of analysis time over WPA. Moreover, because it is lossless, the module-wise analysis fully retains precision and recall. Surprisingly, as our results show, it sometimes even yields precision superior to WPA. The initial summary generation, on average, takes about 3.67 times as long as WPA.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Philipp Dominik", + "last_name": "Schubert", + "institution": "Paderborn University" + }, + { + "first_name": "Ben", + "last_name": "Hermann", + "institution": "TU Dortmund University" + }, + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Paderborn University" + } + ], + "dblp_key": "conf/ecoop/SchubertHB21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.6", + "title": "CodeDJ: Reproducible Queries over Large-Scale Software Repositories", + "abstract": "Analyzing massive code bases is a staple of modern software engineering research – a welcome side-effect of the advent of large-scale software repositories such as GitHub. Selecting which projects one should analyze is a labor-intensive process, and a process that can lead to biased results if the selection is not representative of the population of interest. One issue faced by researchers is that the interface exposed by software repositories only allows the most basic of queries. CodeDJ is an infrastructure for querying repositories composed of a persistent datastore, constantly updated with data acquired from GitHub, and an in-memory database with a Rust query interface. CodeDJ supports reproducibility, historical queries are answered deterministically using past states of the datastore; thus researchers can reproduce published results. To illustrate the benefits of CodeDJ, we identify biases in the data of a published study and, by repeating the analysis with new data, we demonstrate that the study’s conclusions were sensitive to the choice of projects.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Petr", + "last_name": "Maj", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Konrad", + "last_name": "Siek", + "institution": "" + }, + { + "first_name": "Alexander", + "last_name": "Kovalenko", + "institution": "" + }, + { + "first_name": "Jan", + "last_name": "Vítek", + "institution": "Czech Technical University in Prague" + } + ], + "dblp_key": "conf/ecoop/MajSKV21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.10", + "title": "Multiparty Session Types for Safe Runtime Adaptation in an Actor Language", + "abstract": "Human fallibility, unpredictable operating environments, and the heterogeneity of hardware devices are driving the need for software to be able to adapt as seen in the Internet of Things or telecommunication networks. Unfortunately, mainstream programming languages do not readily allow a software component to sense and respond to its operating environment, by discovering, replacing, and communicating with components that are not part of the original system design, while maintaining static correctness guarantees. In particular, if a new component is discovered at runtime, there is no guarantee that its communication behaviour is compatible with existing components. We address this problem by using multiparty session types with explicit connection actions, a type formalism used to model distributed communication protocols. By associating session types with software components, the discovery process can check protocol compatibility and, when required, correctly replace components without jeapordising safety. We present the design and implementation of EnsembleS, the first actor-based language with adaptive features and a static session type system, and apply it to a case study based on an adaptive DNS server. We formalise the type system of EnsembleS and prove the safety of well-typed programs, making essential use of recent advances in non-classical multiparty session types.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Paul", + "last_name": "Harvey", + "institution": "Rakuten (Japan)" + }, + { + "first_name": "Simon", + "last_name": "Fowler", + "institution": "University of Glasgow" + }, + { + "first_name": "Ornela", + "last_name": "Dardha", + "institution": "University of Glasgow" + }, + { + "first_name": "Gay, Simon", + "last_name": "J.", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/ecoop/00020DG21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.14", + "title": "Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation", + "abstract": "Program families (software product lines) are increasingly adopted by industry for building families of related software systems. A program family offers a set of features (configured options) to control the presence and absence of software functionality. Features in program families are often assigned at compile-time, so their values can only be read at run-time. However, today many program families and application domains demand run-time adaptation, reconfiguration, and post-deployment tuning. Dynamic program families (dynamic software product lines) have emerged as an attempt to handle variability at run-time. Features in dynamic program families can be controlled by ordinary program variables, so reads and writes to them may happen at run-time. Recently, a decision tree lifted domain for analyzing traditional program families with numerical features has been proposed, in which decision nodes contain linear constraints defined over numerical features and leaf nodes contain analysis properties defined over program variables. Decision nodes partition the configuration space of possible feature values, while leaf nodes provide analysis information corresponding to each partition of the configuration space. As features are statically assigned at compile-time, decision nodes can be added, modified, and deleted only when analyzing read accesses of features. In this work, we extend the decision tree lifted domain so that it can be used to efficiently analyze dynamic program families with numerical features. Since features can now be changed at run-time, decision nodes can be modified when handling read and write accesses of feature variables. For this purpose, we define extended transfer functions for assignments and tests as well as a special widening operator to ensure termination of the lifted analysis. To illustrate the potential of this approach, we have implemented a lifted static analyzer, called DSPLNum²Analyzer, for inferring numerical invariants of dynamic program families written in C. An empirical evaluation on benchmarks from SV-COMP indicates that our tool is effective and provides a flexible way of adjusting the precision/cost ratio in static analysis of dynamic program families.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aleksandar S.", + "last_name": "Dimovski", + "institution": "University of Copenhagen" + }, + { + "first_name": "Sven", + "last_name": "Apel", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/ecoop/DimovskiA21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.5", + "title": "ALPACAS: A Language for Parametric Assessment of Critical Architecture Safety", + "abstract": "This paper introduces Alpacas, a domain-specific language and algorithms aimed at architecture modeling and safety assessment for critical systems. It allows to study the effects of random and systematic faults on complex critical systems and their reliability. The underlying semantic framework of the language is Stochastic Guarded Transition Systems, for which Alpacas provides a feature-rich declarative modeling language and algorithms for symbolic analysis and Monte-Carlo simulation, allowing to compute safety indicators such as minimal cutsets and reliability. Built as a domain-specific language deeply embedded in Scala 3, Alpacas offers generic modeling capabilities and type-safety unparalleled in other existing safety assessment frameworks. This improved expressive power allows to address complex system modeling tasks, such as formalizing the architectural design space of a critical function, and exploring it to identify the most reliable variant. The features and algorithms of Alpacas are illustrated on a case study of a thrust allocation and power dispatch system for an electric vertical takeoff and landing aircraft.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Maxime", + "last_name": "Buyse", + "institution": "" + }, + { + "first_name": "Rémi", + "last_name": "Delmas", + "institution": "" + }, + { + "first_name": "Youssef", + "last_name": "Hamadi", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BuyseDH21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.16", + "title": "Accelerating Object-Sensitive Pointer Analysis by Exploiting Object Containment and Reachability", + "abstract": "Object-sensitive pointer analysis for an object-oriented program can be accelerated if context-sensitivity can be selectively applied to some precision-critical variables/objects in the program. Existing pre-analyses, which are performed to make such selections, either preserve precision but achieve limited speedups by reasoning about all the possible value flows in the program conservatively or achieve greater speedups but sacrifice precision (often unduly) by examining only some but not all the value flows in the program heuristically. In this paper, we introduce a new approach, named Turner, that represents a sweet spot between the two existing ones, as it is designed to enable object-sensitive pointer analysis to run significantly faster than the former approach and achieve significantly better precision than the latter approach. Turner is simple, lightweight yet effective due to two novel aspects in its design. First, we exploit a key observation that some precision-uncritical objects can be approximated based on the object-containment relationship pre-established (by applying Andersen’s analysis). This approximation introduces a small degree yet the only source of imprecision into Turner. Second, leveraging this initial approximation, we introduce a simple DFA to reason about object reachability for a method intra-procedurally from its entry to its exit along all the possible value flows established by its statements to finalize its precision-critical variables/objects identified. We have validated Turner with an implementation in Soot against the state of the art using a set of 12 popular Java benchmarks and applications.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dongjie", + "last_name": "He", + "institution": "UNSW Sydney" + }, + { + "first_name": "Jingbo", + "last_name": "Lu", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yaoqing", + "last_name": "Gao", + "institution": "Huawei Technologies (Canada)" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/ecoop/HeLGX21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.17", + "title": "Signal Classes: A Mechanism for Building Synchronous and Persistent Signal Networks", + "abstract": "Signals are principal abstraction in reactive programming languages and constitute the basics of reactive computations in modern systems, such as the Internet of Things. Signals sometimes utilize past values, which leads to space leak, a problem where accumulated past values waste resources such as the main memory. Persistent signals, an abstraction for time-varying values with their execution histories, provide a generalized and standardized way of space leak management by leaving this management to the database system. However, the current design of persistent signals is very rudimental. For example, they cannot represent complex data structures; they can only be connected using pre-defined API methods that implicitly synchronize the persistent signal network; and they cannot be created dynamically. In this paper, we show that these problems are derived from more fundamental one: no language mechanism is provided to group related persistent signals. To address this problem, we propose a new language mechanism signal classes. A signal class packages a network of related persistent signals that comprises a complex data structure. A signal class defines the scope of synchronization, making it possible to flexibly create persistent signal networks by methods not limited to the use of pre-defined API methods. Furthermore, a signal class can be instantiated, and this instance forms a unit of lifecycle management, which enables the dynamic creation of persistent signals. We formalize signal classes as a small core language where the computation is deliberately defined to interact with the underlying database system using relational algebra. Based on this formalization, we prove the language’s glitch freedom. We also formulate its type soundness by introducing an additional check of program well-formedness. This mechanism is implemented as a compiler and a runtime library that is based on a time-series database. The usefulness of the language is demonstrated through the vehicle tracking simulator and viewer case study. We also conducted a performance evaluation that confirms the feasibility of this case study.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Tetsuo", + "last_name": "Kamina", + "institution": "Oita University" + }, + { + "first_name": "Tomoyuki", + "last_name": "Aotani", + "institution": "Tokyo Institute of Technology" + }, + { + "first_name": "Hidehiko", + "last_name": "Masuhara", + "institution": "Tokyo Institute of Technology" + } + ], + "dblp_key": "conf/ecoop/KaminaAM21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.18", + "title": "Refinements of Futures Past: Higher-Order Specification with Implicit Refinement Types", + "abstract": "Refinement types decorate types with assertions that enable automatic verification. Like assertions, refinements are limited to binders that are in scope, and hence, cannot express higher-order specifications. Ghost variables circumvent this limitation but are prohibitively tedious to use as the programmer must divine and explicate their values at all call-sites. We introduce Implicit Refinement Types which turn ghost variables into implicit pair and function types, in a way that lets the refinement typechecker automatically synthesize their values at compile time. Implicit Refinement Types further take advantage of refinement type information, allowing them to be used as a lightweight verification tool, rather than merely as a technique to automate programming tasks. We evaluate the utility of Implicit Refinement Types by showing how they enable the modular specification and automatic verification of various higher-order examples including stateful protocols, access control, and resource usage.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Anish", + "last_name": "Tondwalkar", + "institution": "" + }, + { + "first_name": "Matthew", + "last_name": "Kolosick", + "institution": "" + }, + { + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/TondwalkarKJ21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.20", + "title": "On the Monitorability of Session Types, in Theory and Practice", + "abstract": "Software components are expected to communicate according to predetermined protocols and APIs. Numerous methods have been proposed to check the correctness of communicating systems against such protocols/APIs. Session types are one such method, used both for static type-checking as well as for run-time monitoring. This work takes a fresh look at the run-time verification of communicating systems using session types, in theory and in practice. On the theoretical side, we develop a formal model of session-monitored processes. We then use this model to formulate and prove new results on the monitorability of session types, defined in terms of soundness (i.e., whether monitors only flag ill-typed processes) and completeness (i.e., whether all ill-typed processes can be flagged by a monitor). On the practical side, we show that our monitoring theory is indeed realisable: we instantiate our formal model as a Scala toolkit (called STMonitor) for the automatic generation of session monitors. These executable monitors can be used as proxies to instrument communication across black-box processes written in any programming language. Finally, we evaluate the viability of our approach through a series of benchmarks.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Christian Bartolo", + "last_name": "Burlò", + "institution": "Gran Sasso Science Institute" + }, + { + "first_name": "Adrian", + "last_name": "Francalanza", + "institution": "University of Malta" + }, + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "Technical University of Denmark" + } + ], + "dblp_key": "conf/ecoop/BurloFS21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.19", + "title": "Dealing with Variability in API Misuse Specification", + "abstract": "APIs are the primary mechanism for developers to gain access to externally defined services and tools. However, previous research has revealed API misuses that violate the contract of APIs to be prevalent. Such misuses can have harmful consequences, especially in the context of cryptographic libraries. Various API-misuse detectors have been proposed to address this issue - including CogniCrypt, one of the most versatile of such detectors and that uses a language (CrySL) to specify cryptographic API usage contracts. Nonetheless, existing approaches to detect API misuse had not been designed for systematic reuse, ignoring the fact that different versions of a library, different versions of a platform, and different recommendations/guidelines might introduce variability in the correct usage of an API. Yet, little is known about how such variability impacts the specification of the correct API usage. This paper investigates this question by analyzing the impact of various sources of variability on widely used Java cryptographic libraries (including JCA/JCE, Bouncy Castle, and Google Tink). The results of our investigation show that sources of variability like new versions of the API and security standards significantly impact the specifications. We then use the insights gained from our investigation to motivate an extension to the CrySL language (named MetaCrySL), which builds on meta-programming concepts. We evaluate MetaCrySL by specifying usage rules for a family of Android versions and illustrate that MetaCrySL can model all forms of variability we identified and drastically reduce the size of a family of specifications for the correct usage of cryptographic APIs.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Rodrigo", + "last_name": "Bonifácio", + "institution": "Universidade de Brasília" + }, + { + "first_name": "Stefan", + "last_name": "Krüger", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Krishna", + "last_name": "Narasimhan", + "institution": "Paderborn University" + }, + { + "first_name": "Eric", + "last_name": "Bodden", + "institution": "Paderborn University" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Paderborn University" + } + ], + "dblp_key": "conf/ecoop/BonifacioKNBM21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.22", + "title": "Multiparty Languages: The Choreographic and Multitier Cases (Pearl)", + "abstract": "Choreographic languages aim to express multiparty communication protocols, by providing primitives that make interaction manifest. Multitier languages enable programming computation that spans across several tiers of a distributed system, by supporting primitives that allow computation to change the location of execution. Rooted into different theoretical underpinnings—respectively process calculi and lambda calculus—the two paradigms have been investigated independently by different research communities with little or no contact. As a result, the link between the two paradigms has remained hidden for long. In this paper, we show that choreographic languages and multitier languages are surprisingly similar. We substantiate our claim by isolating the core abstractions that differentiate the two approaches and by providing algorithms that translate one into the other in a straightforward way. We believe that this work paves the way for joint research and cross-fertilisation among the two communities.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Saverio", + "last_name": "Giallorenzo", + "institution": "" + }, + { + "first_name": "Fabrizio", + "last_name": "Montesi", + "institution": "Department of Physics, Mathematics and Informatics" + }, + { + "first_name": "Marco", + "last_name": "Peressotti", + "institution": "Department of Physics, Mathematics and Informatics" + }, + { + "first_name": "David", + "last_name": "Richter", + "institution": "" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/GiallorenzoMPRS21", + "venue": "ecoop", + "year": 2021 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2021.21", + "title": "λ-Based Object-Oriented Programming (Pearl)", + "abstract": "We show that a minimal subset of Java 8 excluding classes supports a simple and natural programming style, which we call λ-based object-oriented programming. That is, on one hand the programmer can use tuples in place of objects (class instances), and tuples can be desugared to lambdas following their classical encoding in the λ-calculus. On the other hand, lambdas can be equipped with additional behaviour, thanks to the fact that they may implement interfaces with default methods, hence inheritance and dynamic dispatch are still supported. We formally describe the encoding by a translation from FJλ, an FJ variant including lambdas and interfaces with default methods, to FJλ-, a subset of FJλ with no classes (hence no constructors and fields). We provide several examples illustrating this novel programming style.", + "date": "2021-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2021.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Marco", + "last_name": "Servetto", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Elena", + "last_name": "Zucca", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/ecoop/ServettoZ21", + "venue": "ecoop", + "year": 2021 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2022.json b/data/pl_conferences/ecoop/2022.json new file mode 100644 index 0000000..f96c669 --- /dev/null +++ b/data/pl_conferences/ecoop/2022.json @@ -0,0 +1,1046 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.7", + "title": "Functional Programming with Datalog", + "abstract": "Datalog is a carefully restricted logic programming language. What makes Datalog attractive is its declarative fixpoint semantics: Datalog queries consist of simple Horn clauses, yet Datalog solvers efficiently compute all derivable tuples even for recursive queries. However, as we argue in this paper, Datalog is ill-suited as a programming language and Datalog programs are hard to write and maintain. We propose a \"new\" frontend for Datalog: functional programming with sets called functional IncA. While programmers write recursive functions over algebraic data types and sets, we transparently translate all code to Datalog relations. However, we retain Datalog’s strengths: Functions that generate sets can encode arbitrary relations and mutually recursive functions have fixpoint semantics. We also ensure that the generated Datalog program terminates whenever the original functional program terminates, so that we can apply off-the-shelve bottom-up Datalog solvers. We demonstrate the versatility and ease of use of functional IncA by implementing a type checker, a program transformation, an interpreter of the untyped lambda calculus, two data-flow analyses, and clone detection of Java bytecode.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Pacak,", + "last_name": "André", + "institution": "" + }, + { + "first_name": "Erdweg,", + "last_name": "Sebastian", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/PacakE22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.0", + "title": "Front Matter, Table of Contents, Preface, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Conference Organization", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ali,", + "last_name": "Karim", + "institution": "University of Alberta" + }, + { + "first_name": "Vitek,", + "last_name": "Jan", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/X22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.1", + "title": "Verified Compilation and Optimization of Floating-Point Programs in CakeML", + "abstract": "Verified compilers such as CompCert and CakeML have become increasingly realistic over the last few years, but their support for floating-point arithmetic has thus far been limited. In particular, they lack the \"fast-math-style\" optimizations that unverified mainstream compilers perform. Supporting such optimizations in the setting of verified compilers is challenging because these optimizations, for the most part, do not preserve the IEEE-754 floating-point semantics. However, IEEE-754 floating-point numbers are finite approximations of the real numbers, and we argue that any compiler correctness result for fast-math optimizations should appeal to a real-valued semantics rather than the rigid IEEE-754 floating-point numbers. This paper presents RealCake, an extension of CakeML that achieves end-to-end correctness results for fast-math-style optimized compilation of floating-point arithmetic. This result is achieved by giving CakeML a flexible floating-point semantics and integrating an external proof-producing accuracy analysis. RealCake’s end-to-end theorems relate the I/O behavior of the original source program under real-number semantics to the observable I/O behavior of the compiler generated and fast-math-optimized machine code.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Becker,", + "last_name": "Heiko", + "institution": "Max Planck Institute for Informatics" + }, + { + "first_name": "Rabe,", + "last_name": "Robert", + "institution": "" + }, + { + "first_name": "Darulova,", + "last_name": "Eva", + "institution": "Uppsala University" + }, + { + "first_name": "Myreen, Magnus", + "last_name": "O.", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Tatlock,", + "last_name": "Zachary", + "institution": "University of Washington" + }, + { + "first_name": "Kumar,", + "last_name": "Ramana", + "institution": "Google DeepMind (United Kingdom)" + }, + { + "first_name": "Tan, Yong", + "last_name": "Kiam", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Fox,", + "last_name": "Anthony", + "institution": "ARM (United Kingdom)" + } + ], + "dblp_key": "conf/ecoop/BeckerRDMTKTF22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.9", + "title": "A Deterministic Memory Allocator for Dynamic Symbolic Execution", + "abstract": "Dynamic symbolic execution (DSE) has established itself as an effective testing and analysis technique. While the memory model in DSE has attracted significant attention, the memory allocator has been largely ignored, despite its significant influence on DSE. In this paper, we discuss the different ways in which the memory allocator can influence DSE and the main design principles that a memory allocator for DSE needs to follow: support for external calls, cross-run and cross-path determinism, spatially and temporally distanced allocations, and stability. We then present KDAlloc, a deterministic allocator for DSE that is guided by these six design principles. We implement KDAlloc in KLEE, a popular DSE engine, and first show that it is competitive with KLEE’s default allocator in terms of performance and memory overhead, and in fact significantly improves performance in several cases. We then highlight its benefits for use-after-free error detection and two distinct DSE-based techniques: MoKlee, a system for saving DSE runs to disk and later (partially) restoring them, and SymLive, a system for finding infinite-loop bugs.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Schemmel,", + "last_name": "Daniel", + "institution": "Imperial College London" + }, + { + "first_name": "Büning,", + "last_name": "Julian", + "institution": "RWTH Aachen University" + }, + { + "first_name": "Busse,", + "last_name": "Frank", + "institution": "Imperial College London" + }, + { + "first_name": "Nowack,", + "last_name": "Martin", + "institution": "Imperial College London" + }, + { + "first_name": "Cadar,", + "last_name": "Cristian", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/SchemmelBBNC22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.12", + "title": "", + "abstract": "We present two methods for defining corecursive functions that go beyond what is accepted by the builtin corecursion mechanisms of the Coq proof assistant. This gain in expressiveness is obtained by using a combination of axioms from Coq’s standard library that, to our best knowledge, do not introduce inconsistencies but enable reasoning in standard mathematics. Both methods view corecursive functions as limits of sequences of approximations, and both are based on a property of productiveness that, intuitively, requires that for each input, an arbitrarily close approximation of the corresponding output is eventually obtained. The first method uses Coq’s builtin corecursive mechanisms in a non-standard way, while the second method uses none of the mechanisms but redefines them. Both methods are implemented in Coq and are illustrated with examples.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Vlad", + "last_name": "Rusu", + "institution": "Centre Inria de l'Université de Lille" + }, + { + "first_name": "David", + "last_name": "Nowak", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/ecoop/RusuN22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.11", + "title": "Concolic Execution for WebAssembly", + "abstract": "WebAssembly (Wasm) is a new binary instruction format that allows targeted compiled code written in high-level languages to be executed by the browser’s JavaScript engine with near-native speed. Despite its clear performance advantages, Wasm opens up the opportunity for bugs or security vulnerabilities to be introduced into Web programs, as pre-existing issues in programs written in unsafe languages can be transferred down to cross-compiled binaries. The source code of such binaries is frequently unavailable for static analysis, creating the demand for tools that can directly tackle Wasm code. Despite this potentially security-critical situation, there is still a noticeable lack of tool support for analysing Wasm binaries. We present WASP, a symbolic execution engine for testing Wasm modules, which works directly on Wasm code and was built on top of a standard-compliant Wasm reference implementation. WASP was thoroughly evaluated: it was used to symbolically test a generic data-structure library for C and the Amazon Encryption SDK for C, demonstrating that it can find bugs and generate high-coverage testing inputs for real-world C applications; and was further tested against the Test-Comp benchmark, obtaining results comparable to well-established symbolic execution and testing tools for C.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Marques,", + "last_name": "Filipe", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Fragoso Santos,", + "last_name": "José", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Santos,", + "last_name": "Nuno", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Adão,", + "last_name": "Pedro", + "institution": "University of Lisbon" + } + ], + "dblp_key": "conf/ecoop/MarquesS0A22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.13", + "title": "REST: Integrating Term Rewriting with Program Verification", + "abstract": "We introduce REST, a novel term rewriting technique for theorem proving that uses online termination checking and can be integrated with existing program verifiers. REST enables flexible but terminating term rewriting for theorem proving by: (1) exploiting newly-introduced term orderings that are more permissive than standard rewrite simplification orderings; (2) dynamically and iteratively selecting orderings based on the path of rewrites taken so far; and (3) integrating external oracles that allow steps that cannot be justified with rewrite rules. Our REST approach is designed around an easily implementable core algorithm, parameterizable by choices of term orderings and their implementations; in this way our approach can be easily integrated into existing tools. We implemented REST as a Haskell library and incorporated it into Liquid Haskell's evaluation strategy, extending Liquid Haskell with rewriting rules. We evaluated our REST implementation by comparing it against both existing rewriting techniques and E-matching and by showing that it can be used to supplant manual lemma application in many existing Liquid Haskell proofs.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Zachary", + "last_name": "Grannan", + "institution": "" + }, + { + "first_name": "Niki", + "last_name": "Vazou", + "institution": "" + }, + { + "first_name": "Eva", + "last_name": "Darulová", + "institution": "" + }, + { + "first_name": "Alexander J.", + "last_name": "Summers", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/GrannanVDS22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.2", + "title": "Elementary Type Inference", + "abstract": "Languages with polymorphic type systems are made convenient to use by employing type inference to avoid redundant type information. Unfortunately, features such as impredicative types and subtyping make complete type inference very challenging or impossible to realize. This paper presents a form of partial type inference called elementary type inference. Elementary type inference adopts the idea of inferring only monotypes from past work on predicative higher-ranked polymorphism. This idea is extended with the addition of explicit type applications that work for any polytypes. Thus easy (predicative) instantiations can be inferred, while all other (impredicative) instantiations are always possible with explicit type applications without any compromise in expressiveness. Our target is a System F extension with top and bottom types, similar to the language employed by Pierce and Turner in their seminal work on local type inference. We show a sound, complete and decidable type system for a calculus called F_{< :}^e, that targets that extension of System F. A key design choice in F_{< :}^e is to consider top and bottom types as polytypes only. An important technical challenge is that the combination of predicative implicit instantiation and impredicative explicit type applications, in the presence of standard subtyping rules, is non-trivial. Without some restrictions, key properties, such as subsumption and stability of type substitution lemmas, break. To address this problem we introduce a variant of polymorphic subtyping called stable subtyping with some mild restrictions on implicit instantiation. All the results are mechanically formalized in the Abella theorem prover.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Zhao,", + "last_name": "Jinxu", + "institution": "Chinese University of Hong Kong" + }, + { + "first_name": "Oliveira, Bruno C. d.", + "last_name": "S.", + "institution": "Chinese University of Hong Kong" + } + ], + "dblp_key": "conf/ecoop/ZhaoO22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.14", + "title": "Static Analysis for AWS Best Practices in Python Code", + "abstract": "Amazon Web Services (AWS) is a comprehensive and broadly adopted cloud provider. AWS SDKs provide access to AWS services through API endpoints. However, incorrect use of these APIs can lead to code defects, crashes, performance issues, and other problems. AWS best practices are a set of guidelines for correct and secure use of these APIs to access cloud services, allowing conformant clients to fully reap the benefits of cloud computing. We present static analyses, developed in the context of a commercial service for detection of code defects and security vulnerabilities, to identify deviations from AWS best practices. We focus on applications that use the AWS SDK for Python, called Boto3. Precise static analysis of Python cloud applications requires robust type inference for inferring the types of cloud service clients. However, Boto3’s \"Pythonic\" APIs pose unique challenges for type resolution, as does the interprocedural style in which service clients are used. We offer a layered approach that combines multiple type-resolution and tracking strategies in a staged manner: (i) general-purpose type inference augmented by type annotations, (ii) interprocedural dataflow analysis expressed in a domain-specific language, and (iii) name-based resolution as a low-confidence fallback. Across >3,000 popular Python GitHub repos that make use of the AWS SDK, our layered type inference system achieves 85% precision and 100% recall in inferring Boto3 clients in Python client code. Additionally, we use real-world developer feedback to assess a representative sample of eight AWS best-practice rules. These rules detect a wide range of issues including pagination, polling, and batch operations. Developers have accepted more than 85% of the recommendations made by five out of eight Python rules, and almost 83% of all recommendations.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Mukherjee,", + "last_name": "Rajdeep", + "institution": "" + }, + { + "first_name": "Omer", + "last_name": "Tripp", + "institution": "" + }, + { + "first_name": "Ben", + "last_name": "Liblit", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Wilson", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/MukherjeeTLW22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.8", + "title": "Design-By-Contract for Flexible Multiparty Session Protocols", + "abstract": "Choreographic models support a correctness-by-construction principle in distributed programming. Also, they enable the automatic generation of correct message-based communication patterns from a global specification of the desired system behaviour. In this paper we extend the theory of choreography automata, a choreographic model based on finite-state automata, with two key features. First, we allow participants to act only in some of the scenarios described by the choreography automaton. While this seems natural, many choreographic approaches in the literature, and choreography automata in particular, forbid this behaviour. Second, we equip communications with assertions constraining the values that can be communicated, enabling a design-by-contract approach. We provide a toolchain allowing to exploit the theory above to generate APIs for TypeScript web programming. Programs communicating via the generated APIs follow, by construction, the prescribed communication pattern and are free from communication errors such as deadlocks.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Lorenzo", + "last_name": "Gheri", + "institution": "Imperial College London" + }, + { + "first_name": "Ivan", + "last_name": "Lanese", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Neil", + "last_name": "Sayers", + "institution": "Clinical Research Solutions" + }, + { + "first_name": "Emilio", + "last_name": "Tuosto", + "institution": "Gran Sasso Science Institute" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/GheriLSTY22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.15", + "title": "What If We Don't Pop the Stack? The Return of 2nd-Class Values", + "abstract": "Type systems usually characterize the shape of values but not their free variables. However, there are many desirable safety properties one could guarantee if one could track how references can escape. For example, one may implement algebraic effect handlers using capabilities -- a value which permits one to perform the effect -- safely if one can guarantee that the capability itself does not escape the scope bound by the effect handler. To this end, we study the $\\textrm{CF}_{", + "date": "2021-05-25", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aleksander", + "last_name": "Boruch-Gruszecki", + "institution": "" + }, + { + "first_name": "Jonathan Immanuel", + "last_name": "Brachthäuser", + "institution": "" + }, + { + "first_name": "Edward", + "last_name": "Lee", + "institution": "" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/XhebrajB0R22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.5", + "title": "How to Take the Inverse of a Type", + "abstract": "Context-free session types provide a typing discipline for recursive structured communication protocols on bidirectional channels. They overcome the restriction of regular session type systems to tail recursive protocols. This extension enables us to implement serialisation and deserialisation of tree structures in a fully type-safe manner. We present the theory underlying the language FreeST 2, which features context-free session types in an extension of System F with linear types and a kind system to distinguish message types and channel types. The system presents some metatheoretical challenges, which we address, contractivity in the presence of polymorphism, a non-trivial equational theory on types, and decidability of type equivalence. We also establish standard results on type preservation, progress, and a characterisation of erroneous processes.", + "date": "2021-06-12", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bernardo", + "last_name": "Almeida", + "institution": "" + }, + { + "first_name": "Mordido,", + "last_name": "Andreia", + "institution": "" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "" + }, + { + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/MarshallO22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.4", + "title": "Stay Safe Under Panic: Affine Rust Programming with Multiparty Session Types", + "abstract": "Communicating systems comprise diverse software components across networks. To ensure their robustness, modern programming languages such as Rust provide both strongly typed channels, whose usage is guaranteed to be affine (at most once), and cancellation operations over binary channels. For coordinating components to correctly communicate and synchronise with each other, we use the structuring mechanism from multiparty session types, extending it with affine communication channels and implicit/explicit cancellation mechanisms. This new typing discipline, affine multiparty session types (AMPST), ensures cancellation termination of multiple, independently running components and guarantees that communication will not get stuck due to error or abrupt termination. Guided by AMPST, we implemented an automated generation tool (MultiCrusty) of Rust APIs associated with cancellation termination algorithms, by which the Rust compiler auto-detects unsafe programs. Our evaluation shows that MultiCrusty provides an efficient mechanism for communication, synchronisation and propagation of the notifications of cancellation for arbitrary processes. We have implemented several usecases, including popular application protocols (OAuth, SMTP), and protocols with exception handling patterns (circuit breaker, distributed logging).", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Nicolas", + "last_name": "Lagaillardie", + "institution": "Imperial College London" + }, + { + "first_name": "Rumyana", + "last_name": "Neykova", + "institution": "Brunel University of London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/LagaillardieNY22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.10", + "title": "Accumulation Analysis", + "abstract": "A typestate specification indicates which behaviors of an object are permitted in each of the object’s states. In the general case, soundly checking a typestate specification requires precise information about aliasing (i.e., an alias or pointer analysis), which is computationally expensive. This requirement has hindered the adoption of sound typestate analyses in practice. This paper identifies accumulation typestate specifications, which are the subset of typestate specifications that can be soundly checked without any information about aliasing. An accumulation typestate specification can be checked instead by an accumulation analysis: a simple, fast dataflow analysis that conservatively approximates the operations that have been performed on an object. This paper formalizes the notions of accumulation analysis and accumulation typestate specification. It proves that accumulation typestate specifications are exactly those typestate specifications that can be checked soundly without aliasing information. Further, 41% of the typestate specifications that appear in the research literature are accumulation typestate specifications.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Kellogg,", + "last_name": "Martin", + "institution": "University of Washington" + }, + { + "first_name": "Shadab,", + "last_name": "Narges", + "institution": "University of California, Riverside" + }, + { + "first_name": "Sridharan,", + "last_name": "Manu", + "institution": "University of California, Riverside" + }, + { + "first_name": "Ernst, Michael", + "last_name": "D.", + "institution": "University of Washington" + } + ], + "dblp_key": "conf/ecoop/KelloggSSE22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.6", + "title": "Compiling Volatile Correctly in Java", + "abstract": "The compilation scheme for Volatile accesses in the OpenJDK 9 HotSpot Java Virtual Machine has a major problem that persists despite a recent bug report and a long discussion. One of the suggested fixes is to let Java compile Volatile accesses in the same way as C/C++11. However, we show that this approach is invalid for Java. Indeed, we show a set of optimizations that is valid for C/C++11 but invalid for Java, while the compilation scheme is similar. We prove the correctness of the compilation scheme to Power and x86 and a suite of valid optimizations in Java. Our proofs are based on a language model that we validate by proving key properties such as the DRF-SC theorem and by running litmus tests via our implementation of Java in Herd7.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Liu,", + "last_name": "Shuyang", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Bender,", + "last_name": "John", + "institution": "Sandia National Laboratories" + }, + { + "first_name": "Palsberg,", + "last_name": "Jens", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/ecoop/LiuBP22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.16", + "title": "Maniposynth: Bimodal Tangible Functional Programming", + "abstract": "Traditionally, writing code is a non-graphical, abstract, and linear process. Not everyone is comfortable with this way of thinking at all times. Can programming be transformed into a graphical, concrete, non-linear activity? While nodes-and-wires and blocks-based programming environments do leverage graphical direct manipulation, users perform their manipulations on abstract syntax tree elements, which are still abstract. Is it possible to be more concrete - could users instead directly manipulate live program values to create their program? We present a system, Maniposynth, that reimagines functional programming as a non-linear workflow where program expressions are spread on a 2D canvas. The live results of those expressions are continuously displayed and available for direct manipulation. The non-linear canvas liberates users to work out-of-order, and the live values can be interacted with via drag-and-drop. Incomplete programs are gracefully handled via hole expressions, which allow Maniposynth to offer program synthesis. Throughout the workflow, the program is valid OCaml code which the user may inspect and edit in their preferred text editor at any time. With Maniposynth's direct manipulation features, we created 38 programs drawn from a functional data structures course. We additionally hired two professional OCaml developers to implement a subset of these programs. We report on these experiences and discuss to what degree Maniposynth meets its goals of providing a non-linear, concrete, graphical programming workflow.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Brian", + "last_name": "Hempel", + "institution": "University of Chicago" + }, + { + "first_name": "Ravi", + "last_name": "Chugh", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/ecoop/HempelC22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.17", + "title": "Synchron - An API and Runtime for Embedded Systems", + "abstract": "Programming embedded applications involves writing concurrent, event-driven and timing-aware programs. Traditionally, such programs are written in machine-oriented programming languages like C or Assembly. We present an alternative by introducing Synchron, an API that offers high-level abstractions to the programmer while supporting the low-level infrastructure in an associated runtime system and one-time-effort drivers. Embedded systems applications exhibit the general characteristics of being (i) concurrent, (ii) I/O-bound and (iii) timing-aware. To address each of these concerns, the Synchron API consists of three components - (1) a Concurrent ML (CML) inspired message-passing concurrency model, (2) a message-passing-based I/O interface that translates between low-level interrupt based and memory-mapped peripherals, and (3) a timing operator, syncT, that marries CML’s sync operator with timing windows inspired from the TinyTimber kernel. We implement the Synchron API as the bytecode instructions of a virtual machine called SynchronVM. SynchronVM hosts a Caml-inspired functional language as its frontend language, and the backend of the VM supports the STM32F4 and NRF52 microcontrollers, with RAM in the order of hundreds of kilobytes. We illustrate the expressiveness of the Synchron API by showing examples of expressing state machines commonly found in embedded systems. The timing functionality is demonstrated through a music programming exercise. Finally, we provide benchmarks on the response time, jitter rates, memory, and power usage of the SynchronVM.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sarkar,", + "last_name": "Abhiroop", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Svensson, Bo", + "last_name": "Joel", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Sheeran,", + "last_name": "Mary", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/ecoop/SarkarSS22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.18", + "title": "Direct Foundations for Compositional Programming", + "abstract": "The recently proposed CP language adopts Compositional Programming: a new modular programming style that solves challenging problems such as the Expression Problem. CP is implemented on top of a polymorphic core language with disjoint intersection types called Fi+. The semantics of Fi+ employs an elaboration to a target language and relies on a sophisticated proof technique to prove the coherence of the elaboration. Unfortunately, the proof technique is technically challenging and hard to scale to many common features, including recursion or impredicative polymorphism. Thus, the original formulation of Fi+ does not support the two later features, which creates a gap between theory and practice, since CP fundamentally relies on them. This paper presents a new formulation of Fi+ based on a type-directed operational semantics (TDOS). The TDOS approach was recently proposed to model the semantics of languages with disjoint intersection types (but without polymorphism). Our work shows that the TDOS approach can be extended to languages with disjoint polymorphism and model the full Fi+ calculus. Unlike the elaboration semantics, which gives the semantics to Fi+ indirectly via a target language, the TDOS approach gives a semantics to Fi+ directly. With a TDOS, there is no need for a coherence proof. Instead, we can simply prove that the semantics is deterministic. The proof of determinism only uses simple reasoning techniques, such as straightforward induction, and is able to handle problematic features such as recursion and impredicative polymorphism. This removes the gap between theory and practice and validates the original proofs of correctness for CP. We formalized the TDOS variant of the Fi+ calculus and all its proofs in the Coq proof assistant.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Andong", + "last_name": "Fan", + "institution": "Zhejiang University" + }, + { + "first_name": "Xuejing", + "last_name": "Huang", + "institution": "University of Hong Kong" + }, + { + "first_name": "Xu,", + "last_name": "Han", + "institution": "Peking University" + }, + { + "first_name": "Yaozhu", + "last_name": "Sun", + "institution": "University of Hong Kong" + }, + { + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/ecoop/FanHXSO22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.24", + "title": "JavaScript Sealed Classes", + "abstract": "In this work, we study the JavaScript Sealed Classes, which differ from regular classes in a few ways that allow ahead-of-time (AoT) compilers to implement them more efficiently. Sealed classes are compatible with the rest of the language so that they can be combined with all other structures, including regular classes, and can be gradually integrated into existing code bases. We present the design of the sealed classes and study their implementation in the hopc AoT compiler. We present an in-depth analysis of the speed of sealed classes compared to regular classes. To do so, we assembled a new suite of benchmarks that focuses on the efficiency of the class implementations. On this suite, we found that sealed classes provide an average speedup of 19%. The more classes and methods programs use, the greater the speedup. For the most favorable test that uses them intensively, we measured a speedup of 56%.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.24", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Serrano,", + "last_name": "Manuel", + "institution": "Centre Inria d'Université Côte d'Azur" + } + ], + "dblp_key": "conf/ecoop/Serrano22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.19", + "title": "Low-Level Bi-Abduction", + "abstract": "The paper proposes a new static analysis designed to handle open programs, i.e., fragments of programs, with dynamic pointer-linked data structures - in particular, various kinds of lists - that employ advanced low-level pointer operations. The goal is to allow such programs be analysed without a need of writing analysis harnesses that would first initialise the structures being handled. The approach builds on a special flavour of separation logic and the approach of bi-abduction. The code of interest is analyzed along the call tree, starting from its leaves, with each function analysed just once without any call context, leading to a set of contracts summarizing the behaviour of the analysed functions. In order to handle the considered programs, methods of abduction existing in the literature are significantly modified and extended in the paper. The proposed approach has been implemented in a tool prototype and successfully evaluated on not large but complex programs.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "" + }, + { + "first_name": "Petr", + "last_name": "Peringer", + "institution": "" + }, + { + "first_name": "Adam", + "last_name": "Rogalewicz", + "institution": "" + }, + { + "first_name": "Veronika", + "last_name": "Šoková", + "institution": "" + }, + { + "first_name": "Tomáš", + "last_name": "Vojnar", + "institution": "" + }, + { + "first_name": "Florian", + "last_name": "Zuleger", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/HolikPRSVZ22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.22", + "title": "Ferrite: A Judgmental Embedding of Session Types in Rust", + "abstract": "Multiparty message-passing protocols are notoriously difficult to design, due to interaction mismatches that lead to errors such as deadlocks. Existing protocol specification formats have been developed to prevent such errors (e.g. multiparty session types (MPST)). In order to further constrain protocols, specifications can be extended with refinements, i.e. logical predicates to control the behaviour of the protocol based on previous values exchanged. Unfortunately, existing refinement theories and implementations are tightly coupled with specification formats. This paper proposes a framework for multiparty message-passing protocols with refinements and its implementation in Rust. Our work decouples correctness of refinements from the underlying model of computation, which results in a specification-agnostic framework. Our contributions are threefold. First, we introduce a trace system which characterises valid refined traces, i.e. a sequence of sending and receiving actions correct with respect to refinements. Second, we give a correct model of computation named refined communicating system (RCS), which is an extension of communicating automata systems with refinements. We prove that RCS only produce valid refined traces. We show how to generate RCS from mainstream protocol specification formats, such as refined multiparty session types (RMPST) or refined choreography automata. Third, we illustrate the flexibility of the framework by developing both a static analysis technique and an improved model of computation for dynamic refinement evaluation. Finally, we provide a Rust toolchain for decentralised RMPST, evaluate our implementation with a set of benchmarks from the literature, and observe that refinement overhead is negligible.", + "date": "2020-09-28", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Chen,", + "last_name": "Ruofei", + "institution": "" + }, + { + "first_name": "Balzer,", + "last_name": "Stephanie", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Toninho,", + "last_name": "Bernardo", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "conf/ecoop/ChenBT22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.27", + "title": "API Generation for Multiparty Session Types, Revisited and Revised Using Scala 3", + "abstract": "Construction and analysis of distributed systems is difficult. Multiparty session types (MPST) constitute a method to make it easier. The idea is to use type checking to statically prove deadlock freedom and protocol compliance of communicating processes. In practice, the premier approach to apply the MPST method in combination with mainstream programming languages has been based on API generation. In this paper (pearl), we revisit and revise this approach. Regarding our \"revisitation\", using Scala 3, we present the existing API generation approach, which is based on deterministic finite automata (DFA), in terms of both the existing states-as-classes encoding of DFAs as APIs, and a new states-as-type-parameters encoding; the latter leverages match types in Scala 3. Regarding our \"revision\", also using Scala 3, we present a new API generation approach that is based on sets of pomsets instead of DFAs; it crucially leverages match types, too. Our fresh perspective allows us to avoid two forms of combinatorial explosion resulting from implementing concurrent subprotocols in the DFA-based approach. We implement our approach in a new API generation tool.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.27", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Cledou,", + "last_name": "Guillermina", + "institution": "INESC TEC" + }, + { + "first_name": "Edixhoven,", + "last_name": "Luc", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Jongmans,", + "last_name": "Sung-Shik", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Proença,", + "last_name": "José", + "institution": "Polytechnic Institute of Porto" + } + ], + "dblp_key": "conf/ecoop/CledouEJP22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.21", + "title": "PEDroid: Automatically Extracting Patches from Android App Updates", + "abstract": "Identifying and analyzing code patches is a common practice to not only understand existing bugs but also help find and fix similar bugs in new projects. Most patch analysis techniques aim at open-source projects, in which the differentials of source code are easily identified, and some extra information such as code commit logs could be leveraged to help find and locate patches. The task, however, becomes challenging when source code as well as development logs are lacking. A typical scenario is to discover patches in an updated Android app, which requires bytecode-level analysis. In this paper, we propose an approach to automatically identify and extract patches from updated Android apps by comparing the updated versions and their predecessors. Given two Android apps (original and updated versions), our approach first identifies identical and modified methods by similarity comparison through code features and app structures. Then, it compares these modified methods with their original implementations in the original app, and detects whether a patch is applied to the modified method by analyzing the difference in internal semantics. We implemented PEDroid, a prototype patch extraction tool against Android apps, and evaluated it with a set of popular open-source apps and a set of real-world apps from different Android vendors. PEDroid identifies 28 of the 36 known patches in the former, and successfully analyzes 568 real-world app updates in the latter, among which 94.37% of updates could be completed within 20 minutes.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Li,", + "last_name": "Hehao", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Wang,", + "last_name": "Yizhuo", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Zhang,", + "last_name": "Yiwei", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Li,", + "last_name": "Juanru", + "institution": "Shanghai Jiao Tong University" + }, + { + "first_name": "Gu,", + "last_name": "Dawu", + "institution": "Shanghai Jiao Tong University" + } + ], + "dblp_key": "conf/ecoop/LiWZLG22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.30", + "title": "Qilin: A New Framework For Supporting Fine-Grained Context-Sensitivity in Java Pointer Analysis", + "abstract": "Existing whole-program context-sensitive pointer analysis frameworks for Java, which were open-sourced over one decade ago, were designed and implemented to support only method-level context-sensitivity (where all the variables/objects in a method are qualified by a common context abstraction representing a context under which the method is analyzed). We introduce Qilin as a generalized (modern) alternative, which has been open-sourced on GitHub, to support the current research trend on exploring fine-grained context-sensitivity (including variable-level context-sensitivity where different variables/objects in a method can be analyzed under different context abstractions at the variable level), precisely, efficiently, and modularly. To meet these four design goals, Qilin is developed as an imperative framework (implemented in Java) consisting of a fine-grained pointer analysis kernel with parameterized context-sensitivity that supports on-the-fly call graph construction and exception analysis, solved iteratively based on a new carefully-crafted incremental worklist-based constraint solver, on top of its handlers for complex Java features. We have evaluated Qilin extensively using a set of 12 representative Java programs (popularly used in the literature). For method-level context-sensitive analyses, we compare Qilin with Doop (a declarative framework that defines the state-of-the-art), Qilin yields logically the same precision but more efficiently (e.g., 2.4x faster for four typical baselines considered, on average). For fine-grained context-sensitive analyses (which are not currently supported by open-source Java pointer analysis frameworks such as Doop), we show that Qilin allows seven recent approaches to be instantiated effectively in our parameterized framework, requiring additionally only an average of 50 LOC each.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.30", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "He,", + "last_name": "Dongjie", + "institution": "UNSW Sydney" + }, + { + "first_name": "Lu,", + "last_name": "Jingbo", + "institution": "UNSW Sydney" + }, + { + "first_name": "Xue,", + "last_name": "Jingling", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/ecoop/HeLX22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.20", + "title": "Functional Programming for Distributed Systems with XC", + "abstract": "Programming distributed systems is notoriously hard due to - among the others - concurrency, asynchronous execution, message loss, and device failures. Homogeneous distributed systems consist of similar devices that communicate to neighbours and execute the same program: they include wireless sensor networks, network hardware, and robot swarms. For the homogeneous case, we investigate an experimental language design that aims to push the abstraction boundaries farther, compared to existing approaches. In this paper, we introduce the design of XC, a programming language to develop homogeneous distributed systems. In XC, developers define the single program that every device executes and the overall behaviour is achieved collectively, in an emergent way. The programming framework abstracts over concurrency, asynchronous execution, message loss, and device failures. We propose a minimalistic design, which features a single declarative primitive for communication, state management, and connection management. A mechanism called alignment enables developers to abstract over asynchronous execution while still retaining composability. We define syntax and operational semantics of a core calculus, and briefly discuss its main properties. XC comes with two DSL implementations: a DSL in Scala and one in C++. An evaluation based on smart-city monitoring demonstrates XC in a realistic application.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Audrito,", + "last_name": "Giorgio", + "institution": "University of Turin" + }, + { + "first_name": "Casadei,", + "last_name": "Roberto", + "institution": "Azienda-Unita' Sanitaria Locale Di Cesena" + }, + { + "first_name": "Damiani,", + "last_name": "Ferruccio", + "institution": "University of Turin" + }, + { + "first_name": "Salvaneschi,", + "last_name": "Guido", + "institution": "University of St.Gallen" + }, + { + "first_name": "Viroli,", + "last_name": "Mirko", + "institution": "Azienda-Unita' Sanitaria Locale Di Cesena" + } + ], + "dblp_key": "conf/ecoop/AudritoCDSV22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.29", + "title": "Experience: Model-Based, Feedback-Driven, Greybox Web Fuzzing with BackREST", + "abstract": "Following the advent of the American Fuzzy Lop (AFL), fuzzing had a surge in popularity, and modern day fuzzers range from simple blackbox random input generators to complex whitebox concolic frameworks that are capable of deep program introspection. Web application fuzzers, however, did not benefit from the tremendous advancements in fuzzing for binary programs and remain largely blackbox in nature. In this experience paper, we show how techniques like state-aware crawling, type inference, coverage and taint analysis can be integrated with a black-box fuzzer to find more critical vulnerabilities, faster (speedups between 7.4× and 25.9×). Comparing BackREST against three other web fuzzers on five large (>500 KLOC) Node.js applications shows how it consistently achieves comparable coverage while reporting more vulnerabilities than state-of-the-art. Finally, using BackREST, we uncovered eight 0-days, out of which six were not reported by any other fuzzer. All the 0-days have been disclosed and most are now public, including two in the highly popular Sequelize and Mongodb libraries.", + "date": "2021-08-19", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.29", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "François", + "last_name": "Gauthier", + "institution": "" + }, + { + "first_name": "Behnaz", + "last_name": "Hassanshahi", + "institution": "" + }, + { + "first_name": "Benjamin", + "last_name": "Selwyn-Smith", + "institution": "" + }, + { + "first_name": "Trong", + "last_name": "Nhan", + "institution": "" + }, + { + "first_name": "Max", + "last_name": "Schlüter", + "institution": "" + }, + { + "first_name": "Micah", + "last_name": "Williams", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/ecoop/GauthierHSMSW22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.23", + "title": "A Self-Dual Distillation of Session Types", + "abstract": "We introduce ƛ (\"lambda-barrier\"), a minimal extension of linear λ-calculus with concurrent communication, which adds only a single new fork construct for spawning threads. It is inspired by GV, a session-typed functional language also based on linear λ-calculus. Unlike GV, ƛ strives to be as simple as possible, and adds no new operations other than fork, no new type formers, and no explicit definition of session type duality. Instead, we use linear function function type τ₁ -∘ τ₂ for communication between threads, which is dual to τ₂ -∘ τ₁, i.e., the function type constructor is dual to itself. Nevertheless, we can encode session types as ƛ types, GV’s channel operations as ƛ terms, and show that this encoding is type-preserving. The linear type system of ƛ ensures that all programs are deadlock-free and satisfy global progress, which we prove in Coq. Because of ƛ’s minimality, these proofs are simpler than mechanized proofs of deadlock freedom for GV.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jacobs,", + "last_name": "Jules", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "conf/ecoop/Jacobs22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.28", + "title": "Global Type Inference for Featherweight Generic Java", + "abstract": "Java's type system mostly relies on type checking augmented with local type inference to improve programmer convenience. We study global type inference for Featherweight Generic Java (FGJ), a functional Java core language. Given generic class headers and field specifications, our inference algorithm infers all method types if classes do not make use of polymorphic recursion. The algorithm is constraint-based and improves on prior work in several respects. Despite the restricted setting, global type inference for FGJ is NP-complete.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.28", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Stadelmeier", + "institution": "" + }, + { + "first_name": "Martin", + "last_name": "Plümicke", + "institution": "" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/StadelmeierP022", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.25", + "title": "Union Types with Disjoint Switches", + "abstract": "Union types are nowadays a common feature in many modern programming languages. This paper investigates a formulation of union types with an elimination construct that enables case analysis (or switches) on types. The interesting aspect of this construct is that each clause must operate on disjoint types. By using disjoint switches, it is possible to ensure exhaustiveness (i.e. all possible cases are handled), and that none of the cases overlap. In turn, this means that the order of the cases does not matter and that reordering the cases has no impact on the semantics, helping with program understanding and refactoring. While implemented in the Ceylon language, disjoint switches have not been formally studied in the research literature, although a related notion of disjointness has been studied in the context of disjoint intersection types. We study union types with disjoint switches formally and in a language independent way. We first present a simplified calculus, called the union calculus (λ_u), which includes disjoint switches and prove several results, including type soundness and determinism. The notion of disjointness in λ_u is in essence the dual notion of disjointness for intersection types. We then present a more feature-rich formulation of λ_u, which includes intersection types, distributive subtyping and a simple form of nominal types. This extension reveals new challenges. Those challenges require us to depart from the dual notion of disjointness for intersection types, and use a more general formulation of disjointness instead. Among other applications, we show that disjoint switches provide an alternative to certain forms of overloading, and that they enable a simple approach to nullable (or optional) types. All the results about λ_u and its extensions have been formalized in the Coq theorem prover.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.25", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Rehman,", + "last_name": "Baber", + "institution": "University of Hong Kong" + }, + { + "first_name": "Huang,", + "last_name": "Xuejing", + "institution": "University of Hong Kong" + }, + { + "first_name": "Xie,", + "last_name": "Ningning", + "institution": "University of Cambridge" + }, + { + "first_name": "Oliveira, Bruno C. d.", + "last_name": "S.", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/ecoop/RehmanHXO22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.32", + "title": "Vincent: Green Hot Methods in the JVM (Extended Abstract)", + "abstract": "In this paper, we show the energy efficiency of Java applications can be improved by applying Dynamic Voltage and Frequency Scaling (DVFS) inside the Java Virtual Machine (JVM). We augment the JVM to record the energy consumption of hot methods as the underlying CPU is run at different clock frequencies; after all the frequency possibilities for a method have been explored, the execution of the method in an optimized run is set to the CPU frequency that leads to the most energy-efficient execution for that method. We introduce a new sampling methodology to overcome the dual challenges in our design: both the underlying measurement mechanism for energy profiling and the DVFS for energy optimization are overhead-prone. We extend JikesRVM with our approach and benchmark it over the DaCapo suite on a server-class Linux machine. Experiments show we are able to use 14.9% less energy than built-in power management in Linux, and improve energy efficiency by 21.1% w.r.t. the metric of Energy-Delay Product (EDP).", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.32", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Liu,", + "last_name": "Kenan", + "institution": "Binghamton University" + }, + { + "first_name": "Mahmoud,", + "last_name": "Khaled", + "institution": "Binghamton University" + }, + { + "first_name": "Yoo,", + "last_name": "Joonhwan", + "institution": "Binghamton University" + }, + { + "first_name": "Liu, Yu", + "last_name": "David", + "institution": "Binghamton University" + } + ], + "dblp_key": "conf/ecoop/LiuMYL22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.34", + "title": "Slicing of Probabilistic Programs Based on Specifications (Extended Abstract)", + "abstract": "We present the first slicing approach for probabilistic programs based on specifications. Concretely, we show that when probabilistic programs are accompanied by their functional specifications in the form of pre- and post-condition, one can exploit this semantic information to produce specification-preserving slices strictly more precise than slices yielded by conventional techniques based on data/control dependency. To illustrate this, assume that Alice and Bob repeatedly flip a fair coin until observing a matching outcome, either both heads or both tails. However, Alice decides to \"trick\" Bob and switches the outcome of her coin, before comparing it to Bob’s. The game can be encoded by the program below, which is instrumented with a variable n that tracks the required number of rounds until observing the first match. The program terminates after K loop iterations with probability 1/(2^K) provided K > 0, and with probability 0 otherwise, satisfying the annotated specification. \\\\ pre: 1/(2^K) [K > 0] n := 0; a, b := 0, 1; while (a ̸= b) do n := n + 1; {a := 0} [1/2] {a := 1}; a := 1 − a; {b := 0} [1/2] {b := 1} \\\\ post: [n = K] Traditional slicing techniques based on data/control dependencies conclude that the only valid slice of the program (w.r.t. output variable n) is the very same program. However, our slicing approach allows removing the assignment a := 1-a from the loop body, while preserving the program specification. At the technical level, our slicing technique works by propagating post-conditions backward using the greatest pre-expectation transformer - the probabilistic counterpart of Dijkstra’s weakest pre-condition transformer. This endows programs with an axiomatic semantics, expressed in terms of a verification condition generator (VCGen) that yields quantitative proof obligations. In particular, we design (and prove sound) VCGens for both the partial (allowing divergence) and the total (requiring termination) correctness of probabilistic programs, making our slicing technique termination-sensitive. To handle iteration, we assume that program loops are annotated with invariants. To reason about (probabilistic) termination, we assume that loop annotations also include (probabilistic) variants. Another appealing property of our slicing technique is its modularity: It yields valid slices of a program from valid slices of its subprograms. Most importantly, this involves only local reasoning. Besides developing the theoretical foundations of our slicing approach, we also exhibit an algorithm for computing program slices. Interestingly, the algorithm computes the least slice that can be derived from the slicing approach, according to a proper notion of slice size, using, as main ingredient, a shortest-path algorithm. Finally, we demonstrate the applicability of our approach by means of a few illustrative examples and a case study from the probabilistic modeling field.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.34", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Navarro,", + "last_name": "Marcelo", + "institution": "University of Chile" + }, + { + "first_name": "Olmedo,", + "last_name": "Federico", + "institution": "University of Chile" + } + ], + "dblp_key": "conf/ecoop/NavarroO22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.35", + "title": "Prisma: A Tierless Language for Enforcing Contract-Client Protocols in Decentralized Applications (Extended Abstract)", + "abstract": "Decentralized applications (dApps) consist of smart contracts that run on blockchains and clients that model collaborating parties. dApps are used to model financial and legal business functionality. Today, contracts and clients are written as separate programs - in different programming languages - communicating via send and receive operations. This makes distributed program flow awkward to express and reason about, increasing the potential for mismatches in the client-contract interface, which can be exploited by malicious clients, potentially leading to huge financial losses. In this paper, we present Prisma, a language for tierless decentralized applications, where the contract and its clients are defined in one unit. Pairs of send and receive actions that \"belong together\" are encapsulated into a single direct-style operation, which is executed differently by sending and receiving parties. This enables expressing distributed program flow via standard control flow and renders mismatching communication impossible. We prove formally that our compiler preserves program behavior in presence of an attacker controlling the client code. We systematically compare Prisma with mainstream and advanced programming models for dApps and provide empirical evidence for its expressiveness and performance. The design space of dApp programming and other multi-party languages depends on one major choice: a local model versus a global model. In a local model, parties are defined in separate programs and their interactions are encoded via send and receive effects. In a global language, parties are defined within one shared program and interactions are encoded via combined send-and-receive operations with no effects visible to the outside world. The global model is followed by tierless [Christian Queinnec, 2000; Cooper et al., 2007; Choi and Chang, 2019; Fowler et al., 2019; Serrano et al., 2006; Serrano and Prunet, 2016; Radanne et al., 2016; Weisenburger et al., 2018] and choreographic [Kohei Honda et al., 2011; Fabrizio Montesi et al., 2014; Saverio Giallorenzo et al., 2020] languages. However, known approaches to dApp programming follow the local model, thus rely on explicitly specifying the client-contract interaction protocol. Moreover, the contract and clients are implemented in different languages, hence, developers have to master two technology stacks. The dominating approach in industry is Solidity [Mix, 2019] for the contract and JavaScript for clients. Solidity relies on expressing the protocol using assertions in the contract code, which are checked at run time [Solidity documentation - common patterns, 2020]. Failing to insert the correct assertions may give parties illegal access to monetary values to the detriment of others [Nikolić et al., 2018; Luu et al., 2016]. In research, contract languages [Ankush Das et al., 2019; Michael J. Coblenz, 2017; Franklin Schrans et al., 2018; Franklin Schrans et al., 2019; Michael J. Coblenz et al., 2019; Michael J. Coblenz et al., 2019; Reed Oei et al., 2020; Sam Blackshear et al., 2019] have been proposed that rely on advanced type systems such as session types, type states, and linear types. The global model has not been explored for dApp programming. This is unfortunate given the potential to get by with a standard typing discipline and to avoid intricacies and potential mismatches of a two-language stack. Our work fills this gap by proposing Prisma - the first language that features a global programming model for Ethereum dApps. While we focus on the Ethereum blockchain, we believe our techniques to be applicable to other smart contract platforms. Prisma enables interleaving contract and client logic within the same program and adopts a direct style (DS) notation for encoding send-and-receive operations (with our awaitCl language construct) akin to languages with async/await [Gavin M. Bierman et al., 2012; Scala async rfc]. DS addresses shortcomings with the currently dominant encoding of the protocol’s finite state machines (FSM) [Mix, 2019; Michael J. Coblenz, 2017; Franklin Schrans et al., 2018; Franklin Schrans et al., 2019; Michael J. Coblenz et al., 2019; Michael J. Coblenz et al., 2019]. We argue writing FSM style corresponds to a control-flow graph of basic blocks, which is low-level and more suited to be written by a compiler than by a human. With FSM style, the contract is a passive entity whose execution is driven by clients. whereas the DS encoding allows the contract to actively ask clients for input, fitting dApp execution where a dominant contract controls execution and diverts control to other parties when their input is needed. In the following Prisma snippet, the payout function is a function invoked by the contract when it is time to pay money to a client. In Prisma, variables, methods and classes are separated into two namespaces, one for the contract and one for the clients. The payout method is located on the contract via the annotation @co. The body of the method diverts the control to the client using awaitCl(...) { ... }, hence the contained readLine call is executed on the client. Note that no explicit send/receive operations are needed but the communication protocol is expressed through the program control flow. Only after the check client == toBePayed that the correct client replied, the current contact balance balance() is transferred to the client via transfer. @co def payout(toBePayed: Arr[Address]): Unit = { awaitCl(client => client == toBePayed) { readLine(\"Press enter for payout\") } toBePayed.transfer(balance()) } Overall, Prisma relieves the developer from the responsibility of correctly managing distributed, asynchronous program flows and the heterogeneous technology stack. Instead, the burden is put on the compiler, which distributes the program flow by means of selective continuation-passing-style (CPS) translation and defunctionalisation and inserts guards against malicious client interactions. We needed to develop a CPS translation for the code that runs on the Ethereum Virtual Machine (EVM) since the EVM has no built-in support for concurrency primitives which could be used for asynchronous communication. While CPS translations are well-known, we cannot use them out-of-the-box because the control flow is interwoven with distribution in our case. A CPS translation that does not take distribution into account would allow malicious clients to force the contract to deviate from the intended control flow by sending a spoofed continuation. Thus, it was imperative to prove correctness of our distributed CPS translation to ensure control-flow integrity of the contract.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.35", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "David", + "last_name": "Richter", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "David", + "last_name": "Kretzler", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "University of St.Gallen" + }, + { + "first_name": "Guido", + "last_name": "Salvaneschi", + "institution": "University of St.Gallen" + }, + { + "first_name": "Sebastian", + "last_name": "Faust", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technische Universität Darmstadt" + } + ], + "dblp_key": "conf/ecoop/RichterKWSFM22", + "venue": "ecoop", + "year": 2022 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2022.33", + "title": "Hinted Dictionaries: Efficient Functional Ordered Sets and Maps (Extended Abstract)", + "abstract": "Sets and maps are two essential collection types for programming used widely in data analytics [Shaikhha et al., 2022]. The underlying implementation for both are normally based on 1) hash tables or 2) ordered data structures. The former provides (average-case) constant-time lookup, insertion, and deletion operations, while the latter performs these operations in a logarithmic time. The trade-off between these two approaches has been heavily investigated in systems communities [Kim et al., 2009]. An important class of operations are those dealing with two collection types, such as set-set-union or the merge of two maps. One of the main advantages of hash-based implementations is a straightforward implementation for such operations with a linear computational complexity. However, naïvely using ordered dictionaries results in an implementation with a computational complexity of O(n log(n)). Motivating Example. The following C++ code computes the intersection of two sets, implemented by std::unordered_set, a hash-table-based set: std::unordered_set result; for(auto& e : set1) { if(set2.count(e)) result.emplace(e); } However, the same fact is not true for ordered data structures; changing the dictionary type to std::set, an ordered implementation, results in a program with O(n log(n)) computational complexity. This is because both the count (lookup) and emplace (insertion) methods have logarithmic computational complexity. As a partial remedy, the standard library of C++ provides an alternative insertion method that can take linear time, if used appropriately. The emplace_hint method takes a hint for the position that the element will be inserted. If the hint correctly specifies the insertion point, the computational complexity will be amortized to constant time. std::set result; auto hint = result.begin(); for(auto& e : set1) { if(set2.count(e)) hint = result.emplace_hint(hint, e); } However, the above implementation still suffers from an O(n log(n)) computational complexity, due to the logarithmic computational complexity of the lookup operation (count) of the second set. Thanks to the orderedness of the second set, one can observe that once an element is looked up, there is no longer any need to search its preceding elements at the next iterations. By leveraging this feature, we can provide a hinted lookup method with an amortized constant run-time. Hinted Data Structures. The following code, shows an alternative implementation for set intersection that uses such hinted lookup operations: hinted_set result; hinted_set::hint_t hint = result.begin(); for(auto& e : set1) { hinted_set::hint_t hint2 = set2.seek(e); if(hint2.found) hint = result.insert_hint(hint, e); set2.after(hint2); } The above hinted set data-structure enables faster insertion and lookup by providing a cursor through a hint object (of type hint_t). The seek method returns the hint object hint2 pointing to element e. Thanks to the invocation of set2.after(hint2), the irrelevant elements of set2 (which are smaller than e) are no longer considered in the next iterations. The expression hint2.found specifies if the element exists in set2 or not. Finally, if an element exists in the second set (specified by hint2.found), it is inserted into its correct position using insert_hint. The existing work on efficient ordered dictionaries can be divided into two categories. First, in the imperative world, there are C++ ordered dictionaries (e.g., std::map) with limited hinting capabilities only for insertion through emplace_hint, but not for deletion and lookup, as observed previously. Second, from the functional world, Adams' sets [Adams, 1993] provide efficient implementations for set-set operators. Functional languages such as Haskell have implemented ordered sets and maps based on them for more than twenty years [Straka, 2010]. Furthermore, it has been shown [Blelloch et al., 2016] that Adams' maps can be used to provide a parallel implementation for balanced trees such as AVL, Red-Black, Weight-Balanced, and Treaps. However, Adams' maps do not expose any hint-based operations to the programmer. At first glance, these two approaches seem completely irrelevant to each other. The key contribution of this paper is hinted dictionaries, an ordered data structure that unifies the techniques from both imperative and functional worlds. The essential building block of hinted dictionaries are hint objects, that enable faster operations (than the traditional O(log n) complexity) by maintaining a pointer into the data structure. The underlying representation for hinted dictionaries can be sorted arrays, unbalanced trees, and balanced trees by sharing the same interface. In our running example, alternative data structures can be provided by simply changing the type signature of the hinted set from hinted_set to another implementation, without modifying anything else.", + "date": "2022-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2022.33", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Edinburgh" + }, + { + "first_name": "Mahdi", + "last_name": "Ghorbani", + "institution": "University of Edinburgh" + }, + { + "first_name": "Hesam", + "last_name": "Shahrokhi", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/ecoop/ShaikhhaGS22", + "venue": "ecoop", + "year": 2022 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2023.json b/data/pl_conferences/ecoop/2023.json new file mode 100644 index 0000000..010c82e --- /dev/null +++ b/data/pl_conferences/ecoop/2023.json @@ -0,0 +1,1286 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.0", + "title": "Front Matter, Table of Contents, Preface, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Conference Organization", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ali,", + "last_name": "Karim", + "institution": "University of Alberta" + }, + { + "first_name": "Salvaneschi,", + "last_name": "Guido", + "institution": "University of St.Gallen" + } + ], + "dblp_key": "conf/ecoop/X23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.2", + "title": "Nested Pure Operation-Based CRDTs", + "abstract": "Modern distributed applications increasingly replicate data to guarantee high availability and optimal user experience. Conflict-free Replicated Data Types (CRDTs) are a family of data types specially designed for highly available systems that guarantee some form of eventual consistency. Designing CRDTs is very difficult because it requires devising designs that guarantee convergence in the presence of conflicting operations. Even though design patterns and structured frameworks have emerged to aid developers with this problem, they mostly focus on statically structured data; nesting and dynamically changing the structure of a CRDT remains to be an open issue. This paper explores support for nested CRDTs in a structured and systematic way. To this end, we define an approach for building nested CRDTs based on the work of pure operation-based CRDTs, resulting in nested pure operation-based CRDTs. We add constructs to control the nesting of CRDTs into a pure operation-based CRDT framework and show how several well-known CRDT designs can be defined in our framework. We provide an implementation of nested pure operation-based CRDTs as an extension to the Flec, an existing TypeScript-based framework for pure operation-based CRDTs. We validate our approach, 1) by implementing a portfolio of nested data structures, 2) by implementing and verifying our approach in the VeriFx language, and 3) by implementing a real-world application scenario and comparing its network usage against an implementation in the closest related work, Automerge. We show that the framework is general enough to nest well-known CRDT designs like maps and lists, and its performance in terms of network traffic is comparable to the state of the art.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bauwens,", + "last_name": "Jim", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Gonzalez Boix,", + "last_name": "Elisa", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/ecoop/BauwensB23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.11", + "title": "super-Charging Object-Oriented Programming Through Precise Typing of Open Recursion", + "abstract": "We present a new variation of object-oriented programming built around three simple and orthogonal constructs: classes for storing object state, interfaces for expressing object types, and mixins for reusing and overriding implementations. We show that the latter can be made uniquely expressive by leveraging a novel feature that we call precisely-typed open recursion. This features uses \"this\" and \"super\" annotations to express the requirements of any given partial method implementation on the types of respectively the current object and the inherited definitions. Crucially, the fact that mixins do not introduce types nor subtyping relationships means they can be composed even when the overriding and overridden methods have incomparable types. Together with advanced type inference and structural typing support provided by the MLscript programming language, we show that this enables an elegant and powerful solution to the Expression Problem.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Fan,", + "last_name": "Andong", + "institution": "Hong Kong University of Science and Technology" + }, + { + "first_name": "Parreaux,", + "last_name": "Lionel", + "institution": "Hong Kong University of Science and Technology" + } + ], + "dblp_key": "conf/ecoop/FanP23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.13", + "title": "Dynamic Determinacy Race Detection for Task-Parallel Programs with Promises", + "abstract": "Much of the past work on dynamic data-race and determinacy-race detection algorithms for task parallelism has focused on structured parallelism with fork-join constructs and, more recently, with future constructs. This paper addresses the problem of dynamic detection of data-races and determinacy-races in task-parallel programs with promises, which are more general than fork-join constructs and futures. The motivation for our work is twofold. First, promises have now become a mainstream synchronization construct, with their inclusion in multiple languages, including C++, JavaScript, and Java. Second, past work on dynamic data-race and determinacy-race detection for task-parallel programs does not apply to programs with promises, thereby identifying a vital need for this work. This paper makes multiple contributions. First, we introduce a featherweight programming language that captures the semantics of task-parallel programs with promises and provides a basis for formally defining determinacy using our semantics. This definition subsumes functional determinacy (same output for same input) and structural determinacy (same computation graph for same input). The main theoretical result shows that the absence of data races is sufficient to guarantee determinacy with both properties. We are unaware of any prior work that established this result for task-parallel programs with promises. Next, we introduce a new Dynamic Race Detector for Promises that we call DRDP. DRDP is the first known race detection algorithm that executes a task-parallel program sequentially without requiring the serial-projection property; this is a critical requirement since programs with promises do not satisfy the serial-projection property in general. Finally, the paper includes experimental results obtained from an implementation of DRDP. The results show that, with some important optimizations introduced in our work, the space and time overheads of DRDP are comparable to those of more restrictive race detection algorithms from past work. To the best of our knowledge, DRDP is the first determinacy race detector for task-parallel programs with promises.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jin,", + "last_name": "Feiyang", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Yu,", + "last_name": "Lechen", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Cogumbreiro,", + "last_name": "Tiago", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Shirako,", + "last_name": "Jun", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Sarkar,", + "last_name": "Vivek", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/ecoop/JinYCSS23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.4", + "title": "Hoogle⋆: Constants and λ-abstractions in Petri-net-based Synthesis using Symbolic Execution", + "abstract": "Type-directed component-based program synthesis is the task of automatically building a function with applications of available components and whose type matches a given goal type. Existing approaches to component-based synthesis, based on classical proof search, cannot deal with large sets of components. Recently, Hoogle+, a component-based synthesizer for Haskell, overcomes this issue by reducing the search problem to a Petri-net reachability problem. However, Hoogle+ cannot synthesize constants nor λ-abstractions, which limits the problems that it can solve. We present Hoogle⋆, an extension to Hoogle+ that brings constants and λ-abstractions to the search space, in two independent steps. First, we introduce the notion of wildcard component, a component that matches all types. This enables the algorithm to produce incomplete functions, i.e., functions containing occurrences of the wildcard component. Second, we complete those functions, by replacing each occurrence with constants or custom-defined λ-abstractions. We have chosen to find constants by means of an inference algorithm: we present a new unification algorithm based on symbolic execution that uses the input-output examples supplied by the user to compute substitutions for the occurrences of the wildcard. When compared to Hoogle+, Hoogle⋆ can solve more kinds of problems, especially problems that require the generation of constants and λ-abstractions, without performance degradation.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Botelho Guerra,", + "last_name": "Henrique", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Ferreira, João", + "last_name": "F.", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Costa Seco,", + "last_name": "João", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "conf/ecoop/Guerra0S23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.1", + "title": "Designing Asynchronous Multiparty Protocols with Crash-Stop Failures", + "abstract": "Session types provide a typing discipline for message-passing systems. However, most session type approaches assume an ideal world: one in which everything is reliable and without failures. Yet this is in stark contrast with distributed systems in the real world. To address this limitation, we introduce Teatrino, a code generation toolchain that utilises asynchronous multiparty session types (MPST) with crash-stop semantics to support failure handling protocols. We augment asynchronous MPST and processes with crash handling branches. Our approach requires no user-level syntax extensions for global types and features a formalisation of global semantics, which captures complex behaviours induced by crashed/crash handling processes. The sound and complete correspondence between global and local type semantics guarantees deadlock-freedom, protocol conformance, and liveness of typed processes in the presence of crashes. Our theory is implemented in the toolchain Teatrino, which provides correctness by construction. Teatrino extends the Scribble multiparty protocol language to generate protocol-conforming Scala code, using the Effpi concurrent programming library. We extend both Scribble and Effpi to support crash-stop behaviour. We demonstrate the feasibility of our methodology and evaluate Teatrino with examples extended from both session type and distributed systems literature.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Adam D.", + "last_name": "Barwell", + "institution": "" + }, + { + "first_name": "Ping", + "last_name": "Hou", + "institution": "" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "" + }, + { + "first_name": "Fangyi", + "last_name": "Zhou", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BarwellHY023", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.3", + "title": "Multi-Graded Featherweight Java", + "abstract": "Resource-aware type systems statically approximate not only the expected result type of a program, but also the way external resources are used, e.g., how many times the value of a variable is needed. We extend the type system of Featherweight Java to be resource-aware, parametrically on an arbitrary grade algebra modeling a specific usage of resources. We prove that this type system is sound with respect to a resource-aware version of reduction, that is, a well-typed program has a reduction sequence which does not get stuck due to resource consumption. Moreover, we show that the available grades can be heterogeneous, that is, obtained by combining grades of different kinds, via a minimal collection of homomorphisms from one kind to another. Finally, we show how grade algebras and homomorphisms can be specified as Java classes, so that grade annotations in types can be written in the language itself.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Riccardo", + "last_name": "Bianchini", + "institution": "" + }, + { + "first_name": "Francesco", + "last_name": "Dagnino", + "institution": "" + }, + { + "first_name": "Paola", + "last_name": "Giannini", + "institution": "" + }, + { + "first_name": "E.", + "last_name": "Zucca", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BianchiniDGZ23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.14", + "title": "Algebraic Replicated Data Types: Programming Secure Local-First Software", + "abstract": "This paper is about programming support for local-first applications that manage private data locally, but still synchronize data between multiple devices. Typical use cases are synchronizing settings and data, and collaboration between multiple users. Such applications must preserve the privacy and integrity of the user’s data without impeding or interrupting the user’s normal workflow - even when the device is offline or has a flaky network connection. From the programming perspective, availability along with privacy and security concerns pose significant challenges, for which developers have to learn and use specialized solutions such as conflict-free replicated data types (CRDTs) or APIs for centralized data stores. This work relieves developers from this complexity by enabling the direct and automatic use of algebraic data types - which developers already use to express the business logic of the application - for synchronization and collaboration. Moreover, we use this approach to provide end-to-end encryption and authentication between multiple replicas (using a shared secret), that is suitable for a coordination-free setting. Overall, our approach combines all the following advantages: it (1) allows developers to design custom data types, (2) provides data privacy and integrity when using untrusted intermediaries, (3) is coordination free, (4) guarantees eventual consistency by construction (i.e., independent of developer errors), (5) does not cause indefinite growth of metadata, (6) has sufficiently efficient implementations for the local-first setting.", + "date": "2020-03-31", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Hector", + "last_name": "Sanjuan", + "institution": "" + }, + { + "first_name": "Samuli", + "last_name": "Poyhtari", + "institution": "" + }, + { + "first_name": "Pedro", + "last_name": "Teixeira", + "institution": "" + }, + { + "first_name": "Ioannis", + "last_name": "Psaras", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/KuessnerMWM23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.10", + "title": "On Leveraging Tests to Infer Nullable Annotations", + "abstract": "Issues related to the dereferencing of null pointers are a pervasive and widely studied problem, and numerous static analyses have been proposed for this purpose. These are typically based on dataflow analysis, and take advantage of annotations indicating whether a type is nullable or not. The presence of such annotations can significantly improve the accuracy of null checkers. However, most code found in the wild is not annotated, and tools must fall back on default assumptions, leading to both false positives and false negatives. Manually annotating code is a laborious task and requires deep knowledge of how a program interacts with clients and components. We propose to infer nullable annotations from an analysis of existing test cases. For this purpose, we execute instrumented tests and capture nullable API interactions. Those recorded interactions are then refined (santitised and propagated) in order to improve their precision and recall. We evaluate our approach on seven projects from the spring ecosystems and two google projects which have been extensively manually annotated with thousands of @Nullable annotations. We find that our approach has a high precision, and can find around half of the existing @Nullable annotations. This suggests that the method proposed is useful to mechanise a significant part of the very labour-intensive annotation task.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dietrich,", + "last_name": "Jens", + "institution": "Victoria University of Wellington" + }, + { + "first_name": "Pearce, David", + "last_name": "J.", + "institution": "ConsenSys (United States)" + }, + { + "first_name": "Chandramohan,", + "last_name": "Mahin", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/00010C23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.5", + "title": "Modular Abstract Definitional Interpreters for WebAssembly", + "abstract": "Even though static analyses can improve performance and secure programs against vulnerabilities, no static whole-program analyses exist for WebAssembly (Wasm) to date. Part of the reason is that Wasm has many complex language concerns, and it is not obvious how to adopt existing analysis frameworks for these features. This paper explores how abstract definitional interpretation can be used to develop sophisticated analyses for Wasm and other complex languages efficiently. In particular, we show that the semantics of Wasm can be decomposed into 19 language-independent components that abstract different aspects of Wasm. We have written a highly configurable definitional interpreter for full Wasm 1.0 in 1628 LOC against these components. Analysis developers can instantiate this interpreter with different value and effect abstractions to obtain abstract definitional interpreters that compute inter-procedural control and data-flow information. This way, we develop the first whole-program dead code, constant propagation, and taint analyses for Wasm, each in less than 210 LOC. We evaluate our analyses on 1458 Wasm binaries collected by others in the wild. Our implementation is based on a novel framework for definitional abstract interpretation in Scala that eliminates scalability issues of prior work.", + "date": "2021-11-02", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Brandl,", + "last_name": "Katharina", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Erdweg,", + "last_name": "Sebastian", + "institution": "Johannes Gutenberg University Mainz" + }, + { + "first_name": "Keidel,", + "last_name": "Sven", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Hansen,", + "last_name": "Nils", + "institution": "Johannes Gutenberg University Mainz" + } + ], + "dblp_key": "conf/ecoop/BrandlEKH23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.6", + "title": "Dynamically Updatable Multiparty Session Protocols: Generating Concurrent Go Code from Unbounded Protocols", + "abstract": "Multiparty Session Types (MPST) are a typing disciplines that guarantee the absence of deadlocks and communication errors in concurrent and distributed systems. However, existing MPST frameworks do not support protocols with dynamic unbounded participants, and cannot express many common programming patterns that require the introduction of new participants into a protocol. This poses a barrier for the adoption of MPST in languages that favour the creation of new participants (processes, lightweight threads, etc) that communicate via message passing, such as Go or Erlang. This paper proposes Dynamically Updatable Multiparty Session Protocols, a new MPST theory (DMst) that supports protocols with an unbounded number of fresh participants, whose communication topologies are dynamically updatable. We prove that DMst guarantees deadlock-freedom and liveness. We implement a toolchain, GoScr (Go-Scribble), which generates Go implementations from DMst, ensuring by construction, that the different participants will only perform I/O actions that comply with a given protocol specification. We evaluate our toolchain by (1) implementing representative parallel and concurrent algorithms from existing benchmarks, textbooks and literature; (2) showing that GoScr does not introduce significant overheads compared to a naive implementation, for computationally expensive benchmarks; and (3) building three realistic protocols (dynamic task delegation, recursive Domain Name System, and a parallel Min-Max strategy) in GoScr that could not be represented with previous theories of session types.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Castro-Perez,", + "last_name": "David", + "institution": "University of Kent" + }, + { + "first_name": "Yoshida,", + "last_name": "Nobuko", + "institution": "University of Oxford" + } + ], + "dblp_key": "conf/ecoop/Castro-PerezY23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.8", + "title": "Wiring Circuits Is Easy as {0, 1, ω}, or Is It", + "abstract": "Quantitative Type-Systems support fine-grained reasoning about term usage in our programming languages. Hardware Design Languages are another style of language in which quantitative typing would be beneficial. When wiring components together we must ensure that there are no unused ports, dangling wires, or accidental fan-ins and fan-outs. Although many wire usage checks are detectable using static analysis tools, such as Verilator, quantitative typing supports making these extrinsic checks an intrinsic aspect of the type-system. With quantitative typing of bound terms, we can provide design-time checks that all wires and ports have been used, and ensure that all wiring decisions are explicitly made, and are neither implicit nor accidental. We showcase the use of quantitative types in hardware design languages by detailing how we can retrofit quantitative types onto SystemVerilog netlists, and the impact that such a quantitative type-system has when creating designs. Netlists are gate-level descriptions of hardware that are produced as the result of synthesis, and it is from these netlists that hardware is generated (fabless or fabbed). First, we present a simple structural type-system for a featherweight version of SystemVerilog netlists that demonstrates how we can type netlists using standard structural techniques, and what it means for netlists to be type-safe but still lead to ill-wired designs. We then detail how to retrofit the language with quantitative types, make the type-system sub-structural, and detail how our new type-safety result ensures that wires and ports are used once. Our ideas have been proven both practically and formally by realising our work in Idris2, through which we can construct a verified language implementation that can type-check existing designs. From this work we can look to promote quantitative typing back up the synthesis chain to a more comprehensive hardware description language; and to help develop new and better hardware description languages with quantitative typing.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "de Muijnck-Hughes,", + "last_name": "Jan", + "institution": "University of Glasgow" + }, + { + "first_name": "Vanderbauwhede,", + "last_name": "Wim", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/ecoop/Muijnck-HughesV23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.7", + "title": "Modular Compilation for Higher-Order Functional Choreographies", + "abstract": "Choreographic programming is a paradigm for concurrent and distributed software, whereby descriptions of the intended communications (choreographies) are automatically compiled into distributed code with strong safety and liveness properties (e.g., deadlock-freedom). Recent efforts tried to combine the theories of choreographic programming and higher-order functional programming, in order to integrate the benefits of the former with the modularity of the latter. However, they do not offer a satisfactory theory of compilation compared to the literature, because of important syntactic and semantic shortcomings: compilation is not modular (editing a part might require recompiling everything) and the generated code can perform unexpected global synchronisations. In this paper, we find that these shortcomings are not mere coincidences. Rather, they stem from genuine new challenges posed by the integration of choreographies and functions: knowing which participants are involved in a choreography becomes nontrivial, and divergence in applications requires rethinking how to prove the semantic correctness of compilation. We present a novel theory of compilation for functional choreographies that overcomes these challenges, based on types and a careful design of the semantics of choreographies and distributed code. The result: a modular notion of compilation, which produces code that is deadlock-free and correct (it operationally corresponds to its source choreography).", + "date": "2021-11-05", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Luı́s", + "last_name": "Cruz-Filipe", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Eva", + "last_name": "Graversen", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Lovro", + "last_name": "Lugović", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Fabrizio", + "last_name": "Montesi", + "institution": "University of Southern Denmark" + }, + { + "first_name": "Marco", + "last_name": "Peressotti", + "institution": "University of Southern Denmark" + } + ], + "dblp_key": "conf/ecoop/Cruz-FilipeGLMP23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.12", + "title": "LoRe: A Programming Model for Verifiably Safe Local-First Software (Extended Abstract)", + "abstract": "Local-first software manages and processes private data locally while still enabling collaboration between multiple parties connected via partially unreliable networks. Such software typically involves interactions with users and the execution environment (the outside world). The unpredictability of such interactions paired with their decentralized nature make reasoning about the correctness of local-first software a challenging endeavor. Yet, existing solutions to develop local-first software do not provide support for automated safety guarantees and instead expect developers to reason about concurrent interactions in an environment with unreliable network conditions. We propose LoRe, a programming model and compiler that automatically verifies developer-supplied safety properties for local-first applications. LoRe combines the declarative data flow of reactive programming with static analysis and verification techniques to precisely determine concurrent interactions that violate safety invariants and to selectively employ strong consistency through coordination where required. We propose a formalized proof principle and demonstrate how to automate the process in a prototype implementation that outputs verified executable code. Our evaluation shows that LoRe simplifies the development of safe local-first software when compared to state-of-the-art approaches and that verification times are acceptable.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Julian", + "last_name": "Haas", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Ragnar", + "last_name": "Mogk", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Elena", + "last_name": "Yanakieva", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Annette", + "last_name": "Bieniusa", + "institution": "University of Kaiserslautern" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "Technische Universität Darmstadt" + } + ], + "dblp_key": "conf/ecoop/HaasMYBM23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.9", + "title": "VeriFx: Correct Replicated Data Types for the Masses", + "abstract": "Distributed systems adopt weak consistency to ensure high availability and low latency, but state convergence is hard to guarantee due to conflicts. Experts carefully design replicated data types (RDTs) that resemble sequential data types and embed conflict resolution mechanisms that ensure convergence. Designing RDTs is challenging as their correctness depends on subtleties such as the ordering of concurrent operations. Currently, researchers manually verify RDTs, either by paper proofs or using proof assistants. Unfortunately, paper proofs are subject to reasoning flaws and mechanized proofs verify a formalization instead of a real-world implementation. Furthermore, writing mechanized proofs is reserved for verification experts and is extremely time-consuming. To simplify the design, implementation, and verification of RDTs, we propose VeriFx, a specialized programming language for RDTs with automated proof capabilities. VeriFx lets programmers implement RDTs atop functional collections and express correctness properties that are verified automatically. Verified RDTs can be transpiled to mainstream languages (currently Scala and JavaScript). VeriFx provides libraries for implementing and verifying Conflict-free Replicated Data Types (CRDTs) and Operational Transformation (OT) functions. These libraries implement the general execution model of those approaches and define their correctness properties. We use the libraries to implement and verify an extensive portfolio of 51 CRDTs, 16 of which are used in industrial databases, and reproduce a study on the correctness of OT functions.", + "date": "2022-07-06", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Kevin De", + "last_name": "Porre", + "institution": "" + }, + { + "first_name": "Carla", + "last_name": "Ferreira", + "institution": "" + }, + { + "first_name": "Elisa Gonzalez", + "last_name": "Boix", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/Porre0B23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.16", + "title": "Constraint Based Compiler Optimization for Energy Harvesting Applications", + "abstract": "We propose a method for optimizing the energy efficiency of software code running on small computing devices in the Internet of Things (IoT) that are powered exclusively by electricity harvested from ambient energy in the environment. Due to the weak and unstable nature of the energy source, it is challenging for developers to manually optimize the software code to deal with mismatch between the intermittent power supply and the computation demand. Our method overcomes the challenge by using a combination of three techniques. First, we use static program analysis to automatically identify opportunities for precomputation, i.e., computation that may be performed ahead of time as opposed to just in time. Second, we optimize the precomputation policy, i.e., a way to split and reorder steps of a computation task in the original software to match the intermittent power supply while satisfying a variety of system requirements; this is accomplished by formulating energy optimization as a constraint satisfiability problem and then solving the problem using an off-the-shelf SMT solver. Third, we use a state-of-the-art compiler platform (LLVM) to automate the program transformation to ensure that the optimized software code is correct by construction. We have evaluated our method on a large number of benchmark programs, which are C programs implementing secure communication protocols that are popular for energy-harvesting IoT devices. Our experimental results show that the method is efficient in optimizing all benchmark programs. Furthermore, the optimized programs significantly outperform the original programs in terms of energy efficiency and latency, and the overall improvement ranges from 2.3X to 36.7X.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Li,", + "last_name": "Yannan", + "institution": "University of Southern California" + }, + { + "first_name": "Wang,", + "last_name": "Chao", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/ecoop/LiW23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.17", + "title": "Restrictable Variants: A Simple and Practical Alternative to Extensible Variants", + "abstract": "We propose restrictable variants as a simple and practical alternative to extensible variants. Restrictable variants combine nominal and structural typing: a restrictable variant is an algebraic data type indexed by a type-level set formula that captures its set of active labels. We introduce new pattern-matching constructs that allows programmers to write functions that only match on a subset of variants, i.e., pattern-matches may be non-exhaustive. We then present a type system for restrictable variants which ensures that such non-exhaustive matches cannot get stuck at runtime. An essential feature of restrictable variants is that the type system can capture structure-preserving transformations: specifically the introduction and elimination of variants. This property is important for writing reusable functions, yet many row-based extensible variant systems lack it. In this paper, we present a calculus with restrictable variants, two partial pattern-matching constructs, and a type system that ensures progress and preservation. The type system extends Hindley-Milner with restrictable variants and supports type inference with an extension of Algorithm W with Boolean unification. We implement restrictable variants as an extension of the Flix programming language and conduct a few case studies to illustrate their practical usefulness.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Jonathan Lindegaard", + "last_name": "Starup", + "institution": "Aarhus University" + }, + { + "first_name": "Matthew", + "last_name": "Lutze", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/ecoop/MadsenSL23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.18", + "title": "Programming with Purity Reflection: Peaceful Coexistence of Effects, Laziness, and Parallelism", + "abstract": "We present purity reflection, a programming language feature that enables higher-order functions to inspect the purity of their function arguments and to vary their behavior based on this information. The upshot is that operations on data structures can selectively use lazy and/or parallel evaluation while ensuring that side effects are never lost or re-ordered. The technique builds on a recent Hindley-Milner style type and effect system based on Boolean unification which supports both effect polymorphism and complete type inference. We illustrate that avoiding the so-called 'poisoning problem' is crucial to support purity reflection. We propose several new data structures that use purity reflection to switch between eager and lazy, sequential and parallel evaluation. We propose a DelayList, which is maximally lazy but switches to eager evaluation for impure operations. We also propose a DelayMap which is maximally lazy in its values, but also exploits eager and parallel evaluation. We implement purity reflection as an extension of the Flix programming language. We present a new effect-aware form of monomorphization that eliminates purity reflection at compile-time. And finally, we evaluate the cost of this new monomorphization on compilation time and on code size, and determine that it is minimal.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Jaco van de", + "last_name": "Pol", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/ecoop/MadsenP23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.21", + "title": "Automata Learning with an Incomplete Teacher", + "abstract": "The preceding decade has seen significant interest in use of active learning to build models of programs and protocols. But existing algorithms assume the existence of an idealized oracle - a so-called Minimally Adequate Teacher (MAT) - that cannot be fully realized in practice and so is usually approximated with testing. This work proposes a new framework for active learning based on an incomplete teacher. This new formulation, called iMAT, neatly handles scenarios in which the teacher has access to only a finite number of tests or otherwise has gaps in its knowledge. We adapt Angluin’s L^⋆ algorithm for learning finite automata to incomplete teachers and we build a prototype implementation in OCaml that uses an SMT solver to help fill in information not supplied by the teacher. We demonstrate the behavior of our iMAT prototype on a variety of learning problems from a standard benchmark suite.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Moeller,", + "last_name": "Mark", + "institution": "Cornell University" + }, + { + "first_name": "Wiener,", + "last_name": "Thomas", + "institution": "Cornell University" + }, + { + "first_name": "Solko-Breslin,", + "last_name": "Alaia", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Koch,", + "last_name": "Caleb", + "institution": "Stanford University" + }, + { + "first_name": "Foster,", + "last_name": "Nate", + "institution": "Cornell University" + }, + { + "first_name": "Silva,", + "last_name": "Alexandra", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/ecoop/MoellerWSKF023", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.22", + "title": "Modular Verification of State-Based CRDTs in Separation Logic", + "abstract": "Arguments about correctness of a concurrent data structure are typically carried out by using the notion of linearizability and specifying the linearization points of the data structure's procedures. Such arguments are often cumbersome as the linearization points' position in time can be dynamic (depend on the interference, run-time values and events from the past, or even future), non-local (appear in procedures other than the one considered), and whose position in the execution trace may only be determined after the considered procedure has already terminated. In this paper we propose a new method, based on a separation-style logic, for reasoning about concurrent objects with such linearization points. We embrace the dynamic nature of linearization points, and encode it as part of the data structure's auxiliary state, so that it can be dynamically modified in place by auxiliary code, as needed when some appropriate run-time event occurs. We name the idea linking-in-time, because it reduces temporal reasoning to spatial reasoning. For example, modifying a temporal position of a linearization point can be modeled similarly to a pointer update in separation logic. Furthermore, the auxiliary state provides a convenient way to concisely express the properties essential for reasoning about clients of such concurrent objects. We illustrate the method by verifying (mechanically in Coq) an intricate optimal snapshot algorithm due to Jayanti, as well as some clients.", + "date": "2016-04-27", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Delbianco, Germán", + "last_name": "Andrés", + "institution": "" + }, + { + "first_name": "Sergey,", + "last_name": "Ilya", + "institution": "" + }, + { + "first_name": "Nanevski,", + "last_name": "Aleksandar", + "institution": "" + }, + { + "first_name": "Banerjee,", + "last_name": "Anindya", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/NietoDGTB23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.23", + "title": "Information Flow Analysis for Detecting Non-Determinism in Blockchain", + "abstract": "A mandatory feature for blockchain software, such as smart contracts and decentralized applications, is determinism. In fact, non-deterministic behaviors do not allow blockchain nodes to reach one common consensual state or a deterministic response, which causes the blockchain to be forked, stopped, or to deny services. While domain-specific languages are deterministic by design, general-purpose languages widely used for the development of smart contracts such as Go, provide many sources of non-determinism. However, not all non-deterministic behaviours are critical. In fact, only those that affect the state or the response of the blockchain can cause problems, as other uses (for example, logging) are only observable by the node that executes the application and not by others. Therefore, some frameworks for blockchains, such as Hyperledger Fabric or Cosmos SDK, do not prohibit the use of non-deterministic constructs but leave the programmer the burden of ensuring that the blockchain application is deterministic. In this paper, we present a flow-based approach to detect non-deterministic vulnerabilities which could compromise the blockchain. The analysis is implemented in GoLiSA, a semantics-based static analyzer for Go applications. Our experimental results show that GoLiSA is able to detect all vulnerabilities related to non-determinism on a significant set of applications, with better results than other open-source analyzers for blockchain software written in Go.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Olivieri,", + "last_name": "Luca", + "institution": "University of Verona" + }, + { + "first_name": "Negrini,", + "last_name": "Luca", + "institution": "Consorzio per la Ricerca Sanitaria" + }, + { + "first_name": "Arceri,", + "last_name": "Vincenzo", + "institution": "University of Parma" + }, + { + "first_name": "Tagliaferro,", + "last_name": "Fabio", + "institution": "University of Florence" + }, + { + "first_name": "Ferrara,", + "last_name": "Pietro", + "institution": "Ca' Foscari University of Venice" + }, + { + "first_name": "Cortesi,", + "last_name": "Agostino", + "institution": "Ca' Foscari University of Venice" + }, + { + "first_name": "Spoto,", + "last_name": "Fausto", + "institution": "University of Verona" + } + ], + "dblp_key": "conf/ecoop/OlivieriNAT0CS23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.19", + "title": "Exact Separation Logic: Towards Bridging the Gap Between Verification and Bug-Finding", + "abstract": "Over-approximating (OX) program logics, such as separation logic (SL), are used for verifying properties of heap-manipulating programs: all terminating behaviour is characterised, but established results and errors need not be reachable. OX function specifications are thus incompatible with true bug-finding supported by symbolic execution tools such as Pulse and Pulse-X. In contrast, under-approximating (UX) program logics, such as incorrectness separation logic, are used to find true results and bugs: established results and errors are reachable, but there is no mechanism for understanding if all terminating behaviour has been characterised. \\nWe introduce exact separation logic (ESL), which provides fully-verified function specifications compatible with both OX verification and UX true bug-funding: all terminating behaviour is characterised and all established results and errors are reachable. We prove soundness for ESL with mutually recursive functions, demonstrating, for the first time, function compositionality for a UX logic. We show that UX program logics require subtle definitions of internal and external function specifications compared with the familiar definitions of OX logics. We investigate the expressivity of ESL and, for the first time, explore the role of abstraction in UX reasoning by verifying abstract ESL specifications of various data-structure algorithms. In doing so, we highlight the difference between abstraction (hiding information) and over-approximation (losing information). Our findings demonstrate that abstraction cannot be used as freely in UX logics as in OX logics, but also that it should be feasible to use ESL to provide tractable function specifications for self-contained, critical code, which would then be used for both verification and true bug-finding.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Petar", + "last_name": "Maksimović", + "institution": "" + }, + { + "first_name": "Caroline", + "last_name": "Cronjäger", + "institution": "" + }, + { + "first_name": "Andreas", + "last_name": "Lööw", + "institution": "" + }, + { + "first_name": "Julian", + "last_name": "Sutherland", + "institution": "" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/MaksimovicCLSG23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.20", + "title": "Morpheus: Automated Safety Verification of Data-Dependent Parser Combinator Programs", + "abstract": "Parser combinators are a well-known mechanism used for the compositional construction of parsers, and have shown to be particularly useful in writing parsers for rich grammars with data-dependencies and global state. Verifying applications written using them, however, has proven to be challenging in large part because of the inherently effectful nature of the parsers being composed and the difficulty in reasoning about the arbitrarily rich data-dependent semantic actions that can be associated with parsing actions. In this paper, we address these challenges by defining a parser combinator framework called Morpheus equipped with abstractions for defining composable effects tailored for parsing and semantic actions, and a rich specification language used to define safety properties over the constituent parsers comprising a program. Even though its abstractions yield many of the same expressivity benefits as other parser combinator systems, Morpheus is carefully engineered to yield a substantially more tractable automated verification pathway. We demonstrate its utility in verifying a number of realistic, challenging parsing applications, including several cases that involve non-trivial data-dependent relations.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Mishra,", + "last_name": "Ashish", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Jagannathan,", + "last_name": "Suresh", + "institution": "Purdue University West Lafayette" + } + ], + "dblp_key": "conf/ecoop/MishraJ23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.29", + "title": "Semantics for Noninterference with Interaction Trees", + "abstract": "Noninterference is the strong information-security property that a program does not leak secrets through publicly-visible behavior. In the presence of effects such as nontermination, state, and exceptions, reasoning about noninterference quickly becomes subtle. We advocate using interaction trees (ITrees) to provide compositional mechanized proofs of noninterference for multi-language, effectful, nonterminating programs, while retaining executability of the semantics. We develop important foundations for security analysis with ITrees: two indistinguishability relations, leading to two standard notions of noninterference with adversaries of different strength, along with metatheory libraries for reasoning about each. We demonstrate the utility of our results using a simple imperative language with embedded assembly, along with a compiler into that assembly language.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.29", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Silver,", + "last_name": "Lucas", + "institution": "University of Pennsylvania" + }, + { + "first_name": "He,", + "last_name": "Paul", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Cecchetti,", + "last_name": "Ethan", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Hirsch, Andrew", + "last_name": "K.", + "institution": "University at Buffalo, State University of New York" + }, + { + "first_name": "Zdancewic,", + "last_name": "Steve", + "institution": "University of Pennsylvania" + } + ], + "dblp_key": "conf/ecoop/SilverHCHZ23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.27", + "title": "An Efficient Vectorized Hash Table for Batch Computations", + "abstract": "In recent years, the increasing demand for high-performance analytics on big data has led the research on batch hash tables. It is shown that this type of hash table can benefit from the cache locality and multi-threading more than ordinary hash tables. Moreover, the batch design for hash tables is amenable to using advanced features of modern processors such as prefetching and SIMD vectorization. While state-of-the-art research and open-source projects on batch hash tables made efforts to propose improved designs by better usage of mentioned hardware features, their approaches still do not fully exploit the existing opportunities for performance improvements. Furthermore, there is a gap for a high-level batch API of such hash tables for wider adoption of these high-performance data structures. In this paper, we present Vec-HT, a parallel, SIMD-vectorized, and prefetching-enabled hash table for fast batch processing. To allow developers to fully take advantage of its performance, we recommend a high-level batch API design. Our experimental results show the superiority and competitiveness of this approach in comparison with the alternative implementations and state-of-the-art for the data-intensive workloads of relational join processing, set operations, and sparse vector processing.", + "date": "2023-07-11", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.27", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Shahrokhi,", + "last_name": "Hesam", + "institution": "University of Edinburgh" + }, + { + "first_name": "Shaikhha, Amir; id_orcid", + "last_name": "0000-0002-9062-759X", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/ShahrokhiS23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.28", + "title": "Hinted Dictionaries: Efficient Functional Ordered Sets and Maps", + "abstract": "This paper introduces hinted dictionaries for expressing efficient ordered sets and maps functionally. As opposed to the traditional ordered dictionaries with logarithmic operations, hinted dictionaries can achieve better performance by using cursor-like objects referred to as hints. Hinted dictionaries unify the interfaces of imperative ordered dictionaries (e.g., C++ maps) and functional ones (e.g., Adams' sets). We show that such dictionaries can use sorted arrays, unbalanced trees, and balanced trees as their underlying representations. Throughout the paper, we use Scala to present the different components of hinted dictionaries. We also provide a C++ implementation to evaluate the effectiveness of hinted dictionaries. Hinted dictionaries provide superior performance for set-set operations in comparison with the standard library of C++. Also, they show a competitive performance in comparison with the SciPy library for sparse vector operations.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.28", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Shaikhha,", + "last_name": "Amir", + "institution": "University of Edinburgh" + }, + { + "first_name": "Ghorbani,", + "last_name": "Mahdi", + "institution": "University of Edinburgh" + }, + { + "first_name": "Shahrokhi,", + "last_name": "Hesam", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/ecoop/ShaikhhaGS23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.26", + "title": "Sinatra: Stateful Instantaneous Updates for Commercial Browsers Through Multi-Version eXecution", + "abstract": "Browsers are the main way in which most users experience the internet, which makes them a prime target for malicious entities. The best defense for the common user is to keep their browser always up-to-date, installing updates as soon as they are available. Unfortunately, updating a browser is disruptive as it results in loss of user state. Even though modern browsers reopen all pages (tabs) after an update to minimize inconvenience, this approach still loses all local user state in each page (e.g., contents of unsubmitted forms, including associated JavaScript validation state) and assumes that pages can be refreshed and result in the same contents. We believe this is an important barrier that keeps users from updating their browsers as frequently as possible. In this paper, we present the design, implementation, and evaluation of Sinatra, which supports instantaneous browser updates that do not result in any data loss through a novel Multi-Version eXecution (MVX) approach for JavaScript programs, combined with a sophisticated proxy. Sinatra works in pure JavaScript, does not require any browser support, thus works on closed-source browsers, and requires trivial changes to each target page, that can be automated. First, Sinatra captures all the non-determinism available to a JavaScript program (e.g., event handlers executed, expired timers, invocations of Math.random). Our evaluation shows that Sinatra requires 6MB to store such events, and the memory grows at a modest rate of 253KB/s as the user keeps interacting with each page. When an update becomes available, Sinatra transfer the state by re-executing the same set of non-deterministic events on the new browser. During this time, which can be as long as 1.5 seconds, Sinatra uses MVX to allow the user to keep interacting with the old browser. Finally, Sinatra changes the roles in less than 10ms, and the user starts interacting with the new browser, effectively performing a browser update with zero downtime and no loss of state.", + "date": "2016-10-07", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.26", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Rumsevicius,", + "last_name": "Ugnius", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Venkateshwaran,", + "last_name": "Siddhanth", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Kidane,", + "last_name": "Ellen", + "institution": "University of Illinois Chicago" + }, + { + "first_name": "Pina,", + "last_name": "Luís", + "institution": "University of Illinois Chicago" + } + ], + "dblp_key": "conf/ecoop/RumseviciusVKP23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.30", + "title": "Interaction Tree Specifications: A Framework for Specifying Recursive, Effectful Computations That Supports Auto-Active Verification", + "abstract": "This paper presents a specification framework for monadic, recursive, interactive programs that supports auto-active verification, an approach that combines user-provided guidance with automatic verification techniques. This verification tool is designed to have the flexibility of a manual approach to verification along with the usability benefits of automatic approaches. We accomplish this by augmenting Interaction Trees, a Coq datastructure for representing effectful computations, with logical quantifier events. We show that this yields a language of specifications that are easy to understand, automatable, and are powerful enough to handle properties that involve non-termination. Our framework is implemented as a library in Coq. We demonstrate the effectiveness of this framework by verifying real, low-level code.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.30", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Silver,", + "last_name": "Lucas", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Westbrook,", + "last_name": "Eddy", + "institution": "Galois (United States)" + }, + { + "first_name": "Yacavone,", + "last_name": "Matthew", + "institution": "Galois (United States)" + }, + { + "first_name": "Scott,", + "last_name": "Ryan", + "institution": "Galois (United States)" + } + ], + "dblp_key": "conf/ecoop/SilverWYS23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.25", + "title": "A Direct-Style Effect Notation for Sequential and Parallel Programs", + "abstract": "Modeling sequential and parallel composition of effectful computations has been investigated in a variety of languages for a long time. In particular, the popular do-notation provides a lightweight effect embedding for any instance of a monad. Idiom bracket notation, on the other hand, provides an embedding for applicatives. First, while monads force effects to be executed sequentially, ignoring potential for parallelism, applicatives do not support sequential effects. Composing sequential with parallel effects remains an open problem. This is even more of an issue as real programs consist of a combination of both sequential and parallel segments. Second, common notations do not support invoking effects in direct-style, instead forcing a rigid structure upon the code. In this paper, we propose a mixed applicative/monadic notation that retains parallelism where possible, but allows sequentiality where necessary. We leverage a direct-style notation where sequentiality or parallelism is derived from the structure of the code. We provide a mechanisation of our effectful language in Coq and prove that our compilation approach retains the parallelism of the source program.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.25", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "David H.", + "last_name": "Richter", + "institution": "" + }, + { + "first_name": "Timon", + "last_name": "Böhler", + "institution": "" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/RichterBWM23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.31", + "title": "Breaking the Negative Cycle: Exploring the Design Space of Stratification for First-Class Datalog Constraints", + "abstract": "The λ_Dat calculus brings together the power of functional and declarative logic programming in one language. In λ_Dat, Datalog constraints are first-class values that can be constructed, passed around as arguments, returned, composed with other constraints, and solved. A significant part of the expressive power of Datalog comes from the use of negation. Stratified negation is a particularly simple and practical form of negation accessible to ordinary programmers. Stratification requires that Datalog programs must not use recursion through negation. For a Datalog program, this requirement is straightforward to check, but for a λ_Dat program, it is not so simple: A λ_Dat program constructs, composes, and solves Datalog programs at runtime. Hence stratification cannot readily be determined at compile-time. In this paper, we explore the design space of stratification for λ_Dat. We investigate strategies to ensure, at compile-time, that programs constructed at runtime are guaranteed to be stratified, and we argue that previous design choices in the Flix programming language have been suboptimal.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.31", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jonathan Lindegaard", + "last_name": "Starup", + "institution": "Aarhus University" + }, + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/ecoop/StarupML23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.32", + "title": "Asynchronous Multiparty Session Type Implementability is Decidable - Lessons Learned from Message Sequence Charts", + "abstract": "Multiparty session types (MSTs) provide efficient means to specify and verify asynchronous message-passing systems. For a global type, which specifies all interactions between roles in a system, the implementability problem asks whether there are local specifications for all roles such that their composition is deadlock-free and generates precisely the specified executions. Decidability of the implementability problem is an open question. We answer it positively for global types with sender-driven choice, which allow a sender to send to different receivers upon branching and a receiver to receive from different senders. To achieve this, we generalise results from the domain of high-level message sequence charts (HMSCs). This connection also allows us to comprehensively investigate how HMSC techniques can be adapted to the MST setting. This comprises techniques to make the problem algorithmically more tractable as well as a variant of implementability that may open new design space for MSTs. Inspired by potential performance benefits, we introduce a generalisation of the implementability problem that we, unfortunately, prove to be undecidable.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.32", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Felix", + "last_name": "Stutz", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "conf/ecoop/Stutz23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.33", + "title": "ConDRust: Scalable Deterministic Concurrency from Verifiable Rust Programs", + "abstract": "SAT/SMT-solvers and model checkers automate formal verification of sequential programs. Formal reasoning about scalable concurrent programs is still manual and requires expert knowledge. But scalability is a fundamental requirement of current and future programs. Sequential imperative programs compose statements, function/method calls and control flow constructs. Concurrent programming models provide constructs for concurrent composition. Concurrency abstractions such as threads and synchronization primitives such as locks compose the individual parts of a concurrent program that are meant to execute in parallel. We propose to rather compose the individual parts again using sequential composition and compile this sequential composition into a concurrent one. The developer can use existing tools to formally verify the sequential program while the translated concurrent program provides the dearly requested scalability. Following this insight, we present ConDRust, a new programming model and compiler for Rust programs. The ConDRust compiler translates sequential composition into a concurrent composition based on threads and message-passing channels. During compilation, the compiler preserves the semantics of the sequential program along with much desired properties such as determinism. Our evaluation shows that our ConDRust compiler generates concurrent deterministic code that can outperform even non-deterministic programs by up to a factor of three for irregular algorithms that are particularly hard to parallelize.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.33", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Suchert,", + "last_name": "Felix", + "institution": "Technische Universität Dresden" + }, + { + "first_name": "Zeidler,", + "last_name": "Lisza", + "institution": "Barkhausen Institut" + }, + { + "first_name": "Castrillon,", + "last_name": "Jeronimo", + "institution": "Technische Universität Dresden" + }, + { + "first_name": "Ertel,", + "last_name": "Sebastian", + "institution": "Barkhausen Institut" + } + ], + "dblp_key": "conf/ecoop/SuchertZCE23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.34", + "title": "Dependent Merges and First-Class Environments", + "abstract": "In most programming languages a (runtime) environment stores all the definitions that are available to programmers. Typically, environments are a meta-level notion, used only conceptually or internally in the implementation of programming languages. Only a few programming languages allow environments to be first-class values, which can be manipulated directly in programs. Although there is some research on calculi with first-class environments for statically typed programming languages, these calculi typically have significant restrictions. In this paper we propose a statically typed calculus, called 𝖤_i, with first-class environments. The main novelty of the 𝖤_i calculus is its support for first-class environments, together with an expressive set of operators that manipulate them. Such operators include: reification of the current environment, environment concatenation, environment restriction, and reflection mechanisms for running computations under a given environment. In 𝖤_i any type can act as a context (i.e. an environment type) and contexts are simply types. Furthermore, because 𝖤_i supports subtyping, there is a natural notion of context subtyping. There are two important ideas in 𝖤_i that generalize and are inspired by existing notions in the literature. The 𝖤_i calculus borrows disjoint intersection types and a merge operator, used in 𝖤_i to model contexts and environments, from the λ_i calculus. However, unlike the merges in λ_i, the merges in 𝖤_i can depend on previous components of a merge. From implicit calculi, the 𝖤_i calculus borrows the notion of a query, which allows type-based lookups on environments. In particular, queries are key to the ability of 𝖤_i to reify the current environment, or some parts of it. We prove the determinism and type soundness of 𝖤_i, and show that 𝖤_i can encode all well-typed λ_i programs.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.34", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Tan,", + "last_name": "Jinhao", + "institution": "University of Hong Kong" + }, + { + "first_name": "Oliveira, Bruno C. d.", + "last_name": "S.", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "conf/ecoop/TanO23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.40", + "title": "On Using VeriFast, VerCors, Plural, and KeY to Check Object Usage (Experience Paper)", + "abstract": "Marco Giunti: Partially supported by Dstl, reference: ACC2028868.\\n\\nPublisher Copyright:\\n© João Mota Marco Giunti and António Ravara;", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.40", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Mota,", + "last_name": "João", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Giunti,", + "last_name": "Marco", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Ravara,", + "last_name": "António", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "conf/ecoop/MotaGR23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.35", + "title": "Synthesis-Aided Crash Consistency for Storage Systems", + "abstract": "Reliable storage systems must be crash consistent - guaranteed to recover to a consistent state after a crash. Crash consistency is non-trivial as it requires maintaining complex invariants about persistent data structures in the presence of caching, reordering, and system failures. Current programming models offer little support for implementing crash consistency, forcing storage system developers to roll their own consistency mechanisms. Bugs in these mechanisms can lead to severe data loss for applications that rely on persistent storage. This paper presents a new synthesis-aided programming model for building crash-consistent storage systems. In this approach, storage systems can assume an angelic crash-consistency model, where the underlying storage stack promises to resolve crashes in favor of consistency whenever possible. To realize this model, we introduce a new labeled writes interface for developers to identify their writes to disk, and develop a program synthesis tool, DepSynth, that generates dependency rules to enforce crash consistency over these labeled writes. We evaluate our model in a case study on a production storage system at Amazon Web Services. We find that DepSynth can automate crash consistency for this complex storage system, with similar results to existing expert-written code, and can automatically identify and correct consistency and performance issues.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.35", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Van Geffen,", + "last_name": "Jacob", + "institution": "University of Washington" + }, + { + "first_name": "Wang,", + "last_name": "Xi", + "institution": "Amazon (United States)" + }, + { + "first_name": "Torlak,", + "last_name": "Emina", + "institution": "Amazon (United States)" + }, + { + "first_name": "Bornholt,", + "last_name": "James", + "institution": "Amazon (United States)" + } + ], + "dblp_key": "conf/ecoop/Geffen0TB23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.37", + "title": "Do Machine Learning Models Produce TypeScript Types That Type Check?", + "abstract": "Type migration is the process of adding types to untyped code to gain assurance at compile time. TypeScript and other gradual type systems facilitate type migration by allowing programmers to start with imprecise types and gradually strengthen them. However, adding types is a manual effort and several migrations on large, industry codebases have been reported to have taken several years. In the research community, there has been significant interest in using machine learning to automate TypeScript type migration. Existing machine learning models report a high degree of accuracy in predicting individual TypeScript type annotations. However, in this paper we argue that accuracy can be misleading, and we should address a different question: can an automatic type migration tool produce code that passes the TypeScript type checker? We present TypeWeaver, a TypeScript type migration tool that can be used with an arbitrary type prediction model. We evaluate TypeWeaver with three models from the literature: DeepTyper, a recurrent neural network; LambdaNet, a graph neural network; and InCoder, a general-purpose, multi-language transformer that supports fill-in-the-middle tasks. Our tool automates several steps that are necessary for using a type prediction model, including (1) importing types for a project’s dependencies; (2) migrating JavaScript modules to TypeScript notation; (3) inserting predicted type annotations into the program to produce TypeScript when needed; and (4) rejecting non-type predictions when needed. We evaluate TypeWeaver on a dataset of 513 JavaScript packages, including packages that have never been typed before. With the best type prediction model, we find that only 21% of packages type check, but more encouragingly, 69% of files type check successfully.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.37", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ming‐Ho", + "last_name": "Yee", + "institution": "Northeastern University" + }, + { + "first_name": "Arjun", + "last_name": "Guha", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/YeeG23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.44", + "title": "Python Type Hints Are Turing Complete (Pearl/Brave New Idea)", + "abstract": "Grigore proved that Java generics are Turing complete by describing a reduction from Turing machines to Java subtyping. Furthermore, he demonstrated that his \"subtyping machines\" could have metaprogramming applications if not for their extremely high compilation times. The current work reexamines Grigore’s study in the context of another prominent programming language - Python. We show that the undecidable Java fragment used in Grigore’s construction is included in Python’s type system, making it Turing complete. In contrast to Java, Python type hints are checked by third-party static analyzers and run-time type checkers. The new undecidability result means that both kinds of type checkers cannot fully incorporate Python’s type system and guarantee termination. The paper includes a survey of infinite subtyping cycles in various type checkers and type reification in different Python distributions. In addition, we present an alternative reduction in which the Turing machines are simulated in real time, resulting in a significantly faster compilation. Our work is accompanied by a Python implementation of both reductions that compiles Turing machines into Python subtyping machines.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.44", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Roth,", + "last_name": "Ori", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/ecoop/Roth23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.36", + "title": "Synthesizing Conjunctive Queries for Code Search", + "abstract": "This paper presents Squid, a new conjunctive query synthesis algorithm for searching code with target patterns. Given positive and negative examples along with a natural language description, Squid analyzes the relations derived from the examples by a Datalog-based program analyzer and synthesizes a conjunctive query expressing the search intent. The synthesized query can be further used to search for desired grammatical constructs in the editor. To achieve high efficiency, we prune the huge search space by removing unnecessary relations and enumerating query candidates via refinement. We also introduce two quantitative metrics for query prioritization to select the queries from multiple candidates, yielding desired queries for code search. We have evaluated Squid on over thirty code search tasks. It is shown that Squid successfully synthesizes the conjunctive queries for all the tasks, taking only 2.56 seconds on average.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.36", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Chengpeng", + "last_name": "Wang", + "institution": "" + }, + { + "first_name": "Peisen", + "last_name": "Yao", + "institution": "" + }, + { + "first_name": "Tang,", + "last_name": "Wensheng", + "institution": "" + }, + { + "first_name": "Gang", + "last_name": "Fan", + "institution": "" + }, + { + "first_name": "Charles", + "last_name": "Zhang", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/WangYTFZ23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.39", + "title": "Rust for Morello: Always-On Memory Safety, Even in Unsafe Code (Experience Paper)", + "abstract": "Memory safety issues are a serious concern in systems programming. Rust is a systems language that provides memory safety through a combination of a static checks embodied in the type system and ad hoc dynamic checks inserted where this analysis becomes impractical. The Morello prototype architecture from ARM uses capabilities, fat pointers augmented with object bounds information, to catch failures of memory safety. This paper presents a compiler from Rust to the Morello architecture, together with a comparison of the performance of Rust’s runtime safety checks and the hardware-supported checks of Morello. The cost of Morello’s always-on memory safety guarantees is 39% in our 19 benchmark suites from the Rust crates repository (comprising 870 total benchmarks). For this cost, Morello’s capabilities ensure that even unsafe Rust code benefits from memory safety guarantees.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.39", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Harris,", + "last_name": "Sarah", + "institution": "University of Kent" + }, + { + "first_name": "Cooksey,", + "last_name": "Simon", + "institution": "University of Kent" + }, + { + "first_name": "Vollmer,", + "last_name": "Michael", + "institution": "University of Kent" + }, + { + "first_name": "Batty,", + "last_name": "Mark", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/ecoop/HarrisC0B23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.43", + "title": "On the Rise of Modern Software Documentation (Pearl/Brave New Idea)", + "abstract": "Classical software documentation, as it was conceived and intended decades ago, is not the only reality anymore. Official documentation from authoritative and official sources is being replaced by real-time collaborative platforms and ecosystems that have seen a surge, influenced by changes in society, technology, and best practices. These modern tools influence the way developers document the conception, design, and implementation of software. As a by-product of these shifts, developers are changing their way of communicating about software. Where once official documentation stood as the only truth about a project, we now find a multitude of volatile and heterogeneous documentation sources, forming a complex and ever-changing documentation landscape. Software projects often include a top-level README file with important information, which we leverage to identify their documentation landscape. Starting from ∼12K GitHub repositories, we mine their README files to extract links to additional documentation sources. We present a qualitative analysis, revealing multiple dimensions of the documentation landscape (e.g., content type, source type), highlighting important insights. By analyzing instant messaging application links (e.g., Gitter, Slack, Discord) in the histories of README files, we show how this part of the landscape has grown and evolved in the last decade. Our findings show that modern documentation encompasses communication platforms, which are exploding in popularity. This is not a passing phenomenon: On the contrary, it entails a number of unknowns and socio-technical problems the research community is currently ill-prepared to tackle.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.43", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Raglianti,", + "last_name": "Marco", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Nagy,", + "last_name": "Csaba", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Minelli,", + "last_name": "Roberto", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Lin,", + "last_name": "Bin", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Lanza,", + "last_name": "Michele", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/ecoop/Raglianti0M0L23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.38", + "title": "Building Code Transpilers for Domain-Specific Languages Using Program Synthesis (Experience Paper)", + "abstract": "Domain-specific languages (DSLs) are prevalent across many application domains. Such languages let developers easily express computations using high-level abstractions that result in performant implementations. To leverage DSLs, however, application developers need to master the DSL’s syntax and manually rewrite existing code. Compilers can aid in this effort, but part of building a compiler requires transpiling code from the source code to the target DSL. Such transpilation is typically done via pattern-matching rules on the source code. Sadly, developing such rules is often a painstaking and error-prone process. In this paper, we describe our experience in using program synthesis to build code transpilers. To do so, we developed MetaLift, a new framework for building transpilers that transform general-purpose code into DSLs using program synthesis. To use MetaLift, transpiler developers first define the target DSL’s semantics using MetaLift’s specification language, and specify the search space for each input code fragment to be transpiled using MetaLift’s API. MetaLift then leverages program synthesizers and theorem provers to automatically find transpilations expressed in the target DSL that is provably semantic equivalent to the input code. We have used MetaLift to build three DSL transpilers targeting different programming models and application domains. Our results show that the MetaLift-based compilers can translate many benchmarks used in prior work created by specialized implementations, but can be built using orders-of-magnitude fewer lines of code as compared to prior work.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.38", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bhatia,", + "last_name": "Sahil", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Kohli,", + "last_name": "Sumer", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Seshia, Sanjit", + "last_name": "A.", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Cheung,", + "last_name": "Alvin", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/ecoop/BhatiaKSC23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.41", + "title": "The Dolorem Pattern: Growing a Language Through Compile-Time Function Execution (Pearl/Brave New Idea)", + "abstract": "Programming languages are often designed as static, monolithic units. As a result, they are inflexible. We show a new mechanism of programming language design that allows to more flexible languages: by using compile-time function execution and metaprogramming, we implement a language mostly in itself. Our approach is usable for creating feature-rich, yet low-overhead system programming languages. We illustrate it on two systems, one that lowers to C and one that lowers to LLVM.", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.41", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Henniger,", + "last_name": "Simon", + "institution": "Technical University of Munich" + }, + { + "first_name": "Amin,", + "last_name": "Nada", + "institution": "Harvard University Press" + } + ], + "dblp_key": "conf/ecoop/HennigerA23", + "venue": "ecoop", + "year": 2023 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2023.42", + "title": "Synthetic Behavioural Typing: Sound, Regular Multiparty Sessions via Implicit Local Types (Pearl/Brave New Idea)", + "abstract": "Programming distributed systems is difficult. Multiparty session typing (MPST) is a method to automatically prove safety and liveness of protocol implementations relative to protocol specifications. In this paper, we introduce two new techniques to significantly improve the expressiveness of the MPST method: projection is based on implicit local types instead of explicit; type checking is based on the operational semantics of implicit local types instead of on the syntax. That is, the reduction relation on implicit local types is used not only \"a posteriori\" to prove type soundness (as usual), but also \"a priori\" to define the typing rules - synthetically. Classes of protocols that can now be specified/implemented/verified for the first time using the MPST method include: recursive protocols in which different roles participate in different branches; protocols in which a receiver chooses the sender of the first communication; protocols in which multiple roles synchronously choose both the sender and the receiver of a next communication, implemented as mixed input/output processes. We present the theory of the new techniques, as well as their future potential, and we demonstrate their present capabilities to effectively support regular expressions as global types (not possible before).", + "date": "2023-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2023.42", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jongmans,", + "last_name": "Sung-Shik", + "institution": "Open University of the Netherlands" + }, + { + "first_name": "Ferreira,", + "last_name": "Francisco", + "institution": "Royal Holloway University of London" + } + ], + "dblp_key": "conf/ecoop/JongmansF23", + "venue": "ecoop", + "year": 2023 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2024.json b/data/pl_conferences/ecoop/2024.json new file mode 100644 index 0000000..f1d6820 --- /dev/null +++ b/data/pl_conferences/ecoop/2024.json @@ -0,0 +1,1426 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.0", + "title": "Front Matter, Table of Contents, Preface, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Conference Organization", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aldrich,", + "last_name": "Jonathan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Salvaneschi,", + "last_name": "Guido", + "institution": "University of St.Gallen" + } + ], + "dblp_key": "conf/ecoop/X24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.1", + "title": "A Sound Type System for Secure Currency Flow", + "abstract": "In this paper we focus on TinySol, a minimal calculus for Solidity smart contracts, introduced by Bartoletti et al. We start by rephrasing its syntax (to emphasise its object-oriented flavour) and give a new big-step operational semantics. We then use it to define two security properties, namely call integrity and noninterference. These two properties have some similarities in their definition, in that they both require that some part of a program is not influenced by the other part. However, we show that the two properties are actually incomparable. Nevertheless, we provide a type system for noninterference and show that well-typed programs satisfy call integrity as well; hence, programs that are accepted by our type system satisfy both properties. We finally discuss the practical usability of the type system and its limitations by means of some simple examples.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Luca", + "last_name": "Aceto", + "institution": "Reykjavík University" + }, + { + "first_name": "Daniele", + "last_name": "Gorla", + "institution": "Sapienza University of Rome" + }, + { + "first_name": "Stian", + "last_name": "Lybech", + "institution": "Reykjavík University" + } + ], + "dblp_key": "conf/ecoop/AcetoGL24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.4", + "title": "Dynamically Generating Callback Summaries for Enhancing Static Analysis", + "abstract": "Interprocedural static analyses require a complete and precise callgraph. Since third-party libraries are responsible for large portions of the code of an app, a substantial fraction of the effort in callgraph generation is therefore spent on the library code for each app. For analyses that are oblivious to the inner workings of a library and only require the user code to be processed, the library can be replaced with a summary that allows to reconstruct the callbacks from library code back to user code. To improve performance, we propose the automatic generation and use of precise pre-computed callgraph summaries for commonly used libraries. Reflective method calls within libraries and callback-driven APIs pose further challenges for generating precise callgraphs using static analysis. Pre-computed summaries can also help analyses avoid these challenges. We present CGMiner, an approach for automatically generating callgraph models for library code. It dynamically observes sample apps that use one or more particular target libraries. As we show, CGMiner yields more than 94% of correct edges, whereas existing work only achieves around 33% correct edges. CGMiner avoids the high false positive rate of existing tools. We show that CGMiner integrated into FlowDroid uncovers 40% more data flows than our baseline without callback summaries.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Arzt,", + "last_name": "Steven", + "institution": "Fraunhofer Institute for Secure Information Technology" + }, + { + "first_name": "Miltenberger,", + "last_name": "Marc", + "institution": "Fraunhofer Institute for Secure Information Technology" + }, + { + "first_name": "Näumann,", + "last_name": "Julius", + "institution": "Technische Universität Darmstadt" + } + ], + "dblp_key": "conf/ecoop/ArztMN24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.10", + "title": "Indirection-Bounded Call Graph Analysis", + "abstract": "Call graphs play a crucial role in analyzing the structure and behavior of programs. For JavaScript and other dynamically typed programming languages, static call graph analysis relies on approximating the possible flow of functions and objects, and producing usable call graphs for large, real-world programs remains challenging. \\nIn this paper, we propose a simple but effective technique that addresses performance issues encountered in call graph generation. We observe via a dynamic analysis that typical JavaScript program code exhibits small levels of indirection of object pointers and higher-order functions. We demonstrate that a widely used analysis algorithm, wave propagation, closely follows the levels of indirections, so that call edges discovered early are more likely to be true positives. By bounding the number of indirections covered by this analysis, in many cases it can find most true-positive call edges in less time. We also show that indirection-bounded analysis can similarly be incorporated into the field-based call graph analysis algorithm ACG. \\nWe have experimentally evaluated the modified wave propagation algorithm on 25 large Node.js-based JavaScript programs. Indirection-bounded analysis on average yields close to a 2X speed-up with only 5% reduction in recall and almost identical precision relative to the baseline analysis, using dynamically generated call graphs for the recall and precision measurements. To demonstrate the robustness of the approach, we also evaluated the modified ACG algorithm on 10 web-based and 4 mobile-based medium sized benchmarks, with similar results.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Madhurima", + "last_name": "Chakraborty", + "institution": "University of California, Riverside" + }, + { + "first_name": "Aakash", + "last_name": "Gnanakumar", + "institution": "University of California, Riverside" + }, + { + "first_name": "Manu", + "last_name": "Sridharan", + "institution": "University of California, Riverside" + }, + { + "first_name": "Anders", + "last_name": "Møller", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/ecoop/ChakrabortyGSM24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.3", + "title": "A Dynamic Logic for Symbolic Execution for the Smart Contract Programming Language Michelson", + "abstract": "Verification of smart contracts is an important topic in the context of blockchain technology. We study an approach to verification that is based on symbolic execution. As a formal basis for symbolic execution, we design a dynamic logic for Michelson, the smart contract language of the Tezos blockchain, and prove its soundness in the proof assistant Agda. Towards the soundness proof we formalize the concrete semantics as well as its symbolic counterpart in a unified setting. The logic encompasses single contract runs as well as inter-contract runs chained in a single transaction.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Arvay,", + "last_name": "Barnabas", + "institution": "University of Freiburg" + }, + { + "first_name": "Doan, Thi Thu", + "last_name": "Ha", + "institution": "University of Freiburg" + }, + { + "first_name": "Thiemann,", + "last_name": "Peter", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/ecoop/ArvayD024", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.14", + "title": "The Performance Effects of Virtual-Machine Instruction Pointer Updates", + "abstract": "How much performance do VM instruction-pointer (IP) updates cost and how much benefit do we get from optimizing them away? Two decades ago it had little effect on the hardware of the day, but on recent hardware the dependence chain of IP updates can become the critical path on processors with out-of-order execution. In particular, this happens if the VM instructions are light-weight and the application programs are loop-dominated. The present work presents several ways of reducing or eliminating the dependence chains from IP updates, either by breaking the dependence chains with the loop optimization or by reducing the number of IP updates (the c and ci optimizations) or their latency (the b optimization). Some benchmarks see speedups from these optimizations by factors > 2 on most recent cores, while other benchmarks and older cores see more modest results, often in the speedup ranges 1.1-1.3.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ertl, M.", + "last_name": "Anton", + "institution": "TU Wien" + }, + { + "first_name": "Paysan,", + "last_name": "Bernd", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/ErtlP24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.7", + "title": "HOBBIT: Hashed OBject Based InTegrity", + "abstract": "C vulnerabilities usually hold verbatim for C++ programs. The counterfeit-object-oriented programming attack demonstrated that this relation is asymmetric, i.e., it only applies to C++. The problem pinpointed by this COOP attack is that C++ does not validate the integrity of its objects. By injecting malicious objects with manipulated virtual function table pointers, attackers can hijack control-flow of programs. The software security community addressed the COOP-problem in the years following its discovery, but together with the emergence of transient-execution attacks, such as Spectre, researchers also shifted their attention. We present Hobbit, a software-only solution to prevent COOP attacks by validating object integrity for virtual function pointer tables. Hobbit does not require any hardware specific features, scales to multi-million lines of C++ source code, and our LLVM-based implementation offers a configurable performance impact between 121.63% and 2.80% on compute-intensive SPEC CPU C++ benchmarks. Hobbit’s security analysis indicates strong resistance to brute forcing attacks and demonstrates additional benefits of using execute-only memory.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bernad,", + "last_name": "Matthias", + "institution": "Universität der Bundeswehr München" + }, + { + "first_name": "Brunthaler,", + "last_name": "Stefan", + "institution": "Universität der Bundeswehr München" + } + ], + "dblp_key": "conf/ecoop/Bernad024", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.15", + "title": "Rose: Composable Autodiff for the Interactive Web", + "abstract": "Reverse-mode automatic differentiation (autodiff) has been popularized by deep learning, but its ability to compute gradients is also valuable for interactive use cases such as bidirectional computer-aided design, embedded physics simulations, visualizing causal inference, and more. Unfortunately, the web is ill-served by existing autodiff frameworks, which use autodiff strategies that perform poorly on dynamic scalar programs, and pull in heavy dependencies that would result in unacceptable webpage sizes. This work introduces Rose, a lightweight autodiff framework for the web using a new hybrid approach to reverse-mode autodiff, blending conventional tracing and transformation techniques in a way that uses the host language for metaprogramming while also allowing the programmer to explicitly define reusable functions that comprise a larger differentiable computation. We demonstrate the value of the Rose design by porting two differentiable physics simulations, and evaluate its performance on an optimization-based diagramming application, showing Rose outperforming the state-of-the-art in web-based autodiff by multiple orders of magnitude.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sam", + "last_name": "Estep", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Wode", + "last_name": "Ni", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Raven", + "last_name": "Rothkopf", + "institution": "Columbia University" + }, + { + "first_name": "Joshua", + "last_name": "Sunshine", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/ecoop/EstepNRS24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.9", + "title": "A Language-Based Version Control System for Python", + "abstract": "Despite being the most popular programming language, Python has not yet received enough attention from the community. To the best of our knowledge, there is no general static analysis framework proposed to facilitate the implementation of dedicated Python static analyzers. To fill this gap, we design and implement such a framework (named Scalpel) and make it publicly available as an open-source project. The Scalpel framework has already integrated a number of fundamental static analysis functions (e.g., call graph constructions, control-flow graph constructions, alias analysis, etc.) that are ready to be reused by developers to implement client applications focusing on statically resolving dedicated Python problems such as detecting bugs or fixing vulnerabilities.", + "date": "2022-02-24", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Li", + "last_name": "Li", + "institution": "" + }, + { + "first_name": "Jiawei", + "last_name": "Wang", + "institution": "" + }, + { + "first_name": "Haowei", + "last_name": "Quan", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/CarvalhoS24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.13", + "title": "Pure Methods for roDOT", + "abstract": "Object-oriented programming languages typically allow mutation of objects, but pure methods are common too. There is great interest in recognizing which methods are pure, because it eases analysis of program behavior and allows modifying the program without changing its behavior. The roDOT calculus is a formal calculus extending DOT with reference mutability. In this paper, we explore purity conditions in roDOT and pose a SEF guarantee, by which the type system guarantees that methods of certain types are side-effect free. We use the idea from ReIm to detect pure methods by argument types. Applying this idea to roDOT required just a few changes to the type system, but necessitated re-working a significant part of the soundness proof. In addition, we state a transformation guarantee, which states that in a roDOT program, calls to SEF methods can be safely reordered without changing the outcome of the program. We proved type soundness of the updated roDOT calculus, using multiple layers of typing judgments. We proved the SEF guarantee by applying the Immutability guarantee, and the transformation guarantee by applying the SEF guarantee within a framework for reasoning about safe transformations of roDOT programs. All proofs are mechanized in Coq.", + "date": "2022-07-07", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dort,", + "last_name": "Vlastimil", + "institution": "" + }, + { + "first_name": "Aleksander", + "last_name": "Boruch-Gruszecki", + "institution": "" + }, + { + "first_name": "Lhoták,", + "last_name": "Ondřej", + "institution": "" + }, + { + "first_name": "Parízek,", + "last_name": "Pavel", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/DortLLP24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.6", + "title": "Cross Module Quickening - The Curious Case of C Extensions", + "abstract": "Dynamic programming languages such as Python offer expressive power and programmer productivity at the expense of performance. Although the topic of optimizing Python has received considerable attention over the years, a key obstacle remains elusive: C extensions. Time and again, optimized run-time environments, such as JIT compilers and optimizing interpreters, fall short of optimizing across C extensions, as they cannot reason about the native code hiding underneath. To bridge this gap, we present an analysis of C extensions for Python. The analysis data indicates that C extensions come in different varieties. One such variety is to merely speed up a single thing, such as reading a file and processing it directly in C. Another variety offers broad access through an API, resulting in a domain-specific language realized by function calls. While the former variety of C extensions offer little optimization potential for optimizing run-times, we find that the latter variety does offer considerable optimization potential. This optimization potential rests on dynamic locality that C extensions cannot readily tap. We introduce a new, interpreter-based optimization leveraging this untapped optimization potential called Cross-Module Quickening. The key idea is that C extensions can use an optimization interface to register highly-optimized operations on C extension-specific datatypes. A quickening interpreter uses these information to continuously specialize programs with C extensions. To quantify the attainable performance potential of going beyond C extensions, we demonstrate a concrete instantiation of Cross-Module Quickening for the CPython interpreter and the popular NumPy C extension. We evaluate our implementation with the NPBench benchmark suite and report performance improvements by a factor of up to 2.84.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Berlakovich,", + "last_name": "Felix", + "institution": "Universität der Bundeswehr München" + }, + { + "first_name": "Brunthaler,", + "last_name": "Stefan", + "institution": "Universität der Bundeswehr München" + } + ], + "dblp_key": "conf/ecoop/Berlakovich024", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.5", + "title": "Behavioural Up/down Casting For Statically Typed Languages", + "abstract": "We provide support for polymorphism in static typestate analysis for object-oriented languages with upcasts and downcasts. Recent work has shown how typestate analysis can be embedded in the development of Java programs to obtain safer behaviour at runtime, e.g., absence of null pointer errors and protocol completion. In that approach, inheritance is supported at the price of limiting casts in source code, thus only allowing those at the beginning of the protocol, i.e., immediately after objects creation, or at the end, and in turn seriously affecting the applicability of the analysis. In this paper, we provide a solution to this open problem in typestate analysis by introducing a theory based on a richer data structure, named typestate tree, which supports upcast and downcast operations at any point of the protocol by leveraging union and intersection types. The soundness of the typestate tree-based approach has been mechanised in Coq. The theory can be applied to most object-oriented languages statically analysable through typestates, thus opening new scenarios for acceptance of programs exploiting inheritance and casting. To defend this thesis, we show an application of the theory, by embedding the typestate tree mechanism in a Java-like object-oriented language, and proving its soundness.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bacchiani,", + "last_name": "Lorenzo", + "institution": "University of Bologna" + }, + { + "first_name": "Bravetti,", + "last_name": "Mario", + "institution": "University of Bologna" + }, + { + "first_name": "Giunti,", + "last_name": "Marco", + "institution": "University of Oxford" + }, + { + "first_name": "Mota,", + "last_name": "João", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Ravara,", + "last_name": "António", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "conf/ecoop/BacchianiBGMR24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.8", + "title": "Understanding Concurrency Bugs in Real-World Programs with Kotlin Coroutines", + "abstract": "Kotlin language has recently become prominent for developing both Android and server-side applications. These programs are typically designed to be fast and responsive, with asynchrony and concurrency at their core. To enable developers to write asynchronous and concurrent code safely and concisely, Kotlin provides built-in coroutines support. However, developers unfamiliar with the coroutines concept may write programs with subtle concurrency bugs and face unexpected program behaviors. Besides the traditional concurrency bug patterns, such as data races and deadlocks, these bugs may exhibit patterns related to the coroutine semantics. Understanding these coroutine-specific bug patterns in real-world Kotlin applications is essential in avoiding common mistakes and writing correct programs. In this paper, we present the first study of real-world concurrency bugs related to Kotlin coroutines. We examined 55 concurrency bug cases selected from 7 popular open-source repositories that use Kotlin coroutines, including IntelliJ IDEA, Firefox, and Ktor, and analyzed their bug characteristics and root causes. We identified common bug patterns related to asynchrony and Kotlin’s coroutine semantics, presenting them with their root causes, misconceptions that led to the bugs, and strategies for their automated detection. Overall, this study provides insight into programming with Kotlin coroutines concurrency and its pitfalls, aiming to shed light on common bug patterns and foster further research and development of concurrency analysis tools for Kotlin programs.", + "date": "2021-05-24", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Saeed", + "last_name": "Taheri", + "institution": "University of Utah" + }, + { + "first_name": "Ganesh", + "last_name": "Gopalakrishnan", + "institution": "University of Utah" + }, + { + "first_name": "van Deursen,", + "last_name": "Arie", + "institution": "" + }, + { + "first_name": "Ozkan, Burcu", + "last_name": "Kulahcioglu", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/BrockberndKDO24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.12", + "title": "Mutation-Based Lifted Repair of Software Product Lines", + "abstract": "The introduction of separation logic has led to the development of symbolic execution techniques and tools that are (functionally) compositional with function specifications that can be used in broader calling contexts. Many of the compositional symbolic execution tools developed in academia and industry have been grounded on a formal foundation, but either the function specifications are not validated with respect to the underlying separation logic of the theory, or there is a large gulf between the theory and the implementation of the tool. We introduce a formal compositional symbolic execution engine which creates and uses function specifications from an underlying separation logic and provides a sound theoretical foundation for, and indeed was partially inspired by, the Gillian symbolic execution platform. This is achieved by providing an axiomatic interface which describes the properties of the consume and produce operations used in the engine to update compositionally the symbolic state, for example when calling function specifications. This consume-produce technique is used by VeriFast, Viper, and Gillian, but has not been previously characterised independently of the tool. As part of our result, we give consume and produce operations inspired by the Gillian implementation that satisfy the properties described by our axiomatic interface. A surprising property is that our engine semantics provides a common foundation for both correctness and incorrectness reasoning, with the difference in the underlying engine only amounting to the choice to use satisfiability or validity. We use this property to extend the Gillian platform, which previously only supported correctness reasoning, with incorrectness reasoning and automatic true bug-finding using incorrectness bi-abduction. We evaluate our new Gillian platform by using the Gillian instantiation to C. This instantiation is the first tool grounded on a common formal compositional symbolic execution engine to support both correctness and incorrectness reasoning.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dimovski, Aleksandar", + "last_name": "S.", + "institution": "Mother Teresa University" + } + ], + "dblp_key": "conf/ecoop/Dimovski24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.16", + "title": "Mover Logic: A Concurrent Program Logic for Reduction and Rely-Guarantee Reasoning", + "abstract": "Rely-guarantee (RG) logic uses thread interference specifications (relies and guarantees) to reason about the correctness of multithreaded software. Unfortunately, RG logic requires each function postcondition to be \"stabilized\" or specialized to the behavior of other threads, making it difficult to write function specifications that are reusable at multiple call sites. This paper presents mover logic, which extends RG logic to address this problem via the notion of atomic functions. Atomic functions behave as if they execute serially without interference from concurrent threads, and so they can be assigned more general and reusable specifications that avoid the stabilization requirement of RG logic. Several practical verifiers (Calvin-R, QED, CIVL, Armada, Anchor, etc.) have demonstrated the modularity benefits of atomic function specifications. However, the complexity of these systems and their correctness proofs makes it challenging to understand and extend these systems. Mover logic formalizes the central ideas of reduction in a declarative program logic that provides a foundation for future work in this area.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Cormac", + "last_name": "Flanagan", + "institution": "" + }, + { + "first_name": "Stephen N.", + "last_name": "Freund", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/FlanaganF24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.11", + "title": "Regrading Policies for Flexible Information Flow Control in Session-Typed Concurrency", + "abstract": "Noninterference guarantees that an attacker cannot infer secrets by interacting with a program. Information flow control (IFC) type systems assert noninterference by tracking the level of information learned (pc) and disallowing communication to entities of lesser or unrelated level than the pc. Control flow constructs such as loops are at odds with this pattern because they necessitate downgrading the pc upon recursion to be practical. In a concurrent setting, however, downgrading is not generally safe. This paper utilizes session types to track the flow of information and contributes an IFC type system for message-passing concurrent processes that allows downgrading the pc upon recursion. To make downgrading safe, the paper introduces regrading policies. Regrading policies are expressed in terms of integrity labels, which are also key to safe composition of entities with different regrading policies. The paper develops the type system and proves progress-sensitive noninterference for well-typed processes, ruling out timing attacks that exploit the relative order of messages. The type system has been implemented in a type checker, which supports security-polymorphic processes.", + "date": "2023-09-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Balzer,", + "last_name": "Stephanie", + "institution": "" + }, + { + "first_name": "Derakhshan,", + "last_name": "Farzaneh", + "institution": "" + }, + { + "first_name": "Harper,", + "last_name": "Robert", + "institution": "" + }, + { + "first_name": "Yue", + "last_name": "Yao", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/DerakhshanBY24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.17", + "title": "Fair Join Pattern Matching for Actors", + "abstract": "Join patterns provide a promising approach to the development of concurrent and distributed message-passing applications. Several variations and implementations have been presented in the literature - but various aspects remain under-explored: in particular, how to specify a suitable notion of message matching, how to implement it correctly and efficiently, and how to systematically evaluate the implementation performance. In this work we focus on actor-based programming, and study the application of join patterns with conditional guards (i.e., the most expressive and challenging version of join patterns in literature). We formalise a novel specification of fair and deterministic join pattern matching, ensuring that older messages are always consumed if they can be matched. We present a stateful, tree-based join pattern matching algorithm and prove that it correctly implements our fair and deterministic matching specification. We present a novel Scala 3 actor library (called JoinActors) that implements our join pattern formalisation, leveraging macros to provide an intuitive API. Finally, we evaluate the performance of our implementation, by introducing a systematic benchmarking approach that takes into account the nuances of join pattern matching (in particular, its sensitivity to input traffic and complexity of patterns and guards).", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Philipp", + "last_name": "Haller", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Abdallatif", + "last_name": "Hussein", + "institution": "Technical University of Denmark" + }, + { + "first_name": "Hernán", + "last_name": "Melgratti", + "institution": "Consejo Nacional de Investigaciones Científicas y Técnicas" + }, + { + "first_name": "Alceste", + "last_name": "Scalas", + "institution": "Technical University of Denmark" + }, + { + "first_name": "Emilio", + "last_name": "Tuosto", + "institution": "Gran Sasso Science Institute" + } + ], + "dblp_key": "conf/ecoop/HallerHMST24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.24", + "title": "Qafny: A Quantum-Program Verifier", + "abstract": "Because of the probabilistic/nondeterministic behavior of quantum programs, it is highly advisable to verify them formally to ensure that they correctly implement their specifications. Formal verification, however, also traditionally requires significant effort. To address this challenge, we present Qafny, an automated proof system based on the program verifier Dafny and designed for verifying quantum programs. At its core, Qafny uses a type-guided quantum proof system that translates quantum operations to classical array operations modeled within a classical separation logic framework. We prove the soundness and completeness of our proof system and implement a prototype compiler that transforms Qafny programs and specifications into Dafny for automated verification purposes. We then illustrate the utility of Qafny's automated capabilities in efficiently verifying important quantum algorithms, including quantum-walk algorithms, Grover's algorithm, and Shor's algorithm.", + "date": "2022-11-11", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.24", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Liyi", + "last_name": "Li", + "institution": "Iowa State University" + }, + { + "first_name": "Mingwei", + "last_name": "Zhu", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Cleaveland,", + "last_name": "Rance", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Nicolellis,", + "last_name": "Alexander", + "institution": "Iowa State University" + }, + { + "first_name": "Yi", + "last_name": "Lee", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Le", + "last_name": "Chang", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "conf/ecoop/0002ZCNLC024", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.18", + "title": "A CFL-Reachability Formulation of Callsite-Sensitive Pointer Analysis with Built-In On-The-Fly Call Graph Construction", + "abstract": "In object-oriented languages, the traditional CFL-reachability formulation for k-callsite-sensitive pointer analysis (kCFA) focuses on modeling field accesses and calling contexts, but it relies on a separate algorithm for call graph construction. This division can result in a loss of precision in kCFA, a problem that persists even when using the most precise call graphs, whether pre-constructed or generated on the fly. Moreover, pre-analyses based on this framework aiming to improve the efficiency of kCFA may inadvertently reduce its precision, due to the framework’s lack of native call graph construction, essential for precise analysis. Addressing this gap, this paper introduces a novel CFL-reachability formulation of kCFA for Java, uniquely integrating on-the-fly call graph construction. This advancement not only addresses the precision loss inherent in the traditional CFL-reachability-based approach but also enhances its overall applicability. In a significant secondary contribution, we present the first precision-preserving pre-analysis to accelerate kCFA. This pre-analysis leverages selective context sensitivity to improve the efficiency of kCFA without sacrificing its precision. Collectively, these contributions represent a substantial step forward in pointer analysis, offering both theoretical and practical advancements that could benefit future developments in the field.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "He,", + "last_name": "Dongjie", + "institution": "Chongqing University" + }, + { + "first_name": "Lu,", + "last_name": "Jingbo", + "institution": "UNSW Sydney" + }, + { + "first_name": "Xue,", + "last_name": "Jingling", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/ecoop/HeLX24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.30", + "title": "Verifying Lock-Free Search Structure Templates", + "abstract": "We present and verify template algorithms for lock-free concurrent search structures that cover a broad range of existing implementations based on lists and skiplists. Our linearizability proofs are fully mechanized in the concurrent separation logic Iris. The proofs are modular and cover the broader design space of the underlying algorithms by parameterizing the verification over aspects such as the low-level representation of nodes and the style of data structure maintenance. As a further technical contribution, we present a mechanization of a recently proposed method for reasoning about future-dependent linearization points using hindsight arguments. The mechanization builds on Iris' support for prophecy reasoning and user-defined ghost resources. We demonstrate that the method can help to reduce the proof effort compared to direct prophecy-based proofs.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.30", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Patel,", + "last_name": "Nisarg", + "institution": "New York University" + }, + { + "first_name": "Dennis", + "last_name": "Shasha", + "institution": "New York University" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" + } + ], + "dblp_key": "conf/ecoop/PatelSW24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.20", + "title": "Taking a Closer Look: An Outlier-Driven Approach to Compilation-Time Optimization", + "abstract": "Improving compilation time in optimizing compilers is challenging due to their large number of interconnected components. This includes compiler optimizations, compiler tiers, heuristics, and profiling information. Despite this complexity, research in compilation-time optimization is often guided by analyzing metrics of entire program runs, such as the total compilation time and overall memory footprint. This coarse-grained perspective hides relevant information, such as source program functions for which the compiler allocates a lot of memory or compiler optimizations with a high impact on the total compilation time. This leaves high-level metrics as the only reference point for driving optimization design. Consequently, compilation-time regressions in one program function that are obscured by improvements in other functions stay undetected, while the impacts of compiler changes on untouched parts of the compiler are mainly unknown. Furthermore, developers overlook long-standing compiler defects because their high-level metrics do not change over time. To address these limitations, we propose ICON, a new data-driven approach to compilation-time optimization that breaks up high-level metrics into individual source program functions, compiler optimizations, or even into individual instructions in the compiler source code. Our methodology enables an iterative in-depth compilation-time analysis, focusing on outliers to identify optimization opportunities. We show that outliers, both in terms of time spent in a particular compiler optimization, and in terms of individual compilations that take substantially longer, can reveal potential problems in the compiler implementation. We applied our approach to GraalVM and extracted data for multiple of its language runtimes. We analyzed the resulting data, present the first detailed look into the distribution of compilation time in the GraalVM compiler, a state-of-the-art multi-language compiler, and identified defects that led to regressions in overall compilation time or the compilation time of specific languages. We furthermore designed two optimizations based on the identified outliers that improve compilation time between 2.25% and 9.45%. We believe that our approach can guide compiler developers in finding usually overlooked optimization potential and defects, and focus future research efforts in making compilers more efficient.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Huemer,", + "last_name": "Florian", + "institution": "Johannes Kepler University of Linz" + }, + { + "first_name": "Leopoldseder,", + "last_name": "David", + "institution": "" + }, + { + "first_name": "Prokopec,", + "last_name": "Aleksandar", + "institution": "" + }, + { + "first_name": "Mosaner,", + "last_name": "Raphael", + "institution": "" + }, + { + "first_name": "Mössenböck,", + "last_name": "Hanspeter", + "institution": "Johannes Kepler University of Linz" + } + ], + "dblp_key": "conf/ecoop/HuemerLPMM24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.21", + "title": "Learning Gradual Typing Performance", + "abstract": "Gradual typing has emerged as a promising typing discipline for reconciling static and dynamic typing, which have respective strengths and shortcomings. Thanks to its promises, gradual typing has gained tremendous momentum in both industry and academia. A main challenge in gradual typing is that, however, the performance of its programs can often be unpredictable, and adding or removing the type of a a single parameter may lead to wild performance swings. Many approaches have been proposed to optimize gradual typing performance, but little work has been done to aid the understanding of the performance landscape of gradual typing and navigating the migration process (which adds type annotations to make programs more static) to avert performance slowdowns. Motivated by this situation, this work develops a machine-learning-based approach to predict the performance of each possible way of adding type annotations to a program. On top of that, many supports for program migrations could be developed, such as finding the most performant neighbor of any given configuration. Our approach gauges runtime overheads of dynamic type checks inserted by gradual typing and uses that information to train a machine learning model, which is used to predict the running time of gradual programs. We have evaluated our approach on 12 Python benchmarks for both guarded and transient semantics. For guarded semantics, our evaluation results indicate that with only 40 training instances generated from each benchmark, the predicted times for all other instances differ on average by 4% from the measured times. For transient semantics, the time difference ratio is higher but the time difference is often within 0.1 seconds.", + "date": "2022-03-08", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Guo,", + "last_name": "Daya", + "institution": "" + }, + { + "first_name": "Lu,", + "last_name": "Shuai", + "institution": "" + }, + { + "first_name": "Duan,", + "last_name": "Nan", + "institution": "" + }, + { + "first_name": "Yanlin", + "last_name": "Wang", + "institution": "" + }, + { + "first_name": "Ming", + "last_name": "Zhou", + "institution": "" + }, + { + "first_name": "Jian", + "last_name": "Yin", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/Khan0024", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.23", + "title": "InferType: A Compiler Toolkit for Implementing Efficient Constraint-Based Type Inference", + "abstract": "Over the last several decades, software has been woven into the fabric of every aspect of our society. As software development surges and code infrastructure of enterprise applications ages, it is now more critical than ever to increase software development productivity and modernize legacy applications. Advances in deep learning and machine learning algorithms have enabled numerous breakthroughs, motivating researchers to leverage AI techniques to improve software development efficiency. Thus, the fast-emerging research area of AI for Code has garnered new interest and gathered momentum. In this paper, we present a large-scale dataset CodeNet, consisting of over 14 million code samples and about 500 million lines of code in 55 different programming languages, which is aimed at teaching AI to code. In addition to its large scale, CodeNet has a rich set of high-quality annotations to benchmark and help accelerate research in AI techniques for a variety of critical coding tasks, including code similarity and classification, code translation between a large variety of programming languages, and code performance (runtime and memory) improvement techniques. Additionally, CodeNet provides sample input and output test sets for 98.5% of the code samples, which can be used as an oracle for determining code correctness and potentially guide reinforcement learning for code quality improvements. As a usability feature, we provide several pre-processing tools in CodeNet to transform source code into representations that can be readily used as inputs into machine learning models. Results of code classification and code similarity experiments using the CodeNet dataset are provided as a reference. We hope that the scale, diversity and rich, high-quality annotations of CodeNet will offer unprecedented research opportunities at the intersection of AI and Software Engineering.", + "date": "2021-05-25", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Puri,", + "last_name": "Ruchir", + "institution": "The University of Tokyo" + }, + { + "first_name": "Kung, David", + "last_name": "S.", + "institution": "The University of Tokyo" + }, + { + "first_name": "Janssen,", + "last_name": "Geert", + "institution": "The University of Tokyo" + }, + { + "first_name": "Zhang,", + "last_name": "Wei", + "institution": "" + }, + { + "first_name": "Domeniconi,", + "last_name": "Giacomo", + "institution": "" + }, + { + "first_name": "Zolotov,", + "last_name": "Vladimir", + "institution": "" + }, + { + "first_name": "Dolby,", + "last_name": "Julian", + "institution": "" + }, + { + "first_name": "Chen,", + "last_name": "Jie", + "institution": "" + }, + { + "first_name": "Choudhury,", + "last_name": "Mihir", + "institution": "" + }, + { + "first_name": "Decker,", + "last_name": "Lindsey", + "institution": "" + }, + { + "first_name": "Thost,", + "last_name": "Veronika", + "institution": "" + }, + { + "first_name": "Buratti,", + "last_name": "Luca", + "institution": "" + }, + { + "first_name": "Pujar,", + "last_name": "Saurabh", + "institution": "" + }, + { + "first_name": "Ramji,", + "last_name": "Shyam", + "institution": "" + }, + { + "first_name": "Finkler,", + "last_name": "Ulrich", + "institution": "" + }, + { + "first_name": "Malaika,", + "last_name": "Susan", + "institution": "" + }, + { + "first_name": "Reiss,", + "last_name": "Frederick", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/LiYC24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.22", + "title": "Constrictor: Immutability as a Design Concept", + "abstract": "Many object-oriented applications in algorithm design rely on objects never changing during their lifetime. This is often tackled by marking object references as read-only, e.g., using the const keyword in C++. In other languages like Python or Java where such a concept does not exist, programmers rely on best practices that are entirely unenforced. While reliance on best practices is obviously too permissive, const-checking is too restrictive: it is possible for a method to mutate the internal state while still satisfying the property we expect from an \"immutable\" object in this setting. We would therefore like to enforce the immutability of an object’s abstract state. We check an object’s immutability through a view of its abstract state: for instances of an immutable class, the view does not change when running any of the class’s methods, even if some of the internal state does change. If all methods of a class are verified as non-mutating, we can deem the entire class view-immutable. We present an SMT-based algorithm to check view-immutability, and implement it in our linter/verifier, Constrictor. We evaluate Constrictor on 51 examples of immutability-related design violations. Our evaluation shows that Constrictor is effective at catching a variety of prototypical design violations, and does so in seconds. We also explore Constrictor with two real-world case studies.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Kinsbruner,", + "last_name": "Elad", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Itzhaky,", + "last_name": "Shachar", + "institution": "Technion – Israel Institute of Technology" + }, + { + "first_name": "Peleg,", + "last_name": "Hila", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/ecoop/KinsbrunerIP24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.26", + "title": "Matching Plans for Frame Inference in Compositional Reasoning", + "abstract": "The use of function specifications to reason about function calls and the manipulation of user-defined predicates are two essential ingredients of modern compositional verification tools based on separation logic. To execute these operations successfully, these tools must be able to solve the frame inference problem, that is, to understand which parts of the state are relevant for the operation at hand. We introduce matching plans, a concept that is used in the Gillian verification platform to automate frame inference efficiently. We extract matching plans and their automation machinery from the Gillian implementation and present them in a tool-agnostic way, making the Gillian approach available to the broader verification community as a verification-tool design pattern.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.26", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Lööw,", + "last_name": "Andreas", + "institution": "Imperial College London" + }, + { + "first_name": "Nantes-Sobrinho,", + "last_name": "Daniele", + "institution": "Imperial College London" + }, + { + "first_name": "Ayoun,", + "last_name": "Sacha-Élie", + "institution": "Imperial College London" + }, + { + "first_name": "Maksimović,", + "last_name": "Petar", + "institution": "Imperial College London" + }, + { + "first_name": "Gardner,", + "last_name": "Philippa", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/LoowNAMG24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.27", + "title": "The Fault in Our Stars: Designing Reproducible Large-scale Code Analysis Experiments", + "abstract": "Large-scale software repositories are a source of insights for software engineering. They offer an unmatched window into the software development process at scale. Their sheer number and size holds the promise of broadly applicable results. At the same time, that very size presents practical challenges for scaling tools and algorithms to millions of projects. A reasonable approach is to limit studies to representative samples of the population of interest. Broadly applicable conclusions can then be obtained by generalizing to the entire population. The contribution of this paper is a standardized experimental design methodology for choosing the inputs of studies working with large-scale repositories. We advocate for a methodology that clearly lays out what the population of interest is, how to sample it, and that fosters reproducibility. Along the way, we discourage researchers from using extrinsic attributes of projects such as stars, that measure some unclear notion of popularity.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.27", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Maj,", + "last_name": "Petr", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Muroya,", + "last_name": "Stefanie", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Siek,", + "last_name": "Konrad", + "institution": "Czech Technical University in Prague" + }, + { + "first_name": "Di Grazia,", + "last_name": "Luca", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Vitek,", + "last_name": "Jan", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/MajMSGV24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.29", + "title": "Generalizing Shape Analysis with Gradual Types", + "abstract": "Frameworks for writing, compiling, and optimizing deep learning (DL) models have recently enabled progress in areas like computer vision and natural language processing. Extending these frameworks to accommodate the rapidly diversifying landscape of DL models and hardware platforms presents challenging tradeoffs between expressivity, composability, and portability. We present Relay, a new compiler framework for DL. Relay's functional, statically typed intermediate representation (IR) unifies and generalizes existing DL IRs to express state-of-the-art models. The introduction of Relay's expressive IR requires careful design of domain-specific optimizations, addressed via Relay's extension mechanisms. Using these extension mechanisms, Relay supports a unified compiler that can target a variety of hardware platforms. Our evaluation demonstrates Relay's competitive performance for a broad class of models and devices (CPUs, GPUs, and emerging accelerators). Relay's design demonstrates how a unified IR can provide expressivity, composability, and portability without compromising performance.", + "date": "2019-04-17", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.29", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Migeed,", + "last_name": "Zeina", + "institution": "University of California, Los Angeles" + }, + { + "first_name": "Reed,", + "last_name": "James", + "institution": "New York City Fire Department" + }, + { + "first_name": "Ansel,", + "last_name": "Jason", + "institution": "Menlo School" + }, + { + "first_name": "Palsberg,", + "last_name": "Jens", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/ecoop/MigeedRAP24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.28", + "title": "Static Basic Block Versioning", + "abstract": "Basic Block Versioning (BBV) is a compilation technique for optimizing program execution. It consists in duplicating and specializing basic blocks of code according to the execution contexts of the blocks, up to a version limit. BBV has been used in Just-In-Time (JIT) compilers for reducing the dynamic type checks of dynamic languages. Our work revisits the BBV technique to adapt it to Ahead-of-Time (AOT) compilation. This Static BBV (SBBV) raises new challenges, most importantly how to ensure the convergence of the algorithm when the specializations of the basic blocks are not based on profiled variable values and how to select the good specialization contexts. SBBV opens new opportunities for more precise optimizations as the compiler can explore multiple versions and only keep those within the version limit that yield better generated code. In this paper, we present the main SBBV algorithm and its use to optimize the dynamic type checks, array bound checks, and mixed-type arithmetic operators often found in dynamic languages. We have implemented SBBV in two AOT compilers for the Scheme programming language that we have used to evaluate the technique’s effectiveness. On a suite of benchmarks, we have observed that even with a low limit of 2 versions, SBBV greatly reduces the number of dynamic type tests (by 54% and 62% on average) and accelerates the execution time (by about 10% on average). Previous work has needed a higher version limit to achieve a similar level of optimization. We also observe a small impact on compilation time and code size (a decrease in some cases).", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.28", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Olivier", + "last_name": "Melançon", + "institution": "Université de Montréal" + }, + { + "first_name": "Marc", + "last_name": "Feeley", + "institution": "Université de Montréal" + }, + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Centre Inria d'Université Côte d'Azur" + } + ], + "dblp_key": "conf/ecoop/MelanconFS24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.31", + "title": "Ozone: Fully Out-of-Order Choreographies", + "abstract": "Choreographic programming is a paradigm for writing distributed applications. It allows programmers to write a single program, called a choreography, that can be compiled to generate correct implementations of each process in the application. Although choreographies provide good static guarantees, they can exhibit high latency when messages or processes are delayed. This is because processes in a choreography typically execute in a fixed, deterministic order, and cannot adapt to the order that messages arrive at runtime. In non-choreographic code, programmers can address this problem by allowing processes to execute out of order - for instance by using futures or reactive programming. However, in choreographic code, out-of-order process execution can lead to serious and subtle bugs, called communication integrity violations (CIVs). In this paper, we develop a model of choreographic programming for out-of-order processes that guarantees absence of CIVs and deadlocks. As an application of our approach, we also introduce an API for safe non-blocking communication via futures in the choreographic programming language Choral. The API allows processes to execute out of order, participate in multiple choreographies concurrently, and to handle unordered data messages. We provide an illustrative evaluation of our API, showing that out-of-order execution can reduce latency and increase throughput by overlapping communication with computation.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.31", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dan", + "last_name": "Plyukhin", + "institution": "" + }, + { + "first_name": "Marco", + "last_name": "Peressotti", + "institution": "" + }, + { + "first_name": "Fabrizio", + "last_name": "Montesi", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/PlyukhinPM24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.33", + "title": "Compiling with Arrays", + "abstract": "Linear algebra computations are foundational for neural networks and machine learning, often handled through arrays. While many functional programming languages feature lists and recursion, arrays in linear algebra demand constant-time access and bulk operations. To bridge this gap, some languages represent arrays as (eager) functions instead of lists. In this paper, we connect this idea to a formal logical foundation by interpreting functions as the usual negative types from polarized type theory, and arrays as the corresponding dual positive version of the function type. Positive types are defined to have a single elimination form whose computational interpretation is pattern matching. Just like (positive) product types bind two variables during pattern matching, (positive) array types bind variables with multiplicity during pattern matching. We follow a similar approach for Booleans by introducing conditionally-defined variables. The positive formulation for the array type enables us to combine typed partial evaluation and common subexpression elimination into an elegant algorithm whose result enjoys a property we call maximal fission, which we argue can be beneficial for further optimizations. For this purpose, we present the novel intermediate representation indexed administrative normal form (A_{i}NF), which relies on the formal logical foundation of the positive formulation for the array type to facilitate maximal loop fission and subsequent optimizations. A_{i}NF is normal with regard to commuting conversion for both let-bindings and for-loops, leading to flat and maximally fissioned terms. We mechanize the translation and normalization from a simple surface language to A_{i}NF, establishing that the process terminates, preserves types, and produces maximally fissioned terms.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.33", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Richter,", + "last_name": "David", + "institution": "" + }, + { + "first_name": "Timon", + "last_name": "Böhler", + "institution": "" + }, + { + "first_name": "Pascal", + "last_name": "Weisenburger", + "institution": "" + }, + { + "first_name": "Mira", + "last_name": "Mezini", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/0001BWM24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.34", + "title": "Pipit on the Post: Proving Pre- and Post-Conditions of Reactive Systems", + "abstract": "Synchronous languages such as Lustre and Scade are used to implement safety-critical control systems; proving such programs correct and having the proved properties apply to the compiled code is therefore equally critical. We introduce Pipit, a small synchronous language embedded in F*, designed for verifying control systems and executing them in real-time. Pipit includes a verified translation to transition systems; by reusing F*’s existing proof automation, certain safety properties can be automatically proved by k-induction on the transition system. Pipit can also generate executable code in a subset of F* which is suitable for compilation and real-time execution on embedded devices. The executable code is deterministic and total and preserves the semantics of the original program.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.34", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Robinson,", + "last_name": "Amos", + "institution": "" + }, + { + "first_name": "Potanin,", + "last_name": "Alex", + "institution": "Australian National University" + } + ], + "dblp_key": "conf/ecoop/RobinsonP24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.32", + "title": "Tenspiler: A Verified-Lifting-Based Compiler for Tensor Operations", + "abstract": "Tensor processing infrastructures such as deep learning frameworks and specialized hardware accelerators have revolutionized how computationally intensive code from domains such as deep learning and image processing is executed and optimized. These infrastructures provide powerful and expressive abstractions while ensuring high performance. However, to utilize them, code must be written specifically using the APIs / ISAs of such software frameworks or hardware accelerators. Importantly, given the fast pace of innovation in these domains, code written today quickly becomes legacy as new frameworks and accelerators are developed, and migrating such legacy code manually is a considerable effort. To enable developers in leveraging such DSLs while preserving their current programming paradigm, we introduce Tenspiler, a verified lifting-based compiler that uses program synthesis to translate sequential programs written in general-purpose programming languages (e.g., C++ or Python code) into tensor operations. Central to Tenspiler is our carefully crafted yet simple intermediate language, named TensIR, that expresses tensor operations. TensIR enables efficient lifting, verification, and code generation. Currently, Tenspiler already supports $\\textbf{six}$ DSLs, spanning a broad spectrum of software and hardware environments. Furthermore, we show that new backends can be easily supported by Tenspiler by adding simple pattern-matching rules for TensIR. Using 10 real-world code benchmark suites, our experimental evaluation shows that by translating code to be executed on $\\textbf{6}$ different software frameworks and hardware devices, Tenspiler offers on average 105$\\times$ kernel and 9.65$\\times$ end-to-end execution time improvement over the fully-optimized sequential implementation of the same benchmarks.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.32", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jie", + "last_name": "Qiu", + "institution": "University of Pittsburgh" + }, + { + "first_name": "C.R.", + "last_name": "Cai", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Sahil", + "last_name": "Bhatia", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Niranjan", + "last_name": "Hasabnis", + "institution": "Intel (United States)" + }, + { + "first_name": "Sanjit A.", + "last_name": "Seshia", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/ecoop/QiuCBHSC24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.37", + "title": "Java Bytecode Normalization for Code Similarity Analysis", + "abstract": "Analyzing the similarity of two code fragments has many applications, including code clone, vulnerability and plagiarism detection. Most existing approaches for similarity analysis work on source code. However, in scenarios like plagiarism detection, copyright violation detection or Software Bill of Materials creation source code is often not available and thus similarity analysis has to be performed on binary formats. Java bytecode is a binary format executable by the Java Virtual Machine and obtained from the compilation of Java source code. Performing similarity detection on bytecode is challenging because different compilers can compile the same source code to syntactically vastly different bytecode. In this work we assess to what extent one can nonetheless enable similarity detection by bytecode normalization, a procedure to transform Java bytecode into a representation that is identical for the same original source code, irrespective of the Java compiler and Java version used during compilation. Our manual study revealed 16 classes of compilation differences that various compilation environments may induce. Based on these findings, we implemented bytecode normalization in a tool jNorm. It uses Jimple as intermediate representation, applies common code optimizations and transforms all classes of compilation difference to a normalized form, thus achieving a representation of the bytecode that is identical despite different compilation environments. Our evaluation, performed on more than 300 popular Java projects, shows that solely the act of incrementing a compiler version may cause differences in 46% of all resulting bytecode files. By applying bytecode normalization, one can remove more than 99% of these differences, thus acting as a crucial enabler for subsequent applications of bytecode similarity analysis.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.37", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Schott,", + "last_name": "Stefan", + "institution": "Paderborn University" + }, + { + "first_name": "Ponta, Serena", + "last_name": "Elisa", + "institution": "" + }, + { + "first_name": "Fischer,", + "last_name": "Wolfram", + "institution": "" + }, + { + "first_name": "Klauke,", + "last_name": "Jonas", + "institution": "Paderborn University" + }, + { + "first_name": "Bodden,", + "last_name": "Eric", + "institution": "Paderborn University" + } + ], + "dblp_key": "conf/ecoop/SchottPFKB24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.36", + "title": "Scaling Interprocedural Static Data-Flow Analysis to Large C/C++ Applications: An Experience Report", + "abstract": "Interprocedural data-flow analysis is important for computing precise information on whole programs. In theory, the popular algorithmic framework interprocedural distributive environments (IDE) provides a tool to solve distributive interprocedural data-flow problems efficiently. Yet, unfortunately, available state-of-the-art implementations of the IDE framework start to run into scalability issues for programs with several thousands of lines of code, depending on the static analysis domain. Since the IDE framework is a basic building block for many static program analyses, this presents a serious limitation. In this paper, we report on our experience with making the IDE algorithm scale to C/C++ applications with up to 500 000 lines of code. We analyze the IDE algorithm and its state-of-the-art implementations to identify their weaknesses related to scalability at both a conceptual and implementation level. Based on this analysis, we propose several optimizations to overcome these weaknesses, aiming at a sweet spot between reducing running time and memory consumption. As a result, we provide an improved IDE solver that implements our optimizations within the PhASAR static analysis framework. Our evaluation on real-world C/C++ applications shows that applying the optimizations speeds up the analysis on average by up to 7×, while also reducing memory consumption by 7× on average as well. For the first time, these optimizations allow us to analyze programs with several hundreds of thousands of lines of LLVM-IR code in reasonable time and space.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.36", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Schiebel,", + "last_name": "Fabian", + "institution": "Fraunhofer Institute for Mechatronic Systems Design" + }, + { + "first_name": "Sattler,", + "last_name": "Florian", + "institution": "Saarland University" + }, + { + "first_name": "Schubert, Philipp", + "last_name": "Dominik", + "institution": "Heinz Nixdorf Stiftung" + }, + { + "first_name": "Apel,", + "last_name": "Sven", + "institution": "Saarland University" + }, + { + "first_name": "Bodden,", + "last_name": "Eric", + "institution": "Fraunhofer Institute for Mechatronic Systems Design" + } + ], + "dblp_key": "conf/ecoop/SchiebelSSAB24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.35", + "title": "Partial Redundancy Elimination in Two Iterative Data Flow Analyses", + "abstract": "Partial Redundancy Elimination (PRE) is a powerful and well-known code optimization. The idea to combine Common Subexpression Elimination and Loop Invariant Code Motion optimizations into a single optimization was originally conceived by Morel and Renvoise. Their algorithm is bidirectional in nature and was not complete and optimal. Later, Knoop et al. proposed the first complete and optimal algorithm, Lazy Code Motion (LCM), which takes four unidirectional data flow analyses. In a recent paper, Roy et al. proposed an algorithm for PRE that uses three iterative data flow analyses. Here, we propose an efficient algorithm for PRE, which takes only two iterative data flow analyses followed by two computation passes over the program. The algorithm is both computationally and lifetime optimal. The proposed algorithm computes the information required for performing the transformation in two passes over the program without considering safety. The two iterative data flow analyses are required for making the transformation safe. The use of well-known data flow analyses, i.e., available expressions analysis and anticipated expressions analysis, makes the algorithm simple to understand and easy to prove its correctness. The proposed algorithm is more efficient than the existing algorithms since it takes only two iterative data flow analyses. The efficiency of the proposed algorithm is demonstrated by implementing it in LLVM Compiler Infrastructure and comparing the time taken with other selected best-known algorithms.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.35", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Roy,", + "last_name": "Reshma", + "institution": "National Institute of Technology Calicut" + }, + { + "first_name": "S,", + "last_name": "Sreekala", + "institution": "National Institute of Technology Calicut" + }, + { + "first_name": "Paleri,", + "last_name": "Vineeth", + "institution": "National Institute of Technology Calicut" + } + ], + "dblp_key": "conf/ecoop/RoySP24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.39", + "title": "Formalizing, Mechanizing, and Verifying Class-Based Refinement Types", + "abstract": "Refinement types have been extensively used in class-based languages to specify and verify fine-grained logical specifications. Despite the advances in practical aspects such as applicability and usability, two fundamental issues persist. First, the soundness of existing class-based refinement type systems is inadequately explored, casting doubts on their reliability. Second, the expressiveness of existing systems is limited, restricting the depiction of semantic properties related to object-oriented constructs. This work tackles these issues through a systematic framework. We formalize a declarative class-based refinement type calculus (named RFJ), that is expressive and concise. We rigorously develop the soundness meta-theory of this calculus, followed by its mechanization in Coq. Finally, to ensure the calculus’s verifiability, we propose an algorithmic verification approach based on a fragment of first-order logic (named LFJ), and implement this approach as a type checker.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.39", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sun,", + "last_name": "Ke", + "institution": "Peking University" + }, + { + "first_name": "Wang,", + "last_name": "Di", + "institution": "Peking University" + }, + { + "first_name": "Chen,", + "last_name": "Sheng", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Wang,", + "last_name": "Meng", + "institution": "University of Bristol" + }, + { + "first_name": "Hao,", + "last_name": "Dan", + "institution": "Peking University" + } + ], + "dblp_key": "conf/ecoop/Sun000024", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.40", + "title": "Information Flow Control in Cyclic Process Networks", + "abstract": "Protection of confidential data is an important security consideration of today's applications. Of particular concern is to guard against unintentional leakage to a (malicious) observer, who may interact with the program and draw inference from made observations. Information flow control (IFC) type systems address this concern by statically ruling out such leakage. This paper contributes an IFC type system for message-passing concurrent programs, the computational model of choice for many of today's applications such as cloud computing and IoT applications. Such applications typically either implicitly or explicitly codify protocols according to which message exchange must happen, and to statically ensure protocol safety, behavioral type systems such as session types can be used. This paper marries IFC with session typing and contributes over prior work in the following regards: (1) support of realistic cyclic process networks as opposed to the restriction to tree-shaped networks, (2) more permissive, yet entirely secure, IFC control, exploiting cyclic process networks, and (3) considering deadlocks as another form of side channel, and asserting deadlock-sensitive noninterference (DSNI) for well-typed programs. To prove DSNI, the paper develops a novel logical relation that accounts for cyclic process networks. The logical relation is rooted in linear logic, but drops the tree-topology restriction imposed by prior work.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.40", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bas van den", + "last_name": "Heuvel", + "institution": "University of Freiburg" + }, + { + "first_name": "Farzaneh", + "last_name": "Derakhshan", + "institution": "Illinois Institute of Technology" + }, + { + "first_name": "Stephanie", + "last_name": "Balzer", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/ecoop/0001DB24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.43", + "title": "Inductive Predicate Synthesis Modulo Programs", + "abstract": "A growing trend in program analysis is to encode verification conditions within the language of the input program. This simplifies the design of analysis tools by utilizing off-the-shelf verifiers, but makes communication with the underlying solver more challenging. Essentially, the analyzer operates at the level of input programs, whereas the solver operates at the level of problem encodings. To bridge this gap, the verifier must pass along proof-rules from the analyzer to the solver. For example, an analyzer for concurrent programs built on an inductive program verifier might need to declare Owicki-Gries style proof-rules for the underlying solver. Each such proof-rule further specifies how a program should be verified, meaning that the problem of passing proof-rules is a form of invariant synthesis. Similarly, many program analysis tasks reduce to the synthesis of pure, loop-free Boolean functions (i.e., predicates), relative to a program. From this observation, we propose Inductive Predicate Synthesis Modulo Programs (IPS-MP) which extends high-level languages with minimal synthesis features to guide analysis. In IPS-MP, unknown predicates appear under assume and assert statements, acting as specifications modulo the program semantics. Existing synthesis solvers are inefficient at IPS-MP as they target more general problems. In this paper, we show that IPS-MP admits an efficient solution in the Boolean case, despite being generally undecidable. Moreover, we show that IPS-MP reduces to the satisfiability of constrained Horn clauses, which is less general than existing synthesis problems, yet expressive enough to encode verification tasks. We provide reductions from challenging verification tasks -- such as parameterized model checking -- to IPS-MP. We realize these reductions with an efficient IPS-MP-solver based on SeaHorn, and describe a application to smart-contract verification.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.43", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Scott", + "last_name": "Wesley", + "institution": "Dalhousie University" + }, + { + "first_name": "Maria", + "last_name": "Christakis", + "institution": "TU Wien" + }, + { + "first_name": "Jorge A.", + "last_name": "Navas", + "institution": "" + }, + { + "first_name": "Richard", + "last_name": "Trefler", + "institution": "University of Waterloo" + }, + { + "first_name": "Valentin", + "last_name": "Wüstholz", + "institution": "" + }, + { + "first_name": "Arie", + "last_name": "Gurfinkel", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/ecoop/WesleyCNTWG24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.42", + "title": "Failure Transparency in Stateful Dataflow Systems", + "abstract": "Failure transparency enables users to reason about distributed systems at a higher level of abstraction, where complex failure-handling logic is hidden. This is especially true for stateful dataflow systems, which are the backbone of many cloud applications. In particular, this paper focuses on proving failure transparency in Apache Flink, a popular stateful dataflow system. Even though failure transparency is a critical aspect of Apache Flink, to date it has not been formally proven. Showing that the failure transparency mechanism is correct, however, is challenging due to the complexity of the mechanism itself. Nevertheless, this complexity can be effectively hidden behind a failure transparent programming interface. To show that Apache Flink is failure transparent, we model it in small-step operational semantics. Next, we provide a novel definition of failure transparency based on observational explainability, a concept which relates executions according to their observations. Finally, we provide a formal proof of failure transparency for the implementation model; i.e., we prove that the failure-free model correctly abstracts from the failure-related details of the implementation model. We also show liveness of the implementation model under a fair execution assumption. These results are a first step towards a verified stack for stateful dataflow systems.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.42", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aleksey Kirillovich", + "last_name": "Veresov", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Jonas", + "last_name": "Spenger", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Paris", + "last_name": "Carbone", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Philipp", + "last_name": "Haller", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/ecoop/VeresovSCH24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.47", + "title": "Defining Name Accessibility Using Scope Graphs", + "abstract": "Many programming languages allow programmers to regulate accessibility; i.e., annotating a declaration with keywords such as export and private to indicate where it can be accessed. Despite the importance of name accessibility for, e.g., compilers, editor auto-completion and tooling, and automated refactorings, few existing type systems provide a formal account of name accessibility. We present a declarative, executable, and language-parametric model for name accessibility, which provides a formal specification of name accessibility in Java, C#, C++, Rust, and Eiffel. We achieve this by defining name accessibility as a predicate on resolution paths through scope graphs. Since scope graphs are a language-independent model of name resolution, our model provides a uniform approach to defining different accessibility policies for different languages. Our model is implemented in Statix, a logic language for executable type system specification using scope graphs. We evaluate its correctness on a test suite that compares it with the C#, Java, and Rust compilers, and show we can synthesize access modifiers in programs with holes accurately.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.47", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Zwaan,", + "last_name": "Aron", + "institution": "Delft University of Technology" + }, + { + "first_name": "Bach Poulsen,", + "last_name": "Casper", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "conf/ecoop/ZwaanP24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.45", + "title": "Higher-Order Specifications for Deductive Synthesis of Programs with Pointers", + "abstract": "Synthetic Separation Logic (SSL) is a formalism that powers SuSLik, the state-of-the-art approach for the deductive synthesis of provably-correct programs in C-like languages that manipulate heap-based linked data structures. Despite its expressivity, SSL suffers from two shortcomings that hinder its utility. First, its main specification component, inductive predicates, only admits first-order definitions of data structure shapes, which leads to the proliferation of “boiler-plate” predicates for specifying common patterns. Second, SSL requires concrete definitions of data structures to synthesise programs that manipulate them, which results in the need to change a specification for a synthesis task every time changes are introduced into the layout of the involved structures. We propose to significantly lift the level of abstraction used in writing Separation Logic specifications for synthesis – both simplifying the approach and making the specifications more usable and easy to read and follow. We avoid the need to repetitively re-state low-level representation details throughout the specifications – allowing the reuse of different implementations of the same data structure by abstracting away the details of a specific layout used in memory. Our novel high-level front-end language called Pika significantly improves the expressiveness of SuSLik. We implemented a layout-agnostic synthesiser from Pika to SuSLik enabling push-button synthesis of C programs with in-place memory updates, along with the accompanying full proofs that they meet Separation Logic-style specifications, from high-level specifications that resemble ordinary functional programs. Our experiments show that our tool can produce C code that is comparable in its performance characteristics and is sometimes faster than Haskell.", + "date": "2024-09-12", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.45", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "David", + "last_name": "Young", + "institution": "" + }, + { + "first_name": "Ziyi", + "last_name": "Yang", + "institution": "" + }, + { + "first_name": "Ilya", + "last_name": "Sergey", + "institution": "" + }, + { + "first_name": "Alex", + "last_name": "Potanin", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/YoungYSP24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.44", + "title": "Type Tailoring", + "abstract": "Type systems evolve too slowly to keep up with the quick evolution of libraries - especially libraries that introduce abstractions. Type tailoring offers a lightweight solution by equipping the core language with an API for modifying the elaboration of surface code into the internal language of the typechecker. Through user-programmable elaboration, tailoring rules appear to improve the precision and expressiveness of the underlying type system. Furthermore, type tailoring cooperates with the host type system by expanding to code that the host then typechecks. In the context of a hygienic metaprogramming system, tailoring rules can even harmoniously compose with one another. Type tailoring has emerged as a theme across several languages and metaprogramming systems, but never with direct support and rarely in the same shape twice. For example, both OCaml and Typed Racket enable forms of tailoring, but in quite different ways. This paper identifies key dimensions of type tailoring systems and tradeoffs along each dimension. It demonstrates the usefulness of tailoring with examples that cover sized vectors, database queries, and optional types. Finally, it outlines a vision for future research at the intersection of types and metaprogramming.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.44", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Wiersdorf,", + "last_name": "Ashton", + "institution": "University of Utah" + }, + { + "first_name": "Chang,", + "last_name": "Stephen", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Felleisen,", + "last_name": "Matthias", + "institution": "Northeastern University" + }, + { + "first_name": "Greenman,", + "last_name": "Ben", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/ecoop/Wiersdorf0FG24", + "venue": "ecoop", + "year": 2024 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2024.46", + "title": "{CtChecker}: A Precise, Sound and Efficient Static Analysis for Constant-Time Programming", + "abstract": "Timing channel attacks are emerging as real-world threats to computer security. In cryptographic systems, an effective countermeasure against timing attacks is the constant-time programming discipline. However, strictly enforcing the discipline manually is both time-consuming and error-prone. While various tools exist for analyzing/verifying constant-time programs, they sacrifice at least one feature among precision, soundness and efficiency. In this paper, we build CtChecker, a sound static analysis for constant-time programming. Under the hood, CtChecker uses a static information flow analysis to identify violations of constant-time discipline. Despite the common wisdom that sound, static information flow analysis lacks precision for real-world applications, we show that by enabling field-sensitivity, context-sensitivity and partial flow-sensitivity, CtChecker reports fewer false positives compared with existing sound tools. Evaluation on real-world cryptographic systems shows that CtChecker analyzes 24K lines of source code in under one minute. Moreover, CtChecker reveals that some repaired code generated by program rewriters supposedly remove timing channels are still not constant-time.", + "date": "2024-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2024.46", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Zhou,", + "last_name": "Quan", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Dang,", + "last_name": "Sixuan", + "institution": "Duke University" + }, + { + "first_name": "Zhang,", + "last_name": "Danfeng", + "institution": "Duke University" + } + ], + "dblp_key": "conf/ecoop/ZhouDZ24", + "venue": "ecoop", + "year": 2024 + } +] \ No newline at end of file diff --git a/data/pl_conferences/ecoop/2025.json b/data/pl_conferences/ecoop/2025.json new file mode 100644 index 0000000..19bf66a --- /dev/null +++ b/data/pl_conferences/ecoop/2025.json @@ -0,0 +1,1296 @@ +[ + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.0", + "title": "Front Matter, Table of Contents, Preface, Conference Organization", + "abstract": "Front Matter, Table of Contents, Preface, Conference Organization", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.0", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Aldrich,", + "last_name": "Jonathan", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Silva,", + "last_name": "Alexandra", + "institution": "Cornell University" + } + ], + "dblp_key": "conf/ecoop/X25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.12", + "title": "Automatic Goal Clone Detection in Rocq", + "abstract": "Proof engineering in Rocq is a labor-intensive process, and as proof developments grow in size, redundancy and maintainability become challenges. One such redundancy is goal cloning, i.e., proving α-equivalent goals multiple times, leading to wasted effort and bloated proof scripts. In this paper, we introduce clone-finder, a novel technique for detecting goal clones in Rocq proofs. By leveraging the formal notion of α-equivalence for Gallina terms, clone-finder systematically identifies duplicated proof goals across large Rocq codebases. We evaluate clone-finder on 40 real-world Rocq projects from the CoqGym dataset. Our results reveal that each project contains an average of 27.73 instances of goal clone. We observed that the clones can be categorized as either exact goal duplication, generalization, or α-equivalent goals with different proofs, each signifying varying levels duplicate effort. Our findings highlight significant untapped potential for proof reuse in Rocq-based formal verification projects, paving the way for future improvements in automated proof engineering.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.12", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ghanbari,", + "last_name": "Ali", + "institution": "Auburn University" + } + ], + "dblp_key": "conf/ecoop/000125", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.2", + "title": "The Algebra of Patterns", + "abstract": "Pattern matching is a popular feature in functional, imperative and object-oriented programming languages. Language designers should therefore invest effort in a good design for pattern matching. Most languages choose a first-match semantics for pattern matching; that is, clauses are tried in the order in which they appear in the program until the first one matches. As a consequence, the order in which the clauses appear cannot be arbitrarily changed, which results in a less declarative programming model. The declarative alternative to this is an order-independent semantics for pattern matching, which is not implemented in most programming languages since it requires more verbose patterns. The reason for this verbosity is that the syntax of patterns is usually not expressive enough to express the complement of a pattern. In this paper, we show a principled way to make order-independent pattern matching practical. Our solution consists of two parts: First, we introduce a boolean algebra of patterns which can express the complement of a pattern. Second, we introduce default clauses to pattern matches. These default clauses capture the essential idea of a fallthrough case without sacrificing the property of order-independence.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.2", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Binder,", + "last_name": "David", + "institution": "University of Kent" + }, + { + "first_name": "Ermantraut,", + "last_name": "Lean", + "institution": "Radboud University Nijmegen" + } + ], + "dblp_key": "conf/ecoop/BinderE25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.5", + "title": "Compositional Bug Detection for Internally Unsafe Libraries: A Logical Approach to Type Unsoundness", + "abstract": "Rust is a modern programming language marrying the best of language design by offering fine-grained control over system resources (thus enabling efficient implementations), while simultaneously ensuring memory safety and data-race freedom. However, ensuring type safety in internally unsafe libraries remains an important and non-trivial challenge, where unsafe features enable low-level control but can introduce undefined behaviour (UB). Existing works on reasoning about unsafe code either use verification techniques to show correctness (i.e. safety, useful only when the unsafe code is indeed correct), or use bug detection techniques to show incorrectness (i.e. unsafety) but fail to do so automatically (to avoid developer burden), compositionally (to support libraries without a main function), soundly (without false positives) and generally (rather than applying to specific patterns). We close this gap by developing RUXt, a fully automatic, compositional bug detection technique for detecting UB in internally unsafe Rust libraries with a formal inadequacy theorem (formalised and proven in Rocq) providing a no-false-positives guarantee. RUXt leverages the Rust type system to under-approximate the set of safe values for user-defined types and detect safety violations without requiring manual annotations by the user. By encoding well-typed values in Rust as separation logic assertions, RUXt enables compositional reasoning about types to refute unsound type signatures and detect UB. The inadequacy theorem of RUXt ensures that each UB detected by RUXt in an internally unsafe library is a true safety violation that can be triggered by a safe program, i.e. one that solely interacts with the safe API of the library. To this end, when RUXt identifies a UB, it additionally produces a safe program witnessing the UB. In addition, we develop a prototype implementation in OCaml that can analyse programs written in a small model of Rust, and apply it to several case studies, showcasing its ability to detect true safety violations.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.5", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Carrott,", + "last_name": "Pedro", + "institution": "Imperial College London" + }, + { + "first_name": "Ayoun,", + "last_name": "Sacha-Élie", + "institution": "Imperial College London" + }, + { + "first_name": "Raad,", + "last_name": "Azalea", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/CarrottAR25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.4", + "title": "Ensuring Convergence and Invariants Without Coordination", + "abstract": "The CAP theorem demonstrates a trade-off between consistency and availability (and, by extension, latency) in systems where network partitions are unavoidable, such as in cloud computing and local-first software. While adopting weak consistency can preserve availability, it may result in inconsistencies that compromise application correctness. Replicated data types provide a principled, coordination-free approach to guarantee convergence but do not consider application invariants. Existing methods for maintaining invariants in replicated systems either rely on coordination - undermining the benefits of weak consistency - or suffer from limited applicability. This paper introduces the No-Op framework, a generic approach for enforcing consistency without coordination while guaranteeing both convergence and invariant preservation. The core idea of the No-Op approach is to resolve conflicts among concurrent operations by prioritising one operation over the other according to programmer-defined conflict resolution policies. This prioritisation transforms the less-preferred operation into a no-side-effect operation, ensuring conflict-free execution. We formalise the model underlying the No-Op framework and introduce a replication protocol built upon it, accompanied by a formal proof of correctness for both the framework and the protocol. Furthermore, we demonstrate the framework’s applicability by showcasing the design of widely used replicated data types and the preservation of a wide range of application invariants.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.4", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Borrego,", + "last_name": "Dina", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Preguiça,", + "last_name": "Nuno", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Gonzalez Boix,", + "last_name": "Elisa", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Ferreira,", + "last_name": "Carla", + "institution": "Universidade Nova de Lisboa" + } + ], + "dblp_key": "conf/ecoop/BorregoPB025", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.1", + "title": "A Theory of (Linear-Time) Timed Monitors", + "abstract": "Runtime Verification (RV) is gaining popularity due to its scalability and ability to analyse block-box systems. Monitoring is at the heart of RV; a logical formula ϕ, formalising some property of interest, is typically translated into a monitor that checks whether the system under scrutiny satisfies ϕ during its execution. A logical formula ϕ is violation (resp. satisfaction) monitorable iff there exists a monitor for ϕ that is both sound and complete w.r.t. its violation (resp. satisfaction). The monitorability problem is thus concerned with determining the largest subset of a logic L that is monitorable. Although this problem has been solved for expressive untimed logics, it remains open for timed logics, where formulae can express both the order of events and the quantity of time separating them. This paper solves the monitorability problem for T^lin, a new expressive (linear-time) timed μ-calculus that we propose. First, we show that T^lin is strictly more expressive than MTL, the de facto timed extension of LTL. Second, we identify MT^lin, the largest monitorable fragment of T^lin: we characterise its largest subsets of formulae that are violation monitorable, satisfaction monitorable, and complete monitorable (both satisfaction and violation monitorable). To wit, this is the first work that answers the monitorability question for such an expressive timed logic.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.1", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Amara,", + "last_name": "Mouloud", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Giovanni", + "last_name": "Bernardi", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Mohammed", + "last_name": "Foughali", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Adrian", + "last_name": "Francalanza", + "institution": "University of Malta" + } + ], + "dblp_key": "conf/ecoop/Amara0FF25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.3", + "title": "Pydrofoil: Accelerating Sail-Based Instruction Set Simulators", + "abstract": "We present Pydrofoil, a multi-stage compiler that generates instruction set simulators (ISSs) from processor instruction set architectures (ISAs) expressed in the high-level, verification-oriented ISA specification language Sail. Pydrofoil achieves a > 230× speedup over the C-based ISS generated by Sail on our benchmarks, thanks to the following insights. (i) An ISS is effectively an interpreter loop, and tracing just-in-time (JIT) compilers have proven effective at accelerating those, albeit mostly for dynamically typed languages. (ii) ISS workloads are highly atypical, dominated by intensive bit manipulation operations. Conventional compiler optimisations for general-purpose programming languages have limited impact for speeding up such workloads. We develop suitable domain-specific optimisations. (iii) Neither tracing JIT compilers, nor ahead-of-time (AOT) compilation alone, even with domain-specific optimisations, suffice for the generation of performant ISSs. Pydrofoil therefore implements a hybrid approach, pairing an AOT compiler with a tracing JIT built on the meta-tracing PyPy framework. AOT and JIT use domain-specific optimisations. Our benchmarks demonstrate that combining AOT and JIT compilers provides significantly greater performance gains than using either compiler alone.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.3", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Bolz-Tereick, Carl", + "last_name": "Friedrich", + "institution": "Heinrich Heine University Düsseldorf" + }, + { + "first_name": "Panayi,", + "last_name": "Luke", + "institution": "Imperial College London" + }, + { + "first_name": "McKeogh,", + "last_name": "Ferdia", + "institution": "University of St Andrews" + }, + { + "first_name": "Spink,", + "last_name": "Tom", + "institution": "University of St Andrews" + }, + { + "first_name": "Berger,", + "last_name": "Martin", + "institution": "University of Sussex" + } + ], + "dblp_key": "conf/ecoop/Bolz-TereickPMS25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.15", + "title": "Spegion: Implicit and Non-Lexical Regions with Sized Allocations", + "abstract": "Region based memory management is a powerful tool designed with the goal of ensuring memory safety statically. The region calculus of Tofte and Talpin is a well known example of a region based system, which uses regions to manage memory in a stack-like fashion. However, the region calculus is lexically scoped and requires explicit annotation of memory regions, which can be cumbersome for the programmer. Other systems have addressed non-lexical regions, but these approaches typically require the use of a substructural type system to track the lifetimes of regions. We present Spegion, a language with implicit non-lexical regions, which provides these same memory safety guarantees for programs that go beyond using memory allocation in a stack-like manner. We are able to achieve this with a concise syntax, and without the use of substructural types, relying instead on an effect system to enforce constraints on region allocation and deallocation. These regions may be divided into sub-regions, i.e., Splittable rEgions, allowing fine grained control over memory allocation. Furthermore, Spegion permits sized allocations, where each value has an associated size which is used to ensure that regions are not over-allocated into. We present a type system for Spegion and prove it is type safe with respect to a small-step operational semantics.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.15", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Hughes,", + "last_name": "Jack", + "institution": "University of Kent" + }, + { + "first_name": "Vollmer,", + "last_name": "Michael", + "institution": "University of Kent" + }, + { + "first_name": "Batty,", + "last_name": "Mark", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/ecoop/00020B25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.10", + "title": "Bottom-Up Synthesis of Memory Mutations with Separation Logic", + "abstract": "Programming-by-Example (PBE) is the paradigm of program synthesis specified via input-output pairs. It is commonly used because examples are easy to provide and collect from the environment. A popular optimization for enumerative synthesis with examples is Observational Equivalence (OE), which groups programs into equivalence classes according to their evaluation on example inputs. Current formulations of OE, however, are severely limited by the assumption that the synthesizer’s target language contains only pure components with no side-effects, either enforcing this in their target language, or ignoring it, leading to an incorrect enumeration. This limits their ability to use realistic component sets. We address this limitation by borrowing from Separation Logic, which can compositionally reason about heap mutations. We reformulate PBE using a restricted Separation Logic: Concrete Heap Separation Logic (CHSL), transforming the search for programs into a proof search in CHSL. This lets us perform bottom-up enumerative synthesis without the need for expert-provided annotations or domain-specific inferences, but with three key advantages: we (i) preserve correctness in the presence of memory-mutating operations, (ii) compact the search space by representing many concrete programs as one under CHSL, and (iii) perform a provably correct OE-reduction. We present SObEq (Side-effects in OBservational EQuivalence), a bottom-up enumerative algorithm that, given a PBE task, searches for its CHSL derivation. The SObEq algorithm is proved correct with no purity assumptions: we show it is guaranteed to lose no solutions. We also evaluate our implementation of SObEq on benchmarks from the literature and online sources, and show that it produces high-quality results quickly.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.10", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ferdowsi,", + "last_name": "Kasra", + "institution": "University of California San Diego" + }, + { + "first_name": "Peleg,", + "last_name": "Hila", + "institution": "Technion – Israel Institute of Technology" + } + ], + "dblp_key": "conf/ecoop/FerdowsiP25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.11", + "title": "Contract Usage and Evolution in Android Mobile Applications", + "abstract": "Contracts and assertions are effective methods to enhance software quality by enforcing preconditions, postconditions, and invariants. Previous research has demonstrated the value of contracts in traditional software development. However, the adoption and impact of contracts in the context of mobile app development, particularly of Android apps, remain unexplored. To address this, we present the first large-scale empirical study on the use of contracts in Android apps, written in Java or Kotlin. We consider contract elements divided into five categories: conditional runtime exceptions, APIs, annotations, assertions, and other. We analyzed 2,390 Android apps from the F-Droid repository and processed 52,977 KLOC to determine 1) how and to what extent contracts are used, 2) which language features are used to denote contracts, 3) how contract usage evolves from the first to the last version, and 4) whether contracts are used safely in the context of program evolution and inheritance. Our findings include: 1) although most apps do not specify contracts, annotation-based approaches are the most popular; 2) apps that use contracts continue to use them in later versions, but the number of methods increases at a higher rate than the number of contracts; and 3) there are potentially unsafe specification changes when apps evolve and in subtyping relationships, which indicates a lack of specification stability. Finally, we present a qualitative study that gathers challenges faced by practitioners when using contracts and that validates our recommendations.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.11", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Ferreira, David", + "last_name": "R.", + "institution": "Universidade do Porto" + }, + { + "first_name": "Mendes,", + "last_name": "Alexandra", + "institution": "Universidade do Porto" + }, + { + "first_name": "Ferreira, João", + "last_name": "F.", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + }, + { + "first_name": "Carreira,", + "last_name": "Carolina", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + } + ], + "dblp_key": "conf/ecoop/FerreiraM0C25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.13", + "title": "FuzzFlesh: Randomised Testing of Decompilers via Control Flow Graph-Based Program Generation", + "abstract": "Decompilation is the process of translating compiled code into high-level code. Control flow recovery is a challenging part of the process. \"Misdecompilations\" can occur, whereby the decompiled code does not accurately represent the semantics of the compiled code, despite it being syntactically valid. This is problematic because it can mislead users who are trying to reason about the program. We present CFG-based program generation: a novel approach to randomised testing that aims to improve the control flow recovery of decompilers. CFG-based program generation involves randomly generating control flow graphs (CFGs) and paths through each graph. Inspired by prior work in the domain of GPU computing, (CFG, path) pairs are \"fleshed\" into test programs. Each program is decompiled and recompiled. The test oracle verifies whether the actual runtime path through the graph matches the expected path. Any difference in the execution paths after recompilation indicates a possible misdecompilation. A key benefit of this approach is that it is largely independent of the source and target languages in question because it is focused on control flow. The approach is therefore applicable to numerous decompilation settings. The trade-off resulting from the focus on control flow is that misdecompilation bugs that do not relate to control flow (e.g. bugs that involve specific arithmetic operations) are out of scope. We have implemented this approach in FuzzFlesh, an open-source randomised testing tool. FuzzFlesh can be easily configured to target a variety of low-level languages and decompiler toolchains because most of the CFG and path generation process is language-independent. At present, FuzzFlesh supports testing decompilation of Java bytecode, .NET assembly and x86 machine code. In addition to program generation, FuzzFlesh also includes an automated test-case reducer that operates on the CFG rather than the low-level program, which means that it can be applied to any of the target languages. We present a large experimental campaign applying FuzzFlesh to a variety of decompilers, leading to the discovery of 12 previously-unknown bugs across two language formats, six of which have been fixed. We present experiments comparing our generic FuzzFlesh tool to two state-of-the-art decompiler testing tools targeted at specific languages. As expected, the coverage our generic FuzzFlesh tool achieves on a given decompiler is lower than the coverage achieved by a tool specifically designed for the input format of that decompiler. However, due to its focus on control flow, FuzzFlesh is able to cover sections of control flow recovery code that the targeted tools cannot reach, and identify control flow related bugs that the targeted tools miss.", + "date": "2022-02-24", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.13", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Pemma", + "last_name": "Reiter", + "institution": "" + }, + { + "first_name": "Hui Jun", + "last_name": "Tay", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/GorzynskiD25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.14", + "title": "IsaBIL: A Framework for Verifying (In)correctness of Binaries in Isabelle/HOL", + "abstract": "This paper presents IsaBIL, a binary analysis framework in Isabelle/HOL that is based on the widely used Binary Analysis Platform (BAP). Specifically, in IsaBIL, we formalise BAP’s intermediate language, called BIL and integrate it with Hoare logic (to enable proofs of correctness) as well as incorrectness logic (to enable proofs of incorrectness). IsaBIL inherits the full flexibility of BAP, allowing us to verify binaries for a wide range of languages (C, C++, Rust), toolchains (LLVM, Ghidra) and target architectures (x86, RISC-V), and can also be used when the source code for a binary is unavailable. To make verification tractable, we develop a number of big-step rules that combine BIL’s existing small-step rules at different levels of abstraction to support reuse. We develop high-level reasoning rules for RISC-V instructions (our main target architecture) to further optimise verification. Additionally, we develop Isabelle proof tactics that exploit common patterns in C binaries for RISC-V to discharge large numbers of proof goals (often in the 100s) automatically. IsaBIL includes an Isabelle/ML based parser for BIL programs, allowing one to automatically generate the associated Isabelle/HOL program locale from a BAP output. Taken together, IsaBIL provides a highly flexible proof environment for program binaries. As examples, we prove correctness of key examples from the Joint Strike Fighter coding standards and the MITRE database.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.14", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Griffin,", + "last_name": "Matt", + "institution": "University of Surrey" + }, + { + "first_name": "Dongol,", + "last_name": "Brijesh", + "institution": "University of Surrey" + }, + { + "first_name": "Raad,", + "last_name": "Azalea", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/GriffinDR25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.9", + "title": "Event Race Detection for Node.js Using Delay Injections", + "abstract": "Node.js is a widely used platform for building JavaScript server-side web applications, desktop applications, and software engineering tools. Its asynchronous execution model is essential for performance, but also gives rise to event races, which cause many subtle bugs that can be hard to detect and reproduce. Current solutions to expose such races are based on modifications of the source code of the Node.js system or on guided executions using complex happens-before modeling. This paper presents a simpler and more effective approach called NACD that works by dynamically instrumenting core asynchronous operations in the Node.js runtime system to inject delays and thereby reveal event race bugs. It consists of a small, robust runtime instrumentation module implemented in JavaScript that is configured by a flexible JSON model of the essential parts of the Node.js API. Experimental results show that NACD can reproduce event race bugs with higher probability and fewer runs than state-of-the-art tools.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.9", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Endo, Andre", + "last_name": "Takeshi", + "institution": "Universidade Federal de São Carlos" + }, + { + "first_name": "Møller,", + "last_name": "Anders", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/ecoop/EndoM25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.6", + "title": "Detecting Functionality-Specific Vulnerabilities via Retrieving Individual Functionality-Equivalent APIs in Open-Source Repositories", + "abstract": "Functionality-specific vulnerabilities, which mainly occur in Application Programming Interfaces (APIs) with specific functionalities, are crucial for software developers to detect and avoid. When detecting individual functionality-specific vulnerabilities, the existing two categories of approaches are ineffective because they consider only the API bodies and are unable to handle diverse implementations of functionality-equivalent APIs. To effectively detect functionality-specific vulnerabilities, we propose APISS, the first approach to utilize API doc strings and signatures instead of API bodies. APISS first retrieves functionality-equivalent APIs for APIs with existing vulnerabilities and then migrates Proof-of-Concepts (PoCs) of the existing vulnerabilities for newly detected vulnerable APIs. To retrieve functionality-equivalent APIs, we leverage a Large Language Model for API embedding to improve the accuracy and address the effectiveness and scalability issues suffered by the existing approaches. To migrate PoCs of the existing vulnerabilities for newly detected vulnerable APIs, we design a semi-automatic schema to substantially reduce manual costs. We conduct a comprehensive evaluation to empirically compare APISS with four state-of-the-art approaches of detecting vulnerabilities and two state-of-the-art approaches of retrieving functionality-equivalent APIs. The evaluation subjects include 180 widely used Java repositories using 10 existing vulnerabilities, along with their PoCs. The results show that APISS effectively retrieves functionality-equivalent APIs, achieving a Top-1 Accuracy of 0.81 while the best of the baselines under comparison achieves only 0.55. APISS is highly efficient: the manual costs are within 10 minutes per vulnerability and the end-to-end runtime overhead of testing one candidate API is less than 2 hours. APISS detects 179 new vulnerabilities and receives 60 new CVE IDs, bringing high value to security practice.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.6", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Chen,", + "last_name": "Tianyu", + "institution": "Peking University" + }, + { + "first_name": "Wang,", + "last_name": "Zeyu", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Li,", + "last_name": "Lin", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Li,", + "last_name": "Ding", + "institution": "Peking University" + }, + { + "first_name": "Li,", + "last_name": "Zongyang", + "institution": "Peking University" + }, + { + "first_name": "Chang,", + "last_name": "Xiaoning", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Bian,", + "last_name": "Pan", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Liang,", + "last_name": "Guangtai", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Wang,", + "last_name": "Qianxiang", + "institution": "Huawei Technologies (China)" + }, + { + "first_name": "Xie,", + "last_name": "Tao", + "institution": "Peking University" + } + ], + "dblp_key": "conf/ecoop/ChenWL0LCBLW025", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.8", + "title": "An Effectful Object Calculus", + "abstract": "We show how to smoothly incorporate in the object-oriented paradigm constructs to raise, compose, and handle effects in an arbitrary monad. The underlying pure calculus is meant to be a representative of the last generation of OO languages, and the effectful extension is manageable enough for ordinary programmers; notably, constructs to raise effects are just special methods. We equip the calculus with an expressive type-and-effect system, which, again by relying on standard features such as inheritance and generic types, allows a simple form of effect polymorphism. The soundness of the type-and-effect system is expressed and proved by a recently introduced technique, where the semantics is formalized by a one-step reduction relation from language expressions into monadic ones, so that it is enough to prove progress and subject reduction properties on this relation.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.8", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dagnino,", + "last_name": "Francesco", + "institution": "University of Genoa" + }, + { + "first_name": "Giannini,", + "last_name": "Paola", + "institution": "Università degli Studi del Piemonte Orientale “Amedeo Avogadro”" + }, + { + "first_name": "Zucca,", + "last_name": "Elena", + "institution": "University of Genoa" + } + ], + "dblp_key": "conf/ecoop/DagninoGZ25a", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.7", + "title": "Monadic Type-And-Effect Soundness", + "abstract": "We introduce the abstract notions of monadic operational semantics, a small-step semantics where computational effects are modularly modeled by a monad, and type-and-effect system, including effect types whose interpretation lifts well-typedness to its monadic version. In this meta-theory, as usual in the non-monadic case, we can express progress and subject reduction, and provide a proof, given once and for all, that they imply soundness. The approach is illustrated on a lambda calculus with generic effects, equipped with an expressive type-and-effect system We provide proofs of progress and subject reduction, parametric on the interpretation of effect types. In this way, we obtain as instances many significant examples, such as checking exceptions, preventing/limiting non-determinism, constraining order/fairness of outputs. We also provide an extension with constructs to raise and handle computational effects, which can be instantiated to model different policies.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.7", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dagnino", + "last_name": "F.", + "institution": "" + }, + { + "first_name": "Giannini", + "last_name": "P.", + "institution": "" + }, + { + "first_name": "Zucca", + "last_name": "E.", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/DagninoGZ25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.16", + "title": "A Lightweight Method for Generating Multi-Tier JIT Compilation Virtual Machine in a Meta-Tracing Compiler Framework", + "abstract": "Meta-compiler frameworks, such as RPython and Graal/Truffle, generate high-performance virtual machines (VMs) from interpreter definitions. Although they generate VMs with high-quality just-in-time (JIT) compilers, they still lack an important feature that dedicated VMs (i.e., VMs that are developed for specific languages) have, namely multi-tier compilation. Multi-tier compilation uses light-weight compilers at early stages and highly optimizing compilers at later stages in order to balance between compilation overheads and code quality. We propose a novel approach to enabling multi-tier compilation in the VMs generated by a meta-compiler framework. Instead of extending the JIT compiler backend of the framework, our approach drives an existing (heavyweight) compiler backend in the framework to quickly generate unoptimized native code by merely embedding directives and compile-time operations into interpreter definitions. As a validation of the approach, we developed 2SOM, a Simple Object Machine with a two-tier JIT compiler based on RPython. 2SOM first applies the tier-1 threaded code generator that is generated by our proposed technique, then, to the loops that exceed a threshold, applies the tier-2 tracing JIT compiler that is generated by the original RPython framework. Our performance evaluation that runs a program with a realistic workload showed that 2SOM improved, when compared against an RPython-based VM, warm-up performance by 15%, with merely a 5% reduction in peak performance.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.16", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Izawa,", + "last_name": "Yusuke", + "institution": "Tokyo Metropolitan University" + }, + { + "first_name": "Masuhara,", + "last_name": "Hidehiko", + "institution": "Institute of Science Tokyo" + }, + { + "first_name": "Bolz-Tereick, Carl", + "last_name": "Friedrich", + "institution": "Heinrich Heine University Düsseldorf" + } + ], + "dblp_key": "conf/ecoop/IzawaMB25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.17", + "title": "Contrasting Deadlock-Free Session Processes", + "abstract": "Deadlock freedom is a crucial property for message-passing programs. Over the years, several different type systems for concurrent processes that ensure deadlock freedom have been proposed; this diversity raises the question of how they compare. We address this question, considering two type systems not covered in prior work: Kokke etal's HCP, a type system based on a linear logic with hypersequents, and Padovani's priority-based type system for asynchronous processes, dubbed P. Their distinctive features make formal comparisons relevant and challenging. Our findings are two-fold: (1) the hypersequent setting does not drastically change the class of deadlock-free processes induced by linear logic, and (2) we relate the classes of deadlock-free processes induced by HCP and P. We prove that our results hold under both synchronous and asynchronous communication. Our results provide new insights into the essential mechanisms involved in statically avoiding deadlocks in concurrency.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.17", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Juan C.", + "last_name": "Jaramillo", + "institution": "University of Groningen" + }, + { + "first_name": "Jorge A.", + "last_name": "Pérez", + "institution": "University of Groningen" + } + ], + "dblp_key": "conf/ecoop/Jaramillo025", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.18", + "title": "Practical Type-Based Taint Checking and Inference", + "abstract": "Many important security properties can be formulated in terms of flows of tainted data, and improved taint analysis tools to prevent such flows are of critical need. Most existing taint analyses use whole-program static analysis, leading to scalability challenges. Type-based checking is a promising alternative, as it enables modular and incremental checking for fast performance. However, type-based approaches have not been widely adopted in practice, due to challenges with false positives and annotating existing codebases. In this paper, we present a new approach to type-based checking of taint properties that addresses these challenges, based on two key techniques. First, we present a new type-based tainting checker with significantly reduced false positives, via more practical handling of third-party libraries and other language constructs. Second, we present a novel technique to automatically infer tainting type qualifiers for existing code. Our technique supports inference of generic type argument annotations, crucial for tainting properties. We implemented our techniques in a tool TaintTyper and evaluated it on real-world benchmarks. TaintTyper exceeds the recall of a state-of-the-art whole-program taint analyzer, with comparable precision, and 2.93X-22.9X faster checking time. Further, TaintTyper infers annotations comparable to those written by hand, suitable for insertion into source code. TaintTyper is a promising new approach to efficient and practical taint checking.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.18", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Karimipour,", + "last_name": "Nima", + "institution": "University of California, Riverside" + }, + { + "first_name": "Das,", + "last_name": "Kanak", + "institution": "University of California, Riverside" + }, + { + "first_name": "Sridharan,", + "last_name": "Manu", + "institution": "University of California, Riverside" + }, + { + "first_name": "Hassanshahi,", + "last_name": "Behnaz", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/KarimipourDSH25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.20", + "title": "Incremental Computing by Differential Execution", + "abstract": "Incremental computing offers the potential for significant performance gains by efficiently updating computations in response to changing data. However, traditional approaches are either problem-specific or use an inefficient all-or-nothing strategy of rerunning affected computations entirely. This paper presents differential semantics, a novel approach that directly embeds the propagation of changes into the semantics of a general-purpose programming language. Given a precise description of input changes, differential semantics rules define how these changes are tracked and propagated through core language constructs like assignments, conditionals, and loops to produce corresponding output changes. We formalize differential semantics and verify key properties, including correctness, using the Rocq proof assistant. We also develop and formally prove a set of optimizations, particularly for loop handling, that enable asymptotic performance improvements. An implementation of the semantics as a differential interpreter achieves order-of-magnitude speedups over recomputation on the Bellman-Ford shortest path algorithm.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.20", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Kumar,", + "last_name": "Prashant", + "institution": "" + }, + { + "first_name": "Pacak,", + "last_name": "André", + "institution": "" + }, + { + "first_name": "Erdweg,", + "last_name": "Sebastian", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/KumarPE25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.19", + "title": "Profile-Guided Field Externalization in an Ahead-Of-Time Compiler", + "abstract": "Field externalization is a technique to reduce the footprint of objects by removing fields that most frequently contain zero or null. While researchers have developed ways to bring this optimization into the Java world, these have been limited to research compilers or virtual machines for embedded systems. In this work, we present a novel field externalization technique that uses information from static analysis and profiling to determine externalizable fields. During compilation, we remove those fields and define companion classes. These are used in case of non-default-value writes to the externalized fields. Our approach also correctly handles synchronization to prevent issues in multithreaded environments. We integrated our approach into the modern Java ahead-of-time compiler GraalVM Native Image. We conducted an evaluation on a diverse set of benchmarks that includes standard and microservice-based benchmarks. For standard benchmarks, our approach reduces the total allocated bytes by 2.76% and the maximum resident set size (max-RSS) by 2.55%. For microservice benchmarks, we achieved a reduction of 6.88% for normalized allocated bytes and 2.45% for max-RSS. We computed these improvements via the geometric mean. The median reductions are are 1.46% (alloc. bytes) and 0.22% (max-RSS) in standard benchmarks, as well as 3.63% (alloc. bytes) and 0.20% (max-RSS) in microservice benchmarks.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.19", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Kloibhofer,", + "last_name": "Sebastian", + "institution": "Johannes Kepler University of Linz" + }, + { + "first_name": "Makor,", + "last_name": "Lukas", + "institution": "Johannes Kepler University of Linz" + }, + { + "first_name": "Hofer,", + "last_name": "Peter", + "institution": "" + }, + { + "first_name": "Leopoldseder,", + "last_name": "David", + "institution": "" + }, + { + "first_name": "Mössenböck,", + "last_name": "Hanspeter", + "institution": "Johannes Kepler University of Linz" + } + ], + "dblp_key": "conf/ecoop/KloibhoferMHLM25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.29", + "title": "Declarative Dynamic Object Reclassification", + "abstract": "In object-oriented languages, dynamic object reclassification is a technique to change the class binding of an object at runtime. Current approaches express when and how to reclassify inside the program’s business code, while maintaining internal consistency. These approaches are less suited for programs that need to be consistent with an external context, such as autonomous systems interacting with a knowledge base. This paper proposes declarative dynamic object reclassification, a novel technique that provides a separation of concerns between a program’s business code and its adaptation logic for reclassification, expressed via a knowledge base. We present Featherweight Semantically Reflected Java, a minimal calculus for declarative dynamic object reclassification that enables the programmer to define consistency both internally (using a type system) and externally (using declarative classification queries). We use this calculus to study how internal and external consistency interact for declarative dynamic object reclassification. We further implement the technique by extending SMOL, a language for reflective programming via external knowledge bases.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.29", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Sieve,", + "last_name": "Riccardo", + "institution": "University of Oslo" + }, + { + "first_name": "Kamburjan,", + "last_name": "Eduard", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Damiani,", + "last_name": "Ferruccio", + "institution": "University of Turin" + }, + { + "first_name": "Johnsen, Einar", + "last_name": "Broch", + "institution": "University of Oslo" + } + ], + "dblp_key": "conf/ecoop/SieveKDJ25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.28", + "title": "Reusing Caches and Invariants for Efficient and Sound Incremental Static Analysis", + "abstract": "Static analysis by means of abstract interpretation is a tool of choice for proving absence of some classes of errors, typically undefined behaviors in C code, in a sound way. However, static analysis tools are hardly integrated in CI/CD processes. One of the main reasons is that they are still time- and memory-expensive to apply after every single patch when developing a program. For solving this issue, incremental static analysis helps developers quickly obtain analysis results after making changes to a program. However, existing approaches are often not guaranteed to be sound, limited to specific analyses, or tied to specific tools. This limits their generalizability and applicability in practice, especially for large and critical software. In this paper, we propose a generic, sound approach to incremental static analysis that is applicable to any abstract interpreter. Our approach leverages the similarity between two versions of a program to soundly reuse previously computed analysis results. We introduce novel methods for summarizing functions and reusing loop invariants. They significantly reduce the cost of reanalysis, while maintaining soundness and a high level of precision. We have formalized our approach, proved it sound, implemented it in Eva, the abstract interpreter of Frama-C, and evaluated it on a set of real-world commits of open-source programs.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.28", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Razafintsialonina,", + "last_name": "Mamy", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Bühler,", + "last_name": "David", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Miné,", + "last_name": "Antoine", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Perrelle,", + "last_name": "Valentin", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + }, + { + "first_name": "Signoles,", + "last_name": "Julien", + "institution": "Commissariat à l'Énergie Atomique et aux Énergies Alternatives" + } + ], + "dblp_key": "conf/ecoop/Razafintsialonina25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.27", + "title": "PoTo: A Hybrid Andersen's Points-To Analysis for Python", + "abstract": "As Python is increasingly being adopted for large and complex programs, the importance of static analysis for Python (such as type inference) grows. Unfortunately, static analysis for Python remains a challenging task due to its dynamic language features and its abundant external libraries. To help fill this gap, this paper presents PoTo, an Andersen-style context-insensitive and flow-insensitive points-to analysis for Python. PoTo addresses Python-specific challenges and works for large programs via a novel hybrid evaluation, integrating traditional static points-to analysis with concrete evaluation in the Python interpreter for external library calls. We evaluate the analysis with two clients: type inference and call graph construction. This paper presents PoTo+, a static type inference for Python built on PoTo. We evaluate PoTo+ and compare it to two state-of-the-art Python type inference techniques: (1) the static rule-based Pytype and (2) the deep-learning based DLInfer. Our results show that PoTo+ outperforms both Pytype and DLInfer on existing Python packages. This paper also presents PoToCG, a call-graph construction analysis for Python built on PoTo. We compare PoToCG to PyCG, the state of the art for this problem, and show that PoTo produces more complete and more precise call graphs.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.27", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Rak-amnouykit,", + "last_name": "Ingkarat", + "institution": "Rensselaer Polytechnic Institute" + }, + { + "first_name": "Milanova,", + "last_name": "Ana", + "institution": "Rensselaer Polytechnic Institute" + }, + { + "first_name": "Baudart,", + "last_name": "Guillaume", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Hirzel,", + "last_name": "Martin", + "institution": "IBM (United States)" + }, + { + "first_name": "Dolby,", + "last_name": "Julian", + "institution": "IBM (United States)" + } + ], + "dblp_key": "conf/ecoop/Rak-amnouykitMB25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.25", + "title": "Reusing Highly Optimized IR in Dynamic Compilation", + "abstract": "Virtual machines (VMs) with dynamic compilers typically specialize compiled code to the state of the running VM instance and thus cannot reuse the code between multiple runs of the same application. The JIT compiler must recompile the same methods for each run of the application separately, which can prolong the application’s warmup time. We propose a technique to reduce compilation time by reusing a highly optimized intermediate representation (IR). We achieve this by tracing compiler-interface calls during compilation. The validity of the specializations in the IR is verified during a replay stage, and the replay also facilitates the relocation of runtime object references. The IR is stored on a compilation server, which can compile it to machine code and provide the code to local or remote VM instances. We implemented a compilation server with IR caching for GraalVM, a high-performance production-grade Java Virtual Machine (JVM). We present an evaluation based on four industry-standard benchmark suites. In each suite, our approach reduces compilation time by 23.6% to 36.8% and warmup time by 13.1% to 21.2% on average while preserving peak application performance.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.25", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Pečimúth,", + "last_name": "Andrej", + "institution": "Charles University" + }, + { + "first_name": "Leopoldseder,", + "last_name": "David", + "institution": "" + }, + { + "first_name": "Tůma,", + "last_name": "Petr", + "institution": "Charles University" + } + ], + "dblp_key": "conf/ecoop/PecimuthL025", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.26", + "title": "Lightweight Diagramming for Lightweight Formal Methods: A Grounded Language Design", + "abstract": "Tools such as Alloy enable users to incrementally define, explore, verify, and diagnose specifications for complex systems. A critical component of these tools is a visualizer that lets users graphically explore generated models. As we show, however, a default visualizer that knows nothing about the domain can be unhelpful and can even actively violate presentational and cognitive principles. At the other extreme, full-blown custom visualization requires significant effort as well as knowledge that a tool user might not possess. Custom visualizations can also exhibit bad (even silent) failures. This paper charts a middle ground between the extremes of default and fully-customizable visualization. We capture essential domain information for lightweight diagramming, embodying this in a language. To identify key elements of lightweight diagrams, we ground the language design in both the cognitive science research on diagrams and in a corpus of 58 custom visualizations. We distill from these sources a small set of orthogonal primitives, and use the primitives to guide a diagramming language called Cope-and-Drag (CnD). We evaluate it on sample tasks, three user studies, and performance, and find that short CnD specifications consistently improve model comprehension over the Alloy default. CnD thus defines a new point in the design space of diagramming: a language that is lightweight, effective, and driven by sound principles.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.26", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Prasad,", + "last_name": "Siddhartha", + "institution": "Brown University" + }, + { + "first_name": "Greenman,", + "last_name": "Ben", + "institution": "University of Utah" + }, + { + "first_name": "Nelson,", + "last_name": "Tim", + "institution": "Brown University" + }, + { + "first_name": "Krishnamurthi,", + "last_name": "Shriram", + "institution": "Brown University" + } + ], + "dblp_key": "conf/ecoop/PrasadGNK25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.21", + "title": "GSOHC: Global Synchronization Optimization in Heterogeneous Computing", + "abstract": "The use of heterogeneous systems has become widespread and popular in the past decade with more than one type of processor, such as CPUs, GPUs (Graphics Processing Units), and FPGAs (Field Programmable Gate Arrays) etc. A wide range of applications use both CPU and GPU to leverage the benefits of their unique features and strengths. Therefore, collaborative computation between CPU and GPU is essential to achieve high program performance. However, poorly placed global synchronization barriers and synchronous memory transfers are the main bottlenecks to enhanced program performance, preventing CPU and GPU computations from overlapping. Based on this observation, we propose a new optimization technique called hetero-sync motion that can relocate such barrier instructions to new locations, resulting in improved performance in CPU-GPU heterogeneous programs. Further, we propose GSOHC, a compiler analysis and optimization framework that automatically finds opportunities for hetero-sync motion in the input program and then performs code transformation to apply the optimization. Our static analysis is a context-sensitive, flow-sensitive inter-procedural data-flow analysis with three phases to identify the optimization opportunities precisely. We have implemented GSOHC using LLVM/Clang infrastructure. On A4000, P100 and A100 GPUs, our optimization achieves speedups of up to 1.8x, 1.9x and 1.9x over the baseline, respectively.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.21", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Kumar Basu,", + "last_name": "Soumik", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Vedurada,", + "last_name": "Jyothi", + "institution": "Indian Institute of Technology Hyderabad" + } + ], + "dblp_key": "conf/ecoop/BasuV25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.30", + "title": "In-Memory Object Graph Stores", + "abstract": "We present a design and implementation of an in-memory object graph store, dubbed εStore. Our key innovation is a storage model - epsilon store - that equates an object on the heap to a node in a graph store. Thus any object on the heap (without changes) can be a part of one, or multiple, graph stores, and vice versa, any node in a graph store can be accessed like any other object on the heap. Specifically, each node in a graph is an object (i.e., instance of a class), and its properties and its edges are the primitive and reference fields declared in its class, respectively. Necessary classes, which are instantiated to represent nodes, are created dynamically by εStore. εStore uses a subset of the Cypher query language to query the graph store. By design, the result of any query is a table (ResultSet) of references to objects on the heap, which users can manipulate the same way as any other object on the heap in their programs. Moreover, a developer can include (transitively) an arbitrary object to become a part of a graph store. Finally, εStore introduces compile-time rewriting of Cypher queries into imperative code to improve the runtime performance. εStore can be used for a number of tasks including implementing methods for complex in-memory structures, writing complex assertions, or a stripped down version of a graph database that can conveniently be used during testing. We implement εStore in Java and show its application using the aforementioned tasks.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.30", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Thimmaiah,", + "last_name": "Aditya", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Yi,", + "last_name": "Zijian", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Kenis,", + "last_name": "Joseph", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Rossbach, Christopher", + "last_name": "J", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Gligoric,", + "last_name": "Milos", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/ecoop/ThimmaiahYKR025", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.23", + "title": "Wastrumentation: Portable WebAssembly Dynamic Analysis with Support for Intercession", + "abstract": "Dynamic program analyses help in understanding a program’s runtime behavior and detect issues related to security, program comprehension, or profiling. Instrumentation platforms aid analysis developers by offering a high-level API to write the analysis, and inserting the analysis into the target program. However, current instrumentation platforms for WebAssembly (Wasm) restrict analysis portability because they require concrete runtime environments. Moreover, their analysis API only allows the development of analyses that observe the target program but cannot modify it. As a result, many popular dynamic analyses present for other languages, such as runtime hardening, virtual patching or runtime optimization, cannot currently be implemented for Wasm atop a dynamic analysis platform. Instead, they need to be built manually, which requires knowledge of low-level details of the Wasm’s semantics and instruction set, and how to safely manipulate it. This paper introduces Wastrumentation, the first dynamic analysis platform for WebAssembly that supports intercession. Our solution, based on source code instrumentation, weaves the analysis code directly into the target program code. Inlining the analysis into the target’s source code avoids dependencies on the runtime environment, making analyses portable across Wasm VMs. Moreover, it enables the implementation of analyses in any Wasm-compatible language. We evaluate our solution in two ways. First, we compare it against a state-of-the-art source code instrumentation platform using the WasmR3 benchmarks. The results show improved memory consumption and competitive performance overhead. Second, we develop an extensive portfolio of dynamic analyses, including novel analyses previously unattainable with source code instrumentation platforms, such as memoization, safe heap access, and the removal of NaN non-determinism.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.23", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Munsters,", + "last_name": "Aäron", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Scull Pupo, Angel", + "last_name": "Luis", + "institution": "Vrije Universiteit Brussel" + }, + { + "first_name": "Gonzalez Boix,", + "last_name": "Elisa", + "institution": "Vrije Universiteit Brussel" + } + ], + "dblp_key": "conf/ecoop/MunstersPB25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.22", + "title": "Quantifying Cache Side-Channel Leakage by Refining Set-Based Abstractions", + "abstract": "We propose an improved abstract interpretation based method for quantifying cache side-channel leakage by addressing two key components of precision loss in existing set-based cache abstractions. Our method targets two key sources of imprecision: (1) imprecision in the abstract transfer function used to update the abstract cache state when interpreting a memory access and (2) imprecision due to the incompleteness of the set-based domain. At the center of our method are two key improvements: (1) the introduction of a new transfer function for updating the abstract cache state which carefully leverages information in the abstract state to prevent the spurious aging of memory blocks and (2) a refinement of the set-based domain based on the finite powerset construction. We show that both the new abstract transformer and the domain refinement enjoy certain enhanced precision properties. We have implemented the method and compared it against the state-of-the-art technique on a suite of benchmark programs implementing both sorting algorithms and cryptographic algorithms. The experimental results show that our method is effective in improving the precision of cache side-channel leakage quantification.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.22", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Mitchell, Jacqueline", + "last_name": "L.", + "institution": "University of Southern California" + }, + { + "first_name": "Wang,", + "last_name": "Chao", + "institution": "University of Southern California" + } + ], + "dblp_key": "conf/ecoop/Mitchell025", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.24", + "title": "Fair Termination of Asynchronous Binary Sessions", + "abstract": "We study a theory of asynchronous session types ensuring that well-typed processes terminate under a suitable fairness assumption. Fair termination entails starvation freedom and orphan message freedom namely that all messages, including those that are produced early taking advantage of asynchrony, are eventually consumed. The theory is based on a novel fair asynchronous subtyping relation for session types that is coarser than the existing ones. The type system is also the first of its kind that is firmly rooted in linear logic: fair asynchronous subtyping is incorporated as a natural generalization of the cut and axiom rules of linear logic and asynchronous communication is modeled through a suitable set of commuting conversions and of deep cut reductions in linear logic proofs.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.24", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Padovani,", + "last_name": "Luca", + "institution": "University of Bologna" + }, + { + "first_name": "Zavattaro,", + "last_name": "Gianluigi", + "institution": "Institut national de recherche en sciences et technologies du numérique" + } + ], + "dblp_key": "conf/ecoop/PadovaniZ25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.31", + "title": "Multiparty Asynchronous Session Types: A Mechanised Proof of Subject Reduction", + "abstract": "Proofgold is a peer to peer cryptocurrency making use of formal logic. Users can publish theories and then develop a theory by publishing documents with definitions, conjectures and proofs. The blockchain records the theories and their state of development (e.g., which theorems have been proven and when). Two of the main theories are a form of classical set theory (for formalizing mathematics) and an intuitionistic theory of higher-order abstract syntax (for reasoning about syntax with binders). We have also significantly modified the open source Proofgold Core client software to create a faster, more stable and more efficient client, Proofgold Lava. Two important changes are the cryptography code and the database code, and we discuss these improvements. We also discuss how the Proofgold network can be used to support large formalization efforts.", + "date": "2019-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.31", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Tirore,", + "last_name": "Dawit", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Bengtson,", + "last_name": "Jesper", + "institution": "Laboratoire des Sciences du Numérique de Nantes" + }, + { + "first_name": "Carbone,", + "last_name": "Marco", + "institution": "École Normale Supérieure de Lyon" + } + ], + "dblp_key": "conf/ecoop/TiroreBC25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.32", + "title": "Compositional Static Value Analysis for Higher-Order Numerical Programs", + "abstract": "Static analyzers have been successfully developed to detect runtime errors in many languages. However, the automatic analysis of functional languages remains a challenge due to their recursive functions, recursive algebraic data types, and higher-order functions. Classic type systems provide compositional methods that are in general not precise enough to prove the absence of runtime errors such as assertion failures. At the other end of the spectrum, deductive methods are more expressive but may require user guidance to prove invariants. Our work describes a static value analysis by abstract interpretation for a higher-order pure functional language. This analysis provides a sound and automatic approach to discover invariants and prevent assertion and match failures. We have designed a compositional analysis: functions are analyzed only once, at their definition site, generating a summary of their behavior. The summaries can be viewed as input-output relations expressed with relational abstract domains. We present two new abstract domains. A first abstract domain summarizes recursive algebraic data types. A second abstract domain lifts existing disjunctive relational summaries to higher-order by formalizing them as domains able to abstract higher-order functions. Both abstractions are parameterized by the abstractions of basic types (strings, integers, ...). Thanks to this parametric nature, both domains can be combined, allowing the analysis of higher-order functions manipulating algebraic data types and, conversely, algebraic data types using functions as first-class values. We have implemented this analysis in the open-source MOPSA platform. Preliminary evaluation confirms the precision of our approach on a set of 40 handwritten toy programs as well as 20 programs from the state-of-the-art Salto analyzer benchmark.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.32", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Valnet,", + "last_name": "Milla", + "institution": "Sorbonne Université" + }, + { + "first_name": "Monat,", + "last_name": "Raphaël", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Miné,", + "last_name": "Antoine", + "institution": "Sorbonne Université" + } + ], + "dblp_key": "conf/ecoop/ValnetMM25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.33", + "title": "Mono Types - First-Class Containers for Datalog", + "abstract": "We propose mono types, a new abstraction for programming Datalog. Mono types behave like first-class containers that can be stored in relations and to which elements can be added decentrally. But, mono types are more than just containers: They provide a read operation that can yield any result as long as it monotonically grows with each added element and is independent of the order in which elements are added to the container. This design permits a wide range of mono types (e.g., sets, maps, and aggregations), yet guarantees mono types can be integrated into Datalog without jeopardizing Datalog’s least fixed-point semantics. We develop a theory for mono types, which includes constructions for complex mono types, equivalence relation for mono types, and properties about semantics-preserving mono-type transformations. This theory ensures sound Datalog integration and justifies crucial compiler optimizations for mono types. Together, these techniques demonstrate that mono types provide abstraction without regret: We demonstrate in two case studies that programs become easier to write with mono types, while their performance also improves drastically.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.33", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Xu,", + "last_name": "Runqing", + "institution": "" + }, + { + "first_name": "Klopp,", + "last_name": "David", + "institution": "" + }, + { + "first_name": "Erdweg,", + "last_name": "Sebastian", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/XuKE25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.34", + "title": "Taming and Dissecting Recursions Through Interprocedural Weak Topological Ordering", + "abstract": "Abstract interpretation provides a foundational framework for approximating program semantics by interpreting code through abstract domains using semantic functions over ordered sets along a program’s control flow graph (CFG). To facilitate fixpoint computation in abstract interpretation, weak topological ordering (WTO) is an effective strategy for handling loops, as it identifies strategic control points in the CFG where widening and narrowing operations should be applied. However, existing abstract interpreters still face challenges when extending WTO computation in the presence of recursive programs. Computing a precise whole-program WTO requires full context-sensitive analysis which is not scalable for large programs, while context-insensitive analysis introduces spurious cycles that compromise precision. Current approaches either ignore recursion (resulting in unsoundness) or rely on conservative approximations, sacrificing precision by adopting the greatest elements of abstract domains and applying widening at function boundaries without subsequent narrowing refinements. These can lead to undesired results for downstream tasks, such as bug detection. To address the above limitations, we present RecTopo, a new technique to boost the efficiency of precise abstract interpretation in the presence of recursive programs through interprocedural weak topological ordering (IWTO). Rather than pursuing an expensive whole-program WTO analysis, RecTopo employs an on-demand approach that strategically decomposes programs at recursion boundaries and constructs targeted IWTOs for each recursive component. RecTopo dissects and analyzes (nested) recursions through interleaved widening and narrowing operations. This approach enables precise control over interpretation ordering within recursive structures while eliminating spurious recursions through systematic correlation of control flow and call graphs. We implemented RecTopo and evaluated its effectiveness using an assertion-based checking client focused on buffer overflow detection, comparing it against three popular open-source abstract interpreters (IKOS, Clam, CSA). The experiments on 8312 programs from the NIST dataset demonstrate that, on average, RecTopo is 31.99% more precise and achieves a 17.49% higher recall rate compared to three other tools. Moreover, RecTopo exhibits an average precision improvement of 46.51% and a higher recall rate of 32.98% compared to our baselines across ten large open-source projects. Further ablation studies reveal that IWTO reduces spurious widening operations compared to whole-program WTO, resulting in a 12.83% reduction in analysis time.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.34", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yang,", + "last_name": "Jiawei", + "institution": "Hong Kong Polytechnic University" + }, + { + "first_name": "Cheng,", + "last_name": "Xiao", + "institution": "UNSW Sydney" + }, + { + "first_name": "Chang, Bor-Yuh", + "last_name": "Evan", + "institution": "Amazon (United States)" + }, + { + "first_name": "Luo,", + "last_name": "Xiapu", + "institution": "Hong Kong Polytechnic University" + }, + { + "first_name": "Sui,", + "last_name": "Yulei", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/ecoop/Yang0CLS25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.35", + "title": "Chain of Grounded Objectives: Concise Goal-Oriented Prompting for Code Generation", + "abstract": "The use of Large Language Models (LLMs) for code generation has gained significant attention in recent years. Existing methods often aim to improve the quality of generated code by incorporating additional contextual information or guidance into input prompts. Many of these approaches adopt process-oriented reasoning strategies, mimicking human-like step-by-step thinking; however, they may not always align with the structured nature of programming languages. This paper introduces Chain of Grounded Objectives (CGO), a concise goal-oriented prompting approach that embeds functional objectives into prompts to enhance code generation. By focusing on precisely defined objectives rather than explicit procedural steps, CGO aligns more naturally with programming tasks while retaining flexibility. Empirical evaluations on HumanEval, MBPP, their extended versions, and LiveCodeBench show that CGO achieves accuracy comparable to or better than existing methods while using fewer tokens, making it a more efficient approach to LLM-based code generation.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.35", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Yeo,", + "last_name": "Sangyeop", + "institution": "Electronics and Telecommunications Research Institute" + }, + { + "first_name": "Hwang,", + "last_name": "Seung-Won", + "institution": "Seoul National University" + }, + { + "first_name": "Ma,", + "last_name": "Yu-Seung", + "institution": "Electronics and Telecommunications Research Institute" + } + ], + "dblp_key": "conf/ecoop/YeoHM25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.36", + "title": "Efficient Neural Network Verification via Order Leading Exploration of Branch-and-Bound Trees", + "abstract": "The vulnerability of neural networks to adversarial perturbations has necessitated formal verification techniques that can rigorously certify the quality of neural networks. As the state-of-the-art, branch-and-bound (BaB) is a \"divide-and-conquer\" strategy that applies off-the-shelf verifiers to sub-problems for which they perform better. While BaB can identify the sub-problems that are necessary to be split, it explores the space of these sub-problems in a naive \"first-come-first-served\" manner, thereby suffering from an issue of inefficiency to reach a verification conclusion. To bridge this gap, we introduce an order over different sub-problems produced by BaB, concerning with their different likelihoods of containing counterexamples. Based on this order, we propose a novel verification framework Oliva that explores the sub-problem space by prioritizing those sub-problems that are more likely to find counterexamples, in order to efficiently reach the conclusion of the verification. Even if no counterexample can be found in any sub-problem, it only changes the order of visiting different sub-problems and so will not lead to a performance degradation. Specifically, Oliva has two variants, including Oliva^GR, a greedy strategy that always prioritizes the sub-problems that are more likely to find counterexamples, and Oliva^SA, a balanced strategy inspired by simulated annealing that gradually shifts from exploration to exploitation to locate the globally optimal sub-problems. We experimentally evaluate the performance of Oliva on 690 verification problems spanning over 5 models with datasets MNIST and CIFAR-10. Compared to the state-of-the-art approaches, we demonstrate the speedup of Oliva for up to 25× in MNIST, and up to 80× in CIFAR-10.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.36", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Guanqin", + "last_name": "Zhang", + "institution": "" + }, + { + "first_name": "K.", + "last_name": "Fukuda", + "institution": "" + }, + { + "first_name": "Zhenya", + "last_name": "Zhang", + "institution": "" + }, + { + "first_name": "H. M. N. Dilum", + "last_name": "Bandara", + "institution": "" + }, + { + "first_name": "Shiping", + "last_name": "Chen", + "institution": "" + }, + { + "first_name": "Jianjun", + "last_name": "Zhao", + "institution": "" + }, + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "" + } + ], + "dblp_key": "conf/ecoop/ZhangFZB00S25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.39", + "title": "WebGlitch: A Randomised Testing Tool for the WebGPU API (Experience Paper)", + "abstract": "We report on our experience designing a new technique and tool for fuzzing implementations of WebGPU, a W3C standard JavaScript API for in-browser GPU computing. We also report on our experience using our WebGlitch tool to test industrial-strength implementations of WebGPU, leading to the discovery of numerous bugs. WebGPU enables programmatic access to a device’s graphics processing unit (GPU) for in-browser GPU computing, and is being implemented by Google, Mozilla and Apple for inclusion in all of the major web browsers. Guaranteeing the security and reliability of WebGPU is crucial to avoid wide-reaching browser security vulnerabilities and to facilitate portability by ensuring uniform behaviour across different platforms. To that end - inspired by randomised compiler testing techniques - our approach to fuzzing creates random, valid-by-construction programs by continuously selecting a WebGPU API function, then recursively generating all requirements necessary for that API call to be valid based on careful modelling of the API specification. This is implemented as a new open source tool, WebGlitch, which we designed in consultation with engineers at Google who work on the Chrome WebGPU implementation. WebGlitch identifies bugs through sanitiser-boosted crash oracles, differential testing, and by identifying cases where valid-by-construction API calls lead to runtime errors. We present an evaluation showing that WebGlitch can find bugs missed by an existing WebGPU fuzzer, wg-fuzz, and across the broader WebGPU ecosystem: to date, WebGlitch has found 24 previously-unknown bugs (15 fixed so far in response to our reports). Among these, 17 bugs affected WebGPU implementations from Google, Mozilla, and the Deno project. WebGlitch found an additional 4 bugs in the shader compilers used by the graphics APIs that WebGPU interfaces with. The remaining 3 bugs affect the widely-used JavaScript runtimes Node.js and Deno. Fuzzing with WebGlitch also led us to identify an ambiguity in the specification of the WebGPU shading language, for which we proposed an amendment that was accepted by W3C and which has been adopted in the latest version of the specification. Analysing the line coverage of a WebGPU implementation by WebGlitch-generated programs revealed that WebGlitch covers code missed by wg-fuzz and the official conformance test suite. Our hope is that this report on the design of WebGlitch and its deployment in practice will be useful for practitioners and researchers interested in using API fuzzing to improve the reliability of industrial codebases.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.39", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Wong, Matthew K.", + "last_name": "L.", + "institution": "Imperial College London" + }, + { + "first_name": "Donaldson, Alastair", + "last_name": "F.", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/ecoop/WongD25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.38", + "title": "Type-Safe and Portable Support for Packed Data (Experience Paper)", + "abstract": "When components of a system exchange data, they need to serialise the data so that it can be sent over the network. Then, the recipient has to deserialise the data in order to be able to process it. These steps take time and have an impact on the overall system’s performance. A solution to this is to use packed data, which has a unified representation between the memory and the network, removing the need for any marshalling steps. Additionally, using this data representation can improve the program’s performance thanks to the data locality enabled by the compact representation of the data in memory. Unfortunately, no mainstream programming languages support packed data, whether it’s out-of-the-box or through a compiler extension. We present packed-data, a Haskell library that allows for type safe building and reading of packed data in a functional style. The library does not rely on compiler modifications, making it portable, and leverages meta-programming to allow programmers to pack their own data types effortlessly. We evaluate the usability and performance of the library, and conclude that it allows traversing packed data up to 60% faster than unpacked data. We also reflect on how to enhance the performance of library-based support for packed data. Our implementation approach is general and can easily be used with any programming languages that support higher-kinded types.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.38", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Jamet,", + "last_name": "Arthur", + "institution": "University of Kent" + }, + { + "first_name": "Vollmer,", + "last_name": "Michael", + "institution": "University of Kent" + } + ], + "dblp_key": "conf/ecoop/Jamet025", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.41", + "title": "Shouting at Memory: Where Did My Write Go? (Pearl/Brave New Idea)", + "abstract": "Non-Volatile Memory (NVM) promises persistent data, but verifying that promise on real hardware is challenging due to opaque caching and internal buffers like Intel’s WPQ, which obscure the true state of writes. Traditional validation methods often fall short. This paper introduces a novel perspective: leveraging the subtle timing variations of memory accesses as a direct probe into write persistence. We present a software technique, inspired by echolocation, that uses high-resolution timers to measure memory load latencies. These timings act as distinct signatures (\"echoes\") revealing whether a write’s data resides in volatile caches or has reached the NVM persistence domain. This offers a non-invasive method to track write progression towards durability. To reliably interpret these potentially noisy timing signatures and systematically explore complex persistence behaviours, we integrate this echolocation probe into an active model learning framework. This synergy enables the automated inference of a system’s actual persistency semantics directly from black-box hardware observations. The approach is hardware-agnostic, adaptive, and scalable. Preliminary experiments on Intel x86 - a platform where persistence validation is notably challenged by the opaque Write Pending Queue (WPQ) - demonstrate the feasibility of our technique. We observed distinct latency clusters differentiating volatile cache accesses from those reaching the persistence domain. This combined approach offers a promising path towards robust and automated validation of NVM persistency across diverse architectures.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.41", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Klimis,", + "last_name": "Vasileios", + "institution": "Queen Mary University of London" + } + ], + "dblp_key": "conf/ecoop/Klimis25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.42", + "title": "Contract Systems Need Domain-Specific Notations (Pearl/Brave New Idea)", + "abstract": "Contract systems enable programmers to state specifications and have them enforced at run time. First-order contracts are expressed using ordinary code, while higher-order contracts are expressed using the notation familiar from type systems. Most interface descriptions, though, come with properties that involve not just assertions about single method calls, but entire call chains. Typical contract systems cannot express these specifications concisely. Such specifications demand domain-specific notations. In response, this paper proposes that contract systems abstract over the notation used for stating specifications. It presents an architecture for such a system, some illustrative examples, and an evaluation in terms of common notations from the literature.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.42", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Moy,", + "last_name": "Cameron", + "institution": "Northeastern University" + }, + { + "first_name": "Jung,", + "last_name": "Ryan", + "institution": "Northeastern University" + }, + { + "first_name": "Felleisen,", + "last_name": "Matthias", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/ecoop/MoyJF25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.37", + "title": "RacerF: Lightweight Static Data Race Detection for C Code (Experience Paper)", + "abstract": "We present RacerF, a novel static analyser for thread-modular data race detection. The approach behind RacerF exploits static analysis of sequential program behaviour whose results are generalised for multi-threaded programs using a combination of lightweight under- and over-approximating methods. The tool is implemented as a plugin of the Frama-C platform and can leverage several analysis backends, most notably the Frama-C’s abstract interpreter EVA. Although our methods are mostly heuristic without providing formal guarantees, our experimental evaluation shows that even for intricate programs, RacerF can provide very precise results competitive with more heavyweight approaches while being faster than them.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.37", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Dacík,", + "last_name": "Tomáš", + "institution": "Brno University of Technology" + }, + { + "first_name": "Vojnar,", + "last_name": "Tomáš", + "institution": "Masaryk University" + } + ], + "dblp_key": "conf/ecoop/DacikV25", + "venue": "ecoop", + "year": 2025 + }, + { + "paper_id": "10.4230/LIPIcs.ECOOP.2025.40", + "title": "Scaling Up: Revisiting Mining Android Sandboxes at Scale for Malware Classification (Replication Paper)", + "abstract": "The widespread use of smartphones in daily life has raised concerns about privacy and security among researchers and practitioners. Privacy issues are generally highly prevalent in mobile applications, particularly targeting the Android platform - the most popular mobile operating system. For this reason, several techniques have been proposed to identify malicious behavior in Android applications, including the Mining Android Sandbox approach (MAS approach), which aims to identify malicious behavior in repackaged Android applications (apps). However, previous empirical studies evaluated the MAS approach using a small dataset consisting of only 102 pairs of original and repackaged apps. This limitation raises questions about the external validity of their findings and whether the MAS approach can be generalized to larger datasets. To address these concerns, this paper presents the results of a replication study focused on evaluating the performance of the MAS approach regarding its capabilities of correctly classifying malware from different families. Unlike previous studies, our research employs a dataset that is an order of magnitude larger, comprising 4,076 pairs of apps covering a more diverse range of Android malware families. Surprisingly, our findings indicate a poor performance of the MAS approach for identifying malware, with the F1-score decreasing from 0.90 for the small dataset used in the previous studies to 0.54 in our more extensive dataset. Upon closer examination, we discovered that certain malware families partially account for the low accuracy of the MAS approach, which fails to classify a repackaged version of an app as malware correctly. Our findings highlight the limitations of the MAS approach, particularly when scaled, and underscore the importance of complementing it with other techniques to detect a broader range of malware effectively. This opens avenues for further discussion on addressing the blind spots that affect the accuracy of the MAS approach.", + "date": "2025-01-01", + "link": "https://doi.org/10.4230/LIPIcs.ECOOP.2025.40", + "conference_name": "ECOOP", + "authors": [ + { + "first_name": "Handrick Tomaz da Costa,", + "last_name": "Francisco", + "institution": "University Center of Brasília" + }, + { + "first_name": "Medeiros,", + "last_name": "Ismael", + "institution": "Universidade de Brasília" + }, + { + "first_name": "Oliveira,", + "last_name": "Leandro", + "institution": "Universidade de Brasília" + }, + { + "first_name": "Calássio,", + "last_name": "João", + "institution": "Universidade de Brasília" + }, + { + "first_name": "Bonifácio,", + "last_name": "Rodrigo", + "institution": "Universidade de Brasília" + }, + { + "first_name": "Narasimhan,", + "last_name": "Krishna", + "institution": "UniQure (Netherlands)" + }, + { + "first_name": "Mezini,", + "last_name": "Mira", + "institution": "Technische Universität Darmstadt" + }, + { + "first_name": "Ribeiro,", + "last_name": "Márcio", + "institution": "Universidade Federal de Alagoas" + } + ], + "dblp_key": "conf/ecoop/CostaMOCBNM025", + "venue": "ecoop", + "year": 2025 + } +] \ No newline at end of file From 0ab27b27bb04ccf6b157a118c1aab6c034501034 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:05:03 +0200 Subject: [PATCH 19/34] fix: truncate over-long abstracts before embedding instead of aborting A handful of PL conference abstracts (notably PACMPL/LIPIcs 'Journal-first' submissions whose 'abstract' is effectively the full body of the journal extension) exceed the embedding model's ~1536-token window. Previously the entire embed batch aborted with 'At least one of the texts is too long to embed', which in practice meant a single bad row halted bulk consume of an entire venue. Clip oversize texts to the model's word budget and continue. A head excerpt is good enough for semantic retrieval; a hard fail on the whole batch is not. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/EmbeddingModel.py | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/src/oversight/EmbeddingModel.py b/src/oversight/EmbeddingModel.py index bf1a6c0..f101617 100644 --- a/src/oversight/EmbeddingModel.py +++ b/src/oversight/EmbeddingModel.py @@ -50,13 +50,19 @@ def embed_documents_rate_limited( "Only gemini embeddings are supported for now" ) - max_texts_tokens = ( - max([len(text.split()) for text in texts]) / self.words_per_token - ) - # Use 75% of the max tokens to account for unknown words to tokens mapping - assert max_texts_tokens <= self.max_tokens, ( - "At least one of the texts is too long to embed" - ) + # Truncate any text that would exceed the model's token budget. + # Some scraped abstracts (notably PACMPL 'SCICO Journal-first' papers + # whose abstract is the full paper-extension's body) blow past 1536 + # tokens. Rather than abort the whole batch, clip the long ones and + # keep going — semantic retrieval on a head excerpt is still useful. + max_words = int(self.max_tokens * self.words_per_token) + truncated_texts: list[str] = [] + for text in texts: + words = text.split() + if len(words) > max_words: + text = " ".join(words[:max_words]) + truncated_texts.append(text) + texts = truncated_texts # loop through the texts in batches of max_texts_per_request for texts_chunk in chunked_iterable(texts, self.batch_size): @@ -70,7 +76,6 @@ def embed_documents_rate_limited( new_embeddings = self.model.embed_documents(texts_chunk) break except Exception as e: - print(max_texts_tokens) print(f"Error embedding {len(texts_chunk)} texts: {e}") for i, text in enumerate(texts_chunk): print(f"text {i}: {text}") From b2e1e220014d73c69209ef96a9266de0a710e741 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:11:49 +0200 Subject: [PATCH 20/34] feat: ingest CC back-catalogue (1988-2026) 19 of 34 indexed years yielded papers with abstracts. Like ECOOP and ESOP, CC was a Springer LNCS conference until 2016 when it migrated to ACM (LIPIcs); pre-2016 abstracts are mostly missing from OpenAlex/Semantic Scholar. Post-2016 yields 14-29 papers per year. CC 2026 was published while the harvester was running. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/cc/1988.json | 20 + data/pl_conferences/cc/1996.json | 20 + data/pl_conferences/cc/1998.json | 25 + data/pl_conferences/cc/1999.json | 25 + data/pl_conferences/cc/2001.json | 20 + data/pl_conferences/cc/2004.json | 30 ++ data/pl_conferences/cc/2008.json | 25 + data/pl_conferences/cc/2013.json | 45 ++ data/pl_conferences/cc/2014.json | 48 ++ data/pl_conferences/cc/2016.json | 844 +++++++++++++++++++++++++++++++ data/pl_conferences/cc/2018.json | 582 +++++++++++++++++++++ data/pl_conferences/cc/2019.json | 526 +++++++++++++++++++ data/pl_conferences/cc/2020.json | 619 +++++++++++++++++++++++ data/pl_conferences/cc/2021.json | 389 ++++++++++++++ data/pl_conferences/cc/2022.json | 650 ++++++++++++++++++++++++ data/pl_conferences/cc/2023.json | 705 ++++++++++++++++++++++++++ data/pl_conferences/cc/2024.json | 650 ++++++++++++++++++++++++ data/pl_conferences/cc/2025.json | 568 +++++++++++++++++++++ data/pl_conferences/cc/2026.json | 583 +++++++++++++++++++++ 19 files changed, 6374 insertions(+) create mode 100644 data/pl_conferences/cc/1988.json create mode 100644 data/pl_conferences/cc/1996.json create mode 100644 data/pl_conferences/cc/1998.json create mode 100644 data/pl_conferences/cc/1999.json create mode 100644 data/pl_conferences/cc/2001.json create mode 100644 data/pl_conferences/cc/2004.json create mode 100644 data/pl_conferences/cc/2008.json create mode 100644 data/pl_conferences/cc/2013.json create mode 100644 data/pl_conferences/cc/2014.json create mode 100644 data/pl_conferences/cc/2016.json create mode 100644 data/pl_conferences/cc/2018.json create mode 100644 data/pl_conferences/cc/2019.json create mode 100644 data/pl_conferences/cc/2020.json create mode 100644 data/pl_conferences/cc/2021.json create mode 100644 data/pl_conferences/cc/2022.json create mode 100644 data/pl_conferences/cc/2023.json create mode 100644 data/pl_conferences/cc/2024.json create mode 100644 data/pl_conferences/cc/2025.json create mode 100644 data/pl_conferences/cc/2026.json diff --git a/data/pl_conferences/cc/1988.json b/data/pl_conferences/cc/1988.json new file mode 100644 index 0000000..98a58eb --- /dev/null +++ b/data/pl_conferences/cc/1988.json @@ -0,0 +1,20 @@ +[ + { + "paper_id": "10.1007/3-540-51364-7_6", + "title": "Generators for High-Speed Front-Ends", + "abstract": "High-speed compilers can be constructed automatically. We present some existing tools for the generation of fast front-ends. Rex (Regular EXpression tool) is a scanner generator whose specifications are based on regular expressions and arbitrary semantic actions written in one of the target languages C or Modula-2. As scanners sometimes have to consider the context to unambiguously recognize a token the right context can be specified by an additional regular expression and the left context can be handled by so-called start states. The generated scanners automatically compute the line and column position of the tokens and offer an efficient mechanism to normalize identifiers and keywords to upper or lower case letters. The scanners are table-driven and run at a speed of 180,000 to 195,000 lines per minute on a MC 68020 processor. Lalr is a LALR(1) parser generator accepting grammars written in extended BNT notation which may be augmented by semantic actions expressed by statements of the target language. The generator provides a mechanism for S-attribution, that is synthesized attributes can be computed during parsing. In case of LR-conflicts, unlike other tools, Lalr provides not only information about an internal state consisting of a set of items but it prints a derivation tree which is much more useful to analyze the problem. Conflicts can be resolved by specifying precedence and associativity of operators and productions. The generated parsers include automatic error reporting, error recovery, and error repair. The parsers are table-driven and run at a speed of 400,000 lines per minute. Currently parsers can be generated in the target languages C and Modula-2. Ell is a LL(1) parser generator accepting the same specification language as Lalr except that the grammars must obey the LL(1) property. The generated parsers include automatic error reporting, recovery, and repair like Lalr. The parsers are implemented following the recursive descent method and reach a speed of 450,000 lines per minute. The possible target languages are again C and Modula-2 A comparison of the above tools with the corresponding UNIX tools shows that significant improvements have been achieved thus allowing the generation of high-speed compilers.", + "date": "1989-01-01", + "link": "https://doi.org/10.1007/3-540-51364-7_6", + "conference_name": "CC", + "authors": [ + { + "first_name": "Josef", + "last_name": "Grosch", + "institution": "Karlsruhe Institute of Technology" + } + ], + "dblp_key": "conf/cc/Grosch88", + "venue": "cc", + "year": 1988 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/1996.json b/data/pl_conferences/cc/1996.json new file mode 100644 index 0000000..74fb8d2 --- /dev/null +++ b/data/pl_conferences/cc/1996.json @@ -0,0 +1,20 @@ +[ + { + "paper_id": "10.1007/3-540-61053-7_71", + "title": "Delegating Compiler Objects: An Object-Oriented Approach to Crafting Compilers", + "abstract": "Conventional compilers often are large entities that are highly complex, difficult to maintain and hard to reuse. In this article it is argued that this is due to the inherently functional approach to compiler construction. An alternative approach to compiler construction is proposed, based on object-oriented principles, which solves (or at least lessens) the problems of compiler construction. The approach is based on delegating compiler objects (Dcos) that provide a structural decomposition of compilers in addition to the conventional functional decomposition. The DCO approach makes use of the parser delegation and lexer delegation techniques, that provide reuse and modularisation of syntactical, respectively, lexical specifications.", + "date": "1996-01-01", + "link": "https://doi.org/10.1007/3-540-61053-7_71", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jan", + "last_name": "Bosch", + "institution": "" + } + ], + "dblp_key": "conf/cc/Bosch96", + "venue": "cc", + "year": 1996 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/1998.json b/data/pl_conferences/cc/1998.json new file mode 100644 index 0000000..7a2acff --- /dev/null +++ b/data/pl_conferences/cc/1998.json @@ -0,0 +1,25 @@ +[ + { + "paper_id": "10.1007/BFb0026420", + "title": "Generalised Recursive Descent parsing and Fellow-Determinism", + "abstract": "This paper presents a construct for mapping arbitrary non-left recursive context-free grammars into recursive descent parsers that: handle ambiguous grammars correctly; perform with LL(1) efficiency on LL(1) grammars; allow straightforward implementation of both inherited and synthesized attributes; and allow semantic actions to be added at any point in the grammar. We describe both the basic algorithm and a tool, GRDP, which generates parsers which use this technique. Modifications of the basic algorithm to improve efficiency lead to a discussion of follow-determinism, a fundamental property that gives insights into the behaviour of both LL and LR parsers.", + "date": "1998-01-01", + "link": "https://doi.org/10.1007/BFb0026420", + "conference_name": "CC", + "authors": [ + { + "first_name": "Adrian", + "last_name": "Johnstone", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Elizabeth", + "last_name": "Scott", + "institution": "Universidad de Londres" + } + ], + "dblp_key": "conf/cc/JohnstoneS98", + "venue": "cc", + "year": 1998 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/1999.json b/data/pl_conferences/cc/1999.json new file mode 100644 index 0000000..ff48677 --- /dev/null +++ b/data/pl_conferences/cc/1999.json @@ -0,0 +1,25 @@ +[ + { + "paper_id": "10.1007/978-3-540-49051-7_3", + "title": "Faster Generalized LR Parsing", + "abstract": "Tomita devised a method of generalized LR (GLR) parsing to parse ambiguous grammars efficiently. A GLR parser uses linear-time LR parsing techniques as long as possible, falling back on more expensive general techniques when necessary.Much research has addressed speeding up LR parsers. However, we argue that this previous work is not transferable to GLR parsers. Instead, we speed up LR parsers by building larger pushdown automata, trading space for time. A variant of the GLR algorithm then incorporates our faster LR parsers.Our timings show that our new method for GLR parsing can parse highly ambiguous grammars significantly faster than a standard GLR parser.", + "date": "1999-01-01", + "link": "https://doi.org/10.1007/978-3-540-49051-7_3", + "conference_name": "CC", + "authors": [ + { + "first_name": "John", + "last_name": "Aycock", + "institution": "University of Victoria" + }, + { + "first_name": "Nigel", + "last_name": "Horspool", + "institution": "University of Victoria" + } + ], + "dblp_key": "conf/cc/AycockH99", + "venue": "cc", + "year": 1999 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2001.json b/data/pl_conferences/cc/2001.json new file mode 100644 index 0000000..45208ac --- /dev/null +++ b/data/pl_conferences/cc/2001.json @@ -0,0 +1,20 @@ +[ + { + "paper_id": "10.1007/3-540-45306-7_1", + "title": "Virtual Classes and Their Implementation", + "abstract": "One of the characteristics of BETA [4] is the unification of abstraction mechanisms such as class, procedure, process type, generic class, interface, etc. into one abstraction mechanism: the pattern. In addition to keeping the language small, the unification has given a systematic treatment of all abstraction mechanisms and leads to a number of new possibilities. One of the interesting results of the unification is the notion of virtual class [[7],[8], which is the BETA mechanism for expressing genericity. A class may define an attribute in the form of a virtual class just as a class may define an attribute in the form of a virtual procedure. A subclass may then refine the definition of the virtual class attribute into a more specialized class. This is very much in the same way as a virtual procedure can be refined - resulting in a more specialized procedure. Virtual classes can be seen as an object-oriented version of generics. Other attempts to provide genericity for OO languages has been based on various forms of parametric polymorphism and function application rather than inheritance. Virtual classes have been used for more than 15 years in the BETA community and they have demonstrated their usefulness as a powerful abstraction mechanism. There has recently been an increasing interest in virtual classes and a number of proposals for adding virtual classes to other languages, extending virtual classes, and unifying virtual classes and parameterized classes have been made [[1],[2],[3],[13],[14],[15],[16],[17]. Another distinguishing feature of BETA is the notion of nested class [6]. The nested class construct originates already with Simula and is supported in a more general form in BETA. Nested classes have thus been available to the OO community for almost 4 decades, and the mechanism has found many uses in particular to structure large systems. Despite the usefulness, mainstream OO languages have not included general nesting mechanisms although C++ has a restricted form of nested classes, only working as a scoping mechanism. Recently nested classes has been added to the Java language. From a semantic analysis point of view the combination of inheritance, and general nesting adds some complexity to the semantic analysis, since the search space for names becomes two-dimensional. With virtual classes, the analysis becomes even more complicated — for details see ref. [10]. The unification of class and procedure has also lead to an inheritance mechanism for procedures [5] where method-combination is based on the inner-construct known from Simula. In BETA, patterns are first-class values, which implies that procedures as well as classes are first-class values. BETA also supports the notion of class-less objects, which has been adapted in the form of anonymous classes in Java. Finally, it might be mentioned that BETA supports coroutines as well as concurrent active objects. For further details about BETA, see [6,9,11]. The Mjølner System is a program development environment for BETA and may be obtained from ref. [12].", + "date": "2001-01-01", + "link": "https://doi.org/10.1007/3-540-45306-7_1", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ole Lehrmann", + "last_name": "Madsen", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/cc/Madsen01", + "venue": "cc", + "year": 2001 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2004.json b/data/pl_conferences/cc/2004.json new file mode 100644 index 0000000..c627859 --- /dev/null +++ b/data/pl_conferences/cc/2004.json @@ -0,0 +1,30 @@ +[ + { + "paper_id": "10.1007/978-3-540-24723-4_7", + "title": "Generalised Parsing: Some Costs", + "abstract": "We discuss generalisations of bottom up parsing, emphasising the relative costs for real programming languages. Our goal is to provide a roadmap of the available approaches in terms of their space and time performance for programming language applications, focusing mainly on GLR style algorithms. It is well known that the original Tomita GLR algorithm fails to terminate on hidden left recursion: here we analyse two approaches to correct GLR parsing (i) the modification due to Farshi that is incorporated into Visser’s work and (ii) our own right-nullable GLR (RNGLR) algorithm, showing that Farshi’s approach can be expensive. We also present results from our new Binary RNGLR algorithm which is asymptotically the fastest parser in this family and show that the recently reported reduction incorporated parsers can require automata that are too large to be practical on current machines.", + "date": "2004-01-01", + "link": "https://doi.org/10.1007/978-3-540-24723-4_7", + "conference_name": "CC", + "authors": [ + { + "first_name": "Adrian", + "last_name": "Johnstone", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Elizabeth", + "last_name": "Scott", + "institution": "Royal Holloway University of London" + }, + { + "first_name": "Giorgios", + "last_name": "Economopoulos", + "institution": "Royal Holloway University of London" + } + ], + "dblp_key": "conf/cc/JohnstoneSE04", + "venue": "cc", + "year": 2004 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2008.json b/data/pl_conferences/cc/2008.json new file mode 100644 index 0000000..5adb376 --- /dev/null +++ b/data/pl_conferences/cc/2008.json @@ -0,0 +1,25 @@ +[ + { + "paper_id": "10.1007/978-3-540-78791-4_11", + "title": "Compiler-Guaranteed Safety in Code-Copying Virtual Machines", + "abstract": "Virtual Machine authors face a difficult choice between low performance, cheap interpreters, or specialized and costly compilers. A method able to bridge this wide gap is the existing code-copying technique that reuses chunks of the VM’s binary code to create a simple JIT. This technique is not reliable without a compiler guaranteeing that copied chunks are still functionally equivalent despite aggressive optimizations. We present a proof-of-concept, minimal-impact modification of a highly optimizing compiler, GCC. A VM programmer marks chunks of VM source code as copyable. The chunks of native code resulting from compilation of the marked source become addressable and self-contained. Chunks can be safely copied at VM runtime, concatenated and executed together. This allows code-copying VMs to safely achieve speedup up to 3 times, 1.67 on average, over the direct interpretation. This maintainable enhancement makes the code-copying technique reliable and thus practically usable.", + "date": "2008-04-01", + "link": "https://doi.org/10.1007/978-3-540-78791-4_11", + "conference_name": "CC", + "authors": [ + { + "first_name": "Gregory B.", + "last_name": "Prokopski", + "institution": "McGill University" + }, + { + "first_name": "Clark", + "last_name": "Verbrugge", + "institution": "McGill University" + } + ], + "dblp_key": "conf/cc/ProkopskiV08", + "venue": "cc", + "year": 2008 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2013.json b/data/pl_conferences/cc/2013.json new file mode 100644 index 0000000..a22339b --- /dev/null +++ b/data/pl_conferences/cc/2013.json @@ -0,0 +1,45 @@ +[ + { + "paper_id": "10.1007/978-3-642-37051-9_6", + "title": "Simple and Efficient Construction of Static Single Assignment Form", + "abstract": "We present a simple SSA construction algorithm, which allows direct translation from an abstract syntax tree or bytecode into an SSA-based intermediate representation. The algorithm requires no prior analysis and ensures that even during construction the intermediate representation is in SSA form. This allows the application of SSA-based optimizations during construction. After completion, the intermediate representation is in minimal and pruned SSA form. In spite of its simplicity, the runtime of our algorithm is on par with Cytron et al.’s algorithm.", + "date": "2013-01-01", + "link": "https://doi.org/10.1007/978-3-642-37051-9_6", + "conference_name": "CC", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Braun", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Sebastian", + "last_name": "Buchwald", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + }, + { + "first_name": "Roland", + "last_name": "Leißa", + "institution": "Saarland University" + }, + { + "first_name": "Christoph", + "last_name": "Mallon", + "institution": "Saarland University" + }, + { + "first_name": "Andreas", + "last_name": "Zwinkau", + "institution": "Karlsruhe Institute of Technology" + } + ], + "dblp_key": "conf/cc/BraunBHLMZ13", + "venue": "cc", + "year": 2013 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2014.json b/data/pl_conferences/cc/2014.json new file mode 100644 index 0000000..e16b80f --- /dev/null +++ b/data/pl_conferences/cc/2014.json @@ -0,0 +1,48 @@ +[ + { + "paper_id": "10.1007/978-3-642-54807-9_12", + "title": "String Analysis for Dynamic Field Access", + "abstract": "In JavaScript, and scripting languages in general, dynamic field access is a commonly used feature. Unfortunately, current static analysis tools either completely ignore dynamic field access or use overly conservative approximations that lead to poor precision and scalability. We present new string domains to reason about dynamic field access in a static analysis tool. A key feature of the domains is that the equal, concatenate and join operations take $\\mathcal{O}$ (1) time. Experimental evaluation on four common JavaScript libraries, including jQuery and Prototype, shows that traditional string domains are insufficient. For instance, the commonly used constant string domain can only ensure that at most 21% dynamic field accesses are without false positives. In contrast, our string domain $\\mathcal{H}$ ensures no false positives for up to 90% of all dynamic field accesses. We demonstrate that a dataflow analysis equipped with the $\\mathcal{H}$ domain gains significant precision resulting in an analysis speedup of more than 1.5x for 7 out of 10 benchmark programs.", + "date": "2014-01-01", + "link": "https://doi.org/10.1007/978-3-642-54807-9_12", + "conference_name": "CC", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + }, + { + "first_name": "Esben", + "last_name": "Andreasen", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/cc/MadsenA14", + "venue": "cc", + "year": 2014 + }, + { + "paper_id": "10.1007/978-3-642-54807-9_8", + "title": "Taming Control Divergence in GPUs through Control Flow Linearization", + "abstract": "Branch divergence is a very commonly occurring performance problem in GPGPU in which the execution of diverging branches is serialized to execute only one control flow path at a time. Existing hardware mechanism to reconverge threads using a stack causes duplicate execution of code for unstructured control flow graphs. Also the stack mechanism cannot effectively utilize the available parallelism among diverging branches. Further, the amount of nested divergence allowed is also limited by depth of the branch divergence stack. In this paper we propose a simple and elegant transformation to handle all of the above mentioned problems. The transformation converts an unstructured CFG to a structured CFG without duplicating user code. It incurs only a linear increase in the number of basic blocks and also the number of instructions. Our solution linearizes the CFG using a predicate variable. This mechanism reconverges the divergent threads as early as possible. It also reduces the depth of the reconvergence stack. The available parallelism in nested branches can be effectively extracted by scheduling the basic blocks to reduce the effect of stalls due to memory accesses. It can also increase execution efficiency of nested loops with different trip counts for different threads. We implemented the proposed transformation at PTX level using the Ocelot compiler infrastructure. We evaluated the technique using various benchmarks to show that it can be effective in handling the performance problem due to divergence in unstructured CFGs.", + "date": "2014-01-01", + "link": "https://doi.org/10.1007/978-3-642-54807-9_8", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jayvant", + "last_name": "Anantpur", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "R.", + "last_name": "Govindarajan", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/cc/AnantpurG14", + "venue": "cc", + "year": 2014 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2016.json b/data/pl_conferences/cc/2016.json new file mode 100644 index 0000000..a0d5620 --- /dev/null +++ b/data/pl_conferences/cc/2016.json @@ -0,0 +1,844 @@ +[ + { + "paper_id": "10.1145/2892208.2892224", + "title": "Reachability and error diagnosis in LR(1) parsers", + "abstract": "International audience", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892224", + "conference_name": "CC", + "authors": [ + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/cc/Pottier16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892227", + "title": "Reducing memory buffering overhead in software thread-level speculation", + "abstract": "Software-based, automatic parallelization through Thread-Level Speculation (TLS) has significant practical potential, but also high overhead costs. Traditional \"lazy\" buffering mechanisms enable strong isolation of speculative threads, but imply large memory overheads, while more recent \"eager\" mechanisms improve scalability, but are more sensitive to data dependencies and have higher rollback costs. We here describe an integrated system that incorporates the best of both designs, automatically selecting the best buffering mechanism. Our approach builds on well-optimized designs for both techniques, and we describe specific optimizations that improve both lazy and eager buffer management as well. We implement our design within MUTLS, a software-TLS system based on the LLVM compiler framework. Results show that we can get 75% geometric mean performance of OpenMP versions on 9 memory intensive benchmarks. Application of these optimizations is thus a useful part of the optimization stack needed for effective and practical software TLS.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892227", + "conference_name": "CC", + "authors": [ + { + "first_name": "Zhen", + "last_name": "Cao", + "institution": "McGill University" + }, + { + "first_name": "Clark", + "last_name": "Verbrugge", + "institution": "McGill University" + } + ], + "dblp_key": "conf/cc/CaoV16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892211", + "title": "Verified construction of static single assignment form", + "abstract": "Modern compilers use intermediate representations in static single assignment (SSA) form, which simplifies many optimizations. However, the high implementation complexity of efficient SSA construction algorithms poses a challenge to verified compilers. In this paper, we consider a variant of the recent SSA construction algorithm by Braun et al. that combines simplicity and efficiency, and is therefore a promising candidate to tackle this challenge. We prove the correctness of the algorithm using the theorem prover Isabelle/HOL. Furthermore, we prove that the algorithm constructs pruned SSA form and, in case of a reducible control flow graph, minimal SSA form. To the best of our knowledge, these are the first formal proofs regarding the quality of an SSA construction algorithm. Finally, we replace the SSA construction of the CompCertSSA project with code extracted by Isabelle's code generator to demonstrate the applicability to real world programs.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892211", + "conference_name": "CC", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Buchwald", + "institution": "" + }, + { + "first_name": "Denis", + "last_name": "Lohner", + "institution": "" + }, + { + "first_name": "Sebastian", + "last_name": "Ullrich", + "institution": "" + } + ], + "dblp_key": "conf/cc/BuchwaldLU16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892228", + "title": "On fusing recursive traversals of K-d trees", + "abstract": "Loop fusion is a key program transformation for data locality optimization that is implemented in production compilers. But optimizing compilers for imperative languages currently cannot ex- ploit fusion opportunities across a set of recursive tree traversal computations with producer-consumer relationships. In this paper, we develop a compile-time approach to dependence characterization and program transformation to enable fusion across recursively specified traversals over k-d trees. We present the FuseT source-to- source code transformation framework to automatically generate fused composite recursive operators from an input program containing a sequence of primitive recursive operators. We use our framework to implement fused operators for MADNESS, Multi-resolution Adaptive Numerical Environment for Scientific Simulation. We show that locality optimization through fusion can offer significant performance improvement.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892228", + "conference_name": "CC", + "authors": [ + { + "first_name": "Samyam", + "last_name": "Rajbhandari", + "institution": "The Ohio State University" + }, + { + "first_name": "Jinsung", + "last_name": "Kim", + "institution": "The Ohio State University" + }, + { + "first_name": "Sriram", + "last_name": "Krishnamoorthy", + "institution": "Pacific Northwest National Laboratory" + }, + { + "first_name": "Pouchet", + "last_name": "Louis-Noel", + "institution": "The Ohio State University" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Robert J.", + "last_name": "Harrison", + "institution": "Stony Brook University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/cc/RajbhandariKKPR16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892230", + "title": "Sparse representation of implicit flows with applications to side-channel detection", + "abstract": "Information flow analyses traditionally use the Program Dependence Graph (PDG) as a supporting data-structure. This graph relies on Ferrante et al.'s notion of control dependences to represent implicit flows of information. A limitation of this approach is that it may create O(|I| x |E|) implicit flow edges in the PDG, where I are the instructions in a program, and E are the edges in its control flow graph. This paper shows that it is possible to compute information flow analyses using a different notion of implicit dependence, which yields a number of edges linear on the number of definitions plus uses of variables. Our algorithm computes these dependences in a single traversal of the program's dominance tree. This efficiency is possible due to a key property of programs in Static Single Assignment form: the definition of a variable dominates all its uses. Our algorithm correctly implements Hunt and Sands system of security types. Contrary to their original formulation, which required O(IxI) space and time for structured programs, we require only O(I). We have used our ideas to build FlowTracker, a tool that uncovers side-channel vulnerabilities in cryptographic algorithms. FlowTracker handles programs with over one-million assembly instructions in less than 200 seconds, and creates 24% less implicit flow edges than Ferrante et al.'s technique. FlowTracker has detected an issue in a constant-time implementation of Elliptic Curve Cryptography; it has found several time-variant constructions in OpenSSL, one issue in TrueCrypt and it has validated the isochronous behavior of the NaCl library.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892230", + "conference_name": "CC", + "authors": [ + { + "first_name": "B. Dias", + "last_name": "Rodrigues", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Diego F.", + "last_name": "Aranha", + "institution": "Universidade Estadual de Campinas (UNICAMP)" + } + ], + "dblp_key": "conf/cc/RodriguesPA16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892229", + "title": "Relaxed dependence tracking for parallel runtime support", + "abstract": "It is notoriously difficult to achieve both correctness and scalability for many shared-memory parallel programs. To improve correctness and scalability, researchers have developed various kinds of parallel runtime support such as multithreaded record & replay and software transactional memory. Existing forms of runtime support slow programs significantly in order to track an execution's cross-thread dependences accurately. This paper investigates the potential for runtime support to hide latency introduced by dependence tracking, by tracking dependences in a relaxed way---meaning that not all dependences are tracked accurately. The key challenge in relaxing dependence tracking is preserving both the program's semantics and the runtime support's guarantees. We present an approach called relaxed dependence tracking (RT) and demonstrate its potential by building two types of RT-based runtime support. Our evaluation shows that RT hides much of the latency incurred by dependence tracking, although RT-based runtime support incurs costs and complexity in order to handle relaxed dependence information. By demonstrating how to relax dependence tracking to hide latency while preserving correctness, this work shows the potential for addressing a key cost of dependence tracking, thus advancing knowledge in the design of parallel runtime support.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892229", + "conference_name": "CC", + "authors": [ + { + "first_name": "Minjia", + "last_name": "Zhang", + "institution": "The Ohio State University" + }, + { + "first_name": "Swarnendu", + "last_name": "Biswas", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/cc/ZhangBB16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892215", + "title": "Automatic fault location for data structures", + "abstract": "Specification-based data structure verification is a powerful debugging technique. In this work we combine specification-based data structure verification with automatic detection of faulty program statements that corrupt data structures. The user specifies the consistency constraints for dynamic data structures as relationships among the nodes of a memory graph. Our system detects constraint violations to identify corrupted data structures during program execution and then automatically locates faulty code responsible for data structure corruption. Our approach offers two main advantages: (1) a highly precise automatic fault location method, and (2) a simple specification language. We employ incremental constraint checking for time efficient constraint matching and fault location. On average, while Tarantula statistical debugging technique narrows the fault to 10 statements, our technique narrows it to ≈ 4 statements..", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892215", + "conference_name": "CC", + "authors": [ + { + "first_name": "Vineet Kumar", + "last_name": "Singh", + "institution": "University of California, Riverside" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of California, Riverside" + }, + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "New Jersey Institute of Technology" + } + ], + "dblp_key": "conf/cc/SinghGN16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892223", + "title": "Kindergarten cop: dynamic nursery resizing for GHC", + "abstract": "Generational garbage collectors are among the most popular garbage collectors used in programming language runtime systems. Their performance is known to depend heavily on choosing the appropriate size of the area where new objects are allocated (the nursery). In imperative languages, it is usual to make the nursery as large as possible, within the limits imposed by the heap size. Functional languages, however, have quite different memory be- haviour. In this paper, we study the effect that the nursery size has on the performance of lazy functional programs, through the interplay between cache locality and the frequency of collections. We demonstrate that, in contrast with imperative programs, having large nurseries is not always the best solution. Based on these re- sults, we propose two novel algorithms for dynamic nursery resiz- ing that aim to achieve a compromise between good cache locality and the frequency of garbage collections. We present an implemen- tation of these algorithms in the state-of-the-art GHC compiler for the functional language Haskell, and evaluate them using an exten- sive benchmark suite. In the best case, we demonstrate a reduction in total execution times of up to 88.5%, or an 8.7 overall speedup, compared to using the production GHC garbage collector. On aver- age, our technique gives an improvement of 9.3% in overall perfor- mance across a standard suite of 63 benchmarks for the production GHC compiler.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892223", + "conference_name": "CC", + "authors": [ + { + "first_name": "Henrique", + "last_name": "Ferreiro", + "institution": "Universidade da Coruña" + }, + { + "first_name": "Laura M.", + "last_name": "Castro", + "institution": "Universidade da Coruña" + }, + { + "first_name": "Vladimir", + "last_name": "Janjic", + "institution": "University of St Andrews" + }, + { + "first_name": "Kevin", + "last_name": "Hammond", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/cc/FerreiroCJH16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892222", + "title": "Mechanizing conventional SSA for a verified destruction with coalescing", + "abstract": "Modern optimizing compilers rely on the Static Single Assignment (SSA) form to make optimizations fast and simpler to implement. From a semantic perspective, the SSA form is nowadays fairly well understood, as witnessed by recent advances in the field of formally verified compilers. The destruction of the SSA form, however, remains a difficult problem, even in a non-verified environment. In fact, the out-of-SSA transformation has been revisited, for correctness and performance issues, up until recently. Unsurprisingly, state-of-the-art compiler formalizations thus either completely ignore, only partially handle, or implement naively the SSA destruction. This paper reports on the implementation of such a destruction within a verified compiler. We formally define and prove the properties of the generation of Conventional SSA (CSSA) which make its destruction simple to implement and prove. Second, we implement and prove correct a coalescing destruction of CSSA, a la Boissinot et al., where variables can be coalesced according to a refined notion of interference. This formalization work extends the CompCertSSA compiler, whose correctness proof is mechanized in the Coq proof assistant. Our CSSA-based, coalescing destruction removes, on average, more than 99% of introduced copies, and leads to encouraging results concerning spilling during post-SSA register allocation.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892222", + "conference_name": "CC", + "authors": [ + { + "first_name": "Delphine", + "last_name": "Demange", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Yon Fernández de", + "last_name": "Retana", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + } + ], + "dblp_key": "conf/cc/DemangeR16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892220", + "title": "Safe and flexible adaptation via alternate data structure representations", + "abstract": "The choice of data structures is crucial for achieving high performance. For applications that are long-running and/or operate on large data sets, the best choice for main data structures can change multiple times over the course of a single execution. For example, in a graph-processing application where the graph evolves over time, the best data structure for representing the graph may change as the program executes. Similarly, in a database or a key-value store application, with changes in relative frequencies of different types of queries over time, the most efficient data structure changes as well. We introduce an approach that allows applications to adapt to current conditions (input characteristics, operations on data, state) by switching their data structures on-the-fly with little overhead and without the developer worrying about safety or specifying adaptation points (this is handled by our compiler infrastructure). We use our approach on different classes of problems that are compute- and memory-intensive: graph algorithms, database indexing, and two real-world applications, the Memcached object cache and the Space Tyrant online game server. Our results show that off-the-shelf applications can be transformed into adaptive applications with modest programmer effort; that the adaptive versions outperform the original, fixed-representation versions; and that adaptation can be performed on-the-fly safely and with very little runtime overhead.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892220", + "conference_name": "CC", + "authors": [ + { + "first_name": "Amlan", + "last_name": "Kusum", + "institution": "University of California, Riverside" + }, + { + "first_name": "Iulian", + "last_name": "Neamtiu", + "institution": "New Jersey Institute of Technology" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/cc/KusumNG16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892219", + "title": "Register allocation and promotion through combined instruction scheduling and loop unrolling", + "abstract": "Register allocation is a much studied problem. A particularly important context for optimizing register allocation is within loops, since a significant fraction of the execution time of programs is often inside loop code. A variety of algorithms have been proposed in the past for register allocation, but the complexity of the problem has resulted in a decoupling of several important aspects, including loop unrolling, register promotion, and instruction reordering. In this paper, we develop an approach to register allocation and promotion in a unified optimization framework that simultaneously considers the impact of loop unrolling and instruction scheduling. This is done via a novel instruction tiling approach where instructions within a loop are represented along one dimension and innermost loop iterations along the other dimension. By exploiting the regularity along the loop dimension, and imposing essential dependence based constraints on intra-tile execution order, the problem of optimizing register pressure is cast in a constraint programming formalism. Experimental results are provided from thousands of innermost loops extracted from the SPEC benchmarks, demonstrating improvements over the current state-of-the-art.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892219", + "conference_name": "CC", + "authors": [ + { + "first_name": "Łukasz", + "last_name": "Domagała", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Duco van", + "last_name": "Amstel", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/cc/DomagalaARS16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892214", + "title": "Performance implications of transient loop-carried data dependences in automatically parallelized loops", + "abstract": "Recent approaches to automatic parallelization have taken advantage of the low-latency on-chip interconnect provided in modern multicore processors, demonstrating significant speedups, even for complex workloads. Although these techniques can already extract significant thread-level parallelism from application loops, we are interested in quantifying and exploiting any additional performance that remains on the table. This paper confirms the existence of significant extra thread-level parallelism within loops parallelized by the HELIX compiler. However, improving static data dependence analysis is unable to reach the additional performance offered because the existing loop-carried dependences are true only on a small subset of loop iterations. We therefore develop three approaches to take advantage of the transient nature of these data dependences through speculation, via transactional memory support. Results show that coupling the state-of-the-art data dependence analysis with fine-grained speculation achieves most of the speedups and may help close the gap towards the limit of HELIX-style thread-level parallelism.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892214", + "conference_name": "CC", + "authors": [ + { + "first_name": "Niall", + "last_name": "Murphy", + "institution": "University of Cambridge" + }, + { + "first_name": "Timothy M.", + "last_name": "Jones", + "institution": "University of Cambridge" + }, + { + "first_name": "Robert", + "last_name": "Mullins", + "institution": "University of Cambridge" + }, + { + "first_name": "Simone", + "last_name": "Campanoni", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/cc/MurphyJMC16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892221", + "title": "Thread-level speculation with kernel support", + "abstract": "Runtime systems for speculative parallelization can be substantially sped up by implementing them with kernel support. We describe a novel implementation of a thread-level speculation (TLS) system using virtual memory to isolate speculative state, implemented in a Linux kernel module. This design choice not only maximizes performance, but also allows to guarantee soundness in the presence of system calls, such as I/O. Its ability to maintain speedups even on programs with frequent mis-speculation, significantly extends its usability, for instance in speculative parallelization. We demonstrate the advantage of kernel-based TLS on a number of programs from the Cilk suite, where this approach is superior to the state of the art in each single case (7.28x on average). All systems described in this paper are made available as open source.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892221", + "conference_name": "CC", + "authors": [ + { + "first_name": "Clemens", + "last_name": "Hammacher", + "institution": "Saarland University" + }, + { + "first_name": "Kevin", + "last_name": "Streit", + "institution": "Saarland University" + }, + { + "first_name": "Andreas", + "last_name": "Zeller", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/cc/HammacherSZH16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892212", + "title": "Heap bounds protection with low fat pointers", + "abstract": "Heap buffer overflow (underflow) errors are a common source of security vulnerabilities. One prevention mechanism is to add object bounds meta information and to instrument the program with explicit bounds checks for all memory access. The so-called \"fat pointers\" approach is one method for maintaining and propagating the meta information where native machine pointers are replaced with \"fat\" objects that explicitly store object bounds. Another approach is \"low fat pointers\", which encodes meta information within a native pointer itself, eliminating space overheads and also code compatibility issues. This paper presents a new low-fat pointer encoding that is fully compatible with existing libraries (e.g. pre-compiled libraries unaware of the encoding) and standard hardware (e.g. x86_64). We show that our approach has very low memory overhead, and competitive with existing state-of-the-art bounds instrumentation solutions.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892212", + "conference_name": "CC", + "authors": [ + { + "first_name": "Gregory J.", + "last_name": "Duck", + "institution": "National University of Singapore" + }, + { + "first_name": "Roland H. C.", + "last_name": "Yap", + "institution": "National University of Singapore" + } + ], + "dblp_key": "conf/cc/DuckY16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892225", + "title": "Restrictification of function arguments", + "abstract": "Pointer aliasing still hinders compiler optimizations, in spite of years of research on pointer disambiguation. Because the automatic disambiguation of pointers is a difficult endeavor, several programming languages offer programmers mechanisms to distinguish memory references, such as the “restrict” keyword in C. However, the use of such mechanisms is prone to human mistakes. In this paper we present a suite of automatic techniques that mitigate this problem. We have designed, implemented and tested three different ways to disambiguate pointers passed as arguments of functions. Our techniques combine static analyses to infer symbolic bounds of memory regions and code versioning. We generate a clone for each function whose arguments we can disambiguate and optimize it assuming the absence of aliasing among formal parameters. At runtime, we use the results of the symbolic interval tests to decide which version of a function we should call: the original one or the “restricted” clone, whenever we can prove that no aliasing can occur at runtime. An implementation of our restrictification methods in LLVM shows that we can vectorize up to 63% more operations than what could be accomplished using the -O3 optimization level of said compiler. When applying the optimization on OpenCV benchmarks, we have observed speedups as great as 40%.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892225", + "conference_name": "CC", + "authors": [ + { + "first_name": "Victor Hugo Sperle", + "last_name": "Campos", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Péricles", + "last_name": "Alves", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Henrique Nazaré", + "last_name": "Santos", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/cc/CamposASP16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892209", + "title": "Multiversioned decoupled access-execute: the key to energy-efficient compilation of general-purpose programs", + "abstract": "Computer architecture design faces an era of great challenges in an attempt to simultaneously improve performance and energy efficiency. Previous hardware techniques for energy management become severely limited, and thus, compilers play an essential role in matching the software to the more restricted hardware capabilities. One promising approach is software decoupled access-execute (DAE), in which the compiler transforms the code into coarse-grain phases that are well-matched to the Dynamic Voltage and Frequency Scaling (DVFS) capabilities of the hardware. While this method is proved efficient for statically analyzable codes, general-purpose applications pose significant challenges due to pointer aliasing, complex control flow and unknown runtime events. We propose a universal compile-time method to decouple general-purpose applications, using simple but efficient heuristics. Our solutions overcome the challenges of complex code and show that automatic decoupled execution significantly reduces the energy expenditure of irregular or memory-bound applications and even yields slight performance boosts. Overall, our technique achieves over 20% on average energy-delay-product (EDP) improvements (energy over 15% and performance over 5%) across 14 benchmarks from SPEC CPU 2006 and Parboil benchmark suites, with peak EDP improvements surpassing 70%.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892209", + "conference_name": "CC", + "authors": [ + { + "first_name": "Konstantinos", + "last_name": "Koukos", + "institution": "Uppsala University" + }, + { + "first_name": "Per", + "last_name": "Ekemark", + "institution": "Uppsala University" + }, + { + "first_name": "Georgios", + "last_name": "Zacharopoulos", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Vasileios", + "last_name": "Spiliopoulos", + "institution": "Uppsala University" + }, + { + "first_name": "Stefanos", + "last_name": "Kaxiras", + "institution": "Uppsala University" + }, + { + "first_name": "Alexandra", + "last_name": "Jimborean", + "institution": "Uppsala University" + } + ], + "dblp_key": "conf/cc/KoukosEZSKJ16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892232", + "title": "Static deadlock detection for concurrent go by global session graph synthesis", + "abstract": "Go is a programming language developed at Google, with channel-based concurrent features based on CSP. Go can detect global communication deadlocks at runtime when all threads of execution are blocked, but deadlocks in other paths of execution could be undetected. We present a new static analyser for concurrent Go code to find potential communication errors such as communication mismatch and deadlocks at compile time. Our tool extracts the communication operations as session types, which are then converted into Communicating Finite State Machines (CFSMs). Finally, we apply a recent theoretical result on choreography synthesis to generate a global graph representing the overall communication pattern of a concurrent program. If the synthesis is successful, then the program is free from communication errors. We have implemented the technique in a tool, and applied it to analyse common Go concurrency patterns and an open source application with over 700 lines of code.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892232", + "conference_name": "CC", + "authors": [ + { + "first_name": "Nicholas", + "last_name": "Ng", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/cc/NgY16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892218", + "title": "Static detection of energy defect patterns in Android applications", + "abstract": "For static analysis researchers, Android software presents a wide variety of interesting challenges. The target of our work is static detection of energy-drain defects in Android applications. The management of energy-intensive resources (e.g., GPS) creates various opportunities for software defects. Our goal is to detect statically “missing deactivation” energy-drain defects in the user interface of the application. First, we define precisely two patterns of run-time energy-drain behaviors, based on modeling of Android GUI control-flow paths and energy-related listener leaks along such paths. Next, we define a static detection algorithm targeting these patterns. The analysis considers valid interprocedural control-flow paths in a callback method and its transitive callees, in order to detect operations that add or remove listeners. Sequences of callbacks are then analyzed for possible listener leaks. Our evaluation considers the detection of GUI-related energy-drain defects reported in prior work, as well as new defects not discovered by prior approaches. In summary, the detection is very effective and precise, suggesting that the proposed analysis is suitable for practical use in static checking tools for Android.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892218", + "conference_name": "CC", + "authors": [ + { + "first_name": "Haowei", + "last_name": "Wu", + "institution": "The Ohio State University" + }, + { + "first_name": "Shengqian", + "last_name": "Yang", + "institution": "The Ohio State University" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/cc/WuYR16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892237", + "title": "Register allocation and instruction scheduling in Unison", + "abstract": "This paper describes Unison, a simple, flexible, and potentially optimal software tool that performs register allocation and instruction scheduling in integration using combinatorial optimization. The tool can be used as an alternative or as a complement to traditional approaches, which are fast but complex and suboptimal. Unison is most suitable whenever high-quality code is required and longer compilation times can be tolerated (such as in embedded systems or library releases), or the targeted processors are so irregular that traditional compilers fail to generate satisfactory code.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892237", + "conference_name": "CC", + "authors": [ + { + "first_name": "Roberto Castañeda", + "last_name": "Lozano", + "institution": "Swedish Institute" + }, + { + "first_name": "Mats", + "last_name": "Carlsson", + "institution": "Swedish Institute" + }, + { + "first_name": "Gabriel Hjort", + "last_name": "Blindell", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Christian", + "last_name": "Schulte", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/cc/LozanoCBS16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892236", + "title": "SYCO: a systematic testing tool for concurrent objects", + "abstract": "We present the concepts, usage and prototypical implementation of SYCO: a SYstematic testing tool for Concurrent Objects. The system receives as input a program, a selection of method to be tested, and a set of initial values for its parameters. SYCO offers a visual web interface to carry out the testing process and visualize the results of the different executions as well as the sequences of tasks scheduled as a sequence diagram. Its kernel includes state-of-the-art partial-order reduction techniques to avoid redundant computations during testing. Besides, SYCO incorporates an option to effectively catch deadlock errors. In particular, it uses advanced techniques which guide the execution towards potential deadlock paths and discard paths that are guaranteed to be deadlock free.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892236", + "conference_name": "CC", + "authors": [ + { + "first_name": "Elvira", + "last_name": "Albert", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Miguel", + "last_name": "Gómez‐Zamalloa", + "institution": "Universidad Complutense de Madrid" + }, + { + "first_name": "Miguel", + "last_name": "Isabel", + "institution": "Universidad Complutense de Madrid" + } + ], + "dblp_key": "conf/cc/AlbertGI16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892216", + "title": "Mapping deviation: a technique to adapt or to guard loop transformation intuitions for legality", + "abstract": "Parallel architectures are now omnipresent in mainstream electronic devices and exploiting them efficiently is a challenge for all developers. Hence, they need the support of languages, libraries and tools to assist them in the optimization or parallelization task. Compilers can provide a major help by automating this work. However they are very fragile black-boxes. A compiler may take a bad optimization decision because of imprecise heuristics or may turn off an optimization because of imprecise analyses, without providing much control or feedback to the end user. To address this issue, we introduce mapping deviation, a new compiler technique that aims at providing a useful feedback on the semantics of a given program restructuring. Starting from a transformation intuition a user or a compiler wants to apply, our algorithm studies its correctness and can suggest changes or conditions to make it possible rather than being limited to the classical go/no-go answer. This algorithm builds on state-of-the-art polyhedral representation of programs and provides a high flexibility. We present two example applications of this technique: improving semi-automatic optimization tools for programmers and automatically designing runtime tests to check the correctness of a transformation for compilers.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892216", + "conference_name": "CC", + "authors": [ + { + "first_name": "Cédric", + "last_name": "Bastoul", + "institution": "Université de Strasbourg" + } + ], + "dblp_key": "conf/cc/Bastoul16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892226", + "title": "On fast large-scale program analysis in Datalog", + "abstract": "Designing and crafting a static program analysis is challenging due to the complexity of the task at hand. Among the challenges are modelling the semantics of the input language, finding suitable abstractions for the analysis, and handwriting efficient code for the analysis in a traditional imperative language such as C++. Hence, the development of static program analysis tools is costly in terms of development time and resources for real world languages. To overcome, or at least alleviate the costs of developing a static program analysis, Datalog has been proposed as a domain specific language (DSL).With Datalog, a designer expresses a static program analysis in the form of a logical specification. While a domain specific language approach aids in the ease of development of program analyses, it is commonly accepted that such an approach has worse runtime performance than handcrafted static analysis tools. In this work, we introduce a new program synthesis methodology for Datalog specifications to produce highly efficient monolithic C++ analyzers. The synthesis technique requires the re-interpretation of the semi-naïve evaluation as a scaffolding for translation using partial evaluation. To achieve high-performance, we employ staged compilation techniques and specialize the underlying relational data structures for a given Datalog specification. Experimentation on benchmarks for large-scale program analysis validates the superior performance of our approach over available Datalog tools and demonstrates our competitiveness with state-of-the-art handcrafted tools.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892226", + "conference_name": "CC", + "authors": [ + { + "first_name": "Bernhard", + "last_name": "Scholz", + "institution": "" + }, + { + "first_name": "Herbert", + "last_name": "Jordan", + "institution": "" + }, + { + "first_name": "Pavle", + "last_name": "Subotić", + "institution": "University College London" + }, + { + "first_name": "Till", + "last_name": "Westmann", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/cc/ScholzJSW16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892217", + "title": "Input space splitting for OpenCL", + "abstract": "The performance of OpenCL programs suffers from memory and control flow divergence. Therefore, OpenCL compilers employ static analyses to identify non-divergent control flow and memory accesses in order to produce faster code. However, divergence is often input-dependent, hence can be observed for some, but not all inputs. In these cases, vectorizing compilers have to generate slow code because divergence can occur at run time. In this paper, we use a polyhedral abstraction to partition the input space of an OpenCL kernel. For each partition, divergence analysis produces more precise results i.e., it can classify more code parts as non-divergent. Consequently, specializing the kernel for the input space partitions allows for generating better SIMD code because of less divergence. We implemented our technique in an OpenCL driver for the AVX instruction set and evaluate it on a range of OpenCL benchmarks. We observe speed ups of up to 9x for irregular kernels over a state-of-the-art vectorizing OpenCL driver.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892217", + "conference_name": "CC", + "authors": [ + { + "first_name": "Simon", + "last_name": "Moll", + "institution": "Saarland University" + }, + { + "first_name": "Johannes", + "last_name": "Doerfert", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/cc/MollDH16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2897144", + "title": "Improved MHP Analysis", + "abstract": "May-Happen-in-Parallel (MHP) analysis is becoming the backbone of many of the parallel analyses and optimizations. In this paper, we present new approaches to do MHP analysis for X10-like languages that support async-finish-atomic parallelism. We present a fast incremental MHP algorithm to derive all the statements that may run in parallel with a given statement. We also extend the MHP algorithm of Agarwal et al. (answers if two given X10 statements may run in parallel, and under what condition) to improve the computational complexity, without compromising on the precision.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2897144", + "conference_name": "CC", + "authors": [ + { + "first_name": "Aravind", + "last_name": "Sankar", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "Soham", + "last_name": "Chakraborty", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "conf/cc/SankarCN16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892210", + "title": "Automatic data layout generation and kernel mapping for CPU+GPU architectures", + "abstract": "The ubiquity of hybrid CPU+GPU architectures has led to renewed interest in automatic data layout generation owing to the fact that data layouts have a large impact on performance, and that different data layouts yield the best performance on CPUs vs. GPUs. Unfortunately, current programming models still fail to provide an effective solution to the problem of automatic data layout generation for CPU+GPU processors. Specifically, the interaction among wholeprogram data layout optimizations, data movement optimizations, and mapping of kernels across heterogeneous cores pose a major challenge to current programming systems. In this paper, we introduce a novel two-level hierarchical formulation of the data layout and kernel mapping problem for modern heterogeneous architectures. The bottom level formulation deals with the data layout problem for a parallel code region on a given processor, which is NPHard, and we provide a greedy algorithm that uses an affinity graph to obtain approximate solutions. The top level formulation targets data layouts and kernel mapping for the entire program for which we provide a polynomial-time solution using a graph-based shortest path algorithm that uses the data layouts for the code regions (sections) for a given processor computed in the bottom level formulation. We implement this data layout transformation in the new Heterogeneous Habanero-C (H2C) parallel programming framework and propose performance models to characterize the data layout impact on both the CPU and GPU. Our data layout framework shows significant performance improvements of up to 2.9x (geometric mean 1.5x) on a multicore CPU+GPU compared to the manually specified layouts for a set of parallel programs running on a heterogeneous platform consisting of an Intel Xeon CPU and an NVIDIA GPU. Further, our framework also shows performance improvements of up to 2.7x (geometric mean 1.6x) on just the multicore CPU, demonstrating the applicability of our approach to both heterogeneous and homogeneous hardware platforms.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892210", + "conference_name": "CC", + "authors": [ + { + "first_name": "Deepak", + "last_name": "Majeti", + "institution": "Rice University" + }, + { + "first_name": "Kuldeep S.", + "last_name": "Meel", + "institution": "Rice University" + }, + { + "first_name": "Rajkishore", + "last_name": "Barik", + "institution": "Intel (United States)" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + } + ], + "dblp_key": "conf/cc/MajetiMBS16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892235", + "title": "SVF: interprocedural static value-flow analysis in LLVM", + "abstract": "© 2016 ACM. This paper presents SVF, a tool that enables scalable and precise interprocedural Static Value-Flow analysis for C programs by leveraging recent advances in sparse analysis. SVF, which is fully implemented in LLVM, allows value-flow construction and pointer analysis to be performed in an iterative manner, thereby providing increasingly improved precision for both. SVF accepts pointsto information generated by any pointer analysis (e.g., Andersen's analysis) and constructs an interprocedural memory SSA form, in which the def-use chains of both top-level and address-taken variables are captured. Such value-flows can be subsequently exploited to support various forms of program analysis or enable more precise pointer analysis (e.g., flow-sensitive analysis) to be performed sparsely. By dividing a pointer analysis into three loosely coupled components: Graph, Rules and Solver, SVF provides an extensible interface for users to write their own solutions easily. SVF is publicly available at http://unsw-corg.github.io/SVF.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892235", + "conference_name": "CC", + "authors": [ + { + "first_name": "Yulei", + "last_name": "Sui", + "institution": "UNSW Sydney" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/cc/SuiX16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892234", + "title": "Iguana: a practical data-dependent parsing framework", + "abstract": "Data-dependent grammars extend context-free grammars with arbitrary computation, variable binding, and constraints. These features provide the user with the freedom and power to express syntactic constructs outside the realm of context-free grammars, e.g., indentation rules in Haskell and type definitions in C. Data-dependent grammars have been recently presented by Jim et al. as a grammar formalism that enables construction of parsers from a rich format specification. Although some features of data-dependent grammars are available in current parsing tools, e.g., semantic predicates in ANTLR, data-dependent grammars have not yet fully found their way into practice. In this paper we present Iguana, a data-dependent parsing framework, implemented on top of the GLL parsing algorithm. In addition to basic features of data-dependent grammars, Iguana also provides high-level syntactic constructs, e.g., for operator precedence and indentation rules, which are implemented as desugaring to data-dependent grammars. These high-level constructs enable a concise and declarative way to define the syntax of programming languages. Moreover, Iguana's extensible data-dependent grammar API allows the user to easily add new high-level constructs or modify existing ones. We have used Iguana to parse various real programming languages, such as OCaml, Haskell, Java, and C#. In this paper we describe the architecture and features of Iguana, and report on its current implementation status.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892234", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ali", + "last_name": "Afroozeh", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Anastasia", + "last_name": "Izmaylova", + "institution": "Centrum Wiskunde & Informatica" + } + ], + "dblp_key": "conf/cc/AfroozehI16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892233", + "title": "GreenThumb: superoptimizer construction framework", + "abstract": "Developing an optimizing compiler backend remains a laborious process, especially for nontraditional ISAs that have been appearing recently. Superoptimization sidesteps the need for many code transformations by searching for the most optimal instruction sequence semantically equivalent to the original code fragment. Even though superoptimization discovers the best machine-specific code optimizations, it has yet to become widely-used. We propose GreenThumb, an extensible framework that reduces the cost of constructing superoptimizers and provides a fast search algorithm that can be reused for any ISA, exploiting the unique strengths of enumerative, stochastic, and symbolic (SAT-solver-based) search algorithms. To extend GreenThumb to a new ISA, it is only necessary to implement an emulator for the ISA and provide some ISA-specific search utility functions. This paper demonstrates retargetability of GreenThumb by showing how to construct a superoptimizer for a small subset of LLVM IR.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892233", + "conference_name": "CC", + "authors": [ + { + "first_name": "Phitchaya Mangpo", + "last_name": "Phothilimthana", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Aditya", + "last_name": "Thakur", + "institution": "Google (United States)" + }, + { + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" + }, + { + "first_name": "Dinakar", + "last_name": "Dhurjati", + "institution": "Qualcomm (United States)" + } + ], + "dblp_key": "conf/cc/PhothilimthanaT16", + "venue": "cc", + "year": 2016 + }, + { + "paper_id": "10.1145/2892208.2892213", + "title": "Extended lattice-based memory allocation", + "abstract": "This work extends lattice-based memory allocation, an earlier work on memory reuse through array contraction. Such an optimization is used for optimizing high-level programming languages where storage mapping may be abstracted away from programmers and to complement code transformations that introduce intermediate buffers. The main motivation for this extension is to improve the handling of more general forms of specifications we see today, e.g., with loop tiling, pipelining, and other forms of parallelism available in explicitly-parallel languages. Specifically, we handle the case when conflicting constraints (those that describe the array indices that cannot share the same location) are specified as a (non-convex) union of polyhedra. The choice of directions (or basis) of array reuse becomes important when dealing with non-convex specifications. We extend the two dual approaches in the original work to handle unions of polyhedra, and to select a suitable basis. Our final approach relies on a combination of the two, also revealing their links with, on one hand, the construction of multi-dimensional schedules for parallelism and tiling (but with a fundamental difference that we identify) and, on the other hand, the construction of universal reuse vectors (UOV), which was only used so far in a specific context, for schedule-independent mapping.", + "date": "2016-03-14", + "link": "https://doi.org/10.1145/2892208.2892213", + "conference_name": "CC", + "authors": [ + { + "first_name": "Alain", + "last_name": "Darte", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Alexandre", + "last_name": "Isoard", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Tomofumi", + "last_name": "Yuki", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/cc/DarteIY16", + "venue": "cc", + "year": 2016 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2018.json b/data/pl_conferences/cc/2018.json new file mode 100644 index 0000000..6c4e563 --- /dev/null +++ b/data/pl_conferences/cc/2018.json @@ -0,0 +1,582 @@ +[ + { + "paper_id": "10.1145/3178372.3179519", + "title": "An efficient data structure for must-alias analysis", + "abstract": "A must-alias (or “definite-alias”) analysis computes sets of expressions that are guaranteed to be aliased at a given pro- gram point. The analysis has been shown to have significant practical impact, and it is actively used in popular research frameworks and commercial tools. We present a custom data structure that speeds up must-alias analysis by nearly two orders of magnitude (while computing identical results). The data structure achieves efficiency by encoding multiple alias sets in a single linked structure, and compactly representing the aliasing relations of arbitrarily long expressions. We ex- plore the data structure’s performance in both an imperative and a declarative setting and contrast it extensively with prior techniques. With our approach, must-alias analysis can be performed efficiently, over large Java benchmarks, in under half a minute, making the analysis cost acceptable for most practical uses.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179519", + "conference_name": "CC", + "authors": [ + { + "first_name": "George", + "last_name": "Kastrinis", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "George", + "last_name": "Balatsouras", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Kostas", + "last_name": "Ferles", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Nefeli", + "last_name": "Prokopaki-Kostopoulou", + "institution": "National and Kapodistrian University of Athens" + }, + { + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" + } + ], + "dblp_key": "conf/cc/KastrinisBFPS18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179517", + "title": "Parallel sparse flow-sensitive points-to analysis", + "abstract": "This paper aims to contribute to further advances in pointer (or points-to) analysis algorithms along the combined dimen- sions of precision, scalability, and performance. For precision, we aim to support interprocedural ow-sensitive analysis. For scalability, we aim to show that our approach scales to large applications with reasonable memory requirements. For performance, we aim to design a points-to analysis algo- rithm that is amenable to parallel execution. The algorithm introduced in this paper achieves all these goals. As an ex- ample, our experimental results show that our algorithm can analyze the 2.2MLOC Tizen OS framework with < 16GB of memory while delivering an average analysis rate of > 10KLOC/second. Our points-to analysis algorithm, PSEGPT, is based on the Pointer Sparse Evaluation Graph (PSEG) form, a new analysis representation that combines both points-to and heap def-use information. PSEGPT is a scalable interprocedural flow-sensitive context-insensitive points-to analy- sis that is amenable to efficient task-parallel implementa- tions, even though points-to analysis is usually viewed as a challenge problem for parallelization. Our experimental results with 6 real-world applications on a 12-core machine show an average parallel speedup of 4.45× and maximum speedup of 7.35×. The evaluation also includes precision results by demonstrating that our algorithm identifies significantly more inlinable indirect calls (IICs) than SUPT and SS, two states of the art SSA-based points-to analyses implemented in LLVM.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179517", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jisheng", + "last_name": "Zhao", + "institution": "Rice University" + }, + { + "first_name": "Michael", + "last_name": "Burke", + "institution": "Rice University" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Rice University" + } + ], + "dblp_key": "conf/cc/ZhaoBS18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3183634", + "title": "Rethinking compilers in the rise of machine learning and AI (keynote)", + "abstract": "Recent years have witnessed some influential progresses in Machine Learning (ML) and Artificial Intelligence (AI). The progresses may lead to some significant changes to future programming. Many programs, for instance, may be not code written in some specially designed programming languages, but high-level user intentions expressed in natural languages. Deep Learning-based software, despite the difficulties in interpreting their results, may continue its rapid growth in the software market and its influence in people's everyday life. This talk will first examine the implications of these changes to compiler research, and then discuss the potential opportunities that ML and AI could bring to possibly transform the field of compiler research.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3183634", + "conference_name": "CC", + "authors": [ + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + } + ], + "dblp_key": "conf/cc/Shen18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179521", + "title": "Finding missed compiler optimizations by differential testing", + "abstract": "Randomized differential testing of compilers has had great success in finding compiler crashes and silent miscompilations. In this paper we investigate whether we can use similar techniques to improve the quality of the generated code: Can we compare the code generated by different compilers to find optimizations performed by one but missed by another?", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179521", + "conference_name": "CC", + "authors": [ + { + "first_name": "Gergö", + "last_name": "Barany", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/cc/Barany18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179499", + "title": "Tail call elimination and data representation for functional languages on the Java virtual machine", + "abstract": "The Java Virtual Machine (JVM) offers an attractive runtime environment for programming language implementers. The JVM has a simple bytecode format, excellent performance, multiple state-of-the art garbage collectors, robust backwards compatibility, and it runs on almost all platforms. Further, the Java ecosystem grants access to a plethora of libraries and tooling, including debuggers and profilers.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179499", + "conference_name": "CC", + "authors": [ + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aalborg University" + }, + { + "first_name": "Ramin", + "last_name": "Zarifi", + "institution": "University of Waterloo" + }, + { + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" + } + ], + "dblp_key": "conf/cc/MadsenZL18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179529", + "title": "Polyhedral expression propagation", + "abstract": "Polyhedral techniques have proven to be powerful for various optimizations, from automatic parallelization to accelerator programming. At their core, these techniques compute accurate dependences among statement instances in order to apply complex program transformations. Such transformations comprise memory layout or program order modifications by optimizing memory access functions or scheduling functions. However, these approaches treat statements as opaque entities and do not consider changing the structure of the contained expressions or the memory accesses involved.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179529", + "conference_name": "CC", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Doerfert", + "institution": "Saarland University" + }, + { + "first_name": "Shrey", + "last_name": "Sharma", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/cc/DoerfertSH18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179523", + "title": "PAYJIT: space-optimal JIT compilation and its practical implementation", + "abstract": "Just-in-time (JIT) compilation in dynamic programming languages can improve execution speed in code with hot sections. However, that comes at the cost of increased memory usage for the storage of compiled code and associated bookkeeping data, as well as up-front compilation time for the hot code.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179523", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jacob", + "last_name": "Brock", + "institution": "University of Rochester" + }, + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + }, + { + "first_name": "Xiaoran", + "last_name": "Xu", + "institution": "Rice University" + }, + { + "first_name": "Yan", + "last_name": "Zhang", + "institution": "" + } + ], + "dblp_key": "conf/cc/BrockDXZ18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3183636", + "title": "Compiler and language design for quantum computing (keynote)", + "abstract": "Quantum computing, once merely a curious concept discussed within the field of theoretical physics, has long-since become of practical interest in numerous fields and caught the attention of mainstream media. The reason for the widespread interest stems from the tremendous impact it could have on today’s technology. Quantum computing could revolutionize how we develop new materials, how we approach machine learning and optimization tasks, and provide answers to some of the most intriguing questions in physics, chemistry and biology.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3183636", + "conference_name": "CC", + "authors": [ + { + "first_name": "Bettina", + "last_name": "Heim", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/cc/Heim18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179505", + "title": "Compiling for concise code and efficient I/O", + "abstract": "Large infrastructures of Internet companies, such as Facebook and Twitter, are composed of several layers of micro-services. While this modularity provides scalability to the system, the I/O associated with each service request strongly impacts its performance. In this context, writing concise programs which execute I/O efficiently is especially challenging. In this paper, we introduce Ÿauhau, a novel compile-time solution. Ÿauhau reduces the number of I/O calls through rewrites on a simple expression language. To execute I/O concurrently, it lowers the expression language to a dataflow representation. Our approach can be used alongside an existing programming language, permitting the use of legacy code. We describe an implementation in the JVM and use it to evaluate our approach. Experiments show that Ÿauhau can significantly improve I/O, both in terms of the number of I/O calls and concurrent execution. Ÿauhau outperforms state-of-the-art approaches with similar goals.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179505", + "conference_name": "CC", + "authors": [ + { + "first_name": "Sebastian", + "last_name": "Ertel", + "institution": "TU Dresden" + }, + { + "first_name": "Andrés", + "last_name": "Goens", + "institution": "TU Dresden" + }, + { + "first_name": "Justus", + "last_name": "Adam", + "institution": "TU Dresden" + }, + { + "first_name": "Jerónimo", + "last_name": "Castrillón", + "institution": "TU Dresden" + } + ], + "dblp_key": "conf/cc/ErtelGAC18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179507", + "title": "Modeling the conflicting demands of parallelism and Temporal/Spatial locality in affine scheduling", + "abstract": "The construction of effective loop nest optimizers and parallelizers remains challenging despite decades of work in the area. Due to the increasing diversity of loop-intensive applications and to the complex memory/computation hierarchies in modern processors, optimization heuristics are pulled towards conflicting goals, highlighting the lack of a systematic approach to optimizing locality and parallelism. Acknowledging these conflicting demands on loop nest optimization, we propose an algorithmic template capable of modeling the multi-level parallelism and the temporal/spatial locality of multiprocessors and accelerators. This algorithmic template orchestrates a collection of parameterizable, linear optimization problems over a polyhedral space of semantics-preserving transformations. While the overall problem is not convex, effective algorithms can be derived from this template delivering unprecedented performance portability over GPU and multicore CPU. We discuss the rationale for this algorithmic template and validate it on representative computational kernels/benchmarks.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179507", + "conference_name": "CC", + "authors": [ + { + "first_name": "Oleksandr", + "last_name": "Zinenko", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Sven", + "last_name": "Verdoolaege", + "institution": "Statistics Belgium" + }, + { + "first_name": "Chandan", + "last_name": "Reddy", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jun", + "last_name": "Shirako", + "institution": "Atlanta Technical College" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "ETH Zurich" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/cc/ZinenkoVRSGS018", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179497", + "title": "Computing partially path-sensitive MFP solutions in data flow analyses", + "abstract": "Data flow analysis traverses paths in a control flow graph (CFG) representation of programs to compute useful information. Many of these paths are infeasible, i.e. they cannot arise in any possible execution. The information computed along these paths adds imprecision to the conventional Maximal Fixed Point (MFP) solution of a data flow analysis. Existing approaches for removing this imprecision are either specific to a data flow problem or involve control flow graph restructuring which has exponential complexity.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179497", + "conference_name": "CC", + "authors": [ + { + "first_name": "Komal", + "last_name": "Pathade", + "institution": "Tata Consultancy Services (India)" + }, + { + "first_name": "Uday P.", + "last_name": "Khedker", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "conf/cc/PathadeK18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179515", + "title": "CAnDL: a domain specific language for compiler analysis", + "abstract": "Optimizing compilers require sophisticated program analysis and transformations to exploit modern hardware. Implementing the appropriate analysis for a compiler optimization is a time consuming activity. For example, in LLVM, tens of thousands of lines of code are required to detect appropriate places to apply peephole optimizations. It is a barrier to the rapid prototyping and evaluation of new optimizations.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179515", + "conference_name": "CC", + "authors": [ + { + "first_name": "Philip", + "last_name": "Ginsbach", + "institution": "University of Edinburgh" + }, + { + "first_name": "Lewis", + "last_name": "Crawford", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/GinsbachCO18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179501", + "title": "Fast and flexible instruction selection with constraints", + "abstract": "Tree-parsing instruction selection as used in, e.g., lcc, uses dynamic costs to gain flexibility and handle situations (such as read-modify-write instructions) that do not fit into the basic tree-parsing model. The disadvantage of dynamic costs is that we can no longer turn the tree grammar into a tree automaton (as is done by burg) for fast instruction selection for JIT compilers. In this paper we introduce constraints that say whether a tree-grammar rule is applicable or not. While theoretically less powerful than dynamic costs, constraints cover the practical uses of dynamic costs; more importantly, they allow turning the tree grammar with constraints into a tree automaton (with instruction-selection-time checks), resulting in faster instruction selection than with pure instruction-selection-time dynamic programming. We integrate constraints in an instruction selector that matches DAGs with tree rules. We evaluate this concept in lcc and the CACAO JavaVM JIT compiler, and see instruction selector speedups by a factor 1.33--1.89.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179501", + "conference_name": "CC", + "authors": [ + { + "first_name": "Patrick", + "last_name": "Thier", + "institution": "TU Wien" + }, + { + "first_name": "M. Anton", + "last_name": "Ertl", + "institution": "TU Wien" + }, + { + "first_name": "Andreas", + "last_name": "Krall", + "institution": "TU Wien" + } + ], + "dblp_key": "conf/cc/ThierEK18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179495", + "title": "A session type provider: compile-time API generation of distributed protocols with refinements in F#", + "abstract": "We present a library for the specification and implementation of distributed protocols in native F# (and other .NET languages) based on multiparty session types (MPST). There are two main contributions. Our library is the first practical development of MPST to support what we refer to as interaction refinements: a collection of features related to the refinement of protocols, such as message-type refinements (value constraints) and message value dependent control flow. A well-typed endpoint program using our library is guaranteed to perform only compliant session I/O actions w.r.t. to the refined protocol, up to premature termination.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179495", + "conference_name": "CC", + "authors": [ + { + "first_name": "Rumyana", + "last_name": "Neykova", + "institution": "Imperial College London" + }, + { + "first_name": "Raymond", + "last_name": "Hu", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + }, + { + "first_name": "Fahd", + "last_name": "Abdeljallal", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/cc/NeykovaHYA18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179509", + "title": "A polyhedral compilation framework for loops with dynamic data-dependent bounds", + "abstract": "We study the parallelizing compilation and loop nest optimization of an important class of programs where counted loops have a dynamic data-dependent upper bound. Such loops are amenable to a wider set of transformations than general while loops with inductively defined termination conditions: for example, the substitution of closed forms for induction variables remains applicable, removing the loop-carried data dependences induced by termination conditions. We propose an automatic compilation approach to parallelize and optimize dynamic counted loops. Our approach relies on affine relations only, as implemented in state-of-the-art polyhedral libraries. Revisiting a state-of-the-art framework to parallelize arbitrary while loops, we introduce additional control dependences on data-dependent predicates. Our method goes beyond the state of the art in fully automating the process, specializing the code generation algorithm to the case of dynamic counted loops and avoiding the introduction of spurious loop-carried dependences. We conduct experiments on representative irregular computations, from dynamic programming, computer vision and finite element methods to sparse matrix linear algebra. We validate that the method is applicable to general affine transformations for locality optimization, vectorization and parallelization.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179509", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jie", + "last_name": "Zhao", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Michael", + "last_name": "Kruse", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "conf/cc/ZhaoK018", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179525", + "title": "Termination checking and task decomposition for task-based intermittent programs", + "abstract": "Emerging energy-harvesting computer systems extract energy from their environment to compute, sense, and communicate with no battery or tethered power supply. Building software for energy-harvesting devices is a challenge, because they operate only intermittently as energy is available. Programs frequently reboot due to power loss, which can corrupt program state and prevent forward progress. Task-based programming models allow intermittent execution of long-running applications, but require the programmer to decompose code into tasks that will eventually complete between two power failures. Task decomposition is challenging and no tools exist to aid in task decomposition.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179525", + "conference_name": "CC", + "authors": [ + { + "first_name": "Alexei", + "last_name": "Colin", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/cc/ColinL18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179503", + "title": "Semantic reasoning about the sea of nodes", + "abstract": "The Sea of Nodes intermediate representation was introduced by Cliff Click in the mid 90s as an enhanced Static Single Assignment (SSA) form. It improves on the initial SSA form by relaxing the total order on instructions in basic blocks into explicit data and control dependencies. This makes programs more flexible to optimize. This graph-based representation is now used in many industrial-strength compilers, such as HotSpot or Graal. While the SSA form is now well understood from a semantic perspective -- even formally verified optimizing compilers use it in their middle-end -- very few semantic studies have been conducted about the Sea of Nodes.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179503", + "conference_name": "CC", + "authors": [ + { + "first_name": "Delphine", + "last_name": "Demange", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Yon Fernández de", + "last_name": "Retana", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "Université de Rennes" + } + ], + "dblp_key": "conf/cc/DemangeRP18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179513", + "title": "Towards a compiler analysis for parallel algorithmic skeletons", + "abstract": "Parallelizing compilers aim to detect data-parallel loops in sequential programs, which -- after suitable transformation -- can be safely and profitably executed in parallel. However, in the traditional model safe parallelization requires provable absence of dependences. At the same time, several well-known parallel algorithmic skeletons cannot be easily expressed in a data dependence framework due to spurious depedences, which prevent parallel execution. In this paper we argue that commutativity is a more suitable concept supporting formal characterization of parallel algorithmic skeletons. We show that existing commutativity definitions cannot be easily adapted for practical use, and develop a new concept of commutativity based on liveness, which readily integrates with existing compiler analyses. This enables us to develop formal definitions of parallel algorithmic skeletons such as task farms, MapReduce and Divide&Conquer. We show that existing informal characterizations of various parallel algorithmic skeletons are captured by our abstract formalizations. In this way we provide the urgently needed formal characterization of widely used parallel constructs allowing their immediate use in novel parallelizing compilers.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179513", + "conference_name": "CC", + "authors": [ + { + "first_name": "Tobias J.K. Edler von", + "last_name": "Koch", + "institution": "Qualcomm (United States)" + }, + { + "first_name": "Stanislav", + "last_name": "Manilov", + "institution": "University of Edinburgh" + }, + { + "first_name": "Christos", + "last_name": "Vasiladiotis", + "institution": "University of Edinburgh" + }, + { + "first_name": "Murray", + "last_name": "Cole", + "institution": "University of Edinburgh" + }, + { + "first_name": "Björn", + "last_name": "Franke", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/KochMVCF18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179511", + "title": "Generalized profile-guided iterator recognition", + "abstract": "Iterators prescribe the traversal of data structures and determine loop termination, and many loop analyses and transformations require their exact identification. While recognition of iterators is a straight-forward task for affine loops, the situation is different for loops iterating over dynamic data structures or involving control flow dependent computations to determine the next data element. In this paper we propose a compiler analysis for recognizing loop iterators code for a wide class of loops. We initially develop a static analysis, which is then enhanced with profiling information to support speculative code optimizations. We have prototyped our analysis in the LLVM framework and demonstrate its capabilities using the SPEC CPU2006 benchmarks. Our approach is applicable to all loops and we show that we can recognize iterators in, on average, 88.1% of over 75,000 loops using static analysis alone, and up to 94.9% using additional profiling information. Existing techniques perform substantially worse, especially for C and C++ applications, and cover only 35-44% of the loops. Our analysis enables advanced loop optimizations such as decoupled software pipelining, commutativity analysis and source code rejuvenation for real-world applications, which escape analysis and transformation if loop iterators are not recognized accurately.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179511", + "conference_name": "CC", + "authors": [ + { + "first_name": "Stanislav", + "last_name": "Manilov", + "institution": "University of Edinburgh" + }, + { + "first_name": "Christos", + "last_name": "Vasiladiotis", + "institution": "University of Edinburgh" + }, + { + "first_name": "Björn", + "last_name": "Franke", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/ManilovVF18", + "venue": "cc", + "year": 2018 + }, + { + "paper_id": "10.1145/3178372.3179527", + "title": "Efficient dynamic analysis for Node.js", + "abstract": "Due to its popularity, there is an urgent need for dynamic program-analysis tools for Node.js, helping developers find bugs, performance bottlenecks, and bad coding practices. Frameworks based on code-level instrumentation enable dynamic analyses close to program semantics and are more flexible than Node.js built-in profiling tools. However, existing code-level instrumentation frameworks for JavaScript suffer from enormous overheads and difficulties in instrumenting the built-in module library of Node.js. In this paper, we introduce a new dynamic analysis framework for JavaScript and Node.js called NodeProf. While offering similar flexibility as code-level instrumentation frameworks, NodeProf significantly improves analysis performance while ensuring comprehensive code coverage. NodeProf supports runtime (de)activation of analyses and incurs zero overhead when no analysis is active. NodeProf is based on dynamic instrumentation of the JavaScript runtime and leverages automatic partial evaluation to generate efficient machine code. In addition, NodeProf makes use of the language interoperability provided by the runtime and thus allows dynamic analyses to be written in Java and JavaScript with compatibility to Jalangi, a state-of-the-art code-level JavaScript instrumentation framework. Our experiments show that the peak performance of running the same dynamic analyses using NodeProf can be up to three orders of magnitude faster than Jalangi.", + "date": "2018-02-21", + "link": "https://doi.org/10.1145/3178372.3179527", + "conference_name": "CC", + "authors": [ + { + "first_name": "Haiyang", + "last_name": "Sun", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Daniele", + "last_name": "Bonetta", + "institution": "Oracle (United States)" + }, + { + "first_name": "Christian", + "last_name": "Humer", + "institution": "" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/cc/SunBHB18", + "venue": "cc", + "year": 2018 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2019.json b/data/pl_conferences/cc/2019.json new file mode 100644 index 0000000..9764b4c --- /dev/null +++ b/data/pl_conferences/cc/2019.json @@ -0,0 +1,526 @@ +[ + { + "paper_id": "10.1145/3302516.3307354", + "title": "Enabling prefix sum parallelism pattern for recurrences with principled function reconstruction", + "abstract": "Much research work has been done to parallelize loops with recurrences over the last several decades. Recently, sampling-and-reconstruction method was proposed to parallelize a broad class of loops with recurrences in an automated fashion, with a practical runtime approach. Although the parallelized codes achieve linear scalability across multi-cores architectures, the sequential merge inherent to this method makes it not scalable on many core architectures, such as GPUs. At the same time, existing parallel merge approaches used for simple reduction loops cannot be directly and correctly applied to this method.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307354", + "conference_name": "CC", + "authors": [ + { + "first_name": "Yang", + "last_name": "Xia", + "institution": "The Ohio State University" + }, + { + "first_name": "Peng", + "last_name": "Jiang", + "institution": "The Ohio State University" + }, + { + "first_name": "Gagan", + "last_name": "Agrawal", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/cc/XiaJA19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307361", + "title": "The sparse tensor algebra compiler (keynote)", + "abstract": "Tensor algebra is a powerful tool with applications in machine learning, data analytics, engineering, and science. Increasingly often the tensors are sparse, which means most components are zeros. To get the best performance, currently programmers are left to write kernels for every operation, with different mixes of sparse and dense tensors in different formats. There are countless combinations, which makes it impossible to manually implement and optimize them all. The Tensor Algebra Compiler (TACO) is the first system to automatically generate kernels for any tensor algebra operation on tensors in any of the commonly used formats. Its performance is competitive with best-in-class hand-optimized kernels in popular libraries, while supporting far more tensor operations. For more information, see http://tensor-compiler.org.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307361", + "conference_name": "CC", + "authors": [ + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/cc/Amarasinghe19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307349", + "title": "Path sensitive MFP solutions in presence of intersecting infeasible control flow path segments", + "abstract": "Data flow analysis computes Maximum Fix Point (MFP) solution which represents an over approximation of the data reaching a program point along all control flow paths (cfps). Some of these cfps may be infeasible; meaning, the necessary pre-condition for execution of cfp is not satisfiable in any run of the program. Approximations that do not discern data along infeasible cfps may lead to imprecision, because they include spurious information.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307349", + "conference_name": "CC", + "authors": [ + { + "first_name": "Komal", + "last_name": "Pathade", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Uday P.", + "last_name": "Khedker", + "institution": "Indian Institute of Technology Bombay" + } + ], + "dblp_key": "conf/cc/PathadeK19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307352", + "title": "GPU-accelerated fixpoint algorithms for faster compiler analyses", + "abstract": "Inter-procedural data-flow analyses are slow. We parallelize these predicate propagation fixpoint algorithms efficiently on a GPU.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307352", + "conference_name": "CC", + "authors": [ + { + "first_name": "Thorsten", + "last_name": "Blaß", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Michæl", + "last_name": "Philippsen", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + } + ], + "dblp_key": "conf/cc/BlassP19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307359", + "title": "Compare less, defer more: scaling value-contexts based whole-program heap analyses", + "abstract": "The precision of heap analyses determines the precision of several associated optimizations, and has been a prominent area in compiler research. It has been shown that context-sensitive heap analyses are more precise than the insensitive ones, but their scalability continues to be a cause of concern. Though the value-contexts approach improves the scalability of classical call-string based context-sensitive analyses, it still does not scale well for several popular whole-program heap analyses. In this paper, we propose a three-stage analysis approach that lets us scale complex whole-program value-contexts based heap analyses for large programs, without losing their precision.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307359", + "conference_name": "CC", + "authors": [ + { + "first_name": "Manas", + "last_name": "Thakur", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "conf/cc/ThakurN19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307344", + "title": "Property caches revisited", + "abstract": "Property caches are a well-known technique invented over 30 years ago to improve dynamic object accesses. They have been adapted to JavaScript, which they have greatly contributed to accelerate. However, this technique is applicable only when some constraints are satisfied by the objects, the properties, and the property access sites. In this work, we propose enhancements to improve two common usage patterns: prototype accesses and megamorphic accesses. We have implemented these in the Hopc AOT JavaScript compiler and we have measured their impact. We observe that they effectively complement traditional caches. They reduce cache misses and consequently accelerate execution. Moreover, they do not cause a slowdown in the handling of the other usage patterns.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307344", + "conference_name": "CC", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Marc", + "last_name": "Feeley", + "institution": "Université de Montréal" + } + ], + "dblp_key": "conf/cc/SerranoF19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307358", + "title": "Codestitcher: inter-procedural basic block layout optimization", + "abstract": "Modern software executes a large amount of code. Previous techniques of code layout optimization were developed one or two decades ago and have become inadequate to cope with the scale and complexity of new types of applications such as compilers, browsers, interpreters, language VMs and shared libraries.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307358", + "conference_name": "CC", + "authors": [ + { + "first_name": "Rahman", + "last_name": "Lavaee", + "institution": "University of Rochester" + }, + { + "first_name": "John", + "last_name": "Criswell", + "institution": "University of Rochester" + }, + { + "first_name": "Chen", + "last_name": "Ding", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/cc/LavaeeCD19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307348", + "title": "Automatic adaptive approximation for stencil computations", + "abstract": "Approximate computing is necessary to meet deadlines in some compute-intensive applications like simulation. Building them requires a high level of expertise from the application designers as well as a significant development effort. Some application programming interfaces greatly facilitate their conception but they still heavily rely on the developer's domain-specific knowledge and require many modifications to successfully generate an approximate version of the program. In this paper we present new techniques to semi-automatically discover relevant approximate computing parameters. We believe that superior compiler-user interaction is the key to improved productivity. After pinpointing the region of interest to optimize, the developer is guided by the compiler in making the best implementation choices. Static analysis and runtime monitoring are used to infer approximation parameter values for the application. We evaluated these techniques on multiple application kernels that support approximation and show that with the help of our method, we achieve similar performance as non-assisted, hand-tuned version while requiring minimal intervention from the user.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307348", + "conference_name": "CC", + "authors": [ + { + "first_name": "Maxime", + "last_name": "Schmitt", + "institution": "Université de Strasbourg" + }, + { + "first_name": "Philippe", + "last_name": "Helluy", + "institution": "Université de Strasbourg" + }, + { + "first_name": "Cédric", + "last_name": "Bastoul", + "institution": "Central Compilation & Translation Bureau" + } + ], + "dblp_key": "conf/cc/SchmittHB19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307356", + "title": "Spinal code: automatic code extraction for near-user computation in fogs", + "abstract": "In the Internet of Things (IoT) environments, cloud servers integrate various IoT devices including sensors and actuators, and provide new services that assist daily lives of users interacting with the physical world. While response time is a crucial factor of quality of the services, supporting short response time is challenging for the cloud servers due to a growing number and amount of connected devices and their communication. To reduce the burden of the cloud servers, fog computing is a promising alternative to offload computation and communication overheads from the cloud servers to fog nodes. However, since existing fog computing frameworks do not extract codes for fog nodes fully automatically, programmers should manually write and analyze their applications for fog computing. This work proposes Spinal Code, a new compiler-runtime framework for near-user computation that automatically partitions an original cloud-centric program into distributed sub-programs running over the cloud and fog nodes. Moreover, to reduce response time in the physical world, Spinal Code allows programmers to annotate latency sensitive actuators in a program, and optimizes the critical paths from required sensors to the actuators when it generates the sub-programs. This work implements 9 IoT programs across 4 service domains: healthcare, smart home, smart building and smart factory, and demonstrates that Spinal Code successfully reduces 44.3% of response time and 79.9% of communication on the cloud compared with a cloud-centric model.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307356", + "conference_name": "CC", + "authors": [ + { + "first_name": "Bongjun", + "last_name": "Kim", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Seonyeong", + "last_name": "Heo", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Gyeongmin", + "last_name": "Lee", + "institution": "Korea Post" + }, + { + "first_name": "Seungbin", + "last_name": "Song", + "institution": "Yonsei University" + }, + { + "first_name": "Jong", + "last_name": "Kim", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Hanjun", + "last_name": "Kim", + "institution": "Yonsei University" + } + ], + "dblp_key": "conf/cc/KimHLS0K19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307357", + "title": "Revec: program rejuvenation through revectorization", + "abstract": "Modern microprocessors are equipped with Single Instruction Multiple Data (SIMD) or vector instructions which expose data level parallelism at a fine granularity. Programmers exploit this parallelism by using low-level vector intrinsics in their code. However, once programs are written using vector intrinsics of a specific instruction set, the code becomes non-portable. Modern compilers are unable to analyze and retarget the code to newer vector instruction sets. Hence, programmers have to manually rewrite the same code using vector intrinsics of a newer generation to exploit higher data widths and capabilities of new instruction sets. This process is tedious, error-prone and requires maintaining multiple code bases. We propose Revec, a compiler optimization pass which revectorizes already vectorized code, by retargeting it to use vector instructions of newer generations. The transformation is transparent, happening at the compiler intermediate representation level, and enables performance portability of hand-vectorized code.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307357", + "conference_name": "CC", + "authors": [ + { + "first_name": "Charith", + "last_name": "Mendis", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ajay", + "last_name": "Jain", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Paras", + "last_name": "Jain", + "institution": "University of California, Berkeley" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "conf/cc/MendisJJA19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307346", + "title": "Low-cost deterministic C++ exceptions for embedded systems", + "abstract": "The C++ programming language offers a strong exception mechanism for error handling at the language level, improving code readability, safety, and maintainability. However, current C++ implementations are targeted at general-purpose systems, often sacrificing code size, memory usage, and resource determinism for the sake of performance. This makes C++ exceptions a particularly undesirable choice for embedded applications where code size and resource determinism are often paramount. Consequently, embedded coding guidelines either forbid the use of C++ exceptions, or embedded C++ tool chains omit exception handling altogether. In this paper, we develop a novel implementation of C++ exceptions that eliminates these issues, and enables their use for embedded systems. We combine existing stack unwinding techniques with a new approach to memory management and run-time type information (RTTI). In doing so we create a compliant C++ exception handling implementation, providing bounded runtime and memory usage, while reducing code size requirements by up to 82%, and incurring only a minimal runtime overhead for the common case of no exceptions.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307346", + "conference_name": "CC", + "authors": [ + { + "first_name": "James", + "last_name": "Renwick", + "institution": "University of Edinburgh" + }, + { + "first_name": "Tom", + "last_name": "Spink", + "institution": "University of Edinburgh" + }, + { + "first_name": "Björn", + "last_name": "Franke", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/RenwickSF19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307350", + "title": "PPOpenCL: a performance-portable OpenCL compiler with host and kernel thread code fusion", + "abstract": "OpenCL offers code portability but no performance portability. Given an OpenCL program X specifically written for one platform P, existing OpenCL compilers, which usually optimize its host and kernel codes individually, often yield poor performance for another platform Q. Instead of obtaining a performance-improved version of X for Q via manual tuning, we aim to achieve this automatically by a source-to-source OpenCL compiler framework, PPOpenCL. By fusing X's host and kernel thread codes (with the operations in different work-items in the same work-group represented explicitly), we are able to apply data flow analyses, and subsequently, performance-enhancing optimizations on a fused control flow graph specifically for platform Q. Validation against OpenCL benchmarks shows that PPOpenCL (implemented in Clang 3.9.1) can achieve significantly improved portable performance on seven platforms considered.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307350", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ying", + "last_name": "Liu", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Lei", + "last_name": "Huang", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Ming-Chuan", + "last_name": "Wu", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Huimin", + "last_name": "Cui", + "institution": "Institute of Computing Technology" + }, + { + "first_name": "Fang", + "last_name": "Lv", + "institution": "Chinese Academy of Sciences" + }, + { + "first_name": "Xiaobing", + "last_name": "Feng", + "institution": "University of Chinese Academy of Sciences" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/cc/LiuHWCL0X19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307351", + "title": "Valence: variable length calling context encoding", + "abstract": "Many applications, including program optimizations, debugging tools, and event loggers, rely on calling context to gain additional insight about how a program behaves during execution. One common strategy for determining calling contexts is to use compiler instrumentation at each function call site and return sites to encode the call paths and store them in a designated area of memory. While recent works have shown that this approach can generate precise calling context encodings with low overhead, the encodings can grow to hundreds or even thousands of bytes to encode a long call path, for some applications. Such lengthy encodings increase the costs associated with storing, detecting, and decoding call path contexts, and can limit the effectiveness of this approach for many usage scenarios.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307351", + "conference_name": "CC", + "authors": [ + { + "first_name": "Tong", + "last_name": "Zhou", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Michael R.", + "last_name": "Jantz", + "institution": "University of Tennessee at Knoxville" + }, + { + "first_name": "Prasad A.", + "last_name": "Kulkarni", + "institution": "University of Kansas" + }, + { + "first_name": "Kshitij", + "last_name": "Doshi", + "institution": "Intel (United States)" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/cc/ZhouJKDS19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307347", + "title": "To unify or not to unify: a case study on unified builds (in WebKit)", + "abstract": "Unified builds are a simple but effective technique to reduce the build time of large software projects. Unified builds generate large compiler tasks by bundling multiple source files into one, resulting in a significant reduction in build time through removal of redundant work incurred by shared headers. However, unified builds have a negative effect on incremental builds because each compiler task gets larger. An ad-hoc unification strategy causes an excessive slowdown in incremental builds. A rough report from WebKit says the worst slowdown is 20% (6s → 7s), but our investigation shows it is as high as 479% (19s → 110s).", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307347", + "conference_name": "CC", + "authors": [ + { + "first_name": "Takafumi", + "last_name": "Kubota", + "institution": "Keio University" + }, + { + "first_name": "Yusuke", + "last_name": "Suzuki", + "institution": "Keio University" + }, + { + "first_name": "Kenji", + "last_name": "Kono", + "institution": "Keio University" + } + ], + "dblp_key": "conf/cc/KubotaSK19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307355", + "title": "Accelerating web application loading with snapshot of event and DOM handling", + "abstract": "Reducing the loading time of a web app is important for a better user experience. The loading time includes a large amount of JavaScript execution, often composed of the execution of the global code in the script tags followed by the execution of event handlers. One approach to accelerate the app loading is saving the already-loaded execution state of JavaScript objects in a file called the snapshot in advance. Then, we start an app by copying the objects in the snapshot to the JavaScript heap directly, instead of executing JavaScript code to create them. Unfortunately, existing works save only the execution state of the global code in the snapshot, not that of the event handlers. Also, JavaScript code whose execution may change the DOM (Document Object Model) tree is not saved in the snapshot, limiting the coverage of the snapshot.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307355", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jihwan", + "last_name": "Yeo", + "institution": "Seoul National University" + }, + { + "first_name": "Jin-Seok", + "last_name": "Oh", + "institution": "Seoul National University" + }, + { + "first_name": "Soo‐Mook", + "last_name": "Moon", + "institution": "Seoul National University" + } + ], + "dblp_key": "conf/cc/YeoOM19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307345", + "title": "A static slicing method for functional programs and its incremental version", + "abstract": "An effective static slicing technique for functional programs must have two features. Its handling of function calls must be context sensitive without being inefficient, and, because of the widespread use of algebraic datatypes, it must take into account structure transmitted dependences. It has been shown that any analysis that combines these two characteristics is undecidable, and existing slicing methods drop one or the other. We propose a slicing method that only weakens (and not entirely drop) the requirement of context-sensitivity and that too for some and not all programs.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307345", + "conference_name": "CC", + "authors": [ + { + "first_name": "Prasanna Kumar", + "last_name": "K.", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Amitabha", + "last_name": "Sanyal", + "institution": "Indian Institute of Technology Bombay" + }, + { + "first_name": "Amey", + "last_name": "Karkare", + "institution": "Indian Institute of Technology Kanpur" + }, + { + "first_name": "Saswat", + "last_name": "Padhi", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/cc/KSKP19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307360", + "title": "Efficiency and expressiveness in UW-OpenMP", + "abstract": "OpenMP uses the efficient ‘team of workers’ model, where workers are given chunks of tasks (iterations of a parallel-for-loop, or sections in a parallel-sections block) to execute, and worker (not tasks) can be synchronized using barriers. Thus, OpenMP restricts the invocation of barriers in these tasks; as otherwise, the behavior of the program would be dependent on the number of runtime workers. To address such a restriction which can adversely impact programmability and readability, Aloor and Nandivada proposed UW-OpenMP by taking inspiration from the more intuitive interaction of tasks and barriers in newer task parallel languages like X10, HJ, Chapel and so on. UW-OpenMP gives the programmer an impression that each parallel task is executed by a unique worker, and importantly these parallel tasks can be synchronized using a barrier construct. Though UW-OpenMP is a useful extension of OpenMP (more expressive and efficient), it does not admit barriers within recursive functions invoked from parallel-for-loops, because of the inherent challenges in handing them. In this paper, we extend UW-OpenMP (we call it UWOmp++) to address this challenging limitation and in the process also realize more efficient programs.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307360", + "conference_name": "CC", + "authors": [ + { + "first_name": "Raghesh", + "last_name": "Aloor", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "conf/cc/AloorN19", + "venue": "cc", + "year": 2019 + }, + { + "paper_id": "10.1145/3302516.3307353", + "title": "Efficient concolic testing of MPI applications", + "abstract": "Software testing is widely used in industry, but its application in the High Performance Computing area has been scarce. Concolic testing, that automates testing via generation of inputs, has been highly successful for desktop applications and thus recent work on the COMPI tool has extended it to MPI programs. However, COMPI has two limitations. First, it requires the user to specify an upper limit on input size – if the chosen limit is too big, considerable time is wasted and if the chosen limit is too small, the branch coverage achieved is limited. Second, COMPI does not support floating point arithmetic that is common in HPC applications.", + "date": "2019-02-14", + "link": "https://doi.org/10.1145/3302516.3307353", + "conference_name": "CC", + "authors": [ + { + "first_name": "Hongbo", + "last_name": "Li", + "institution": "University of California, Riverside" + }, + { + "first_name": "Zizhong", + "last_name": "Chen", + "institution": "University of California, Riverside" + }, + { + "first_name": "Rajiv", + "last_name": "Gupta", + "institution": "University of California, Riverside" + } + ], + "dblp_key": "conf/cc/LiC019", + "venue": "cc", + "year": 2019 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2020.json b/data/pl_conferences/cc/2020.json new file mode 100644 index 0000000..0158729 --- /dev/null +++ b/data/pl_conferences/cc/2020.json @@ -0,0 +1,619 @@ +[ + { + "paper_id": "10.1145/3377555.3377900", + "title": "Robust quantization of deep neural networks", + "abstract": "We studied robust quantization of deep neural networks (DNNs) for embedded devices. Existing compression techniques often generate DNNs that are sensitive to external errors. Because embedded devices may be affected by external lights and outside weather, DNNs running on those devices must be robust to such errors. For robust quantization of DNNs, we formulate an optimization problem that finds the bit width for each layer minimizing the robustness loss. To efficiently find the solution, we design a dynamic programming based algorithm, called Qed. We also propose an incremental algorithm, Q* that quickly finds a reasonably robust quantization and then gradually improves it. We have evaluated Qed and Q* with three DNN models (LeNet, AlexNet, and VGG-16) and with Gaussian random errors and realistic errors. For comparison, we also evaluate universal quantization that uses equal bit width for all layers and Deep Compression, a weight-sharing based compression technique. When tested with increasing size of errors, Qed most robustly gives correct inference output. Even if a DNN is optimized for robustness, its quantizations may not be robust unless Qed is used. Moreover, we evaluate Q* for its trade off in execution time and robustness. In one tenth of Qed’s execution time, Q* gives a quantization 98% as robust as the one by Qed.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377900", + "conference_name": "CC", + "authors": [ + { + "first_name": "Young‐Seok", + "last_name": "Kim", + "institution": "Hanyang University" + }, + { + "first_name": "Junyeol", + "last_name": "Lee", + "institution": "Hanyang University" + }, + { + "first_name": "Younghoon", + "last_name": "Kim", + "institution": "Hanyang University" + }, + { + "first_name": "Jiwon", + "last_name": "Seo", + "institution": "Hanyang University" + } + ], + "dblp_key": "conf/cc/KimLKS20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377902", + "title": "Mix your contexts well: opportunities unleashed by recent advances in scaling context-sensitivity", + "abstract": "Existing precise context-sensitive heap analyses do not scale well for large OO programs. Further, identifying the right context abstraction becomes quite intriguing as two of the most popular categories of context abstractions (call-site- and object-sensitive) lead to theoretically incomparable precision. In this paper, we address this problem by first doing a detailed comparative study (in terms of precision and efficiency) of the existing approaches, both with and without heap cloning. In addition, we propose novel context abstractions that lead to a new sweet-spot in the arena.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377902", + "conference_name": "CC", + "authors": [ + { + "first_name": "Manas", + "last_name": "Thakur", + "institution": "Indian Institute of Technology Mandi" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "conf/cc/ThakurN20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377888", + "title": "Dynamic property caches: a step towards faster JavaScript proxy objects", + "abstract": "Inline caches and hidden classes are two essential components for closing the performance gap between static languages such as Java, Scheme, or ML and dynamic languages such as JavaScript or Python. They rely on the observation that for a particular object access located at a particular point of the program, the shapes, usually referred to as the hidden classes, of accessed objects are likely to be the same. Taking benefit of that invariant, they replace the expensive lookup the semantics of these languages normally demand with one test, the inline cache, and a memory read indexed by an offset computed during the last cache miss. These optimizations are essential but they are not general enough to cope with JavaScript’s proxies. In particular, when the property name is itself unknown statically, inline cache-based optimizations always take a slow path.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377888", + "conference_name": "CC", + "authors": [ + { + "first_name": "Manuel", + "last_name": "Serrano", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + } + ], + "dblp_key": "conf/cc/SerranoF20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377898", + "title": "Is stateful packrat parsing really linear in practice? a counter-example, an improved grammar, and its parsing algorithms", + "abstract": "Stateful packrat parsing is an algorithm for parsing syntaxes that have context-sensitive features. It is a well-known knowledge among researchers that the running time of stateful packrat parsing is linear for real-world grammars, as demonstrated in existing studies. However, we have found the cases in real-world grammars and tools that lead its running time to become exponential.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377898", + "conference_name": "CC", + "authors": [ + { + "first_name": "Nariyoshi", + "last_name": "Chida", + "institution": "NTT (Japan)" + }, + { + "first_name": "Yuhei", + "last_name": "Kawakoya", + "institution": "NTT (Japan)" + }, + { + "first_name": "Dai", + "last_name": "Ikarashi", + "institution": "NTT (Japan)" + }, + { + "first_name": "Kenji", + "last_name": "Takahashi", + "institution": "NTT (Japan)" + }, + { + "first_name": "Koushik", + "last_name": "Sen", + "institution": "University of California, Berkeley" + } + ], + "dblp_key": "conf/cc/ChidaKITS20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377890", + "title": "Vectorization-aware loop unrolling with seed forwarding", + "abstract": "Loop unrolling is a widely adopted loop transformation, commonly used for enabling subsequent optimizations. Straight-line-code vectorization (SLP) is an optimization that benefits from unrolling. SLP converts isomorphic instruction sequences into vector code. Since unrolling generates repeatead isomorphic instruction sequences, it enables SLP to vectorize more code. However, most production compilers apply these optimizations independently and uncoordinated. Unrolling is commonly tuned to avoid code bloat, not maximizing the potential for vectorization, leading to missed vectorization opportunities.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377890", + "conference_name": "CC", + "authors": [ + { + "first_name": "Rodrigo C. O.", + "last_name": "Rocha", + "institution": "University of Edinburgh" + }, + { + "first_name": "Vasileios", + "last_name": "Porpodas", + "institution": "Intel (United States)" + }, + { + "first_name": "Pavlos", + "last_name": "Petoumenos", + "institution": "University of Manchester" + }, + { + "first_name": "Luís F. W.", + "last_name": "Góes", + "institution": "Pontifícia Universidade Católica de Minas Gerais" + }, + { + "first_name": "Zheng", + "last_name": "Wang", + "institution": "University of Leeds" + }, + { + "first_name": "Murray", + "last_name": "Cole", + "institution": "University of Edinburgh" + }, + { + "first_name": "Hugh", + "last_name": "Leather", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/RochaPPG0CL20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377885", + "title": "Scalable pointer analysis of data structures using semantic models", + "abstract": "Pointer analysis is widely used as a base for different kinds of static analyses and compiler optimizations. Designing a scalable pointer analysis with acceptable precision for use in production compilers is still an open question. Modern object oriented languages like Java and Scala promote abstractions and code reuse, both of which make it difficult to achieve precision. Collection data structures are an example of a pervasively used component in such languages. But analyzing collection implementations with full context sensitivity leads to prohibitively long analysis times.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377885", + "conference_name": "CC", + "authors": [ + { + "first_name": "Pratik", + "last_name": "Fegade", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Christian", + "last_name": "Wimmer", + "institution": "Oracle (United States)" + } + ], + "dblp_key": "conf/cc/FegadeW20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377896", + "title": "Generating fast sparse matrix vector multiplication from a high level generic functional IR", + "abstract": "Usage of high-level intermediate representations promises the generation of fast code from a high-level description, improving the productivity of developers while achieving the performance traditionally only reached with low-level programming approaches.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377896", + "conference_name": "CC", + "authors": [ + { + "first_name": "Federico", + "last_name": "Pizzuti", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "University of Glasgow" + }, + { + "first_name": "Christophe", + "last_name": "Dubach", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/PizzutiSD20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377887", + "title": "A study of event frequency profiling with differential privacy", + "abstract": "Program profiling is widely used to measure run-time execution properties---for example, the frequency of method and statement execution. Such profiling could be applied to deployed software to gain performance insights about the behavior of many instances of the analyzed software. However, such data gathering raises privacy concerns: for example, it reveals whether (and how often) a software user accesses a particular software functionality. There is growing interest in adding privacy protections for many categories of data analyses, but such techniques have not been studied sufficiently for program event profiling.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377887", + "conference_name": "CC", + "authors": [ + { + "first_name": "Hailong", + "last_name": "Zhang", + "institution": "The Ohio State University" + }, + { + "first_name": "Yu", + "last_name": "Hao", + "institution": "The Ohio State University" + }, + { + "first_name": "Sufian", + "last_name": "Latif", + "institution": "The Ohio State University" + }, + { + "first_name": "Raef", + "last_name": "Bassily", + "institution": "The Ohio State University" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/cc/0006HLBR20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377897", + "title": "Secure delivery of program properties through optimizing compilation", + "abstract": "Annotations and assertions capturing static program properties are ubiquitous, from robust software engineering to safety-critical or secure code. These may be functional or non-functional properties of control and data flow, memory usage, I/O and real time. We propose an approach to encode, translate, and preserve the semantics of both functional and non-functional properties along the optimizing compilation of C to machine code. The approach involves (1) capturing and translating source-level properties through lowering passes and intermediate representations, such that data and control flow optimizations will preserve their consistency with the transformed program, and (2) carrying properties and their translation as debug information down to machine code. Our experiments using LLVM validate the soundness, expressiveness and efficiency of the approach, considering a reference suite of functional properties as well as established security properties and applications hardened against side-channel attacks.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377897", + "conference_name": "CC", + "authors": [ + { + "first_name": "Son Tuan", + "last_name": "Vu", + "institution": "Laboratoire de Recherche en Informatique de Paris 6" + }, + { + "first_name": "Karine", + "last_name": "Heydemann", + "institution": "Sorbonne Université" + }, + { + "first_name": "Arnaud de", + "last_name": "Grandmaison", + "institution": "" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "" + } + ], + "dblp_key": "conf/cc/VuHG020", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377893", + "title": "Automatically harnessing sparse acceleration", + "abstract": "Sparse linear algebra is central to many scientific programs, yet compilers fail to optimize it well. High-performance libraries are available, but adoption costs are significant. Moreover, libraries tie programs into vendor-specific software and hardware ecosystems, creating non-portable code.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377893", + "conference_name": "CC", + "authors": [ + { + "first_name": "Philip", + "last_name": "Ginsbach", + "institution": "University of Edinburgh" + }, + { + "first_name": "Bruce", + "last_name": "Collie", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael F. P.", + "last_name": "O'Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/GinsbachCO20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377892", + "title": "Improving database query performance with automatic fusion", + "abstract": "Array-based programming languages have shown significant promise for improving performance of column-based in-memory database systems, allowing elegant representation of query execution plans that are also amenable to standard compiler optimization techniques. Use of loop fusion, however, is not straightforward, due to the complexity of built-in functions for implementing complex database operators. In this work, we apply a compiler approach to optimize SQL query execution plans that are expressed in an array-based intermediate representation. We analyze this code to determine shape properties of the data being processed, and use a subsequent optimization phase to fuse multiple database operators into single, compound operations, reducing the need for separate computation and storage of intermediate values. Experimental results on a range of TPC-H queries show that our fusion technique is effective in generating efficient code, improving query time over a baseline system.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377892", + "conference_name": "CC", + "authors": [ + { + "first_name": "Hanfeng", + "last_name": "Chen", + "institution": "McGill University" + }, + { + "first_name": "Alexander", + "last_name": "Krolik", + "institution": "McGill University" + }, + { + "first_name": "Bettina", + "last_name": "Kemme", + "institution": "McGill University" + }, + { + "first_name": "Clark", + "last_name": "Verbrugge", + "institution": "McGill University" + }, + { + "first_name": "Laurie", + "last_name": "Hendren", + "institution": "McGill University" + } + ], + "dblp_key": "conf/cc/ChenKKVH20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377886", + "title": "Runtime multi-versioning and specialization inside a memoized speculative loop optimizer", + "abstract": "In this paper, we propose a runtime framework that implements code multi-versioning and specialization to optimize and parallelize loop kernels that are invoked many times with varying parameters. These parameters may influence the code structure, the touched memory locations, the workload, and the runtime performance. They may also impact the validity of the parallelizing and optimizing polyhedral transformations that are applied on-the-fly.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377886", + "conference_name": "CC", + "authors": [ + { + "first_name": "Raquel", + "last_name": "Lazcano", + "institution": "Universidad Politécnica de Madrid" + }, + { + "first_name": "Daniel", + "last_name": "Madroñal", + "institution": "Universidad Politécnica de Madrid" + }, + { + "first_name": "Eduardo", + "last_name": "Juárez", + "institution": "Universidad Politécnica de Madrid" + }, + { + "first_name": "Philippe", + "last_name": "Clauss", + "institution": "Université de Strasbourg" + } + ], + "dblp_key": "conf/cc/LazcanoMJC20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377891", + "title": "Mixed-data-model heterogeneous compilation and OpenMP offloading", + "abstract": "Heterogeneous computers combine a general-purpose host processor with domain-specific programmable many-core accelerators, uniting high versatility with high performance and energy efficiency. While the host manages ever-more application memory, accelerators are designed to work mainly on their local memory. This difference in addressed memory leads to a discrepancy between the optimal address width of the host and the accelerator. Today 64-bit host processors are commonplace, but few accelerators exceed 32-bit addressable local memory, a difference expected to increase with 128-bit hosts in the exascale era. Managing this discrepancy requires support for multiple data models in heterogeneous compilers. So far, compiler support for multiple data models has not been explored, which hampers the programmability of such systems and inhibits their adoption.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377891", + "conference_name": "CC", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Kurth", + "institution": "ETH Zurich" + }, + { + "first_name": "Koen", + "last_name": "Wolters", + "institution": "ETH Zurich" + }, + { + "first_name": "Björn", + "last_name": "Forsberg", + "institution": "ETH Zurich" + }, + { + "first_name": "Alessandro", + "last_name": "Capotondi", + "institution": "University of Modena and Reggio Emilia" + }, + { + "first_name": "Andrea", + "last_name": "Marongiu", + "institution": "University of Modena and Reggio Emilia" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "ETH Zurich" + }, + { + "first_name": "Luca", + "last_name": "Benini", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/cc/KurthWFCMGB20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377889", + "title": "Compiling first-order functions to session-typed parallel code", + "abstract": "Building correct and efficient message-passing parallel programs still poses many challenges. The incorrect use of message-passing constructs can introduce deadlocks, and a bad task decomposition will not achieve good speedups. Current approaches focus either on correctness or efficiency, but limited work has been done on ensuring both. In this paper, we propose a new parallel programming framework, PAlg, which is a first-order language with participant annotations that ensures deadlock-freedom by construction. PAlg programs are coupled with an abstraction of their communication structure, a global type from the theory of multiparty session types (MPST). This global type serves as an output for the programmer to assess the efficiency of their achieved parallelisation. PAlg is implemented as an EDSL in Haskell, from which we: 1. compile to low-level message-passing C code; 2. compile to sequential C code, or interpret as sequential Haskell functions; and, 3. infer the communication protocol followed by the compiled message-passing program. We use the properties of global types to perform message reordering optimisations to the compiled C code. We prove the extensional equivalence of the compiled code, as well as protocol compliance. We achieve linear speedups on a shared-memory 12-core machine, and a speedup of 16 on a 2-node, 24-core NUMA.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377889", + "conference_name": "CC", + "authors": [ + { + "first_name": "David", + "last_name": "Castro", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/cc/Castro-PerezY20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377899", + "title": "Bitwidth customization in image processing pipelines using interval analysis and SMT solvers", + "abstract": "Unlike CPUs and GPUs, it is possible to use custom fixed-point data types, specified as a tuple (α, β), on FPGAs. The parameters α and β denote the number of integral and fractional bitwidths respectively. The power and area savings while performing arithmetic operations on fixed-point data types are well known to be significant over using floating-point data types.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377899", + "conference_name": "CC", + "authors": [ + { + "first_name": "Suresh", + "last_name": "Purini", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Vinamra", + "last_name": "Benara", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Ziaul", + "last_name": "Choudhury", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Uday", + "last_name": "Bondhugula", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/cc/PuriniBCB20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377895", + "title": "Balancing performance and productivity for the development of dynamic binary instrumentation tools: a case study on Arm systems", + "abstract": "Dynamic Binary Instrumentation (DBI) is a well-established approach for analysing the execution of applications at the level of machine code. DBI frameworks implement a runtime system capable of modifying running applications without access to their source code. These frameworks provide APIs used by DBI tools to plug in their specific analysis and instrumentation routines. However, the dynamic instrumentation needed by these DBI tools is either challenging to implement, and/or introduces a significant performance overhead.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377895", + "conference_name": "CC", + "authors": [ + { + "first_name": "Cosmin", + "last_name": "Gorgovan", + "institution": "University of Manchester" + }, + { + "first_name": "Guillermo", + "last_name": "Callaghan", + "institution": "University of Manchester" + }, + { + "first_name": "Mikel", + "last_name": "Luján", + "institution": "University of Manchester" + } + ], + "dblp_key": "conf/cc/GorgovanCL20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377901", + "title": "Relaxing the one definition rule in interpreted C++", + "abstract": "Most implementations of the C++ programming language generate binary executable code. However, interpreted execution of C++ sources has its own use cases as the Cling interpreter from CERN's ROOT project has shown. Some limitations are derived from the ODR (One Definition Rule) that rules out multiple definitions of entities within a single translation unit (TU). ODR is there to ensure uniform view of a given C++ entity across translation units. Ensuring uniform view of C++ entities helps when producing ABI compatible binaries. Interpreting C++ presumes a single ever-growing translation unit that define away some of the ODR use-cases. Therefore, it may well be desirable to relax the ODR and, consequently, to support the ability of developers to override any existing definition for a given declaration. This approach is especially well-suited for iterative prototyping. In this paper, we extend Cling, a Clang/LLVM-based C++ interpreter, to enable redefinitions of C++ entities at the prompt. To achieve this, top-level declarations are nested into inline namespaces and the translation unit lookup table is adjusted to invalidate previous definitions that would otherwise result in ambiguities. Formally, this technique refactors the code to an equivalent that does not violate the ODR, as each definition is nested in a different namespace. Furthermore, any previous definition that has been shadowed is still accessible by means of its fully-qualified name. A prototype implementation of the presented technique has been integrated into the Cling C++ interpreter, showing that our technique is feasible and usable.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377901", + "conference_name": "CC", + "authors": [ + { + "first_name": "Javier", + "last_name": "López-Gómez", + "institution": "Universidad Carlos III de Madrid" + }, + { + "first_name": "Javier", + "last_name": "Fernández", + "institution": "Universidad Carlos III de Madrid" + }, + { + "first_name": "David del Rio", + "last_name": "Astorga", + "institution": "Universidad Carlos III de Madrid" + }, + { + "first_name": "Vassil", + "last_name": "Vassilev", + "institution": "Princeton University" + }, + { + "first_name": "N. A.", + "last_name": "Naumann", + "institution": "European Organization for Nuclear Research" + }, + { + "first_name": "J. Daniel", + "last_name": "García", + "institution": "Universidad Carlos III de Madrid" + } + ], + "dblp_key": "conf/cc/Lopez-Gomez0AVN20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377884", + "title": "Postcondition-preserving fusion of postorder tree transformations", + "abstract": "Tree transformations are common in applications such as program rewriting in compilers. Using a series of simple transformations to build a more complex system can make the resulting software easier to understand, maintain, and reason about. Fusion strategies for combining such successive tree transformations promote this modularity, whilst mitigating the performance impact from increased numbers of tree traversals. However, it is important to ensure that fused transformations still perform their intended tasks. Existing approaches to fusing tree transformations tend to take an informal approach to soundness, or be too restrictive to consider the kind of transformations needed in a compiler. We use postconditions to define a more useful formal notion of successful fusion, namely postcondition-preserving fusion. We also present criteria that are sufficient to ensure postcondition-preservation and facilitate modular reasoning about the success of fusion.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377884", + "conference_name": "CC", + "authors": [ + { + "first_name": "E.", + "last_name": "Davies", + "institution": "University of Warwick" + }, + { + "first_name": "Sara", + "last_name": "Kalvala", + "institution": "University of Warwick" + } + ], + "dblp_key": "conf/cc/DaviesK20", + "venue": "cc", + "year": 2020 + }, + { + "paper_id": "10.1145/3377555.3377894", + "title": "Compiler-based graph representations for deep learning models of code", + "abstract": "In natural language processing, novel methods in deep learning, like recurrent neural networks (RNNs) on sequences of words, have been very successful. In contrast to natural languages, programming languages usually have a well-defined structure. With this structure compilers can reason about programs, using graphs such as abstract syntax trees (ASTs) or control-data flow graphs (CDFGs). In this paper, we argue that we should use these graph structures instead of sequences for learning compiler optimization tasks. To this end, we use graph neural networks (GNNs) for learning predictive compiler tasks on two representations based on ASTs and CDFGs. Experiments show that this improves upon the state-of-the-art in the task of heterogeneous OpenCL mapping, while providing orders of magnitude faster inference times, crucial for compiler optimizations. When testing on benchmark suites not included for training, our AST-based model significantly outperforms the state-of-the-art by over 12 percentage points in terms of accuracy. It is the only one to perform clearly better than a random mapping. On the task of predicting thread coarsening factors, we show that all of the methods fail to produce an overall speedup.", + "date": "2020-02-22", + "link": "https://doi.org/10.1145/3377555.3377894", + "conference_name": "CC", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Brauckmann", + "institution": "TU Dresden" + }, + { + "first_name": "Andrés", + "last_name": "Goens", + "institution": "TU Dresden" + }, + { + "first_name": "Sebastian", + "last_name": "Ertel", + "institution": "Barkhausen Institute" + }, + { + "first_name": "Jerónimo", + "last_name": "Castrillón", + "institution": "TU Dresden" + } + ], + "dblp_key": "conf/cc/BrauckmannGEC20", + "venue": "cc", + "year": 2020 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2021.json b/data/pl_conferences/cc/2021.json new file mode 100644 index 0000000..0a473df --- /dev/null +++ b/data/pl_conferences/cc/2021.json @@ -0,0 +1,389 @@ +[ + { + "paper_id": "10.1145/3446804.3446843", + "title": "Lightning BOLT: powerful, fast, and scalable binary optimization", + "abstract": "Profile-guided binary optimization has proved to be an important technology to achieve peak performance, particularly for large-scale binaries that are typical for data-center applications. By applying the profile data at the same representation where sampling-based profiling is collected, binary optimizers can provide double-digit speedups over binaries compiled with profile-guided optimizations using similarly collected profile data. The main blocker for adoption of binary optimizers in practice is the overhead that they add to the already long and demanding build pipelines used for producing highly optimized binaries, which already include aggressive compiler optimizations guided by profile data and also link-time optimizations. This paper addresses the overheads of binary optimizers in the context of BOLT, a modern and powerful open-source binary optimizer. More specifically, this paper describes Lightning BOLT, which is an improved version of the BOLT binary optimizer that drastically reduces BOLT’s processing time and memory requirements, while preserving BOLT’s effectiveness in improving the final binary’s performance. Using a set of real-world data-center and open-source applications, we show that Lightning BOLT speeds up BOLT’s processing by an average of 4.71× and reduces BOLT’s memory consumption by 70.5% on average. Furthermore, Lightning BOLT also provides an adjustable mechanism to further reduce BOLT’s overheads at the cost of some lost performance for the final binary.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446843", + "conference_name": "CC", + "authors": [ + { + "first_name": "Maksim", + "last_name": "Panchenko", + "institution": "Meta (United States)" + }, + { + "first_name": "Rafael", + "last_name": "Auler", + "institution": "Meta (United States)" + }, + { + "first_name": "Laith", + "last_name": "Sakka", + "institution": "Meta (United States)" + }, + { + "first_name": "Guilherme", + "last_name": "Ottoni", + "institution": "Meta (United States)" + } + ], + "dblp_key": "conf/cc/PanchenkoASO21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446845", + "title": "PGZ: automatic zero-value code specialization", + "abstract": "In prior work we proposed Zeroploit, a transform that duplicates code, specializes one path assuming certain key program operands, called versioning variables, are zero, and leaves the other path unspecialized. Dynamically, depending on the versioning variable’s value, either the specialized fast path or the default slow path will execute. We evaluated Zeroploit with hand-optimized codes in that work.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446845", + "conference_name": "CC", + "authors": [ + { + "first_name": "Mark W.", + "last_name": "Stephenson", + "institution": "Nvidia (United States)" + }, + { + "first_name": "Ram", + "last_name": "Rangan", + "institution": "" + } + ], + "dblp_key": "conf/cc/StephensonR21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446844", + "title": "Integrating a functional pattern-based IR into MLIR", + "abstract": "The continued specialization in hardware and software due to the end of Moore's law forces us to question fundamental design choices in compilers, and in particular for domain specific languages. The days where a single universal compiler intermediate representation (IR) was sufficient to perform all important optimizations are over. We need novel IRs and ways for them to interact with one another while leveraging established compiler infrastructures.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446844", + "conference_name": "CC", + "authors": [ + { + "first_name": "Martin Paul", + "last_name": "Lücke", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michel", + "last_name": "Steuwer", + "institution": "University of Edinburgh" + }, + { + "first_name": "A. Gordon", + "last_name": "Smith", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/cc/LuckeSS21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446855", + "title": "Compiling data-parallel Datalog", + "abstract": "Datalog allows intuitive declarative specification of logical inference tasks while enjoying efficient implementation via state-of-the-art engines such as LogicBlox and Soufflé. These engines enable high-performance implementation of complex logical tasks including graph mining, program analysis, and business analytics. However, all efficient modern Datalog solvers make use of shared memory, and present inherent challenges scalability. In this paper, we leverage recent insights in parallel relational algebra and present a methodology for constructing data-parallel deductive databases. Our approach leverages recent developments in parallelizing relational algebra to create an efficient data-parallel semantics for Datalog. Based on our methodology, we have implemented the first MPI-based data-parallel Datalog solver. Our experiments demonstrate comparable performance and improved single-node scalability versus Soufflé, a state-of-art solver.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446855", + "conference_name": "CC", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Gilray", + "institution": "University of Alabama at Birmingham" + }, + { + "first_name": "Sidharth", + "last_name": "Kumar", + "institution": "University of Alabama at Birmingham" + }, + { + "first_name": "Kristopher", + "last_name": "Micinski", + "institution": "Syracuse University" + } + ], + "dblp_key": "conf/cc/GilrayKM21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446848", + "title": "NSan: a floating-point numerical sanitizer", + "abstract": "Sanitizers are a relatively recent trend in software engineering. They aim at automatically finding bugs in programs, and they are now commonly available to programmers as part of compiler toolchains. For example, the LLVM project includes out-of-the-box sanitizers to detect thread safety (tsan), memory (asan,msan,lsan), or undefined behaviour (ubsan) bugs.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446848", + "conference_name": "CC", + "authors": [ + { + "first_name": "Clément", + "last_name": "Courbet", + "institution": "" + } + ], + "dblp_key": "conf/cc/Courbet21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446842", + "title": "PolyBench/Python: benchmarking Python environments with polyhedral optimizations", + "abstract": "Python has become one of the most used and taught languages nowadays. Its expressiveness, cross-compatibility and ease of use have made it popular in areas as diverse as finance, bioinformatics or machine learning. However, Python programs are often significantly slower to execute than an equivalent native C implementation, especially for computation-intensive numerical kernels.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446842", + "conference_name": "CC", + "authors": [ + { + "first_name": "Miguel Á.", + "last_name": "Abella-González", + "institution": "Universidade da Coruña" + }, + { + "first_name": "Pedro", + "last_name": "Carollo-Fernández", + "institution": "Universidade da Coruña" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "Colorado State University" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Gabriel", + "last_name": "Rodríguez", + "institution": "Universidade da Coruña" + } + ], + "dblp_key": "conf/cc/Abella-Gonzalez21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446851", + "title": "Helper function inlining in dynamic binary translation", + "abstract": "Dynamic binary translation (DBT) is the cornerstone of many important applications. Yet, it takes a tremendous effort to develop and maintain a real-world DBT system. To mitigate the engineering effort, helper functions are frequently employed during the development of a DBT system. Though helper functions greatly facilitate the DBT development, their adoption incurs substantial performance overhead due to the helper function calls. To solve this problem, this paper presents a novel approach to inline helper functions in DBT systems. The proposed inlining approach addresses several unique technical challenges. As a result, the performance overhead introduced by helper function calls can be reduced, and meanwhile, the benefits of helper functions for DBT development are not lost. We have implemented a prototype based on the proposed inlining approach using a popular DBT system, QEMU. Experimental results on the benchmark programs from the SPEC CPU 2017 benchmark suite show that an average of 1.2x performance speedup can be achieved. Moreover, the translation overhead introduced by inlining helper functions is negligible.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446851", + "conference_name": "CC", + "authors": [ + { + "first_name": "Wenwen", + "last_name": "Wang", + "institution": "University of Georgia" + } + ], + "dblp_key": "conf/cc/Wang21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446846", + "title": "Resolvable ambiguity: principled resolution of syntactically ambiguous programs", + "abstract": "When building a new programming language, it can be useful to compose parts of existing languages to avoid repeating implementation work. However, this is problematic already at the syntax level, as composing the grammars of language fragments can easily lead to an ambiguous grammar. State-of-the-art parser tools cannot handle ambiguity truly well: either the grammar cannot be handled at all, or the tools give little help to an end-user who writes an ambiguous program. This composability problem is twofold: (i) how can we detect if the composed grammar is ambiguous, and (ii) if it is ambiguous, how can we help a user resolve an ambiguous program? In this paper, we depart from the traditional view of unambiguous grammar design and enable a language designer to work with an ambiguous grammar, while giving users the tools needed to handle these ambiguities. We introduce the concept of resolvable ambiguity wherein a user can resolve an ambiguous program by editing it, as well as an approach to computing the resolutions of an ambiguous program. Furthermore, we present a method based on property-based testing to identify if a composed grammar is unambiguous, resolvably ambiguous, or unresolvably ambiguous. The method is implemented in Haskell and evaluated on a large set of language fragments selected from different languages. The evaluation shows that (i) the approach can handle significantly more cases of language compositions compared to approaches which ban ambiguity altogether, and (ii) that the approach is fast enough to be used in practice.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446846", + "conference_name": "CC", + "authors": [ + { + "first_name": "Viktor", + "last_name": "Palmkvist", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Elias", + "last_name": "Castegren", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "Philipp", + "last_name": "Haller", + "institution": "KTH Royal Institute of Technology" + }, + { + "first_name": "David", + "last_name": "Broman", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/cc/PalmkvistCHB21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446854", + "title": "Communication-safe web programming in TypeScript with routed multiparty session types", + "abstract": "Modern web programming involves coordinating interactions between browser clients and a server. Typically, the interactions in web-based distributed systems are informally described, making it hard to ensure correctness, especially communication safety, i.e. all endpoints progress without type errors or deadlocks, conforming to a specified protocol.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446854", + "conference_name": "CC", + "authors": [ + { + "first_name": "Anson", + "last_name": "Miu", + "institution": "Imperial College London" + }, + { + "first_name": "Francisco", + "last_name": "Ferreira", + "institution": "Imperial College London" + }, + { + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + }, + { + "first_name": "Fangyi", + "last_name": "Zhou", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/cc/Miu0Y021", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446852", + "title": "Deep NLP-based co-evolvement for synthesizing code analysis from natural language", + "abstract": "This paper presents Deepsy, a Natural Language-based synthesizer to assist source code analysis. It takes English descriptions of to-be-found code patterns as its inputs, and automatically produces ASTMatcher expressions that are directly usable by LLVM/Clang to materialize intended code analysis. The code analysis domain features profuse complexities in data types and operations, which make it elusive for prior rule-based synthesizers to tackle. On the other hand, machine learning-based solutions are neither applicable due to the scarcity of well labeled examples. This paper presents how Deepsy addresses the challenges by leveraging deep Natural Language Processing (NLP) and creating a new technique named dependency tree-based co-evolvement.Deepsy features an effective design that seamlessly integrates Natural Language dependency analysis into code analysis and meanwhile synergizes it with type-based narrowing and domain-specific guidance. Deepsy achieves over 70.0% expression-level accuracy and 85.1% individual API-level accuracy, significantly outperforming previous solutions.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446852", + "conference_name": "CC", + "authors": [ + { + "first_name": "Zifan", + "last_name": "Nan", + "institution": "North Carolina State University" + }, + { + "first_name": "Hui", + "last_name": "Guan", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Xipeng", + "last_name": "Shen", + "institution": "North Carolina State University" + }, + { + "first_name": "Chunhua", + "last_name": "Liao", + "institution": "Lawrence Livermore National Laboratory" + } + ], + "dblp_key": "conf/cc/NanGSL21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446849", + "title": "Exploring the space of optimization sequences for code-size reduction: insights and tools", + "abstract": "The optimization space of a compiler is the set of every possible sequence of optimizations that said compiler can use. The exploration of the optimization space of any mainstream compiler has been, for decades, hampered by the lack of benchmarks. However, recent efforts from different research groups have made available a large quantity of compilable code that can be, today, used to overcome this problem. In this paper, we use 15,000 programs from a public collection to explore the optimization space of LLVM, focusing on code-size reduction. This exploration reveals that the probability of beating the default optimization levels of LLVM with random sequences ranges from 10% (considering opt -Oz) to 19% (considering clang -Os). Yet, the distribution of probabilities is uneven across programs: the default levels work well for most programs, and poorly for a few. Based on these observations, we introduce the notion of an Optimization Cache, a table of programs to optimization sequences that can be used to support predictive compilation. We then use an optimization cache to build what we call a Default Covering Set: a small ensemble of optimization sequences that, once combined, tend to be good for any program. Optimization caches and default covering sets are used independently. The former, when applied onto MiBench, yield programs that are 11.9% smaller than programs produced by opt -Os, on average. The latter produce programs 12.5% smaller.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446849", + "conference_name": "CC", + "authors": [ + { + "first_name": "Anderson Faustino da", + "last_name": "Silva", + "institution": "Universidade Estadual de Maringá" + }, + { + "first_name": "Bernardo N. B. de", + "last_name": "Lima", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/cc/SilvaLP21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446850", + "title": "A modern compiler for the French tax code", + "abstract": "In France, income tax is computed from taxpayers' individual returns, using an algorithm that is authored, designed and maintained by the French Public Finances Directorate (DGFiP). This algorithm relies on a legacy custom language and compiler originally designed in 1990, which unlike French wine, did not age well with time. Owing to the shortcomings of the input language and the technical limitations of the compiler, the algorithm is proving harder and harder to maintain, relying on ad-hoc behaviors and workarounds to implement the most recent changes in tax law. Competence loss and aging code also mean that the system does not benefit from any modern compiler techniques that would increase confidence in the implementation.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446850", + "conference_name": "CC", + "authors": [ + { + "first_name": "Denis", + "last_name": "Merigoux", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Raphaël", + "last_name": "Monat", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/cc/MerigouxMP21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446847", + "title": "Data-aware process networks", + "abstract": "With the emergence of reconfigurable FPGA circuits as a credible alternative to GPUs for HPC acceleration, new compilation paradigms are required to map high-level algorithmic descriptions to a circuit configuration (High-Level Synthesis, HLS). In particular, novel parallelization algorithms and intermediate representations are required. In this paper, we present the data-aware process networks (DPN), a dataflow intermediate representation suitable for HLS in the context of high-performance computing. DPN combines the benefits of a low-level dataflow representation -- close to the final circuit -- and affine iteration space tiling to explore the parallelization trade-offs (local memory size, communication volume, parallelization degree). We outline our compilation algorithms to map a C program to a DPN (front-end), then to map a DPN to an FPGA configuration (back-end). Finally, we present synthesis results on compute-intensive kernels from the Polybench suite.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446847", + "conference_name": "CC", + "authors": [ + { + "first_name": "Christophe", + "last_name": "Alias", + "institution": "Université Claude Bernard Lyon 1" + }, + { + "first_name": "Alexandru", + "last_name": "Plesco", + "institution": "" + } + ], + "dblp_key": "conf/cc/AliasP21", + "venue": "cc", + "year": 2021 + }, + { + "paper_id": "10.1145/3446804.3446853", + "title": "Compact native code generation for dynamic languages on micro-core architectures", + "abstract": "Micro-core architectures combine many simple, low memory, low power-consuming CPU cores onto a single chip. Potentially providing significant performance and low power consumption, this technology is not only of great interest in embedded, edge, and IoT uses, but also potentially as accelerators for data-center workloads. Due to the restricted nature of such CPUs, these architectures have traditionally been challenging to program, not least due to the very constrained amounts of memory (often around 32KB) and idiosyncrasies of the technology. However, more recently, dynamic languages such as Python have been ported to a number of micro-cores, but these are often delivered as interpreters which have an associated performance limitation.", + "date": "2021-02-14", + "link": "https://doi.org/10.1145/3446804.3446853", + "conference_name": "CC", + "authors": [ + { + "first_name": "Maurice", + "last_name": "Jamieson", + "institution": "University of Edinburgh" + }, + { + "first_name": "Nick", + "last_name": "Brown", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/Jamieson021", + "venue": "cc", + "year": 2021 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2022.json b/data/pl_conferences/cc/2022.json new file mode 100644 index 0000000..7c795c5 --- /dev/null +++ b/data/pl_conferences/cc/2022.json @@ -0,0 +1,650 @@ +[ + { + "paper_id": "10.1145/3497776.3526941", + "title": "Writing and verifying a Quantum optimizing compiler (keynote)", + "abstract": "As quantum computing hardware evolves, it will continue to face four key limitations: low qubit counts, limited connectivity, high error rates, and short coherence times. Quantum compilers play a key role in addressing these issues, reducing the number of qubits needed to perform a computation, mapping those qubits to the desired hardware, and minimizing the number of costly operations, both in terms of error rates and execution time. However, we cannot afford for compilers to become another source of bugs: Quantum computing is an inherently probabilistic and error-prone process and any additional sources of error are unlikely to be properly diagnosed. To address this, we present VOQC, a verified optimizing compiler for quantum circuits. VOQC heavily optimizes quantum programs while guaranteeing that the output is quantum-mechanically indistinguishable from the input program, up to permutation of qubits. This ensures that compilation produces an equivalent program that is executable on the given hardware. In this talk, we will address the key differences between classical and quantum compilation and the challenges unique to the latter. We will discuss the design decisions that underlie VOQC and how they enable its most powerful optimizations. Finally, we will discuss the developments since VOQC was first published, both within the VOQC toolchain and competing compilers, verified and unverified.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3526941", + "conference_name": "CC", + "authors": [ + { + "first_name": "Robert W.", + "last_name": "Rand", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/cc/000122", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517780", + "title": "Performant portable OpenMP", + "abstract": "Accelerated computing has increased the need to specialize how a program is parallelized depending on the target. Fully exploiting a highly parallel accelerator, such as a GPU, demands more parallelism and sometimes more levels of parallelism than a multicore CPU. OpenMP has a directive for each level of parallelism, but choosing directives for each target can incur a significant productivity cost. We argue that using the new OpenMP loop directive with an appropriate compiler decision process can achieve the same performance benefits of target-specific parallelization with the productivity advantage of a single directive for all targets. In this paper, we introduce a fully descriptive model and demonstrate its benefits with an implementation of the loop directive, comparing performance, productivity, and portability against other production compilers using the SPEC ACCEL benchmark suite. We provide an implementation of our proposal in NVIDIA's HPC compiler. It yields up to 56X speedup and an average of 1.91x-1.79x speedup compared to the baseline performance (depending on the host system) on GPUs, and preserves CPU performance. In addition, our proposal requires 60% fewer parallelism directives.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517780", + "conference_name": "CC", + "authors": [ + { + "first_name": "Güray", + "last_name": "Özen", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "Wolfe", + "institution": "Nvidia (United States)" + } + ], + "dblp_key": "conf/cc/OzenW22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517782", + "title": "On the computation of interprocedural weak control closure", + "abstract": "Many program analysis techniques depend on capturing the control dependencies of the program. Most existing control dependence algorithms either compute intraprocedural control dependencies only, or they compute control dependence relations that are not precise in general including nonterminating systems. Weak control closure (WCC) subsumes all known nontermination insensitive control dependence relations, including those that are appropriate for nonterminating systems. In this paper, we provide the first formal development of an algorithm to compute the WCC for interprocedural programs capturing the weak form of interprocedural control dependencies. The method is widely applicable due to the generality of WCC. Theorems on the theoretical results of soundness, precision, and the worst-case complexity of our method are also included. We have compared our algorithm with a WCC computation algorithm based on a state-of-the-art interprocedural control dependence computation algorithm. The latter algorithm loses soundness, and we improve the precision by 15.21% on all our experimental benchmarks. This empirical evidence suggests that our algorithm is more effective for any client application of WCC requiring interprocedural program analysis.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517782", + "conference_name": "CC", + "authors": [ + { + "first_name": "Abu Naser", + "last_name": "Masud", + "institution": "Mälardalen University" + }, + { + "first_name": "Björn", + "last_name": "Lisper", + "institution": "Mälardalen University" + } + ], + "dblp_key": "conf/cc/MasudL22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517779", + "title": "Seamless deductive inference via macros", + "abstract": "We present an approach to integrating state-of-art bottom-up logic programming within the Rust ecosystem, demonstrating it with Ascent, an extension of Datalog that performs well against comparable systems. Rust’s powerful macro system permits Ascent to be compiled uniformly with the Rust code it’s embedded in and to interoperate with arbitrary user-defined components written in Rust, addressing a challenge in real-world use of logic programming languages: the fact that logical programs are parts of bigger software systems and need to interoperate with other components written in imperative programming languages.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517779", + "conference_name": "CC", + "authors": [ + { + "first_name": "Arash", + "last_name": "Sahebolamri", + "institution": "Syracuse University" + }, + { + "first_name": "Thomas", + "last_name": "Gilray", + "institution": "University of Alabama at Birmingham" + }, + { + "first_name": "Kristopher", + "last_name": "Micinski", + "institution": "Syracuse University" + } + ], + "dblp_key": "conf/cc/SahebolamriGM22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517776", + "title": "BinPointer: towards precise, sound, and scalable binary-level pointer analysis", + "abstract": "Binary-level pointer analysis is critical to binary-level applications such as reverse engineering and binary debloating. In this paper, we propose BinPointer, a new binary-level interprocedural pointer analysis that relies on an offset-sensitive value-tracking analysis to achieve high precision. We also propose a soundness and precision evaluation methodology based on runtime memory accesses triggered by reference input data. Our experimental results demonstrate that BinPointer has higher precision over prior work, while maintaining acceptable scalability. The soundness of BinPointer is also validated through runtime data.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517776", + "conference_name": "CC", + "authors": [ + { + "first_name": "Sun Hyoung", + "last_name": "Kim", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Dongrui", + "last_name": "Zeng", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Cong", + "last_name": "Sun", + "institution": "Xidian University" + }, + { + "first_name": "Gang", + "last_name": "Tan", + "institution": "Pennsylvania State University" + } + ], + "dblp_key": "conf/cc/KimZ0T22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517772", + "title": "QSSA: an SSA-based IR for Quantum computing", + "abstract": "Quantum computing hardware has progressed rapidly. Simultaneously, there has been a proliferation of programming languages and program optimization tools for quantum computing. Existing quantum compilers use intermediate representations (IRs) where quantum programs are described as circuits. Such IRs fail to leverage existing work on compiler optimizations. In such IRs, it is non-trivial to statically check for physical constraints such as the no-cloning theorem, which states that qubits cannot be copied. We introduce QSSA, a novel quantum IR based on static single assignment (SSA) that enables decades of research in compiler optimizations to be applied to quantum compilation. QSSA models quantum operations as being side-effect-free. The inputs and outputs of the operation are in one-to-one correspondence; qubits cannot be created or destroyed. As a result, our IR supports a static analysis pass that verifies no-cloning at compile-time. The quantum circuit is fully encoded within the def-use chain of the IR, allowing us to leverage existing optimization passes on SSA representations such as redundancy elimination and dead-code elimination. Running our QSSA-based compiler on the QASMBench and IBM Quantum Challenge datasets, we show that our optimizations perform comparably to IBM’s Qiskit quantum compiler infrastructure. QSSA allows us to represent, analyze, and transform quantum programs using the robust theory of SSA representations, bringing quantum compilation into the realm of well-understood theory and practice.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517772", + "conference_name": "CC", + "authors": [ + { + "first_name": "Anurudh", + "last_name": "Peduri", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Siddharth", + "last_name": "Bhat", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/PeduriBG22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517766", + "title": "Training of deep learning pipelines on memory-constrained GPUs via segmented fused-tiled execution", + "abstract": "Training models with massive inputs is a significant challenge in the development of Deep Learning pipelines to process very large digital image datasets as required by Whole Slide Imaging (WSI) in computational pathology and analysis of brain fMRI images in computational neuroscience. Graphics Processing Units (GPUs) represent the primary workhorse in training and inference of Deep Learning models. In order to use GPUs to run inference or training on a neural network pipeline, state-of-the-art machine learning frameworks like PyTorch and TensorFlow currently require that the collective memory on the GPUs must be larger than the size of the activations at any stage in the pipeline. Therefore, existing Deep Learning pipelines for these use cases have been forced to develop sub-optimal \"patch-based\" modeling approaches, where images are processed in small segments of an image. In this paper, we present a solution to this problem by employing tiling in conjunction with check-pointing, thereby enabling arbitrarily large images to be directly processed, irrespective of the size of global memory on a GPU and the number of available GPUs. Experimental results using PyTorch demonstrate enhanced functionality/performance over existing frameworks.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517766", + "conference_name": "CC", + "authors": [ + { + "first_name": "Yufan", + "last_name": "Xu", + "institution": "University of Utah" + }, + { + "first_name": "Saurabh", + "last_name": "Raje", + "institution": "University of Utah" + }, + { + "first_name": "Atanas", + "last_name": "Rountev", + "institution": "The Ohio State University" + }, + { + "first_name": "Gerald", + "last_name": "Sabin", + "institution": "RNET Technologies (United States)" + }, + { + "first_name": "Aravind", + "last_name": "Sukumaran-Rajam", + "institution": "Washington State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/cc/XuRRSSS22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517771", + "title": "Graph transformations for register-pressure-aware instruction scheduling", + "abstract": "This paper presents graph transformation algorithms for register-pressure-aware instruction scheduling. The proposed transformations add edges to the data dependence graph (DDG) to eliminate solutions that are either redundant or sub-optimal. Register-pressure-aware instruction scheduling aims at balancing two conflicting objectives: maximizing instruction-level parallelism (ILP) and minimizing register pressure (RP). Graph transformations have been previously proposed for the problem of maximizing ILP without considering RP, which is a problem of limited practical value. In the current paper, we extend that work by proposing graph transformations for the RP minimization objective, which is an important objective in practice. Various cost functions are considered for representing RP, and we show that the proposed transformations preserve optimality with respect to each of them. The proposed transformations are used to reduce the size of the solution space before applying a Branch-and-Bound (B&B) algorithm that exhaustively searches for an optimal solution. The proposed transformations and the B&B algorithm were implemented in the LLVM compiler, and their performance was evaluated experimentally on a CPU target and a GPU target. The SPEC CPU2017 floating-point benchmarks were used on the CPU and the PlaidML benchmarks were used on the GPU. The results show that the proposed transformations significantly reduce the compile time while giving approximately the same execution-time performance.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517771", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ghassan", + "last_name": "Shobaki", + "institution": "California State University, Sacramento" + }, + { + "first_name": "Justin", + "last_name": "Bassett", + "institution": "California State University, Sacramento" + }, + { + "first_name": "Mark", + "last_name": "Heffernan", + "institution": "Google (United States)" + }, + { + "first_name": "Austin", + "last_name": "Kerbow", + "institution": "California State University, Sacramento" + } + ], + "dblp_key": "conf/cc/ShobakiBHK22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517769", + "title": "Automating reinforcement learning architecture design for code optimization", + "abstract": "Reinforcement learning (RL) is emerging as a powerful technique for solving complex code optimization tasks with an ample search space. While promising, existing solutions require a painstaking manual process to tune the right task-specific RL architecture, for which compiler developers need to determine the composition of the RL exploration algorithm, its supporting components like state, reward, and transition functions, and the hyperparameters of these models. This paper introduces SuperSonic, a new open-source framework to allow compiler developers to integrate RL into compilers easily, regardless of their RL expertise. SuperSonic supports customizable RL architecture compositions to target a wide range of optimization tasks. A key feature of SuperSonic is the use of deep RL and multi-task learning techniques to develop a meta-optimizer to automatically find and tune the right RL architecture from training benchmarks. The tuned RL can then be deployed to optimize new programs. We demonstrate the efficacy and generality of SuperSonic by applying it to four code optimization problems and comparing it against eight auto-tuning frameworks. Experimental results show that SuperSonic consistently improves hand-tuned methods by delivering better overall performance, accelerating the deployment-stage search by 1.75x on average (up to 100x).", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517769", + "conference_name": "CC", + "authors": [ + { + "first_name": "Huanting", + "last_name": "Wang", + "institution": "University of Leeds" + }, + { + "first_name": "Zhanyong", + "last_name": "Tang", + "institution": "Northwest University" + }, + { + "first_name": "Cheng", + "last_name": "Zhang", + "institution": "Northwest University" + }, + { + "first_name": "Jiaqi", + "last_name": "Zhao", + "institution": "Northwest University" + }, + { + "first_name": "Chris", + "last_name": "Cummins", + "institution": "" + }, + { + "first_name": "Hugh", + "last_name": "Leather", + "institution": "" + }, + { + "first_name": "Zheng", + "last_name": "Wang", + "institution": "University of Leeds" + } + ], + "dblp_key": "conf/cc/WangTZZCL022", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517778", + "title": "Cape: compiler-aided program transformation for HTM-based cache side-channel defense", + "abstract": "Cache side-channel attacks pose real threats to computer system security. Prior work called Cloak leverages commodity hardware transactional memory (HTM) to protect sensitive data and code from cache side-channel attacks. However, Cloak requires tedious and error-prone manual modifications to vulnerable software by programmers. This paper presents Cape, a compiler analysis and transformation that soundly and automatically protects programs from cache side-channel attacks using Cloak’s defense. An evaluation shows that Cape provides protection that is as strong as Cloak’s, while performing competitively with Cloak.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517778", + "conference_name": "CC", + "authors": [ + { + "first_name": "Rui", + "last_name": "Zhang", + "institution": "The Ohio State University" + }, + { + "first_name": "Michael D.", + "last_name": "Bond", + "institution": "The Ohio State University" + }, + { + "first_name": "Yinqian", + "last_name": "Zhang", + "institution": "Southern University of Science and Technology" + } + ], + "dblp_key": "conf/cc/ZhangBZ22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517770", + "title": "MLIR-based code generation for GPU tensor cores", + "abstract": "The state-of-the-art in high-performance deep learning today is primarily driven by manually developed libraries optimized and highly tuned by expert programmers using low-level abstractions with significant effort. This effort is often repeated for similar hardware and future ones. In this work, we pursue and evaluate the more modular and reusable approach of using compiler IR infrastructure to generate libraries by encoding all the required optimizations as a sequence of transformations and customized passes on an IR. We believe that until the recent introduction of MLIR (Multi-level intermediate representation), it had been hard to represent and transform computation at various levels of abstraction within a single IR.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517770", + "conference_name": "CC", + "authors": [ + { + "first_name": "Navdeep", + "last_name": "Katel", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Vivek", + "last_name": "Khandelwal", + "institution": "Indian Institute of Science Bangalore" + }, + { + "first_name": "Uday", + "last_name": "Bondhugula", + "institution": "Indian Institute of Science Bangalore" + } + ], + "dblp_key": "conf/cc/KatelKB22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517774", + "title": "One-shot tuner for deep learning compilers", + "abstract": "Auto-tuning DL compilers are gaining ground as an optimizing back-end for DL frameworks. While existing work can generate deep learning models that exceed the performance of hand-tuned libraries, they still suffer from prohibitively long auto-tuning time due to repeated hardware measurements in large search spaces. In this paper, we take a neural-predictor inspired approach to reduce the auto-tuning overhead and show that a performance predictor model trained prior to compilation can produce optimized tensor operation codes without repeated search and hardware measurements. To generate a sample-efficient training dataset, we extend input representation to include task-specific information and to guide data sampling methods to focus on learning high-performing codes. We evaluated the resulting predictor model, One-Shot Tuner, against AutoTVM and other prior work, and the results show that One-Shot Tuner speeds up compilation by 2.81x to 67.7x compared to prior work while providing comparable or improved inference time for CNN and Transformer models.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517774", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jaehun", + "last_name": "Ryu", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Eunhyeok", + "last_name": "Park", + "institution": "Pohang University of Science and Technology" + }, + { + "first_name": "Hyojin", + "last_name": "Sung", + "institution": "Pohang University of Science and Technology" + } + ], + "dblp_key": "conf/cc/RyuPS22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517781", + "title": "Caviar: an e-graph based TRS for automatic code optimization", + "abstract": "Term Rewriting Systems (TRSs) are used in compilers to simplify and prove expressions. State-of-the-art TRSs in compilers use a greedy algorithm that applies a set of rewriting rules in a predefined order (where some of the rules are not axiomatic). This leads to a loss of the ability to simplify certain expressions. E-graphs and equality saturation sidestep this issue by representing the different equivalent expressions in a compact manner from which the optimal expression can be extracted. While an e-graph-based TRS can be more powerful than a TRS that uses a greedy algorithm, it is slower because expressions may have a large or sometimes infinite number of equivalent expressions. Accelerating e-graph construction is crucial for making the use of e-graphs practical in compilers. In this paper, we present Caviar, an e-graph-based TRS for proving expressions within compilers. The main advantage of Caviar is its speed. It can prove expressions much faster than base e-graph TRSs. It relies on three techniques: 1) a technique that stops e-graphs from growing when the goal is reached, called Iteration Level Check; 2) a mechanism that balances exploration and exploitation in the equality saturation algorithm, called Pulsing Caviar; 3) a technique to stop e-graph construction before reaching saturation when a non-provable pattern is detected, called Non-Provable Patterns Detection (NPPD). We evaluate caviar on Halide, an optimizing compiler that relies on a greedy-algorithm-based TRS to simplify and prove its expressions. The proposed techniques allow Caviar to accelerate e-graph expansion for the task of proving expressions. They also allow Caviar to prove expressions that Halide’s TRS cannot prove while being only 0.68x slower. Caviar is publicly available at: https://github.com/caviar-trs/caviar.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517781", + "conference_name": "CC", + "authors": [ + { + "first_name": "Smail", + "last_name": "Kourta", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Adel", + "last_name": "Namani", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Fatima Benbouzid-Si", + "last_name": "Tayeb", + "institution": "École Nationale Supérieure d'Informatique" + }, + { + "first_name": "Kim", + "last_name": "Hazelwood", + "institution": "Meta (Israel)" + }, + { + "first_name": "Chris", + "last_name": "Cummins", + "institution": "Meta (Israel)" + }, + { + "first_name": "Hugh", + "last_name": "Leather", + "institution": "Meta (Israel)" + }, + { + "first_name": "Riyadh", + "last_name": "Baghdadi", + "institution": "Supélec" + } + ], + "dblp_key": "conf/cc/KourtaNTHCLB22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517768", + "title": "Memory access scheduling to reduce thread migrations", + "abstract": "It has been widely observed that data movement is emerging as the primary bottleneck to scalability and energy efficiency in future hardware, especially for applications and algorithms that are not cache-friendly and achieve below 1% of peak performance on today’s systems. The idea of “moving compute to data” has been suggested as one approach to address this challenge. While there are approaches that can achieve this migration in software, hardware support is a promising direction from the perspectives of lower overheads and programmer productivity. Migratory thread architectures migrate lightweight hardware thread contexts to the location of the data instead of transferring data to the requesting processor. However, while transporting thread contexts is cheaper than moving data, thread migrations still incur energy and bandwidth overheads and can be particularly expensive if threads frequently migrate in a ping-pong manner between processors due to poor locality of access. In this paper, we propose Memory Access Scheduling, a new compiler optimization that aims to reduce the number of overall thread migrations when executing a program on migratory thread architectures. Our experiments show performance improvements with a geometric mean speedup of 1.23× for a set of 7 explicitly-parallelized kernels, and of 1.10× for a set of 15 automatically-parallelized kernels. We believe that memory access scheduling will also be an important optimization for other locality-centric architectures that benefit from software thread migrations, such as multi-threaded NUMA architectures.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517768", + "conference_name": "CC", + "authors": [ + { + "first_name": "Sana", + "last_name": "Damani", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Prithayan", + "last_name": "Barua", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/cc/DamaniBS22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517775", + "title": "QRANE: lifting QASM programs to an affine IR", + "abstract": "This paper introduces QRANE, a tool that produces the affine intermediate representation (IR) from a quantum program expressed in Quantum Assembly language such as OpenQASM. QRANE finds subsets of quantum gates prescribed by the same operation type and linear relationships, and constructs a structured program representation expressed with polyhedral iteration domains and access relations, all while preserving the original semantics of the quantum program. We explore various policies for deciding amongst different delinearization strategies and discuss their effect on the quality of the reconstruction. Our evaluation demonstrates the high coverage and efficiency obtained with QRANE while enabling research on the benefits of affine transformations for large quantum circuits. Specifically, QRANE reconstructs affine iteration domains of up to 6 dimensions and up to 184 points per domain.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517775", + "conference_name": "CC", + "authors": [ + { + "first_name": "Blake", + "last_name": "Gerard", + "institution": "University of Oklahoma" + }, + { + "first_name": "Tobias", + "last_name": "Grosser", + "institution": "University of Edinburgh" + }, + { + "first_name": "Martin", + "last_name": "Kong", + "institution": "University of Oklahoma" + } + ], + "dblp_key": "conf/cc/GerardGK22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517773", + "title": "A polynomial time exact solution to the bit-aware register binding problem", + "abstract": "Finding the minimum register bank is an optimization problem related to the synthesis of hardware. Given a program, the problem asks for the minimum number of registers plus their minimum size, in bits, that suffices to compile said program. This problem is NP-complete; hence, usually solved via heuristics. In this paper, we show that this problem has an optimal solution in polynomial time, as long as swaps can be inserted in the program to move variables across registers. This observation sets a lower bound to heuristics that minimize the size of register banks. We have compared the optimal algorithm with two classic heuristics. Our approach uses, on average, 6 to 10% less bits than that previous work.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517773", + "conference_name": "CC", + "authors": [ + { + "first_name": "Michael", + "last_name": "Canesche", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Ricardo", + "last_name": "Ferreira", + "institution": "Universidade Federal de Viçosa" + }, + { + "first_name": "José Augusto M.", + "last_name": "Nacif", + "institution": "Universidade Federal de Viçosa" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/cc/CanescheFNP22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517764", + "title": "Efficient profile-guided size optimization for native mobile applications", + "abstract": "Positive user experience of mobile apps demands they not only launch fast and run fluidly, but are also small in order to reduce network bandwidth from regular updates. Conventional optimizations often trade off size regressions for performance wins, making them impractical in the mobile space. Indeed, profile-guided optimization (PGO) is successful in server workloads, but is not effective at reducing size and page faults for mobile apps. Also, profiles must be collected from instrumenting builds that are up to 2X larger, so they cannot run normally on real mobile devices.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517764", + "conference_name": "CC", + "authors": [ + { + "first_name": "Kyungwoo", + "last_name": "Lee", + "institution": "" + }, + { + "first_name": "Ellis", + "last_name": "Hoag", + "institution": "" + }, + { + "first_name": "Nikolai", + "last_name": "Tillmann", + "institution": "" + } + ], + "dblp_key": "conf/cc/LeeHT22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517783", + "title": "Software pre-execution for irregular memory accesses in the HBM era", + "abstract": "The introduction of High Bandwidth Memory (HBM) necessitates the use of intelligent software prefetching in irregular applications to utilize the surplus bandwidth. In this work, we propose Software Pre-execution (SPE), a technique that relies on pre-executing a minimal copy of the loop of concern (we call the pre-execution loop) for the purpose of prefetching irregular accesses. This is complemented by the compiler's enforcing a certain prefetch distance through apriori strip-mining of the original loop such that the execution of the pre-execution loop is interspersed with the main loop to ensure timeliness of prefetches. We find that this approach provides natural advantages over prior art such as preservation of loop vectorization, handling short loops, avoiding performance bottlenecks, amenability to threading and most importantly, effective coverage. We demonstrate these advantages using a variety of benchmarks on Fujitsu's A64FX processor with HBM2 memory - we outperform prior art by 1.3x and 1.2x when using small and huge pages, respectively. Simulations further show that our approach holds stronger promise on upcoming processors with HBM2e.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517783", + "conference_name": "CC", + "authors": [ + { + "first_name": "Sanyam", + "last_name": "Mehta", + "institution": "Hewlett Packard Enterprise (United States)" + }, + { + "first_name": "Gary", + "last_name": "Elsesser", + "institution": "Hewlett Packard Enterprise (United States)" + }, + { + "first_name": "Terry", + "last_name": "Greyzck", + "institution": "Hewlett Packard Enterprise (United States)" + } + ], + "dblp_key": "conf/cc/MehtaEG22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517765", + "title": "Making no-fuss compiler fuzzing effective", + "abstract": "Developing a bug-free compiler is difficult; modern optimizing compilers are among the most complex software systems humans build. Fuzzing is one way to identify subtle compiler bugs that are hard to find with human-constructed tests. Grammar-based fuzzing, however, requires a grammar for a compiler’s input language, and can miss bugs induced by code that does not actually satisfy the grammar the compiler should accept. Grammar-based fuzzing also seldom uses advanced modern fuzzing techniques based on coverage feedback. However, modern mutation-based fuzzers are often ineffective for testing compilers because most inputs they generate do not even come close to getting past the parsing stage of compilation. This paper introduces a technique for taking a modern mutation-based fuzzer (AFL in our case, but the method is general) and augmenting it with operators taken from mutation testing, and program splicing. We conduct a controlled study to show that our hybrid approaches significantly improve fuzzing effectiveness qualitatively (consistently finding unique bugs that baseline approaches do not) and quantitatively (typically finding more unique bugs in the same time span, despite fewer program executions). Our easy-to-apply approach has allowed us to report more than 100 confirmed and fixed bugs in production compilers, and found a bug in the Solidity compiler that earned a security bounty.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517765", + "conference_name": "CC", + "authors": [ + { + "first_name": "Alex", + "last_name": "Groce", + "institution": "Northern Arizona University" + }, + { + "first_name": "Rijnard van", + "last_name": "Tonder", + "institution": "" + }, + { + "first_name": "Goutamkumar Tulajappa", + "last_name": "Kalburgi", + "institution": "Northern Arizona University" + }, + { + "first_name": "Claire Le", + "last_name": "Goues", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/cc/GroceTKG22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517767", + "title": "Loner: utilizing the CPU vector datapath to process scalar integer data", + "abstract": "Modern CPUs utilize SIMD vector instructions and hardware extensions to accelerate code with data-level parallelism. This allows for high performance gains in select application domains such as image and signal processing. However, general purpose code often lacks data-level parallelism or has complex control and data dependencies, which prevents vectorization. Thus, CPU vector registers and functional units frequently sit idle while the scalar datapath unilaterally executes code.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517767", + "conference_name": "CC", + "authors": [ + { + "first_name": "Armand", + "last_name": "Behroozi", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Sunghyun", + "last_name": "Park", + "institution": "University of Michigan–Ann Arbor" + }, + { + "first_name": "Scott", + "last_name": "Mahlke", + "institution": "University of Michigan–Ann Arbor" + } + ], + "dblp_key": "conf/cc/BehrooziPM22", + "venue": "cc", + "year": 2022 + }, + { + "paper_id": "10.1145/3497776.3517777", + "title": "Mapping parallelism in a functional IR through constraint satisfaction: a case study on convolution for mobile GPUs", + "abstract": "Graphics Processing Units (GPUs) are notoriously hard to optimize for manually. What is needed are good automatic code generators and optimizers. Accelerate, Futhark and Lift demonstrated that a functional approach is well suited for this challenge. Lift, for instance, uses a system of rewrite rules with a multi-stage approach. Algorithmic optimizations are first explored, followed by hardware-specific optimizations such as using shared memory and mapping parallelism.", + "date": "2022-03-18", + "link": "https://doi.org/10.1145/3497776.3517777", + "conference_name": "CC", + "authors": [ + { + "first_name": "Naums", + "last_name": "Mogers", + "institution": "University of Edinburgh" + }, + { + "first_name": "Lu", + "last_name": "Li", + "institution": "University of Edinburgh" + }, + { + "first_name": "Valentin", + "last_name": "Radu", + "institution": "University of Sheffield" + }, + { + "first_name": "Christophe", + "last_name": "Dubach", + "institution": "McGill University" + } + ], + "dblp_key": "conf/cc/MogersLRD22", + "venue": "cc", + "year": 2022 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2023.json b/data/pl_conferences/cc/2023.json new file mode 100644 index 0000000..9ffe99d --- /dev/null +++ b/data/pl_conferences/cc/2023.json @@ -0,0 +1,705 @@ +[ + { + "paper_id": "10.1145/3578360.3580258", + "title": "Compiling Discrete Probabilistic Programs for Vectorized Exact Inference", + "abstract": "Probabilistic programming languages (PPLs) are essential for reasoning under uncertainty. Even though many real-world probabilistic programs involve discrete distributions, the state-of-the-art PPLs are suboptimal for a large class of tasks dealing with such distributions. In this paper, we propose BayesTensor, a tensor-based probabilistic programming framework. By generating tensor algebra code from probabilistic programs, BayesTensor takes advantage of the highly-tuned vectorized implementations of tensor processing frameworks. Our experiments show that BayesTensor outperforms the state-of-the-art frameworks in a variety of discrete probabilistic programs, inference over Bayesian Networks, and real-world probabilistic programs employed in data processing systems.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580258", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jingwen", + "last_name": "Pan", + "institution": "University of Edinburgh" + }, + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/PanS23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580256", + "title": "Linker Code Size Optimization for Native Mobile Applications", + "abstract": "Modern mobile applications have grown rapidly in binary size, which restricts user growth and hinders updates for existing users. Thus, reducing the binary size is important for application developers. Recent studies have shown the possibility of using link-time code size optimizations by re-invoking certain compiler optimizations on the linked intermediate representation of the program. However, such methods often incur significant build time overhead and require intrusive changes to the existing build pipeline.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580256", + "conference_name": "CC", + "authors": [ + { + "first_name": "Gai", + "last_name": "Liu", + "institution": "" + }, + { + "first_name": "Umar", + "last_name": "Farooq", + "institution": "" + }, + { + "first_name": "Chengyan", + "last_name": "Zhao", + "institution": "" + }, + { + "first_name": "Xia", + "last_name": "Liu", + "institution": "" + }, + { + "first_name": "Nian", + "last_name": "Sun", + "institution": "" + } + ], + "dblp_key": "conf/cc/LiuFZLS23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580260", + "title": "Automatically Localizing Dynamic Code Generation Bugs in JIT Compiler Back-End", + "abstract": "Just-in-Time (JIT) compilers are ubiquitous in modern computing systems and are used in a wide variety of software. Dynamic code generation bugs, where the JIT compiler silently emits incorrect code, can result in exploitable vulnerabilities. They, therefore, pose serious security concerns and make quick mitigation essential. However, due to the size and complexity of JIT compilers, quickly locating and fixing bugs is often challenging. In addition, the unique characteristics of JIT compilers make existing bug localization approaches inapplicable. Therefore, this paper proposes a new approach to automatic bug localization, explicitly targeting the JIT compiler back-end. The approach is based on explicitly modeling architecture-independent back-end representation and architecture-specific code-generation. Experiments using a prototype implementation on a widely used JIT compiler (Turbofan) indicate that it can successfully localize dynamic code generation bugs in the back-end with high accuracy.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580260", + "conference_name": "CC", + "authors": [ + { + "first_name": "HeuiChan", + "last_name": "Lim", + "institution": "University of Arizona" + }, + { + "first_name": "Saumya", + "last_name": "Debray", + "institution": "University of Arizona" + } + ], + "dblp_key": "conf/cc/LimD23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580264", + "title": "Building a Compiled Query Engine in Python", + "abstract": "The simplicity of Python and its rich set of libraries has made it the most popular language for data science. Moreover, the interpreted nature of Python offers an easy debugging experience for the developers. However, it comes with the price of poor performance compared to the compiled code. In this paper, we adopt and extend state-of-the-art research in query compilers to propose an efficient query engine embedded in Python. Our open-sourced framework enables the developers to do the debugging in Python, while being able to easily build a compiled version of the code for deployment. Our benchmark results on the entire set of TPC-H queries show that our approach covers different types of relational workloads and is competitive with state-of-the-art in-memory engines in both single- and multi-threaded settings.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580264", + "conference_name": "CC", + "authors": [ + { + "first_name": "Hesam", + "last_name": "Shahrokhi", + "institution": "University of Edinburgh" + }, + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/ShahrokhiS23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580261", + "title": "Register Allocation for Compressed ISAs in LLVM", + "abstract": "We present an adaptation to the LLVM greedy register allocator to improve code density for compressed RISC ISAs.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580261", + "conference_name": "CC", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Fried", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Maximilian", + "last_name": "Stemmer-Grabow", + "institution": "Karlsruhe Institute of Technology" + }, + { + "first_name": "Julian", + "last_name": "Wachter", + "institution": "Karlsruhe Institute of Technology" + } + ], + "dblp_key": "conf/cc/FriedSW23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580266", + "title": "Torchy: A Tracing JIT Compiler for PyTorch", + "abstract": "Machine learning (ML) models keep getting larger and more complex. Whereas before models used to be represented by static data-flow graphs, they are now implemented via arbitrary Python code. Eager-mode frameworks, such as PyTorch, are now the standard for developing new ML models. The semantics of eager-mode frameworks is that operations are computed straight away. This greatly simplifies the development process, and it enables more dynamic ML models.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580266", + "conference_name": "CC", + "authors": [ + { + "first_name": "Nuno P.", + "last_name": "Lopes", + "institution": "Instituto de Engenharia de Sistemas e Computadores Investigação e Desenvolvimento" + } + ], + "dblp_key": "conf/cc/Lopes23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580267", + "title": "HyBF: A Hybrid Branch Fusion Strategy for Code Size Reduction", + "abstract": "Binary code size is a first-class design consideration in many computing domains and a critical factor in many more, but compiler optimizations targeting code size are few and often limited in functionality. When size reduction opportunities are left unexploited, it results in higher downstream costs such as memory, storage, bandwidth, or programmer time.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580267", + "conference_name": "CC", + "authors": [ + { + "first_name": "Rodrigo C. O.", + "last_name": "Rocha", + "institution": "University of Edinburgh" + }, + { + "first_name": "Charitha", + "last_name": "Saumya", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Kirshanthan", + "last_name": "Sundararajah", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Pavlos", + "last_name": "Petoumenos", + "institution": "University of Manchester" + }, + { + "first_name": "Milind", + "last_name": "Kulkarni", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/RochaSSP0O23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580254", + "title": "A Multi-threaded Fast Hardware Compiler for HDLs", + "abstract": "A set of new Hardware Description Languages (HDLs) are emerging to ease hardware design. HDL compilation time is a major bottleneck in the designer’s productivity. Moreover, as the HDLs are developed independently, the possibility to share innovations in compilation technology is limited.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580254", + "conference_name": "CC", + "authors": [ + { + "first_name": "Shenghong", + "last_name": "Wang", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Hunter James", + "last_name": "Coffman", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Kenneth H.", + "last_name": "Mayer", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Sakshi", + "last_name": "Garg", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Jose", + "last_name": "Renau", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/cc/WangCMGR23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580257", + "title": "A Deep Learning Model for Loop Interchange", + "abstract": "Loop interchange is an important code optimization that improves data locality and extracts parallelism. While previous research in compilers has tried to automate the selection of which loops to interchange, existing methods have an important limitation. They use less precise machine models. This is mainly because developing a model to predict whether to interchange two loops is challenging since such a prediction depends on many factors. While state-of-the-art methods try to avoid this problem by using a deep-learning based cost model, they suffer from another limitation. They scale proportionally with the number of loop levels of a given loop nest. This is mainly because they use the model to evaluate all the possible loop interchanges (or a subset of the most promising ones). In this paper, we propose a novel deep-learning model for loop interchange that addresses the previous limitations. It takes a code representation as input and predicts the best pair of loops to interchange. Compared to state-of-the-art deep-learning based cost models, it requires constant time to predict the best loop interchange. This is in contrast to state-of-the-art deep learning models that are used to evaluate all the loop pairs and then pick the best one. The proposed model is the first deep learning model that requires a constant time to predict the best loops to interchange. The model is implemented and evaluated in the Tiramisu compiler, a state-of-the-art polyhedral compiler. We evaluate the proposed model on a benchmark of Tiramisu programs and show an accuracy of 78.57% for 1-shot and 85.71% for 2-shots. Experiments show that our model outperforms the cost model currently used by the Tiramisu compiler by 8.57% in terms of 1-shot accuracy, and 5.71% with 2-shots accuracy, while at the same time reducing the total execution time needed for predicting the best pair of loops to interchange.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580257", + "conference_name": "CC", + "authors": [ + { + "first_name": "Lina", + "last_name": "Mezdour", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Khadidja", + "last_name": "Kadem", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Massinissa", + "last_name": "Merouani", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Amina Selma", + "last_name": "Haichour", + "institution": "École Nationale Supérieure d'Informatique" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Riyadh", + "last_name": "Baghdadi", + "institution": "New York University Abu Dhabi" + } + ], + "dblp_key": "conf/cc/MezdourKMHAB23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580273", + "title": "RL4ReAl: Reinforcement Learning for Register Allocation", + "abstract": "We aim to automate decades of research and experience in register allocation, leveraging machine learning. We tackle this problem by embedding a multi-agent reinforcement learning algorithm within LLVM, training it with the state of the art techniques. We formalize the constraints that precisely define the problem for a given instruction-set architecture, while ensuring that the generated code preserves semantic correctness. We also develop a gRPC based framework providing a modular and efficient compiler interface for training and inference. Our approach is architecture independent: we show experimental results targeting Intel x86 and ARM AArch64. Our results match or out-perform the heavily tuned, production-grade register allocators of LLVM.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580273", + "conference_name": "CC", + "authors": [ + { + "first_name": "S.", + "last_name": "VenkataKeerthy", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Siddharth", + "last_name": "Jain", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Anilava", + "last_name": "Kundu", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Rohit", + "last_name": "Aggarwal", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "" + }, + { + "first_name": "Ramakrishna", + "last_name": "Upadrasta", + "institution": "Indian Institute of Technology Hyderabad" + } + ], + "dblp_key": "conf/cc/VenkataKeerthyJ23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580269", + "title": "(De/Re)-Compositions Expressed Systematically via MDH-Based Schedules", + "abstract": "We introduce a new scheduling language, based on the formalism of Multi-Dimensional Homomorphisms (MDH). In contrast to existing scheduling languages, our MDH-based language is designed to systematically \"de-compose\" computations for the memory and core hierarchies of architectures, and \"re-compose\" the computed intermediate results back to the final result -- we say \"(de/re)-composition\" for short. We argue that our scheduling langauge is easy to use and yet expressive enough to express well-performing (de/re)-compositions of popular related approaches, e.g., the TVM compiler, for MDH-supported computations (such as linear algebra routines and stencil computations). Moreover, our language is designed as auto-tunable, i.e., any optimization decision can optionally be left to the auto-tuning engine of our system, and our system can automatically recommend schedules for the user, based on its auto-tuning capabilities. Also, by relying on the MDH approach, we can formally guarantee the correctness of optimizations expressed in our language, thereby further enhancing user experience. Our experiments on GPU and CPU confirm that we can express optimizations that cannot be expressed straightforwardly (or at all) in TVM's scheduling language, thereby achieving higher performance than TVM, and also vendor libraries provided by NVIDIA and Intel, for time-intensive computations used in real-world deep learning neural networks.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580269", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ari", + "last_name": "Rasch", + "institution": "University of Münster" + }, + { + "first_name": "Richard", + "last_name": "Schulze", + "institution": "University of Münster" + }, + { + "first_name": "Denys", + "last_name": "Shabalin", + "institution": "Google (Switzerland)" + }, + { + "first_name": "Anne C.", + "last_name": "Elster", + "institution": "NTNU Samfunnsforskning" + }, + { + "first_name": "Sergei", + "last_name": "Gorlatch", + "institution": "University of Münster" + }, + { + "first_name": "Mary", + "last_name": "Hall", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/cc/RaschSSEGH23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580272", + "title": "Efficiently Learning Locality Optimizations by Decomposing Transformation Domains", + "abstract": "Optimizing compilers for efficient machine learning are more important than ever due to the rising ubiquity of the application domain in numerous facets of life. Predictive model-guided compiler optimization is sometimes used to derive sequences of loop transformations that optimize the performance of the machine learning computations. However, training-data generation for these models often requires the traversal of prohibitively expensive schedule spaces and executing code variants corresponding to different schedule options. The size of these search spaces can quickly explode when predicting the combined effects of multiple loop transformations. This paper characterizes a learning strategy for deriving transformation sequences called Composed Singular Prediction (CSP). Instead of a monolithic cost model that predicts the profitability of a given transformation sequence, CSP exploits a collection of cost models, each trained on a particular loop transformation domain. In a case study, a domain-specific compiler deploys the learned models to predict loop tiling and loop permutation schedules to perform data locality optimization of Conv2d kernels. The system achieves performance improvements up to 4.0x against Intel oneDNN while saving ~ 105.3x in training data collection time compared to exhaustive exploration of the design space.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580272", + "conference_name": "CC", + "authors": [ + { + "first_name": "Tharindu R.", + "last_name": "Patabandi", + "institution": "University of Utah" + }, + { + "first_name": "Mary", + "last_name": "Hall", + "institution": "University of Utah" + } + ], + "dblp_key": "conf/cc/PatabandiH23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580262", + "title": "Matching Linear Algebra and Tensor Code to Specialized Hardware Accelerators", + "abstract": "Dedicated tensor accelerators demonstrate the importance of linear algebra in modern applications. Such accelerators have the potential for impressive performance gains, but require programmers to rewrite code using vendor APIs - a barrier to wider scale adoption. Recent work overcomes this by matching and replacing patterns within code, but such approaches are fragile and fail to cope with the diversity of real-world codes.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580262", + "conference_name": "CC", + "authors": [ + { + "first_name": "Pablo A. Lanzarote", + "last_name": "Martínez", + "institution": "Universidad de Murcia" + }, + { + "first_name": "Jackson", + "last_name": "Woodruff", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jordi", + "last_name": "Armengol-Estapé", + "institution": "University of Edinburgh" + }, + { + "first_name": "Gregorio", + "last_name": "Bernabé", + "institution": "Universidad de Murcia" + }, + { + "first_name": "José M.", + "last_name": "Garcı́a", + "institution": "Universidad de Murcia" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/MartinezWABGO23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580263", + "title": "A Sound and Complete Algorithm for Code Generation in Distance-Based ISA", + "abstract": "The single-thread performance of a processor core is essential even in the multicore era. However, increasing the processing width of a core to improve the single-thread performance leads to a super-linear increase in power consumption. To overcome this power consumption issue, an instruction set architecture for general-purpose processors, called STRAIGHT, has been proposed. STRAIGHT adopts a distance-based ISA, in which source operands are specified by the distance between instructions. In STRAIGHT, it is necessary to satisfy constraints on the distance used as operands to generate executable code. However, it is not yet clear how to generate code that satisfies these constraints in the general case. In this paper, we propose three compiling techniques for STRAIGHT code generation and prove that our techniques can reliably generate code that satisfies the distance constraints. We implemented the proposed method on a compiler and evaluated benchmark programs compiled with it through simulation. The evaluation results showed that the proposed method works in all cases, including conditions where the number of registers is small and existing methods fail to generate code.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580263", + "conference_name": "CC", + "authors": [ + { + "first_name": "Shu", + "last_name": "Sugita", + "institution": "The University of Tokyo" + }, + { + "first_name": "Toru", + "last_name": "Koizumi", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryota", + "last_name": "Shioya", + "institution": "The University of Tokyo" + }, + { + "first_name": "Hidetsugu", + "last_name": "Irie", + "institution": "The University of Tokyo" + }, + { + "first_name": "Shuichi", + "last_name": "Sakai", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/cc/Sugita0SIS23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580265", + "title": "Java Vector API: Benchmarking and Performance Analysis", + "abstract": "The Java Vector API is a new module introduced in Java 16, allowing developers to concisely express vector computations. The API promises both high performance, achieved via the runtime compilation of vector operations to hardware vector instructions, and portability. To the best of our knowledge, there is no study evaluating the performance of the new Java Vector API. To bridge this gap, we propose JVBench, to the best of our knowledge, the first open-source benchmark suite for the Java Vector API. JVBench extensively exercises the features introduced by the Java Vector API, resulting in high API coverage. We use JVBench to evaluate the performance and portability of the Java Vector API on multiple architectures supporting different vector instruction sets. We compare the performance of the Java Vector API on our benchmarks w.r.t. other semantically equivalent implementations, including scalar (non-auto-vectorized) Java code as well as Java code auto-vectorized by the Just in Time (JIT) compiler. Finally, we report patterns and anti-patterns on the use of the Java Vector API significantly affecting application performance.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580265", + "conference_name": "CC", + "authors": [ + { + "first_name": "Matteo", + "last_name": "Basso", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Andrea", + "last_name": "Rosà", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Luca", + "last_name": "Omini", + "institution": "Università della Svizzera italiana" + }, + { + "first_name": "Walter", + "last_name": "Binder", + "institution": "Università della Svizzera italiana" + } + ], + "dblp_key": "conf/cc/BassoROB23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580253", + "title": "A Symbolic Emulator for Shuffle Synthesis on the NVIDIA PTX Code", + "abstract": "Various kinds of applications take advantage of GPUs through automation tools that attempt to automatically exploit the available performance of the GPU's parallel architecture. Directive-based programming models, such as OpenACC, are one such method that easily enables parallel computing by just adhering code annotations to code loops. Such abstract models, however, often prevent programmers from making additional low-level optimizations to take advantage of the advanced architectural features of GPUs because the actual generated computation is hidden from the application developer.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580253", + "conference_name": "CC", + "authors": [ + { + "first_name": "Kazuaki", + "last_name": "Matsumura", + "institution": "Universitat Politècnica de Catalunya" + }, + { + "first_name": "Simon Garcia de", + "last_name": "Gonzalo", + "institution": "Sandia National Laboratories" + }, + { + "first_name": "Antonio J.", + "last_name": "Peña", + "institution": "Barcelona Supercomputing Center" + } + ], + "dblp_key": "conf/cc/MatsumuraGP23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580259", + "title": "LAGrad: Statically Optimized Differentiable Programming in MLIR", + "abstract": "Automatic differentiation (AD) is a central algorithm in deep learning and the emerging field of differentiable programming. However, the performance of AD remains a significant bottleneck in these fields. Training large models requires repeatedly evaluating gradients via AD potentially millions of times. Additionally, the most common form of AD incurs an asymptotically large memory cost relative to the original function being differentiated.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580259", + "conference_name": "CC", + "authors": [ + { + "first_name": "Mai Jacob", + "last_name": "Peng", + "institution": "McGill University" + }, + { + "first_name": "Christophe", + "last_name": "Dubach", + "institution": "McGill University" + } + ], + "dblp_key": "conf/cc/PengD23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580275", + "title": "Codon: A Compiler for High-Performance Pythonic Applications and DSLs", + "abstract": "Domain-specific languages (DSLs) are able to provide intuitive high-level abstractions that are easy to work with while attaining better performance than general-purpose languages. Yet, implementing new DSLs is a burdensome task. As a result, new DSLs are usually embedded in general-purpose languages. While low-level languages like C or C++ often provide better performance as a host than high-level languages like Python, high-level languages are becoming more prevalent in many domains due to their ease and flexibility. Here, we present Codon, a domain-extensible compiler and DSL framework for high-performance DSLs with Python's syntax and semantics. Codon builds on previous work on ahead-of-time type checking and compilation of Python programs and leverages a novel intermediate representation to easily incorporate domain-specific optimizations and analyses. We showcase and evaluate several compiler extensions and DSLs for Codon targeting various domains, including bioinformatics, secure multi-party computation, block-based data compression and parallel programming, showing that Codon DSLs can provide benefits of familiar high-level languages and achieve performance typically only seen with low-level languages, thus bridging the gap between performance and usability.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580275", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ariya", + "last_name": "Shajii", + "institution": "" + }, + { + "first_name": "Gabriel", + "last_name": "Ramı́rez", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Haris", + "last_name": "Smajlović", + "institution": "University of Victoria" + }, + { + "first_name": "Jessica M.", + "last_name": "Ray", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Bonnie", + "last_name": "Berger", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Saman", + "last_name": "Amarasinghe", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Ibrahim", + "last_name": "Numanagić", + "institution": "University of Victoria" + } + ], + "dblp_key": "conf/cc/ShajiiRSRBAN23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580268", + "title": "MOD2IR: High-Performance Code Generation for a Biophysically Detailed Neuronal Simulation DSL", + "abstract": "Advances in computational capabilities and large volumes of experimental data have established computer simulations of brain tissue models as an important pillar in modern neuroscience. Alongside, a variety of domain specific languages (DSLs) have been developed to succinctly express properties of these models, ensure their portability to different platforms, and provide an abstraction that allows scientists to work in their comfort zone of mathematical equations, delegating concerns about performance optimizations to downstream compilers. One of the popular DSLs in modern neuroscience is the NEURON MODeling Language (NMODL). Until now, its compilation process has been split into first transpiling NMODL to C++ and then using a C++ toolchain to emit the efficient machine code. This approach has several drawbacks including the reliance on different programming models to target heterogeneous hardware, maintainability of multiple compiler back-ends and the lack of flexibility to use the domain information for C++ code optimization. To overcome these limitations, we present MOD2IR, a new open-source code generation pipeline for NMODL. MOD2IR leverages the LLVM toolchain to target multiple CPU and GPU hardware platforms. Generating LLVM IR allows the vector extensions of modern CPU architectures to be targeted directly, producing optimized SIMD code. Additionally, this gives MOD2IR significant potential for further optimizations based on the domain information available when LLVM IR code is generated. We present experiments showing that MOD2IR is able to produce on-par execution performance using a single compiler back-end implementation compared to code generated via state-of-the-art C++ compilers, and can even surpass them by up to 1.26×. Moreover, MOD2IR supports JIT-execution of NMODL, yielding both efficient code and an on-the-fly execution workflow.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580268", + "conference_name": "CC", + "authors": [ + { + "first_name": "George", + "last_name": "Mitenkov", + "institution": "Imperial College London" + }, + { + "first_name": "Ioannis", + "last_name": "Magkanaris", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Omar", + "last_name": "Awile", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Pramod", + "last_name": "Kumbhar", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Felix", + "last_name": "Schürmann", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/cc/MitenkovMAKSD23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580255", + "title": "A Hotspot-Driven Semi-automated Competitive Analysis Framework for Identifying Compiler Key Optimizations", + "abstract": "High-performance compilers play an important role in improving the run-time performance of a program, and it is hard and time-consuming to identify the key optimizations implemented in a high-performance compiler with traditional program analysis. In this paper, we propose a hotspot-driven semi-automated competitive analysis framework for identifying key optimizations through comparing the hotspot codes generated by any two different compilers. Our framework is platform-agnostic and works well on both AArch64 and X64 platforms, which automates the stages of hotspot detection and dynamic binary instrumentation only for selected hotspots. With the instrumented instruction characterization information, the framework users can analyze the binary code within a much smaller scope to explore practical optimizations implemented in any of the compilers compared. To demonstrate the effectiveness and practicality, we conduct experiments on SPECspeed 2017 Integer benchmarks(CINT2017) and their binaries generated by open-source GCC compiler versus proprietary Huawei BiSheng and Intel ICC compilers on AArch64 and X64 platforms respectively. Empirical studies show that our methods can identify several significant optimizations that have been implemented by proprietary compilers and as well can be implemented in open-source compilers. To Hangzhou Hongjun Microelectronics Technology(Hjmicro), the identified key optimizations shed great light on optimizing their GCC-based product compiler, which delivers 20.83% improvement for SPECrate 2017 Integer on AArch64 platform.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580255", + "conference_name": "CC", + "authors": [ + { + "first_name": "Wenlong", + "last_name": "Mu", + "institution": "East China Normal University" + }, + { + "first_name": "Yilei", + "last_name": "Zhang", + "institution": "East China Normal University" + }, + { + "first_name": "Bo", + "last_name": "Huang", + "institution": "East China Normal University" + }, + { + "first_name": "Jianmei", + "last_name": "Guo", + "institution": "East China Normal University" + }, + { + "first_name": "Shiqiang", + "last_name": "Cui", + "institution": "" + } + ], + "dblp_key": "conf/cc/MuZHGC23", + "venue": "cc", + "year": 2023 + }, + { + "paper_id": "10.1145/3578360.3580270", + "title": "Lazy Evaluation for the Lazy: Automatically Transforming Call-by-Value into Call-by-Need", + "abstract": "This paper introduces lazification, a code transformation technique that replaces strict with lazy evaluation of function parameters whenever such modification is deemed profitable. The transformation is designed for an imperative, low-level program representation. It involves a static analysis to identify function calls that are candidates for lazification, plus the generation of closures to be lazily activated. Code extraction uses an adaptation of the classic program slicing technique adjusted for the static single assignment representation. If lazification is guided by profiling information, then it can deliver speedups even on traditional benchmarks that are heavily optimized. We have implemented lazification on LLVM 14.0, and have applied it on the C/C++ programs from the LLVM test-suite and from SPEC CPU2017. We could observe statistically significant speedups over clang -O3 on some large programs, including a speedup of 11.1% on Prolang's Bison without profiling support and a speedup of 4.6% on SPEC CPU2017's perlbench (one of the largest programs in the SPEC collection) with profiling support.", + "date": "2023-02-17", + "link": "https://doi.org/10.1145/3578360.3580270", + "conference_name": "CC", + "authors": [ + { + "first_name": "Breno Campos Ferreira", + "last_name": "Guimarães", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/cc/GuimaraesP23", + "venue": "cc", + "year": 2023 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2024.json b/data/pl_conferences/cc/2024.json new file mode 100644 index 0000000..67d3496 --- /dev/null +++ b/data/pl_conferences/cc/2024.json @@ -0,0 +1,650 @@ +[ + { + "paper_id": "10.1145/3640537.3641567", + "title": "Fast Template-Based Code Generation for MLIR", + "abstract": "Fast compilation is essential for JIT-compilation use cases like dynamic languages or databases as well as development productivity when compiling static languages. Template-based compilation allows fast compilation times, but in existing approaches, templates are generally handwritten, limiting flexibility and causing substantial engineering effort.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641567", + "conference_name": "CC", + "authors": [ + { + "first_name": "Florian", + "last_name": "Drescher", + "institution": "" + }, + { + "first_name": "Alexis", + "last_name": "Engelke", + "institution": "" + } + ], + "dblp_key": "conf/cc/DrescherE24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641581", + "title": "A Unified Memory Dependency Framework for Speculative High-Level Synthesis", + "abstract": "Heterogeneous hardware platforms that leverage application-specific hardware accelerators are becoming increasingly popular as the demand for high-performance compute intensive applications rises. The design of such high-performance hardware accelerators is a complex task. High-Level Synthesis (HLS) promises to ease this process by synthesizing hardware from a high-level algorithmic description. Recent works have demonstrated that speculative execution can be inferred from the latter by leveraging compilation transformation and analysis techniques in HLS flows. However, existing work on speculative HLS lacks support for the intricate memory interactions in data-processing applications. In this paper, we introduce a unified memory speculation framework, which allows aggressive scheduling and high-throughput accelerator synthesis in the presence of complex memory dependencies. We show that our technique can generate high-throughput designs for various applications and describe a complete implementation inside an existing speculative HLS toolchain.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641581", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jean-Michel", + "last_name": "Gorius", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Simon", + "last_name": "Rokicki", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Steven", + "last_name": "Derrien", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/cc/GoriusRD24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641568", + "title": "BLQ: Light-Weight Locality-Aware Runtime for Blocking-Less Queuing", + "abstract": "Message queues are used widely in parallel processing systems for worker thread synchronization. When there is a throughput mismatch between the upstream and downstream tasks, the message queue buffer will often exist as either empty or full. Polling on an empty or full queue will affect the performance of upstream or downstream threads, since such polling cycles could have been spent on other computation. Non-blocking queue is an alternative that allow polling cycles to be spared for other tasks per applications’ choice. However, application programmers are not supposed to bear the burden, because a good decision of what to do upon blocking has to take many runtime environment information into consideration.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641568", + "conference_name": "CC", + "authors": [ + { + "first_name": "Qinzhe", + "last_name": "Wu", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Ruihao", + "last_name": "Li", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Jonathan Curtis", + "last_name": "Beard", + "institution": "American Rock Mechanics Association" + }, + { + "first_name": "Lizy K.", + "last_name": "John", + "institution": "The University of Texas at Austin" + } + ], + "dblp_key": "conf/cc/Wu0BJ24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641576", + "title": "CoSense: Compiler Optimizations using Sensor Technical Specifications", + "abstract": "Embedded systems are ubiquitous, but in order to maximize their lifetime on batteries there is a need for faster code execution – i.e., higher energy efficiency, and for reduced memory usage. The large number of sensors integrated into embedded systems gives us the opportunity to exploit sensors’ technical specifications, like a sensor’s value range, to guide compiler optimizations for faster code execution, small binaries, etc. We design and implement such an idea in COSENSE, a novel compiler (extension) based on the LLVM infrastructure, using an existing domain-specific language (DSL), NEWTON, to describe the bounds of and relations between physical quantities measured by sensors. COSENSE utilizes previously unexploited physical information correlated to program variables to drive code optimizations. COSENSE computes value ranges of variables and proceeds to overload functions, compress variable types, substitute code with constants and simplify the condition statements. We evaluated COSENSE using several microbenchmarks and two real-world applications on various platforms and CPUs. For microbenchmarks, COSENSE achieves 1.18× geomean speedup in execution time and 12.35% reduction on average in binary code size with 4.66% compilation time overhead on x86, and 1.23× geomean speedup in execution time and 10.95% reduction on average in binary code size with 5.67% compilation time overhead on ARM. For real-world applications, COSENSE achieves 1.70× and 1.50× speedup in execution time, 12.96% and 0.60% binary code reduction, 9.69% and 30.43% lower energy consumption, with a 26.58% and 24.01% compilation time overhead, respectively.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641576", + "conference_name": "CC", + "authors": [ + { + "first_name": "Pei", + "last_name": "Mu", + "institution": "University of Edinburgh" + }, + { + "first_name": "Nikolaos", + "last_name": "Mavrogeorgis", + "institution": "University of Edinburgh" + }, + { + "first_name": "Christos", + "last_name": "Vasiladiotis", + "institution": "University of Edinburgh" + }, + { + "first_name": "Vasileios", + "last_name": "Tsoutsouras", + "institution": "University of Cambridge" + }, + { + "first_name": "Orestis", + "last_name": "Kaparounakis", + "institution": "University of Cambridge" + }, + { + "first_name": "Phillip", + "last_name": "Stanley‐Marbell", + "institution": "University of Cambridge" + }, + { + "first_name": "Antonio", + "last_name": "Barbalace", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/0003MVTKSB24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641574", + "title": "A Context-Sensitive Pointer Analysis Framework for Rust and Its Application to Call Graph Construction", + "abstract": "Existing program analysis tools for Rust lack the ability to effectively detect security vulnerabilities due to the absence of an accurate call graph and precise points-to information. We present Rupta, the first context-sensitive pointer analysis framework designed for Rust, with a particular focus on its role in constructing call graphs. Operating on Rust MIR, Rupta employs callsite-based context-sensitivity and on-the-fly call graph construction to address a range of pointer analysis challenges, including method/function calls, pointer casts, and nested structs, while preserving type information.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641574", + "conference_name": "CC", + "authors": [ + { + "first_name": "Wei", + "last_name": "Li", + "institution": "UNSW Sydney" + }, + { + "first_name": "Dongjie", + "last_name": "He", + "institution": "UNSW Sydney" + }, + { + "first_name": "Yujiang", + "last_name": "Gui", + "institution": "UNSW Sydney" + }, + { + "first_name": "Wenguang", + "last_name": "Chen", + "institution": "Tsinghua University" + }, + { + "first_name": "Jingling", + "last_name": "Xue", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/cc/LiHGCX24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641562", + "title": "If-Convert as Early as You Must", + "abstract": "Optimizing compilers employ a rich set of transformations that generate highly efficient code for a variety of source languages and target architectures. These transformations typically operate on general control flow constructs which trigger a range of optimization opportunities, such as moving code to less frequently executed paths, and more. Regular loop nests are specifically relevant for accelerating certain domains, leveraging architectural features including vector instructions, hardware-controlled loops and data flows, provided their internal control-flow is eliminated. Compilers typically apply predicating if-conversion late, in their backend, to remove control-flow undesired by the target. Until then, transformations triggered by control-flow constructs that are destined to be removed may end up doing more harm than good. We present an approach that leverages the existing powerful and general optimization flow of LLVM when compiling for targets without control-flow in loops. Rather than trying to teach various transformations how to avoid misoptimizing for such targets, we propose to introduce an aggressive if-conversion pass as early as possible, along with carefully addressing pass-ordering implications. This solution outperforms the traditional compilation flow with only a modest tuning effort, thereby offering a robust and promising compilation approach for branch-restricted targets.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641562", + "conference_name": "CC", + "authors": [ + { + "first_name": "Dorit", + "last_name": "Nuzman", + "institution": "" + }, + { + "first_name": "Ayal", + "last_name": "Zaks", + "institution": "" + }, + { + "first_name": "Ziv", + "last_name": "Ben-Zion", + "institution": "" + } + ], + "dblp_key": "conf/cc/NuzmanZB24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641563", + "title": "Paguroidea: Fused Parser Generator with Transparent Semantic Actions", + "abstract": "Parser generators have long been a savior for programmers, liberating them from the daunting task of crafting correct and maintainable parsers. Yet, this much-needed simplicity often comes at the expense of efficiency.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641563", + "conference_name": "CC", + "authors": [ + { + "first_name": "Yifan", + "last_name": "Zhu", + "institution": "University of Rochester" + }, + { + "first_name": "Quartic", + "last_name": "Cat", + "institution": "Chinese University of Hong Kong, Shenzhen" + }, + { + "first_name": "Boluo", + "last_name": "Ge", + "institution": "North Carolina State University" + }, + { + "first_name": "Shaotong", + "last_name": "Sun", + "institution": "University of Rochester" + } + ], + "dblp_key": "conf/cc/ZhuCGS24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641579", + "title": "Clog: A Declarative Language for C Static Code Checkers", + "abstract": "We present Clog, a declarative language for describing static code checkers for C. Unlike other extensible state-of-the-art checker frameworks, Clog enables powerful interprocedural checkers without exposing the underlying program representation: Clog checkers consist of Datalog-style recursive rules that access the program under analysis via syntactic pattern matching and control flow edges only. We have implemented Clog on top of Clang, using a custom Datalog evaluation strategy that piggy-backs on Clang's AST matching facilities while working around Clang's limitations to achieve our design goal of representation independence.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641579", + "conference_name": "CC", + "authors": [ + { + "first_name": "Alexandru", + "last_name": "Dura", + "institution": "Lund University" + }, + { + "first_name": "Christoph", + "last_name": "Reichenbach", + "institution": "Lund University" + } + ], + "dblp_key": "conf/cc/DuraR24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641578", + "title": "Accurate Coverage Metrics for Compiler-Generated Debugging Information", + "abstract": "Many debugging tools rely on compiler-produced metadata to present a source-language view of program states, such as variable values and source line numbers. While this tends to work for unoptimised programs, current compilers often generate only partial debugging information in optimised programs. Current approaches for measuring the extent of coverage of local variables are based on crude assumptions (for example, assuming variables could cover their whole parent scope) and are not comparable from one compilation to another. In this work, we propose some new metrics, computable by our tools, which could serve as motivation for language implementations to improve debugging quality.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641578", + "conference_name": "CC", + "authors": [ + { + "first_name": "J. Ryan", + "last_name": "Stinnett", + "institution": "King's College London" + }, + { + "first_name": "Stephen", + "last_name": "Kell", + "institution": "King's College London" + } + ], + "dblp_key": "conf/cc/StinnettK24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641577", + "title": "FlowProf: Profiling Multi-threaded Programs using Information-Flow", + "abstract": "Amdahl's law implies that even small sequential bottlenecks can seriously limit the scalability of multi-threaded programs. To achieve scalability, developers must painstakingly identify sequential bottlenecks in their program and eliminate these bottlenecks by either changing synchronization strategies or rearchitecting and rewriting any code with sequential bottlenecks. This can require significant effort by the developer to find and understand how to fix sequential bottlenecks. To address the issue, we bring a new tool, information flow, to the problem of understanding sequential bottlenecks. Information flow can help developers understand whether a bottleneck is fundamental to the computation, or merely an artifact of the implementation.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641577", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ahamed Al", + "last_name": "Nahian", + "institution": "University of California, Irvine" + }, + { + "first_name": "Brian", + "last_name": "Demsky", + "institution": "University of California, Irvine" + } + ], + "dblp_key": "conf/cc/NahianD24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641565", + "title": "UNIFICO: Thread Migration in Heterogeneous-ISA CPUs without State Transformation", + "abstract": "Heterogeneous-ISA processor designs have attracted considerable research interest. However, unlike their homogeneous-ISA counterparts, explicit software support for bridging ISA heterogeneity is required. The lack of a compilation toolchain ready to support heterogeneous-ISA targets has been a major factor hindering research in this exciting emerging area. For any such compiler “getting right” the mechanics involved in state transformation upon migration and doing this efficiently is of critical importance. In particular, any runtime conversion of the current program stack from one architecture to another would be prohibitively expensive. In this paper, we design and develop Unifico, a new multi-ISA compiler that generates binaries that maintain the same stack layout during their execution on either architecture. Unifico avoids the need for runtime stack transformation, thus eliminating overheads associated with ISA migration. Additional responsibilities of the Unifico compiler backend include maintenance of a uniform ABI and virtual address space across ISAs. Unifico is implemented using the LLVM compiler infrastructure, and we are currently targeting the x86-64 and ARMv8 ISAs. We have evaluated Unifico across a range of compute-intensive NAS benchmarks and show its minimal impact on overall execution time, where less than 6% overhead is introduced on average. When compared against the state-of-the-art Popcorn compiler, Unifico reduces binary size overhead from ∼200% to ∼10%, whilst eliminating the stack transformation overhead during ISA migration.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641565", + "conference_name": "CC", + "authors": [ + { + "first_name": "Nikolaos", + "last_name": "Mavrogeorgis", + "institution": "University of Edinburgh" + }, + { + "first_name": "Christos", + "last_name": "Vasiladiotis", + "institution": "University of Edinburgh" + }, + { + "first_name": "Pei", + "last_name": "Mu", + "institution": "University of Edinburgh" + }, + { + "first_name": "Amir", + "last_name": "Khordadi", + "institution": "University of Edinburgh" + }, + { + "first_name": "Björn", + "last_name": "Franke", + "institution": "University of Edinburgh" + }, + { + "first_name": "Antonio", + "last_name": "Barbalace", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/MavrogeorgisV0K24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641571", + "title": "Region-Based Data Layout via Data Reuse Analysis", + "abstract": "Data-structure splicing techniques, such as structure splitting, field reordering, and pointer inlining reorganize data structures to improve cache and translation look-aside buffer (TLB) utilization. Structure types are typically transformed globally in the program, requiring updates to all references to elements of a transformed type. These techniques often rely on instrumentation, tracing, or sampling to create models that guide their transformations. Furthermore, compilers often cannot prove that their transformations are legal and must rely on manual inspection and manual transformation. Applying data-layout transformations locally -- as opposed to globally -- to regions of code removes the need for expensive profiling and simplifies legality verification. This work introduces RebaseDL, a static analysis that finds profitable and legal region-based data layout transformation opportunities that improve access locality. These opportunities are found within code regions that exhibit data reuse. Going beyond structure splicing, RebaseDL also identifies transformation opportunities that do not involve structure types, that is, it identifies data packing transformations. The analysis is implemented in LLVM and it detects multiple transformation opportunities within the SPEC CPU benchmark suite, where the transformation obtains speedups of up to 1.34x for transformed regions.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641571", + "conference_name": "CC", + "authors": [ + { + "first_name": "Caio Salvador", + "last_name": "Rohwedder", + "institution": "University of Alberta" + }, + { + "first_name": "João P. L. de", + "last_name": "Carvalho", + "institution": "University of Alberta" + }, + { + "first_name": "José Nelson", + "last_name": "Amaral", + "institution": "University of Alberta" + } + ], + "dblp_key": "conf/cc/RohwedderCA24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641569", + "title": "Reducing the Overhead of Exact Profiling by Reusing Affine Variables", + "abstract": "An exact profiler inserts counters in a program to record how many times each edge of that program's control-flow graph has been traversed during an execution of it. It is common practice to instrument only edges in the complement of a minimum spanning tree of the program's control-flow graph, following the algorithm proposed by Knuth and Stevenson in 1973. Yet, even with this optimization, the overhead of exact profiling is high. As a consequence, mainstream profile-guided code optimizers resort to sampling, i.e., approximate, profiling, instead of exact frequency counts. This paper introduces a technique to reduce the overhead of exact profiling. We show that it is possible to use the values of variables incremented by constant steps within loops---henceforth called SESE counters---as a replacement for some profiling counters. Such affine variables are common, for they include the induction variable of typical loops. This technique, although simple, is effective. We have implemented it in the LLVM compilation infrastructure. Standard Knuth-Stevenson instrumentation increases the running time of the 135 programs in the LLVM test suite from 648 seconds to 817. The optimization suggested in this paper brings this time down to 738 seconds. In the 949 Jotai programs, standard instrumentation increases the number of processed x86 instructions from 2.96 billion to 3.34 billion, whereas the proposed technique causes 3.07 billion instructions to be fetched.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641569", + "conference_name": "CC", + "authors": [ + { + "first_name": "Léon", + "last_name": "Frenot", + "institution": "École Normale Supérieure de Lyon" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/cc/FrenotP24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641575", + "title": "APPy: Annotated Parallelism for Python on GPUs", + "abstract": "GPUs are increasingly being used used to speed up Python applications in the scientific computing and machine learning domains. Currently, the two common approaches to leveraging GPU acceleration in Python are 1) create a custom native GPU kernel, and import it as a function that can be called from Python; 2) use libraries such as CuPy, which provides pre-defined GPU-implementation-backed tensor operators. The first approach is very flexible but requires tremendous manual effort to create a correct and high performance GPU kernel. While the second approach dramatically improves productivity, it is limited in its generality, as many applications cannot be expressed purely using CuPy’s pre-defined tensor operators. Additionally, redundant memory access can often occur between adjacent tensor operators due to the materialization of intermediate results. In this work, we present APPy (Annotated Parallelism for Python), which enables users to parallelize generic Python loops and tensor expressions for execution on GPUs by adding simple compiler directives (annotations) to Python code. Empirical evaluation on 20 scientific computing kernels from the literature on a server with an AMD Ryzen 7 5800X 8-Core CPU and an NVIDIA RTX 3090 GPU demonstrates that with simple pragmas APPy is able to generate more efficient GPU code and achieves significant geometric mean speedup relative to CuPy (30× on average), and to three state-of-the-art Python compilers, Numba (8.3× on average), DaCe-GPU (3.1× on average) and JAX-GPU (18.8× on average).", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641575", + "conference_name": "CC", + "authors": [ + { + "first_name": "Tong", + "last_name": "Zhou", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Jun", + "last_name": "Shirako", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Vivek", + "last_name": "Sarkar", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/cc/ZhouSS24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641573", + "title": "Stale Profile Matching", + "abstract": "Profile-guided optimizations rely on profile data for directing compilers to generate optimized code. To achieve the maximum performance boost, profile data needs to be collected on the same version of the binary that is being optimized. In practice however, there is typically a gap between the profile collection and the release, which makes a portion of the profile invalid for optimizations. This phenomenon is known as profile staleness, and it is a serious practical problem for data-center workloads both for compilers and binary optimizers.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641573", + "conference_name": "CC", + "authors": [ + { + "first_name": "Amir", + "last_name": "Ayupov", + "institution": "Alpha Omega Alpha Medical Honor Society" + }, + { + "first_name": "Maksim", + "last_name": "Panchenko", + "institution": "Alpha Omega Alpha Medical Honor Society" + }, + { + "first_name": "Sergey", + "last_name": "Pupyrev", + "institution": "Alpha Omega Alpha Medical Honor Society" + } + ], + "dblp_key": "conf/cc/AyupovPP24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641570", + "title": "From Low-Level Fault Modeling (of a Pipeline Attack) to a Proven Hardening Scheme", + "abstract": "Fault attacks present unique safety and security challenges that require dedicated countermeasures, even for bug-free programs. Models of these complex attacks are made workable by approximating their effects to a suitable level of abstraction. The common practice of targeting the Instruction Set Architecture (ISA) level isn't ideal because it discards important micro-architectural information, leading to weaker security guarantees. Conversely, including micro-architectural details makes countermeasures harder to model and reason about, creating a new challenge in validating and trusting protections.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641570", + "conference_name": "CC", + "authors": [ + { + "first_name": "Sébastien", + "last_name": "Michelland", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Christophe", + "last_name": "Deleuze", + "institution": "Institut polytechnique de Grenoble" + }, + { + "first_name": "Laure", + "last_name": "Gonnord", + "institution": "Institut polytechnique de Grenoble" + } + ], + "dblp_key": "conf/cc/MichellandDG24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641564", + "title": "Compiler-Based Memory Encryption for Machine Learning on Commodity Low-Power Devices", + "abstract": "Running machine learning (ML) on low-power IoT devices exposes unique security concerns. Attackers can easily steal or manipulate sensitive user data or proprietary ML models from the devices’ off-chip memory by leveraging their simple hardware structure and the lack of memory encryption hardware. To protect against these real-world threats, we propose a lightweight compiler-based memory encryption scheme, Spitz. Spitz achieves full off-chip memory encryption only with common architectural components on commodity devices, such as programmable on-chip SRAM, AES hardware, and Direct-Memory Access (DMA). Our evaluation on real hardware shows that Spitz maintains competitive performance while realizing full off-chip memory encryption. Spitz is only 1.16–1.73× slower than our best-effort non-secure baseline, and is even faster by 1.5–2.23× compared to a non-secure popular vendor library.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641564", + "conference_name": "CC", + "authors": [ + { + "first_name": "Kiwan", + "last_name": "Maeng", + "institution": "Pennsylvania State University" + }, + { + "first_name": "Brandon", + "last_name": "Lucia", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/cc/MaengL24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641566", + "title": "YFlows: Systematic Dataflow Exploration and Code Generation for Efficient Neural Network Inference using SIMD Architectures on CPUs", + "abstract": "We address the challenges associated with deploying neural networks on CPUs, with a particular focus on minimizing inference time while maintaining accuracy. Our novel approach is to use the dataflow (i.e., computation order) of a neural network to explore data reuse opportunities using heuristic-guided analysis and a code generation framework, which enables exploration of various Single Instruction, Multiple Data (SIMD) implementations to achieve optimized neural network execution. Our results demonstrate that the dataflow that keeps outputs in SIMD registers while also maximizing both input and weight reuse consistently yields the best performance for a wide variety of inference workloads, achieving up to 3x speedup for 8-bit neural networks, and up to 4.8x speedup for binary neural networks, respectively, over the optimized implementations of neural networks today.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641566", + "conference_name": "CC", + "authors": [ + { + "first_name": "Cyrus", + "last_name": "Zhou", + "institution": "University of Chicago" + }, + { + "first_name": "Zack", + "last_name": "Hassman", + "institution": "University of Chicago" + }, + { + "first_name": "Dhirpal", + "last_name": "Shah", + "institution": "University of Chicago" + }, + { + "first_name": "Vaughn", + "last_name": "Richard", + "institution": "University of Chicago" + }, + { + "first_name": "Yanjing", + "last_name": "Li", + "institution": "University of Chicago" + } + ], + "dblp_key": "conf/cc/ZhouHSRL24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641572", + "title": "Fast and Accurate Context-Aware Basic Block Timing Prediction using Transformers", + "abstract": "This paper introduces ORXESTRA, a context-aware execution time prediction model based on Transformers XL, specifically designed to accurately estimate performance in embedded system applications. Unlike traditional machine learning models that often overlook contextual information, resulting in biased predictions for individual isolated basic blocks, ORXESTRA overcomes this limitation by incorporating execution context awareness. By doing so, ORXESTRA effectively accounts for the processor micro-architecture without explicitly modeling micro-architectural elements such as caches, pipelines, and branch predictors. Our evaluations demonstrate ORXESTRA's ability to provide precise timing estimations for different ARM targets (Cortex M4, M7, A53, and A72), surpassing existing machine learning-based approaches in both prediction accuracy and prediction speed.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641572", + "conference_name": "CC", + "authors": [ + { + "first_name": "Abderaouf Nassim", + "last_name": "Amalou", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Élisa", + "last_name": "Fromont", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Isabelle", + "last_name": "Puaut", + "institution": "Centre National de la Recherche Scientifique" + } + ], + "dblp_key": "conf/cc/AmalouFP24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641582", + "title": "Exponentially Expanding the Phase-Ordering Search Space via Dormant Information", + "abstract": "Applying compilation transformations in optimal sequences can significantly improve program speed and reduce code size. However, finding these optimal sequences—a problem known as the phase-ordering problem—remains a long-standing challenge. Specifically, modern compilers offer hundreds of available transformations, making the search space too large to explore efficiently within a reasonable timeframe. Existing solutions address this problem by grouping transformations into short sequences based on prior knowledge from human experts, and then searching for optimal orders among these sequences. Such pruning methods are aggressive, potentially excluding optimal solutions from the search space. Additionally, they rely on prior knowledge and lack scalability when applied to new transformations.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641582", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ruobing", + "last_name": "Han", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Hyesoon", + "last_name": "Kim", + "institution": "Georgia Institute of Technology" + } + ], + "dblp_key": "conf/cc/HanK24", + "venue": "cc", + "year": 2024 + }, + { + "paper_id": "10.1145/3640537.3641580", + "title": "The Next 700 ML-Enabled Compiler Optimizations", + "abstract": "There is a growing interest in enhancing compiler optimizations with ML models, yet interactions between compilers and ML frameworks remain challenging. Some optimizations require tightly coupled models and compiler internals, raising issues with modularity, performance and framework independence. Practical deployment and transparency for the end-user are also important concerns. We propose ML-Compiler-Bridge to enable ML model development within a traditional Python framework while making end-to-end integration with an optimizing compiler possible and efficient. We evaluate it on both research and production use cases, for training and inference, over several optimization problems, multiple compilers and its versions, and gym infrastructures.", + "date": "2024-02-17", + "link": "https://doi.org/10.1145/3640537.3641580", + "conference_name": "CC", + "authors": [ + { + "first_name": "S.", + "last_name": "VenkataKeerthy", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Siddharth", + "last_name": "Jain", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Umesh", + "last_name": "Kalvakuntla", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Pranav Sai", + "last_name": "Gorantla", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Rajiv Shailesh", + "last_name": "Chitale", + "institution": "Indian Institute of Technology Hyderabad" + }, + { + "first_name": "Eugene", + "last_name": "Brevdo", + "institution": "Google (United States)" + }, + { + "first_name": "Albert", + "last_name": "Cohen", + "institution": "" + }, + { + "first_name": "Mircea", + "last_name": "Trofin", + "institution": "Google (United States)" + }, + { + "first_name": "Ramakrishna", + "last_name": "Upadrasta", + "institution": "Indian Institute of Technology Hyderabad" + } + ], + "dblp_key": "conf/cc/VenkataKeerthyJ24", + "venue": "cc", + "year": 2024 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2025.json b/data/pl_conferences/cc/2025.json new file mode 100644 index 0000000..661c425 --- /dev/null +++ b/data/pl_conferences/cc/2025.json @@ -0,0 +1,568 @@ +[ + { + "paper_id": "10.1145/3708493.3712680", + "title": "A Comparative Study on the Accuracy and the Speed of Static and Dynamic Program Classifiers", + "abstract": "Classifying programs based on their tasks is essential in fields such as plagiarism detection, malware analysis, and software auditing. Traditionally, two classification approaches exist: static classifiers analyze program syntax, while dynamic classifiers observe their execution. Although dynamic analysis is regarded as more precise, it is often considered impractical due to high overhead, leading the research community to largely dismiss it. In this paper, we revisit this perception by comparing static and dynamic analyses using the same classification representation: opcode histograms. We show that dynamic histograms---generated from instructions actually executed---are only marginally (4-5%) more accurate than static histograms in non-adversarial settings. However, if an adversary is allowed to obfuscate programs, the accuracy of the dynamic classifier is twice higher than the static one, due to its ability to avoid observing dead-code. Obtaining dynamic histograms with a state-of-the-art Valgrind-based tool incurs an 85x slowdown; however, once we account for the time to produce the representations for static analysis of executables, the overall slowdown reduces to 4x: a result significantly lower than previously reported in the literature.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712680", + "conference_name": "CC", + "authors": [ + { + "first_name": "Anderson Faustino da", + "last_name": "Silva", + "institution": "Universidade Estadual de Maringá" + }, + { + "first_name": "Jerónimo", + "last_name": "Castrillón", + "institution": "Technische Universität Dresden" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/cc/SilvaCP25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712685", + "title": "MimIrADe: Automatic Differentiation in MimIR", + "abstract": "Automatic Differentiation (AD) is at the core of all machine learning frameworks and has applications in scientific computing as well. Theoretical research on reverse-mode AD focuses on functional, higher-order languages, enabling AD to be formulated as a series of local, concise program rewrites. These theoretical approaches focus on correctness but disregard efficiency. Practical implementations, however, employ mutation and taping techniques to enhance efficiency. This approach, however, necessitates intricate, low-level, and non-local program transformations. In this work, we introduce MimIrADe, a functionally inspired AD technique implemented within a higher-order, graph-based (\"sea of nodes\") intermediate representation (IR). Our method consists of a streamlined implementation and incorporates standard optimizations, resulting in an efficient AD system. The higher-order nature of the IR enables us to utilize concise functional AD methods, expressing AD through local rewrites. This locality facilitates modular high-level extensions, such as matrix operations, in a straightforward manner. Additionally, the graph-based structure of the IR ensures that critical implementation aspects---particularly the handling of shared pullback invocations---are managed naturally and efficiently. Our AD pass supports a comprehensive set of features, including non-scalar types, pointers, and higher-order recursive functions. We demonstrate through standard benchmarks that a suite of common optimizations effectively eliminates the overhead typically associated with functional AD approaches, producing differentiated code that performs on par with leading mutation and taping techniques. At the same time, MimIrADe's implementation is an order of magnitude less complex compared to its contenders.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712685", + "conference_name": "CC", + "authors": [ + { + "first_name": "Marcel", + "last_name": "Ullrich", + "institution": "Saarland University" + }, + { + "first_name": "Sebastian", + "last_name": "Hack", + "institution": "Saarland University" + }, + { + "first_name": "Roland", + "last_name": "Leißa", + "institution": "University of Mannheim" + } + ], + "dblp_key": "conf/cc/UllrichHL25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712689", + "title": "Fusion of Operators of Computational Graphs via Greedy Clustering: The XNNC Experience", + "abstract": "Tensor compilers like XLA, TVM, and TensorRT operate on computational graphs, where vertices represent operations and edges represent data flow between these operations. Operator fusion is an optimization that merges operators to improve their efficiency. This paper presents the operator fusion algorithm recently deployed in the Xtensa Neural Network Compiler (XNNC) - Cadence Tensilica's tensor compiler. The algorithm clusters nodes within the computational graph and iteratively grows these clusters until reaching a fixed point. A priority queue, sorted by the estimated profitability of merging cluster candidates, guides this iterative process. It balances precision and practicality, producing models 39% faster than XNNC's previous fusion approach, which was based on a depth-first traversal of the computational graph. Moreover, unlike recently proposed exhaustive or evolutionary search methods, this algorithm terminates quickly while often yielding equally efficient models.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712689", + "conference_name": "CC", + "authors": [ + { + "first_name": "Michael", + "last_name": "Canesche", + "institution": "" + }, + { + "first_name": "Vanderson Martins do", + "last_name": "Rosário", + "institution": "Cadence Design Systems (United States)" + }, + { + "first_name": "Edson", + "last_name": "Borin", + "institution": "Universidade Estadual de Campinas (UNICAMP)" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "conf/cc/CanescheRBP25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712686", + "title": "Finding Missed Code Size Optimizations in Compilers using Large Language Models", + "abstract": "Compilers are complex, and significant effort has been expended on testing them. Techniques such as random program generation and differential testing have proved highly effective and have uncovered thousands of bugs in production compilers. The majority of effort has been expended on validating that a compiler produces correct code for a given input, while less attention has been paid to ensuring that the compiler produces performant code. In this work we adapt differential testing to the task of identifying missed optimization opportunities in compilers. We develop a novel testing approach which combines large language models (LLMs) with a series of differential testing strategies and use them to find missing code size optimizations in C / C++ compilers. The advantage of our approach is its simplicity. We offload the complex task of generating random code to an off-the-shelf LLM, and use heuristics and analyses to identify anomalous compiler behavior. Our approach requires fewer than 150 lines of code to implement. This simplicity makes it extensible. By simply changing the target compiler and initial LLM prompt we port the approach from C / C++ to Rust and Swift, finding bugs in both. To date we have reported 24 confirmed bugs in production compilers, and conclude that LLM-assisted testing is a promising avenue for detecting optimization bugs in real world compilers.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712686", + "conference_name": "CC", + "authors": [ + { + "first_name": "Davide", + "last_name": "Italiano", + "institution": "Alpha Omega Alpha Medical Honor Society" + }, + { + "first_name": "Chris", + "last_name": "Cummins", + "institution": "Alpha Omega Alpha Medical Honor Society" + } + ], + "dblp_key": "conf/cc/ItalianoC25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712683", + "title": "Data-Efficient Performance Modeling via Pre-training", + "abstract": "Performance models are essential for automatic code optimization, enabling compilers to predict the effects of code transformations on performance and guide search for optimal transformations. Building state-of-the-art performance models with deep learning, however, requires vast labeled datasets of random programs – an expensive and time-consuming process, stretching over months. This paper introduces a self-supervised pre-training scheme with autoencoders to reduce the need for labeled data. By pre-training on a large dataset of random programs, the autoencoder learns representations of code and transformations, which are then used to embed programs for the performance model. Implemented in the Tiramisu autoscheduler, our approach improves model accuracy with less data. For example, to achieve a MAPE of 20.72%, the original model requires 18 million data points, whereas our method achieves a similar MAPE of 22.44% with only 3.6 million data points, reducing data requirements by 5×.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712683", + "conference_name": "CC", + "authors": [ + { + "first_name": "Chunting", + "last_name": "Liu", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Riyadh", + "last_name": "Baghdadi", + "institution": "New York University Abu Dhabi" + } + ], + "dblp_key": "conf/cc/LiuB25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712679", + "title": "Enhancing Program Analysis with Deterministic Distinguishable Calling Context", + "abstract": "Calling context is crucial for improving the precision of program analyses in various use cases (clients), such as profiling, debugging, optimization, and security checking. Often the calling context is encoded using a numerical value. We have observed that many clients benefit not only from a deterministic but also globally distinguishable value across runs to simplify bookkeeping and guarantee complete uniqueness. However, existing work only guarantees determinism, not global distinguishability. Clients need to develop auxiliary helpers, which incurs considerable overhead to distinguish encoded values among all calling contexts. In this paper, we propose Deterministic Distinguishable Calling Context Encoding () that can enable both properties of calling context encoding natively. The key idea of is leveraging the static call graph and encoding each calling context as the running call path count. Thereby, a mapping is established statically and can be readily used by the clients. Our experiments with two client tools show that has a comparable overhead compared to two state-of-the-art encoding schemes, PCCE and PCC, and further avoids the expensive overheads of collision detection, up to 2.1× and 50%, for Splash-3 and SPEC CPU 2017, respectively.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712679", + "conference_name": "CC", + "authors": [ + { + "first_name": "Sungkeun", + "last_name": "Kim", + "institution": "Samsung (South Korea)" + }, + { + "first_name": "Khanh", + "last_name": "Nguyen", + "institution": "Texas A&M University" + }, + { + "first_name": "Chia-Che", + "last_name": "Tsai", + "institution": "Texas A&M University" + }, + { + "first_name": "Jaewoo", + "last_name": "Lee", + "institution": "Texas A&M University" + }, + { + "first_name": "Abdullah", + "last_name": "Muzahid", + "institution": "Texas A&M University" + }, + { + "first_name": "Eun Jung", + "last_name": "Kim", + "institution": "Texas A&M University" + } + ], + "dblp_key": "conf/cc/KimNTLM025", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712688", + "title": "A Deep Technical Review of nZDC Fault Tolerance", + "abstract": "Faults within CPU circuits, which generate incorrect results and thus silent data corruption, have become endemic at scale. The only generic techniques to detect one-time or intermittent soft errors, such as particle strikes or voltage spikes, require redundant execution, where copies of each instruction in a program are executed twice and compared. The only software solution for this task that is open source and available for use today is nZDC, which aims to achieve “near-zero silent data corruption” through control- and data-flow redundancy. However, when we tried to apply this to large-scale workloads, we found it suffered a wide set of false positives, negatives, compiler bugs and run-time crashes, which meant it was impossible to benchmark against. This document details the wide set of fixes and workarounds we had to put in place to make nZDC work across full suites. We provide many new insights as to the edge cases that make such instruction duplication tricky under complex ISAs such as AArch64 and their similarly complex ABIs. Evaluation across SPECint 2006 and PARSEC with our extensions takes us from no workloads executing to all bar four, with 2× and 1.6× geomean overhead respectively relative to execution with no fault tolerance.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712688", + "conference_name": "CC", + "authors": [ + { + "first_name": "Minli", + "last_name": "Liao", + "institution": "University of Cambridge" + }, + { + "first_name": "Sam", + "last_name": "Ainsworth", + "institution": "University of Edinburgh" + }, + { + "first_name": "Lev", + "last_name": "Mukhanov", + "institution": "Queen Mary University of London" + }, + { + "first_name": "Timothy M.", + "last_name": "Jones", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/cc/LiaoAM025", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712681", + "title": "Automatic Test Case Generation for Jasper App HDL Compiler: An Industry Experience", + "abstract": "Random test case generation is a challenging subject in compiler testing. Due to the structured and strict nature of the languages required for compiler inputs, using randomization techniques for hunting bugs in compiler implementation represents a big challenge that requires trading off correctness and generation biases against fuzzing techniques for broader exploratory randomization. This paper shares the technology and the practical industry experience on two random testing frameworks developed for the Hardware Description Language (HDL) compiler of Jasper® App, a production formal verification software applied in Electronic Design Automation (EDA) industry. The two frameworks impact distinct parts of the compiler stack and provide different features and strengths for randomization: SystemVerilog Generator script, which creates random and formally provable HDL code, and Fuzz HDL Testing, a fuzzing solution applying LLVM’s libFuzzer to explore random textual inputs.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712681", + "conference_name": "CC", + "authors": [ + { + "first_name": "Mirlaine", + "last_name": "Crepalde", + "institution": "" + }, + { + "first_name": "Augusto", + "last_name": "Mafra", + "institution": "" + }, + { + "first_name": "Lucas", + "last_name": "Cavalini", + "institution": "" + }, + { + "first_name": "Lucas", + "last_name": "Martins", + "institution": "" + }, + { + "first_name": "Guilherme da Costa", + "last_name": "Amorim", + "institution": "" + }, + { + "first_name": "Pedro Henrique", + "last_name": "Santos", + "institution": "" + }, + { + "first_name": "Fabiano", + "last_name": "Peixoto", + "institution": "" + } + ], + "dblp_key": "conf/cc/CrepaldeMCMASP25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712682", + "title": "pyATF: Constraint-Based Auto-Tuning in Python", + "abstract": "We introduce pyATF -- a new, language-independent, open-source auto-tuning tool that fully automatically determines optimized values of performance-critical program parameters. A major feature of pyATF is its support for constrained parameters, e.g., the value of one parameter has to divide the value of another parameter. A further major feature of pyATF is its user interface which is designed with a particular focus on expressivity and usability for real-world demands, and which is offered in the increasingly popular Python programming language. We experimentally confirm the practicality of pyATF using real-world studies from the areas of quantum chemistry, image processing, data mining, and deep learning: we show that pyATF auto-tunes the complex parallel implementations of our studies to higher performance than achieved by state-of-practice approaches, including hand-optimized vendor libraries.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712682", + "conference_name": "CC", + "authors": [ + { + "first_name": "Richard", + "last_name": "Schulze", + "institution": "University of Münster" + }, + { + "first_name": "Sergei", + "last_name": "Gorlatch", + "institution": "University of Münster" + }, + { + "first_name": "Ari", + "last_name": "Rasch", + "institution": "University of Münster" + } + ], + "dblp_key": "conf/cc/SchulzeGR25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712691", + "title": "LLM Compiler: Foundation Language Models for Compiler Optimization", + "abstract": "Large Language Models (LLMs) have demonstrated remarkable capabilities across a variety of software engineering and coding tasks. However, their application in the domain of code and compiler optimization remains underexplored. Training LLMs is resource-intensive, requiring substantial GPU hours and extensive data collection, which can be prohibitive. To address this gap, we introduce LLM Compiler, a suite of robust, openly available, pre-trained models specifically designed for compiler tasks. Built on the foundation of Code Llama, LLM Compiler enhances the understanding of compiler intermediate representations (IRs), assembly language, and optimization techniques. The models have been trained on a vast corpus of 546 billion tokens of LLVM-IR and assembly code and have undergone instruction fine-tuning to interpret compiler behavior. To demonstrate the utility of these research tools, we also present fine-tuned versions of the models with enhanced capabilities in optimizing code size and disassembling from x86_64 and ARM assembly back into LLVM-IR. These achieve 77% of the optimising potential of an autotuning search, and 45% disassembly round trip (14% exact match). LLM Compiler is released under a bespoke commercial license to allow wide reuse and is available in two sizes: 7 billion and 13 billion parameters. Our aim is to provide scalable, cost-effective foundational models for further research and development in compiler optimization by both academic researchers and industry practitioners. Since we released LLM Compiler the community has quantized, repackaged, and downloaded the models over 250k times.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712691", + "conference_name": "CC", + "authors": [ + { + "first_name": "Chris", + "last_name": "Cummins", + "institution": "Alpha Omega Alpha Medical Honor Society" + }, + { + "first_name": "Volker", + "last_name": "Seeker", + "institution": "Alpha Omega Alpha Medical Honor Society" + }, + { + "first_name": "Dejan", + "last_name": "Grubisic", + "institution": "Alpha Omega Alpha Medical Honor Society" + }, + { + "first_name": "Baptiste", + "last_name": "Rozière", + "institution": "" + }, + { + "first_name": "Jonas", + "last_name": "Gehring", + "institution": "" + }, + { + "first_name": "Gabriel", + "last_name": "Synnaeve", + "institution": "" + }, + { + "first_name": "Hugh", + "last_name": "Leather", + "institution": "Alpha Omega Alpha Medical Honor Society" + } + ], + "dblp_key": "conf/cc/CumminsSGRGSL25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712690", + "title": "Scalable Data-Flow Modeling and Validation of Distributed-Memory Algorithms", + "abstract": "Distributed-memory programs that use the Message Passing Interface (MPI) often introduce various kinds of correctness anomalies. This work focuses on the type of anomalies detectable through data-flow modeling. We present a new tool and Domain-Specific Language to describe the data-flow of computations based on collective operations, such as the broadcast or all-gather in MPI. Our tool, CollectCall, models key aspects of distributed-memory algorithms, namely the processor space, symbolic communicators, data, its partitioning and mapping, and a set of communication primitives. Using these concepts, we build constraint systems that model the initial data placement and communication steps of the algorithm. Systems are built and solved with the Z3 SMT and the Integer Set Library (ISL) to decide the correctness of sequences of collective operations. We formalize the correctness requirements for a class of collective communication operations, and demonstrate the effectiveness of our approach on several micro-benchmarks and on well-known distributed algorithms from the literature while comparing against ITAC, MPI-Checker and PSE, state-of-the-art tools.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712690", + "conference_name": "CC", + "authors": [ + { + "first_name": "Raneem", + "last_name": "Abu-Yosef", + "institution": "The Ohio State University" + }, + { + "first_name": "Martin", + "last_name": "Kong", + "institution": "The Ohio State University" + } + ], + "dblp_key": "conf/cc/YosefK25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712694", + "title": "Secure Scripting with CHERIoT MicroPython", + "abstract": "The lean MicroPython runtime is a widely adopted high level programming framework for embedded microcontroller systems. However, the existing MicroPython codebase has limited security features, rendering it a fundamentally insecure runtime environment. This is a critical problem, given the growing deployment of highly interconnected IoT systems on which society depends. Malicious actors seek to compromise such embedded infrastructure, using sophisticated attack vectors. We have implemented a novel variant of MicroPython, adding support for runtime security features provided in the CHERI RISC-V architecture as instantiated by the CHERIoT-RTOS system. Our new MicroPython port supports hardware-enabled spatial memory safety, mitigating a large set of common runtime memory attacks. We have also compartmentalized the MicroPython runtime, to prevent untrusted code from elevating its permissions and taking control of the entire system. We perform a multi-faceted evaluation of our work, involving a qualitative security-focused case study and a quantitative performance analysis. The case study explores the full set of five publicly reported MicroPython vulnerabilities (CVEs). We demonstrate that the enhanced security provided by CHERIoT MicroPython mitigate two heap buffer overflow CVEs. Our performance analysis shows a geometric mean runtime overhead of 48% for secure execution across a set of ten standard Python benchmarks, although we argue this is indicative of worst-case overhead on our prototype platform and a realistic deployment overhead would be significantly lower. This work opens up a new, secure-by-design approach to IoT application development.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712694", + "conference_name": "CC", + "authors": [ + { + "first_name": "Duncan", + "last_name": "Lowther", + "institution": "University of Glasgow" + }, + { + "first_name": "Dejice", + "last_name": "Jacob", + "institution": "University of Glasgow" + }, + { + "first_name": "Jacob", + "last_name": "Trevor", + "institution": "University of Glasgow" + }, + { + "first_name": "Jeremy", + "last_name": "Singer", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/cc/LowtherJTS25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712693", + "title": "Biotite: A High-Performance Static Binary Translator using Source-Level Information", + "abstract": "Research on novel Instruction Set Architectures (ISAs) is actively pursued; however, it requires extensive efforts to develop and maintain comprehensive compilation toolchains for each new ISA. Binary translation can provide a practical solution for ISA researchers to port target programs to novel ISAs when such a level of toolchain support is not available. However, to ensure the correct handling of indirect jumps, existing binary translators rely on complex runtime systems, whose implementation on primitive research ISAs demands significant efforts. ISA researchers generally have access to additional source-level information, including the symbol table and source code, when using binary translators. The symbol table can provide potential jump targets for optimizing indirect jumps, and ISA-independent functions in source code can be directly compiled without translation. Leveraging source-level information as additional input, in this paper, we propose Biotite, a high-performance static binary translator that correctly handles arbitrary indirect jumps. Currently, Biotite supports the translation of RV64GC Linux binaries to self-contained LLVM IR. Our evaluation shows that Biotite successfully translates all benchmarks in SPEC CPU 2017 and achieves a 2.346× performance improvement over QEMU for the integer benchmark suite.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712693", + "conference_name": "CC", + "authors": [ + { + "first_name": "C.", + "last_name": "Chen", + "institution": "The University of Tokyo" + }, + { + "first_name": "Shu", + "last_name": "Sugita", + "institution": "The University of Tokyo" + }, + { + "first_name": "Yuichiro", + "last_name": "Nada", + "institution": "The University of Tokyo" + }, + { + "first_name": "Hidetsugu", + "last_name": "Irie", + "institution": "The University of Tokyo" + }, + { + "first_name": "Shuichi", + "last_name": "Sakai", + "institution": "The University of Tokyo" + }, + { + "first_name": "Ryota", + "last_name": "Shioya", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/cc/ChenSNISS25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712692", + "title": "Post-Link Outlining for Code Size Reduction", + "abstract": "This paper introduces PLOS, a novel Post-Link Outlining approach designed to enhance code Size reduction for resource-constrained environments. Built on top of a post-link optimizer BOLT, PLOS maintains a holistic view of the whole-program structure and behavior, utilizing runtime information while preserving standard build system flows. The approach includes a granular outlining algorithm that matches and replaces repeated instruction sequences within/across modules and outlined functions, along with careful stack frame management to ensure correct function call handling. By integrating profiling information, PLOS balances the trade-off between code size and execution efficiency. The evaluation using eight MiBench benchmarks on an ARM-based Phytium FCT662 core demonstrates that PLOS achieves a mean code size reduction of 10.88% (up to 43.53%) and 6.61% (up to 14.78%) compared to LLVM’s and GCC's standard optimization, respectively, 1.76% (up to 4.75%) over LLVM’s aggressive code size reduction optimizations, and 2.88% (up to 8.56%) over a link-time outliner. The experimental results also show that PLOS can achieve a favorable balance between code size reduction and performance regression.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712692", + "conference_name": "CC", + "authors": [ + { + "first_name": "Shao", + "last_name": "Yuan", + "institution": "Hunan University" + }, + { + "first_name": "Jihong", + "last_name": "He", + "institution": "Hunan University" + }, + { + "first_name": "Yihui", + "last_name": "Xie", + "institution": "Hunan University" + }, + { + "first_name": "Feng", + "last_name": "Wang", + "institution": "Hunan University" + }, + { + "first_name": "Jie", + "last_name": "Zhao", + "institution": "Hunan University" + } + ], + "dblp_key": "conf/cc/YuanHXWZ25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712687", + "title": "DFA-Net: A Compiler-Specific Neural Architecture for Robust Generalization in Data Flow Analyses", + "abstract": "Data flow analysis is fundamental to modern program optimization and verification, serving as a critical foundation for compiler transformations. As machine learning increasingly drives compiler tasks, the need for models that can implicitly understand and correctly reason about data flow properties becomes crucial for maintaining soundness. State-of-the-art machine learning methods, especially graph neural networks (GNNs), face challenges in generalizing beyond training scenarios due to their limited ability to perform large propagations. We present DFA-Net, a neural network architecture tailored for compilers that systematically generalizes. It emulates the reasoning process of compilers, facilitating the generalization of data flow analyses from simple to complex programs. The architecture decomposes data flow analyses into specialized neural networks for initialization, transfer, and meet operations, explicitly incorporating compiler-specific knowledge into the model design. We evaluate DFA-Net on a data flow analysis benchmark from related work and demonstrate that our compiler-specific neural architecture can learn and systematically generalize on this task. DFA-Net demonstrates superior performance over traditional GNNs in data flow analysis, achieving F1 scores of 0.761 versus 0.009 for data dependencies and 0.989 versus 0.196 for dominators at high complexity levels, while maintaining perfect scores for liveness and reachability analyses where GNNs struggle significantly.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712687", + "conference_name": "CC", + "authors": [ + { + "first_name": "Alexander", + "last_name": "Brauckmann", + "institution": "University of Edinburgh" + }, + { + "first_name": "Anderson Faustino da", + "last_name": "Silva", + "institution": "Universidade Estadual de Maringá" + }, + { + "first_name": "Gabriel", + "last_name": "Synnaeve", + "institution": "" + }, + { + "first_name": "Michael", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jerónimo", + "last_name": "Castrillón", + "institution": "Technische Universität Dresden" + }, + { + "first_name": "Hugh", + "last_name": "Leather", + "institution": "Alpha Omega Alpha Medical Honor Society" + } + ], + "dblp_key": "conf/cc/BrauckmannSSOCL25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712695", + "title": "Compiler Support for Speculation in Decoupled Access/Execute Architectures", + "abstract": "Irregular codes are bottlenecked by memory and communication latency. Decoupled access/execute (DAE) is a common technique to tackle this problem. It relies on the compiler to separate memory address generation from the rest of the program, however, such a separation is not always possible due to control and data dependencies between the access and execute slices, resulting in a loss of decoupling. In this paper, we present compiler support for speculation in DAE architectures that preserves decoupling in the face of control dependencies. We speculate memory requests in the access slice and poison mis-speculations in the execute slice without the need for replays or synchronization. Our transformation works on arbitrary, reducible control flow and is proven to preserve sequential consistency. We show that our approach applies to a wide range of architectural work on CPU/GPU prefetchers, CGRAs, and accelerators, enabling DAE on a wider range of codes than before.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712695", + "conference_name": "CC", + "authors": [ + { + "first_name": "Robert", + "last_name": "Szafarczyk", + "institution": "University of Glasgow" + }, + { + "first_name": "Syed Waqar", + "last_name": "Nabi", + "institution": "University of Glasgow" + }, + { + "first_name": "Wim", + "last_name": "Vanderbauwhede", + "institution": "University of Glasgow" + } + ], + "dblp_key": "conf/cc/SzafarczykNV25", + "venue": "cc", + "year": 2025 + }, + { + "paper_id": "10.1145/3708493.3712684", + "title": "Overloading the Dot", + "abstract": "The dot is a highly valued piece of syntactic real estate. Programming languages use the dot for a range of programming constructs: In object-oriented languages, the dot is used for field and method access on classes and objects. In imperative languages, the dot is often used for field access on structs. In functional languages, the dot is often used for field access on records. And finally in some other languages, the dot is used to access the length of arrays and to index into tuples. The dot is minimal yet aesthetically pleasing. More importantly, the dot is the great enabler of auto-completion. Programmers with a specific entity in mind (e.g., an object, struct, or record) can use the dot to trigger auto-completion to be presented with a list of operations available on the entity. This simple feature improves the programming experience and makes it easier to learn new APIs. In this paper, we explore how to overload the dot to support various programming constructs within one language while supporting type inference. We present a principled approach to overloading based on type classes extended with associated types, associated effects, and compiler-generated type classes and instances. We implement the design in the Flix programming language and evaluate its impact on compiler performance and on the quality of error messages.", + "date": "2025-02-25", + "link": "https://doi.org/10.1145/3708493.3712684", + "conference_name": "CC", + "authors": [ + { + "first_name": "J. W. C.", + "last_name": "Tan", + "institution": "Stanford University" + }, + { + "first_name": "Magnus", + "last_name": "Madsen", + "institution": "Aarhus University" + } + ], + "dblp_key": "conf/cc/TanM25", + "venue": "cc", + "year": 2025 + } +] \ No newline at end of file diff --git a/data/pl_conferences/cc/2026.json b/data/pl_conferences/cc/2026.json new file mode 100644 index 0000000..3296b70 --- /dev/null +++ b/data/pl_conferences/cc/2026.json @@ -0,0 +1,583 @@ +[ + { + "paper_id": "10.1145/3771775.3786277", + "title": "It's about Time: Temporal Abstractions for Asynchronous GPU Tensor Computations", + "abstract": "The rise of asynchronous execution and specialized concurrent thread groups has reshaped GPU programming, but it also introduces complex timing and coordination challenges. Developers must carefully manage data readiness, concurrency, and hardware-specific tensor units that current low-level primitives make error-prone and hardware-dependent.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786277", + "conference_name": "CC", + "authors": [ + { + "first_name": "Bastian", + "last_name": "Hagedorn", + "institution": "" + }, + { + "first_name": "Vinod K.", + "last_name": "Grover", + "institution": "Nvidia (United States)" + } + ], + "dblp_key": "conf/cc/HagedornG26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786273", + "title": "Nsight Python: A Python-First Profiling Toolkit for Seamless GPU Kernel Analysis (Tool)", + "abstract": "The proliferation of Python DSLs for developing kernels has democratized GPU programming. While kernel development is now Python-native, performance analysis and optimization still rely on external tools and fragmented workflows.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786273", + "conference_name": "CC", + "authors": [ + { + "first_name": "Bastian", + "last_name": "Hagedorn", + "institution": "" + }, + { + "first_name": "Alexander J.", + "last_name": "Collins", + "institution": "Nvidia (United Kingdom)" + }, + { + "first_name": "Tony", + "last_name": "Mongkolsmai", + "institution": "Nvidia (United Kingdom)" + }, + { + "first_name": "Vinod K.", + "last_name": "Grover", + "institution": "Nvidia (United States)" + } + ], + "dblp_key": "conf/cc/HagedornCMG26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786274", + "title": "RIFS: Run-Time Invariant Function Specialization", + "abstract": "Compilers apply optimizations such as function specialization and constant propagation to eliminate redundant work at compile time. However, because compilers must prove that values are constant, many profitable optimization opportunities remain unrealized. In this paper, we propose run-time invariant function specialization (RIFS), a profile-guided compiler technique that specializes functions based on runtime invariant call-site-specific argument values. RIFS introduces a novel value-profiling LLVM pass to identify runtime invariant arguments, even though they cannot be proven constant statically. A subsequent LLVM transformation pass generates specialized function variants tailored to these value profiles. To efficiently select among potentially thousands of specialization candidates, we develop a predictive cost model that estimates the performance benefit of each candidate prior to code generation. We integrate our passes seamlessly into the existing PGO-enabled LLVM toolchain. We evaluate RIFS across 11 real-world applications, demonstrating substantial improvements over state-of-the-art optimization techniques. RIFS achieves an average speedup of 6.3% and an instruction reduction of 2.5% over the LLVM -O3+PGO baseline.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786274", + "conference_name": "CC", + "authors": [ + { + "first_name": "Saba", + "last_name": "Jamilan", + "institution": "University of California, Santa Cruz" + }, + { + "first_name": "Snehasish", + "last_name": "Kumar", + "institution": "Google (United States)" + }, + { + "first_name": "Heiner", + "last_name": "Litz", + "institution": "University of California, Santa Cruz" + } + ], + "dblp_key": "conf/cc/JamilanKL26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786278", + "title": "TinyGen: Portable and Compact Code Generation for Tiny Machine Learning", + "abstract": "Tiny machine learning (TinyML) enables low-power microcontrollers to leverage the power of artificial intelligence without relying on remote computing resources. Typically, developing a TinyML application relies primarily on existing TinyML frameworks, which provide runtime APIs for loading and executing machine learning models. However, such framework-based TinyML development has limitations in terms of portability, programmability, and resource efficiency, motivating the need for a new approach to the TinyML development and deployment process.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786278", + "conference_name": "CC", + "authors": [ + { + "first_name": "Gaeun", + "last_name": "Ko", + "institution": "Kyung Hee University" + }, + { + "first_name": "Seonyeong", + "last_name": "Heo", + "institution": "Kyung Hee University" + } + ], + "dblp_key": "conf/cc/KoH26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786266", + "title": "Parallel and Customizable Equality Saturation", + "abstract": "Equality saturation enables compilers to explore many semantically equivalent program variants, deferring optimization decisions to a final extraction phase. However, existing frameworks exhibit sequential execution and hard-coded saturation loops. This limits scalability and requires significant engineering effort to customize saturation behavior.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786266", + "conference_name": "CC", + "authors": [ + { + "first_name": "Jonathan Van der", + "last_name": "Cruysse", + "institution": "McGill University" + }, + { + "first_name": "Abd-El-Aziz", + "last_name": "Zayed", + "institution": "McGill University" + }, + { + "first_name": "Mai Jacob", + "last_name": "Peng", + "institution": "McGill University" + }, + { + "first_name": "Christophe", + "last_name": "Dubach", + "institution": "McGill University" + } + ], + "dblp_key": "conf/cc/CruysseZPD26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786268", + "title": "Type Deduction Analysis: Reconstructing Transparent Pointer Types in LLVM-IR", + "abstract": "With version 17, LLVM finalized the transition to opaque pointer types, eliminating explicit pointee‑type information from the Intermediate Representation (IR). Thus, starting from LLVM 17, each pointer type is represented in IR by the unique type ptr. Despite eliminating redundant pointer bitcasts and consequently reducing IR size and compile time, this change disrupts analyses that have reason to rely on pointee-type information, forcing existing compiler projects to depend on outdated LLVM versions. This information can in fact be insightful in fields like approximate computing, where the compiler can apply non-conservative optimizations, or in passes that require it to make analyses and transformations that do not impact the correctness of the program. To address this problem, we present a new Type Deduction Analysis pass that reconstructs transparent pointer types directly from opaque‑pointer IR. Moreover, we illustrate two different case-studies on existing LLVM projects, namely TAFFO and ASPIS, that demonstrate the need for pointee-type information in LLVM compilers.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786268", + "conference_name": "CC", + "authors": [ + { + "first_name": "Niccolò", + "last_name": "Nicolosi", + "institution": "Politecnico di Milano" + }, + { + "first_name": "Gabriele", + "last_name": "Magnani", + "institution": "Politecnico di Milano" + }, + { + "first_name": "Emilio", + "last_name": "Corigliano", + "institution": "Politecnico di Milano" + }, + { + "first_name": "Davide", + "last_name": "Baroffio", + "institution": "Politecnico di Milano" + }, + { + "first_name": "Federico", + "last_name": "Reghenzani", + "institution": "Politecnico di Milano" + }, + { + "first_name": "Giovanni", + "last_name": "Agosta", + "institution": "Politecnico di Milano" + } + ], + "dblp_key": "conf/cc/NicolosiMCBRA26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786270", + "title": "HORIZON: Estimating Alias Analysis Precision Bounds and Their Impact on Performance", + "abstract": "Alias analysis is a technique to identify whether a memory location can be accessed in more than one way. An ideal alias analysis implementation should be both precise and scalable. However, in practice, implementations of alias analysis have to make a trade-off between precision and scalability. The alias analysis implementations that perform inter-procedural analysis are more precise (answer a higher number of alias queries with certainty), but expensive, making them infeasible for practical use. Most compiler developers opt for intra-procedural analysis over inter-procedural, thereby compromising the precision of alias analysis implementations to achieve scalability. For compilers, this compromise leads to a loss in optimization opportunities, limiting the performance achievable by the compiled program.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786270", + "conference_name": "CC", + "authors": [ + { + "first_name": "Khushboo", + "last_name": "Chitre", + "institution": "Indraprastha Institute of Information Technology Delhi" + }, + { + "first_name": "Piyus", + "last_name": "Kedia", + "institution": "Indraprastha Institute of Information Technology Delhi" + }, + { + "first_name": "Rahul", + "last_name": "Purandare", + "institution": "University of Nebraska–Lincoln" + } + ], + "dblp_key": "conf/cc/ChitreKP26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786282", + "title": "Schedgehammer: Auto-tuning Compiler Optimizations beyond Numerical Parameters", + "abstract": "This paper introduces Schedgehammer, a general-purpose auto-scheduling framework that optimizes program execution across diverse compiler infrastructures. Unlike existing auto-schedulers that are tightly coupled to specific intermediate representations or rely on template-based search, Schedgehammer provides a generic, reusable framework for optimization schedules by modeling them as graph-structured objects. This approach captures dependencies among transformations and parameters across compilers, enabling systematic mutation and validation.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786282", + "conference_name": "CC", + "authors": [ + { + "first_name": "Johannes", + "last_name": "Lenfers", + "institution": "University of Münster" + }, + { + "first_name": "Sven", + "last_name": "Spehr", + "institution": "University of Münster" + }, + { + "first_name": "Justus", + "last_name": "Dieckmann", + "institution": "University of Münster" + }, + { + "first_name": "Johannes R.", + "last_name": "Jansen", + "institution": "University of Münster" + }, + { + "first_name": "Martin Paul", + "last_name": "Lücke", + "institution": "University of Münster" + }, + { + "first_name": "Sergei", + "last_name": "Gorlatch", + "institution": "University of Münster" + } + ], + "dblp_key": "conf/cc/LenfersSDJLG26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786269", + "title": "CHEHAB: Automatic Compiler Code Optimization for Fully Homomorphic Encryption", + "abstract": "Fully Homomorphic Encryption (FHE) enables computations to be performed directly on encrypted data without requiring decryption, providing strong privacy guarantees. However, FHE remains computationally expensive, and writing efficient FHE programs is a complex, error-prone, and time-consuming task that demands significant cryptographic expertise. Programmers are often unaware of available optimizations, and applying them manually requires substantial effort. In this paper, we present CHEHAB, a compiler that automatically vectorizes scalar code, optimizes it, and generates highly efficient FHE programs. CHEHAB supports both structured and unstructured code and takes as input programs written in a domain-specific language embedded in C++. It relies on a Term Rewriting System (TRS) based on equality saturation to simplify and transform programs. CHEHAB targets two key challenges in FHE compilation: (1) automatic vectorization of scalar code, and (2) reduction of instruction execution latency and ciphertext noise growth. By leveraging equality saturation, CHEHAB explores a large optimization space to reduce instruction count and circuit depth while improving vector utilization. Experimental evaluation on a set of representative kernels shows that CHEHAB outperforms Coyote, a state-of-the-art vectorizing compiler for FHE. On average, CHEHAB generates code that is 7.38× faster at runtime, incurs 2.49× less accumulated noise, and achieves 251× faster compilation time. CHEHAB is released as an open-source compiler to support reproducibility and further research in FHE compilation.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786269", + "conference_name": "CC", + "authors": [ + { + "first_name": "Abdessamed", + "last_name": "Seddiki", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Arab", + "last_name": "Mohammed", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Zakaria", + "last_name": "Hebbal", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Aimad", + "last_name": "Chabounia", + "institution": "École Nationale Supérieure d'Informatique" + }, + { + "first_name": "Eduardo", + "last_name": "Chielle", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Karima", + "last_name": "Benatchba", + "institution": "École Nationale Supérieure d'Informatique" + }, + { + "first_name": "Challal", + "last_name": "Yacine", + "institution": "Qatar Science and Technology Park" + }, + { + "first_name": "Djamel Eddine", + "last_name": "Menacer", + "institution": "École Nationale Supérieure d'Informatique" + }, + { + "first_name": "Michail", + "last_name": "Maniatakos", + "institution": "New York University Abu Dhabi" + }, + { + "first_name": "Riyadh", + "last_name": "Baghdadi", + "institution": "New York University Abu Dhabi" + } + ], + "dblp_key": "conf/cc/SeddikiMHCCBYMM26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786267", + "title": "Optimizing Sparse Tensor Compilation for Sparse Output", + "abstract": "Sparse tensor algebra plays an important role in many scientific and engineering applications, yet existing sparse libraries and compilers face challenges when the output tensor is sparse. Array-based storage formats, such as CSR, require costly memory reallocations and rely on intermediate tensors (workspaces) to handle sparse scattering into the output, which limits performance and scalability. We introduce a new approach that employs our proposed flexible map-based storage format to directly support sparse scattering into the output without requiring extra workspaces. Our system then applies code and storage-specific optimizations to maximize efficiency. Experimental results across a range of kernels and datasets demonstrate an average speedup of 8.06× over a state-of-the-art compiler and 5.28× over a sparse tensor library.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786267", + "conference_name": "CC", + "authors": [ + { + "first_name": "Shideh", + "last_name": "Hashemian", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael F. P.", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + }, + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/HashemianOS26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786281", + "title": "Accelerating Sparse Algebra with Program Synthesis", + "abstract": "Linear algebra libraries and tensor domain-specific languages are able to deliver high performance for modern scientific and machine learning workloads. While there has been recent work in automatically translating legacy software to use these libraries/DSLs using pattern matching and program lifting, this has been largely limited to dense linear algebra.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786281", + "conference_name": "CC", + "authors": [ + { + "first_name": "José Wesley de Souza", + "last_name": "Magalhães", + "institution": "University of Edinburgh" + }, + { + "first_name": "Shideh", + "last_name": "Hashemian", + "institution": "University of Edinburgh" + }, + { + "first_name": "Alexander", + "last_name": "Brauckmann", + "institution": "University of Edinburgh" + }, + { + "first_name": "Jackson", + "last_name": "Woodruff", + "institution": "University of Edinburgh" + }, + { + "first_name": "Elizabeth", + "last_name": "Polgreen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Michael F. P.", + "last_name": "O’Boyle", + "institution": "University of Edinburgh" + } + ], + "dblp_key": "conf/cc/MagalhaesHBWPO26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786271", + "title": "CPerfSmith: A Randomized C Program Generator for Performance-Oriented Compiler Testing", + "abstract": "Software testing is a critical stage in the software development lifecycle, ensuring that programs behave correctly and reliably across diverse environments. Unlike general software testing, compiler testing requires well-structured input programs that systematically exercise the compiler’s various optimization passes, since incomplete coverage can easily mask critical issues. Currently, a range of techniques exists for compiler testing, including differential testing, fuzzing, slicing, sanitizers and formal methods based validation tools, While these methods are effective at detecting compiler crashes, undefined behavior, or general correctness bugs, they are largely inadequate for systematically evaluating compiler optimizations. Tools like Csmith have pioneered random program generation for compiler testing, but they lack precise control over program structure, which is critical when the goal is to stress specific optimization passes or identify performance regressions. To address this limitation, we developed CPerf- Smith, an extension of Csmith that provides fine-grained control over code constructs, enabling targeted generation of programs that exercise particular compiler optimizations. Through our experiments, CPerfSmith was able to generate over 100 programs exhibiting significant runtime differences across industry-standard C compilers (GCC, Clang, and AOCC). Furthermore, we successfully created more than 30 test cases that revealed significant performance regressions between two subsequent release versions of Clang, demonstrating the tool’s ability to detect missing or improperly applied optimizations.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786271", + "conference_name": "CC", + "authors": [ + { + "first_name": "Yashwanth", + "last_name": "Boda", + "institution": "Indian Institute of Technology Roorkee" + }, + { + "first_name": "Abhijit", + "last_name": "Chunduri", + "institution": "Indian Institute of Technology Roorkee" + }, + { + "first_name": "Ruchi", + "last_name": "Kumari", + "institution": "Indian Institute of Technology Roorkee" + }, + { + "first_name": "Awanish", + "last_name": "Pandey", + "institution": "Indian Institute of Technology Roorkee" + } + ], + "dblp_key": "conf/cc/BodaCKP26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786272", + "title": "SSMR: Statically Detecting Speculation Safe Memory Regions to Mitigate Transient Execution Attacks", + "abstract": "Transient execution attacks exploit speculative execution to leak confidential data through unauthorized transient memory accesses. We make the observation that transient attacks can be identified by one unusual memory access, the transient sensitive data access. To protect systems from such attacks while minimizing performance overhead, we propose leveraging compile-time information to identify memory operations that cannot extract sensitive data and can therefore be deemed safe. Safe memory operations are allowed to execute transiently, causing no extra performance cost. Unsafe memory operations delay accessing the memory system until they are no longer in a speculative state, preventing unauthorized transient accesses to sensitive data. To communicate this information to the microarchitecture, we introduce the set safe memory region (ssmr) instruction. Inserted automatically by the compiler, it establishes the memory regions that may be accessed transiently by a sequence of instructions. This defense incurs only a 7% performance overhead compared to the insecure baseline and mitigates at least two variants of transient execution attacks.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786272", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ange-Thierry", + "last_name": "Ishimwe", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Sam", + "last_name": "McDiarmid-Sterling", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Zack", + "last_name": "McKevitt", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Tamara Silbergleit", + "last_name": "Lehman", + "institution": "University of Colorado Boulder" + } + ], + "dblp_key": "conf/cc/IshimweMML26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786276", + "title": "GraalMHC: ML-Based Method-Hotness Classification for Binary-Size Reduction in Optimizing Compilers", + "abstract": "Optimizing compilers often sacrifice binary size in pursuit of higher run-time performance. In the absence of method execution profiles, they uniformly apply performance-oriented optimizations, typically various forms of code duplication. Duplications in methods that are rarely or never executed only increase binary size without improving performance. Modern static profiler use ML to predict branch profiles, yet they do not identify which methods will be frequently executed at run time. Doing so would enable more selective optimizations, reducing binary size while preserving or only minimally affecting run-time performance.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786276", + "conference_name": "CC", + "authors": [ + { + "first_name": "Milan", + "last_name": "Čugurović", + "institution": "University of Belgrade" + }, + { + "first_name": "Aleksandar", + "last_name": "Prokopec", + "institution": "" + }, + { + "first_name": "Boris", + "last_name": "Spasojevic", + "institution": "" + }, + { + "first_name": "Vojin", + "last_name": "Jovanović", + "institution": "" + }, + { + "first_name": "Milena Vujošević", + "last_name": "Janičić", + "institution": "University of Belgrade" + } + ], + "dblp_key": "conf/cc/CugurovicPSJV26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786275", + "title": "Inside VOLT: Designing an Open-Source GPU Compiler (Tool)", + "abstract": "Recent efforts in open-source GPU research are opening new avenues in a domain that has long been tightly coupled with a few commercial vendors. Emerging open GPU architectures define SIMT functionality through their own ISAs, but executing existing GPU programs and optimizing performance on these ISAs relies on a compiler framework that is technically complex and often undercounted in open-hardware development costs.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786275", + "conference_name": "CC", + "authors": [ + { + "first_name": "Shinnung", + "last_name": "Jeong", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Chihyo", + "last_name": "Ahn", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Huanzhi", + "last_name": "Pu", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Jisheng", + "last_name": "Zhao", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Hyesoon", + "last_name": "Kim", + "institution": "Georgia Institute of Technology" + }, + { + "first_name": "Blaise", + "last_name": "Tine", + "institution": "University of California, Los Angeles" + } + ], + "dblp_key": "conf/cc/JeongAPZKT26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786280", + "title": "Compact Representation and Interleaved Solving for Scalable Constraint-Based Points-to Analysis", + "abstract": "Constraint-based points-to analysis using Andersen-style inclusion constraints is widely used for its convenience, generality, and precision in modeling complex program behaviors. Typically, such analyses generate constraints and resolve them by computing the transitive closure of a constraint graph. However, traditional constraint modeling often introduces redundancy during constraint generation, solving, or both. In the context of points-to analysis for object-oriented languages like Java, this redundancy primarily stems from the modeling of virtual calls and heap operations. As a result, the analysis produces redundant constraints and inflated constraint graphs, thereby increasing analysis time.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786280", + "conference_name": "CC", + "authors": [ + { + "first_name": "Ramya", + "last_name": "Kasaraneni", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "conf/cc/KasaraneniN26", + "venue": "cc", + "year": 2026 + }, + { + "paper_id": "10.1145/3771775.3786279", + "title": "Practical MHP Analysis for Java", + "abstract": "May happen in Parallel (MHP) analysis is one of the most foundational analysis in the context of programs written in parallel languages like Java. The currently known techniques for doing MHP analysis of Java applications suffer from two main challenges: (i) scalability to real-world large applications, (ii) precision in the presence of complex programs. In this manuscript, we address these two issues with a goal of making MHP analysis for Java applications a practical option. We propose a new MHP analysis scheme called GRIP-MHP. It includes techniques to reduce time taken to perform MHP analysis significantly; it does so by using novel schemes to reduce the size of the input graph (representing the original application). GRIP-MHP also addresses many drawbacks in existing techniques, thereby improving the applicability and precision of MHP analysis for real-world Java applications. We implemented GRIP-MHP in the Soot compiler framework. Our experiments show that GRIP-MHP runs successfully in reasonable time on all the tested benchmarks in DaCapo and Renaissance (geomean 20.176×improvement, over prior work). We find that GRIP-MHP performs more precise joining of threads significant leading to improvements in precision of the analysis results: geomean, 1.85×reduction in MHP pairs, over prior work.", + "date": "2026-01-28", + "link": "https://doi.org/10.1145/3771775.3786279", + "conference_name": "CC", + "authors": [ + { + "first_name": "A. Samuel", + "last_name": "Moses", + "institution": "Indian Institute of Technology Madras" + }, + { + "first_name": "V. Krishna", + "last_name": "Nandivada", + "institution": "Indian Institute of Technology Madras" + } + ], + "dblp_key": "conf/cc/MosesN26", + "venue": "cc", + "year": 2026 + } +] \ No newline at end of file From e42015e4a3e5d693e40065456d0e64d9e50a2942 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:12:41 +0200 Subject: [PATCH 21/34] fix: clamp OpenAlex Retry-After to a reasonable cap OpenAlex's daily quota 429 returns Retry-After = remaining seconds in the day, which can be 7+ hours. Honoring that literally wedges the bulk harvester. Cap the requested wait at max(backoff, 60s) so we burn at most the normal backoff budget before giving up on a DOI and moving on. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index 32e7973..f47286f 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -379,7 +379,18 @@ def _request_with_retries( continue if resp.status_code in (429, 500, 502, 503, 504) and attempt < max_attempts: retry_after = resp.headers.get("Retry-After") - wait = float(retry_after) if retry_after else backoff + # OpenAlex's quota-exhaustion 429 sends Retry-After = remaining + # seconds in the day (often 7+ hours). That's not a useful wait + # for an interactive harvest run; clamp to ``backoff`` so we + # fail fast on the second attempt and let the caller move on. + if retry_after: + try: + requested = float(retry_after) + except ValueError: + requested = backoff + wait = min(requested, max(backoff, 60.0)) + else: + wait = backoff logger.warning( "Request to %s returned %s; retry %d/%d in %.1fs", target, From 1a859f137d36ec3343e6a72adf2e0d074395f7e8 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:13:57 +0200 Subject: [PATCH 22/34] fix: cap OpenAlex retries at 2 attempts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit OpenAlex's daily quota 429 returns Retry-After of multiple hours. Even with the wait clamped, six retries-per-paper × dozens of papers-per-year stalls bulk harvesting. Drop to 2 attempts: try once, give up, and fall through to Semantic Scholar. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index f47286f..27fc221 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -789,9 +789,18 @@ def _fetch_openalex(self, doi: str) -> dict[str, Any] | None: url = f"https://api.openalex.org/works/https://doi.org/{doi}" params = {"mailto": _OPENALEX_MAILTO} + # Tight retry budget: when OpenAlex's daily quota is exhausted it + # 429s for hours. Burning the full backoff window per paper + # multiplies a 30-min residual quota outage into days of stalled + # harvesting. Try twice; on persistent 429 fall through to + # Semantic Scholar. try: resp = _request_with_retries( - self._thread_session(), url, params=params, timeout=30 + self._thread_session(), + url, + params=params, + timeout=30, + max_attempts=2, ) except requests.RequestException as exc: logger.warning("OpenAlex request failed for %s: %s", doi, exc) From 031b158c991f338d1575679927cfcd5573187b8a Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:20:29 +0200 Subject: [PATCH 23/34] feat: ingest Haskell Symposium back-catalogue (2000-2009, partial) 7 of 25 indexed years yielded papers. Haskell papers are ACM SIGPLAN with DOIs in the 10.1145 range; OpenAlex usually has the abstracts. The bulk run for 2010-2025 hit OpenAlex's 10k/day quota (daily reset at UTC midnight) and could not be completed within this session. Resume after quota refresh; the ESOP/ECOOP/CC caches are warm so they won't re-cost OpenAlex calls. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/haskell/2000.json | 253 ++++++++++++++++++++ data/pl_conferences/haskell/2002.json | 204 +++++++++++++++++ data/pl_conferences/haskell/2003.json | 240 +++++++++++++++++++ data/pl_conferences/haskell/2004.json | 318 ++++++++++++++++++++++++++ data/pl_conferences/haskell/2005.json | 63 +++++ data/pl_conferences/haskell/2006.json | 25 ++ data/pl_conferences/haskell/2009.json | 40 ++++ 7 files changed, 1143 insertions(+) create mode 100644 data/pl_conferences/haskell/2000.json create mode 100644 data/pl_conferences/haskell/2002.json create mode 100644 data/pl_conferences/haskell/2003.json create mode 100644 data/pl_conferences/haskell/2004.json create mode 100644 data/pl_conferences/haskell/2005.json create mode 100644 data/pl_conferences/haskell/2006.json create mode 100644 data/pl_conferences/haskell/2009.json diff --git a/data/pl_conferences/haskell/2000.json b/data/pl_conferences/haskell/2000.json new file mode 100644 index 0000000..b5cc37c --- /dev/null +++ b/data/pl_conferences/haskell/2000.json @@ -0,0 +1,253 @@ +[ + { + "paper_id": "10.1016/S1571-0661(05)80542-0", + "title": "Derivable Type Classes", + "abstract": "Generic programming allows you to write a function once, and use it many times at different types. A lot of good foundational work on generic programming has been done. The goal of this paper is to propose a practical way of supporting generic programming within the Haskell language, without radically changing the language or its type system. The key idea is to present generic programming as a richer language in which to write default method definitions in a class declaration. On the way, we came across a separate issue, concerning type-class overloading where higher kinds are involved. We propose a simple type-class system extension to allow the programmer to write richer contexts than is currently possible.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80542-0", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Bonn" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "journals/entcs/HinzeJ00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80543-2", + "title": "A Space Semantics for Core Haskell", + "abstract": "Haskell currently lacks a standard operational semantics. We argue that such a semantics should be provided to enable reasoning about operational properties of programs, to ensure that implementations guarantee certain space and time behaviour and to help determine the source of space faults. We present a small-step deterministic semantics for the sequential evaluation of Core Haskell programs and show that it is an accurate model of asymptotic space and time usage. The semantics is a formalisation of a graphical notation so it provides a useful mental model as well as a precise mathematical notation. We discuss its implications for education, programming and implementation. The basic semantics is extended with a monadic IO mechanism so that all the space under the control of an implementation is included.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80543-2", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Adam", + "last_name": "Bakewell", + "institution": "" + }, + { + "first_name": "Runciman", + "last_name": "Colin", + "institution": "" + } + ], + "dblp_key": "journals/entcs/BakewellR00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80541-9", + "title": "Data Field Haskell", + "abstract": "Data fields provide a flexible and highly general model for indexed collections of data. Data Field Haskell is a Haskell dialect that provides an instance of data fields. It can be used for very generic collection-oriented programming, with a special emphasis on multidimensional structures. We give a brief description of the data field model and its underlying theory. We then describe Data Field Haskell, and an implementation.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80541-9", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Jonas", + "last_name": "Holmerin", + "institution": "" + }, + { + "first_name": "Björn", + "last_name": "Lisper", + "institution": "" + } + ], + "dblp_key": "journals/entcs/HolmerinL00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80539-0", + "title": "Preface", + "abstract": "This volume contains the proceedings of the 2000 ACM SIGPLAN Haskell Workshop, which was held on 17th September 2000 in Montreal, Canada. The Haskell Workshop was sponsored by ACM SIGPLAN and formed part of the PLI 2000 colloquium on Principles, Logics, and Implementations of high-level programming languages, which comprised the ICFP/PPDP conferences and associated workshops. Previous Haskell Workshops have been held in La Jolla (1995), Amsterdam (1997), and Paris (1999). The purpose of the Haskell Workshop was to discuss experience with Haskell, and possible future developments for the language. The scope of the workshop included all aspects of the design, semantics, theory, application, implementation, and teaching of Haskell. Submissions that discussed limitations of Haskell at present and/or proposed new ideas for future versions of Haskell were particularly encouraged. A total of 22 submissions were received, from which 11 were selected for presentation. I would like to thank the programme committee and the additional referees for all of their efforts in reviewing the submissions. Graham Hutton University of Nottingham Programme Committee: Richard Bird University of Oxford Andy Gill Oregon Graduate Institute Ralf Hinze University of Bonn Paul Hudak Yale University Graham Hutton (chair) University of Nottingham Erik Meijer University of Utrecht Chris Okasaki Columbia University Tim Sheard Oregon Graduate Institute", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80539-0", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Graham", + "last_name": "Hutton", + "institution": "" + } + ], + "dblp_key": "journals/entcs/Hutton00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80538-9", + "title": "Debugging Haskell by Observing Intermediate Data Structures", + "abstract": "Haskell has long needed a debugger. Although there has been much research into the topic of debugging lazy functional programs, no robust tool has yet come from the Haskell community that can help debug full Haskell. This paper describes a portable debugger for full Haskell, building only on commonly implemented extensions. It is based on the concept of observation of intermediate data structures, rather than the more traditional stepping and variable examination paradigm used by traditional imperative debuggers.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80538-9", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Gill", + "last_name": "Andy", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "journals/entcs/Gill00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80540-7", + "title": "Pattern Guards and Transformational Patterns", + "abstract": "We propose three extensions to patterns and pattern matching in Haskell. The rst, pattern guards, allows the guards of a guarded equation to match patterns and bind variables, as well as to test boolean condition. For this we introduce a natural generalisation of guard expressions to guard quali ers. A frequently-occurring special case is that a function should be applied to a matched value, and the result of this is to be matched against another pattern. For this we introduce a syntactic abbreviation, transformational patterns, that is particularly useful when dealing with views. These proposals can be implemented with very modest syntactic and implementation cost. They are upward compatible with Haskell; all existing programs will continue to work. We also oer a third, much more speculative proposal, which provides the transformational-pattern construct with additional power to explicitly catch pattern match failure. We demonstrate the usefulness of the proposed extension by sev...", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80540-7", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Martin", + "last_name": "Erwig", + "institution": "" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "" + } + ], + "dblp_key": "journals/entcs/ErwigJ00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80545-6", + "title": "Combinator Parsers - From Toys to Tools", + "abstract": "We develop, in a stepwise fashion, a set of parser combinators for constructing deterministic, error-correcting parsers. The only restriction on the grammar is that it is not left recursive. Extensive use is made of lazy evaluation, and the parsers constructed “analyze themselves”. Our new combinators may be used for the construction of large parsers to be used in compilers in practical use.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80545-6", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "S. Doaitse", + "last_name": "Swierstra", + "institution": "Utrecht University" + } + ], + "dblp_key": "journals/entcs/Swierstra00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80547-X", + "title": "Haskell Server Pages - Functional Programming and the Battle for the Middle Tier", + "abstract": "Haskell Server (HSP) provide an easy way to create dynamic web and simplify the task of building middle tier components. This article gives an overview of HSP from a programmer's perspective. It includes examples of HSP in action and gives a precise description of translating HSP scripts into plain Haskell.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80547-X", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "" + }, + { + "first_name": "Danny van", + "last_name": "Velzen", + "institution": "" + } + ], + "dblp_key": "journals/entcs/MeijerV00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80544-4", + "title": "Typed Logical Variables in Haskell", + "abstract": "We describe how to embed a simple typed functional logic programming language in Haskell. The embedding is a natural extension of the Prolog embedding by Seres and Spivey [16]. To get full static typing we need to use the Haskell extensions of quantified types and the ST-monad.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80544-4", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "C.", + "last_name": "Koen", + "institution": "" + }, + { + "first_name": "Peter", + "last_name": "Ljunglöf", + "institution": "" + } + ], + "dblp_key": "journals/entcs/ClaessenL00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80546-8", + "title": "An Overview of Edison", + "abstract": "Edison is a library of functional data structures implemented in Haskell. It supports three main families of abstractions: sequences, collections (e.g., sets and priority queues), and associative collections (e.g., finite maps). This paper summarizes the design of Edison, with particular attention to how that design is influenced by details of Haskell.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80546-8", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Chris", + "last_name": "Okasaki", + "institution": "Columbia University" + } + ], + "dblp_key": "journals/entcs/Okasaki00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80549-3", + "title": "Lambada, Haskell as a Better Java", + "abstract": "The Lambada framework provides facilities for uid interoperation between Haskell (currently both Hugs and GHC using non-Haskell98 extensions) and Java. Using Lambada, we can call Java methods from Haskell, and have Java methods invoke Haskell functions. The framework rests on the Java Native Interface (JNI). The Lambada release includes a tool for generating IDL from Java .class les (using re- ection), which is fed into our existing HDirect to generate Haskell-callable stubs. 1 Introduction It goes without saying that the ability to interact with other languages is of vital importance for the long-term survival of any programming language, in particular for niche languages such as Haskell or ML. Java is an interesting partner for interoperation for a number of reasons: Java comes with an large set of stable, and usually welldocumented and well-designed libraries and APIs. The interaction with Java via the Java Native Interface (JNI) [8, 4] eectively allows us to script the ...", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80549-3", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Erik", + "last_name": "Meijer", + "institution": "" + }, + { + "first_name": "Sigbjørn", + "last_name": "Finne", + "institution": "" + } + ], + "dblp_key": "journals/entcs/MeijerF00", + "venue": "haskell", + "year": 2000 + }, + { + "paper_id": "10.1016/S1571-0661(05)80548-1", + "title": "Developing High-Performance Server Applications in Haskell - Case Study: A Haskell Web Server", + "abstract": "Server applications, and in particular network-based server applications, place a unique combination of demands on a programming language: lightweight concurrency and high I/O throughput are both important. This paper describes a prototype web server written in Concurrent Haskell, and presents two useful results: firstly, a conforming server could be written with minimal effort, leading to an implementation in less than 1500 lines of code, and secondly the naive implementation produced reasonable performance. Furthermore, making minor modifications to a few time-critical components improved performance to a level acceptable for anything but the most heavily loaded web servers.", + "date": "2001-08-01", + "link": "https://doi.org/10.1016/S1571-0661(05)80548-1", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "journals/entcs/Marlow00", + "venue": "haskell", + "year": 2000 + } +] \ No newline at end of file diff --git a/data/pl_conferences/haskell/2002.json b/data/pl_conferences/haskell/2002.json new file mode 100644 index 0000000..86742da --- /dev/null +++ b/data/pl_conferences/haskell/2002.json @@ -0,0 +1,204 @@ +[ + { + "paper_id": "10.1145/581690.581693", + "title": "A recursive do for Haskell", + "abstract": "Certain programs making use of monads need to perform recursion over the values of monadic actions. Although the do-notation of Haskell provides a convenient framework for monadic programming, it lacks the generality to support such recursive bindings. In this paper, we describe an enhanced translation schema for the donotation and its integration into Haskell. The new translation allows variables to be bound recursively, provided the underlying monad comes equipped with an appropriate fixed-point operator.", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581693", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Levent", + "last_name": "Erkök", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "John", + "last_name": "Launchbury", + "institution": "Ola Grimsby Institute" + } + ], + "dblp_key": "conf/haskell/ErkokL02", + "venue": "haskell", + "year": 2002 + }, + { + "paper_id": "10.1145/581690.581691", + "title": "Template meta-programming for Haskell", + "abstract": "We propose a new extension to the purely functional programming language Haskell that supports compile-time meta-programming. The purpose of the system is to support the algorithmic construction of programs at compile-time. The ability to generate code at compile time allows the programmer to implement such features as polytypic programs, macro-like expansion, user directed optimization (such as inlining), and the generation of supporting data structures and functions from existing data structures and functions. Our design is being implemented in the Glasgow Haskell Compiler, ghc. 1", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581691", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Tim", + "last_name": "Sheard", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/haskell/SheardJ02", + "venue": "haskell", + "year": 2002 + }, + { + "paper_id": "10.1145/581690.581692", + "title": "A formal specification of the Haskell 98 module system", + "abstract": "Many programming languages provide means to split large programs into smaller modules. The module system of a language specifies what constitutes a module and how modules interact.This paper presents a formal specification of the module system for the functional programming language Haskell. Although many aspects of Haskell have been subjected to formal analysis, the module system has, to date, been described only informally as part of the Haskell language report. As a result, some aspects of it are not well understood or are under-specified; this causes difficulties in reasoning about Haskell programs, and leads to practical problems such as inconsistencies between different implementations. One significant aspect of our work is that the specification is written in Haskell, which means that it can also be used as an executable test-bed, and as a starting point for Haskell implementers.", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581692", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Iavor S.", + "last_name": "Diatchki", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Oregon Health & Science University" + }, + { + "first_name": "Thomas", + "last_name": "Hallgren", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "conf/haskell/DiatchkiJH02", + "venue": "haskell", + "year": 2002 + }, + { + "paper_id": "10.1145/581690.581698", + "title": "A lightweight implementation of generics and dynamics", + "abstract": "The recent years have seen a number of proposals for extending statically typed languages by dynamics or generics. Most proposals --- if not all --- require significant extensions to the underlying language. In this paper we show that this need not be the case. We propose a particularly lightweight extension that supports both dynamics and generics. Furthermore, the two features are smoothly integrated: dynamic values, for instance, can be passed to generic functions. Our proposal makes do with a standard Hindley-Milner type system augmented by existential types. Building upon these ideas we have implemented a small library that is readily usable both with Hugs and with the Glasgow Haskell compiler.", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581698", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "James", + "last_name": "Cheney", + "institution": "Cornell University" + }, + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Bonn" + } + ], + "dblp_key": "conf/haskell/CheneyH02", + "venue": "haskell", + "year": 2002 + }, + { + "paper_id": "10.1145/581690.581694", + "title": "Eager Haskell: resource-bounded execution yields efficient iteration", + "abstract": "The advantages of the Haskell programming language are rooted in its clean equational semantics. Those advantages evaporate as soon as programmers try to write simple iterative computations and discover that their code must be annotated with calls to seq in order to overcome space leaks introduced by lazy evaluation. The Eager Haskell compiler executes Haskell programs eagerly by default, i.e., bindings and function arguments are evaluated before bodies. When resource bounds are exceeded, computation falls back and is restarted lazily. By using a hybrid of eager and lazy evaluation, we preserve the semantics of Haskell and yet permit efficient iteration.", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581694", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Jan-Willem", + "last_name": "Maessen", + "institution": "" + } + ], + "dblp_key": "conf/haskell/Maessen02", + "venue": "haskell", + "year": 2002 + }, + { + "paper_id": "10.1145/581690.581695", + "title": "Functional reactive programming, continued", + "abstract": "Functional Reactive Programming (FRP) extends a host programming language with a notion of time flow. Arrowized FRP (AFRP) is a version of FRP embedded in Haskell based on the arrow combinators. AFRP is a powerful synchronous dataflow programming language with hybrid modeling capabilities, combining advanced synchronous dataflow features with the higher-order lazy functional abstractions of Haskell. In this paper, we describe the AFRP programming style and our Haskell-based implementation. Of particular interest are the AFRP combinators that support dynamic collections and continuation-based switching. We show how these combinators can be used to express systems with an evolving structure that are difficult to model in more traditional dataflow languages.", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581695", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Henrik", + "last_name": "Nilsson", + "institution": "Yale University" + }, + { + "first_name": "Antony", + "last_name": "Courtney", + "institution": "Yale University" + }, + { + "first_name": "John", + "last_name": "Peterson", + "institution": "Yale University" + } + ], + "dblp_key": "conf/haskell/NilssonCP02", + "venue": "haskell", + "year": 2002 + }, + { + "paper_id": "10.1145/581690.581699", + "title": "Techniques for embedding postfix languages in Haskell", + "abstract": "One popular use for Haskell in recent years has been as a host language for domain-specific embedded languages. But how can one embed a postfix language in Haskell, given that Haskell only supports prefix and infix syntax? This paper describes several such embeddings for increasingly complex postfix languages.", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581699", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Chris", + "last_name": "Okasaki", + "institution": "United States Military Academy" + } + ], + "dblp_key": "conf/haskell/Okasaki02", + "venue": "haskell", + "year": 2002 + }, + { + "paper_id": "10.1145/581690.581696", + "title": "Testing monadic code with QuickCheck", + "abstract": "QuickCheck is a previously published random testing tool for Haskell programs. In this paper we show how to use it for testing monadic code, and in particular imperative code written using the ST monad. QuickCheck tests a program against a specification: we show that QuickCheck's specification language is sufficiently powerful to represent common forms of specifications: algebraic, model-based (both functional and relational), and pre-/post-conditional. Moreover, all these forms of specification can be used directly for testing. We define a new language of monadic properties, and make a link between program testing and the notion of observational equivalence.", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581696", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Koen", + "last_name": "Claessen", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/haskell/Claessen002", + "venue": "haskell", + "year": 2002 + }, + { + "paper_id": "10.1145/581690.581697", + "title": "Haddock, a Haskell documentation tool", + "abstract": "This paper describes Haddock, a tool for automatically generating documentation from Haskell source code. Haddock's unique approach to source code annotations provides a useful separation between the implementation of a library and the interface (and hence also the documentation) of that library, so that as far as possible the documentation annotations in the source code do not affect the programmer's freedom over the structure of the implementation. The internal structure and implementation of Haddock is also discussed.", + "date": "2002-10-03", + "link": "https://doi.org/10.1145/581690.581697", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/haskell/Marlow02", + "venue": "haskell", + "year": 2002 + } +] \ No newline at end of file diff --git a/data/pl_conferences/haskell/2003.json b/data/pl_conferences/haskell/2003.json new file mode 100644 index 0000000..b4a1a53 --- /dev/null +++ b/data/pl_conferences/haskell/2003.json @@ -0,0 +1,240 @@ +[ + { + "paper_id": "10.1145/871895.871903", + "title": "Interactive type debugging in Haskell", + "abstract": "Proceedings of the 2003 ACM SIGPLAN Haskell Workshop", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871903", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Peter J.", + "last_name": "Stuckey", + "institution": "University of Melbourne" + }, + { + "first_name": "Martin", + "last_name": "Sulzmann", + "institution": "National University of Singapore" + }, + { + "first_name": "Jeremy", + "last_name": "Wazny", + "institution": "University of Melbourne" + } + ], + "dblp_key": "conf/haskell/StuckeySW03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871898", + "title": "XML templates and caching in WASH", + "abstract": "Caching of documents is an important concern on the Web. It is a major win in all situations where bandwidth is limited. Unfortunately, the increasing spread of dynamically generated documents seriously hampers traditional caching techniques in browsers and on proxy servers.WASH/CGI is a Haskell-based domain specific language for creating interactive Web applications. The Web pages generated by a WASH/CGI application are highly dynamic and cannot be cached with traditional means.We show how to implement the dynamic caching scheme of the BigWig language [2] in the context of WASH/CGI. The main issue in BigWig's caching scheme is the distinction between fixed parts (that should be cached) and variable parts (that need not be cached) of a document. Since BigWig is a standalone domain-specific language, its compiler can perform the distinction as part of its static analysis. Hence, the challenge in our implementation is to obtain the same information without involving the compiler. To this end, we extend WASH/CGI's document language by mode annotations and define the translation of the resulting annotated document language into JavaScript.To alleviate the awkwardness of programming directly in annotated language, we have defined a surface syntax in the style of HSP (Haskell Server Pages) [11].", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871898", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" + } + ], + "dblp_key": "conf/haskell/Thiemann03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871902", + "title": "Helium, for learning Haskell", + "abstract": "Helium is a user-friendly compiler designed especially for learning the functional programming language Haskell. The quality of the error messages has been the main concern both in the choice of the language features and in the implementation of the compiler. Helium implements almost full Haskell, where the most notable difference is the absence of type classes. Our goal is to let students learn functional programming more quickly and with more fun. The compiler has been successfully employed in two introductory programming courses at Utrecht University.", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871902", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Bastiaan", + "last_name": "Heeren", + "institution": "Utrecht University" + }, + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Utrecht University" + }, + { + "first_name": "Arjan van", + "last_name": "IJzendoorn", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/haskell/HeerenLI03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871897", + "title": "The Yampa arcade", + "abstract": "Simulated worlds are a common (and highly lucrative) application domain that stretches from detailed simulation of physical systems to elaborate video game fantasies. We believe that Functional Reactive Programming (FRP) provides just the right level of functionality to develop simulated worlds in a concise, clear and modular way. We demonstrate the use of FRP in this domain by presenting an implementation of the classic Space Invaders game in Yampa, our most recent Haskell-embedded incarnation of FRP.", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871897", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Antony", + "last_name": "Courtney", + "institution": "Yale University" + }, + { + "first_name": "Henrik", + "last_name": "Nilsson", + "institution": "Yale University" + }, + { + "first_name": "John", + "last_name": "Peterson", + "institution": "Yale University" + } + ], + "dblp_key": "conf/haskell/CourtneyNP03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871900", + "title": "Modeling quantum computing in Haskell", + "abstract": "The paper develops a model of quantum computing from the perspective of functional programming. The model explains the fundamental ideas of quantum computing at a level of abstraction that is familiar to functional programmers. The model also illustrates some of the inherent difficulties in interpreting quantum mechanics and highlights the differences between quantum computing and traditional (functional or otherwise) computing models.", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871900", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Amr", + "last_name": "Sabry", + "institution": "Indiana University" + } + ], + "dblp_key": "conf/haskell/Sabry03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871896", + "title": "Functional Pearl trouble shared is trouble halved", + "abstract": "A nexus is a tree that contains shared nodes, nodes that have more than one incoming arc. Shared nodes are created in almost every functional program - for instance, when updating a purely functional data structure - though programmers are seldom aware of this. In fact, there are only a few algorithms that exploit sharing of nodes consciously. One example is constructing a tree in sublinear time. In this pearl we discuss an intriguing application of nexuses; we show that they serve admirably as memo structures featuring constant time access to memoized function calls. Along the way we encounter Boolean lattices and binomial trees.", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871896", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Richard", + "last_name": "Bird", + "institution": "University of Oxford" + }, + { + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Bonn" + } + ], + "dblp_key": "conf/haskell/BirdH03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871904", + "title": "HsDebug: debugging lazy programs by not being lazy", + "abstract": "Article Share on HsDebug: debugging lazy programs by not being lazy Authors: Robert Ennals University of Cambridge University of CambridgeView Profile , Simon Peyton Jones Microsoft Research Ltd, Cambridge Microsoft Research Ltd, CambridgeView Profile Authors Info & Claims Haskell '03: Proceedings of the 2003 ACM SIGPLAN workshop on HaskellAugust 2003Pages 84–87https://doi.org/10.1145/871895.871904Published:28 August 2003Publication History 7citation345DownloadsMetricsTotal Citations7Total Downloads345Last 12 Months7Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871904", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Robert", + "last_name": "Ennals", + "institution": "University of Cambridge" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/haskell/EnnalsJ03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871901", + "title": "Structure and interpretation of quantum mechanics: a functional framework", + "abstract": "We present a framework for representing quantum entities in Haskell. States and operators are functional objects, and their semantics is defined --- as far as possible --- independently of the base in the Hilbert space. We construct effectively the tensor states for composed systems, and we present a toy model of quantum circuit toolbox. We conclude that functional languages are right tools for formal computations in quantum physics. The paper focuses mainly on the representation, not on computational problems.", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871901", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Jerzy", + "last_name": "Karczmarczuk", + "institution": "Université de Caen Normandie" + } + ], + "dblp_key": "conf/haskell/Karczmarczuk03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871907", + "title": "Haskell tools from the programatica project", + "abstract": "Article Share on Haskell tools from the programatica project Author: Thomas Hallgren Oregon Health & Science University, Beaverton, OR Oregon Health & Science University, Beaverton, ORView Profile Authors Info & Claims Haskell '03: Proceedings of the 2003 ACM SIGPLAN workshop on HaskellAugust 2003Pages 103–106https://doi.org/10.1145/871895.871907Published:28 August 2003Publication History 13citation362DownloadsMetricsTotal Citations13Total Downloads362Last 12 Months4Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871907", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Thomas", + "last_name": "Hallgren", + "institution": "Oregon Health & Science University" + } + ], + "dblp_key": "conf/haskell/Hallgren03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871906", + "title": "Simulating quantified class constraints", + "abstract": "Defining nontrivial class instances for irregular and exponential datatypes in Haskell is challenging, and as a solution it has been proposed to extend the language with quantified class constraints of the form ∀a. C a ⇒ C' (f a) in the contexts of instance declarations. We show how to express the equivalent of such constraints in vanilla Haskell 98, but their utility in this language is limited. We also present a more flexible solution, which relies on a widely-supported language extension.", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871906", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Valery", + "last_name": "Trifonov", + "institution": "Yale University" + } + ], + "dblp_key": "conf/haskell/Trifonov03", + "venue": "haskell", + "year": 2003 + }, + { + "paper_id": "10.1145/871895.871905", + "title": "Haskell and principal types", + "abstract": "This paper points out two problems which prevent Haskell from having principal types. For each problem, we discuss a program which exhibits it. The first problem has to do with type signatures and class constraints containing both generic and nongeneric type variables. The second problem is caused by the monomorphism restriction. In both cases there is an interaction between generalization and class constraints where substituting a nonvariable type for a constrained type variable makes the constraint tautological and opens up for more aggressive generalization.We also discuss how these problems can be solved by introducing quantified class constraints and strengthening the monomorphism restriction from prohibiting only the generalization of constrained type variables to prohibiting any generalization at all. We also give an inference algorithm producing principal types for the new system.", + "date": "2003-08-28", + "link": "https://doi.org/10.1145/871895.871905", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Karl‐Filip", + "last_name": "Faxén", + "institution": "KTH Royal Institute of Technology" + } + ], + "dblp_key": "conf/haskell/Faxen03", + "venue": "haskell", + "year": 2003 + } +] \ No newline at end of file diff --git a/data/pl_conferences/haskell/2004.json b/data/pl_conferences/haskell/2004.json new file mode 100644 index 0000000..2cf8049 --- /dev/null +++ b/data/pl_conferences/haskell/2004.json @@ -0,0 +1,318 @@ +[ + { + "paper_id": "10.1145/1017472.1017478", + "title": "Plugging Haskell in", + "abstract": "Extension languages enable users to expand the functionality of an application without touching its source code. Commonly, these languages are dynamically typed languages, such as Lisp, Python, or domain-specific languages, which support runtime plugins via dynamic loading of components. We show that Haskell can be comfortably used as a statically typed extension language for both Haskell and foreign-language applications supported by the Haskell FFI, and that it can perform type-safe dynamic loading of plugins using dynamic types. Moreover, we discuss how plugin support is especially useful to applications where Haskell is used as an embedded domain-specific language (EDSL). We explain how to realise type-safe plugins using dynamic types, runtime compilation, and dynamic linking, exploiting infrastructure provided by the Glasgow Haskell Compiler. We demonstrate the practicability of our approach with several applications that serve as running examples.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017478", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "André", + "last_name": "Pang", + "institution": "Commonwealth Scientific and Industrial Research Organisation" + }, + { + "first_name": "Don", + "last_name": "Stewart", + "institution": "UNSW Sydney" + }, + { + "first_name": "Sean", + "last_name": "Seefried", + "institution": "UNSW Sydney" + }, + { + "first_name": "Manuel M. T.", + "last_name": "Chakravarty", + "institution": "UNSW Sydney" + } + ], + "dblp_key": "conf/haskell/PangSSC04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017488", + "title": "Strongly typed heterogeneous collections", + "abstract": "A heterogeneous collection is a datatype that is capable of storing data of different types, while providing operations for look-up, update, iteration, and others. There are various kinds of heterogeneous collections, differing in representation, invariants, and access operations. We describe HLIST - a Haskell library for strongly typed heterogeneous collections including extensible records. We illustrate HLIST's benefits in the context of type-safe database access in Haskell. The HLIST library relies on common extensions of Haskell 98. Our exploration raises interesting issues regarding Haskell's type system, in particular, avoidance of overlapping instances, and reification of type equality and type unification.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017488", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "" + }, + { + "first_name": "Ralf", + "last_name": "Lämmel", + "institution": "Centrum Wiskunde & Informatica" + }, + { + "first_name": "Keean", + "last_name": "Schupke", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/haskell/KiselyovLS04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017485", + "title": "Type-safe, self inspecting code", + "abstract": "We present techniques for representing typed abstract syntax trees in the presence of observable recursive structures. The need for this arose from the desire to cope with left-recursion in combinator based parsers. The techniques employed can be used in a much wider setting however, since it enables the inspection and transformation of any program structure, which contains internal references. The hard part of the work is to perform such analyses and transformations in a setting in which the Haskell type checker is still able to statically check the correctness of the program representations, and hence the type correctness of the transformed program.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017485", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Arthur I.", + "last_name": "Baars", + "institution": "Utrecht University" + }, + { + "first_name": "S. Doaitse", + "last_name": "Swierstra", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/haskell/BaarsS04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017479", + "title": "Extending the Haskell foreign function interface with concurrency", + "abstract": "A Haskell system that includes both the Foreign Function Interface and the Concurrent Haskell extension must consider how Concurrent Haskell threads map to external Operating System threads for the purposes of specifying in which thread a foreign call is made.Many concurrent languages take the easy route and specify a one-to-one correspondence between the language's own threads and external OS threads. However, OS threads tend to be expensive, so this choice can limit the performance and scalability of the concurrent language.The main contribution of this paper is a language design that provides a neat solution to this problem, allowing the implementor of the language enough flexibility to provide cheap lightweight threads, while still providing the programmer with control over the mapping between internal threads and external threads where necessary.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017479", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Wolfgang", + "last_name": "Thaller", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/haskell/MarlowJT04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017475", + "title": "BNF converter", + "abstract": "We will demonstrate BNFC (the BNF Converter) [7, 6], a multi-lingual compiler tool. BNFC takes as its input a grammar written in LBNF (Labelled BNF) notation, and generates a compiler front-end (an abstract syntax, a lexer, and a parser). Furthermore, it generates a case skeleton usable as the starting point of back-end construction, a pretty printer, a test bench, and a LaTeX document usable as language specification. The program components can be generated in Haskell, Java, C and C++ and their standard parser and lexer tools. BNFC itself was written in Haskell.The methodology used for the generated front-end is based on Appel's books on compiler construction [3, 1, 2]. BNFC has been used as a teaching tool in compiler construction courses at Chalmers. It has also been applied to research-related programming language development, and in an industrial application producing a compiler for a telecommunications protocol description language [4].BNFC is freely available under the GPL license at its website and in the testing distribution of Debian Linux.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017475", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Markus", + "last_name": "Forsberg", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Aarne", + "last_name": "Ranta", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/haskell/ForsbergR04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017477", + "title": "Functional pearl: i am not a number-i am a free variable", + "abstract": "In this paper, we show how to manipulate syntax with binding using a mixed representation of names for free variables (with respect to the task in hand) and de Bruijn indices [5] for bound variables. By doing so, we retain the advantages of both representations: naming supports easy, arithmetic-free manipulation of terms; de Bruijn indices eliminate the need for α-conversion. Further, we have ensured that not only the user but also the implementation need never deal with de Bruijn indices, except within key basic operations.Moreover, we give a hierarchical representation for names which naturally reflects the structure of the operations we implement. Name choice is safe and straightforward. Our technology combines easily with an approach to syntax manipulation inspired by Huet's 'zippers'[10].Without the ideas in this paper, we would have struggled to implement EPIGRAM [19]. Our example-constructing inductive elimination operators for datatype families-is but one of many where it proves invaluable.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017477", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Conor", + "last_name": "McBride", + "institution": "Durham University" + }, + { + "first_name": "James", + "last_name": "McKinna", + "institution": "University of St Andrews" + } + ], + "dblp_key": "conf/haskell/McBrideM04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017481", + "title": "Functional pearl: implicit configurations-or, type classes reflect the values of types", + "abstract": "The configurations problem is to propagate run-time preferences throughout a program, allowing multiple concurrent configuration sets to coexist safely under statically guaranteed separation. This problem is common in all software systems, but particularly acute in Haskell, where currently the most popular solution relies on unsafe operations and compiler pragmas.We solve the configurations problem in Haskell using only stable and widely implemented language features like the type-class system. In our approach, a term expression can refer to run-time configuration parameters as if they were compile-time constants in global scope. Besides supporting such intuitive term notation and statically guaranteeing separation, our solution also helps improve the program's performance by transparently dispatching to specialized code at run-time. We can propagate any type of configuration data-numbers, strings, IO actions, polymorphic functions, closures, and abstract data types. No previous approach to propagating configurations implicitly in any language provides the same static separation guarantees.The enabling technique behind our solution is to propagate values via types, with the help of polymorphic recursion and higher-rank polymorphism. The technique essentially emulates local type-class instance declarations while preserving coherence. Configuration parameters are propagated throughout the code implicitly as part of type inference rather than explicitly by the programmer. Our technique can be regarded as a portable, coherent, and intuitive alternative to implicit parameters. It motivates adding local instances to Haskell, with a restriction that salvages principal types.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017481", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "Naval Meteorology and Oceanography Command" + }, + { + "first_name": "Chung-chieh", + "last_name": "Shan", + "institution": "Harvard University" + } + ], + "dblp_key": "conf/haskell/KiselyovS04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017486", + "title": "Improving type error diagnosis", + "abstract": "All in-text\\treferences\\tunderlined\\tin\\tblue\\tare\\tlinked\\tto\\tpublications\\ton\\tResearchGate, letting you\\taccess\\tand\\tread\\tthem\\timmediately.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017486", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Peter J.", + "last_name": "Stuckey", + "institution": "University of Melbourne" + }, + { + "first_name": "Martin", + "last_name": "Sulzmann", + "institution": "" + }, + { + "first_name": "Jeremy", + "last_name": "Wazny", + "institution": "University of Melbourne" + } + ], + "dblp_key": "conf/haskell/StuckeySW04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017483", + "title": "wxHaskell: a portable and concise GUI library for haskell", + "abstract": "wxHaskell is a graphical user interface (GUI) library for Haskell that is built on wxWidgets: a free industrial strength GUI library for C++ that has been ported to all major platforms, including Windows, Gtk, and MacOS X. In contrast with many other libraries, wxWidgets retains the native look-and-feel of each particular platform. We show how distinctive features of Haskell, like parametric polymorphism, higher-order functions, and first-class computations, can be used to present a concise and elegant monadic interface for portable GUI programs.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017483", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Utrecht University" + } + ], + "dblp_key": "conf/haskell/Leijen04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017474", + "title": "Haskell type browser", + "abstract": "No abstract available.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017474", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Matthias", + "last_name": "Neubauer", + "institution": "University of Fribourg" + }, + { + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Fribourg" + } + ], + "dblp_key": "conf/haskell/NeubauerT04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017482", + "title": "Programming graphics processors functionally", + "abstract": "Graphics cards for personal computers have recently undergone a radical transformation from fixed-function graphics pipelines to multi-processor, programmable architectures. Multi-processor architectures are clearly advantageous for graphics for the simple reason that graphics computations are naturally concurrent, mapping well to stateless stream processing. They therefore parallelize easily and need no random access to memory with its problematic latencies.This paper presents Vertigo, a purely functional, Haskell-embedded language for 3D graphics and an optimizing compiler that generates graphics processor code. The language integrates procedural surface modeling, shading, and texture generation, and the compiler exploits the unusual processor architecture. The shading sub-language is based on a simple and precise semantic model, in contrast to previous shading languages. Geometry and textures are also defined via a very simple denotational semantics. The formal semantics yields not only programs that are easy to understand and reason about, but also very efficient implementation, thanks to a compiler based on partial evaluation and symbolic optimization, much in the style of Pan [2].Haskell's overloading facility is extremely useful throughout Vertigo. For instance, math operators are used not just for floating point numbers, but also expressions (for differentiation and compilation), tuples, and functions. Typically, these overloadings cascade, as in the case of surfaces, which may be combined via math operators, though they are really functions over tuples of expressions on floating point numbers. Shaders may be composed with the same notational convenience. Functional dependencies are exploited for vector spaces, cross products, and derivatives.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017482", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Conal", + "last_name": "Elliott", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/haskell/Elliott04", + "venue": "haskell", + "year": 2004 + }, + { + "paper_id": "10.1145/1017472.1017473", + "title": "Student paper: HaskellDB improved", + "abstract": "We present an improved version of the HaskellDB database library. The original version relied on TRex, a Haskell extension supported only by the Hugs interpreter. We have replaced the use of TRex by a record implementation which uses more commonly implemented Haskell extensions.Additionally, HaskellDB now supports two different cross-platform database backends. Other changes include database creation functionality, bounded string support, performance enhancements, fixes to the optimisation logic, transaction support and more fine grained expression types.", + "date": "2004-09-22", + "link": "https://doi.org/10.1145/1017472.1017473", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Björn", + "last_name": "Bringert", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Anders", + "last_name": "Höckersten", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Conny", + "last_name": "Andersson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Martin", + "last_name": "Andersson", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Mary Elizabeth", + "last_name": "Bergman", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Victor", + "last_name": "Blomqvist", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Torbjörn", + "last_name": "Martin", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/haskell/BringertHAABBM04", + "venue": "haskell", + "year": 2004 + } +] \ No newline at end of file diff --git a/data/pl_conferences/haskell/2005.json b/data/pl_conferences/haskell/2005.json new file mode 100644 index 0000000..1fbccc1 --- /dev/null +++ b/data/pl_conferences/haskell/2005.json @@ -0,0 +1,63 @@ +[ + { + "paper_id": "10.1145/1088348.1088355", + "title": "Verifying haskell programs using constructive type theory", + "abstract": "Proof assistants based on dependent type theory are closely related to functional programming languages, and so it is tempting to use them to prove the correctness of functional programs. In this paper, we show how Agda, such a proof assistant, can be used to prove theorems about Haskell programs. Haskell programs are translated into an Agda model of their semantics, by translating via GHC's Core language into a monadic form specially adapted to represent Haskell's polymorphism in Agda's predicative type system. The translation can support reasoning about either total values only, or total and partial values, by instantiating the monad appropriately. We claim that, although these Agda models are generated by a relatively complex translation process, proofs about them are simple and natural, and we offer a number of examples to support this claim.", + "date": "2005-09-30", + "link": "https://doi.org/10.1145/1088348.1088355", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Abel", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Marcin", + "last_name": "Benke", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Ana", + "last_name": "Bove", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Ulf", + "last_name": "Norell", + "institution": "Chalmers University of Technology" + } + ], + "dblp_key": "conf/haskell/AbelBBHN05", + "venue": "haskell", + "year": 2005 + }, + { + "paper_id": "10.1145/1088348.1088350", + "title": "Visual haskell: a full-featured haskell development environment", + "abstract": "We describe the design and implementation of a full-featured Haskell development environment, based on Microsoft's extensible Visual Studio environment.Visual Haskell provides a number of features not found in existing Haskell development environments: interactive error-checking, displaying of inferred types in the editor, and other features based on static properties of the source code. Visual Haskell also provides full support for developing and building multi-module Haskell projects, based on the Cabal architecture. Visual Haskell supports the full GHC language, and can be used to develop real Haskell applications (including the code of the plugin itself).Visual Haskell has driven developments in other Haskell-related projects: Cabal, the Concurrent FFI extension, and an API to allow programmatic access to GHC itself. Furthermore, development of the Visual Haskell plugin required industrial-strength foreign language interoperability; we describe all our experiences in detail.", + "date": "2005-09-30", + "link": "https://doi.org/10.1145/1088348.1088350", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Krasimir", + "last_name": "Angelov", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Simon", + "last_name": "Marlow", + "institution": "Microsoft Research (United Kingdom)" + } + ], + "dblp_key": "conf/haskell/AngelovM05", + "venue": "haskell", + "year": 2005 + } +] \ No newline at end of file diff --git a/data/pl_conferences/haskell/2006.json b/data/pl_conferences/haskell/2006.json new file mode 100644 index 0000000..f49e8e3 --- /dev/null +++ b/data/pl_conferences/haskell/2006.json @@ -0,0 +1,25 @@ +[ + { + "paper_id": "10.1145/1159842.1159846", + "title": "Strong types for relational databases", + "abstract": "Haskell's type system with multi-parameter constructor classes and functional dependencies allows static (compile-time) computations to be expressed by logic programming on the level of types. This emergent capability has been exploited for instance to model arbitrary-length tuples (heterogeneous lists), extensible records, functions with variable length argument lists, and (homogenous) lists of statically fixed length (vectors).We explain how type-level programming can be exploited to define a strongly-typed model of relational databases and operations on them. In particular, we present a strongly typed embedding of a significant subset of SQL in Haskell. In this model, meta-data is represented by type-level entities that guard the semantic correctness of database operations at compile time.Apart from the standard relational database operations, such as selection and join, we model functional dependencies (among table attributes), normal forms, and operations for database transformation. We show how functional dependency information can be represented at the type level, and can be transported through operations. This means that type inference statically computes functional dependencies on the result from those on the arguments.Our model shows that Haskell can be used to design and prototype typed languages for designing, programming, and transforming relational databases.", + "date": "2006-01-01", + "link": "https://doi.org/10.1145/1159842.1159846", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "" + }, + { + "first_name": "Joost", + "last_name": "Visser", + "institution": "" + } + ], + "dblp_key": "conf/haskell/SilvaV06", + "venue": "haskell", + "year": 2006 + } +] \ No newline at end of file diff --git a/data/pl_conferences/haskell/2009.json b/data/pl_conferences/haskell/2009.json new file mode 100644 index 0000000..0f70722 --- /dev/null +++ b/data/pl_conferences/haskell/2009.json @@ -0,0 +1,40 @@ +[ + { + "paper_id": "10.1145/1596638.1667736", + "title": "Tool DemonstrationCLasHFrom Haskell to Hardware", + "abstract": "C\\ensuremath{\\lambda}aSH is a functional hardware description language that borrows both its syntax and semantics from the functional programming language Haskell. Polymorphism and higher-order functions provide a level of abstraction and generality that allow a circuit designer to describe circuits in a more natural way than possible with the language elements found in the traditional hardware description languages.", + "date": "2009-01-01", + "link": "https://doi.org/10.1145/1596638.1667736", + "conference_name": "Haskell", + "authors": [ + { + "first_name": "Christiaan", + "last_name": "Baaij", + "institution": "" + }, + { + "first_name": "Matthijs", + "last_name": "Kooijman", + "institution": "" + }, + { + "first_name": "Jan", + "last_name": "Kuper", + "institution": "" + }, + { + "first_name": "Marco", + "last_name": "Gerards", + "institution": "" + }, + { + "first_name": "Bert", + "last_name": "Molenkamp", + "institution": "" + } + ], + "dblp_key": "conf/haskell/BaaijKKGM09", + "venue": "haskell", + "year": 2009 + } +] \ No newline at end of file From ff7aa8a7569e13b9b1466ad5b6f46825e78b22ac Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:47:46 +0200 Subject: [PATCH 24/34] fix: anchor PLConferenceHarvester paper date to conference year MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit OpenAlex returns ``publication_date`` as the journal release date, which for ACM-published PACMPL volumes is December of the year *before* the conference (POPL 2018 → 2017-12-27, POPL 2020 → 2019-12-20). Pre-PACMPL POPL 2015 has the same shape (ACM dated the proceedings 2014-12-19). The harvester previously wrote this date straight to the JSON ``date`` field. Paper.from_scraped_json then stored it as ``update_date`` in the DB, so year-bucketing queries over ``update_date`` saw POPL 2018 papers as 2017 papers — making POPL 2015/2017/2018/2020 appear absent under their conference year. PLDI/ICFP/OOPSLA happen mid-year so the bug is invisible there. Snap any out-of-year publication_date back to ``YYYY-01-01`` for the conference year. In-year dates are preserved unchanged. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PLConferenceHarvester.py | 29 +++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/src/oversight/PLConferenceHarvester.py b/src/oversight/PLConferenceHarvester.py index 27fc221..8a74266 100644 --- a/src/oversight/PLConferenceHarvester.py +++ b/src/oversight/PLConferenceHarvester.py @@ -755,7 +755,7 @@ def _build_paper(self, entry: dict[str, Any], doi: str) -> dict[str, Any] | None else: authors = _dblp_authors(entry) - date = publication_date or self._fallback_date() + date = self._normalise_publication_date(publication_date) link = _doi_link(doi) return { @@ -777,6 +777,33 @@ def _fallback_date(self) -> str: # year for downstream date filters. return f"{self.year}-01-01" + def _normalise_publication_date(self, publication_date: str | None) -> str: + """Return a date string anchored to the conference year. + + OpenAlex's ``publication_date`` for journal-published proceedings is + the *journal* release date, which for January-conference PACMPL + volumes (POPL is the textbook case) lands in late December of the + prior calendar year. Pre-PACMPL POPL 2015 has the same shape: ACM's + DL records the proceedings as published 2014-12-19 even though the + symposium ran in January 2015. + + When the harvester then writes this date through to the DB's + ``update_date`` column, the year-bucketing query sees POPL 2018 + papers as 2017 papers — making whole conference years appear to be + missing. (PLDI/ICFP/OOPSLA happen mid-year so OpenAlex's date is in + the right calendar year and the bug is invisible there.) + + Snap any out-of-year date back to ``YYYY-01-01`` for the conference + year. In-year dates are preserved (most non-POPL volumes). + """ + if not publication_date: + return self._fallback_date() + if not publication_date[:4].isdigit(): + return self._fallback_date() + if int(publication_date[:4]) != self.year: + return self._fallback_date() + return publication_date + # ------------------------------------------------------------------ # OpenAlex # ------------------------------------------------------------------ From 34636adb4c5eefc66ccb82eaca3cc6e437aba86c Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:47:55 +0200 Subject: [PATCH 25/34] feat: re-ingest POPL 2015, 2018, 2020 with conference-year dates Re-runs of PLConferenceHarvester for POPL 2015/2018/2020 with the date-normalisation fix in place. All three years now carry dates within the conference year (2015-01-15 / 2018-01-01 / 2020-01-01) instead of the journal-release date OpenAlex returns (December of the prior year), restoring them to the year-bucketing inventory query. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/popl/2015.json | 1628 +++++++++---------- data/pl_conferences/popl/2018.json | 2100 ++++++++++++------------ data/pl_conferences/popl/2020.json | 2368 ++++++++++++++-------------- 3 files changed, 3048 insertions(+), 3048 deletions(-) diff --git a/data/pl_conferences/popl/2015.json b/data/pl_conferences/popl/2015.json index 568df94..b31ff63 100644 --- a/data/pl_conferences/popl/2015.json +++ b/data/pl_conferences/popl/2015.json @@ -1,19 +1,39 @@ [ { - "paper_id": "10.1145/2676726.2677004", - "title": "Ur/Web: A Simple Model for Programming the Web", - "abstract": "The World Wide Web has evolved gradually from a document delivery platform to an architecture for distributed programming. This largely unplanned evolution is apparent in the set of interconnected languages and protocols that any Web application must manage. This paper presents Ur/Web, a domain-specific, statically typed functional programming language with a much simpler model for programming modern Web applications. Ur/Web's model is unified, where programs in a single programming language are compiled to other \"Web standards\" languages as needed; supports novel kinds of encapsulation of Web-specific state; and exposes simple concurrency, where programmers can reason about distributed, multithreaded applications via a mix of transactions and cooperative preemption. We give a tutorial introduction to the main features of Ur/Web and discuss the language implementation and the production Web applications that use it.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677004", + "paper_id": "10.1145/2676726.2677010", + "title": "On Characterizing the Data Access Complexity of Programs", + "abstract": "Technology trends will cause data movement to account for the majority of energy expenditure and execution time on emerging computers. Therefore, computational complexity will no longer be a sufficient metric for comparing algorithms, and a fundamental characterization of data access complexity will be increasingly important. The problem of developing lower bounds for data access complexity has been modeled using the formalism of Hong and Kung's red/blue pebble game for computational directed acyclic graphs (CDAGs). However, previously developed approaches to lower bounds analysis for the red/blue pebble game are very limited in effectiveness when applied to CDAGs of real programs, with computations comprised of multiple sub-computations with differing DAG structure. We address this problem by developing an approach for effectively composing lower bounds based on graph decomposition. We also develop a static analysis algorithm to derive the asymptotic data-access lower bounds of programs, as a function of the problem size and cache size.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677010", "conference_name": "POPL", "authors": [ { - "first_name": "Adam", - "last_name": "Chlipala", - "institution": "Massachusetts Institute of Technology" + "first_name": "Venmugil", + "last_name": "Elango", + "institution": "The Ohio State University" + }, + { + "first_name": "Fabrice", + "last_name": "Rastello", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Louis-Noël", + "last_name": "Pouchet", + "institution": "The Ohio State University" + }, + { + "first_name": "J.", + "last_name": "Ramanujam", + "institution": "Louisiana State University" + }, + { + "first_name": "P.", + "last_name": "Sadayappan", + "institution": "The Ohio State University" } ], - "dblp_key": "conf/popl/Chlipala15", + "dblp_key": "conf/popl/ElangoRPRS15", "venue": "popl", "year": 2015 }, @@ -21,7 +41,7 @@ "paper_id": "10.1145/2676726.2676982", "title": "K-Java: A Complete Semantics of Java", "abstract": "This paper presents K-Java, a complete executable formal semantics of Java 1.4. K-Java was extensively tested with a test suite developed alongside the project, following the Test Driven Development methodology. In order to maintain clarity while handling the great size of Java, the semantics was split into two separate definitions -- a static semantics and a dynamic semantics. The output of the static semantics is a preprocessed Java program, which is passed as input to the dynamic semantics for execution. The preprocessed program is a valid Java program, which uses a subset of the features of Java. The semantics is applied to model-check multi-threaded programs. Both the test suite and the static semantics are generic and ready to be used in other Java-related projects.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676982", "conference_name": "POPL", "authors": [ @@ -41,366 +61,358 @@ "year": 2015 }, { - "paper_id": "10.1145/2676726.2677013", - "title": "Towards the Essence of Hygiene", - "abstract": "Hygiene is an essential aspect of Scheme's macro system that prevents unintended variable capture. However, previous work on hygiene has focused on algorithmic implementation rather than precise, mathematical definition of what constitutes hygiene. This is in stark contrast with lexical scope, alpha-equivalence and capture-avoiding substitution, which also deal with preventing unintended variable capture but have widely applicable and well-understood mathematical definitions.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677013", + "paper_id": "10.1145/2676726.2676987", + "title": "Analyzing Program Analyses", + "abstract": "We want to prove that a static analysis of a given program is complete, namely, no imprecision arises when asking some query on the program behavior in the concrete (ie, for its concrete semantics) or in the abstract (ie, for its abstract interpretation). Completeness proofs are therefore useful to assign confidence to alarms raised by static analyses. We introduce the completeness class of an abstraction as the set of all programs for which the abstraction is complete. Our first result shows that for any nontrivial abstraction, its completeness class is not recursively enumerable. We then introduce a stratified deductive system to prove the completeness of program analyses over an abstract domain A. We prove the soundness of the deductive system. We observe that the only sources of incompleteness are assignments and Boolean tests --- unlikely a common belief in static analysis, joins do not induce incompleteness. The first layer of this proof system is generic, abstraction-agnostic, and it deals with the standard constructs for program composition, that is, sequential composition, branching and guarded iteration. The second layer is instead abstraction-specific: the designer of an abstract domain A provides conditions for completeness in A of assignments and Boolean tests which have to be checked by a suitable static analysis or assumed in the completeness proof as hypotheses. We instantiate the second layer of this proof system first with a generic nonrelational abstraction in order to provide a sound rule for the completeness of assignments. Orthogonally, we instantiate it to the numerical abstract domains of Intervals and Octagons, providing necessary and sufficient conditions for the completeness of their Boolean tests and of assignments for Octagons.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676987", "conference_name": "POPL", "authors": [ { - "first_name": "Michael D.", - "last_name": "Adams", - "institution": "University of Utah" - } - ], - "dblp_key": "conf/popl/Adams15", - "venue": "popl", - "year": 2015 - }, - { - "paper_id": "10.1145/2676726.2682620", - "title": "Databases and Programming: Two Subjects Divided by a Common Language?", - "abstract": "The 1990s saw a hugely productive interaction between database and programming language research. Ideas about type systems from programming languages played a central role in generalizing and adapting relational database systems to new data models. At the same time databases provided some of the best concrete examples of the application of concurrency theory and of the benefits of high-level optimization in functional programming languages. One of the driving ambitions behind this research was the idea that database access should be properly embedded in programming languages: one should not have to be bilingual in order to use a database from a programming language; and that goal has to some extent been realized.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2682620", - "conference_name": "POPL", - "authors": [ + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Verona" + }, { - "first_name": "Peter", - "last_name": "Buneman", - "institution": "University of Edinburgh" + "first_name": "Francesco", + "last_name": "Logozzo", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Francesco", + "last_name": "Ranzato", + "institution": "University of Padua" } ], - "dblp_key": "conf/popl/Buneman15", + "dblp_key": "conf/popl/GiacobazziLR15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676972", - "title": "Sound Modular Verification of C Code Executing in an Unverified Context", - "abstract": "Over the past decade, great progress has been made in the static modular verification of C code by means of separation logic-based program logics. However, the runtime guarantees offered by such verification are relatively limited when the verified modules are part of a whole program that also contains unverified modules. In particular, a memory safety error in an unverified module can corrupt the runtime state, leading to assertion failures or invalid memory accesses in the verified modules. This paper develops runtime checks to be inserted at the boundary between the verified and the unverified part of a program, to guarantee that no assertion failures or invalid memory accesses can occur at runtime in any verified module. One of the key challenges is enforcing the separation logic frame rule, which we achieve by checking the integrity of the footprint of the verified part of the program on each control flow transition from the unverified to the verified part. This in turn requires the presence of some support for module-private memory at runtime. We formalize our approach and prove soundness. We implement the necessary runtime checks by means of a program transformation that translates C code with separation logic annotations into plain C, and that relies on a protected module architecture for providing module-private memory and restricted module entry points. Benchmarks show the performance impact of this transformation depends on the choice of boundary between the verified and unverified parts of the program, but is below 4% for real-world applications.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676972", + "paper_id": "10.1145/2676726.2677011", + "title": "A Coalgebraic Decision Procedure for NetKAT", + "abstract": "NetKAT is a domain-specific language and logic for specifying and verifying network packet-processing functions. It consists of Kleene algebra with tests (KAT) augmented with primitives for testing and modifying packet headers and encoding network topologies. Previous work developed the design of the language and its standard semantics, proved the soundness and completeness of the logic, defined a PSPACE algorithm for deciding equivalence, and presented several practical applications.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677011", "conference_name": "POPL", "authors": [ { - "first_name": "Pieter", - "last_name": "Agten", - "institution": "KU Leuven" + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" }, { - "first_name": "Bart", - "last_name": "Jacobs", - "institution": "KU Leuven" + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" }, { - "first_name": "Frank", - "last_name": "Piessens", - "institution": "KU Leuven" + "first_name": "Mae", + "last_name": "Milano", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "Radboud University Nijmegen" + }, + { + "first_name": "Laure", + "last_name": "Thompson", + "institution": "Cornell University" } ], - "dblp_key": "conf/popl/Agten0P15", + "dblp_key": "conf/popl/FosterKM0T15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677000", - "title": "Higher-Order Approximate Relational Refinement Types for Mechanism Design and Differential Privacy", - "abstract": "Mechanism design is the study of algorithm design where the inputs to the algorithm are controlled by strategic agents, who must be incentivized to faithfully report them. Unlike typical programmatic properties, it is not sufficient for algorithms to merely satisfy the property, incentive properties are only useful if the strategic agents also believe this fact.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677000", + "paper_id": "10.1145/2676726.2677008", + "title": "Succinct Representation of Concurrent Trace Sets", + "abstract": "We present a method and a tool for generating succinct representations of sets of concurrent traces. We focus on trace sets that contain all correct or all incorrect permutations of events from a given trace. We represent trace sets as HB-Formulas that are Boolean combinations of happens-before constraints between events. To generate a representation of incorrect interleavings, our method iteratively explores interleavings that violate the specification and gathers generalizations of the discovered interleavings into an HB-Formula; its complement yields a representation of correct interleavings.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677008", "conference_name": "POPL", "authors": [ { - "first_name": "Gilles", - "last_name": "Barthe", - "institution": "IMDEA Software" - }, - { - "first_name": "Marco", - "last_name": "Gaboardi", - "institution": "University of Dundee" + "first_name": "Ashutosh", + "last_name": "Gupta", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Emilio Jesús Gallego", - "last_name": "Arias", - "institution": "University of Pennsylvania" + "first_name": "Thomas A.", + "last_name": "Henzinger", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Justin", - "last_name": "Hsu", + "first_name": "Arjun", + "last_name": "Radhakrishna", "institution": "University of Pennsylvania" }, { - "first_name": "Aaron", - "last_name": "Roth", - "institution": "University of Pennsylvania" + "first_name": "Roopsha", + "last_name": "Samanta", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Pierre-Yves", - "last_name": "Strub", - "institution": "IMDEA Software" + "first_name": "Thorsten", + "last_name": "Tarrach", + "institution": "Institute of Science and Technology Austria" } ], - "dblp_key": "conf/popl/BartheGAHRS15", + "dblp_key": "conf/popl/GuptaHRST15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676968", - "title": "Quantitative Interprocedural Analysis", - "abstract": "We consider the quantitative analysis problem for interprocedural control-flow graphs (ICFGs). The input consists of an ICFG, a positive weight function that assigns every transition a positive integer-valued number, and a labelling of the transitions (events) as good, bad, and neutral events. The weight function assigns to each transition a numerical value that represents a measure of how good or bad an event is. The quantitative analysis problem asks whether there is a run of the ICFG where the ratio of the sum of the numerical weights of good events versus the sum of weights of bad events in the long-run is at least a given threshold (or equivalently, to compute the maximal ratio among all valid paths in the ICFG). The quantitative analysis problem for ICFGs can be solved in polynomial time, and we present an efficient and practical algorithm for the problem.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676968", + "paper_id": "10.1145/2676726.2676984", + "title": "A Calculus for Relaxed Memory", + "abstract": "We propose a new approach to programming multi-core, relaxed-memory architectures in imperative, portable programming languages. Our memory model is based on explicit, programmer-specified requirements for order of execution and the visibility of writes. The compiler then realizes those requirements in the most efficient manner it can. This is in contrast to existing memory models, which---if they allow programmer control over synchronization at all---are based on inferring the execution and visibility consequences of synchronization operations or annotations in the code.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676984", "conference_name": "POPL", "authors": [ { - "first_name": "Krishnendu", - "last_name": "Chatterjee", - "institution": "Institute of Science and Technology Austria" - }, - { - "first_name": "Andreas", - "last_name": "Pavlogiannis", - "institution": "Institute of Science and Technology Austria" + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" }, { - "first_name": "Yaron", - "last_name": "Velner", - "institution": "Tel Aviv University" + "first_name": "Michael J.", + "last_name": "Sullivan", + "institution": "Carnegie Mellon University" } ], - "dblp_key": "conf/popl/ChatterjeePV15", + "dblp_key": "conf/popl/CraryS15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676973", - "title": "Program Boosting: Program Synthesis via Crowd-Sourcing", - "abstract": "In this paper, we investigate an approach to program synthesis that is based on crowd-sourcing. With the help of crowd-sourcing, we aim to capture the \"wisdom of the crowds\" to find good if not perfect solutions to inherently tricky programming tasks, which elude even expert developers and lack an easy-to-formalize specification. We propose an approach we call program boosting, which involves crowd-sourcing imperfect solutions to a difficult programming problem from developers and then blending these programs together in a way that improves their correctness. We implement this approach in a system called CROWDBOOST and show in our experiments that interesting and highly non-trivial tasks such as writing regular expressions for URLs or email addresses can be effectively crowd-sourced. We demonstrate that carefully blending the crowd-sourced results together consistently produces a boost, yielding results that are better than any of the starting programs. Our experiments on 465 program pairs show consistent boosts in accuracy and demonstrate that program boosting can be performed at a relatively modest monetary cost.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676973", + "paper_id": "10.1145/2676726.2676977", + "title": "Specification Inference Using Context-Free Language Reachability", + "abstract": "We present a framework for computing context-free language reachability properties when parts of the program are missing. Our framework infers candidate specifications for missing program pieces that are needed for verifying a property of interest, and presents these specifications to a human auditor for validation. We have implemented this framework for a taint analysis of Android apps that relies on specifications for Android library methods. In an extensive experimental study on 179 apps, our tool performs verification with only a small number of queries to a human auditor.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676977", "conference_name": "POPL", "authors": [ { - "first_name": "R", - "last_name": "Cochran", - "institution": "University of North Carolina at Chapel Hill" - }, - { - "first_name": "Loris", - "last_name": "D’Antoni", - "institution": "University of Pennsylvania" - }, - { - "first_name": "Benjamin", - "last_name": "Livshits", - "institution": "Microsoft (United States)" + "first_name": "Osbert", + "last_name": "Bastani", + "institution": "Stanford University" }, { - "first_name": "Dávid", - "last_name": "Molnár", - "institution": "Microsoft (United States)" + "first_name": "Saswat", + "last_name": "Anand", + "institution": "Stanford University" }, { - "first_name": "Margus", - "last_name": "Veanes", - "institution": "Microsoft (United States)" + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" } ], - "dblp_key": "conf/popl/CochranDLMV15", + "dblp_key": "conf/popl/BastaniAA15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677002", - "title": "Tractable Refinement Checking for Concurrent Objects", - "abstract": "Efficient implementations of concurrent objects such as semaphores, locks, and atomic collections are essential to modern computing. Yet programming such objects is error prone: in minimizing the synchronization overhead between concurrent object invocations, one risks the conformance to reference implementations --- or in formal terms, one risks violating observational refinement. Testing this refinement even within a single execution is intractable, limiting existing approaches to executions with very few object invocations.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677002", + "paper_id": "10.1145/2676726.2676993", + "title": "Full Abstraction for Signal Flow Graphs", + "abstract": "Network theory uses the string diagrammatic language of monoidal categories to study graphical structures formally, eschewing specialised translations into intermediate formalisms. Recently, there has been a concerted research focus on developing a network theoretic approach to signal flow graphs, which are classical structures in control theory, signal processing and a cornerstone in the study of feedback. In this approach, signal flow graphs are given a relational denotational semantics in terms of formal power series.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676993", "conference_name": "POPL", "authors": [ { - "first_name": "Ahmed", - "last_name": "Bouajjani", - "institution": "Laboratoire d'Informatique Algorithmique: Fondements et Applications" - }, - { - "first_name": "Michael", - "last_name": "Emmi", - "institution": "Madrid Institute for Advanced Studies" + "first_name": "Filippo", + "last_name": "Bonchi", + "institution": "École Normale Supérieure de Lyon" }, { - "first_name": "Constantin", - "last_name": "Enea", - "institution": "Université Paris Cité" + "first_name": "Paweł", + "last_name": "Sobociński", + "institution": "Bournemouth University" }, { - "first_name": "Jad", - "last_name": "Hamza", - "institution": "Université Paris Cité" + "first_name": "Fabio", + "last_name": "Zanasi", + "institution": "École Normale Supérieure de Lyon" } ], - "dblp_key": "conf/popl/BouajjaniEEH15", + "dblp_key": "conf/popl/BonchiSZ15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676988", - "title": "Self-Representation in Girard's System U", - "abstract": "In 1991, Pfenning and Lee studied whether System F could support a typed self-interpreter. They concluded that typed self-representation for System F \"seems to be impossible\", but were able to represent System F in Fω. Further, they found that the representation of Fω requires kind polymorphism, which is outside Fω. In 2009, Rendel, Ostermann and Hofer conjectured that the representation of kind-polymorphic terms would require another, higher form of polymorphism. Is this a case of infinite regress? We show that it is not and present a typed self-representation for Girard's System U, the first for a λ-calculus with decidable type checking. System U extends System Fω with kind polymorphic terms and types. We show that kind polymorphic types (i.e. types that depend on kinds) are sufficient to \"tie the knot\" -- they enable representations of kind polymorphic terms without introducing another form of polymorphism. Our self-representation supports operations that iterate over a term, each of which can be applied to a representation of itself. We present three typed self-applicable operations: a self-interpreter that recovers a term from its representation, a predicate that tests the intensional structure of a term, and a typed continuation-passing-style (CPS) transformation -- the first typed self-applicable CPS transformation. Our techniques could have applications from verifiably type-preserving metaprograms, to growable typed languages, to more efficient self-interpreters.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676988", + "paper_id": "10.1145/2676726.2676981", + "title": "DReX: A Declarative Language for Efficiently Evaluating Regular String Transformations", + "abstract": "We present DReX, a declarative language that can express all regular string-to string transformations, and can still be efficiently evaluated. The class of regular string transformations has a robust theoretical foundation including multiple characterizations, closure properties, and decidable analysis questions, and admits a number of string operations such as insertion, deletion, substring swap, and reversal. Recent research has led to a characterization of regular string transformations using a primitive set of function combinators analogous to the definition of regular languages using regular expressions. While these combinators form the basis for the language DReX proposed in this paper, our main technical focus is on the complexity of evaluating the output of a DReX program on a given input string. It turns out that the natural evaluation algorithm involves dynamic programming, leading to complexity that is cubic in the length of the input string. Our main contribution is identifying a consistency restriction on the use of combinators in DReX programs, and a single-pass evaluation algorithm for consistent programs with time complexity that is linear in the length of the input string and polynomial in the size of the program. We show that the consistency restriction does not limit the expressiveness, and whether a DReX program is consistent can be checked efficiently. We report on a prototype implementation, and evaluate it using a representative set of text processing tasks.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676981", "conference_name": "POPL", "authors": [ { - "first_name": "Matt", - "last_name": "Brown", - "institution": "UCLA Health" + "first_name": "Rajeev", + "last_name": "Alur", + "institution": "University of Pennsylvania" }, { - "first_name": "Jens", - "last_name": "Palsberg", - "institution": "UCLA Health" + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Mukund", + "last_name": "Raghothaman", + "institution": "University of Pennsylvania" } ], - "dblp_key": "conf/popl/BrownP15", + "dblp_key": "conf/popl/AlurDR15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676991", - "title": "Polymorphic Functions with Set-Theoretic Types: Part 2: Local Type Inference and Type Reconstruction", - "abstract": "This article is the second part of a two articles series about the definition of higher order polymorphic functions in a type system with recursive types and set-theoretic type connectives (unions, intersections, and negations).", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676991", + "paper_id": "10.1145/2676726.2677005", + "title": "Differential Privacy: Now it's Getting Personal", + "abstract": "Differential privacy provides a way to get useful information about sensitive data without revealing much about any one individual. It enjoys many nice compositionality properties not shared by other approaches to privacy, including, in particular, robustness against side-knowledge.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677005", "conference_name": "POPL", "authors": [ { - "first_name": "Giuseppe", - "last_name": "Castagna", - "institution": "Sorbonne Paris Cité" - }, - { - "first_name": "Kim", - "last_name": "Nguyễn", - "institution": "Université Paris-Sud" + "first_name": "Hamid", + "last_name": "Ebadi", + "institution": "Chalmers University of Technology" }, { - "first_name": "Zhiwu", - "last_name": "Xu", - "institution": "China Southern Power Grid (China)" + "first_name": "David", + "last_name": "Sands", + "institution": "Chalmers University of Technology" }, { - "first_name": "Pietro", - "last_name": "Abate", - "institution": "Université Paris Cité" + "first_name": "Gerardo", + "last_name": "Schneider", + "institution": "University of Gothenburg" } ], - "dblp_key": "conf/popl/Castagna0XA15", + "dblp_key": "conf/popl/EbadiSS15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677003", - "title": "From Network Interface to Multithreaded Web Applications: A Case Study in Modular Program Verification", - "abstract": "Many verifications of realistic software systems are monolithic, in the sense that they define single global invariants over complete system state. More modular proof techniques promise to support reuse of component proofs and even reduce the effort required to verify one concrete system, just as modularity simplifies standard software development. This paper reports on one case study applying modular proof techniques in the Coq proof assistant. To our knowledge, it is the first modular verification certifying a system that combines infrastructure with an application of interest to end users. We assume a nonblocking API for managing TCP networking streams, and on top of that we work our way up to certifying multithreaded, database-backed Web applications. Key verified components include a cooperative threading library and an implementation of a domain-specific language for XML processing. We have deployed our case-study system on mobile robots, where it interfaces with off-the-shelf components for sensing, actuation, and control.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677003", + "paper_id": "10.1145/2676726.2676973", + "title": "Program Boosting: Program Synthesis via Crowd-Sourcing", + "abstract": "In this paper, we investigate an approach to program synthesis that is based on crowd-sourcing. With the help of crowd-sourcing, we aim to capture the \"wisdom of the crowds\" to find good if not perfect solutions to inherently tricky programming tasks, which elude even expert developers and lack an easy-to-formalize specification. We propose an approach we call program boosting, which involves crowd-sourcing imperfect solutions to a difficult programming problem from developers and then blending these programs together in a way that improves their correctness. We implement this approach in a system called CROWDBOOST and show in our experiments that interesting and highly non-trivial tasks such as writing regular expressions for URLs or email addresses can be effectively crowd-sourced. We demonstrate that carefully blending the crowd-sourced results together consistently produces a boost, yielding results that are better than any of the starting programs. Our experiments on 465 program pairs show consistent boosts in accuracy and demonstrate that program boosting can be performed at a relatively modest monetary cost.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676973", "conference_name": "POPL", "authors": [ { - "first_name": "Adam", - "last_name": "Chlipala", - "institution": "Massachusetts Institute of Technology" + "first_name": "R", + "last_name": "Cochran", + "institution": "University of North Carolina at Chapel Hill" + }, + { + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dávid", + "last_name": "Molnár", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" } ], - "dblp_key": "conf/popl/Chlipala15a", + "dblp_key": "conf/popl/CochranDLMV15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676977", - "title": "Specification Inference Using Context-Free Language Reachability", - "abstract": "We present a framework for computing context-free language reachability properties when parts of the program are missing. Our framework infers candidate specifications for missing program pieces that are needed for verifying a property of interest, and presents these specifications to a human auditor for validation. We have implemented this framework for a taint analysis of Android apps that relies on specifications for Android library methods. In an extensive experimental study on 179 apps, our tool performs verification with only a small number of queries to a human auditor.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676977", + "paper_id": "10.1145/2676726.2676988", + "title": "Self-Representation in Girard's System U", + "abstract": "In 1991, Pfenning and Lee studied whether System F could support a typed self-interpreter. They concluded that typed self-representation for System F \"seems to be impossible\", but were able to represent System F in Fω. Further, they found that the representation of Fω requires kind polymorphism, which is outside Fω. In 2009, Rendel, Ostermann and Hofer conjectured that the representation of kind-polymorphic terms would require another, higher form of polymorphism. Is this a case of infinite regress? We show that it is not and present a typed self-representation for Girard's System U, the first for a λ-calculus with decidable type checking. System U extends System Fω with kind polymorphic terms and types. We show that kind polymorphic types (i.e. types that depend on kinds) are sufficient to \"tie the knot\" -- they enable representations of kind polymorphic terms without introducing another form of polymorphism. Our self-representation supports operations that iterate over a term, each of which can be applied to a representation of itself. We present three typed self-applicable operations: a self-interpreter that recovers a term from its representation, a predicate that tests the intensional structure of a term, and a typed continuation-passing-style (CPS) transformation -- the first typed self-applicable CPS transformation. Our techniques could have applications from verifiably type-preserving metaprograms, to growable typed languages, to more efficient self-interpreters.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676988", "conference_name": "POPL", "authors": [ { - "first_name": "Osbert", - "last_name": "Bastani", - "institution": "Stanford University" - }, - { - "first_name": "Saswat", - "last_name": "Anand", - "institution": "Stanford University" + "first_name": "Matt", + "last_name": "Brown", + "institution": "UCLA Health" }, { - "first_name": "Alex", - "last_name": "Aiken", - "institution": "Stanford University" + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "UCLA Health" } ], - "dblp_key": "conf/popl/BastaniAA15", + "dblp_key": "conf/popl/BrownP15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676993", - "title": "Full Abstraction for Signal Flow Graphs", - "abstract": "Network theory uses the string diagrammatic language of monoidal categories to study graphical structures formally, eschewing specialised translations into intermediate formalisms. Recently, there has been a concerted research focus on developing a network theoretic approach to signal flow graphs, which are classical structures in control theory, signal processing and a cornerstone in the study of feedback. In this approach, signal flow graphs are given a relational denotational semantics in terms of formal power series.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676993", + "paper_id": "10.1145/2676726.2676963", + "title": "A Scalable, Correct Time-Stamped Stack", + "abstract": "Concurrent data-structures, such as stacks, queues, and deques, often implicitly enforce a total order over elements in their underlying memory layout. However, much of this order is unnecessary: linearizability only requires that elements are ordered if the insert methods ran in sequence. We propose a new approach which uses timestamping to avoid unnecessary ordering. Pairs of elements can be left unordered if their associated insert operations ran concurrently, and order imposed as necessary at the eventual removal.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676963", "conference_name": "POPL", "authors": [ { - "first_name": "Filippo", - "last_name": "Bonchi", - "institution": "École Normale Supérieure de Lyon" + "first_name": "Mike", + "last_name": "Dodds", + "institution": "University of York" }, { - "first_name": "Paweł", - "last_name": "Sobociński", - "institution": "Bournemouth University" + "first_name": "Andreas", + "last_name": "Haas", + "institution": "University of Salzburg" }, { - "first_name": "Fabio", - "last_name": "Zanasi", - "institution": "École Normale Supérieure de Lyon" + "first_name": "Christoph", + "last_name": "Kirsch", + "institution": "University of Salzburg" } ], - "dblp_key": "conf/popl/BonchiSZ15", + "dblp_key": "conf/popl/DoddsHK15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676981", - "title": "DReX: A Declarative Language for Efficiently Evaluating Regular String Transformations", - "abstract": "We present DReX, a declarative language that can express all regular string-to string transformations, and can still be efficiently evaluated. The class of regular string transformations has a robust theoretical foundation including multiple characterizations, closure properties, and decidable analysis questions, and admits a number of string operations such as insertion, deletion, substring swap, and reversal. Recent research has led to a characterization of regular string transformations using a primitive set of function combinators analogous to the definition of regular languages using regular expressions. While these combinators form the basis for the language DReX proposed in this paper, our main technical focus is on the complexity of evaluating the output of a DReX program on a given input string. It turns out that the natural evaluation algorithm involves dynamic programming, leading to complexity that is cubic in the length of the input string. Our main contribution is identifying a consistency restriction on the use of combinators in DReX programs, and a single-pass evaluation algorithm for consistent programs with time complexity that is linear in the length of the input string and polynomial in the size of the program. We show that the consistency restriction does not limit the expressiveness, and whether a DReX program is consistent can be checked efficiently. We report on a prototype implementation, and evaluate it using a representative set of text processing tasks.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676981", + "paper_id": "10.1145/2676726.2676968", + "title": "Quantitative Interprocedural Analysis", + "abstract": "We consider the quantitative analysis problem for interprocedural control-flow graphs (ICFGs). The input consists of an ICFG, a positive weight function that assigns every transition a positive integer-valued number, and a labelling of the transitions (events) as good, bad, and neutral events. The weight function assigns to each transition a numerical value that represents a measure of how good or bad an event is. The quantitative analysis problem asks whether there is a run of the ICFG where the ratio of the sum of the numerical weights of good events versus the sum of weights of bad events in the long-run is at least a given threshold (or equivalently, to compute the maximal ratio among all valid paths in the ICFG). The quantitative analysis problem for ICFGs can be solved in polynomial time, and we present an efficient and practical algorithm for the problem.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676968", "conference_name": "POPL", "authors": [ { - "first_name": "Rajeev", - "last_name": "Alur", - "institution": "University of Pennsylvania" + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Loris", - "last_name": "D’Antoni", - "institution": "University of Pennsylvania" + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Mukund", - "last_name": "Raghothaman", - "institution": "University of Pennsylvania" + "first_name": "Yaron", + "last_name": "Velner", + "institution": "Tel Aviv University" } ], - "dblp_key": "conf/popl/AlurDR15", + "dblp_key": "conf/popl/ChatterjeePV15", "venue": "popl", "year": 2015 }, @@ -408,7 +420,7 @@ "paper_id": "10.1145/2676726.2676979", "title": "Faster Algorithms for Algebraic Path Properties in Recursive State Machines with Constant Treewidth", "abstract": "Interprocedural analysis is at the heart of numerous applications in programming languages, such as alias analysis, constant propagation, etc. Recursive state machines (RSMs) are standard models for interprocedural analysis. We consider a general framework with RSMs where the transitions are labeled from a semiring, and path properties are algebraic with semiring operations. RSMs with algebraic path properties can model interprocedural dataflow analysis problems, the shortest path problem, the most probable path problem, etc. The traditional algorithms for interprocedural analysis focus on path properties where the starting point is fixed as the entry point of a specific method. In this work, we consider possible multiple queries as required in many applications such as in alias analysis. The study of multiple queries allows us to bring in a very important algorithmic distinction between the resource usage of the one-time preprocessing vs for each individual query. The second aspect that we consider is that the control flow graphs for most programs have constant treewidth. Our main contributions are simple and implementable algorithms that support multiple queries for algebraic path properties for RSMs that have constant treewidth. Our theoretical results show that our algorithms have small additional one-time preprocessing, but can answer subsequent queries significantly faster as compared to the current best-known solutions for several important problems, such as interprocedural reachability and shortest path. We provide a prototype implementation for interprocedural reachability and intraprocedural shortest path that gives a significant speed-up on several benchmarks.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676979", "conference_name": "POPL", "authors": [ @@ -438,409 +450,328 @@ "year": 2015 }, { - "paper_id": "10.1145/2676726.2676984", - "title": "A Calculus for Relaxed Memory", - "abstract": "We propose a new approach to programming multi-core, relaxed-memory architectures in imperative, portable programming languages. Our memory model is based on explicit, programmer-specified requirements for order of execution and the visibility of writes. The compiler then realizes those requirements in the most efficient manner it can. This is in contrast to existing memory models, which---if they allow programmer control over synchronization at all---are based on inferring the execution and visibility consequences of synchronization operations or annotations in the code.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676984", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Karl", - "last_name": "Crary", - "institution": "Carnegie Mellon University" - }, - { - "first_name": "Michael J.", - "last_name": "Sullivan", - "institution": "Carnegie Mellon University" - } - ], - "dblp_key": "conf/popl/CraryS15", - "venue": "popl", - "year": 2015 - }, - { - "paper_id": "10.1145/2676726.2677006", - "title": "Fiat: Deductive Synthesis of Abstract Data Types in a Proof Assistant", - "abstract": "We present Fiat, a library for the Coq proof assistant supporting refinement of declarative specifications into efficient functional programs with a high degree of automation. Each refinement process leaves a proof trail, checkable by the normal Coq kernel, justifying its soundness. We focus on the synthesis of abstract data types that package methods with private data. We demonstrate the utility of our framework by applying it to the synthesis of query structures -- abstract data types with SQL-like query and insert operations. Fiat includes a library for writing specifications of query structures in SQL-inspired notation, expressing operations over relations (tables) in terms of mathematical sets. This library includes a suite of tactics for automating the refinement of specifications into efficient, correct-by-construction OCaml code. Using these tactics, a programmer can generate such an implementation completely automatically by only specifying the equivalent of SQL indexes, data structures capturing useful views of the abstract data. Throughout we speculate on the new programming modularity possibilities enabled by an automated refinement system with proved-correct rules.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677006", + "paper_id": "10.1145/2676726.2677002", + "title": "Tractable Refinement Checking for Concurrent Objects", + "abstract": "Efficient implementations of concurrent objects such as semaphores, locks, and atomic collections are essential to modern computing. Yet programming such objects is error prone: in minimizing the synchronization overhead between concurrent object invocations, one risks the conformance to reference implementations --- or in formal terms, one risks violating observational refinement. Testing this refinement even within a single execution is intractable, limiting existing approaches to executions with very few object invocations.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677002", "conference_name": "POPL", "authors": [ { - "first_name": "Benjamin", - "last_name": "Delaware", - "institution": "Massachusetts Institute of Technology" + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Laboratoire d'Informatique Algorithmique: Fondements et Applications" }, { - "first_name": "Clément", - "last_name": "Pit-Claudel", - "institution": "" + "first_name": "Michael", + "last_name": "Emmi", + "institution": "Madrid Institute for Advanced Studies" }, { - "first_name": "Jason", - "last_name": "Gross", - "institution": "" + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Université Paris Cité" }, { - "first_name": "Adam", - "last_name": "Chlipala", - "institution": "" + "first_name": "Jad", + "last_name": "Hamza", + "institution": "Université Paris Cité" } ], - "dblp_key": "conf/popl/DelawarePGC15", + "dblp_key": "conf/popl/BouajjaniEEH15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677005", - "title": "Differential Privacy: Now it's Getting Personal", - "abstract": "Differential privacy provides a way to get useful information about sensitive data without revealing much about any one individual. It enjoys many nice compositionality properties not shared by other approaches to privacy, including, in particular, robustness against side-knowledge.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677005", + "paper_id": "10.1145/2676726.2677012", + "title": "Proof Spaces for Unbounded Parallelism", + "abstract": "In this paper, we present a new approach to automatically ver-ify multi-threaded programs which are executed by an unbounded number of threads running in parallel. The starting point for our work is the problem of how we can leverage existing automated verification technology for sequential programs (abstract interpretation, Craig interpolation, constraint solving, etc.) for multi-threaded programs. Suppose that we are given a correctness proof for a trace of a program (or for some other program fragment). We observe that the proof can always be decomposed into a finite set of Hoare triples, and we ask what can be proved from the finite set of Hoare triples using only simple combinatorial inference rules (without access to a theorem prover and without the possibility to infer genuinely new Hoare triples)? We introduce a proof system where one proves the correctness of a multi-threaded program by showing that for each trace of the program, there exists a correctness proof in the space of proofs that are derivable from a finite set of axioms using simple combinatorial inference rules. This proof system is complete with respect to the classical proof method of establishing an inductive invariant (which uses thread quantification and control predicates). Moreover, it is possible to algorithmically check whether a given set of axioms is sufficient to prove the correctness of a multi-threaded program, using ideas from well-structured transition systems. 1.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677012", "conference_name": "POPL", "authors": [ { - "first_name": "Hamid", - "last_name": "Ebadi", - "institution": "Chalmers University of Technology" + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" }, { - "first_name": "David", - "last_name": "Sands", - "institution": "Chalmers University of Technology" + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "University of Toronto" }, { - "first_name": "Gerardo", - "last_name": "Schneider", - "institution": "University of Gothenburg" - } - ], - "dblp_key": "conf/popl/EbadiSS15", - "venue": "popl", - "year": 2015 - }, - { - "paper_id": "10.1145/2676726.2682621", - "title": "Automating Repetitive Tasks for the Masses", - "abstract": "The programming languages (PL) research community has traditionally catered to the needs of professional programmers in the continuously evolving technical industry. However, there is a new opportunity that knocks our doors. The recent IT revolution has resulted in the masses having access to personal computing devices. More than 99% of these computer users are non-programmers and are today limited to being passive consumers of the software that is made available to them. Can we empower these users to more effectively leverage computers for their daily tasks? The formalisms, techniques, and tools developed in the PL and the formal methods research communities can play a pivotal role!", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2682621", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Sumit", - "last_name": "Gulwani", - "institution": "Microsoft (United States)" + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" } ], - "dblp_key": "conf/popl/Gulwani15", + "dblp_key": "conf/popl/FarzanKP15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676967", - "title": "Space-Efficient Manifest Contracts", - "abstract": "The standard algorithm for higher-order contract checking can lead to unbounded space consumption and can destroy tail recursion, altering a program's asymptotic space complexity. While space efficiency for gradual types---contracts mediating untyped and typed code---is well studied, sound space efficiency for manifest contracts---contracts that check stronger properties than simple types, e.g., \"is a natural'' instead of \"is an integer''---remains an open problem.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676967", + "paper_id": "10.1145/2676726.2677003", + "title": "From Network Interface to Multithreaded Web Applications: A Case Study in Modular Program Verification", + "abstract": "Many verifications of realistic software systems are monolithic, in the sense that they define single global invariants over complete system state. More modular proof techniques promise to support reuse of component proofs and even reduce the effort required to verify one concrete system, just as modularity simplifies standard software development. This paper reports on one case study applying modular proof techniques in the Coq proof assistant. To our knowledge, it is the first modular verification certifying a system that combines infrastructure with an application of interest to end users. We assume a nonblocking API for managing TCP networking streams, and on top of that we work our way up to certifying multithreaded, database-backed Web applications. Key verified components include a cooperative threading library and an implementation of a domain-specific language for XML processing. We have deployed our case-study system on mobile robots, where it interfaces with off-the-shelf components for sensing, actuation, and control.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677003", "conference_name": "POPL", "authors": [ { - "first_name": "Michael", - "last_name": "Greenberg", - "institution": "Princeton University" + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" } ], - "dblp_key": "conf/popl/Greenberg15", + "dblp_key": "conf/popl/Chlipala15a", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676963", - "title": "A Scalable, Correct Time-Stamped Stack", - "abstract": "Concurrent data-structures, such as stacks, queues, and deques, often implicitly enforce a total order over elements in their underlying memory layout. However, much of this order is unnecessary: linearizability only requires that elements are ordered if the insert methods ran in sequence. We propose a new approach which uses timestamping to avoid unnecessary ordering. Pairs of elements can be left unordered if their associated insert operations ran concurrently, and order imposed as necessary at the eventual removal.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676963", + "paper_id": "10.1145/2676726.2676969", + "title": "Integrating Linear and Dependent Types", + "abstract": "In this paper, we show how to integrate linear types with type dependency, by extending the linear/non-linear calculus of Benton to support type dependency. Next, we give an application of this calculus by giving a proof-theoretic account of imperative programming, which requires extending the calculus with computationally irrelevant quantification, proof irrelevance, and a monad of computations. We show the soundness of our theory by giving a realizability model in the style of Nuprl, which permits us to validate not only the beta-laws for each type, but also the eta-laws. These extensions permit us to decompose Hoare triples into a collection of simpler type-theoretic connectives, yielding a rich equational theory for dependently-typed higher-order imperative programs. Furthermore, both the type theory and its model are relatively simple, even when all of the extensions are considered.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676969", "conference_name": "POPL", "authors": [ { - "first_name": "Mike", - "last_name": "Dodds", - "institution": "University of York" + "first_name": "Neelakantan R.", + "last_name": "Krishnaswami", + "institution": "University of Birmingham" }, { - "first_name": "Andreas", - "last_name": "Haas", - "institution": "University of Salzburg" + "first_name": "Pierre", + "last_name": "Pradic", + "institution": "École Normale Supérieure de Lyon" }, { - "first_name": "Christoph", - "last_name": "Kirsch", - "institution": "University of Salzburg" + "first_name": "Nick", + "last_name": "Benton", + "institution": "Microsoft (United States)" } ], - "dblp_key": "conf/popl/DoddsHK15", + "dblp_key": "conf/popl/KrishnaswamiPB15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677010", - "title": "On Characterizing the Data Access Complexity of Programs", - "abstract": "Technology trends will cause data movement to account for the majority of energy expenditure and execution time on emerging computers. Therefore, computational complexity will no longer be a sufficient metric for comparing algorithms, and a fundamental characterization of data access complexity will be increasingly important. The problem of developing lower bounds for data access complexity has been modeled using the formalism of Hong and Kung's red/blue pebble game for computational directed acyclic graphs (CDAGs). However, previously developed approaches to lower bounds analysis for the red/blue pebble game are very limited in effectiveness when applied to CDAGs of real programs, with computations comprised of multiple sub-computations with differing DAG structure. We address this problem by developing an approach for effectively composing lower bounds based on graph decomposition. We also develop a static analysis algorithm to derive the asymptotic data-access lower bounds of programs, as a function of the problem size and cache size.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677010", + "paper_id": "10.1145/2676726.2677013", + "title": "Towards the Essence of Hygiene", + "abstract": "Hygiene is an essential aspect of Scheme's macro system that prevents unintended variable capture. However, previous work on hygiene has focused on algorithmic implementation rather than precise, mathematical definition of what constitutes hygiene. This is in stark contrast with lexical scope, alpha-equivalence and capture-avoiding substitution, which also deal with preventing unintended variable capture but have widely applicable and well-understood mathematical definitions.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677013", "conference_name": "POPL", "authors": [ { - "first_name": "Venmugil", - "last_name": "Elango", - "institution": "The Ohio State University" - }, - { - "first_name": "Fabrice", - "last_name": "Rastello", - "institution": "Institut national de recherche en informatique et en automatique" - }, - { - "first_name": "Louis-Noël", - "last_name": "Pouchet", - "institution": "The Ohio State University" - }, - { - "first_name": "J.", - "last_name": "Ramanujam", - "institution": "Louisiana State University" - }, - { - "first_name": "P.", - "last_name": "Sadayappan", - "institution": "The Ohio State University" + "first_name": "Michael D.", + "last_name": "Adams", + "institution": "University of Utah" } ], - "dblp_key": "conf/popl/ElangoRPRS15", + "dblp_key": "conf/popl/Adams15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677012", - "title": "Proof Spaces for Unbounded Parallelism", - "abstract": "In this paper, we present a new approach to automatically ver-ify multi-threaded programs which are executed by an unbounded number of threads running in parallel. The starting point for our work is the problem of how we can leverage existing automated verification technology for sequential programs (abstract interpretation, Craig interpolation, constraint solving, etc.) for multi-threaded programs. Suppose that we are given a correctness proof for a trace of a program (or for some other program fragment). We observe that the proof can always be decomposed into a finite set of Hoare triples, and we ask what can be proved from the finite set of Hoare triples using only simple combinatorial inference rules (without access to a theorem prover and without the possibility to infer genuinely new Hoare triples)? We introduce a proof system where one proves the correctness of a multi-threaded program by showing that for each trace of the program, there exists a correctness proof in the space of proofs that are derivable from a finite set of axioms using simple combinatorial inference rules. This proof system is complete with respect to the classical proof method of establishing an inductive invariant (which uses thread quantification and control predicates). Moreover, it is possible to algorithmically check whether a given set of axioms is sufficient to prove the correctness of a multi-threaded program, using ideas from well-structured transition systems. 1.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677012", + "paper_id": "10.1145/2676726.2677004", + "title": "Ur/Web: A Simple Model for Programming the Web", + "abstract": "The World Wide Web has evolved gradually from a document delivery platform to an architecture for distributed programming. This largely unplanned evolution is apparent in the set of interconnected languages and protocols that any Web application must manage. This paper presents Ur/Web, a domain-specific, statically typed functional programming language with a much simpler model for programming modern Web applications. Ur/Web's model is unified, where programs in a single programming language are compiled to other \"Web standards\" languages as needed; supports novel kinds of encapsulation of Web-specific state; and exposes simple concurrency, where programmers can reason about distributed, multithreaded applications via a mix of transactions and cooperative preemption. We give a tutorial introduction to the main features of Ur/Web and discuss the language implementation and the production Web applications that use it.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677004", "conference_name": "POPL", "authors": [ { - "first_name": "Azadeh", - "last_name": "Farzan", - "institution": "University of Toronto" - }, - { - "first_name": "Zachary", - "last_name": "Kincaid", - "institution": "University of Toronto" - }, - { - "first_name": "Andreas", - "last_name": "Podelski", - "institution": "University of Freiburg" + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" } ], - "dblp_key": "conf/popl/FarzanKP15", + "dblp_key": "conf/popl/Chlipala15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676975", - "title": "Deep Specifications and Certified Abstraction Layers", - "abstract": "Modern computer systems consist of a multitude of abstraction layers (e.g., OS kernels, hypervisors, device drivers, network protocols), each of which defines an interface that hides the implementation details of a particular set of functionality. Client programs built on top of each layer can be understood solely based on the interface, independent of the layer implementation. Despite their obvious importance, abstraction layers have mostly been treated as a system concept; they have almost never been formally specified or verified. This makes it difficult to establish strong correctness properties, and to scale program verification across multiple layers.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676975", + "paper_id": "10.1145/2676726.2676989", + "title": "Conjugate Hylomorphisms - Or: The Mother of All Structured Recursion Schemes", + "abstract": "The past decades have witnessed an extensive study of structured recursion schemes. A general scheme is the hylomorphism, which captures the essence of divide-and-conquer: a problem is broken into sub-problems by a coalgebra; sub-problems are solved recursively; the sub-solutions are combined by an algebra to form a solution. In this paper we develop a simple toolbox for assembling recursive coalgebras, which by definition ensure that their hylo equations have unique solutions, whatever the algebra. Our main tool is the conjugate rule, a generic rule parametrized by an adjunction and a conjugate pair of natural transformations. We show that many basic adjunctions induce useful recursion schemes. In fact, almost every structured recursion scheme seems to arise as an instance of the conjugate rule. Further, we adapt our toolbox to the more expressive setting of parametrically recursive coalgebras, where the original input is also passed to the algebra. The formal development is complemented by a series of worked-out examples in Haskell.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676989", "conference_name": "POPL", "authors": [ { - "first_name": "Ronghui", - "last_name": "Gu", - "institution": "Yale University" - }, - { - "first_name": "Jérémie", - "last_name": "Koenig", - "institution": "Yale University" - }, - { - "first_name": "Tahina", - "last_name": "Ramananandro", - "institution": "Yale University" - }, - { - "first_name": "Zhong", - "last_name": "Shao", - "institution": "Yale University" + "first_name": "Ralf", + "last_name": "Hinze", + "institution": "University of Oxford" }, { - "first_name": "Xiongnan", + "first_name": "Nicolas", "last_name": "Wu", - "institution": "Yale University" - }, - { - "first_name": "Shu-Chun", - "last_name": "Weng", - "institution": "Yale University" - }, - { - "first_name": "Haozhong", - "last_name": "Zhang", - "institution": "University of Science and Technology of China" + "institution": "University of Oxford" }, { - "first_name": "Yu", - "last_name": "Guo", - "institution": "University of Science and Technology of China" + "first_name": "Jeremy", + "last_name": "Gibbons", + "institution": "University of Oxford" } ], - "dblp_key": "conf/popl/GuKRSWWZG15", + "dblp_key": "conf/popl/HinzeWG15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676987", - "title": "Analyzing Program Analyses", - "abstract": "We want to prove that a static analysis of a given program is complete, namely, no imprecision arises when asking some query on the program behavior in the concrete (ie, for its concrete semantics) or in the abstract (ie, for its abstract interpretation). Completeness proofs are therefore useful to assign confidence to alarms raised by static analyses. We introduce the completeness class of an abstraction as the set of all programs for which the abstraction is complete. Our first result shows that for any nontrivial abstraction, its completeness class is not recursively enumerable. We then introduce a stratified deductive system to prove the completeness of program analyses over an abstract domain A. We prove the soundness of the deductive system. We observe that the only sources of incompleteness are assignments and Boolean tests --- unlikely a common belief in static analysis, joins do not induce incompleteness. The first layer of this proof system is generic, abstraction-agnostic, and it deals with the standard constructs for program composition, that is, sequential composition, branching and guarded iteration. The second layer is instead abstraction-specific: the designer of an abstract domain A provides conditions for completeness in A of assignments and Boolean tests which have to be checked by a suitable static analysis or assumed in the completeness proof as hypotheses. We instantiate the second layer of this proof system first with a generic nonrelational abstraction in order to provide a sound rule for the completeness of assignments. Orthogonally, we instantiate it to the numerical abstract domains of Intervals and Octagons, providing necessary and sufficient conditions for the completeness of their Boolean tests and of assignments for Octagons.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676987", + "paper_id": "10.1145/2676726.2676991", + "title": "Polymorphic Functions with Set-Theoretic Types: Part 2: Local Type Inference and Type Reconstruction", + "abstract": "This article is the second part of a two articles series about the definition of higher order polymorphic functions in a type system with recursive types and set-theoretic type connectives (unions, intersections, and negations).", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676991", "conference_name": "POPL", "authors": [ { - "first_name": "Roberto", - "last_name": "Giacobazzi", - "institution": "University of Verona" + "first_name": "Giuseppe", + "last_name": "Castagna", + "institution": "Sorbonne Paris Cité" }, { - "first_name": "Francesco", - "last_name": "Logozzo", - "institution": "Microsoft (United States)" + "first_name": "Kim", + "last_name": "Nguyễn", + "institution": "Université Paris-Sud" }, { - "first_name": "Francesco", - "last_name": "Ranzato", - "institution": "University of Padua" + "first_name": "Zhiwu", + "last_name": "Xu", + "institution": "China Southern Power Grid (China)" + }, + { + "first_name": "Pietro", + "last_name": "Abate", + "institution": "Université Paris Cité" } ], - "dblp_key": "conf/popl/GiacobazziLR15", + "dblp_key": "conf/popl/Castagna0XA15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676989", - "title": "Conjugate Hylomorphisms - Or: The Mother of All Structured Recursion Schemes", - "abstract": "The past decades have witnessed an extensive study of structured recursion schemes. A general scheme is the hylomorphism, which captures the essence of divide-and-conquer: a problem is broken into sub-problems by a coalgebra; sub-problems are solved recursively; the sub-solutions are combined by an algebra to form a solution. In this paper we develop a simple toolbox for assembling recursive coalgebras, which by definition ensure that their hylo equations have unique solutions, whatever the algebra. Our main tool is the conjugate rule, a generic rule parametrized by an adjunction and a conjugate pair of natural transformations. We show that many basic adjunctions induce useful recursion schemes. In fact, almost every structured recursion scheme seems to arise as an instance of the conjugate rule. Further, we adapt our toolbox to the more expressive setting of parametrically recursive coalgebras, where the original input is also passed to the algebra. The formal development is complemented by a series of worked-out examples in Haskell.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676989", + "paper_id": "10.1145/2676726.2677006", + "title": "Fiat: Deductive Synthesis of Abstract Data Types in a Proof Assistant", + "abstract": "We present Fiat, a library for the Coq proof assistant supporting refinement of declarative specifications into efficient functional programs with a high degree of automation. Each refinement process leaves a proof trail, checkable by the normal Coq kernel, justifying its soundness. We focus on the synthesis of abstract data types that package methods with private data. We demonstrate the utility of our framework by applying it to the synthesis of query structures -- abstract data types with SQL-like query and insert operations. Fiat includes a library for writing specifications of query structures in SQL-inspired notation, expressing operations over relations (tables) in terms of mathematical sets. This library includes a suite of tactics for automating the refinement of specifications into efficient, correct-by-construction OCaml code. Using these tactics, a programmer can generate such an implementation completely automatically by only specifying the equivalent of SQL indexes, data structures capturing useful views of the abstract data. Throughout we speculate on the new programming modularity possibilities enabled by an automated refinement system with proved-correct rules.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677006", "conference_name": "POPL", "authors": [ { - "first_name": "Ralf", - "last_name": "Hinze", - "institution": "University of Oxford" + "first_name": "Benjamin", + "last_name": "Delaware", + "institution": "Massachusetts Institute of Technology" }, { - "first_name": "Nicolas", - "last_name": "Wu", - "institution": "University of Oxford" + "first_name": "Clément", + "last_name": "Pit-Claudel", + "institution": "" + }, + { + "first_name": "Jason", + "last_name": "Gross", + "institution": "" }, { - "first_name": "Jeremy", - "last_name": "Gibbons", - "institution": "University of Oxford" + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "" } ], - "dblp_key": "conf/popl/HinzeWG15", + "dblp_key": "conf/popl/DelawarePGC15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677001", - "title": "Probabilistic Termination: Soundness, Completeness, and Compositionality", - "abstract": "We propose a framework to prove almost sure termination for probabilistic programs with real valued variables. It is based on ranking supermartingales, a notion analogous to ranking functions on non-probabilistic programs. The framework is proven sound and complete for a meaningful class of programs involving randomization and bounded nondeterminism. We complement this foundational insigh by a practical proof methodology, based on sound conditions that enable compositional reasoning and are amenable to a direct implementation using modern theorem provers. This is integrated in a small dependent type system, to overcome the problem that lexicographic ranking functions fail when combined with randomization. Among others, this compositional methodology enables the verification of probabilistic programs outside the complete class that admits ranking supermartingales.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677001", + "paper_id": "10.1145/2676726.2677000", + "title": "Higher-Order Approximate Relational Refinement Types for Mechanism Design and Differential Privacy", + "abstract": "Mechanism design is the study of algorithm design where the inputs to the algorithm are controlled by strategic agents, who must be incentivized to faithfully report them. Unlike typical programmatic properties, it is not sufficient for algorithms to merely satisfy the property, incentive properties are only useful if the strategic agents also believe this fact.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677000", "conference_name": "POPL", "authors": [ { - "first_name": "Luis María Ferrer", - "last_name": "Fioriti", - "institution": "Saarland University" + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" }, { - "first_name": "Holger", - "last_name": "Hermanns", - "institution": "Saarland University" + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "University of Dundee" + }, + { + "first_name": "Emilio Jesús Gallego", + "last_name": "Arias", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Aaron", + "last_name": "Roth", + "institution": "University of Pennsylvania" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "IMDEA Software" } ], - "dblp_key": "conf/popl/FioritiH15", + "dblp_key": "conf/popl/BartheGAHRS15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677011", - "title": "A Coalgebraic Decision Procedure for NetKAT", - "abstract": "NetKAT is a domain-specific language and logic for specifying and verifying network packet-processing functions. It consists of Kleene algebra with tests (KAT) augmented with primitives for testing and modifying packet headers and encoding network topologies. Previous work developed the design of the language and its standard semantics, proved the soundness and completeness of the logic, defined a PSPACE algorithm for deciding equivalence, and presented several practical applications.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677011", + "paper_id": "10.1145/2676726.2676972", + "title": "Sound Modular Verification of C Code Executing in an Unverified Context", + "abstract": "Over the past decade, great progress has been made in the static modular verification of C code by means of separation logic-based program logics. However, the runtime guarantees offered by such verification are relatively limited when the verified modules are part of a whole program that also contains unverified modules. In particular, a memory safety error in an unverified module can corrupt the runtime state, leading to assertion failures or invalid memory accesses in the verified modules. This paper develops runtime checks to be inserted at the boundary between the verified and the unverified part of a program, to guarantee that no assertion failures or invalid memory accesses can occur at runtime in any verified module. One of the key challenges is enforcing the separation logic frame rule, which we achieve by checking the integrity of the footprint of the verified part of the program on each control flow transition from the unverified to the verified part. This in turn requires the presence of some support for module-private memory at runtime. We formalize our approach and prove soundness. We implement the necessary runtime checks by means of a program transformation that translates C code with separation logic annotations into plain C, and that relies on a protected module architecture for providing module-private memory and restricted module entry points. Benchmarks show the performance impact of this transformation depends on the choice of boundary between the verified and unverified parts of the program, but is below 4% for real-world applications.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676972", "conference_name": "POPL", "authors": [ { - "first_name": "Nate", - "last_name": "Foster", - "institution": "Cornell University" - }, - { - "first_name": "Dexter", - "last_name": "Kozen", - "institution": "Cornell University" - }, - { - "first_name": "Mae", - "last_name": "Milano", - "institution": "Cornell University" + "first_name": "Pieter", + "last_name": "Agten", + "institution": "KU Leuven" }, { - "first_name": "Alexandra", - "last_name": "Silva", - "institution": "Radboud University Nijmegen" + "first_name": "Bart", + "last_name": "Jacobs", + "institution": "KU Leuven" }, { - "first_name": "Laure", - "last_name": "Thompson", - "institution": "Cornell University" + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" } ], - "dblp_key": "conf/popl/FosterKM0T15", + "dblp_key": "conf/popl/Agten0P15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676992", - "title": "Principal Type Schemes for Gradual Programs", - "abstract": "Gradual typing is a discipline for integrating dynamic checking into a static type system. Since its introduction in functional languages, it has been adapted to a variety of type systems, including object-oriented, security, and substructural. This work studies its application to implicitly typed languages based on type inference. Siek and Vachharajani designed a gradual type inference system and algorithm that infers gradual types but still rejects ill-typed static programs. However, the type system requires local reasoning about type substitutions, an imperative inference algorithm, and a subtle correctness statement.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676992", + "paper_id": "10.1145/2676726.2682620", + "title": "Databases and Programming: Two Subjects Divided by a Common Language?", + "abstract": "The 1990s saw a hugely productive interaction between database and programming language research. Ideas about type systems from programming languages played a central role in generalizing and adapting relational database systems to new data models. At the same time databases provided some of the best concrete examples of the application of concurrency theory and of the benefits of high-level optimization in functional programming languages. One of the driving ambitions behind this research was the idea that database access should be properly embedded in programming languages: one should not have to be bilingual in order to use a database from a programming language; and that goal has to some extent been realized.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2682620", "conference_name": "POPL", "authors": [ { - "first_name": "Ronald", - "last_name": "Garcia", - "institution": "University of British Columbia" - }, - { - "first_name": "Matteo", - "last_name": "Cimini", - "institution": "Indiana University Bloomington" + "first_name": "Peter", + "last_name": "Buneman", + "institution": "University of Edinburgh" } ], - "dblp_key": "conf/popl/GarciaC15", + "dblp_key": "conf/popl/Buneman15", "venue": "popl", "year": 2015 }, @@ -848,7 +779,7 @@ "paper_id": "10.1145/2676726.2676998", "title": "Leveraging Weighted Automata in Compositional Reasoning about Concurrent Probabilistic Systems", "abstract": "We propose the first sound and complete learning-based compositional verification technique for probabilistic safety properties on concurrent systems where each component is an Markov decision process. Different from previous works, weighted assumptions are introduced to attain completeness of our framework. Since weighted assumptions can be implicitly represented by multi-terminal binary decision diagrams (MTBDD's), we give an L*-based learning algorithm for MTBDD's to infer weighted assumptions. Experimental results suggest promising outlooks for our compositional technique.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676998", "conference_name": "POPL", "authors": [ @@ -878,78 +809,114 @@ "year": 2015 }, { - "paper_id": "10.1145/2676726.2676966", - "title": "A Formally-Verified C Static Analyzer", - "abstract": "This paper reports on the design and soundness proof, using the Coq proof assistant, of Verasco, a static analyzer based on abstract interpretation for most of the ISO C 1999 language (excluding recursion and dynamic allocation). Verasco establishes the absence of run-time errors in the analyzed programs. It enjoys a modular architecture that supports the extensible combination of multiple abstract domains, both relational and non-relational. Verasco integrates with the CompCert formally-verified C compiler so that not only the soundness of the analysis results is guaranteed with mathematical certitude, but also the fact that these guarantees carry over to the compiled code.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676966", + "paper_id": "10.1145/2676726.2682621", + "title": "Automating Repetitive Tasks for the Masses", + "abstract": "The programming languages (PL) research community has traditionally catered to the needs of professional programmers in the continuously evolving technical industry. However, there is a new opportunity that knocks our doors. The recent IT revolution has resulted in the masses having access to personal computing devices. More than 99% of these computer users are non-programmers and are today limited to being passive consumers of the software that is made available to them. Can we empower these users to more effectively leverage computers for their daily tasks? The formalisms, techniques, and tools developed in the PL and the formal methods research communities can play a pivotal role!", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2682621", "conference_name": "POPL", "authors": [ { - "first_name": "Jacques-Henri", - "last_name": "Jourdan", - "institution": "Institut national de recherche en sciences et technologies du numérique" + "first_name": "Sumit", + "last_name": "Gulwani", + "institution": "Microsoft (United States)" + } + ], + "dblp_key": "conf/popl/Gulwani15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676975", + "title": "Deep Specifications and Certified Abstraction Layers", + "abstract": "Modern computer systems consist of a multitude of abstraction layers (e.g., OS kernels, hypervisors, device drivers, network protocols), each of which defines an interface that hides the implementation details of a particular set of functionality. Client programs built on top of each layer can be understood solely based on the interface, independent of the layer implementation. Despite their obvious importance, abstraction layers have mostly been treated as a system concept; they have almost never been formally specified or verified. This makes it difficult to establish strong correctness properties, and to scale program verification across multiple layers.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676975", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ronghui", + "last_name": "Gu", + "institution": "Yale University" }, { - "first_name": "Vincent", - "last_name": "Laporte", - "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + "first_name": "Jérémie", + "last_name": "Koenig", + "institution": "Yale University" }, { - "first_name": "Sandrine", - "last_name": "Blazy", - "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + "first_name": "Tahina", + "last_name": "Ramananandro", + "institution": "Yale University" }, { - "first_name": "Xavier", - "last_name": "Leroy", - "institution": "Institut national de recherche en sciences et technologies du numérique" + "first_name": "Zhong", + "last_name": "Shao", + "institution": "Yale University" }, { - "first_name": "David", - "last_name": "Pichardie", - "institution": "École Normale Supérieure de Rennes" + "first_name": "Xiongnan", + "last_name": "Wu", + "institution": "Yale University" + }, + { + "first_name": "Shu-Chun", + "last_name": "Weng", + "institution": "Yale University" + }, + { + "first_name": "Haozhong", + "last_name": "Zhang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Yu", + "last_name": "Guo", + "institution": "University of Science and Technology of China" } ], - "dblp_key": "conf/popl/JourdanLBLP15", + "dblp_key": "conf/popl/GuKRSWWZG15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677008", - "title": "Succinct Representation of Concurrent Trace Sets", - "abstract": "We present a method and a tool for generating succinct representations of sets of concurrent traces. We focus on trace sets that contain all correct or all incorrect permutations of events from a given trace. We represent trace sets as HB-Formulas that are Boolean combinations of happens-before constraints between events. To generate a representation of incorrect interleavings, our method iteratively explores interleavings that violate the specification and gathers generalizations of the discovered interleavings into an HB-Formula; its complement yields a representation of correct interleavings.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677008", + "paper_id": "10.1145/2676726.2676992", + "title": "Principal Type Schemes for Gradual Programs", + "abstract": "Gradual typing is a discipline for integrating dynamic checking into a static type system. Since its introduction in functional languages, it has been adapted to a variety of type systems, including object-oriented, security, and substructural. This work studies its application to implicitly typed languages based on type inference. Siek and Vachharajani designed a gradual type inference system and algorithm that infers gradual types but still rejects ill-typed static programs. However, the type system requires local reasoning about type substitutions, an imperative inference algorithm, and a subtle correctness statement.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676992", "conference_name": "POPL", "authors": [ { - "first_name": "Ashutosh", - "last_name": "Gupta", - "institution": "Institute of Science and Technology Austria" - }, - { - "first_name": "Thomas A.", - "last_name": "Henzinger", - "institution": "Institute of Science and Technology Austria" - }, - { - "first_name": "Arjun", - "last_name": "Radhakrishna", - "institution": "University of Pennsylvania" + "first_name": "Ronald", + "last_name": "Garcia", + "institution": "University of British Columbia" }, { - "first_name": "Roopsha", - "last_name": "Samanta", - "institution": "Institute of Science and Technology Austria" - }, + "first_name": "Matteo", + "last_name": "Cimini", + "institution": "Indiana University Bloomington" + } + ], + "dblp_key": "conf/popl/GarciaC15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676965", + "title": "Equations, Contractions, and Unique Solutions", + "abstract": "One of the most studied behavioural equivalences is bisimilarity. Its success is much due to the associated bisimulation proof method, which can be further enhanced by means of \"up-to bisimulation\" techniques such as \"up-to context\".", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676965", + "conference_name": "POPL", + "authors": [ { - "first_name": "Thorsten", - "last_name": "Tarrach", - "institution": "Institute of Science and Technology Austria" + "first_name": "Davide", + "last_name": "Sangiorgi", + "institution": "University of Bologna" } ], - "dblp_key": "conf/popl/GuptaHRST15", + "dblp_key": "conf/popl/Sangiorgi15", "venue": "popl", "year": 2015 }, @@ -957,7 +924,7 @@ "paper_id": "10.1145/2676726.2676980", "title": "Iris: Monoids and Invariants as an Orthogonal Basis for Concurrent Reasoning", "abstract": "We present Iris, a concurrent separation logic with a simple premise: monoids and invariants are all you need. Partial commutative monoids enable us to express---and invariants enable us to enforce---user-defined *protocols* on shared state, which are at the conceptual core of most recent program logics for concurrency. Furthermore, through a novel extension of the concept of a *view shift*, Iris supports the encoding of *logically atomic specifications*, i.e., Hoare-style specs that permit the client of an operation to treat the operation essentially as if it were atomic, even if it is not.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676980", "conference_name": "POPL", "authors": [ @@ -1001,34 +968,11 @@ "venue": "popl", "year": 2015 }, - { - "paper_id": "10.1145/2676726.2676994", - "title": "Dependent Information Flow Types", - "abstract": "In this paper, we develop a novel notion of dependent information flow types. Dependent information flow types fit within the standard framework of dependent type theory, but, unlike usual dependent types, crucially allow the security level of a type, rather than just the structural data type itself, to depend on runtime values.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676994", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Luísa", - "last_name": "Lourenço", - "institution": "Universidade Nova de Lisboa" - }, - { - "first_name": "Luı́s", - "last_name": "Caires", - "institution": "Universidade Nova de Lisboa" - } - ], - "dblp_key": "conf/popl/LourencoC15", - "venue": "popl", - "year": 2015 - }, { "paper_id": "10.1145/2676726.2682622", "title": "Coding by Everyone, Every Day", "abstract": "In recent years, advances in machine learning and related fields have led to significant advances in a range of user-interface technologies, including audio processing, speech recognition, and natural language processing. These advances in turn have enabled speech-based digital assistants and speech-to-speech translation systems to become practical to deploy on a large scale. In essence, machines are becoming capable of hearing what we are saying. But will they understand what we want them to do when we talk to them? What are the prospects for getting useful work done in essence, by synthesizing programs -- through the act of having a conversation with a computer? In this lecture, I will speculate on the central role that programming-language design and program synthesis may have in this possible -- and I will argue, likely -- future of computing, one in which every user writes programs, every day, by conversing with a computing system.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2682622", "conference_name": "POPL", "authors": [ @@ -1043,30 +987,58 @@ "year": 2015 }, { - "paper_id": "10.1145/2676726.2676969", - "title": "Integrating Linear and Dependent Types", - "abstract": "In this paper, we show how to integrate linear types with type dependency, by extending the linear/non-linear calculus of Benton to support type dependency. Next, we give an application of this calculus by giving a proof-theoretic account of imperative programming, which requires extending the calculus with computationally irrelevant quantification, proof irrelevance, and a monad of computations. We show the soundness of our theory by giving a realizability model in the style of Nuprl, which permits us to validate not only the beta-laws for each type, but also the eta-laws. These extensions permit us to decompose Hoare triples into a collection of simpler type-theoretic connectives, yielding a rich equational theory for dependently-typed higher-order imperative programs. Furthermore, both the type theory and its model are relatively simple, even when all of the extensions are considered.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676969", + "paper_id": "10.1145/2676726.2676967", + "title": "Space-Efficient Manifest Contracts", + "abstract": "The standard algorithm for higher-order contract checking can lead to unbounded space consumption and can destroy tail recursion, altering a program's asymptotic space complexity. While space efficiency for gradual types---contracts mediating untyped and typed code---is well studied, sound space efficiency for manifest contracts---contracts that check stronger properties than simple types, e.g., \"is a natural'' instead of \"is an integer''---remains an open problem.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676967", "conference_name": "POPL", "authors": [ { - "first_name": "Neelakantan R.", - "last_name": "Krishnaswami", - "institution": "University of Birmingham" + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Princeton University" + } + ], + "dblp_key": "conf/popl/Greenberg15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676966", + "title": "A Formally-Verified C Static Analyzer", + "abstract": "This paper reports on the design and soundness proof, using the Coq proof assistant, of Verasco, a static analyzer based on abstract interpretation for most of the ISO C 1999 language (excluding recursion and dynamic allocation). Verasco establishes the absence of run-time errors in the analyzed programs. It enjoys a modular architecture that supports the extensible combination of multiple abstract domains, both relational and non-relational. Verasco integrates with the CompCert formally-verified C compiler so that not only the soundness of the analysis results is guaranteed with mathematical certitude, but also the fact that these guarantees carry over to the compiled code.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676966", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Institut national de recherche en sciences et technologies du numérique" }, { - "first_name": "Pierre", - "last_name": "Pradic", - "institution": "École Normale Supérieure de Lyon" + "first_name": "Vincent", + "last_name": "Laporte", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" }, { - "first_name": "Nick", - "last_name": "Benton", - "institution": "Microsoft (United States)" + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Xavier", + "last_name": "Leroy", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "École Normale Supérieure de Rennes" } ], - "dblp_key": "conf/popl/KrishnaswamiPB15", + "dblp_key": "conf/popl/JourdanLBLP15", "venue": "popl", "year": 2015 }, @@ -1074,7 +1046,7 @@ "paper_id": "10.1145/2676726.2677009", "title": "Predicting Program Properties from "Big Code"", "abstract": "We present a new approach for predicting program properties from massive codebases (aka \"Big Code\"). Our approach first learns a probabilistic model from existing data and then uses this model to predict properties of new, unseen programs.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2677009", "conference_name": "POPL", "authors": [ @@ -1099,30 +1071,101 @@ "year": 2015 }, { - "paper_id": "10.1145/2676726.2676964", - "title": "From Communicating Machines to Graphical Choreographies", - "abstract": "Graphical choreographies, or global graphs, are general multiparty session specifications featuring expressive constructs such as forking, merging, and joining for representing application-level protocols. Global graphs can be directly translated into modelling notations such as BPMN and UML. This paper presents an algorithm whereby a global graph can be constructed from asynchronous interactions represented by communicating finite-state machines (CFSMs). Our results include: a sound and complete characterisation of a subset of safe CFSMs from which global graphs can be constructed; an algorithm to translate CFSMs to global graphs; a time complexity analysis; and an implementation of our theory, as well as an experimental evaluation.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676964", + "paper_id": "10.1145/2676726.2677001", + "title": "Probabilistic Termination: Soundness, Completeness, and Compositionality", + "abstract": "We propose a framework to prove almost sure termination for probabilistic programs with real valued variables. It is based on ranking supermartingales, a notion analogous to ranking functions on non-probabilistic programs. The framework is proven sound and complete for a meaningful class of programs involving randomization and bounded nondeterminism. We complement this foundational insigh by a practical proof methodology, based on sound conditions that enable compositional reasoning and are amenable to a direct implementation using modern theorem provers. This is integrated in a small dependent type system, to overcome the problem that lexicographic ranking functions fail when combined with randomization. Among others, this compositional methodology enables the verification of probabilistic programs outside the complete class that admits ranking supermartingales.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677001", "conference_name": "POPL", "authors": [ { - "first_name": "Julien", - "last_name": "Lange", - "institution": "Imperial College London" + "first_name": "Luis María Ferrer", + "last_name": "Fioriti", + "institution": "Saarland University" }, { - "first_name": "Emilio", - "last_name": "Tuosto", - "institution": "University of Leicester" + "first_name": "Holger", + "last_name": "Hermanns", + "institution": "Saarland University" + } + ], + "dblp_key": "conf/popl/FioritiH15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676990", + "title": "Decentralizing SDN Policies", + "abstract": "Software-defined networking (SDN) is a new paradigm for operating and managing computer networks. SDN enables logically-centralized control over network devices through a \"controller\" --- software that operates independently of the network hardware. Network operators can run both in-house and third-party SDN programs on top of the controller, e.g., to specify routing and access control policies.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676990", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Oded", + "last_name": "Padon", + "institution": "Tel Aviv University" }, { - "first_name": "Nobuko", - "last_name": "Yoshida", - "institution": "Imperial College London" + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Amherst" + }, + { + "first_name": "Aleksandr", + "last_name": "Karbyshev", + "institution": "Tel Aviv University" + }, + { + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Academic College of Tel Aviv-Yafo" } ], - "dblp_key": "conf/popl/LangeTY15", + "dblp_key": "conf/popl/PadonIKLSS15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676986", + "title": "Abstract Symbolic Automata: Mixed syntactic/semantic similarity analysis of executables", + "abstract": "We introduce a model for mixed syntactic/semantic approximation of programs based on symbolic finite automata (SFA). The edges of SFA are labeled by predicates whose semantics specifies the denotations that are allowed by the edge. We introduce the notion of abstract symbolic finite automaton (ASFA) where approximation is made by abstract interpretation of symbolic finite automata, acting both at syntactic (predicate) and semantic (denotation) level. We investigate in the details how the syntactic and semantic abstractions of SFA relate to each other and contribute to the determination of the recognized language. Then we introduce a family of transformations for simplifying ASFA. We apply this model to prove properties of commonly used tools for similarity analysis of binary executables. Following the structure of their control flow graphs, disassembled binary executables are represented as (concrete) SFA, where states are program points and predicates represent the (possibly infinite) I/O semantics of each basic block in a constraint form. Known tools for binary code analysis are viewed as specific choices of symbolic and semantic abstractions in our framework, making symbolic finite automata and their abstract interpretations a unifying model for comparing and reasoning about soundness and completeness of analyses of low-level code.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676986", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Mila Dalla", + "last_name": "Preda", + "institution": "University of Verona" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", + "institution": "University of Verona" + }, + { + "first_name": "Arun", + "last_name": "Lakhotia", + "institution": "University of Louisiana at Lafayette" + }, + { + "first_name": "Isabella", + "last_name": "Mastroeni", + "institution": "University of Verona" + } + ], + "dblp_key": "conf/popl/PredaGLM15", "venue": "popl", "year": 2015 }, @@ -1130,7 +1173,7 @@ "paper_id": "10.1145/2676726.2676974", "title": "Programming up to Congruence", "abstract": "This paper presents the design of Zombie, a dependently-typed programming language that uses an adaptation of a congruence closure algorithm for proof and type inference. This algorithm allows the type checker to automatically use equality assumptions from the context when reasoning about equality. Most dependently-typed languages automatically use equalities that follow from beta-reduction during type checking; however, such reasoning is incompatible with congruence closure. In contrast, Zombie does not use automatic beta-reduction because types may contain potentially diverging terms. Therefore Zombie provides a unique opportunity to explore an alternative definition of equivalence in dependently-typed language design.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676974", "conference_name": "POPL", "authors": [ @@ -1150,25 +1193,40 @@ "year": 2015 }, { - "paper_id": "10.1145/2676726.2676970", - "title": "Functors are Type Refinement Systems", - "abstract": "The standard reading of type theory through the lens of category theory is based on the idea of viewing a type system as a category of well-typed terms. We propose a basic revision of this reading: rather than interpreting type systems as categories, we describe them as functors from a category of typing derivations to a category of underlying terms. Then, turning this around, we explain how in fact any functor gives rise to a generalized type system, with an abstract notion of typing judgment, typing derivations and typing rules. This leads to a purely categorical reformulation of various natural classes of type systems as natural classes of functors.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676970", + "paper_id": "10.1145/2676726.2676971", + "title": "Safe & Efficient Gradual Typing for TypeScript", + "abstract": "Current proposals for adding gradual typing to JavaScript, such as Closure, TypeScript and Dart, forgo soundness to deal with issues of scale, code reuse, and popular programming patterns. We show how to address these issues in practice while retaining soundness. We design and implement a new gradual type system, prototyped for expediency as a 'Safe' compilation mode for TypeScript. Our compiler achieves soundness by enforcing stricter static checks and embedding residual runtime checks in compiled code. It emits plain JavaScript that runs on stock virtual machines. Our main theorem is a simulation that ensures that the checks introduced by Safe TypeScript (1) catch any dynamic type error, and (2) do not alter the semantics of type-safe TypeScript code.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676971", "conference_name": "POPL", "authors": [ { - "first_name": "Paul-André", - "last_name": "Melliès", - "institution": "Sorbonne Paris Cité" + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "University of Maryland, College Park" }, { - "first_name": "Noam", - "last_name": "Zeilberger", - "institution": "Inria Saclay - Île de France" + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Cédric", + "last_name": "Fournet", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Gavin", + "last_name": "Bierman", + "institution": "Oracle (United States)" + }, + { + "first_name": "Panagiotis", + "last_name": "Vekris", + "institution": "University of California San Diego" } ], - "dblp_key": "conf/popl/MelliesZ15", + "dblp_key": "conf/popl/RastogiSFBV15", "venue": "popl", "year": 2015 }, @@ -1176,7 +1234,7 @@ "paper_id": "10.1145/2676726.2676978", "title": "Runtime Enforcement of Security Policies on Black Box Reactive Programs", "abstract": "Security enforcement mechanisms like execution monitors are used to make sure that some untrusted program complies with a policy. Different enforcement mechanisms have different strengths and weaknesses and hence it is important to understand the qualities of various enforcement mechanisms.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676978", "conference_name": "POPL", "authors": [ @@ -1206,114 +1264,43 @@ "year": 2015 }, { - "paper_id": "10.1145/2676726.2676983", - "title": "Higher Inductive Types as Homotopy-Initial Algebras", - "abstract": "Homotopy Type Theory is a new field of mathematics based on the recently-discovered correspondence between Martin-Löf's constructive type theory and abstract homotopy theory. We have a powerful interplay between these disciplines - we can use geometric intuition to formulate new concepts in type theory and, conversely, use type-theoretic machinery to verify and often simplify existing mathematical proofs.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676983", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Kristina", - "last_name": "Sojakova", - "institution": "Carnegie Mellon University" - } - ], - "dblp_key": "conf/popl/Sojakova15", - "venue": "popl", - "year": 2015 - }, - { - "paper_id": "10.1145/2676726.2676990", - "title": "Decentralizing SDN Policies", - "abstract": "Software-defined networking (SDN) is a new paradigm for operating and managing computer networks. SDN enables logically-centralized control over network devices through a \"controller\" --- software that operates independently of the network hardware. Network operators can run both in-house and third-party SDN programs on top of the controller, e.g., to specify routing and access control policies.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676990", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Oded", - "last_name": "Padon", - "institution": "Tel Aviv University" - }, - { - "first_name": "Neil", - "last_name": "Immerman", - "institution": "University of Massachusetts Amherst" - }, - { - "first_name": "Aleksandr", - "last_name": "Karbyshev", - "institution": "Tel Aviv University" - }, - { - "first_name": "Ori", - "last_name": "Lahav", - "institution": "Tel Aviv University" - }, - { - "first_name": "Mooly", - "last_name": "Sagiv", - "institution": "Tel Aviv University" - }, - { - "first_name": "Sharon", - "last_name": "Shoham", - "institution": "Academic College of Tel Aviv-Yafo" - } - ], - "dblp_key": "conf/popl/PadonIKLSS15", - "venue": "popl", - "year": 2015 - }, - { - "paper_id": "10.1145/2676726.2676985", - "title": "Compositional CompCert", - "abstract": "This paper reports on the development of Compositional CompCert, the first verified separate compiler for C.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676985", + "paper_id": "10.1145/2676726.2676999", + "title": "Algebraic Effects, Linearity, and Quantum Programming Languages", + "abstract": "We develop a new framework of algebraic theories with linear parameters, and use it to analyze the equational reasoning principles of quantum computing and quantum programming languages. We use the framework as follows:", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676999", "conference_name": "POPL", "authors": [ { - "first_name": "Gordon", - "last_name": "Stewart", - "institution": "Princeton University" - }, - { - "first_name": "Lennart", - "last_name": "Beringer", - "institution": "Princeton University" - }, - { - "first_name": "Santiago", - "last_name": "Cuéllar", - "institution": "Princeton University" - }, - { - "first_name": "Andrew W.", - "last_name": "Appel", - "institution": "Princeton University" + "first_name": "Sam", + "last_name": "Staton", + "institution": "Radboud University Nijmegen" } ], - "dblp_key": "conf/popl/StewartBCA15", + "dblp_key": "conf/popl/Staton15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2677007", - "title": "Symbolic Algorithms for Language Equivalence and Kleene Algebra with Tests", - "abstract": "We propose algorithms for checking language equivalence of finite automata over a large alphabet. We use symbolic automata, where the transition function is compactly represented using (multi-terminal) binary decision diagrams (BDD). The key idea consists in computing a bisimulation by exploring reachable pairs symbolically, so as to avoid redundancies. This idea can be combined with already existing optimisations, and we show in particular a nice integration with the disjoint sets forest data-structure from Hopcroft and Karp's standard algorithm.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677007", + "paper_id": "10.1145/2676726.2676994", + "title": "Dependent Information Flow Types", + "abstract": "In this paper, we develop a novel notion of dependent information flow types. Dependent information flow types fit within the standard framework of dependent type theory, but, unlike usual dependent types, crucially allow the security level of a type, rather than just the structural data type itself, to depend on runtime values.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676994", "conference_name": "POPL", "authors": [ { - "first_name": "Damien", - "last_name": "Pous", - "institution": "Université Claude Bernard Lyon 1" + "first_name": "Luísa", + "last_name": "Lourenço", + "institution": "Universidade Nova de Lisboa" + }, + { + "first_name": "Luı́s", + "last_name": "Caires", + "institution": "Universidade Nova de Lisboa" } ], - "dblp_key": "conf/popl/Pous15", + "dblp_key": "conf/popl/LourencoC15", "venue": "popl", "year": 2015 }, @@ -1321,7 +1308,7 @@ "paper_id": "10.1145/2676726.2676996", "title": "Manifest Contracts for Datatypes", "abstract": "We study algebraic data types in a manifest contract system, a software contract system where contract information occurs as refinement types. We first compare two simple approaches: refinements on type constructors and refinements on data constructors. For example, lists of positive integers can be described by {l:int list | for_all (lambda y. y > 0) l} in the former, whereas by a user-defined datatype pos_list with cons of type {x:int | x > 0} X pos_list -> pos_list in the latter. The two approaches are complementary: the former makes it easier for a programmer to write types and the latter enables more efficient contract checking. To take the best of both worlds, we propose (1) a syntactic translation from refinements on type constructors to equivalent refinements on data constructors and (2) dynamically checked casts between different but compatible datatypes such as int list and pos_list. We define a manifest contract calculus to formalize the semantics of the casts and prove that the translation is correct.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676996", "conference_name": "POPL", "authors": [ @@ -1346,127 +1333,155 @@ "year": 2015 }, { - "paper_id": "10.1145/2676726.2676986", - "title": "Abstract Symbolic Automata: Mixed syntactic/semantic similarity analysis of executables", - "abstract": "We introduce a model for mixed syntactic/semantic approximation of programs based on symbolic finite automata (SFA). The edges of SFA are labeled by predicates whose semantics specifies the denotations that are allowed by the edge. We introduce the notion of abstract symbolic finite automaton (ASFA) where approximation is made by abstract interpretation of symbolic finite automata, acting both at syntactic (predicate) and semantic (denotation) level. We investigate in the details how the syntactic and semantic abstractions of SFA relate to each other and contribute to the determination of the recognized language. Then we introduce a family of transformations for simplifying ASFA. We apply this model to prove properties of commonly used tools for similarity analysis of binary executables. Following the structure of their control flow graphs, disassembled binary executables are represented as (concrete) SFA, where states are program points and predicates represent the (possibly infinite) I/O semantics of each basic block in a constraint form. Known tools for binary code analysis are viewed as specific choices of symbolic and semantic abstractions in our framework, making symbolic finite automata and their abstract interpretations a unifying model for comparing and reasoning about soundness and completeness of analyses of low-level code.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676986", + "paper_id": "10.1145/2676726.2676976", + "title": "A Meta Lambda Calculus with Cross-Level Computation", + "abstract": "We propose meta lambda calculus Lambda-* as a basic model of textual substitution via metavariables. The most important feature of the calculus is that every beta-redex can be reduced regardless of whether the beta-redex contains meta-level variables or not. Such a meta lambda calculus has never been achieved before due to difficulty to manage binding structure consistently with alpha-renaming in the presence of meta-level variables. We overcome the difficulty by introducing a new mechanism to deal with substitution and binding structure in a systematic way without the notion of free variables and alpha-renaming.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676976", "conference_name": "POPL", "authors": [ { - "first_name": "Mila Dalla", - "last_name": "Preda", - "institution": "University of Verona" - }, - { - "first_name": "Roberto", - "last_name": "Giacobazzi", - "institution": "University of Verona" - }, - { - "first_name": "Arun", - "last_name": "Lakhotia", - "institution": "University of Louisiana at Lafayette" - }, - { - "first_name": "Isabella", - "last_name": "Mastroeni", - "institution": "University of Verona" + "first_name": "Kazunori", + "last_name": "Tobisawa", + "institution": "The University of Tokyo" } ], - "dblp_key": "conf/popl/PredaGLM15", + "dblp_key": "conf/popl/Tobisawa15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676971", - "title": "Safe & Efficient Gradual Typing for TypeScript", - "abstract": "Current proposals for adding gradual typing to JavaScript, such as Closure, TypeScript and Dart, forgo soundness to deal with issues of scale, code reuse, and popular programming patterns. We show how to address these issues in practice while retaining soundness. We design and implement a new gradual type system, prototyped for expediency as a 'Safe' compilation mode for TypeScript. Our compiler achieves soundness by enforcing stricter static checks and embedding residual runtime checks in compiled code. It emits plain JavaScript that runs on stock virtual machines. Our main theorem is a simulation that ensures that the checks introduced by Safe TypeScript (1) catch any dynamic type error, and (2) do not alter the semantics of type-safe TypeScript code.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676971", + "paper_id": "10.1145/2676726.2676964", + "title": "From Communicating Machines to Graphical Choreographies", + "abstract": "Graphical choreographies, or global graphs, are general multiparty session specifications featuring expressive constructs such as forking, merging, and joining for representing application-level protocols. Global graphs can be directly translated into modelling notations such as BPMN and UML. This paper presents an algorithm whereby a global graph can be constructed from asynchronous interactions represented by communicating finite-state machines (CFSMs). Our results include: a sound and complete characterisation of a subset of safe CFSMs from which global graphs can be constructed; an algorithm to translate CFSMs to global graphs; a time complexity analysis; and an implementation of our theory, as well as an experimental evaluation.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676964", "conference_name": "POPL", "authors": [ { - "first_name": "Aseem", - "last_name": "Rastogi", - "institution": "University of Maryland, College Park" + "first_name": "Julien", + "last_name": "Lange", + "institution": "Imperial College London" }, { - "first_name": "Nikhil", - "last_name": "Swamy", - "institution": "Microsoft (United States)" + "first_name": "Emilio", + "last_name": "Tuosto", + "institution": "University of Leicester" }, { - "first_name": "Cédric", - "last_name": "Fournet", - "institution": "Microsoft (United States)" - }, + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" + } + ], + "dblp_key": "conf/popl/LangeTY15", + "venue": "popl", + "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676970", + "title": "Functors are Type Refinement Systems", + "abstract": "The standard reading of type theory through the lens of category theory is based on the idea of viewing a type system as a category of well-typed terms. We propose a basic revision of this reading: rather than interpreting type systems as categories, we describe them as functors from a category of typing derivations to a category of underlying terms. Then, turning this around, we explain how in fact any functor gives rise to a generalized type system, with an abstract notion of typing judgment, typing derivations and typing rules. This leads to a purely categorical reformulation of various natural classes of type systems as natural classes of functors.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676970", + "conference_name": "POPL", + "authors": [ { - "first_name": "Gavin", - "last_name": "Bierman", - "institution": "Oracle (United States)" + "first_name": "Paul-André", + "last_name": "Melliès", + "institution": "Sorbonne Paris Cité" }, { - "first_name": "Panagiotis", - "last_name": "Vekris", - "institution": "University of California San Diego" + "first_name": "Noam", + "last_name": "Zeilberger", + "institution": "Inria Saclay - Île de France" } ], - "dblp_key": "conf/popl/RastogiSFBV15", + "dblp_key": "conf/popl/MelliesZ15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676965", - "title": "Equations, Contractions, and Unique Solutions", - "abstract": "One of the most studied behavioural equivalences is bisimilarity. Its success is much due to the associated bisimulation proof method, which can be further enhanced by means of \"up-to bisimulation\" techniques such as \"up-to context\".", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676965", + "paper_id": "10.1145/2676726.2676985", + "title": "Compositional CompCert", + "abstract": "This paper reports on the development of Compositional CompCert, the first verified separate compiler for C.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676985", "conference_name": "POPL", "authors": [ { - "first_name": "Davide", - "last_name": "Sangiorgi", - "institution": "University of Bologna" + "first_name": "Gordon", + "last_name": "Stewart", + "institution": "Princeton University" + }, + { + "first_name": "Lennart", + "last_name": "Beringer", + "institution": "Princeton University" + }, + { + "first_name": "Santiago", + "last_name": "Cuéllar", + "institution": "Princeton University" + }, + { + "first_name": "Andrew W.", + "last_name": "Appel", + "institution": "Princeton University" } ], - "dblp_key": "conf/popl/Sangiorgi15", + "dblp_key": "conf/popl/StewartBCA15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676976", - "title": "A Meta Lambda Calculus with Cross-Level Computation", - "abstract": "We propose meta lambda calculus Lambda-* as a basic model of textual substitution via metavariables. The most important feature of the calculus is that every beta-redex can be reduced regardless of whether the beta-redex contains meta-level variables or not. Such a meta lambda calculus has never been achieved before due to difficulty to manage binding structure consistently with alpha-renaming in the presence of meta-level variables. We overcome the difficulty by introducing a new mechanism to deal with substitution and binding structure in a systematic way without the notion of free variables and alpha-renaming.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676976", + "paper_id": "10.1145/2676726.2677014", + "title": "Data-Parallel String-Manipulating Programs", + "abstract": "String-manipulating programs are an important class of programs with applications in malware detection, graphics, input sanitization for Web security, and large-scale HTML processing. This paper extends prior work on BEK, an expressive domain-specific language for writing string-manipulating programs, with algorithmic insights that make BEK both analyzable and data-parallel. By analyzable we mean that unlike most general purpose programming languages, many algebraic properties of a BEK program are decidable (i.e., one can check whether two programs commute or compute the inverse of a program). By data-parallel we mean that a BEK program can compute on arbitrary subsections of its input in parallel, thus exploiting parallel hardware. This latter requirement is particularly important for programs which operate on large data: without data parallelism, a programmer cannot hide the latency of reading data from various storage media (i.e., reading a terabyte of data from a modern hard drive takes about 3 hours). With a data-parallel approach, the system can split data across multiple disks and thus hide the latency of reading the data.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677014", "conference_name": "POPL", "authors": [ { - "first_name": "Kazunori", - "last_name": "Tobisawa", - "institution": "The University of Tokyo" + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Todd", + "last_name": "Mytkowicz", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Dávid", + "last_name": "Molnár", + "institution": "Microsoft (United States)" + }, + { + "first_name": "Benjamin", + "last_name": "Livshits", + "institution": "Microsoft (United States)" } ], - "dblp_key": "conf/popl/Tobisawa15", + "dblp_key": "conf/popl/VeanesMML15", "venue": "popl", "year": 2015 }, { - "paper_id": "10.1145/2676726.2676999", - "title": "Algebraic Effects, Linearity, and Quantum Programming Languages", - "abstract": "We develop a new framework of algebraic theories with linear parameters, and use it to analyze the equational reasoning principles of quantum computing and quantum programming languages. We use the framework as follows:", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2676999", + "paper_id": "10.1145/2676726.2677007", + "title": "Symbolic Algorithms for Language Equivalence and Kleene Algebra with Tests", + "abstract": "We propose algorithms for checking language equivalence of finite automata over a large alphabet. We use symbolic automata, where the transition function is compactly represented using (multi-terminal) binary decision diagrams (BDD). The key idea consists in computing a bisimulation by exploring reachable pairs symbolically, so as to avoid redundancies. This idea can be combined with already existing optimisations, and we show in particular a nice integration with the disjoint sets forest data-structure from Hopcroft and Karp's standard algorithm.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2677007", "conference_name": "POPL", "authors": [ { - "first_name": "Sam", - "last_name": "Staton", - "institution": "Radboud University Nijmegen" + "first_name": "Damien", + "last_name": "Pous", + "institution": "Université Claude Bernard Lyon 1" } ], - "dblp_key": "conf/popl/Staton15", + "dblp_key": "conf/popl/Pous15", "venue": "popl", "year": 2015 }, @@ -1474,7 +1489,7 @@ "paper_id": "10.1145/2676726.2676997", "title": "Summary-Based Context-Sensitive Data-Dependence Analysis in Presence of Callbacks", "abstract": "Building a summary for library code is a common approach to speeding up the analysis of client code. In presence of callbacks, some reachability relationships between library nodes cannot be obtained during library-code summarization. Thus, the library code may have to be analyzed again during the analysis of the client code with the library summary. In this paper, we propose to summarize library code with tree-adjoining-language (TAL) reachability. Compared with the summary built with context-free-language (CFL) reachability, the summary built with TAL reachability further contains conditional reachability relationships. The conditional reachability relationships can lead to much lighter analysis of the library code during the client code analysis with the TAL-reachability-based library summary. We also performed an experimental comparison of context-sensitive data-dependence analysis with the TAL-reachability-based library summary and context-sensitive data-dependence analysis with the CFL-reachability-based library summary using 15 benchmark subjects. Our experimental results demonstrate that the former has an 8X speed-up over the latter on average.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676997", "conference_name": "POPL", "authors": [ @@ -1513,44 +1528,11 @@ "venue": "popl", "year": 2015 }, - { - "paper_id": "10.1145/2676726.2677014", - "title": "Data-Parallel String-Manipulating Programs", - "abstract": "String-manipulating programs are an important class of programs with applications in malware detection, graphics, input sanitization for Web security, and large-scale HTML processing. This paper extends prior work on BEK, an expressive domain-specific language for writing string-manipulating programs, with algorithmic insights that make BEK both analyzable and data-parallel. By analyzable we mean that unlike most general purpose programming languages, many algebraic properties of a BEK program are decidable (i.e., one can check whether two programs commute or compute the inverse of a program). By data-parallel we mean that a BEK program can compute on arbitrary subsections of its input in parallel, thus exploiting parallel hardware. This latter requirement is particularly important for programs which operate on large data: without data parallelism, a programmer cannot hide the latency of reading data from various storage media (i.e., reading a terabyte of data from a modern hard drive takes about 3 hours). With a data-parallel approach, the system can split data across multiple disks and thus hide the latency of reading the data.", - "date": "2014-12-19", - "link": "https://doi.org/10.1145/2676726.2677014", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Margus", - "last_name": "Veanes", - "institution": "Microsoft (United States)" - }, - { - "first_name": "Todd", - "last_name": "Mytkowicz", - "institution": "Microsoft (United States)" - }, - { - "first_name": "Dávid", - "last_name": "Molnár", - "institution": "Microsoft (United States)" - }, - { - "first_name": "Benjamin", - "last_name": "Livshits", - "institution": "Microsoft (United States)" - } - ], - "dblp_key": "conf/popl/VeanesMML15", - "venue": "popl", - "year": 2015 - }, { "paper_id": "10.1145/2676726.2676995", "title": "Common Compiler Optimisations are Invalid in the C11 Memory Model and what we can do about it", "abstract": "We show that the weak memory model introduced by the 2011 C and C++ standards does not permit many common source-to-source program transformations (such as expression linearisation and \"roach motel\" reorderings) that modern compilers perform and that are deemed to be correct. As such it cannot be used to define the semantics of intermediate languages of compilers, as, for instance, LLVM aimed to. We consider a number of possible local fixes, some strengthening and some weakening the model. We evaluate the proposed fixes by determining which program transformations are valid with respect to each of the patched models. We provide formal Coq proofs of their correctness or counterexamples as appropriate.", - "date": "2014-12-19", + "date": "2015-01-01", "link": "https://doi.org/10.1145/2676726.2676995", "conference_name": "POPL", "authors": [ @@ -1583,5 +1565,23 @@ "dblp_key": "conf/popl/VafeiadisBCMN15", "venue": "popl", "year": 2015 + }, + { + "paper_id": "10.1145/2676726.2676983", + "title": "Higher Inductive Types as Homotopy-Initial Algebras", + "abstract": "Homotopy Type Theory is a new field of mathematics based on the recently-discovered correspondence between Martin-Löf's constructive type theory and abstract homotopy theory. We have a powerful interplay between these disciplines - we can use geometric intuition to formulate new concepts in type theory and, conversely, use type-theoretic machinery to verify and often simplify existing mathematical proofs.", + "date": "2015-01-01", + "link": "https://doi.org/10.1145/2676726.2676983", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Kristina", + "last_name": "Sojakova", + "institution": "Carnegie Mellon University" + } + ], + "dblp_key": "conf/popl/Sojakova15", + "venue": "popl", + "year": 2015 } ] \ No newline at end of file diff --git a/data/pl_conferences/popl/2018.json b/data/pl_conferences/popl/2018.json index 6dd6e19..51da64c 100644 --- a/data/pl_conferences/popl/2018.json +++ b/data/pl_conferences/popl/2018.json @@ -3,7 +3,7 @@ "paper_id": "10.1145/3158154", "title": "RustBelt: securing the foundations of the rust programming language", "abstract": "Rust is a new systems programming language that promises to overcome the seemingly fundamental tradeoff between high-level safety guarantees and low-level control over resource management. Unfortunately, none of Rust's safety claims have been formally proven, and there is good reason to question whether they actually hold. Specifically, Rust employs a strong, ownership-based type system, but then extends the expressive power of this core type system through libraries that internally use unsafe features. In this paper, we give the first formal (and machine-checked) safety proof for a language representing a realistic subset of Rust. Our proof is extensible in the sense that, for each new Rust library that uses unsafe features, we can say what verification condition it must satisfy in order for it to be deemed a safe extension to the language. We have carried out this verification for some of the most important libraries that are used throughout the Rust ecosystem.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158154", "conference_name": "POPL", "authors": [ @@ -32,39 +32,11 @@ "venue": "popl", "year": 2018 }, - { - "paper_id": "10.1145/3158100", - "title": "Relatively complete refinement type system for verification of higher-order non-deterministic programs", - "abstract": "This paper considers verification of non-deterministic higher-order functional programs. Our contribution is a novel type system in which the types are used to express and verify (conditional) safety, termination, non-safety, and non-termination properties in the presence of ∀-∃ branching behavior due to non-determinism. For instance, the judgement ⊢ e :{ u : int | φ( u ) } ∀∀ says that every evaluation of e either diverges or reduces to some integer u satisfying φ( u ), whereas ⊢ e :{ u : int | ψ( u ) } ∃∀ says that there exists an evaluation of e that either diverges or reduces to some integer u satisfying ψ( u ). Note that the former is a safety property whereas the latter is a counterexample to a (conditional) termination property. Following the recent work on type-based verification methods for deterministic higher-order functional programs, we formalize the idea on the foundation of dependent refinement types , thereby allowing the type system to express and verify rich properties involving program values, branching behaviors, and the combination thereof. Our type system is able to seamlessly combine deductions of both universal and existential facts within a unified framework, paving the way for an exciting opportunity for new type-based verification methods that combine both universal and existential reasoning. For example, our system can prove the existence of a path violating some safety property from a proof of termination that uses a well-foundedness termination argument. We prove that our type system is sound and relatively complete, and further, thanks to having both modes of non-determinism, we show that our types are closed under complement.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158100", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Hiroshi", - "last_name": "Unno", - "institution": "University of Tsukuba" - }, - { - "first_name": "Yuki", - "last_name": "Satake", - "institution": "University of Tsukuba" - }, - { - "first_name": "Tachio", - "last_name": "Terauchi", - "institution": "Waseda University" - } - ], - "dblp_key": "journals/pacmpl/0001ST18", - "venue": "popl", - "year": 2018 - }, { "paper_id": "10.1145/3158153", "title": "Recalling a witness: foundations and applications of monotonic state", "abstract": "We provide a way to ease the verification of programs whose state evolves monotonically. The main idea is that a property witnessed in a prior state can be soundly recalled in the current state, provided (1) state evolves according to a given preorder, and (2) the property is preserved by this preorder. In many scenarios, such monotonic reasoning yields concise modular proofs, saving the need for explicit program invariants. We distill our approach into the monotonic-state monad , a general yet compact interface for Hoare-style reasoning about monotonic state in a dependently typed language. We prove the soundness of the monotonic-state monad and use it as a unified foundation for reasoning about monotonic state in the F ⋆ verification system. Based on this foundation, we build libraries for various mutable data structures like monotonic references and apply these libraries at scale to the verification of several distributed applications.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158153", "conference_name": "POPL", "authors": [ @@ -104,99 +76,96 @@ "year": 2018 }, { - "paper_id": "10.1145/3158144", - "title": "Verifying equivalence of database-driven applications", - "abstract": "This paper addresses the problem of verifying equivalence between a pair of programs that operate over databases with different schemas. This problem is particularly important in the context of web applications, which typically undergo database refactoring either for performance or maintainability reasons. While web applications should have the same externally observable behavior before and after schema migration, there are no existing tools for proving equivalence of such programs. This paper takes a first step towards solving this problem by formalizing the equivalence and refinement checking problems for database-driven applications. We also propose a proof methodology based on the notion of bisimulation invariants over relational algebra with updates and describe a technique for synthesizing such bisimulation invariants. We have implemented the proposed technique in a tool called Mediator for verifying equivalence between database-driven applications written in our intermediate language and evaluate our tool on 21 benchmarks extracted from textbooks and real-world web applications. Our results show that the proposed methodology can successfully verify 20 of these benchmarks.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158144", + "paper_id": "10.1145/3158102", + "title": "Jones-optimal partial evaluation by specialization-safe normalization", + "abstract": "We present partial evaluation by specialization-safe normalization, a novel partial evaluation technique that is Jones-optimal, that can be self-applied to achieve the Futamura projections and that can be type-checked to ensure it always generates code with the correct type. Jones-optimality is the gold-standard for nontrivial partial evaluation and guarantees that a specializer can remove an entire layer of interpretation. We achieve Jones-optimality by using a novel affine-variable static analysis that directs specialization-safe normalization to always decrease a program’s runtime. We demonstrate the robustness of our approach by showing Jones-optimality in a variety of settings. We have formally proved that our partial evaluator is Jones-optimal for call-by-value reduction, and we have experimentally shown that it is Jones-optimal for call-by-value, normal-order, and memoized normal-order. Each of our experiments tests Jones-optimality with three different self-interpreters. We implemented our partial evaluator in F ω µ i , a recent language for typed self-applicable meta-programming. It is the first Jones-optimal and self-applicable partial evaluator whose type guarantees that it always generates type-correct code.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158102", "conference_name": "POPL", "authors": [ { - "first_name": "Yuepeng", - "last_name": "Wang", - "institution": "The University of Texas at Austin" - }, - { - "first_name": "Işıl", - "last_name": "Dillig", - "institution": "The University of Texas at Austin" - }, - { - "first_name": "Shuvendu K.", - "last_name": "Lahiri", - "institution": "Microsoft Research (United Kingdom)" + "first_name": "Matt", + "last_name": "Brown", + "institution": "University of California, Los Angeles" }, { - "first_name": "William R.", - "last_name": "Cook", - "institution": "The University of Texas at Austin" + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" } ], - "dblp_key": "journals/pacmpl/0001DLC18", + "dblp_key": "journals/pacmpl/BrownP18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158140", - "title": "Collapsing towers of interpreters", - "abstract": "Given a tower of interpreters, i.e., a sequence of multiple interpreters interpreting one another as input programs, we aim to collapse this tower into a compiler that removes all interpretive overhead and runs in a single pass. In the real world, a use case might be Python code executed by an x86 runtime, on a CPU emulated in a JavaScript VM, running on an ARM CPU. Collapsing such a tower can not only exponentially improve runtime performance, but also enable the use of base-language tools for interpreted programs, e.g., for analysis and verification. In this paper, we lay the foundations in an idealized but realistic setting. We present a multi-level lambda calculus that features staging constructs and stage polymorphism: based on runtime parameters, an evaluator either executes source code (thereby acting as an interpreter) or generates code (thereby acting as a compiler). We identify stage polymorphism, a programming model from the domain of high-performance program generators, as the key mechanism to make such interpreters compose in a collapsible way. We present Pink, a meta-circular Lisp-like evaluator on top of this calculus, and demonstrate that we can collapse arbitrarily many levels of self-interpretation, including levels with semantic modifications. We discuss several examples: compiling regular expressions through an interpreter to base code, building program transformers from modi ed interpreters, and others. We develop these ideas further to include reflection and reification, culminating in Purple, a reflective language inspired by Brown, Blond, and Black, which realizes a conceptually infinite tower, where every aspect of the semantics can change dynamically. Addressing an open challenge, we show how user programs can be compiled and recompiled under user-modified semantics.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158140", + "paper_id": "10.1145/3158115", + "title": "Alone together: compositional reasoning and inference for weak isolation", + "abstract": "Serializability is a well-understood correctness criterion that simplifies reasoning about the behavior of concurrent transactions by ensuring they are isolated from each other while they execute. However, enforcing serializable isolation comes at a steep cost in performance because it necessarily restricts opportunities to exploit concurrency even when such opportunities would not violate application-specific invariants. As a result, database systems in practice support, and often encourage, developers to implement transactions using weaker alternatives. These alternatives break the strong isolation guarantees offered by serializable transactions to permit greater concurrency. Unfortunately, the semantics of weak isolation is poorly understood, and usually explained only informally in terms of low-level implementation artifacts. Consequently, verifying high-level correctness properties in such environments remains a challenging problem. To address this issue, we present a novel program logic that enables compositional reasoning about the behavior of concurrently executing weakly-isolated transactions. Recognizing that the proof burden necessary to use this logic may dissuade application developers, we also describe an inference procedure based on this foundation that ascertains the weakest isolation level that still guarantees the safety of high-level consistency assertions associated with such transactions. The key to effective inference is the observation that weakly-isolated transactions can be viewed as functional (monadic) computations over an abstract database state, allowing us to treat their operations as state transformers over the database. This interpretation enables automated verification using off-the-shelf SMT solvers. Our development is parametric over a transaction’s specific isolation semantics, allowing it to be applicable over a range of concurrency control mechanisms. Case studies and experiments on real-world applications (written in an embedded DSL in OCaml) demonstrate the utility of our approach, and provide strong evidence that automated verification of weakly-isolated transactions can be placed on the same formal footing as their strongly-isolated serializable counterparts.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158115", "conference_name": "POPL", "authors": [ { - "first_name": "Nada", - "last_name": "Amin", - "institution": "University of Cambridge" + "first_name": "Gowtham", + "last_name": "Kaki", + "institution": "Purdue University West Lafayette" }, { - "first_name": "Tiark", - "last_name": "Rompf", + "first_name": "Kartik", + "last_name": "Nagar", "institution": "Purdue University West Lafayette" - } - ], - "dblp_key": "journals/pacmpl/AminR18", - "venue": "popl", - "year": 2018 - }, - { - "paper_id": "10.1145/3158095", - "title": "Handling fibred algebraic effects", - "abstract": "We study algebraic computational effects and their handlers in the dependently typed setting. We describe computational effects using a generalisation of Plotkin and Pretnar's effect theories, whose dependently typed operations allow us to capture precise notions of computation, e.g., state with location-dependent store types and dependently typed update monads. Our treatment of handlers is based on an observation that their conventional term-level definition leads to unsound program equivalences being derivable in languages that include a notion of homomorphism. We solve this problem by giving handlers a novel type-based treatment via a new computation type, the user-defined algebra type, which pairs a value type (the carrier) with a set of value terms (the operations), capturing Plotkin and Pretnar's insight that effect handlers denote algebras. We then show that the conventional presentation of handlers can be routinely derived, and demonstrate that this type-based treatment of handlers provides a useful mechanism for reasoning about effectful computations. We also equip the resulting language with a sound denotational semantics based on families fibrations.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158095", - "conference_name": "POPL", - "authors": [ + }, { - "first_name": "Danel", - "last_name": "Ahman", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Mahsa", + "last_name": "Najafzadeh", + "institution": "Purdue University West Lafayette" + }, + { + "first_name": "Suresh", + "last_name": "Jagannathan", + "institution": "Purdue University West Lafayette" } ], - "dblp_key": "journals/pacmpl/Ahman18", + "dblp_key": "journals/pacmpl/KakiNNJ18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158146", - "title": "Synthesizing coupling proofs of differential privacy", - "abstract": "Differential privacy has emerged as a promising probabilistic formulation of privacy, generating intense interest within academia and industry. We present a push-button, automated technique for verifying ε-differential privacy of sophisticated randomized algorithms. We make several conceptual, algorithmic, and practical contributions: (i) Inspired by the recent advances on approximate couplings and randomness alignment, we present a new proof technique called coupling strategies, which casts differential privacy proofs as a winning strategy in a game where we have finite privacy resources to expend. (ii) To discover a winning strategy, we present a constraint-based formulation of the problem as a set of Horn modulo couplings (HMC) constraints, a novel combination of first-order Horn clauses and probabilistic constraints. (iii) We present a technique for solving HMC constraints by transforming probabilistic constraints into logical constraints with uninterpreted functions. (iv) Finally, we implement our technique in the FairSquare verifier and provide the first automated privacy proofs for a number of challenging algorithms from the differential privacy literature, including Report Noisy Max, the Exponential Mechanism, and the Sparse Vector Mechanism.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158146", + "paper_id": "10.1145/3158119", + "title": "Data-centric dynamic partial order reduction", + "abstract": "We present a new dynamic partial-order reduction method for stateless model checking of concurrent programs. A common approach for exploring program behaviors relies on enumerating the traces of the program, without storing the visited states (aka stateless exploration). As the number of distinct traces grows exponentially, dynamic partial-order reduction (DPOR) techniques have been successfully used to partition the space of traces into equivalence classes ( Mazurkiewicz partitioning), with the goal of exploring only few representative traces from each class. We introduce a new equivalence on traces under sequential consistency semantics, which we call the observation equivalence. Two traces are observationally equivalent if every read event observes the same write event in both traces. While the traditional Mazurkiewicz equivalence is control-centric, our new definition is data-centric. We show that our observation equivalence is coarser than the Mazurkiewicz equivalence, and in many cases even exponentially coarser. We devise a DPOR exploration of the trace space, called data-centric DPOR, based on the observation equivalence. For acyclic architectures, our algorithm is guaranteed to explore exactly one representative trace from each observation class, while spending polynomial time per class. Hence, our algorithm is optimal wrt the observation equivalence, and in several cases explores exponentially fewer traces than any enumerative method based on the Mazurkiewicz equivalence. For cyclic architectures, we consider an equivalence between traces which is finer than the observation equivalence; but coarser than the Mazurkiewicz equivalence, and in some cases is exponentially coarser. Our data-centric DPOR algorithm remains optimal under this trace equivalence. Finally, we perform a basic experimental comparison between the existing Mazurkiewicz-based DPOR and our data-centric DPOR on a set of academic benchmarks. Our results show a significant reduction in both running time and the number of explored equivalence classes.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158119", "conference_name": "POPL", "authors": [ { - "first_name": "Aws", - "last_name": "Albarghouthi", - "institution": "University of Wisconsin–Madison" + "first_name": "Marek", + "last_name": "Chalupa", + "institution": "Masaryk University" }, { - "first_name": "Justin", - "last_name": "Hsu", - "institution": "University College London" + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Institute of Science and Technology Austria" + }, + { + "first_name": "Nishant", + "last_name": "Sinha", + "institution": "" + }, + { + "first_name": "Kapil", + "last_name": "Vaidya", + "institution": "Indian Institute of Technology Bombay" } ], - "dblp_key": "journals/pacmpl/AlbarghouthiH18", + "dblp_key": "journals/pacmpl/ChalupaCPSV18", "venue": "popl", "year": 2018 }, @@ -204,7 +173,7 @@ "paper_id": "10.1145/3158120", "title": "Analytical modeling of cache behavior for affine programs", "abstract": "Optimizing compilers implement program transformation strategies aimed at reducing data movement to or from main memory by exploiting the data-cache hierarchy. However, instead of attempting to minimize the number of cache misses, very approximate cost models are used, due to the lack of precise compile-time models for misses for hierarchical caches. The current state of practice for cache miss analysis is based on accurate simulation. However, simulation requires time proportional to the dataset/problem size, as well as the number of distinct cache configurations of interest to be evaluated. This paper takes a fundamentally different approach, by focusing on polyhedral programs with static control flow. Instead of relying on costly simulation, a closed-form solution for modeling of misses in a set associative cache hierarchy is developed. This solution can enable program transformation choice at compile time to optimize cache misses. A tool implementing the approach has been developed and used for validation of the framework.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158120", "conference_name": "POPL", "authors": [ @@ -234,424 +203,325 @@ "year": 2018 }, { - "paper_id": "10.1145/3158110", - "title": "Type-preserving CPS translation of Σ and Π types is not not possible", - "abstract": "Dependently typed languages such as Coq are used to specify and prove functional correctness of source programs, but what we ultimately need are guarantees about correctness of compiled code. By preserving dependent types through each compiler pass, we could preserve source-level specifications and correctness proofs into the generated target-language programs. Unfortunately, type-preserving compilation of dependent types is hard. In 2002, Barthe and Uustalu showed that type-preserving CPS is not possible for languages such as Coq. Specifically, they showed that for strong dependent pairs (Σ types), the standard typed call-by-name CPS is not type preserving . They further proved that for dependent case analysis on sums, a class of typed CPS translations—including the standard translation—is not possible . In 2016, Morrisett noticed a similar problem with the standard call-by-value CPS translation for dependent functions (Π types). In essence, the problem is that the standard typed CPS translation by double-negation, in which computations are assigned types of the form ( A → ⊥) → ⊥, disrupts the term/type equivalence that is used during type checking in a dependently typed language. In this paper, we prove that type-preserving CPS translation for dependently typed languages is not not possible. We develop both call-by-name and call-by-value CPS translations from the Calculus of Constructions with both Π and Σ types (CC) to a dependently typed target language, and prove type preservation and compiler correctness of each translation. Our target language is CC extended with an additional equivalence rule and an additional typing rule, which we prove consistent by giving a model in the extensional Calculus of Constructions. Our key observation is that we can use a CPS translation that employs answer-type polymorphism , where CPS-translated computations have type ∀ α. ( A → α) → α. This type justifies, by a free theorem , the new equality rule in our target language and allows us to recover the term/type equivalences that CPS translation disrupts. Finally, we conjecture that our translation extends to dependent case analysis on sums, despite the impossibility result, and provide a proof sketch.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158110", + "paper_id": "10.1145/3158145", + "title": "Proving expected sensitivity of probabilistic programs", + "abstract": "Program sensitivity, also known as Lipschitz continuity, describes how small changes in a program’s input lead to bounded changes in the output. We propose an average notion of program sensitivity for probabilistic programs—expected sensitivity—that averages a distance function over a probabilistic coupling of two output distributions from two similar inputs. By varying the distance, expected sensitivity recovers useful notions of probabilistic function sensitivity, including stability of machine learning algorithms and convergence of Markov chains. Furthermore, expected sensitivity satisfies clean compositional properties and is amenable to formal verification. We develop a relational program logic called EpRHL for proving expected sensitivity properties. Our logic features two key ideas. First, relational pre-conditions and post-conditions are expressed using distances, a real-valued generalization of typical boolean-valued (relational) assertions. Second, judgments are interpreted in terms of expectation coupling, a novel, quantitative generalization of probabilistic couplings which supports compositional reasoning. We demonstrate our logic on examples beyond the reach of prior relational logics. Our main example formalizes uniform stability of the stochastic gradient method. Furthermore, we prove rapid mixing for a probabilistic model of population dynamics. We also extend our logic with a transitivity principle for expectation couplings to capture the path coupling proof technique by Bubley and Dyer, and formalize rapid mixing of the Glauber dynamics from statistical physics.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158145", "conference_name": "POPL", "authors": [ { - "first_name": "William J.", - "last_name": "Bowman", - "institution": "Northeastern University" + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" }, { - "first_name": "Youyou", - "last_name": "Cong", - "institution": "Ochanomizu University" + "first_name": "Thomas", + "last_name": "Espitau", + "institution": "Computer Algorithms for Medicine" }, { - "first_name": "Nick", - "last_name": "Rioux", - "institution": "Northeastern University" + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en sciences et technologies du numérique" }, { - "first_name": "Amal", - "last_name": "Ahmed", - "institution": "Northeastern University" + "first_name": "Justin", + "last_name": "Hsu", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "École Polytechnique" } ], - "dblp_key": "journals/pacmpl/BowmanCRA18", + "dblp_key": "journals/pacmpl/BartheEGHS18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158096", - "title": "Handle with care: relational interpretation of algebraic effects and handlers", - "abstract": "Algebraic effects and handlers have received a lot of attention recently, both from the theoretical point of view and in practical language design. This stems from the fact that algebraic effects give the programmer unprecedented freedom to define, combine, and interpret computational effects. This plenty-of-rope, however, demands not only a deep understanding of the underlying semantics, but also access to practical means of reasoning about effectful code, including correctness and program equivalence. In this paper we tackle this problem by constructing a step-indexed relational interpretation of a call-by-value calculus with algebraic effect handlers and a row-based polymorphic type-and-effect system. Our calculus, while striving for simplicity, enjoys desirable theoretical properties, and is close to the cores of programming languages with algebraic effects used in the wild, while the logical relation we build for it can be used to reason about non-trivial properties, such as contextual equivalence and contextual approximation of programs. Our development has been fully formalised in the Coq proof assistant.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158096", + "paper_id": "10.1145/3158136", + "title": "Online detection of effectively callback free objects with applications to smart contracts", + "abstract": "Callbacks are essential in many programming environments, but drastically complicate program understanding and reasoning because they allow to mutate object's local states by external objects in unexpected fashions, thus breaking modularity. The famous DAO bug in the cryptocurrency framework Ethereum, employed callbacks to steal $150M. We define the notion of Effectively Callback Free (ECF) objects in order to allow callbacks without preventing modular reasoning. An object is ECF in a given execution trace if there exists an equivalent execution trace without callbacks to this object. An object is ECF if it is ECF in every possible execution trace. We study the decidability of dynamically checking ECF in a given execution trace and statically checking if an object is ECF. We also show that dynamically checking ECF in Ethereum is feasible and can be done online. By running the history of all execution traces in Ethereum, we were able to verify that virtually all existing contract executions, excluding these of the DAO or of contracts with similar known vulnerabilities, are ECF. Finally, we show that ECF, whether it is verified dynamically or statically, enables modular reasoning about objects with encapsulated state.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158136", "conference_name": "POPL", "authors": [ { - "first_name": "Dariusz", - "last_name": "Biernacki", - "institution": "University of Wrocław" + "first_name": "Shelly", + "last_name": "Grossman", + "institution": "Tel Aviv University" }, { - "first_name": "Maciej", - "last_name": "Piróg", - "institution": "University of Wrocław" + "first_name": "Ittai", + "last_name": "Abraham", + "institution": "Kitware (United States)" }, { - "first_name": "Piotr", - "last_name": "Polesiuk", - "institution": "University of Wrocław" + "first_name": "Guy", + "last_name": "Golan-Gueta", + "institution": "Kitware (United States)" }, { - "first_name": "Filip", - "last_name": "Sieczkowski", - "institution": "University of Wrocław" + "first_name": "Yan", + "last_name": "Michalevsky", + "institution": "Stanford University" + }, + { + "first_name": "Noam", + "last_name": "Rinetzky", + "institution": "Tel Aviv University" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Yoni", + "last_name": "Zohar", + "institution": "Tel Aviv University" } ], - "dblp_key": "journals/pacmpl/BiernackiPPS18", + "dblp_key": "journals/pacmpl/GrossmanAGMRSZ18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158111", - "title": "Decidability of conversion for type theory in type theory", - "abstract": "Type theory should be able to handle its own meta-theory, both to justify its foundational claims and to obtain a verified implementation. At the core of a type checker for intensional type theory lies an algorithm to check equality of types, or in other words, to check whether two types are convertible. We have formalized in Agda a practical conversion checking algorithm for a dependent type theory with one universe à la Russell, natural numbers, and η-equality for Π types. We prove the algorithm correct via a Kripke logical relation parameterized by a suitable notion of equivalence of terms. We then instantiate the parameterized fundamental lemma twice: once to obtain canonicity and injectivity of type formers, and once again to prove the completeness of the algorithm. Our proof relies on inductive-recursive definitions, but not on the uniqueness of identity proofs. Thus, it is valid in variants of intensional Martin-Löf Type Theory as long as they support induction-recursion, for instance, Extensional, Observational, or Homotopy Type Theory.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158111", + "paper_id": "10.1145/3158122", + "title": "Lexicographic ranking supermartingales: an efficient approach to termination of probabilistic programs", + "abstract": "Probabilistic programs extend classical imperative programs with real-valued random variables and random branching. The most basic liveness property for such programs is the termination property. The qualitative (aka almost-sure) termination problem asks whether a given program program terminates with probability 1. While ranking functions provide a sound and complete method for non-probabilistic programs, the extension of them to probabilistic programs is achieved via ranking supermartingales (RSMs). Although deep theoretical results have been established about RSMs, their application to probabilistic programs with nondeterminism has been limited only to programs of restricted control-flow structure. For non-probabilistic programs, lexicographic ranking functions provide a compositional and practical approach for termination analysis of real-world programs. In this work we introduce lexicographic RSMs and show that they present a sound method for almost-sure termination of probabilistic programs with nondeterminism. We show that lexicographic RSMs provide a tool for compositional reasoning about almost-sure termination, and for probabilistic programs with linear arithmetic they can be synthesized efficiently (in polynomial time). We also show that with additional restrictions even asymptotic bounds on expected termination time can be obtained through lexicographic RSMs. Finally, we present experimental results on benchmarks adapted from previous work to demonstrate the effectiveness of our approach.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158122", "conference_name": "POPL", "authors": [ { - "first_name": "Andreas", - "last_name": "Abel", - "institution": "University of Gothenburg" + "first_name": "Sheshansh", + "last_name": "Agrawal", + "institution": "Indian Institute of Technology Bombay" }, { - "first_name": "Joakim", - "last_name": "Öhman", - "institution": "IMDEA Software" + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Andrea", - "last_name": "Vezzosi", - "institution": "Chalmers University of Technology" + "first_name": "Petr", + "last_name": "Novotný", + "institution": "Institute of Science and Technology Austria" } ], - "dblp_key": "journals/pacmpl/0001OV18", - "venue": "popl", - "year": 2018 - }, - { - "paper_id": "10.1145/3158102", - "title": "Jones-optimal partial evaluation by specialization-safe normalization", - "abstract": "We present partial evaluation by specialization-safe normalization, a novel partial evaluation technique that is Jones-optimal, that can be self-applied to achieve the Futamura projections and that can be type-checked to ensure it always generates code with the correct type. Jones-optimality is the gold-standard for nontrivial partial evaluation and guarantees that a specializer can remove an entire layer of interpretation. We achieve Jones-optimality by using a novel affine-variable static analysis that directs specialization-safe normalization to always decrease a program’s runtime. We demonstrate the robustness of our approach by showing Jones-optimality in a variety of settings. We have formally proved that our partial evaluator is Jones-optimal for call-by-value reduction, and we have experimentally shown that it is Jones-optimal for call-by-value, normal-order, and memoized normal-order. Each of our experiments tests Jones-optimality with three different self-interpreters. We implemented our partial evaluator in F ω µ i , a recent language for typed self-applicable meta-programming. It is the first Jones-optimal and self-applicable partial evaluator whose type guarantees that it always generates type-correct code.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158102", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Matt", - "last_name": "Brown", - "institution": "University of California, Los Angeles" - }, - { - "first_name": "Jens", - "last_name": "Palsberg", - "institution": "University of California, Los Angeles" - } - ], - "dblp_key": "journals/pacmpl/BrownP18", + "dblp_key": "journals/pacmpl/AgrawalC018", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158093", - "title": "Linear Haskell: practical linearity in a higher-order polymorphic language", - "abstract": "Linear type systems have a long and storied history, but not a clear path forward to integrate with existing languages such as OCaml or Haskell. In this paper, we study a linear type system designed with two crucial properties in mind: backwards-compatibility and code reuse across linear and non-linear users of a library. Only then can the benefits of linear types permeate conventional functional programming. Rather than bifurcate types into linear and non-linear counterparts, we instead attach linearity to function arrows . Linear functions can receive inputs from linearly-bound values, but can also operate over unrestricted, regular values. To demonstrate the efficacy of our linear type system — both how easy it can be integrated in an existing language implementation and how streamlined it makes it to write programs with linear types — we implemented our type system in ghc, the leading Haskell compiler, and demonstrate two kinds of applications of linear types: mutable data with pure interfaces; and enforcing protocols in I/O-performing functions.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158093", + "paper_id": "10.1145/3158092", + "title": "String constraints with concatenation and transducers solved efficiently", + "abstract": "String analysis is the problem of reasoning about how strings are manipulated by a program. It has numerous applications including automatic detection of cross-site scripting, and automatic test-case generation. A popular string analysis technique includes symbolic executions, which at their core use constraint solvers over the string domain, a.k.a. string solvers. Such solvers typically reason about constraints expressed in theories over strings with the concatenation operator as an atomic constraint. In recent years, researchers started to recognise the importance of incorporating the replace-all operator (i.e. replace all occurrences of a string by another string) and, more generally, finite-state transductions in the theories of strings with concatenation. Such string operations are typically crucial for reasoning about XSS vulnerabilities in web applications, especially for modelling sanitisation functions and implicit browser transductions (e.g. innerHTML). Although this results in an undecidable theory in general, it was recently shown that the straight-line fragment of the theory is decidable, and is sufficiently expressive in practice. In this paper, we provide the first string solver that can reason about constraints involving both concatenation and finite-state transductions. Moreover, it has a completeness and termination guarantee for several important fragments (e.g. straight-line fragment). The main challenge addressed in the paper is the prohibitive worst-case complexity of the theory (double-exponential time), which is exponentially harder than the case without finite-state transductions. To this end, we propose a method that exploits succinct alternating finite-state automata as concise symbolic representations of string constraints. In contrast to previous approaches using nondeterministic automata, alternation offers not only exponential savings in space when representing Boolean combinations of transducers, but also a possibility of succinct representation of otherwise costly combinations of transducers and concatenation. Reasoning about the emptiness of the AFA language requires a state-space exploration in an exponential-sized graph, for which we use model checking algorithms (e.g. IC3). We have implemented our algorithm and demonstrated its efficacy on benchmarks that are derived from cross-site scripting analysis and other examples in the literature.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158092", "conference_name": "POPL", "authors": [ { - "first_name": "Jean-Philippe", - "last_name": "Bernardy", - "institution": "University of Gothenburg" + "first_name": "Lukáš", + "last_name": "Holík", + "institution": "Brno University of Technology" }, { - "first_name": "Mathieu", - "last_name": "Boespflug", - "institution": "" + "first_name": "Petr", + "last_name": "Janků", + "institution": "Brno University of Technology" }, { - "first_name": "Ryan R.", - "last_name": "Newton", - "institution": "Indiana University" + "first_name": "Anthony W.", + "last_name": "Lin", + "institution": "University of Oxford" }, { - "first_name": "Simon Peyton", - "last_name": "Jones", - "institution": "Microsoft Research (United Kingdom)" + "first_name": "Philipp", + "last_name": "Rümmer", + "institution": "Uppsala University" }, { - "first_name": "Arnaud", - "last_name": "Spiwack", - "institution": "" + "first_name": "Tomáš", + "last_name": "Vojnar", + "institution": "Brno University of Technology" } ], - "dblp_key": "journals/pacmpl/BernardyBNJS18", + "dblp_key": "journals/pacmpl/HolikJLRV18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158145", - "title": "Proving expected sensitivity of probabilistic programs", - "abstract": "Program sensitivity, also known as Lipschitz continuity, describes how small changes in a program’s input lead to bounded changes in the output. We propose an average notion of program sensitivity for probabilistic programs—expected sensitivity—that averages a distance function over a probabilistic coupling of two output distributions from two similar inputs. By varying the distance, expected sensitivity recovers useful notions of probabilistic function sensitivity, including stability of machine learning algorithms and convergence of Markov chains. Furthermore, expected sensitivity satisfies clean compositional properties and is amenable to formal verification. We develop a relational program logic called EpRHL for proving expected sensitivity properties. Our logic features two key ideas. First, relational pre-conditions and post-conditions are expressed using distances, a real-valued generalization of typical boolean-valued (relational) assertions. Second, judgments are interpreted in terms of expectation coupling, a novel, quantitative generalization of probabilistic couplings which supports compositional reasoning. We demonstrate our logic on examples beyond the reach of prior relational logics. Our main example formalizes uniform stability of the stochastic gradient method. Furthermore, we prove rapid mixing for a probabilistic model of population dynamics. We also extend our logic with a transitivity principle for expectation couplings to capture the path coupling proof technique by Bubley and Dyer, and formalize rapid mixing of the Glauber dynamics from statistical physics.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158145", + "paper_id": "10.1145/3158131", + "title": "Up-to techniques using sized types", + "abstract": "Up-to techniques are used to make it easier—or feasible—to construct, for instance, proofs of bisimilarity. This text shows how many up-to techniques can be framed as size-preserving functions , using sized types to keep track of sizes. Through a number of examples it is argued that this approach to up-to techniques is often convenient to use in practice. Some examples of functions that cannot be made size-preserving are also included, in order to illustrate the limits of the approach. On the more theoretical side a class of up-to techniques intended to capture a natural mode of use of size-preserving functions is defined. This class turns out to correspond closely to \"functions below the companion\", a notion recently introduced by Pous.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158131", "conference_name": "POPL", "authors": [ { - "first_name": "Gilles", - "last_name": "Barthe", - "institution": "IMDEA Software Institute" - }, - { - "first_name": "Thomas", - "last_name": "Espitau", - "institution": "Computer Algorithms for Medicine" - }, - { - "first_name": "Benjamin", - "last_name": "Grégoire", - "institution": "Institut national de recherche en sciences et technologies du numérique" - }, - { - "first_name": "Justin", - "last_name": "Hsu", - "institution": "California University of Pennsylvania" - }, - { - "first_name": "Pierre-Yves", - "last_name": "Strub", - "institution": "École Polytechnique" + "first_name": "Nils Anders", + "last_name": "Danielsson", + "institution": "University of Gothenburg" } ], - "dblp_key": "journals/pacmpl/BartheEGHS18", + "dblp_key": "journals/pacmpl/Danielsson18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158099", - "title": "Higher-order constrained horn clauses for verification", - "abstract": "Motivated by applications in automated verification of higher-order functional programs, we develop a notion of constrained Horn clauses in higher-order logic and a decision problem concerning their satisfiability. We show that, although satisfiable systems of higher-order clauses do not generally have least models, there is a notion of canonical model obtained through a reduction to a problem concerning a kind of monotone logic program. Following work in higher-order program verification, we develop a refinement type system in order to reason about and automate the search for models. This provides a sound but incomplete method for solving the decision problem. Finally, we show that there is a sense in which we can use refinement types to express properties of terms whilst staying within the higher-order constrained Horn clause framework.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158099", + "paper_id": "10.1145/3158095", + "title": "Handling fibred algebraic effects", + "abstract": "We study algebraic computational effects and their handlers in the dependently typed setting. We describe computational effects using a generalisation of Plotkin and Pretnar's effect theories, whose dependently typed operations allow us to capture precise notions of computation, e.g., state with location-dependent store types and dependently typed update monads. Our treatment of handlers is based on an observation that their conventional term-level definition leads to unsound program equivalences being derivable in languages that include a notion of homomorphism. We solve this problem by giving handlers a novel type-based treatment via a new computation type, the user-defined algebra type, which pairs a value type (the carrier) with a set of value terms (the operations), capturing Plotkin and Pretnar's insight that effect handlers denote algebras. We then show that the conventional presentation of handlers can be routinely derived, and demonstrate that this type-based treatment of handlers provides a useful mechanism for reasoning about effectful computations. We also equip the resulting language with a sound denotational semantics based on families fibrations.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158095", "conference_name": "POPL", "authors": [ { - "first_name": "Toby Cathcart", - "last_name": "Burn", - "institution": "University of Oxford" - }, - { - "first_name": "C.-H. Luke", - "last_name": "Ong", - "institution": "University of Oxford" - }, - { - "first_name": "Steven", - "last_name": "Ramsay", - "institution": "University of Bristol" + "first_name": "Danel", + "last_name": "Ahman", + "institution": "Institut national de recherche en informatique et en automatique" } ], - "dblp_key": "journals/pacmpl/BurnOR18", + "dblp_key": "journals/pacmpl/Ahman18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158103", - "title": "Migrating gradual types", - "abstract": "Gradual typing allows programs to enjoy the benefits of both static typing and dynamic typing. While it is often desirable to migrate a program from more dynamically-typed to more statically-typed or vice versa, gradual typing itself does not provide a way to facilitate this migration. This places the burden on programmers who have to manually add or remove type annotations. Besides the general challenge of adding type annotations to dynamically typed code, there are subtle interactions between these annotations in gradually typed code that exacerbate the situation. For example, to migrate a program to be as static as possible, in general, all possible combinations of adding or removing type annotations from parameters must be tried out and compared. In this paper, we address this problem by developing migrational typing, which efficiently types all possible ways of adding or removing type annotations from a gradually typed program. The typing result supports automatically migrating a program to be as static as possible, or introducing the least number of dynamic types necessary to remove a type error. The approach can be extended to support user-defined criteria about which annotations to modify. We have implemented migrational typing and evaluated it on large programs. The results show that migrational typing scales linearly with the size of the program and takes only 2–4 times longer than plain gradual typing.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158103", + "paper_id": "10.1145/3158128", + "title": "Symbolic types for lenient symbolic execution", + "abstract": "We present lambda_sym, a typed λ-calculus for lenient symbolic execution , where some language constructs do not recognize symbolic values. Its type system, however, ensures safe behavior of all symbolic values in a program. Our calculus extends a base occurrence typing system with symbolic types and mutable state, making it a suitable model for both functional and imperative symbolically executed languages. Naively allowing mutation in this mixed setting introduces soundness issues, however, so we further add concreteness polymorphism , which restores soundness without rejecting too many valid programs. To show that our calculus is a useful model for a real language, we implemented Typed Rosette, a typed extension of the solver-aided Rosette language. We evaluate Typed Rosette by porting a large code base, demonstrating that our type system accommodates a wide variety of symbolically executed programs.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158128", "conference_name": "POPL", "authors": [ { - "first_name": "John Peter", - "last_name": "Campora", - "institution": "University of Louisiana at Lafayette" - }, - { - "first_name": "Sheng", - "last_name": "Chen", - "institution": "University of Louisiana at Lafayette" + "first_name": "Stephen", + "last_name": "Chang", + "institution": "Northeastern University" }, { - "first_name": "Martin", - "last_name": "Erwig", - "institution": "Oregon State University" + "first_name": "Alex", + "last_name": "Knauth", + "institution": "Northeastern University" }, { - "first_name": "Eric", - "last_name": "Walkingshaw", - "institution": "Oregon State University" + "first_name": "Emina", + "last_name": "Torlak", + "institution": "University of Washington" } ], - "dblp_key": "journals/pacmpl/Campora0EW18", + "dblp_key": "journals/pacmpl/ChangKT18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158122", - "title": "Lexicographic ranking supermartingales: an efficient approach to termination of probabilistic programs", - "abstract": "Probabilistic programs extend classical imperative programs with real-valued random variables and random branching. The most basic liveness property for such programs is the termination property. The qualitative (aka almost-sure) termination problem asks whether a given program program terminates with probability 1. While ranking functions provide a sound and complete method for non-probabilistic programs, the extension of them to probabilistic programs is achieved via ranking supermartingales (RSMs). Although deep theoretical results have been established about RSMs, their application to probabilistic programs with nondeterminism has been limited only to programs of restricted control-flow structure. For non-probabilistic programs, lexicographic ranking functions provide a compositional and practical approach for termination analysis of real-world programs. In this work we introduce lexicographic RSMs and show that they present a sound method for almost-sure termination of probabilistic programs with nondeterminism. We show that lexicographic RSMs provide a tool for compositional reasoning about almost-sure termination, and for probabilistic programs with linear arithmetic they can be synthesized efficiently (in polynomial time). We also show that with additional restrictions even asymptotic bounds on expected termination time can be obtained through lexicographic RSMs. Finally, we present experimental results on benchmarks adapted from previous work to demonstrate the effectiveness of our approach.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158122", + "paper_id": "10.1145/3158146", + "title": "Synthesizing coupling proofs of differential privacy", + "abstract": "Differential privacy has emerged as a promising probabilistic formulation of privacy, generating intense interest within academia and industry. We present a push-button, automated technique for verifying ε-differential privacy of sophisticated randomized algorithms. We make several conceptual, algorithmic, and practical contributions: (i) Inspired by the recent advances on approximate couplings and randomness alignment, we present a new proof technique called coupling strategies, which casts differential privacy proofs as a winning strategy in a game where we have finite privacy resources to expend. (ii) To discover a winning strategy, we present a constraint-based formulation of the problem as a set of Horn modulo couplings (HMC) constraints, a novel combination of first-order Horn clauses and probabilistic constraints. (iii) We present a technique for solving HMC constraints by transforming probabilistic constraints into logical constraints with uninterpreted functions. (iv) Finally, we implement our technique in the FairSquare verifier and provide the first automated privacy proofs for a number of challenging algorithms from the differential privacy literature, including Report Noisy Max, the Exponential Mechanism, and the Sparse Vector Mechanism.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158146", "conference_name": "POPL", "authors": [ { - "first_name": "Sheshansh", - "last_name": "Agrawal", - "institution": "Indian Institute of Technology Bombay" - }, - { - "first_name": "Krishnendu", - "last_name": "Chatterjee", - "institution": "Institute of Science and Technology Austria" + "first_name": "Aws", + "last_name": "Albarghouthi", + "institution": "University of Wisconsin–Madison" }, { - "first_name": "Petr", - "last_name": "Novotný", - "institution": "Institute of Science and Technology Austria" + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University College London" } ], - "dblp_key": "journals/pacmpl/AgrawalC018", + "dblp_key": "journals/pacmpl/AlbarghouthiH18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158119", - "title": "Data-centric dynamic partial order reduction", - "abstract": "We present a new dynamic partial-order reduction method for stateless model checking of concurrent programs. A common approach for exploring program behaviors relies on enumerating the traces of the program, without storing the visited states (aka stateless exploration). As the number of distinct traces grows exponentially, dynamic partial-order reduction (DPOR) techniques have been successfully used to partition the space of traces into equivalence classes ( Mazurkiewicz partitioning), with the goal of exploring only few representative traces from each class. We introduce a new equivalence on traces under sequential consistency semantics, which we call the observation equivalence. Two traces are observationally equivalent if every read event observes the same write event in both traces. While the traditional Mazurkiewicz equivalence is control-centric, our new definition is data-centric. We show that our observation equivalence is coarser than the Mazurkiewicz equivalence, and in many cases even exponentially coarser. We devise a DPOR exploration of the trace space, called data-centric DPOR, based on the observation equivalence. For acyclic architectures, our algorithm is guaranteed to explore exactly one representative trace from each observation class, while spending polynomial time per class. Hence, our algorithm is optimal wrt the observation equivalence, and in several cases explores exponentially fewer traces than any enumerative method based on the Mazurkiewicz equivalence. For cyclic architectures, we consider an equivalence between traces which is finer than the observation equivalence; but coarser than the Mazurkiewicz equivalence, and in some cases is exponentially coarser. Our data-centric DPOR algorithm remains optimal under this trace equivalence. Finally, we perform a basic experimental comparison between the existing Mazurkiewicz-based DPOR and our data-centric DPOR on a set of academic benchmarks. Our results show a significant reduction in both running time and the number of explored equivalence classes.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158119", + "paper_id": "10.1145/3158110", + "title": "Type-preserving CPS translation of Σ and Π types is not not possible", + "abstract": "Dependently typed languages such as Coq are used to specify and prove functional correctness of source programs, but what we ultimately need are guarantees about correctness of compiled code. By preserving dependent types through each compiler pass, we could preserve source-level specifications and correctness proofs into the generated target-language programs. Unfortunately, type-preserving compilation of dependent types is hard. In 2002, Barthe and Uustalu showed that type-preserving CPS is not possible for languages such as Coq. Specifically, they showed that for strong dependent pairs (Σ types), the standard typed call-by-name CPS is not type preserving . They further proved that for dependent case analysis on sums, a class of typed CPS translations—including the standard translation—is not possible . In 2016, Morrisett noticed a similar problem with the standard call-by-value CPS translation for dependent functions (Π types). In essence, the problem is that the standard typed CPS translation by double-negation, in which computations are assigned types of the form ( A → ⊥) → ⊥, disrupts the term/type equivalence that is used during type checking in a dependently typed language. In this paper, we prove that type-preserving CPS translation for dependently typed languages is not not possible. We develop both call-by-name and call-by-value CPS translations from the Calculus of Constructions with both Π and Σ types (CC) to a dependently typed target language, and prove type preservation and compiler correctness of each translation. Our target language is CC extended with an additional equivalence rule and an additional typing rule, which we prove consistent by giving a model in the extensional Calculus of Constructions. Our key observation is that we can use a CPS translation that employs answer-type polymorphism , where CPS-translated computations have type ∀ α. ( A → α) → α. This type justifies, by a free theorem , the new equality rule in our target language and allows us to recover the term/type equivalences that CPS translation disrupts. Finally, we conjecture that our translation extends to dependent case analysis on sums, despite the impossibility result, and provide a proof sketch.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158110", "conference_name": "POPL", "authors": [ { - "first_name": "Marek", - "last_name": "Chalupa", - "institution": "Masaryk University" - }, - { - "first_name": "Krishnendu", - "last_name": "Chatterjee", - "institution": "Institute of Science and Technology Austria" - }, - { - "first_name": "Andreas", - "last_name": "Pavlogiannis", - "institution": "Institute of Science and Technology Austria" - }, - { - "first_name": "Nishant", - "last_name": "Sinha", - "institution": "" + "first_name": "William J.", + "last_name": "Bowman", + "institution": "Northeastern University" }, { - "first_name": "Kapil", - "last_name": "Vaidya", - "institution": "Indian Institute of Technology Bombay" - } - ], - "dblp_key": "journals/pacmpl/ChalupaCPSV18", - "venue": "popl", - "year": 2018 - }, - { - "paper_id": "10.1145/3158150", - "title": "Bonsai: synthesis-based reasoning for type systems", - "abstract": "When designing a type system, we may want to mechanically check the design to guide its further development. We describe algorithms that perform symbolic reasoning about executable models of type systems. The algorithms support three queries. First, they check type soundness and synthesize a counterexample program if such a soundness bug is found. Second, they compare two versions of a type system, synthesizing a program accepted by one but rejected by the other. Third, they minimize the size of synthesized counterexample programs. These algorithms symbolically evaluate typecheckers and interpreters, producing formulas that characterize the set of programs that fail or succeed in the typechecker and the interpreter. However, symbolically evaluating interpreters poses efficiency challenges, which are caused by having to merge execution paths of the various possible input programs. Our main contribution is the bonsai tree , a novel symbolic representation of programs and program states that addresses these challenges. Bonsai trees encode complex syntactic information in terms of logical constraints, enabling more efficient merging. We implement these algorithms in the Bonsai tool, an assistant for type system designers. We perform case studies on how Bonsai helps test and explore a variety of type systems. Bonsai efficiently synthesizes counterexamples for soundness bugs previously inaccessible to automatic tools and is the first automated tool to find a counterexample for the recently discovered Scala soundness bug SI-9633.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158150", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Kartik", - "last_name": "Chandra", - "institution": "Stanford University" + "first_name": "Youyou", + "last_name": "Cong", + "institution": "Ochanomizu University" }, { - "first_name": "Rastislav", - "last_name": "Bodík", - "institution": "University of Washington" - } - ], - "dblp_key": "journals/pacmpl/ChandraB18", - "venue": "popl", - "year": 2018 - }, - { - "paper_id": "10.1145/3158132", - "title": "Univalent higher categories via complete Semi-Segal types", - "abstract": "Category theory in homotopy type theory is intricate as categorical laws can only be stated \"up to homotopy\", and thus require coherences. The established notion of a univalent category (as introduced by Ahrens et al.) solves this by considering only truncated types, roughly corresponding to an ordinary category. This fails to capture many naturally occurring structures, stemming from the fact that the naturally occurring structures in homotopy type theory are not ordinary, but rather higher categories. Out of the large variety of approaches to higher category theory that mathematicians have proposed, we believe that, for type theory, the simplicial strategy is best suited. Work by Lurie and Harpaz motivates the following definition. Given the first ( n +3) levels of a semisimplicial type S , we can equip S with three properties: first, contractibility of the types of certain horn fillers; second, a completeness property; and third, a truncation condition. We call this a complete semi-Segal n -type . This is very similar to an earlier suggestion by Schreiber. The definition of a univalent (1-) category by Ahrens et al. can easily be extended or restricted to the definition of a univalent n -category (more precisely, ( n ,1)-category) for n ∈ {0,1,2}, and we show that the type of complete semi-Segal n -types is equivalent to the type of univalent n -categories in these cases. Thus, we believe that the notion of a complete semi-Segal n -type can be taken as the definition of a univalent n -category. We provide a formalisation in the proof assistant Agda using a completely explicit representation of semi-simplicial types for levels up to 4.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158132", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Paolo", - "last_name": "Capriotti", - "institution": "University of Nottingham" + "first_name": "Nick", + "last_name": "Rioux", + "institution": "Northeastern University" }, { - "first_name": "Nicolai", - "last_name": "Kraus", - "institution": "University of Nottingham" + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" } ], - "dblp_key": "journals/pacmpl/CapriottiK18", + "dblp_key": "journals/pacmpl/BowmanCRA18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158128", - "title": "Symbolic types for lenient symbolic execution", - "abstract": "We present lambda_sym, a typed λ-calculus for lenient symbolic execution , where some language constructs do not recognize symbolic values. Its type system, however, ensures safe behavior of all symbolic values in a program. Our calculus extends a base occurrence typing system with symbolic types and mutable state, making it a suitable model for both functional and imperative symbolically executed languages. Naively allowing mutation in this mixed setting introduces soundness issues, however, so we further add concreteness polymorphism , which restores soundness without rejecting too many valid programs. To show that our calculus is a useful model for a real language, we implemented Typed Rosette, a typed extension of the solver-aided Rosette language. We evaluate Typed Rosette by porting a large code base, demonstrating that our type system accommodates a wide variety of symbolically executed programs.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158128", + "paper_id": "10.1145/3158100", + "title": "Relatively complete refinement type system for verification of higher-order non-deterministic programs", + "abstract": "This paper considers verification of non-deterministic higher-order functional programs. Our contribution is a novel type system in which the types are used to express and verify (conditional) safety, termination, non-safety, and non-termination properties in the presence of ∀-∃ branching behavior due to non-determinism. For instance, the judgement ⊢ e :{ u : int | φ( u ) } ∀∀ says that every evaluation of e either diverges or reduces to some integer u satisfying φ( u ), whereas ⊢ e :{ u : int | ψ( u ) } ∃∀ says that there exists an evaluation of e that either diverges or reduces to some integer u satisfying ψ( u ). Note that the former is a safety property whereas the latter is a counterexample to a (conditional) termination property. Following the recent work on type-based verification methods for deterministic higher-order functional programs, we formalize the idea on the foundation of dependent refinement types , thereby allowing the type system to express and verify rich properties involving program values, branching behaviors, and the combination thereof. Our type system is able to seamlessly combine deductions of both universal and existential facts within a unified framework, paving the way for an exciting opportunity for new type-based verification methods that combine both universal and existential reasoning. For example, our system can prove the existence of a path violating some safety property from a proof of termination that uses a well-foundedness termination argument. We prove that our type system is sound and relatively complete, and further, thanks to having both modes of non-determinism, we show that our types are closed under complement.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158100", "conference_name": "POPL", "authors": [ { - "first_name": "Stephen", - "last_name": "Chang", - "institution": "Northeastern University" + "first_name": "Hiroshi", + "last_name": "Unno", + "institution": "University of Tsukuba" }, { - "first_name": "Alex", - "last_name": "Knauth", - "institution": "Northeastern University" + "first_name": "Yuki", + "last_name": "Satake", + "institution": "University of Tsukuba" }, { - "first_name": "Emina", - "last_name": "Torlak", - "institution": "University of Washington" + "first_name": "Tachio", + "last_name": "Terauchi", + "institution": "Waseda University" } ], - "dblp_key": "journals/pacmpl/ChangKT18", + "dblp_key": "journals/pacmpl/0001ST18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158127", - "title": "Linearity in higher-order recursion schemes", - "abstract": "Higher-order recursion schemes (HORS) have recently emerged as a promising foundation for higher-order program verification. We examine the impact of enriching HORS with linear types. To that end, we introduce two frameworks that blend non-linear and linear types: a variant of the λY -calculus and an extension of HORS, called linear HORS (LHORS). First we prove that the two formalisms are equivalent and there exist polynomial-time translations between them. Then, in order to support model-checking of (trees generated by) LHORS, we propose a refined version of alternating parity tree automata, called LNAPTA, whose behaviour depends on information about linearity. We show that the complexity of LNAPTA model-checking for LHORS depends on two type-theoretic parameters: linear order and linear depth. The former is in general smaller than the standard notion of order and ignores linear function spaces. In contrast, the latter measures the depth of linear clusters inside a type. Our main result states that LNAPTA model-checking of LHORS of linear order n is n-EXPTIME-complete, when linear depth is fixed. This generalizes and improves upon the classic result of Ong, which relies on the standard notion of order. To illustrate the significance of the result, we consider two applications: the MSO model-checking problem on variants of HORS with case distinction (RSFD and HORSC) on a finite domain and a call-by-value resource verification problem. In both cases, decidability can be established by translation into HORS, but the implied complexity bounds will be suboptimal due to increases in type order. In contrast, we show that the complexity bounds derived by translations into LHORS and appealing to our result are optimal in that they match the respective hardness results.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158127", + "paper_id": "10.1145/3158090", + "title": "WebRelate: integrating web data with spreadsheets using examples", + "abstract": "Data integration between web sources and relational data is a key challenge faced by data scientists and spreadsheet users. There are two main challenges in programmatically joining web data with relational data. First, most websites do not expose a direct interface to obtain tabular data, so the user needs to formulate a logic to get to different webpages for each input row in the relational table. Second, after reaching the desired webpage, the user needs to write complex scripts to extract the relevant data, which is often conditioned on the input data. Since many data scientists and end-users come from diverse backgrounds, writing such complex regular-expression based logical scripts to perform data integration tasks is unfortunately often beyond their programming expertise. We present WebRelate, a system that allows users to join semi-structured web data with relational data in spreadsheets using input-output examples. WebRelate decomposes the web data integration task into two sub-tasks of i) URL learning and ii) input-dependent web extraction. We introduce a novel synthesis paradigm called \"Output-constrained Programming By Examples\", which allows us to use the finite set of possible outputs for the new inputs to efficiently constrain the search in the synthesis algorithm. We instantiate this paradigm for the two sub-tasks in WebRelate. The first sub-task generates the URLs for the webpages containing the desired data for all rows in the relational table. WebRelate achieves this by learning a string transformation program using a few example URLs. The second sub-task uses examples of desired data to be extracted from the corresponding webpages and learns a program to extract the data for the other rows. We design expressive domain-specific languages for URL generation and web data extraction, and present efficient synthesis algorithms for learning programs in these DSLs from few input-output examples. We evaluate WebRelate on 88 real-world web data integration tasks taken from online help forums and Excel product team, and show that WebRelate can learn the desired programs within few seconds using only 1 example for the majority of the tasks.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158090", "conference_name": "POPL", "authors": [ { - "first_name": "Pierre", - "last_name": "Clairambault", - "institution": "Université Claude Bernard Lyon 1" - }, - { - "first_name": "Charles", - "last_name": "Grellois", - "institution": "University of Bologna" + "first_name": "Jeevana Priya", + "last_name": "Inala", + "institution": "Moscow Institute of Thermal Technology" }, { - "first_name": "Andrzej S.", - "last_name": "Murawski", - "institution": "University of Oxford" + "first_name": "Rishabh", + "last_name": "Singh", + "institution": "Microsoft (United States)" } ], - "dblp_key": "journals/pacmpl/ClairambaultGM18", + "dblp_key": "journals/pacmpl/InalaS18", "venue": "popl", "year": 2018 }, @@ -659,7 +529,7 @@ "paper_id": "10.1145/3158091", "title": "What is decidable about string constraints with the ReplaceAll function", "abstract": "The theory of strings with concatenation has been widely argued as the basis of constraint solving for verifying string-manipulating programs. However, this theory is far from adequate for expressing many string constraints that are also needed in practice; for example, the use of regular constraints (pattern matching against a regular expression), and the string-replace function (replacing either the first occurrence or all occurrences of a ``pattern'' string constant/variable/regular expression by a ``replacement'' string constant/variable), among many others. Both regular constraints and the string-replace function are crucial for such applications as analysis of JavaScript (or more generally HTML5 applications) against cross-site scripting (XSS) vulnerabilities, which motivates us to consider a richer class of string constraints. The importance of the string-replace function (especially the replace-all facility) is increasingly recognised, which can be witnessed by the incorporation of the function in the input languages of several string constraint solvers. Recently, it was shown that any theory of strings containing the string-replace function (even the most restricted version where pattern/replacement strings are both constant strings) becomes undecidable if we do not impose some kind of straight-line (aka acyclicity) restriction on the formulas. Despite this, the straight-line restriction is still practically sensible since this condition is typically met by string constraints that are generated by symbolic execution. In this paper, we provide the first systematic study of straight-line string constraints with the string-replace function and the regular constraints as the basic operations. We show that a large class of such constraints (i.e. when only a constant string or a regular expression is permitted in the pattern) is decidable. We note that the string-replace function, even under this restriction, is sufficiently powerful for expressing the concatenation operator and much more (e.g. extensions of regular expressions with string variables). This gives us the most expressive decidable logic containing concatenation, replace, and regular constraints under the same umbrella. Our decision procedure for the straight-line fragment follows an automata-theoretic approach, and is modular in the sense that the string-replace terms are removed one by one to generate more and more regular constraints, which can then be discharged by the state-of-the-art string constraint solvers. We also show that this fragment is, in a way, a maximal decidable subclass of the straight-line fragment with string-replace and regular constraints. To this end, we show undecidability results for the following two extensions: (1) variables are permitted in the pattern parameter of the replace function, (2) length constraints are permitted.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158091", "conference_name": "POPL", "authors": [ @@ -694,358 +564,282 @@ "year": 2018 }, { - "paper_id": "10.1145/3158106", - "title": "Transactions in relaxed memory architectures", - "abstract": "The integration of transactions into hardware relaxed memory architectures is a topic of current research both in industry and academia. In this paper, we provide a general architectural framework for the introduction of transactions into models of relaxed memory in hardware, including the SC, TSO, ARMv8 and PPC models. Our framework incorporates flexible and expressive forms of transaction aborts and execution that have hitherto been in the realm of software transactional memory. In contrast to software transactional memory, we account for the characteristics of relaxed memory as a restricted form of distributed system, without a notion of global time. We prove abstraction theorems to demonstrate that the programmer API matches the intuitions and expectations about transactions.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158106", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Brijesh", - "last_name": "Dongol", - "institution": "Brunel University of London" - }, - { - "first_name": "Radha", - "last_name": "Jagadeesan", - "institution": "DePaul University" - }, - { - "first_name": "James", - "last_name": "Riely", - "institution": "DePaul University" - } - ], - "dblp_key": "journals/pacmpl/DongolJR18", - "venue": "popl", - "year": 2018 - }, - { - "paper_id": "10.1145/3158126", - "title": "Parametricity versus the universal type", - "abstract": "There has long been speculation in the scientific literature on how to dynamically enforce parametricity such as that yielded by System F. Almost 20 years ago, Sumii and Pierce proposed a formal compiler from System F into the cryptographic lambda calculus: an untyped lambda calculus extended with an idealised model of encryption. They conjectured that this compiler was fully abstract, i.e. that compiled terms are contextually equivalent if and only if the original terms were, a property that can be seen as a form of secure compilation. The conjecture has received attention in several other publications since then, but remains open to this day. More recently, several researchers have been looking at gradually-typed languages that extend System F. In this setting it is natural to wonder whether embedding System F into these gradually-typed languages preserves contextual equivalence and thus parametricity. In this paper, we answer both questions negatively. We provide a concrete counterexample: two System F terms whose contextual equivalence is not preserved by the Sumii-Pierce compiler, nor the embedding into the polymorphic blame calculus. This counterexample relies on the absence in System F of what we call a universal type, i.e., a type that all other types can be injected into and extracted from. As the languages in which System F is compiled have a universal type, the compilation cannot be fully abstract; this paper explains why. We believe this paper thus sheds light on recent results in the field of gradually typed languages and it provides a perspective for further research into secure compilation of polymorphic languages.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158126", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Dominique", - "last_name": "Devriese", - "institution": "KU Leuven" - }, - { - "first_name": "Marco", - "last_name": "Patrignani", - "institution": "Helmholtz Center for Information Security" - }, - { - "first_name": "Frank", - "last_name": "Piessens", - "institution": "KU Leuven" - } - ], - "dblp_key": "journals/pacmpl/DevriesePP18", - "venue": "popl", - "year": 2018 - }, - { - "paper_id": "10.1145/3158147", - "title": "Measurable cones and stable, measurable functions: a model for probabilistic higher-order programming", - "abstract": "We define a notion of stable and measurable map between cones endowed with measurability tests and show that it forms a cpo-enriched cartesian closed category. This category gives a denotational model of an extension of PCF supporting the main primitives of probabilistic functional programming, like continuous and discrete probabilistic distributions, sampling, conditioning and full recursion. We prove the soundness and adequacy of this model with respect to a call-by-name operational semantics and give some examples of its denotations.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158147", + "paper_id": "10.1145/3158099", + "title": "Higher-order constrained horn clauses for verification", + "abstract": "Motivated by applications in automated verification of higher-order functional programs, we develop a notion of constrained Horn clauses in higher-order logic and a decision problem concerning their satisfiability. We show that, although satisfiable systems of higher-order clauses do not generally have least models, there is a notion of canonical model obtained through a reduction to a problem concerning a kind of monotone logic program. Following work in higher-order program verification, we develop a refinement type system in order to reason about and automate the search for models. This provides a sound but incomplete method for solving the decision problem. Finally, we show that there is a sense in which we can use refinement types to express properties of terms whilst staying within the higher-order constrained Horn clause framework.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158099", "conference_name": "POPL", "authors": [ { - "first_name": "Thomas", - "last_name": "Ehrhard", - "institution": "Université Paris Cité" + "first_name": "Toby Cathcart", + "last_name": "Burn", + "institution": "University of Oxford" }, { - "first_name": "Michele", - "last_name": "Pagani", - "institution": "Université Paris Cité" + "first_name": "C.-H. Luke", + "last_name": "Ong", + "institution": "University of Oxford" }, { - "first_name": "Christine", - "last_name": "Tasson", - "institution": "Délégation Paris 7" + "first_name": "Steven", + "last_name": "Ramsay", + "institution": "University of Bristol" } ], - "dblp_key": "journals/pacmpl/EhrhardPT18", + "dblp_key": "journals/pacmpl/BurnOR18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158118", - "title": "Optimal Dyck reachability for data-dependence and alias analysis", - "abstract": "A fundamental algorithmic problem at the heart of static analysis is Dyck reachability. The input is a graph where the edges are labeled with different types of opening and closing parentheses, and the reachability information is computed via paths whose parentheses are properly matched. We present new results for Dyck reachability problems with applications to alias analysis and data-dependence analysis. Our main contributions, that include improved upper bounds as well as lower bounds that establish optimality guarantees, are as follows: First, we consider Dyck reachability on bidirected graphs, which is the standard way of performing field-sensitive points-to analysis. Given a bidirected graph with n nodes and m edges, we present: (i) an algorithm with worst-case running time O ( m + n · α( n )), where α( n ) is the inverse Ackermann function, improving the previously known O ( n 2 ) time bound; (ii) a matching lower bound that shows that our algorithm is optimal wrt to worst-case complexity; and (iii) an optimal average-case upper bound of O ( m ) time, improving the previously known O ( m · log n ) bound. Second, we consider the problem of context-sensitive data-dependence analysis, where the task is to obtain analysis summaries of library code in the presence of callbacks. Our algorithm preprocesses libraries in almost linear time, after which the contribution of the library in the complexity of the client analysis is only linear, and only wrt the number of call sites. Third, we prove that combinatorial algorithms for Dyck reachability on general graphs with truly sub-cubic bounds cannot be obtained without obtaining sub-cubic combinatorial algorithms for Boolean Matrix Multiplication, which is a long-standing open problem. Thus we establish that the existing combinatorial algorithms for Dyck reachability are (conditionally) optimal for general graphs. We also show that the same hardness holds for graphs of constant treewidth. Finally, we provide a prototype implementation of our algorithms for both alias analysis and data-dependence analysis. Our experimental evaluation demonstrates that the new algorithms significantly outperform all existing methods on the two problems, over real-world benchmarks.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158118", + "paper_id": "10.1145/3158140", + "title": "Collapsing towers of interpreters", + "abstract": "Given a tower of interpreters, i.e., a sequence of multiple interpreters interpreting one another as input programs, we aim to collapse this tower into a compiler that removes all interpretive overhead and runs in a single pass. In the real world, a use case might be Python code executed by an x86 runtime, on a CPU emulated in a JavaScript VM, running on an ARM CPU. Collapsing such a tower can not only exponentially improve runtime performance, but also enable the use of base-language tools for interpreted programs, e.g., for analysis and verification. In this paper, we lay the foundations in an idealized but realistic setting. We present a multi-level lambda calculus that features staging constructs and stage polymorphism: based on runtime parameters, an evaluator either executes source code (thereby acting as an interpreter) or generates code (thereby acting as a compiler). We identify stage polymorphism, a programming model from the domain of high-performance program generators, as the key mechanism to make such interpreters compose in a collapsible way. We present Pink, a meta-circular Lisp-like evaluator on top of this calculus, and demonstrate that we can collapse arbitrarily many levels of self-interpretation, including levels with semantic modifications. We discuss several examples: compiling regular expressions through an interpreter to base code, building program transformers from modi ed interpreters, and others. We develop these ideas further to include reflection and reification, culminating in Purple, a reflective language inspired by Brown, Blond, and Black, which realizes a conceptually infinite tower, where every aspect of the semantics can change dynamically. Addressing an open challenge, we show how user programs can be compiled and recompiled under user-modified semantics.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158140", "conference_name": "POPL", "authors": [ { - "first_name": "Krishnendu", - "last_name": "Chatterjee", - "institution": "Institute of Science and Technology Austria" - }, - { - "first_name": "Bhavya", - "last_name": "Choudhary", - "institution": "Indian Institute of Technology Bombay" + "first_name": "Nada", + "last_name": "Amin", + "institution": "University of Cambridge" }, { - "first_name": "Andreas", - "last_name": "Pavlogiannis", - "institution": "Institute of Science and Technology Austria" + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" } ], - "dblp_key": "journals/pacmpl/ChatterjeeCP18", + "dblp_key": "journals/pacmpl/AminR18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158131", - "title": "Up-to techniques using sized types", - "abstract": "Up-to techniques are used to make it easier—or feasible—to construct, for instance, proofs of bisimilarity. This text shows how many up-to techniques can be framed as size-preserving functions , using sized types to keep track of sizes. Through a number of examples it is argued that this approach to up-to techniques is often convenient to use in practice. Some examples of functions that cannot be made size-preserving are also included, in order to illustrate the limits of the approach. On the more theoretical side a class of up-to techniques intended to capture a natural mode of use of size-preserving functions is defined. This class turns out to correspond closely to \"functions below the companion\", a notion recently introduced by Pous.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158131", + "paper_id": "10.1145/3158125", + "title": "Go with the flow: compositional abstractions for concurrent data structures", + "abstract": "Concurrent separation logics have helped to significantly simplify correctness proofs for concurrent data structures. However, a recurring problem in such proofs is that data structure abstractions that work well in the sequential setting are much harder to reason about in a concurrent setting due to complex sharing and overlays. To solve this problem, we propose a novel approach to abstracting regions in the heap by encoding the data structure invariant into a local condition on each individual node. This condition may depend on a quantity associated with the node that is computed as a fixpoint over the entire heap graph. We refer to this quantity as a flow . Flows can encode both structural properties of the heap (e.g. the reachable nodes from the root form a tree) as well as data invariants (e.g. sortedness). We then introduce the notion of a flow interface , which expresses the relies and guarantees that a heap region imposes on its context to maintain the local flow invariant with respect to the global heap. Our main technical result is that this notion leads to a new semantic model of separation logic. In this model, flow interfaces provide a general abstraction mechanism for describing complex data structures. This abstraction mechanism admits proof rules that generalize over a wide variety of data structures. To demonstrate the versatility of our approach, we show how to extend the logic RGSep with flow interfaces. We have used this new logic to prove linearizability and memory safety of nontrivial concurrent data structures. In particular, we obtain parametric linearizability proofs for concurrent dictionary algorithms that abstract from the details of the underlying data structure representation. These proofs cannot be easily expressed using the abstraction mechanisms provided by existing separation logics.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158125", "conference_name": "POPL", "authors": [ { - "first_name": "Nils Anders", - "last_name": "Danielsson", - "institution": "University of Gothenburg" + "first_name": "Siddharth", + "last_name": "Krishna", + "institution": "New York University" + }, + { + "first_name": "Dennis", + "last_name": "Shasha", + "institution": "New York University" + }, + { + "first_name": "Thomas", + "last_name": "Wies", + "institution": "New York University" } ], - "dblp_key": "journals/pacmpl/Danielsson18", + "dblp_key": "journals/pacmpl/KrishnaSW18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158113", - "title": "Sound, complete, and tractable linearizability monitoring for concurrent collections", - "abstract": "While many program properties like the validity of assertions and in-bounds array accesses admit nearly-trivial monitoring algorithms, the standard correctness criterion for concurrent data structures does not. Given an implementation of an arbitrary abstract data type, checking whether the operations invoked in one single concurrent execution are linearizable, i.e., indistinguishable from an execution where the same operations are invoked atomically, requires exponential time in the number of operations. In this work we identify a class of collection abstract data types which admit polynomial-time linearizability monitors. Collections capture the majority of concurrent data structures available in practice, including stacks, queues, sets, and maps. Although monitoring executions of arbitrary abstract data types requires enumerating exponentially-many possible linearizations, collections enjoy combinatorial properties which avoid the enumeration. We leverage these properties to reduce linearizability to Horn satisfiability. As far as we know, ours is the first sound, complete, and tractable algorithm for monitoring linearizability for types beyond single-value registers.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158113", + "paper_id": "10.1145/3158150", + "title": "Bonsai: synthesis-based reasoning for type systems", + "abstract": "When designing a type system, we may want to mechanically check the design to guide its further development. We describe algorithms that perform symbolic reasoning about executable models of type systems. The algorithms support three queries. First, they check type soundness and synthesize a counterexample program if such a soundness bug is found. Second, they compare two versions of a type system, synthesizing a program accepted by one but rejected by the other. Third, they minimize the size of synthesized counterexample programs. These algorithms symbolically evaluate typecheckers and interpreters, producing formulas that characterize the set of programs that fail or succeed in the typechecker and the interpreter. However, symbolically evaluating interpreters poses efficiency challenges, which are caused by having to merge execution paths of the various possible input programs. Our main contribution is the bonsai tree , a novel symbolic representation of programs and program states that addresses these challenges. Bonsai trees encode complex syntactic information in terms of logical constraints, enabling more efficient merging. We implement these algorithms in the Bonsai tool, an assistant for type system designers. We perform case studies on how Bonsai helps test and explore a variety of type systems. Bonsai efficiently synthesizes counterexamples for soundness bugs previously inaccessible to automatic tools and is the first automated tool to find a counterexample for the recently discovered Scala soundness bug SI-9633.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158150", "conference_name": "POPL", "authors": [ { - "first_name": "Michael", - "last_name": "Emmi", - "institution": "SRI International" + "first_name": "Kartik", + "last_name": "Chandra", + "institution": "Stanford University" }, { - "first_name": "Constantin", - "last_name": "Enea", - "institution": "Université Paris Cité" + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" } ], - "dblp_key": "journals/pacmpl/EmmiE18", + "dblp_key": "journals/pacmpl/ChandraB18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158136", - "title": "Online detection of effectively callback free objects with applications to smart contracts", - "abstract": "Callbacks are essential in many programming environments, but drastically complicate program understanding and reasoning because they allow to mutate object's local states by external objects in unexpected fashions, thus breaking modularity. The famous DAO bug in the cryptocurrency framework Ethereum, employed callbacks to steal $150M. We define the notion of Effectively Callback Free (ECF) objects in order to allow callbacks without preventing modular reasoning. An object is ECF in a given execution trace if there exists an equivalent execution trace without callbacks to this object. An object is ECF if it is ECF in every possible execution trace. We study the decidability of dynamically checking ECF in a given execution trace and statically checking if an object is ECF. We also show that dynamically checking ECF in Ethereum is feasible and can be done online. By running the history of all execution traces in Ethereum, we were able to verify that virtually all existing contract executions, excluding these of the DAO or of contracts with similar known vulnerabilities, are ECF. Finally, we show that ECF, whether it is verified dynamically or statically, enables modular reasoning about objects with encapsulated state.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158136", + "paper_id": "10.1145/3158126", + "title": "Parametricity versus the universal type", + "abstract": "There has long been speculation in the scientific literature on how to dynamically enforce parametricity such as that yielded by System F. Almost 20 years ago, Sumii and Pierce proposed a formal compiler from System F into the cryptographic lambda calculus: an untyped lambda calculus extended with an idealised model of encryption. They conjectured that this compiler was fully abstract, i.e. that compiled terms are contextually equivalent if and only if the original terms were, a property that can be seen as a form of secure compilation. The conjecture has received attention in several other publications since then, but remains open to this day. More recently, several researchers have been looking at gradually-typed languages that extend System F. In this setting it is natural to wonder whether embedding System F into these gradually-typed languages preserves contextual equivalence and thus parametricity. In this paper, we answer both questions negatively. We provide a concrete counterexample: two System F terms whose contextual equivalence is not preserved by the Sumii-Pierce compiler, nor the embedding into the polymorphic blame calculus. This counterexample relies on the absence in System F of what we call a universal type, i.e., a type that all other types can be injected into and extracted from. As the languages in which System F is compiled have a universal type, the compilation cannot be fully abstract; this paper explains why. We believe this paper thus sheds light on recent results in the field of gradually typed languages and it provides a perspective for further research into secure compilation of polymorphic languages.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158126", "conference_name": "POPL", "authors": [ { - "first_name": "Shelly", - "last_name": "Grossman", - "institution": "Tel Aviv University" - }, - { - "first_name": "Ittai", - "last_name": "Abraham", - "institution": "Kitware (United States)" - }, - { - "first_name": "Guy", - "last_name": "Golan-Gueta", - "institution": "Kitware (United States)" - }, - { - "first_name": "Yan", - "last_name": "Michalevsky", - "institution": "Stanford University" - }, - { - "first_name": "Noam", - "last_name": "Rinetzky", - "institution": "Tel Aviv University" + "first_name": "Dominique", + "last_name": "Devriese", + "institution": "KU Leuven" }, { - "first_name": "Mooly", - "last_name": "Sagiv", - "institution": "Tel Aviv University" + "first_name": "Marco", + "last_name": "Patrignani", + "institution": "Helmholtz Center for Information Security" }, { - "first_name": "Yoni", - "last_name": "Zohar", - "institution": "Tel Aviv University" + "first_name": "Frank", + "last_name": "Piessens", + "institution": "KU Leuven" } ], - "dblp_key": "journals/pacmpl/GrossmanAGMRSZ18", + "dblp_key": "journals/pacmpl/DevriesePP18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158090", - "title": "WebRelate: integrating web data with spreadsheets using examples", - "abstract": "Data integration between web sources and relational data is a key challenge faced by data scientists and spreadsheet users. There are two main challenges in programmatically joining web data with relational data. First, most websites do not expose a direct interface to obtain tabular data, so the user needs to formulate a logic to get to different webpages for each input row in the relational table. Second, after reaching the desired webpage, the user needs to write complex scripts to extract the relevant data, which is often conditioned on the input data. Since many data scientists and end-users come from diverse backgrounds, writing such complex regular-expression based logical scripts to perform data integration tasks is unfortunately often beyond their programming expertise. We present WebRelate, a system that allows users to join semi-structured web data with relational data in spreadsheets using input-output examples. WebRelate decomposes the web data integration task into two sub-tasks of i) URL learning and ii) input-dependent web extraction. We introduce a novel synthesis paradigm called \"Output-constrained Programming By Examples\", which allows us to use the finite set of possible outputs for the new inputs to efficiently constrain the search in the synthesis algorithm. We instantiate this paradigm for the two sub-tasks in WebRelate. The first sub-task generates the URLs for the webpages containing the desired data for all rows in the relational table. WebRelate achieves this by learning a string transformation program using a few example URLs. The second sub-task uses examples of desired data to be extracted from the corresponding webpages and learns a program to extract the data for the other rows. We design expressive domain-specific languages for URL generation and web data extraction, and present efficient synthesis algorithms for learning programs in these DSLs from few input-output examples. We evaluate WebRelate on 88 real-world web data integration tasks taken from online help forums and Excel product team, and show that WebRelate can learn the desired programs within few seconds using only 1 example for the majority of the tasks.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158090", + "paper_id": "10.1145/3158096", + "title": "Handle with care: relational interpretation of algebraic effects and handlers", + "abstract": "Algebraic effects and handlers have received a lot of attention recently, both from the theoretical point of view and in practical language design. This stems from the fact that algebraic effects give the programmer unprecedented freedom to define, combine, and interpret computational effects. This plenty-of-rope, however, demands not only a deep understanding of the underlying semantics, but also access to practical means of reasoning about effectful code, including correctness and program equivalence. In this paper we tackle this problem by constructing a step-indexed relational interpretation of a call-by-value calculus with algebraic effect handlers and a row-based polymorphic type-and-effect system. Our calculus, while striving for simplicity, enjoys desirable theoretical properties, and is close to the cores of programming languages with algebraic effects used in the wild, while the logical relation we build for it can be used to reason about non-trivial properties, such as contextual equivalence and contextual approximation of programs. Our development has been fully formalised in the Coq proof assistant.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158096", "conference_name": "POPL", "authors": [ { - "first_name": "Jeevana Priya", - "last_name": "Inala", - "institution": "Moscow Institute of Thermal Technology" + "first_name": "Dariusz", + "last_name": "Biernacki", + "institution": "University of Wrocław" }, { - "first_name": "Rishabh", - "last_name": "Singh", - "institution": "Microsoft (United States)" + "first_name": "Maciej", + "last_name": "Piróg", + "institution": "University of Wrocław" + }, + { + "first_name": "Piotr", + "last_name": "Polesiuk", + "institution": "University of Wrocław" + }, + { + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "University of Wrocław" } ], - "dblp_key": "journals/pacmpl/InalaS18", + "dblp_key": "journals/pacmpl/BiernackiPPS18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158149", - "title": "Strategy synthesis for linear arithmetic games", - "abstract": "Many problems in formal methods can be formalized as two-player games. For several applications—program synthesis, for example—in addition to determining which player wins the game, we are interested in computing a winning strategy for that player. This paper studies the strategy synthesis problem for games defined within the theory of linear rational arithmetic. Two types of games are considered. A satisfiability game , described by a quantified formula, is played by two players that take turns instantiating quantifiers. The objective of each player is to prove (or disprove) satisfiability of the formula. A reachability game , described by a pair of formulas defining the legal moves of each player, is played by two players that take turns choosing positions—rational vectors of some fixed dimension. The objective of each player is to reach a position where the opposing player has no legal moves (or to play the game forever). We give a complete algorithm for synthesizing winning strategies for satisfiability games and a sound (but necessarily incomplete) algorithm for synthesizing winning strategies for reachability games.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158149", + "paper_id": "10.1145/3158112", + "title": "Safety and conservativity of definitions in HOL and Isabelle/HOL", + "abstract": "Definitions are traditionally considered to be a safe mechanism for introducing concepts on top of a logic known to be consistent. In contrast to arbitrary axioms, definitions should in principle be treatable as a form of abbreviation, and thus compiled away from the theory without losing provability. In particular, definitions should form a conservative extension of the pure logic. These properties are crucial for modern interactive theorem provers, since they ensure the consistency of the logic, as well as a valid environment for total/certified functional programming. We prove these properties, namely, safety and conservativity, for Higher-Order Logic (HOL), a logic implemented in several mainstream theorem provers and relied upon by thousands of users. Some unique features of HOL, such as the requirement to give non-emptiness proofs when defining new types and the impossibility to unfold type definitions, make the proof of these properties, and also the very formulation of safety, nontrivial. Our study also factors in the essential variation of HOL definitions featured by Isabelle/HOL, a popular member of the HOL-based provers family. The current work improves on recent results which showed a weaker property, consistency of Isabelle/HOL's definitions.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158112", "conference_name": "POPL", "authors": [ { - "first_name": "Azadeh", - "last_name": "Farzan", - "institution": "University of Toronto" + "first_name": "Ondřej", + "last_name": "Kunčar", + "institution": "" }, { - "first_name": "Zachary", - "last_name": "Kincaid", - "institution": "Princeton University" + "first_name": "Andrei", + "last_name": "Popescu", + "institution": "Romanian Academy" } ], - "dblp_key": "journals/pacmpl/FarzanK18", + "dblp_key": "journals/pacmpl/Kuncar018", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158137", - "title": "Correctness of speculative optimizations with dynamic deoptimization", - "abstract": "High-performance dynamic language implementations make heavy use of speculative optimizations to achieve speeds close to statically compiled languages. These optimizations are typically performed by a just-in-time compiler that generates code under a set of assumptions about the state of the program and its environment. In certain cases, a program may execute code compiled under assumptions that are no longer valid. The implementation must then deoptimize the program on-the-fly; this entails finding semantically equivalent code that does not rely on invalid assumptions, translating program state to that expected by the target code, and transferring control. This paper looks at the interaction between optimization and deoptimization, and shows that reasoning about speculation is surprisingly easy when assumptions are made explicit in the program representation. This insight is demonstrated on a compiler intermediate representation, named sourir, modeled after the high-level representation for a dynamic language. Traditional compiler optimizations such as constant folding, unreachable code elimination, and function inlining are shown to be correct in the presence of assumptions. Furthermore, the paper establishes the correctness of compiler transformations specific to deoptimization: namely unrestricted deoptimization, predicate hoisting, and assume composition.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158137", + "paper_id": "10.1145/3158089", + "title": "Synthesizing bijective lenses", + "abstract": "Bidirectional transformations between different data representations occur frequently in modern software systems. They appear as serializers and deserializers, as parsers and pretty printers, as database views and view updaters, and as a multitude of different kinds of ad hoc data converters. Manually building bidirectional transformations---by writing two separate functions that are intended to be inverses---is tedious and error prone. A better approach is to use a domain-specific language in which both directions can be written as a single expression. However, these domain-specific languages can be difficult to program in, requiring programmers to manage fiddly details while working in a complex type system. We present an alternative approach. Instead of coding transformations manually, we synthesize them from declarative format descriptions and examples. Specifically, we present Optician, a tool for type-directed synthesis of bijective string transformers. The inputs to Optician are a pair of ordinary regular expressions representing two data formats and a few concrete examples for disambiguation. The output is a well-typed program in Boomerang (a bidirectional language based on the theory of lenses). The main technical challenge involves navigating the vast program search space efficiently. In particular, and unlike most prior work on type-directed synthesis, our system operates in the context of a language with a rich equivalence relation on types (the theory of regular expressions). Consequently, program synthesis requires search in two dimensions: First, our synthesis algorithm must find a pair of \"syntactically compatible types,\" and second, using the structure of those types, it must find a type- and example-compliant term. Our key insight is that it is possible to reduce the size of this search space without losing any computational power by defining a new language of lenses designed specifically for synthesis. The new language is free from arbitrary function composition and operates only over types and terms in a new disjunctive normal form. We prove (1) our new language is just as powerful as a more natural, compositional, and declarative language and (2) our synthesis algorithm is sound and complete with respect to the new language. We also demonstrate empirically that our new language changes the synthesis problem from one that admits intractable solutions to one that admits highly efficient solutions, able to synthesize intricate lenses between complex file formats in seconds. We evaluate Optician on a benchmark suite of 39 examples that includes both microbenchmarks and realistic examples derived from other data management systems including Flash Fill, a tool for synthesizing string transformations in spreadsheets, and Augeas, a tool for bidirectional processing of Linux system configuration files.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158089", "conference_name": "POPL", "authors": [ { - "first_name": "Olivier", - "last_name": "Flückiger", - "institution": "Northeastern University" - }, - { - "first_name": "Gabriel", - "last_name": "Scherer", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Anders", + "last_name": "Miltner", + "institution": "Princeton University" }, { - "first_name": "Ming-Ho", - "last_name": "Yee", - "institution": "Northeastern University" + "first_name": "Kathleen", + "last_name": "Fisher", + "institution": "Tufts University" }, { - "first_name": "Aviral", - "last_name": "Goel", - "institution": "Northeastern University" + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" }, { - "first_name": "Amal", - "last_name": "Ahmed", - "institution": "Northeastern University" + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" }, { - "first_name": "Jan", - "last_name": "Vitek", - "institution": "Czech Technical University in Prague" + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" } ], - "dblp_key": "journals/pacmpl/FluckigerSYGAV18", + "dblp_key": "journals/pacmpl/MiltnerFPWZ18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158115", - "title": "Alone together: compositional reasoning and inference for weak isolation", - "abstract": "Serializability is a well-understood correctness criterion that simplifies reasoning about the behavior of concurrent transactions by ensuring they are isolated from each other while they execute. However, enforcing serializable isolation comes at a steep cost in performance because it necessarily restricts opportunities to exploit concurrency even when such opportunities would not violate application-specific invariants. As a result, database systems in practice support, and often encourage, developers to implement transactions using weaker alternatives. These alternatives break the strong isolation guarantees offered by serializable transactions to permit greater concurrency. Unfortunately, the semantics of weak isolation is poorly understood, and usually explained only informally in terms of low-level implementation artifacts. Consequently, verifying high-level correctness properties in such environments remains a challenging problem. To address this issue, we present a novel program logic that enables compositional reasoning about the behavior of concurrently executing weakly-isolated transactions. Recognizing that the proof burden necessary to use this logic may dissuade application developers, we also describe an inference procedure based on this foundation that ascertains the weakest isolation level that still guarantees the safety of high-level consistency assertions associated with such transactions. The key to effective inference is the observation that weakly-isolated transactions can be viewed as functional (monadic) computations over an abstract database state, allowing us to treat their operations as state transformers over the database. This interpretation enables automated verification using off-the-shelf SMT solvers. Our development is parametric over a transaction’s specific isolation semantics, allowing it to be applicable over a range of concurrency control mechanisms. Case studies and experiments on real-world applications (written in an embedded DSL in OCaml) demonstrate the utility of our approach, and provide strong evidence that automated verification of weakly-isolated transactions can be placed on the same formal footing as their strongly-isolated serializable counterparts.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158115", + "paper_id": "10.1145/3158127", + "title": "Linearity in higher-order recursion schemes", + "abstract": "Higher-order recursion schemes (HORS) have recently emerged as a promising foundation for higher-order program verification. We examine the impact of enriching HORS with linear types. To that end, we introduce two frameworks that blend non-linear and linear types: a variant of the λY -calculus and an extension of HORS, called linear HORS (LHORS). First we prove that the two formalisms are equivalent and there exist polynomial-time translations between them. Then, in order to support model-checking of (trees generated by) LHORS, we propose a refined version of alternating parity tree automata, called LNAPTA, whose behaviour depends on information about linearity. We show that the complexity of LNAPTA model-checking for LHORS depends on two type-theoretic parameters: linear order and linear depth. The former is in general smaller than the standard notion of order and ignores linear function spaces. In contrast, the latter measures the depth of linear clusters inside a type. Our main result states that LNAPTA model-checking of LHORS of linear order n is n-EXPTIME-complete, when linear depth is fixed. This generalizes and improves upon the classic result of Ong, which relies on the standard notion of order. To illustrate the significance of the result, we consider two applications: the MSO model-checking problem on variants of HORS with case distinction (RSFD and HORSC) on a finite domain and a call-by-value resource verification problem. In both cases, decidability can be established by translation into HORS, but the implied complexity bounds will be suboptimal due to increases in type order. In contrast, we show that the complexity bounds derived by translations into LHORS and appealing to our result are optimal in that they match the respective hardness results.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158127", "conference_name": "POPL", "authors": [ { - "first_name": "Gowtham", - "last_name": "Kaki", - "institution": "Purdue University West Lafayette" - }, - { - "first_name": "Kartik", - "last_name": "Nagar", - "institution": "Purdue University West Lafayette" + "first_name": "Pierre", + "last_name": "Clairambault", + "institution": "Université Claude Bernard Lyon 1" }, { - "first_name": "Mahsa", - "last_name": "Najafzadeh", - "institution": "Purdue University West Lafayette" + "first_name": "Charles", + "last_name": "Grellois", + "institution": "University of Bologna" }, { - "first_name": "Suresh", - "last_name": "Jagannathan", - "institution": "Purdue University West Lafayette" + "first_name": "Andrzej S.", + "last_name": "Murawski", + "institution": "University of Oxford" } ], - "dblp_key": "journals/pacmpl/KakiNNJ18", + "dblp_key": "journals/pacmpl/ClairambaultGM18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158142", - "title": "Non-linear reasoning for invariant synthesis", - "abstract": "Automatic generation of non-linear loop invariants is a long-standing challenge in program analysis, with many applications. For instance, reasoning about exponentials provides a way to find invariants of digital-filter programs, and reasoning about polynomials and/or logarithms is needed for establishing invariants that describe the time or memory usage of many well-known algorithms. An appealing approach to this challenge is to exploit the powerful recurrence-solving techniques that have been developed in the field of computer algebra, which can compute exact characterizations of non-linear repetitive behavior. However, there is a gap between the capabilities of recurrence solvers and the needs of program analysis: (1) loop bodies are not merely systems of recurrence relations---they may contain conditional branches, nested loops, non-deterministic assignments, etc., and (2) a client program analyzer must be able to reason about the closed-form solutions produced by a recurrence solver (e.g., to prove assertions). This paper presents a method for generating non-linear invariants of general loops based on analyzing recurrence relations. The key components are an abstract domain for reasoning about non-linear arithmetic, a semantics-based method for extracting recurrence relations from loop bodies, and a recurrence solver that avoids closed forms that involve complex or irrational numbers. Our technique has been implemented in a program analyzer that can analyze general loops and mutually recursive procedures. Our experiments show that our technique shows promise for non-linear assertion-checking and resource-bound generation.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158142", + "paper_id": "10.1145/3158106", + "title": "Transactions in relaxed memory architectures", + "abstract": "The integration of transactions into hardware relaxed memory architectures is a topic of current research both in industry and academia. In this paper, we provide a general architectural framework for the introduction of transactions into models of relaxed memory in hardware, including the SC, TSO, ARMv8 and PPC models. Our framework incorporates flexible and expressive forms of transaction aborts and execution that have hitherto been in the realm of software transactional memory. In contrast to software transactional memory, we account for the characteristics of relaxed memory as a restricted form of distributed system, without a notion of global time. We prove abstraction theorems to demonstrate that the programmer API matches the intuitions and expectations about transactions.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158106", "conference_name": "POPL", "authors": [ { - "first_name": "Zachary", - "last_name": "Kincaid", - "institution": "Princeton University" - }, - { - "first_name": "John", - "last_name": "Cyphert", - "institution": "University of Wisconsin–Madison" + "first_name": "Brijesh", + "last_name": "Dongol", + "institution": "Brunel University of London" }, { - "first_name": "Jason", - "last_name": "Breck", - "institution": "University of Wisconsin–Madison" + "first_name": "Radha", + "last_name": "Jagadeesan", + "institution": "DePaul University" }, { - "first_name": "Thomas", - "last_name": "Reps", - "institution": "University of Wisconsin–Madison" + "first_name": "James", + "last_name": "Riely", + "institution": "DePaul University" } ], - "dblp_key": "journals/pacmpl/KincaidCBR18", + "dblp_key": "journals/pacmpl/DongolJR18", "venue": "popl", "year": 2018 }, @@ -1053,7 +847,7 @@ "paper_id": "10.1145/3158105", "title": "Effective stateless model checking for C/C++ concurrency", "abstract": "We present a stateless model checking algorithm for verifying concurrent programs running under RC11, a repaired version of the C/C++11 memory model without dependency cycles. Unlike most previous approaches, which enumerate thread interleavings up to some partial order reduction improvements, our approach works directly on execution graphs and (in the absence of RMW instructions and SC atomics) avoids redundant exploration by construction. We have implemented a model checker, called RCMC, based on this approach and applied it to a number of challenging concurrent programs. Our experiments confirm that RCMC is significantly faster, scales better than other model checking tools, and is also more resilient to small changes in the benchmarks.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158105", "conference_name": "POPL", "authors": [ @@ -1083,40 +877,30 @@ "year": 2018 }, { - "paper_id": "10.1145/3158092", - "title": "String constraints with concatenation and transducers solved efficiently", - "abstract": "String analysis is the problem of reasoning about how strings are manipulated by a program. It has numerous applications including automatic detection of cross-site scripting, and automatic test-case generation. A popular string analysis technique includes symbolic executions, which at their core use constraint solvers over the string domain, a.k.a. string solvers. Such solvers typically reason about constraints expressed in theories over strings with the concatenation operator as an atomic constraint. In recent years, researchers started to recognise the importance of incorporating the replace-all operator (i.e. replace all occurrences of a string by another string) and, more generally, finite-state transductions in the theories of strings with concatenation. Such string operations are typically crucial for reasoning about XSS vulnerabilities in web applications, especially for modelling sanitisation functions and implicit browser transductions (e.g. innerHTML). Although this results in an undecidable theory in general, it was recently shown that the straight-line fragment of the theory is decidable, and is sufficiently expressive in practice. In this paper, we provide the first string solver that can reason about constraints involving both concatenation and finite-state transductions. Moreover, it has a completeness and termination guarantee for several important fragments (e.g. straight-line fragment). The main challenge addressed in the paper is the prohibitive worst-case complexity of the theory (double-exponential time), which is exponentially harder than the case without finite-state transductions. To this end, we propose a method that exploits succinct alternating finite-state automata as concise symbolic representations of string constraints. In contrast to previous approaches using nondeterministic automata, alternation offers not only exponential savings in space when representing Boolean combinations of transducers, but also a possibility of succinct representation of otherwise costly combinations of transducers and concatenation. Reasoning about the emptiness of the AFA language requires a state-space exploration in an exponential-sized graph, for which we use model checking algorithms (e.g. IC3). We have implemented our algorithm and demonstrated its efficacy on benchmarks that are derived from cross-site scripting analysis and other examples in the literature.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158092", + "paper_id": "10.1145/3158135", + "title": "On automatically proving the correctness of math.h implementations", + "abstract": "Industry standard implementations of math.h claim (often without formal proof) tight bounds on floating-point errors. We demonstrate a novel static analysis that proves these bounds and verifies the correctness of these implementations. Our key insight is a reduction of this verification task to a set of mathematical optimization problems that can be solved by off-the-shelf computer algebra systems. We use this analysis to prove the correctness of implementations in Intel's math library automatically. Prior to this work, these implementations could only be verified with significant manual effort.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158135", "conference_name": "POPL", "authors": [ { - "first_name": "Lukáš", - "last_name": "Holík", - "institution": "Brno University of Technology" - }, - { - "first_name": "Petr", - "last_name": "Janků", - "institution": "Brno University of Technology" - }, - { - "first_name": "Anthony W.", - "last_name": "Lin", - "institution": "University of Oxford" + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Stanford University" }, { - "first_name": "Philipp", - "last_name": "Rümmer", - "institution": "Uppsala University" + "first_name": "Rahul", + "last_name": "Sharma", + "institution": "Microsoft Research (India)" }, { - "first_name": "Tomáš", - "last_name": "Vojnar", - "institution": "Brno University of Technology" + "first_name": "Alex", + "last_name": "Aiken", + "institution": "Stanford University" } ], - "dblp_key": "journals/pacmpl/HolikJLRV18", + "dblp_key": "journals/pacmpl/Lee0A18", "venue": "popl", "year": 2018 }, @@ -1124,7 +908,7 @@ "paper_id": "10.1145/3158129", "title": "An axiomatic basis for bidirectional programming", "abstract": "Among the frameworks of bidirectional transformations proposed for addressing various synchronisation (consistency maintenance) problems, Foster et al.’s [2007] asymmetric lenses have influenced the design of a generation of bidirectional programming languages. Most of these languages are based on a declarative programming model, and only allow the programmer to describe a consistency specification with ad hoc and/or awkward control over the consistency restoration behaviour. However, synchronisation problems are diverse and require vastly different consistency restoration strategies, and to cope with the diversity, the programmer must have the ability to fully control and reason about the consistency restoration behaviour. The putback-based approach to bidirectional programming aims to provide exactly this ability, and this paper strengthens the putback-based position by proposing the first fully fledged reasoning framework for a bidirectional language — a Hoare-style logic for Ko et al.’s [2016] putback-based language BiGUL. The Hoare-style logic lets the BiGUL programmer precisely characterise the bidirectional behaviour of their programs by reasoning solely in the putback direction, thereby offering a unidirectional programming abstraction that is reasonably straightforward to work with and yet provides full control not achieved by previous approaches. The theory has been formalised and checked in Agda, but this paper presents the Hoare-style logic in a semi-formal way to make it easily understood and usable by the working BiGUL programmer.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158129", "conference_name": "POPL", "authors": [ @@ -1144,505 +928,490 @@ "year": 2018 }, { - "paper_id": "10.1145/3158112", - "title": "Safety and conservativity of definitions in HOL and Isabelle/HOL", - "abstract": "Definitions are traditionally considered to be a safe mechanism for introducing concepts on top of a logic known to be consistent. In contrast to arbitrary axioms, definitions should in principle be treatable as a form of abbreviation, and thus compiled away from the theory without losing provability. In particular, definitions should form a conservative extension of the pure logic. These properties are crucial for modern interactive theorem provers, since they ensure the consistency of the logic, as well as a valid environment for total/certified functional programming. We prove these properties, namely, safety and conservativity, for Higher-Order Logic (HOL), a logic implemented in several mainstream theorem provers and relied upon by thousands of users. Some unique features of HOL, such as the requirement to give non-emptiness proofs when defining new types and the impossibility to unfold type definitions, make the proof of these properties, and also the very formulation of safety, nontrivial. Our study also factors in the essential variation of HOL definitions featured by Isabelle/HOL, a popular member of the HOL-based provers family. The current work improves on recent results which showed a weaker property, consistency of Isabelle/HOL's definitions.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158112", + "paper_id": "10.1145/3158093", + "title": "Linear Haskell: practical linearity in a higher-order polymorphic language", + "abstract": "Linear type systems have a long and storied history, but not a clear path forward to integrate with existing languages such as OCaml or Haskell. In this paper, we study a linear type system designed with two crucial properties in mind: backwards-compatibility and code reuse across linear and non-linear users of a library. Only then can the benefits of linear types permeate conventional functional programming. Rather than bifurcate types into linear and non-linear counterparts, we instead attach linearity to function arrows . Linear functions can receive inputs from linearly-bound values, but can also operate over unrestricted, regular values. To demonstrate the efficacy of our linear type system — both how easy it can be integrated in an existing language implementation and how streamlined it makes it to write programs with linear types — we implemented our type system in ghc, the leading Haskell compiler, and demonstrate two kinds of applications of linear types: mutable data with pure interfaces; and enforcing protocols in I/O-performing functions.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158093", "conference_name": "POPL", "authors": [ { - "first_name": "Ondřej", - "last_name": "Kunčar", + "first_name": "Jean-Philippe", + "last_name": "Bernardy", + "institution": "University of Gothenburg" + }, + { + "first_name": "Mathieu", + "last_name": "Boespflug", "institution": "" }, { - "first_name": "Andrei", - "last_name": "Popescu", - "institution": "Romanian Academy" + "first_name": "Ryan R.", + "last_name": "Newton", + "institution": "Indiana University" + }, + { + "first_name": "Simon Peyton", + "last_name": "Jones", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "Arnaud", + "last_name": "Spiwack", + "institution": "" } ], - "dblp_key": "journals/pacmpl/Kuncar018", + "dblp_key": "journals/pacmpl/BernardyBNJS18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158133", - "title": "Generating good generators for inductive relations", - "abstract": "Property-based random testing (PBRT) is widely used in the functional programming and verification communities. For testing simple properties, PBRT tools such as QuickCheck can automatically generate random inputs of a given type. But for more complex properties, effective testing often demands generators for random inputs that belong to a given type and satisfy some logical condition. QuickCheck provides a library of combinators for building such generators by hand, but this can be tedious for simple conditions and error prone for more complex ones. Fortunately, the process can often be automated. The most prominent method, narrowing, works by traversing the structure of the condition, lazily instantiating parts of the data structure as constraints involving them are met. We show how to use ideas from narrowing to compile a large subclass of Coq's inductive relations into efficient generators, avoiding the interpretive overhead of previous implementations. More importantly, the same compilation technique allows us to produce proof terms certifying that each derived generator is good---i.e., sound and complete with respect to the inductive relation it was derived from. We implement our algorithm as an extension of QuickChick, an existing tool for property-based testing in Coq. We evaluate our method by automatically deriving good generators for the majority of the specifications in Software Foundations, a formalized textbook on programming language foundations.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158133", + "paper_id": "10.1145/3158118", + "title": "Optimal Dyck reachability for data-dependence and alias analysis", + "abstract": "A fundamental algorithmic problem at the heart of static analysis is Dyck reachability. The input is a graph where the edges are labeled with different types of opening and closing parentheses, and the reachability information is computed via paths whose parentheses are properly matched. We present new results for Dyck reachability problems with applications to alias analysis and data-dependence analysis. Our main contributions, that include improved upper bounds as well as lower bounds that establish optimality guarantees, are as follows: First, we consider Dyck reachability on bidirected graphs, which is the standard way of performing field-sensitive points-to analysis. Given a bidirected graph with n nodes and m edges, we present: (i) an algorithm with worst-case running time O ( m + n · α( n )), where α( n ) is the inverse Ackermann function, improving the previously known O ( n 2 ) time bound; (ii) a matching lower bound that shows that our algorithm is optimal wrt to worst-case complexity; and (iii) an optimal average-case upper bound of O ( m ) time, improving the previously known O ( m · log n ) bound. Second, we consider the problem of context-sensitive data-dependence analysis, where the task is to obtain analysis summaries of library code in the presence of callbacks. Our algorithm preprocesses libraries in almost linear time, after which the contribution of the library in the complexity of the client analysis is only linear, and only wrt the number of call sites. Third, we prove that combinatorial algorithms for Dyck reachability on general graphs with truly sub-cubic bounds cannot be obtained without obtaining sub-cubic combinatorial algorithms for Boolean Matrix Multiplication, which is a long-standing open problem. Thus we establish that the existing combinatorial algorithms for Dyck reachability are (conditionally) optimal for general graphs. We also show that the same hardness holds for graphs of constant treewidth. Finally, we provide a prototype implementation of our algorithms for both alias analysis and data-dependence analysis. Our experimental evaluation demonstrates that the new algorithms significantly outperform all existing methods on the two problems, over real-world benchmarks.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158118", "conference_name": "POPL", "authors": [ { - "first_name": "Leonidas", - "last_name": "Lampropoulos", - "institution": "California University of Pennsylvania" + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Zoe", - "last_name": "Paraskevopoulou", - "institution": "Princeton University" + "first_name": "Bhavya", + "last_name": "Choudhary", + "institution": "Indian Institute of Technology Bombay" }, { - "first_name": "Benjamin C.", - "last_name": "Pierce", - "institution": "California University of Pennsylvania" + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Institute of Science and Technology Austria" } ], - "dblp_key": "journals/pacmpl/LampropoulosPP18", + "dblp_key": "journals/pacmpl/ChatterjeeCP18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158125", - "title": "Go with the flow: compositional abstractions for concurrent data structures", - "abstract": "Concurrent separation logics have helped to significantly simplify correctness proofs for concurrent data structures. However, a recurring problem in such proofs is that data structure abstractions that work well in the sequential setting are much harder to reason about in a concurrent setting due to complex sharing and overlays. To solve this problem, we propose a novel approach to abstracting regions in the heap by encoding the data structure invariant into a local condition on each individual node. This condition may depend on a quantity associated with the node that is computed as a fixpoint over the entire heap graph. We refer to this quantity as a flow . Flows can encode both structural properties of the heap (e.g. the reachable nodes from the root form a tree) as well as data invariants (e.g. sortedness). We then introduce the notion of a flow interface , which expresses the relies and guarantees that a heap region imposes on its context to maintain the local flow invariant with respect to the global heap. Our main technical result is that this notion leads to a new semantic model of separation logic. In this model, flow interfaces provide a general abstraction mechanism for describing complex data structures. This abstraction mechanism admits proof rules that generalize over a wide variety of data structures. To demonstrate the versatility of our approach, we show how to extend the logic RGSep with flow interfaces. We have used this new logic to prove linearizability and memory safety of nontrivial concurrent data structures. In particular, we obtain parametric linearizability proofs for concurrent dictionary algorithms that abstract from the details of the underlying data structure representation. These proofs cannot be easily expressed using the abstraction mechanisms provided by existing separation logics.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158125", + "paper_id": "10.1145/3158132", + "title": "Univalent higher categories via complete Semi-Segal types", + "abstract": "Category theory in homotopy type theory is intricate as categorical laws can only be stated \"up to homotopy\", and thus require coherences. The established notion of a univalent category (as introduced by Ahrens et al.) solves this by considering only truncated types, roughly corresponding to an ordinary category. This fails to capture many naturally occurring structures, stemming from the fact that the naturally occurring structures in homotopy type theory are not ordinary, but rather higher categories. Out of the large variety of approaches to higher category theory that mathematicians have proposed, we believe that, for type theory, the simplicial strategy is best suited. Work by Lurie and Harpaz motivates the following definition. Given the first ( n +3) levels of a semisimplicial type S , we can equip S with three properties: first, contractibility of the types of certain horn fillers; second, a completeness property; and third, a truncation condition. We call this a complete semi-Segal n -type . This is very similar to an earlier suggestion by Schreiber. The definition of a univalent (1-) category by Ahrens et al. can easily be extended or restricted to the definition of a univalent n -category (more precisely, ( n ,1)-category) for n ∈ {0,1,2}, and we show that the type of complete semi-Segal n -types is equivalent to the type of univalent n -categories in these cases. Thus, we believe that the notion of a complete semi-Segal n -type can be taken as the definition of a univalent n -category. We provide a formalisation in the proof assistant Agda using a completely explicit representation of semi-simplicial types for levels up to 4.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158132", "conference_name": "POPL", "authors": [ { - "first_name": "Siddharth", - "last_name": "Krishna", - "institution": "New York University" - }, - { - "first_name": "Dennis", - "last_name": "Shasha", - "institution": "New York University" + "first_name": "Paolo", + "last_name": "Capriotti", + "institution": "University of Nottingham" }, { - "first_name": "Thomas", - "last_name": "Wies", - "institution": "New York University" + "first_name": "Nicolai", + "last_name": "Kraus", + "institution": "University of Nottingham" } ], - "dblp_key": "journals/pacmpl/KrishnaSW18", + "dblp_key": "journals/pacmpl/CapriottiK18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158135", - "title": "On automatically proving the correctness of math.h implementations", - "abstract": "Industry standard implementations of math.h claim (often without formal proof) tight bounds on floating-point errors. We demonstrate a novel static analysis that proves these bounds and verifies the correctness of these implementations. Our key insight is a reduction of this verification task to a set of mathematical optimization problems that can be solved by off-the-shelf computer algebra systems. We use this analysis to prove the correctness of implementations in Intel's math library automatically. Prior to this work, these implementations could only be verified with significant manual effort.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158135", + "paper_id": "10.1145/3158137", + "title": "Correctness of speculative optimizations with dynamic deoptimization", + "abstract": "High-performance dynamic language implementations make heavy use of speculative optimizations to achieve speeds close to statically compiled languages. These optimizations are typically performed by a just-in-time compiler that generates code under a set of assumptions about the state of the program and its environment. In certain cases, a program may execute code compiled under assumptions that are no longer valid. The implementation must then deoptimize the program on-the-fly; this entails finding semantically equivalent code that does not rely on invalid assumptions, translating program state to that expected by the target code, and transferring control. This paper looks at the interaction between optimization and deoptimization, and shows that reasoning about speculation is surprisingly easy when assumptions are made explicit in the program representation. This insight is demonstrated on a compiler intermediate representation, named sourir, modeled after the high-level representation for a dynamic language. Traditional compiler optimizations such as constant folding, unreachable code elimination, and function inlining are shown to be correct in the presence of assumptions. Furthermore, the paper establishes the correctness of compiler transformations specific to deoptimization: namely unrestricted deoptimization, predicate hoisting, and assume composition.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158137", "conference_name": "POPL", "authors": [ { - "first_name": "Wonyeol", - "last_name": "Lee", - "institution": "Stanford University" + "first_name": "Olivier", + "last_name": "Flückiger", + "institution": "Northeastern University" }, { - "first_name": "Rahul", - "last_name": "Sharma", - "institution": "Microsoft Research (India)" + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Institut national de recherche en informatique et en automatique" }, { - "first_name": "Alex", - "last_name": "Aiken", - "institution": "Stanford University" + "first_name": "Ming-Ho", + "last_name": "Yee", + "institution": "Northeastern University" + }, + { + "first_name": "Aviral", + "last_name": "Goel", + "institution": "Northeastern University" + }, + { + "first_name": "Amal", + "last_name": "Ahmed", + "institution": "Northeastern University" + }, + { + "first_name": "Jan", + "last_name": "Vitek", + "institution": "Czech Technical University in Prague" } ], - "dblp_key": "journals/pacmpl/Lee0A18", + "dblp_key": "journals/pacmpl/FluckigerSYGAV18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158123", - "title": "Algorithmic analysis of termination problems for quantum programs", - "abstract": "We introduce the notion of linear ranking super-martingale (LRSM) for quantum programs (with nondeterministic choices, namely angelic and demonic choices). Several termination theorems are established showing that the existence of the LRSMs of a quantum program implies its termination. Thus, the termination problems of quantum programs is reduced to realisability and synthesis of LRSMs. We further show that the realisability and synthesis problem of LRSMs for quantum programs can be reduced to an SDP (Semi-Definite Programming) problem, which can be settled with the existing SDP solvers. The techniques developed in this paper are used to analyse the termination of several example quantum programs, including quantum random walks and quantum Bernoulli factory for random number generation. This work is essentially a generalisation of constraint-based approach to the corresponding problems for probabilistic programs developed in the recent literature by adding two novel ideas: (1) employing the fundamental Gleason's theorem in quantum mechanics to guide the choices of templates; and (2) a generalised Farkas' lemma in terms of observables (Hermitian operators) in quantum physics.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158123", + "paper_id": "10.1145/3158147", + "title": "Measurable cones and stable, measurable functions: a model for probabilistic higher-order programming", + "abstract": "We define a notion of stable and measurable map between cones endowed with measurability tests and show that it forms a cpo-enriched cartesian closed category. This category gives a denotational model of an extension of PCF supporting the main primitives of probabilistic functional programming, like continuous and discrete probabilistic distributions, sampling, conditioning and full recursion. We prove the soundness and adequacy of this model with respect to a call-by-name operational semantics and give some examples of its denotations.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158147", "conference_name": "POPL", "authors": [ { - "first_name": "Yangjia", - "last_name": "Li", - "institution": "Institute of Software" + "first_name": "Thomas", + "last_name": "Ehrhard", + "institution": "Université Paris Cité" }, { - "first_name": "Mingsheng", - "last_name": "Ying", - "institution": "Chinese Academy of Sciences" + "first_name": "Michele", + "last_name": "Pagani", + "institution": "Université Paris Cité" + }, + { + "first_name": "Christine", + "last_name": "Tasson", + "institution": "Délégation Paris 7" } ], - "dblp_key": "journals/pacmpl/LiY18", + "dblp_key": "journals/pacmpl/EhrhardPT18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158098", - "title": "Foundations for natural proofs and quantifier instantiation", - "abstract": "We give foundational results that explain the efficacy of heuristics used for dealing with quantified formulas and recursive definitions. We develop a framework for first order logic (FOL) over an uninterpreted combination of background theories. Our central technical result is that systematic term instantiation is complete for a fragment of FOL that we call safe . Coupled with the fact that unfolding recursive definitions is essentially term instantiation and with the observation that heap verification engines generate verification conditions in the safe fragment explains the efficacy of verification engines like natural proofs that resort to such heuristics. Furthermore, we study recursive definitions with least fixpoint semantics and show that though they are not amenable to complete procedures, we can systematically introduce induction principles that in practice bridge the divide between FOL and FOL with recursive definitions.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158098", + "paper_id": "10.1145/3158133", + "title": "Generating good generators for inductive relations", + "abstract": "Property-based random testing (PBRT) is widely used in the functional programming and verification communities. For testing simple properties, PBRT tools such as QuickCheck can automatically generate random inputs of a given type. But for more complex properties, effective testing often demands generators for random inputs that belong to a given type and satisfy some logical condition. QuickCheck provides a library of combinators for building such generators by hand, but this can be tedious for simple conditions and error prone for more complex ones. Fortunately, the process can often be automated. The most prominent method, narrowing, works by traversing the structure of the condition, lazily instantiating parts of the data structure as constraints involving them are met. We show how to use ideas from narrowing to compile a large subclass of Coq's inductive relations into efficient generators, avoiding the interpretive overhead of previous implementations. More importantly, the same compilation technique allows us to produce proof terms certifying that each derived generator is good---i.e., sound and complete with respect to the inductive relation it was derived from. We implement our algorithm as an extension of QuickChick, an existing tool for property-based testing in Coq. We evaluate our method by automatically deriving good generators for the majority of the specifications in Software Foundations, a formalized textbook on programming language foundations.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158133", "conference_name": "POPL", "authors": [ { - "first_name": "Christof", - "last_name": "Löding", - "institution": "RWTH Aachen University" + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "California University of Pennsylvania" }, { - "first_name": "P.", - "last_name": "Madhusudan", - "institution": "University of Illinois Urbana-Champaign" + "first_name": "Zoe", + "last_name": "Paraskevopoulou", + "institution": "Princeton University" }, { - "first_name": "Lucas", - "last_name": "Peña", - "institution": "University of Illinois Urbana-Champaign" + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" } ], - "dblp_key": "journals/pacmpl/LodingMP18", + "dblp_key": "journals/pacmpl/LampropoulosPP18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158134", - "title": "Why is random testing effective for partition tolerance bugs?", - "abstract": "Random testing has proven to be an effective way to catch bugs in distributed systems in the presence of network partition faults. This is surprising, as the space of potentially faulty executions is enormous, and the bugs depend on a subtle interplay between sequences of operations and faults. We provide a theoretical justification of the effectiveness of random testing in this context. First, we show a general construction, using the probabilistic method from combinatorics, that shows that whenever a random test covers a fixed coverage goal with sufficiently high probability, a small randomly-chosen set of tests achieves full coverage with high probability. In particular, we show that our construction can give test sets exponentially smaller than systematic enumeration. Second, based on an empirical study of many bugs found by random testing in production distributed systems, we introduce notions of test coverage relating to network partition faults which are effective in finding bugs. Finally, we show using combinatorial arguments that for these notions of test coverage we introduce, we can find a lower bound on the probability that a random test covers a given goal. Our general construction then explains why random testing tools achieve good coverage---and hence, find bugs---quickly. While we formulate our results in terms of network partition faults, our construction provides a step towards rigorous analysis of random testing algorithms, and can be applicable in other scenarios.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158134", + "paper_id": "10.1145/3158144", + "title": "Verifying equivalence of database-driven applications", + "abstract": "This paper addresses the problem of verifying equivalence between a pair of programs that operate over databases with different schemas. This problem is particularly important in the context of web applications, which typically undergo database refactoring either for performance or maintainability reasons. While web applications should have the same externally observable behavior before and after schema migration, there are no existing tools for proving equivalence of such programs. This paper takes a first step towards solving this problem by formalizing the equivalence and refinement checking problems for database-driven applications. We also propose a proof methodology based on the notion of bisimulation invariants over relational algebra with updates and describe a technique for synthesizing such bisimulation invariants. We have implemented the proposed technique in a tool called Mediator for verifying equivalence between database-driven applications written in our intermediate language and evaluate our tool on 21 benchmarks extracted from textbooks and real-world web applications. Our results show that the proposed methodology can successfully verify 20 of these benchmarks.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158144", "conference_name": "POPL", "authors": [ { - "first_name": "Rupak", - "last_name": "Majumdar", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" }, { - "first_name": "Filip", - "last_name": "Niksic", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" + }, + { + "first_name": "Shuvendu K.", + "last_name": "Lahiri", + "institution": "Microsoft Research (United Kingdom)" + }, + { + "first_name": "William R.", + "last_name": "Cook", + "institution": "The University of Texas at Austin" } ], - "dblp_key": "journals/pacmpl/MajumdarN18", + "dblp_key": "journals/pacmpl/0001DLC18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158094", - "title": "Polyadic approximations, fibrations and intersection types", - "abstract": "Starting from an exact correspondence between linear approximations and non-idempotent intersection types, we develop a general framework for building systems of intersection types characterizing normalization properties. We show how this construction, which uses in a fundamental way Melliès and Zeilberger's ``type systems as functors'' viewpoint, allows us to recover equivalent versions of every well known intersection type system (including Coppo and Dezani's original system, as well as its non-idempotent variants independently introduced by Gardner and de Carvalho). We also show how new systems of intersection types may be built almost automatically in this way.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158094", + "paper_id": "10.1145/3158113", + "title": "Sound, complete, and tractable linearizability monitoring for concurrent collections", + "abstract": "While many program properties like the validity of assertions and in-bounds array accesses admit nearly-trivial monitoring algorithms, the standard correctness criterion for concurrent data structures does not. Given an implementation of an arbitrary abstract data type, checking whether the operations invoked in one single concurrent execution are linearizable, i.e., indistinguishable from an execution where the same operations are invoked atomically, requires exponential time in the number of operations. In this work we identify a class of collection abstract data types which admit polynomial-time linearizability monitors. Collections capture the majority of concurrent data structures available in practice, including stacks, queues, sets, and maps. Although monitoring executions of arbitrary abstract data types requires enumerating exponentially-many possible linearizations, collections enjoy combinatorial properties which avoid the enumeration. We leverage these properties to reduce linearizability to Horn satisfiability. As far as we know, ours is the first sound, complete, and tractable algorithm for monitoring linearizability for types beyond single-value registers.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158113", "conference_name": "POPL", "authors": [ { - "first_name": "Damiano", - "last_name": "Mazza", - "institution": "Université Sorbonne Paris Nord" - }, - { - "first_name": "Luc", - "last_name": "Pellissier", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Michael", + "last_name": "Emmi", + "institution": "SRI International" }, { - "first_name": "Pierre", - "last_name": "Vial", + "first_name": "Constantin", + "last_name": "Enea", "institution": "Université Paris Cité" } ], - "dblp_key": "journals/pacmpl/MazzaPV18", + "dblp_key": "journals/pacmpl/EmmiE18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158121", - "title": "A new proof rule for almost-sure termination", - "abstract": "We present a new proof rule for proving almost-sure termination of probabilistic programs, including those that contain demonic non-determinism. An important question for a probabilistic program is whether the probability mass of all its diverging runs is zero, that is that it terminates \"almost surely\". Proving that can be hard, and this paper presents a new method for doing so. It applies directly to the program's source code, even if the program contains demonic choice. Like others, we use variant functions (a.k.a. \"super-martingales\") that are real-valued and decrease randomly on each loop iteration; but our key innovation is that the amount as well as the probability of the decrease are parametric. We prove the soundness of the new rule, indicate where its applicability goes beyond existing rules, and explain its connection to classical results on denumerable (non-demonic) Markov chains.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158121", + "paper_id": "10.1145/3158111", + "title": "Decidability of conversion for type theory in type theory", + "abstract": "Type theory should be able to handle its own meta-theory, both to justify its foundational claims and to obtain a verified implementation. At the core of a type checker for intensional type theory lies an algorithm to check equality of types, or in other words, to check whether two types are convertible. We have formalized in Agda a practical conversion checking algorithm for a dependent type theory with one universe à la Russell, natural numbers, and η-equality for Π types. We prove the algorithm correct via a Kripke logical relation parameterized by a suitable notion of equivalence of terms. We then instantiate the parameterized fundamental lemma twice: once to obtain canonicity and injectivity of type formers, and once again to prove the completeness of the algorithm. Our proof relies on inductive-recursive definitions, but not on the uniqueness of identity proofs. Thus, it is valid in variants of intensional Martin-Löf Type Theory as long as they support induction-recursion, for instance, Extensional, Observational, or Homotopy Type Theory.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158111", "conference_name": "POPL", "authors": [ { - "first_name": "Annabelle", - "last_name": "McIver", - "institution": "Macquarie University" - }, - { - "first_name": "Carroll", - "last_name": "Morgan", - "institution": "Commonwealth Scientific and Industrial Research Organisation" + "first_name": "Andreas", + "last_name": "Abel", + "institution": "University of Gothenburg" }, { - "first_name": "Benjamin Lucien", - "last_name": "Kaminski", - "institution": "University College London" + "first_name": "Joakim", + "last_name": "Öhman", + "institution": "IMDEA Software" }, { - "first_name": "Joost-Pieter", - "last_name": "Katoen", - "institution": "RWTH Aachen University" + "first_name": "Andrea", + "last_name": "Vezzosi", + "institution": "Chalmers University of Technology" } ], - "dblp_key": "journals/pacmpl/McIverMKK18", + "dblp_key": "journals/pacmpl/0001OV18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158089", - "title": "Synthesizing bijective lenses", - "abstract": "Bidirectional transformations between different data representations occur frequently in modern software systems. They appear as serializers and deserializers, as parsers and pretty printers, as database views and view updaters, and as a multitude of different kinds of ad hoc data converters. Manually building bidirectional transformations---by writing two separate functions that are intended to be inverses---is tedious and error prone. A better approach is to use a domain-specific language in which both directions can be written as a single expression. However, these domain-specific languages can be difficult to program in, requiring programmers to manage fiddly details while working in a complex type system. We present an alternative approach. Instead of coding transformations manually, we synthesize them from declarative format descriptions and examples. Specifically, we present Optician, a tool for type-directed synthesis of bijective string transformers. The inputs to Optician are a pair of ordinary regular expressions representing two data formats and a few concrete examples for disambiguation. The output is a well-typed program in Boomerang (a bidirectional language based on the theory of lenses). The main technical challenge involves navigating the vast program search space efficiently. In particular, and unlike most prior work on type-directed synthesis, our system operates in the context of a language with a rich equivalence relation on types (the theory of regular expressions). Consequently, program synthesis requires search in two dimensions: First, our synthesis algorithm must find a pair of \"syntactically compatible types,\" and second, using the structure of those types, it must find a type- and example-compliant term. Our key insight is that it is possible to reduce the size of this search space without losing any computational power by defining a new language of lenses designed specifically for synthesis. The new language is free from arbitrary function composition and operates only over types and terms in a new disjunctive normal form. We prove (1) our new language is just as powerful as a more natural, compositional, and declarative language and (2) our synthesis algorithm is sound and complete with respect to the new language. We also demonstrate empirically that our new language changes the synthesis problem from one that admits intractable solutions to one that admits highly efficient solutions, able to synthesize intricate lenses between complex file formats in seconds. We evaluate Optician on a benchmark suite of 39 examples that includes both microbenchmarks and realistic examples derived from other data management systems including Flash Fill, a tool for synthesizing string transformations in spreadsheets, and Augeas, a tool for bidirectional processing of Linux system configuration files.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158089", + "paper_id": "10.1145/3158149", + "title": "Strategy synthesis for linear arithmetic games", + "abstract": "Many problems in formal methods can be formalized as two-player games. For several applications—program synthesis, for example—in addition to determining which player wins the game, we are interested in computing a winning strategy for that player. This paper studies the strategy synthesis problem for games defined within the theory of linear rational arithmetic. Two types of games are considered. A satisfiability game , described by a quantified formula, is played by two players that take turns instantiating quantifiers. The objective of each player is to prove (or disprove) satisfiability of the formula. A reachability game , described by a pair of formulas defining the legal moves of each player, is played by two players that take turns choosing positions—rational vectors of some fixed dimension. The objective of each player is to reach a position where the opposing player has no legal moves (or to play the game forever). We give a complete algorithm for synthesizing winning strategies for satisfiability games and a sound (but necessarily incomplete) algorithm for synthesizing winning strategies for reachability games.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158149", "conference_name": "POPL", "authors": [ { - "first_name": "Anders", - "last_name": "Miltner", - "institution": "Princeton University" - }, - { - "first_name": "Kathleen", - "last_name": "Fisher", - "institution": "Tufts University" - }, - { - "first_name": "Benjamin C.", - "last_name": "Pierce", - "institution": "California University of Pennsylvania" + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" }, { - "first_name": "David", - "last_name": "Walker", + "first_name": "Zachary", + "last_name": "Kincaid", "institution": "Princeton University" - }, - { - "first_name": "Steve", - "last_name": "Zdancewic", - "institution": "California University of Pennsylvania" } ], - "dblp_key": "journals/pacmpl/MiltnerFPWZ18", + "dblp_key": "journals/pacmpl/FarzanK18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158139", - "title": "Soft contract verification for higher-order stateful programs", - "abstract": "Software contracts allow programmers to state rich program properties using the full expressive power of an object language. However, since they are enforced at runtime, monitoring contracts imposes significant overhead and delays error discovery. So contract veri cation aims to guarantee all or most of these properties ahead of time, enabling valuable optimizations and yielding a more general assurance of correctness. Existing methods for static contract verification satisfy the needs of more restricted target languages, but fail to address the challenges unique to those conjoining untyped, dynamic programming, higher-order functions, modularity, and statefulness. Our approach tackles all these features at once, in the context of the full Racket system—a mature environment for stateful, higher-order, multi-paradigm programming with or with- out types. Evaluating our method using a set of both pure and stateful benchmarks, we are able to verify 99.94% of checks statically (all but 28 of 49, 861). Stateful, higher-order functions pose significant challenges for static contract verification in particular. In the presence of these features, a modular analysis must permit code from the current module to escape permanently to an opaque context (unspecified code from outside the current module) that may be stateful and therefore store a reference to the escaped closure. Also, contracts themselves, being predicates wri en in unrestricted Racket, may exhibit stateful behavior; a sound approach must be robust to contracts which are arbitrarily expressive and interwoven with the code they monitor. In this paper, we present and evaluate our solution based on higher-order symbolic execution, explain the techniques we used to address such thorny issues, formalize a notion of behavioral approximation, and use it to provide a mechanized proof of soundness.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158139", + "paper_id": "10.1145/3158103", + "title": "Migrating gradual types", + "abstract": "Gradual typing allows programs to enjoy the benefits of both static typing and dynamic typing. While it is often desirable to migrate a program from more dynamically-typed to more statically-typed or vice versa, gradual typing itself does not provide a way to facilitate this migration. This places the burden on programmers who have to manually add or remove type annotations. Besides the general challenge of adding type annotations to dynamically typed code, there are subtle interactions between these annotations in gradually typed code that exacerbate the situation. For example, to migrate a program to be as static as possible, in general, all possible combinations of adding or removing type annotations from parameters must be tried out and compared. In this paper, we address this problem by developing migrational typing, which efficiently types all possible ways of adding or removing type annotations from a gradually typed program. The typing result supports automatically migrating a program to be as static as possible, or introducing the least number of dynamic types necessary to remove a type error. The approach can be extended to support user-defined criteria about which annotations to modify. We have implemented migrational typing and evaluated it on large programs. The results show that migrational typing scales linearly with the size of the program and takes only 2–4 times longer than plain gradual typing.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158103", "conference_name": "POPL", "authors": [ { - "first_name": "Phúc C.", - "last_name": "Nguyễn", - "institution": "University of Maryland, College Park" + "first_name": "John Peter", + "last_name": "Campora", + "institution": "University of Louisiana at Lafayette" }, { - "first_name": "Thomas", - "last_name": "Gilray", - "institution": "University of Maryland, College Park" + "first_name": "Sheng", + "last_name": "Chen", + "institution": "University of Louisiana at Lafayette" }, { - "first_name": "Sam", - "last_name": "Tobin-Hochstadt", - "institution": "Indiana University" + "first_name": "Martin", + "last_name": "Erwig", + "institution": "Oregon State University" }, { - "first_name": "David Van", - "last_name": "Horn", - "institution": "University of Maryland, College Park" + "first_name": "Eric", + "last_name": "Walkingshaw", + "institution": "Oregon State University" } ], - "dblp_key": "journals/pacmpl/NguyenGTH18", + "dblp_key": "journals/pacmpl/Campora0EW18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158117", - "title": "Inference of static semantics for incomplete C programs", - "abstract": "Incomplete source code naturally emerges in software development: during the design phase, while evolving, testing and analyzing programs. Therefore, the ability to understand partial programs is a valuable asset. However, this problem is still unsolved in the C programming language. Difficulties stem from the fact that parsing C requires, not only syntax, but also semantic information. Furthermore, inferring types so that they respect C's type system is a challenging task. In this paper we present a technique that lets us solve these problems. We provide a unification-based type inference capable of dealing with C intricacies. The ideas we present let us reconstruct partial C programs into complete well-typed ones. Such program reconstruction has several applications: enabling static analysis tools in scenarios where software components may be absent; improving static analysis tools that do not rely on build-specifications; allowing stub-generation and testing tools to work on snippets; and assisting programmers on the extraction of reusable data-structures out of the program parts that use them. Our evaluation is performed on source code from a variety of C libraries such as GNU's Coreutils, GNULib, GNOME's GLib, and GDSL; on implementations from Sedgewick's books; and on snippets from popular open-source projects like CPython, FreeBSD, and Git.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158117", + "paper_id": "10.1145/3158098", + "title": "Foundations for natural proofs and quantifier instantiation", + "abstract": "We give foundational results that explain the efficacy of heuristics used for dealing with quantified formulas and recursive definitions. We develop a framework for first order logic (FOL) over an uninterpreted combination of background theories. Our central technical result is that systematic term instantiation is complete for a fragment of FOL that we call safe . Coupled with the fact that unfolding recursive definitions is essentially term instantiation and with the observation that heap verification engines generate verification conditions in the safe fragment explains the efficacy of verification engines like natural proofs that resort to such heuristics. Furthermore, we study recursive definitions with least fixpoint semantics and show that though they are not amenable to complete procedures, we can systematically introduce induction principles that in practice bridge the divide between FOL and FOL with recursive definitions.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158098", "conference_name": "POPL", "authors": [ { - "first_name": "Leandro T. C.", - "last_name": "Melo", - "institution": "Universidade Federal de Minas Gerais" - }, - { - "first_name": "Rodrigo", - "last_name": "Ribeiro", - "institution": "Universidade Federal de Ouro Preto" + "first_name": "Christof", + "last_name": "Löding", + "institution": "RWTH Aachen University" }, { - "first_name": "Marcus Rodrigues de", - "last_name": "Araújo", - "institution": "Universidade Federal de Minas Gerais" + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" }, { - "first_name": "Fernando Magno Quintão", - "last_name": "Pereira", - "institution": "Universidade Federal de Minas Gerais" + "first_name": "Lucas", + "last_name": "Peña", + "institution": "University of Illinois Urbana-Champaign" } ], - "dblp_key": "journals/pacmpl/MeloRAP18", + "dblp_key": "journals/pacmpl/LodingMP18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158130", - "title": "Simplicitly: foundations and applications of implicit function types", - "abstract": "Understanding a program entails understanding its context; dependencies, configurations and even implementations are all forms of contexts. Modern programming languages and theorem provers offer an array of constructs to define contexts, implicitly. Scala offers implicit parameters which are used pervasively, but which cannot be abstracted over. This paper describes a generalization of implicit parameters to implicit function types , a powerful way to abstract over the context in which some piece of code is run. We provide a formalization based on bidirectional type-checking that closely follows the semantics implemented by the Scala compiler. To demonstrate their range of abstraction capabilities, we present several applications that make use of implicit function types. We show how to encode the builder pattern, tagless interpreters, reader and free monads and we assess the performance of the monadic structures presented.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158130", + "paper_id": "10.1145/3158142", + "title": "Non-linear reasoning for invariant synthesis", + "abstract": "Automatic generation of non-linear loop invariants is a long-standing challenge in program analysis, with many applications. For instance, reasoning about exponentials provides a way to find invariants of digital-filter programs, and reasoning about polynomials and/or logarithms is needed for establishing invariants that describe the time or memory usage of many well-known algorithms. An appealing approach to this challenge is to exploit the powerful recurrence-solving techniques that have been developed in the field of computer algebra, which can compute exact characterizations of non-linear repetitive behavior. However, there is a gap between the capabilities of recurrence solvers and the needs of program analysis: (1) loop bodies are not merely systems of recurrence relations---they may contain conditional branches, nested loops, non-deterministic assignments, etc., and (2) a client program analyzer must be able to reason about the closed-form solutions produced by a recurrence solver (e.g., to prove assertions). This paper presents a method for generating non-linear invariants of general loops based on analyzing recurrence relations. The key components are an abstract domain for reasoning about non-linear arithmetic, a semantics-based method for extracting recurrence relations from loop bodies, and a recurrence solver that avoids closed forms that involve complex or irrational numbers. Our technique has been implemented in a program analyzer that can analyze general loops and mutually recursive procedures. Our experiments show that our technique shows promise for non-linear assertion-checking and resource-bound generation.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158142", "conference_name": "POPL", "authors": [ { - "first_name": "Martin", - "last_name": "Odersky", - "institution": "École Polytechnique Fédérale de Lausanne" - }, - { - "first_name": "Olivier", - "last_name": "Blanvillain", - "institution": "École Polytechnique Fédérale de Lausanne" - }, - { - "first_name": "Fengyun", - "last_name": "Liu", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Zachary", + "last_name": "Kincaid", + "institution": "Princeton University" }, { - "first_name": "Aggelos", - "last_name": "Biboudis", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "John", + "last_name": "Cyphert", + "institution": "University of Wisconsin–Madison" }, { - "first_name": "Heather", - "last_name": "Miller", - "institution": "Northeastern University" + "first_name": "Jason", + "last_name": "Breck", + "institution": "University of Wisconsin–Madison" }, { - "first_name": "Sandro", - "last_name": "Stucki", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" } ], - "dblp_key": "journals/pacmpl/OderskyBLBMS18", + "dblp_key": "journals/pacmpl/KincaidCBR18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158114", - "title": "Reducing liveness to safety in first-order logic", - "abstract": "We develop a new technique for verifying temporal properties of infinite-state (distributed) systems. The main idea is to reduce the temporal verification problem to the problem of verifying the safety of infinite-state systems expressed in first-order logic. This allows to leverage existing techniques for safety verification to verify temporal properties of interesting distributed protocols, including some that have not been mechanically verified before. We model infinite-state systems using first-order logic, and use first-order temporal logic (FO-LTL) to specify temporal properties. This general formalism allows to naturally model distributed systems, while supporting both unbounded-parallelism (where the system is allowed to dynamically create processes), and infinite-state per process. The traditional approach for verifying temporal properties of infinite-state systems employs well-founded relations (e.g. using linear arithmetic ranking functions). In contrast, our approach is based the idea of fair cycle detection. In finite-state systems, temporal verification can always be reduced to fair cycle detection (a system contains a fair cycle if it revisits a state after satisfying all fairness constraints). However, with both infinitely many states and infinitely many fairness constraints, a straightforward reduction to fair cycle detection is unsound. To regain soundness, we augment the infinite-state transition system by a dynamically computed finite set, that exploits the locality of transitions. This set lets us define a form of fair cycle detection that is sound in the presence of both infinitely many states, and infinitely many fairness constraints. Our approach allows a new style of temporal verification that does not explicitly involve ranking functions. This fits well with pure first-order verification which does not explicitly reason about numerical values. In particular, it can be used with effectively propositional first-order logic (EPR), in which case checking verification conditions is decidable. We applied our technique to verify temporal properties of several interesting protocols. To the best of our knowledge, we have obtained the first mechanized liveness proof for both TLB Shootdown, and Stoppable Paxos.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158114", + "paper_id": "10.1145/3158107", + "title": "Simplifying ARM concurrency: multicopy-atomic axiomatic and operational models for ARMv8", + "abstract": "ARM has a relaxed memory model, previously specified in informal prose for ARMv7 and ARMv8. Over time, and partly due to work building formal semantics for ARM concurrency, it has become clear that some of the complexity of the model is not justified by the potential benefits. In particular, the model was originally non-multicopy-atomic : writes could become visible to some other threads before becoming visible to all — but this has not been exploited in production implementations, the corresponding potential hardware optimisations are thought to have insufficient benefits in the ARM context, and it gives rise to subtle complications when combined with other ARMv8 features. The ARMv8 architecture has therefore been revised: it now has a multicopy-atomic model. It has also been simplified in other respects, including more straightforward notions of dependency, and the architecture now includes a formal concurrency model. In this paper we detail these changes and discuss their motivation. We define two formal concurrency models: an operational one, simplifying the Flowing model of Flur et al., and the axiomatic model of the revised ARMv8 specification. The models were developed by an academic group and by ARM staff, respectively, and this extended collaboration partly motivated the above changes. We prove the equivalence of the two models. The operational model is integrated into an executable exploration tool with new web interface, demonstrated by exhaustively checking the possible behaviours of a loop-unrolled version of a Linux kernel lock implementation, a previously known bug due to unprevented speculation, and a fixed version.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158107", "conference_name": "POPL", "authors": [ { - "first_name": "Oded", - "last_name": "Padon", - "institution": "Tel Aviv University" + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" }, { - "first_name": "Jochen", - "last_name": "Hoenicke", - "institution": "University of Freiburg" + "first_name": "Shaked", + "last_name": "Flur", + "institution": "University of Cambridge" }, { - "first_name": "Giuliano", - "last_name": "Losa", - "institution": "University of California, Los Angeles" + "first_name": "Will", + "last_name": "Deacon", + "institution": "ARM (United Kingdom)" }, { - "first_name": "Andreas", - "last_name": "Podelski", - "institution": "University of Freiburg" + "first_name": "Jon", + "last_name": "French", + "institution": "University of Cambridge" }, { - "first_name": "Mooly", - "last_name": "Sagiv", - "institution": "Tel Aviv University" + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of St Andrews" }, { - "first_name": "Sharon", - "last_name": "Shoham", - "institution": "Tel Aviv University" + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" } ], - "dblp_key": "journals/pacmpl/PadonHLPSS18", + "dblp_key": "journals/pacmpl/PulteFDFSS18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158104", - "title": "Intrinsically-typed definitional interpreters for imperative languages", - "abstract": "A definitional interpreter defines the semantics of an object language in terms of the (well-known) semantics of a host language, enabling understanding and validation of the semantics through execution. Combining a definitional interpreter with a separate type system requires a separate type safety proof. An alternative approach, at least for pure object languages, is to use a dependently-typed language to encode the object language type system in the definition of the abstract syntax. Using such intrinsically-typed abstract syntax definitions allows the host language type checker to verify automatically that the interpreter satisfies type safety. Does this approach scale to larger and more realistic object languages, and in particular to languages with mutable state and objects? In this paper, we describe and demonstrate techniques and libraries in Agda that successfully scale up intrinsically-typed definitional interpreters to handle rich object languages with non-trivial binding structures and mutable state. While the resulting interpreters are certainly more complex than the simply-typed λ-calculus interpreter we start with, we claim that they still meet the goals of being concise, comprehensible, and executable, while guaranteeing type safety for more elaborate object languages. We make the following contributions: (1) A dependent-passing style technique for hiding the weakening of indexed values as they propagate through monadic code. (2) An Agda library for programming with scope graphs and frames , which provides a uniform approach to dealing with name binding in intrinsically-typed interpreters. (3) Case studies of intrinsically-typed definitional interpreters for the simply-typed λ-calculus with references (STLC+Ref) and for a large subset of Middleweight Java (MJ).", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158104", + "paper_id": "10.1145/3158123", + "title": "Algorithmic analysis of termination problems for quantum programs", + "abstract": "We introduce the notion of linear ranking super-martingale (LRSM) for quantum programs (with nondeterministic choices, namely angelic and demonic choices). Several termination theorems are established showing that the existence of the LRSMs of a quantum program implies its termination. Thus, the termination problems of quantum programs is reduced to realisability and synthesis of LRSMs. We further show that the realisability and synthesis problem of LRSMs for quantum programs can be reduced to an SDP (Semi-Definite Programming) problem, which can be settled with the existing SDP solvers. The techniques developed in this paper are used to analyse the termination of several example quantum programs, including quantum random walks and quantum Bernoulli factory for random number generation. This work is essentially a generalisation of constraint-based approach to the corresponding problems for probabilistic programs developed in the recent literature by adding two novel ideas: (1) employing the fundamental Gleason's theorem in quantum mechanics to guide the choices of templates; and (2) a generalised Farkas' lemma in terms of observables (Hermitian operators) in quantum physics.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158123", "conference_name": "POPL", "authors": [ { - "first_name": "Casper Bach", - "last_name": "Poulsen", - "institution": "Delft University of Technology" - }, - { - "first_name": "Arjen", - "last_name": "Rouvoet", - "institution": "Delft University of Technology" - }, - { - "first_name": "Andrew", - "last_name": "Tolmach", - "institution": "Portland State University" - }, - { - "first_name": "Robbert", - "last_name": "Krebbers", - "institution": "Delft University of Technology" + "first_name": "Yangjia", + "last_name": "Li", + "institution": "Institute of Software" }, { - "first_name": "Eelco", - "last_name": "Visser", - "institution": "Delft University of Technology" + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Chinese Academy of Sciences" } ], - "dblp_key": "journals/pacmpl/PoulsenRTKV18", + "dblp_key": "journals/pacmpl/LiY18", "venue": "popl", "year": 2018 }, { - "paper_id": "10.1145/3158101", - "title": "Unifying analytic and statically-typed quasiquotes", - "abstract": "Metaprograms are programs that manipulate (generate, analyze and evaluate) other programs. These tasks are greatly facilitated by quasiquotation, a technique to construct and deconstruct program fragments using quoted code templates expressed in the syntax of the manipulated language. We argue that two main flavors of quasiquotes have existed so far: Lisp-style quasiquotes, which can both construct and deconstruct programs but may produce code that contains type mismatches and unbound variables; and MetaML-style quasiquotes, which rely on static typing to prevent these errors, but can only construct programs. In this paper, we show how to combine the advantages of both flavors into a unified framework: we allow the construction, deconstruction and evaluation of program fragments while ensuring that generated programs are well-typed and well-scoped, a combination unseen in previous work. We formalize our approach as λ {} , a multi-stage calculus with code pattern matching and rewriting, and prove its type safety. We also present its realization in Squid, a metaprogramming framework for Scala, leveraging Scala’s expressive type system. To demonstrate the usefulness of our approach, we introduce speculative rewrite rules , a novel code transformation technique that makes decisive use of these capabilities, and we outline how it simplifies the design of some crucial query compiler optimizations.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158101", + "paper_id": "10.1145/3158121", + "title": "A new proof rule for almost-sure termination", + "abstract": "We present a new proof rule for proving almost-sure termination of probabilistic programs, including those that contain demonic non-determinism. An important question for a probabilistic program is whether the probability mass of all its diverging runs is zero, that is that it terminates \"almost surely\". Proving that can be hard, and this paper presents a new method for doing so. It applies directly to the program's source code, even if the program contains demonic choice. Like others, we use variant functions (a.k.a. \"super-martingales\") that are real-valued and decrease randomly on each loop iteration; but our key innovation is that the amount as well as the probability of the decrease are parametric. We prove the soundness of the new rule, indicate where its applicability goes beyond existing rules, and explain its connection to classical results on denumerable (non-demonic) Markov chains.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158121", "conference_name": "POPL", "authors": [ { - "first_name": "Lionel", - "last_name": "Parreaux", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Annabelle", + "last_name": "McIver", + "institution": "Macquarie University" }, { - "first_name": "Antoine", - "last_name": "Voizard", - "institution": "California University of Pennsylvania" + "first_name": "Carroll", + "last_name": "Morgan", + "institution": "Commonwealth Scientific and Industrial Research Organisation" }, { - "first_name": "Amir", - "last_name": "Shaikhha", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Benjamin Lucien", + "last_name": "Kaminski", + "institution": "University College London" }, { - "first_name": "Christoph", - "last_name": "Koch", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Joost-Pieter", + "last_name": "Katoen", + "institution": "RWTH Aachen University" } ], - "dblp_key": "journals/pacmpl/ParreauxVSK18", + "dblp_key": "journals/pacmpl/McIverMKK18", "venue": "popl", "year": 2018 }, @@ -1650,7 +1419,7 @@ "paper_id": "10.1145/3158124", "title": "Monadic refinements for relational cost analysis", "abstract": "Formal frameworks for cost analysis of programs have been widely studied in the unary setting and, to a limited extent, in the relational setting. However, many of these frameworks focus only on the cost aspect, largely side-lining functional properties that are often a prerequisite for cost analysis, thus leaving many interesting programs out of their purview. In this paper, we show that elegant, simple, expressive proof systems combining cost analysis and functional properties can be built by combining already known ingredients: higher-order refinements and cost monads. Specifically, we derive two syntax-directed proof systems, U C and R C , for unary and relational cost analysis, by adding a cost monad to a (syntax-directed) logic of higher-order programs. We study the metatheory of the systems, show that several nontrivial examples can be verified in them, and prove that existing frameworks for cost analysis (RelCost and RAML) can be embedded in them.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158124", "conference_name": "POPL", "authors": [ @@ -1685,68 +1454,30 @@ "year": 2018 }, { - "paper_id": "10.1145/3158107", - "title": "Simplifying ARM concurrency: multicopy-atomic axiomatic and operational models for ARMv8", - "abstract": "ARM has a relaxed memory model, previously specified in informal prose for ARMv7 and ARMv8. Over time, and partly due to work building formal semantics for ARM concurrency, it has become clear that some of the complexity of the model is not justified by the potential benefits. In particular, the model was originally non-multicopy-atomic : writes could become visible to some other threads before becoming visible to all — but this has not been exploited in production implementations, the corresponding potential hardware optimisations are thought to have insufficient benefits in the ARM context, and it gives rise to subtle complications when combined with other ARMv8 features. The ARMv8 architecture has therefore been revised: it now has a multicopy-atomic model. It has also been simplified in other respects, including more straightforward notions of dependency, and the architecture now includes a formal concurrency model. In this paper we detail these changes and discuss their motivation. We define two formal concurrency models: an operational one, simplifying the Flowing model of Flur et al., and the axiomatic model of the revised ARMv8 specification. The models were developed by an academic group and by ARM staff, respectively, and this extended collaboration partly motivated the above changes. We prove the equivalence of the two models. The operational model is integrated into an executable exploration tool with new web interface, demonstrated by exhaustively checking the possible behaviours of a loop-unrolled version of a Linux kernel lock implementation, a previously known bug due to unprevented speculation, and a fixed version.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158107", + "paper_id": "10.1145/3158143", + "title": "A practical construction for decomposing numerical abstract domains", + "abstract": "Numerical abstract domains such as Polyhedra, Octahedron, Octagon, Interval, and others are an essential component of static program analysis. The choice of domain offers a performance/precision tradeoff ranging from cheap and imprecise (Interval) to expensive and precise (Polyhedra). Recently, significant speedups were achieved for Octagon and Polyhedra by manually decomposing their transformers to work with the Cartesian product of projections associated with partitions of the variable set. While practically useful, this manual process is time consuming, error-prone, and has to be applied from scratch for every domain. In this paper, we present a generic approach for decomposing the transformers of sub-polyhedra domains along with conditions for checking whether the decomposed transformers lose precision with respect to the original transformers. These conditions are satisfied by most practical transformers, thus our approach is suitable for increasing the performance of these transformers without compromising their precision. Furthermore, our approach is ``black box:'' it does not require changes to the internals of the original non-decomposed transformers or additional manual effort per domain. We implemented our approach and applied it to the domains of Zones, Octagon, and Polyhedra. We then compared the performance of the decomposed transformers obtained with our generic method versus the state of the art: the (non-decomposed) PPL for Polyhedra and the much faster ELINA (which uses manual decomposition) for Polyhedra and Octagon. Against ELINA we demonstrate finer partitions and an associated speedup of about 2x on average. Our results indicate that the general construction presented in this work is a viable method for improving the performance of sub-polyhedra domains. It enables designers of abstract domains to benefit from decomposition without re-writing all of their transformers from scratch as required by prior work.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158143", "conference_name": "POPL", "authors": [ { - "first_name": "Christopher", - "last_name": "Pulte", - "institution": "University of Cambridge" - }, - { - "first_name": "Shaked", - "last_name": "Flur", - "institution": "University of Cambridge" - }, - { - "first_name": "Will", - "last_name": "Deacon", - "institution": "ARM (United Kingdom)" - }, - { - "first_name": "Jon", - "last_name": "French", - "institution": "University of Cambridge" - }, - { - "first_name": "Susmit", - "last_name": "Sarkar", - "institution": "University of St Andrews" + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "ETH Zurich" }, { - "first_name": "Peter", - "last_name": "Sewell", - "institution": "University of Cambridge" - } - ], - "dblp_key": "journals/pacmpl/PulteFDFSS18", - "venue": "popl", - "year": 2018 - }, - { - "paper_id": "10.1145/3158108", - "title": "Progress of concurrent objects with partial methods", - "abstract": "Various progress properties have been proposed for concurrent objects, such as wait-freedom, lock-freedom, starvation-freedom and deadlock-freedom. However, none of them applies to concurrent objects with partial methods, i.e., methods that are supposed not to return under certain circumstances. A typical example is the lock_acquire method, which must not return when the lock has already been acquired. In this paper we propose two new progress properties, partial starvation-freedom (PSF) and partial deadlock-freedom (PDF), for concurrent objects with partial methods. We also design four patterns to write abstract specifications for PSF or PDF objects under strongly or weakly fair scheduling, so that these objects contextually refine the abstract specifications. Our Abstraction Theorem shows the equivalence between PSF (or PDF) and the progress-aware contextual refinement. Finally, we generalize the program logic LiLi to have a new logic to verify the PSF (or PDF) property and linearizability of concurrent objects.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158108", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Hongjin", - "last_name": "Liang", - "institution": "University of Science and Technology of China" + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" }, { - "first_name": "Xinyu", - "last_name": "Feng", - "institution": "Nanjing University of Science and Technology" + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" } ], - "dblp_key": "journals/pacmpl/LiangF18", + "dblp_key": "journals/pacmpl/SinghPV18", "venue": "popl", "year": 2018 }, @@ -1754,7 +1485,7 @@ "paper_id": "10.1145/3158116", "title": "Programming and proving with distributed protocols", "abstract": "Distributed systems play a crucial role in modern infrastructure, but are notoriously difficult to implement correctly. This difficulty arises from two main challenges: (a) correctly implementing core system components (e.g., two-phase commit), so all their internal invariants hold, and (b) correctly composing standalone system components into functioning trustworthy applications (e.g., persistent storage built on top of a two-phase commit instance). Recent work has developed several approaches for addressing (a) by means of mechanically verifying implementations of core distributed components, but no methodology exists to address (b) by composing such verified components into larger verified applications. As a result, expensive verification efforts for key system components are not easily reusable, which hinders further verification efforts. In this paper, we present Disel, the first framework for implementation and compositional verification of distributed systems and their clients, all within the mechanized, foundational context of the Coq proof assistant. In Disel, users implement distributed systems using a domain specific language shallowly embedded in Coq and providing both high-level programming constructs as well as low-level communication primitives. Components of composite systems are specified in Disel as protocols, which capture system-specific logic and disentangle system definitions from implementation details. By virtue of Disel's dependent type system, well-typed implementations always satisfy their protocols' invariants and never go wrong, allowing users to verify system implementations interactively using Disel's Hoare-style program logic, which extends state-of-the-art techniques for concurrency verification to the distributed setting. By virtue of the substitution principle and frame rule provided by Disel's logic, system components can be composed leading to modular, reusable verified distributed systems. We describe Disel, illustrate its use with a series of examples, outline its logic and metatheory, and report on our experience using it as a framework for implementing, specifying, and verifying distributed systems.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158116", "conference_name": "POPL", "authors": [ @@ -1779,40 +1510,78 @@ "year": 2018 }, { - "paper_id": "10.1145/3158138", - "title": "JaVerT: JavaScript verification toolchain", - "abstract": "The dynamic nature of JavaScript and its complex semantics make it a difficult target for logic-based verification. We introduce JaVerT, a semi-automatic JavaScript Verification Toolchain, based on separation logic and aimed at the specialist developer wanting rich, mechanically verified specifications of critical JavaScript code. To specify JavaScript programs, we design abstractions that capture its key heap structures (for example, prototype chains and function closures), allowing the developer to write clear and succinct specifications with minimal knowledge of the JavaScript internals. To verify JavaScript programs, we develop JaVerT, a verification pipeline consisting of: JS-2-JSIL, a well-tested compiler from JavaScript to JSIL, an intermediate goto language capturing the fundamental dynamic features of JavaScript; JSIL Verify, a semi-automatic verification tool based on a sound JSIL separation logic; and verified axiomatic specifications of the JavaScript internal functions. Using JaVerT, we verify functional correctness properties of: data-structure libraries (key-value map, priority queue) written in an object-oriented style; operations on data structures such as binary search trees (BSTs) and lists; examples illustrating function closures; and test cases from the official ECMAScript test suite. The verification times suggest that reasoning about larger, more complex code using JaVerT is feasible.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158138", + "paper_id": "10.1145/3158114", + "title": "Reducing liveness to safety in first-order logic", + "abstract": "We develop a new technique for verifying temporal properties of infinite-state (distributed) systems. The main idea is to reduce the temporal verification problem to the problem of verifying the safety of infinite-state systems expressed in first-order logic. This allows to leverage existing techniques for safety verification to verify temporal properties of interesting distributed protocols, including some that have not been mechanically verified before. We model infinite-state systems using first-order logic, and use first-order temporal logic (FO-LTL) to specify temporal properties. This general formalism allows to naturally model distributed systems, while supporting both unbounded-parallelism (where the system is allowed to dynamically create processes), and infinite-state per process. The traditional approach for verifying temporal properties of infinite-state systems employs well-founded relations (e.g. using linear arithmetic ranking functions). In contrast, our approach is based the idea of fair cycle detection. In finite-state systems, temporal verification can always be reduced to fair cycle detection (a system contains a fair cycle if it revisits a state after satisfying all fairness constraints). However, with both infinitely many states and infinitely many fairness constraints, a straightforward reduction to fair cycle detection is unsound. To regain soundness, we augment the infinite-state transition system by a dynamically computed finite set, that exploits the locality of transitions. This set lets us define a form of fair cycle detection that is sound in the presence of both infinitely many states, and infinitely many fairness constraints. Our approach allows a new style of temporal verification that does not explicitly involve ranking functions. This fits well with pure first-order verification which does not explicitly reason about numerical values. In particular, it can be used with effectively propositional first-order logic (EPR), in which case checking verification conditions is decidable. We applied our technique to verify temporal properties of several interesting protocols. To the best of our knowledge, we have obtained the first mechanized liveness proof for both TLB Shootdown, and Stoppable Paxos.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158114", "conference_name": "POPL", "authors": [ { - "first_name": "José Fragoso", - "last_name": "Santos", - "institution": "Imperial College London" + "first_name": "Oded", + "last_name": "Padon", + "institution": "Tel Aviv University" }, { - "first_name": "Petar", - "last_name": "Maksimović", - "institution": "Imperial College London" + "first_name": "Jochen", + "last_name": "Hoenicke", + "institution": "University of Freiburg" }, { - "first_name": "Daiva", - "last_name": "Naudžiūnienė", - "institution": "Imperial College London" + "first_name": "Giuliano", + "last_name": "Losa", + "institution": "University of California, Los Angeles" }, { - "first_name": "Thomas", - "last_name": "Wood", - "institution": "Imperial College London" + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" }, { - "first_name": "Philippa", - "last_name": "Gardner", - "institution": "Imperial College London" + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" } ], - "dblp_key": "journals/pacmpl/SantosMNWG18", + "dblp_key": "journals/pacmpl/PadonHLPSS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158117", + "title": "Inference of static semantics for incomplete C programs", + "abstract": "Incomplete source code naturally emerges in software development: during the design phase, while evolving, testing and analyzing programs. Therefore, the ability to understand partial programs is a valuable asset. However, this problem is still unsolved in the C programming language. Difficulties stem from the fact that parsing C requires, not only syntax, but also semantic information. Furthermore, inferring types so that they respect C's type system is a challenging task. In this paper we present a technique that lets us solve these problems. We provide a unification-based type inference capable of dealing with C intricacies. The ideas we present let us reconstruct partial C programs into complete well-typed ones. Such program reconstruction has several applications: enabling static analysis tools in scenarios where software components may be absent; improving static analysis tools that do not rely on build-specifications; allowing stub-generation and testing tools to work on snippets; and assisting programmers on the extraction of reusable data-structures out of the program parts that use them. Our evaluation is performed on source code from a variety of C libraries such as GNU's Coreutils, GNULib, GNOME's GLib, and GDSL; on implementations from Sedgewick's books; and on snippets from popular open-source projects like CPython, FreeBSD, and Git.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158117", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Leandro T. C.", + "last_name": "Melo", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Rodrigo", + "last_name": "Ribeiro", + "institution": "Universidade Federal de Ouro Preto" + }, + { + "first_name": "Marcus Rodrigues de", + "last_name": "Araújo", + "institution": "Universidade Federal de Minas Gerais" + }, + { + "first_name": "Fernando Magno Quintão", + "last_name": "Pereira", + "institution": "Universidade Federal de Minas Gerais" + } + ], + "dblp_key": "journals/pacmpl/MeloRAP18", "venue": "popl", "year": 2018 }, @@ -1820,7 +1589,7 @@ "paper_id": "10.1145/3158148", "title": "Denotational validation of higher-order Bayesian inference", "abstract": "We present a modular semantic account of Bayesian inference algorithms for probabilistic programming languages, as used in data science and machine learning. Sophisticated inference algorithms are often explained in terms of composition of smaller parts. However, neither their theoretical justification nor their implementation reflects this modularity. We show how to conceptualise and analyse such inference algorithms as manipulating intermediate representations of probabilistic programs using higher-order functions and inductive types, and their denotational semantics. Semantic accounts of continuous distributions use measurable spaces. However, our use of higher-order functions presents a substantial technical difficulty: it is impossible to define a measurable space structure over the collection of measurable functions between arbitrary measurable spaces that is compatible with standard operations on those functions, such as function application. We overcome this difficulty using quasi-Borel spaces, a recently proposed mathematical structure that supports both function spaces and continuous distributions. We define a class of semantic structures for representing probabilistic programs, and semantic validity criteria for transformations of these representations in terms of distribution preservation. We develop a collection of building blocks for composing representations. We use these building blocks to validate common inference algorithms such as Sequential Monte Carlo and Markov Chain Monte Carlo. To emphasize the connection between the semantic manipulation and its traditional measure theoretic origins, we use Kock's synthetic measure theory. We demonstrate its usefulness by proving a quasi-Borel counterpart to the Metropolis-Hastings-Green theorem.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158148", "conference_name": "POPL", "authors": [ @@ -1860,22 +1629,83 @@ "institution": "University of Tübingen" }, { - "first_name": "Sean", - "last_name": "Moss", - "institution": "University of Cambridge" + "first_name": "Sean", + "last_name": "Moss", + "institution": "University of Cambridge" + }, + { + "first_name": "Chris", + "last_name": "Heunen", + "institution": "University of Edinburgh" + }, + { + "first_name": "Zoubin", + "last_name": "Ghahramani", + "institution": "Uber AI (United States)" + } + ], + "dblp_key": "journals/pacmpl/ScibiorKVSYCOMH18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158104", + "title": "Intrinsically-typed definitional interpreters for imperative languages", + "abstract": "A definitional interpreter defines the semantics of an object language in terms of the (well-known) semantics of a host language, enabling understanding and validation of the semantics through execution. Combining a definitional interpreter with a separate type system requires a separate type safety proof. An alternative approach, at least for pure object languages, is to use a dependently-typed language to encode the object language type system in the definition of the abstract syntax. Using such intrinsically-typed abstract syntax definitions allows the host language type checker to verify automatically that the interpreter satisfies type safety. Does this approach scale to larger and more realistic object languages, and in particular to languages with mutable state and objects? In this paper, we describe and demonstrate techniques and libraries in Agda that successfully scale up intrinsically-typed definitional interpreters to handle rich object languages with non-trivial binding structures and mutable state. While the resulting interpreters are certainly more complex than the simply-typed λ-calculus interpreter we start with, we claim that they still meet the goals of being concise, comprehensible, and executable, while guaranteeing type safety for more elaborate object languages. We make the following contributions: (1) A dependent-passing style technique for hiding the weakening of indexed values as they propagate through monadic code. (2) An Agda library for programming with scope graphs and frames , which provides a uniform approach to dealing with name binding in intrinsically-typed interpreters. (3) Case studies of intrinsically-typed definitional interpreters for the simply-typed λ-calculus with references (STLC+Ref) and for a large subset of Middleweight Java (MJ).", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158104", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Casper Bach", + "last_name": "Poulsen", + "institution": "Delft University of Technology" + }, + { + "first_name": "Arjen", + "last_name": "Rouvoet", + "institution": "Delft University of Technology" + }, + { + "first_name": "Andrew", + "last_name": "Tolmach", + "institution": "Portland State University" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" }, { - "first_name": "Chris", - "last_name": "Heunen", - "institution": "University of Edinburgh" + "first_name": "Eelco", + "last_name": "Visser", + "institution": "Delft University of Technology" + } + ], + "dblp_key": "journals/pacmpl/PoulsenRTKV18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158134", + "title": "Why is random testing effective for partition tolerance bugs?", + "abstract": "Random testing has proven to be an effective way to catch bugs in distributed systems in the presence of network partition faults. This is surprising, as the space of potentially faulty executions is enormous, and the bugs depend on a subtle interplay between sequences of operations and faults. We provide a theoretical justification of the effectiveness of random testing in this context. First, we show a general construction, using the probabilistic method from combinatorics, that shows that whenever a random test covers a fixed coverage goal with sufficiently high probability, a small randomly-chosen set of tests achieves full coverage with high probability. In particular, we show that our construction can give test sets exponentially smaller than systematic enumeration. Second, based on an empirical study of many bugs found by random testing in production distributed systems, we introduce notions of test coverage relating to network partition faults which are effective in finding bugs. Finally, we show using combinatorial arguments that for these notions of test coverage we introduce, we can find a lower bound on the probability that a random test covers a given goal. Our general construction then explains why random testing tools achieve good coverage---and hence, find bugs---quickly. While we formulate our results in terms of network partition faults, our construction provides a step towards rigorous analysis of random testing algorithms, and can be applicable in other scenarios.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158134", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Zoubin", - "last_name": "Ghahramani", - "institution": "Uber AI (United States)" + "first_name": "Filip", + "last_name": "Niksic", + "institution": "Max Planck Institute for Software Systems" } ], - "dblp_key": "journals/pacmpl/ScibiorKVSYCOMH18", + "dblp_key": "journals/pacmpl/MajumdarN18", "venue": "popl", "year": 2018 }, @@ -1883,7 +1713,7 @@ "paper_id": "10.1145/3158152", "title": "A logical relation for monadic encapsulation of state: proving contextual equivalences in the presence of runST", "abstract": "We present a logical relations model of a higher-order functional programming language with impredicative polymorphism, recursive types, and a Haskell-style ST monad type with runST. We use our logical relations model to show that runST provides proper encapsulation of state, by showing that effectful computations encapsulated by runST are heap independent. Furthermore, we show that contextual refinements and equivalences that are expected to hold for pure computations do indeed hold in the presence of runST. This is the first time such relational results have been proven for a language with monadic encapsulation of state. We have formalized all the technical development and results in Coq.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158152", "conference_name": "POPL", "authors": [ @@ -1912,39 +1742,11 @@ "venue": "popl", "year": 2018 }, - { - "paper_id": "10.1145/3158143", - "title": "A practical construction for decomposing numerical abstract domains", - "abstract": "Numerical abstract domains such as Polyhedra, Octahedron, Octagon, Interval, and others are an essential component of static program analysis. The choice of domain offers a performance/precision tradeoff ranging from cheap and imprecise (Interval) to expensive and precise (Polyhedra). Recently, significant speedups were achieved for Octagon and Polyhedra by manually decomposing their transformers to work with the Cartesian product of projections associated with partitions of the variable set. While practically useful, this manual process is time consuming, error-prone, and has to be applied from scratch for every domain. In this paper, we present a generic approach for decomposing the transformers of sub-polyhedra domains along with conditions for checking whether the decomposed transformers lose precision with respect to the original transformers. These conditions are satisfied by most practical transformers, thus our approach is suitable for increasing the performance of these transformers without compromising their precision. Furthermore, our approach is ``black box:'' it does not require changes to the internals of the original non-decomposed transformers or additional manual effort per domain. We implemented our approach and applied it to the domains of Zones, Octagon, and Polyhedra. We then compared the performance of the decomposed transformers obtained with our generic method versus the state of the art: the (non-decomposed) PPL for Polyhedra and the much faster ELINA (which uses manual decomposition) for Polyhedra and Octagon. Against ELINA we demonstrate finer partitions and an associated speedup of about 2x on average. Our results indicate that the general construction presented in this work is a viable method for improving the performance of sub-polyhedra domains. It enables designers of abstract domains to benefit from decomposition without re-writing all of their transformers from scratch as required by prior work.", - "date": "2017-12-27", - "link": "https://doi.org/10.1145/3158143", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Gagandeep", - "last_name": "Singh", - "institution": "ETH Zurich" - }, - { - "first_name": "Markus", - "last_name": "Püschel", - "institution": "ETH Zurich" - }, - { - "first_name": "Martin", - "last_name": "Vechev", - "institution": "ETH Zurich" - } - ], - "dblp_key": "journals/pacmpl/SinghPV18", - "venue": "popl", - "year": 2018 - }, { "paper_id": "10.1145/3158141", "title": "Refinement reflection: complete verification with SMT", "abstract": "We introduce Refinement Reflection , a new framework for building SMT-based deductive verifiers. The key idea is to reflect the code implementing a user-defined function into the function’s (output) refinement type. As a consequence, at uses of the function, the function definition is instantiated in the SMT logic in a precise fashion that permits decidable verification. Reflection allows the user to write equational proofs of programs just by writing other programs using pattern-matching and recursion to perform case-splitting and induction. Thus, via the propositions-as-types principle, we show that reflection permits the specification of arbitrary functional correctness properties. Finally, we introduce a proof-search algorithm called Proof by Logical Evaluation that uses techniques from model checking and abstract interpretation, to completely automate equational reasoning. We have implemented reflection in Liquid Haskell and used it to verify that the widely used instances of the Monoid, Applicative, Functor, and Monad typeclasses actually satisfy key algebraic laws required to make the clients safe, and have used reflection to build the first library that actually verifies assumptions about associativity and ordering that are crucial for safe deterministic parallelism.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158141", "conference_name": "POPL", "authors": [ @@ -1992,7 +1794,7 @@ "paper_id": "10.1145/3158097", "title": "Automated lemma synthesis in symbolic-heap separation logic", "abstract": "The symbolic-heap fragment of separation logic has been actively developed and advocated for verifying the memory-safety property of computer programs. At present, one of its biggest challenges is to effectively prove entailments containing inductive heap predicates. These entailments are usually proof obligations generated when verifying programs that manipulate complex data structures like linked lists, trees, or graphs. To assist in proving such entailments, this paper introduces a lemma synthesis framework, which automatically discovers lemmas to serve as eureka steps in the proofs. Mathematical induction and template-based constraint solving are two pillars of our framework. To derive the supporting lemmas for a given entailment, the framework firstly identifies possible lemma templates from the entailment's heap structure. It then sets up unknown relations among each template's variables and conducts structural induction proof to generate constraints about these relations. Finally, it solves the constraints to find out actual definitions of the unknown relations, thus discovers the lemmas. We have integrated this framework into a prototype prover and have experimented it on various entailment benchmarks. The experimental results show that our lemma-synthesis-assisted prover can prove many entailments that could not be handled by existing techniques. This new proposal opens up more opportunities to automatically reason with complex inductive heap predicates.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158097", "conference_name": "POPL", "authors": [ @@ -2021,11 +1823,176 @@ "venue": "popl", "year": 2018 }, + { + "paper_id": "10.1145/3158108", + "title": "Progress of concurrent objects with partial methods", + "abstract": "Various progress properties have been proposed for concurrent objects, such as wait-freedom, lock-freedom, starvation-freedom and deadlock-freedom. However, none of them applies to concurrent objects with partial methods, i.e., methods that are supposed not to return under certain circumstances. A typical example is the lock_acquire method, which must not return when the lock has already been acquired. In this paper we propose two new progress properties, partial starvation-freedom (PSF) and partial deadlock-freedom (PDF), for concurrent objects with partial methods. We also design four patterns to write abstract specifications for PSF or PDF objects under strongly or weakly fair scheduling, so that these objects contextually refine the abstract specifications. Our Abstraction Theorem shows the equivalence between PSF (or PDF) and the progress-aware contextual refinement. Finally, we generalize the program logic LiLi to have a new logic to verify the PSF (or PDF) property and linearizability of concurrent objects.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158108", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Hongjin", + "last_name": "Liang", + "institution": "University of Science and Technology of China" + }, + { + "first_name": "Xinyu", + "last_name": "Feng", + "institution": "Nanjing University of Science and Technology" + } + ], + "dblp_key": "journals/pacmpl/LiangF18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158138", + "title": "JaVerT: JavaScript verification toolchain", + "abstract": "The dynamic nature of JavaScript and its complex semantics make it a difficult target for logic-based verification. We introduce JaVerT, a semi-automatic JavaScript Verification Toolchain, based on separation logic and aimed at the specialist developer wanting rich, mechanically verified specifications of critical JavaScript code. To specify JavaScript programs, we design abstractions that capture its key heap structures (for example, prototype chains and function closures), allowing the developer to write clear and succinct specifications with minimal knowledge of the JavaScript internals. To verify JavaScript programs, we develop JaVerT, a verification pipeline consisting of: JS-2-JSIL, a well-tested compiler from JavaScript to JSIL, an intermediate goto language capturing the fundamental dynamic features of JavaScript; JSIL Verify, a semi-automatic verification tool based on a sound JSIL separation logic; and verified axiomatic specifications of the JavaScript internal functions. Using JaVerT, we verify functional correctness properties of: data-structure libraries (key-value map, priority queue) written in an object-oriented style; operations on data structures such as binary search trees (BSTs) and lists; examples illustrating function closures; and test cases from the official ECMAScript test suite. The verification times suggest that reasoning about larger, more complex code using JaVerT is feasible.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158138", + "conference_name": "POPL", + "authors": [ + { + "first_name": "José Fragoso", + "last_name": "Santos", + "institution": "Imperial College London" + }, + { + "first_name": "Petar", + "last_name": "Maksimović", + "institution": "Imperial College London" + }, + { + "first_name": "Daiva", + "last_name": "Naudžiūnienė", + "institution": "Imperial College London" + }, + { + "first_name": "Thomas", + "last_name": "Wood", + "institution": "Imperial College London" + }, + { + "first_name": "Philippa", + "last_name": "Gardner", + "institution": "Imperial College London" + } + ], + "dblp_key": "journals/pacmpl/SantosMNWG18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158130", + "title": "Simplicitly: foundations and applications of implicit function types", + "abstract": "Understanding a program entails understanding its context; dependencies, configurations and even implementations are all forms of contexts. Modern programming languages and theorem provers offer an array of constructs to define contexts, implicitly. Scala offers implicit parameters which are used pervasively, but which cannot be abstracted over. This paper describes a generalization of implicit parameters to implicit function types , a powerful way to abstract over the context in which some piece of code is run. We provide a formalization based on bidirectional type-checking that closely follows the semantics implemented by the Scala compiler. To demonstrate their range of abstraction capabilities, we present several applications that make use of implicit function types. We show how to encode the builder pattern, tagless interpreters, reader and free monads and we assess the performance of the monadic structures presented.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158130", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martin", + "last_name": "Odersky", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Olivier", + "last_name": "Blanvillain", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Fengyun", + "last_name": "Liu", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Aggelos", + "last_name": "Biboudis", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Heather", + "last_name": "Miller", + "institution": "Northeastern University" + }, + { + "first_name": "Sandro", + "last_name": "Stucki", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/OderskyBLBMS18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158139", + "title": "Soft contract verification for higher-order stateful programs", + "abstract": "Software contracts allow programmers to state rich program properties using the full expressive power of an object language. However, since they are enforced at runtime, monitoring contracts imposes significant overhead and delays error discovery. So contract veri cation aims to guarantee all or most of these properties ahead of time, enabling valuable optimizations and yielding a more general assurance of correctness. Existing methods for static contract verification satisfy the needs of more restricted target languages, but fail to address the challenges unique to those conjoining untyped, dynamic programming, higher-order functions, modularity, and statefulness. Our approach tackles all these features at once, in the context of the full Racket system—a mature environment for stateful, higher-order, multi-paradigm programming with or with- out types. Evaluating our method using a set of both pure and stateful benchmarks, we are able to verify 99.94% of checks statically (all but 28 of 49, 861). Stateful, higher-order functions pose significant challenges for static contract verification in particular. In the presence of these features, a modular analysis must permit code from the current module to escape permanently to an opaque context (unspecified code from outside the current module) that may be stateful and therefore store a reference to the escaped closure. Also, contracts themselves, being predicates wri en in unrestricted Racket, may exhibit stateful behavior; a sound approach must be robust to contracts which are arbitrarily expressive and interwoven with the code they monitor. In this paper, we present and evaluate our solution based on higher-order symbolic execution, explain the techniques we used to address such thorny issues, formalize a notion of behavioral approximation, and use it to provide a mechanized proof of soundness.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158139", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Phúc C.", + "last_name": "Nguyễn", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Thomas", + "last_name": "Gilray", + "institution": "University of Maryland, College Park" + }, + { + "first_name": "Sam", + "last_name": "Tobin-Hochstadt", + "institution": "Indiana University" + }, + { + "first_name": "David Van", + "last_name": "Horn", + "institution": "University of Maryland, College Park" + } + ], + "dblp_key": "journals/pacmpl/NguyenGTH18", + "venue": "popl", + "year": 2018 + }, + { + "paper_id": "10.1145/3158094", + "title": "Polyadic approximations, fibrations and intersection types", + "abstract": "Starting from an exact correspondence between linear approximations and non-idempotent intersection types, we develop a general framework for building systems of intersection types characterizing normalization properties. We show how this construction, which uses in a fundamental way Melliès and Zeilberger's ``type systems as functors'' viewpoint, allows us to recover equivalent versions of every well known intersection type system (including Coppo and Dezani's original system, as well as its non-idempotent variants independently introduced by Gardner and de Carvalho). We also show how new systems of intersection types may be built almost automatically in this way.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158094", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Damiano", + "last_name": "Mazza", + "institution": "Université Sorbonne Paris Nord" + }, + { + "first_name": "Luc", + "last_name": "Pellissier", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Pierre", + "last_name": "Vial", + "institution": "Université Paris Cité" + } + ], + "dblp_key": "journals/pacmpl/MazzaPV18", + "venue": "popl", + "year": 2018 + }, { "paper_id": "10.1145/3158109", "title": "A principled approach to ornamentation in ML", "abstract": "Ornaments are a way to describe changes in datatype definitions reorganizing, adding, or dropping some pieces of data so that functions operating on the bare definition can be partially and sometimes totally lifted into functions operating on the ornamented structure. We propose an extension of ML with higher-order ornaments, demonstrate its expressiveness with a few typical examples, including code refactoring, study the metatheoretical properties of ornaments, and describe their elaboration process. We formalize ornamentation via an a posteriori abstraction of the bare code, returning a generic term, which lives in a meta-language above ML. The lifted code is obtained by application of the generic term to well-chosen arguments, followed by staged reduction, and some remaining simplifications. We use logical relations to closely relate the lifted code to the bare code.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158109", "conference_name": "POPL", "authors": [ @@ -2048,7 +2015,7 @@ "paper_id": "10.1145/3158151", "title": "Program synthesis using abstraction refinement", "abstract": "We present a new approach to example-guided program synthesis based on counterexample-guided abstraction refinement . Our method uses the abstract semantics of the underlying DSL to find a program P whose abstract behavior satisfies the examples. However, since program P may be spurious with respect to the concrete semantics, our approach iteratively refines the abstraction until we either find a program that satisfies the examples or prove that no such DSL program exists. Because many programs have the same input-output behavior in terms of their abstract semantics , this synthesis methodology significantly reduces the search space compared to existing techniques that use purely concrete semantics. While synthesis using abstraction refinement (SYNGAR) could be implemented in different settings, we propose a refinement-based synthesis algorithm that uses abstract finite tree automata (AFTA) . Our technique uses a coarse initial program abstraction to construct an initial AFTA, which is iteratively refined by constructing a proof of incorrectness of any spurious program. In addition to ruling out the spurious program accepted by the previous AFTA, proofs of incorrectness are also useful for ruling out many other spurious programs. We implement these ideas in a framework called Blaze, which can be instantiated in different domains by providing a suitable DSL and its corresponding concrete and abstract semantics. We have used the Blaze framework to build synthesizers for string and matrix transformations, and we compare Blaze with existing techniques. Our results for the string domain show that Blaze compares favorably with FlashFill, a domain-specific synthesizer that is now deployed in Microsoft PowerShell. In the context of matrix manipulations, we compare Blaze against Prose, a state-of-the-art general-purpose VSA-based synthesizer, and show that Blaze results in a 90x speed-up over Prose. In both application domains, Blaze also consistently improves upon the performance of two other existing techniques by at least an order of magnitude.", - "date": "2017-12-27", + "date": "2018-01-01", "link": "https://doi.org/10.1145/3158151", "conference_name": "POPL", "authors": [ @@ -2071,5 +2038,38 @@ "dblp_key": "journals/pacmpl/WangDS18", "venue": "popl", "year": 2018 + }, + { + "paper_id": "10.1145/3158101", + "title": "Unifying analytic and statically-typed quasiquotes", + "abstract": "Metaprograms are programs that manipulate (generate, analyze and evaluate) other programs. These tasks are greatly facilitated by quasiquotation, a technique to construct and deconstruct program fragments using quoted code templates expressed in the syntax of the manipulated language. We argue that two main flavors of quasiquotes have existed so far: Lisp-style quasiquotes, which can both construct and deconstruct programs but may produce code that contains type mismatches and unbound variables; and MetaML-style quasiquotes, which rely on static typing to prevent these errors, but can only construct programs. In this paper, we show how to combine the advantages of both flavors into a unified framework: we allow the construction, deconstruction and evaluation of program fragments while ensuring that generated programs are well-typed and well-scoped, a combination unseen in previous work. We formalize our approach as λ {} , a multi-stage calculus with code pattern matching and rewriting, and prove its type safety. We also present its realization in Squid, a metaprogramming framework for Scala, leveraging Scala’s expressive type system. To demonstrate the usefulness of our approach, we introduce speculative rewrite rules , a novel code transformation technique that makes decisive use of these capabilities, and we outline how it simplifies the design of some crucial query compiler optimizations.", + "date": "2018-01-01", + "link": "https://doi.org/10.1145/3158101", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Lionel", + "last_name": "Parreaux", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Antoine", + "last_name": "Voizard", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Amir", + "last_name": "Shaikhha", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Christoph", + "last_name": "Koch", + "institution": "École Polytechnique Fédérale de Lausanne" + } + ], + "dblp_key": "journals/pacmpl/ParreauxVSK18", + "venue": "popl", + "year": 2018 } ] \ No newline at end of file diff --git a/data/pl_conferences/popl/2020.json b/data/pl_conferences/popl/2020.json index 0673a88..f949adf 100644 --- a/data/pl_conferences/popl/2020.json +++ b/data/pl_conferences/popl/2020.json @@ -1,80 +1,189 @@ [ { - "paper_id": "10.1145/3371106", - "title": "A simple differentiable programming language", - "abstract": "Automatic differentiation plays a prominent role in scientific computing and in modern machine learning, often in the context of powerful programming systems. The relation of the various embodiments of automatic differentiation to the mathematical notion of derivative is not always entirely clear---discrepancies can arise, sometimes inadvertently. In order to study automatic differentiation in such programming contexts, we define a small but expressive programming language that includes a construct for reverse-mode differentiation. We give operational and denotational semantics for this language. The operational semantics employs popular implementation techniques, while the denotational semantics employs notions of differentiation familiar from real analysis. We establish that these semantics coincide.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371106", + "paper_id": "10.1145/3371077", + "title": "Undecidability of d<: and its decidable fragments", + "abstract": "Dependent Object Types (DOT) is a calculus with path dependent types, intersection types, and object self-references, which serves as the core calculus of Scala 3. Although the calculus has been proven sound, it remains open whether type checking in DOT is decidable. In this paper, we establish undecidability proofs of type checking and subtyping of D <: , a syntactic subset of DOT. It turns out that even for D <: , undecidability is surprisingly difficult to show, as evidenced by counterexamples for past attempts. To prove undecidability, we discover an equivalent definition of the D <: subtyping rules in normal form. Besides being easier to reason about, this definition makes the phenomenon of subtyping reflection explicit as a single inference rule. After removing this rule, we discover two decidable fragments of D <: subtyping and identify algorithms to decide them. We prove soundness and completeness of the algorithms with respect to the fragments, and we prove that the algorithms terminate. Our proofs are mechanized in a combination of Coq and Agda.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371077", "conference_name": "POPL", "authors": [ { - "first_name": "Martı́n", - "last_name": "Abadi", - "institution": "Google (United States)" + "first_name": "Jason Z. S.", + "last_name": "Hu", + "institution": "McGill University" }, { - "first_name": "Gordon", - "last_name": "Plotkin", - "institution": "Google (United States)" + "first_name": "Ondřej", + "last_name": "Lhoták", + "institution": "University of Waterloo" } ], - "dblp_key": "journals/pacmpl/AbadiP20", + "dblp_key": "journals/pacmpl/HuL20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371122", - "title": "Synthesis of coordination programs from linear temporal specifications", - "abstract": "This paper presents a method for synthesizing a reactive program to coordinate the actions of a group of other reactive programs so that the combined system satisfies a temporal specification of its desired long-term behavior. Traditionally, reactive synthesis has been applied to the construction of a stateful hardware circuit. This work is motivated by applications to other domains, such as the IoT (the Internet of Things) and robotics, where it is necessary to coordinate the actions of multiple sensors, devices, and robots to carry out a task. The mathematical model represents each agent as a process in Hoare’s CSP model. Given a network of interacting agents, called an environment , and a temporal specification of long-term behavior, the synthesis method constructs a coordinator process (if one exists) that guides the actions of the environment agents so that the combined system is deadlock-free and satisfies the given specification. The main technical challenge is that a coordinator may have only partial information of the environment state, due to non-determinism within the environment and internal environment actions that are hidden from the coordinator. This is the first method to handle both sources of partial information and to do so for arbitrary linear temporal logic specifications. It is established that the coordination synthesis problem is PSPACE -hard in the size of the environment. A prototype implementation is able to synthesize compact solutions for a number of coordination problems.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371122", + "paper_id": "10.1145/3371098", + "title": "Decomposition diversity with symmetric data and codata", + "abstract": "The expression problem describes a fundamental trade-off in program design: Should a program's primary decomposition be determined by the way its domain objects are constructed (\"functional\" decomposition), or by the way they are destructed (\"object-oriented\" decomposition)? We argue that programming languages should not force one of these decompositions on the programmer; rather, a programming language should support both ways of decomposing a program in a symmetric way, with an easy translation between these decompositions. However, current programming languages are usually not symmetric and hence make it unnecessarily hard to switch the decomposition. We propose a language that is symmetric in this regard and allows a fully automatic translation between \"functional\" and \"object-oriented\" decomposition. We present a language with algebraic data types and pattern matching for \"functional\" decomposition and codata types and copattern matching for \"object-oriented\" decomposition, together with a bijective translation that turns a data type into a codata type (\"destructorization\") or vice versa (\"constructorization\"). We present the first symmetric programming language with support for local (co)pattern matching, which includes local anonymous function or object definitions, that allows an automatic translation as described above. We also present the first mechanical formalization of such a language and prove i) that the type system is sound, that the translations between data and codata types are ii) type-preserving, iii) behavior-preserving and iv) inverses of each other. We also extract a mechanically verified implementation from our formalization and have implemented an IDE with direct support for these translations.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371098", "conference_name": "POPL", "authors": [ { - "first_name": "Suguman", - "last_name": "Bansal", - "institution": "Rice University" + "first_name": "David A.", + "last_name": "Binder", + "institution": "University of Tübingen" }, { - "first_name": "Kedar S.", - "last_name": "Namjoshi", - "institution": "Nokia (United States)" + "first_name": "Julian", + "last_name": "Jabs", + "institution": "University of Tübingen" }, { - "first_name": "Yaniv", - "last_name": "Saʼar", - "institution": "" + "first_name": "Ingo", + "last_name": "Skupin", + "institution": "University of Tübingen" + }, + { + "first_name": "Klaus", + "last_name": "Ostermann", + "institution": "University of Tübingen" } ], - "dblp_key": "journals/pacmpl/BansalNS20", + "dblp_key": "journals/pacmpl/BinderJSO20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371094", - "title": "Parameterized verification under TSO is PSPACE-complete", - "abstract": "We consider parameterized verification of concurrent programs under the Total Store Order (TSO) semantics. A program consists of a set of processes that share a set of variables on which they can perform read and write operations. We show that the reachability problem for a system consisting of an arbitrary number of identical processes is PSPACE-complete. We prove that the complexity is reduced to polynomial time if the processes are not allowed to read the initial values of the variables in the memory. When the processes are allowed to perform atomic read-modify-write operations, the reachability problem has a non-primitive recursive complexity.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371094", + "paper_id": "10.1145/3371087", + "title": "Trace types and denotational semantics for sound programmable inference in probabilistic languages", + "abstract": "Modern probabilistic programming languages aim to formalize and automate key aspects of probabilistic modeling and inference. Many languages provide constructs for programmable inference that enable developers to improve inference speed and accuracy by tailoring an algorithm for use with a particular model or dataset. Unfortunately, it is easy to use these constructs to write unsound programs that appear to run correctly but produce incorrect results. To address this problem, we present a denotational semantics for programmable inference in higher-order probabilistic programming languages, along with a type system that ensures that well-typed inference programs are sound by construction. A central insight is that the type of a probabilistic expression can track the space of its possible execution traces, not just the type of value that it returns, as these traces are often the objects that inference algorithms manipulate. We use our semantics and type system to establish soundness properties of custom inference programs that use constructs for variational, sequential Monte Carlo, importance sampling, and Markov chain Monte Carlo inference.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371087", "conference_name": "POPL", "authors": [ { - "first_name": "Parosh Aziz", - "last_name": "Abdulla", - "institution": "Uppsala University" + "first_name": "Alexander K.", + "last_name": "Lew", + "institution": "Massachusetts Institute of Technology" }, { - "first_name": "Mohamed Faouzi", - "last_name": "Atig", - "institution": "Uppsala University" + "first_name": "Marco", + "last_name": "Cusumano-Towner", + "institution": "Massachusetts Institute of Technology" }, { - "first_name": "Rojin", - "last_name": "Rezvan", - "institution": "Sharif University of Technology" + "first_name": "Benjamin", + "last_name": "Sherman", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Michael", + "last_name": "Carbin", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Vikash K.", + "last_name": "Mansinghka", + "institution": "Massachusetts Institute of Technology" } ], - "dblp_key": "journals/pacmpl/AbdullaAR20", + "dblp_key": "journals/pacmpl/LewCSCM20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371109", + "title": "Stacked borrows: an aliasing model for Rust", + "abstract": "Type systems are useful not just for the safety guarantees they provide, but also for helping compilers generate more efficient code by simplifying important program analyses. In Rust, the type system imposes a strict discipline on pointer aliasing, and it is an express goal of the Rust compiler developers to make use of that alias information for the purpose of program optimizations that reorder memory accesses. The problem is that Rust also supports unsafe code, and programmers can write unsafe code that bypasses the usual compiler checks to violate the aliasing discipline. To strike a balance between optimizations and unsafe code, the language needs to provide a set of rules such that unsafe code authors can be sure, if they are following these rules, that the compiler will preserve the semantics of their code despite all the optimizations it is doing. In this work, we propose Stacked Borrows , an operational semantics for memory accesses in Rust. Stacked Borrows defines an aliasing discipline and declares programs violating it to have undefined behavior , meaning the compiler does not have to consider such programs when performing optimizations. We give formal proofs (mechanized in Coq) showing that this rules out enough programs to enable optimizations that reorder memory accesses around unknown code and function calls, based solely on intraprocedural reasoning. We also implemented this operational model in an interpreter for Rust and ran large parts of the Rust standard library test suite in the interpreter to validate that the model permits enough real-world unsafe Rust code.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371109", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Hoang-Hai", + "last_name": "Dang", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/JungDKD20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371126", + "title": "The fire triangle: how to mix substitution, dependent elimination, and effects", + "abstract": "There is a critical tension between substitution, dependent elimination and effects in type theory. In this paper, we crystallize this tension in the form of a no-go theorem that constitutes the fire triangle of type theory. To release this tension, we propose ∂CBPV, an extension of call-by-push-value (CBPV) —a general calculus of effects—to dependent types. Then, by extending to ∂CBPV the well-known decompositions of call-by-name and call-by-value into CBPV, we show why, in presence of effects, dependent elimination must be restricted in call-by-name, and substitution must be restricted in call-by-value. To justify ∂CBPV and show that it is general enough to interpret many kinds of effects, we define various effectful syntactic translations from ∂CBPV to Martin-Löf type theory: the reader, weaning and forcing translations.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371126", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Pierre-Marie", + "last_name": "Pédrot", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Nicolas", + "last_name": "Tabareau", + "institution": "Institut national de recherche en informatique et en automatique" + } + ], + "dblp_key": "journals/pacmpl/PedrotT20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371103", + "title": "Deciding memory safety for single-pass heap-manipulating programs", + "abstract": "We investigate the decidability of automatic program verification for programs that manipulate heaps, and in particular, decision procedures for proving memory safety for them. We extend recent work that identified a decidable subclass of uninterpreted programs to a class of alias-aware programs that can update maps. We apply this theory to develop verification algorithms for memory safety— determining if a heap-manipulating program that allocates and frees memory locations and manipulates heap pointers does not dereference an unallocated memory location. We show that this problem is decidable when the initial allocated heap forms a forest data-structure and when programs are streaming-coherent , which intuitively restricts programs to make a single pass over a data-structure. Our experimental evaluation on a set of library routines that manipulate forest data-structures shows that common single-pass algorithms on data-structures often fall in the decidable class, and that our decision procedure is efficient in verifying them.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371103", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Umang", + "last_name": "Mathur", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Adithya", + "last_name": "Murali", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Paul", + "last_name": "Krogmeier", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "P.", + "last_name": "Madhusudan", + "institution": "University of Illinois Urbana-Champaign" + }, + { + "first_name": "Mahesh", + "last_name": "Viswanathan", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/MathurMKMV20", "venue": "popl", "year": 2020 }, @@ -82,7 +191,7 @@ "paper_id": "10.1145/3371089", "title": "Relational proofs for quantum programs", "abstract": "Relational verification of quantum programs has many potential applications in quantum and post-quantum security and other domains. We propose a relational program logic for quantum programs. The interpretation of our logic is based on a quantum analogue of probabilistic couplings. We use our logic to verify non-trivial relational properties of quantum programs, including uniformity for samples generated by the quantum Bernoulli factory, reliability of quantum teleportation against noise (bit and phase flip), security of quantum one-time pad and equivalence of quantum walks.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371089", "conference_name": "POPL", "authors": [ @@ -116,11 +225,34 @@ "venue": "popl", "year": 2020 }, + { + "paper_id": "10.1145/3371081", + "title": "Reductions for safety proofs", + "abstract": "Program reductions are used widely to simplify reasoning about the correctness of concurrent and distributed programs. In this paper, we propose a general approach to proof simplification of concurrent programs based on exploring generic classes of reductions. We introduce two classes of sound program reductions, study their theoretical properties, show how they can be effectively used in algorithmic verification, and demonstrate that they are very effective in producing proofs of a diverse class of programs without targeting specific syntactic properties of these programs. The most novel contribution of this paper is the introduction of the concept of context in the definition of program reductions. We demonstrate how commutativity of program steps in some program contexts can be used to define a generic class of sound reductions which can be used to automatically produce proofs for programs whose complete Floyd-Hoare style proofs are theoretically beyond the reach of automated verification technology of today.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371081", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azadeh", + "last_name": "Farzan", + "institution": "University of Toronto" + }, + { + "first_name": "Anthony", + "last_name": "Vandikas", + "institution": "University of Toronto" + } + ], + "dblp_key": "journals/pacmpl/FarzanV20", + "venue": "popl", + "year": 2020 + }, { "paper_id": "10.1145/3371124", "title": "Augmented example-based synthesis using relational perturbation properties", "abstract": "Example-based specifications for program synthesis are inherently ambiguous and may cause synthesizers to generate programs that do not exhibit intended behavior on unseen inputs. Existing synthesis techniques attempt to address this problem by either placing a domain-specific syntactic bias on the hypothesis space or heavily relying on user feedback to help resolve ambiguity. We present a new framework to address the ambiguity/generalizability problem in example-based synthesis. The key feature of our framework is that it places a semantic bias on the hypothesis space using \"relational perturbation properties\" that relate the perturbation/change in a program output to the perturbation/change in a program input. An example of such a property is permutation invariance: the program output does not change when the elements of the program input (array) are permuted. The framework is portable across multiple domains and synthesizers and is based on two core steps: (1) automatically augment the set of user-provided examples by \"applying\" relational perturbation properties and (2) use a generic example-based synthesizer to generate a program consistent with the augmented set of examples. Our framework can be instantiated with three different user interfaces, with varying degrees of user engagement to help infer relevant relational perturbation properties. This includes an interface in which the user only provides examples and our framework automatically infers relevant properties. We implement our framework in a tool SKETCHAX specialized to the SKETCH synthesizer and demonstrate that SKETCHAX is effective in significantly boosting the performance of SKETCH for all three user interfaces.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371124", "conference_name": "POPL", "authors": [ @@ -150,149 +282,160 @@ "year": 2020 }, { - "paper_id": "10.1145/3371116", - "title": "Binders by day, labels by night: effect instances via lexically scoped handlers", - "abstract": "Handlers of algebraic effects aspire to be a practical and robust programming construct that allows one to define, use, and combine different computational effects. Interestingly, a critical problem that still bars the way to their popular adoption is how to combine different uses of the same effect in a program, particularly in a language with a static type-and-effect system. For example, it is rudimentary to define the “mutable memory cell” effect as a pair of operations, put and get , together with a handler, but it is far from obvious how to use this effect a number of times to operate a number of memory cells in a single context. In this paper, we propose a solution based on lexically scoped effects in which each use (an “instance”) of an effect can be singled out by name, bound by an enclosing handler and tracked in the type of the expression. Such a setting proves to be delicate with respect to the choice of semantics, as it depends on the explosive mixture of effects, polymorphism, and reduction under binders. Hence, we devise a novel approach to Kripke-style logical relations that can deal with open terms, which allows us to prove the desired properties of our calculus. We formalise our core results in Coq, and introduce an experimental surface-level programming language to show that our approach is applicable in practice.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371116", + "paper_id": "10.1145/3371134", + "title": "Decidable subtyping for path dependent types", + "abstract": "Path dependent types have long served as an expressive component of the Scala programming language. They allow for the modelling of both bounded polymorphism and a degree of nominal subtyping. Nominality in turn provides the ability to capture first class modules. Thus a single language feature gives rise to a rich array of expressiveness. Recent work has proven path dependent types sound in the presence of both intersection and recursive types, but unfortunately typing remains undecidable, posing problems for programmers who rely on the results of type checkers. The Wyvern programming language is an object oriented language with path dependent types, recursive types and first class modules. In this paper we define two variants of Wyvern that feature decidable typing, along with machine checked proofs of decidability. Despite the restrictions, our approaches retain the ability to encode the parameteric polymorphism of Java generics along with many idioms of the Scala module system.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371134", "conference_name": "POPL", "authors": [ { - "first_name": "Dariusz", - "last_name": "Biernacki", - "institution": "University of Wrocław" + "first_name": "Julian", + "last_name": "Mackay", + "institution": "Victoria University of Wellington" }, { - "first_name": "Maciej", - "last_name": "Piróg", - "institution": "University of Wrocław" + "first_name": "Alex", + "last_name": "Potanin", + "institution": "Victoria University of Wellington" }, { - "first_name": "Piotr", - "last_name": "Polesiuk", - "institution": "University of Wrocław" + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" }, { - "first_name": "Filip", - "last_name": "Sieczkowski", - "institution": "University of Wrocław" + "first_name": "Lindsay", + "last_name": "Groves", + "institution": "Victoria University of Wellington" } ], - "dblp_key": "journals/pacmpl/BiernackiPPS20", + "dblp_key": "journals/pacmpl/MackayPAG20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371075", - "title": "Formal verification of a constant-time preserving C compiler", - "abstract": "Timing side-channels are arguably one of the main sources of vulnerabilities in cryptographic implementations. One effective mitigation against timing side-channels is to write programs that do not perform secret-dependent branches and memory accesses. This mitigation, known as \"cryptographic constant-time\", is adopted by several popular cryptographic libraries. This paper focuses on compilation of cryptographic constant-time programs, and more specifically on the following question: is the code generated by a realistic compiler for a constant-time source program itself provably constant-time? Surprisingly, we answer the question positively for a mildly modified version of the CompCert compiler, a formally verified and moderately optimizing compiler for C. Concretely, we modify the CompCert compiler to eliminate sources of potential leakage. Then, we instrument the operational semantics of CompCert intermediate languages so as to be able to capture cryptographic constant-time. Finally, we prove that the modified CompCert compiler preserves constant-time. Our mechanization maximizes reuse of the CompCert correctness proof, through the use of new proof techniques for proving preservation of constant-time. These techniques achieve complementary trade-offs between generality and tractability of proof effort, and are of independent interest.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371075", + "paper_id": "10.1145/3371123", + "title": "A probabilistic separation logic", + "abstract": "Probabilistic independence is a useful concept for describing the result of random sampling—a basic operation in all probabilistic languages—and for reasoning about groups of random variables. Nevertheless, existing verification methods handle independence poorly, if at all. We propose a probabili stic separation logic PSL, where separation models probabilistic independence. We first give a new, probabilistic model of the logic of bunched implications (BI). We then build a program logic based on these assertions, and prove soundness of the proof system. We demonstrate our logic by verifying information-theoretic security of cryptographic constructions for several well-known tasks, including private information retrieval, oblivious transfer, secure multi-party addition, and simple oblivious RAM. Our proofs reason purely in terms of high-level properties, like independence and uniformity.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371123", "conference_name": "POPL", "authors": [ { "first_name": "Gilles", "last_name": "Barthe", - "institution": "IMDEA Software Institute" + "institution": "IMDEA Software" }, { - "first_name": "Sandrine", - "last_name": "Blazy", - "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" }, { - "first_name": "Benjamin", - "last_name": "Grégoire", - "institution": "Institut national de recherche en sciences et technologies du numérique" - }, + "first_name": "Kevin", + "last_name": "Liao", + "institution": "University of Illinois Urbana-Champaign" + } + ], + "dblp_key": "journals/pacmpl/BartheHL20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371086", + "title": "Par means parallel: multiplicative linear logic proofs as concurrent functional programs", + "abstract": "Along the lines of Abramsky’s “Proofs-as-Processes” program, we present an interpretation of multiplicative linear logic as typing system for concurrent functional programming. In particular, we study a linear multiple-conclusion natural deduction system and show it is isomorphic to a simple and natural extension of λ-calculus with parallelism and communication primitives, called λpar. We shall prove that λpar satisfies all the desirable properties for a typed programming language: subject reduction, progress, strong normalization and confluence.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371086", + "conference_name": "POPL", + "authors": [ { - "first_name": "Rémi", - "last_name": "Hutin", - "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + "first_name": "Federico", + "last_name": "Aschieri", + "institution": "TU Wien" }, { - "first_name": "Vincent", - "last_name": "Laporte", - "institution": "Institut national de recherche en sciences et technologies du numérique" - }, + "first_name": "Francesco A.", + "last_name": "Genco", + "institution": "Institut d'Histoire et de Philosophie des Sciences et des Techniques" + } + ], + "dblp_key": "journals/pacmpl/AschieriG20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371125", + "title": "Semantics of higher-order probabilistic programs with conditioning", + "abstract": "We present a denotational semantics for higher-order probabilistic programs in terms of linear operators between Banach spaces. Our semantics is rooted in the classical theory of Banach spaces and their tensor products, but bears similarities with the well-known semantics of higher-order programs a la Scott through the use of ordered Banach spaces which allow definitions in terms of fixed points. Our semantics is a model of intuitionistic linear logic: it is based on a symmetric monoidal closed category of ordered Banach spaces which treats randomness as a linear resource, but by constructing an exponential comonad we can also accommodate non-linear reasoning. We apply our semantics to the verification of the classical Gibbs sampling algorithm.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371125", + "conference_name": "POPL", + "authors": [ { - "first_name": "David", - "last_name": "Pichardie", - "institution": "Université de Rennes" + "first_name": "Fredrik", + "last_name": "Dahlqvist", + "institution": "Imperial College London" }, { - "first_name": "Alix", - "last_name": "Trieu", - "institution": "Aarhus University" + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" } ], - "dblp_key": "journals/pacmpl/BartheBGHLPT20", + "dblp_key": "journals/pacmpl/DahlqvistK20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371110", - "title": "Abstract interpretation of distributed network control planes", - "abstract": "The control plane of most computer networks runs distributed routing protocols that determine if and how traffic is forwarded. Errors in the configuration of network control planes frequently knock down critical online services, leading to economic damage for service providers and significant hardship for users. Validation via ahead-of-time simulation can help find configuration errors but such techniques are expensive or even intractable for large industrial networks. We explore the use of abstract interpretation to address this fundamental scaling challenge and find that the right abstractions can reduce the asymptotic complexity of network simulation. Based on this observation, we build a tool called ShapeShifter for reachability analysis. On a suite of 127 production networks from a large cloud provider, ShapeShifter provides an asymptotic improvement in runtime and memory over the state-of-the-art simulator. These gains come with a minimal loss in precision. Our abstract analysis accurately predicts reachability for all destinations for 95% of the networks and for most destinations for the remaining 5%. We also find that abstract interpretation of network control planes not only speeds up existing analyses but also facilitates new kinds of analyses. We illustrate this advantage through a new destination \"hijacking\" analysis for the border gateway protocol (BGP), the globally-deployed routing protocol.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371110", + "paper_id": "10.1145/3371122", + "title": "Synthesis of coordination programs from linear temporal specifications", + "abstract": "This paper presents a method for synthesizing a reactive program to coordinate the actions of a group of other reactive programs so that the combined system satisfies a temporal specification of its desired long-term behavior. Traditionally, reactive synthesis has been applied to the construction of a stateful hardware circuit. This work is motivated by applications to other domains, such as the IoT (the Internet of Things) and robotics, where it is necessary to coordinate the actions of multiple sensors, devices, and robots to carry out a task. The mathematical model represents each agent as a process in Hoare’s CSP model. Given a network of interacting agents, called an environment , and a temporal specification of long-term behavior, the synthesis method constructs a coordinator process (if one exists) that guides the actions of the environment agents so that the combined system is deadlock-free and satisfies the given specification. The main technical challenge is that a coordinator may have only partial information of the environment state, due to non-determinism within the environment and internal environment actions that are hidden from the coordinator. This is the first method to handle both sources of partial information and to do so for arbitrary linear temporal logic specifications. It is established that the coordination synthesis problem is PSPACE -hard in the size of the environment. A prototype implementation is able to synthesize compact solutions for a number of coordination problems.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371122", "conference_name": "POPL", "authors": [ { - "first_name": "Ryan", - "last_name": "Beckett", - "institution": "Microsoft (United States)" - }, - { - "first_name": "Aarti", - "last_name": "Gupta", - "institution": "Princeton University" + "first_name": "Suguman", + "last_name": "Bansal", + "institution": "Rice University" }, { - "first_name": "Ratul", - "last_name": "Mahajan", - "institution": "University of Washington" + "first_name": "Kedar S.", + "last_name": "Namjoshi", + "institution": "Nokia (United States)" }, { - "first_name": "David", - "last_name": "Walker", - "institution": "Princeton University" + "first_name": "Yaniv", + "last_name": "Saʼar", + "institution": "" } ], - "dblp_key": "journals/pacmpl/BeckettGMW20", + "dblp_key": "journals/pacmpl/BansalNS20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371099", - "title": "Reduction monads and their signatures", - "abstract": "In this work, we study reduction monads , which are essentially the same as monads relative to the free functor from sets into multigraphs. Reduction monads account for two aspects of the lambda calculus: on the one hand, in the monadic viewpoint, the lambda calculus is an object equipped with a well-behaved substitution; on the other hand, in the graphical viewpoint, it is an oriented multigraph whose vertices are terms and whose edges witness the reductions between two terms. We study presentations of reduction monads. To this end, we propose a notion of reduction signature . As usual, such a signature plays the role of a virtual presentation, and specifies arities for generating operations—possibly subject to equations—together with arities for generating reduction rules. For each such signature, we define a category of models; any model is, in particular, a reduction monad. If the initial object of this category of models exists, we call it the reduction monad presented (or specified) by the given reduction signature . Our main result identifies a class of reduction signatures which specify a reduction monad in the above sense. We show in the examples that our approach covers several standard variants of the lambda calculus.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371099", + "paper_id": "10.1145/3371111", + "title": "Executable formal semantics for the POSIX shell", + "abstract": "The POSIX shell is a widely deployed, powerful tool for managing computer systems. The shell is the expert’s control panel, a necessary tool for configuring, compiling, installing, maintaining, and deploying systems. Even though it is powerful, critical infrastructure, the POSIX shell is maligned and misunderstood. Its power and its subtlety are a dangerous combination. We define a formal, mechanized, executable small-step semantics for the POSIX shell, which we call Smoosh. We compared Smoosh against seven other shells that aim for some measure of POSIX compliance (bash, dash, zsh, OSH, mksh, ksh93, and yash). Using three test suites—the POSIX test suite, the Modernish test suite and shell diagnostic, and a test suite of our own device—we found Smoosh’s semantics to be the most conformant to the POSIX standard. Modernish judges Smoosh to have the fewest bugs (just one, from using dash’s parser) and no quirks. To show that our semantics is useful beyond yielding a conformant, executable shell, we also implemented a symbolic stepper to illuminate the subtle behavior of the shell. Smoosh will serve as a foundation for formal study of the POSIX shell, supporting research on and development of new shells, new tooling for shells, and new shell designs.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371111", "conference_name": "POPL", "authors": [ { - "first_name": "Benedikt", - "last_name": "Ahrens", - "institution": "University of Birmingham" - }, - { - "first_name": "André", - "last_name": "Hirschowitz", - "institution": "Observatoire de la Côte d’Azur" - }, - { - "first_name": "Ambroise", - "last_name": "Lafont", - "institution": "IMT Atlantique" + "first_name": "Michael", + "last_name": "Greenberg", + "institution": "Pomona College" }, { - "first_name": "Marco", - "last_name": "Maggesi", - "institution": "University of Florence" + "first_name": "Austin J.", + "last_name": "Blatt", + "institution": "" } ], - "dblp_key": "journals/pacmpl/AhrensHLM20", + "dblp_key": "journals/pacmpl/GreenbergB20", "venue": "popl", "year": 2020 }, @@ -300,7 +443,7 @@ "paper_id": "10.1145/3371112", "title": "Mechanized semantics and verified compilation for a dataflow synchronous language with reset", "abstract": "Specifications based on block diagrams and state machines are used to design control software, especially in the certified development of safety-critical applications. Tools like SCADE Suite and Simulink/Stateflow are equipped with compilers that translate such specifications into executable code. They provide programming languages for composing functions over streams as typified by Dataflow Synchronous Languages like Lustre. Recent work builds on CompCert to specify and verify a compiler for the core of Lustre in the Coq Interactive Theorem Prover. It formally links the stream-based semantics of the source language to the sequential memory manipulations of generated assembly code. We extend this work to treat a primitive for resetting subsystems. Our contributions include new semantic rules that are suitable for mechanized reasoning, a novel intermediate language for generating optimized code, and proofs of correctness for the associated compilation passes.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371112", "conference_name": "POPL", "authors": [ @@ -325,287 +468,195 @@ "year": 2020 }, { - "paper_id": "10.1145/3371090", - "title": "Seminaïve evaluation for a higher-order functional language", - "abstract": "One of the workhorse techniques for implementing bottom-up Datalog engines is seminaïve evaluation. This optimization improves the performance of Datalog's most distinctive feature: recursively defined predicates. These are computed iteratively, and under a naïve evaluation strategy, each iteration recomputes all previous values. Seminaïve evaluation computes a safe approximation of the difference between iterations. This can asymptotically improve the performance of Datalog queries. Seminaïve evaluation is defined partly as a program transformation and partly as a modified iteration strategy, and takes advantage of the first-order nature of Datalog code. This paper extends the seminaïve transformation to higher-order programs written in the Datafun language, which extends Datalog with features like first-class relations, higher-order functions, and datatypes like sum types.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371090", + "paper_id": "10.1145/3371099", + "title": "Reduction monads and their signatures", + "abstract": "In this work, we study reduction monads , which are essentially the same as monads relative to the free functor from sets into multigraphs. Reduction monads account for two aspects of the lambda calculus: on the one hand, in the monadic viewpoint, the lambda calculus is an object equipped with a well-behaved substitution; on the other hand, in the graphical viewpoint, it is an oriented multigraph whose vertices are terms and whose edges witness the reductions between two terms. We study presentations of reduction monads. To this end, we propose a notion of reduction signature . As usual, such a signature plays the role of a virtual presentation, and specifies arities for generating operations—possibly subject to equations—together with arities for generating reduction rules. For each such signature, we define a category of models; any model is, in particular, a reduction monad. If the initial object of this category of models exists, we call it the reduction monad presented (or specified) by the given reduction signature . Our main result identifies a class of reduction signatures which specify a reduction monad in the above sense. We show in the examples that our approach covers several standard variants of the lambda calculus.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371099", "conference_name": "POPL", "authors": [ { - "first_name": "Michael", - "last_name": "Arntzenius", + "first_name": "Benedikt", + "last_name": "Ahrens", "institution": "University of Birmingham" }, { - "first_name": "Neel", - "last_name": "Krishnaswami", - "institution": "University of Cambridge" - } - ], - "dblp_key": "journals/pacmpl/ArntzeniusK20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371069", - "title": "Taylor subsumes Scott, Berry, Kahn and Plotkin", - "abstract": "The speculative ambition of replacing the old theory of program approximation based on syntactic continuity with the theory of resource consumption based on Taylor expansion and originating from the differential λ-calculus is nowadays at hand. Using this resource sensitive theory, we provide simple proofs of important results in λ-calculus that are usually demonstrated by exploiting Scott’s continuity, Berry’s stability or Kahn and Plotkin’s sequentiality theory. A paradigmatic example is given by the Perpendicular Lines Lemma for the Böhm tree semantics, which is proved here simply by induction, but relying on the main properties of resource approximants: strong normalization, confluence and linearity.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371069", - "conference_name": "POPL", - "authors": [ + "first_name": "André", + "last_name": "Hirschowitz", + "institution": "Observatoire de la Côte d’Azur" + }, { - "first_name": "Davide", - "last_name": "Barbarossa", - "institution": "Université Sorbonne Paris Nord" + "first_name": "Ambroise", + "last_name": "Lafont", + "institution": "IMT Atlantique" }, { - "first_name": "Giulio", - "last_name": "Manzonetto", - "institution": "Université Sorbonne Paris Nord" + "first_name": "Marco", + "last_name": "Maggesi", + "institution": "University of Florence" } ], - "dblp_key": "journals/pacmpl/BarbarossaM20", + "dblp_key": "journals/pacmpl/AhrensHLM20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371098", - "title": "Decomposition diversity with symmetric data and codata", - "abstract": "The expression problem describes a fundamental trade-off in program design: Should a program's primary decomposition be determined by the way its domain objects are constructed (\"functional\" decomposition), or by the way they are destructed (\"object-oriented\" decomposition)? We argue that programming languages should not force one of these decompositions on the programmer; rather, a programming language should support both ways of decomposing a program in a symmetric way, with an easy translation between these decompositions. However, current programming languages are usually not symmetric and hence make it unnecessarily hard to switch the decomposition. We propose a language that is symmetric in this regard and allows a fully automatic translation between \"functional\" and \"object-oriented\" decomposition. We present a language with algebraic data types and pattern matching for \"functional\" decomposition and codata types and copattern matching for \"object-oriented\" decomposition, together with a bijective translation that turns a data type into a codata type (\"destructorization\") or vice versa (\"constructorization\"). We present the first symmetric programming language with support for local (co)pattern matching, which includes local anonymous function or object definitions, that allows an automatic translation as described above. We also present the first mechanical formalization of such a language and prove i) that the type system is sound, that the translations between data and codata types are ii) type-preserving, iii) behavior-preserving and iv) inverses of each other. We also extract a mechanically verified implementation from our formalization and have implemented an IDE with direct support for these translations.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371098", + "paper_id": "10.1145/3371084", + "title": "Towards verified stochastic variational inference for probabilistic programs", + "abstract": "Probabilistic programming is the idea of writing models from statistics and machine learning using program notations and reasoning about these models using generic inference engines. Recently its combination with deep learning has been explored intensely, which led to the development of so called deep probabilistic programming languages, such as Pyro, Edward and ProbTorch. At the core of this development lie inference engines based on stochastic variational inference algorithms. When asked to find information about the posterior distribution of a model written in such a language, these algorithms convert this posterior-inference query into an optimisation problem and solve it approximately by a form of gradient ascent or descent. In this paper, we analyse one of the most fundamental and versatile variational inference algorithms, called score estimator or REINFORCE, using tools from denotational semantics and program analysis. We formally express what this algorithm does on models denoted by programs, and expose implicit assumptions made by the algorithm on the models. The violation of these assumptions may lead to an undefined optimisation objective or the loss of convergence guarantee of the optimisation process. We then describe rules for proving these assumptions, which can be automated by static program analyses. Some of our rules use nontrivial facts from continuous mathematics, and let us replace requirements about integrals in the assumptions, such as integrability of functions defined in terms of programs' denotations, by conditions involving differentiation or boundedness, which are much easier to prove automatically (and manually). Following our general methodology, we have developed a static program analysis for the Pyro programming language that aims at discharging the assumption about what we call model-guide support match. Our analysis is applied to the eight representative model-guide pairs from the Pyro webpage, which include sophisticated neural network models such as AIR. It finds a bug in one of these cases, reveals a non-standard use of an inference engine in another, and shows that the assumptions are met in the remaining six cases.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371084", "conference_name": "POPL", "authors": [ { - "first_name": "David A.", - "last_name": "Binder", - "institution": "University of Tübingen" + "first_name": "Wonyeol", + "last_name": "Lee", + "institution": "Korea Advanced Institute of Science and Technology" }, { - "first_name": "Julian", - "last_name": "Jabs", - "institution": "University of Tübingen" + "first_name": "Hangyeol", + "last_name": "Yu", + "institution": "Korea Advanced Institute of Science and Technology" }, { - "first_name": "Ingo", - "last_name": "Skupin", - "institution": "University of Tübingen" + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Université Paris Sciences et Lettres" }, { - "first_name": "Klaus", - "last_name": "Ostermann", - "institution": "University of Tübingen" + "first_name": "Hongseok", + "last_name": "Yang", + "institution": "Korea Advanced Institute of Science and Technology" } ], - "dblp_key": "journals/pacmpl/BinderJSO20", + "dblp_key": "journals/pacmpl/LeeYRY20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371086", - "title": "Par means parallel: multiplicative linear logic proofs as concurrent functional programs", - "abstract": "Along the lines of Abramsky’s “Proofs-as-Processes” program, we present an interpretation of multiplicative linear logic as typing system for concurrent functional programming. In particular, we study a linear multiple-conclusion natural deduction system and show it is isomorphic to a simple and natural extension of λ-calculus with parallelism and communication primitives, called λpar. We shall prove that λpar satisfies all the desirable properties for a typed programming language: subject reduction, progress, strong normalization and confluence.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371086", + "paper_id": "10.1145/3371074", + "title": "Actris: session-type based reasoning in separation logic", + "abstract": "Message passing is a useful abstraction to implement concurrent programs. For real-world systems, however, it is often combined with other programming and concurrency paradigms, such as higher-order functions, mutable state, shared-memory concurrency, and locks. We present Actris: a logic for proving functional correctness of programs that use a combination of the aforementioned features. Actris combines the power of modern concurrent separation logics with a first-class protocol mechanism—based on session types—for reasoning about message passing in the presence of other concurrency paradigms. We show that Actris provides a suitable level of abstraction by proving functional correctness of a variety of examples, including a distributed merge sort, a distributed load-balancing mapper, and a variant of the map-reduce model, using relatively simple specifications. Soundness of Actris is proved using a model of its protocol mechanism in the Iris framework. We mechanised the theory of Actris, together with tactics for symbolic execution of programs, as well as all examples in the paper, in the Coq proof assistant.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371074", "conference_name": "POPL", "authors": [ { - "first_name": "Federico", - "last_name": "Aschieri", - "institution": "TU Wien" + "first_name": "Jonas Kastberg", + "last_name": "Hinrichsen", + "institution": "IT University of Copenhagen" }, { - "first_name": "Francesco A.", - "last_name": "Genco", - "institution": "Institut d'Histoire et de Philosophie des Sciences et des Techniques" + "first_name": "Jesper", + "last_name": "Bengtson", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" } ], - "dblp_key": "journals/pacmpl/AschieriG20", + "dblp_key": "journals/pacmpl/HinrichsenBK20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371123", - "title": "A probabilistic separation logic", - "abstract": "Probabilistic independence is a useful concept for describing the result of random sampling—a basic operation in all probabilistic languages—and for reasoning about groups of random variables. Nevertheless, existing verification methods handle independence poorly, if at all. We propose a probabili stic separation logic PSL, where separation models probabilistic independence. We first give a new, probabilistic model of the logic of bunched implications (BI). We then build a program logic based on these assertions, and prove soundness of the proof system. We demonstrate our logic by verifying information-theoretic security of cryptographic constructions for several well-known tasks, including private information retrieval, oblivious transfer, secure multi-party addition, and simple oblivious RAM. Our proofs reason purely in terms of high-level properties, like independence and uniformity.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371123", + "paper_id": "10.1145/3371096", + "title": "Abstract extensionality: on the properties of incomplete abstract interpretations", + "abstract": "In this paper we generalise the notion of extensional (functional) equivalence of programs to abstract equivalences induced by abstract interpretations . The standard notion of extensional equivalence is recovered as the special case, induced by the concrete interpretation. Some properties of the extensional equivalence, such as the one spelled out in Rice’s theorem, lift to the abstract equivalences in suitably generalised forms. On the other hand, the generalised framework gives rise to interesting and important new properties, and allows refined, non-extensional analyses. In particular, since programs turn out to be extensionally equivalent if and only if they are equivalent just for the concrete interpretation, it follows that any non-trivial abstract interpretation uncovers some intensional aspect of programs. This striking result is also effective, in the sense that it allows constructing, for any non-trivial abstraction, a pair of programs that are extensionally equivalent, but have different abstract semantics. The construction is based on the fact that abstract interpretations are always sound, but that they can be made incomplete through suitable code transformations. To construct these transformations, we introduce a novel technique for building incompleteness cliques of extensionally equivalent yet abstractly distinguishable programs: They are built together with abstract interpretations that produce false alarms. While programs are forced into incompleteness cliques using both control-flow and data-flow transformations, the main result follows from limitations of data-flow transformations with respect to control-flow ones. A further consequence is that the class of incomplete programs for a non-trivial abstraction is Turing complete. The obtained results also shed a new light on the relation between the techniques of code obfuscation and the precision in program analysis.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371096", "conference_name": "POPL", "authors": [ { - "first_name": "Gilles", - "last_name": "Barthe", + "first_name": "Roberto", + "last_name": "Bruni", + "institution": "University of Pisa" + }, + { + "first_name": "Roberto", + "last_name": "Giacobazzi", "institution": "IMDEA Software" }, { - "first_name": "Justin", - "last_name": "Hsu", - "institution": "University of Wisconsin–Madison" + "first_name": "Roberta", + "last_name": "Gori", + "institution": "University of Pisa" }, { - "first_name": "Kevin", - "last_name": "Liao", - "institution": "University of Illinois Urbana-Champaign" - } - ], - "dblp_key": "journals/pacmpl/BartheHL20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371132", - "title": "Backpropagation in the simply typed lambda-calculus with linear negation", - "abstract": "Backpropagation is a classic automatic differentiation algorithm computing the gradient of functions specified by a certain class of simple, first-order programs, called computational graphs. It is a fundamental tool in several fields, most notably machine learning, where it is the key for efficiently training (deep) neural networks. Recent years have witnessed the quick growth of a research field called differentiable programming, the aim of which is to express computational graphs more synthetically and modularly by resorting to actual programming languages endowed with control flow operators and higher-order combinators, such as map and fold. In this paper, we extend the backpropagation algorithm to a paradigmatic example of such a programming language: we define a compositional program transformation from the simply-typed lambda-calculus to itself augmented with a notion of linear negation, and prove that this computes the gradient of the source program with the same efficiency as first-order backpropagation. The transformation is completely effect-free and thus provides a purely logical understanding of the dynamics of backpropagation.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371132", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Aloïs", - "last_name": "Brunel", - "institution": "" - }, - { - "first_name": "Damiano", - "last_name": "Mazza", - "institution": "Centre National de la Recherche Scientifique" - }, - { - "first_name": "Michele", - "last_name": "Pagani", - "institution": "Université Paris Cité" - } - ], - "dblp_key": "journals/pacmpl/BrunelMP20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371125", - "title": "Semantics of higher-order probabilistic programs with conditioning", - "abstract": "We present a denotational semantics for higher-order probabilistic programs in terms of linear operators between Banach spaces. Our semantics is rooted in the classical theory of Banach spaces and their tensor products, but bears similarities with the well-known semantics of higher-order programs a la Scott through the use of ordered Banach spaces which allow definitions in terms of fixed points. Our semantics is a model of intuitionistic linear logic: it is based on a symmetric monoidal closed category of ordered Banach spaces which treats randomness as a linear resource, but by constructing an exponential comonad we can also accommodate non-linear reasoning. We apply our semantics to the verification of the classical Gibbs sampling algorithm.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371125", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Fredrik", - "last_name": "Dahlqvist", - "institution": "Imperial College London" - }, - { - "first_name": "Dexter", - "last_name": "Kozen", - "institution": "Cornell University" - } - ], - "dblp_key": "journals/pacmpl/DahlqvistK20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371071", - "title": "Dependent type systems as macros", - "abstract": "We present Turnstile+, a high-level, macros-based metaDSL for building dependently typed languages. With it, programmers may rapidly prototype and iterate on the design of new dependently typed features and extensions. Or they may create entirely new DSLs whose dependent type ``power'' is tailored to a specific domain. Our framework's support of language-oriented programming also makes it suitable for experimenting with systems of interacting components, e.g., a proof assistant and its companion DSLs. This paper explains the implementation details of Turnstile+, as well as how it may be used to create a wide-variety of dependently typed languages, from a lightweight one with indexed types, to a full spectrum proof assistant, complete with a tactic system and extensions for features like sized types and SMT interaction.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371071", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Stephen", - "last_name": "Chang", - "institution": "Northeastern University" - }, - { - "first_name": "Michael", - "last_name": "Ballantyne", - "institution": "Northeastern University" - }, - { - "first_name": "Milo", - "last_name": "Turner", - "institution": "Northeastern University" + "first_name": "Isabel", + "last_name": "Garcia-Contreras", + "institution": "Universidad Politécnica de Madrid" }, { - "first_name": "William J.", - "last_name": "Bowman", - "institution": "University of British Columbia" + "first_name": "Duško", + "last_name": "Pavlović", + "institution": "University of Hawaii System" } ], - "dblp_key": "journals/pacmpl/ChangBTB20", + "dblp_key": "journals/pacmpl/BruniGGGP20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371096", - "title": "Abstract extensionality: on the properties of incomplete abstract interpretations", - "abstract": "In this paper we generalise the notion of extensional (functional) equivalence of programs to abstract equivalences induced by abstract interpretations . The standard notion of extensional equivalence is recovered as the special case, induced by the concrete interpretation. Some properties of the extensional equivalence, such as the one spelled out in Rice’s theorem, lift to the abstract equivalences in suitably generalised forms. On the other hand, the generalised framework gives rise to interesting and important new properties, and allows refined, non-extensional analyses. In particular, since programs turn out to be extensionally equivalent if and only if they are equivalent just for the concrete interpretation, it follows that any non-trivial abstract interpretation uncovers some intensional aspect of programs. This striking result is also effective, in the sense that it allows constructing, for any non-trivial abstraction, a pair of programs that are extensionally equivalent, but have different abstract semantics. The construction is based on the fact that abstract interpretations are always sound, but that they can be made incomplete through suitable code transformations. To construct these transformations, we introduce a novel technique for building incompleteness cliques of extensionally equivalent yet abstractly distinguishable programs: They are built together with abstract interpretations that produce false alarms. While programs are forced into incompleteness cliques using both control-flow and data-flow transformations, the main result follows from limitations of data-flow transformations with respect to control-flow ones. A further consequence is that the class of incomplete programs for a non-trivial abstraction is Turing complete. The obtained results also shed a new light on the relation between the techniques of code obfuscation and the precision in program analysis.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371096", + "paper_id": "10.1145/3371095", + "title": "The weak call-by-value λ-calculus is reasonable for both time and space", + "abstract": "We study the weak call-by-value λ-calculus as a model for computational complexity theory and establish the natural measures for time and space — the number of beta-reduction steps and the size of the largest term in a computation — as reasonable measures with respect to the invariance thesis of Slot and van Emde Boas from 1984. More precisely, we show that, using those measures, Turing machines and the weak call-by-value λ-calculus can simulate each other within a polynomial overhead in time and a constant factor overhead in space for all computations terminating in (encodings of) ”true” or ”false”. The simulation yields that standard complexity classes like P , NP , PSPACE , or EXP can be defined solely in terms of the λ-calculus, but does not cover sublinear time or space. Note that our measures still have the well-known size explosion property, where the space measure of a computation can be exponentially bigger than its time measure. However, our result implies that this exponential gap disappears once complexity classes are considered instead of concrete computations. We consider this result a first step towards a solution for the long-standing open problem of whether the natural measures for time and space of the λ-calculus are reasonable. Our proof for the weak call-by-value λ-calculus is the first proof of reasonability (including both time and space) for a functional language based on natural measures and enables the formal verification of complexity-theoretic proofs concerning complexity classes, both on paper and in proof assistants. The proof idea relies on a hybrid of two simulation strategies of reductions in the weak call-by-value λ-calculus by Turing machines, both of which are insufficient if taken alone. The first strategy is the most naive one in the sense that a reduction sequence is simulated precisely as given by the reduction rules; in particular, all substitutions are executed immediately. This simulation runs within a constant overhead in space, but the overhead in time might be exponential. The second strategy is heap-based and relies on structure sharing, similar to existing compilers of eager functional languages. This strategy only has a polynomial overhead in time, but the space consumption might require an additional factor of log n , which is essentially due to the size of the pointers required for this strategy. Our main contribution is the construction and verification of a space-aware interleaving of the two strategies, which is shown to yield both a constant overhead in space and a polynomial overhead in time.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371095", "conference_name": "POPL", "authors": [ { - "first_name": "Roberto", - "last_name": "Bruni", - "institution": "University of Pisa" - }, - { - "first_name": "Roberto", - "last_name": "Giacobazzi", - "institution": "IMDEA Software" - }, - { - "first_name": "Roberta", - "last_name": "Gori", - "institution": "University of Pisa" + "first_name": "Yannick", + "last_name": "Forster", + "institution": "Saarland University" }, { - "first_name": "Isabel", - "last_name": "Garcia-Contreras", - "institution": "Universidad Politécnica de Madrid" + "first_name": "Fabian", + "last_name": "Kunze", + "institution": "Saarland University" }, { - "first_name": "Duško", - "last_name": "Pavlović", - "institution": "University of Hawaii System" + "first_name": "Marc", + "last_name": "Roth", + "institution": "Saarland University" } ], - "dblp_key": "journals/pacmpl/BruniGGGP20", + "dblp_key": "journals/pacmpl/ForsterKR20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371073", - "title": "Complexity and information in invariant inference", - "abstract": "This paper addresses the complexity of SAT-based invariant inference, a prominent approach to safety verification. We consider the problem of inferring an inductive invariant of polynomial length given a transition system and a safety property. We analyze the complexity of this problem in a black-box model, called the Hoare-query model, which is general enough to capture algorithms such as IC3/PDR and its variants. An algorithm in this model learns about the system's reachable states by querying the validity of Hoare triples. We show that in general an algorithm in the Hoare-query model requires an exponential number of queries. Our lower bound is information-theoretic and applies even to computationally unrestricted algorithms, showing that no choice of generalization from the partial information obtained in a polynomial number of Hoare queries can lead to an efficient invariant inference procedure in this class. We then show, for the first time, that by utilizing rich Hoare queries, as done in PDR, inference can be exponentially more efficient than approaches such as ICE learning, which only utilize inductiveness checks of candidates. We do so by constructing a class of transition systems for which a simple version of PDR with a single frame infers invariants in a polynomial number of queries, whereas every algorithm using only inductiveness checks and counterexamples requires an exponential number of queries. Our results also shed light on connections and differences with the classical theory of exact concept learning with queries, and imply that learning from counterexamples to induction is harder than classical exact learning from labeled examples. This demonstrates that the convergence rate of Counterexample-Guided Inductive Synthesis depends on the form of counterexamples.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371073", + "paper_id": "10.1145/3371116", + "title": "Binders by day, labels by night: effect instances via lexically scoped handlers", + "abstract": "Handlers of algebraic effects aspire to be a practical and robust programming construct that allows one to define, use, and combine different computational effects. Interestingly, a critical problem that still bars the way to their popular adoption is how to combine different uses of the same effect in a program, particularly in a language with a static type-and-effect system. For example, it is rudimentary to define the “mutable memory cell” effect as a pair of operations, put and get , together with a handler, but it is far from obvious how to use this effect a number of times to operate a number of memory cells in a single context. In this paper, we propose a solution based on lexically scoped effects in which each use (an “instance”) of an effect can be singled out by name, bound by an enclosing handler and tracked in the type of the expression. Such a setting proves to be delicate with respect to the choice of semantics, as it depends on the explosive mixture of effects, polymorphism, and reduction under binders. Hence, we devise a novel approach to Kripke-style logical relations that can deal with open terms, which allows us to prove the desired properties of our calculus. We formalise our core results in Coq, and introduce an experimental surface-level programming language to show that our approach is applicable in practice.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371116", "conference_name": "POPL", "authors": [ { - "first_name": "Yotam M. Y.", - "last_name": "Feldman", - "institution": "Tel Aviv University" + "first_name": "Dariusz", + "last_name": "Biernacki", + "institution": "University of Wrocław" }, { - "first_name": "Neil", - "last_name": "Immerman", - "institution": "University of Massachusetts Boston" + "first_name": "Maciej", + "last_name": "Piróg", + "institution": "University of Wrocław" }, { - "first_name": "Mooly", - "last_name": "Sagiv", - "institution": "Tel Aviv University" + "first_name": "Piotr", + "last_name": "Polesiuk", + "institution": "University of Wrocław" }, { - "first_name": "Sharon", - "last_name": "Shoham", - "institution": "Tel Aviv University" + "first_name": "Filip", + "last_name": "Sieczkowski", + "institution": "University of Wrocław" } ], - "dblp_key": "journals/pacmpl/FeldmanISS20", + "dblp_key": "journals/pacmpl/BiernackiPPS20", "venue": "popl", "year": 2020 }, @@ -613,7 +664,7 @@ "paper_id": "10.1145/3371070", "title": "Deductive verification with ghost monitors", "abstract": "We present a new approach to deductive program verification based on auxiliary programs called ghost monitors . This technique is useful when the syntactic structure of the target program is not well suited for verification, for example, when an essentially recursive algorithm is implemented in an iterative fashion. Our approach consists in implementing, specifying, and verifying an auxiliary program that monitors the execution of the target program, in such a way that the correctness of the monitor entails the correctness of the target. The ghost monitor maintains the necessary data and invariants to facilitate the proof. It can be implemented and verified in any suitable framework, which does not have to be related to the language of the target programs. This technique is also applicable when we want to establish relational properties between two target programs written in different languages and having different syntactic structure. We then show how ghost monitors can be used to specify and prove fine-grained properties about the infinite behaviors of target programs. Since this cannot be easily done using existing verification frameworks, we introduce a dedicated language for ghost monitors, with an original construction to catch and handle divergent executions. The soundness of the underlying program logic is established using a particular flavor of transfinite games. This language and its soundness are formalized and mechanically checked.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371070", "conference_name": "POPL", "authors": [ @@ -637,34 +688,11 @@ "venue": "popl", "year": 2020 }, - { - "paper_id": "10.1145/3371111", - "title": "Executable formal semantics for the POSIX shell", - "abstract": "The POSIX shell is a widely deployed, powerful tool for managing computer systems. The shell is the expert’s control panel, a necessary tool for configuring, compiling, installing, maintaining, and deploying systems. Even though it is powerful, critical infrastructure, the POSIX shell is maligned and misunderstood. Its power and its subtlety are a dangerous combination. We define a formal, mechanized, executable small-step semantics for the POSIX shell, which we call Smoosh. We compared Smoosh against seven other shells that aim for some measure of POSIX compliance (bash, dash, zsh, OSH, mksh, ksh93, and yash). Using three test suites—the POSIX test suite, the Modernish test suite and shell diagnostic, and a test suite of our own device—we found Smoosh’s semantics to be the most conformant to the POSIX standard. Modernish judges Smoosh to have the fewest bugs (just one, from using dash’s parser) and no quirks. To show that our semantics is useful beyond yielding a conformant, executable shell, we also implemented a symbolic stepper to illuminate the subtle behavior of the shell. Smoosh will serve as a foundation for formal study of the POSIX shell, supporting research on and development of new shells, new tooling for shells, and new shell designs.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371111", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Michael", - "last_name": "Greenberg", - "institution": "Pomona College" - }, - { - "first_name": "Austin J.", - "last_name": "Blatt", - "institution": "" - } - ], - "dblp_key": "journals/pacmpl/GreenbergB20", - "venue": "popl", - "year": 2020 - }, { "paper_id": "10.1145/3371105", "title": "Aiming low is harder: induction for lower bounds in probabilistic program verification", "abstract": "We present a new inductive rule for verifying lower bounds on expected values of random variables after execution of probabilistic loops as well as on their expected runtimes. Our rule is simple in the sense that loop body semantics need to be applied only finitely often in order to verify that the candidates are indeed lower bounds. In particular, it is not necessary to find the limit of a sequence as in many previous rules.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371105", "conference_name": "POPL", "authors": [ @@ -694,165 +722,71 @@ "year": 2020 }, { - "paper_id": "10.1145/3371131", - "title": "Full abstraction for the quantum lambda-calculus", - "abstract": "Quantum programming languages permit a hardware independent, high-level description of quantum algorithms. In particular, the quantum λ-calculus is a higher-order language with quantum primitives, mixing quantum data and classical control. Giving satisfactory denotational semantics to the quantum λ-calculus is a challenging problem that has attracted significant interest. In the past few years, both static (the quantum relational model) and dynamic (quantum game semantics) denotational models were given, with matching computational adequacy results. However, no model was known to be fully abstract. Our first contribution is a full abstraction result for the games model of the quantum λ-calculus. Full abstraction holds with respect to an observational quotient of strategies, obtained by summing valuations of all states matching a given observable. Our proof method for full abstraction extends a technique recently introduced to prove full abstraction for probabilistic coherence spaces with respect to probabilistic PCF. Our second contribution is an interpretation-preserving functor from quantum games to the quantum relational model, extending a long line of work on connecting static and dynamic denotational models. From this, it follows that the quantum relational model is fully abstract as well. Altogether, this gives a complete denotational landscape for the semantics of the quantum λ-calculus, with static and dynamic models related by a clean functorial correspondence, and both fully abstract.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371131", + "paper_id": "10.1145/3371082", + "title": "Deterministic parallel fixpoint computation", + "abstract": "Abstract interpretation is a general framework for expressing static program analyses. It reduces the problem of extracting properties of a program to computing an approximation of the least fixpoint of a system of equations. The de facto approach for computing this approximation uses a sequential algorithm based on weak topological order (WTO). This paper presents a deterministic parallel algorithm for fixpoint computation by introducing the notion of weak partial order (WPO). We present an algorithm for constructing a WPO in almost-linear time. Finally, we describe Pikos, our deterministic parallel abstract interpreter, which extends the sequential abstract interpreter IKOS. We evaluate the performance and scalability of Pikos on a suite of 1017 C programs. When using 4 cores, Pikos achieves an average speedup of 2.06x over IKOS, with a maximum speedup of 3.63x. When using 16 cores, Pikos achieves a maximum speedup of 10.97x.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371082", "conference_name": "POPL", "authors": [ { - "first_name": "Pierre", - "last_name": "Clairambault", - "institution": "Université Claude Bernard Lyon 1" + "first_name": "Sung Kook", + "last_name": "Kim", + "institution": "University of California, Davis" }, { - "first_name": "Marc de", - "last_name": "Visme", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Arnaud J.", + "last_name": "Venet", + "institution": "Meta (United States)" + }, + { + "first_name": "Aditya V.", + "last_name": "Thakur", + "institution": "University of California, Davis" } ], - "dblp_key": "journals/pacmpl/ClairambaultV20", + "dblp_key": "journals/pacmpl/KimVT20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371080", - "title": "Program synthesis by type-guided abstraction refinement", - "abstract": "We consider the problem of type-directed component-based synthesis where, given a set of (typed) components and a query type , the goal is to synthesize a term that inhabits the query. Classical approaches based on proof search in intuitionistic logics do not scale up to the standard libraries of modern languages, which span hundreds or thousands of components. Recent graph reachability based methods proposed for Java do scale, but only apply to monomorphic data and components: polymorphic data and components infinitely explode the size of the graph that must be searched, rendering synthesis intractable. We introduce type-guided abstraction refinement (TYGAR), a new approach for scalable type-directed synthesis over polymorphic datatypes and components. Our key insight is that we can overcome the explosion by building a graph over abstract types which represent a potentially unbounded set of concrete types. We show how to use graph reachability to search for candidate terms over abstract types, and introduce a new algorithm that uses proofs of untypeability of ill-typed candidates to iteratively refine the abstraction until a well-typed result is found. We have implemented TYGAR in H+, a tool that takes as input a set of Haskell libraries and a query type, and returns a Haskell term that uses functions from the provided libraries to implement the query type. Our support for polymorphism allows H+ to work with higher-order functions and type classes, and enables more precise queries due to parametricity. We have evaluated H+ on 44 queries using a set of popular Haskell libraries with a total of 291 components. H+ returns an interesting solution within the first five results for 32 out of 44 queries. Our results show that TYGAR allows H+ to rapidly return well-typed terms, with the median time to first solution of just 1.4 seconds. Moreover, we observe that gains from iterative refinement over exhaustive enumeration are more pronounced on harder queries.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371080", + "paper_id": "10.1145/3371118", + "title": "A language for probabilistically oblivious computation", + "abstract": "An oblivious computation is one that is free of direct and indirect information leaks, e.g., due to observable differences in timing and memory access patterns. This paper presents Lambda Obliv, a core language whose type system enforces obliviousness. Prior work on type-enforced oblivious computation has focused on deterministic programs. Lambda Obliv is new in its consideration of programs that implement probabilistic algorithms, such as those involved in cryptography. Lambda Obliv employs a substructural type system and a novel notion of probability region to ensure that information is not leaked via the observed distribution of visible events. Probability regions support reasoning about probabilistic correlation and independence between values, and our use of probability regions is motivated by a source of unsoundness that we discovered in the type system of ObliVM, a language for implementing state of the art oblivious algorithms. We prove that Lambda Obliv's type system enforces obliviousness and show that it is expressive enough to typecheck advanced tree-based oblivious RAMs.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371118", "conference_name": "POPL", "authors": [ - { - "first_name": "Zheng", - "last_name": "Guo", - "institution": "University of California, San Diego" - }, - { - "first_name": "Michael B.", - "last_name": "James", - "institution": "University of California, San Diego" - }, { "first_name": "David", - "last_name": "Justo", - "institution": "University of California, San Diego" - }, - { - "first_name": "Jiaxiao", - "last_name": "Zhou", - "institution": "University of California, San Diego" + "last_name": "Darais", + "institution": "University of Vermont" }, { - "first_name": "Ziteng", - "last_name": "Wang", - "institution": "University of California, San Diego" + "first_name": "Ian", + "last_name": "Sweet", + "institution": "University of Maryland, College Park" }, { - "first_name": "Ranjit", - "last_name": "Jhala", - "institution": "University of California, San Diego" + "first_name": "Chang", + "last_name": "Liu", + "institution": "Citadel" }, { - "first_name": "Nadia", - "last_name": "Polikarpova", - "institution": "University of California, San Diego" - } - ], - "dblp_key": "journals/pacmpl/GuoJJZWJP20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371081", - "title": "Reductions for safety proofs", - "abstract": "Program reductions are used widely to simplify reasoning about the correctness of concurrent and distributed programs. In this paper, we propose a general approach to proof simplification of concurrent programs based on exploring generic classes of reductions. We introduce two classes of sound program reductions, study their theoretical properties, show how they can be effectively used in algorithmic verification, and demonstrate that they are very effective in producing proofs of a diverse class of programs without targeting specific syntactic properties of these programs. The most novel contribution of this paper is the introduction of the concept of context in the definition of program reductions. We demonstrate how commutativity of program steps in some program contexts can be used to define a generic class of sound reductions which can be used to automatically produce proofs for programs whose complete Floyd-Hoare style proofs are theoretically beyond the reach of automated verification technology of today.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371081", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Azadeh", - "last_name": "Farzan", - "institution": "University of Toronto" - }, - { - "first_name": "Anthony", - "last_name": "Vandikas", - "institution": "University of Toronto" - } - ], - "dblp_key": "journals/pacmpl/FarzanV20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371118", - "title": "A language for probabilistically oblivious computation", - "abstract": "An oblivious computation is one that is free of direct and indirect information leaks, e.g., due to observable differences in timing and memory access patterns. This paper presents Lambda Obliv, a core language whose type system enforces obliviousness. Prior work on type-enforced oblivious computation has focused on deterministic programs. Lambda Obliv is new in its consideration of programs that implement probabilistic algorithms, such as those involved in cryptography. Lambda Obliv employs a substructural type system and a novel notion of probability region to ensure that information is not leaked via the observed distribution of visible events. Probability regions support reasoning about probabilistic correlation and independence between values, and our use of probability regions is motivated by a source of unsoundness that we discovered in the type system of ObliVM, a language for implementing state of the art oblivious algorithms. We prove that Lambda Obliv's type system enforces obliviousness and show that it is expressive enough to typecheck advanced tree-based oblivious RAMs.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371118", - "conference_name": "POPL", - "authors": [ - { - "first_name": "David", - "last_name": "Darais", - "institution": "University of Vermont" - }, - { - "first_name": "Ian", - "last_name": "Sweet", - "institution": "University of Maryland, College Park" - }, - { - "first_name": "Chang", - "last_name": "Liu", - "institution": "Citadel" - }, - { - "first_name": "Michael", - "last_name": "Hicks", - "institution": "University of Maryland, College Park" + "first_name": "Michael", + "last_name": "Hicks", + "institution": "University of Maryland, College Park" } ], "dblp_key": "journals/pacmpl/DaraisSLH20", "venue": "popl", "year": 2020 }, - { - "paper_id": "10.1145/3371095", - "title": "The weak call-by-value λ-calculus is reasonable for both time and space", - "abstract": "We study the weak call-by-value λ-calculus as a model for computational complexity theory and establish the natural measures for time and space — the number of beta-reduction steps and the size of the largest term in a computation — as reasonable measures with respect to the invariance thesis of Slot and van Emde Boas from 1984. More precisely, we show that, using those measures, Turing machines and the weak call-by-value λ-calculus can simulate each other within a polynomial overhead in time and a constant factor overhead in space for all computations terminating in (encodings of) ”true” or ”false”. The simulation yields that standard complexity classes like P , NP , PSPACE , or EXP can be defined solely in terms of the λ-calculus, but does not cover sublinear time or space. Note that our measures still have the well-known size explosion property, where the space measure of a computation can be exponentially bigger than its time measure. However, our result implies that this exponential gap disappears once complexity classes are considered instead of concrete computations. We consider this result a first step towards a solution for the long-standing open problem of whether the natural measures for time and space of the λ-calculus are reasonable. Our proof for the weak call-by-value λ-calculus is the first proof of reasonability (including both time and space) for a functional language based on natural measures and enables the formal verification of complexity-theoretic proofs concerning complexity classes, both on paper and in proof assistants. The proof idea relies on a hybrid of two simulation strategies of reductions in the weak call-by-value λ-calculus by Turing machines, both of which are insufficient if taken alone. The first strategy is the most naive one in the sense that a reduction sequence is simulated precisely as given by the reduction rules; in particular, all substitutions are executed immediately. This simulation runs within a constant overhead in space, but the overhead in time might be exponential. The second strategy is heap-based and relies on structure sharing, similar to existing compilers of eager functional languages. This strategy only has a polynomial overhead in time, but the space consumption might require an additional factor of log n , which is essentially due to the size of the pointers required for this strategy. Our main contribution is the construction and verification of a space-aware interleaving of the two strategies, which is shown to yield both a constant overhead in space and a polynomial overhead in time.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371095", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Yannick", - "last_name": "Forster", - "institution": "Saarland University" - }, - { - "first_name": "Fabian", - "last_name": "Kunze", - "institution": "Saarland University" - }, - { - "first_name": "Marc", - "last_name": "Roth", - "institution": "Saarland University" - } - ], - "dblp_key": "journals/pacmpl/ForsterKR20", - "venue": "popl", - "year": 2020 - }, { "paper_id": "10.1145/3371092", "title": "Liquidate your assets: reasoning about resource usage in liquid Haskell", "abstract": "Liquid Haskell is an extension to the type system of Haskell that supports formal reasoning about program correctness by encoding logical properties as refinement types. In this article, we show how Liquid Haskell can also be used to reason about program efficiency in the same setting. We use the system's existing verification machinery to ensure that the results of our cost analysis are valid, together with custom invariants for particular program contexts to ensure that the results of our analysis are precise. To illustrate our approach, we analyse the efficiency of a wide range of popular data structures and algorithms, and in doing so, explore various notions of resource usage. Our experience is that reasoning about efficiency in Liquid Haskell is often just as simple as reasoning about correctness, and that the two can naturally be combined.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371092", "conference_name": "POPL", "authors": [ @@ -877,386 +811,375 @@ "year": 2020 }, { - "paper_id": "10.1145/3371074", - "title": "Actris: session-type based reasoning in separation logic", - "abstract": "Message passing is a useful abstraction to implement concurrent programs. For real-world systems, however, it is often combined with other programming and concurrency paradigms, such as higher-order functions, mutable state, shared-memory concurrency, and locks. We present Actris: a logic for proving functional correctness of programs that use a combination of the aforementioned features. Actris combines the power of modern concurrent separation logics with a first-class protocol mechanism—based on session types—for reasoning about message passing in the presence of other concurrency paradigms. We show that Actris provides a suitable level of abstraction by proving functional correctness of a variety of examples, including a distributed merge sort, a distributed load-balancing mapper, and a variant of the map-reduce model, using relatively simple specifications. Soundness of Actris is proved using a model of its protocol mechanism in the Iris framework. We mechanised the theory of Actris, together with tactics for symbolic execution of programs, as well as all examples in the paper, in the Coq proof assistant.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371074", + "paper_id": "10.1145/3371132", + "title": "Backpropagation in the simply typed lambda-calculus with linear negation", + "abstract": "Backpropagation is a classic automatic differentiation algorithm computing the gradient of functions specified by a certain class of simple, first-order programs, called computational graphs. It is a fundamental tool in several fields, most notably machine learning, where it is the key for efficiently training (deep) neural networks. Recent years have witnessed the quick growth of a research field called differentiable programming, the aim of which is to express computational graphs more synthetically and modularly by resorting to actual programming languages endowed with control flow operators and higher-order combinators, such as map and fold. In this paper, we extend the backpropagation algorithm to a paradigmatic example of such a programming language: we define a compositional program transformation from the simply-typed lambda-calculus to itself augmented with a notion of linear negation, and prove that this computes the gradient of the source program with the same efficiency as first-order backpropagation. The transformation is completely effect-free and thus provides a purely logical understanding of the dynamics of backpropagation.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371132", "conference_name": "POPL", "authors": [ { - "first_name": "Jonas Kastberg", - "last_name": "Hinrichsen", - "institution": "IT University of Copenhagen" + "first_name": "Aloïs", + "last_name": "Brunel", + "institution": "" }, { - "first_name": "Jesper", - "last_name": "Bengtson", - "institution": "IT University of Copenhagen" + "first_name": "Damiano", + "last_name": "Mazza", + "institution": "Centre National de la Recherche Scientifique" }, { - "first_name": "Robbert", - "last_name": "Krebbers", - "institution": "Delft University of Technology" + "first_name": "Michele", + "last_name": "Pagani", + "institution": "Université Paris Cité" } ], - "dblp_key": "journals/pacmpl/HinrichsenBK20", + "dblp_key": "journals/pacmpl/BrunelMP20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371102", - "title": "RustBelt meets relaxed memory", - "abstract": "The Rust programming language supports safe systems programming by means of a strong ownership-tracking type system. In their prior work on RustBelt, Jung et al. began the task of setting Rust’s safety claims on a more rigorous formal foundation. Specifically, they used Iris, a Coq-based separation logic framework, to build a machine-checked proof of semantic soundness for a λ-calculus model of Rust, as well as for a number of widely-used Rust libraries that internally employ unsafe language features. However, they also made the significant simplifying assumption that the language is sequentially consistent. In this paper, we adapt RustBelt to account for the relaxed-memory operations that concurrent Rust libraries actually use, in the process uncovering a data race in the Arc library. We focus on the most interesting technical problem: how to reason about resource reclamation under relaxed memory , using a logical construction we call synchronized ghost state .", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371102", + "paper_id": "10.1145/3371083", + "title": "Recurrence extraction for functional programs through call-by-push-value", + "abstract": "The main way of analysing the complexity of a program is that of extracting and solving a recurrence that expresses its running time in terms of the size of its input. We develop a method that automatically extracts such recurrences from the syntax of higher-order recursive functional programs. The resulting recurrences, which are programs in a call-by-name language with recursion, explicitly compute the running time in terms of the size of the input. In order to achieve this in a uniform way that covers both call-by-name and call-by-value evaluation strategies, we use Call-by-Push-Value (CBPV) as an intermediate language. Finally, we use domain theory to develop a denotational cost semantics for the resulting recurrences.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371083", "conference_name": "POPL", "authors": [ { - "first_name": "Hoang-Hai", - "last_name": "Dang", - "institution": "Max Planck Institute for Software Systems" + "first_name": "G. A.", + "last_name": "Kavvos", + "institution": "Wesleyan University" }, { - "first_name": "Jacques-Henri", - "last_name": "Jourdan", - "institution": "Laboratoire de Recherche en Informatique" + "first_name": "Edward", + "last_name": "Morehouse", + "institution": "Wesleyan University" }, { - "first_name": "Jan-Oliver", - "last_name": "Kaiser", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Daniel R.", + "last_name": "Licata", + "institution": "Wesleyan University" }, { - "first_name": "Derek", - "last_name": "Dreyer", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Norman", + "last_name": "Danner", + "institution": "Wesleyan University" } ], - "dblp_key": "journals/pacmpl/DangJKD20", + "dblp_key": "journals/pacmpl/KavvosMLD20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371077", - "title": "Undecidability of d<: and its decidable fragments", - "abstract": "Dependent Object Types (DOT) is a calculus with path dependent types, intersection types, and object self-references, which serves as the core calculus of Scala 3. Although the calculus has been proven sound, it remains open whether type checking in DOT is decidable. In this paper, we establish undecidability proofs of type checking and subtyping of D <: , a syntactic subset of DOT. It turns out that even for D <: , undecidability is surprisingly difficult to show, as evidenced by counterexamples for past attempts. To prove undecidability, we discover an equivalent definition of the D <: subtyping rules in normal form. Besides being easier to reason about, this definition makes the phenomenon of subtyping reflection explicit as a single inference rule. After removing this rule, we discover two decidable fragments of D <: subtyping and identify algorithms to decide them. We prove soundness and completeness of the algorithms with respect to the fragments, and we prove that the algorithms terminate. Our proofs are mechanized in a combination of Coq and Agda.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371077", + "paper_id": "10.1145/3371131", + "title": "Full abstraction for the quantum lambda-calculus", + "abstract": "Quantum programming languages permit a hardware independent, high-level description of quantum algorithms. In particular, the quantum λ-calculus is a higher-order language with quantum primitives, mixing quantum data and classical control. Giving satisfactory denotational semantics to the quantum λ-calculus is a challenging problem that has attracted significant interest. In the past few years, both static (the quantum relational model) and dynamic (quantum game semantics) denotational models were given, with matching computational adequacy results. However, no model was known to be fully abstract. Our first contribution is a full abstraction result for the games model of the quantum λ-calculus. Full abstraction holds with respect to an observational quotient of strategies, obtained by summing valuations of all states matching a given observable. Our proof method for full abstraction extends a technique recently introduced to prove full abstraction for probabilistic coherence spaces with respect to probabilistic PCF. Our second contribution is an interpretation-preserving functor from quantum games to the quantum relational model, extending a long line of work on connecting static and dynamic denotational models. From this, it follows that the quantum relational model is fully abstract as well. Altogether, this gives a complete denotational landscape for the semantics of the quantum λ-calculus, with static and dynamic models related by a clean functorial correspondence, and both fully abstract.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371131", "conference_name": "POPL", "authors": [ { - "first_name": "Jason Z. S.", - "last_name": "Hu", - "institution": "McGill University" + "first_name": "Pierre", + "last_name": "Clairambault", + "institution": "Université Claude Bernard Lyon 1" }, { - "first_name": "Ondřej", - "last_name": "Lhoták", - "institution": "University of Waterloo" + "first_name": "Marc de", + "last_name": "Visme", + "institution": "Centre National de la Recherche Scientifique" } ], - "dblp_key": "journals/pacmpl/HuL20", + "dblp_key": "journals/pacmpl/ClairambaultV20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371127", - "title": "SyTeCi: automating contextual equivalence for higher-order programs with references", - "abstract": "We propose a framework to study contextual equivalence of programs written in a call-by-value functional language with local integer references. It reduces the problem of contextual equivalence to the problem of non-reachability in a transition system of memory configurations. This reduction is complete for recursion-free programs. Restricting to programs that do not allocate references inside the body of functions, we encode this non-reachability problem as a set of constrained Horn clause that can then be checked for satisfiability automatically. Restricting furthermore to a language with finite data-types, we also get a new decidability result for contextual equivalence at any type.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371127", + "paper_id": "10.1145/3371069", + "title": "Taylor subsumes Scott, Berry, Kahn and Plotkin", + "abstract": "The speculative ambition of replacing the old theory of program approximation based on syntactic continuity with the theory of resource consumption based on Taylor expansion and originating from the differential λ-calculus is nowadays at hand. Using this resource sensitive theory, we provide simple proofs of important results in λ-calculus that are usually demonstrated by exploiting Scott’s continuity, Berry’s stability or Kahn and Plotkin’s sequentiality theory. A paradigmatic example is given by the Perpendicular Lines Lemma for the Böhm tree semantics, which is proved here simply by induction, but relying on the main properties of resource approximants: strong normalization, confluence and linearity.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371069", "conference_name": "POPL", "authors": [ { - "first_name": "Guilhem", - "last_name": "Jaber", - "institution": "Laboratoire des Sciences du Numérique de Nantes" + "first_name": "Davide", + "last_name": "Barbarossa", + "institution": "Université Sorbonne Paris Nord" + }, + { + "first_name": "Giulio", + "last_name": "Manzonetto", + "institution": "Université Sorbonne Paris Nord" } ], - "dblp_key": "journals/pacmpl/Jaber20", + "dblp_key": "journals/pacmpl/BarbarossaM20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371108", - "title": "Partial type constructors: or, making ad hoc datatypes less ad hoc", - "abstract": "Functional programming languages assume that type constructors are total. Yet functional programmers know better: counterexamples range from container types that make limiting assumptions about their contents (e.g., requiring computable equality or ordering functions) to type families with defining equations only over certain choices of arguments. We present a language design and formal theory of partial type constructors, capturing the domains of type constructors using qualified types. Our design is both simple and expressive: we support partial datatypes as first-class citizens (including as instances of parametric abstractions, such as the Haskell Functor and Monad classes), and show a simple type elaboration algorithm that avoids placing undue annotation burden on programmers. We show that our type system rejects ill-defined types and can be compiled to a semantic model based on System F. Finally, we have conducted an experimental analysis of a body of Haskell code, using a proof-of-concept implementation of our system; while there are cases where our system requires additional annotations, these cases are rarely encountered in practical Haskell code.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371108", + "paper_id": "10.1145/3371072", + "title": "The next 700 relational program logics", + "abstract": "We propose the first framework for defining relational program logics for arbitrary monadic effects. The framework is embedded within a relational dependent type theory and is highly expressive. At the semantic level, we provide an algebraic presentation of relational specifications as a class of relative monads, and link computations and specifications by introducing relational effect observations, which map pairs of monadic computations to relational specifications in a way that respects the algebraic structure. For an arbitrary relational effect observation, we generically define the core of a sound relational program logic, and explain how to complete it to a full-fledged logic for the monadic effect at hand. We show that this generic framework can be used to define relational program logics for effects as diverse as state, input-output, nondeterminism, and discrete probabilities. We, moreover, show that by instantiating our framework with state and unbounded iteration we can embed a variant of Benton's Relational Hoare Logic, and also sketch how to reconstruct Relational Hoare Type Theory. Finally, we identify and overcome conceptual challenges that prevented previous relational program logics from properly dealing with control effects, and are the first to provide a relational program logic for exceptions.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371072", "conference_name": "POPL", "authors": [ { - "first_name": "Mark P.", - "last_name": "Jones", - "institution": "Portland State University" + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Institut national de recherche en informatique et en automatique" }, { - "first_name": "J. Garrett", - "last_name": "Morris", - "institution": "University of Kansas" + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "State Key Laboratory of Cryptology" }, { - "first_name": "Richard A.", - "last_name": "Eisenberg", - "institution": "Bryn Mawr College" - } - ], - "dblp_key": "journals/pacmpl/JonesME20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371097", - "title": "What is decidable about gradual types?", - "abstract": "Programmers can use gradual types to migrate programs to have more precise type annotations and thereby improve their readability, efficiency, and safety. Such migration requires an exploration of the migration space and can benefit from tool support, as shown in previous work. Our goal is to provide a foundation for better tool support by settling decidability questions about migration with gradual types. We present three algorithms and a hardness result for deciding key properties and we explain how they can be useful during an exploration. In particular, we show how to decide whether the migration space is finite, whether it has a top element, and whether it is a singleton. We also show that deciding whether it has a maximal element is NP-hard. Our implementation of our algorithms worked as expected on a suite of microbenchmarks.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371097", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Zeina", - "last_name": "Migeed", - "institution": "University of California, Los Angeles" + "first_name": "Exequiel", + "last_name": "Rivas", + "institution": "Institut national de recherche en informatique et en automatique" }, { - "first_name": "Jens", - "last_name": "Palsberg", - "institution": "University of California, Los Angeles" + "first_name": "Antoine Van", + "last_name": "Muylder", + "institution": "Institut national de recherche en informatique et en automatique" } ], - "dblp_key": "journals/pacmpl/MigeedP20", + "dblp_key": "journals/pacmpl/MaillardHRM20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371109", - "title": "Stacked borrows: an aliasing model for Rust", - "abstract": "Type systems are useful not just for the safety guarantees they provide, but also for helping compilers generate more efficient code by simplifying important program analyses. In Rust, the type system imposes a strict discipline on pointer aliasing, and it is an express goal of the Rust compiler developers to make use of that alias information for the purpose of program optimizations that reorder memory accesses. The problem is that Rust also supports unsafe code, and programmers can write unsafe code that bypasses the usual compiler checks to violate the aliasing discipline. To strike a balance between optimizations and unsafe code, the language needs to provide a set of rules such that unsafe code authors can be sure, if they are following these rules, that the compiler will preserve the semantics of their code despite all the optimizations it is doing. In this work, we propose Stacked Borrows , an operational semantics for memory accesses in Rust. Stacked Borrows defines an aliasing discipline and declares programs violating it to have undefined behavior , meaning the compiler does not have to consider such programs when performing optimizations. We give formal proofs (mechanized in Coq) showing that this rules out enough programs to enable optimizations that reorder memory accesses around unknown code and function calls, based solely on intraprocedural reasoning. We also implemented this operational model in an interpreter for Rust and ran large parts of the Rust standard library test suite in the interpreter to validate that the model permits enough real-world unsafe Rust code.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371109", + "paper_id": "10.1145/3371080", + "title": "Program synthesis by type-guided abstraction refinement", + "abstract": "We consider the problem of type-directed component-based synthesis where, given a set of (typed) components and a query type , the goal is to synthesize a term that inhabits the query. Classical approaches based on proof search in intuitionistic logics do not scale up to the standard libraries of modern languages, which span hundreds or thousands of components. Recent graph reachability based methods proposed for Java do scale, but only apply to monomorphic data and components: polymorphic data and components infinitely explode the size of the graph that must be searched, rendering synthesis intractable. We introduce type-guided abstraction refinement (TYGAR), a new approach for scalable type-directed synthesis over polymorphic datatypes and components. Our key insight is that we can overcome the explosion by building a graph over abstract types which represent a potentially unbounded set of concrete types. We show how to use graph reachability to search for candidate terms over abstract types, and introduce a new algorithm that uses proofs of untypeability of ill-typed candidates to iteratively refine the abstraction until a well-typed result is found. We have implemented TYGAR in H+, a tool that takes as input a set of Haskell libraries and a query type, and returns a Haskell term that uses functions from the provided libraries to implement the query type. Our support for polymorphism allows H+ to work with higher-order functions and type classes, and enables more precise queries due to parametricity. We have evaluated H+ on 44 queries using a set of popular Haskell libraries with a total of 291 components. H+ returns an interesting solution within the first five results for 32 out of 44 queries. Our results show that TYGAR allows H+ to rapidly return well-typed terms, with the median time to first solution of just 1.4 seconds. Moreover, we observe that gains from iterative refinement over exhaustive enumeration are more pronounced on harder queries.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371080", "conference_name": "POPL", "authors": [ { - "first_name": "Ralf", - "last_name": "Jung", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Zheng", + "last_name": "Guo", + "institution": "University of California, San Diego" }, { - "first_name": "Hoang-Hai", - "last_name": "Dang", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Michael B.", + "last_name": "James", + "institution": "University of California, San Diego" }, { - "first_name": "Jeehoon", - "last_name": "Kang", - "institution": "Korea Advanced Institute of Science and Technology" - }, - { - "first_name": "Derek", - "last_name": "Dreyer", - "institution": "Max Planck Institute for Software Systems" - } - ], - "dblp_key": "journals/pacmpl/JungDKD20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371133", - "title": "Does blame shifting work?", - "abstract": "Contract systems, especially of the higher-order flavor, go hand in hand with blame. The pragmatic purpose of blame is to narrow down the code that a programmer needs to examine to locate the bug when the contract system discovers a contract violation. Or so the literature on higher-order contracts claims. In reality, however, there is neither empirical nor theoretical evidence that connects blame with the location of bugs. The reputation of blame as a tool for weeding out bugs rests on anecdotes about how programmers use contracts to shift blame and their attention from one part of a program to another until they discover the source of the problem. This paper aims to fill the apparent gap and shed light to the relation between blame and bugs. To that end, we introduce an empirical methodology for investigating whether, for a given contract system, it is possible to translate blame information to the location of bugs in a systematic manner. Our methodology is inspired by how programmers attempt to increase the precision of the contracts of a blamed component in order to shift blame to another component, which becomes the next candidate for containing the bug. In particular, we construct a framework that enables us to ask for a contract system whether (i) the process of blame shifting causes blame to eventually settle to the component that contains the bug; and (ii) every shift moves blame ``closer'' to the faulty component. Our methodology offers a rigorous means for evaluating the pragmatics of contract systems, and we employ it to analyze Racket's contract system. Along the way, we uncover subtle points about the pragmatic meaning of contracts and blame in Racket: (i) the expressiveness of Racket's off-the-shelf contract language is not sufficient to narrow down the blamed portion of the code to the faulty component in all cases; and (ii) contracts that trigger state changes (even unexpectedly, perhaps in the runtime system's data structures or caches) interfere with program evaluation in subtle ways and thus blame shifting can lead programmers on a detour when searching for a bug. These points highlight how evaluations such as ours suggest fixes to language design.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371133", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Lukas", - "last_name": "Lazarek", - "institution": "Northwestern University" + "first_name": "David", + "last_name": "Justo", + "institution": "University of California, San Diego" }, { - "first_name": "Alexis", - "last_name": "King", - "institution": "Northwestern University" + "first_name": "Jiaxiao", + "last_name": "Zhou", + "institution": "University of California, San Diego" }, { - "first_name": "Samanvitha", - "last_name": "Sundar", - "institution": "Northwestern University" + "first_name": "Ziteng", + "last_name": "Wang", + "institution": "University of California, San Diego" }, { - "first_name": "Robert Bruce", - "last_name": "Findler", - "institution": "Northwestern University" + "first_name": "Ranjit", + "last_name": "Jhala", + "institution": "University of California, San Diego" }, { - "first_name": "Christos", - "last_name": "Dimoulas", - "institution": "Northwestern University" + "first_name": "Nadia", + "last_name": "Polikarpova", + "institution": "University of California, San Diego" } ], - "dblp_key": "journals/pacmpl/LazarekKSFD20", + "dblp_key": "journals/pacmpl/GuoJJZWJP20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371083", - "title": "Recurrence extraction for functional programs through call-by-push-value", - "abstract": "The main way of analysing the complexity of a program is that of extracting and solving a recurrence that expresses its running time in terms of the size of its input. We develop a method that automatically extracts such recurrences from the syntax of higher-order recursive functional programs. The resulting recurrences, which are programs in a call-by-name language with recursion, explicitly compute the running time in terms of the size of the input. In order to achieve this in a uniform way that covers both call-by-name and call-by-value evaluation strategies, we use Call-by-Push-Value (CBPV) as an intermediate language. Finally, we use domain theory to develop a denotational cost semantics for the resulting recurrences.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371083", + "paper_id": "10.1145/3371071", + "title": "Dependent type systems as macros", + "abstract": "We present Turnstile+, a high-level, macros-based metaDSL for building dependently typed languages. With it, programmers may rapidly prototype and iterate on the design of new dependently typed features and extensions. Or they may create entirely new DSLs whose dependent type ``power'' is tailored to a specific domain. Our framework's support of language-oriented programming also makes it suitable for experimenting with systems of interacting components, e.g., a proof assistant and its companion DSLs. This paper explains the implementation details of Turnstile+, as well as how it may be used to create a wide-variety of dependently typed languages, from a lightweight one with indexed types, to a full spectrum proof assistant, complete with a tactic system and extensions for features like sized types and SMT interaction.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371071", "conference_name": "POPL", "authors": [ { - "first_name": "G. A.", - "last_name": "Kavvos", - "institution": "Wesleyan University" + "first_name": "Stephen", + "last_name": "Chang", + "institution": "Northeastern University" }, { - "first_name": "Edward", - "last_name": "Morehouse", - "institution": "Wesleyan University" + "first_name": "Michael", + "last_name": "Ballantyne", + "institution": "Northeastern University" }, { - "first_name": "Daniel R.", - "last_name": "Licata", - "institution": "Wesleyan University" + "first_name": "Milo", + "last_name": "Turner", + "institution": "Northeastern University" }, { - "first_name": "Norman", - "last_name": "Danner", - "institution": "Wesleyan University" + "first_name": "William J.", + "last_name": "Bowman", + "institution": "University of British Columbia" } ], - "dblp_key": "journals/pacmpl/KavvosMLD20", + "dblp_key": "journals/pacmpl/ChangBTB20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371072", - "title": "The next 700 relational program logics", - "abstract": "We propose the first framework for defining relational program logics for arbitrary monadic effects. The framework is embedded within a relational dependent type theory and is highly expressive. At the semantic level, we provide an algebraic presentation of relational specifications as a class of relative monads, and link computations and specifications by introducing relational effect observations, which map pairs of monadic computations to relational specifications in a way that respects the algebraic structure. For an arbitrary relational effect observation, we generically define the core of a sound relational program logic, and explain how to complete it to a full-fledged logic for the monadic effect at hand. We show that this generic framework can be used to define relational program logics for effects as diverse as state, input-output, nondeterminism, and discrete probabilities. We, moreover, show that by instantiating our framework with state and unbounded iteration we can embed a variant of Benton's Relational Hoare Logic, and also sketch how to reconstruct Relational Hoare Type Theory. Finally, we identify and overcome conceptual challenges that prevented previous relational program logics from properly dealing with control effects, and are the first to provide a relational program logic for exceptions.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371072", + "paper_id": "10.1145/3371113", + "title": "The future is ours: prophecy variables in separation logic", + "abstract": "Early in the development of Hoare logic, Owicki and Gries introduced auxiliary variables as a way of encoding information about the history of a program’s execution that is useful for verifying its correctness. Over a decade later, Abadi and Lamport observed that it is sometimes also necessary to know in advance what a program will do in the future . To address this need, they proposed prophecy variables , originally as a proof technique for refinement mappings between state machines. However, despite the fact that prophecy variables are a clearly useful reasoning mechanism, there is (surprisingly) almost no work that attempts to integrate them into Hoare logic. In this paper, we present the first account of prophecy variables in a Hoare-style program logic that is flexible enough to verify logical atomicity (a relative of linearizability) for classic examples from the concurrency literature like RDCSS and the Herlihy-Wing queue. Our account is formalized in the Iris framework for separation logic in Coq. It makes essential use of ownership to encode the exclusive right to resolve a prophecy, which in turn enables us to enforce soundness of prophecies with a very simple set of proof rules.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371113", "conference_name": "POPL", "authors": [ { - "first_name": "Kenji", - "last_name": "Maillard", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Ralf", + "last_name": "Jung", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Cătălin", - "last_name": "Hriţcu", - "institution": "State Key Laboratory of Cryptology" + "first_name": "Rodolphe", + "last_name": "Lepigre", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Exequiel", - "last_name": "Rivas", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "G.", + "last_name": "Parthasarathy", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Antoine Van", - "last_name": "Muylder", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Marianna", + "last_name": "Rapoport", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Amin", + "last_name": "Timany", + "institution": "KU Leuven" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Bart", + "last_name": "Jacobs", + "institution": "KU Leuven" } ], - "dblp_key": "journals/pacmpl/MaillardHRM20", + "dblp_key": "journals/pacmpl/JungLPRTDJ20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371082", - "title": "Deterministic parallel fixpoint computation", - "abstract": "Abstract interpretation is a general framework for expressing static program analyses. It reduces the problem of extracting properties of a program to computing an approximation of the least fixpoint of a system of equations. The de facto approach for computing this approximation uses a sequential algorithm based on weak topological order (WTO). This paper presents a deterministic parallel algorithm for fixpoint computation by introducing the notion of weak partial order (WPO). We present an algorithm for constructing a WPO in almost-linear time. Finally, we describe Pikos, our deterministic parallel abstract interpreter, which extends the sequential abstract interpreter IKOS. We evaluate the performance and scalability of Pikos on a suite of 1017 C programs. When using 4 cores, Pikos achieves an average speedup of 2.06x over IKOS, with a maximum speedup of 3.63x. When using 16 cores, Pikos achieves a maximum speedup of 10.97x.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371082", + "paper_id": "10.1145/3371133", + "title": "Does blame shifting work?", + "abstract": "Contract systems, especially of the higher-order flavor, go hand in hand with blame. The pragmatic purpose of blame is to narrow down the code that a programmer needs to examine to locate the bug when the contract system discovers a contract violation. Or so the literature on higher-order contracts claims. In reality, however, there is neither empirical nor theoretical evidence that connects blame with the location of bugs. The reputation of blame as a tool for weeding out bugs rests on anecdotes about how programmers use contracts to shift blame and their attention from one part of a program to another until they discover the source of the problem. This paper aims to fill the apparent gap and shed light to the relation between blame and bugs. To that end, we introduce an empirical methodology for investigating whether, for a given contract system, it is possible to translate blame information to the location of bugs in a systematic manner. Our methodology is inspired by how programmers attempt to increase the precision of the contracts of a blamed component in order to shift blame to another component, which becomes the next candidate for containing the bug. In particular, we construct a framework that enables us to ask for a contract system whether (i) the process of blame shifting causes blame to eventually settle to the component that contains the bug; and (ii) every shift moves blame ``closer'' to the faulty component. Our methodology offers a rigorous means for evaluating the pragmatics of contract systems, and we employ it to analyze Racket's contract system. Along the way, we uncover subtle points about the pragmatic meaning of contracts and blame in Racket: (i) the expressiveness of Racket's off-the-shelf contract language is not sufficient to narrow down the blamed portion of the code to the faulty component in all cases; and (ii) contracts that trigger state changes (even unexpectedly, perhaps in the runtime system's data structures or caches) interfere with program evaluation in subtle ways and thus blame shifting can lead programmers on a detour when searching for a bug. These points highlight how evaluations such as ours suggest fixes to language design.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371133", "conference_name": "POPL", "authors": [ { - "first_name": "Sung Kook", - "last_name": "Kim", - "institution": "University of California, Davis" + "first_name": "Lukas", + "last_name": "Lazarek", + "institution": "Northwestern University" }, { - "first_name": "Arnaud J.", - "last_name": "Venet", - "institution": "Meta (United States)" + "first_name": "Alexis", + "last_name": "King", + "institution": "Northwestern University" }, { - "first_name": "Aditya V.", - "last_name": "Thakur", - "institution": "University of California, Davis" + "first_name": "Samanvitha", + "last_name": "Sundar", + "institution": "Northwestern University" + }, + { + "first_name": "Robert Bruce", + "last_name": "Findler", + "institution": "Northwestern University" + }, + { + "first_name": "Christos", + "last_name": "Dimoulas", + "institution": "Northwestern University" } ], - "dblp_key": "journals/pacmpl/KimVT20", + "dblp_key": "journals/pacmpl/LazarekKSFD20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371134", - "title": "Decidable subtyping for path dependent types", - "abstract": "Path dependent types have long served as an expressive component of the Scala programming language. They allow for the modelling of both bounded polymorphism and a degree of nominal subtyping. Nominality in turn provides the ability to capture first class modules. Thus a single language feature gives rise to a rich array of expressiveness. Recent work has proven path dependent types sound in the presence of both intersection and recursive types, but unfortunately typing remains undecidable, posing problems for programmers who rely on the results of type checkers. The Wyvern programming language is an object oriented language with path dependent types, recursive types and first class modules. In this paper we define two variants of Wyvern that feature decidable typing, along with machine checked proofs of decidability. Despite the restrictions, our approaches retain the ability to encode the parameteric polymorphism of Java generics along with many idioms of the Scala module system.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371134", + "paper_id": "10.1145/3371110", + "title": "Abstract interpretation of distributed network control planes", + "abstract": "The control plane of most computer networks runs distributed routing protocols that determine if and how traffic is forwarded. Errors in the configuration of network control planes frequently knock down critical online services, leading to economic damage for service providers and significant hardship for users. Validation via ahead-of-time simulation can help find configuration errors but such techniques are expensive or even intractable for large industrial networks. We explore the use of abstract interpretation to address this fundamental scaling challenge and find that the right abstractions can reduce the asymptotic complexity of network simulation. Based on this observation, we build a tool called ShapeShifter for reachability analysis. On a suite of 127 production networks from a large cloud provider, ShapeShifter provides an asymptotic improvement in runtime and memory over the state-of-the-art simulator. These gains come with a minimal loss in precision. Our abstract analysis accurately predicts reachability for all destinations for 95% of the networks and for most destinations for the remaining 5%. We also find that abstract interpretation of network control planes not only speeds up existing analyses but also facilitates new kinds of analyses. We illustrate this advantage through a new destination \"hijacking\" analysis for the border gateway protocol (BGP), the globally-deployed routing protocol.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371110", "conference_name": "POPL", "authors": [ { - "first_name": "Julian", - "last_name": "Mackay", - "institution": "Victoria University of Wellington" + "first_name": "Ryan", + "last_name": "Beckett", + "institution": "Microsoft (United States)" }, { - "first_name": "Alex", - "last_name": "Potanin", - "institution": "Victoria University of Wellington" + "first_name": "Aarti", + "last_name": "Gupta", + "institution": "Princeton University" }, { - "first_name": "Jonathan", - "last_name": "Aldrich", - "institution": "Carnegie Mellon University" + "first_name": "Ratul", + "last_name": "Mahajan", + "institution": "University of Washington" }, { - "first_name": "Lindsay", - "last_name": "Groves", - "institution": "Victoria University of Wellington" + "first_name": "David", + "last_name": "Walker", + "institution": "Princeton University" } ], - "dblp_key": "journals/pacmpl/MackayPAG20", + "dblp_key": "journals/pacmpl/BeckettGMW20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371084", - "title": "Towards verified stochastic variational inference for probabilistic programs", - "abstract": "Probabilistic programming is the idea of writing models from statistics and machine learning using program notations and reasoning about these models using generic inference engines. Recently its combination with deep learning has been explored intensely, which led to the development of so called deep probabilistic programming languages, such as Pyro, Edward and ProbTorch. At the core of this development lie inference engines based on stochastic variational inference algorithms. When asked to find information about the posterior distribution of a model written in such a language, these algorithms convert this posterior-inference query into an optimisation problem and solve it approximately by a form of gradient ascent or descent. In this paper, we analyse one of the most fundamental and versatile variational inference algorithms, called score estimator or REINFORCE, using tools from denotational semantics and program analysis. We formally express what this algorithm does on models denoted by programs, and expose implicit assumptions made by the algorithm on the models. The violation of these assumptions may lead to an undefined optimisation objective or the loss of convergence guarantee of the optimisation process. We then describe rules for proving these assumptions, which can be automated by static program analyses. Some of our rules use nontrivial facts from continuous mathematics, and let us replace requirements about integrals in the assumptions, such as integrability of functions defined in terms of programs' denotations, by conditions involving differentiation or boundedness, which are much easier to prove automatically (and manually). Following our general methodology, we have developed a static program analysis for the Pyro programming language that aims at discharging the assumption about what we call model-guide support match. Our analysis is applied to the eight representative model-guide pairs from the Pyro webpage, which include sophisticated neural network models such as AIR. It finds a bug in one of these cases, reveals a non-standard use of an inference engine in another, and shows that the assumptions are met in the remaining six cases.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371084", + "paper_id": "10.1145/3371102", + "title": "RustBelt meets relaxed memory", + "abstract": "The Rust programming language supports safe systems programming by means of a strong ownership-tracking type system. In their prior work on RustBelt, Jung et al. began the task of setting Rust’s safety claims on a more rigorous formal foundation. Specifically, they used Iris, a Coq-based separation logic framework, to build a machine-checked proof of semantic soundness for a λ-calculus model of Rust, as well as for a number of widely-used Rust libraries that internally employ unsafe language features. However, they also made the significant simplifying assumption that the language is sequentially consistent. In this paper, we adapt RustBelt to account for the relaxed-memory operations that concurrent Rust libraries actually use, in the process uncovering a data race in the Arc library. We focus on the most interesting technical problem: how to reason about resource reclamation under relaxed memory , using a logical construction we call synchronized ghost state .", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371102", "conference_name": "POPL", "authors": [ { - "first_name": "Wonyeol", - "last_name": "Lee", - "institution": "Korea Advanced Institute of Science and Technology" + "first_name": "Hoang-Hai", + "last_name": "Dang", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Hangyeol", - "last_name": "Yu", - "institution": "Korea Advanced Institute of Science and Technology" + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Laboratoire de Recherche en Informatique" }, { - "first_name": "Xavier", - "last_name": "Rival", - "institution": "Université Paris Sciences et Lettres" + "first_name": "Jan-Oliver", + "last_name": "Kaiser", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Hongseok", - "last_name": "Yang", - "institution": "Korea Advanced Institute of Science and Technology" + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" } ], - "dblp_key": "journals/pacmpl/LeeYRY20", + "dblp_key": "journals/pacmpl/DangJKD20", "venue": "popl", "year": 2020 }, @@ -1264,7 +1187,7 @@ "paper_id": "10.1145/3371088", "title": "Virtual timeline: a formal abstraction for verifying preemptive schedulers with temporal isolation", "abstract": "The reliability and security of safety-critical real-time systems are of utmost importance because the failure of these systems could incur severe consequences (e.g., loss of lives or failure of a mission). Such properties require strong isolation between components and they rely on enforcement mechanisms provided by the underlying operating system (OS) kernel. In addition to spatial isolation which is commonly provided by OS kernels to various extents, it also requires temporal isolation, that is, properties on the schedule of one component (e.g., schedulability) are independent of behaviors of other components. The strict isolation between components relies critically on algorithmic properties of the concrete implementation of the scheduler, such as timely provision of time slots, obliviousness to preemption, etc. However, existing work either only reasons about an abstract model of the scheduler, or proves properties of the scheduler implementation that are not rich enough to establish the isolation between different components. In this paper, we present a novel compositional framework for reasoning about algorithmic properties of the concrete implementation of preemptive schedulers. In particular, we use virtual timeline , a variant of the supply bound function used in real-time scheduling analysis, to specify and reason about the scheduling of each component in isolation. We show that the properties proved on this abstraction carry down to the generated assembly code of the OS kernel. Using this framework, we successfully verify a real-time OS kernel, which extends mCertiKOS, a single-processor non-preemptive kernel, with user-level preemption, a verified timer interrupt handler, and a verified real-time scheduler. We prove that in the absence of microarchitectural-level timing channels, this new kernel enjoys temporal and spatial isolation on top of the functional correctness guarantee. All the proofs are implemented in the Coq proof assistant.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371088", "conference_name": "POPL", "authors": [ @@ -1309,40 +1232,261 @@ "year": 2020 }, { - "paper_id": "10.1145/3371087", - "title": "Trace types and denotational semantics for sound programmable inference in probabilistic languages", - "abstract": "Modern probabilistic programming languages aim to formalize and automate key aspects of probabilistic modeling and inference. Many languages provide constructs for programmable inference that enable developers to improve inference speed and accuracy by tailoring an algorithm for use with a particular model or dataset. Unfortunately, it is easy to use these constructs to write unsound programs that appear to run correctly but produce incorrect results. To address this problem, we present a denotational semantics for programmable inference in higher-order probabilistic programming languages, along with a type system that ensures that well-typed inference programs are sound by construction. A central insight is that the type of a probabilistic expression can track the space of its possible execution traces, not just the type of value that it returns, as these traces are often the objects that inference algorithms manipulate. We use our semantics and type system to establish soundness properties of custom inference programs that use constructs for variational, sequential Monte Carlo, importance sampling, and Markov chain Monte Carlo inference.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371087", + "paper_id": "10.1145/3371108", + "title": "Partial type constructors: or, making ad hoc datatypes less ad hoc", + "abstract": "Functional programming languages assume that type constructors are total. Yet functional programmers know better: counterexamples range from container types that make limiting assumptions about their contents (e.g., requiring computable equality or ordering functions) to type families with defining equations only over certain choices of arguments. We present a language design and formal theory of partial type constructors, capturing the domains of type constructors using qualified types. Our design is both simple and expressive: we support partial datatypes as first-class citizens (including as instances of parametric abstractions, such as the Haskell Functor and Monad classes), and show a simple type elaboration algorithm that avoids placing undue annotation burden on programmers. We show that our type system rejects ill-defined types and can be compiled to a semantic model based on System F. Finally, we have conducted an experimental analysis of a body of Haskell code, using a proof-of-concept implementation of our system; while there are cases where our system requires additional annotations, these cases are rarely encountered in practical Haskell code.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371108", "conference_name": "POPL", "authors": [ { - "first_name": "Alexander K.", - "last_name": "Lew", - "institution": "Massachusetts Institute of Technology" - }, - { - "first_name": "Marco", - "last_name": "Cusumano-Towner", - "institution": "Massachusetts Institute of Technology" + "first_name": "Mark P.", + "last_name": "Jones", + "institution": "Portland State University" }, { - "first_name": "Benjamin", - "last_name": "Sherman", - "institution": "Massachusetts Institute of Technology" + "first_name": "J. Garrett", + "last_name": "Morris", + "institution": "University of Kansas" }, + { + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" + } + ], + "dblp_key": "journals/pacmpl/JonesME20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371090", + "title": "Seminaïve evaluation for a higher-order functional language", + "abstract": "One of the workhorse techniques for implementing bottom-up Datalog engines is seminaïve evaluation. This optimization improves the performance of Datalog's most distinctive feature: recursively defined predicates. These are computed iteratively, and under a naïve evaluation strategy, each iteration recomputes all previous values. Seminaïve evaluation computes a safe approximation of the difference between iterations. This can asymptotically improve the performance of Datalog queries. Seminaïve evaluation is defined partly as a program transformation and partly as a modified iteration strategy, and takes advantage of the first-order nature of Datalog code. This paper extends the seminaïve transformation to higher-order programs written in the Datafun language, which extends Datalog with features like first-class relations, higher-order functions, and datatypes like sum types.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371090", + "conference_name": "POPL", + "authors": [ { "first_name": "Michael", - "last_name": "Carbin", - "institution": "Massachusetts Institute of Technology" + "last_name": "Arntzenius", + "institution": "University of Birmingham" }, { - "first_name": "Vikash K.", - "last_name": "Mansinghka", - "institution": "Massachusetts Institute of Technology" + "first_name": "Neel", + "last_name": "Krishnaswami", + "institution": "University of Cambridge" } ], - "dblp_key": "journals/pacmpl/LewCSCM20", + "dblp_key": "journals/pacmpl/ArntzeniusK20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371106", + "title": "A simple differentiable programming language", + "abstract": "Automatic differentiation plays a prominent role in scientific computing and in modern machine learning, often in the context of powerful programming systems. The relation of the various embodiments of automatic differentiation to the mathematical notion of derivative is not always entirely clear---discrepancies can arise, sometimes inadvertently. In order to study automatic differentiation in such programming contexts, we define a small but expressive programming language that includes a construct for reverse-mode differentiation. We give operational and denotational semantics for this language. The operational semantics employs popular implementation techniques, while the denotational semantics employs notions of differentiation familiar from real analysis. We establish that these semantics coincide.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371106", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Martı́n", + "last_name": "Abadi", + "institution": "Google (United States)" + }, + { + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "Google (United States)" + } + ], + "dblp_key": "journals/pacmpl/AbadiP20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371094", + "title": "Parameterized verification under TSO is PSPACE-complete", + "abstract": "We consider parameterized verification of concurrent programs under the Total Store Order (TSO) semantics. A program consists of a set of processes that share a set of variables on which they can perform read and write operations. We show that the reachability problem for a system consisting of an arbitrary number of identical processes is PSPACE-complete. We prove that the complexity is reduced to polynomial time if the processes are not allowed to read the initial values of the variables in the memory. When the processes are allowed to perform atomic read-modify-write operations, the reachability problem has a non-primitive recursive complexity.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371094", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Parosh Aziz", + "last_name": "Abdulla", + "institution": "Uppsala University" + }, + { + "first_name": "Mohamed Faouzi", + "last_name": "Atig", + "institution": "Uppsala University" + }, + { + "first_name": "Rojin", + "last_name": "Rezvan", + "institution": "Sharif University of Technology" + } + ], + "dblp_key": "journals/pacmpl/AbdullaAR20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371075", + "title": "Formal verification of a constant-time preserving C compiler", + "abstract": "Timing side-channels are arguably one of the main sources of vulnerabilities in cryptographic implementations. One effective mitigation against timing side-channels is to write programs that do not perform secret-dependent branches and memory accesses. This mitigation, known as \"cryptographic constant-time\", is adopted by several popular cryptographic libraries. This paper focuses on compilation of cryptographic constant-time programs, and more specifically on the following question: is the code generated by a realistic compiler for a constant-time source program itself provably constant-time? Surprisingly, we answer the question positively for a mildly modified version of the CompCert compiler, a formally verified and moderately optimizing compiler for C. Concretely, we modify the CompCert compiler to eliminate sources of potential leakage. Then, we instrument the operational semantics of CompCert intermediate languages so as to be able to capture cryptographic constant-time. Finally, we prove that the modified CompCert compiler preserves constant-time. Our mechanization maximizes reuse of the CompCert correctness proof, through the use of new proof techniques for proving preservation of constant-time. These techniques achieve complementary trade-offs between generality and tractability of proof effort, and are of independent interest.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371075", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Sandrine", + "last_name": "Blazy", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "Rémi", + "last_name": "Hutin", + "institution": "Institut de Recherche en Informatique et Systèmes Aléatoires" + }, + { + "first_name": "Vincent", + "last_name": "Laporte", + "institution": "Institut national de recherche en sciences et technologies du numérique" + }, + { + "first_name": "David", + "last_name": "Pichardie", + "institution": "Université de Rennes" + }, + { + "first_name": "Alix", + "last_name": "Trieu", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/BartheBGHLPT20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371073", + "title": "Complexity and information in invariant inference", + "abstract": "This paper addresses the complexity of SAT-based invariant inference, a prominent approach to safety verification. We consider the problem of inferring an inductive invariant of polynomial length given a transition system and a safety property. We analyze the complexity of this problem in a black-box model, called the Hoare-query model, which is general enough to capture algorithms such as IC3/PDR and its variants. An algorithm in this model learns about the system's reachable states by querying the validity of Hoare triples. We show that in general an algorithm in the Hoare-query model requires an exponential number of queries. Our lower bound is information-theoretic and applies even to computationally unrestricted algorithms, showing that no choice of generalization from the partial information obtained in a polynomial number of Hoare queries can lead to an efficient invariant inference procedure in this class. We then show, for the first time, that by utilizing rich Hoare queries, as done in PDR, inference can be exponentially more efficient than approaches such as ICE learning, which only utilize inductiveness checks of candidates. We do so by constructing a class of transition systems for which a simple version of PDR with a single frame infers invariants in a polynomial number of queries, whereas every algorithm using only inductiveness checks and counterexamples requires an exponential number of queries. Our results also shed light on connections and differences with the classical theory of exact concept learning with queries, and imply that learning from counterexamples to induction is harder than classical exact learning from labeled examples. This demonstrates that the convergence rate of Counterexample-Guided Inductive Synthesis depends on the form of counterexamples.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371073", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Yotam M. Y.", + "last_name": "Feldman", + "institution": "Tel Aviv University" + }, + { + "first_name": "Neil", + "last_name": "Immerman", + "institution": "University of Massachusetts Boston" + }, + { + "first_name": "Mooly", + "last_name": "Sagiv", + "institution": "Tel Aviv University" + }, + { + "first_name": "Sharon", + "last_name": "Shoham", + "institution": "Tel Aviv University" + } + ], + "dblp_key": "journals/pacmpl/FeldmanISS20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371079", + "title": "Persistency semantics of the Intel-x86 architecture", + "abstract": "Emerging non-volatile memory (NVM) technologies promise the durability of disks with the performance of RAM. To describe the persistency guarantees of NVM, several memory persistency models have been proposed in the literature. However, the persistency semantics of the ubiquitous x86 architecture remains unexplored to date. To close this gap, we develop the Px86 (‘persistent x86’) model, formalising the persistency semantics of Intel-x86 for the first time. We formulate Px86 both operationally and declaratively, and prove that the two characterisations are equivalent. To demonstrate the application of Px86, we develop two persistent libraries over Px86: a persistent transactional library, and a persistent variant of the Michael–Scott queue. Finally, we encode our declarative Px86 model in Alloy and use it to generate persistency litmus tests automatically.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371079", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Azalea", + "last_name": "Raad", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Gil", + "last_name": "Neiger", + "institution": "Intel (United States)" + }, + { + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + } + ], + "dblp_key": "journals/pacmpl/RaadWNV20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371129", + "title": "Guarded Kleene algebra with tests: verification of uninterpreted programs in nearly linear time", + "abstract": "Guarded Kleene Algebra with Tests (GKAT) is a variation on Kleene Algebra with Tests (KAT) that arises by restricting the union (+) and iteration (*) operations from KAT to predicate-guarded versions. We develop the (co)algebraic theory of GKAT and show how it can be efficiently used to reason about imperative programs. In contrast to KAT, whose equational theory is PSPACE-complete, we show that the equational theory of GKAT is (almost) linear time. We also provide a full Kleene theorem and prove completeness for an analogue of Salomaa’s axiomatization of Kleene Algebra.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371129", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steffen", + "last_name": "Smolka", + "institution": "Cornell University" + }, + { + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Justin", + "last_name": "Hsu", + "institution": "University of Wisconsin–Madison" + }, + { + "first_name": "Tobias", + "last_name": "Kappé", + "institution": "University College London" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "University College London" + } + ], + "dblp_key": "journals/pacmpl/SmolkaFHKKS20", "venue": "popl", "year": 2020 }, @@ -1350,7 +1494,7 @@ "paper_id": "10.1145/3371078", "title": "Incorrectness logic", "abstract": "Program correctness and incorrectness are two sides of the same coin. As a programmer, even if you would like to have correctness, you might find yourself spending most of your time reasoning about incorrectness. This includes informal reasoning that people do while looking at or thinking about their code, as well as that supported by automated testing and static analysis tools. This paper describes a simple logic for program incorrectness which is, in a sense, the other side of the coin to Hoare's logic of correctness.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371078", "conference_name": "POPL", "authors": [ @@ -1365,37 +1509,162 @@ "year": 2020 }, { - "paper_id": "10.1145/3371113", - "title": "The future is ours: prophecy variables in separation logic", - "abstract": "Early in the development of Hoare logic, Owicki and Gries introduced auxiliary variables as a way of encoding information about the history of a program’s execution that is useful for verifying its correctness. Over a decade later, Abadi and Lamport observed that it is sometimes also necessary to know in advance what a program will do in the future . To address this need, they proposed prophecy variables , originally as a proof technique for refinement mappings between state machines. However, despite the fact that prophecy variables are a clearly useful reasoning mechanism, there is (surprisingly) almost no work that attempts to integrate them into Hoare logic. In this paper, we present the first account of prophecy variables in a Hoare-style program logic that is flexible enough to verify logical atomicity (a relative of linearizability) for classic examples from the concurrency literature like RDCSS and the Herlihy-Wing queue. Our account is formalized in the Iris framework for separation logic in Coq. It makes essential use of ownership to encode the exclusive right to resolve a prophecy, which in turn enables us to enforce soundness of prophecies with a very simple set of proof rules.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371113", + "paper_id": "10.1145/3371135", + "title": "Label-dependent session types", + "abstract": "Session types have emerged as a typing discipline for communication protocols. Existing calculi with session types come equipped with many different primitives that combine communication with the introduction or elimination of the transmitted value. We present a foundational session type calculus with a lightweight operational semantics. It fully decouples communication from the introduction and elimination of data and thus features a single communication reduction, which acts as a rendezvous between senders and receivers. We achieve this decoupling by introducing label-dependent session types, a minimalist value-dependent session type system with subtyping. The system is sufficiently powerful to simulate existing functional session type systems. Compared to such systems, label-dependent session types place fewer restrictions on the code. We further introduce primitive recursion over natural numbers at the type level, thus allowing to describe protocols whose behaviour depends on numbers exchanged in messages. An algorithmic type checking system is introduced and proved equivalent to its declarative counterpart. The new calculus showcases a novel lightweight integration of dependent types and linear typing, with has uses beyond session type systems.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371135", "conference_name": "POPL", "authors": [ { - "first_name": "Ralf", - "last_name": "Jung", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Peter", + "last_name": "Thiemann", + "institution": "University of Freiburg" }, { - "first_name": "Rodolphe", - "last_name": "Lepigre", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Vasco T.", + "last_name": "Vasconcelos", + "institution": "University of Lisbon" + } + ], + "dblp_key": "journals/pacmpl/ThiemannV20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371127", + "title": "SyTeCi: automating contextual equivalence for higher-order programs with references", + "abstract": "We propose a framework to study contextual equivalence of programs written in a call-by-value functional language with local integer references. It reduces the problem of contextual equivalence to the problem of non-reachability in a transition system of memory configurations. This reduction is complete for recursion-free programs. Restricting to programs that do not allocate references inside the body of functions, we encode this non-reachability problem as a set of constrained Horn clause that can then be checked for satisfiability automatically. Restricting furthermore to a language with finite data-types, we also get a new decidability result for contextual equivalence at any type.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371127", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Guilhem", + "last_name": "Jaber", + "institution": "Laboratoire des Sciences du Numérique de Nantes" + } + ], + "dblp_key": "journals/pacmpl/Jaber20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371091", + "title": "CompCertM: CompCert with C-assembly linking and lightweight modular verification", + "abstract": "Supporting multi-language linking such as linking C and handwritten assembly modules in the verified compiler CompCert requires a more compositional verification technique than that used in CompCert just supporting separate compilation. The two extensions, CompCertX and Compositional CompCert, supporting multi-language linking take different approaches. The former simplifies the problem by imposing restrictions that the source modules should have no mutual dependence and be verified against certain well-behaved specifications. On the other hand, the latter develops a new verification technique that directly solves the problem but at the expense of significantly increasing the verification cost. In this paper, we develop a novel lightweight verification technique, called RUSC (Refinement Under Self-related Contexts), and demonstrate how RUSC can solve the problem without any restrictions but still with low verification overhead. For this, we develop CompCertM, a full extension of the latest version of CompCert supporting multi-language linking. Moreover, we demonstrate the power of RUSC as a program verification technique by modularly verifying interesting programs consisting of C and handwritten assembly against their mathematical specifications.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371091", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Youngju", + "last_name": "Song", + "institution": "Seoul National University" }, { - "first_name": "G.", - "last_name": "Parthasarathy", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Minki", + "last_name": "Cho", + "institution": "Seoul National University" }, { - "first_name": "Marianna", - "last_name": "Rapoport", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Dongjoo", + "last_name": "Kim", + "institution": "Seoul National University" }, { - "first_name": "Amin", - "last_name": "Timany", - "institution": "KU Leuven" + "first_name": "Yonghyun", + "last_name": "Kim", + "institution": "Seoul National University" + }, + { + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Korea Advanced Institute of Science and Technology" + }, + { + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" + } + ], + "dblp_key": "journals/pacmpl/SongCKKKH20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371120", + "title": "Synthesizing replacement classes", + "abstract": "We present a new technique for automatically synthesizing replacement classes. The technique starts with an original class O and a potential replacement class R, then uses R to synthesize a new class that implements the same interface and provides the same functionality as O. Critically, our technique works with a synthe- sized inter-class equivalence predicate between the states of O and R. It uses this predicate to ensure that original and synthesized methods leave corresponding O and R objects in equivalent states. The predicate therefore enables the technique to synthesize individual replacement methods in isolation while still obtain- ing a replacement class that leaves the original and replacement objects in equivalent states after arbitrarily long method invocation sequences. We have implemented the technique as part of a tool, named Mask, and evaluated it using open-source Java classes. The results highlight the effectiveness of Mask in synthesizing replacement classes.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371120", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Malavika", + "last_name": "Samak", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Deokhwan", + "last_name": "Kim", + "institution": "Massachusetts Institute of Technology" + }, + { + "first_name": "Martin", + "last_name": "Rinard", + "institution": "Massachusetts Institute of Technology" + } + ], + "dblp_key": "journals/pacmpl/SamakKR20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371101", + "title": "Spy game: verifying a local generic solver in Iris", + "abstract": "We verify the partial correctness of a \"local generic solver\", that is, an on-demand, incremental, memoizing least fixed point computation algorithm. The verification is carried out in Iris, a modern breed of concurrent separation logic. The specification is simple: the solver computes the optimal least fixed point of a system of monotone equations. Although the solver relies on mutable internal state for memoization and for \"spying\", a form of dynamic dependency discovery, it is apparently pure: no side effects are mentioned in its specification. As auxiliary contributions, we provide several illustrations of the use of prophecy variables, a novel feature of Iris; we establish a restricted form of the infinitary conjunction rule; and we provide a specification and proof of Longley's modulus function, an archetypical example of spying.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371101", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Paulo Emílio de", + "last_name": "Vilhena", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "François", + "last_name": "Pottier", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Jacques-Henri", + "last_name": "Jourdan", + "institution": "Laboratoire de Recherche en Informatique" + } + ], + "dblp_key": "journals/pacmpl/VilhenaPJ20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371100", + "title": "The high-level benefits of low-level sandboxing", + "abstract": "Sandboxing is a common technique that allows low-level, untrusted components to safely interact with trusted code. However, previous work has only investigated the low-level memory isolation guarantees of sandboxing, leaving open the question of the end-to-end guarantees that sandboxing affords programmers. In this paper, we fill this gap by showing that sandboxing enables reasoning about the known concept of robust safety , i.e. , safety of the trusted code even in the presence of arbitrary untrusted code. To do this, we first present an idealized operational semantics for a language that combines trusted code with untrusted code. Sandboxing is built into our semantics. Then, we prove that safety properties of the trusted code (as enforced through a rich type system) are upheld in the presence of arbitrary untrusted code, so long as all interactions with untrusted code occur at the “any” type (a type inhabited by all values). Finally, to alleviate the burden of having to interact with untrusted code at only the “any” type, we formalize and prove safe several wrappers , which automatically convert values between the “any” type and much richer types. All our results are mechanized in the Coq proof assistant.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371100", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Michael", + "last_name": "Sammler", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" }, { "first_name": "Derek", @@ -1403,50 +1672,68 @@ "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Bart", - "last_name": "Jacobs", - "institution": "KU Leuven" + "first_name": "Tadeusz", + "last_name": "Litak", + "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" } ], - "dblp_key": "journals/pacmpl/JungLPRTDJ20", + "dblp_key": "journals/pacmpl/SammlerGDL20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371103", - "title": "Deciding memory safety for single-pass heap-manipulating programs", - "abstract": "We investigate the decidability of automatic program verification for programs that manipulate heaps, and in particular, decision procedures for proving memory safety for them. We extend recent work that identified a decidable subclass of uninterpreted programs to a class of alias-aware programs that can update maps. We apply this theory to develop verification algorithms for memory safety— determining if a heap-manipulating program that allocates and frees memory locations and manipulates heap pointers does not dereference an unallocated memory location. We show that this problem is decidable when the initial allocated heap forms a forest data-structure and when programs are streaming-coherent , which intuitively restricts programs to make a single pass over a data-structure. Our experimental evaluation on a set of library routines that manipulate forest data-structures shows that common single-pass algorithms on data-structures often fall in the decidable class, and that our decision procedure is efficient in verifying them.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371103", + "paper_id": "10.1145/3371117", + "title": "Visualization by example", + "abstract": "While visualizations play a crucial role in gaining insights from data, generating useful visualizations from a complex dataset is far from an easy task. In particular, besides understanding the functionality provided by existing visualization libraries, generating the desired visualization also requires reshaping and aggregating the underlying data as well as composing different visual elements to achieve the intended visual narrative. This paper aims to simplify visualization tasks by automatically synthesizing the required program from simple visual sketches provided by the user. Specifically, given an input data set and a visual sketch that demonstrates how to visualize a very small subset of this data, our technique automatically generates a program that can be used to visualize the entire data set. From a program synthesis perspective, automating visualization tasks poses several challenges that are not addressed by prior techniques. First, because many visualization tasks require data wrangling in addition to generating plots from a given table, we need to decompose the end-to-end synthesis task into two separate sub-problems. Second, because the intermediate specification that results from the decomposition is necessarily imprecise, this makes the data wrangling task particularly challenging in our context. In this paper, we address these problems by developing a new compositional visualization-by-example technique that (a) decomposes the end-to-end task into two different synthesis problems over different DSLs and (b) leverages bi-directional program analysis to deal with the complexity that arises from having an imprecise intermediate specification. We have implemented our visualization-by-example approach in a tool called Viser and evaluate it on over 80 visualization tasks collected from on-line forums and tutorials. Viser can solve 84 of these benchmarks within a 600 second time limit, and, for those tasks that can be solved, the desired visualization is among the top-5 generated by Viser in 70% of the cases.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371117", "conference_name": "POPL", "authors": [ { - "first_name": "Umang", - "last_name": "Mathur", - "institution": "University of Illinois Urbana-Champaign" + "first_name": "Chenglong", + "last_name": "Wang", + "institution": "University of Washington" }, { - "first_name": "Adithya", - "last_name": "Murali", - "institution": "University of Illinois Urbana-Champaign" + "first_name": "Yu", + "last_name": "Feng", + "institution": "University of California, Santa Barbara" }, { - "first_name": "Paul", - "last_name": "Krogmeier", - "institution": "University of Illinois Urbana-Champaign" + "first_name": "Rastislav", + "last_name": "Bodík", + "institution": "University of Washington" }, { - "first_name": "P.", - "last_name": "Madhusudan", - "institution": "University of Illinois Urbana-Champaign" + "first_name": "Alvin", + "last_name": "Cheung", + "institution": "University of California, Berkeley" }, { - "first_name": "Mahesh", - "last_name": "Viswanathan", - "institution": "University of Illinois Urbana-Champaign" + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" } ], - "dblp_key": "journals/pacmpl/MathurMKMV20", + "dblp_key": "journals/pacmpl/WangFBCD20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371085", + "title": "Fast, sound, and effectively complete dynamic race prediction", + "abstract": "Writing concurrent programs is highly error-prone due to the nondeterminism in interprocess communication. The most reliable indicators of errors in concurrency are data races , which are accesses to a shared resource that can be executed concurrently. We study the problem of predicting data races in lock-based concurrent programs. The input consists of a concurrent trace t , and the task is to determine all pairs of events of t that constitute a data race. The problem lies at the heart of concurrent verification and has been extensively studied for over three decades. However, existing polynomial-time sound techniques are highly incomplete and can miss simple races. In this work we develop M 2: a new polynomial-time algorithm for this problem, which has no false positives. In addition, our algorithm is complete for input traces that consist of two processes, i.e., it provably detects all races in the trace. We also develop sufficient criteria for detecting completeness dynamically in cases of more than two processes. We make an experimental evaluation of our algorithm on a challenging set of benchmarks taken from recent literature on the topic. Our algorithm soundly reports hundreds of real races, many of which are missed by existing methods. In addition, using our dynamic completeness criteria, M 2 concludes that it has detected all races in the benchmark set, hence the reports are both sound and complete. Finally, its running times are comparable, and often smaller than the theoretically fastest, yet highly incomplete, existing methods. To our knowledge, M 2 is the first sound algorithm that achieves such a level of performance on both running time and completeness of the reported races.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371085", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Andreas", + "last_name": "Pavlogiannis", + "institution": "Aarhus University" + } + ], + "dblp_key": "journals/pacmpl/Pavlogiannis20", "venue": "popl", "year": 2020 }, @@ -1454,7 +1741,7 @@ "paper_id": "10.1145/3371114", "title": "Graduality and parametricity: together again for the first time", "abstract": "Parametric polymorphism and gradual typing have proven to be a difficult combination, with no language yet produced that satisfies the fundamental theorems of each: parametricity and graduality. Notably, Toro, Labrada, and Tanter (POPL 2019) conjecture that for any gradual extension of System F that uses dynamic type generation, graduality and parametricity are ``simply incompatible''. However, we argue that it is not graduality and parametricity that are incompatible per se, but instead that combining the syntax of System F with dynamic type generation as in previous work necessitates type-directed computation, which we show has been a common source of graduality and parametricity violations in previous work. We then show that by modifying the syntax of universal and existential types to make the type name generation explicit, we remove the need for type-directed computation, and get a language that satisfies both graduality and parametricity theorems. The language has a simple runtime semantics, which can be explained by translation to a statically typed language where the dynamic type is interpreted as a dynamically extensible sum type. Far from being in conflict, we show that the parametricity theorem follows as a direct corollary of a relational interpretation of the graduality property.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371114", "conference_name": "POPL", "authors": [ @@ -1479,43 +1766,45 @@ "year": 2020 }, { - "paper_id": "10.1145/3371136", - "title": "Pointer life cycle types for lock-free data structures with memory reclamation", - "abstract": "We consider the verification of lock-free data structures that manually manage their memory with the help of a safe memory reclamation (SMR) algorithm. Our first contribution is a type system that checks whether a program properly manages its memory. If the type check succeeds, it is safe to ignore the SMR algorithm and consider the program under garbage collection. Intuitively, our types track the protection of pointers as guaranteed by the SMR algorithm. There are two design decisions. The type system does not track any shape information, which makes it extremely lightweight. Instead, we rely on invariant annotations that postulate a protection by the SMR. To this end, we introduce angels, ghost variables with an angelic semantics. Moreover, the SMR algorithm is not hard-coded but a parameter of the type system definition. To achieve this, we rely on a recent specification language for SMR algorithms. Our second contribution is to automate the type inference and the invariant check. For the type inference, we show a quadratic-time algorithm. For the invariant check, we give a source-to-source translation that links our programs to off-the-shelf verification tools. It compiles away the angelic semantics. This allows us to infer appropriate annotations automatically in a guess-and-check manner. To demonstrate the effectiveness of our type-based verification approach, we check linearizability for various list and set implementations from the literature with both hazard pointers and epoch-based memory reclamation. For many of the examples, this is the first time they are verified automatically. For the ones where there is a competitor, we obtain a speed-up of up to two orders of magnitude.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371136", + "paper_id": "10.1145/3371128", + "title": "Detecting floating-point errors via atomic conditions", + "abstract": "This paper tackles the important, difficult problem of detecting program inputs that trigger large floating-point errors in numerical code. It introduces a novel, principled dynamic analysis that leverages the mathematically rigorously analyzed condition numbers for atomic numerical operations, which we call atomic conditions , to effectively guide the search for large floating-point errors. Compared with existing approaches, our work based on atomic conditions has several distinctive benefits: (1) it does not rely on high-precision implementations to act as approximate oracles, which are difficult to obtain in general and computationally costly; and (2) atomic conditions provide accurate, modular search guidance. These benefits in combination lead to a highly effective approach that detects more significant errors in real-world code (e.g., widely-used numerical library functions) and achieves several orders of speedups over the state-of-the-art, thus making error analysis significantly more practical. We expect the methodology and principles behind our approach to benefit other floating-point program analysis tasks such as debugging, repair and synthesis. To facilitate the reproduction of our work, we have made our implementation, evaluation data and results publicly available on GitHub at <a>https://github.com/FP-Analysis/atomic-condition</a>.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371128", "conference_name": "POPL", "authors": [ { - "first_name": "Roland", - "last_name": "Meyer", - "institution": "Technische Universität Braunschweig" + "first_name": "Daming", + "last_name": "Zou", + "institution": "Peking University" }, { - "first_name": "Sebastian", - "last_name": "Wolff", - "institution": "Technische Universität Braunschweig" - } - ], - "dblp_key": "journals/pacmpl/MeyerW20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371085", - "title": "Fast, sound, and effectively complete dynamic race prediction", - "abstract": "Writing concurrent programs is highly error-prone due to the nondeterminism in interprocess communication. The most reliable indicators of errors in concurrency are data races , which are accesses to a shared resource that can be executed concurrently. We study the problem of predicting data races in lock-based concurrent programs. The input consists of a concurrent trace t , and the task is to determine all pairs of events of t that constitute a data race. The problem lies at the heart of concurrent verification and has been extensively studied for over three decades. However, existing polynomial-time sound techniques are highly incomplete and can miss simple races. In this work we develop M 2: a new polynomial-time algorithm for this problem, which has no false positives. In addition, our algorithm is complete for input traces that consist of two processes, i.e., it provably detects all races in the trace. We also develop sufficient criteria for detecting completeness dynamically in cases of more than two processes. We make an experimental evaluation of our algorithm on a challenging set of benchmarks taken from recent literature on the topic. Our algorithm soundly reports hundreds of real races, many of which are missed by existing methods. In addition, using our dynamic completeness criteria, M 2 concludes that it has detected all races in the benchmark set, hence the reports are both sound and complete. Finally, its running times are comparable, and often smaller than the theoretically fastest, yet highly incomplete, existing methods. To our knowledge, M 2 is the first sound algorithm that achieves such a level of performance on both running time and completeness of the reported races.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371085", - "conference_name": "POPL", - "authors": [ + "first_name": "Muhan", + "last_name": "Zeng", + "institution": "Peking University" + }, { - "first_name": "Andreas", - "last_name": "Pavlogiannis", - "institution": "Aarhus University" + "first_name": "Yingfei", + "last_name": "Xiong", + "institution": "Peking University" + }, + { + "first_name": "Zhoulai", + "last_name": "Fu", + "institution": "IT University of Copenhagen" + }, + { + "first_name": "Lu", + "last_name": "Zhang", + "institution": "Peking University" + }, + { + "first_name": "Zhendong", + "last_name": "Su", + "institution": "ETH Zurich" } ], - "dblp_key": "journals/pacmpl/Pavlogiannis20", + "dblp_key": "journals/pacmpl/ZouZXFZS20", "venue": "popl", "year": 2020 }, @@ -1523,7 +1812,7 @@ "paper_id": "10.1145/3371130", "title": "Provenance-guided synthesis of Datalog programs", "abstract": "We propose a new approach to synthesize Datalog programs from input-output specifications. Our approach leverages query provenance to scale the counterexample-guided inductive synthesis (CEGIS) procedure for program synthesis. In each iteration of the procedure, a SAT solver proposes a candidate Datalog program, and a Datalog solver evaluates the proposed program to determine whether it meets the desired specification. Failure to satisfy the specification results in additional constraints to the SAT solver. We propose efficient algorithms to learn these constraints based on “ why ” and “ why not ” provenance information obtained from the Datalog solver. We have implemented our approach in a tool called ProSynth and present experimental results that demonstrate significant improvements over the state-of-the-art, including in synthesizing invented predicates, reducing running times, and in decreasing variances in synthesis performance. On a suite of 40 synthesis tasks from three different domains, ProSynth is able to synthesize the desired program in 10 seconds on average per task—an order of magnitude faster than baseline approaches—and takes only under a second each for 28 of them.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371130", "conference_name": "POPL", "authors": [ @@ -1558,185 +1847,48 @@ "year": 2020 }, { - "paper_id": "10.1145/3371126", - "title": "The fire triangle: how to mix substitution, dependent elimination, and effects", - "abstract": "There is a critical tension between substitution, dependent elimination and effects in type theory. In this paper, we crystallize this tension in the form of a no-go theorem that constitutes the fire triangle of type theory. To release this tension, we propose ∂CBPV, an extension of call-by-push-value (CBPV) —a general calculus of effects—to dependent types. Then, by extending to ∂CBPV the well-known decompositions of call-by-name and call-by-value into CBPV, we show why, in presence of effects, dependent elimination must be restricted in call-by-name, and substitution must be restricted in call-by-value. To justify ∂CBPV and show that it is general enough to interpret many kinds of effects, we define various effectful syntactic translations from ∂CBPV to Martin-Löf type theory: the reader, weaning and forcing translations.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371126", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Pierre-Marie", - "last_name": "Pédrot", - "institution": "Institut national de recherche en informatique et en automatique" - }, - { - "first_name": "Nicolas", - "last_name": "Tabareau", - "institution": "Institut national de recherche en informatique et en automatique" - } - ], - "dblp_key": "journals/pacmpl/PedrotT20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371079", - "title": "Persistency semantics of the Intel-x86 architecture", - "abstract": "Emerging non-volatile memory (NVM) technologies promise the durability of disks with the performance of RAM. To describe the persistency guarantees of NVM, several memory persistency models have been proposed in the literature. However, the persistency semantics of the ubiquitous x86 architecture remains unexplored to date. To close this gap, we develop the Px86 (‘persistent x86’) model, formalising the persistency semantics of Intel-x86 for the first time. We formulate Px86 both operationally and declaratively, and prove that the two characterisations are equivalent. To demonstrate the application of Px86, we develop two persistent libraries over Px86: a persistent transactional library, and a persistent variant of the Michael–Scott queue. Finally, we encode our declarative Px86 model in Alloy and use it to generate persistency litmus tests automatically.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371079", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Azalea", - "last_name": "Raad", - "institution": "Max Planck Institute for Software Systems" - }, - { - "first_name": "John", - "last_name": "Wickerson", - "institution": "Imperial College London" - }, - { - "first_name": "Gil", - "last_name": "Neiger", - "institution": "Intel (United States)" - }, - { - "first_name": "Viktor", - "last_name": "Vafeiadis", - "institution": "Max Planck Institute for Software Systems" - } - ], - "dblp_key": "journals/pacmpl/RaadWNV20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371120", - "title": "Synthesizing replacement classes", - "abstract": "We present a new technique for automatically synthesizing replacement classes. The technique starts with an original class O and a potential replacement class R, then uses R to synthesize a new class that implements the same interface and provides the same functionality as O. Critically, our technique works with a synthe- sized inter-class equivalence predicate between the states of O and R. It uses this predicate to ensure that original and synthesized methods leave corresponding O and R objects in equivalent states. The predicate therefore enables the technique to synthesize individual replacement methods in isolation while still obtain- ing a replacement class that leaves the original and replacement objects in equivalent states after arbitrarily long method invocation sequences. We have implemented the technique as part of a tool, named Mask, and evaluated it using open-source Java classes. The results highlight the effectiveness of Mask in synthesizing replacement classes.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371120", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Malavika", - "last_name": "Samak", - "institution": "Massachusetts Institute of Technology" - }, - { - "first_name": "Deokhwan", - "last_name": "Kim", - "institution": "Massachusetts Institute of Technology" - }, - { - "first_name": "Martin", - "last_name": "Rinard", - "institution": "Massachusetts Institute of Technology" - } - ], - "dblp_key": "journals/pacmpl/SamakKR20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371100", - "title": "The high-level benefits of low-level sandboxing", - "abstract": "Sandboxing is a common technique that allows low-level, untrusted components to safely interact with trusted code. However, previous work has only investigated the low-level memory isolation guarantees of sandboxing, leaving open the question of the end-to-end guarantees that sandboxing affords programmers. In this paper, we fill this gap by showing that sandboxing enables reasoning about the known concept of robust safety , i.e. , safety of the trusted code even in the presence of arbitrary untrusted code. To do this, we first present an idealized operational semantics for a language that combines trusted code with untrusted code. Sandboxing is built into our semantics. Then, we prove that safety properties of the trusted code (as enforced through a rich type system) are upheld in the presence of arbitrary untrusted code, so long as all interactions with untrusted code occur at the “any” type (a type inhabited by all values). Finally, to alleviate the burden of having to interact with untrusted code at only the “any” type, we formalize and prove safe several wrappers , which automatically convert values between the “any” type and much richer types. All our results are mechanized in the Coq proof assistant.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371100", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Michael", - "last_name": "Sammler", - "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" - }, - { - "first_name": "Deepak", - "last_name": "Garg", - "institution": "Max Planck Institute for Software Systems" - }, - { - "first_name": "Derek", - "last_name": "Dreyer", - "institution": "Max Planck Institute for Software Systems" - }, - { - "first_name": "Tadeusz", - "last_name": "Litak", - "institution": "Friedrich-Alexander-Universität Erlangen-Nürnberg" - } - ], - "dblp_key": "journals/pacmpl/SammlerGDL20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371135", - "title": "Label-dependent session types", - "abstract": "Session types have emerged as a typing discipline for communication protocols. Existing calculi with session types come equipped with many different primitives that combine communication with the introduction or elimination of the transmitted value. We present a foundational session type calculus with a lightweight operational semantics. It fully decouples communication from the introduction and elimination of data and thus features a single communication reduction, which acts as a rendezvous between senders and receivers. We achieve this decoupling by introducing label-dependent session types, a minimalist value-dependent session type system with subtyping. The system is sufficiently powerful to simulate existing functional session type systems. Compared to such systems, label-dependent session types place fewer restrictions on the code. We further introduce primitive recursion over natural numbers at the type level, thus allowing to describe protocols whose behaviour depends on numbers exchanged in messages. An algorithmic type checking system is introduced and proved equivalent to its declarative counterpart. The new calculus showcases a novel lightweight integration of dependent types and linear typing, with has uses beyond session type systems.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371135", + "paper_id": "10.1145/3371097", + "title": "What is decidable about gradual types?", + "abstract": "Programmers can use gradual types to migrate programs to have more precise type annotations and thereby improve their readability, efficiency, and safety. Such migration requires an exploration of the migration space and can benefit from tool support, as shown in previous work. Our goal is to provide a foundation for better tool support by settling decidability questions about migration with gradual types. We present three algorithms and a hardness result for deciding key properties and we explain how they can be useful during an exploration. In particular, we show how to decide whether the migration space is finite, whether it has a top element, and whether it is a singleton. We also show that deciding whether it has a maximal element is NP-hard. Our implementation of our algorithms worked as expected on a suite of microbenchmarks.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371097", "conference_name": "POPL", "authors": [ { - "first_name": "Peter", - "last_name": "Thiemann", - "institution": "University of Freiburg" + "first_name": "Zeina", + "last_name": "Migeed", + "institution": "University of California, Los Angeles" }, { - "first_name": "Vasco T.", - "last_name": "Vasconcelos", - "institution": "University of Lisbon" + "first_name": "Jens", + "last_name": "Palsberg", + "institution": "University of California, Los Angeles" } ], - "dblp_key": "journals/pacmpl/ThiemannV20", + "dblp_key": "journals/pacmpl/MigeedP20", "venue": "popl", "year": 2020 }, { - "paper_id": "10.1145/3371091", - "title": "CompCertM: CompCert with C-assembly linking and lightweight modular verification", - "abstract": "Supporting multi-language linking such as linking C and handwritten assembly modules in the verified compiler CompCert requires a more compositional verification technique than that used in CompCert just supporting separate compilation. The two extensions, CompCertX and Compositional CompCert, supporting multi-language linking take different approaches. The former simplifies the problem by imposing restrictions that the source modules should have no mutual dependence and be verified against certain well-behaved specifications. On the other hand, the latter develops a new verification technique that directly solves the problem but at the expense of significantly increasing the verification cost. In this paper, we develop a novel lightweight verification technique, called RUSC (Refinement Under Self-related Contexts), and demonstrate how RUSC can solve the problem without any restrictions but still with low verification overhead. For this, we develop CompCertM, a full extension of the latest version of CompCert supporting multi-language linking. Moreover, we demonstrate the power of RUSC as a program verification technique by modularly verifying interesting programs consisting of C and handwritten assembly against their mathematical specifications.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371091", + "paper_id": "10.1145/3371136", + "title": "Pointer life cycle types for lock-free data structures with memory reclamation", + "abstract": "We consider the verification of lock-free data structures that manually manage their memory with the help of a safe memory reclamation (SMR) algorithm. Our first contribution is a type system that checks whether a program properly manages its memory. If the type check succeeds, it is safe to ignore the SMR algorithm and consider the program under garbage collection. Intuitively, our types track the protection of pointers as guaranteed by the SMR algorithm. There are two design decisions. The type system does not track any shape information, which makes it extremely lightweight. Instead, we rely on invariant annotations that postulate a protection by the SMR. To this end, we introduce angels, ghost variables with an angelic semantics. Moreover, the SMR algorithm is not hard-coded but a parameter of the type system definition. To achieve this, we rely on a recent specification language for SMR algorithms. Our second contribution is to automate the type inference and the invariant check. For the type inference, we show a quadratic-time algorithm. For the invariant check, we give a source-to-source translation that links our programs to off-the-shelf verification tools. It compiles away the angelic semantics. This allows us to infer appropriate annotations automatically in a guess-and-check manner. To demonstrate the effectiveness of our type-based verification approach, we check linearizability for various list and set implementations from the literature with both hazard pointers and epoch-based memory reclamation. For many of the examples, this is the first time they are verified automatically. For the ones where there is a competitor, we obtain a speed-up of up to two orders of magnitude.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371136", "conference_name": "POPL", "authors": [ { - "first_name": "Youngju", - "last_name": "Song", - "institution": "Seoul National University" - }, - { - "first_name": "Minki", - "last_name": "Cho", - "institution": "Seoul National University" - }, - { - "first_name": "Dongjoo", - "last_name": "Kim", - "institution": "Seoul National University" - }, - { - "first_name": "Yonghyun", - "last_name": "Kim", - "institution": "Seoul National University" - }, - { - "first_name": "Jeehoon", - "last_name": "Kang", - "institution": "Korea Advanced Institute of Science and Technology" + "first_name": "Roland", + "last_name": "Meyer", + "institution": "Technische Universität Braunschweig" }, - { - "first_name": "Chung-Kil", - "last_name": "Hur", - "institution": "Seoul National University" + { + "first_name": "Sebastian", + "last_name": "Wolff", + "institution": "Technische Universität Braunschweig" } ], - "dblp_key": "journals/pacmpl/SongCKKKH20", + "dblp_key": "journals/pacmpl/MeyerW20", "venue": "popl", "year": 2020 }, @@ -1744,7 +1896,7 @@ "paper_id": "10.1145/3371104", "title": "Optimal approximate sampling from discrete probability distributions", "abstract": "This paper addresses a fundamental problem in random variate generation: given access to a random source that emits a stream of independent fair bits, what is the most accurate and entropy-efficient algorithm for sampling from a discrete probability distribution ( p 1 , …, p n ), where the probabilities of the output distribution ( p̂ 1 , …, p̂ n ) of the sampling algorithm must be specified using at most k bits of precision? We present a theoretical framework for formulating this problem and provide new techniques for finding sampling algorithms that are optimal both statistically (in the sense of sampling accuracy) and information-theoretically (in the sense of entropy consumption). We leverage these results to build a system that, for a broad family of measures of statistical accuracy, delivers a sampling algorithm whose expected entropy usage is minimal among those that induce the same distribution (i.e., is “entropy-optimal”) and whose output distribution ( p̂ 1 , …, p̂ n ) is a closest approximation to the target distribution ( p 1 , …, p n ) among all entropy-optimal sampling algorithms that operate within the specified k -bit precision. This optimal approximate sampler is also a closer approximation than any (possibly entropy-suboptimal) sampler that consumes a bounded amount of entropy with the specified precision, a class which includes floating-point implementations of inversion sampling and related methods found in many software libraries. We evaluate the accuracy, entropy consumption, precision requirements, and wall-clock runtime of our optimal approximate sampling algorithms on a broad set of distributions, demonstrating the ways that they are superior to existing approximate samplers and establishing that they often consume significantly fewer resources than are needed by exact samplers.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371104", "conference_name": "POPL", "authors": [ @@ -1774,45 +1926,63 @@ "year": 2020 }, { - "paper_id": "10.1145/3371129", - "title": "Guarded Kleene algebra with tests: verification of uninterpreted programs in nearly linear time", - "abstract": "Guarded Kleene Algebra with Tests (GKAT) is a variation on Kleene Algebra with Tests (KAT) that arises by restricting the union (+) and iteration (*) operations from KAT to predicate-guarded versions. We develop the (co)algebraic theory of GKAT and show how it can be efficiently used to reason about imperative programs. In contrast to KAT, whose equational theory is PSPACE-complete, we show that the equational theory of GKAT is (almost) linear time. We also provide a full Kleene theorem and prove completeness for an analogue of Salomaa’s axiomatization of Kleene Algebra.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371129", + "paper_id": "10.1145/3371121", + "title": "Kind inference for datatypes", + "abstract": "In recent years, languages like Haskell have seen a dramatic surge of new features that significantly extends the expressive power of their type systems. With these features, the challenge of kind inference for datatype declarations has presented itself and become a worthy research problem on its own. This paper studies kind inference for datatypes. Inspired by previous research on type-inference, we offer declarative specifications for what datatype declarations should be accepted, both for Haskell98 and for a more advanced system we call PolyKinds, based on the extensions in modern Haskell, including a limited form of dependent types. We believe these formulations to be novel and without precedent, even for Haskell98. These specifications are complemented with implementable algorithmic versions. We study soundness, completeness and the existence of principal kinds in these systems, proving the properties where they hold. This work can serve as a guide both to language designers who wish to formalize their datatype declarations and also to implementors keen to have principled inference of principal types. This technical supplement to Kind Inference for Datatypes serves to expand upon the text in the main paper. It contains detailed typing rules, proofs, and connections to the Glasgow Haskell Compiler (GHC).", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371121", "conference_name": "POPL", "authors": [ { - "first_name": "Steffen", - "last_name": "Smolka", - "institution": "Cornell University" + "first_name": "Ningning", + "last_name": "Xie", + "institution": "University of Hong Kong" }, { - "first_name": "Nate", - "last_name": "Foster", - "institution": "Cornell University" + "first_name": "Richard A.", + "last_name": "Eisenberg", + "institution": "Bryn Mawr College" }, { - "first_name": "Justin", - "last_name": "Hsu", - "institution": "University of Wisconsin–Madison" + "first_name": "Bruno C. d. S.", + "last_name": "Oliveira", + "institution": "University of Hong Kong" + } + ], + "dblp_key": "journals/pacmpl/XieEO20", + "venue": "popl", + "year": 2020 + }, + { + "paper_id": "10.1145/3371115", + "title": "Disentanglement in nested-parallel programs", + "abstract": "Nested parallelism has proved to be a popular approach for programming the rapidly expanding range of multicore computers. It allows programmers to express parallelism at a high level and relies on a run-time system and a scheduler to deliver efficiency and scalability. As a result, many programming languages and extensions that support nested parallelism have been developed, including in C/C++, Java, Haskell, and ML. Yet, writing efficient and scalable nested parallel programs remains challenging, primarily due to difficult concurrency bugs arising from destructive updates or effects. For decades, researchers have argued that functional programming can simplify writing parallel programs by allowing more control over effects but functional programs continue to underperform in comparison to parallel programs written in lower-level languages. The fundamental difficulty with functional languages is that they have high demand for memory, and this demand only grows with parallelism. In this paper, we identify a memory property, called disentanglement, of nested-parallel programs, and propose memory management techniques for improved efficiency and scalability. Disentanglement allows for (destructive) effects as long as concurrently executing threads do not gain knowledge of the memory objects allocated by each other. We formally define disentanglement by considering an ML-like higher-order language with mutable references and presenting a dynamic semantics for it that enables reasoning about computation graphs of nested parallel programs. Based on this graph semantics, we formalize a classic correctness property---determinacy race freedom---and prove that it implies disentanglement. This establishes that disentanglement applies to a relatively broad class of parallel programs. We then propose memory management techniques for nested-parallel programs that take advantage of disentanglement for improved efficiency and scalability. We show that these techniques are practical by extending the MLton compiler for Standard ML to support this form of nested parallelism. Our empirical evaluation shows that our techniques are efficient and scale well.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371115", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Sam", + "last_name": "Westrick", + "institution": "Carnegie Mellon University" }, { - "first_name": "Tobias", - "last_name": "Kappé", - "institution": "University College London" + "first_name": "Rohan", + "last_name": "Yadav", + "institution": "Carnegie Mellon University" }, { - "first_name": "Dexter", - "last_name": "Kozen", - "institution": "Cornell University" + "first_name": "Matthew", + "last_name": "Fluet", + "institution": "Rochester Institute of Technology" }, { - "first_name": "Alexandra", - "last_name": "Silva", - "institution": "University College London" + "first_name": "Umut A.", + "last_name": "Acar", + "institution": "Carnegie Mellon University" } ], - "dblp_key": "journals/pacmpl/SmolkaFHKKS20", + "dblp_key": "journals/pacmpl/WestrickYFA20", "venue": "popl", "year": 2020 }, @@ -1820,7 +1990,7 @@ "paper_id": "10.1145/3371076", "title": "Coq Coq correct! verification of type checking and erasure for Coq, in Coq", "abstract": "Coq is built around a well-delimited kernel that perfoms typechecking for definitions in a variant of the Calculus of Inductive Constructions (CIC). Although the metatheory of CIC is very stable and reliable, the correctness of its implementation in Coq is less clear. Indeed, implementing an efficient type checker for CIC is a rather complex task, and many parts of the code rely on implicit invariants which can easily be broken by further evolution of the code. Therefore, on average, one critical bug has been found every year in Coq. This paper presents the first implementation of a type checker for the kernel of Coq (without the module system and template polymorphism), which is proven correct in Coq with respect to its formal specification and axiomatisation of part of its metatheory. Note that because of Gödel's incompleteness theorem, there is no hope to prove completely the correctness of the specification of Coq inside Coq (in particular strong normalisation or canonicity), but it is possible to prove the correctness of the implementation assuming the correctness of the specification, thus moving from a trusted code base (TCB) to a trusted theory base (TTB) paradigm. Our work is based on the MetaCoq project which provides metaprogramming facilities to work with terms and declarations at the level of this kernel. Our type checker is based on the specification of the typing relation of the Polymorphic, Cumulative Calculus of Inductive Constructions (PCUIC) at the basis of Coq and the verification of a relatively efficient and sound type-checker for it. In addition to the kernel implementation, an essential feature of Coq is the so-called extraction: the production of executable code in functional languages from Coq definitions. We present a verified version of this subtle type-and-proof erasure step, therefore enabling the verified extraction of a safe type-checker for Coq.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371076", "conference_name": "POPL", "authors": [ @@ -1855,30 +2025,25 @@ "year": 2020 }, { - "paper_id": "10.1145/3371101", - "title": "Spy game: verifying a local generic solver in Iris", - "abstract": "We verify the partial correctness of a \"local generic solver\", that is, an on-demand, incremental, memoizing least fixed point computation algorithm. The verification is carried out in Iris, a modern breed of concurrent separation logic. The specification is simple: the solver computes the optimal least fixed point of a system of monotone equations. Although the solver relies on mutable internal state for memoization and for \"spying\", a form of dynamic dependency discovery, it is apparently pure: no side effects are mentioned in its specification. As auxiliary contributions, we provide several illustrations of the use of prophecy variables, a novel feature of Iris; we establish a restricted form of the infinitary conjunction rule; and we provide a specification and proof of Longley's modulus function, an archetypical example of spying.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371101", + "paper_id": "10.1145/3371107", + "title": "PλωNK: functional probabilistic NetKAT", + "abstract": "This work presents PλωNK, a functional probabilistic network programming language that extends Probabilistic NetKAT (PNK). Like PNK, it enables probabilistic modelling of network behaviour, by providing probabilistic choice and infinite iteration (to simulate looping network packets). Yet, unlike PNK, it also offers abstraction and higher-order functions to make programming much more convenient. The formalisation of PλωNK is challenging for two reasons: Firstly, network programming induces multiple side effects (in particular, parallelism and probabilistic choice) which need to be carefully controlled in a functional setting. Our system uses an explicit syntax for thunks and sequencing which makes the interplay of these effects explicit. Secondly, measure theory, the standard domain for formalisations of (continuous) probablistic languages, does not admit higher-order functions. We address this by leveraging ω-Quasi Borel Spaces (ωQBSes), a recent advancement in the domain theory of probabilistic programming languages. We believe that our work is not only useful for bringing abstraction to PNK, but that—as part of our contribution—we have developed the meta-theory for a probabilistic language that combines advanced features like higher-order functions, iteration and parallelism, which may inform similar meta-theoretic efforts.", + "date": "2020-01-01", + "link": "https://doi.org/10.1145/3371107", "conference_name": "POPL", "authors": [ { - "first_name": "Paulo Emílio de", - "last_name": "Vilhena", - "institution": "Institut national de recherche en informatique et en automatique" - }, - { - "first_name": "François", - "last_name": "Pottier", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Alexander", + "last_name": "Vandenbroucke", + "institution": "KU Leuven" }, { - "first_name": "Jacques-Henri", - "last_name": "Jourdan", - "institution": "Laboratoire de Recherche en Informatique" + "first_name": "Tom", + "last_name": "Schrijvers", + "institution": "KU Leuven" } ], - "dblp_key": "journals/pacmpl/VilhenaPJ20", + "dblp_key": "journals/pacmpl/VandenbrouckeS20", "venue": "popl", "year": 2020 }, @@ -1886,7 +2051,7 @@ "paper_id": "10.1145/3371093", "title": "Proving expected sensitivity of probabilistic programs with randomized variable-dependent termination time", "abstract": "The notion of program sensitivity (aka Lipschitz continuity) specifies that changes in the program input result in proportional changes to the program output. For probabilistic programs the notion is naturally extended to expected sensitivity. A previous approach develops a relational program logic framework for proving expected sensitivity of probabilistic while loops, where the number of iterations is fixed and bounded. In this work, we consider probabilistic while loops where the number of iterations is not fixed, but randomized and depends on the initial input values. We present a sound approach for proving expected sensitivity of such programs. Our sound approach is martingale-based and can be automated through existing martingale-synthesis algorithms. Furthermore, our approach is compositional for sequential composition of while loops under a mild side condition. We demonstrate the effectiveness of our approach on several classical examples from Gambler's Ruin, stochastic hybrid systems and stochastic gradient descent. We also present experimental results showing that our automated approach can handle various probabilistic programs in the literature.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371093", "conference_name": "POPL", "authors": [ @@ -1920,105 +2085,11 @@ "venue": "popl", "year": 2020 }, - { - "paper_id": "10.1145/3371117", - "title": "Visualization by example", - "abstract": "While visualizations play a crucial role in gaining insights from data, generating useful visualizations from a complex dataset is far from an easy task. In particular, besides understanding the functionality provided by existing visualization libraries, generating the desired visualization also requires reshaping and aggregating the underlying data as well as composing different visual elements to achieve the intended visual narrative. This paper aims to simplify visualization tasks by automatically synthesizing the required program from simple visual sketches provided by the user. Specifically, given an input data set and a visual sketch that demonstrates how to visualize a very small subset of this data, our technique automatically generates a program that can be used to visualize the entire data set. From a program synthesis perspective, automating visualization tasks poses several challenges that are not addressed by prior techniques. First, because many visualization tasks require data wrangling in addition to generating plots from a given table, we need to decompose the end-to-end synthesis task into two separate sub-problems. Second, because the intermediate specification that results from the decomposition is necessarily imprecise, this makes the data wrangling task particularly challenging in our context. In this paper, we address these problems by developing a new compositional visualization-by-example technique that (a) decomposes the end-to-end task into two different synthesis problems over different DSLs and (b) leverages bi-directional program analysis to deal with the complexity that arises from having an imprecise intermediate specification. We have implemented our visualization-by-example approach in a tool called Viser and evaluate it on over 80 visualization tasks collected from on-line forums and tutorials. Viser can solve 84 of these benchmarks within a 600 second time limit, and, for those tasks that can be solved, the desired visualization is among the top-5 generated by Viser in 70% of the cases.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371117", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Chenglong", - "last_name": "Wang", - "institution": "University of Washington" - }, - { - "first_name": "Yu", - "last_name": "Feng", - "institution": "University of California, Santa Barbara" - }, - { - "first_name": "Rastislav", - "last_name": "Bodík", - "institution": "University of Washington" - }, - { - "first_name": "Alvin", - "last_name": "Cheung", - "institution": "University of California, Berkeley" - }, - { - "first_name": "Işıl", - "last_name": "Dillig", - "institution": "The University of Texas at Austin" - } - ], - "dblp_key": "journals/pacmpl/WangFBCD20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371107", - "title": "PλωNK: functional probabilistic NetKAT", - "abstract": "This work presents PλωNK, a functional probabilistic network programming language that extends Probabilistic NetKAT (PNK). Like PNK, it enables probabilistic modelling of network behaviour, by providing probabilistic choice and infinite iteration (to simulate looping network packets). Yet, unlike PNK, it also offers abstraction and higher-order functions to make programming much more convenient. The formalisation of PλωNK is challenging for two reasons: Firstly, network programming induces multiple side effects (in particular, parallelism and probabilistic choice) which need to be carefully controlled in a functional setting. Our system uses an explicit syntax for thunks and sequencing which makes the interplay of these effects explicit. Secondly, measure theory, the standard domain for formalisations of (continuous) probablistic languages, does not admit higher-order functions. We address this by leveraging ω-Quasi Borel Spaces (ωQBSes), a recent advancement in the domain theory of probabilistic programming languages. We believe that our work is not only useful for bringing abstraction to PNK, but that—as part of our contribution—we have developed the meta-theory for a probabilistic language that combines advanced features like higher-order functions, iteration and parallelism, which may inform similar meta-theoretic efforts.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371107", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Alexander", - "last_name": "Vandenbroucke", - "institution": "KU Leuven" - }, - { - "first_name": "Tom", - "last_name": "Schrijvers", - "institution": "KU Leuven" - } - ], - "dblp_key": "journals/pacmpl/VandenbrouckeS20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371115", - "title": "Disentanglement in nested-parallel programs", - "abstract": "Nested parallelism has proved to be a popular approach for programming the rapidly expanding range of multicore computers. It allows programmers to express parallelism at a high level and relies on a run-time system and a scheduler to deliver efficiency and scalability. As a result, many programming languages and extensions that support nested parallelism have been developed, including in C/C++, Java, Haskell, and ML. Yet, writing efficient and scalable nested parallel programs remains challenging, primarily due to difficult concurrency bugs arising from destructive updates or effects. For decades, researchers have argued that functional programming can simplify writing parallel programs by allowing more control over effects but functional programs continue to underperform in comparison to parallel programs written in lower-level languages. The fundamental difficulty with functional languages is that they have high demand for memory, and this demand only grows with parallelism. In this paper, we identify a memory property, called disentanglement, of nested-parallel programs, and propose memory management techniques for improved efficiency and scalability. Disentanglement allows for (destructive) effects as long as concurrently executing threads do not gain knowledge of the memory objects allocated by each other. We formally define disentanglement by considering an ML-like higher-order language with mutable references and presenting a dynamic semantics for it that enables reasoning about computation graphs of nested parallel programs. Based on this graph semantics, we formalize a classic correctness property---determinacy race freedom---and prove that it implies disentanglement. This establishes that disentanglement applies to a relatively broad class of parallel programs. We then propose memory management techniques for nested-parallel programs that take advantage of disentanglement for improved efficiency and scalability. We show that these techniques are practical by extending the MLton compiler for Standard ML to support this form of nested parallelism. Our empirical evaluation shows that our techniques are efficient and scale well.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371115", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Sam", - "last_name": "Westrick", - "institution": "Carnegie Mellon University" - }, - { - "first_name": "Rohan", - "last_name": "Yadav", - "institution": "Carnegie Mellon University" - }, - { - "first_name": "Matthew", - "last_name": "Fluet", - "institution": "Rochester Institute of Technology" - }, - { - "first_name": "Umut A.", - "last_name": "Acar", - "institution": "Carnegie Mellon University" - } - ], - "dblp_key": "journals/pacmpl/WestrickYFA20", - "venue": "popl", - "year": 2020 - }, { "paper_id": "10.1145/3371119", "title": "Interaction trees: representing recursive and impure programs in Coq", "abstract": "Interaction trees (ITrees) are a general-purpose data structure for representing the behaviors of recursive programs that interact with their environments. A coinductive variant of “free monads,” ITrees are built out of uninterpreted events and their continuations. They support compositional construction of interpreters from event handlers , which give meaning to events by defining their semantics as monadic actions. ITrees are expressive enough to represent impure and potentially nonterminating, mutually recursive computations, while admitting a rich equational theory of equivalence up to weak bisimulation. In contrast to other approaches such as relationally specified operational semantics, ITrees are executable via code extraction, making them suitable for debugging, testing, and implementing software artifacts that are amenable to formal verification. We have implemented ITrees and their associated theory as a Coq library, mechanizing classic domain- and category-theoretic results about program semantics, iteration, monadic structures, and equational reasoning. Although the internals of the library rely heavily on coinductive proofs, the interface hides these details so that clients can use and reason about ITrees without explicit use of Coq’s coinduction tactics. To showcase the utility of our theory, we prove the termination-sensitive correctness of a compiler from a simple imperative source language to an assembly-like target whose meanings are given in an ITree-based denotational semantics. Unlike previous results using operational techniques, our bisimulation proof follows straightforwardly by structural induction and elementary rewriting via an equational theory of combinators for control-flow graphs.", - "date": "2019-12-20", + "date": "2020-01-01", "link": "https://doi.org/10.1145/3371119", "conference_name": "POPL", "authors": [ @@ -2061,76 +2132,5 @@ "dblp_key": "journals/pacmpl/XiaZHHMPZ20", "venue": "popl", "year": 2020 - }, - { - "paper_id": "10.1145/3371121", - "title": "Kind inference for datatypes", - "abstract": "In recent years, languages like Haskell have seen a dramatic surge of new features that significantly extends the expressive power of their type systems. With these features, the challenge of kind inference for datatype declarations has presented itself and become a worthy research problem on its own. This paper studies kind inference for datatypes. Inspired by previous research on type-inference, we offer declarative specifications for what datatype declarations should be accepted, both for Haskell98 and for a more advanced system we call PolyKinds, based on the extensions in modern Haskell, including a limited form of dependent types. We believe these formulations to be novel and without precedent, even for Haskell98. These specifications are complemented with implementable algorithmic versions. We study soundness, completeness and the existence of principal kinds in these systems, proving the properties where they hold. This work can serve as a guide both to language designers who wish to formalize their datatype declarations and also to implementors keen to have principled inference of principal types. This technical supplement to Kind Inference for Datatypes serves to expand upon the text in the main paper. It contains detailed typing rules, proofs, and connections to the Glasgow Haskell Compiler (GHC).", - "date": "2019-11-11", - "link": "https://doi.org/10.1145/3371121", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Ningning", - "last_name": "Xie", - "institution": "University of Hong Kong" - }, - { - "first_name": "Richard A.", - "last_name": "Eisenberg", - "institution": "Bryn Mawr College" - }, - { - "first_name": "Bruno C. d. S.", - "last_name": "Oliveira", - "institution": "University of Hong Kong" - } - ], - "dblp_key": "journals/pacmpl/XieEO20", - "venue": "popl", - "year": 2020 - }, - { - "paper_id": "10.1145/3371128", - "title": "Detecting floating-point errors via atomic conditions", - "abstract": "This paper tackles the important, difficult problem of detecting program inputs that trigger large floating-point errors in numerical code. It introduces a novel, principled dynamic analysis that leverages the mathematically rigorously analyzed condition numbers for atomic numerical operations, which we call atomic conditions , to effectively guide the search for large floating-point errors. Compared with existing approaches, our work based on atomic conditions has several distinctive benefits: (1) it does not rely on high-precision implementations to act as approximate oracles, which are difficult to obtain in general and computationally costly; and (2) atomic conditions provide accurate, modular search guidance. These benefits in combination lead to a highly effective approach that detects more significant errors in real-world code (e.g., widely-used numerical library functions) and achieves several orders of speedups over the state-of-the-art, thus making error analysis significantly more practical. We expect the methodology and principles behind our approach to benefit other floating-point program analysis tasks such as debugging, repair and synthesis. To facilitate the reproduction of our work, we have made our implementation, evaluation data and results publicly available on GitHub at <a>https://github.com/FP-Analysis/atomic-condition</a>.", - "date": "2019-12-20", - "link": "https://doi.org/10.1145/3371128", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Daming", - "last_name": "Zou", - "institution": "Peking University" - }, - { - "first_name": "Muhan", - "last_name": "Zeng", - "institution": "Peking University" - }, - { - "first_name": "Yingfei", - "last_name": "Xiong", - "institution": "Peking University" - }, - { - "first_name": "Zhoulai", - "last_name": "Fu", - "institution": "IT University of Copenhagen" - }, - { - "first_name": "Lu", - "last_name": "Zhang", - "institution": "Peking University" - }, - { - "first_name": "Zhendong", - "last_name": "Su", - "institution": "ETH Zurich" - } - ], - "dblp_key": "journals/pacmpl/ZouZXFZS20", - "venue": "popl", - "year": 2020 } ] \ No newline at end of file From ec6741b31622f9c2659d6bc0b1b11a8076f4b86f Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 18:55:39 +0200 Subject: [PATCH 26/34] feat: re-ingest POPL 2017 with conference-year date Re-run of PLConferenceHarvester for POPL 2017 with the date-normalisation fix in place. All 66 papers now carry 2017-01-01 instead of the journal-release date 2016-12-22 OpenAlex returns, moving them out of the 2016 bucket (128 -> 62 real POPL 2016) and into 2017 (0 -> 66) in the year-bucketing inventory query. Co-Authored-By: Claude Opus 4.7 (1M context) --- data/pl_conferences/popl/2017.json | 2060 ++++++++++++++-------------- 1 file changed, 1030 insertions(+), 1030 deletions(-) diff --git a/data/pl_conferences/popl/2017.json b/data/pl_conferences/popl/2017.json index 2d51031..84f9fb0 100644 --- a/data/pl_conferences/popl/2017.json +++ b/data/pl_conferences/popl/2017.json @@ -1,29 +1,19 @@ [ { - "paper_id": "10.1145/3009837.3009886", - "title": "Type systems as macros", - "abstract": "We present Turnstile, a metalanguage for creating typed embedded languages. To implement the type system, programmers write type checking rules resembling traditional judgment syntax. To implement the semantics, they incorporate elaborations into these rules. Turnstile critically depends on the idea of linguistic reuse. It exploits a macro system in a novel way to simultaneously type check and rewrite a surface program into a target language. Reusing a macro system also yields modular implementations whose rules may be mixed and matched to create other languages. Combined with typical compiler and runtime reuse, Turnstile produces performant typed embedded languages with little effort.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009886", + "paper_id": "10.1145/3009837.3009841", + "title": "The exp-log normal form of types: decomposing extensional equality and representing terms compactly", + "abstract": "Lambda calculi with algebraic data types lie at the core of functional programming languages and proof assistants, but conceal at least two fundamental theoretical problems already in the presence of the simplest non-trivial data type, the sum type. First, we do not know of an explicit and implemented algorithm for deciding the beta-eta-equality of terms---and this in spite of the first decidability results proven two decades ago. Second, it is not clear how to decide when two types are essentially the same, i.e. isomorphic, in spite of the meta-theoretic results on decidability of the isomorphism. In this paper, we present the exp-log normal form of types---derived from the representation of exponential polynomials via the unary exponential and logarithmic functions---that any type built from arrows, products, and sums, can be isomorphically mapped to. The type normal form can be used as a simple heuristic for deciding type isomorphism, thanks to the fact that it is a systematic application of the high-school identities. We then show that the type normal form allows to reduce the standard beta-eta equational theory of the lambda calculus to a specialized version of itself, while preserving the completeness of equality on terms. We end by describing an alternative representation of normal terms of the lambda calculus with sums, together with a Coq-implemented converter into/from our new term calculus. The difference with the only other previously implemented heuristic for deciding interesting instances of eta-equality by Balat, Di Cosmo, and Fiore, is that we exploit the type information of terms substantially and this often allows us to obtain a canonical representation of terms without performing sophisticated term analyses.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009841", "conference_name": "POPL", "authors": [ { - "first_name": "Stephen", - "last_name": "Chang", - "institution": "Northeastern University" - }, - { - "first_name": "Alex", - "last_name": "Knauth", - "institution": "Northeastern University" - }, - { - "first_name": "Ben", - "last_name": "Greenman", - "institution": "Northeastern University" + "first_name": "Danko", + "last_name": "Ilik", + "institution": "" } ], - "dblp_key": "conf/popl/ChangKG17", + "dblp_key": "conf/popl/Ilik17", "venue": "popl", "year": 2017 }, @@ -31,7 +21,7 @@ "paper_id": "10.1145/3009837.3009867", "title": "LMS-Verify: abstraction without regret for verified systems programming", "abstract": "Performance critical software is almost always developed in C, as programmers do not trust high-level languages to deliver the same reliable performance. This is bad because low-level code in unsafe languages attracts security vulnerabilities and because development is far less productive, with PL advances mostly lost on programmers operating under tight performance constraints. High-level languages provide memory safety out of the box, but they are deemed too slow and unpredictable for serious system software.", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3009867", "conference_name": "POPL", "authors": [ @@ -50,11 +40,34 @@ "venue": "popl", "year": 2017 }, + { + "paper_id": "10.1145/3009837.3009882", + "title": "Polymorphism, subtyping, and type inference in MLsub", + "abstract": "We present a type system combining subtyping and ML-style parametric polymorphism. Unlike previous work, our system supports type inference and has compact principal types. We demonstrate this system in the minimal language MLsub, which types a strict superset of core ML programs.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009882", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephen K.", + "last_name": "Dolan", + "institution": "University of Cambridge" + }, + { + "first_name": "Alan", + "last_name": "Mycroft", + "institution": "University of Cambridge" + } + ], + "dblp_key": "conf/popl/DolanM17", + "venue": "popl", + "year": 2017 + }, { "paper_id": "10.1145/3009837.3009853", "title": "Typed self-evaluation via intensional type functions", "abstract": "Many popular languages have a self-interpreter, that is, an interpreter for the language written in itself. So far, work on polymorphically-typed self-interpreters has concentrated on self-recognizers that merely recover a program from its representation. A larger and until now unsolved challenge is to implement a polymorphically-typed self-evaluator that evaluates the represented program and produces a representation of the result. We present Fωμi, the first λ-calculus that supports a polymorphically-typed self-evaluator. Our calculus extends Fω with recursive types and intensional type functions and has decidable type checking. Our key innovation is a novel implementation of type equality proofs that enables us to define a versatile representation of programs. Our results establish a new category of languages that can support polymorphically-typed self-evaluators.", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3009853", "conference_name": "POPL", "authors": [ @@ -74,111 +87,129 @@ "year": 2017 }, { - "paper_id": "10.1145/3009837.3009863", - "title": "Automatically generating the dynamic semantics of gradually typed languages", - "abstract": "Many language designers have adopted gradual typing. However, there remains open questions regarding how to gradualize languages. Cimini and Siek (2016) created a methodology and algorithm to automatically generate the type system of a gradually typed language from a fully static version of the language. In this paper, we address the next challenge of how to automatically generate the dynamic semantics of gradually typed languages. Such languages typically use an intermediate language with explicit casts.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009863", + "paper_id": "10.1145/3009837.3009855", + "title": "Interactive proofs in higher-order concurrent separation logic", + "abstract": "When using a proof assistant to reason in an embedded logic -- like separation logic -- one cannot benefit from the proof contexts and basic tactics of the proof assistant. This results in proofs that are at a too low level of abstraction because they are cluttered with bookkeeping code related to manipulating the object logic.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009855", "conference_name": "POPL", "authors": [ { - "first_name": "Matteo", - "last_name": "Cimini", - "institution": "Indiana University" + "first_name": "Robbert", + "last_name": "Krebbers", + "institution": "Delft University of Technology" }, { - "first_name": "Jeremy G.", - "last_name": "Siek", - "institution": "Indiana University" + "first_name": "Amin", + "last_name": "Timany", + "institution": "KU Leuven" + }, + { + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" } ], - "dblp_key": "conf/popl/CiminiS17", + "dblp_key": "conf/popl/KrebbersTB17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009878", - "title": "Dijkstra monads for free", - "abstract": "Dijkstra monads enable a dependent type theory to be enhanced with support for specifying and verifying effectful code via weakest preconditions. Together with their closely related counterparts, Hoare monads, they provide the basis on which verification tools like F*, Hoare Type Theory (HTT), and Ynot are built. We show that Dijkstra monads can be derived \"for free\" by applying a continuation-passing style (CPS) translation to the standard monadic definitions of the underlying computational effects. Automatically deriving Dijkstra monads in this way provides a correct-by-construction and efficient way of reasoning about user-defined effects in dependent type theories. We demonstrate these ideas in EMF*, a new dependently typed calculus, validating it via both formal proof and a prototype implementation within F*. Besides equipping F* with a more uniform and extensible effect system, EMF* enables a novel mixture of intrinsic and extrinsic proofs within F*.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009878", + "paper_id": "10.1145/3009837.3009895", + "title": "Serializability for eventual consistency: criterion, analysis, and applications", + "abstract": "Developing and reasoning about systems using eventually consistent data stores is a difficult challenge due to the presence of unexpected behaviors that do not occur under sequential consistency. A fundamental problem in this setting is to identify a correctness criterion that precisely captures intended application behaviors yet is generic enough to be applicable to a wide range of applications.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009895", "conference_name": "POPL", "authors": [ { - "first_name": "Danel", - "last_name": "Ahman", - "institution": "University of Edinburgh" - }, - { - "first_name": "Cătălin", - "last_name": "Hriţcu", - "institution": "Microsoft (United States)" + "first_name": "Lucas", + "last_name": "Brutschy", + "institution": "ETH Zurich" }, { - "first_name": "Kenji", - "last_name": "Maillard", - "institution": "Microsoft (United States)" + "first_name": "Dimitar", + "last_name": "Dimitrov", + "institution": "ETH Zurich" }, { - "first_name": "Guido", - "last_name": "Martínez", - "institution": "State Key Laboratory of Cryptology" + "first_name": "Péter", + "last_name": "Müller", + "institution": "ETH Zurich" }, { - "first_name": "Gordon", - "last_name": "Plotkin", - "institution": "University of Edinburgh" - }, + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" + } + ], + "dblp_key": "conf/popl/BrutschyD0V17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009877", + "title": "A relational model of types-and-effects in higher-order concurrent separation logic", + "abstract": "Recently we have seen a renewed interest in programming languages that tame the complexity of state and concurrency through refined type systems with more fine-grained control over effects. In addition to simplifying reasoning and eliminating whole classes of bugs, statically tracking effects opens the door to advanced compiler optimizations.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009877", + "conference_name": "POPL", + "authors": [ { - "first_name": "Jonathan", - "last_name": "Protzenko", - "institution": "Microsoft (United States)" + "first_name": "Morten", + "last_name": "Krogh-Jespersen", + "institution": "Aarhus University" }, { - "first_name": "Aseem", - "last_name": "Rastogi", - "institution": "Microsoft Research (India)" + "first_name": "Kasper", + "last_name": "Svendsen", + "institution": "University of Cambridge" }, { - "first_name": "Nikhil", - "last_name": "Swamy", - "institution": "Microsoft (United States)" + "first_name": "Lars", + "last_name": "Birkedal", + "institution": "Aarhus University" } ], - "dblp_key": "conf/popl/AhmanHMMPPRS17", + "dblp_key": "conf/popl/Krogh-Jespersen17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009895", - "title": "Serializability for eventual consistency: criterion, analysis, and applications", - "abstract": "Developing and reasoning about systems using eventually consistent data stores is a difficult challenge due to the presence of unexpected behaviors that do not occur under sequential consistency. A fundamental problem in this setting is to identify a correctness criterion that precisely captures intended application behaviors yet is generic enough to be applicable to a wide range of applications.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009895", + "paper_id": "10.1145/3009837.3009890", + "title": "A semantic account of metric preservation", + "abstract": "Program sensitivity measures how robust a program is to small changes in its input, and is a fundamental notion in domains ranging from differential privacy to cyber-physical systems. A natural way to formalize program sensitivity is in terms of metrics on the input and output spaces, requiring that an r-sensitive function map inputs that are at distance d to outputs that are at distance at most r · d. Program sensitivity is thus an analogue of Lipschitz continuity for programs.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009890", "conference_name": "POPL", "authors": [ { - "first_name": "Lucas", - "last_name": "Brutschy", - "institution": "ETH Zurich" + "first_name": "Arthur Azevedo de", + "last_name": "Amorim", + "institution": "California University of Pennsylvania" }, { - "first_name": "Dimitar", - "last_name": "Dimitrov", - "institution": "ETH Zurich" + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Buffalo State University" }, { - "first_name": "Péter", - "last_name": "Müller", - "institution": "ETH Zurich" + "first_name": "Justin", + "last_name": "Hsu", + "institution": "California University of Pennsylvania" }, { - "first_name": "Martin", - "last_name": "Vechev", - "institution": "ETH Zurich" + "first_name": "Shin-ya", + "last_name": "Katsumata", + "institution": "Kyoto University" + }, + { + "first_name": "Ikram", + "last_name": "Cherigui", + "institution": "" } ], - "dblp_key": "conf/popl/BrutschyD0V17", + "dblp_key": "conf/popl/AmorimGHKC17", "venue": "popl", "year": 2017 }, @@ -186,7 +217,7 @@ "paper_id": "10.1145/3009837.3009889", "title": "Hypercollecting semantics and its application to static analysis of information flow", "abstract": "We show how static analysis for secure information flow can be expressed and proved correct entirely within the framework of abstract interpretation. The key idea is to define a Galois connection that directly approximates the hyperproperty of interest. To enable use of such Galois connections, we introduce a fixpoint characterisation of hypercollecting semantics, i.e. a \"set of sets\" transformer. This makes it possible to systematically derive static analyses for hyperproperties entirely within the calculational framework of abstract interpretation. We evaluate this technique by deriving example static analyses. For qualitative information flow, we derive a dependence analysis similar to the logic of Amtoft and Banerjee (SAS '04) and the type system of Hunt and Sands (POPL '06). For quantitative information flow, we derive a novel cardinality analysis that bounds the leakage conveyed by a program instead of simply deciding whether it exists. This encompasses problems that are hypersafety but not k-safety. We put the framework to use and introduce variations that achieve precision rivalling the most recent and precise static analyses for information flow.", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3009889", "conference_name": "POPL", "authors": [ @@ -221,582 +252,638 @@ "year": 2017 }, { - "paper_id": "10.1145/3009837.3009866", - "title": "Type soundness proofs with definitional interpreters", - "abstract": "While type soundness proofs are taught in every graduate PL class, the gap between realistic languages and what is accessible to formal proofs is large. In the case of Scala, it has been shown that its formal model, the Dependent Object Types (DOT) calculus, cannot simultaneously support key metatheoretic properties such as environment narrowing and subtyping transitivity, which are usually required for a type soundness proof. Moreover, Scala and many other realistic languages lack a general substitution property.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009866", + "paper_id": "10.1145/3009837.3009846", + "title": "Rigorous floating-point mixed-precision tuning", + "abstract": "Virtually all real-valued computations are carried out using floating-point data types and operations. The precision of these data types must be set with the goals of reducing the overall round-off error, but also emphasizing performance improvements. Often, a mixed-precision allocation achieves this optimum; unfortunately, there are no techniques available to compute such allocations and conservatively meet a given error target across all program inputs. In this work, we present a rigorous approach to precision allocation based on formal analysis via Symbolic Taylor Expansions, and error analysis based on interval functions. This approach is implemented in an automated tool called FPTuner that generates and solves a quadratically constrained quadratic program to obtain a precision-annotated version of the given expression. FPTuner automatically introduces all the requisite precision up and down casting operations. It also allows users to flexibly control precision allocation using constraints to cap the number of high precision operators as well as group operators to allocate the same precision to facilitate vectorization. We evaluate FPTuner by tuning several benchmarks and measuring the proportion of lower precision operators allocated as we increase the error threshold. We also measure the reduction in energy consumption resulting from executing mixed-precision tuned code on a real hardware platform. We observe significant energy savings in response to mixed-precision tuning, but also observe situations where unexpected compiler behaviors thwart intended optimizations.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009846", "conference_name": "POPL", "authors": [ { - "first_name": "Nada", - "last_name": "Amin", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Wei‐Fan", + "last_name": "Chiang", + "institution": "University of Utah" }, { - "first_name": "Tiark", - "last_name": "Rompf", - "institution": "Purdue University West Lafayette" - } - ], - "dblp_key": "conf/popl/AminR17", - "venue": "popl", - "year": 2017 - }, - { - "paper_id": "10.1145/3009837.3009873", - "title": "Stochastic invariants for probabilistic termination", - "abstract": "Termination is one of the basic liveness properties, and we study the termination problem for probabilistic programs with real-valued variables. Previous works focused on the qualitative problem that asks whether an input program terminates with probability 1 (almost-sure termination). A powerful approach for this qualitative problem is the notion of ranking supermartingales with respect to a given set of invariants. The quantitative problem (probabilistic termination) asks for bounds on the termination probability, and this problem has not been addressed yet. A fundamental and conceptual drawback of the existing approaches to address probabilistic termination is that even though the supermartingales consider the probabilistic behaviour of the programs, the invariants are obtained completely ignoring the probabilistic aspect (i.e., the invariants are obtained considering all behaviours with no information about the probability).", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009873", - "conference_name": "POPL", - "authors": [ + "first_name": "Mark", + "last_name": "Baranowski", + "institution": "University of Utah" + }, { - "first_name": "Krishnendu", - "last_name": "Chatterjee", - "institution": "Institute of Science and Technology Austria" + "first_name": "Ian", + "last_name": "Briggs", + "institution": "University of Utah" }, { - "first_name": "Petr", - "last_name": "Novotný", - "institution": "Institute of Science and Technology Austria" + "first_name": "Alexey", + "last_name": "Solovyev", + "institution": "University of Utah" }, { - "first_name": "Đorđe", - "last_name": "Žikelić", - "institution": "University of Cambridge" + "first_name": "Ganesh", + "last_name": "Gopalakrishnan", + "institution": "University of Utah" + }, + { + "first_name": "Zvonimir", + "last_name": "Rakamarić", + "institution": "University of Utah" } ], - "dblp_key": "conf/popl/ChatterjeeNZ17", + "dblp_key": "conf/popl/ChiangBBSGR17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009896", - "title": "Coupling proofs are probabilistic product programs", - "abstract": "Couplings are a powerful mathematical tool for reasoning about pairs of probabilistic processes. Recent developments in formal verification identify a close connection between couplings and pRHL, a relational program logic motivated by applications to provable security, enabling formal construction of couplings from the probability theory literature. However, existing work using pRHL merely shows existence of a coupling and does not give a way to prove quantitative properties about the coupling, needed to reason about mixing and convergence of probabilistic processes. Furthermore, pRHL is inherently incomplete, and is not able to capture some advanced forms of couplings such as shift couplings. We address both problems as follows.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009896", + "paper_id": "10.1145/3009837.3009847", + "title": "Fencing off go: liveness and safety for channel-based programming", + "abstract": "Go is a production-level statically typed programming language whose design features explicit message-passing primitives and lightweight threads, enabling (and encouraging) programmers to develop concurrent systems where components interact through communication more so than by lock-based shared memory concurrency. Go can only detect global deadlocks at runtime, but provides no compile-time protection against all too common communication mismatches or partial deadlocks.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009847", "conference_name": "POPL", "authors": [ { - "first_name": "Gilles", - "last_name": "Barthe", - "institution": "IMDEA Software" - }, + "first_name": "Julien", + "last_name": "Lange", + "institution": "Imperial College London" + }, { - "first_name": "Benjamin", - "last_name": "Grégoire", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Nicholas", + "last_name": "Ng", + "institution": "Imperial College London" }, { - "first_name": "Justin", - "last_name": "Hsu", - "institution": "California University of Pennsylvania" + "first_name": "Bernardo", + "last_name": "Toninho", + "institution": "Imperial College London" }, { - "first_name": "Pierre-Yves", - "last_name": "Strub", - "institution": "IMDEA Software" + "first_name": "Nobuko", + "last_name": "Yoshida", + "institution": "Imperial College London" } ], - "dblp_key": "conf/popl/BartheGHS17", + "dblp_key": "conf/popl/LangeNTY17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009890", - "title": "A semantic account of metric preservation", - "abstract": "Program sensitivity measures how robust a program is to small changes in its input, and is a fundamental notion in domains ranging from differential privacy to cyber-physical systems. A natural way to formalize program sensitivity is in terms of metrics on the input and output spaces, requiring that an r-sensitive function map inputs that are at distance d to outputs that are at distance at most r · d. Program sensitivity is thus an analogue of Lipschitz continuity for programs.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009890", + "paper_id": "10.1145/3009837.3009900", + "title": "Hazelnut: a bidirectionally typed structure editor calculus", + "abstract": "Structure editors allow programmers to edit the tree structure of a program directly. This can have cognitive benefits, particularly for novice and end-user programmers. It also simplifies matters for tool designers, because they do not need to contend with malformed program text.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009900", "conference_name": "POPL", "authors": [ { - "first_name": "Arthur Azevedo de", - "last_name": "Amorim", - "institution": "California University of Pennsylvania" + "first_name": "Cyrus", + "last_name": "Omar", + "institution": "Carnegie Mellon University" }, { - "first_name": "Marco", - "last_name": "Gaboardi", - "institution": "Buffalo State University" + "first_name": "Ian", + "last_name": "Voysey", + "institution": "Carnegie Mellon University" }, { - "first_name": "Justin", - "last_name": "Hsu", - "institution": "California University of Pennsylvania" + "first_name": "Michael", + "last_name": "Hilton", + "institution": "Oregon State University" }, { - "first_name": "Shin-ya", - "last_name": "Katsumata", - "institution": "Kyoto University" + "first_name": "Jonathan", + "last_name": "Aldrich", + "institution": "Carnegie Mellon University" }, { - "first_name": "Ikram", - "last_name": "Cherigui", - "institution": "" + "first_name": "Matthew A.", + "last_name": "Hammer", + "institution": "University of Colorado Boulder" } ], - "dblp_key": "conf/popl/AmorimGHKC17", + "dblp_key": "conf/popl/OmarVHAH17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009861", - "title": "Computational higher-dimensional type theory", - "abstract": "Formal constructive type theory has proved to be an effective language for mechanized proof. By avoiding non-constructive principles, such as the law of the excluded middle, type theory admits sharper proofs and broader interpretations of results. From a computer science perspective, interest in type theory arises from its applications to programming languages. Standard constructive type theories used in mechanization admit computational interpretations based on meta-mathematical normalization theorems. These proofs are notoriously brittle; any change to the theory potentially invalidates its computational meaning. As a case in point, Voevodsky's univalence axiom raises questions about the computational meaning of proofs.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009861", + "paper_id": "10.1145/3009837.3009898", + "title": "Contextual isomorphisms", + "abstract": "What is the right notion of \"isomorphism\" between types, in a simple type theory? The traditional answer is: a pair of terms that are inverse up to a specified congruence. We firstly argue that, in the presence of effects, this answer is too liberal and needs to be restricted, using Führmann's notion of thunkability in the case of value types (as in call-by-value), or using Munch-Maccagnoni's notion of linearity in the case of computation types (as in call-by-name). Yet that leaves us with different notions of isomorphism for different kinds of type.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009898", "conference_name": "POPL", "authors": [ { - "first_name": "Carlo", - "last_name": "Angiuli", + "first_name": "Paul Blain", + "last_name": "Levy", + "institution": "University of Birmingham" + } + ], + "dblp_key": "conf/popl/Levy17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009869", + "title": "Parallel functional arrays", + "abstract": "The goal of this paper is to develop a form of functional arrays (sequences) that are as efficient as imperative arrays, can be used in parallel, and have well defined cost-semantics. The key idea is to consider sequences with functional value semantics but non-functional cost semantics. Because the value semantics is functional, \"updating\" a sequence returns a new sequence. We allow operations on \"older\" sequences (called interior sequences) to be more expensive than operations on the \"most recent\" sequences (called leaf sequences).", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009869", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Ananya", + "last_name": "Kumar", "institution": "Carnegie Mellon University" }, { - "first_name": "Robert", - "last_name": "Harper", + "first_name": "Guy E.", + "last_name": "Blelloch", "institution": "Carnegie Mellon University" }, { - "first_name": "Todd M.", - "last_name": "Wilson", - "institution": "California State University, Fresno" + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" } ], - "dblp_key": "conf/popl/AngiuliHW17", + "dblp_key": "conf/popl/KumarBH17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009846", - "title": "Rigorous floating-point mixed-precision tuning", - "abstract": "Virtually all real-valued computations are carried out using floating-point data types and operations. The precision of these data types must be set with the goals of reducing the overall round-off error, but also emphasizing performance improvements. Often, a mixed-precision allocation achieves this optimum; unfortunately, there are no techniques available to compute such allocations and conservatively meet a given error target across all program inputs. In this work, we present a rigorous approach to precision allocation based on formal analysis via Symbolic Taylor Expansions, and error analysis based on interval functions. This approach is implemented in an automated tool called FPTuner that generates and solves a quadratically constrained quadratic program to obtain a precision-annotated version of the given expression. FPTuner automatically introduces all the requisite precision up and down casting operations. It also allows users to flexibly control precision allocation using constraints to cap the number of high precision operators as well as group operators to allocate the same precision to facilitate vectorization. We evaluate FPTuner by tuning several benchmarks and measuring the proportion of lower precision operators allocated as we increase the error threshold. We also measure the reduction in energy consumption resulting from executing mixed-precision tuned code on a real hardware platform. We observe significant energy savings in response to mixed-precision tuning, but also observe situations where unexpected compiler behaviors thwart intended optimizations.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009846", + "paper_id": "10.1145/3009837.3009879", + "title": "Learning nominal automata", + "abstract": "We present an Angluin-style algorithm to learn nominal automata, which are acceptors of languages over infinite (structured) alphabets. The abstract approach we take allows us to seamlessly extend known variations of the algorithm to this new setting. In particular we can learn a subclass of nominal non-deterministic automata. An implementation using a recently developed Haskell library for nominal computation is provided for preliminary experiments.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009879", "conference_name": "POPL", "authors": [ { - "first_name": "Wei‐Fan", - "last_name": "Chiang", - "institution": "University of Utah" - }, - { - "first_name": "Mark", - "last_name": "Baranowski", - "institution": "University of Utah" + "first_name": "Joshua", + "last_name": "Moerman", + "institution": "Radboud University Nijmegen" }, { - "first_name": "Ian", - "last_name": "Briggs", - "institution": "University of Utah" + "first_name": "Matteo", + "last_name": "Sammartino", + "institution": "University College London" }, { - "first_name": "Alexey", - "last_name": "Solovyev", - "institution": "University of Utah" + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "University College London" }, { - "first_name": "Ganesh", - "last_name": "Gopalakrishnan", - "institution": "University of Utah" + "first_name": "Bartek", + "last_name": "Klin", + "institution": "University of Warsaw" }, { - "first_name": "Zvonimir", - "last_name": "Rakamarić", - "institution": "University of Utah" + "first_name": "Michał", + "last_name": "Szynwelski", + "institution": "University of Warsaw" } ], - "dblp_key": "conf/popl/ChiangBBSGR17", + "dblp_key": "conf/popl/MoermanS0KS17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009888", - "title": "On verifying causal consistency", - "abstract": "Causal consistency is one of the most adopted consistency criteria for distributed implementations of data structures. It ensures that operations are executed at all sites according to their causal precedence. We address the issue of verifying automatically whether the executions of an implementation of a data structure are causally consistent. We consider two problems: (1) checking whether one single execution is causally consistent, which is relevant for developing testing and bug finding algorithms, and (2) verifying whether all the executions of an implementation are causally consistent.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009888", + "paper_id": "10.1145/3009837.3009873", + "title": "Stochastic invariants for probabilistic termination", + "abstract": "Termination is one of the basic liveness properties, and we study the termination problem for probabilistic programs with real-valued variables. Previous works focused on the qualitative problem that asks whether an input program terminates with probability 1 (almost-sure termination). A powerful approach for this qualitative problem is the notion of ranking supermartingales with respect to a given set of invariants. The quantitative problem (probabilistic termination) asks for bounds on the termination probability, and this problem has not been addressed yet. A fundamental and conceptual drawback of the existing approaches to address probabilistic termination is that even though the supermartingales consider the probabilistic behaviour of the programs, the invariants are obtained completely ignoring the probabilistic aspect (i.e., the invariants are obtained considering all behaviours with no information about the probability).", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009873", "conference_name": "POPL", "authors": [ { - "first_name": "Ahmed", - "last_name": "Bouajjani", - "institution": "Délégation Paris 7" - }, - { - "first_name": "Constantin", - "last_name": "Enea", - "institution": "Délégation Paris 7" + "first_name": "Krishnendu", + "last_name": "Chatterjee", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Rachid", - "last_name": "Guerraoui", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Petr", + "last_name": "Novotný", + "institution": "Institute of Science and Technology Austria" }, { - "first_name": "Jad", - "last_name": "Hamza", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Đorđe", + "last_name": "Žikelić", + "institution": "University of Cambridge" } ], - "dblp_key": "conf/popl/BouajjaniEGH17", + "dblp_key": "conf/popl/ChatterjeeNZ17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009883", - "title": "Ogre and Pythia: an invariance proof method for weak consistency models", - "abstract": "We design an invariance proof method for concurrent programs parameterised by a weak consistency model. The calculational design of the invariance proof method is by abstract interpretation of a truly parallel analytic semantics. This generalises the methods by Lamport and Owicki-Gries for sequential consistency. We use cat as an example of language to write consistency specifications of both concurrent programs and machine architectures.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009883", + "paper_id": "10.1145/3009837.3009866", + "title": "Type soundness proofs with definitional interpreters", + "abstract": "While type soundness proofs are taught in every graduate PL class, the gap between realistic languages and what is accessible to formal proofs is large. In the case of Scala, it has been shown that its formal model, the Dependent Object Types (DOT) calculus, cannot simultaneously support key metatheoretic properties such as environment narrowing and subtyping transitivity, which are usually required for a type soundness proof. Moreover, Scala and many other realistic languages lack a general substitution property.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009866", "conference_name": "POPL", "authors": [ { - "first_name": "Jade", - "last_name": "Alglave", - "institution": "Microsoft Research (United Kingdom)" + "first_name": "Nada", + "last_name": "Amin", + "institution": "École Polytechnique Fédérale de Lausanne" }, { - "first_name": "Patrick", - "last_name": "Cousot", - "institution": "New York University" + "first_name": "Tiark", + "last_name": "Rompf", + "institution": "Purdue University West Lafayette" } ], - "dblp_key": "conf/popl/AlglaveC17", + "dblp_key": "conf/popl/AminR17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009858", - "title": "Relational cost analysis", - "abstract": "Establishing quantitative bounds on the execution cost of programs is essential in many areas of computer science such as complexity analysis, compiler optimizations, security and privacy. Techniques based on program analysis, type systems and abstract interpretation are well-studied, but methods for analyzing how the execution costs of two programs compare to each other have not received attention. Naively combining the worst and best case execution costs of the two programs does not work well in many cases because such analysis forgets the similarities between the programs or the inputs.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009858", + "paper_id": "10.1145/3009837.3009868", + "title": "Beginner's luck: a language for property-based generators", + "abstract": "Property-based random testing à la QuickCheck requires building efficient generators for well-distributed random data satisfying complex logical predicates, but writing these generators can be difficult and error prone. We propose a domain-specific language in which generators are conveniently expressed by decorating predicates with lightweight annotations to control both the distribution of generated values and the amount of constraint solving that happens before each variable is instantiated. This language, called Luck, makes generators easier to write, read, and maintain.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009868", "conference_name": "POPL", "authors": [ { - "first_name": "Ezgi", - "last_name": "Çiçek", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Leonidas", + "last_name": "Lampropoulos", + "institution": "California University of Pennsylvania" }, { - "first_name": "Gilles", - "last_name": "Barthe", - "institution": "IMDEA Software Institute" + "first_name": "Diane", + "last_name": "Gallois-Wong", + "institution": "State Key Laboratory of Cryptology" }, { - "first_name": "Marco", - "last_name": "Gaboardi", - "institution": "Buffalo State University" + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Institut national de recherche en informatique et en automatique" }, { - "first_name": "Deepak", - "last_name": "Garg", - "institution": "Max Planck Institute for Software Systems" + "first_name": "John", + "last_name": "Hughes", + "institution": "Chalmers University of Technology" }, { - "first_name": "Jan", - "last_name": "Hoffmann", - "institution": "Carnegie Mellon University" + "first_name": "Benjamin C.", + "last_name": "Pierce", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Li-yao", + "last_name": "Xia", + "institution": "Institut national de recherche en informatique et en automatique" } ], - "dblp_key": "conf/popl/CicekBG0H17", + "dblp_key": "conf/popl/LampropoulosGHH17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009892", - "title": "Modules, abstraction, and parametric polymorphism", - "abstract": "Reynolds's Abstraction theorem forms the mathematical foundation for data abstraction. His setting was the polymorphic lambda calculus. Today, many modern languages, such as the ML family, employ rich module systems designed to give more expressive support for data abstraction than the polymorphic lambda calculus, but analogues of the Abstraction theorem for such module systems have lagged far behind.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009892", - "conference_name": "POPL", - "authors": [ + "paper_id": "10.1145/3009837.3009899", + "title": "A posteriori environment analysis with Pushdown Delta CFA", + "abstract": "Flow-driven higher-order inlining is blocked by free variables, yet current theories of environment analysis cannot reliably cope with multiply-bound variables. One of these, ΔCFA, is a promising theory based on stack change but is undermined by its finite-state model of the stack. We present Pushdown ΔCFA which takes a ΔCFA-approach to pushdown models of control flow and can cope with multiply-bound variables, even in the face of recursion.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009899", + "conference_name": "POPL", + "authors": [ { - "first_name": "Karl", - "last_name": "Crary", - "institution": "Carnegie Mellon University" + "first_name": "Kimball", + "last_name": "Germane", + "institution": "University of Utah" + }, + { + "first_name": "Matthew", + "last_name": "Might", + "institution": "University of Utah" } ], - "dblp_key": "conf/popl/Crary17", + "dblp_key": "conf/popl/GermaneM17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009862", - "title": "Intersection type calculi of bounded dimension", - "abstract": "A notion of dimension in intersection typed λ-calculi is presented. The dimension of a typed λ-term is given by the minimal norm of an elaboration (a proof theoretic decoration) necessary for typing the term at its type, and, intuitively, measures intersection introduction as a resource.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009862", + "paper_id": "10.1145/3009837.3009858", + "title": "Relational cost analysis", + "abstract": "Establishing quantitative bounds on the execution cost of programs is essential in many areas of computer science such as complexity analysis, compiler optimizations, security and privacy. Techniques based on program analysis, type systems and abstract interpretation are well-studied, but methods for analyzing how the execution costs of two programs compare to each other have not received attention. Naively combining the worst and best case execution costs of the two programs does not work well in many cases because such analysis forgets the similarities between the programs or the inputs.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009858", "conference_name": "POPL", "authors": [ { - "first_name": "Andrej", - "last_name": "Dudenhefner", - "institution": "TU Dortmund University" + "first_name": "Ezgi", + "last_name": "Çiçek", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Jakob", - "last_name": "Rehof", - "institution": "TU Dortmund University" + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software Institute" + }, + { + "first_name": "Marco", + "last_name": "Gaboardi", + "institution": "Buffalo State University" + }, + { + "first_name": "Deepak", + "last_name": "Garg", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" } ], - "dblp_key": "conf/popl/DudenhefnerR17", + "dblp_key": "conf/popl/CicekBG0H17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009882", - "title": "Polymorphism, subtyping, and type inference in MLsub", - "abstract": "We present a type system combining subtyping and ML-style parametric polymorphism. Unlike previous work, our system supports type inference and has compact principal types. We demonstrate this system in the minimal language MLsub, which types a strict superset of core ML programs.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009882", + "paper_id": "10.1145/3009837.3009861", + "title": "Computational higher-dimensional type theory", + "abstract": "Formal constructive type theory has proved to be an effective language for mechanized proof. By avoiding non-constructive principles, such as the law of the excluded middle, type theory admits sharper proofs and broader interpretations of results. From a computer science perspective, interest in type theory arises from its applications to programming languages. Standard constructive type theories used in mechanization admit computational interpretations based on meta-mathematical normalization theorems. These proofs are notoriously brittle; any change to the theory potentially invalidates its computational meaning. As a case in point, Voevodsky's univalence axiom raises questions about the computational meaning of proofs.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009861", "conference_name": "POPL", "authors": [ { - "first_name": "Stephen K.", - "last_name": "Dolan", - "institution": "University of Cambridge" + "first_name": "Carlo", + "last_name": "Angiuli", + "institution": "Carnegie Mellon University" }, { - "first_name": "Alan", - "last_name": "Mycroft", - "institution": "University of Cambridge" + "first_name": "Robert", + "last_name": "Harper", + "institution": "Carnegie Mellon University" + }, + { + "first_name": "Todd M.", + "last_name": "Wilson", + "institution": "California State University, Fresno" } ], - "dblp_key": "conf/popl/DolanM17", + "dblp_key": "conf/popl/AngiuliHW17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009844", - "title": "Monadic second-order logic on finite sequences", - "abstract": "We extend the weak monadic second-order logic of one successor on finite strings (M2L-STR) to symbolic alphabets by allowing character predicates to range over decidable quantifier free theories instead of finite alphabets. We call this logic, which is able to describe sequences over complex and potentially infinite domains, symbolic M2L-STR (S-M2L-STR). We then present a decision procedure for S-M2L-STR based on a reduction to symbolic finite automata, a decidable extension of finite automata that allows transitions to carry predicates and can therefore model symbolic alphabets. The reduction constructs a symbolic automaton over an alphabet consisting of pairs of symbols where the first element of the pair is a symbol in the original formula’s alphabet, while the second element is a bit-vector. To handle this modified alphabet we show that the Cartesian product of two decidable Boolean algebras (e.g., the formula’s one and the bit-vector’s one) also forms a decidable Boolean algebras. To make the decision procedure practical, we propose two efficient representations of the Cartesian product of two Boolean algebras, one based on algebraic decision diagrams and one on a variant of Shannon expansions. Finally, we implement our decision procedure and evaluate it on more than 10,000 formulas. Despite the generality, our implementation has comparable performance with the state-of-the-art M2L-STR solvers.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009844", + "paper_id": "10.1145/3009837.3009885", + "title": "Fast polyhedra abstract domain", + "abstract": "Numerical abstract domains are an important ingredient of modern static analyzers used for verifying critical program properties (e.g., absence of buffer overflow or memory safety). Among the many numerical domains introduced over the years, Polyhedra is the most expressive one, but also the most expensive: it has worst-case exponential space and time complexity. As a consequence, static analysis with the Polyhedra domain is thought to be impractical when applied to large scale, real world programs.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009885", "conference_name": "POPL", "authors": [ { - "first_name": "Loris", - "last_name": "D’Antoni", - "institution": "University of Wisconsin–Madison" + "first_name": "Gagandeep", + "last_name": "Singh", + "institution": "ETH Zurich" }, { - "first_name": "Margus", - "last_name": "Veanes", - "institution": "Microsoft (United States)" + "first_name": "Markus", + "last_name": "Püschel", + "institution": "ETH Zurich" + }, + { + "first_name": "Martin", + "last_name": "Vechev", + "institution": "ETH Zurich" } ], - "dblp_key": "conf/popl/DAntoniV17", + "dblp_key": "conf/popl/SinghPV17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009841", - "title": "The exp-log normal form of types: decomposing extensional equality and representing terms compactly", - "abstract": "Lambda calculi with algebraic data types lie at the core of functional programming languages and proof assistants, but conceal at least two fundamental theoretical problems already in the presence of the simplest non-trivial data type, the sum type. First, we do not know of an explicit and implemented algorithm for deciding the beta-eta-equality of terms---and this in spite of the first decidability results proven two decades ago. Second, it is not clear how to decide when two types are essentially the same, i.e. isomorphic, in spite of the meta-theoretic results on decidability of the isomorphism. In this paper, we present the exp-log normal form of types---derived from the representation of exponential polynomials via the unary exponential and logarithmic functions---that any type built from arrows, products, and sums, can be isomorphically mapped to. The type normal form can be used as a simple heuristic for deciding type isomorphism, thanks to the fact that it is a systematic application of the high-school identities. We then show that the type normal form allows to reduce the standard beta-eta equational theory of the lambda calculus to a specialized version of itself, while preserving the completeness of equality on terms. We end by describing an alternative representation of normal terms of the lambda calculus with sums, together with a Coq-implemented converter into/from our new term calculus. The difference with the only other previously implemented heuristic for deciding interesting instances of eta-equality by Balat, Di Cosmo, and Fiore, is that we exploit the type information of terms substantially and this often allows us to obtain a canonical representation of terms without performing sophisticated term analyses.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009841", + "paper_id": "10.1145/3009837.3009865", + "title": "Sums of uncertainty: refinements go gradual", + "abstract": "A long-standing shortcoming of statically typed functional languages is that type checking does not rule out pattern-matching failures (run-time match exceptions). Refinement types distinguish different values of datatypes; if a program annotated with refinements passes type checking, pattern-matching failures become impossible. Unfortunately, refinement is a monolithic property of a type, exacerbating the difficulty of adding refinement types to nontrivial programs.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009865", "conference_name": "POPL", "authors": [ { - "first_name": "Danko", - "last_name": "Ilik", - "institution": "" + "first_name": "Khurram A.", + "last_name": "Jafery", + "institution": "University of British Columbia" + }, + { + "first_name": "Jana", + "last_name": "Dunfield", + "institution": "University of British Columbia" } ], - "dblp_key": "conf/popl/Ilik17", + "dblp_key": "conf/popl/JaferyD17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009871", - "title": "Java generics are turing complete", - "abstract": "This paper describes a reduction from the halting problem of Turing machines to subtype checking in Java. It follows that subtype checking in Java is undecidable, which answers a question posed by Kennedy and Pierce in 2007. It also follows that Java's type checker can recognize any recursive language, which improves a result of Gill and Levy from 2016. The latter point is illustrated by a parser generator for fluent interfaces.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009871", + "paper_id": "10.1145/3009837.3009887", + "title": "Coming to terms with quantified reasoning", + "abstract": "The theory of finite term algebras provides a natural framework to describe the semantics of functional languages. The ability to efficiently reason about term algebras is essential to automate program analysis and verification for functional or imperative programs over inductively defined data types such as lists and trees. However, as the theory of finite term algebras is not finitely axiomatizable, reasoning about quantified properties over term algebras is challenging.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009887", "conference_name": "POPL", "authors": [ { - "first_name": "Radu", - "last_name": "Grigore", - "institution": "University of Kent" + "first_name": "Laura", + "last_name": "Kovács", + "institution": "TU Wien" + }, + { + "first_name": "Simon", + "last_name": "Robillard", + "institution": "Chalmers University of Technology" + }, + { + "first_name": "Андрей", + "last_name": "Воронков", + "institution": "Chalmers University of Technology" } ], - "dblp_key": "conf/popl/Grigore17", + "dblp_key": "conf/popl/KovacsRV17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009893", - "title": "Thread modularity at many levels: a pearl in compositional verification", - "abstract": "A thread-modular proof for the correctness of a concurrent program is based on an inductive and interference-free annotation of each thread. It is well-known that the corresponding proof system is not complete (unless one adds auxiliary variables). We describe a hierarchy of proof systems where each level k corresponds to a generalized notion of thread modularity (level 1 corresponds to the original notion). Each level is strictly more expressive than the previous. Further, each level precisely captures programs that can be proved using uniform Ashcroft invariants with k universal quantifiers. We demonstrate the usefulness of the hierarchy by giving a compositional proof of the Mach shootdown algorithm for TLB consistency. We show a proof at level 2 that shows the algorithm is correct for an arbitrary number of CPUs. However, there is no proof for the algorithm at level 1 which does not involve auxiliary state.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009893", + "paper_id": "10.1145/3009837.3009842", + "title": "Towards automatic resource bound analysis for OCaml", + "abstract": "This article presents a resource analysis system for OCaml programs. The system automatically derives worst-case resource bounds for higher-order polymorphic programs with user-defined inductive types. The technique is parametric in the resource and can derive bounds for time, memory allocations and energy usage. The derived bounds are multivariate resource polynomials which are functions of different size parameters that depend on the standard OCaml types. Bound inference is fully automatic and reduced to a linear optimization problem that is passed to an off-the-shelf LP solver. Technically, the analysis system is based on a novel multivariate automatic amortized resource analysis (AARA). It builds on existing work on linear AARA for higher-order programs with user-defined inductive types and on multivariate AARA for first-order programs with built-in lists and binary trees. This is the first amortized analysis, that automatically derives polynomial bounds for higher-order functions and polynomial bounds that depend on user-defined inductive types. Moreover, the analysis handles a limited form of side effects and even outperforms the linear bound inference of previous systems. At the same time, it preserves the expressivity and efficiency of existing AARA techniques. The practicality of the analysis system is demonstrated with an implementation and integration with Inria's OCaml compiler. The implementation is used to automatically derive resource bounds for 411 functions and 6018 lines of code derived from OCaml libraries, the CompCert compiler, and implementations of textbook algorithms. In a case study, the system infers bounds on the number of queries that are sent by OCaml programs to DynamoDB, a commercial NoSQL cloud database service.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009842", "conference_name": "POPL", "authors": [ { - "first_name": "Jochen", - "last_name": "Hoenicke", - "institution": "University of Freiburg" + "first_name": "Jan", + "last_name": "Hoffmann", + "institution": "Carnegie Mellon University" }, { - "first_name": "Rupak", - "last_name": "Majumdar", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Ankush", + "last_name": "Das", + "institution": "Carnegie Mellon University" }, { - "first_name": "Andreas", - "last_name": "Podelski", - "institution": "University of Freiburg" + "first_name": "Shu-Chun", + "last_name": "Weng", + "institution": "Yale University" } ], - "dblp_key": "conf/popl/HoenickeMP17", + "dblp_key": "conf/popl/HoffmannDW17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009899", - "title": "A posteriori environment analysis with Pushdown Delta CFA", - "abstract": "Flow-driven higher-order inlining is blocked by free variables, yet current theories of environment analysis cannot reliably cope with multiply-bound variables. One of these, ΔCFA, is a promising theory based on stack change but is undermined by its finite-state model of the stack. We present Pushdown ΔCFA which takes a ΔCFA-approach to pushdown models of control flow and can cope with multiply-bound variables, even in the face of recursion.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009899", + "paper_id": "10.1145/3009837.3009871", + "title": "Java generics are turing complete", + "abstract": "This paper describes a reduction from the halting problem of Turing machines to subtype checking in Java. It follows that subtype checking in Java is undecidable, which answers a question posed by Kennedy and Pierce in 2007. It also follows that Java's type checker can recognize any recursive language, which improves a result of Gill and Levy from 2016. The latter point is illustrated by a parser generator for fluent interfaces.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009871", "conference_name": "POPL", "authors": [ { - "first_name": "Kimball", - "last_name": "Germane", - "institution": "University of Utah" - }, - { - "first_name": "Matthew", - "last_name": "Might", - "institution": "University of Utah" + "first_name": "Radu", + "last_name": "Grigore", + "institution": "University of Kent" } ], - "dblp_key": "conf/popl/GermaneM17", + "dblp_key": "conf/popl/Grigore17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009851", - "title": "Component-based synthesis for complex APIs", - "abstract": "Component-based approaches to program synthesis assemble programs from a database of existing components, such as methods provided by an API. In this paper, we present a novel type-directed algorithm for component-based synthesis. The key novelty of our approach is the use of a compact Petri-net representation to model relationships between methods in an API. Given a target method signature S, our approach performs reachability analysis on the underlying Petri-net model to identify sequences of method calls that could be used to synthesize an implementation of S. The programs synthesized by our algorithm are guaranteed to type check and pass all test cases provided by the user.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009851", + "paper_id": "10.1145/3009837.3009892", + "title": "Modules, abstraction, and parametric polymorphism", + "abstract": "Reynolds's Abstraction theorem forms the mathematical foundation for data abstraction. His setting was the polymorphic lambda calculus. Today, many modern languages, such as the ML family, employ rich module systems designed to give more expressive support for data abstraction than the polymorphic lambda calculus, but analogues of the Abstraction theorem for such module systems have lagged far behind.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009892", "conference_name": "POPL", "authors": [ { - "first_name": "Yu", - "last_name": "Feng", - "institution": "The University of Texas at Austin" - }, - { - "first_name": "Ruben", - "last_name": "Martins", - "institution": "The University of Texas at Austin" - }, - { - "first_name": "Yuepeng", - "last_name": "Wang", - "institution": "The University of Texas at Austin" - }, - { - "first_name": "Işıl", - "last_name": "Dillig", - "institution": "The University of Texas at Austin" - }, - { - "first_name": "Thomas", - "last_name": "Reps", - "institution": "University of Wisconsin–Madison" + "first_name": "Karl", + "last_name": "Crary", + "institution": "Carnegie Mellon University" } ], - "dblp_key": "conf/popl/FengM0DR17", + "dblp_key": "conf/popl/Crary17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009839", - "title": "Mixed-size concurrency: ARM, POWER, C/C++11, and SC", - "abstract": "Previous work on the semantics of relaxed shared-memory concurrency has only considered the case in which each load reads the data of exactly one store. In practice, however, multiprocessors support mixed-size accesses, and these are used by systems software and (to some degree) exposed at the C/C++ language level. A semantic foundation for software, therefore, has to address them.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009839", + "paper_id": "10.1145/3009837.3009859", + "title": "The geometry of parallelism: classical, probabilistic, and quantum effects", + "abstract": "We introduce a Geometry of Interaction model for higher-order quantum computation, and prove its adequacy for a fully fledged quantum programming language in which entanglement, duplication, and recursion are all available.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009859", "conference_name": "POPL", "authors": [ { - "first_name": "Shaked", - "last_name": "Flur", - "institution": "University of Cambridge" + "first_name": "Ugo Dal", + "last_name": "Lago", + "institution": "University of Bologna" }, { - "first_name": "Susmit", - "last_name": "Sarkar", - "institution": "University of St Andrews" + "first_name": "Claudia", + "last_name": "Faggian", + "institution": "Institut de Recherche en Informatique Fondamentale" }, { - "first_name": "Christopher", - "last_name": "Pulte", - "institution": "University of Cambridge" + "first_name": "Benoît", + "last_name": "Valiron", + "institution": "Université Paris-Saclay" }, { - "first_name": "Kyndylan", - "last_name": "Nienhuis", - "institution": "University of Cambridge" - }, + "first_name": "Akira", + "last_name": "Yoshimizu", + "institution": "The University of Tokyo" + } + ], + "dblp_key": "conf/popl/LagoFVY17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009854", + "title": "On the relationship between higher-order recursion schemes and higher-order fixpoint logic", + "abstract": "We study the relationship between two kinds of higher-order extensions", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009854", + "conference_name": "POPL", + "authors": [ { - "first_name": "Luc", - "last_name": "Maranget", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Naoki", + "last_name": "Kobayashi", + "institution": "The University of Tokyo" }, { - "first_name": "Kathryn E.", - "last_name": "Gray", - "institution": "University of Cambridge" + "first_name": "Étienne", + "last_name": "Lozes", + "institution": "Centre National de la Recherche Scientifique" }, { - "first_name": "Ali", - "last_name": "Sezgin", - "institution": "University of Cambridge" - }, + "first_name": "Florian", + "last_name": "Bruse", + "institution": "University of Kassel" + } + ], + "dblp_key": "conf/popl/KobayashiLB17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009863", + "title": "Automatically generating the dynamic semantics of gradually typed languages", + "abstract": "Many language designers have adopted gradual typing. However, there remains open questions regarding how to gradualize languages. Cimini and Siek (2016) created a methodology and algorithm to automatically generate the type system of a gradually typed language from a fully static version of the language. In this paper, we address the next challenge of how to automatically generate the dynamic semantics of gradually typed languages. Such languages typically use an intermediate language with explicit casts.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009863", + "conference_name": "POPL", + "authors": [ { - "first_name": "Mark", - "last_name": "Batty", - "institution": "University of Kent" + "first_name": "Matteo", + "last_name": "Cimini", + "institution": "Indiana University" }, { - "first_name": "Peter", - "last_name": "Sewell", - "institution": "University of Cambridge" + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" } ], - "dblp_key": "conf/popl/FlurSPNMGSBS17", + "dblp_key": "conf/popl/CiminiS17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009865", - "title": "Sums of uncertainty: refinements go gradual", - "abstract": "A long-standing shortcoming of statically typed functional languages is that type checking does not rule out pattern-matching failures (run-time match exceptions). Refinement types distinguish different values of datatypes; if a program annotated with refinements passes type checking, pattern-matching failures become impossible. Unfortunately, refinement is a monolithic property of a type, exacerbating the difficulty of adding refinement types to nontrivial programs.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009865", + "paper_id": "10.1145/3009837.3009870", + "title": "Analyzing divergence in bisimulation semantics", + "abstract": "Some bisimulation based abstract equivalence relations may equate divergent systems with non-divergent ones, examples including weak bisimulation equivalence and branching bisimulation equivalence. Thus extra efforts are needed to analyze divergence for the compared systems. In this paper we propose a new method for analyzing divergence in bisimulation semantics, which relies only on simple observations of individual transitions. We show that this method can verify several typical divergence preserving bisimulation equivalences including two well-known ones. As an application case study, we use the proposed method to verify the HSY collision stack to draw the conclusion that the stack implementation is correct in terms of linearizability with lock-free progress condition.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009870", "conference_name": "POPL", "authors": [ { - "first_name": "Khurram A.", - "last_name": "Jafery", - "institution": "University of British Columbia" + "first_name": "Xinxin", + "last_name": "Liu", + "institution": "Chinese Academy of Sciences" }, { - "first_name": "Jana", - "last_name": "Dunfield", - "institution": "University of British Columbia" + "first_name": "Tingting", + "last_name": "Yu", + "institution": "Institute of Software" + }, + { + "first_name": "Wenhui", + "last_name": "Zhang", + "institution": "Institute of Software" } ], - "dblp_key": "conf/popl/JaferyD17", + "dblp_key": "conf/popl/LiuYZ17", "venue": "popl", "year": 2017 }, @@ -804,7 +891,7 @@ "paper_id": "10.1145/3009837.3009876", "title": "LOIS: syntax and semantics", "abstract": "We present the semantics of an imperative programming language called LOIS (Looping Over Infinite Sets), which allows iterating through certain infinite sets, in finite time. Our semantics intuitively correspond to execution of infinitely many threads in parallel. This allows to merge the power of abstract mathematical constructions into imperative programming. Infinite sets are internally represented using first order formulas over some underlying logical structure, and SMT solvers are employed to evaluate programs.", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3009876", "conference_name": "POPL", "authors": [ @@ -824,778 +911,673 @@ "year": 2017 }, { - "paper_id": "10.1145/3009837.3009854", - "title": "On the relationship between higher-order recursion schemes and higher-order fixpoint logic", - "abstract": "We study the relationship between two kinds of higher-order extensions", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009854", + "paper_id": "10.1145/3009837.3009893", + "title": "Thread modularity at many levels: a pearl in compositional verification", + "abstract": "A thread-modular proof for the correctness of a concurrent program is based on an inductive and interference-free annotation of each thread. It is well-known that the corresponding proof system is not complete (unless one adds auxiliary variables). We describe a hierarchy of proof systems where each level k corresponds to a generalized notion of thread modularity (level 1 corresponds to the original notion). Each level is strictly more expressive than the previous. Further, each level precisely captures programs that can be proved using uniform Ashcroft invariants with k universal quantifiers. We demonstrate the usefulness of the hierarchy by giving a compositional proof of the Mach shootdown algorithm for TLB consistency. We show a proof at level 2 that shows the algorithm is correct for an arbitrary number of CPUs. However, there is no proof for the algorithm at level 1 which does not involve auxiliary state.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009893", "conference_name": "POPL", "authors": [ { - "first_name": "Naoki", - "last_name": "Kobayashi", - "institution": "The University of Tokyo" + "first_name": "Jochen", + "last_name": "Hoenicke", + "institution": "University of Freiburg" }, { - "first_name": "Étienne", - "last_name": "Lozes", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Rupak", + "last_name": "Majumdar", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Florian", - "last_name": "Bruse", - "institution": "University of Kassel" + "first_name": "Andreas", + "last_name": "Podelski", + "institution": "University of Freiburg" } ], - "dblp_key": "conf/popl/KobayashiLB17", + "dblp_key": "conf/popl/HoenickeMP17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009842", - "title": "Towards automatic resource bound analysis for OCaml", - "abstract": "This article presents a resource analysis system for OCaml programs. The system automatically derives worst-case resource bounds for higher-order polymorphic programs with user-defined inductive types. The technique is parametric in the resource and can derive bounds for time, memory allocations and energy usage. The derived bounds are multivariate resource polynomials which are functions of different size parameters that depend on the standard OCaml types. Bound inference is fully automatic and reduced to a linear optimization problem that is passed to an off-the-shelf LP solver. Technically, the analysis system is based on a novel multivariate automatic amortized resource analysis (AARA). It builds on existing work on linear AARA for higher-order programs with user-defined inductive types and on multivariate AARA for first-order programs with built-in lists and binary trees. This is the first amortized analysis, that automatically derives polynomial bounds for higher-order functions and polynomial bounds that depend on user-defined inductive types. Moreover, the analysis handles a limited form of side effects and even outperforms the linear bound inference of previous systems. At the same time, it preserves the expressivity and efficiency of existing AARA techniques. The practicality of the analysis system is demonstrated with an implementation and integration with Inria's OCaml compiler. The implementation is used to automatically derive resource bounds for 411 functions and 6018 lines of code derived from OCaml libraries, the CompCert compiler, and implementations of textbook algorithms. In a case study, the system infers bounds on the number of queries that are sent by OCaml programs to DynamoDB, a commercial NoSQL cloud database service.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009842", + "paper_id": "10.1145/3009837.3009851", + "title": "Component-based synthesis for complex APIs", + "abstract": "Component-based approaches to program synthesis assemble programs from a database of existing components, such as methods provided by an API. In this paper, we present a novel type-directed algorithm for component-based synthesis. The key novelty of our approach is the use of a compact Petri-net representation to model relationships between methods in an API. Given a target method signature S, our approach performs reachability analysis on the underlying Petri-net model to identify sequences of method calls that could be used to synthesize an implementation of S. The programs synthesized by our algorithm are guaranteed to type check and pass all test cases provided by the user.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009851", "conference_name": "POPL", "authors": [ { - "first_name": "Jan", - "last_name": "Hoffmann", - "institution": "Carnegie Mellon University" + "first_name": "Yu", + "last_name": "Feng", + "institution": "The University of Texas at Austin" }, { - "first_name": "Ankush", - "last_name": "Das", - "institution": "Carnegie Mellon University" + "first_name": "Ruben", + "last_name": "Martins", + "institution": "The University of Texas at Austin" }, { - "first_name": "Shu-Chun", - "last_name": "Weng", - "institution": "Yale University" - } - ], - "dblp_key": "conf/popl/HoffmannDW17", - "venue": "popl", - "year": 2017 - }, - { - "paper_id": "10.1145/3009837.3009855", - "title": "Interactive proofs in higher-order concurrent separation logic", - "abstract": "When using a proof assistant to reason in an embedded logic -- like separation logic -- one cannot benefit from the proof contexts and basic tactics of the proof assistant. This results in proofs that are at a too low level of abstraction because they are cluttered with bookkeeping code related to manipulating the object logic.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009855", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Robbert", - "last_name": "Krebbers", - "institution": "Delft University of Technology" + "first_name": "Yuepeng", + "last_name": "Wang", + "institution": "The University of Texas at Austin" }, { - "first_name": "Amin", - "last_name": "Timany", - "institution": "KU Leuven" + "first_name": "Işıl", + "last_name": "Dillig", + "institution": "The University of Texas at Austin" }, { - "first_name": "Lars", - "last_name": "Birkedal", - "institution": "Aarhus University" + "first_name": "Thomas", + "last_name": "Reps", + "institution": "University of Wisconsin–Madison" } ], - "dblp_key": "conf/popl/KrebbersTB17", + "dblp_key": "conf/popl/FengM0DR17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009860", - "title": "A short counterexample property for safety and liveness verification of fault-tolerant distributed algorithms", - "abstract": "Distributed algorithms have many mission-critical applications ranging from embedded systems and replicated databases to cloud computing. Due to asynchronous communication, process faults, or network failures, these algorithms are difficult to design and verify. Many algorithms achieve fault tolerance by using threshold guards that, for instance, ensure that a process waits until it has received an acknowledgment from a majority of its peers. Consequently, domain-specific languages for fault-tolerant distributed systems offer language support for threshold guards.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009860", + "paper_id": "10.1145/3009837.3009886", + "title": "Type systems as macros", + "abstract": "We present Turnstile, a metalanguage for creating typed embedded languages. To implement the type system, programmers write type checking rules resembling traditional judgment syntax. To implement the semantics, they incorporate elaborations into these rules. Turnstile critically depends on the idea of linguistic reuse. It exploits a macro system in a novel way to simultaneously type check and rewrite a surface program into a target language. Reusing a macro system also yields modular implementations whose rules may be mixed and matched to create other languages. Combined with typical compiler and runtime reuse, Turnstile produces performant typed embedded languages with little effort.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009886", "conference_name": "POPL", "authors": [ { - "first_name": "Igor", - "last_name": "Konnov", - "institution": "TU Wien" - }, - { - "first_name": "Marijana", - "last_name": "Lazić", - "institution": "TU Wien" + "first_name": "Stephen", + "last_name": "Chang", + "institution": "Northeastern University" }, { - "first_name": "Helmut", - "last_name": "Veith", - "institution": "TU Wien" + "first_name": "Alex", + "last_name": "Knauth", + "institution": "Northeastern University" }, { - "first_name": "Josef", - "last_name": "Widder", - "institution": "TU Wien" + "first_name": "Ben", + "last_name": "Greenman", + "institution": "Northeastern University" } ], - "dblp_key": "conf/popl/KonnovLVW17", + "dblp_key": "conf/popl/ChangKG17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009880", - "title": "Stream fusion, to completeness", - "abstract": "Stream processing is mainstream (again): Widely-used stream libraries are now available for virtually all modern OO and functional languages, from Java to C# to Scala to OCaml to Haskell. Yet expressivity and performance are still lacking. For instance, the popular, well-optimized Java 8 streams do not support the zip operator and are still an order of magnitude slower than hand-written loops.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009880", + "paper_id": "10.1145/3009837.3009839", + "title": "Mixed-size concurrency: ARM, POWER, C/C++11, and SC", + "abstract": "Previous work on the semantics of relaxed shared-memory concurrency has only considered the case in which each load reads the data of exactly one store. In practice, however, multiprocessors support mixed-size accesses, and these are used by systems software and (to some degree) exposed at the C/C++ language level. A semantic foundation for software, therefore, has to address them.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009839", "conference_name": "POPL", "authors": [ { - "first_name": "Oleg", - "last_name": "Kiselyov", - "institution": "Tohoku University" + "first_name": "Shaked", + "last_name": "Flur", + "institution": "University of Cambridge" }, { - "first_name": "Aggelos", - "last_name": "Biboudis", - "institution": "National and Kapodistrian University of Athens" + "first_name": "Susmit", + "last_name": "Sarkar", + "institution": "University of St Andrews" }, { - "first_name": "Nick", - "last_name": "Palladinos", - "institution": "" + "first_name": "Christopher", + "last_name": "Pulte", + "institution": "University of Cambridge" }, { - "first_name": "Yannis", - "last_name": "Smaragdakis", - "institution": "National and Kapodistrian University of Athens" - } - ], - "dblp_key": "conf/popl/KiselyovBPS17", - "venue": "popl", - "year": 2017 - }, - { - "paper_id": "10.1145/3009837.3009850", - "title": "A promising semantics for relaxed-memory concurrency", - "abstract": "Despite many years of research, it has proven very difficult to develop a memory model for concurrent programming languages that adequately balances the conflicting desiderata of programmers, compilers, and hardware. In this paper, we propose the first relaxed memory model that (1) accounts for a broad spectrum of features from the C++11 concurrency model, (2) is implementable, in the sense that it provably validates many standard compiler optimizations and reorderings, as well as standard compilation schemes to x86-TSO and Power, (3) justifies simple invariant-based reasoning, thus demonstrating the absence of bad \"out-of-thin-air\" behaviors, (4) supports \"DRF\" guarantees, ensuring that programmers who use sufficient synchronization need not understand the full complexities of relaxed-memory semantics, and (5) defines the semantics of racy programs without relying on undefined behaviors, which is a prerequisite for applicability to type-safe languages like Java.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009850", - "conference_name": "POPL", - "authors": [ + "first_name": "Kyndylan", + "last_name": "Nienhuis", + "institution": "University of Cambridge" + }, { - "first_name": "Jeehoon", - "last_name": "Kang", - "institution": "Seoul National University" + "first_name": "Luc", + "last_name": "Maranget", + "institution": "Institut national de recherche en informatique et en automatique" }, { - "first_name": "Chung-Kil", - "last_name": "Hur", - "institution": "Seoul National University" + "first_name": "Kathryn E.", + "last_name": "Gray", + "institution": "University of Cambridge" }, { - "first_name": "Ori", - "last_name": "Lahav", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Ali", + "last_name": "Sezgin", + "institution": "University of Cambridge" }, { - "first_name": "Viktor", - "last_name": "Vafeiadis", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" }, { - "first_name": "Derek", - "last_name": "Dreyer", - "institution": "Max Planck Institute for Software Systems" + "first_name": "Peter", + "last_name": "Sewell", + "institution": "University of Cambridge" } ], - "dblp_key": "conf/popl/KangHLVD17", + "dblp_key": "conf/popl/FlurSPNMGSBS17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009877", - "title": "A relational model of types-and-effects in higher-order concurrent separation logic", - "abstract": "Recently we have seen a renewed interest in programming languages that tame the complexity of state and concurrency through refined type systems with more fine-grained control over effects. In addition to simplifying reasoning and eliminating whole classes of bugs, statically tracking effects opens the door to advanced compiler optimizations.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009877", + "paper_id": "10.1145/3009837.3009891", + "title": "A program optimization for automatic database result caching", + "abstract": "Most popular Web applications rely on persistent databases based on languages like SQL for declarative specification of data models and the operations that read and modify them. As applications scale up in user base, they often face challenges responding quickly enough to the high volume of requests. A common aid is caching of database results in the application's memory space, taking advantage of program-specific knowledge of which caching schemes are sound and useful, embodied in handwritten modifications that make the program less maintainable. These modifications also require nontrivial reasoning about the read-write dependencies across operations. In this paper, we present a compiler optimization that automatically adds sound SQL caching to Web applications coded in the Ur/Web domain-specific functional language, with no modifications required to source code. We use a custom cache implementation that supports concurrent operations without compromising the transactional semantics of the database abstraction. Through experiments with microbenchmarks and production Ur/Web applications, we show that our optimization in many cases enables an easy doubling or more of an application's throughput, requiring nothing more than passing an extra command-line flag to the compiler.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009891", "conference_name": "POPL", "authors": [ { - "first_name": "Morten", - "last_name": "Krogh-Jespersen", - "institution": "Aarhus University" - }, - { - "first_name": "Kasper", - "last_name": "Svendsen", - "institution": "University of Cambridge" + "first_name": "Ziv", + "last_name": "Scully", + "institution": "Carnegie Mellon University" }, { - "first_name": "Lars", - "last_name": "Birkedal", - "institution": "Aarhus University" + "first_name": "Adam", + "last_name": "Chlipala", + "institution": "Massachusetts Institute of Technology" } ], - "dblp_key": "conf/popl/Krogh-Jespersen17", + "dblp_key": "conf/popl/ScullyC17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009869", - "title": "Parallel functional arrays", - "abstract": "The goal of this paper is to develop a form of functional arrays (sequences) that are as efficient as imperative arrays, can be used in parallel, and have well defined cost-semantics. The key idea is to consider sequences with functional value semantics but non-functional cost semantics. Because the value semantics is functional, \"updating\" a sequence returns a new sequence. We allow operations on \"older\" sequences (called interior sequences) to be more expensive than operations on the \"most recent\" sequences (called leaf sequences).", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009869", + "paper_id": "10.1145/3009837.3009897", + "title": "Do be do be do", + "abstract": "We explore the design and implementation of Frank, a strict functional programming language with a bidirectional effect type system designed from the ground up around a novel variant of Plotkin and Pretnar's effect handler abstraction.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009897", "conference_name": "POPL", "authors": [ { - "first_name": "Ananya", - "last_name": "Kumar", - "institution": "Carnegie Mellon University" + "first_name": "Sam", + "last_name": "Lindley", + "institution": "University of Edinburgh" }, { - "first_name": "Guy E.", - "last_name": "Blelloch", - "institution": "Carnegie Mellon University" + "first_name": "Conor", + "last_name": "McBride", + "institution": "University of Strathclyde" }, { - "first_name": "Robert", - "last_name": "Harper", - "institution": "Carnegie Mellon University" + "first_name": "Craig", + "last_name": "McLaughlin", + "institution": "University of Edinburgh" } ], - "dblp_key": "conf/popl/KumarBH17", + "dblp_key": "conf/popl/LindleyMM17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009887", - "title": "Coming to terms with quantified reasoning", - "abstract": "The theory of finite term algebras provides a natural framework to describe the semantics of functional languages. The ability to efficiently reason about term algebras is essential to automate program analysis and verification for functional or imperative programs over inductively defined data types such as lists and trees. However, as the theory of finite term algebras is not finitely axiomatizable, reasoning about quantified properties over term algebras is challenging.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009887", + "paper_id": "10.1145/3009837.3009880", + "title": "Stream fusion, to completeness", + "abstract": "Stream processing is mainstream (again): Widely-used stream libraries are now available for virtually all modern OO and functional languages, from Java to C# to Scala to OCaml to Haskell. Yet expressivity and performance are still lacking. For instance, the popular, well-optimized Java 8 streams do not support the zip operator and are still an order of magnitude slower than hand-written loops.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009880", "conference_name": "POPL", "authors": [ { - "first_name": "Laura", - "last_name": "Kovács", - "institution": "TU Wien" + "first_name": "Oleg", + "last_name": "Kiselyov", + "institution": "Tohoku University" }, { - "first_name": "Simon", - "last_name": "Robillard", - "institution": "Chalmers University of Technology" + "first_name": "Aggelos", + "last_name": "Biboudis", + "institution": "National and Kapodistrian University of Athens" }, { - "first_name": "Андрей", - "last_name": "Воронков", - "institution": "Chalmers University of Technology" - } - ], - "dblp_key": "conf/popl/KovacsRV17", - "venue": "popl", - "year": 2017 - }, - { - "paper_id": "10.1145/3009837.3009872", - "title": "Type directed compilation of row-typed algebraic effects", - "abstract": "Algebraic effect handlers, introduced by Plotkin and Power in 2002,", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009872", - "conference_name": "POPL", - "authors": [ + "first_name": "Nick", + "last_name": "Palladinos", + "institution": "" + }, { - "first_name": "Daan", - "last_name": "Leijen", - "institution": "Microsoft (United States)" + "first_name": "Yannis", + "last_name": "Smaragdakis", + "institution": "National and Kapodistrian University of Athens" } ], - "dblp_key": "conf/popl/Leijen17", + "dblp_key": "conf/popl/KiselyovBPS17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009868", - "title": "Beginner's luck: a language for property-based generators", - "abstract": "Property-based random testing à la QuickCheck requires building efficient generators for well-distributed random data satisfying complex logical predicates, but writing these generators can be difficult and error prone. We propose a domain-specific language in which generators are conveniently expressed by decorating predicates with lightweight annotations to control both the distribution of generated values and the amount of constraint solving that happens before each variable is instantiated. This language, called Luck, makes generators easier to write, read, and maintain.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009868", + "paper_id": "10.1145/3009837.3009856", + "title": "Gradual refinement types", + "abstract": "Refinement types are an effective language-based verification technique. However, as any expressive typing discipline, its strength is its weakness, imposing sometimes undesired rigidity. Guided by abstract interpretation, we extend the gradual typing agenda and develop the notion of gradual refinement types, allowing smooth evolution and interoperability between simple types and logically-refined types. In doing so, we address two challenges unexplored in the gradual typing literature: dealing with imprecise logical information, and with dependent function types. The first challenge leads to a crucial notion of locality for refinement formulas, and the second yields novel operators related to type- and term-level substitution, identifying new opportunity for runtime errors in gradual dependently-typed languages. The gradual language we present is type safe, type sound, and satisfies the refined criteria for gradually-typed languages of Siek et al. We also explain how to extend our approach to richer refinement logics, anticipating key challenges to consider.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009856", "conference_name": "POPL", "authors": [ { - "first_name": "Leonidas", - "last_name": "Lampropoulos", - "institution": "California University of Pennsylvania" - }, - { - "first_name": "Diane", - "last_name": "Gallois-Wong", - "institution": "State Key Laboratory of Cryptology" - }, - { - "first_name": "Cătălin", - "last_name": "Hriţcu", - "institution": "Institut national de recherche en informatique et en automatique" - }, - { - "first_name": "John", - "last_name": "Hughes", - "institution": "Chalmers University of Technology" - }, - { - "first_name": "Benjamin C.", - "last_name": "Pierce", - "institution": "California University of Pennsylvania" + "first_name": "Nico", + "last_name": "Lehmann", + "institution": "University of Chile" }, { - "first_name": "Li-yao", - "last_name": "Xia", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Éric", + "last_name": "Tanter", + "institution": "University of Chile" } ], - "dblp_key": "conf/popl/LampropoulosGHH17", + "dblp_key": "conf/popl/LehmannT17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009847", - "title": "Fencing off go: liveness and safety for channel-based programming", - "abstract": "Go is a production-level statically typed programming language whose design features explicit message-passing primitives and lightweight threads, enabling (and encouraging) programmers to develop concurrent systems where components interact through communication more so than by lock-based shared memory concurrency. Go can only detect global deadlocks at runtime, but provides no compile-time protection against all too common communication mismatches or partial deadlocks.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009847", + "paper_id": "10.1145/3009837.3009862", + "title": "Intersection type calculi of bounded dimension", + "abstract": "A notion of dimension in intersection typed λ-calculi is presented. The dimension of a typed λ-term is given by the minimal norm of an elaboration (a proof theoretic decoration) necessary for typing the term at its type, and, intuitively, measures intersection introduction as a resource.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009862", "conference_name": "POPL", "authors": [ { - "first_name": "Julien", - "last_name": "Lange", - "institution": "Imperial College London" - }, - { - "first_name": "Nicholas", - "last_name": "Ng", - "institution": "Imperial College London" - }, - { - "first_name": "Bernardo", - "last_name": "Toninho", - "institution": "Imperial College London" + "first_name": "Andrej", + "last_name": "Dudenhefner", + "institution": "TU Dortmund University" }, { - "first_name": "Nobuko", - "last_name": "Yoshida", - "institution": "Imperial College London" + "first_name": "Jakob", + "last_name": "Rehof", + "institution": "TU Dortmund University" } ], - "dblp_key": "conf/popl/LangeNTY17", + "dblp_key": "conf/popl/DudenhefnerR17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009859", - "title": "The geometry of parallelism: classical, probabilistic, and quantum effects", - "abstract": "We introduce a Geometry of Interaction model for higher-order quantum computation, and prove its adequacy for a fully fledged quantum programming language in which entanglement, duplication, and recursion are all available.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009859", + "paper_id": "10.1145/3009837.3009850", + "title": "A promising semantics for relaxed-memory concurrency", + "abstract": "Despite many years of research, it has proven very difficult to develop a memory model for concurrent programming languages that adequately balances the conflicting desiderata of programmers, compilers, and hardware. In this paper, we propose the first relaxed memory model that (1) accounts for a broad spectrum of features from the C++11 concurrency model, (2) is implementable, in the sense that it provably validates many standard compiler optimizations and reorderings, as well as standard compilation schemes to x86-TSO and Power, (3) justifies simple invariant-based reasoning, thus demonstrating the absence of bad \"out-of-thin-air\" behaviors, (4) supports \"DRF\" guarantees, ensuring that programmers who use sufficient synchronization need not understand the full complexities of relaxed-memory semantics, and (5) defines the semantics of racy programs without relying on undefined behaviors, which is a prerequisite for applicability to type-safe languages like Java.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009850", "conference_name": "POPL", "authors": [ { - "first_name": "Ugo Dal", - "last_name": "Lago", - "institution": "University of Bologna" + "first_name": "Jeehoon", + "last_name": "Kang", + "institution": "Seoul National University" }, { - "first_name": "Claudia", - "last_name": "Faggian", - "institution": "Institut de Recherche en Informatique Fondamentale" + "first_name": "Chung-Kil", + "last_name": "Hur", + "institution": "Seoul National University" }, { - "first_name": "Benoît", - "last_name": "Valiron", - "institution": "Université Paris-Saclay" + "first_name": "Ori", + "last_name": "Lahav", + "institution": "Max Planck Institute for Software Systems" }, { - "first_name": "Akira", - "last_name": "Yoshimizu", - "institution": "The University of Tokyo" + "first_name": "Viktor", + "last_name": "Vafeiadis", + "institution": "Max Planck Institute for Software Systems" + }, + { + "first_name": "Derek", + "last_name": "Dreyer", + "institution": "Max Planck Institute for Software Systems" } ], - "dblp_key": "conf/popl/LagoFVY17", + "dblp_key": "conf/popl/KangHLVD17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009870", - "title": "Analyzing divergence in bisimulation semantics", - "abstract": "Some bisimulation based abstract equivalence relations may equate divergent systems with non-divergent ones, examples including weak bisimulation equivalence and branching bisimulation equivalence. Thus extra efforts are needed to analyze divergence for the compared systems. In this paper we propose a new method for analyzing divergence in bisimulation semantics, which relies only on simple observations of individual transitions. We show that this method can verify several typical divergence preserving bisimulation equivalences including two well-known ones. As an application case study, we use the proposed method to verify the HSY collision stack to draw the conclusion that the stack implementation is correct in terms of linearizability with lock-free progress condition.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009870", + "paper_id": "10.1145/3009837.3009888", + "title": "On verifying causal consistency", + "abstract": "Causal consistency is one of the most adopted consistency criteria for distributed implementations of data structures. It ensures that operations are executed at all sites according to their causal precedence. We address the issue of verifying automatically whether the executions of an implementation of a data structure are causally consistent. We consider two problems: (1) checking whether one single execution is causally consistent, which is relevant for developing testing and bug finding algorithms, and (2) verifying whether all the executions of an implementation are causally consistent.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009888", "conference_name": "POPL", "authors": [ { - "first_name": "Xinxin", - "last_name": "Liu", - "institution": "Chinese Academy of Sciences" + "first_name": "Ahmed", + "last_name": "Bouajjani", + "institution": "Délégation Paris 7" }, { - "first_name": "Tingting", - "last_name": "Yu", - "institution": "Institute of Software" + "first_name": "Constantin", + "last_name": "Enea", + "institution": "Délégation Paris 7" }, { - "first_name": "Wenhui", - "last_name": "Zhang", - "institution": "Institute of Software" + "first_name": "Rachid", + "last_name": "Guerraoui", + "institution": "École Polytechnique Fédérale de Lausanne" + }, + { + "first_name": "Jad", + "last_name": "Hamza", + "institution": "École Polytechnique Fédérale de Lausanne" } ], - "dblp_key": "conf/popl/LiuYZ17", + "dblp_key": "conf/popl/BouajjaniEGH17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009898", - "title": "Contextual isomorphisms", - "abstract": "What is the right notion of \"isomorphism\" between types, in a simple type theory? The traditional answer is: a pair of terms that are inverse up to a specified congruence. We firstly argue that, in the presence of effects, this answer is too liberal and needs to be restricted, using Führmann's notion of thunkability in the case of value types (as in call-by-value), or using Munch-Maccagnoni's notion of linearity in the case of computation types (as in call-by-name). Yet that leaves us with different notions of isomorphism for different kinds of type.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009898", + "paper_id": "10.1145/3009837.3009872", + "title": "Type directed compilation of row-typed algebraic effects", + "abstract": "Algebraic effect handlers, introduced by Plotkin and Power in 2002,", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009872", "conference_name": "POPL", "authors": [ { - "first_name": "Paul Blain", - "last_name": "Levy", - "institution": "University of Birmingham" + "first_name": "Daan", + "last_name": "Leijen", + "institution": "Microsoft (United States)" } ], - "dblp_key": "conf/popl/Levy17", + "dblp_key": "conf/popl/Leijen17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009856", - "title": "Gradual refinement types", - "abstract": "Refinement types are an effective language-based verification technique. However, as any expressive typing discipline, its strength is its weakness, imposing sometimes undesired rigidity. Guided by abstract interpretation, we extend the gradual typing agenda and develop the notion of gradual refinement types, allowing smooth evolution and interoperability between simple types and logically-refined types. In doing so, we address two challenges unexplored in the gradual typing literature: dealing with imprecise logical information, and with dependent function types. The first challenge leads to a crucial notion of locality for refinement formulas, and the second yields novel operators related to type- and term-level substitution, identifying new opportunity for runtime errors in gradual dependently-typed languages. The gradual language we present is type safe, type sound, and satisfies the refined criteria for gradually-typed languages of Siek et al. We also explain how to extend our approach to richer refinement logics, anticipating key challenges to consider.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009856", + "paper_id": "10.1145/3009837.3009878", + "title": "Dijkstra monads for free", + "abstract": "Dijkstra monads enable a dependent type theory to be enhanced with support for specifying and verifying effectful code via weakest preconditions. Together with their closely related counterparts, Hoare monads, they provide the basis on which verification tools like F*, Hoare Type Theory (HTT), and Ynot are built. We show that Dijkstra monads can be derived \"for free\" by applying a continuation-passing style (CPS) translation to the standard monadic definitions of the underlying computational effects. Automatically deriving Dijkstra monads in this way provides a correct-by-construction and efficient way of reasoning about user-defined effects in dependent type theories. We demonstrate these ideas in EMF*, a new dependently typed calculus, validating it via both formal proof and a prototype implementation within F*. Besides equipping F* with a more uniform and extensible effect system, EMF* enables a novel mixture of intrinsic and extrinsic proofs within F*.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009878", "conference_name": "POPL", "authors": [ { - "first_name": "Nico", - "last_name": "Lehmann", - "institution": "University of Chile" + "first_name": "Danel", + "last_name": "Ahman", + "institution": "University of Edinburgh" }, { - "first_name": "Éric", - "last_name": "Tanter", - "institution": "University of Chile" - } - ], - "dblp_key": "conf/popl/LehmannT17", - "venue": "popl", - "year": 2017 - }, - { - "paper_id": "10.1145/3009837.3009857", - "title": "Dynamic race detection for C++11", - "abstract": "The intricate rules for memory ordering and synchronisation associated with the C/C++11 memory model mean that data races can be difficult to eliminate from concurrent programs. Dynamic data race analysis can pinpoint races in large and complex applications, but the state-of-the-art ThreadSanitizer (tsan) tool for C/C++ considers only sequentially consistent program executions, and does not correctly model synchronisation between C/C++11 atomic operations. We present a scalable dynamic data race analysis for C/C++11 that correctly captures C/C++11 synchronisation, and uses instrumentation to support exploration of a class of non sequentially consistent executions. We concisely define the memory model fragment captured by our instrumentation via a restricted axiomatic semantics, and show that the axiomatic semantics permits exactly those executions explored by our instrumentation. We have implemented our analysis in tsan, and evaluate its effectiveness on benchmark programs, enabling a comparison with the CDSChecker tool, and on two large and highly concurrent applications: the Firefox and Chromium web browsers. Our results show that our method can detect races that are beyond the scope of the original tsan tool, and that the overhead associated with applying our enhanced instrumentation to large applications is tolerable.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009857", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Christopher", - "last_name": "Lidbury", - "institution": "Imperial College London" + "first_name": "Cătălin", + "last_name": "Hriţcu", + "institution": "Microsoft (United States)" }, { - "first_name": "Alastair F.", - "last_name": "Donaldson", - "institution": "Imperial College London" - } - ], - "dblp_key": "conf/popl/LidburyD17", - "venue": "popl", - "year": 2017 - }, - { - "paper_id": "10.1145/3009837.3009881", - "title": "Semantic-directed clumping of disjunctive abstract states", - "abstract": "To infer complex structural invariants, shape analyses rely on expressive families of logical properties. Many such analyses manipulate abstract memory states that consist of separating conjunctions of basic predicates describing atomic blocks or summaries. Moreover, they use finite disjunctions of abstract memory states in order to account for dissimilar shapes. Disjunctions should be kept small for the sake of scalability, though precision often requires to keep additional case splits. In this context, deciding when and how to merge case splits and to replace them with summaries is critical both for the precision and for the efficiency. Existing techniques use sets of syntactic rules, which are tedious to design and prone to failure. In this paper, we design a semantic criterion to clump abstract states based on their silhouette which applies not only to the conservative union of disjuncts, but also to the weakening of separating conjunction of memory predicates into inductive summaries. Our approach allows to define union and widening operators that aim at preserving the case splits that are required for the analysis to succeed. We implement this approach in the MemCAD analyzer, and evaluate it on real-world C codes from existing libraries, including programs dealing with doubly linked lists, red-black trees and AVL-trees.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009881", - "conference_name": "POPL", - "authors": [ + "first_name": "Kenji", + "last_name": "Maillard", + "institution": "Microsoft (United States)" + }, { - "first_name": "Huisong", - "last_name": "Li", - "institution": "Institut national de recherche en informatique et en automatique" + "first_name": "Guido", + "last_name": "Martínez", + "institution": "State Key Laboratory of Cryptology" }, { - "first_name": "Francois", - "last_name": "Berenger", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Gordon", + "last_name": "Plotkin", + "institution": "University of Edinburgh" }, { - "first_name": "Bor-Yuh Evan", - "last_name": "Chang", - "institution": "University of Colorado Boulder" + "first_name": "Jonathan", + "last_name": "Protzenko", + "institution": "Microsoft (United States)" }, { - "first_name": "Xavier", - "last_name": "Rival", - "institution": "Centre National de la Recherche Scientifique" + "first_name": "Aseem", + "last_name": "Rastogi", + "institution": "Microsoft Research (India)" + }, + { + "first_name": "Nikhil", + "last_name": "Swamy", + "institution": "Microsoft (United States)" } ], - "dblp_key": "conf/popl/LiBCR17", + "dblp_key": "conf/popl/AhmanHMMPPRS17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009897", - "title": "Do be do be do", - "abstract": "We explore the design and implementation of Frank, a strict functional programming language with a bidirectional effect type system designed from the ground up around a novel variant of Plotkin and Pretnar's effect handler abstraction.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009897", + "paper_id": "10.1145/3009837.3009857", + "title": "Dynamic race detection for C++11", + "abstract": "The intricate rules for memory ordering and synchronisation associated with the C/C++11 memory model mean that data races can be difficult to eliminate from concurrent programs. Dynamic data race analysis can pinpoint races in large and complex applications, but the state-of-the-art ThreadSanitizer (tsan) tool for C/C++ considers only sequentially consistent program executions, and does not correctly model synchronisation between C/C++11 atomic operations. We present a scalable dynamic data race analysis for C/C++11 that correctly captures C/C++11 synchronisation, and uses instrumentation to support exploration of a class of non sequentially consistent executions. We concisely define the memory model fragment captured by our instrumentation via a restricted axiomatic semantics, and show that the axiomatic semantics permits exactly those executions explored by our instrumentation. We have implemented our analysis in tsan, and evaluate its effectiveness on benchmark programs, enabling a comparison with the CDSChecker tool, and on two large and highly concurrent applications: the Firefox and Chromium web browsers. Our results show that our method can detect races that are beyond the scope of the original tsan tool, and that the overhead associated with applying our enhanced instrumentation to large applications is tolerable.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009857", "conference_name": "POPL", "authors": [ { - "first_name": "Sam", - "last_name": "Lindley", - "institution": "University of Edinburgh" - }, - { - "first_name": "Conor", - "last_name": "McBride", - "institution": "University of Strathclyde" + "first_name": "Christopher", + "last_name": "Lidbury", + "institution": "Imperial College London" }, { - "first_name": "Craig", - "last_name": "McLaughlin", - "institution": "University of Edinburgh" + "first_name": "Alastair F.", + "last_name": "Donaldson", + "institution": "Imperial College London" } ], - "dblp_key": "conf/popl/LindleyMM17", + "dblp_key": "conf/popl/LidburyD17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009874", - "title": "Contract-based resource verification for higher-order functions with memoization", - "abstract": "We present a new approach for specifying and verifying resource utilization of higher-order functional programs that use lazy evaluation and memoization. In our approach, users can specify the desired resource bound as templates with numerical holes e.g. as steps <= ? not asymptotic to size(l) + ? in the contracts of functions. They can also express invariants necessary for establishing the bounds that may depend on the state of memoization. Our approach operates in two phases: first generating an instrumented first-order program that accurately models the higher-order control flow and the effects of memoization on resources using sets, algebraic datatypes and mutual recursion, and then verifying the contracts of the first-order program by producing verification conditions of the form there exists for all using an extended assume/guarantee reasoning. We use our approach to verify precise bounds on resources such as evaluation steps and number of heap-allocated objects on 17 challenging data structures and algorithms. Our benchmarks, comprising of 5K lines of functional Scala code, include lazy mergesort, Okasaki's real-time queue and deque data structures that rely on aliasing of references to first-class functions; lazy data structures based on numerical representations such as the conqueue data structure of Scala's data-parallel library, cyclic streams, as well as dynamic programming algorithms such as knapsack and Viterbi. Our evaluations show that when averaged over all benchmarks the actual runtime resource consumption is 80% of the value inferred by our tool when estimating the number of evaluation steps, and is 88% for the number of heap-allocated objects.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009874", + "paper_id": "10.1145/3009837.3009896", + "title": "Coupling proofs are probabilistic product programs", + "abstract": "Couplings are a powerful mathematical tool for reasoning about pairs of probabilistic processes. Recent developments in formal verification identify a close connection between couplings and pRHL, a relational program logic motivated by applications to provable security, enabling formal construction of couplings from the probability theory literature. However, existing work using pRHL merely shows existence of a coupling and does not give a way to prove quantitative properties about the coupling, needed to reason about mixing and convergence of probabilistic processes. Furthermore, pRHL is inherently incomplete, and is not able to capture some advanced forms of couplings such as shift couplings. We address both problems as follows.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009896", "conference_name": "POPL", "authors": [ { - "first_name": "Ravichandhran", - "last_name": "Madhavan", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Gilles", + "last_name": "Barthe", + "institution": "IMDEA Software" }, { - "first_name": "Sumith", - "last_name": "Kulal", - "institution": "Indian Institute of Technology Bombay" + "first_name": "Benjamin", + "last_name": "Grégoire", + "institution": "Institut national de recherche en informatique et en automatique" }, { - "first_name": "Viktor", - "last_name": "Kunčak", - "institution": "École Polytechnique Fédérale de Lausanne" + "first_name": "Justin", + "last_name": "Hsu", + "institution": "California University of Pennsylvania" + }, + { + "first_name": "Pierre-Yves", + "last_name": "Strub", + "institution": "IMDEA Software" } ], - "dblp_key": "conf/popl/MadhavanKK17", + "dblp_key": "conf/popl/BartheGHS17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009875", - "title": "Stateful manifest contracts", - "abstract": "This paper studies hybrid contract verification for an imperative higher-order language based on a so-called manifest contract system. In manifest contract systems, contracts are part of static types and contract verification is hybrid in the sense that some contracts are statically verified, typically by subtyping, but others are dynamically by casts. It is, however, not trivial to extend existing manifest contract systems, which have been designed mostly for pure functional languages, to imperative features, mainly because of the lack of flow-sensitivity, which should be taken into account in verifying imperative programs statically.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009875", + "paper_id": "10.1145/3009837.3009844", + "title": "Monadic second-order logic on finite sequences", + "abstract": "We extend the weak monadic second-order logic of one successor on finite strings (M2L-STR) to symbolic alphabets by allowing character predicates to range over decidable quantifier free theories instead of finite alphabets. We call this logic, which is able to describe sequences over complex and potentially infinite domains, symbolic M2L-STR (S-M2L-STR). We then present a decision procedure for S-M2L-STR based on a reduction to symbolic finite automata, a decidable extension of finite automata that allows transitions to carry predicates and can therefore model symbolic alphabets. The reduction constructs a symbolic automaton over an alphabet consisting of pairs of symbols where the first element of the pair is a symbol in the original formula’s alphabet, while the second element is a bit-vector. To handle this modified alphabet we show that the Cartesian product of two decidable Boolean algebras (e.g., the formula’s one and the bit-vector’s one) also forms a decidable Boolean algebras. To make the decision procedure practical, we propose two efficient representations of the Cartesian product of two Boolean algebras, one based on algebraic decision diagrams and one on a variant of Shannon expansions. Finally, we implement our decision procedure and evaluate it on more than 10,000 formulas. Despite the generality, our implementation has comparable performance with the state-of-the-art M2L-STR solvers.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009844", "conference_name": "POPL", "authors": [ { - "first_name": "Taro", - "last_name": "Sekiyama", - "institution": "IBM Research - Tokyo" + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" }, { - "first_name": "Atsushi", - "last_name": "Igarashi", - "institution": "Kyoto University" + "first_name": "Margus", + "last_name": "Veanes", + "institution": "Microsoft (United States)" } ], - "dblp_key": "conf/popl/SekiyamaI17", + "dblp_key": "conf/popl/DAntoniV17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009894", - "title": "QWIRE: a core language for quantum circuits", - "abstract": "This paper introduces QWIRE (``choir''), a language for defining quantum circuits and an interface for manipulating them inside of an arbitrary classical host language. QWIRE is minimal---it contains only a few primitives---and sound with respect to the physical properties entailed by quantum mechanics. At the same time, QWIRE is expressive and highly modular due to its relationship with the host language, mirroring the QRAM model of computation that places a quantum computer (controlled by circuits) alongside a classical computer (controlled by the host language).", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009894", + "paper_id": "10.1145/3009837.3009883", + "title": "Ogre and Pythia: an invariance proof method for weak consistency models", + "abstract": "We design an invariance proof method for concurrent programs parameterised by a weak consistency model. The calculational design of the invariance proof method is by abstract interpretation of a truly parallel analytic semantics. This generalises the methods by Lamport and Owicki-Gries for sequential consistency. We use cat as an example of language to write consistency specifications of both concurrent programs and machine architectures.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009883", "conference_name": "POPL", "authors": [ { - "first_name": "Jennifer", - "last_name": "Paykin", - "institution": "California University of Pennsylvania" - }, - { - "first_name": "Robert W.", - "last_name": "Rand", - "institution": "California University of Pennsylvania" + "first_name": "Jade", + "last_name": "Alglave", + "institution": "Microsoft Research (United Kingdom)" }, { - "first_name": "Steve", - "last_name": "Zdancewic", - "institution": "California University of Pennsylvania" + "first_name": "Patrick", + "last_name": "Cousot", + "institution": "New York University" } ], - "dblp_key": "conf/popl/Paykin0Z17", + "dblp_key": "conf/popl/AlglaveC17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009879", - "title": "Learning nominal automata", - "abstract": "We present an Angluin-style algorithm to learn nominal automata, which are acceptors of languages over infinite (structured) alphabets. The abstract approach we take allows us to seamlessly extend known variations of the algorithm to this new setting. In particular we can learn a subclass of nominal non-deterministic automata. An implementation using a recently developed Haskell library for nominal computation is provided for preliminary experiments.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009879", + "paper_id": "10.1145/3009837.3009860", + "title": "A short counterexample property for safety and liveness verification of fault-tolerant distributed algorithms", + "abstract": "Distributed algorithms have many mission-critical applications ranging from embedded systems and replicated databases to cloud computing. Due to asynchronous communication, process faults, or network failures, these algorithms are difficult to design and verify. Many algorithms achieve fault tolerance by using threshold guards that, for instance, ensure that a process waits until it has received an acknowledgment from a majority of its peers. Consequently, domain-specific languages for fault-tolerant distributed systems offer language support for threshold guards.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009860", "conference_name": "POPL", "authors": [ { - "first_name": "Joshua", - "last_name": "Moerman", - "institution": "Radboud University Nijmegen" - }, - { - "first_name": "Matteo", - "last_name": "Sammartino", - "institution": "University College London" + "first_name": "Igor", + "last_name": "Konnov", + "institution": "TU Wien" }, { - "first_name": "Alexandra", - "last_name": "Silva", - "institution": "University College London" + "first_name": "Marijana", + "last_name": "Lazić", + "institution": "TU Wien" }, { - "first_name": "Bartek", - "last_name": "Klin", - "institution": "University of Warsaw" + "first_name": "Helmut", + "last_name": "Veith", + "institution": "TU Wien" }, { - "first_name": "Michał", - "last_name": "Szynwelski", - "institution": "University of Warsaw" + "first_name": "Josef", + "last_name": "Widder", + "institution": "TU Wien" } ], - "dblp_key": "conf/popl/MoermanS0KS17", + "dblp_key": "conf/popl/KonnovLVW17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009901", - "title": "Deciding equivalence with sums and the empty type", - "abstract": "The logical technique of focusing can be applied to the λ-calculus; in a simple type system with atomic types and negative type formers (functions, products, the unit type), its normal forms coincide with βη-normal forms. Introducing a saturation phase gives a notion of quasi-normal forms in presence of positive types (sum types and the empty type). This rich structure let us prove the decidability of βη-equivalence in presence of the empty type, the fact that it coincides with contextual equivalence, and with set-theoretic equality in all finite models.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009901", + "paper_id": "10.1145/3009837.3009881", + "title": "Semantic-directed clumping of disjunctive abstract states", + "abstract": "To infer complex structural invariants, shape analyses rely on expressive families of logical properties. Many such analyses manipulate abstract memory states that consist of separating conjunctions of basic predicates describing atomic blocks or summaries. Moreover, they use finite disjunctions of abstract memory states in order to account for dissimilar shapes. Disjunctions should be kept small for the sake of scalability, though precision often requires to keep additional case splits. In this context, deciding when and how to merge case splits and to replace them with summaries is critical both for the precision and for the efficiency. Existing techniques use sets of syntactic rules, which are tedious to design and prone to failure. In this paper, we design a semantic criterion to clump abstract states based on their silhouette which applies not only to the conservative union of disjuncts, but also to the weakening of separating conjunction of memory predicates into inductive summaries. Our approach allows to define union and widening operators that aim at preserving the case splits that are required for the analysis to succeed. We implement this approach in the MemCAD analyzer, and evaluate it on real-world C codes from existing libraries, including programs dealing with doubly linked lists, red-black trees and AVL-trees.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009881", "conference_name": "POPL", "authors": [ { - "first_name": "Gabriel", - "last_name": "Scherer", - "institution": "Northeastern University" + "first_name": "Huisong", + "last_name": "Li", + "institution": "Institut national de recherche en informatique et en automatique" + }, + { + "first_name": "Francois", + "last_name": "Berenger", + "institution": "Centre National de la Recherche Scientifique" + }, + { + "first_name": "Bor-Yuh Evan", + "last_name": "Chang", + "institution": "University of Colorado Boulder" + }, + { + "first_name": "Xavier", + "last_name": "Rival", + "institution": "Centre National de la Recherche Scientifique" } ], - "dblp_key": "conf/popl/Scherer17", + "dblp_key": "conf/popl/LiBCR17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009900", - "title": "Hazelnut: a bidirectionally typed structure editor calculus", - "abstract": "Structure editors allow programmers to edit the tree structure of a program directly. This can have cognitive benefits, particularly for novice and end-user programmers. It also simplifies matters for tool designers, because they do not need to contend with malformed program text.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009900", + "paper_id": "10.1145/3009837.3009875", + "title": "Stateful manifest contracts", + "abstract": "This paper studies hybrid contract verification for an imperative higher-order language based on a so-called manifest contract system. In manifest contract systems, contracts are part of static types and contract verification is hybrid in the sense that some contracts are statically verified, typically by subtyping, but others are dynamically by casts. It is, however, not trivial to extend existing manifest contract systems, which have been designed mostly for pure functional languages, to imperative features, mainly because of the lack of flow-sensitivity, which should be taken into account in verifying imperative programs statically.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009875", "conference_name": "POPL", "authors": [ { - "first_name": "Cyrus", - "last_name": "Omar", - "institution": "Carnegie Mellon University" - }, - { - "first_name": "Ian", - "last_name": "Voysey", - "institution": "Carnegie Mellon University" - }, - { - "first_name": "Michael", - "last_name": "Hilton", - "institution": "Oregon State University" - }, - { - "first_name": "Jonathan", - "last_name": "Aldrich", - "institution": "Carnegie Mellon University" + "first_name": "Taro", + "last_name": "Sekiyama", + "institution": "IBM Research - Tokyo" }, { - "first_name": "Matthew A.", - "last_name": "Hammer", - "institution": "University of Colorado Boulder" + "first_name": "Atsushi", + "last_name": "Igarashi", + "institution": "Kyoto University" } ], - "dblp_key": "conf/popl/OmarVHAH17", + "dblp_key": "conf/popl/SekiyamaI17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009891", - "title": "A program optimization for automatic database result caching", - "abstract": "Most popular Web applications rely on persistent databases based on languages like SQL for declarative specification of data models and the operations that read and modify them. As applications scale up in user base, they often face challenges responding quickly enough to the high volume of requests. A common aid is caching of database results in the application's memory space, taking advantage of program-specific knowledge of which caching schemes are sound and useful, embodied in handwritten modifications that make the program less maintainable. These modifications also require nontrivial reasoning about the read-write dependencies across operations. In this paper, we present a compiler optimization that automatically adds sound SQL caching to Web applications coded in the Ur/Web domain-specific functional language, with no modifications required to source code. We use a custom cache implementation that supports concurrent operations without compromising the transactional semantics of the database abstraction. Through experiments with microbenchmarks and production Ur/Web applications, we show that our optimization in many cases enables an easy doubling or more of an application's throughput, requiring nothing more than passing an extra command-line flag to the compiler.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009891", + "paper_id": "10.1145/3009837.3009849", + "title": "Big types in little runtime: open-world soundness and collaborative blame for gradual type systems", + "abstract": "Gradual typing combines static and dynamic typing in the same language, offering programmers the error detection and strong guarantees of static types and the rapid prototyping and flexible programming idioms of dynamic types. Many gradually typed languages are implemented by translation into an untyped target language (e.g., Typed Clojure, TypeScript, Gradualtalk, and Reticulated Python). For such languages, it is desirable to support arbitrary interaction between translated code and legacy code in the untyped language while maintaining the type soundness of the translated code. In this paper we formalize this goal in the form of the open-world soundness criterion. We discuss why it is challenging to achieve open-world soundness using the traditional proxy-based approach for higher-order casts. However, the transient design satisfies open-world soundness. Indeed, we present a formal semantics for the transient design and prove that our semantics satisfies open-world soundness. In this paper we also solve a challenging problem for the transient design: how to provide blame tracking without proxies. We define a semantics for blame and prove the Blame Theorem. We also prove that the Gradual Guarantee holds for this system, ensuring that programs can be evolved freely between static and dynamic typing. Finally, we demonstrate that the runtime overhead of the transient approach is low in the context of Reticulated Python, an implementation of gradual typing for Python.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009849", "conference_name": "POPL", "authors": [ { - "first_name": "Ziv", - "last_name": "Scully", - "institution": "Carnegie Mellon University" + "first_name": "Michael M.", + "last_name": "Vitousek", + "institution": "Indiana University" }, { - "first_name": "Adam", - "last_name": "Chlipala", - "institution": "Massachusetts Institute of Technology" + "first_name": "Cameron", + "last_name": "Swords", + "institution": "Indiana University" + }, + { + "first_name": "Jeremy G.", + "last_name": "Siek", + "institution": "Indiana University" } ], - "dblp_key": "conf/popl/ScullyC17", + "dblp_key": "conf/popl/VitousekSS17", "venue": "popl", - "year": 2017 - }, - { - "paper_id": "10.1145/3009837.3009885", - "title": "Fast polyhedra abstract domain", - "abstract": "Numerical abstract domains are an important ingredient of modern static analyzers used for verifying critical program properties (e.g., absence of buffer overflow or memory safety). Among the many numerical domains introduced over the years, Polyhedra is the most expressive one, but also the most expensive: it has worst-case exponential space and time complexity. As a consequence, static analysis with the Polyhedra domain is thought to be impractical when applied to large scale, real world programs.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009885", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009845", + "title": "Genesis: synthesizing forwarding tables in multi-tenant networks", + "abstract": "Operators in multi-tenant cloud datacenters require support for diverse and complex end-to-end policies, such as, reachability, middlebox traversals, isolation, traffic engineering, and network resource management. We present Genesis, a datacenter network management system which allows policies to be specified in a declarative manner without explicitly programming the network data plane. Genesis tackles the problem of enforcing policies by synthesizing switch forwarding tables. It uses the formal foundations of constraint solving in combination with fast off-the-shelf SMT solvers. To improve synthesis performance, Genesis incorporates a novel search strategy that uses regular expressions to specify properties that leverage the structure of datacenter networks, and a divide-and-conquer synthesis procedure which exploits the structure of policy relationships. We have prototyped Genesis, and conducted experiments with a variety of workloads on real-world topologies to demonstrate its performance.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009845", "conference_name": "POPL", "authors": [ { - "first_name": "Gagandeep", - "last_name": "Singh", - "institution": "ETH Zurich" + "first_name": "Kausik", + "last_name": "Subramanian", + "institution": "University of Wisconsin–Madison" }, { - "first_name": "Markus", - "last_name": "Püschel", - "institution": "ETH Zurich" + "first_name": "Loris", + "last_name": "D’Antoni", + "institution": "University of Wisconsin–Madison" }, { - "first_name": "Martin", - "last_name": "Vechev", - "institution": "ETH Zurich" + "first_name": "Aditya", + "last_name": "Akella", + "institution": "University of Wisconsin–Madison" } ], - "dblp_key": "conf/popl/SinghPV17", + "dblp_key": "conf/popl/SubramanianDA17", "venue": "popl", "year": 2017 }, @@ -1603,7 +1585,7 @@ "paper_id": "10.1145/3009837.3011999", "title": "Rust: from POPL to practice (keynote)", "abstract": "In 2015, a language based fundamentally on substructural typing–Rust–hit its 1.0 release, and less than a year later it has been put into production use in a number of tech companies, including some household names. The language has started a trend, with several other mainstream languages, including C++ and Swift, in the early stages of incorporating ideas about ownership. How did this come about?", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3011999", "conference_name": "POPL", "authors": [ @@ -1618,20 +1600,35 @@ "year": 2017 }, { - "paper_id": "10.1145/3009837.3009923", - "title": "The influence of dependent types (keynote)", - "abstract": "What has dependent type theory done for Haskell? In this talk, I will discuss the influence of dependent types on the design of programming languages and on the practice of functional programmers. Over the past ten years, the Glasgow Haskell compiler has adopted several type system features inspired by dependent type theory. However, this process has not been a direct translation; working in the context of an existing language has lead us to new designs in the semantics of dependent types. I will take a close look at what we have achieved in GHC and discuss what we have learned from this experiment: what works now, what doesn't work yet, and what has surprised us along the way.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009923", + "paper_id": "10.1145/3009837.3009838", + "title": "Automatically comparing memory consistency models", + "abstract": "A memory consistency model (MCM) is the part of a programming language or computer architecture specification that defines which values can legally be read from shared memory locations. Because MCMs take into account various optimisations employed by architectures and compilers, they are often complex and counterintuitive, which makes them challenging to design and to understand.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009838", "conference_name": "POPL", "authors": [ { - "first_name": "Stephanie", - "last_name": "Weirich", - "institution": "California University of Pennsylvania" + "first_name": "John", + "last_name": "Wickerson", + "institution": "Imperial College London" + }, + { + "first_name": "Mark", + "last_name": "Batty", + "institution": "University of Kent" + }, + { + "first_name": "Tyler", + "last_name": "Sorensen", + "institution": "Imperial College London" + }, + { + "first_name": "George A.", + "last_name": "Constantinides", + "institution": "Imperial College London" } ], - "dblp_key": "conf/popl/Weirich17", + "dblp_key": "conf/popl/WickersonBSC17", "venue": "popl", "year": 2017 }, @@ -1639,7 +1636,7 @@ "paper_id": "10.1145/3009837.3009852", "title": "Exact Bayesian inference by symbolic disintegration", "abstract": "Bayesian inference, of posterior knowledge from prior knowledge and observed evidence, is typically defined by Bayes's rule, which says the posterior multiplied by the probability of an observation equals a joint probability. But the observation of a continuous quantity usually has probability zero, in which case Bayes's rule says only that the unknown times zero is zero. To infer a posterior distribution from a zero-probability observation, the statistical notion of disintegration tells us to specify the observation as an expression rather than a predicate, but does not tell us how to compute the posterior. We present the first method of computing a disintegration from a probabilistic program and an expression of a quantity to be observed, even when the observation has probability zero. Because the method produces an exact posterior term and preserves a semantics in which monadic terms denote measures, it composes with other inference methods in a modular way-without sacrificing accuracy or performance.", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3009852", "conference_name": "POPL", "authors": [ @@ -1658,49 +1655,11 @@ "venue": "popl", "year": 2017 }, - { - "paper_id": "10.1145/3009837.3009843", - "title": "Cantor meets scott: semantic foundations for probabilistic networks", - "abstract": "ProbNetKAT is a probabilistic extension of NetKAT with a denotational semantics based on Markov kernels. The language is expressive enough to generate continuous distributions, which raises the question of how to compute effectively in the language. This paper gives an new characterization of ProbNetKAT’s semantics using domain theory, which provides the foundation needed to build a practical implementation. We show how to use the semantics to approximate the behavior of arbitrary ProbNetKAT programs using distributions with finite support. We develop a prototype implementation and show how to use it to solve a variety of problems including characterizing the expected congestion induced by different routing schemes and reasoning probabilistically about reachability in a network.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009843", - "conference_name": "POPL", - "authors": [ - { - "first_name": "Steffen", - "last_name": "Smolka", - "institution": "Cornell University" - }, - { - "first_name": "Praveen", - "last_name": "Kumar", - "institution": "Cornell University" - }, - { - "first_name": "Nate", - "last_name": "Foster", - "institution": "Cornell University" - }, - { - "first_name": "Dexter", - "last_name": "Kozen", - "institution": "Cornell University" - }, - { - "first_name": "Alexandra", - "last_name": "Silva", - "institution": "University College London" - } - ], - "dblp_key": "conf/popl/SmolkaKFK017", - "venue": "popl", - "year": 2017 - }, { "paper_id": "10.1145/3009837.3009864", "title": "Complexity verification using guided theorem enumeration", "abstract": "Determining if a given program satisfies a given bound on the amount of resources that it may use is a fundamental problem with critical practical applications. Conventional automatic verifiers for safety properties cannot be applied to address this problem directly because such verifiers target properties expressed in decidable theories; however, many practical bounds are expressed in nonlinear theories, which are undecidable.", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3009864", "conference_name": "POPL", "authors": [ @@ -1725,30 +1684,58 @@ "year": 2017 }, { - "paper_id": "10.1145/3009837.3009845", - "title": "Genesis: synthesizing forwarding tables in multi-tenant networks", - "abstract": "Operators in multi-tenant cloud datacenters require support for diverse and complex end-to-end policies, such as, reachability, middlebox traversals, isolation, traffic engineering, and network resource management. We present Genesis, a datacenter network management system which allows policies to be specified in a declarative manner without explicitly programming the network data plane. Genesis tackles the problem of enforcing policies by synthesizing switch forwarding tables. It uses the formal foundations of constraint solving in combination with fast off-the-shelf SMT solvers. To improve synthesis performance, Genesis incorporates a novel search strategy that uses regular expressions to specify properties that leverage the structure of datacenter networks, and a divide-and-conquer synthesis procedure which exploits the structure of policy relationships. We have prototyped Genesis, and conducted experiments with a variety of workloads on real-world topologies to demonstrate its performance.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009845", + "paper_id": "10.1145/3009837.3009901", + "title": "Deciding equivalence with sums and the empty type", + "abstract": "The logical technique of focusing can be applied to the λ-calculus; in a simple type system with atomic types and negative type formers (functions, products, the unit type), its normal forms coincide with βη-normal forms. Introducing a saturation phase gives a notion of quasi-normal forms in presence of positive types (sum types and the empty type). This rich structure let us prove the decidability of βη-equivalence in presence of the empty type, the fact that it coincides with contextual equivalence, and with set-theoretic equality in all finite models.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009901", "conference_name": "POPL", "authors": [ { - "first_name": "Kausik", - "last_name": "Subramanian", - "institution": "University of Wisconsin–Madison" + "first_name": "Gabriel", + "last_name": "Scherer", + "institution": "Northeastern University" + } + ], + "dblp_key": "conf/popl/Scherer17", + "venue": "popl", + "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009843", + "title": "Cantor meets scott: semantic foundations for probabilistic networks", + "abstract": "ProbNetKAT is a probabilistic extension of NetKAT with a denotational semantics based on Markov kernels. The language is expressive enough to generate continuous distributions, which raises the question of how to compute effectively in the language. This paper gives an new characterization of ProbNetKAT’s semantics using domain theory, which provides the foundation needed to build a practical implementation. We show how to use the semantics to approximate the behavior of arbitrary ProbNetKAT programs using distributions with finite support. We develop a prototype implementation and show how to use it to solve a variety of problems including characterizing the expected congestion induced by different routing schemes and reasoning probabilistically about reachability in a network.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009843", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Steffen", + "last_name": "Smolka", + "institution": "Cornell University" }, { - "first_name": "Loris", - "last_name": "D’Antoni", - "institution": "University of Wisconsin–Madison" + "first_name": "Praveen", + "last_name": "Kumar", + "institution": "Cornell University" }, { - "first_name": "Aditya", - "last_name": "Akella", - "institution": "University of Wisconsin–Madison" + "first_name": "Nate", + "last_name": "Foster", + "institution": "Cornell University" + }, + { + "first_name": "Dexter", + "last_name": "Kozen", + "institution": "Cornell University" + }, + { + "first_name": "Alexandra", + "last_name": "Silva", + "institution": "University College London" } ], - "dblp_key": "conf/popl/SubramanianDA17", + "dblp_key": "conf/popl/SmolkaKFK017", "venue": "popl", "year": 2017 }, @@ -1756,7 +1743,7 @@ "paper_id": "10.1145/3009837.3009848", "title": "Context-sensitive data-dependence analysis via linear conjunctive language reachability", "abstract": "Many program analysis problems can be formulated as graph reachability problems. In the literature, context-free language (CFL) reachability has been the most popular formulation and can be computed in subcubic time. The context-sensitive data-dependence analysis is a fundamental abstraction that can express a broad range of program analysis problems. It essentially describes an interleaved matched-parenthesis language reachability problem. The language is not context-free, and the problem is well-known to be undecidable. In practice, many program analyses adopt CFL-reachability to exactly model the matched parentheses for either context-sensitivity or structure-transmitted data-dependence, but not both. Thus, the CFL-reachability formulation for context-sensitive data-dependence analysis is inherently an approximation.", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3009848", "conference_name": "POPL", "authors": [ @@ -1776,91 +1763,86 @@ "year": 2017 }, { - "paper_id": "10.1145/3009837.3009849", - "title": "Big types in little runtime: open-world soundness and collaborative blame for gradual type systems", - "abstract": "Gradual typing combines static and dynamic typing in the same language, offering programmers the error detection and strong guarantees of static types and the rapid prototyping and flexible programming idioms of dynamic types. Many gradually typed languages are implemented by translation into an untyped target language (e.g., Typed Clojure, TypeScript, Gradualtalk, and Reticulated Python). For such languages, it is desirable to support arbitrary interaction between translated code and legacy code in the untyped language while maintaining the type soundness of the translated code. In this paper we formalize this goal in the form of the open-world soundness criterion. We discuss why it is challenging to achieve open-world soundness using the traditional proxy-based approach for higher-order casts. However, the transient design satisfies open-world soundness. Indeed, we present a formal semantics for the transient design and prove that our semantics satisfies open-world soundness. In this paper we also solve a challenging problem for the transient design: how to provide blame tracking without proxies. We define a semantics for blame and prove the Blame Theorem. We also prove that the Gradual Guarantee holds for this system, ensuring that programs can be evolved freely between static and dynamic typing. Finally, we demonstrate that the runtime overhead of the transient approach is low in the context of Reticulated Python, an implementation of gradual typing for Python.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009849", + "paper_id": "10.1145/3009837.3009840", + "title": "Invariants of quantum programs: characterisations and generation", + "abstract": "Program invariant is a fundamental notion widely used in program verification and analysis. The aim of this paper is twofold: (i) find an appropriate definition of invariants for quantum programs; and (ii) develop an effective technique of invariant generation for verification and analysis of quantum programs.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009840", "conference_name": "POPL", "authors": [ { - "first_name": "Michael M.", - "last_name": "Vitousek", - "institution": "Indiana University" + "first_name": "Mingsheng", + "last_name": "Ying", + "institution": "Tsinghua University" }, { - "first_name": "Cameron", - "last_name": "Swords", - "institution": "Indiana University" + "first_name": "Shenggang", + "last_name": "Ying", + "institution": "University of Technology Sydney" }, { - "first_name": "Jeremy G.", - "last_name": "Siek", - "institution": "Indiana University" + "first_name": "Xiaodi", + "last_name": "Wu", + "institution": "University of Oregon" } ], - "dblp_key": "conf/popl/VitousekSS17", + "dblp_key": "conf/popl/YingYW17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009838", - "title": "Automatically comparing memory consistency models", - "abstract": "A memory consistency model (MCM) is the part of a programming language or computer architecture specification that defines which values can legally be read from shared memory locations. Because MCMs take into account various optimisations employed by architectures and compilers, they are often complex and counterintuitive, which makes them challenging to design and to understand.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009838", + "paper_id": "10.1145/3009837.3009874", + "title": "Contract-based resource verification for higher-order functions with memoization", + "abstract": "We present a new approach for specifying and verifying resource utilization of higher-order functional programs that use lazy evaluation and memoization. In our approach, users can specify the desired resource bound as templates with numerical holes e.g. as steps <= ? not asymptotic to size(l) + ? in the contracts of functions. They can also express invariants necessary for establishing the bounds that may depend on the state of memoization. Our approach operates in two phases: first generating an instrumented first-order program that accurately models the higher-order control flow and the effects of memoization on resources using sets, algebraic datatypes and mutual recursion, and then verifying the contracts of the first-order program by producing verification conditions of the form there exists for all using an extended assume/guarantee reasoning. We use our approach to verify precise bounds on resources such as evaluation steps and number of heap-allocated objects on 17 challenging data structures and algorithms. Our benchmarks, comprising of 5K lines of functional Scala code, include lazy mergesort, Okasaki's real-time queue and deque data structures that rely on aliasing of references to first-class functions; lazy data structures based on numerical representations such as the conqueue data structure of Scala's data-parallel library, cyclic streams, as well as dynamic programming algorithms such as knapsack and Viterbi. Our evaluations show that when averaged over all benchmarks the actual runtime resource consumption is 80% of the value inferred by our tool when estimating the number of evaluation steps, and is 88% for the number of heap-allocated objects.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009874", "conference_name": "POPL", "authors": [ { - "first_name": "John", - "last_name": "Wickerson", - "institution": "Imperial College London" - }, - { - "first_name": "Mark", - "last_name": "Batty", - "institution": "University of Kent" + "first_name": "Ravichandhran", + "last_name": "Madhavan", + "institution": "École Polytechnique Fédérale de Lausanne" }, { - "first_name": "Tyler", - "last_name": "Sorensen", - "institution": "Imperial College London" + "first_name": "Sumith", + "last_name": "Kulal", + "institution": "Indian Institute of Technology Bombay" }, { - "first_name": "George A.", - "last_name": "Constantinides", - "institution": "Imperial College London" + "first_name": "Viktor", + "last_name": "Kunčak", + "institution": "École Polytechnique Fédérale de Lausanne" } ], - "dblp_key": "conf/popl/WickersonBSC17", + "dblp_key": "conf/popl/MadhavanKK17", "venue": "popl", "year": 2017 }, { - "paper_id": "10.1145/3009837.3009840", - "title": "Invariants of quantum programs: characterisations and generation", - "abstract": "Program invariant is a fundamental notion widely used in program verification and analysis. The aim of this paper is twofold: (i) find an appropriate definition of invariants for quantum programs; and (ii) develop an effective technique of invariant generation for verification and analysis of quantum programs.", - "date": "2016-12-22", - "link": "https://doi.org/10.1145/3009837.3009840", + "paper_id": "10.1145/3009837.3009894", + "title": "QWIRE: a core language for quantum circuits", + "abstract": "This paper introduces QWIRE (``choir''), a language for defining quantum circuits and an interface for manipulating them inside of an arbitrary classical host language. QWIRE is minimal---it contains only a few primitives---and sound with respect to the physical properties entailed by quantum mechanics. At the same time, QWIRE is expressive and highly modular due to its relationship with the host language, mirroring the QRAM model of computation that places a quantum computer (controlled by circuits) alongside a classical computer (controlled by the host language).", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009894", "conference_name": "POPL", "authors": [ { - "first_name": "Mingsheng", - "last_name": "Ying", - "institution": "Tsinghua University" + "first_name": "Jennifer", + "last_name": "Paykin", + "institution": "California University of Pennsylvania" }, { - "first_name": "Shenggang", - "last_name": "Ying", - "institution": "University of Technology Sydney" + "first_name": "Robert W.", + "last_name": "Rand", + "institution": "California University of Pennsylvania" }, { - "first_name": "Xiaodi", - "last_name": "Wu", - "institution": "University of Oregon" + "first_name": "Steve", + "last_name": "Zdancewic", + "institution": "California University of Pennsylvania" } ], - "dblp_key": "conf/popl/YingYW17", + "dblp_key": "conf/popl/Paykin0Z17", "venue": "popl", "year": 2017 }, @@ -1868,7 +1850,7 @@ "paper_id": "10.1145/3009837.3009884", "title": "LightDP: towards automating differential privacy proofs", "abstract": "The growing popularity and adoption of differential privacy in academic and industrial settings has resulted in the development of increasingly sophisticated algorithms for releasing information while preserving privacy. Accompanying this phenomenon is the natural rise in the development and publication of incorrect algorithms, thus demonstrating the necessity of formal verification tools. However, existing formal methods for differential privacy face a dilemma: methods based on customized logics can verify sophisticated algorithms but come with a steep learning curve and significant annotation burden on the programmers, while existing programming platforms lack expressive power for some sophisticated algorithms.", - "date": "2016-12-22", + "date": "2017-01-01", "link": "https://doi.org/10.1145/3009837.3009884", "conference_name": "POPL", "authors": [ @@ -1886,5 +1868,23 @@ "dblp_key": "conf/popl/ZhangK17", "venue": "popl", "year": 2017 + }, + { + "paper_id": "10.1145/3009837.3009923", + "title": "The influence of dependent types (keynote)", + "abstract": "What has dependent type theory done for Haskell? In this talk, I will discuss the influence of dependent types on the design of programming languages and on the practice of functional programmers. Over the past ten years, the Glasgow Haskell compiler has adopted several type system features inspired by dependent type theory. However, this process has not been a direct translation; working in the context of an existing language has lead us to new designs in the semantics of dependent types. I will take a close look at what we have achieved in GHC and discuss what we have learned from this experiment: what works now, what doesn't work yet, and what has surprised us along the way.", + "date": "2017-01-01", + "link": "https://doi.org/10.1145/3009837.3009923", + "conference_name": "POPL", + "authors": [ + { + "first_name": "Stephanie", + "last_name": "Weirich", + "institution": "California University of Pennsylvania" + } + ], + "dblp_key": "conf/popl/Weirich17", + "venue": "popl", + "year": 2017 } ] \ No newline at end of file From d0cf87cbeb5f64eebdbbf6eef906aef09c98bc4f Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 21:12:01 +0200 Subject: [PATCH 27/34] fix(api): expose PL conferences in /api/search source filter The /api/search endpoint hardcodes its source allowlist in three places (GET param parsing, sources_flags iteration, default-everything fallback) and the recently ingested PL venues (POPL, PLDI, ICFP, OOPSLA, ESOP, ECOOP, CC, Haskell) were absent from all of them. Net effect: 8,032 PL papers were unreachable from the frontend even with no filters applied. Adds the eight PL venues alongside the existing AI/Systems venues in all three places. No behavioral change for existing sources. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/flask_app.py | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/src/oversight/flask_app.py b/src/oversight/flask_app.py index 3b950d6..a505e84 100644 --- a/src/oversight/flask_app.py +++ b/src/oversight/flask_app.py @@ -61,6 +61,21 @@ def _build_filters( if sources_flags.get(conf, False): selected_sources.append(conf) + # Handle individual PL conferences + pl_conferences = [ + "POPL", + "PLDI", + "ICFP", + "OOPSLA", + "ESOP", + "ECOOP", + "CC", + "Haskell", + ] + for conf in pl_conferences: + if sources_flags.get(conf, False): + selected_sources.append(conf) + # Build filter from selected sources if selected_sources: filters.append(repo.build_filter_sql(selected_sources)) @@ -81,6 +96,14 @@ def _build_filters( "MLSys", "EuroSys", "VLDB", + "POPL", + "PLDI", + "ICFP", + "OOPSLA", + "ESOP", + "ECOOP", + "CC", + "Haskell", ] ) ) @@ -118,6 +141,20 @@ def search() -> tuple[dict[str, Any], int]: for conf in systems_conferences: sources[conf] = request.args.get(conf, "false").lower() == "true" + # Add individual PL conferences + pl_conferences = [ + "POPL", + "PLDI", + "ICFP", + "OOPSLA", + "ESOP", + "ECOOP", + "CC", + "Haskell", + ] + for conf in pl_conferences: + sources[conf] = request.args.get(conf, "false").lower() == "true" + body = { "text": request.args.get("text", ""), "time_window_days": request.args.get("time_window_days"), From f8bab7ad221334eace4d779c05085aa50b084b44 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 21:12:38 +0200 Subject: [PATCH 28/34] fix: include cs.LO and cs.PL in arxiv embedding scope The arxiv embedding pass previously only embedded papers in cs.AI, cs.CL, cs.LG, and cs.MA. Logic (cs.LO) and Programming Languages (cs.PL) papers were ingested but never embedded, so they were invisible to semantic search even though present in the paper table. Adds cs.LO and cs.PL to the eligible-for-embedding category list. A backfill embedding pass over already-ingested cs.LO and cs.PL rows needs to be run separately (out of scope for this commit). Co-Authored-By: Claude Opus 4.7 (1M context) --- src/oversight/PaperDatabase.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/oversight/PaperDatabase.py b/src/oversight/PaperDatabase.py index c13ba2b..d07ac32 100644 --- a/src/oversight/PaperDatabase.py +++ b/src/oversight/PaperDatabase.py @@ -19,7 +19,14 @@ class PaperDatabase: def __init__(self) -> None: load_dotenv() - self.ai_categories = ["cs:cs:AI", "cs:cs:CL", "cs:cs:LG", "cs:cs:MA"] + self.ai_categories = [ + "cs:cs:AI", + "cs:cs:CL", + "cs:cs:LG", + "cs:cs:MA", + "cs:cs:LO", + "cs:cs:PL", + ] self.con: psycopg.Connection[tuple[Any, ...]] | None = None self.date_format = "%Y-%m-%d" From 5d5ee6c24fd2f042ab6d4a4b35ebea503ca819c8 Mon Sep 17 00:00:00 2001 From: Charlie Lidbury Date: Sun, 10 May 2026 21:14:04 +0200 Subject: [PATCH 29/34] feat(frontend): add PL conference toggles to source filters Adds POPL, PLDI, ICFP, OOPSLA, ESOP, ECOOP, CC, and Haskell Symposium to the sidebar source filter alongside the existing AI and Systems groupings, plus the inventory display order. Mirrors the structure of the existing systems-conferences and AI-conferences blocks (collapsible group with per-venue toggles and an indeterminate parent checkbox). Pairs with the API change that exposes PL venues to /api/search. Co-Authored-By: Claude Opus 4.7 (1M context) --- frontend/pages/index.tsx | 66 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 64 insertions(+), 2 deletions(-) diff --git a/frontend/pages/index.tsx b/frontend/pages/index.tsx index 0647f8f..81e1401 100644 --- a/frontend/pages/index.tsx +++ b/frontend/pages/index.tsx @@ -49,7 +49,16 @@ export default function HomePage() { NSDI: true, MLSys: true, EuroSys: true, - VLDB: true + VLDB: true, + // PL conferences + POPL: true, + PLDI: true, + ICFP: true, + OOPSLA: true, + ESOP: true, + ECOOP: true, + CC: true, + Haskell: true }); const [sidebarOpen, setSidebarOpen] = useState(false); const sidebarRef = useRef(null); @@ -58,6 +67,7 @@ export default function HomePage() { const [eyeSpinning, setEyeSpinning] = useState(false); const [systemsExpanded, setSystemsExpanded] = useState(false); const [aiExpanded, setAiExpanded] = useState(false); + const [plExpanded, setPlExpanded] = useState(false); const [loading, setLoading] = useState(false); const lastRequestIdRef = useRef(0); const [error, setError] = useState(null); @@ -149,10 +159,12 @@ export default function HomePage() { // Conference categories const aiConferences = ['ICML', 'NeurIPS', 'ICLR']; const systemsConferences = ['OSDI', 'SOSP', 'ASPLOS', 'ATC', 'NSDI', 'MLSys', 'EuroSys', 'VLDB']; + const plConferences = ['POPL', 'PLDI', 'ICFP', 'OOPSLA', 'ESOP', 'ECOOP', 'CC', 'Haskell']; // Check if all conferences in a category are selected const isAllAISelected = aiConferences.every(conf => sources[conf as keyof typeof sources]); const isAllSystemsSelected = systemsConferences.every(conf => sources[conf as keyof typeof sources]); + const isAllPLSelected = plConferences.every(conf => sources[conf as keyof typeof sources]); function toggleSource(key: keyof typeof sources) { setSources((s) => ({ ...s, [key]: !s[key] })); @@ -180,6 +192,17 @@ export default function HomePage() { }); } + function toggleAllPL() { + const newValue = !isAllPLSelected; + setSources((s) => { + const updated = { ...s }; + plConferences.forEach(conf => { + updated[conf as keyof typeof sources] = newValue; + }); + return updated; + }); + } + async function fetchInventory() { setInventoryOpen(true); setInventoryError(null); @@ -429,6 +452,44 @@ export default function HomePage() { ))} + {/* PL conferences */} +
+ + {plExpanded && plConferences.map(conf => ( + + ))} +
+ {/* arXiv */}